Attachment #184197 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>
    </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>
    </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.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;
	}
}

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();
    
}




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 );
	
}




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 String label;
	private IDiagramConnectionEndpointDef endpoint1Def;
	private IDiagramConnectionEndpointDef endpoint2Def;
	private IModelElement endpoint1Model;
	private IModelElement endpoint2Model;
	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();
        Function labelFunction = initExpression
        ( 
            this.definition.getLabel().getLocalizedText(), 
            new Runnable()
            {
                public void run()
                {
                }
            }
        );
        this.label = (String)labelFunction.value();
        labelFunction.dispose();
        
        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()
	{
		return this.label;
	}
    
	@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.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;
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 String label;
	private Function labelFunction;
	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()
                {
                	refreshLabel();
                }
            }
        );
        refreshLabel();
        this.labelProperty = FunctionUtil.getFunctionProperty(this.modelElement, this.labelFunction);
        if (this.labelProperty == null)
        {
        	throw new RuntimeException( "Label function does not contain a property.");
        }
    }
    
    public DiagramNodeTemplate getDiagramNodeTemplate()
    {
    	return this.nodeTemplate;
    }
    
    public IModelElement getLocalModelElement()
    {
        return this.modelElement;
    }    
        
	@Override
	public void render(SapphireRenderingContext context)
	{
		throw new UnsupportedOperationException();
	}

	public String getLabel()
	{
		return this.label;
	}

	public void setLabel(String newValue)
	{
		if (this.labelProperty != null)
		{
			this.modelElement.write(this.labelProperty, newValue);
			refreshLabel();
		}
	}
	
    private void refreshLabel()
    {        
        if( this.labelFunction != null )
        {
            this.label = (String) this.labelFunction.value();
        }
        
        if( this.label == null )
        {
        	this.label = "#null#";
        }
        else
        {
        	this.label = this.label.trim();
        }        
    }
	
}




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.runtime.CoreException;
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 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());
        }
        catch( CoreException 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 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.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 org.eclipse.gef.DefaultEditDomain;
import org.eclipse.graphiti.ui.editor.DiagramEditor;
import org.eclipse.sapphire.ui.diagram.editor.SapphireDiagramEditorPart;

public class SapphireDiagramEditor extends DiagramEditor 
{
	private SapphireDiagramEditorPart diagramPart;
	
	public SapphireDiagramEditor(SapphireDiagramEditorPart diagramPart)
	{
		this.diagramPart = diagramPart;
		DefaultEditDomain ded = new DefaultEditDomain( this );
	}
	
	public SapphireDiagramEditorPart getDiagramEditorPart()
	{
		return this.diagramPart;
	}
}




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.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.DiagramNodePart;

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);
        
		return null;
	}

}




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 EClass 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 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 IADFView, 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 name of the EClass
		PictogramElement pe = context.getPictogramElement();
		DiagramNodePart nodePart = (DiagramNodePart)getBusinessObjectForPictogramElement(pe);
		return nodePart.getLabel();
	}

	public void setValue(String value, IDirectEditingContext context) 
	{
		// set the new id for the adf view
		PictogramElement pe = context.getPictogramElement();
				
		if (pe.eContainer() instanceof Shape)
		{
			DiagramNodePart nodePart = (DiagramNodePart)getBusinessObjectForPictogramElement(pe);
			String oldValue = nodePart.getLabel();
			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 adf view
		updatePictogramElement(((Shape)pe).getContainer());

	}

}




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.IAddFeature;
import org.eclipse.graphiti.features.ICreateConnectionFeature;
import org.eclipse.graphiti.features.ICreateFeature;
import org.eclipse.graphiti.features.IDirectEditingFeature;
import org.eclipse.graphiti.features.IUpdateFeature;
import org.eclipse.graphiti.features.context.IAddContext;
import org.eclipse.graphiti.features.context.IDirectEditingContext;
import org.eclipse.graphiti.features.context.IUpdateContext;
import org.eclipse.graphiti.features.impl.IIndependenceSolver;
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.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.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.SapphireDirectEditNodeFeature;
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;
	}
	
	@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);
		}
		
		return super.getDirectEditingFeature(context);		
	}
	
	@Override
	public IUpdateFeature getUpdateFeature(IUpdateContext context) 
	{
		PictogramElement pictogramElement = context.getPictogramElement();
		if (pictogramElement instanceof ContainerShape) 
		{
			Object bo = getBusinessObjectForPictogramElement(pictogramElement);
			if (bo instanceof DiagramNodePart) 
			{
				return new SapphireUpdateNodeFeature(this);
			}
		}
		return super.getUpdateFeature(context);
	}	
}




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.AbstractDiagramTypeProvider;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.graphiti.platform.IDiagramEditor;
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;
	
	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());
	}
}

Return to bug 330482

Added Link Here

(-)sdef/MapEditor.sdef (+65 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	</node>
20	<connection>
21	<id>connections</id>
22	<tool-palette-label>Route</tool-palette-label>
23	<tool-palette-desc>Map Route</tool-palette-desc>
24	<property>Routes</property>
25	<label>${ Distance == null ? "<Distance>" : Distance }</label>
26	<endpoint1>
27	<property>FromDestination</property>
28	<value>${Name}</value>
29	<type>NONE</type>
30	</endpoint1>
31	<endpoint2>
32	<property>ToDestination</property>
33	<value>${Name}</value>
34	<type>ARROW</type>
35	</endpoint2>
36	</connection>
37	</diagram-page>
38
39	<editor-page>
40	<id>overview</id>
41	<page-name>Overview</page-name>
42	<page-header-text>Overview</page-header-text>
43	<root-node>
44	<node>
45	<label>Destinations</label>
46	<section>
47	<description>Destinations in the map</description>
48	<content>
49	<property-editor>Destinations</property-editor>
50	</content>
51	</section>
52	</node>
53	<node>
54	<label>Routes</label>
55	<section>
56	<description>Routes in the map</description>
57	<content>
58	<property-editor>Routes</property-editor>
59	</content>
60	</section>
61	</node>
62	</root-node>
63	</editor-page>
64	</definition>
65

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

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 (+91 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	}

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 (+177 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 String label;
21	private IDiagramConnectionEndpointDef endpoint1Def;
22	private IDiagramConnectionEndpointDef endpoint2Def;
23	private IModelElement endpoint1Model;
24	private IModelElement endpoint2Model;
25	private Function endpoint1Function;
26	private Function endpoint2Function;
27
28	public DiagramConnectionPart(DiagramConnectionTemplate connectionTemplate)
29	{
30	this.connectionTemplate = connectionTemplate;
31	}
32
33	@Override
34	protected void init()
35	{
36	super.init();
37
38	this.definition = (IDiagramConnectionDef)super.definition;
39	this.modelElement = getModelElement();
40	Function labelFunction = initExpression
41	(
42	this.definition.getLabel().getLocalizedText(),
43	new Runnable()
44	{
45	public void run()
46	{
47	}
48	}
49	);
50	this.label = (String)labelFunction.value();
51	labelFunction.dispose();
52
53	this.endpoint1Def = this.definition.getEndpoint1().element();
54	this.endpoint2Def = this.definition.getEndpoint2().element();
55	this.endpoint1Model = processEndpoint(this.endpoint1Def);
56	this.endpoint2Model = processEndpoint(this.endpoint2Def);
57	this.endpoint1Function = initExpression
58	(
59	this.endpoint1Model,
60	this.endpoint1Def.getValue().getContent(),
61	new Runnable()
62	{
63	public void run()
64	{
65	refreshEndpoint1();
66	}
67	}
68	);
69	this.endpoint2Function = initExpression
70	(
71	this.endpoint2Model,
72	this.endpoint2Def.getValue().getContent(),
73	new Runnable()
74	{
75	public void run()
76	{
77	refreshEndpoint2();
78	}
79	}
80	);
81	}
82
83	public DiagramConnectionTemplate getDiagramConnectionTemplate()
84	{
85	return this.connectionTemplate;
86	}
87
88	public IModelElement getLocalModelElement()
89	{
90	return this.modelElement;
91	}
92
93	public IModelElement getEndpoint1()
94	{
95	return this.endpoint1Model;
96	}
97
98	public IModelElement getEndpoint2()
99	{
100	return this.endpoint2Model;
101	}
102
103	public String getLabel()
104	{
105	return this.label;
106	}
107
108	@Override
109	public void render(SapphireRenderingContext context)
110	{
111	throw new UnsupportedOperationException();
112	}
113
114	public void refreshEndpoint1()
115	{
116	if (this.endpoint1Function != null)
117	{
118	Object value = this.endpoint1Function.value();
119	String property = this.endpoint1Def.getProperty().getContent();
120	setModelProperty(this.modelElement, property, value);
121	}
122	}
123
124	public void refreshEndpoint2()
125	{
126	if (this.endpoint2Function != null)
127	{
128	Object value = this.endpoint2Function.value();
129	String property = this.endpoint2Def.getProperty().getContent();
130	setModelProperty(this.modelElement, property, value);
131	}
132	}
133
134	private IModelElement processEndpoint(IDiagramConnectionEndpointDef endpointDef)
135	{
136	String propertyName = endpointDef.getProperty().getContent();
137	ModelProperty modelProperty = resolve(this.modelElement, propertyName);
138	if (!(modelProperty instanceof ValueProperty))
139	{
140	throw new RuntimeException( "Property " + propertyName + " not a ValueProperty");
141	}
142	ValueProperty property = (ValueProperty)modelProperty;
143	Value<?> valObj = this.modelElement.read(property);
144	if (!(valObj instanceof ReferenceValue))
145	{
146	throw new RuntimeException( "Property " + propertyName + " value not a reference");
147	}
148	ReferenceValue<?> refVal = (ReferenceValue<?>)valObj;
149	Object targetObj = refVal.resolve();
150	if (!(targetObj instanceof IModelElement))
151	{
152	throw new RuntimeException( "Target not an IModelElement");
153	}
154	return (IModelElement)targetObj;
155	}
156
157	private void setModelProperty(final IModelElement modelElement,
158	String propertyName, Object value)
159	{
160	if (propertyName != null)
161	{
162	final ModelElementType type = modelElement.getModelElementType();
163	final ModelProperty property = type.getProperty( propertyName );
164	if( property == null )
165	{
166	throw new RuntimeException( "Could not find property " + propertyName + " in " + type.getQualifiedName() );
167	}
168	if (!(property instanceof ValueProperty))
169	{
170	throw new RuntimeException( "Property " + propertyName + " not a ValueProperty");
171	}
172
173	modelElement.write((ValueProperty)property, value);
174	}
175	}
176
177	}

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/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 (+21 lines)
1	package org.eclipse.sapphire.ui.diagram.graphiti.editor;
2
3	import org.eclipse.gef.DefaultEditDomain;
4	import org.eclipse.graphiti.ui.editor.DiagramEditor;
5	import org.eclipse.sapphire.ui.diagram.editor.SapphireDiagramEditorPart;
6
7	public class SapphireDiagramEditor extends DiagramEditor
8	{
9	private SapphireDiagramEditorPart diagramPart;
10
11	public SapphireDiagramEditor(SapphireDiagramEditorPart diagramPart)
12	{
13	this.diagramPart = diagramPart;
14	DefaultEditDomain ded = new DefaultEditDomain( this );
15	}
16
17	public SapphireDiagramEditorPart getDiagramEditorPart()
18	{
19	return this.diagramPart;
20	}
21	}

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/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/SapphireDiagramTypeProvider.java (+38 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.sapphire.ui.diagram.editor.SapphireDiagramEditorPart;
7	import org.eclipse.sapphire.ui.diagram.graphiti.editor.SapphireDiagramEditor;
8
9	public class SapphireDiagramTypeProvider extends AbstractDiagramTypeProvider
10	{
11	private SapphireDiagramEditorPart diagramPart;
12	private SapphireDiagramFeatureProvider featureProvider;
13
14	public SapphireDiagramTypeProvider()
15	{
16	this.featureProvider =
17	new SapphireDiagramFeatureProvider(this, new SapphireDiagramSolver());
18	setFeatureProvider(this.featureProvider);
19	}
20
21	public void setDiagramPart(SapphireDiagramEditorPart diagramPart)
22	{
23	this.diagramPart = diagramPart;
24	this.featureProvider.setDiagramPart(diagramPart);
25	}
26
27	public SapphireDiagramEditorPart getDiagramPart()
28	{
29	return this.diagramPart;
30	}
31
32	@Override
33	public void init(Diagram diagram, IDiagramEditor diagramEditor)
34	{
35	super.init(diagram, diagramEditor);
36	setDiagramPart(((SapphireDiagramEditor)diagramEditor).getDiagramEditorPart());
37	}
38	}