Attachment #184669 for bug #330482

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 12-18 Link Here

(-)META-INF/MANIFEST.MF (-1 / +6 lines)
12	org.eclipse.wst.xml.ui,	12	org.eclipse.wst.xml.ui,
13	org.eclipse.ui,	13	org.eclipse.ui,
14	org.eclipse.ui.views,	14	org.eclipse.ui.views,
15	org.eclipse.help	15	org.eclipse.help,
		16	org.eclipse.emf.transaction,
		17	org.eclipse.ui.views.properties.tabbed,
		18	org.eclipse.gef,
		19	org.eclipse.graphiti,
		20	org.eclipse.graphiti.ui
16	Bundle-ActivationPolicy: lazy	21	Bundle-ActivationPolicy: lazy
17	Bundle-RequiredExecutionEnvironment: J2SE-1.5	22	Bundle-RequiredExecutionEnvironment: J2SE-1.5
18	Bundle-Vendor: %providerName	23	Bundle-Vendor: %providerName

Lines 146-150 Link Here

(-)plugin.xml (+10 lines)
146	id="org.eclipse.sapphire.samples.ezbug.ui.BugDatabaseEditor"	146	id="org.eclipse.sapphire.samples.ezbug.ui.BugDatabaseEditor"
147	name="Bug Database Editor (Sapphire Sample)"/>	147	name="Bug Database Editor (Sapphire Sample)"/>
148	</extension>	148	</extension>
		149
		150	<extension point="org.eclipse.ui.editors">
		151	<editor
		152	class="org.eclipse.sapphire.samples.map.ui.MapEditor"
		153	default="true"
		154	filenames="map.xml"
		155	id="org.eclipse.sapphire.samples.map.ui.MapEditor"
		156	name="Map Editor"/>
		157	</extension>
		158
149		159
150	</plugin>	160	</plugin>




<definition>

  <import>
    <bundle>org.eclipse.sapphire.samples</bundle>
    <package>org.eclipse.sapphire.samples.map</package>
    <package>org.eclipse.sapphire.samples.map.ui</package>
  </import>
  
  <diagram-page>
    <id>diagram</id>
    <page-name>Diagram</page-name>
    <page-header-text>Diagram</page-header-text>
    <node>
      <id>destinations</id>
      <tool-palette-label>Destination</tool-palette-label>
      <tool-palette-desc>Map Destination</tool-palette-desc>
      <property>Destinations</property>
      <label>${Name == null ? "&lt;Destination&gt;" : Name}</label>
      <instance-id>${Name}</instance-id>
    </node>
    <connection>
      <id>connections</id>
      <tool-palette-label>Route</tool-palette-label>
      <tool-palette-desc>Map Route</tool-palette-desc>
      <property>Routes</property>
      <label>${Distance == null ? "&lt;Distance&gt;" : Distance}</label>
      <endpoint1>
        <property>FromDestination</property>
        <value>${Name}</value>
        <type>NONE</type>
      </endpoint1>
      <endpoint2>
        <property>ToDestination</property>
        <value>${Name}</value>
        <type>ARROW</type>
      </endpoint2>
      <instance-id>${FromDestination}-${ToDestination}</instance-id>
    </connection>
  </diagram-page>
  
  <editor-page>
    <id>overview</id>
    <page-name>Overview</page-name>
    <page-header-text>Overview</page-header-text>
    <root-node>
      <node>
        <label>Destinations</label>
        <section>
          <description>Destinations in the map</description>
          <content>
            <property-editor>Destinations</property-editor>
          </content>
        </section>
      </node>
      <node>
        <label>Routes</label>
        <section>
          <description>Routes in the map</description>
          <content>
            <property-editor>Routes</property-editor>
          </content>
        </section>
      </node>
    </root-node>
  </editor-page>
</definition>
    




package org.eclipse.sapphire.samples.map;

import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.Value;
import org.eclipse.sapphire.modeling.ValueProperty;
import org.eclipse.sapphire.modeling.annotations.GenerateImpl;
import org.eclipse.sapphire.modeling.annotations.Label;
import org.eclipse.sapphire.modeling.annotations.NonNullValue;
import org.eclipse.sapphire.modeling.xml.annotations.XmlBinding;

@GenerateImpl

public interface IDestination extends IModelElement 
{
	ModelElementType TYPE = new ModelElementType( IDestination.class );
	
    // *** Name ***
    
    @XmlBinding( path = "name" )
    @Label( standard = "name" )
    @NonNullValue
    //@DefaultValue( text = "Destination" )

    ValueProperty PROP_NAME = new ValueProperty( TYPE, "Name" );

    Value<String> getName();
    void setName( String name );
	
}




package org.eclipse.sapphire.samples.map;

import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ListProperty;
import org.eclipse.sapphire.modeling.ModelElementList;
import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.annotations.GenerateImpl;
import org.eclipse.sapphire.modeling.annotations.Type;
import org.eclipse.sapphire.modeling.xml.annotations.XmlListBinding;
import org.eclipse.sapphire.modeling.xml.annotations.XmlRootBinding;

@GenerateImpl
@XmlRootBinding( elementName = "map")

public interface IMap extends IModelElement
{
	ModelElementType TYPE = new ModelElementType( IMap.class );
	
    // *** Destinations ***

    @Type( base = IDestination.class )
    @XmlListBinding( mappings = @XmlListBinding.Mapping( element = "destination", type = IDestination.class ) )
    
    ListProperty PROP_DESTINATIONS = new ListProperty( TYPE, "Destinations" );
    
    ModelElementList<IDestination> getDestinations();
	
    // *** Routes ***
    
    @Type( base = IRoute.class )
    @XmlListBinding( mappings = @XmlListBinding.Mapping( element = "route", type = IRoute.class ) )
    
    ListProperty PROP_ROUTES = new ListProperty( TYPE, "Routes" );
    
    ModelElementList<IRoute> getRoutes();
    
}




package org.eclipse.sapphire.samples.map;

import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.ReferenceValue;
import org.eclipse.sapphire.modeling.Value;
import org.eclipse.sapphire.modeling.ValueProperty;
import org.eclipse.sapphire.modeling.annotations.GenerateImpl;
import org.eclipse.sapphire.modeling.annotations.Label;
import org.eclipse.sapphire.modeling.annotations.NonNullValue;
import org.eclipse.sapphire.modeling.annotations.Reference;
import org.eclipse.sapphire.modeling.xml.annotations.XmlBinding;
import org.eclipse.sapphire.samples.map.internal.DestinationReferenceService;

@GenerateImpl

public interface IRoute extends IModelElement 
{
	ModelElementType TYPE = new ModelElementType( IRoute.class );
	
	// *** FromDestination ***
	
	@Reference( target = IDestination.class, service = DestinationReferenceService.class )
	@XmlBinding( path = "from-destination")
	@NonNullValue
	@Label(standard = "from destination")

	ValueProperty PROP_FROM_DESTINATION = new ValueProperty( TYPE, "FromDestination" );

    ReferenceValue<IDestination> getFromDestination();
    void setFromDestination( String name );
	
	// *** ToDestination ***
	
	@Reference( target = IDestination.class, service = DestinationReferenceService.class )
	@XmlBinding( path = "to-destination")
	@NonNullValue
	@Label(standard = "to destination")

	ValueProperty PROP_TO_DESTINATION = new ValueProperty( TYPE, "ToDestination" );

    ReferenceValue<IDestination> getToDestination();
    void setToDestination( String name );
    
    // *** Distance ***
    
    @XmlBinding( path = "distance" )
    @Label( standard = "distance" )
    @NonNullValue

    ValueProperty PROP_DISTANCE = new ValueProperty( TYPE, "Distance" );

    Value<String> getDistance();
    void setDistance( String distance );
    
}




package org.eclipse.sapphire.samples.map.internal;

import org.eclipse.sapphire.modeling.ModelElementList;
import org.eclipse.sapphire.modeling.ReferenceService;
import org.eclipse.sapphire.samples.map.IDestination;
import org.eclipse.sapphire.samples.map.IMap;

public class DestinationReferenceService extends ReferenceService 
{

	@Override
	public Object resolve(String reference) 
	{
		if (reference != null)
		{
			IMap map = element().nearest(IMap.class);
			ModelElementList<IDestination> dests = map.getDestinations();
			for (IDestination dest : dests)
			{
				if (reference.equals(dest.getName().getContent()))
				{
					return dest;
				}
			}
		}
		return null;
	}

}




package org.eclipse.sapphire.samples.map.ui;

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.xml.RootXmlResource;
import org.eclipse.sapphire.samples.map.IMap;
import org.eclipse.sapphire.ui.SapphireEditor;
import org.eclipse.sapphire.ui.diagram.editor.SapphireDiagramEditorPart;
import org.eclipse.sapphire.ui.diagram.graphiti.editor.SapphireDiagramEditor;
import org.eclipse.sapphire.ui.diagram.graphiti.editor.SapphireDiagramEditorInput;
import org.eclipse.sapphire.ui.editor.views.masterdetails.MasterDetailsPage;
import org.eclipse.sapphire.ui.xml.XmlEditorResourceStore;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.part.FileEditorInput;
import org.eclipse.wst.sse.ui.StructuredTextEditor;

public class MapEditor extends SapphireEditor 
{
	private IMap modelMap;
	private StructuredTextEditor mapSourceEditor;
	private SapphireDiagramEditorPart mapDiagramPart;
	private MasterDetailsPage mapOverviewPage;
	
    public MapEditor()
    {
        super( "org.eclipse.sapphire.samples" );
    }

	@Override
	protected void createSourcePages() throws PartInitException 
	{
		this.mapSourceEditor = new StructuredTextEditor();
		this.mapSourceEditor.setEditorPart(this);
        final FileEditorInput rootEditorInput = (FileEditorInput) getEditorInput();
        
        int index = addPage( this.mapSourceEditor, rootEditorInput );
        setPageText( index, "map.xml" );
	}

	@Override
	protected IModelElement createModel() 
	{
		this.modelMap = IMap.TYPE.instantiate(new RootXmlResource(new XmlEditorResourceStore(this, this.mapSourceEditor)));
		return this.modelMap;
	}

	@Override
	protected void createDiagramPages() throws PartInitException
	{
		IPath path = new Path( "org.eclipse.sapphire.samples/sdef/MapEditor.sdef/diagram" );
		this.mapDiagramPart = new SapphireDiagramEditorPart(this, this.modelMap, path);
		SapphireDiagramEditor diagramEditor = this.mapDiagramPart.getDiagramEditor();
		SapphireDiagramEditorInput diagramEditorInput = this.mapDiagramPart.getDiagramEditorInput();
		addPage(0, diagramEditor, diagramEditorInput);
		setPageText( 0, "Diagram" );
		setPageId(this.pages.get(0), "Diagram");
	}
	
	@Override
	protected void createFormPages() throws PartInitException 
	{
		IPath path = new Path( "org.eclipse.sapphire.samples/sdef/MapEditor.sdef/overview" );
		this.mapOverviewPage = new MasterDetailsPage(this, this.modelMap, path);
        addPage(1, this.mapOverviewPage);
        setPageText(1, "Overview");
        setPageId(this.pages.get(1), "Overview");		
	}

	public IMap getMap()
	{
		return this.modelMap;
	}
	
	@Override
	public void doSave( final IProgressMonitor monitor )
	{
		super.doSave(monitor);
		SapphireDiagramEditor diagramEditor = this.mapDiagramPart.getDiagramEditor();
		diagramEditor.doSave(monitor);
	}
}

Lines 19-25 Link Here

(-)META-INF/MANIFEST.MF (-2 / +11 lines)
19	org.eclipse.sapphire.ui.swt.renderer,	19	org.eclipse.sapphire.ui.swt.renderer,
20	org.eclipse.sapphire.ui.swt.renderer.actions,	20	org.eclipse.sapphire.ui.swt.renderer.actions,
21	org.eclipse.sapphire.ui.util,	21	org.eclipse.sapphire.ui.util,
22	org.eclipse.sapphire.ui.xml	22	org.eclipse.sapphire.ui.xml,
		23	org.eclipse.sapphire.ui.diagram.editor,
		24	org.eclipse.sapphire.ui.diagram.graphiti.editor
23	Require-Bundle: org.eclipse.debug.ui,	25	Require-Bundle: org.eclipse.debug.ui,
24	org.eclipse.jdt.ui,	26	org.eclipse.jdt.ui,
25	org.eclipse.ui.forms;visibility:=reexport,	27	org.eclipse.ui.forms;visibility:=reexport,
Lines 37-42 Link Here
37	org.eclipse.help,	39	org.eclipse.help,
38	org.eclipse.ui.views,	40	org.eclipse.ui.views,
39	org.eclipse.jface.text,	41	org.eclipse.jface.text,
40	org.apache.ant	42	org.apache.ant,
		43	org.eclipse.gef,
		44	org.eclipse.graphiti,
		45	org.eclipse.graphiti.mm,
		46	org.eclipse.graphiti.pattern,
		47	org.eclipse.graphiti.ui,
		48	org.eclipse.emf.transaction,
		49	org.eclipse.ui.views.properties.tabbed
41	Bundle-ActivationPolicy: lazy	50	Bundle-ActivationPolicy: lazy
42	Bundle-RequiredExecutionEnvironment: J2SE-1.5	51	Bundle-RequiredExecutionEnvironment: J2SE-1.5

Lines 15-17 Link Here

(-)plugin.properties (+4 lines)
15	showInSourceCommandName = Show in Source	15	showInSourceCommandName = Show in Source
16	showInSourceCommandDescription = Shows the location in the source file that corresponds to the selected entity.	16	showInSourceCommandDescription = Shows the location in the source file that corresponds to the selected entity.
17	builderName = Sapphire UI Builder	17	builderName = Sapphire UI Builder
		18	sapphireDiagramTypeDescription = Sapphire Diagram Type
		19	sapphireDiagramTypeName = Sapphire Diagram Type
		20	sapphireDiagramTypeProviderDescription = Sapphire Diagram Type Provider
		21	sapphireDiagramTypeProviderName = Sapphire Diagram Type Provider




    </builder> 
  </extension> 
  
   <extension point="org.eclipse.graphiti.ui.diagramTypes">
      <diagramType
            description="%sapphireDiagramTypeDescription"
            id="org.eclipse.sapphire.ui.SapphireDiagramType"
            name="%sapphireDiagramTypeName"
            type="sapphireDiagram">
      </diagramType>
   </extension>
   
   <extension point="org.eclipse.graphiti.ui.diagramTypeProviders">
      <diagramTypeProvider
            class="org.eclipse.sapphire.ui.diagram.graphiti.providers.SapphireDiagramTypeProvider"
            description="%sapphireDiagramTypeProviderDescription"
            id="org.eclipse.sapphire.ui.sapphireDiagramTypeProvider"
            name="%sapphireDiagramTypeProviderName">
         <diagramType id="org.eclipse.sapphire.ui.SapphireDiagramType"/>
      </diagramTypeProvider>
   </extension>
     
</plugin>

Lines 18-23 Link Here

(-)src/org/eclipse/sapphire/ui/SapphireEditor.java (+9 lines)
18	import java.net.URI;	18	import java.net.URI;
19	import java.util.Collections;	19	import java.util.Collections;
20	import java.util.HashMap;	20	import java.util.HashMap;
		21	import java.util.Iterator;
21	import java.util.Map;	22	import java.util.Map;
22	import java.util.Set;	23	import java.util.Set;
23		24
Lines 285-290 Link Here
285	this.model = createModel();	286	this.model = createModel();
286	adaptModel( this.model );	287	adaptModel( this.model );
287		288
		289	createDiagramPages();
		290
288	createFormPages();	291	createFormPages();
289		292
290	createFileChangeListener();	293	createFileChangeListener();
Lines 330-335 Link Here
330	protected abstract void createSourcePages() throws PartInitException;	333	protected abstract void createSourcePages() throws PartInitException;
331	protected abstract void createFormPages() throws PartInitException;	334	protected abstract void createFormPages() throws PartInitException;
332		335
		336	// default impl does nothing, subclass may override it to add diagram pages
		337	protected void createDiagramPages() throws PartInitException
		338	{
		339
		340	}
		341
333	protected final void setPageId( final Object page,	342	protected final void setPageId( final Object page,
334	final String id )	343	final String id )
335	{	344	{




import org.eclipse.sapphire.modeling.xml.annotations.XmlListBinding;
import org.eclipse.sapphire.modeling.xml.annotations.XmlRootBinding;
import org.eclipse.sapphire.ui.def.internal.SapphireUiDefMethods;
import org.eclipse.sapphire.ui.diagram.def.IDiagramPageDef;

/**
 * @author <a href="mailto:konstantin.komissarchik@oracle.com">Konstantin Komissarchik</a>

    
    ModelElementList<IEditorPageDef> getEditorPageDefs();
    
    // *** DiagramPageDefs ***
    
    @Type( base = IDiagramPageDef.class )
    @XmlListBinding( mappings = @XmlListBinding.Mapping( element = "diagram-page", type = IDiagramPageDef.class ) )
    
    ListProperty PROP_DIAGRAM_PAGE_DEFS = new ListProperty( TYPE, "DiagramPageDefs" );
    
    ModelElementList<IDiagramPageDef> getDiagramPageDefs();
    
    // *** DialogDefs ***
    
    @Type( base = ISapphireDialogDef.class )




package org.eclipse.sapphire.ui.def;

import org.eclipse.sapphire.modeling.BundleResourceStore;
import org.eclipse.sapphire.modeling.ResourceStoreException;
import org.eclipse.sapphire.modeling.SharedModelsCache;
import org.eclipse.sapphire.modeling.xml.RootXmlResource;
import org.eclipse.sapphire.modeling.xml.XmlResourceStore;
import org.eclipse.sapphire.ui.diagram.def.IDiagramPageDef;
import org.eclipse.sapphire.ui.internal.SapphireUiFrameworkPlugin;

public class SapphireDiagramDefFactory 
{
	public static IDiagramPageDef load(final String bundleId, final String path)
	{
        try
        {
            return load( new XmlResourceStore( new BundleResourceStore( bundleId, path ) ), false );
        }
        catch( ResourceStoreException e )
        {
            SapphireUiFrameworkPlugin.log( e );
            return null;
        }		
	}
	
	public static IDiagramPageDef load( final XmlResourceStore resourceStore,
            							final boolean writable )
	{
		IDiagramPageDef model;

		if( writable )
		{
			model = IDiagramPageDef.TYPE.instantiate( new RootXmlResource( resourceStore ) );
		}
		else
		{
			final SharedModelsCache.StandardKey key = new SharedModelsCache.StandardKey( resourceStore, IDiagramPageDef.TYPE );
			
			model = (IDiagramPageDef) SharedModelsCache.retrieve( key );
			
			if( model == null )
			{
				model = IDiagramPageDef.TYPE.instantiate( new RootXmlResource( resourceStore ) );
				SharedModelsCache.store( key, model );			
			}	
		}
		return model;
	}

}


Added Link Here

(-)src/org/eclipse/sapphire/ui/diagram/def/ConnectionEndpointType.java (+10 lines)
1	package org.eclipse.sapphire.ui.diagram.def;
2
3
4	public enum ConnectionEndpointType
5	{
6	NONE,
7	ARROW,
8	CIRCLE,
9	ELLIPSE;
10	}




package org.eclipse.sapphire.ui.diagram.def;

import org.eclipse.sapphire.modeling.ElementProperty;
import org.eclipse.sapphire.modeling.ModelElementHandle;
import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.Value;
import org.eclipse.sapphire.modeling.ValueProperty;
import org.eclipse.sapphire.modeling.annotations.GenerateImpl;
import org.eclipse.sapphire.modeling.annotations.Label;
import org.eclipse.sapphire.modeling.annotations.Type;
import org.eclipse.sapphire.modeling.xml.annotations.XmlBinding;
import org.eclipse.sapphire.ui.def.ISapphirePartDef;

@GenerateImpl

public interface IDiagramConnectionDef 
	
	extends ISapphirePartDef 
	
{
	ModelElementType TYPE = new ModelElementType( IDiagramConnectionDef.class );
	
    // *** Id ***
    
    @Label( standard = "ID" )
    @XmlBinding( path = "id" )
    
    ValueProperty PROP_ID = new ValueProperty( TYPE, "Id" );
    
    Value<String> getId();
    void setId( String id );
    
    // *** Property ***
    
    @Label( standard = "property" )
    @XmlBinding( path = "property" )
    
    ValueProperty PROP_PROPERTY = new ValueProperty( TYPE, "Property" );
    
    Value<String> getProperty();
    void setProperty( String property );
    
    // *** ToolPaletteLabel ***
    
    @Label( standard = "tool palette label" )
    @XmlBinding( path = "tool-palette-label" )
    
    ValueProperty PROP_TOOL_PALETTE_LABEL = new ValueProperty( TYPE, "ToolPaletteLabel" );
    
    Value<String> getToolPaletteLabel();
    void setToolPaletteLabel( String paletteLabel );
    
    // *** ToolPaletteDesc ***
    
    @Label( standard = "tool palette description" )
    @XmlBinding( path = "tool-palette-desc" )
    
    ValueProperty PROP_TOOL_PALETTE_DESC = new ValueProperty( TYPE, "ToolPaletteDesc" );
    
    Value<String> getToolPaletteDesc();
    void setToolPaletteDesc( String paletteDesc );    
        
    // *** Label ***
    
    @Label( standard = "label" )
    @XmlBinding( path = "label" )
    
    ValueProperty PROP_LABEL = new ValueProperty( TYPE, "Label" );
    
    Value<String> getLabel();
    void setLabel( String label );
    
    // *** Endpoint1 ***
    
    @Type( base = IDiagramConnectionEndpointDef.class )
    @XmlBinding( path = "endpoint1" )

    ElementProperty PROP_ENDPOINT_1 = new ElementProperty( TYPE, "Endpoint1" );
    
    ModelElementHandle<IDiagramConnectionEndpointDef> getEndpoint1();

    // *** Endpoint2 ***
    
    @Type( base = IDiagramConnectionEndpointDef.class )
    @XmlBinding( path = "endpoint2" )

    ElementProperty PROP_ENDPOINT_2 = new ElementProperty( TYPE, "Endpoint2" );
    
    ModelElementHandle<IDiagramConnectionEndpointDef> getEndpoint2();
    
    // *** InstanceId ***
    
    @Label( standard = "instance id" )
    @XmlBinding( path = "instance-id" )
    
    ValueProperty PROP_INSTANCE_ID = new ValueProperty( TYPE, "InstanceId" );
    
    Value<String> getInstanceId();
    void setInstanceId( String instanceId );
    
    
}




package org.eclipse.sapphire.ui.diagram.def;

import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.Value;
import org.eclipse.sapphire.modeling.ValueProperty;
import org.eclipse.sapphire.modeling.annotations.GenerateImpl;
import org.eclipse.sapphire.modeling.annotations.Label;
import org.eclipse.sapphire.modeling.annotations.Type;
import org.eclipse.sapphire.modeling.xml.annotations.XmlBinding;
import org.eclipse.sapphire.ui.def.ISapphirePartDef;

@GenerateImpl

public interface IDiagramConnectionEndpointDef 

	extends ISapphirePartDef 
	
{
	ModelElementType TYPE = new ModelElementType( IDiagramConnectionEndpointDef.class );
	
    // *** Property ***
    
    @Label( standard = "property" )
    @XmlBinding( path = "property" )
    
    ValueProperty PROP_PROPERTY = new ValueProperty( TYPE, "Property" );
    
    Value<String> getProperty();
    void setProperty( String property );
    
    // *** Value ***
    
    @Label( standard = "value" )
    @XmlBinding( path = "value" )
    
    ValueProperty PROP_VALUE = new ValueProperty( TYPE, "Value" );
    
    Value<String> getValue();
    void setValue( String value );
    
    
	// *** Type ***
	
	@Type( base = ConnectionEndpointType.class )
	@XmlBinding( path = "connectionDecoratorType" )
	
	ValueProperty PROP_TYPE = new ValueProperty( TYPE, "Type" );
	
	Value<ConnectionEndpointType> getType();
	void setType( String value );
	void setType( ConnectionEndpointType value );
    
	
}




package org.eclipse.sapphire.ui.diagram.def;

import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.Value;
import org.eclipse.sapphire.modeling.ValueProperty;
import org.eclipse.sapphire.modeling.annotations.GenerateImpl;
import org.eclipse.sapphire.modeling.annotations.Label;
import org.eclipse.sapphire.modeling.xml.annotations.XmlBinding;
import org.eclipse.sapphire.ui.def.ISapphirePartDef;

@GenerateImpl

public interface IDiagramNodeDef 

	extends ISapphirePartDef
	
{
	ModelElementType TYPE = new ModelElementType( IDiagramNodeDef.class );
	
    // *** Id ***
    
    @Label( standard = "ID" )
    @XmlBinding( path = "id" )
    
    ValueProperty PROP_ID = new ValueProperty( TYPE, "Id" );
    
    Value<String> getId();
    void setId( String id );
    
    // *** ToolPaletteLabel ***
    
    @Label( standard = "tool palette label" )
    @XmlBinding( path = "tool-palette-label" )
    
    ValueProperty PROP_TOOL_PALETTE_LABEL = new ValueProperty( TYPE, "ToolPaletteLabel" );
    
    Value<String> getToolPaletteLabel();
    void setToolPaletteLabel( String paletteLabel );
    
    // *** ToolPaletteDesc ***
    
    @Label( standard = "tool palette description" )
    @XmlBinding( path = "tool-palette-desc" )
    
    ValueProperty PROP_TOOL_PALETTE_DESC = new ValueProperty( TYPE, "ToolPaletteDesc" );
    
    Value<String> getToolPaletteDesc();
    void setToolPaletteDesc( String paletteDesc );

    // *** Property ***
    
    @Label( standard = "property" )
    @XmlBinding( path = "property" )
    
    ValueProperty PROP_PROPERTY = new ValueProperty( TYPE, "Property" );
    
    Value<String> getProperty();
    void setProperty( String property );
        
    // *** Label ***
    
    @Label( standard = "label" )
    @XmlBinding( path = "label" )
    
    ValueProperty PROP_LABEL = new ValueProperty( TYPE, "Label" );
    
    Value<String> getLabel();
    void setLabel( String label );
	
    // *** InstanceId ***
    
    @Label( standard = "instance id" )
    @XmlBinding( path = "instance-id" )
    
    ValueProperty PROP_INSTANCE_ID = new ValueProperty( TYPE, "InstanceId" );
    
    Value<String> getInstanceId();
    void setInstanceId( String instanceId );
}




package org.eclipse.sapphire.ui.diagram.def;

import org.eclipse.sapphire.modeling.ListProperty;
import org.eclipse.sapphire.modeling.ModelElementList;
import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.Value;
import org.eclipse.sapphire.modeling.ValueProperty;
import org.eclipse.sapphire.modeling.annotations.DefaultValue;
import org.eclipse.sapphire.modeling.annotations.GenerateImpl;
import org.eclipse.sapphire.modeling.annotations.Label;
import org.eclipse.sapphire.modeling.annotations.Type;
import org.eclipse.sapphire.modeling.xml.annotations.XmlBinding;
import org.eclipse.sapphire.modeling.xml.annotations.XmlListBinding;
import org.eclipse.sapphire.ui.def.ISapphirePartDef;

@GenerateImpl

public interface IDiagramPageDef 
	
	extends ISapphirePartDef
	
{
	ModelElementType TYPE = new ModelElementType( IDiagramPageDef.class);
	
    // *** Id ***
    
    @Label( standard = "ID" )
    @XmlBinding( path = "id" )
    
    ValueProperty PROP_ID = new ValueProperty( TYPE, "Id" );
    
    Value<String> getId();
    void setId( String id );
    
    // *** PageName ***
    
    @Label( standard = "page name" )
    @DefaultValue( text = "Diagram" )
    @XmlBinding( path = "page-name" )
    
    ValueProperty PROP_PAGE_NAME = new ValueProperty( TYPE, "PageName" );
    
    Value<String> getPageName();
    void setPageName( String pageName );
    
    // *** PageHeaderText ***
    
    @Label( standard = "page header text" )
    @DefaultValue( text = "Diagram View" )
    @XmlBinding( path = "page-header-text" )
    
    ValueProperty PROP_PAGE_HEADER_TEXT = new ValueProperty( TYPE, "PageHeaderText" );
    
    Value<String> getPageHeaderText();
    void setPageHeaderText( String pageHeaderText );
	
	// *** DiagramNodeDefs ***
    
    @Type( base = IDiagramNodeDef.class )
    @XmlListBinding( mappings = @XmlListBinding.Mapping( element = "node", type = IDiagramNodeDef.class ) )
                             
    ListProperty PROP_DIAGRAM_NODE_DEFS = new ListProperty( TYPE, "DiagramNodeDefs" );
    
    ModelElementList<IDiagramNodeDef> getDiagramNodeDefs();
    
	// *** DiagramConnectionDefs ***
    
    @Type( base = IDiagramConnectionDef.class )
    @XmlListBinding( mappings = @XmlListBinding.Mapping( element = "connection", type = IDiagramConnectionDef.class ) )
                             
    ListProperty PROP_DIAGRAM_CONNECTION_DEFS = new ListProperty( TYPE, "DiagramConnectionDefs" );
    
    ModelElementList<IDiagramConnectionDef> getDiagramConnectionDefs();
	
}




package org.eclipse.sapphire.ui.diagram.editor;

import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.ModelProperty;
import org.eclipse.sapphire.modeling.ReferenceValue;
import org.eclipse.sapphire.modeling.Value;
import org.eclipse.sapphire.modeling.ValueProperty;
import org.eclipse.sapphire.modeling.el.Function;
import org.eclipse.sapphire.ui.SapphirePart;
import org.eclipse.sapphire.ui.SapphireRenderingContext;
import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionDef;
import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionEndpointDef;

public class DiagramConnectionPart extends SapphirePart 
{
	private DiagramConnectionTemplate connectionTemplate;
	private IDiagramConnectionDef definition;
	private IModelElement modelElement;
	private IDiagramConnectionEndpointDef endpoint1Def;
	private IDiagramConnectionEndpointDef endpoint2Def;
	private IModelElement endpoint1Model;
	private IModelElement endpoint2Model;
	private Function labelFunction;
	private ValueProperty labelProperty;
	private Function idFunction;
	private Function endpoint1Function;
	private Function endpoint2Function;
	
	public DiagramConnectionPart(DiagramConnectionTemplate connectionTemplate)
	{
		this.connectionTemplate = connectionTemplate;
	}
	
    @Override
    protected void init()
    {
        super.init();
        
        this.definition = (IDiagramConnectionDef)super.definition;
        this.modelElement = getModelElement();
        this.labelFunction = initExpression
        ( 
            this.definition.getLabel().getLocalizedText(), 
            new Runnable()
            {
                public void run()
                {
                }
            }
        );
        
        this.labelProperty = FunctionUtil.getFunctionProperty(this.modelElement, this.labelFunction);
        if (this.labelProperty == null)
        {
        	throw new RuntimeException( "Label function does not contain a property.");
        }
        
        this.idFunction = initExpression
        ( 
            this.definition.getInstanceId().getLocalizedText(), 
            new Runnable()
            {
                public void run()
                {
                }
            }
        );
        
        this.endpoint1Def = this.definition.getEndpoint1().element();
        this.endpoint2Def = this.definition.getEndpoint2().element();
        this.endpoint1Model = processEndpoint(this.endpoint1Def);
        this.endpoint2Model = processEndpoint(this.endpoint2Def);
        this.endpoint1Function = initExpression
        (
        	this.endpoint1Model, 
        	this.endpoint1Def.getValue().getContent(), 
            new Runnable()
        	{
	            public void run()
	            {
	            	refreshEndpoint1();
	            }
        	}
        );
        this.endpoint2Function = initExpression
        (
        	this.endpoint2Model, 
        	this.endpoint2Def.getValue().getContent(), 
            new Runnable()
        	{
	            public void run()
	            {
	            	refreshEndpoint2();
	            }
        	}
        );
    }
    
    public DiagramConnectionTemplate getDiagramConnectionTemplate()
    {
    	return this.connectionTemplate;
    }
    
    public IModelElement getLocalModelElement()
    {
        return this.modelElement;
    }    
    
    public IModelElement getEndpoint1()
    {
    	return this.endpoint1Model;
    }
    
    public IModelElement getEndpoint2()
    {
    	return this.endpoint2Model;
    }

    public String getLabel()
	{
        String label = null;
        
        if( this.labelFunction != null )
        {
            label = (String) this.labelFunction.value();
        }
        
        if( label == null )
        {
            label = "#null#";
        }
        
        return label;
	}
    
    public void setLabel(String newValue)
    {
		if (this.labelProperty != null)
		{
			this.modelElement.write(this.labelProperty, newValue);
		}    	
    }
    
    public String getInstanceId()
	{
        String id = null;
        
        if( this.idFunction != null )
        {
            id = (String) this.idFunction.value();
        }
        
        if( id == null )
        {
            id = "#null#";
        }
        
        return id;
	}

    @Override
	public void render(SapphireRenderingContext context)
	{
		throw new UnsupportedOperationException();
	}
	
	public void refreshEndpoint1()
	{
		if (this.endpoint1Function != null)
		{
			Object value = this.endpoint1Function.value();
			String property = this.endpoint1Def.getProperty().getContent();
			setModelProperty(this.modelElement, property, value);
		}		
	}
	
	public void refreshEndpoint2()
	{
		if (this.endpoint2Function != null)
		{
			Object value = this.endpoint2Function.value();
			String property = this.endpoint2Def.getProperty().getContent();
			setModelProperty(this.modelElement, property, value);
		}		
	}
	
	private IModelElement processEndpoint(IDiagramConnectionEndpointDef endpointDef)
	{
		String propertyName = endpointDef.getProperty().getContent();
		ModelProperty modelProperty = resolve(this.modelElement, propertyName);
        if (!(modelProperty instanceof ValueProperty))
        {
        	throw new RuntimeException( "Property " + propertyName + " not a ValueProperty");
        }
        ValueProperty property = (ValueProperty)modelProperty;
		Value<?> valObj = this.modelElement.read(property);
		if (!(valObj instanceof ReferenceValue))
		{
			throw new RuntimeException( "Property " + propertyName + " value not a reference");
		}
		ReferenceValue<?> refVal = (ReferenceValue<?>)valObj;
		Object targetObj = refVal.resolve();
		if (!(targetObj instanceof IModelElement))
		{
			throw new RuntimeException( "Target not an IModelElement");
		}
		return (IModelElement)targetObj;
	}
	
    private void setModelProperty(final IModelElement modelElement, 
			String propertyName, Object value)
	{
		if (propertyName != null)
		{
			final ModelElementType type = modelElement.getModelElementType();
			final ModelProperty property = type.getProperty( propertyName );
			if( property == null )
			{
				throw new RuntimeException( "Could not find property " + propertyName + " in " + type.getQualifiedName() );
			}
			if (!(property instanceof ValueProperty))
			{
				throw new RuntimeException( "Property " + propertyName + " not a ValueProperty");
			}
		
			modelElement.write((ValueProperty)property, value);
		}    	
	}
	
}




package org.eclipse.sapphire.ui.diagram.editor;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.eclipse.sapphire.modeling.ElementProperty;
import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ListProperty;
import org.eclipse.sapphire.modeling.ModelElementList;
import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.ModelProperty;
import org.eclipse.sapphire.modeling.Value;
import org.eclipse.sapphire.modeling.ValueProperty;
import org.eclipse.sapphire.modeling.el.Function;
import org.eclipse.sapphire.modeling.el.FunctionContext;
import org.eclipse.sapphire.modeling.el.ModelElementFunctionContext;
import org.eclipse.sapphire.modeling.el.parser.ExpressionLanguageParser;
import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionDef;
import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionEndpointDef;
import org.eclipse.sapphire.ui.internal.SapphireUiFrameworkPlugin;

public class DiagramConnectionTemplate 
{
	private SapphireDiagramEditorPart diagramEditor;
	private IDiagramConnectionDef definition;
	private IModelElement modelElement;	
	private ModelProperty modelProperty;
	private String toolPaletteLabel;
	private String toolPaletteDesc;
	
	private List<DiagramConnectionPart> diagramConnections;
	    
    public DiagramConnectionTemplate(final SapphireDiagramEditorPart diagramEditor, 
    		IDiagramConnectionDef definition, IModelElement modelElement)
    {
    	this.diagramEditor = diagramEditor;
    	this.modelElement = modelElement;
    	this.definition = definition;
    	
        this.toolPaletteLabel = this.definition.getToolPaletteLabel().getContent();
        this.toolPaletteDesc = this.definition.getToolPaletteDesc().getContent();
        
        this.diagramConnections = new ArrayList<DiagramConnectionPart>();
        
        String propertyName = this.definition.getProperty().getContent();
        this.modelProperty = resolve(this.modelElement, propertyName);
        if (this.modelProperty instanceof ListProperty)
        {
        	ListProperty listProperty = (ListProperty)this.modelProperty;
        	ModelElementList<?> list = this.modelElement.read(listProperty);
            for( IModelElement listEntryModelElement : list )
            {
            	DiagramConnectionPart connection = new DiagramConnectionPart(this);
            	connection.init(this.diagramEditor, listEntryModelElement, definition, 
            			Collections.<String,String>emptyMap());
            	this.diagramConnections.add(connection);
            }
        }
        else if (this.modelProperty instanceof ElementProperty)
        {
        	ElementProperty elementProperty = (ElementProperty)this.modelProperty;
        	if (this.modelElement.read(elementProperty) != null)
        	{
	        	IModelElement localModelElement = this.modelElement.read(elementProperty).element();
	        	DiagramConnectionPart connection = new DiagramConnectionPart(this);
	        	connection.init(this.diagramEditor, localModelElement, definition, 
	        			Collections.<String,String>emptyMap());
	        	
	        	this.diagramConnections.add(connection);
        	}
        }
    }
    
    public List<DiagramConnectionPart> getDiagramConnections()
    {
    	return this.diagramConnections;
    }
    
    public String getToolPaletteLabel()
    {
    	return this.toolPaletteLabel;
    }
    
    public String getToolPaletteDesc()
    {
    	return this.toolPaletteDesc;
    }
    
    public DiagramConnectionPart createNewDiagramConnection(DiagramNodePart srcNode, 
    														DiagramNodePart targetNode)
    {
    	IModelElement newElement = null;
    	if (this.modelProperty instanceof ListProperty)
    	{
    		ListProperty listProperty = (ListProperty)this.modelProperty;
    		ModelElementList<?> list = this.modelElement.read(listProperty);
    		newElement = list.addNewElement();
    	}
    	else if (this.modelProperty instanceof ElementProperty)
    	{
    		// TODO what if the element property does exist?
    		ElementProperty elementProperty = (ElementProperty)this.modelProperty;
    		newElement = this.modelElement.read(elementProperty).element(true);
    	}
    	
    	IDiagramConnectionEndpointDef srcAnchorDef = this.definition.getEndpoint1().element();
    	String srcProperty = srcAnchorDef.getProperty().getContent();
    	String srcExpr = srcAnchorDef.getValue().getContent();
    	Function srcFunc = getNodeReferenceFunction(srcNode, srcExpr);
    	Object srcValue = srcFunc.value();
    	srcFunc.dispose();
    	setModelProperty(newElement, srcProperty, srcValue);
    	
    	IDiagramConnectionEndpointDef targetAnchorDef = this.definition.getEndpoint2().element();
    	String targetProperty = targetAnchorDef.getProperty().getContent();
    	String targetExpr = targetAnchorDef.getValue().getContent();
    	Function targetFunc = getNodeReferenceFunction(targetNode, targetExpr);
    	Object targetValue = targetFunc.value();
    	targetFunc.dispose();
    	setModelProperty(newElement, targetProperty, targetValue);
    	
    	DiagramConnectionPart newConn = new DiagramConnectionPart(this);
    	newConn.init(this.diagramEditor, newElement, this.definition, 
    			Collections.<String,String>emptyMap());
    	this.diagramConnections.add(newConn);
    	return newConn;
    }
    
    private ModelProperty resolve(final IModelElement modelElement, 
    		String propertyName)
    {
    	if (propertyName != null)
    	{
	        final ModelElementType type = modelElement.getModelElementType();
	        final ModelProperty property = type.getProperty( propertyName );
	        if( property == null )
	        {
	            throw new RuntimeException( "Could not find property " + propertyName + " in " + type.getQualifiedName() );
	        }
	        return property;
    	}    
        return null;
    }

    private void setModelProperty(final IModelElement modelElement, 
    								String propertyName, Object value)
    {
    	if (propertyName != null)
    	{
	        final ModelElementType type = modelElement.getModelElementType();
	        final ModelProperty property = type.getProperty( propertyName );
	        if( property == null )
	        {
	            throw new RuntimeException( "Could not find property " + propertyName + " in " + type.getQualifiedName() );
	        }
	        if (!(property instanceof ValueProperty))
	        {
	        	throw new RuntimeException( "Property " + propertyName + " not a ValueProperty");
	        }
	        		
	        modelElement.write((ValueProperty)property, ((Value<?>)value).getContent());
    	}    	
    }
    
    private Function getNodeReferenceFunction(final DiagramNodePart nodePart,
    											final String expression)
    {
        final FunctionContext context = new ModelElementFunctionContext( nodePart.getLocalModelElement() );
        Function result = null;
        
        if( expression != null )
        {
            try
            {
                result = ExpressionLanguageParser.parse( context, expression );
            }
            catch( Exception e )
            {
                SapphireUiFrameworkPlugin.log( e );
                result = null;
            }
        }
        return result;
    }
}




package org.eclipse.sapphire.ui.diagram.editor;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.resources.IFile;
import org.eclipse.sapphire.modeling.ModelElementList;
import org.eclipse.sapphire.modeling.ResourceStoreException;
import org.eclipse.sapphire.modeling.WorkspaceFileResourceStore;
import org.eclipse.sapphire.modeling.xml.RootXmlResource;
import org.eclipse.sapphire.modeling.xml.XmlResourceStore;
import org.eclipse.sapphire.ui.diagram.geometry.IBendPoint;
import org.eclipse.sapphire.ui.diagram.geometry.IDiagramConnectionGeometry;
import org.eclipse.sapphire.ui.diagram.geometry.IDiagramGeometry;
import org.eclipse.sapphire.ui.diagram.geometry.IDiagramNodeGeometry;

public class DiagramGeometryWrapper 
{
	private IFile file;
	private IDiagramGeometry geometryModel;
	private SapphireDiagramEditorPart diagramPart;
	
	private HashMap<DiagramNodePart, Bounds> nodeGeometries;
	private HashMap<DiagramConnectionPart, List<Point>> connectionBendpoints;
	
	public DiagramGeometryWrapper(IFile file, SapphireDiagramEditorPart diagramPart)
		throws ResourceStoreException
	{
		this.file = file;
		this.diagramPart = diagramPart;
		this.nodeGeometries = new HashMap<DiagramNodePart, Bounds>();
		this.connectionBendpoints = new HashMap<DiagramConnectionPart, List<Point>>();
		read();
	}
	
	public void addNode(DiagramNodePart nodePart, int x, int y, int w, int h)
	{
		Bounds bounds = new Bounds(x, y, w, h);
		this.nodeGeometries.put(nodePart, bounds);
	}
	
	public void removeNode(DiagramNodePart nodePart)
	{
		this.nodeGeometries.remove(nodePart);
	}
	
	public void updateNode(DiagramNodePart nodePart, int x, int y)
	{
		Bounds bounds = this.nodeGeometries.get(nodePart);
		if (bounds != null)
		{
			bounds.x = x;
			bounds.y = y;
		}
	}

	public void updateNode(DiagramNodePart nodePart, int x, int y, int w, int h)
	{
		Bounds bounds = this.nodeGeometries.get(nodePart);
		if (bounds != null)
		{
			bounds.x = x;
			bounds.y = y;
			bounds.height = h;
			bounds.width = w;
		}
	}
	
	public Bounds getNode(DiagramNodePart nodePart)
	{
		return this.nodeGeometries.get(nodePart);
	}
	
	public void addConnectionBendpoint(DiagramConnectionPart connPart, int index, int x, int y)
	{
		List<Point> bendpoints = this.connectionBendpoints.get(connPart);
		if (bendpoints == null)
		{
			bendpoints = new ArrayList<Point>();
			this.connectionBendpoints.put(connPart, bendpoints);
		}
		Point newPt = new Point(x, y);
		bendpoints.add(index, newPt);
	}
	
	public void removeConnectionBendpoint(DiagramConnectionPart connPart, int index)
	{
		List<Point> bendpoints = this.connectionBendpoints.get(connPart);
		if (bendpoints != null)
		{
			bendpoints.remove(index);
		}
	}
	
	public boolean setConnectionBendpoint(DiagramConnectionPart connPart, int index, int x, int y)
	{
		List<Point> bendpoints = this.connectionBendpoints.get(connPart);
		if (bendpoints != null && index < bendpoints.size())
		{
			bendpoints.set(index, new Point(x, y));
			return true;
		}
		return false;
	}
	

	public List<Point> getConnectionBendpoints(DiagramConnectionPart connPart)
	{
		return this.connectionBendpoints.get(connPart);
	}
	
	public void removeConnectionBendpoints(DiagramConnectionPart connPart)
	{
		this.connectionBendpoints.remove(connPart);
	}
	
	public void removeAllConnectionBendpoints()
	{
		this.connectionBendpoints.clear();
	}
	
	public void read() throws ResourceStoreException
	{
		final XmlResourceStore resourceStore = new XmlResourceStore( new WorkspaceFileResourceStore(this.file ));
		this.geometryModel = IDiagramGeometry.TYPE.instantiate(new RootXmlResource( resourceStore ));

		ModelElementList<IDiagramNodeGeometry> nodes = this.geometryModel.getDiagramNodeGeometries();
		for (IDiagramNodeGeometry node : nodes)
		{
			String id = node.getNodeId().getContent();
			DiagramNodePart nodePart = getNodeElement(id);
			if (nodePart != null)
			{
				int x = node.getX().getContent() != null ? node.getX().getContent() : -1;
				int y = node.getY().getContent() != null ? node.getY().getContent() : -1;
				int width = node.getWidth().getContent() != null ? node.getWidth().getContent() : -1;
				int height = node.getHeight().getContent() != null ? node.getHeight().getContent() : -1;
				this.addNode(nodePart, x, y, width, height);
			}
		}
		
		ModelElementList<IDiagramConnectionGeometry> connList = this.geometryModel.getDiagramConnectionGeometries();
		for (IDiagramConnectionGeometry connBend : connList)
		{
			String connId = connBend.getConnectionId().getContent();
			DiagramConnectionPart connPart = getConnectionElement(connId);
			if (connPart != null)
			{
				ModelElementList<IBendPoint> bps = connBend.getConnectionBendpoints();
				int index = 0;
				for (IBendPoint pt : bps)
				{
					this.addConnectionBendpoint(connPart, index++, pt.getX().getContent(), pt.getY().getContent());
				}
			}			
		}
	}
	
	public void write() throws ResourceStoreException
	{
		this.geometryModel.getDiagramNodeGeometries().clear();
		Iterator<DiagramNodePart> it = this.nodeGeometries.keySet().iterator();
		while (it.hasNext())
		{
			DiagramNodePart nodePart = it.next();
			Bounds bounds = this.nodeGeometries.get(nodePart);
			String id = nodePart.getInstanceId();
			
			if (bounds != null && id != null)
			{
				IDiagramNodeGeometry diagramNode = this.geometryModel.getDiagramNodeGeometries().addNewElement();
				diagramNode.setNodeId(id);
				diagramNode.setX(bounds.x);
				diagramNode.setY(bounds.y);
				diagramNode.setWidth(bounds.width);
				diagramNode.setHeight(bounds.height);
			}
		}
		
		this.geometryModel.getDiagramConnectionGeometries().clear();
		Iterator<DiagramConnectionPart> connIt = this.connectionBendpoints.keySet().iterator();
		while (connIt.hasNext())
		{
			DiagramConnectionPart connPart = connIt.next();
			List<Point> bps = this.connectionBendpoints.get(connPart);
			String id = connPart.getInstanceId();
			
			if (bps != null && id != null)
			{
				IDiagramConnectionGeometry conn = this.geometryModel.getDiagramConnectionGeometries().addNewElement();
				conn.setConnectionId(id);
				for (Point pt : bps)
				{
					IBendPoint pt2 = conn.getConnectionBendpoints().addNewElement();
					pt2.setX(pt.x);
					pt2.setY(pt.y);
				}
			}
		}
		
		this.geometryModel.resource().save();
	}

	private DiagramNodePart getNodeElement(String nodeId)
	{
		for (DiagramNodeTemplate nodeTemplate : this.diagramPart.getNodeTemplates())
		{
			for (DiagramNodePart nodePart : nodeTemplate.getDiagramNodes())
			{
				String nodeId2 = nodePart.getInstanceId();
				if (nodeId != null && nodeId2 != null && nodeId.equals(nodeId2))
				{
					return nodePart;
				}
			}
		}
		return null;
	}
	
	private DiagramConnectionPart getConnectionElement(String connId)
	{
		for (DiagramConnectionTemplate connTemplate : this.diagramPart.getConnectionTemplates())
		{
			for (DiagramConnectionPart connPart : connTemplate.getDiagramConnections())
			{
				String connId2 = connPart.getInstanceId();
				if (connId != null && connId2 != null && connId.equals(connId2))
				{
					return connPart;
				}
			}
		}
		return null;
	}

	// -------------------------------------------------------------------
	// Inner classes
	// -------------------------------------------------------------------
	
	public static class Point
	{
		public int x;
		public int y;
		
		public Point(int x, int y)
		{
			this.x = x;
			this.y = y;
		}
	}
	
	public static final class Bounds extends Point
	{
		public int width;
		public int height;
		
		public Bounds(int x, int y, int width, int height)
		{
			super(x, y);
			this.width = width;
			this.height = height;
		}
	}
}




package org.eclipse.sapphire.ui.diagram.editor;

import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ValueProperty;
import org.eclipse.sapphire.modeling.el.Function;
import org.eclipse.sapphire.ui.SapphirePart;
import org.eclipse.sapphire.ui.SapphireRenderingContext;
import org.eclipse.sapphire.ui.diagram.def.IDiagramNodeDef;

public class DiagramNodePart extends SapphirePart 
{
	private DiagramNodeTemplate nodeTemplate;
	private IDiagramNodeDef definition;
	private IModelElement modelElement;
	private Function labelFunction;
	private Function idFunction;
	private ValueProperty labelProperty;
	
	public DiagramNodePart(DiagramNodeTemplate nodeTemplate)
	{
		this.nodeTemplate = nodeTemplate;
	}
	
    @Override
    protected void init()
    {
        super.init();
        
        this.definition = (IDiagramNodeDef)super.definition;
        this.modelElement = getModelElement();
        this.labelFunction = initExpression
        ( 
            this.definition.getLabel().getLocalizedText(), 
            new Runnable()
            {
                public void run()
                {
                }
            }
        );
        this.labelProperty = FunctionUtil.getFunctionProperty(this.modelElement, this.labelFunction);
        if (this.labelProperty == null)
        {
        	throw new RuntimeException( "Label function does not contain a property.");
        }
        
        this.idFunction = initExpression
        ( 
            this.definition.getInstanceId().getLocalizedText(), 
            new Runnable()
            {
                public void run()
                {
                }
            }
        );
    }
    
    public DiagramNodeTemplate getDiagramNodeTemplate()
    {
    	return this.nodeTemplate;
    }
    
    public IModelElement getLocalModelElement()
    {
        return this.modelElement;
    }    
        
	@Override
	public void render(SapphireRenderingContext context)
	{
		throw new UnsupportedOperationException();
	}

	public String getLabel()
	{
        String label = null;
        
        if( this.labelFunction != null )
        {
            label = (String) this.labelFunction.value();
        }
        
        if( label == null )
        {
            label = "#null#";
        }
        
        return label;
	}

	public void setLabel(String newValue)
	{
		if (this.labelProperty != null)
		{
			this.modelElement.write(this.labelProperty, newValue);
		}
	}
	
	public String getInstanceId()
	{
        String id = null;
        
        if( this.idFunction != null )
        {
            id = (String) this.idFunction.value();
        }
        
        if( id == null )
        {
            id = "#null#";
        }
        
        return id;
		
	}
		
}




package org.eclipse.sapphire.ui.diagram.editor;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.eclipse.sapphire.modeling.ElementProperty;
import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ListProperty;
import org.eclipse.sapphire.modeling.ModelElementList;
import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.ModelProperty;
import org.eclipse.sapphire.ui.diagram.def.IDiagramNodeDef;

public class DiagramNodeTemplate 
{
	private SapphireDiagramEditorPart diagramEditor;
	private IDiagramNodeDef definition;
	private IModelElement modelElement;	
	private ModelProperty modelProperty;
	private String toolPaletteLabel;
	private String toolPaletteDesc;
	
	private List<DiagramNodePart> diagramNodes;
	    
    public DiagramNodeTemplate(final SapphireDiagramEditorPart diagramEditor, IDiagramNodeDef definition, IModelElement modelElement)
    {
    	this.diagramEditor = diagramEditor;
    	this.modelElement = modelElement;
    	this.definition = definition;
    	
        this.toolPaletteLabel = this.definition.getToolPaletteLabel().getContent();
        this.toolPaletteDesc = this.definition.getToolPaletteDesc().getContent();
        
        this.diagramNodes = new ArrayList<DiagramNodePart>();
        
        String propertyName = this.definition.getProperty().getContent();
        this.modelProperty = resolve(this.modelElement, propertyName);
        if (this.modelProperty instanceof ListProperty)
        {
        	ListProperty listProperty = (ListProperty)this.modelProperty;
        	ModelElementList<?> list = this.modelElement.read(listProperty);
            for( IModelElement listEntryModelElement : list )
            {
            	DiagramNodePart node = new DiagramNodePart(this);
            	node.init(this.diagramEditor, listEntryModelElement, definition, 
            			Collections.<String,String>emptyMap());
            	this.diagramNodes.add(node);
            }
        }
        else if (this.modelProperty instanceof ElementProperty)
        {
        	ElementProperty elementProperty = (ElementProperty)this.modelProperty;
        	if (this.modelElement.read(elementProperty) != null)
        	{
	        	IModelElement localModelElement = this.modelElement.read(elementProperty).element();
	        	DiagramNodePart node = new DiagramNodePart(this);
	        	node.init(this.diagramEditor, localModelElement, definition, 
	        			Collections.<String,String>emptyMap());
	        	
	        	this.diagramNodes.add(node);
        	}
        }
    }
    
    public List<DiagramNodePart> getDiagramNodes()
    {
    	return this.diagramNodes;
    }
    
    public String getToolPaletteLabel()
    {
    	return this.toolPaletteLabel;
    }
    
    public String getToolPaletteDesc()
    {
    	return this.toolPaletteDesc;
    }
    
    public DiagramNodePart createNewDiagramNode()
    {
    	IModelElement newElement = null;
    	if (this.modelProperty instanceof ListProperty)
    	{
    		ListProperty listProperty = (ListProperty)this.modelProperty;
    		ModelElementList<?> list = this.modelElement.read(listProperty);
    		newElement = list.addNewElement();
    	}
    	else if (this.modelProperty instanceof ElementProperty)
    	{
    		// TODO what if the element property does exist?
    		ElementProperty elementProperty = (ElementProperty)this.modelProperty;
    		newElement = this.modelElement.read(elementProperty).element(true);
    	}
    	DiagramNodePart newNode = new DiagramNodePart(this);
    	newNode.init(this.diagramEditor, newElement, this.definition, 
    			Collections.<String,String>emptyMap());
    	this.diagramNodes.add(newNode);
    	return newNode;
    }
    
    private ModelProperty resolve(final IModelElement modelElement, 
    		String propertyName)
    {
    	if (propertyName != null)
    	{
	        final ModelElementType type = modelElement.getModelElementType();
	        final ModelProperty property = type.getProperty( propertyName );
	        
	        if( property == null )
	        {
	            throw new RuntimeException( "Could not find property " + propertyName + " in " + type.getQualifiedName() );
	        }
	        return property;
    	}    
        return null;
    }
    
}




package org.eclipse.sapphire.ui.diagram.editor;

import java.util.List;

import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.ModelProperty;
import org.eclipse.sapphire.modeling.ValueProperty;
import org.eclipse.sapphire.modeling.el.Function;
import org.eclipse.sapphire.modeling.el.RootPropertyAccessFunction;

public class FunctionUtil 
{
    public static ValueProperty getFunctionProperty(IModelElement modelElement, Function function)
    {
    	if (function instanceof RootPropertyAccessFunction)
    	{
    		RootPropertyAccessFunction rpaf = (RootPropertyAccessFunction)function;
    		if (rpaf.operand(0).value() instanceof String)
    		{
    			String propName = (String)rpaf.operand(0).value();
    	        final ModelElementType type = modelElement.getModelElementType();
    	        final ModelProperty property = type.getProperty(propName);
    			if (property instanceof ValueProperty)
    			{
    				return (ValueProperty)property;
    			}
    		}
    	}
    	else 
    	{
    		List<Function> subFuncs = function.operands();
    		for (Function subFunc : subFuncs)
    		{
    			ValueProperty property = getFunctionProperty(modelElement, subFunc);
    			if (property != null)
    			{
    				return property;
    			}
    		}
    	}
    	return null;
    }

}




package org.eclipse.sapphire.ui.diagram.editor;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.help.IContext;
import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ModelElementList;
import org.eclipse.sapphire.ui.ISapphirePart;
import org.eclipse.sapphire.ui.SapphireAction;
import org.eclipse.sapphire.ui.SapphireActionGroup;
import org.eclipse.sapphire.ui.SapphireEditor;
import org.eclipse.sapphire.ui.SapphireImageCache;
import org.eclipse.sapphire.ui.SapphirePartListener;
import org.eclipse.sapphire.ui.def.ISapphirePartDef;
import org.eclipse.sapphire.ui.def.ISapphireUiDef;
import org.eclipse.sapphire.ui.def.SapphireUiDefFactory;
import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionDef;
import org.eclipse.sapphire.ui.diagram.def.IDiagramNodeDef;
import org.eclipse.sapphire.ui.diagram.def.IDiagramPageDef;
import org.eclipse.sapphire.ui.diagram.graphiti.editor.SapphireDiagramEditor;
import org.eclipse.sapphire.ui.diagram.graphiti.editor.SapphireDiagramEditorFactory;
import org.eclipse.sapphire.ui.diagram.graphiti.editor.SapphireDiagramEditorInput;
import org.eclipse.sapphire.ui.internal.SapphireUiFrameworkPlugin;

public class SapphireDiagramEditorPart
	implements ISapphirePart
{
    private final SapphireEditor editor;
    private final IModelElement rootModelElement;
    private IDiagramPageDef diagramPageDef = null;
    private DiagramGeometryWrapper diagramGeometry;
    private List<DiagramNodeTemplate> nodeTemplates;
    private List<DiagramConnectionTemplate> connectionTemplates;
    private SapphireDiagramEditorInput diagramInput;
    private SapphireDiagramEditor diagramEditor;
	
	public SapphireDiagramEditorPart(final SapphireEditor editor,
								final IModelElement rootModelElement,
								final IPath pageDefinitionLocation )
	{
		this(editor, rootModelElement, pageDefinitionLocation, null);
	}

	public SapphireDiagramEditorPart(final SapphireEditor editor,
								final IModelElement rootModelElement,
								final IPath pageDefinitionLocation,
								String pageName )
	{
		this.editor = editor;
		this.rootModelElement = rootModelElement;

        final String bundleId = pageDefinitionLocation.segment( 0 );
        final String pageId = pageDefinitionLocation.lastSegment();
        final String relPath = pageDefinitionLocation.removeFirstSegments( 1 ).removeLastSegments( 1 ).toPortableString();
        
        final ISapphireUiDef def = SapphireUiDefFactory.load( bundleId, relPath );
        
        for( IDiagramPageDef pg : def.getDiagramPageDefs() )
        {
            if( pageId.equals( pg.getId().getText() ) )
            {
                this.diagramPageDef = pg;
                break;
            }
        }
                
        this.nodeTemplates = new ArrayList<DiagramNodeTemplate>();
        ModelElementList<IDiagramNodeDef> nodeDefs = this.diagramPageDef.getDiagramNodeDefs();
        
        for (IDiagramNodeDef nodeDef : nodeDefs)
        {
        	DiagramNodeTemplate nodeTemplate = new DiagramNodeTemplate(this, nodeDef, this.rootModelElement);
        	this.nodeTemplates.add(nodeTemplate);
        }
        
        this.connectionTemplates = new ArrayList<DiagramConnectionTemplate>();
        ModelElementList<IDiagramConnectionDef> connectionDefs = this.diagramPageDef.getDiagramConnectionDefs();
        for (IDiagramConnectionDef connectionDef : connectionDefs)
        {
        	DiagramConnectionTemplate connectionTemplate = new DiagramConnectionTemplate(this, connectionDef, this.rootModelElement);
        	this.connectionTemplates.add(connectionTemplate);
        }       
        
        initializeDiagramEditor();
	}

	private void initializeDiagramEditor()
	{
        try
        {
        	this.diagramInput = SapphireDiagramEditorFactory.createEditorInput(this.editor.getEditorInput());
        	IFile npFile = this.diagramInput.getNodePositionFile();
        	this.diagramGeometry = new DiagramGeometryWrapper(npFile, this);
        }
        catch( Exception e )
        {
            SapphireUiFrameworkPlugin.log( e );
        }
    	this.diagramEditor = new SapphireDiagramEditor(this);
	}
	
	public SapphireDiagramEditorInput getDiagramEditorInput()
	{
		return this.diagramInput;
	}
	
	public SapphireDiagramEditor getDiagramEditor()
	{
		return this.diagramEditor;
	}
	
	public List<DiagramNodeTemplate> getNodeTemplates()
	{
		return this.nodeTemplates;
	}
	
	public List<DiagramConnectionTemplate> getConnectionTemplates()
	{
		return this.connectionTemplates;
	}
	
	public DiagramGeometryWrapper getDiagramGeometry()
	{
		return this.diagramGeometry;
	}
	
	public ISapphirePart getParentPart() 
	{	
		return this.editor;
	}

	public <T> T getNearestPart(Class<T> partType) {
		// TODO Auto-generated method stub
		return null;
	}

	public IModelElement getModelElement() 
	{	
		return this.rootModelElement;
	}

	public IStatus getValidationState() {
		// TODO Auto-generated method stub
		return null;
	}

	public IContext getDocumentationContext() {
		// TODO Auto-generated method stub
		return null;
	}

	public SapphireImageCache getImageCache() {
		// TODO Auto-generated method stub
		return null;
	}

	public void addListener(SapphirePartListener listener) {
		// TODO Auto-generated method stub
		
	}

	public void removeListener(SapphirePartListener listener) {
		// TODO Auto-generated method stub
		
	}

	public void dispose() {
		// TODO Auto-generated method stub
		
	}

	public ISapphirePartDef getDefinition() 
	{	
		return this.diagramPageDef;
	}

	public Set<String> getActionContexts() {
		// TODO Auto-generated method stub
		return null;
	}

	public String getMainActionContext() {
		// TODO Auto-generated method stub
		return null;
	}

	public SapphireActionGroup getActions() {
		// TODO Auto-generated method stub
		return null;
	}

	public SapphireActionGroup getActions(String context) {
		// TODO Auto-generated method stub
		return null;
	}

	public SapphireAction getAction(String id) {
		// TODO Auto-generated method stub
		return null;
	}
}




package org.eclipse.sapphire.ui.diagram.geometry;

import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.Value;
import org.eclipse.sapphire.modeling.ValueProperty;
import org.eclipse.sapphire.modeling.annotations.GenerateImpl;
import org.eclipse.sapphire.modeling.annotations.Type;
import org.eclipse.sapphire.modeling.xml.annotations.CustomXmlValueBinding;
import org.eclipse.sapphire.ui.diagram.geometry.internal.GeometryAttributeBinding;

@GenerateImpl

public interface IBendPoint extends IModelElement 
{
	ModelElementType TYPE = new ModelElementType( IBendPoint.class );
	
    // *** X ***
    
    @Type( base = Integer.class )
    @CustomXmlValueBinding( impl = GeometryAttributeBinding.class, params = {"x"})
    
    ValueProperty PROP_X = new ValueProperty( TYPE, "X");
    
    Value<Integer> getX();
    void setX(Integer value);
	void setX(String value);

    // *** Y ***
    
    @Type( base = Integer.class )
    @CustomXmlValueBinding( impl = GeometryAttributeBinding.class, params = {"y"})

    ValueProperty PROP_Y = new ValueProperty( TYPE, "Y");
    
    Value<Integer> getY();
    void setY(Integer value);
	void setY(String value);
	
}




package org.eclipse.sapphire.ui.diagram.geometry;

import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ListProperty;
import org.eclipse.sapphire.modeling.ModelElementList;
import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.Value;
import org.eclipse.sapphire.modeling.ValueProperty;
import org.eclipse.sapphire.modeling.annotations.GenerateImpl;
import org.eclipse.sapphire.modeling.annotations.NonNullValue;
import org.eclipse.sapphire.modeling.annotations.Type;
import org.eclipse.sapphire.modeling.xml.annotations.XmlBinding;
import org.eclipse.sapphire.modeling.xml.annotations.XmlListBinding;

@GenerateImpl

public interface IDiagramConnectionGeometry extends IModelElement 
{
	ModelElementType TYPE = new ModelElementType( IDiagramConnectionGeometry.class );
	
	// *** ConnectionId ***
	
	@XmlBinding( path = "id")
	@NonNullValue

	ValueProperty PROP_CONNECTION_ID = new ValueProperty( TYPE, "ConnectionId" );

    Value<String> getConnectionId();
    void setConnectionId( String name );

    // *** ConnectionBendpoints***

    @Type( base = IBendPoint.class )
    @XmlListBinding( mappings = @XmlListBinding.Mapping( element = "bendpoint", type = IBendPoint.class ) )
    
    ListProperty PROP_CONNECTION_BENDPOINTS = new ListProperty( TYPE, "ConnectionBendPoints" );
    
    ModelElementList<IBendPoint> getConnectionBendpoints();
    
    
}




package org.eclipse.sapphire.ui.diagram.geometry;

import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ListProperty;
import org.eclipse.sapphire.modeling.ModelElementList;
import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.annotations.GenerateImpl;
import org.eclipse.sapphire.modeling.annotations.Type;
import org.eclipse.sapphire.modeling.xml.annotations.XmlListBinding;
import org.eclipse.sapphire.modeling.xml.annotations.XmlRootBinding;

@GenerateImpl
@XmlRootBinding( elementName = "diagram-geometry" )

public interface IDiagramGeometry extends IModelElement 
{
	ModelElementType TYPE = new ModelElementType( IDiagramGeometry.class );
	
    // *** DiagramNodeGeometries ***

    @Type( base = IDiagramNodeGeometry.class )
    
    @XmlListBinding( mappings = @XmlListBinding.Mapping( element = "node", type = IDiagramNodeGeometry.class ) )
    
    ListProperty PROP_DIAGRAM_NODE_GEOMETRIES = new ListProperty( TYPE, "DiagramNodeGeometries" );
    
    ModelElementList<IDiagramNodeGeometry> getDiagramNodeGeometries();
	
    // *** DiagramConnectionGeometries ***

    @Type( base = IDiagramConnectionGeometry.class )
    
    @XmlListBinding( mappings = @XmlListBinding.Mapping( element = "connection", type = IDiagramConnectionGeometry.class ) )
    
    ListProperty PROP_DIAGRAM_CONNECTION_GEOMETRIES = new ListProperty( TYPE, "DiagramConnectionGeometries" );
    
    ModelElementList<IDiagramConnectionGeometry> getDiagramConnectionGeometries();

}




package org.eclipse.sapphire.ui.diagram.geometry;

import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.Value;
import org.eclipse.sapphire.modeling.ValueProperty;
import org.eclipse.sapphire.modeling.annotations.GenerateImpl;
import org.eclipse.sapphire.modeling.annotations.NonNullValue;
import org.eclipse.sapphire.modeling.annotations.Type;
import org.eclipse.sapphire.modeling.xml.annotations.CustomXmlValueBinding;
import org.eclipse.sapphire.modeling.xml.annotations.XmlBinding;
import org.eclipse.sapphire.ui.diagram.geometry.internal.GeometryAttributeBinding;

@GenerateImpl

public interface IDiagramNodeGeometry extends IModelElement
{
	ModelElementType TYPE = new ModelElementType( IDiagramNodeGeometry.class );
	
	// *** NodeId ***
	
	@XmlBinding( path = "id")
	@NonNullValue

	ValueProperty PROP_NODE_ID = new ValueProperty( TYPE, "NodeId" );

    Value<String> getNodeId();
    void setNodeId( String name );

    // *** X ***
    
    @Type( base = Integer.class )
    @CustomXmlValueBinding( impl = GeometryAttributeBinding.class, params = {"gemometry", "x"})
    
    ValueProperty PROP_X = new ValueProperty( TYPE, "X");
    
    Value<Integer> getX();
    void setX(Integer value);
	void setX(String value);

    // *** Y ***
    
    @Type( base = Integer.class )
    @CustomXmlValueBinding( impl = GeometryAttributeBinding.class, params = {"gemometry", "y"})

    ValueProperty PROP_Y = new ValueProperty( TYPE, "Y");
    
    Value<Integer> getY();
    void setY(Integer value);
	void setY(String value);
    
    // *** Width ***
    
    @Type( base = Integer.class )
    @CustomXmlValueBinding( impl = GeometryAttributeBinding.class, params = {"gemometry", "width"})
    
    ValueProperty PROP_WIDTH = new ValueProperty( TYPE, "Width");
    
    Value<Integer> getWidth();
    void setWidth(Integer value);
	void setWidth(String value);
	
    // *** Height ***
    
    @Type( base = Integer.class )
    @CustomXmlValueBinding( impl = GeometryAttributeBinding.class, params = {"gemometry", "height"})
    
    ValueProperty PROP_HEIGHT = new ValueProperty( TYPE, "Height");
    
    Value<Integer> getHeight();
    void setHeight(Integer value);
	void setHeight(String value);
	
}




package org.eclipse.sapphire.ui.diagram.geometry.internal;

import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ModelProperty;
import org.eclipse.sapphire.modeling.xml.XmlElement;
import org.eclipse.sapphire.modeling.xml.XmlValueBindingImpl;

public class GeometryAttributeBinding extends XmlValueBindingImpl
{
	private String modelPath = null;
	private String attrName = null;
	
	@Override
    public void init( final IModelElement element,
            final ModelProperty property,
            final String[] params )
	{
		super.init(element, property, params);
		if (params != null)
		{
			if (params.length > 1)
			{
				this.modelPath = params[0];
				this.attrName = params[1];
			}
			else if (params.length > 0) 
			{
				this.attrName = params[0];
			}
		}
	}

	@Override
	public String read() 
	{
		String attrVal = null;
		if (this.attrName != null)
		{
			XmlElement geometryEl = xml(false);
			if (geometryEl != null)
			{
				if (this.modelPath != null)
				{
					geometryEl = geometryEl.getChildElement(this.modelPath, false);
				}
				if (geometryEl != null)
				{
					attrVal = ( geometryEl.getAttributeText(this.attrName) );
				}
			}
		}
		return attrVal;
	}

	@Override
	public void write(String value) 
	{
		if (this.attrName != null)
		{
			XmlElement geometryEl = xml(true);
			if (this.modelPath != null)
			{
				geometryEl = geometryEl.getChildElement(this.modelPath, true);
			}
			geometryEl.setAttributeText( this.attrName, value, true );
		}		
	}
}




package org.eclipse.sapphire.ui.diagram.graphiti;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.emf.common.command.CommandStack;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.common.util.WrappedException;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.transaction.RecordingCommand;
import org.eclipse.emf.transaction.Transaction;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.transaction.impl.TransactionalEditingDomainImpl;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.graphiti.ui.editor.DiagramEditorFactory;

public class GraphitiFileService 
{
	public static TransactionalEditingDomain createEmfFileForDiagram(URI diagramResourceUri, final Diagram diagram) {

		// Create a resource set and EditingDomain
		final TransactionalEditingDomain editingDomain = DiagramEditorFactory.createResourceSetAndEditingDomain();
		final ResourceSet resourceSet = editingDomain.getResourceSet();
		// Create a resource for this file.
		final Resource resource = resourceSet.createResource(diagramResourceUri);
		final CommandStack commandStack = editingDomain.getCommandStack();
		commandStack.execute(new RecordingCommand(editingDomain) {

			@Override
			protected void doExecute() {
				resource.setTrackingModification(true);
				resource.getContents().add(diagram);

			}
		});

		save(editingDomain, Collections.<Resource, Map<?, ?>> emptyMap());
		return editingDomain;
	}

	private static void save(TransactionalEditingDomain editingDomain, Map<Resource, Map<?, ?>> options) {
		saveInWorkspaceRunnable(editingDomain, options);
	}

	private static void saveInWorkspaceRunnable(final TransactionalEditingDomain editingDomain, final Map<Resource, Map<?, ?>> options) {

		final Map<URI, Throwable> failedSaves = new HashMap<URI, Throwable>();
		final IWorkspaceRunnable wsRunnable = new IWorkspaceRunnable() {			
			public void run(final IProgressMonitor monitor) throws CoreException {

				final Runnable runnable = new Runnable() {
					
					public void run() {
						Transaction parentTx;
						if (editingDomain != null
								&& (parentTx = ((TransactionalEditingDomainImpl) editingDomain).getActiveTransaction()) != null) {
							do {
								if (!parentTx.isReadOnly()) {
									throw new IllegalStateException(
											"FileService.save() called from within a command (likely produces a deadlock)");
								}
							} while ((parentTx = ((TransactionalEditingDomainImpl) editingDomain).getActiveTransaction().getParent()) != null);
						}

						final EList<Resource> resources = editingDomain.getResourceSet().getResources();
						// Copy list to an array to prevent
						// ConcurrentModificationExceptions
						// during the saving of the dirty resources
						Resource[] resourcesArray = new Resource[resources.size()];
						resourcesArray = resources.toArray(resourcesArray);
						final Set<Resource> savedResources = new HashSet<Resource>();
						for (int i = 0; i < resourcesArray.length; i++) {
							// In case resource modification tracking is
							// switched on, we can check if a resource
							// has been modified, so that we only need to same
							// really changed resources; otherwise
							// we need to save all resources in the set
							final Resource resource = resourcesArray[i];
							if (resource.isModified()) {
								try {
									resource.save(options.get(resource));
									savedResources.add(resource);
								} catch (final Throwable t) {
									failedSaves.put(resource.getURI(), t);
								}
							}
						}
					}
				};

				try {
					editingDomain.runExclusive(runnable);
				} catch (final InterruptedException e) {
					throw new RuntimeException(e);
				}
				editingDomain.getCommandStack().flush();
			}
		};
		try {
			ResourcesPlugin.getWorkspace().run(wsRunnable, null);
			if (!failedSaves.isEmpty()) {
				throw new WrappedException(createMessage(failedSaves), new RuntimeException());
			}
		} catch (final CoreException e) {
			final Throwable cause = e.getStatus().getException();
			if (cause instanceof RuntimeException) {
				throw (RuntimeException) cause;
			}
			throw new RuntimeException(e);
		}
	}

	private static String createMessage(Map<URI, Throwable> failedSaves) {
		final StringBuilder buf = new StringBuilder("The following resources could not be saved:");
		for (final Entry<URI, Throwable> entry : failedSaves.entrySet()) {
			buf.append("\nURI: ").append(entry.getKey().toString()).append(", cause: \n").append(getExceptionAsString(entry.getValue()));
		}
		return buf.toString();
	}

	private static String getExceptionAsString(Throwable t) {
		final StringWriter stringWriter = new StringWriter();
		final PrintWriter printWriter = new PrintWriter(stringWriter);
		t.printStackTrace(printWriter);
		final String result = stringWriter.toString();
		try {
			stringWriter.close();
		} catch (final IOException e) {
			// $JL-EXC$ ignore
		}
		printWriter.close();
		return result;
	}
	
	public static IFile EmfResourceToIFile(Resource resource)
	{
		IFile ifile = null;
		
		URI uri = resource.getURI();
	    uri = resource.getResourceSet().getURIConverter().normalize(uri);
	    
	    String scheme = uri.scheme();
	    if ("platform".equals(scheme) && uri.segmentCount() > 1 &&
	    		"resource".equals(uri.segment(0)))
	    {
	    	StringBuffer platformResourcePath = new StringBuffer();
	    	for (int j = 1, size = uri.segmentCount(); j < size; ++j)
	    	{
	    		platformResourcePath.append('/');
	    		platformResourcePath.append(uri.segment(j));
	    	}
	    	return ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(platformResourcePath.toString()));
	    }
		return ifile;
	}

}




package org.eclipse.sapphire.ui.diagram.graphiti.editor;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.emf.transaction.RecordingCommand;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.transaction.util.TransactionUtil;
import org.eclipse.graphiti.features.IAddFeature;
import org.eclipse.graphiti.features.context.impl.AddConnectionContext;
import org.eclipse.graphiti.features.context.impl.AddContext;
import org.eclipse.graphiti.mm.algorithms.styles.Point;
import org.eclipse.graphiti.mm.pictograms.Anchor;
import org.eclipse.graphiti.mm.pictograms.Connection;
import org.eclipse.graphiti.mm.pictograms.ContainerShape;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.graphiti.mm.pictograms.Shape;
import org.eclipse.graphiti.services.Graphiti;
import org.eclipse.graphiti.ui.editor.DiagramEditor;
import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionPart;
import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionTemplate;
import org.eclipse.sapphire.ui.diagram.editor.DiagramGeometryWrapper;
import org.eclipse.sapphire.ui.diagram.editor.DiagramGeometryWrapper.Bounds;
import org.eclipse.sapphire.ui.diagram.editor.DiagramNodePart;
import org.eclipse.sapphire.ui.diagram.editor.DiagramNodeTemplate;
import org.eclipse.sapphire.ui.diagram.editor.SapphireDiagramEditorPart;
import org.eclipse.sapphire.ui.internal.SapphireUiFrameworkPlugin;

@SuppressWarnings("restriction")
public class SapphireDiagramEditor extends DiagramEditor 
{
	private SapphireDiagramEditorPart diagramPart;
	
	public SapphireDiagramEditor(SapphireDiagramEditorPart diagramPart)
	{
		this.diagramPart = diagramPart;
	}
	
	public SapphireDiagramEditorPart getDiagramEditorPart()
	{
		return this.diagramPart;
	}
	
	@Override
	public void doSave(final IProgressMonitor monitor )
	{
		super.doSave(monitor);
		try
		{
			this.diagramPart.getDiagramGeometry().write();
		}
        catch( Exception e )
        {
            SapphireUiFrameworkPlugin.log( e );
        }		
	}
	
	public void syncDiagramWithModel()
	{
		final Diagram diagram = getDiagramTypeProvider().getDiagram();
		
		TransactionalEditingDomain ted = TransactionUtil.getEditingDomain(diagram);
		ted.getCommandStack().execute(new RecordingCommand(ted) 
		{
			protected void doExecute() 
			{		
				removeConnections(diagram);
				removeNodes(diagram);
				
				reconstructNodes(diagram);
				reconstructConnections(diagram);
			}
		});
	}
	
	private void removeConnections(final Diagram diagram) 
	{
		List<Connection> cons = diagram.getConnections();
		Iterator<Connection> consIt = cons.iterator();
		// don't cause ConcurrentModificationException
		Collection<Connection> allCons = new HashSet<Connection>();
		while (consIt.hasNext()) 
		{
			Connection con = consIt.next();
			allCons.add(con);
		}
		consIt = allCons.iterator();
		while (consIt.hasNext()) 
		{
			Connection con = consIt.next();			
			Graphiti.getPeService().deletePictogramElement(con);
		}		
	}
	
	private void removeNodes(final Diagram diagram)
	{
		List<Shape> containerShapes = diagram.getChildren();
		Iterator<Shape> shapeIt = containerShapes.iterator();
		// don't cause ConcurrentModificationException
		Collection<Shape> allShapes = new HashSet<Shape>();
		while (shapeIt.hasNext())
		{
			Shape shape = shapeIt.next();
			allShapes.add(shape);
		}
		shapeIt = allShapes.iterator();
		while (shapeIt.hasNext())
		{
			Shape containerShape = shapeIt.next();
			Graphiti.getPeService().deletePictogramElement(containerShape);
		}
	}
	
	private void reconstructNodes(final Diagram diagram)
	{
		// Add the nodes back to the diagram thus re-establishing mapping between
		// pictograms and business objects
		
		int nodeX = 50;
		int nodeY = 50;
		int xInc = 100;
		DiagramGeometryWrapper diagramGeometry = SapphireDiagramEditor.this.diagramPart.getDiagramGeometry();
		
		for (DiagramNodeTemplate nodeTemplate : SapphireDiagramEditor.this.diagramPart.getNodeTemplates())
		{
			for (DiagramNodePart nodePart : nodeTemplate.getDiagramNodes())
			{
				Bounds bounds = diagramGeometry.getNode(nodePart);
				if (bounds == null)
				{
					bounds = new Bounds(nodeX, nodeY, -1, -1);
					nodeX += xInc;
				}
				AddContext ctx = new AddContext();
				ctx.setNewObject(nodePart);
				ctx.setTargetContainer(diagram);
				ctx.setWidth(bounds.width);
				ctx.setHeight(bounds.height);
				ctx.setX(bounds.x);
				ctx.setY(bounds.y);
				IAddFeature ft = getDiagramTypeProvider().getFeatureProvider().getAddFeature(ctx);						
				ft.add(ctx);						
			}
		}		
	}
	
	private void reconstructConnections(final Diagram diagram)
	{
		DiagramGeometryWrapper diagramGeometry = SapphireDiagramEditor.this.diagramPart.getDiagramGeometry();
		// add the connections back to the diagram
		for (DiagramConnectionTemplate connTemplate : SapphireDiagramEditor.this.diagramPart.getConnectionTemplates())
		{
			for (DiagramConnectionPart connPart : connTemplate.getDiagramConnections())
			{
				IModelElement endpoint1 = connPart.getEndpoint1();
				IModelElement endpoint2 = connPart.getEndpoint2();
				DiagramNodePart nodePart1 = getDiagramNode(endpoint1);
				DiagramNodePart nodePart2 = getDiagramNode(endpoint2);
				if (nodePart1 != null && nodePart2 != null)
				{
					ContainerShape sourceShape = getContainerShape(nodePart1);
					ContainerShape targetShape = getContainerShape(nodePart2);
					if (sourceShape != null && targetShape != null)
					{
						Anchor sourceAnchor = sourceShape.getAnchors().get(0);
						Anchor targetAnchor = targetShape.getAnchors().get(0);
						AddConnectionContext connCtx = new AddConnectionContext(sourceAnchor, targetAnchor);
						connCtx.setNewObject(connPart);
						IAddFeature fcfp = getDiagramTypeProvider().getFeatureProvider().getAddFeature(connCtx);
						
						Connection conn = (Connection)fcfp.add(connCtx);
						if (conn instanceof FreeFormConnection && 
								diagramGeometry.getConnectionBendpoints(connPart) != null)
						{
							FreeFormConnection freeConn = (FreeFormConnection)conn;
							List<org.eclipse.sapphire.ui.diagram.editor.DiagramGeometryWrapper.Point> bps = 
								diagramGeometry.getConnectionBendpoints(connPart);
							List<Point> bendpoints = freeConn.getBendpoints();
							int index = 0;
							for (org.eclipse.sapphire.ui.diagram.editor.DiagramGeometryWrapper.Point pt : bps)
							{
								Point newPoint = Graphiti.getGaService().createPoint(pt.x, pt.y);										
								bendpoints.add(index++, newPoint);										
							}
						}
					}							
				}
			}
		}		
	}
	
	private DiagramNodePart getDiagramNode(IModelElement endpoint)
	{
		for (DiagramNodeTemplate nodeTemplate : this.diagramPart.getNodeTemplates())
		{
			for (DiagramNodePart nodePart : nodeTemplate.getDiagramNodes())
			{
				IModelElement element = nodePart.getLocalModelElement();
				if (element == endpoint)
				{
					return nodePart;
				}
			}
		}		
		return null;	
	}
	
	private ContainerShape getContainerShape(Object bo)
	{
		ContainerShape containerShape = null;
		PictogramElement [] pictograms = 
			getDiagramTypeProvider().getFeatureProvider().getAllPictogramElementsForBusinessObject(bo);
		for (PictogramElement pictogram : pictograms)
		{
			if (pictogram instanceof ContainerShape)
			{
				containerShape = (ContainerShape)pictogram;
				break;
			}
		}
		return containerShape;
	}
	
}




package org.eclipse.sapphire.ui.diagram.graphiti.editor;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.Iterator;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.Path;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.graphiti.services.Graphiti;
import org.eclipse.graphiti.ui.editor.DiagramEditorFactory;
import org.eclipse.graphiti.ui.internal.services.GraphitiUiInternal;
import org.eclipse.graphiti.ui.services.GraphitiUi;
import org.eclipse.sapphire.modeling.util.internal.FileUtil;
import org.eclipse.sapphire.ui.diagram.graphiti.GraphitiFileService;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IFileEditorInput;

public class SapphireDiagramEditorFactory 
{
	public static final String SAPPHIRE_DIAGRAM_TYPE = "sapphireDiagram";
	
	public static SapphireDiagramEditorInput createEditorInput(IEditorInput otherInput) 
		throws CoreException
	{
		if (otherInput instanceof SapphireDiagramEditorInput)
		{
			return (SapphireDiagramEditorInput)otherInput;
		}
		else if (otherInput instanceof IFileEditorInput)
		{
			final IFileEditorInput fileInput = (IFileEditorInput) otherInput;
			final IFile file = fileInput.getFile();
			final IProject project = file.getProject();
			
			final IFolder diagramFolder = project.getFolder(".settings/diagrams/");
			String fileName = file.getName();
			if (fileName.endsWith(".xml"))
			{
				fileName = fileName.substring(0, fileName.indexOf(".xml"));
			}
			
			TransactionalEditingDomain domain = null;
			ResourceSet resourceSet = null;
			Diagram diagram = null;
			URI diagramFileUri = null;
			
			// create diagram file if it doesn't exist
			final IFile diagramFile = diagramFolder.getFile(fileName + ".xmi");
			if (!diagramFile.exists())
			{
				FileUtil.mkdirs( diagramFile.getParent().getLocation().toFile() );
				diagramFile.create( new ByteArrayInputStream(new byte[0]), true, null );
				
				// Create Diagram Obj
				diagram = Graphiti.getPeCreateService().createDiagram(
						SAPPHIRE_DIAGRAM_TYPE, fileName, 10, false);
				diagramFileUri = URI.createPlatformResourceURI(diagramFile.getFullPath().toString(), true);
				domain = GraphitiFileService.createEmfFileForDiagram(diagramFileUri, diagram);
			}
			else
			{			
				domain = DiagramEditorFactory.createResourceSetAndEditingDomain();
				resourceSet = domain.getResourceSet();
			
				diagramFileUri = GraphitiUiInternal.getEmfService().getFileURI(diagramFile, resourceSet);
				if (diagramFileUri != null)
				{
					final Resource resource = resourceSet.createResource(diagramFileUri);
					try
					{
						resource.load(null);
					}
					catch (IOException ie)
					{
						ie.printStackTrace();
					}
					EList<EObject> objs = resource.getContents();
					Iterator<EObject> it = objs.iterator();					
					while (it.hasNext()) 
					{
						EObject obj = it.next();
						if ((obj == null) && !Diagram.class.isInstance(obj))
							continue;
						diagram = (Diagram)obj;
						break;
					}
				}				
			}
			// create diagram node position file if it doesn't exist
			IFile nodePosFile = diagramFile.getParent().getFile(new Path(fileName + ".np"));
			if (!nodePosFile.exists())
			{
				nodePosFile.create( new ByteArrayInputStream(new byte[0]), true, null );
			}

			// create sapphire diagram editor input
			if (diagram != null)
			{
				String providerId = GraphitiUi.getExtensionManager().getDiagramTypeProviderId(diagram.getDiagramTypeId());
				final SapphireDiagramEditorInput diagramEditorInput = 
					SapphireDiagramEditorInput.createEditorInput(diagram, domain, providerId, false);
				diagramEditorInput.setNodePositionFile(nodePosFile);
				return diagramEditorInput;
			}
		}
		return null;
	}

}




package org.eclipse.sapphire.ui.diagram.graphiti.editor;

import org.eclipse.core.resources.IFile;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.graphiti.ui.editor.DiagramEditorInput;

public class SapphireDiagramEditorInput extends DiagramEditorInput 
{
	private Diagram diagram;
	private IFile nodePositionFile;
	
	public SapphireDiagramEditorInput(Diagram diagram, String diagramUriString,
			TransactionalEditingDomain domain, String providerId,
			boolean disposeEditingDomain) 
	{
		super(diagramUriString, domain, providerId, disposeEditingDomain);
		this.diagram = diagram;
	}

	public SapphireDiagramEditorInput(Diagram diagram, URI diagramUri,
			TransactionalEditingDomain domain, String providerId,
			boolean disposeEditingDomain) 
	{
		super(diagramUri, domain, providerId, disposeEditingDomain);
		this.diagram = diagram;
	}
	
	public Diagram getDiagram() 
	{
		return this.diagram;
	}	
	
	public TransactionalEditingDomain getEditingDomain() 
	{
		return this.editingDomain;
	}
	
	@SuppressWarnings("rawtypes")
	public Object getAdapter(Class adapter) 
	{
		if (EObject.class.isAssignableFrom(adapter)) 
		{
			return getDiagram();
		} 
		else if (Diagram.class.isAssignableFrom(adapter)) 
		{
			return getDiagram();
		}
		else if (TransactionalEditingDomain.class.isAssignableFrom(adapter)) 
		{
			return getEditingDomain();
		} 
		else if (ResourceSet.class.isAssignableFrom(adapter)) 
		{
			return getEditingDomain().getResourceSet();
		}		
		return null;
	}
	
	public IFile getNodePositionFile()
	{
		return this.nodePositionFile;
	}
	
	public void setNodePositionFile(IFile file)
	{
		this.nodePositionFile = file;
	}
	
	
	public static SapphireDiagramEditorInput createEditorInput(Diagram diagram, 
			TransactionalEditingDomain domain, String providerId, boolean disposeEditingDomain) 
	{
		final Resource resource = diagram.eResource();
		if (resource == null) {
			throw new IllegalArgumentException();
		}
		final String fragment = resource.getURIFragment(diagram);
		final URI fragmentUri = resource.getURI().appendFragment(fragment);
		SapphireDiagramEditorInput diagramEditorInput;
		diagramEditorInput = new SapphireDiagramEditorInput(diagram, fragmentUri,
				domain, providerId, disposeEditingDomain);
		return diagramEditorInput;
	}	
	
}




package org.eclipse.sapphire.ui.diagram.graphiti.features;

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.IAddBendpointContext;
import org.eclipse.graphiti.features.impl.DefaultAddBendpointFeature;
import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionPart;
import org.eclipse.sapphire.ui.diagram.editor.DiagramGeometryWrapper;
import org.eclipse.sapphire.ui.diagram.graphiti.providers.SapphireDiagramFeatureProvider;

public class SapphireAddBendpointFeature extends DefaultAddBendpointFeature 
{
	public SapphireAddBendpointFeature(IFeatureProvider fp)
	{
		super(fp);
	}
	
	@Override
	public void addBendpoint(IAddBendpointContext context) 
	{
		super.addBendpoint(context);
		
		FreeFormConnection freeFormConnection = context.getConnection();
		Object bo = getBusinessObjectForPictogramElement(freeFormConnection);
		if (bo instanceof DiagramConnectionPart)
		{
			DiagramGeometryWrapper dg = 
				((SapphireDiagramFeatureProvider)getFeatureProvider()).getDiagramGeometry();
			dg.addConnectionBendpoint((DiagramConnectionPart)bo, 
					context.getBendpointIndex(), context.getX(), context.getY());
		}		
	}	
}




package org.eclipse.sapphire.ui.diagram.graphiti.features;

import org.eclipse.graphiti.features.IDirectEditingInfo;
import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.IAddConnectionContext;
import org.eclipse.graphiti.features.context.IAddContext;
import org.eclipse.graphiti.features.impl.AbstractAddFeature;
import org.eclipse.graphiti.mm.GraphicsAlgorithmContainer;
import org.eclipse.graphiti.mm.algorithms.Polygon;
import org.eclipse.graphiti.mm.algorithms.Polyline;
import org.eclipse.graphiti.mm.algorithms.Text;
import org.eclipse.graphiti.mm.pictograms.Connection;
import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.graphiti.services.Graphiti;
import org.eclipse.graphiti.services.IGaService;
import org.eclipse.graphiti.services.IPeCreateService;
import org.eclipse.graphiti.util.IColorConstant;
import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionPart;

public class SapphireAddConnectionFeature extends AbstractAddFeature 
{
	public SapphireAddConnectionFeature(IFeatureProvider fp)
	{
		super(fp);
	}
	
	public boolean canAdd(IAddContext context) 
	{
		// return true if given business object is an DiagramConnectionPart
		// note, that the context must be an instance of IAddConnectionContext
		if (context instanceof IAddConnectionContext && 
				context.getNewObject() instanceof DiagramConnectionPart) 
		{
			return true;
		}
		return false;
	}

	public PictogramElement add(IAddContext context) 
	{
		IAddConnectionContext addConContext = (IAddConnectionContext) context;
		DiagramConnectionPart connectionPart = (DiagramConnectionPart) context.getNewObject();

		IPeCreateService peCreateService = Graphiti.getPeCreateService();
		// CONNECTION WITH POLYLINE
		Connection connection = peCreateService.createFreeFormConnection(getDiagram());
		connection.setStart(addConContext.getSourceAnchor());
		connection.setEnd(addConContext.getTargetAnchor());

		IGaService gaService = Graphiti.getGaService();
		Polyline polyline = gaService.createPolyline(connection);
		polyline.setForeground(manageColor(IColorConstant.BLACK));
		polyline.setLineWidth(1);
       
		// create link and wire it
		link(connection, connectionPart);

		// add dynamic text decorator for the reference name
		ConnectionDecorator textDecorator = peCreateService.createConnectionDecorator(connection, true, 0.5, true);
		Text text = gaService.createDefaultText(textDecorator);
		text.setForeground(manageColor(IColorConstant.BLACK));
		gaService.setLocation(text, 10, 0);		
		
		text.setValue(connectionPart.getLabel());

		// add static graphical decorators (composition and navigable)
		ConnectionDecorator cd;
		cd = peCreateService.createConnectionDecorator(connection, false, 1.0, true);
		createArrow(cd);

        // provide information to support direct-editing directly 

        // after object creation (must be activated additionally)
        IDirectEditingInfo directEditingInfo = getFeatureProvider().getDirectEditingInfo();

        // set container shape for direct editing after object creation
        directEditingInfo.setMainPictogramElement(connection);

        // set shape and graphics algorithm where the editor for
        // direct editing shall be opened after object creation
        directEditingInfo.setPictogramElement(textDecorator);
        directEditingInfo.setGraphicsAlgorithm(text);
		
		return connection;
	}

	private Polygon createArrow(GraphicsAlgorithmContainer gaContainer) 
	{
		Polygon polygon = Graphiti.getGaCreateService().createPolygon(gaContainer, new int[] { -8, 4, 0, 0, -8, -4, -5, 0 });
		polygon.setBackground(manageColor(IColorConstant.BLACK));
		//polygon.setStyle(StyleUtil.getStyleForADFView(getDiagram()));
		polygon.setFilled(true);
		return polygon;
	}
	
}




package org.eclipse.sapphire.ui.diagram.graphiti.features;

import org.eclipse.graphiti.features.IDirectEditingInfo;
import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.IAddContext;
import org.eclipse.graphiti.features.impl.AbstractAddShapeFeature;
import org.eclipse.graphiti.mm.algorithms.Polyline;
import org.eclipse.graphiti.mm.algorithms.Rectangle;
import org.eclipse.graphiti.mm.algorithms.Text;
import org.eclipse.graphiti.mm.algorithms.styles.Orientation;
import org.eclipse.graphiti.mm.pictograms.ContainerShape;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.graphiti.mm.pictograms.Shape;
import org.eclipse.graphiti.services.Graphiti;
import org.eclipse.graphiti.services.IGaService;
import org.eclipse.graphiti.services.IPeCreateService;
import org.eclipse.graphiti.util.ColorConstant;
import org.eclipse.graphiti.util.IColorConstant;
import org.eclipse.sapphire.ui.diagram.editor.DiagramGeometryWrapper;
import org.eclipse.sapphire.ui.diagram.editor.DiagramNodePart;
import org.eclipse.sapphire.ui.diagram.graphiti.providers.SapphireDiagramFeatureProvider;

public class SapphireAddNodeFeature extends AbstractAddShapeFeature 
{
    private static final IColorConstant CLASS_TEXT_FOREGROUND = new ColorConstant(51, 51, 153);
    private static final IColorConstant CLASS_FOREGROUND = new ColorConstant(255, 102, 0);
    private static final IColorConstant CLASS_BACKGROUND =  new ColorConstant(255, 204, 153);
	
	public SapphireAddNodeFeature(IFeatureProvider fp)
	{
		super(fp);
	}
	
	public boolean canAdd(IAddContext context) 
	{
		Object newObj = context.getNewObject();
		if (newObj instanceof DiagramNodePart && context.getTargetContainer() instanceof Diagram)
		{
			return true;
		}
		return false;
	}

	public PictogramElement add(IAddContext context)
	{
		DiagramNodePart nodePart = (DiagramNodePart)context.getNewObject();
		final Diagram targetDiagram = (Diagram) context.getTargetContainer();
		
        // CONTAINER SHAPE WITH RECTANGLE
        IPeCreateService peCreateService = Graphiti.getPeCreateService();
        ContainerShape containerShape =  peCreateService.createContainerShape(targetDiagram, true);

        // define a default size for the shape
        int width = 100;
        int height = 50; 
        IGaService gaService = Graphiti.getGaService();
        {
            // create and set graphics algorithm
            Rectangle rectangle = gaService.createRectangle(containerShape);
            rectangle.setForeground(manageColor(CLASS_FOREGROUND));
            rectangle.setBackground(manageColor(CLASS_BACKGROUND));
            rectangle.setLineWidth(2);
            gaService.setLocationAndSize(rectangle,
                context.getX(), context.getY(), width, height);
 
            // create link and wire it
            link(containerShape, nodePart);
        }
		
        // SHAPE WITH LINE
        {
            // create shape for line
            Shape shape = peCreateService.createShape(containerShape, false);
 
            // create and set graphics algorithm
            Polyline polyline =
                gaService.createPolyline(shape, new int[] { 0, 20, width, 20 });
            polyline.setForeground(manageColor(CLASS_FOREGROUND));
            polyline.setLineWidth(2);
        }
 
        // SHAPE WITH TEXT
        {
            // create shape for text
            Shape shape = peCreateService.createShape(containerShape, false);
 
            // create and set text graphics algorithm
            Text text = gaService.createDefaultText(shape, nodePart.getLabel());
            text.setForeground(manageColor(CLASS_TEXT_FOREGROUND));
            text.setHorizontalAlignment(Orientation.ALIGNMENT_CENTER);
            text.setVerticalAlignment(Orientation.ALIGNMENT_CENTER);
            //text.getFont().setBold(true);
            gaService.setLocationAndSize(text, 0, 0, width, 20);
 
            // create link and wire it
            link(shape, nodePart);
            
			// provide information to support direct-editing directly
			// after object creation (must be activated additionally)
			final IDirectEditingInfo directEditingInfo = getFeatureProvider().getDirectEditingInfo();
			// set container shape for direct editing after object creation
			directEditingInfo.setMainPictogramElement(containerShape);
			// set shape and graphics algorithm where the editor for
			// direct editing shall be opened after object creation
			directEditingInfo.setPictogramElement(shape);
			directEditingInfo.setGraphicsAlgorithm(text);            
        }
        
        // add a chopbox anchor to the shape
        peCreateService.createChopboxAnchor(containerShape);
        
        // Save the node bounds
        DiagramGeometryWrapper diagramGeometry = 
        	((SapphireDiagramFeatureProvider)getFeatureProvider()).getDiagramGeometry();
        diagramGeometry.addNode(nodePart, context.getX(), context.getY(), width, height);
        
		return containerShape;
	}

}




package org.eclipse.sapphire.ui.diagram.graphiti.features;

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.ICreateConnectionContext;
import org.eclipse.graphiti.features.context.impl.AddConnectionContext;
import org.eclipse.graphiti.features.impl.AbstractCreateConnectionFeature;
import org.eclipse.graphiti.mm.pictograms.Anchor;
import org.eclipse.graphiti.mm.pictograms.Connection;
import org.eclipse.sapphire.ui.SapphirePart;
import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionPart;
import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionTemplate;
import org.eclipse.sapphire.ui.diagram.editor.DiagramNodePart;

public class SapphireCreateConnectionFeature extends AbstractCreateConnectionFeature 
{
	private DiagramConnectionTemplate connectionTemplate;
	
	public SapphireCreateConnectionFeature(IFeatureProvider fp, DiagramConnectionTemplate connectionTemplate)
	{
		super(fp, connectionTemplate.getToolPaletteLabel(), connectionTemplate.getToolPaletteDesc());
		this.connectionTemplate = connectionTemplate;		
	}
	
	public boolean canCreate(ICreateConnectionContext context) 
	{
		// return true if both anchors belong to an IModelElement
		// and those model elements are not identical
		SapphirePart source = getEndpoint(context.getSourceAnchor());
		SapphirePart target = getEndpoint(context.getTargetAnchor());
		if (source instanceof DiagramNodePart && 
				source instanceof DiagramNodePart && source != target) 
		{
			return true;
		}
		return false;
	}

	public Connection create(ICreateConnectionContext context) 
	{
		Connection newConnection = null;

		// get model elements which should be connected
		SapphirePart source = getEndpoint(context.getSourceAnchor());
		SapphirePart target = getEndpoint(context.getTargetAnchor());

		if (source instanceof DiagramNodePart && target instanceof DiagramNodePart) 
		{
			DiagramNodePart sourceNode = (DiagramNodePart)source;
			DiagramNodePart targetNode = (DiagramNodePart)target;
			// create new business object
			DiagramConnectionPart connectionPart = 
				this.connectionTemplate.createNewDiagramConnection(sourceNode, targetNode);

			// add connection for business object
			AddConnectionContext addContext = new AddConnectionContext(context.getSourceAnchor(), context.getTargetAnchor());
			addContext.setNewObject(connectionPart);
			newConnection = (Connection) getFeatureProvider().addIfPossible(addContext);
			
	        // activate direct editing after object creation
	        getFeatureProvider().getDirectEditingInfo().setActive(true);
		}

		return newConnection;
	}

	public boolean canStartConnection(ICreateConnectionContext context) 
	{
		// return true if start anchor belongs to an IModelElement
		if (getEndpoint(context.getSourceAnchor()) instanceof DiagramNodePart) 
		{
			return true;
		}
		return false;
	}

	/**
	 * Returns the SapphirePart belonging to the anchor, or null if not available.
	 */
	private SapphirePart getEndpoint(Anchor anchor) 
	{
		if (anchor != null) 
		{
			Object obj = getBusinessObjectForPictogramElement(anchor.getParent());
			if (obj instanceof SapphirePart) 
			{
				return (SapphirePart) obj;
			}
		}
		return null;
	}
	
}




package org.eclipse.sapphire.ui.diagram.graphiti.features;

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.ICreateContext;
import org.eclipse.graphiti.features.impl.AbstractCreateFeature;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.sapphire.ui.diagram.editor.DiagramNodePart;
import org.eclipse.sapphire.ui.diagram.editor.DiagramNodeTemplate;

public class SapphireCreateNodeFeature extends AbstractCreateFeature 
{
	private DiagramNodeTemplate nodeTemplate;
	
	public SapphireCreateNodeFeature(IFeatureProvider fp, DiagramNodeTemplate nodeTemplate)
	{
		super(fp, nodeTemplate.getToolPaletteLabel(), nodeTemplate.getToolPaletteDesc());
		this.nodeTemplate = nodeTemplate;		
	}

	public boolean canCreate(ICreateContext context) 
	{		
		return context.getTargetContainer() instanceof Diagram;
	}

	public Object[] create(ICreateContext context) 
	{
		DiagramNodePart nodePart = this.nodeTemplate.createNewDiagramNode();
		
		addGraphicalRepresentation(context, nodePart);
		return new Object[] { nodePart };
	}
}




package org.eclipse.sapphire.ui.diagram.graphiti.features;

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.IDirectEditingContext;
import org.eclipse.graphiti.features.impl.AbstractDirectEditingFeature;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionPart;

public class SapphireDirectEditConnectionFeature extends AbstractDirectEditingFeature 
{
	public SapphireDirectEditConnectionFeature(IFeatureProvider fp)
	{
		super(fp);
	}
	
	public int getEditingType() 
	{
		return TYPE_TEXT;
	}

	public String getInitialValue(IDirectEditingContext context) 
	{
		PictogramElement pe = (PictogramElement)context.getPictogramElement().eContainer();
		Object bo = getBusinessObjectForPictogramElement(pe);
		if (bo instanceof DiagramConnectionPart)
		{
			DiagramConnectionPart connPart = (DiagramConnectionPart)bo;
			return connPart.getLabel();
		}
		return null;
	}

	public void setValue(String value, IDirectEditingContext context) 
	{
		PictogramElement pe = (PictogramElement)context.getPictogramElement().eContainer();
		Object bo = getBusinessObjectForPictogramElement(pe);
		if (bo instanceof DiagramConnectionPart)
		{
			DiagramConnectionPart connPart = (DiagramConnectionPart)bo;
			connPart.setLabel(value);
			updatePictogramElement(pe);
		}
	}

}




package org.eclipse.sapphire.ui.diagram.graphiti.features;

import java.util.Iterator;

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.IDirectEditingContext;
import org.eclipse.graphiti.features.impl.AbstractDirectEditingFeature;
import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
import org.eclipse.graphiti.mm.algorithms.Text;
import org.eclipse.graphiti.mm.pictograms.Anchor;
import org.eclipse.graphiti.mm.pictograms.Connection;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.graphiti.mm.pictograms.Shape;
import org.eclipse.graphiti.services.Graphiti;
import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionPart;
import org.eclipse.sapphire.ui.diagram.editor.DiagramNodePart;

public class SapphireDirectEditNodeFeature extends AbstractDirectEditingFeature 
{
	public SapphireDirectEditNodeFeature(IFeatureProvider fp)
	{
		super(fp);
	}
	
	public int getEditingType() 
	{
		return TYPE_TEXT;
	}

	@Override
	public boolean canDirectEdit(IDirectEditingContext context) 
	{
		PictogramElement pe = context.getPictogramElement();
		Object bo = getBusinessObjectForPictogramElement(pe);
		GraphicsAlgorithm ga = context.getGraphicsAlgorithm();
		// support direct editing, if it is a DiagramNodePart, and the user clicked
		// directly on the text and not somewhere else in the rectangle
		if (bo instanceof DiagramNodePart && ga instanceof Text) 
		{
			return true;
		}
		// direct editing not supported in all other cases
		return false;
	}

	public String getInitialValue(IDirectEditingContext context) 
	{
		// return the current label of the node
		PictogramElement pe = context.getPictogramElement();
		DiagramNodePart nodePart = (DiagramNodePart)getBusinessObjectForPictogramElement(pe);
		return nodePart.getLabel();
	}

	public void setValue(String value, IDirectEditingContext context) 
	{
		PictogramElement pe = context.getPictogramElement();
				
		if (pe.eContainer() instanceof Shape)
		{
			DiagramNodePart nodePart = (DiagramNodePart)getBusinessObjectForPictogramElement(pe);
			nodePart.setLabel(value);
			IModelElement nodeElement = nodePart.getLocalModelElement();
			Shape nodeShape = (Shape)pe.eContainer();
			
			// go through all the connections associated with this bo and update them
			for (Iterator<Anchor> iter = nodeShape.getAnchors().iterator(); iter.hasNext();) 
			{
				Anchor anchor = iter.next();
				for (Iterator<Connection> iterator = Graphiti.getPeService().getAllConnections(anchor).iterator(); iterator.hasNext();) 
				{
					Connection connection = iterator.next();
					Object bo = getBusinessObjectForPictogramElement(connection);
					if (bo instanceof DiagramConnectionPart)
					{
						DiagramConnectionPart connectionPart = (DiagramConnectionPart)bo;
						IModelElement endpoint1 = connectionPart.getEndpoint1();
						IModelElement endpoint2 = connectionPart.getEndpoint2();
						if (endpoint1 == nodeElement)
						{
							connectionPart.refreshEndpoint1();
						}
						else if (endpoint2 == nodeElement)
						{
							connectionPart.refreshEndpoint2();
						}
					}
				}
			}
			
		}
				
		// Explicitly update the shape to display the new value in the diagram
		// Note, that this might not be necessary in future versions of Graphiti
		// (currently in discussion)

		// we know, that pe is the Shape of the Text, so its container is the
		// main shape of the node
		updatePictogramElement(((Shape)pe).getContainer());

	}

}




package org.eclipse.sapphire.ui.diagram.graphiti.features;

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.IMoveBendpointContext;
import org.eclipse.graphiti.features.impl.DefaultMoveBendpointFeature;
import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionPart;
import org.eclipse.sapphire.ui.diagram.editor.DiagramGeometryWrapper;
import org.eclipse.sapphire.ui.diagram.graphiti.providers.SapphireDiagramFeatureProvider;

public class SapphireMoveBendpointFeature extends DefaultMoveBendpointFeature 
{
	public SapphireMoveBendpointFeature(IFeatureProvider fp)
	{
		super(fp);
	}
	
	@Override
	public boolean moveBendpoint(IMoveBendpointContext context) 
	{
		boolean ret = false;
		super.moveBendpoint(context);
		
		FreeFormConnection freeFormConnection = context.getConnection();
		Object bo = getBusinessObjectForPictogramElement(freeFormConnection);
		if (bo instanceof DiagramConnectionPart)
		{
			DiagramGeometryWrapper dg = 
				((SapphireDiagramFeatureProvider)getFeatureProvider()).getDiagramGeometry();
			ret = dg.setConnectionBendpoint((DiagramConnectionPart)bo, 
					context.getBendpointIndex(), context.getX(), context.getY());
		}		
		return ret;
	}
	
}




package org.eclipse.sapphire.ui.diagram.graphiti.features;

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.IMoveShapeContext;
import org.eclipse.graphiti.features.impl.DefaultMoveShapeFeature;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.sapphire.ui.diagram.editor.DiagramGeometryWrapper;
import org.eclipse.sapphire.ui.diagram.editor.DiagramNodePart;
import org.eclipse.sapphire.ui.diagram.graphiti.providers.SapphireDiagramFeatureProvider;

public class SapphireMoveNodeFeature extends DefaultMoveShapeFeature 
{
	public SapphireMoveNodeFeature(IFeatureProvider fp)
	{
		super(fp);
	}
	
	@Override
	protected void internalMove(IMoveShapeContext context) 
	{
		super.internalMove(context);
 		PictogramElement pe = context.getPictogramElement();
 		Object bo = getBusinessObjectForPictogramElement(pe);
 		if (bo instanceof DiagramNodePart)
 		{
			DiagramGeometryWrapper dg = 
				((SapphireDiagramFeatureProvider)getFeatureProvider()).getDiagramGeometry();
			dg.updateNode((DiagramNodePart)bo, context.getX(), context.getY());
 		}
	}
}




package org.eclipse.sapphire.ui.diagram.graphiti.features;

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.IRemoveBendpointContext;
import org.eclipse.graphiti.features.impl.DefaultRemoveBendpointFeature;
import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionPart;
import org.eclipse.sapphire.ui.diagram.editor.DiagramGeometryWrapper;
import org.eclipse.sapphire.ui.diagram.graphiti.providers.SapphireDiagramFeatureProvider;

public class SapphireRemoveBendpointFeature extends DefaultRemoveBendpointFeature 
{
	public SapphireRemoveBendpointFeature(IFeatureProvider fp)
	{
		super(fp);
	}
	
	@Override
	public void removeBendpoint(IRemoveBendpointContext context) 
	{
		super.removeBendpoint(context);
		
		FreeFormConnection freeFormConnection = context.getConnection();
		Object bo = getBusinessObjectForPictogramElement(freeFormConnection);
		if (bo instanceof DiagramConnectionPart)
		{
			DiagramGeometryWrapper dg = 
				((SapphireDiagramFeatureProvider)getFeatureProvider()).getDiagramGeometry();
			dg.removeConnectionBendpoint((DiagramConnectionPart)bo, context.getBendpointIndex());
		}
		
	}

}




package org.eclipse.sapphire.ui.diagram.graphiti.features;

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.IReason;
import org.eclipse.graphiti.features.context.IUpdateContext;
import org.eclipse.graphiti.features.impl.AbstractUpdateFeature;
import org.eclipse.graphiti.features.impl.Reason;
import org.eclipse.graphiti.mm.algorithms.Text;
import org.eclipse.graphiti.mm.pictograms.Connection;
import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionPart;

public class SapphireUpdateConnectionFeature extends AbstractUpdateFeature 
{
	public SapphireUpdateConnectionFeature(IFeatureProvider fp)
	{
		super(fp);
	}
	
	public boolean canUpdate(IUpdateContext context) 
	{
		PictogramElement pe = context.getPictogramElement();
		Object bo = getBusinessObjectForPictogramElement(pe);
		return bo instanceof DiagramConnectionPart;
	}

	public IReason updateNeeded(IUpdateContext context) 
	{
		// retrieve name from pictogram model
		String pictogramName = null;
		PictogramElement pictogramElement = context.getPictogramElement();
		if (pictogramElement instanceof Connection) {
			Connection c = (Connection) pictogramElement;
			for (ConnectionDecorator cd : c.getConnectionDecorators()) {
				if (cd.getGraphicsAlgorithm() instanceof Text) {
					Text text = (Text) cd.getGraphicsAlgorithm();
					pictogramName = text.getValue();
				}
			}
		}

		// retrieve name from business model
		String businessName = null;
		Object bo = getBusinessObjectForPictogramElement(pictogramElement);
		if (bo instanceof DiagramConnectionPart) 
		{
			DiagramConnectionPart connPart = (DiagramConnectionPart)bo;
			businessName = connPart.getLabel();
		}

		// update needed, if names are different
		boolean updateNameNeeded = ((pictogramName == null && businessName != null) || (pictogramName != null && !pictogramName
				.equals(businessName)));
		if (updateNameNeeded) 
		{
			return Reason.createTrueReason("Name is out of date"); //$NON-NLS-1$
		} 
		else
		{
			return Reason.createFalseReason();
		}
	}

	public boolean update(IUpdateContext context) 
	{
		String businessName = null;
		PictogramElement pe = context.getPictogramElement();
		Object bo = getBusinessObjectForPictogramElement(pe);
		if (bo instanceof DiagramConnectionPart) 
		{
			DiagramConnectionPart connPart = (DiagramConnectionPart)bo;
			businessName = connPart.getLabel();
		}
		
		// Set name in pictogram model
		if (pe instanceof Connection) 
		{
			Connection c = (Connection) pe;
			for (ConnectionDecorator cd : c.getConnectionDecorators()) 
			{
				if (cd.getGraphicsAlgorithm() instanceof Text)
				{
					Text text = (Text) cd.getGraphicsAlgorithm();
					text.setValue(businessName);
					return true;
				}
			}
		}
		
		return false;
	}

}




package org.eclipse.sapphire.ui.diagram.graphiti.features;

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.IReason;
import org.eclipse.graphiti.features.context.IUpdateContext;
import org.eclipse.graphiti.features.impl.AbstractUpdateFeature;
import org.eclipse.graphiti.features.impl.Reason;
import org.eclipse.graphiti.mm.algorithms.Text;
import org.eclipse.graphiti.mm.pictograms.ContainerShape;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.graphiti.mm.pictograms.Shape;
import org.eclipse.sapphire.ui.diagram.editor.DiagramNodePart;

public class SapphireUpdateNodeFeature extends AbstractUpdateFeature 
{
	public SapphireUpdateNodeFeature(IFeatureProvider fp)
	{
		super(fp);
	}
	
	public boolean canUpdate(IUpdateContext context) 
	{
		Object bo = getBusinessObjectForPictogramElement(context.getPictogramElement());
		return bo instanceof DiagramNodePart;
	}

	public IReason updateNeeded(IUpdateContext context) 
	{
		// retrieve name from pictogram model
		String pictogramName = null;
		PictogramElement pictogramElement = context.getPictogramElement();
		if (pictogramElement instanceof ContainerShape) 
		{
			ContainerShape cs = (ContainerShape) pictogramElement;
			for (Shape shape : cs.getChildren()) 
			{
				if (shape.getGraphicsAlgorithm() instanceof Text) {
					Text text = (Text) shape.getGraphicsAlgorithm();
					pictogramName = text.getValue();
				}
			}
		}
		// retrieve name from business model
		String businessName = null;
		Object bo = getBusinessObjectForPictogramElement(pictogramElement);
		if (bo instanceof DiagramNodePart) 
		{
			DiagramNodePart nodePart = (DiagramNodePart) bo;
			businessName = nodePart.getLabel();
		}
		// update needed, if names are different
		boolean updateNameNeeded = 
			((pictogramName == null && businessName != null) || 
					(pictogramName != null && !pictogramName.equals(businessName)));
		if (updateNameNeeded) 
		{
			return Reason.createTrueReason("Name is out of date"); //$NON-NLS-1$
		} 
		else 
		{
			return Reason.createFalseReason();
		}		
	}

	public boolean update(IUpdateContext context) 
	{
		// retrieve name from business model
		String businessName = null;
		PictogramElement pictogramElement = context.getPictogramElement();
		Object bo = getBusinessObjectForPictogramElement(pictogramElement);
		if (bo instanceof DiagramNodePart) {
			DiagramNodePart nodePart = (DiagramNodePart) bo;
			businessName = nodePart.getLabel();
		}

		// Set name in pictogram model
		if (pictogramElement instanceof ContainerShape) 
		{
			ContainerShape cs = (ContainerShape) pictogramElement;
			for (Shape shape : cs.getChildren()) 
			{
				if (shape.getGraphicsAlgorithm() instanceof Text) 
				{
					Text text = (Text) shape.getGraphicsAlgorithm();
					text.setValue(businessName);
					return true;
				}
			}
		}

		return false;
	}

}




package org.eclipse.sapphire.ui.diagram.graphiti.providers;

import java.util.List;

import org.eclipse.graphiti.dt.IDiagramTypeProvider;
import org.eclipse.graphiti.features.IAddBendpointFeature;
import org.eclipse.graphiti.features.IAddFeature;
import org.eclipse.graphiti.features.ICreateConnectionFeature;
import org.eclipse.graphiti.features.ICreateFeature;
import org.eclipse.graphiti.features.IDirectEditingFeature;
import org.eclipse.graphiti.features.IMoveBendpointFeature;
import org.eclipse.graphiti.features.IMoveShapeFeature;
import org.eclipse.graphiti.features.IRemoveBendpointFeature;
import org.eclipse.graphiti.features.IUpdateFeature;
import org.eclipse.graphiti.features.context.IAddBendpointContext;
import org.eclipse.graphiti.features.context.IAddContext;
import org.eclipse.graphiti.features.context.IDirectEditingContext;
import org.eclipse.graphiti.features.context.IMoveBendpointContext;
import org.eclipse.graphiti.features.context.IMoveShapeContext;
import org.eclipse.graphiti.features.context.IRemoveBendpointContext;
import org.eclipse.graphiti.features.context.IUpdateContext;
import org.eclipse.graphiti.features.impl.IIndependenceSolver;
import org.eclipse.graphiti.mm.pictograms.Connection;
import org.eclipse.graphiti.mm.pictograms.ContainerShape;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.graphiti.ui.features.DefaultFeatureProvider;
import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionPart;
import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionTemplate;
import org.eclipse.sapphire.ui.diagram.editor.DiagramGeometryWrapper;
import org.eclipse.sapphire.ui.diagram.editor.DiagramNodePart;
import org.eclipse.sapphire.ui.diagram.editor.DiagramNodeTemplate;
import org.eclipse.sapphire.ui.diagram.editor.SapphireDiagramEditorPart;
import org.eclipse.sapphire.ui.diagram.graphiti.features.SapphireAddBendpointFeature;
import org.eclipse.sapphire.ui.diagram.graphiti.features.SapphireAddConnectionFeature;
import org.eclipse.sapphire.ui.diagram.graphiti.features.SapphireAddNodeFeature;
import org.eclipse.sapphire.ui.diagram.graphiti.features.SapphireCreateConnectionFeature;
import org.eclipse.sapphire.ui.diagram.graphiti.features.SapphireCreateNodeFeature;
import org.eclipse.sapphire.ui.diagram.graphiti.features.SapphireDirectEditConnectionFeature;
import org.eclipse.sapphire.ui.diagram.graphiti.features.SapphireDirectEditNodeFeature;
import org.eclipse.sapphire.ui.diagram.graphiti.features.SapphireMoveBendpointFeature;
import org.eclipse.sapphire.ui.diagram.graphiti.features.SapphireMoveNodeFeature;
import org.eclipse.sapphire.ui.diagram.graphiti.features.SapphireRemoveBendpointFeature;
import org.eclipse.sapphire.ui.diagram.graphiti.features.SapphireUpdateConnectionFeature;
import org.eclipse.sapphire.ui.diagram.graphiti.features.SapphireUpdateNodeFeature;

public class SapphireDiagramFeatureProvider extends DefaultFeatureProvider 
{
	private SapphireDiagramEditorPart diagramPart;
	
	public SapphireDiagramFeatureProvider(IDiagramTypeProvider dtp, IIndependenceSolver solver)
	{
		super(dtp);
		this.setIndependenceSolver(solver);
	}
	
	public void setDiagramPart(SapphireDiagramEditorPart diagramPart)
	{
		this.diagramPart = diagramPart;
		
	}
	
	public SapphireDiagramEditorPart getDiagramPart()
	{
		return this.diagramPart;
	}
	
	public DiagramGeometryWrapper getDiagramGeometry()
	{
		return this.diagramPart.getDiagramGeometry();
	}
	
	@Override
	public IAddFeature getAddFeature(IAddContext context) 
	{
		Object obj = context.getNewObject();
		if (obj instanceof DiagramNodePart)
		{
			return new SapphireAddNodeFeature(this);
		}
		else if (obj instanceof DiagramConnectionPart)
		{
			return new SapphireAddConnectionFeature(this);
		}
		
		return super.getAddFeature(context);
	}
	
	@Override
	public ICreateFeature[] getCreateFeatures() 
	{
		List<DiagramNodeTemplate> nodeTemplates = this.diagramPart.getNodeTemplates();
		ICreateFeature[] features = new ICreateFeature[nodeTemplates.size()];
		int i = 0;
		for (DiagramNodeTemplate nodeTemplate : nodeTemplates)
		{
			SapphireCreateNodeFeature createNodeFeature = 
				new SapphireCreateNodeFeature(this, nodeTemplate);
			features[i++] = createNodeFeature;
		}
		return features;
	}	
	
	@Override
    public ICreateConnectionFeature[] getCreateConnectionFeatures() 
	{
		List<DiagramConnectionTemplate> connectionTemplates = this.diagramPart.getConnectionTemplates();
		ICreateConnectionFeature[] features = new ICreateConnectionFeature[connectionTemplates.size()];
		int i = 0;
		for (DiagramConnectionTemplate connectionTemplate : connectionTemplates)
		{
			SapphireCreateConnectionFeature createConnectionFeature = 
				new SapphireCreateConnectionFeature(this, connectionTemplate);
			features[i++] = createConnectionFeature;
		}
		return features;
	}
	
	@Override
	public IDirectEditingFeature getDirectEditingFeature(IDirectEditingContext context) 
	{
		PictogramElement pe = context.getPictogramElement();
		Object bo = getBusinessObjectForPictogramElement((PictogramElement) pe.eContainer());
		if (bo instanceof DiagramNodePart)
		{
			return new SapphireDirectEditNodeFeature(this);
		}
		else if (bo instanceof DiagramConnectionPart)
		{
			return new SapphireDirectEditConnectionFeature(this);
		}
		return super.getDirectEditingFeature(context);		
	}
	
	@Override
	public IUpdateFeature getUpdateFeature(IUpdateContext context) 
	{
		PictogramElement pe = context.getPictogramElement();
		if (pe instanceof ContainerShape) 
		{
			Object bo = getBusinessObjectForPictogramElement(pe);
			if (bo instanceof DiagramNodePart) 
			{
				return new SapphireUpdateNodeFeature(this);
			}
		}
		else if (pe instanceof Connection)
		{
			Object bo = getBusinessObjectForPictogramElement(pe);
			if (bo instanceof DiagramConnectionPart)
			{
				return new SapphireUpdateConnectionFeature(this);
			}
		}
		return super.getUpdateFeature(context);
	}
	
	@Override
	public IAddBendpointFeature getAddBendpointFeature(IAddBendpointContext context) 
	{
		IAddBendpointFeature ret = new SapphireAddBendpointFeature(this);
		return ret;
	}
	
	@Override
	public IRemoveBendpointFeature getRemoveBendpointFeature(IRemoveBendpointContext context) 
	{
		IRemoveBendpointFeature ret = new SapphireRemoveBendpointFeature(this);
		return ret;
	}

	@Override
	public IMoveBendpointFeature getMoveBendpointFeature(IMoveBendpointContext context) 
	{
		IMoveBendpointFeature ret = new SapphireMoveBendpointFeature(this);
		return ret;
	}
	
    @Override
    public IMoveShapeFeature getMoveShapeFeature(IMoveShapeContext context) 
    {
    	return new SapphireMoveNodeFeature(this);
    }
	
}




package org.eclipse.sapphire.ui.diagram.graphiti.providers;

import java.util.HashMap;

import org.eclipse.graphiti.features.impl.IIndependenceSolver;
import org.eclipse.sapphire.ui.SapphirePart;

public class SapphireDiagramSolver implements IIndependenceSolver 
{
	private HashMap<String, SapphirePart> keyToBOMap;
	private HashMap<SapphirePart, String> bOToKeyMap;
	private int counter = 0;

	public SapphireDiagramSolver()
	{
		this.keyToBOMap = new HashMap<String, SapphirePart>();
		this.bOToKeyMap = new HashMap<SapphirePart, String>();		
	}
	
	public String getKeyForBusinessObject(Object bo) 
	{
		if (bo instanceof SapphirePart)			
		{
			SapphirePart part = (SapphirePart)bo;
			if (this.bOToKeyMap.containsKey(bo))
			{
				return this.bOToKeyMap.get(bo);
			}
			String key = Integer.toString(this.counter++);
			this.keyToBOMap.put(key, part);
			this.bOToKeyMap.put(part, key);
			
			return key;
		}
		return null;
	}

	public Object getBusinessObjectForKey(String key) 
	{
		if (key == null)
			return null;
		return this.keyToBOMap.get(key);
	}

}




package org.eclipse.sapphire.ui.diagram.graphiti.providers;

import org.eclipse.graphiti.dt.IDiagramTypeProvider;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.graphiti.tb.DefaultToolBehaviorProvider;
import org.eclipse.graphiti.tb.IContextButtonPadData;


public class SapphireDiagramToolBehaviorProvider extends DefaultToolBehaviorProvider 
{
	public SapphireDiagramToolBehaviorProvider(IDiagramTypeProvider dtp) 
	{
		super(dtp);
	}

	/**
	 * Override super class impl to not include "Remove"
	 */
	@Override
	protected void setGenericContextButtons(IContextButtonPadData data, PictogramElement pe, int identifiers) 
	{
		identifiers -= CONTEXT_BUTTON_REMOVE;
		super.setGenericContextButtons(data, pe, identifiers);
	}
}




package org.eclipse.sapphire.ui.diagram.graphiti.providers;

import org.eclipse.graphiti.dt.AbstractDiagramTypeProvider;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.graphiti.platform.IDiagramEditor;
import org.eclipse.graphiti.tb.IToolBehaviorProvider;
import org.eclipse.sapphire.ui.diagram.editor.SapphireDiagramEditorPart;
import org.eclipse.sapphire.ui.diagram.graphiti.editor.SapphireDiagramEditor;

public class SapphireDiagramTypeProvider extends AbstractDiagramTypeProvider 
{
	private SapphireDiagramEditorPart diagramPart;
	private SapphireDiagramFeatureProvider featureProvider;
	private IToolBehaviorProvider[] toolBehaviorProviders;
	
	public SapphireDiagramTypeProvider()
	{
		this.featureProvider = 
			new SapphireDiagramFeatureProvider(this, new SapphireDiagramSolver());
		setFeatureProvider(this.featureProvider);
	}
	
	public void setDiagramPart(SapphireDiagramEditorPart diagramPart)
	{
		this.diagramPart = diagramPart;
		this.featureProvider.setDiagramPart(diagramPart);		
	}
	
	public SapphireDiagramEditorPart getDiagramPart()
	{
		return this.diagramPart;
	}
	
	@Override
	public void init(Diagram diagram, IDiagramEditor diagramEditor)
	{
		super.init(diagram, diagramEditor);
		setDiagramPart(((SapphireDiagramEditor)diagramEditor).getDiagramEditorPart());
	}
	
    @Override
    public IToolBehaviorProvider[] getAvailableToolBehaviorProviders() 
    {
        if (this.toolBehaviorProviders == null) 
        {
            this.toolBehaviorProviders =
                new IToolBehaviorProvider[] { new SapphireDiagramToolBehaviorProvider(this) };
        }
        return this.toolBehaviorProviders;
    }
	
    @Override
    public void postInit() 
    {    	
    	SapphireDiagramEditor sapphireEditor = (SapphireDiagramEditor)getDiagramEditor();
    	sapphireEditor.syncDiagramWithModel();
    	sapphireEditor.doSave(null);
    }
    
}

Return to bug 330482

Added Link Here

(-)sdef/MapEditor.sdef (+67 lines)
1	<definition>
2
3	<import>
4	<bundle>org.eclipse.sapphire.samples</bundle>
5	<package>org.eclipse.sapphire.samples.map</package>
6	<package>org.eclipse.sapphire.samples.map.ui</package>
7	</import>
8
9	<diagram-page>
10	<id>diagram</id>
11	<page-name>Diagram</page-name>
12	<page-header-text>Diagram</page-header-text>
13	<node>
14	<id>destinations</id>
15	<tool-palette-label>Destination</tool-palette-label>
16	<tool-palette-desc>Map Destination</tool-palette-desc>
17	<property>Destinations</property>
18	<label>${Name == null ? "<Destination>" : Name}</label>
19	<instance-id>${Name}</instance-id>
20	</node>
21	<connection>
22	<id>connections</id>
23	<tool-palette-label>Route</tool-palette-label>
24	<tool-palette-desc>Map Route</tool-palette-desc>
25	<property>Routes</property>
26	<label>${Distance == null ? "<Distance>" : Distance}</label>
27	<endpoint1>
28	<property>FromDestination</property>
29	<value>${Name}</value>
30	<type>NONE</type>
31	</endpoint1>
32	<endpoint2>
33	<property>ToDestination</property>
34	<value>${Name}</value>
35	<type>ARROW</type>
36	</endpoint2>
37	<instance-id>${FromDestination}-${ToDestination}</instance-id>
38	</connection>
39	</diagram-page>
40
41	<editor-page>
42	<id>overview</id>
43	<page-name>Overview</page-name>
44	<page-header-text>Overview</page-header-text>
45	<root-node>
46	<node>
47	<label>Destinations</label>
48	<section>
49	<description>Destinations in the map</description>
50	<content>
51	<property-editor>Destinations</property-editor>
52	</content>
53	</section>
54	</node>
55	<node>
56	<label>Routes</label>
57	<section>
58	<description>Routes in the map</description>
59	<content>
60	<property-editor>Routes</property-editor>
61	</content>
62	</section>
63	</node>
64	</root-node>
65	</editor-page>
66	</definition>
67

Added Link Here

(-)src/org/eclipse/sapphire/samples/map/IDestination.java (+30 lines)
1	package org.eclipse.sapphire.samples.map;
2
3	import org.eclipse.sapphire.modeling.IModelElement;
4	import org.eclipse.sapphire.modeling.ModelElementType;
5	import org.eclipse.sapphire.modeling.Value;
6	import org.eclipse.sapphire.modeling.ValueProperty;
7	import org.eclipse.sapphire.modeling.annotations.GenerateImpl;
8	import org.eclipse.sapphire.modeling.annotations.Label;
9	import org.eclipse.sapphire.modeling.annotations.NonNullValue;
10	import org.eclipse.sapphire.modeling.xml.annotations.XmlBinding;
11
12	@GenerateImpl
13
14	public interface IDestination extends IModelElement
15	{
16	ModelElementType TYPE = new ModelElementType( IDestination.class );
17
18	// * Name *
19
20	@XmlBinding( path = "name" )
21	@Label( standard = "name" )
22	@NonNullValue
23	//@DefaultValue( text = "Destination" )
24
25	ValueProperty PROP_NAME = new ValueProperty( TYPE, "Name" );
26
27	Value<String> getName();
28	void setName( String name );
29
30	}

Added Link Here

(-)src/org/eclipse/sapphire/samples/map/ui/MapEditor.java (+83 lines)
1	package org.eclipse.sapphire.samples.map.ui;
2
3	import org.eclipse.core.runtime.IPath;
4	import org.eclipse.core.runtime.IProgressMonitor;
5	import org.eclipse.core.runtime.Path;
6	import org.eclipse.sapphire.modeling.IModelElement;
7	import org.eclipse.sapphire.modeling.xml.RootXmlResource;
8	import org.eclipse.sapphire.samples.map.IMap;
9	import org.eclipse.sapphire.ui.SapphireEditor;
10	import org.eclipse.sapphire.ui.diagram.editor.SapphireDiagramEditorPart;
11	import org.eclipse.sapphire.ui.diagram.graphiti.editor.SapphireDiagramEditor;
12	import org.eclipse.sapphire.ui.diagram.graphiti.editor.SapphireDiagramEditorInput;
13	import org.eclipse.sapphire.ui.editor.views.masterdetails.MasterDetailsPage;
14	import org.eclipse.sapphire.ui.xml.XmlEditorResourceStore;
15	import org.eclipse.ui.PartInitException;
16	import org.eclipse.ui.part.FileEditorInput;
17	import org.eclipse.wst.sse.ui.StructuredTextEditor;
18
19	public class MapEditor extends SapphireEditor
20	{
21	private IMap modelMap;
22	private StructuredTextEditor mapSourceEditor;
23	private SapphireDiagramEditorPart mapDiagramPart;
24	private MasterDetailsPage mapOverviewPage;
25
26	public MapEditor()
27	{
28	super( "org.eclipse.sapphire.samples" );
29	}
30
31	@Override
32	protected void createSourcePages() throws PartInitException
33	{
34	this.mapSourceEditor = new StructuredTextEditor();
35	this.mapSourceEditor.setEditorPart(this);
36	final FileEditorInput rootEditorInput = (FileEditorInput) getEditorInput();
37
38	int index = addPage( this.mapSourceEditor, rootEditorInput );
39	setPageText( index, "map.xml" );
40	}
41
42	@Override
43	protected IModelElement createModel()
44	{
45	this.modelMap = IMap.TYPE.instantiate(new RootXmlResource(new XmlEditorResourceStore(this, this.mapSourceEditor)));
46	return this.modelMap;
47	}
48
49	@Override
50	protected void createDiagramPages() throws PartInitException
51	{
52	IPath path = new Path( "org.eclipse.sapphire.samples/sdef/MapEditor.sdef/diagram" );
53	this.mapDiagramPart = new SapphireDiagramEditorPart(this, this.modelMap, path);
54	SapphireDiagramEditor diagramEditor = this.mapDiagramPart.getDiagramEditor();
55	SapphireDiagramEditorInput diagramEditorInput = this.mapDiagramPart.getDiagramEditorInput();
56	addPage(0, diagramEditor, diagramEditorInput);
57	setPageText( 0, "Diagram" );
58	setPageId(this.pages.get(0), "Diagram");
59	}
60
61	@Override
62	protected void createFormPages() throws PartInitException
63	{
64	IPath path = new Path( "org.eclipse.sapphire.samples/sdef/MapEditor.sdef/overview" );
65	this.mapOverviewPage = new MasterDetailsPage(this, this.modelMap, path);
66	addPage(1, this.mapOverviewPage);
67	setPageText(1, "Overview");
68	setPageId(this.pages.get(1), "Overview");
69	}
70
71	public IMap getMap()
72	{
73	return this.modelMap;
74	}
75
76	@Override
77	public void doSave( final IProgressMonitor monitor )
78	{
79	super.doSave(monitor);
80	SapphireDiagramEditor diagramEditor = this.mapDiagramPart.getDiagramEditor();
81	diagramEditor.doSave(monitor);
82	}
83	}

Lines 24-27 Link Here

(-)plugin.xml (+19 lines)
24	</builder>	24	</builder>
25	</extension>	25	</extension>
26		26
		27	<extension point="org.eclipse.graphiti.ui.diagramTypes">
		28	<diagramType
		29	description="%sapphireDiagramTypeDescription"
		30	id="org.eclipse.sapphire.ui.SapphireDiagramType"
		31	name="%sapphireDiagramTypeName"
		32	type="sapphireDiagram">
		33	</diagramType>
		34	</extension>
		35
		36	<extension point="org.eclipse.graphiti.ui.diagramTypeProviders">
		37	<diagramTypeProvider
		38	class="org.eclipse.sapphire.ui.diagram.graphiti.providers.SapphireDiagramTypeProvider"
		39	description="%sapphireDiagramTypeProviderDescription"
		40	id="org.eclipse.sapphire.ui.sapphireDiagramTypeProvider"
		41	name="%sapphireDiagramTypeProviderName">
		42	<diagramType id="org.eclipse.sapphire.ui.SapphireDiagramType"/>
		43	</diagramTypeProvider>
		44	</extension>
		45
27	</plugin>	46	</plugin>

Lines 26-31 Link Here

(-)src/org/eclipse/sapphire/ui/def/ISapphireUiDef.java (+10 lines)
26	import org.eclipse.sapphire.modeling.xml.annotations.XmlListBinding;	26	import org.eclipse.sapphire.modeling.xml.annotations.XmlListBinding;
27	import org.eclipse.sapphire.modeling.xml.annotations.XmlRootBinding;	27	import org.eclipse.sapphire.modeling.xml.annotations.XmlRootBinding;
28	import org.eclipse.sapphire.ui.def.internal.SapphireUiDefMethods;	28	import org.eclipse.sapphire.ui.def.internal.SapphireUiDefMethods;
		29	import org.eclipse.sapphire.ui.diagram.def.IDiagramPageDef;
29		30
30	/**	31	/**
31	* @author <a href="mailto:konstantin.komissarchik@oracle.com">Konstantin Komissarchik</a>	32	* @author <a href="mailto:konstantin.komissarchik@oracle.com">Konstantin Komissarchik</a>
Lines 129-134 Link Here
129		130
130	ModelElementList<IEditorPageDef> getEditorPageDefs();	131	ModelElementList<IEditorPageDef> getEditorPageDefs();
131		132
		133	// * DiagramPageDefs *
		134
		135	@Type( base = IDiagramPageDef.class )
		136	@XmlListBinding( mappings = @XmlListBinding.Mapping( element = "diagram-page", type = IDiagramPageDef.class ) )
		137
		138	ListProperty PROP_DIAGRAM_PAGE_DEFS = new ListProperty( TYPE, "DiagramPageDefs" );
		139
		140	ModelElementList<IDiagramPageDef> getDiagramPageDefs();
		141
132	// * DialogDefs *	142	// * DialogDefs *
133		143
134	@Type( base = ISapphireDialogDef.class )	144	@Type( base = ISapphireDialogDef.class )

Added Link Here

(-)src/org/eclipse/sapphire/ui/def/SapphireDiagramDefFactory.java (+51 lines)
1	package org.eclipse.sapphire.ui.def;
2
3	import org.eclipse.sapphire.modeling.BundleResourceStore;
4	import org.eclipse.sapphire.modeling.ResourceStoreException;
5	import org.eclipse.sapphire.modeling.SharedModelsCache;
6	import org.eclipse.sapphire.modeling.xml.RootXmlResource;
7	import org.eclipse.sapphire.modeling.xml.XmlResourceStore;
8	import org.eclipse.sapphire.ui.diagram.def.IDiagramPageDef;
9	import org.eclipse.sapphire.ui.internal.SapphireUiFrameworkPlugin;
10
11	public class SapphireDiagramDefFactory
12	{
13	public static IDiagramPageDef load(final String bundleId, final String path)
14	{
15	try
16	{
17	return load( new XmlResourceStore( new BundleResourceStore( bundleId, path ) ), false );
18	}
19	catch( ResourceStoreException e )
20	{
21	SapphireUiFrameworkPlugin.log( e );
22	return null;
23	}
24	}
25
26	public static IDiagramPageDef load( final XmlResourceStore resourceStore,
27	final boolean writable )
28	{
29	IDiagramPageDef model;
30
31	if( writable )
32	{
33	model = IDiagramPageDef.TYPE.instantiate( new RootXmlResource( resourceStore ) );
34	}
35	else
36	{
37	final SharedModelsCache.StandardKey key = new SharedModelsCache.StandardKey( resourceStore, IDiagramPageDef.TYPE );
38
39	model = (IDiagramPageDef) SharedModelsCache.retrieve( key );
40
41	if( model == null )
42	{
43	model = IDiagramPageDef.TYPE.instantiate( new RootXmlResource( resourceStore ) );
44	SharedModelsCache.store( key, model );
45	}
46	}
47	return model;
48	}
49
50	}
51

Added Link Here

(-)src/org/eclipse/sapphire/ui/diagram/def/IDiagramConnectionDef.java (+102 lines)
1	package org.eclipse.sapphire.ui.diagram.def;
2
3	import org.eclipse.sapphire.modeling.ElementProperty;
4	import org.eclipse.sapphire.modeling.ModelElementHandle;
5	import org.eclipse.sapphire.modeling.ModelElementType;
6	import org.eclipse.sapphire.modeling.Value;
7	import org.eclipse.sapphire.modeling.ValueProperty;
8	import org.eclipse.sapphire.modeling.annotations.GenerateImpl;
9	import org.eclipse.sapphire.modeling.annotations.Label;
10	import org.eclipse.sapphire.modeling.annotations.Type;
11	import org.eclipse.sapphire.modeling.xml.annotations.XmlBinding;
12	import org.eclipse.sapphire.ui.def.ISapphirePartDef;
13
14	@GenerateImpl
15
16	public interface IDiagramConnectionDef
17
18	extends ISapphirePartDef
19
20	{
21	ModelElementType TYPE = new ModelElementType( IDiagramConnectionDef.class );
22
23	// * Id *
24
25	@Label( standard = "ID" )
26	@XmlBinding( path = "id" )
27
28	ValueProperty PROP_ID = new ValueProperty( TYPE, "Id" );
29
30	Value<String> getId();
31	void setId( String id );
32
33	// * Property *
34
35	@Label( standard = "property" )
36	@XmlBinding( path = "property" )
37
38	ValueProperty PROP_PROPERTY = new ValueProperty( TYPE, "Property" );
39
40	Value<String> getProperty();
41	void setProperty( String property );
42
43	// * ToolPaletteLabel *
44
45	@Label( standard = "tool palette label" )
46	@XmlBinding( path = "tool-palette-label" )
47
48	ValueProperty PROP_TOOL_PALETTE_LABEL = new ValueProperty( TYPE, "ToolPaletteLabel" );
49
50	Value<String> getToolPaletteLabel();
51	void setToolPaletteLabel( String paletteLabel );
52
53	// * ToolPaletteDesc *
54
55	@Label( standard = "tool palette description" )
56	@XmlBinding( path = "tool-palette-desc" )
57
58	ValueProperty PROP_TOOL_PALETTE_DESC = new ValueProperty( TYPE, "ToolPaletteDesc" );
59
60	Value<String> getToolPaletteDesc();
61	void setToolPaletteDesc( String paletteDesc );
62
63	// * Label *
64
65	@Label( standard = "label" )
66	@XmlBinding( path = "label" )
67
68	ValueProperty PROP_LABEL = new ValueProperty( TYPE, "Label" );
69
70	Value<String> getLabel();
71	void setLabel( String label );
72
73	// * Endpoint1 *
74
75	@Type( base = IDiagramConnectionEndpointDef.class )
76	@XmlBinding( path = "endpoint1" )
77
78	ElementProperty PROP_ENDPOINT_1 = new ElementProperty( TYPE, "Endpoint1" );
79
80	ModelElementHandle<IDiagramConnectionEndpointDef> getEndpoint1();
81
82	// * Endpoint2 *
83
84	@Type( base = IDiagramConnectionEndpointDef.class )
85	@XmlBinding( path = "endpoint2" )
86
87	ElementProperty PROP_ENDPOINT_2 = new ElementProperty( TYPE, "Endpoint2" );
88
89	ModelElementHandle<IDiagramConnectionEndpointDef> getEndpoint2();
90
91	// * InstanceId *
92
93	@Label( standard = "instance id" )
94	@XmlBinding( path = "instance-id" )
95
96	ValueProperty PROP_INSTANCE_ID = new ValueProperty( TYPE, "InstanceId" );
97
98	Value<String> getInstanceId();
99	void setInstanceId( String instanceId );
100
101
102	}

Added Link Here

(-)src/org/eclipse/sapphire/ui/diagram/def/IDiagramPageDef.java (+75 lines)
1	package org.eclipse.sapphire.ui.diagram.def;
2
3	import org.eclipse.sapphire.modeling.ListProperty;
4	import org.eclipse.sapphire.modeling.ModelElementList;
5	import org.eclipse.sapphire.modeling.ModelElementType;
6	import org.eclipse.sapphire.modeling.Value;
7	import org.eclipse.sapphire.modeling.ValueProperty;
8	import org.eclipse.sapphire.modeling.annotations.DefaultValue;
9	import org.eclipse.sapphire.modeling.annotations.GenerateImpl;
10	import org.eclipse.sapphire.modeling.annotations.Label;
11	import org.eclipse.sapphire.modeling.annotations.Type;
12	import org.eclipse.sapphire.modeling.xml.annotations.XmlBinding;
13	import org.eclipse.sapphire.modeling.xml.annotations.XmlListBinding;
14	import org.eclipse.sapphire.ui.def.ISapphirePartDef;
15
16	@GenerateImpl
17
18	public interface IDiagramPageDef
19
20	extends ISapphirePartDef
21
22	{
23	ModelElementType TYPE = new ModelElementType( IDiagramPageDef.class);
24
25	// * Id *
26
27	@Label( standard = "ID" )
28	@XmlBinding( path = "id" )
29
30	ValueProperty PROP_ID = new ValueProperty( TYPE, "Id" );
31
32	Value<String> getId();
33	void setId( String id );
34
35	// * PageName *
36
37	@Label( standard = "page name" )
38	@DefaultValue( text = "Diagram" )
39	@XmlBinding( path = "page-name" )
40
41	ValueProperty PROP_PAGE_NAME = new ValueProperty( TYPE, "PageName" );
42
43	Value<String> getPageName();
44	void setPageName( String pageName );
45
46	// * PageHeaderText *
47
48	@Label( standard = "page header text" )
49	@DefaultValue( text = "Diagram View" )
50	@XmlBinding( path = "page-header-text" )
51
52	ValueProperty PROP_PAGE_HEADER_TEXT = new ValueProperty( TYPE, "PageHeaderText" );
53
54	Value<String> getPageHeaderText();
55	void setPageHeaderText( String pageHeaderText );
56
57	// * DiagramNodeDefs *
58
59	@Type( base = IDiagramNodeDef.class )
60	@XmlListBinding( mappings = @XmlListBinding.Mapping( element = "node", type = IDiagramNodeDef.class ) )
61
62	ListProperty PROP_DIAGRAM_NODE_DEFS = new ListProperty( TYPE, "DiagramNodeDefs" );
63
64	ModelElementList<IDiagramNodeDef> getDiagramNodeDefs();
65
66	// * DiagramConnectionDefs *
67
68	@Type( base = IDiagramConnectionDef.class )
69	@XmlListBinding( mappings = @XmlListBinding.Mapping( element = "connection", type = IDiagramConnectionDef.class ) )
70
71	ListProperty PROP_DIAGRAM_CONNECTION_DEFS = new ListProperty( TYPE, "DiagramConnectionDefs" );
72
73	ModelElementList<IDiagramConnectionDef> getDiagramConnectionDefs();
74
75	}

Added Link Here

(-)src/org/eclipse/sapphire/ui/diagram/editor/DiagramConnectionPart.java (+231 lines)
1	package org.eclipse.sapphire.ui.diagram.editor;
2
3	import org.eclipse.sapphire.modeling.IModelElement;
4	import org.eclipse.sapphire.modeling.ModelElementType;
5	import org.eclipse.sapphire.modeling.ModelProperty;
6	import org.eclipse.sapphire.modeling.ReferenceValue;
7	import org.eclipse.sapphire.modeling.Value;
8	import org.eclipse.sapphire.modeling.ValueProperty;
9	import org.eclipse.sapphire.modeling.el.Function;
10	import org.eclipse.sapphire.ui.SapphirePart;
11	import org.eclipse.sapphire.ui.SapphireRenderingContext;
12	import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionDef;
13	import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionEndpointDef;
14
15	public class DiagramConnectionPart extends SapphirePart
16	{
17	private DiagramConnectionTemplate connectionTemplate;
18	private IDiagramConnectionDef definition;
19	private IModelElement modelElement;
20	private IDiagramConnectionEndpointDef endpoint1Def;
21	private IDiagramConnectionEndpointDef endpoint2Def;
22	private IModelElement endpoint1Model;
23	private IModelElement endpoint2Model;
24	private Function labelFunction;
25	private ValueProperty labelProperty;
26	private Function idFunction;
27	private Function endpoint1Function;
28	private Function endpoint2Function;
29
30	public DiagramConnectionPart(DiagramConnectionTemplate connectionTemplate)
31	{
32	this.connectionTemplate = connectionTemplate;
33	}
34
35	@Override
36	protected void init()
37	{
38	super.init();
39
40	this.definition = (IDiagramConnectionDef)super.definition;
41	this.modelElement = getModelElement();
42	this.labelFunction = initExpression
43	(
44	this.definition.getLabel().getLocalizedText(),
45	new Runnable()
46	{
47	public void run()
48	{
49	}
50	}
51	);
52
53	this.labelProperty = FunctionUtil.getFunctionProperty(this.modelElement, this.labelFunction);
54	if (this.labelProperty == null)
55	{
56	throw new RuntimeException( "Label function does not contain a property.");
57	}
58
59	this.idFunction = initExpression
60	(
61	this.definition.getInstanceId().getLocalizedText(),
62	new Runnable()
63	{
64	public void run()
65	{
66	}
67	}
68	);
69
70	this.endpoint1Def = this.definition.getEndpoint1().element();
71	this.endpoint2Def = this.definition.getEndpoint2().element();
72	this.endpoint1Model = processEndpoint(this.endpoint1Def);
73	this.endpoint2Model = processEndpoint(this.endpoint2Def);
74	this.endpoint1Function = initExpression
75	(
76	this.endpoint1Model,
77	this.endpoint1Def.getValue().getContent(),
78	new Runnable()
79	{
80	public void run()
81	{
82	refreshEndpoint1();
83	}
84	}
85	);
86	this.endpoint2Function = initExpression
87	(
88	this.endpoint2Model,
89	this.endpoint2Def.getValue().getContent(),
90	new Runnable()
91	{
92	public void run()
93	{
94	refreshEndpoint2();
95	}
96	}
97	);
98	}
99
100	public DiagramConnectionTemplate getDiagramConnectionTemplate()
101	{
102	return this.connectionTemplate;
103	}
104
105	public IModelElement getLocalModelElement()
106	{
107	return this.modelElement;
108	}
109
110	public IModelElement getEndpoint1()
111	{
112	return this.endpoint1Model;
113	}
114
115	public IModelElement getEndpoint2()
116	{
117	return this.endpoint2Model;
118	}
119
120	public String getLabel()
121	{
122	String label = null;
123
124	if( this.labelFunction != null )
125	{
126	label = (String) this.labelFunction.value();
127	}
128
129	if( label == null )
130	{
131	label = "#null#";
132	}
133
134	return label;
135	}
136
137	public void setLabel(String newValue)
138	{
139	if (this.labelProperty != null)
140	{
141	this.modelElement.write(this.labelProperty, newValue);
142	}
143	}
144
145	public String getInstanceId()
146	{
147	String id = null;
148
149	if( this.idFunction != null )
150	{
151	id = (String) this.idFunction.value();
152	}
153
154	if( id == null )
155	{
156	id = "#null#";
157	}
158
159	return id;
160	}
161
162	@Override
163	public void render(SapphireRenderingContext context)
164	{
165	throw new UnsupportedOperationException();
166	}
167
168	public void refreshEndpoint1()
169	{
170	if (this.endpoint1Function != null)
171	{
172	Object value = this.endpoint1Function.value();
173	String property = this.endpoint1Def.getProperty().getContent();
174	setModelProperty(this.modelElement, property, value);
175	}
176	}
177
178	public void refreshEndpoint2()
179	{
180	if (this.endpoint2Function != null)
181	{
182	Object value = this.endpoint2Function.value();
183	String property = this.endpoint2Def.getProperty().getContent();
184	setModelProperty(this.modelElement, property, value);
185	}
186	}
187
188	private IModelElement processEndpoint(IDiagramConnectionEndpointDef endpointDef)
189	{
190	String propertyName = endpointDef.getProperty().getContent();
191	ModelProperty modelProperty = resolve(this.modelElement, propertyName);
192	if (!(modelProperty instanceof ValueProperty))
193	{
194	throw new RuntimeException( "Property " + propertyName + " not a ValueProperty");
195	}
196	ValueProperty property = (ValueProperty)modelProperty;
197	Value<?> valObj = this.modelElement.read(property);
198	if (!(valObj instanceof ReferenceValue))
199	{
200	throw new RuntimeException( "Property " + propertyName + " value not a reference");
201	}
202	ReferenceValue<?> refVal = (ReferenceValue<?>)valObj;
203	Object targetObj = refVal.resolve();
204	if (!(targetObj instanceof IModelElement))
205	{
206	throw new RuntimeException( "Target not an IModelElement");
207	}
208	return (IModelElement)targetObj;
209	}
210
211	private void setModelProperty(final IModelElement modelElement,
212	String propertyName, Object value)
213	{
214	if (propertyName != null)
215	{
216	final ModelElementType type = modelElement.getModelElementType();
217	final ModelProperty property = type.getProperty( propertyName );
218	if( property == null )
219	{
220	throw new RuntimeException( "Could not find property " + propertyName + " in " + type.getQualifiedName() );
221	}
222	if (!(property instanceof ValueProperty))
223	{
224	throw new RuntimeException( "Property " + propertyName + " not a ValueProperty");
225	}
226
227	modelElement.write((ValueProperty)property, value);
228	}
229	}
230
231	}

Added Link Here

(-)src/org/eclipse/sapphire/ui/diagram/editor/DiagramConnectionTemplate.java (+186 lines)
1	package org.eclipse.sapphire.ui.diagram.editor;
2
3	import java.util.ArrayList;
4	import java.util.Collections;
5	import java.util.List;
6
7	import org.eclipse.sapphire.modeling.ElementProperty;
8	import org.eclipse.sapphire.modeling.IModelElement;
9	import org.eclipse.sapphire.modeling.ListProperty;
10	import org.eclipse.sapphire.modeling.ModelElementList;
11	import org.eclipse.sapphire.modeling.ModelElementType;
12	import org.eclipse.sapphire.modeling.ModelProperty;
13	import org.eclipse.sapphire.modeling.Value;
14	import org.eclipse.sapphire.modeling.ValueProperty;
15	import org.eclipse.sapphire.modeling.el.Function;
16	import org.eclipse.sapphire.modeling.el.FunctionContext;
17	import org.eclipse.sapphire.modeling.el.ModelElementFunctionContext;
18	import org.eclipse.sapphire.modeling.el.parser.ExpressionLanguageParser;
19	import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionDef;
20	import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionEndpointDef;
21	import org.eclipse.sapphire.ui.internal.SapphireUiFrameworkPlugin;
22
23	public class DiagramConnectionTemplate
24	{
25	private SapphireDiagramEditorPart diagramEditor;
26	private IDiagramConnectionDef definition;
27	private IModelElement modelElement;
28	private ModelProperty modelProperty;
29	private String toolPaletteLabel;
30	private String toolPaletteDesc;
31
32	private List<DiagramConnectionPart> diagramConnections;
33
34	public DiagramConnectionTemplate(final SapphireDiagramEditorPart diagramEditor,
35	IDiagramConnectionDef definition, IModelElement modelElement)
36	{
37	this.diagramEditor = diagramEditor;
38	this.modelElement = modelElement;
39	this.definition = definition;
40
41	this.toolPaletteLabel = this.definition.getToolPaletteLabel().getContent();
42	this.toolPaletteDesc = this.definition.getToolPaletteDesc().getContent();
43
44	this.diagramConnections = new ArrayList<DiagramConnectionPart>();
45
46	String propertyName = this.definition.getProperty().getContent();
47	this.modelProperty = resolve(this.modelElement, propertyName);
48	if (this.modelProperty instanceof ListProperty)
49	{
50	ListProperty listProperty = (ListProperty)this.modelProperty;
51	ModelElementList<?> list = this.modelElement.read(listProperty);
52	for( IModelElement listEntryModelElement : list )
53	{
54	DiagramConnectionPart connection = new DiagramConnectionPart(this);
55	connection.init(this.diagramEditor, listEntryModelElement, definition,
56	Collections.<String,String>emptyMap());
57	this.diagramConnections.add(connection);
58	}
59	}
60	else if (this.modelProperty instanceof ElementProperty)
61	{
62	ElementProperty elementProperty = (ElementProperty)this.modelProperty;
63	if (this.modelElement.read(elementProperty) != null)
64	{
65	IModelElement localModelElement = this.modelElement.read(elementProperty).element();
66	DiagramConnectionPart connection = new DiagramConnectionPart(this);
67	connection.init(this.diagramEditor, localModelElement, definition,
68	Collections.<String,String>emptyMap());
69
70	this.diagramConnections.add(connection);
71	}
72	}
73	}
74
75	public List<DiagramConnectionPart> getDiagramConnections()
76	{
77	return this.diagramConnections;
78	}
79
80	public String getToolPaletteLabel()
81	{
82	return this.toolPaletteLabel;
83	}
84
85	public String getToolPaletteDesc()
86	{
87	return this.toolPaletteDesc;
88	}
89
90	public DiagramConnectionPart createNewDiagramConnection(DiagramNodePart srcNode,
91	DiagramNodePart targetNode)
92	{
93	IModelElement newElement = null;
94	if (this.modelProperty instanceof ListProperty)
95	{
96	ListProperty listProperty = (ListProperty)this.modelProperty;
97	ModelElementList<?> list = this.modelElement.read(listProperty);
98	newElement = list.addNewElement();
99	}
100	else if (this.modelProperty instanceof ElementProperty)
101	{
102	// TODO what if the element property does exist?
103	ElementProperty elementProperty = (ElementProperty)this.modelProperty;
104	newElement = this.modelElement.read(elementProperty).element(true);
105	}
106
107	IDiagramConnectionEndpointDef srcAnchorDef = this.definition.getEndpoint1().element();
108	String srcProperty = srcAnchorDef.getProperty().getContent();
109	String srcExpr = srcAnchorDef.getValue().getContent();
110	Function srcFunc = getNodeReferenceFunction(srcNode, srcExpr);
111	Object srcValue = srcFunc.value();
112	srcFunc.dispose();
113	setModelProperty(newElement, srcProperty, srcValue);
114
115	IDiagramConnectionEndpointDef targetAnchorDef = this.definition.getEndpoint2().element();
116	String targetProperty = targetAnchorDef.getProperty().getContent();
117	String targetExpr = targetAnchorDef.getValue().getContent();
118	Function targetFunc = getNodeReferenceFunction(targetNode, targetExpr);
119	Object targetValue = targetFunc.value();
120	targetFunc.dispose();
121	setModelProperty(newElement, targetProperty, targetValue);
122
123	DiagramConnectionPart newConn = new DiagramConnectionPart(this);
124	newConn.init(this.diagramEditor, newElement, this.definition,
125	Collections.<String,String>emptyMap());
126	this.diagramConnections.add(newConn);
127	return newConn;
128	}
129
130	private ModelProperty resolve(final IModelElement modelElement,
131	String propertyName)
132	{
133	if (propertyName != null)
134	{
135	final ModelElementType type = modelElement.getModelElementType();
136	final ModelProperty property = type.getProperty( propertyName );
137	if( property == null )
138	{
139	throw new RuntimeException( "Could not find property " + propertyName + " in " + type.getQualifiedName() );
140	}
141	return property;
142	}
143	return null;
144	}
145
146	private void setModelProperty(final IModelElement modelElement,
147	String propertyName, Object value)
148	{
149	if (propertyName != null)
150	{
151	final ModelElementType type = modelElement.getModelElementType();
152	final ModelProperty property = type.getProperty( propertyName );
153	if( property == null )
154	{
155	throw new RuntimeException( "Could not find property " + propertyName + " in " + type.getQualifiedName() );
156	}
157	if (!(property instanceof ValueProperty))
158	{
159	throw new RuntimeException( "Property " + propertyName + " not a ValueProperty");
160	}
161
162	modelElement.write((ValueProperty)property, ((Value<?>)value).getContent());
163	}
164	}
165
166	private Function getNodeReferenceFunction(final DiagramNodePart nodePart,
167	final String expression)
168	{
169	final FunctionContext context = new ModelElementFunctionContext( nodePart.getLocalModelElement() );
170	Function result = null;
171
172	if( expression != null )
173	{
174	try
175	{
176	result = ExpressionLanguageParser.parse( context, expression );
177	}
178	catch( Exception e )
179	{
180	SapphireUiFrameworkPlugin.log( e );
181	result = null;
182	}
183	}
184	return result;
185	}
186	}

Added Link Here

(-)src/org/eclipse/sapphire/ui/diagram/geometry/IBendPoint.java (+40 lines)
1	package org.eclipse.sapphire.ui.diagram.geometry;
2
3	import org.eclipse.sapphire.modeling.IModelElement;
4	import org.eclipse.sapphire.modeling.ModelElementType;
5	import org.eclipse.sapphire.modeling.Value;
6	import org.eclipse.sapphire.modeling.ValueProperty;
7	import org.eclipse.sapphire.modeling.annotations.GenerateImpl;
8	import org.eclipse.sapphire.modeling.annotations.Type;
9	import org.eclipse.sapphire.modeling.xml.annotations.CustomXmlValueBinding;
10	import org.eclipse.sapphire.ui.diagram.geometry.internal.GeometryAttributeBinding;
11
12	@GenerateImpl
13
14	public interface IBendPoint extends IModelElement
15	{
16	ModelElementType TYPE = new ModelElementType( IBendPoint.class );
17
18	// * X *
19
20	@Type( base = Integer.class )
21	@CustomXmlValueBinding( impl = GeometryAttributeBinding.class, params = {"x"})
22
23	ValueProperty PROP_X = new ValueProperty( TYPE, "X");
24
25	Value<Integer> getX();
26	void setX(Integer value);
27	void setX(String value);
28
29	// * Y *
30
31	@Type( base = Integer.class )
32	@CustomXmlValueBinding( impl = GeometryAttributeBinding.class, params = {"y"})
33
34	ValueProperty PROP_Y = new ValueProperty( TYPE, "Y");
35
36	Value<Integer> getY();
37	void setY(Integer value);
38	void setY(String value);
39
40	}

Added Link Here

(-)src/org/eclipse/sapphire/ui/diagram/graphiti/GraphitiFileService.java (+172 lines)
1	package org.eclipse.sapphire.ui.diagram.graphiti;
2
3	import java.io.IOException;
4	import java.io.PrintWriter;
5	import java.io.StringWriter;
6	import java.util.Collections;
7	import java.util.HashMap;
8	import java.util.HashSet;
9	import java.util.Map;
10	import java.util.Map.Entry;
11	import java.util.Set;
12
13	import org.eclipse.core.resources.IFile;
14	import org.eclipse.core.resources.IWorkspaceRunnable;
15	import org.eclipse.core.resources.ResourcesPlugin;
16	import org.eclipse.core.runtime.CoreException;
17	import org.eclipse.core.runtime.IProgressMonitor;
18	import org.eclipse.core.runtime.Path;
19	import org.eclipse.emf.common.command.CommandStack;
20	import org.eclipse.emf.common.util.EList;
21	import org.eclipse.emf.common.util.URI;
22	import org.eclipse.emf.common.util.WrappedException;
23	import org.eclipse.emf.ecore.resource.Resource;
24	import org.eclipse.emf.ecore.resource.ResourceSet;
25	import org.eclipse.emf.transaction.RecordingCommand;
26	import org.eclipse.emf.transaction.Transaction;
27	import org.eclipse.emf.transaction.TransactionalEditingDomain;
28	import org.eclipse.emf.transaction.impl.TransactionalEditingDomainImpl;
29	import org.eclipse.graphiti.mm.pictograms.Diagram;
30	import org.eclipse.graphiti.ui.editor.DiagramEditorFactory;
31
32	public class GraphitiFileService
33	{
34	public static TransactionalEditingDomain createEmfFileForDiagram(URI diagramResourceUri, final Diagram diagram) {
35
36	// Create a resource set and EditingDomain
37	final TransactionalEditingDomain editingDomain = DiagramEditorFactory.createResourceSetAndEditingDomain();
38	final ResourceSet resourceSet = editingDomain.getResourceSet();
39	// Create a resource for this file.
40	final Resource resource = resourceSet.createResource(diagramResourceUri);
41	final CommandStack commandStack = editingDomain.getCommandStack();
42	commandStack.execute(new RecordingCommand(editingDomain) {
43
44	@Override
45	protected void doExecute() {
46	resource.setTrackingModification(true);
47	resource.getContents().add(diagram);
48
49	}
50	});
51
52	save(editingDomain, Collections.<Resource, Map<?, ?>> emptyMap());
53	return editingDomain;
54	}
55
56	private static void save(TransactionalEditingDomain editingDomain, Map<Resource, Map<?, ?>> options) {
57	saveInWorkspaceRunnable(editingDomain, options);
58	}
59
60	private static void saveInWorkspaceRunnable(final TransactionalEditingDomain editingDomain, final Map<Resource, Map<?, ?>> options) {
61
62	final Map<URI, Throwable> failedSaves = new HashMap<URI, Throwable>();
63	final IWorkspaceRunnable wsRunnable = new IWorkspaceRunnable() {
64	public void run(final IProgressMonitor monitor) throws CoreException {
65
66	final Runnable runnable = new Runnable() {
67
68	public void run() {
69	Transaction parentTx;
70	if (editingDomain != null
71	&& (parentTx = ((TransactionalEditingDomainImpl) editingDomain).getActiveTransaction()) != null) {
72	do {
73	if (!parentTx.isReadOnly()) {
74	throw new IllegalStateException(
75	"FileService.save() called from within a command (likely produces a deadlock)");
76	}
77	} while ((parentTx = ((TransactionalEditingDomainImpl) editingDomain).getActiveTransaction().getParent()) != null);
78	}
79
80	final EList<Resource> resources = editingDomain.getResourceSet().getResources();
81	// Copy list to an array to prevent
82	// ConcurrentModificationExceptions
83	// during the saving of the dirty resources
84	Resource[] resourcesArray = new Resource[resources.size()];
85	resourcesArray = resources.toArray(resourcesArray);
86	final Set<Resource> savedResources = new HashSet<Resource>();
87	for (int i = 0; i < resourcesArray.length; i++) {
88	// In case resource modification tracking is
89	// switched on, we can check if a resource
90	// has been modified, so that we only need to same
91	// really changed resources; otherwise
92	// we need to save all resources in the set
93	final Resource resource = resourcesArray[i];
94	if (resource.isModified()) {
95	try {
96	resource.save(options.get(resource));
97	savedResources.add(resource);
98	} catch (final Throwable t) {
99	failedSaves.put(resource.getURI(), t);
100	}
101	}
102	}
103	}
104	};
105
106	try {
107	editingDomain.runExclusive(runnable);
108	} catch (final InterruptedException e) {
109	throw new RuntimeException(e);
110	}
111	editingDomain.getCommandStack().flush();
112	}
113	};
114	try {
115	ResourcesPlugin.getWorkspace().run(wsRunnable, null);
116	if (!failedSaves.isEmpty()) {
117	throw new WrappedException(createMessage(failedSaves), new RuntimeException());
118	}
119	} catch (final CoreException e) {
120	final Throwable cause = e.getStatus().getException();
121	if (cause instanceof RuntimeException) {
122	throw (RuntimeException) cause;
123	}
124	throw new RuntimeException(e);
125	}
126	}
127
128	private static String createMessage(Map<URI, Throwable> failedSaves) {
129	final StringBuilder buf = new StringBuilder("The following resources could not be saved:");
130	for (final Entry<URI, Throwable> entry : failedSaves.entrySet()) {
131	buf.append("\nURI: ").append(entry.getKey().toString()).append(", cause: \n").append(getExceptionAsString(entry.getValue()));
132	}
133	return buf.toString();
134	}
135
136	private static String getExceptionAsString(Throwable t) {
137	final StringWriter stringWriter = new StringWriter();
138	final PrintWriter printWriter = new PrintWriter(stringWriter);
139	t.printStackTrace(printWriter);
140	final String result = stringWriter.toString();
141	try {
142	stringWriter.close();
143	} catch (final IOException e) {
144	// $JL-EXC$ ignore
145	}
146	printWriter.close();
147	return result;
148	}
149
150	public static IFile EmfResourceToIFile(Resource resource)
151	{
152	IFile ifile = null;
153
154	URI uri = resource.getURI();
155	uri = resource.getResourceSet().getURIConverter().normalize(uri);
156
157	String scheme = uri.scheme();
158	if ("platform".equals(scheme) && uri.segmentCount() > 1 &&
159	"resource".equals(uri.segment(0)))
160	{
161	StringBuffer platformResourcePath = new StringBuffer();
162	for (int j = 1, size = uri.segmentCount(); j < size; ++j)
163	{
164	platformResourcePath.append('/');
165	platformResourcePath.append(uri.segment(j));
166	}
167	return ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(platformResourcePath.toString()));
168	}
169	return ifile;
170	}
171
172	}

Added Link Here

(-)src/org/eclipse/sapphire/ui/diagram/graphiti/editor/SapphireDiagramEditor.java (+230 lines)
1	package org.eclipse.sapphire.ui.diagram.graphiti.editor;
2
3	import java.util.Collection;
4	import java.util.HashSet;
5	import java.util.Iterator;
6	import java.util.List;
7
8	import org.eclipse.core.runtime.IProgressMonitor;
9	import org.eclipse.emf.transaction.RecordingCommand;
10	import org.eclipse.emf.transaction.TransactionalEditingDomain;
11	import org.eclipse.emf.transaction.util.TransactionUtil;
12	import org.eclipse.graphiti.features.IAddFeature;
13	import org.eclipse.graphiti.features.context.impl.AddConnectionContext;
14	import org.eclipse.graphiti.features.context.impl.AddContext;
15	import org.eclipse.graphiti.mm.algorithms.styles.Point;
16	import org.eclipse.graphiti.mm.pictograms.Anchor;
17	import org.eclipse.graphiti.mm.pictograms.Connection;
18	import org.eclipse.graphiti.mm.pictograms.ContainerShape;
19	import org.eclipse.graphiti.mm.pictograms.Diagram;
20	import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
21	import org.eclipse.graphiti.mm.pictograms.PictogramElement;
22	import org.eclipse.graphiti.mm.pictograms.Shape;
23	import org.eclipse.graphiti.services.Graphiti;
24	import org.eclipse.graphiti.ui.editor.DiagramEditor;
25	import org.eclipse.sapphire.modeling.IModelElement;
26	import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionPart;
27	import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionTemplate;
28	import org.eclipse.sapphire.ui.diagram.editor.DiagramGeometryWrapper;
29	import org.eclipse.sapphire.ui.diagram.editor.DiagramGeometryWrapper.Bounds;
30	import org.eclipse.sapphire.ui.diagram.editor.DiagramNodePart;
31	import org.eclipse.sapphire.ui.diagram.editor.DiagramNodeTemplate;
32	import org.eclipse.sapphire.ui.diagram.editor.SapphireDiagramEditorPart;
33	import org.eclipse.sapphire.ui.internal.SapphireUiFrameworkPlugin;
34
35	@SuppressWarnings("restriction")
36	public class SapphireDiagramEditor extends DiagramEditor
37	{
38	private SapphireDiagramEditorPart diagramPart;
39
40	public SapphireDiagramEditor(SapphireDiagramEditorPart diagramPart)
41	{
42	this.diagramPart = diagramPart;
43	}
44
45	public SapphireDiagramEditorPart getDiagramEditorPart()
46	{
47	return this.diagramPart;
48	}
49
50	@Override
51	public void doSave(final IProgressMonitor monitor )
52	{
53	super.doSave(monitor);
54	try
55	{
56	this.diagramPart.getDiagramGeometry().write();
57	}
58	catch( Exception e )
59	{
60	SapphireUiFrameworkPlugin.log( e );
61	}
62	}
63
64	public void syncDiagramWithModel()
65	{
66	final Diagram diagram = getDiagramTypeProvider().getDiagram();
67
68	TransactionalEditingDomain ted = TransactionUtil.getEditingDomain(diagram);
69	ted.getCommandStack().execute(new RecordingCommand(ted)
70	{
71	protected void doExecute()
72	{
73	removeConnections(diagram);
74	removeNodes(diagram);
75
76	reconstructNodes(diagram);
77	reconstructConnections(diagram);
78	}
79	});
80	}
81
82	private void removeConnections(final Diagram diagram)
83	{
84	List<Connection> cons = diagram.getConnections();
85	Iterator<Connection> consIt = cons.iterator();
86	// don't cause ConcurrentModificationException
87	Collection<Connection> allCons = new HashSet<Connection>();
88	while (consIt.hasNext())
89	{
90	Connection con = consIt.next();
91	allCons.add(con);
92	}
93	consIt = allCons.iterator();
94	while (consIt.hasNext())
95	{
96	Connection con = consIt.next();
97	Graphiti.getPeService().deletePictogramElement(con);
98	}
99	}
100
101	private void removeNodes(final Diagram diagram)
102	{
103	List<Shape> containerShapes = diagram.getChildren();
104	Iterator<Shape> shapeIt = containerShapes.iterator();
105	// don't cause ConcurrentModificationException
106	Collection<Shape> allShapes = new HashSet<Shape>();
107	while (shapeIt.hasNext())
108	{
109	Shape shape = shapeIt.next();
110	allShapes.add(shape);
111	}
112	shapeIt = allShapes.iterator();
113	while (shapeIt.hasNext())
114	{
115	Shape containerShape = shapeIt.next();
116	Graphiti.getPeService().deletePictogramElement(containerShape);
117	}
118	}
119
120	private void reconstructNodes(final Diagram diagram)
121	{
122	// Add the nodes back to the diagram thus re-establishing mapping between
123	// pictograms and business objects
124
125	int nodeX = 50;
126	int nodeY = 50;
127	int xInc = 100;
128	DiagramGeometryWrapper diagramGeometry = SapphireDiagramEditor.this.diagramPart.getDiagramGeometry();
129
130	for (DiagramNodeTemplate nodeTemplate : SapphireDiagramEditor.this.diagramPart.getNodeTemplates())
131	{
132	for (DiagramNodePart nodePart : nodeTemplate.getDiagramNodes())
133	{
134	Bounds bounds = diagramGeometry.getNode(nodePart);
135	if (bounds == null)
136	{
137	bounds = new Bounds(nodeX, nodeY, -1, -1);
138	nodeX += xInc;
139	}
140	AddContext ctx = new AddContext();
141	ctx.setNewObject(nodePart);
142	ctx.setTargetContainer(diagram);
143	ctx.setWidth(bounds.width);
144	ctx.setHeight(bounds.height);
145	ctx.setX(bounds.x);
146	ctx.setY(bounds.y);
147	IAddFeature ft = getDiagramTypeProvider().getFeatureProvider().getAddFeature(ctx);
148	ft.add(ctx);
149	}
150	}
151	}
152
153	private void reconstructConnections(final Diagram diagram)
154	{
155	DiagramGeometryWrapper diagramGeometry = SapphireDiagramEditor.this.diagramPart.getDiagramGeometry();
156	// add the connections back to the diagram
157	for (DiagramConnectionTemplate connTemplate : SapphireDiagramEditor.this.diagramPart.getConnectionTemplates())
158	{
159	for (DiagramConnectionPart connPart : connTemplate.getDiagramConnections())
160	{
161	IModelElement endpoint1 = connPart.getEndpoint1();
162	IModelElement endpoint2 = connPart.getEndpoint2();
163	DiagramNodePart nodePart1 = getDiagramNode(endpoint1);
164	DiagramNodePart nodePart2 = getDiagramNode(endpoint2);
165	if (nodePart1 != null && nodePart2 != null)
166	{
167	ContainerShape sourceShape = getContainerShape(nodePart1);
168	ContainerShape targetShape = getContainerShape(nodePart2);
169	if (sourceShape != null && targetShape != null)
170	{
171	Anchor sourceAnchor = sourceShape.getAnchors().get(0);
172	Anchor targetAnchor = targetShape.getAnchors().get(0);
173	AddConnectionContext connCtx = new AddConnectionContext(sourceAnchor, targetAnchor);
174	connCtx.setNewObject(connPart);
175	IAddFeature fcfp = getDiagramTypeProvider().getFeatureProvider().getAddFeature(connCtx);
176
177	Connection conn = (Connection)fcfp.add(connCtx);
178	if (conn instanceof FreeFormConnection &&
179	diagramGeometry.getConnectionBendpoints(connPart) != null)
180	{
181	FreeFormConnection freeConn = (FreeFormConnection)conn;
182	List<org.eclipse.sapphire.ui.diagram.editor.DiagramGeometryWrapper.Point> bps =
183	diagramGeometry.getConnectionBendpoints(connPart);
184	List<Point> bendpoints = freeConn.getBendpoints();
185	int index = 0;
186	for (org.eclipse.sapphire.ui.diagram.editor.DiagramGeometryWrapper.Point pt : bps)
187	{
188	Point newPoint = Graphiti.getGaService().createPoint(pt.x, pt.y);
189	bendpoints.add(index++, newPoint);
190	}
191	}
192	}
193	}
194	}
195	}
196	}
197
198	private DiagramNodePart getDiagramNode(IModelElement endpoint)
199	{
200	for (DiagramNodeTemplate nodeTemplate : this.diagramPart.getNodeTemplates())
201	{
202	for (DiagramNodePart nodePart : nodeTemplate.getDiagramNodes())
203	{
204	IModelElement element = nodePart.getLocalModelElement();
205	if (element == endpoint)
206	{
207	return nodePart;
208	}
209	}
210	}
211	return null;
212	}
213
214	private ContainerShape getContainerShape(Object bo)
215	{
216	ContainerShape containerShape = null;
217	PictogramElement [] pictograms =
218	getDiagramTypeProvider().getFeatureProvider().getAllPictogramElementsForBusinessObject(bo);
219	for (PictogramElement pictogram : pictograms)
220	{
221	if (pictogram instanceof ContainerShape)
222	{
223	containerShape = (ContainerShape)pictogram;
224	break;
225	}
226	}
227	return containerShape;
228	}
229
230	}

Added Link Here

(-)src/org/eclipse/sapphire/ui/diagram/graphiti/editor/SapphireDiagramEditorFactory.java (+119 lines)
1	package org.eclipse.sapphire.ui.diagram.graphiti.editor;
2
3	import java.io.ByteArrayInputStream;
4	import java.io.IOException;
5	import java.util.Iterator;
6
7	import org.eclipse.core.resources.IFile;
8	import org.eclipse.core.resources.IFolder;
9	import org.eclipse.core.resources.IProject;
10	import org.eclipse.core.runtime.CoreException;
11	import org.eclipse.core.runtime.Path;
12	import org.eclipse.emf.common.util.EList;
13	import org.eclipse.emf.common.util.URI;
14	import org.eclipse.emf.ecore.EObject;
15	import org.eclipse.emf.ecore.resource.Resource;
16	import org.eclipse.emf.ecore.resource.ResourceSet;
17	import org.eclipse.emf.transaction.TransactionalEditingDomain;
18	import org.eclipse.graphiti.mm.pictograms.Diagram;
19	import org.eclipse.graphiti.services.Graphiti;
20	import org.eclipse.graphiti.ui.editor.DiagramEditorFactory;
21	import org.eclipse.graphiti.ui.internal.services.GraphitiUiInternal;
22	import org.eclipse.graphiti.ui.services.GraphitiUi;
23	import org.eclipse.sapphire.modeling.util.internal.FileUtil;
24	import org.eclipse.sapphire.ui.diagram.graphiti.GraphitiFileService;
25	import org.eclipse.ui.IEditorInput;
26	import org.eclipse.ui.IFileEditorInput;
27
28	public class SapphireDiagramEditorFactory
29	{
30	public static final String SAPPHIRE_DIAGRAM_TYPE = "sapphireDiagram";
31
32	public static SapphireDiagramEditorInput createEditorInput(IEditorInput otherInput)
33	throws CoreException
34	{
35	if (otherInput instanceof SapphireDiagramEditorInput)
36	{
37	return (SapphireDiagramEditorInput)otherInput;
38	}
39	else if (otherInput instanceof IFileEditorInput)
40	{
41	final IFileEditorInput fileInput = (IFileEditorInput) otherInput;
42	final IFile file = fileInput.getFile();
43	final IProject project = file.getProject();
44
45	final IFolder diagramFolder = project.getFolder(".settings/diagrams/");
46	String fileName = file.getName();
47	if (fileName.endsWith(".xml"))
48	{
49	fileName = fileName.substring(0, fileName.indexOf(".xml"));
50	}
51
52	TransactionalEditingDomain domain = null;
53	ResourceSet resourceSet = null;
54	Diagram diagram = null;
55	URI diagramFileUri = null;
56
57	// create diagram file if it doesn't exist
58	final IFile diagramFile = diagramFolder.getFile(fileName + ".xmi");
59	if (!diagramFile.exists())
60	{
61	FileUtil.mkdirs( diagramFile.getParent().getLocation().toFile() );
62	diagramFile.create( new ByteArrayInputStream(new byte[0]), true, null );
63
64	// Create Diagram Obj
65	diagram = Graphiti.getPeCreateService().createDiagram(
66	SAPPHIRE_DIAGRAM_TYPE, fileName, 10, false);
67	diagramFileUri = URI.createPlatformResourceURI(diagramFile.getFullPath().toString(), true);
68	domain = GraphitiFileService.createEmfFileForDiagram(diagramFileUri, diagram);
69	}
70	else
71	{
72	domain = DiagramEditorFactory.createResourceSetAndEditingDomain();
73	resourceSet = domain.getResourceSet();
74
75	diagramFileUri = GraphitiUiInternal.getEmfService().getFileURI(diagramFile, resourceSet);
76	if (diagramFileUri != null)
77	{
78	final Resource resource = resourceSet.createResource(diagramFileUri);
79	try
80	{
81	resource.load(null);
82	}
83	catch (IOException ie)
84	{
85	ie.printStackTrace();
86	}
87	EList<EObject> objs = resource.getContents();
88	Iterator<EObject> it = objs.iterator();
89	while (it.hasNext())
90	{
91	EObject obj = it.next();
92	if ((obj == null) && !Diagram.class.isInstance(obj))
93	continue;
94	diagram = (Diagram)obj;
95	break;
96	}
97	}
98	}
99	// create diagram node position file if it doesn't exist
100	IFile nodePosFile = diagramFile.getParent().getFile(new Path(fileName + ".np"));
101	if (!nodePosFile.exists())
102	{
103	nodePosFile.create( new ByteArrayInputStream(new byte[0]), true, null );
104	}
105
106	// create sapphire diagram editor input
107	if (diagram != null)
108	{
109	String providerId = GraphitiUi.getExtensionManager().getDiagramTypeProviderId(diagram.getDiagramTypeId());
110	final SapphireDiagramEditorInput diagramEditorInput =
111	SapphireDiagramEditorInput.createEditorInput(diagram, domain, providerId, false);
112	diagramEditorInput.setNodePositionFile(nodePosFile);
113	return diagramEditorInput;
114	}
115	}
116	return null;
117	}
118
119	}

Added Link Here

(-)src/org/eclipse/sapphire/ui/diagram/graphiti/features/SapphireAddBendpointFeature.java (+33 lines)
1	package org.eclipse.sapphire.ui.diagram.graphiti.features;
2
3	import org.eclipse.graphiti.features.IFeatureProvider;
4	import org.eclipse.graphiti.features.context.IAddBendpointContext;
5	import org.eclipse.graphiti.features.impl.DefaultAddBendpointFeature;
6	import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
7	import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionPart;
8	import org.eclipse.sapphire.ui.diagram.editor.DiagramGeometryWrapper;
9	import org.eclipse.sapphire.ui.diagram.graphiti.providers.SapphireDiagramFeatureProvider;
10
11	public class SapphireAddBendpointFeature extends DefaultAddBendpointFeature
12	{
13	public SapphireAddBendpointFeature(IFeatureProvider fp)
14	{
15	super(fp);
16	}
17
18	@Override
19	public void addBendpoint(IAddBendpointContext context)
20	{
21	super.addBendpoint(context);
22
23	FreeFormConnection freeFormConnection = context.getConnection();
24	Object bo = getBusinessObjectForPictogramElement(freeFormConnection);
25	if (bo instanceof DiagramConnectionPart)
26	{
27	DiagramGeometryWrapper dg =
28	((SapphireDiagramFeatureProvider)getFeatureProvider()).getDiagramGeometry();
29	dg.addConnectionBendpoint((DiagramConnectionPart)bo,
30	context.getBendpointIndex(), context.getX(), context.getY());
31	}
32	}
33	}

Added Link Here

(-)src/org/eclipse/sapphire/ui/diagram/graphiti/features/SapphireAddConnectionFeature.java (+97 lines)
1	package org.eclipse.sapphire.ui.diagram.graphiti.features;
2
3	import org.eclipse.graphiti.features.IDirectEditingInfo;
4	import org.eclipse.graphiti.features.IFeatureProvider;
5	import org.eclipse.graphiti.features.context.IAddConnectionContext;
6	import org.eclipse.graphiti.features.context.IAddContext;
7	import org.eclipse.graphiti.features.impl.AbstractAddFeature;
8	import org.eclipse.graphiti.mm.GraphicsAlgorithmContainer;
9	import org.eclipse.graphiti.mm.algorithms.Polygon;
10	import org.eclipse.graphiti.mm.algorithms.Polyline;
11	import org.eclipse.graphiti.mm.algorithms.Text;
12	import org.eclipse.graphiti.mm.pictograms.Connection;
13	import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;
14	import org.eclipse.graphiti.mm.pictograms.PictogramElement;
15	import org.eclipse.graphiti.services.Graphiti;
16	import org.eclipse.graphiti.services.IGaService;
17	import org.eclipse.graphiti.services.IPeCreateService;
18	import org.eclipse.graphiti.util.IColorConstant;
19	import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionPart;
20
21	public class SapphireAddConnectionFeature extends AbstractAddFeature
22	{
23	public SapphireAddConnectionFeature(IFeatureProvider fp)
24	{
25	super(fp);
26	}
27
28	public boolean canAdd(IAddContext context)
29	{
30	// return true if given business object is an DiagramConnectionPart
31	// note, that the context must be an instance of IAddConnectionContext
32	if (context instanceof IAddConnectionContext &&
33	context.getNewObject() instanceof DiagramConnectionPart)
34	{
35	return true;
36	}
37	return false;
38	}
39
40	public PictogramElement add(IAddContext context)
41	{
42	IAddConnectionContext addConContext = (IAddConnectionContext) context;
43	DiagramConnectionPart connectionPart = (DiagramConnectionPart) context.getNewObject();
44
45	IPeCreateService peCreateService = Graphiti.getPeCreateService();
46	// CONNECTION WITH POLYLINE
47	Connection connection = peCreateService.createFreeFormConnection(getDiagram());
48	connection.setStart(addConContext.getSourceAnchor());
49	connection.setEnd(addConContext.getTargetAnchor());
50
51	IGaService gaService = Graphiti.getGaService();
52	Polyline polyline = gaService.createPolyline(connection);
53	polyline.setForeground(manageColor(IColorConstant.BLACK));
54	polyline.setLineWidth(1);
55
56	// create link and wire it
57	link(connection, connectionPart);
58
59	// add dynamic text decorator for the reference name
60	ConnectionDecorator textDecorator = peCreateService.createConnectionDecorator(connection, true, 0.5, true);
61	Text text = gaService.createDefaultText(textDecorator);
62	text.setForeground(manageColor(IColorConstant.BLACK));
63	gaService.setLocation(text, 10, 0);
64
65	text.setValue(connectionPart.getLabel());
66
67	// add static graphical decorators (composition and navigable)
68	ConnectionDecorator cd;
69	cd = peCreateService.createConnectionDecorator(connection, false, 1.0, true);
70	createArrow(cd);
71
72	// provide information to support direct-editing directly
73
74	// after object creation (must be activated additionally)
75	IDirectEditingInfo directEditingInfo = getFeatureProvider().getDirectEditingInfo();
76
77	// set container shape for direct editing after object creation
78	directEditingInfo.setMainPictogramElement(connection);
79
80	// set shape and graphics algorithm where the editor for
81	// direct editing shall be opened after object creation
82	directEditingInfo.setPictogramElement(textDecorator);
83	directEditingInfo.setGraphicsAlgorithm(text);
84
85	return connection;
86	}
87
88	private Polygon createArrow(GraphicsAlgorithmContainer gaContainer)
89	{
90	Polygon polygon = Graphiti.getGaCreateService().createPolygon(gaContainer, new int[] { -8, 4, 0, 0, -8, -4, -5, 0 });
91	polygon.setBackground(manageColor(IColorConstant.BLACK));
92	//polygon.setStyle(StyleUtil.getStyleForADFView(getDiagram()));
93	polygon.setFilled(true);
94	return polygon;
95	}
96
97	}

Added Link Here

(-)src/org/eclipse/sapphire/ui/diagram/graphiti/providers/SapphireDiagramToolBehaviorProvider.java (+25 lines)
1	package org.eclipse.sapphire.ui.diagram.graphiti.providers;
2
3	import org.eclipse.graphiti.dt.IDiagramTypeProvider;
4	import org.eclipse.graphiti.mm.pictograms.PictogramElement;
5	import org.eclipse.graphiti.tb.DefaultToolBehaviorProvider;
6	import org.eclipse.graphiti.tb.IContextButtonPadData;
7
8
9	public class SapphireDiagramToolBehaviorProvider extends DefaultToolBehaviorProvider
10	{
11	public SapphireDiagramToolBehaviorProvider(IDiagramTypeProvider dtp)
12	{
13	super(dtp);
14	}
15
16	/**
17	* Override super class impl to not include "Remove"
18	*/
19	@Override
20	protected void setGenericContextButtons(IContextButtonPadData data, PictogramElement pe, int identifiers)
21	{
22	identifiers -= CONTEXT_BUTTON_REMOVE;
23	super.setGenericContextButtons(data, pe, identifiers);
24	}
25	}

Added Link Here

(-)src/org/eclipse/sapphire/ui/diagram/graphiti/providers/SapphireDiagramTypeProvider.java (+60 lines)
1	package org.eclipse.sapphire.ui.diagram.graphiti.providers;
2
3	import org.eclipse.graphiti.dt.AbstractDiagramTypeProvider;
4	import org.eclipse.graphiti.mm.pictograms.Diagram;
5	import org.eclipse.graphiti.platform.IDiagramEditor;
6	import org.eclipse.graphiti.tb.IToolBehaviorProvider;
7	import org.eclipse.sapphire.ui.diagram.editor.SapphireDiagramEditorPart;
8	import org.eclipse.sapphire.ui.diagram.graphiti.editor.SapphireDiagramEditor;
9
10	public class SapphireDiagramTypeProvider extends AbstractDiagramTypeProvider
11	{
12	private SapphireDiagramEditorPart diagramPart;
13	private SapphireDiagramFeatureProvider featureProvider;
14	private IToolBehaviorProvider[] toolBehaviorProviders;
15
16	public SapphireDiagramTypeProvider()
17	{
18	this.featureProvider =
19	new SapphireDiagramFeatureProvider(this, new SapphireDiagramSolver());
20	setFeatureProvider(this.featureProvider);
21	}
22
23	public void setDiagramPart(SapphireDiagramEditorPart diagramPart)
24	{
25	this.diagramPart = diagramPart;
26	this.featureProvider.setDiagramPart(diagramPart);
27	}
28
29	public SapphireDiagramEditorPart getDiagramPart()
30	{
31	return this.diagramPart;
32	}
33
34	@Override
35	public void init(Diagram diagram, IDiagramEditor diagramEditor)
36	{
37	super.init(diagram, diagramEditor);
38	setDiagramPart(((SapphireDiagramEditor)diagramEditor).getDiagramEditorPart());
39	}
40
41	@Override
42	public IToolBehaviorProvider[] getAvailableToolBehaviorProviders()
43	{
44	if (this.toolBehaviorProviders == null)
45	{
46	this.toolBehaviorProviders =
47	new IToolBehaviorProvider[] { new SapphireDiagramToolBehaviorProvider(this) };
48	}
49	return this.toolBehaviorProviders;
50	}
51
52	@Override
53	public void postInit()
54	{
55	SapphireDiagramEditor sapphireEditor = (SapphireDiagramEditor)getDiagramEditor();
56	sapphireEditor.syncDiagramWithModel();
57	sapphireEditor.doSave(null);
58	}
59
60	}