Attachment #186532 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




      id="org.eclipse.sapphire.samples.ezbug.ui.BugDatabaseEditor"
      name="Bug Database Editor (Sapphire Sample)"/>
  </extension>

  <extension point="org.eclipse.ui.editors">
    <editor
      class="org.eclipse.sapphire.samples.map.ui.MapEditor"
      default="true"
      filenames="map.xml"
      id="org.eclipse.sapphire.samples.map.ui.MapEditor"
      name="Map Editor"/>
  </extension>
  
  <extension point="org.eclipse.ui.editors">
    <editor
      class="org.eclipse.sapphire.samples.library.ui.LibraryEditor"
      default="true"
      filenames="library.xml"
      id="org.eclipse.sapphire.samples.library.ui.LibraryEditor"
      name="Library Editor"/>
  </extension>

  
</plugin>




<definition>

  <import>
    <bundle>org.eclipse.sapphire.samples</bundle>
    <package>org.eclipse.sapphire.samples.library</package>
    <package>org.eclipse.sapphire.samples.library.ui</package>
    <package>org.eclipse.sapphire.samples.library.internal</package>
  </import>
  
  <diagram-page>
    <id>diagram</id>
    <page-name>Diagram</page-name>
    <page-header-text>Diagram</page-header-text>
    <node>
      <hint><name>width</name><value>95</value></hint>
      <hint><name>height</name><value>85</value></hint>
      <hint><name>resizable</name><value>false</value></hint>    
      <id>books</id>
      <tool-palette-label>Book</tool-palette-label>
      <tool-palette-desc>Book</tool-palette-desc>
      <property>Books</property>
      <image>
        <id>bookImage</id>
        <path>images/book.png</path>
        <hint><name>x</name><value>0</value></hint>
        <hint><name>y</name><value>0</value></hint>
        <hint><name>width</name><value>64</value></hint>
        <hint><name>height</name><value>64</value></hint>
      </image>
      <label>
        <content>${Title == null ? "&lt;Title&gt;" : Title}</content>
        <hint><name>x</name><value>0</value></hint>
        <hint><name>y</name><value>70</value></hint>
        <hint><name>height</name><value>15</value></hint>
      </label>
      <instance-id>${Title}</instance-id>
      <connection>
        <id>connections</id>
        <tool-palette-label>Book Reference</tool-palette-label>
        <tool-palette-desc>Book Reference</tool-palette-desc>
        <property>ReferencedBooks</property>
        <label>
          <content>Reference</content>
        </label>
        <endpoint>
          <property>ReferencedBook</property>
          <value>${Title}</value>
          <type>ARROW</type>
        </endpoint>
        <instance-id>${ReferencedBook}</instance-id>
      </connection>
    </node>
  </diagram-page>
  
  <editor-page>
    <id>overview</id>
    <page-name>Overview</page-name>
    <page-header-text>Overview</page-header-text>
    <root-node>
      <node>
        <label>Books</label>
        <section>
          <description>Books in the library</description>
          <content>
            <property-editor>
              <property>Books</property>
              <child-property>
                <property>Title</property>
              </child-property>
              <child-property>
                <property>Author</property>
              </child-property>
              <hint><name>show.label.above</name><value>true</value></hint>
              <hint>
                <name>column.widths</name>
                <value>150,150</value>
              </hint>
            </property-editor>
            <separator>
              <label>References</label>
            </separator>
            <switching-panel>
              <list-selection-controller>
                <property>Books</property>
              </list-selection-controller>
              <panel>
                <key>IBook</key>
                <content>
                  <property-editor>ReferencedBooks</property-editor>
                </content>          
              </panel>
              <default-panel>
                <content>
                  <label>Select a book above to configure additional properties.</label>
                </content>
              </default-panel>
            </switching-panel>
          </content>  
        </section>
      </node>
    </root-node>
  </editor-page>
  
</definition>




<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>
      <hint><name>width</name><value>70</value></hint>
      <hint><name>height</name><value>85</value></hint>      
      <property>Destinations</property>
      <label>
        <content>${Name == null ? "&lt;Destination&gt;" : Name}</content>
      </label>
      <instance-id>${Name}</instance-id>
    </node>
    <connection>
      <id>connections</id>
      <tool-palette-label>Route</tool-palette-label>
      <tool-palette-desc>Map Route</tool-palette-desc>
      <property>Routes</property>
      <label>
        <content>${Distance == null ? "&lt;Distance&gt;" : Distance}</content>
      </label>
      <endpoint1>
        <property>FromDestination</property>
        <value>${Name}</value>
        <type>NONE</type>
      </endpoint1>
      <endpoint2>
        <property>ToDestination</property>
        <value>${Name}</value>
        <type>ARROW</type>
      </endpoint2>
      <instance-id>${FromDestination}-${ToDestination}</instance-id>
    </connection>
  </diagram-page>
  
  <editor-page>
    <id>overview</id>
    <page-name>Overview</page-name>
    <page-header-text>Overview</page-header-text>
    <root-node>
      <node>
        <label>Destinations</label>
        <section>
          <description>Destinations in the map</description>
          <content>
            <property-editor>Destinations</property-editor>
          </content>
        </section>
      </node>
      <node>
        <label>Routes</label>
        <section>
          <description>Routes in the map</description>
          <content>
            <property-editor>Routes</property-editor>
          </content>
        </section>
      </node>
    </root-node>
  </editor-page>
</definition>
    




package org.eclipse.sapphire.samples.library;

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

@GenerateImpl

public interface IBook extends IModelElement 
{
    ModelElementType TYPE = new ModelElementType( IBook.class );

    // *** Title ***
    
    @XmlBinding( path = "title" )
    @Label( standard = "title" )
    @NonNullValue

    ValueProperty PROP_TITLE = new ValueProperty( TYPE, "Title" );

    Value<String> getTitle();
    void setTitle( String name );

    // *** Author ***
    
    @XmlBinding( path = "Author" )
    @Label( standard = "Author" )
    @NonNullValue

    ValueProperty PROP_AUTHOR = new ValueProperty( TYPE, "Author" );

    Value<String> getAuthor();
    void setAuthor( String author );
    
    // *** ReferencedBooks ***
    
    @Type( base = IBookReference.class )
    @XmlListBinding( mappings = @XmlListBinding.Mapping( element = "referenced-book", type = IBookReference.class ) )
    
    ListProperty PROP_REFERENCED_BOOKS = new ListProperty( TYPE, "ReferencedBooks" );
    
    ModelElementList<IBookReference> getReferencedBooks();
    
}




package org.eclipse.sapphire.samples.library;

import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.ReferenceValue;
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.library.internal.BookReferenceService;

@GenerateImpl

public interface IBookReference extends IModelElement 
{
	ModelElementType TYPE = new ModelElementType( IBookReference.class );
	
	// *** ReferencedBook ***
	
	@Reference( target = IBook.class, service = BookReferenceService.class )
	@XmlBinding( path = "referenced-book")
	@NonNullValue
	@Label(standard = "referenced book")

	ValueProperty PROP_REFERENCED_BOOK = new ValueProperty( TYPE, "ReferencedBook" );

    ReferenceValue<IBook> getReferencedBook();
    void setReferencedBook( String name );
	
}




package org.eclipse.sapphire.samples.library;

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 = "library")

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

    @Type( base = IBook.class )
    @XmlListBinding( mappings = @XmlListBinding.Mapping( element = "book", type = IBook.class ) )
    
    ListProperty PROP_BOOKS = new ListProperty( TYPE, "Books" );
    
    ModelElementList<IBook> getBooks();
	

}




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

import org.eclipse.sapphire.modeling.ModelElementList;
import org.eclipse.sapphire.modeling.ReferenceService;
import org.eclipse.sapphire.samples.library.IBook;
import org.eclipse.sapphire.samples.library.ILibrary;

public class BookReferenceService extends ReferenceService 
{

	@Override
	public Object resolve(String reference) 
	{
		if (reference != null)
		{
			ILibrary library = element().nearest(ILibrary.class);
			ModelElementList<IBook> books = library.getBooks();
			for (IBook book : books)
			{
				if (reference.equals(book.getTitle().getContent()))
				{
					return book;
				}
			}
		}
		return null;
	}

}




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

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.xml.RootXmlResource;
import org.eclipse.sapphire.samples.library.ILibrary;
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 LibraryEditor extends SapphireEditor 
{
	private ILibrary modelLibrary;
	private StructuredTextEditor librarySourceEditor;
	private SapphireDiagramEditorPart libraryDiagramPart;
	private MasterDetailsPage libraryOverviewPage;
	
    public LibraryEditor()
    {
        super( "org.eclipse.sapphire.samples" );
    }

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

	@Override
	protected IModelElement createModel() 
	{
		this.modelLibrary = ILibrary.TYPE.instantiate(new RootXmlResource(new XmlEditorResourceStore(this, this.librarySourceEditor)));
		return this.modelLibrary;
	}

	@Override
	protected void createDiagramPages() throws PartInitException
	{
		IPath path = new Path( "org.eclipse.sapphire.samples/sdef/LibraryEditor.sdef/diagram" );
		this.libraryDiagramPart = new SapphireDiagramEditorPart(this, this.modelLibrary, path);
		SapphireDiagramEditor diagramEditor = this.libraryDiagramPart.getDiagramEditor();
		SapphireDiagramEditorInput diagramEditorInput = this.libraryDiagramPart.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/LibraryEditor.sdef/overview" );
		this.libraryOverviewPage = new MasterDetailsPage(this, this.modelLibrary, path);
        addPage(1, this.libraryOverviewPage);
        setPageText(1, "Overview");
        setPageId(this.pages.get(1), "Overview");		
	}

	public ILibrary getMap()
	{
		return this.modelLibrary;
	}
	
	@Override
	public void doSave( final IProgressMonitor monitor )
	{
		super.doSave(monitor);
		SapphireDiagramEditor diagramEditor = this.libraryDiagramPart.getDiagramEditor();
		diagramEditor.doSave(monitor);
	}
}




package org.eclipse.sapphire.samples.map;

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

@GenerateImpl

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

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

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




package org.eclipse.sapphire.samples.map;

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

@GenerateImpl
@XmlRootBinding( elementName = "map")

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

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




package org.eclipse.sapphire.samples.map;

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

@GenerateImpl

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

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

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

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

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

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

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




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

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

public class DestinationReferenceService extends ReferenceService 
{

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

}




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

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

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

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

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

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

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

Lines 19-25 Link Here

(-)META-INF/MANIFEST.MF (-2 / +12 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 36-42 Link Here
36	org.eclipse.ui.workbench,	38	org.eclipse.ui.workbench,
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,
		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
40	Import-Package: com.ibm.icu.text	50	Import-Package: com.ibm.icu.text
41	Bundle-ActivationPolicy: lazy	51	Bundle-ActivationPolicy: lazy
42	Bundle-RequiredExecutionEnvironment: J2SE-1.5	52	Bundle-RequiredExecutionEnvironment: J2SE-1.5

Lines 14-16 Link Here

(-)plugin.properties (+8 lines)
14	jumpCommandDescription = Shows the entity represented by the text value currently in the field.	14	jumpCommandDescription = Shows the entity represented by the text value currently in the field.
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	<<<<<<< plugin.properties
		18	builderName = Sapphire UI Builder
		19	sapphireDiagramTypeDescription = Sapphire Diagram Type
		20	sapphireDiagramTypeName = Sapphire Diagram Type
		21	sapphireDiagramTypeProviderDescription = Sapphire Diagram Type Provider
		22	sapphireDiagramTypeProviderName = Sapphire Diagram Type Provider
		23	=======
		24	>>>>>>> 1.3




<plugin>

  <extension point="org.eclipse.sapphire.modeling.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"/>
         <imageProvider id="org.eclipse.sapphire.diagram.graphiti.SapphireDiagramImageProvider"/>
      </diagramTypeProvider>
   </extension>
     
   <extension
         point="org.eclipse.graphiti.ui.imageProviders">
      <imageProvider
            class="org.eclipse.sapphire.ui.diagram.graphiti.providers.SapphireDiagramImageProvider"
            id="org.eclipse.sapphire.diagram.graphiti.SapphireDiagramImageProvider">
      </imageProvider>
   </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.el.Function;
import org.eclipse.sapphire.modeling.localization.Localizable;
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 ***
    
    @Type( base = IDiagramLabelDef.class )
    @XmlBinding( path = "label" )
    
    ElementProperty PROP_LABEL = new ElementProperty( TYPE, "Label" );
    
    ModelElementHandle<IDiagramLabelDef> getLabel();

    // *** Endpoint1 ***
    
    @Type( base = IDiagramConnectionEndpointDef.class )
    @XmlBinding( path = "endpoint1" )

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

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

    ElementProperty PROP_ENDPOINT_2 = new ElementProperty( TYPE, "Endpoint2" );
    
    ModelElementHandle<IDiagramConnectionEndpointDef> getEndpoint2();
    
    // *** InstanceId ***
    
    @Type( base = Function.class )
    @Label( standard = "instance id" )
    @Localizable
    @XmlBinding( path = "instance-id" )
    
    ValueProperty PROP_INSTANCE_ID = new ValueProperty( TYPE, "InstanceId" );
    
    Value<Function> getInstanceId();
    void setInstanceId( String value );
    void setInstanceId( Function 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.annotations.Type;
import org.eclipse.sapphire.modeling.el.Function;
import org.eclipse.sapphire.modeling.localization.Localizable;
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 ***

    @Type( base = Function.class )
    @Label( standard = "value" )
    @Localizable
    @XmlBinding( path = "value" )
    
    ValueProperty PROP_VALUE = new ValueProperty( TYPE, "Value" );
    
    Value<Function> getValue();
    void setValue( String value );
    void setValue( Function value );
        
	// *** Type ***
	
	@Type( base = ConnectionEndpointType.class )
	@XmlBinding( path = "type" )
	
	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.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.el.Function;
import org.eclipse.sapphire.modeling.localization.Localizable;
import org.eclipse.sapphire.modeling.xml.annotations.XmlBinding;
import org.eclipse.sapphire.ui.def.ISapphirePartDef;

@GenerateImpl

public interface IDiagramEmbeddedConnectionDef 

	extends ISapphirePartDef
	
{
	ModelElementType TYPE = new ModelElementType( IDiagramEmbeddedConnectionDef.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 ***
    
    @Type( base = IDiagramLabelDef.class )
    @XmlBinding( path = "label" )
    
    ElementProperty PROP_LABEL = new ElementProperty( TYPE, "Label" );
    
    ModelElementHandle<IDiagramLabelDef> getLabel();
    	    
    // *** Endpoint ***
    
    @Type( base = IDiagramConnectionEndpointDef.class )
    @XmlBinding( path = "endpoint" )

    ElementProperty PROP_ENDPOINT = new ElementProperty( TYPE, "Endpoint" );
    
    ModelElementHandle<IDiagramConnectionEndpointDef> getEndpoint();

    // *** InstanceId ***
    
    @Type( base = Function.class )
    @Label( standard = "instance id" )
    @Localizable
    @XmlBinding( path = "instance-id" )
    
    ValueProperty PROP_INSTANCE_ID = new ValueProperty( TYPE, "InstanceId" );
    
    Value<Function> getInstanceId();
    void setInstanceId( String value );
    void setInstanceId( Function 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.annotations.Type;
import org.eclipse.sapphire.modeling.el.Function;
import org.eclipse.sapphire.modeling.localization.Localizable;
import org.eclipse.sapphire.modeling.xml.annotations.XmlBinding;
import org.eclipse.sapphire.ui.def.ISapphirePartDef;

@GenerateImpl

public interface IDiagramLabelDef 

	extends ISapphirePartDef
	
{
	ModelElementType TYPE = new ModelElementType( IDiagramLabelDef.class );
	
    // *** Content ***
    
    @Type( base = Function.class )
    @Label( standard = "content" )
    @Localizable
    @XmlBinding( path = "content" )
    
    ValueProperty PROP_CONTENT = new ValueProperty( TYPE, "Content" );
    
    Value<Function> getContent();
    void setContent( String value );
    void setContent( Function value );
    
}




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.el.Function;
import org.eclipse.sapphire.modeling.localization.Localizable;
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 );
    
    // *** Image ***
    
    @Type( base = IDiagramNodeImageDef.class )
    @XmlBinding( path = "image" )

    ElementProperty PROP_IMAGE = new ElementProperty( TYPE, "Image" );
    
    ModelElementHandle<IDiagramNodeImageDef> getImage();
    
    // *** Label ***
    
    @Type( base = IDiagramLabelDef.class )
    @XmlBinding( path = "label" )
    
    ElementProperty PROP_LABEL = new ElementProperty( TYPE, "Label" );
    
    ModelElementHandle<IDiagramLabelDef> getLabel();
    	    
    // *** InstanceId ***
    
    @Type( base = Function.class )
    @Label( standard = "instance id" )
    @Localizable
    @XmlBinding( path = "instance-id" )
    
    ValueProperty PROP_INSTANCE_ID = new ValueProperty( TYPE, "InstanceId" );
    
    Value<Function> getInstanceId();
    void setInstanceId( String value );
    void setInstanceId( Function value );
        
    // *** EmbeddedConnections ***
    
    @Type( base = IDiagramEmbeddedConnectionDef.class )
    @XmlBinding( path = "connection" )

    ElementProperty PROP_EMBEDDED_CONNECTIONS = new ElementProperty( TYPE, "EmbeddedConnections" );
    
    ModelElementHandle<IDiagramEmbeddedConnectionDef> getEmbeddedConnections();
    
}




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 IDiagramNodeImageDef 

	extends ISapphirePartDef 

{
	ModelElementType TYPE = new ModelElementType( IDiagramNodeImageDef.class );
	
    // *** ImageId ***
    
    @Label( standard = "image id" )
    @XmlBinding( path = "id" )
    
    ValueProperty PROP_IMAGE_ID = new ValueProperty( TYPE, "ImageId" );
    
    Value<String> getImageId();
    void setImageId( String Id );

    // *** ImagePath ***
    
    @Label( standard = "image path" )
    @XmlBinding( path = "path" )
    
    ValueProperty PROP_IMAGE_PATH = new ValueProperty( TYPE, "ImagePath" );
    
    Value<String> getImagePath();
    void setImagePath( String path );
	
}




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.emf.transaction.RecordingCommand;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.transaction.util.TransactionUtil;
import org.eclipse.graphiti.features.IAddFeature;
import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.IRemoveFeature;
import org.eclipse.graphiti.features.context.IRemoveContext;
import org.eclipse.graphiti.features.context.impl.AddConnectionContext;
import org.eclipse.graphiti.features.context.impl.RemoveContext;
import org.eclipse.graphiti.features.context.impl.UpdateContext;
import org.eclipse.graphiti.mm.pictograms.Connection;
import org.eclipse.graphiti.mm.pictograms.ContainerShape;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.ModelProperty;
import org.eclipse.sapphire.modeling.ModelPropertyChangeEvent;
import org.eclipse.sapphire.modeling.ModelPropertyListener;
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.modeling.el.FunctionResult;
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 
{
	protected DiagramConnectionTemplate connectionTemplate;
	private IDiagramConnectionDef localDefinition;
	protected IModelElement modelElement;
	private IDiagramConnectionEndpointDef endpoint1Def;
	private IDiagramConnectionEndpointDef endpoint2Def;
	private IModelElement endpoint1Model;
	private IModelElement endpoint2Model;
	protected FunctionResult labelFunctionResult;
	protected ValueProperty labelProperty;
	protected FunctionResult idFunctionResult;
	private FunctionResult endpoint1FunctionResult;
	private FunctionResult endpoint2FunctionResult;
	protected ModelPropertyListener modelPropertyListener;
	
	public DiagramConnectionPart() {}
	
	public DiagramConnectionPart(DiagramConnectionTemplate connectionTemplate)
	{
		this.connectionTemplate = connectionTemplate;
	}
	
    @Override
    protected void init()
    {
        super.init();
        
        this.localDefinition = (IDiagramConnectionDef)super.definition;
        this.modelElement = getModelElement();
        this.labelFunctionResult = initExpression
        ( 
        	this.modelElement,
        	this.localDefinition.getLabel().element().getContent(), 
            new Runnable()
            {
                public void run()
                {
                	refreshLabel();
                }
            }
        );
        
        this.labelProperty = FunctionUtil.getFunctionProperty(this.modelElement, 
        		this.labelFunctionResult);
        
        this.idFunctionResult = initExpression
        ( 
        	this.modelElement,
            this.localDefinition.getInstanceId(), 
            new Runnable()
            {
                public void run()
                {
                }
            }
        );
        
        this.endpoint1Def = this.localDefinition.getEndpoint1().element();        
        this.endpoint1Model = processEndpoint(this.endpoint1Def);
        if (this.endpoint1Model != null)
        {
	        this.endpoint1FunctionResult = initExpression
	        (
	        	this.endpoint1Model, 
	        	this.endpoint1Def.getValue(), 
	            new Runnable()
	        	{
		            public void run()
		            {
		            	refreshEndpoint1();
		            }
	        	}
	        );
        }
        
        this.endpoint2Def = this.localDefinition.getEndpoint2().element();
        this.endpoint2Model = processEndpoint(this.endpoint2Def);
        if (this.endpoint2Model != null)
        {
	        this.endpoint2FunctionResult = initExpression
	        (
	        	this.endpoint2Model, 
	        	this.endpoint2Def.getValue(), 
	            new Runnable()
	        	{
		            public void run()
		            {
		            	refreshEndpoint2();
		            }
	        	}
	        );
        }        
        
        // Add model property listener
        this.modelPropertyListener = new ModelPropertyListener()
        {
            @Override
            public void handlePropertyChangedEvent( final ModelPropertyChangeEvent event )
            {
                handleModelPropertyChange( event );
            }
        };
        addModelListener();        
    }
    
    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 boolean canEditLabel()
    {
    	return this.labelProperty != null;
    }
    
    public String getLabel()
	{
        String label = null;
        
        if( this.labelFunctionResult != null )
        {
            label = (String) this.labelFunctionResult.value();
        }
        
        if( label == null )
        {
            label = "#null#";
        }
        
        return label;
	}
    
    public void setLabel(String newValue)
    {
		if (this.labelProperty != null)
		{
			this.modelElement.write(this.labelProperty, newValue);
		}    	
    }
    
    public void refreshLabel()
    {
		final SapphireDiagramEditorPart diagramEditor = (SapphireDiagramEditorPart)getParentPart();
		final IFeatureProvider fp = 
						diagramEditor.getDiagramEditor().getDiagramTypeProvider().getFeatureProvider();
		final PictogramElement pe = getConnection(fp, this);
		if (pe != null)
		{
			UpdateContext context = new UpdateContext(pe);
			fp.updateIfPossible(context);
		}		
    	
    }
    
    public String getInstanceId()
	{
        String id = null;
        
        if( this.idFunctionResult != null )
        {
            id = (String) this.idFunctionResult.value();
        }
        
        if( id == null )
        {
            id = "#null#";
        }
        
        return id;
	}

    @Override
	public void render(SapphireRenderingContext context)
	{
		throw new UnsupportedOperationException();
	}
	
    @Override
    public void dispose()
    {
        super.dispose();
        if (this.labelFunctionResult != null)
        {
        	this.labelFunctionResult.dispose();
        }
        if (this.idFunctionResult != null)
        {
        	this.idFunctionResult.dispose();
        }
        if (this.endpoint1FunctionResult != null)
        {
        	this.endpoint1FunctionResult.dispose();
        }
        if (this.endpoint2FunctionResult != null)
        {
        	this.endpoint2FunctionResult.dispose();
        }
    }
    
	public void refreshEndpoint1()
	{
		if (this.endpoint1FunctionResult != null)
		{
			Object value = this.endpoint1FunctionResult.value();
			String property = this.endpoint1Def.getProperty().getContent();
			setModelProperty(this.modelElement, property, value);
		}		
	}
	
	public void refreshEndpoint2()
	{
		if (this.endpoint2FunctionResult != null)
		{
			Object value = this.endpoint2FunctionResult.value();
			String property = this.endpoint2Def.getProperty().getContent();
			setModelProperty(this.modelElement, property, value);
		}		
	}

	protected 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();
		return (IModelElement)targetObj;
	}
	
    protected 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);
		}    	
	}
	
    public void addModelListener()
    {
    	this.modelElement.addListener(this.modelPropertyListener, 
    								this.endpoint1Def.getProperty().getContent());
    	this.modelElement.addListener(this.modelPropertyListener, 
									this.endpoint2Def.getProperty().getContent());
    }
    
    public void removeModelListener()
    {
    	this.modelElement.removeListener(this.modelPropertyListener, 
    								this.endpoint1Def.getProperty().getContent());
    	this.modelElement.removeListener(this.modelPropertyListener, 
									this.endpoint2Def.getProperty().getContent());
    }
    
    protected void handleModelPropertyChange(final ModelPropertyChangeEvent event)
    {
    	final ModelProperty property = event.getProperty();
    	    	
    	if (property.getName().equals(this.endpoint1Def.getProperty().getContent()) || 
    			property.getName().equals(this.endpoint2Def.getProperty().getContent()))
    	{
        	SapphireDiagramEditorPart diagramEditor = (SapphireDiagramEditorPart)getParentPart();
    		final IFeatureProvider fp = diagramEditor.getDiagramEditor().getDiagramTypeProvider().getFeatureProvider();
    		final Diagram diagram = diagramEditor.getDiagramEditor().getDiagramTypeProvider().getDiagram();
    		final TransactionalEditingDomain ted = TransactionUtil.getEditingDomain(diagram);

    		removeDiagramConnection(fp, ted);
    		
    		boolean sourceChange = property.getName().equals(this.endpoint1Def.getProperty().getContent()) ? true : false;
    		handleEndpointChange(sourceChange);
			// add new connection to the diagram
    		addNewConnectionIfPossible(fp, ted, diagramEditor);
    	}
    }    
    
    private void handleEndpointChange(boolean sourceChange) 
    {
		if (sourceChange)
		{
			this.endpoint1Model = processEndpoint(this.endpoint1Def);
			if (this.endpoint1FunctionResult != null)
			{
				this.endpoint1FunctionResult.dispose();
				this.endpoint1FunctionResult = null;
			}
	        if (this.endpoint1Model != null)
	        {
		        this.endpoint1FunctionResult = initExpression
		        (
		        	this.endpoint1Model, 
		        	this.endpoint1Def.getValue(), 
		            new Runnable()
		        	{
			            public void run()
			            {
			            	refreshEndpoint1();
			            }
		        	}
		        );
	        }			
		}
		else
		{
			this.endpoint2Model = processEndpoint(this.endpoint2Def);
			if (this.endpoint2FunctionResult != null)
			{
				this.endpoint2FunctionResult.dispose();
				this.endpoint2FunctionResult = null;
			}
	        if (this.endpoint2Model != null)
	        {
		        this.endpoint2FunctionResult = initExpression
		        (
		        	this.endpoint2Model, 
		        	this.endpoint2Def.getValue(), 
		            new Runnable()
		        	{
			            public void run()
			            {
			            	refreshEndpoint2();
			            }
		        	}
		        );
	        }			
		}
    }
    
    protected void removeDiagramConnection(IFeatureProvider fp, TransactionalEditingDomain ted)
    {
		// remove the existing connection pe from the diagram
		if (this.getEndpoint1() != null && this.getEndpoint2() != null)
		{
			PictogramElement pe = getConnection(fp, this);
			if (pe != null)
			{
				final IRemoveContext rc = new RemoveContext(pe);
				final IRemoveFeature removeFeature = fp.getRemoveFeature(rc);
				if (removeFeature != null) 
				{
					ted.getCommandStack().execute(new RecordingCommand(ted) 
					{
						protected void doExecute() 
						{			    					
							removeFeature.remove(rc);
						}
					});
				}
			}
		}    	
    }
    
    protected void addNewConnectionIfPossible(IFeatureProvider fp, TransactionalEditingDomain ted,
    						SapphireDiagramEditorPart diagramEditor)
    {
		// add new connection to the diagram
		if (this.getEndpoint1() != null && this.getEndpoint2() != null)
		{
			DiagramNodePart srcNodePart = diagramEditor.getDiagramNodePart(this.getEndpoint1());
			DiagramNodePart targetNodePart = diagramEditor.getDiagramNodePart(this.getEndpoint2());
			ContainerShape srcNode = getContainerShape(fp, srcNodePart);
			ContainerShape targetNode = getContainerShape(fp, targetNodePart);
			final AddConnectionContext addContext = 
					new AddConnectionContext(srcNode.getAnchors().get(0), targetNode.getAnchors().get(0));
			addContext.setNewObject(this);
			final IAddFeature addFeature = fp.getAddFeature(addContext);
			if (addFeature != null) 
			{
				ted.getCommandStack().execute(new RecordingCommand(ted) 
				{
					protected void doExecute() 
					{			    					
						addFeature.add(addContext);
					}
				});
			}			
		}     	
    }
    
	protected Connection getConnection(IFeatureProvider fp, Object bo)
	{
		PictogramElement [] pictograms = fp.getAllPictogramElementsForBusinessObject(bo);
		for (PictogramElement pictogram : pictograms)
		{
			if (pictogram instanceof Connection)
			{
				return (Connection)pictogram;
			}
		}
		return null;
	}
    
	protected ContainerShape getContainerShape(IFeatureProvider fp, Object bo)
	{
		ContainerShape containerShape = null;
		PictogramElement [] pictograms = fp.getAllPictogramElementsForBusinessObject(bo);
		for (PictogramElement pictogram : pictograms)
		{
			if (pictogram instanceof ContainerShape)
			{
				containerShape = (ContainerShape)pictogram;
				break;
			}
		}
		return containerShape;
	}
	
}




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

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

import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.transaction.util.TransactionUtil;
import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.mm.pictograms.Diagram;
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.ModelPropertyChangeEvent;
import org.eclipse.sapphire.modeling.ModelPropertyListener;
import org.eclipse.sapphire.modeling.Value;
import org.eclipse.sapphire.modeling.ValueProperty;
import org.eclipse.sapphire.modeling.annotations.Reference;
import org.eclipse.sapphire.modeling.el.FailSafeFunction;
import org.eclipse.sapphire.modeling.el.Function;
import org.eclipse.sapphire.modeling.el.FunctionResult;
import org.eclipse.sapphire.modeling.el.ModelElementFunctionContext;
import org.eclipse.sapphire.modeling.localization.LocalizationService;
import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionDef;
import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionEndpointDef;

public class DiagramConnectionTemplate 
{
	protected SapphireDiagramEditorPart diagramEditor;
	private IDiagramConnectionDef definition;
	protected IModelElement modelElement;
	protected String propertyName;
	private ListProperty modelProperty;
	protected String toolPaletteLabel;
	protected String toolPaletteDesc;
	protected ModelPropertyListener modelPropertyListener;
	
	private List<DiagramConnectionPart> diagramConnections;
	
	public DiagramConnectionTemplate() {}
	
    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>();
        
        this.propertyName = this.definition.getProperty().getContent();
        this.modelProperty = (ListProperty)resolve(this.modelElement, this.propertyName);
        	
    	ModelElementList<?> list = this.modelElement.read(this.modelProperty);
        for( IModelElement listEntryModelElement : list )
        {
        	DiagramConnectionPart connection = new DiagramConnectionPart(this);
        	connection.init(this.diagramEditor, listEntryModelElement, definition, 
        			Collections.<String,String>emptyMap());
        	addConnectionPart(null, connection);
        }
                
        // Add model property listener
        this.modelPropertyListener = new ModelPropertyListener()
        {
            @Override
            public void handlePropertyChangedEvent( final ModelPropertyChangeEvent event )
            {
                handleModelPropertyChange( event );
            }
        };
        addModelListener();        
    }
    
    public List<DiagramConnectionPart> getDiagramConnections(IModelElement srcNodeModel)
    {
    	return this.diagramConnections;
    }
    
    public String getToolPaletteLabel()
    {
    	return this.toolPaletteLabel;
    }
    
    public String getToolPaletteDesc()
    {
    	return this.toolPaletteDesc;
    }
    
    public boolean canCreateNewConnection(DiagramNodePart srcNode, DiagramNodePart targetNode)
    {
    	boolean canCreate = false;
    	ModelElementType srcType = srcNode.getModelElement().getModelElementType();
    	ModelElementType targetType = targetNode.getModelElement().getModelElementType();
    	
        ModelElementType type = this.modelProperty.getType();
        ModelProperty prop1 = type.getProperty(this.definition.getEndpoint1().element().getProperty().getContent());
        if (prop1.getType() == null && prop1.hasAnnotation(Reference.class))
        {
        	canCreate = prop1.getAnnotation(Reference.class).target().isAssignableFrom(srcType.getModelElementClass());
        	if (!canCreate)
        		return false;
        }
        ModelProperty prop2 = type.getProperty(this.definition.getEndpoint2().element().getProperty().getContent());
        if (prop2.getType() == null && prop2.hasAnnotation(Reference.class))
        {
        	canCreate = prop2.getAnnotation(Reference.class).target().isAssignableFrom(targetType.getModelElementClass());
        }
    	return canCreate;
    }
    
    public void addModelListener()
    {
    	this.modelElement.addListener(this.modelPropertyListener, this.propertyName);
    }
    
    public void removeModelLister()
    {
    	this.modelElement.removeListener(this.modelPropertyListener, this.propertyName);
    }
    
    public SapphireDiagramEditorPart getDiagramEditor()
    {
    	return this.diagramEditor;
    }
    
    public DiagramConnectionPart createNewDiagramConnection(DiagramNodePart srcNode, 
    														DiagramNodePart targetNode)
    {
		ModelElementList<?> list = this.modelElement.read(this.modelProperty);
		IModelElement newElement = list.addNewElement();
		
    	IDiagramConnectionEndpointDef srcAnchorDef = this.definition.getEndpoint1().element();
    	String srcProperty = srcAnchorDef.getProperty().getContent();
    	Value<Function> srcFunc = srcAnchorDef.getValue();
    	FunctionResult srcFuncResult = getNodeReferenceFunction(srcNode, srcFunc);
    	if (srcFuncResult != null)
    	{
	    	setModelProperty(newElement, srcProperty, srcFuncResult.value());
	    	srcFuncResult.dispose();
    	}
    	
    	IDiagramConnectionEndpointDef targetAnchorDef = this.definition.getEndpoint2().element();
    	String targetProperty = targetAnchorDef.getProperty().getContent();
    	Value<Function> targetFunc = targetAnchorDef.getValue();;
    	FunctionResult targetFuncResult = getNodeReferenceFunction(targetNode, targetFunc);
    	if (targetFuncResult != null)
    	{
	    	setModelProperty(newElement, targetProperty, targetFuncResult.value());
	    	targetFuncResult.dispose();
    	}
    	
    	DiagramConnectionPart newConn = new DiagramConnectionPart(this);
    	newConn.init(this.diagramEditor, newElement, this.definition, 
    			Collections.<String,String>emptyMap());
    	addConnectionPart(null, newConn);
    	return newConn;
    }
    
    public DiagramConnectionPart createNewDiagramConnection(IModelElement connElement, IModelElement srcNodeElement)
    {
    	DiagramConnectionPart connPart = new DiagramConnectionPart(this);
    	connPart.init(this.diagramEditor, connElement, this.definition, 
    			Collections.<String,String>emptyMap());
    	addConnectionPart(null, connPart);
    	return connPart;
    }
    
    protected 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;
    }

    protected 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);
    	}    	
    }
    
    protected FunctionResult getNodeReferenceFunction(final DiagramNodePart nodePart,
    											final Value<Function> function)
    {
        Function f = null;
        FunctionResult fr = null;
        
        if( function != null )
        {
            f = function.getContent();
        }
        
        if( f != null )
        {
            
            f = FailSafeFunction.create( f, String.class );
            fr = f.evaluate( new ModelElementFunctionContext( nodePart.getLocalModelElement(), this.definition.adapt( LocalizationService.class ) ) );
        }
        return fr;
    }
    
    protected void handleModelPropertyChange(final ModelPropertyChangeEvent event)
    {
    	final IModelElement element = event.getModelElement();
    	final ModelProperty property = event.getProperty();
    	ModelElementList<?> newList = (ModelElementList<?>)element.read(property);
    	
    	if (newList.size() != getDiagramConnections(element).size())
    	{
    		List<DiagramConnectionPart> connParts = getDiagramConnections(element);
    		List<IModelElement> oldList = new ArrayList<IModelElement>(connParts.size());
    		for (DiagramConnectionPart connPart : connParts)
    		{
    			oldList.add(connPart.getLocalModelElement());
    		}
    		
    		final IFeatureProvider fp = this.diagramEditor.getDiagramEditor().getDiagramTypeProvider().getFeatureProvider();
    		final Diagram diagram = this.diagramEditor.getDiagramEditor().getDiagramTypeProvider().getDiagram();
			final TransactionalEditingDomain ted = TransactionUtil.getEditingDomain(diagram);
    		
	    	if (newList.size() > oldList.size())
	    	{
	    		// new connections are added
	    		List<IModelElement> newConns = ListUtil.ListDiff(newList, oldList);
	    		for (IModelElement newConn : newConns)
	    		{	    			
	            	DiagramConnectionPart connPart = createNewDiagramConnection(newConn, element);
	            	connPart.addNewConnectionIfPossible(fp, ted, this.diagramEditor);
	    		}
	    	}
	    	else
	    	{
	    		// connections are deleted
	    		List<IModelElement> deletedConns = ListUtil.ListDiff(newList, oldList);
	    		for (IModelElement deletedConn : deletedConns)
	    		{
	    			DiagramConnectionPart connPart = getConnectionPart(element, deletedConn);
	    			if (connPart != null)
	    			{
	    				connPart.removeDiagramConnection(fp, ted);
		    			connPart.dispose();
		    			removeConnectionPart(element, connPart);
	    			}
	    		}
	    	}
    	}
    }
    
    protected void addConnectionPart(IModelElement srcNodeModel, DiagramConnectionPart connPart)
    {
    	this.diagramConnections.add(connPart);
    }
    
    protected void removeConnectionPart(IModelElement srcNodeModel, DiagramConnectionPart connPart)
    {
    	this.diagramConnections.remove(connPart);
    }
    
    protected DiagramConnectionPart getConnectionPart(IModelElement srcNodeModel, IModelElement connModel)
    {
    	List<DiagramConnectionPart> connParts = getDiagramConnections(srcNodeModel);
    	for (DiagramConnectionPart connPart : connParts)
    	{
    		if (connPart.getLocalModelElement().equals(connModel))
    		{
    			return connPart;
    		}
    	}
    	return null;
    }
        
}




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

import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.transaction.util.TransactionUtil;
import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ModelProperty;
import org.eclipse.sapphire.modeling.ModelPropertyChangeEvent;
import org.eclipse.sapphire.modeling.ModelPropertyListener;
import org.eclipse.sapphire.modeling.el.FunctionResult;
import org.eclipse.sapphire.ui.SapphireRenderingContext;
import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionEndpointDef;
import org.eclipse.sapphire.ui.diagram.def.IDiagramEmbeddedConnectionDef;

public class DiagramEmbeddedConnectionPart extends DiagramConnectionPart 
{
	private IDiagramEmbeddedConnectionDef localDefinition;
	private IModelElement srcNodeModel;
	private IModelElement endpointModel;
	private FunctionResult endpointFunctionResult;
	private IDiagramConnectionEndpointDef endpointDef;
	
	public DiagramEmbeddedConnectionPart(DiagramEmbeddedConnectionTemplate connTemplate,
			IModelElement srcNodeModel)
	{
		this.connectionTemplate = connTemplate;
		this.srcNodeModel = srcNodeModel;
	}
	
    @Override
    protected void init()
    {        
        this.localDefinition = (IDiagramEmbeddedConnectionDef)super.definition;
        this.modelElement = super.getModelElement();
        this.labelFunctionResult = initExpression
        ( 
        	this.modelElement,
        	this.localDefinition.getLabel().element().getContent(), 
            new Runnable()
            {
                public void run()
                {
                }
            }
        );
        this.labelProperty = FunctionUtil.getFunctionProperty(this.modelElement, this.labelFunctionResult);
        
        this.idFunctionResult = initExpression
        ( 
        	this.modelElement,
            this.localDefinition.getInstanceId(), 
            new Runnable()
            {
                public void run()
                {
                }
            }
        );        

        this.endpointDef = this.localDefinition.getEndpoint().element();
        this.endpointModel = processEndpoint(this.endpointDef);
        if (this.endpointModel != null)
        {
	        this.endpointFunctionResult = initExpression
	        (
	        	this.endpointModel, 
	        	this.endpointDef.getValue(), 
	            new Runnable()
	        	{
		            public void run()
		            {
		            	refreshEndpoint2();
		            }
	        	}
	        );
        }        
        // Add model property listener
        this.modelPropertyListener = new ModelPropertyListener()
        {
            @Override
            public void handlePropertyChangedEvent( final ModelPropertyChangeEvent event )
            {
                handleModelPropertyChange( event );
            }
        };
        addModelListener();        
    }
    
    @Override
    public IModelElement getEndpoint1()
    {
    	return this.srcNodeModel;
    }
    
    @Override
    public IModelElement getEndpoint2()
    {
    	return this.endpointModel;
    }

    @Override
	public void refreshEndpoint1()
	{
	}
	
    @Override
	public void refreshEndpoint2()
	{
		if (this.endpointFunctionResult != null)
		{
			Object value = this.endpointFunctionResult.value();
			String property = this.endpointDef.getProperty().getContent();
			setModelProperty(this.modelElement, property, value);
		}		
	}
        
    public DiagramNodePart getSourceNodePart()
    {
    	SapphireDiagramEditorPart diagramPart = (SapphireDiagramEditorPart)getParentPart();
    	return diagramPart.getDiagramNodePart(this.srcNodeModel);
    }
    
	@Override
	public void render(SapphireRenderingContext context) 
	{
		// TODO Auto-generated method stub

	}

    @Override
    public void dispose()
    {
    	super.dispose();
    	if (this.endpointFunctionResult != null)
    	{
    		this.endpointFunctionResult.dispose();
    	}    	
    }
    
    @Override
    public void addModelListener()
    {
    	if (this.labelProperty != null)
    	{
	    	this.modelElement.addListener(this.modelPropertyListener, 
	    								this.labelProperty.getName());
    	}
    	this.modelElement.addListener(this.modelPropertyListener, 
    								this.endpointDef.getProperty().getContent());
    }
    
    @Override
    public void removeModelListener()
    {
    	if (this.labelProperty != null)
    	{
	    	this.modelElement.removeListener(this.modelPropertyListener, 
	    								this.labelProperty.getName());
    	}
    	this.modelElement.removeListener(this.modelPropertyListener, 
    								this.endpointDef.getProperty().getContent());
    }

    @Override
    protected void handleModelPropertyChange(final ModelPropertyChangeEvent event)
    {
    	final ModelProperty property = event.getProperty();
    	if (property.getName().equals(this.endpointDef.getProperty().getContent()))
    	{
	    	SapphireDiagramEditorPart diagramEditor = (SapphireDiagramEditorPart)getParentPart();
			final IFeatureProvider fp = diagramEditor.getDiagramEditor().getDiagramTypeProvider().getFeatureProvider();
			final Diagram diagram = diagramEditor.getDiagramEditor().getDiagramTypeProvider().getDiagram();
			final TransactionalEditingDomain ted = TransactionUtil.getEditingDomain(diagram);
			
			removeDiagramConnection(fp, ted);
			handleEndpointChange();
			addNewConnectionIfPossible(fp, ted, diagramEditor);
    	}    			
    }    
    
    private void handleEndpointChange()
    {
        this.endpointModel = processEndpoint(this.endpointDef);
        if (this.endpointFunctionResult != null)
        {
        	this.endpointFunctionResult.dispose();
        	this.endpointFunctionResult = null;
        }
        if (this.endpointModel != null)
        {        	
	        this.endpointFunctionResult = initExpression
	        (
	        	this.endpointModel, 
	        	this.endpointDef.getValue(), 
	            new Runnable()
	        	{
		            public void run()
		            {
		            	refreshEndpoint2();
		            }
	        	}
	        );
        }        
    }
    
}




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

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

import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.transaction.util.TransactionUtil;
import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.sapphire.modeling.ElementProperty;
import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ListProperty;
import org.eclipse.sapphire.modeling.ModelElementDisposedEvent;
import org.eclipse.sapphire.modeling.ModelElementList;
import org.eclipse.sapphire.modeling.ModelElementListener;
import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.ModelProperty;
import org.eclipse.sapphire.modeling.ModelPropertyChangeEvent;
import org.eclipse.sapphire.modeling.ModelPropertyListener;
import org.eclipse.sapphire.modeling.Value;
import org.eclipse.sapphire.modeling.annotations.Reference;
import org.eclipse.sapphire.modeling.el.Function;
import org.eclipse.sapphire.modeling.el.FunctionResult;
import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionEndpointDef;
import org.eclipse.sapphire.ui.diagram.def.IDiagramEmbeddedConnectionDef;

public class DiagramEmbeddedConnectionTemplate extends DiagramConnectionTemplate
{
	private DiagramNodeTemplate nodeTemplate;
	private IDiagramEmbeddedConnectionDef definition;
	private Map<IModelElement, List<DiagramConnectionPart>> diagramConnectionMap;
	private ModelElementListener modelElementListener;
		
    public DiagramEmbeddedConnectionTemplate(final SapphireDiagramEditorPart diagramEditor,
    										final DiagramNodeTemplate nodeTemplate, 
    										IDiagramEmbeddedConnectionDef definition, 
    										IModelElement modelElement)
    {
    	this.diagramEditor = diagramEditor;
    	this.nodeTemplate = nodeTemplate;
    	this.modelElement = modelElement;
    	this.definition = definition;
    	
        this.toolPaletteLabel = this.definition.getToolPaletteLabel().getContent();
        this.toolPaletteDesc = this.definition.getToolPaletteDesc().getContent();
        
        this.diagramConnectionMap = new HashMap<IModelElement, List<DiagramConnectionPart>>();
        
        ListProperty nodeProperty = (ListProperty)this.nodeTemplate.getModelProperty();
        this.propertyName = this.definition.getProperty().getContent();
        
        this.modelPropertyListener = new ModelPropertyListener()
        {
            @Override
            public void handlePropertyChangedEvent( final ModelPropertyChangeEvent event )
            {
                handleModelPropertyChange( event );
            }
        };
        
        this.modelElementListener = new ModelElementListener() 
        {
        	@Override
        	public void handleElementDisposedEvent( final ModelElementDisposedEvent event )
        	{
        		handleModelElementDispose(event);
        	}
		};
		
    	ModelElementList<?> list = this.modelElement.read(nodeProperty);
        for (IModelElement srcNodeModel : list)
        {
        	ModelProperty connProp = resolve(srcNodeModel, this.propertyName);
        	if (connProp instanceof ListProperty)
        	{
        		ListProperty connListProperty = (ListProperty)connProp;
        		ModelElementList<?> connList = srcNodeModel.read(connListProperty);
        		List<DiagramConnectionPart> partList = new ArrayList<DiagramConnectionPart>();
        		for (IModelElement endpointModel : connList)
        		{
        			DiagramEmbeddedConnectionPart connPart = 
        				new DiagramEmbeddedConnectionPart(this, srcNodeModel);
        			connPart.init(this.diagramEditor, endpointModel, this.definition, 
        					Collections.<String,String>emptyMap());
        			partList.add(connPart);
        		}
        		this.diagramConnectionMap.put(srcNodeModel, partList);
        		addModelListener(srcNodeModel);
        	}
        }            	
    }
        
    @Override
    public boolean canCreateNewConnection(DiagramNodePart srcNode, DiagramNodePart targetNode)
    {    	
    	IModelElement srcNodeModel = srcNode.getLocalModelElement();
    	
    	// check the source node type
    	ModelElementType srcNodeType = srcNodeModel.getModelElementType();
    	ModelElementType desiredsrcNodeType = this.nodeTemplate.getNodeType();
    	
    	if (!srcNodeType.equals(desiredsrcNodeType))
    	{
    		return false;
    	}
    	
    	// check the target node type
    	ModelElementType targetType = targetNode.getLocalModelElement().getModelElementType();
    	
    	ModelProperty connProp = resolve(srcNodeModel, this.propertyName);    	
        ModelElementType connType = connProp.getType();
        ModelProperty endpointProp = 
        	connType.getProperty(this.definition.getEndpoint().element().getProperty().getContent());
        if (endpointProp.getType() == null && endpointProp.hasAnnotation(Reference.class))
        {
        	return endpointProp.getAnnotation(Reference.class).target().isAssignableFrom(targetType.getModelElementClass());
        }
    	return false;
    }
        
    @Override
    public DiagramEmbeddedConnectionPart createNewDiagramConnection(DiagramNodePart srcNode, 
			DiagramNodePart targetNode)
    {
    	IModelElement srcNodeModel = srcNode.getLocalModelElement();
    	ModelProperty modelProperty = this.nodeTemplate.getModelProperty();
    	boolean found = false;
    	if (modelProperty instanceof ListProperty)
    	{
        	ListProperty listProperty = (ListProperty)modelProperty;
        	ModelElementList<?> list = this.modelElement.read(listProperty);
            for (IModelElement listEntryModelElement : list)
            {
            	if (listEntryModelElement.equals(srcNodeModel))
            	{
            		found = true;
            		break;
            	}            	
            }
    	}
        else if (modelProperty instanceof ElementProperty)
        {
        	ElementProperty elementProperty = (ElementProperty)modelProperty;
        	if (this.modelElement.read(elementProperty) != null)
        	{
	        	IModelElement localModelElement = this.modelElement.read(elementProperty).element();
	        	if (localModelElement == srcNodeModel)
	        	{
	        		found = true;
	        	}
        	}
        }
    	if (!found)
    	{
    		throw new RuntimeException( "Cannot locate the source node element");
    	}
    	
    	ModelProperty connProp = resolve(srcNodeModel, this.propertyName);
    	IModelElement newEndpoint = null;
    	if (connProp instanceof ListProperty)
    	{
    		ListProperty listProperty = (ListProperty)connProp;
    		ModelElementList<?> list = srcNodeModel.read(listProperty);
    		newEndpoint = list.addNewElement();    		
    	}
    	IDiagramConnectionEndpointDef endpointDef = this.definition.getEndpoint().element();
    	String endpointProperty = endpointDef.getProperty().getContent();
    	Value<Function> endpointFunc = endpointDef.getValue();
    	FunctionResult endpointFuncResult = getNodeReferenceFunction(targetNode, endpointFunc);
    	if (endpointFuncResult != null)
    	{
	    	setModelProperty(newEndpoint, endpointProperty, endpointFuncResult.value());
	    	endpointFuncResult.dispose();
    	}
    	
		DiagramEmbeddedConnectionPart connPart = 
			new DiagramEmbeddedConnectionPart(this, srcNodeModel);
		connPart.init(this.diagramEditor, newEndpoint, this.definition, 
				Collections.<String,String>emptyMap());               			
		addConnectionPart(srcNodeModel, connPart);                		
    	
    	return connPart;
    }
    
    @Override
    public DiagramConnectionPart createNewDiagramConnection(IModelElement connElement, IModelElement srcNodeElement)
    {
		DiagramEmbeddedConnectionPart connPart = 
			new DiagramEmbeddedConnectionPart(this, srcNodeElement);
		connPart.init(this.diagramEditor, connElement, this.definition, 
				Collections.<String,String>emptyMap());
		addConnectionPart(srcNodeElement, connPart);
    	return connPart;
    }
    
    public void addModelListener(IModelElement srcNodeModel)
    {
    	srcNodeModel.addListener(this.modelPropertyListener, this.propertyName);
    	srcNodeModel.addListener(this.modelElementListener);
    }
    
    public void removeModelListener(IModelElement srcNodeModel)
    {
    	srcNodeModel.removeListener(this.modelPropertyListener, this.propertyName);
    	srcNodeModel.removeListener(this.modelElementListener);
    } 
    
    @Override
    public List<DiagramConnectionPart> getDiagramConnections(IModelElement srcNodeModel)
    {
    	List<DiagramConnectionPart> allConnParts = new ArrayList<DiagramConnectionPart>();
    	if (srcNodeModel != null)
    	{
    		if (this.diagramConnectionMap.get(srcNodeModel) != null)
    		{
    			allConnParts.addAll(this.diagramConnectionMap.get(srcNodeModel));
    		}
    	}
    	else
    	{    		
    		// return all the connection parts
    		Iterator<IModelElement> it = this.diagramConnectionMap.keySet().iterator();
    		while (it.hasNext())
    		{
    			allConnParts.addAll(this.diagramConnectionMap.get(it.next()));
    		}
    	}
		return allConnParts;
    }

    @Override
    protected void addConnectionPart(IModelElement srcNodeModel, DiagramConnectionPart connPart)
    {
    	List<DiagramConnectionPart> connParts = this.diagramConnectionMap.get(srcNodeModel);
    	if (connParts == null)
    	{
    		connParts = new ArrayList<DiagramConnectionPart>();
    		this.diagramConnectionMap.put(srcNodeModel, connParts);
    	}
    	connParts.add(connPart);
    }

    @Override
    protected void removeConnectionPart(IModelElement srcNodeModel, DiagramConnectionPart connPart)
    {
    	List<DiagramConnectionPart> connParts = this.diagramConnectionMap.get(srcNodeModel);
    	if (connParts != null)
    	{
    		connParts.remove(connPart);
    	}
    }
    
    private void handleModelElementDispose(final ModelElementDisposedEvent event)
    {
    	IModelElement element = event.getModelElement();
    	List<DiagramConnectionPart> connParts = getDiagramConnections(element);
		final IFeatureProvider fp = this.diagramEditor.getDiagramEditor().getDiagramTypeProvider().getFeatureProvider();
		final Diagram diagram = this.diagramEditor.getDiagramEditor().getDiagramTypeProvider().getDiagram();
		final TransactionalEditingDomain ted = TransactionUtil.getEditingDomain(diagram);
    	
    	for (DiagramConnectionPart connPart : connParts)
    	{
			connPart.removeDiagramConnection(fp, ted);
			connPart.dispose();
    	}
    	connParts.clear();
    	removeModelListener(element);
    }
}




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

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

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

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

	public void updateNode(DiagramNodePart nodePart, int x, int y, int w, int h)
	{
		Bounds bounds = this.nodeGeometries.get(nodePart);
		if (bounds != null)
		{
			bounds.x = x;
			bounds.y = y;
			bounds.height = h;
			bounds.width = w;
		}
	}
	
	public Bounds getNode(DiagramNodePart nodePart)
	{
		return this.nodeGeometries.get(nodePart);
	}
		
	public void addConnectionBendpoint(DiagramConnectionPart connPart, int index, int x, int y)
	{
		HashMap<DiagramConnectionPart, List<Point>> connBendpointsMap = 
			getConnectionBenpointsMap(connPart, true);
		List<Point> bendpoints = connBendpointsMap.get(connPart);
		if (bendpoints == null)
		{
			bendpoints = new ArrayList<Point>();
			connBendpointsMap.put(connPart, bendpoints);
		}
		Point newPt = new Point(x, y);
		bendpoints.add(index, newPt);
	}
	
	public void removeConnectionBendpoint(DiagramConnectionPart connPart, int index)
	{
		HashMap<DiagramConnectionPart, List<Point>> connBendpointsMap = 
			getConnectionBenpointsMap(connPart, false);
		if (connBendpointsMap == null)
		{
			throw new RuntimeException("Could not locate connection benpoints map for the embedded connection");
		}
		List<Point> bendpoints = connBendpointsMap.get(connPart);
		if (bendpoints != null)
		{
			bendpoints.remove(index);
		}
	}
	
	public boolean updateConnectionBendpoint(DiagramConnectionPart connPart, int index, int x, int y)
	{
		HashMap<DiagramConnectionPart, List<Point>> connBendpointsMap = 
			getConnectionBenpointsMap(connPart, false);
		if (connBendpointsMap == null)
		{
			throw new RuntimeException("Could not locate connection benpoints map for the embedded connection");
		}
		List<Point> bendpoints = connBendpointsMap.get(connPart);
		if (bendpoints != null && index < bendpoints.size())
		{
			bendpoints.set(index, new Point(x, y));
			return true;
		}
		return false;
	}
	

	public List<Point> getConnectionBendpoints(DiagramConnectionPart connPart)
	{
		HashMap<DiagramConnectionPart, List<Point>> connBendpointsMap = 
			getConnectionBenpointsMap(connPart, false);		
		if (connBendpointsMap != null)
		{
			return connBendpointsMap.get(connPart);
		}
		return null;
	}
		
	public void removeConnectionBendpoints(DiagramConnectionPart connPart)
	{
		HashMap<DiagramConnectionPart, List<Point>> connBendpointsMap = 
			getConnectionBenpointsMap(connPart, false);		
		if (connBendpointsMap != null)
		{
			connBendpointsMap.remove(connPart);
		}		
	}
	
	public void read() throws ResourceStoreException
	{
		final XmlResourceStore resourceStore = new XmlResourceStore( new WorkspaceFileResourceStore(this.file ));
		this.geometryModel = IDiagramGeometry.TYPE.instantiate(new RootXmlResource( resourceStore ));

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

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

	private DiagramConnectionPart getConnectionPart(DiagramNodePart nodePart, String connId)
	{
		DiagramNodeTemplate nodeTemplate = nodePart.getDiagramNodeTemplate();
		DiagramEmbeddedConnectionTemplate connTemplate = 
			nodeTemplate.getEmbeddedConnectionTemplate();
		if (connTemplate != null)
		{
			List<DiagramConnectionPart> connParts = connTemplate.getDiagramConnections(nodePart.getLocalModelElement());
			for (DiagramConnectionPart connPart : connParts)
			{
				String connId2 = connPart.getInstanceId();
				if (connId != null && connId2 != null && connId.equals(connId2))
				{
					return connPart;
				}				
			}
		}
		return null;
	}

	private HashMap<DiagramConnectionPart, List<Point>> getConnectionBenpointsMap(DiagramConnectionPart connPart, boolean create)
	{
		HashMap<DiagramConnectionPart, List<Point>> connBendpointsMap = null;
		if (connPart instanceof DiagramEmbeddedConnectionPart)
		{
			DiagramNodePart srcNodePart = ((DiagramEmbeddedConnectionPart)connPart).getSourceNodePart();
			if (srcNodePart == null)
			{
				throw new RuntimeException("Could not locate the source node for the embedded connection");
			}
			connBendpointsMap = this.embeddedConnectionBendpoints.get(srcNodePart);
			if (connBendpointsMap == null)
			{
				if (create)
				{
					connBendpointsMap = new HashMap<DiagramConnectionPart, List<Point>>();
					this.embeddedConnectionBendpoints.put(srcNodePart, connBendpointsMap);
				}
			}
		}
		else
		{
			connBendpointsMap = this.connectionBendpoints;
		}
		return connBendpointsMap;
	}
	
	private void addConnectionBenpointsToModel(HashMap<DiagramConnectionPart, List<Point>> connBendpointsMap, 
			ModelElementList<IDiagramConnectionGeometry> connGeometries)
	{
		Iterator<DiagramConnectionPart> connIt = connBendpointsMap.keySet().iterator();
		while (connIt.hasNext())
		{
			DiagramConnectionPart connPart = connIt.next();
			List<Point> bps = connBendpointsMap.get(connPart);
			String id = connPart.getInstanceId();
			
			if (bps != null && id != null)
			{
				IDiagramConnectionGeometry conn = connGeometries.addNewElement();
				conn.setConnectionId(id);
				for (Point pt : bps)
				{
					IBendPoint pt2 = conn.getConnectionBendpoints().addNewElement();
					pt2.setX(pt.x);
					pt2.setY(pt.y);
				}
			}
		}
		
	}
	
	// -------------------------------------------------------------------
	// Inner classes
	// -------------------------------------------------------------------
	
	public static class Point
	{
		public int x;
		public int y;
		
		public Point(int x, int y)
		{
			this.x = x;
			this.y = y;
		}
	}
	
	public static final class Bounds extends Point
	{
		public int width;
		public int height;
		
		public Bounds(int x, int y, int width, int height)
		{
			super(x, y);
			this.width = width;
			this.height = height;
		}
	}
}




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

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.impl.UpdateContext;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ValueProperty;
import org.eclipse.sapphire.modeling.el.FunctionResult;
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 FunctionResult labelFunctionResult;
	private FunctionResult idFunctionResult;
	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.labelFunctionResult = initExpression
        ( 
        	this.modelElement,
            this.definition.getLabel().element().getContent(), 
            new Runnable()
            {
                public void run()
                {
                	refreshLabel();
                }
            }
        );
        this.labelProperty = FunctionUtil.getFunctionProperty(this.modelElement, this.labelFunctionResult);
        
        this.idFunctionResult = initExpression
        ( 
        	this.modelElement,
            this.definition.getInstanceId(), 
            new Runnable()
            {
                public void run()
                {
                }
            }
        );
    }
    
    public DiagramNodeTemplate getDiagramNodeTemplate()
    {
    	return this.nodeTemplate;
    }
    
    public IModelElement getLocalModelElement()
    {
        return this.modelElement;
    }    
        
	@Override
	public void render(SapphireRenderingContext context)
	{
		throw new UnsupportedOperationException();
	}

	@Override
	public void dispose()
	{
		super.dispose();
		if (this.labelFunctionResult != null)
		{
			this.labelFunctionResult.dispose();
		}
		
		if (this.idFunctionResult != null)
		{
			this.idFunctionResult.dispose();
		}
	}
	
	public String getLabel()
	{
        String label = null;
        
        if( this.labelFunctionResult != null )
        {
            label = (String) this.labelFunctionResult.value();
        }
        
        if( label == null )
        {
            label = "#null#";
        }
        
        return label;
	}

	public void setLabel(String newValue)
	{
		if (this.labelProperty != null)
		{
			this.modelElement.write(this.labelProperty, newValue);
		}
	}
	
	public void refreshLabel()
	{
		final SapphireDiagramEditorPart diagramEditor = (SapphireDiagramEditorPart)getParentPart();
		final IFeatureProvider fp = 
						diagramEditor.getDiagramEditor().getDiagramTypeProvider().getFeatureProvider();
		final PictogramElement pe = getDiagramNodeTemplate().getContainerShape(fp, this);
		if (pe != null)
		{
			UpdateContext context = new UpdateContext(pe);
			fp.updateIfPossible(context);
		}		
	}
	
	public boolean canEditLabel()
	{
		return this.labelProperty != null;
	}
	
	public String getInstanceId()
	{
        String id = null;
        
        if( this.idFunctionResult != null )
        {
            id = (String) this.idFunctionResult.value();
        }
        
        if( id == null )
        {
            id = "#null#";
        }
        
        return id;		
	}
	
	public boolean canResizeShape()
	{
		return this.definition.getHint("resizable", true);
	}
	
}




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

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

import org.eclipse.emf.transaction.RecordingCommand;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.transaction.util.TransactionUtil;
import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.IRemoveFeature;
import org.eclipse.graphiti.features.context.IRemoveContext;
import org.eclipse.graphiti.features.context.impl.AddContext;
import org.eclipse.graphiti.features.context.impl.RemoveContext;
import org.eclipse.graphiti.mm.pictograms.ContainerShape;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
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.ModelPropertyChangeEvent;
import org.eclipse.sapphire.modeling.ModelPropertyListener;
import org.eclipse.sapphire.ui.diagram.def.IDiagramEmbeddedConnectionDef;
import org.eclipse.sapphire.ui.diagram.def.IDiagramNodeDef;

public class DiagramNodeTemplate 
{
	private SapphireDiagramEditorPart diagramEditor;
	private IDiagramNodeDef definition;
	private IModelElement modelElement;	
	private String propertyName;
	private ListProperty modelProperty;
	private String toolPaletteLabel;
	private String toolPaletteDesc;
	private DiagramEmbeddedConnectionTemplate embeddedConnTemplate;
	private ModelPropertyListener modelPropertyListener;
	
	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>();
        
        this.propertyName = this.definition.getProperty().getContent();
        this.modelProperty = (ListProperty)resolve(this.modelElement, this.propertyName);
    	ModelElementList<?> list = this.modelElement.read(this.modelProperty);
        for( IModelElement listEntryModelElement : list )
        {
        	DiagramNodePart node = new DiagramNodePart(this);
        	node.init(this.diagramEditor, listEntryModelElement, definition, 
        			Collections.<String,String>emptyMap());
        	this.diagramNodes.add(node);
        }
        
        // handle embedded connections
        if (this.definition.getEmbeddedConnections().element() != null)
        {
        	IDiagramEmbeddedConnectionDef embeddedConnDef = 
        				this.definition.getEmbeddedConnections().element();
        	this.embeddedConnTemplate = new DiagramEmbeddedConnectionTemplate(
        									this.diagramEditor,
        									this, 
        									embeddedConnDef, 
        									this.modelElement);
        }
        
        // Add model property listener
        this.modelPropertyListener = new ModelPropertyListener()
        {
            @Override
            public void handlePropertyChangedEvent( final ModelPropertyChangeEvent event )
            {
                handleModelPropertyChange( event );
            }
        };
        addModelListener();        
    }
    
    public IDiagramNodeDef getDefinition()
    {
    	return this.definition;
    }
    
    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;
		ModelElementList<?> list = this.modelElement.read(this.modelProperty);
		newElement = list.addNewElement();
    	DiagramNodePart newNode = createNodePart(newElement);
    	return newNode;
    }
    
    public ModelProperty getModelProperty()
    {
    	return this.modelProperty;
    }
    
    public ModelElementType getNodeType()
    {
    	return this.modelProperty.getType();
    }
    
    public DiagramEmbeddedConnectionTemplate getEmbeddedConnectionTemplate()
    {
    	return this.embeddedConnTemplate;
    }
    
    public void addModelListener()
    {
    	this.modelElement.addListener(this.modelPropertyListener, this.propertyName);
    }
    
    public void removeModelLister()
    {
    	this.modelElement.removeListener(this.modelPropertyListener, this.propertyName);
    }
    
    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 handleModelPropertyChange(final ModelPropertyChangeEvent event)
    {
    	final IModelElement element = event.getModelElement();
    	final ModelProperty property = event.getProperty();
    	ModelElementList<?> newList = (ModelElementList<?>)element.read(property);
    	if (newList.size() != getDiagramNodes().size())
    	{
    		List<DiagramNodePart> nodeParts = getDiagramNodes();
    		List<IModelElement> oldList = new ArrayList<IModelElement>(nodeParts.size());
    		for (DiagramNodePart nodePart : nodeParts)
    		{
    			oldList.add(nodePart.getLocalModelElement());
    		}
    		
    		final IFeatureProvider fp = this.diagramEditor.getDiagramEditor().getDiagramTypeProvider().getFeatureProvider();
    		final Diagram diagram = this.diagramEditor.getDiagramEditor().getDiagramTypeProvider().getDiagram();
			final TransactionalEditingDomain ted = TransactionUtil.getEditingDomain(diagram);
    		
	    	if (newList.size() > oldList.size())
	    	{
	    		// new nodes are added outside of the diagram editor
	    		List<IModelElement> newNodes = ListUtil.ListDiff(newList, oldList);
	    		for (IModelElement newNode : newNodes)
	    		{
	    			// If new model element is added through palette, we don't need to 
	    			// add its graphical representation to the diagram since the create
	    			// feature takes care of that. If the new model element is added through
	    			// other means (form editor or source editor, we need to add the PE to the
	    			// diagram
	    			DiagramNodePart nodePart = getNodePart(newNode);
	    			if (nodePart == null)
	    			{
	    		    	nodePart = createNodePart(newNode);
						AddContext ctx = new AddContext();
						ctx.setNewObject(nodePart);
						ctx.setTargetContainer(diagram);
		    			fp.addIfPossible(ctx);
	    			}
	    		}
	    	}
	    	else if (newList.size() < oldList.size())
	    	{
	    		// nodes are deleted
	    		List<IModelElement> deletedNodes = ListUtil.ListDiff(newList, oldList);
	    		for (IModelElement deletedNode : deletedNodes)
	    		{
	    			DiagramNodePart nodePart = getNodePart(deletedNode);
	    			if (nodePart != null)
	    			{
	    				PictogramElement pe = getContainerShape(fp, nodePart);
	    				final IRemoveContext rc = new RemoveContext(pe);
	    				final IRemoveFeature removeFeature = fp.getRemoveFeature(rc);
	    				if (removeFeature != null) 
	    				{
	    					ted.getCommandStack().execute(new RecordingCommand(ted) 
	    					{
	    						protected void doExecute() 
	    						{			    					
	    							removeFeature.remove(rc);
	    						}
	    					});
	    					nodePart.dispose();
	    					this.diagramNodes.remove(nodePart);
	    				}	    				
	    			}
	    		}
	    	}
    	}
    }
    
    private DiagramNodePart getNodePart(IModelElement element)
    {
    	List<DiagramNodePart> nodeParts = getDiagramNodes();
    	for (DiagramNodePart nodePart2 : nodeParts)
    	{
    		if (nodePart2.getLocalModelElement().equals(element))
    		{
    			return nodePart2;
    		}
    	}
    	return null;
    }
    
    private DiagramNodePart createNodePart(IModelElement element)
    {
    	DiagramNodePart newNode = new DiagramNodePart(this);
    	newNode.init(this.diagramEditor, element, this.definition, 
    			Collections.<String,String>emptyMap());
    	if (this.embeddedConnTemplate != null)
    	{
    		this.embeddedConnTemplate.addModelListener(element);
    	}
    	this.diagramNodes.add(newNode);
    	return newNode;    	
    }
    
	public ContainerShape getContainerShape(IFeatureProvider fp, Object bo)
	{
		ContainerShape containerShape = null;
		PictogramElement [] pictograms = fp.getAllPictogramElementsForBusinessObject(bo);
		for (PictogramElement pictogram : pictograms)
		{
			if (pictogram instanceof ContainerShape)
			{
				containerShape = (ContainerShape)pictogram;
				break;
			}
		}
		return containerShape;
	}
    
}




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.FunctionResult;
import org.eclipse.sapphire.modeling.el.RootPropertyAccessFunction;

public class FunctionUtil 
{
    public static ValueProperty getFunctionProperty(IModelElement modelElement, FunctionResult functionResult)
    {
    	if (functionResult.function() instanceof RootPropertyAccessFunction)
    	{
    		if (functionResult.operand(0).value() instanceof String)
    		{
    			String propName = (String)functionResult.operand(0).value();
    	        final ModelElementType type = modelElement.getModelElementType();
    	        final ModelProperty property = type.getProperty(propName);
    			if (property instanceof ValueProperty)
    			{
    				return (ValueProperty)property;
    			}
    		}
    	}
    	else 
    	{
    		List<FunctionResult> subFuncs = functionResult.operands();
    		for (FunctionResult 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 org.eclipse.sapphire.modeling.IModelElement;

public class ListUtil 
{
	public static List<IModelElement> ListDiff(List<? extends IModelElement> list1, 
			List<? extends IModelElement> list2)
	{
		List<IModelElement> retList = new ArrayList<IModelElement>();
		if (list1.size() > list2.size())
		{
			for (IModelElement element : list1)
			{
				if (!list2.contains(element))
				{
					retList.add(element);
				}
			}
		}
		else if (list2.size() > list1.size())
		{			
			for (IModelElement element : list2)
			{
				if (!list1.contains(element))
				{
					retList.add(element);
				}
			}
		}
		return retList;
	}
	
}




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

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

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

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

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

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

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

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

	public IModelElement getModelElement() 
	{	
		return this.rootModelElement;
	}
	
	public DiagramNodePart getDiagramNodePart(IModelElement nodeElement)
	{
		if (nodeElement == null)
			return null;
		
		List<DiagramNodeTemplate> nodeTemplates = this.getNodeTemplates();
		for (DiagramNodeTemplate nodeTemplate : nodeTemplates)
		{
			if (nodeTemplate.getNodeType().equals(nodeElement.getModelElementType()))
			{
				List<DiagramNodePart> nodeParts = nodeTemplate.getDiagramNodes();
				for (DiagramNodePart nodePart : nodeParts)
				{
					if (nodePart.getLocalModelElement().equals(nodeElement))
					{
						return nodePart;
					}
				}
			}
		}
		return null;
	}
	
	public IStatus getValidationState() {
		// TODO Auto-generated method stub
		return null;
	}

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

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

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

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

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

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

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

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

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

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

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




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

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

@GenerateImpl

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

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

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




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

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

@GenerateImpl

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

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

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

    // *** ConnectionBendpoints***

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




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

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

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

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

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

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

}




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

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

@GenerateImpl

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

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

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

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

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

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

    @Type( base = IDiagramConnectionGeometry.class )
    
    @XmlListBinding( mappings = @XmlListBinding.Mapping( element = "connection", type = IDiagramConnectionGeometry.class ) )
    
    ListProperty PROP_EMBEDDED_CONNECTION_GEOMETRIES = new ListProperty( TYPE, "EmbeddedConnectionGeometries" );
    
    ModelElementList<IDiagramConnectionGeometry> getEmbeddedConnectionGeometries();	
	
}




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

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

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

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

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




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

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

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

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

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

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

			}
		});

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

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

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

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

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

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

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

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

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

}




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

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

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

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




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.sapphire.ui.internal.SapphireUiFrameworkPlugin;
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)
					{
						SapphireUiFrameworkPlugin.log(ie);
					}
					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.IResizeConfiguration;

public class NoResizeConfiguration implements IResizeConfiguration 
{
	public boolean isVerticalResizeAllowed() 
	{
		return false;
	}

	public boolean isHorizontalResizeAllowed() 
	{
		return false;
	}

}




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

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

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




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

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

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

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

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

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

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

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

        // provide information to support direct-editing directly 

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

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

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

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




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

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.IAddContext;
import org.eclipse.graphiti.features.impl.AbstractAddShapeFeature;
import org.eclipse.graphiti.mm.algorithms.Image;
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.def.ISapphirePartDef;
import org.eclipse.sapphire.ui.diagram.def.IDiagramLabelDef;
import org.eclipse.sapphire.ui.diagram.def.IDiagramNodeDef;
import org.eclipse.sapphire.ui.diagram.def.IDiagramNodeImageDef;
import org.eclipse.sapphire.ui.diagram.editor.DiagramGeometryWrapper;
import org.eclipse.sapphire.ui.diagram.editor.DiagramNodePart;
import org.eclipse.sapphire.ui.diagram.graphiti.providers.SapphireDiagramFeatureProvider;

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

	public PictogramElement add(IAddContext context)
	{
		DiagramNodePart nodePart = (DiagramNodePart)context.getNewObject();
		final Diagram targetDiagram = (Diagram) context.getTargetContainer();
		
        // define a default size for the shape
        IDiagramNodeDef nodeDef = (IDiagramNodeDef)nodePart.getDefinition();
        int width = nodeDef.getHint(ISapphirePartDef.HINT_WIDTH, -1);
        int height = nodeDef.getHint(ISapphirePartDef.HINT_HEIGHT, -1);
        int x, y;
        if (context.getX() != -1)
        {
        	x = context.getX();
        }
        else
        {
        	x = defaultX;
        	defaultX += xInc;
        }
        if (context.getY() != -1)
        {
        	y = context.getY();
        }
        else
        {
        	y = defaultY;
        	defaultY += yInc;
        }

        // CONTAINER SHAPE WITH RECTANGLE
        IPeCreateService peCreateService = Graphiti.getPeCreateService();
        ContainerShape containerShape =  peCreateService.createContainerShape(targetDiagram, true);
        IGaService gaService = Graphiti.getGaService();
        
        // TODO clean this up
        // The temporary logic is to create a default rectangle if no icon is associated with the node
        if (nodeDef.getImage().element() == null)
        {
            // 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, x, y, 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);
	        }
        }
        else
        {
        	IDiagramNodeImageDef imageDef = nodeDef.getImage().element();
        	Rectangle rectangle = gaService.createRectangle(containerShape);
        	rectangle.setFilled(false);
        	rectangle.setLineVisible(false);
        	gaService.setLocationAndSize(rectangle, x, y, width, height);
        	
        	link(containerShape, nodePart);
        	
            // Shape with Image
            {
            	Shape shape = peCreateService.createShape(containerShape, false);
            	String imageId = imageDef.getImageId().getContent();
            	Image image = gaService.createImage(shape, imageId);
            	int imageX = imageDef.getHint("x", 0);
            	int imageY = imageDef.getHint("y", 0);
                int imageWidth = imageDef.getHint(ISapphirePartDef.HINT_WIDTH, width);
                int imageHeight = imageDef.getHint(ISapphirePartDef.HINT_HEIGHT, -1);
            	
    	        gaService.setLocationAndSize(image, imageX, imageY, imageWidth, imageHeight);
            }        	
        }

        if (nodeDef.getLabel().element() != null)
        {
            // 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);

            IDiagramLabelDef labelDef = nodeDef.getLabel().element();
            int labelX = labelDef.getHint("x", 0);
        	int labelY = labelDef.getHint("y", 0);            
            int labelWidth = labelDef.getHint(ISapphirePartDef.HINT_WIDTH, width);
            int labelHeight = labelDef.getHint(ISapphirePartDef.HINT_HEIGHT, 15);
            
            gaService.setLocationAndSize(text, labelX, labelY, labelWidth, labelHeight);
 
            // create link and wire it
            link(shape, nodePart);            
        }
        
        // add a chopbox anchor to the shape
        peCreateService.createChopboxAnchor(containerShape);
        
        // Save the node bounds
        DiagramGeometryWrapper diagramGeometry = 
        	((SapphireDiagramFeatureProvider)getFeatureProvider()).getDiagramGeometry();
        diagramGeometry.addNode(nodePart, x, y, width, height);
        
		return containerShape;
	}

}




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

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.ICreateConnectionContext;
import org.eclipse.graphiti.features.context.impl.AddConnectionContext;
import org.eclipse.graphiti.features.impl.AbstractCreateConnectionFeature;
import org.eclipse.graphiti.mm.pictograms.Anchor;
import org.eclipse.graphiti.mm.pictograms.Connection;
import org.eclipse.sapphire.ui.SapphirePart;
import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionPart;
import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionTemplate;
import org.eclipse.sapphire.ui.diagram.editor.DiagramEmbeddedConnectionPart;
import org.eclipse.sapphire.ui.diagram.editor.DiagramEmbeddedConnectionTemplate;
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 && 
				target instanceof DiagramNodePart && source != target) 
		{
			return this.connectionTemplate.canCreateNewConnection((DiagramNodePart)source, 
					(DiagramNodePart)target);
		}
		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
			if (this.connectionTemplate instanceof DiagramEmbeddedConnectionTemplate)
			{
				((DiagramEmbeddedConnectionTemplate)this.connectionTemplate).removeModelListener(sourceNode.getLocalModelElement());
			}
			else
			{
				this.connectionTemplate.removeModelLister();
			}
			DiagramConnectionPart connectionPart = 
				this.connectionTemplate.createNewDiagramConnection(sourceNode, targetNode);

			if (this.connectionTemplate instanceof DiagramEmbeddedConnectionTemplate)
			{
				((DiagramEmbeddedConnectionTemplate)this.connectionTemplate).addModelListener(sourceNode.getLocalModelElement());
			}
			else
			{
				this.connectionTemplate.addModelListener();
			}
			
			// add connection for business object
			AddConnectionContext addContext = new AddConnectionContext(context.getSourceAnchor(), context.getTargetAnchor());
			addContext.setNewObject(connectionPart);
			newConnection = (Connection) getFeatureProvider().addIfPossible(addContext);
			
	        // activate direct editing after object creation
	        getFeatureProvider().getDirectEditingInfo().setActive(true);
		}

		return newConnection;
	}

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

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




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

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

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

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

	public Object[] create(ICreateContext context) 
	{
		// In general the model property listener in the node template should handle 
		// the addition of new element. But the passed in context contains x, y, width and
		// height of the new node, we are bypassing the listener mechanism here.
		this.nodeTemplate.removeModelLister();
		DiagramNodePart nodePart = this.nodeTemplate.createNewDiagramNode();
		this.nodeTemplate.addModelListener();
		
		addGraphicalRepresentation(context, nodePart);
		return new Object[] { nodePart };
	}
}




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

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.IDeleteContext;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.graphiti.ui.features.DefaultDeleteFeature;
import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ModelElementList;
import org.eclipse.sapphire.ui.diagram.editor.DiagramConnectionPart;

public class SapphireDeleteConnectionFeature extends DefaultDeleteFeature 
{
	private boolean shouldDelete;
	
	public SapphireDeleteConnectionFeature(IFeatureProvider fp)
	{
		super(fp);
	}
	
	@Override
	protected boolean getUserDecision() 
	{
		this.shouldDelete = super.getUserDecision();
		return this.shouldDelete;
	}
	
	@Override
	public void delete(IDeleteContext context) 
	{
		PictogramElement pe = context.getPictogramElement();
		Object[] businessObjectsForPictogramElement = getAllBusinessObjectsForPictogramElement(pe);
		if (businessObjectsForPictogramElement != null && businessObjectsForPictogramElement.length > 0) 
		{
			if (!getUserDecision()) 
			{
				return;
			}			
		}
		
		preDelete(context);
		deleteBusinessObjects(businessObjectsForPictogramElement);
		postDelete(context);
	}
	
	@Override
	protected void deleteBusinessObject(Object bo) 
	{
		if (bo instanceof DiagramConnectionPart) 
		{
			final DiagramConnectionPart connPart = (DiagramConnectionPart)bo;
			final IModelElement element = connPart.getLocalModelElement();
			final ModelElementList<?> list = (ModelElementList<?>) element.parent();
			list.remove(element);						
		}
	}
	
	@Override
	public boolean hasDoneChanges() 
	{
		return this.shouldDelete;
	}
}




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

import java.util.Iterator;

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.IDeleteContext;
import org.eclipse.graphiti.features.context.impl.DeleteContext;
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.graphiti.ui.features.DefaultDeleteFeature;
import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ModelElementList;
import org.eclipse.sapphire.ui.diagram.editor.DiagramNodePart;

public class SapphireDeleteNodeFeature extends DefaultDeleteFeature 
{
	private boolean shouldDelete;
	
	public SapphireDeleteNodeFeature(IFeatureProvider fp)
	{
		super(fp);
	}
	
	@Override
	protected boolean getUserDecision() 
	{
		this.shouldDelete = super.getUserDecision();
		return this.shouldDelete;
	}
	
	@Override
	public void preDelete(IDeleteContext context) 
	{
		PictogramElement pe = context.getPictogramElement();
		if (pe instanceof Shape)
		{
			Shape shape = (Shape)pe;
		
			for (Iterator<Anchor> iter = shape.getAnchors().iterator(); iter.hasNext();) 
			{
				Anchor anchor = iter.next();
				
				Iterator<Connection> connIt = Graphiti.getPeService().getAllConnections(anchor).iterator();
				while (connIt.hasNext())
				{
					Connection connection = connIt.next();				
					IDeleteContext dc = new DeleteContext(connection);
					SapphireInternalDeleteConnectionFeature df = new SapphireInternalDeleteConnectionFeature(getFeatureProvider());
					df.delete(dc);
				}
			}
		}		
	}
	
	@Override
	public void delete(IDeleteContext context) 
	{
		PictogramElement pe = context.getPictogramElement();
		Object[] businessObjectsForPictogramElement = getAllBusinessObjectsForPictogramElement(pe);
		if (businessObjectsForPictogramElement != null && businessObjectsForPictogramElement.length > 0) 
		{
			if (!getUserDecision()) 
			{
				return;
			}			
		}
		
		preDelete(context);
		deleteBusinessObjects(businessObjectsForPictogramElement);
		postDelete(context);
	}
	
	@Override
	protected void deleteBusinessObject(Object bo) 
	{
		if (bo instanceof DiagramNodePart)
		{
			DiagramNodePart nodePart = (DiagramNodePart)bo;
			IModelElement element = nodePart.getLocalModelElement();
			ModelElementList<?> list = (ModelElementList<?>) element.parent();
			list.remove(element);			
		}
	}
	
	@Override
	public boolean hasDoneChanges() 
	{
		return this.shouldDelete;
	}
	
}




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

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

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

	@Override
	public boolean canDirectEdit(IDirectEditingContext context) 
	{
		PictogramElement pe = (PictogramElement)context.getPictogramElement().eContainer();
		Object bo = getBusinessObjectForPictogramElement(pe);
		// support direct editing, if it is a DiagramConnectionPart, and the 
		// DiagramConnectionPart contains editable label
		if (bo instanceof DiagramConnectionPart && 
				((DiagramConnectionPart)bo).canEditLabel()) 
		{
			return true;
		}
		// direct editing not supported in all other cases
		return false;
	}
	
	public String getInitialValue(IDirectEditingContext context) 
	{
		PictogramElement pe = (PictogramElement)context.getPictogramElement().eContainer();
		Object bo = getBusinessObjectForPictogramElement(pe);
		if (bo instanceof DiagramConnectionPart)
		{
			DiagramConnectionPart connPart = (DiagramConnectionPart)bo;
			return connPart.getLabel();
		}
		return null;
	}

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

}




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

import java.util.Iterator;

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

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

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

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

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

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

	}

}




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

import org.eclipse.graphiti.features.IFeatureProvider;

public class SapphireInternalDeleteConnectionFeature extends
		SapphireDeleteConnectionFeature 
{
	public SapphireInternalDeleteConnectionFeature(IFeatureProvider fp)
	{
		super(fp);
	}
	
	@Override
	protected boolean getUserDecision() 
	{
		return true;
	}
	
	@Override
	public boolean hasDoneChanges() 
	{
		return true;
	}	
}




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

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

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




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

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

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




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

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

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

}




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

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.IRemoveContext;
import org.eclipse.graphiti.features.impl.DefaultRemoveFeature;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.sapphire.ui.diagram.graphiti.providers.SapphireDiagramFeatureProvider;

public class SapphireRemoveFeature extends DefaultRemoveFeature 
{
	public SapphireRemoveFeature(IFeatureProvider fp)
	{
		super(fp);
	}

	@Override
	public void preRemove(IRemoveContext context) 
	{
		PictogramElement pe = context.getPictogramElement();
		SapphireDiagramFeatureProvider sfp = (SapphireDiagramFeatureProvider)getFeatureProvider();
		final Object bo = sfp.getBusinessObjectForPictogramElement(pe);
		
		sfp.remove(bo);
	 }

}




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

import org.eclipse.graphiti.features.DefaultResizeConfiguration;
import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.IResizeConfiguration;
import org.eclipse.graphiti.features.context.IResizeShapeContext;
import org.eclipse.graphiti.features.impl.DefaultResizeShapeFeature;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.sapphire.ui.diagram.editor.DiagramNodePart;

public class SapphireResizeShapeFeature extends DefaultResizeShapeFeature 
{
	public SapphireResizeShapeFeature(IFeatureProvider fp)
	{
		super(fp);
	}
	
	@Override
	public boolean canResizeShape(IResizeShapeContext context) 
	{
		PictogramElement pe = context.getPictogramElement();
 		Object bo = getBusinessObjectForPictogramElement(pe);
 		if (bo instanceof DiagramNodePart)
 		{
 			DiagramNodePart nodePart = (DiagramNodePart)bo;
 			return nodePart.canResizeShape();
 		}
 		return super.canResizeShape(context);
	}
	
	@Override
	public IResizeConfiguration getResizeConfiguration(IResizeShapeContext context) 
	{
		if (!canResizeShape(context))
		{
			return new NoResizeConfiguration();
		}
		return new DefaultResizeConfiguration();
	}
	
}




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

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

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

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

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

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

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

}




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

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

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

	public IReason updateNeeded(IUpdateContext context) 
	{
		// retrieve name from pictogram model
		String pictogramName = null;
		PictogramElement pictogramElement = context.getPictogramElement();
		if (pictogramElement instanceof ContainerShape) 
		{
			ContainerShape cs = (ContainerShape) pictogramElement;
			for (Shape shape : cs.getChildren()) 
			{
				if (shape.getGraphicsAlgorithm() instanceof Text) 
				{
					Text text = (Text) shape.getGraphicsAlgorithm();
					pictogramName = text.getValue();
					break;
				}
			}
		}
		// 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.ArrayList;
import java.util.List;

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

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

	@Override
	public IMoveBendpointFeature getMoveBendpointFeature(IMoveBendpointContext context) 
	{
		IMoveBendpointFeature ret = new SapphireMoveBendpointFeature(this);
		return ret;
	}
	
    @Override
    public IMoveShapeFeature getMoveShapeFeature(IMoveShapeContext context) 
    {
    	return new SapphireMoveNodeFeature(this);
    }
	
	@Override
	public IResizeShapeFeature getResizeShapeFeature(IResizeShapeContext context) 
	{
		IResizeShapeFeature ret = new SapphireResizeShapeFeature(this);
		return ret;
	}
	
	/**
	 * When a PE is removed from the diagram, we need to remove the corresponding
	 * key from the solver and the saved node position/connection bendpoints from
	 * the cached diagram geometry
	 * @param bo
	 */
	public void remove(Object bo)
	{
		((SapphireDiagramSolver)this.getIndependenceSolver()).removeBO(bo);
		
		DiagramGeometryWrapper gw = getDiagramGeometry();
		if (bo instanceof DiagramNodePart)
		{
			gw.removeNode((DiagramNodePart)bo);
		}
		else if (bo instanceof DiagramConnectionPart)
		{
			gw.removeConnectionBendpoints((DiagramConnectionPart)bo);
		}
	}
	    
}




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

import org.eclipse.graphiti.ui.platform.AbstractImageProvider;

public class SapphireDiagramImageProvider extends AbstractImageProvider 
{
	public SapphireDiagramImageProvider()
	{
		super();
	}
	
	@Override
	protected void addAvailableImages() 
	{

	}
	
	public void registerImage(String imageId, String imageFilePath)
	{
		this.addImageFilePath(imageId, imageFilePath);
	}

}




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

	public boolean removeBO(Object bo)
	{
		if (this.bOToKeyMap.containsKey(bo))
		{
			String key = this.bOToKeyMap.get(bo);
			this.bOToKeyMap.remove(bo);
			this.keyToBOMap.remove(key);
			return true;
		}
		return false;
	}
}




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

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


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

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




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

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.List;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.graphiti.dt.AbstractDiagramTypeProvider;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.graphiti.platform.IDiagramEditor;
import org.eclipse.graphiti.tb.IToolBehaviorProvider;
import org.eclipse.graphiti.ui.internal.platform.ExtensionManager;
import org.eclipse.graphiti.ui.platform.IImageProvider;
import org.eclipse.graphiti.ui.services.GraphitiUi;
import org.eclipse.sapphire.ui.def.IImportDirective;
import org.eclipse.sapphire.ui.def.ISapphireUiDef;
import org.eclipse.sapphire.ui.diagram.def.IDiagramNodeDef;
import org.eclipse.sapphire.ui.diagram.def.IDiagramNodeImageDef;
import org.eclipse.sapphire.ui.diagram.editor.DiagramNodeTemplate;
import org.eclipse.sapphire.ui.diagram.editor.SapphireDiagramEditorPart;
import org.eclipse.sapphire.ui.diagram.graphiti.editor.SapphireDiagramEditor;
import org.eclipse.sapphire.ui.internal.SapphireUiFrameworkPlugin;
import org.eclipse.ui.internal.util.BundleUtility;
import org.osgi.framework.Bundle;

public class SapphireDiagramTypeProvider extends AbstractDiagramTypeProvider 
{
	private SapphireDiagramEditorPart diagramPart;
	private SapphireDiagramFeatureProvider featureProvider;
	private IToolBehaviorProvider[] toolBehaviorProviders;
	
	public SapphireDiagramTypeProvider()
	{
		this.featureProvider = 
			new SapphireDiagramFeatureProvider(this, new SapphireDiagramSolver());
		setFeatureProvider(this.featureProvider);
	}
	
	public void setDiagramPart(SapphireDiagramEditorPart diagramPart)
	{
		this.diagramPart = diagramPart;
		this.featureProvider.setDiagramPart(diagramPart);		
	}
	
	public SapphireDiagramEditorPart getDiagramPart()
	{
		return this.diagramPart;
	}
	
	@Override
	public void init(Diagram diagram, IDiagramEditor diagramEditor)
	{
		super.init(diagram, diagramEditor);
		setDiagramPart(((SapphireDiagramEditor)diagramEditor).getDiagramEditorPart());
		ExtensionManager extManager = (ExtensionManager)GraphitiUi.getExtensionManager();
		IImageProvider imageProviders[] = extManager.getImageProviders();
		SapphireDiagramImageProvider sapphireImageProvider = null;
		for (IImageProvider imageProvider : imageProviders)
		{
			if (imageProvider instanceof SapphireDiagramImageProvider)
			{
				sapphireImageProvider = (SapphireDiagramImageProvider)imageProvider;
				break;
			}
		}
		if (sapphireImageProvider != null)
		{
			List<DiagramNodeTemplate> nodeTemplates = this.diagramPart.getNodeTemplates();
			for (DiagramNodeTemplate nodeTemplate : nodeTemplates)
			{
				IDiagramNodeDef nodeDef = nodeTemplate.getDefinition();
				if (nodeDef.getImage().element() != null)
				{
					IDiagramNodeImageDef imageDef = nodeDef.getImage().element();
					ISapphireUiDef uiDef = imageDef.nearest(ISapphireUiDef.class);
					String imageId = imageDef.getImageId().getContent();
					String imagePath = imageDef.getImagePath().getContent();
					
					String bundleId = resolveImageBundle(uiDef, imagePath);
					// Graphiti's image provider doesn't support images from different plugins.
					// See http://www.eclipse.org/forums/index.php?t=tree&th=201973&start=0&S=3813ad4d99f2ac8bd56a0072ffa6ebd9
					if (bundleId != null)
					{
						sapphireImageProvider.setPluginId(bundleId);
					}
					
					if (imageId != null && imagePath != null)
					{
						sapphireImageProvider.registerImage(imageId, imagePath);
					}
				}
			}
		}
	}
	
    @Override
    public IToolBehaviorProvider[] getAvailableToolBehaviorProviders() 
    {
        if (this.toolBehaviorProviders == null) 
        {
            this.toolBehaviorProviders =
                new IToolBehaviorProvider[] { new SapphireDiagramToolBehaviorProvider(this) };
        }
        return this.toolBehaviorProviders;
    }
	
    @Override
    public void postInit() 
    {    	
    	SapphireDiagramEditor sapphireEditor = (SapphireDiagramEditor)getDiagramEditor();
    	sapphireEditor.syncDiagramWithModel();
    	sapphireEditor.doSave(null);
    }
    
    private String resolveImageBundle(ISapphireUiDef def, String imagePath)
    {
    	try
    	{
	    	for (IImportDirective directive : def.getImportDirectives())
	    	{
	            final String bundleId = directive.getBundle().getText();
	            Bundle bundle = Platform.getBundle(bundleId);
	            URL url = BundleUtility.find(bundle, imagePath);
				URL locatedURL = FileLocator.toFileURL(url);
				if ("file".equalsIgnoreCase(locatedURL.getProtocol()))
				{
					String fullPath = new Path(locatedURL.getPath()).toOSString();
					File f = new File(fullPath);
					if (f.exists())
					{
						return bundleId;
					}
				}
	    	}
    	}
    	catch (IOException e)
    	{
    		SapphireUiFrameworkPlugin.log(e);
    	}
    	return null;
    }
}

Return to bug 330482

Lines 148-152 Link Here

(-)plugin.xml (+19 lines)
148	id="org.eclipse.sapphire.samples.ezbug.ui.BugDatabaseEditor"	148	id="org.eclipse.sapphire.samples.ezbug.ui.BugDatabaseEditor"
149	name="Bug Database Editor (Sapphire Sample)"/>	149	name="Bug Database Editor (Sapphire Sample)"/>
150	</extension>	150	</extension>
		151
		152	<extension point="org.eclipse.ui.editors">
		153	<editor
		154	class="org.eclipse.sapphire.samples.map.ui.MapEditor"
		155	default="true"
		156	filenames="map.xml"
		157	id="org.eclipse.sapphire.samples.map.ui.MapEditor"
		158	name="Map Editor"/>
		159	</extension>
		160
		161	<extension point="org.eclipse.ui.editors">
		162	<editor
		163	class="org.eclipse.sapphire.samples.library.ui.LibraryEditor"
		164	default="true"
		165	filenames="library.xml"
		166	id="org.eclipse.sapphire.samples.library.ui.LibraryEditor"
		167	name="Library Editor"/>
		168	</extension>
		169
151		170
152	</plugin>	171	</plugin>

Added Link Here

(-)sdef/LibraryEditor.sdef (+104 lines)
1	<definition>
2
3	<import>
4	<bundle>org.eclipse.sapphire.samples</bundle>
5	<package>org.eclipse.sapphire.samples.library</package>
6	<package>org.eclipse.sapphire.samples.library.ui</package>
7	<package>org.eclipse.sapphire.samples.library.internal</package>
8	</import>
9
10	<diagram-page>
11	<id>diagram</id>
12	<page-name>Diagram</page-name>
13	<page-header-text>Diagram</page-header-text>
14	<node>
15	<hint><name>width</name><value>95</value></hint>
16	<hint><name>height</name><value>85</value></hint>
17	<hint><name>resizable</name><value>false</value></hint>
18	<id>books</id>
19	<tool-palette-label>Book</tool-palette-label>
20	<tool-palette-desc>Book</tool-palette-desc>
21	<property>Books</property>
22	<image>
23	<id>bookImage</id>
24	<path>images/book.png</path>
25	<hint><name>x</name><value>0</value></hint>
26	<hint><name>y</name><value>0</value></hint>
27	<hint><name>width</name><value>64</value></hint>
28	<hint><name>height</name><value>64</value></hint>
29	</image>
30	<label>
31	<content>${Title == null ? "<Title>" : Title}</content>
32	<hint><name>x</name><value>0</value></hint>
33	<hint><name>y</name><value>70</value></hint>
34	<hint><name>height</name><value>15</value></hint>
35	</label>
36	<instance-id>${Title}</instance-id>
37	<connection>
38	<id>connections</id>
39	<tool-palette-label>Book Reference</tool-palette-label>
40	<tool-palette-desc>Book Reference</tool-palette-desc>
41	<property>ReferencedBooks</property>
42	<label>
43	<content>Reference</content>
44	</label>
45	<endpoint>
46	<property>ReferencedBook</property>
47	<value>${Title}</value>
48	<type>ARROW</type>
49	</endpoint>
50	<instance-id>${ReferencedBook}</instance-id>
51	</connection>
52	</node>
53	</diagram-page>
54
55	<editor-page>
56	<id>overview</id>
57	<page-name>Overview</page-name>
58	<page-header-text>Overview</page-header-text>
59	<root-node>
60	<node>
61	<label>Books</label>
62	<section>
63	<description>Books in the library</description>
64	<content>
65	<property-editor>
66	<property>Books</property>
67	<child-property>
68	<property>Title</property>
69	</child-property>
70	<child-property>
71	<property>Author</property>
72	</child-property>
73	<hint><name>show.label.above</name><value>true</value></hint>
74	<hint>
75	<name>column.widths</name>
76	<value>150,150</value>
77	</hint>
78	</property-editor>
79	<separator>
80	<label>References</label>
81	</separator>
82	<switching-panel>
83	<list-selection-controller>
84	<property>Books</property>
85	</list-selection-controller>
86	<panel>
87	<key>IBook</key>
88	<content>
89	<property-editor>ReferencedBooks</property-editor>
90	</content>
91	</panel>
92	<default-panel>
93	<content>
94	<label>Select a book above to configure additional properties.</label>
95	</content>
96	</default-panel>
97	</switching-panel>
98	</content>
99	</section>
100	</node>
101	</root-node>
102	</editor-page>
103
104	</definition>

Added Link Here

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

Added Link Here

(-)src/org/eclipse/sapphire/samples/library/IBook.java (+53 lines)
1	package org.eclipse.sapphire.samples.library;
2
3	import org.eclipse.sapphire.modeling.IModelElement;
4	import org.eclipse.sapphire.modeling.ListProperty;
5	import org.eclipse.sapphire.modeling.ModelElementList;
6	import org.eclipse.sapphire.modeling.ModelElementType;
7	import org.eclipse.sapphire.modeling.Value;
8	import org.eclipse.sapphire.modeling.ValueProperty;
9	import org.eclipse.sapphire.modeling.annotations.GenerateImpl;
10	import org.eclipse.sapphire.modeling.annotations.Label;
11	import org.eclipse.sapphire.modeling.annotations.NonNullValue;
12	import org.eclipse.sapphire.modeling.annotations.Type;
13	import org.eclipse.sapphire.modeling.xml.annotations.XmlBinding;
14	import org.eclipse.sapphire.modeling.xml.annotations.XmlListBinding;
15
16	@GenerateImpl
17
18	public interface IBook extends IModelElement
19	{
20	ModelElementType TYPE = new ModelElementType( IBook.class );
21
22	// * Title *
23
24	@XmlBinding( path = "title" )
25	@Label( standard = "title" )
26	@NonNullValue
27
28	ValueProperty PROP_TITLE = new ValueProperty( TYPE, "Title" );
29
30	Value<String> getTitle();
31	void setTitle( String name );
32
33	// * Author *
34
35	@XmlBinding( path = "Author" )
36	@Label( standard = "Author" )
37	@NonNullValue
38
39	ValueProperty PROP_AUTHOR = new ValueProperty( TYPE, "Author" );
40
41	Value<String> getAuthor();
42	void setAuthor( String author );
43
44	// * ReferencedBooks *
45
46	@Type( base = IBookReference.class )
47	@XmlListBinding( mappings = @XmlListBinding.Mapping( element = "referenced-book", type = IBookReference.class ) )
48
49	ListProperty PROP_REFERENCED_BOOKS = new ListProperty( TYPE, "ReferencedBooks" );
50
51	ModelElementList<IBookReference> getReferencedBooks();
52
53	}

Added Link Here

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

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	}

Lines 17-21 Link Here

(-)plugin.xml (-1 / +29 lines)
17	<plugin>	17	<plugin>
18		18
19	<extension point="org.eclipse.sapphire.modeling.extension"/>	19	<extension point="org.eclipse.sapphire.modeling.extension"/>
20		20
		21	<extension point="org.eclipse.graphiti.ui.diagramTypes">
		22	<diagramType
		23	description="%sapphireDiagramTypeDescription"
		24	id="org.eclipse.sapphire.ui.SapphireDiagramType"
		25	name="%sapphireDiagramTypeName"
		26	type="sapphireDiagram">
		27	</diagramType>
		28	</extension>
		29
		30	<extension point="org.eclipse.graphiti.ui.diagramTypeProviders">
		31	<diagramTypeProvider
		32	class="org.eclipse.sapphire.ui.diagram.graphiti.providers.SapphireDiagramTypeProvider"
		33	description="%sapphireDiagramTypeProviderDescription"
		34	id="org.eclipse.sapphire.ui.sapphireDiagramTypeProvider"
		35	name="%sapphireDiagramTypeProviderName">
		36	<diagramType id="org.eclipse.sapphire.ui.SapphireDiagramType"/>
		37	<imageProvider id="org.eclipse.sapphire.diagram.graphiti.SapphireDiagramImageProvider"/>
		38	</diagramTypeProvider>
		39	</extension>
		40
		41	<extension
		42	point="org.eclipse.graphiti.ui.imageProviders">
		43	<imageProvider
		44	class="org.eclipse.sapphire.ui.diagram.graphiti.providers.SapphireDiagramImageProvider"
		45	id="org.eclipse.sapphire.diagram.graphiti.SapphireDiagramImageProvider">
		46	</imageProvider>
		47	</extension>
		48
21	</plugin>	49	</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 (+105 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.el.Function;
12	import org.eclipse.sapphire.modeling.localization.Localizable;
13	import org.eclipse.sapphire.modeling.xml.annotations.XmlBinding;
14	import org.eclipse.sapphire.ui.def.ISapphirePartDef;
15
16	@GenerateImpl
17
18	public interface IDiagramConnectionDef
19
20	extends ISapphirePartDef
21
22	{
23	ModelElementType TYPE = new ModelElementType( IDiagramConnectionDef.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	// * Property *
36
37	@Label( standard = "property" )
38	@XmlBinding( path = "property" )
39
40	ValueProperty PROP_PROPERTY = new ValueProperty( TYPE, "Property" );
41
42	Value<String> getProperty();
43	void setProperty( String property );
44
45	// * ToolPaletteLabel *
46
47	@Label( standard = "tool palette label" )
48	@XmlBinding( path = "tool-palette-label" )
49
50	ValueProperty PROP_TOOL_PALETTE_LABEL = new ValueProperty( TYPE, "ToolPaletteLabel" );
51
52	Value<String> getToolPaletteLabel();
53	void setToolPaletteLabel( String paletteLabel );
54
55	// * ToolPaletteDesc *
56
57	@Label( standard = "tool palette description" )
58	@XmlBinding( path = "tool-palette-desc" )
59
60	ValueProperty PROP_TOOL_PALETTE_DESC = new ValueProperty( TYPE, "ToolPaletteDesc" );
61
62	Value<String> getToolPaletteDesc();
63	void setToolPaletteDesc( String paletteDesc );
64
65	// * Label *
66
67	@Type( base = IDiagramLabelDef.class )
68	@XmlBinding( path = "label" )
69
70	ElementProperty PROP_LABEL = new ElementProperty( TYPE, "Label" );
71
72	ModelElementHandle<IDiagramLabelDef> getLabel();
73
74	// * Endpoint1 *
75
76	@Type( base = IDiagramConnectionEndpointDef.class )
77	@XmlBinding( path = "endpoint1" )
78
79	ElementProperty PROP_ENDPOINT_1 = new ElementProperty( TYPE, "Endpoint1" );
80
81	ModelElementHandle<IDiagramConnectionEndpointDef> getEndpoint1();
82
83	// * Endpoint2 *
84
85	@Type( base = IDiagramConnectionEndpointDef.class )
86	@XmlBinding( path = "endpoint2" )
87
88	ElementProperty PROP_ENDPOINT_2 = new ElementProperty( TYPE, "Endpoint2" );
89
90	ModelElementHandle<IDiagramConnectionEndpointDef> getEndpoint2();
91
92	// * InstanceId *
93
94	@Type( base = Function.class )
95	@Label( standard = "instance id" )
96	@Localizable
97	@XmlBinding( path = "instance-id" )
98
99	ValueProperty PROP_INSTANCE_ID = new ValueProperty( TYPE, "InstanceId" );
100
101	Value<Function> getInstanceId();
102	void setInstanceId( String value );
103	void setInstanceId( Function value );
104
105	}

Added Link Here

(-)src/org/eclipse/sapphire/ui/diagram/editor/DiagramConnectionPart.java (+474 lines)
1	package org.eclipse.sapphire.ui.diagram.editor;
2
3	import org.eclipse.emf.transaction.RecordingCommand;
4	import org.eclipse.emf.transaction.TransactionalEditingDomain;
5	import org.eclipse.emf.transaction.util.TransactionUtil;
6	import org.eclipse.graphiti.features.IAddFeature;
7	import org.eclipse.graphiti.features.IFeatureProvider;
8	import org.eclipse.graphiti.features.IRemoveFeature;
9	import org.eclipse.graphiti.features.context.IRemoveContext;
10	import org.eclipse.graphiti.features.context.impl.AddConnectionContext;
11	import org.eclipse.graphiti.features.context.impl.RemoveContext;
12	import org.eclipse.graphiti.features.context.impl.UpdateContext;
13	import org.eclipse.graphiti.mm.pictograms.Connection;
14	import org.eclipse.graphiti.mm.pictograms.ContainerShape;
15	import org.eclipse.graphiti.mm.pictograms.Diagram;
16	import org.eclipse.graphiti.mm.pictograms.PictogramElement;
17	import org.eclipse.sapphire.modeling.IModelElement;
18	import org.eclipse.sapphire.modeling.ModelElementType;
19	import org.eclipse.sapphire.modeling.ModelProperty;
20	import org.eclipse.sapphire.modeling.ModelPropertyChangeEvent;
21	import org.eclipse.sapphire.modeling.ModelPropertyListener;
22	import org.eclipse.sapphire.modeling.ReferenceValue;
23	import org.eclipse.sapphire.modeling.Value;
24	import org.eclipse.sapphire.modeling.ValueProperty;
25	import org.eclipse.sapphire.modeling.el.Function;
26	import org.eclipse.sapphire.modeling.el.FunctionResult;
27	import org.eclipse.sapphire.ui.SapphirePart;
28	import org.eclipse.sapphire.ui.SapphireRenderingContext;
29	import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionDef;
30	import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionEndpointDef;
31
32	public class DiagramConnectionPart extends SapphirePart
33	{
34	protected DiagramConnectionTemplate connectionTemplate;
35	private IDiagramConnectionDef localDefinition;
36	protected IModelElement modelElement;
37	private IDiagramConnectionEndpointDef endpoint1Def;
38	private IDiagramConnectionEndpointDef endpoint2Def;
39	private IModelElement endpoint1Model;
40	private IModelElement endpoint2Model;
41	protected FunctionResult labelFunctionResult;
42	protected ValueProperty labelProperty;
43	protected FunctionResult idFunctionResult;
44	private FunctionResult endpoint1FunctionResult;
45	private FunctionResult endpoint2FunctionResult;
46	protected ModelPropertyListener modelPropertyListener;
47
48	public DiagramConnectionPart() {}
49
50	public DiagramConnectionPart(DiagramConnectionTemplate connectionTemplate)
51	{
52	this.connectionTemplate = connectionTemplate;
53	}
54
55	@Override
56	protected void init()
57	{
58	super.init();
59
60	this.localDefinition = (IDiagramConnectionDef)super.definition;
61	this.modelElement = getModelElement();
62	this.labelFunctionResult = initExpression
63	(
64	this.modelElement,
65	this.localDefinition.getLabel().element().getContent(),
66	new Runnable()
67	{
68	public void run()
69	{
70	refreshLabel();
71	}
72	}
73	);
74
75	this.labelProperty = FunctionUtil.getFunctionProperty(this.modelElement,
76	this.labelFunctionResult);
77
78	this.idFunctionResult = initExpression
79	(
80	this.modelElement,
81	this.localDefinition.getInstanceId(),
82	new Runnable()
83	{
84	public void run()
85	{
86	}
87	}
88	);
89
90	this.endpoint1Def = this.localDefinition.getEndpoint1().element();
91	this.endpoint1Model = processEndpoint(this.endpoint1Def);
92	if (this.endpoint1Model != null)
93	{
94	this.endpoint1FunctionResult = initExpression
95	(
96	this.endpoint1Model,
97	this.endpoint1Def.getValue(),
98	new Runnable()
99	{
100	public void run()
101	{
102	refreshEndpoint1();
103	}
104	}
105	);
106	}
107
108	this.endpoint2Def = this.localDefinition.getEndpoint2().element();
109	this.endpoint2Model = processEndpoint(this.endpoint2Def);
110	if (this.endpoint2Model != null)
111	{
112	this.endpoint2FunctionResult = initExpression
113	(
114	this.endpoint2Model,
115	this.endpoint2Def.getValue(),
116	new Runnable()
117	{
118	public void run()
119	{
120	refreshEndpoint2();
121	}
122	}
123	);
124	}
125
126	// Add model property listener
127	this.modelPropertyListener = new ModelPropertyListener()
128	{
129	@Override
130	public void handlePropertyChangedEvent( final ModelPropertyChangeEvent event )
131	{
132	handleModelPropertyChange( event );
133	}
134	};
135	addModelListener();
136	}
137
138	public DiagramConnectionTemplate getDiagramConnectionTemplate()
139	{
140	return this.connectionTemplate;
141	}
142
143	public IModelElement getLocalModelElement()
144	{
145	return this.modelElement;
146	}
147
148	public IModelElement getEndpoint1()
149	{
150	return this.endpoint1Model;
151	}
152
153	public IModelElement getEndpoint2()
154	{
155	return this.endpoint2Model;
156	}
157
158	public boolean canEditLabel()
159	{
160	return this.labelProperty != null;
161	}
162
163	public String getLabel()
164	{
165	String label = null;
166
167	if( this.labelFunctionResult != null )
168	{
169	label = (String) this.labelFunctionResult.value();
170	}
171
172	if( label == null )
173	{
174	label = "#null#";
175	}
176
177	return label;
178	}
179
180	public void setLabel(String newValue)
181	{
182	if (this.labelProperty != null)
183	{
184	this.modelElement.write(this.labelProperty, newValue);
185	}
186	}
187
188	public void refreshLabel()
189	{
190	final SapphireDiagramEditorPart diagramEditor = (SapphireDiagramEditorPart)getParentPart();
191	final IFeatureProvider fp =
192	diagramEditor.getDiagramEditor().getDiagramTypeProvider().getFeatureProvider();
193	final PictogramElement pe = getConnection(fp, this);
194	if (pe != null)
195	{
196	UpdateContext context = new UpdateContext(pe);
197	fp.updateIfPossible(context);
198	}
199
200	}
201
202	public String getInstanceId()
203	{
204	String id = null;
205
206	if( this.idFunctionResult != null )
207	{
208	id = (String) this.idFunctionResult.value();
209	}
210
211	if( id == null )
212	{
213	id = "#null#";
214	}
215
216	return id;
217	}
218
219	@Override
220	public void render(SapphireRenderingContext context)
221	{
222	throw new UnsupportedOperationException();
223	}
224
225	@Override
226	public void dispose()
227	{
228	super.dispose();
229	if (this.labelFunctionResult != null)
230	{
231	this.labelFunctionResult.dispose();
232	}
233	if (this.idFunctionResult != null)
234	{
235	this.idFunctionResult.dispose();
236	}
237	if (this.endpoint1FunctionResult != null)
238	{
239	this.endpoint1FunctionResult.dispose();
240	}
241	if (this.endpoint2FunctionResult != null)
242	{
243	this.endpoint2FunctionResult.dispose();
244	}
245	}
246
247	public void refreshEndpoint1()
248	{
249	if (this.endpoint1FunctionResult != null)
250	{
251	Object value = this.endpoint1FunctionResult.value();
252	String property = this.endpoint1Def.getProperty().getContent();
253	setModelProperty(this.modelElement, property, value);
254	}
255	}
256
257	public void refreshEndpoint2()
258	{
259	if (this.endpoint2FunctionResult != null)
260	{
261	Object value = this.endpoint2FunctionResult.value();
262	String property = this.endpoint2Def.getProperty().getContent();
263	setModelProperty(this.modelElement, property, value);
264	}
265	}
266
267	protected IModelElement processEndpoint(IDiagramConnectionEndpointDef endpointDef)
268	{
269	String propertyName = endpointDef.getProperty().getContent();
270	ModelProperty modelProperty = resolve(this.modelElement, propertyName);
271	if (!(modelProperty instanceof ValueProperty))
272	{
273	throw new RuntimeException( "Property " + propertyName + " not a ValueProperty");
274	}
275	ValueProperty property = (ValueProperty)modelProperty;
276	Value<?> valObj = this.modelElement.read(property);
277	if (!(valObj instanceof ReferenceValue))
278	{
279	throw new RuntimeException( "Property " + propertyName + " value not a reference");
280	}
281	ReferenceValue<?> refVal = (ReferenceValue<?>)valObj;
282	Object targetObj = refVal.resolve();
283	return (IModelElement)targetObj;
284	}
285
286	protected void setModelProperty(final IModelElement modelElement,
287	String propertyName, Object value)
288	{
289	if (propertyName != null)
290	{
291	final ModelElementType type = modelElement.getModelElementType();
292	final ModelProperty property = type.getProperty( propertyName );
293	if( property == null )
294	{
295	throw new RuntimeException( "Could not find property " + propertyName + " in " + type.getQualifiedName() );
296	}
297	if (!(property instanceof ValueProperty))
298	{
299	throw new RuntimeException( "Property " + propertyName + " not a ValueProperty");
300	}
301
302	modelElement.write((ValueProperty)property, value);
303	}
304	}
305
306	public void addModelListener()
307	{
308	this.modelElement.addListener(this.modelPropertyListener,
309	this.endpoint1Def.getProperty().getContent());
310	this.modelElement.addListener(this.modelPropertyListener,
311	this.endpoint2Def.getProperty().getContent());
312	}
313
314	public void removeModelListener()
315	{
316	this.modelElement.removeListener(this.modelPropertyListener,
317	this.endpoint1Def.getProperty().getContent());
318	this.modelElement.removeListener(this.modelPropertyListener,
319	this.endpoint2Def.getProperty().getContent());
320	}
321
322	protected void handleModelPropertyChange(final ModelPropertyChangeEvent event)
323	{
324	final ModelProperty property = event.getProperty();
325
326	if (property.getName().equals(this.endpoint1Def.getProperty().getContent()) \|\|
327	property.getName().equals(this.endpoint2Def.getProperty().getContent()))
328	{
329	SapphireDiagramEditorPart diagramEditor = (SapphireDiagramEditorPart)getParentPart();
330	final IFeatureProvider fp = diagramEditor.getDiagramEditor().getDiagramTypeProvider().getFeatureProvider();
331	final Diagram diagram = diagramEditor.getDiagramEditor().getDiagramTypeProvider().getDiagram();
332	final TransactionalEditingDomain ted = TransactionUtil.getEditingDomain(diagram);
333
334	removeDiagramConnection(fp, ted);
335
336	boolean sourceChange = property.getName().equals(this.endpoint1Def.getProperty().getContent()) ? true : false;
337	handleEndpointChange(sourceChange);
338	// add new connection to the diagram
339	addNewConnectionIfPossible(fp, ted, diagramEditor);
340	}
341	}
342
343	private void handleEndpointChange(boolean sourceChange)
344	{
345	if (sourceChange)
346	{
347	this.endpoint1Model = processEndpoint(this.endpoint1Def);
348	if (this.endpoint1FunctionResult != null)
349	{
350	this.endpoint1FunctionResult.dispose();
351	this.endpoint1FunctionResult = null;
352	}
353	if (this.endpoint1Model != null)
354	{
355	this.endpoint1FunctionResult = initExpression
356	(
357	this.endpoint1Model,
358	this.endpoint1Def.getValue(),
359	new Runnable()
360	{
361	public void run()
362	{
363	refreshEndpoint1();
364	}
365	}
366	);
367	}
368	}
369	else
370	{
371	this.endpoint2Model = processEndpoint(this.endpoint2Def);
372	if (this.endpoint2FunctionResult != null)
373	{
374	this.endpoint2FunctionResult.dispose();
375	this.endpoint2FunctionResult = null;
376	}
377	if (this.endpoint2Model != null)
378	{
379	this.endpoint2FunctionResult = initExpression
380	(
381	this.endpoint2Model,
382	this.endpoint2Def.getValue(),
383	new Runnable()
384	{
385	public void run()
386	{
387	refreshEndpoint2();
388	}
389	}
390	);
391	}
392	}
393	}
394
395	protected void removeDiagramConnection(IFeatureProvider fp, TransactionalEditingDomain ted)
396	{
397	// remove the existing connection pe from the diagram
398	if (this.getEndpoint1() != null && this.getEndpoint2() != null)
399	{
400	PictogramElement pe = getConnection(fp, this);
401	if (pe != null)
402	{
403	final IRemoveContext rc = new RemoveContext(pe);
404	final IRemoveFeature removeFeature = fp.getRemoveFeature(rc);
405	if (removeFeature != null)
406	{
407	ted.getCommandStack().execute(new RecordingCommand(ted)
408	{
409	protected void doExecute()
410	{
411	removeFeature.remove(rc);
412	}
413	});
414	}
415	}
416	}
417	}
418
419	protected void addNewConnectionIfPossible(IFeatureProvider fp, TransactionalEditingDomain ted,
420	SapphireDiagramEditorPart diagramEditor)
421	{
422	// add new connection to the diagram
423	if (this.getEndpoint1() != null && this.getEndpoint2() != null)
424	{
425	DiagramNodePart srcNodePart = diagramEditor.getDiagramNodePart(this.getEndpoint1());
426	DiagramNodePart targetNodePart = diagramEditor.getDiagramNodePart(this.getEndpoint2());
427	ContainerShape srcNode = getContainerShape(fp, srcNodePart);
428	ContainerShape targetNode = getContainerShape(fp, targetNodePart);
429	final AddConnectionContext addContext =
430	new AddConnectionContext(srcNode.getAnchors().get(0), targetNode.getAnchors().get(0));
431	addContext.setNewObject(this);
432	final IAddFeature addFeature = fp.getAddFeature(addContext);
433	if (addFeature != null)
434	{
435	ted.getCommandStack().execute(new RecordingCommand(ted)
436	{
437	protected void doExecute()
438	{
439	addFeature.add(addContext);
440	}
441	});
442	}
443	}
444	}
445
446	protected Connection getConnection(IFeatureProvider fp, Object bo)
447	{
448	PictogramElement [] pictograms = fp.getAllPictogramElementsForBusinessObject(bo);
449	for (PictogramElement pictogram : pictograms)
450	{
451	if (pictogram instanceof Connection)
452	{
453	return (Connection)pictogram;
454	}
455	}
456	return null;
457	}
458
459	protected ContainerShape getContainerShape(IFeatureProvider fp, Object bo)
460	{
461	ContainerShape containerShape = null;
462	PictogramElement [] pictograms = fp.getAllPictogramElementsForBusinessObject(bo);
463	for (PictogramElement pictogram : pictograms)
464	{
465	if (pictogram instanceof ContainerShape)
466	{
467	containerShape = (ContainerShape)pictogram;
468	break;
469	}
470	}
471	return containerShape;
472	}
473
474	}

Added Link Here

(-)src/org/eclipse/sapphire/ui/diagram/editor/DiagramConnectionTemplate.java (+300 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.emf.transaction.TransactionalEditingDomain;
8	import org.eclipse.emf.transaction.util.TransactionUtil;
9	import org.eclipse.graphiti.features.IFeatureProvider;
10	import org.eclipse.graphiti.mm.pictograms.Diagram;
11	import org.eclipse.sapphire.modeling.IModelElement;
12	import org.eclipse.sapphire.modeling.ListProperty;
13	import org.eclipse.sapphire.modeling.ModelElementList;
14	import org.eclipse.sapphire.modeling.ModelElementType;
15	import org.eclipse.sapphire.modeling.ModelProperty;
16	import org.eclipse.sapphire.modeling.ModelPropertyChangeEvent;
17	import org.eclipse.sapphire.modeling.ModelPropertyListener;
18	import org.eclipse.sapphire.modeling.Value;
19	import org.eclipse.sapphire.modeling.ValueProperty;
20	import org.eclipse.sapphire.modeling.annotations.Reference;
21	import org.eclipse.sapphire.modeling.el.FailSafeFunction;
22	import org.eclipse.sapphire.modeling.el.Function;
23	import org.eclipse.sapphire.modeling.el.FunctionResult;
24	import org.eclipse.sapphire.modeling.el.ModelElementFunctionContext;
25	import org.eclipse.sapphire.modeling.localization.LocalizationService;
26	import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionDef;
27	import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionEndpointDef;
28
29	public class DiagramConnectionTemplate
30	{
31	protected SapphireDiagramEditorPart diagramEditor;
32	private IDiagramConnectionDef definition;
33	protected IModelElement modelElement;
34	protected String propertyName;
35	private ListProperty modelProperty;
36	protected String toolPaletteLabel;
37	protected String toolPaletteDesc;
38	protected ModelPropertyListener modelPropertyListener;
39
40	private List<DiagramConnectionPart> diagramConnections;
41
42	public DiagramConnectionTemplate() {}
43
44	public DiagramConnectionTemplate(final SapphireDiagramEditorPart diagramEditor,
45	IDiagramConnectionDef definition, IModelElement modelElement)
46	{
47	this.diagramEditor = diagramEditor;
48	this.modelElement = modelElement;
49	this.definition = definition;
50
51	this.toolPaletteLabel = this.definition.getToolPaletteLabel().getContent();
52	this.toolPaletteDesc = this.definition.getToolPaletteDesc().getContent();
53
54	this.diagramConnections = new ArrayList<DiagramConnectionPart>();
55
56	this.propertyName = this.definition.getProperty().getContent();
57	this.modelProperty = (ListProperty)resolve(this.modelElement, this.propertyName);
58
59	ModelElementList<?> list = this.modelElement.read(this.modelProperty);
60	for( IModelElement listEntryModelElement : list )
61	{
62	DiagramConnectionPart connection = new DiagramConnectionPart(this);
63	connection.init(this.diagramEditor, listEntryModelElement, definition,
64	Collections.<String,String>emptyMap());
65	addConnectionPart(null, connection);
66	}
67
68	// Add model property listener
69	this.modelPropertyListener = new ModelPropertyListener()
70	{
71	@Override
72	public void handlePropertyChangedEvent( final ModelPropertyChangeEvent event )
73	{
74	handleModelPropertyChange( event );
75	}
76	};
77	addModelListener();
78	}
79
80	public List<DiagramConnectionPart> getDiagramConnections(IModelElement srcNodeModel)
81	{
82	return this.diagramConnections;
83	}
84
85	public String getToolPaletteLabel()
86	{
87	return this.toolPaletteLabel;
88	}
89
90	public String getToolPaletteDesc()
91	{
92	return this.toolPaletteDesc;
93	}
94
95	public boolean canCreateNewConnection(DiagramNodePart srcNode, DiagramNodePart targetNode)
96	{
97	boolean canCreate = false;
98	ModelElementType srcType = srcNode.getModelElement().getModelElementType();
99	ModelElementType targetType = targetNode.getModelElement().getModelElementType();
100
101	ModelElementType type = this.modelProperty.getType();
102	ModelProperty prop1 = type.getProperty(this.definition.getEndpoint1().element().getProperty().getContent());
103	if (prop1.getType() == null && prop1.hasAnnotation(Reference.class))
104	{
105	canCreate = prop1.getAnnotation(Reference.class).target().isAssignableFrom(srcType.getModelElementClass());
106	if (!canCreate)
107	return false;
108	}
109	ModelProperty prop2 = type.getProperty(this.definition.getEndpoint2().element().getProperty().getContent());
110	if (prop2.getType() == null && prop2.hasAnnotation(Reference.class))
111	{
112	canCreate = prop2.getAnnotation(Reference.class).target().isAssignableFrom(targetType.getModelElementClass());
113	}
114	return canCreate;
115	}
116
117	public void addModelListener()
118	{
119	this.modelElement.addListener(this.modelPropertyListener, this.propertyName);
120	}
121
122	public void removeModelLister()
123	{
124	this.modelElement.removeListener(this.modelPropertyListener, this.propertyName);
125	}
126
127	public SapphireDiagramEditorPart getDiagramEditor()
128	{
129	return this.diagramEditor;
130	}
131
132	public DiagramConnectionPart createNewDiagramConnection(DiagramNodePart srcNode,
133	DiagramNodePart targetNode)
134	{
135	ModelElementList<?> list = this.modelElement.read(this.modelProperty);
136	IModelElement newElement = list.addNewElement();
137
138	IDiagramConnectionEndpointDef srcAnchorDef = this.definition.getEndpoint1().element();
139	String srcProperty = srcAnchorDef.getProperty().getContent();
140	Value<Function> srcFunc = srcAnchorDef.getValue();
141	FunctionResult srcFuncResult = getNodeReferenceFunction(srcNode, srcFunc);
142	if (srcFuncResult != null)
143	{
144	setModelProperty(newElement, srcProperty, srcFuncResult.value());
145	srcFuncResult.dispose();
146	}
147
148	IDiagramConnectionEndpointDef targetAnchorDef = this.definition.getEndpoint2().element();
149	String targetProperty = targetAnchorDef.getProperty().getContent();
150	Value<Function> targetFunc = targetAnchorDef.getValue();;
151	FunctionResult targetFuncResult = getNodeReferenceFunction(targetNode, targetFunc);
152	if (targetFuncResult != null)
153	{
154	setModelProperty(newElement, targetProperty, targetFuncResult.value());
155	targetFuncResult.dispose();
156	}
157
158	DiagramConnectionPart newConn = new DiagramConnectionPart(this);
159	newConn.init(this.diagramEditor, newElement, this.definition,
160	Collections.<String,String>emptyMap());
161	addConnectionPart(null, newConn);
162	return newConn;
163	}
164
165	public DiagramConnectionPart createNewDiagramConnection(IModelElement connElement, IModelElement srcNodeElement)
166	{
167	DiagramConnectionPart connPart = new DiagramConnectionPart(this);
168	connPart.init(this.diagramEditor, connElement, this.definition,
169	Collections.<String,String>emptyMap());
170	addConnectionPart(null, connPart);
171	return connPart;
172	}
173
174	protected ModelProperty resolve(final IModelElement modelElement,
175	String propertyName)
176	{
177	if (propertyName != null)
178	{
179	final ModelElementType type = modelElement.getModelElementType();
180	final ModelProperty property = type.getProperty( propertyName );
181	if( property == null )
182	{
183	throw new RuntimeException( "Could not find property " + propertyName + " in " + type.getQualifiedName() );
184	}
185	return property;
186	}
187	return null;
188	}
189
190	protected void setModelProperty(final IModelElement modelElement,
191	String propertyName, Object value)
192	{
193	if (propertyName != null)
194	{
195	final ModelElementType type = modelElement.getModelElementType();
196	final ModelProperty property = type.getProperty( propertyName );
197	if( property == null )
198	{
199	throw new RuntimeException( "Could not find property " + propertyName + " in " + type.getQualifiedName() );
200	}
201	if (!(property instanceof ValueProperty))
202	{
203	throw new RuntimeException( "Property " + propertyName + " not a ValueProperty");
204	}
205
206	modelElement.write((ValueProperty)property, value);
207	}
208	}
209
210	protected FunctionResult getNodeReferenceFunction(final DiagramNodePart nodePart,
211	final Value<Function> function)
212	{
213	Function f = null;
214	FunctionResult fr = null;
215
216	if( function != null )
217	{
218	f = function.getContent();
219	}
220
221	if( f != null )
222	{
223
224	f = FailSafeFunction.create( f, String.class );
225	fr = f.evaluate( new ModelElementFunctionContext( nodePart.getLocalModelElement(), this.definition.adapt( LocalizationService.class ) ) );
226	}
227	return fr;
228	}
229
230	protected void handleModelPropertyChange(final ModelPropertyChangeEvent event)
231	{
232	final IModelElement element = event.getModelElement();
233	final ModelProperty property = event.getProperty();
234	ModelElementList<?> newList = (ModelElementList<?>)element.read(property);
235
236	if (newList.size() != getDiagramConnections(element).size())
237	{
238	List<DiagramConnectionPart> connParts = getDiagramConnections(element);
239	List<IModelElement> oldList = new ArrayList<IModelElement>(connParts.size());
240	for (DiagramConnectionPart connPart : connParts)
241	{
242	oldList.add(connPart.getLocalModelElement());
243	}
244
245	final IFeatureProvider fp = this.diagramEditor.getDiagramEditor().getDiagramTypeProvider().getFeatureProvider();
246	final Diagram diagram = this.diagramEditor.getDiagramEditor().getDiagramTypeProvider().getDiagram();
247	final TransactionalEditingDomain ted = TransactionUtil.getEditingDomain(diagram);
248
249	if (newList.size() > oldList.size())
250	{
251	// new connections are added
252	List<IModelElement> newConns = ListUtil.ListDiff(newList, oldList);
253	for (IModelElement newConn : newConns)
254	{
255	DiagramConnectionPart connPart = createNewDiagramConnection(newConn, element);
256	connPart.addNewConnectionIfPossible(fp, ted, this.diagramEditor);
257	}
258	}
259	else
260	{
261	// connections are deleted
262	List<IModelElement> deletedConns = ListUtil.ListDiff(newList, oldList);
263	for (IModelElement deletedConn : deletedConns)
264	{
265	DiagramConnectionPart connPart = getConnectionPart(element, deletedConn);
266	if (connPart != null)
267	{
268	connPart.removeDiagramConnection(fp, ted);
269	connPart.dispose();
270	removeConnectionPart(element, connPart);
271	}
272	}
273	}
274	}
275	}
276
277	protected void addConnectionPart(IModelElement srcNodeModel, DiagramConnectionPart connPart)
278	{
279	this.diagramConnections.add(connPart);
280	}
281
282	protected void removeConnectionPart(IModelElement srcNodeModel, DiagramConnectionPart connPart)
283	{
284	this.diagramConnections.remove(connPart);
285	}
286
287	protected DiagramConnectionPart getConnectionPart(IModelElement srcNodeModel, IModelElement connModel)
288	{
289	List<DiagramConnectionPart> connParts = getDiagramConnections(srcNodeModel);
290	for (DiagramConnectionPart connPart : connParts)
291	{
292	if (connPart.getLocalModelElement().equals(connModel))
293	{
294	return connPart;
295	}
296	}
297	return null;
298	}
299
300	}

Added Link Here

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

Added Link Here

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

Added Link Here

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

Added Link Here

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

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/features/SapphireResizeShapeFeature.java (+41 lines)
1	package org.eclipse.sapphire.ui.diagram.graphiti.features;
2
3	import org.eclipse.graphiti.features.DefaultResizeConfiguration;
4	import org.eclipse.graphiti.features.IFeatureProvider;
5	import org.eclipse.graphiti.features.IResizeConfiguration;
6	import org.eclipse.graphiti.features.context.IResizeShapeContext;
7	import org.eclipse.graphiti.features.impl.DefaultResizeShapeFeature;
8	import org.eclipse.graphiti.mm.pictograms.PictogramElement;
9	import org.eclipse.sapphire.ui.diagram.editor.DiagramNodePart;
10
11	public class SapphireResizeShapeFeature extends DefaultResizeShapeFeature
12	{
13	public SapphireResizeShapeFeature(IFeatureProvider fp)
14	{
15	super(fp);
16	}
17
18	@Override
19	public boolean canResizeShape(IResizeShapeContext context)
20	{
21	PictogramElement pe = context.getPictogramElement();
22	Object bo = getBusinessObjectForPictogramElement(pe);
23	if (bo instanceof DiagramNodePart)
24	{
25	DiagramNodePart nodePart = (DiagramNodePart)bo;
26	return nodePart.canResizeShape();
27	}
28	return super.canResizeShape(context);
29	}
30
31	@Override
32	public IResizeConfiguration getResizeConfiguration(IResizeShapeContext context)
33	{
34	if (!canResizeShape(context))
35	{
36	return new NoResizeConfiguration();
37	}
38	return new DefaultResizeConfiguration();
39	}
40
41	}

Added Link Here

(-)src/org/eclipse/sapphire/ui/diagram/graphiti/providers/SapphireDiagramImageProvider.java (+23 lines)
1	package org.eclipse.sapphire.ui.diagram.graphiti.providers;
2
3	import org.eclipse.graphiti.ui.platform.AbstractImageProvider;
4
5	public class SapphireDiagramImageProvider extends AbstractImageProvider
6	{
7	public SapphireDiagramImageProvider()
8	{
9	super();
10	}
11
12	@Override
13	protected void addAvailableImages()
14	{
15
16	}
17
18	public void registerImage(String imageId, String imageFilePath)
19	{
20	this.addImageFilePath(imageId, imageFilePath);
21	}
22
23	}

Added Link Here

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

Added Link Here

(-)src/org/eclipse/sapphire/ui/diagram/graphiti/providers/SapphireDiagramTypeProvider.java (+145 lines)
1	package org.eclipse.sapphire.ui.diagram.graphiti.providers;
2
3	import java.io.File;
4	import java.io.IOException;
5	import java.net.URL;
6	import java.util.List;
7
8	import org.eclipse.core.runtime.FileLocator;
9	import org.eclipse.core.runtime.Path;
10	import org.eclipse.core.runtime.Platform;
11	import org.eclipse.graphiti.dt.AbstractDiagramTypeProvider;
12	import org.eclipse.graphiti.mm.pictograms.Diagram;
13	import org.eclipse.graphiti.platform.IDiagramEditor;
14	import org.eclipse.graphiti.tb.IToolBehaviorProvider;
15	import org.eclipse.graphiti.ui.internal.platform.ExtensionManager;
16	import org.eclipse.graphiti.ui.platform.IImageProvider;
17	import org.eclipse.graphiti.ui.services.GraphitiUi;
18	import org.eclipse.sapphire.ui.def.IImportDirective;
19	import org.eclipse.sapphire.ui.def.ISapphireUiDef;
20	import org.eclipse.sapphire.ui.diagram.def.IDiagramNodeDef;
21	import org.eclipse.sapphire.ui.diagram.def.IDiagramNodeImageDef;
22	import org.eclipse.sapphire.ui.diagram.editor.DiagramNodeTemplate;
23	import org.eclipse.sapphire.ui.diagram.editor.SapphireDiagramEditorPart;
24	import org.eclipse.sapphire.ui.diagram.graphiti.editor.SapphireDiagramEditor;
25	import org.eclipse.sapphire.ui.internal.SapphireUiFrameworkPlugin;
26	import org.eclipse.ui.internal.util.BundleUtility;
27	import org.osgi.framework.Bundle;
28
29	public class SapphireDiagramTypeProvider extends AbstractDiagramTypeProvider
30	{
31	private SapphireDiagramEditorPart diagramPart;
32	private SapphireDiagramFeatureProvider featureProvider;
33	private IToolBehaviorProvider[] toolBehaviorProviders;
34
35	public SapphireDiagramTypeProvider()
36	{
37	this.featureProvider =
38	new SapphireDiagramFeatureProvider(this, new SapphireDiagramSolver());
39	setFeatureProvider(this.featureProvider);
40	}
41
42	public void setDiagramPart(SapphireDiagramEditorPart diagramPart)
43	{
44	this.diagramPart = diagramPart;
45	this.featureProvider.setDiagramPart(diagramPart);
46	}
47
48	public SapphireDiagramEditorPart getDiagramPart()
49	{
50	return this.diagramPart;
51	}
52
53	@Override
54	public void init(Diagram diagram, IDiagramEditor diagramEditor)
55	{
56	super.init(diagram, diagramEditor);
57	setDiagramPart(((SapphireDiagramEditor)diagramEditor).getDiagramEditorPart());
58	ExtensionManager extManager = (ExtensionManager)GraphitiUi.getExtensionManager();
59	IImageProvider imageProviders[] = extManager.getImageProviders();
60	SapphireDiagramImageProvider sapphireImageProvider = null;
61	for (IImageProvider imageProvider : imageProviders)
62	{
63	if (imageProvider instanceof SapphireDiagramImageProvider)
64	{
65	sapphireImageProvider = (SapphireDiagramImageProvider)imageProvider;
66	break;
67	}
68	}
69	if (sapphireImageProvider != null)
70	{
71	List<DiagramNodeTemplate> nodeTemplates = this.diagramPart.getNodeTemplates();
72	for (DiagramNodeTemplate nodeTemplate : nodeTemplates)
73	{
74	IDiagramNodeDef nodeDef = nodeTemplate.getDefinition();
75	if (nodeDef.getImage().element() != null)
76	{
77	IDiagramNodeImageDef imageDef = nodeDef.getImage().element();
78	ISapphireUiDef uiDef = imageDef.nearest(ISapphireUiDef.class);
79	String imageId = imageDef.getImageId().getContent();
80	String imagePath = imageDef.getImagePath().getContent();
81
82	String bundleId = resolveImageBundle(uiDef, imagePath);
83	// Graphiti's image provider doesn't support images from different plugins.
84	// See http://www.eclipse.org/forums/index.php?t=tree&th=201973&start=0&S=3813ad4d99f2ac8bd56a0072ffa6ebd9
85	if (bundleId != null)
86	{
87	sapphireImageProvider.setPluginId(bundleId);
88	}
89
90	if (imageId != null && imagePath != null)
91	{
92	sapphireImageProvider.registerImage(imageId, imagePath);
93	}
94	}
95	}
96	}
97	}
98
99	@Override
100	public IToolBehaviorProvider[] getAvailableToolBehaviorProviders()
101	{
102	if (this.toolBehaviorProviders == null)
103	{
104	this.toolBehaviorProviders =
105	new IToolBehaviorProvider[] { new SapphireDiagramToolBehaviorProvider(this) };
106	}
107	return this.toolBehaviorProviders;
108	}
109
110	@Override
111	public void postInit()
112	{
113	SapphireDiagramEditor sapphireEditor = (SapphireDiagramEditor)getDiagramEditor();
114	sapphireEditor.syncDiagramWithModel();
115	sapphireEditor.doSave(null);
116	}
117
118	private String resolveImageBundle(ISapphireUiDef def, String imagePath)
119	{
120	try
121	{
122	for (IImportDirective directive : def.getImportDirectives())
123	{
124	final String bundleId = directive.getBundle().getText();
125	Bundle bundle = Platform.getBundle(bundleId);
126	URL url = BundleUtility.find(bundle, imagePath);
127	URL locatedURL = FileLocator.toFileURL(url);
128	if ("file".equalsIgnoreCase(locatedURL.getProtocol()))
129	{
130	String fullPath = new Path(locatedURL.getPath()).toOSString();
131	File f = new File(fullPath);
132	if (f.exists())
133	{
134	return bundleId;
135	}
136	}
137	}
138	}
139	catch (IOException e)
140	{
141	SapphireUiFrameworkPlugin.log(e);
142	}
143	return null;
144	}
145	}