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

Lines 15-17 Link Here

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




    </builder> 
  </extension> 
  
   <extension point="org.eclipse.graphiti.ui.diagramTypes">
      <diagramType
            description="%sapphireDiagramTypeDescription"
            id="org.eclipse.sapphire.ui.SapphireDiagramType"
            name="%sapphireDiagramTypeName"
            type="sapphireDiagram">
      </diagramType>
   </extension>
   
   <extension point="org.eclipse.graphiti.ui.diagramTypeProviders">
      <diagramTypeProvider
            class="org.eclipse.sapphire.ui.diagram.graphiti.providers.SapphireDiagramTypeProvider"
            description="%sapphireDiagramTypeProviderDescription"
            id="org.eclipse.sapphire.ui.sapphireDiagramTypeProvider"
            name="%sapphireDiagramTypeProviderName">
         <diagramType id="org.eclipse.sapphire.ui.SapphireDiagramType"/>
         <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.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 ***
    
    @Label( standard = "instance id" )
    @XmlBinding( path = "instance-id" )
    
    ValueProperty PROP_INSTANCE_ID = new ValueProperty( TYPE, "InstanceId" );
    
    Value<String> getInstanceId();
    void setInstanceId( String instanceId );
        
}




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

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

@GenerateImpl

public interface IDiagramConnectionEndpointDef 

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




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

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

@GenerateImpl

public interface 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 ***
    
    @Label( standard = "instance id" )
    @XmlBinding( path = "instance-id" )
    
    ValueProperty PROP_INSTANCE_ID = new ValueProperty( TYPE, "InstanceId" );
    
    Value<String> getInstanceId();
    void setInstanceId( String instanceId );
    

}




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

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

@GenerateImpl

public interface IDiagramLabelDef 

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




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

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

@GenerateImpl

public interface 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 ***
    
    @Label( standard = "instance id" )
    @XmlBinding( path = "instance-id" )
    
    ValueProperty PROP_INSTANCE_ID = new ValueProperty( TYPE, "InstanceId" );
    
    Value<String> getInstanceId();
    void setInstanceId( String instanceId );
    
    // *** 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 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.ReferenceValue;
import org.eclipse.sapphire.modeling.Value;
import org.eclipse.sapphire.modeling.ValueProperty;
import org.eclipse.sapphire.modeling.el.Function;
import org.eclipse.sapphire.ui.SapphirePart;
import org.eclipse.sapphire.ui.SapphireRenderingContext;
import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionDef;
import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionEndpointDef;

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

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

    @Override
	public void render(SapphireRenderingContext context)
	{
		throw new UnsupportedOperationException();
	}
	
    @Override
    public void dispose()
    {
        super.dispose();
        if (this.labelFunction != null)
        {
        	this.labelFunction.dispose();
        }
        if (this.idFunction != null)
        {
        	this.idFunction.dispose();
        }
        if (this.endpoint1Function != null)
        {
        	this.endpoint1Function.dispose();
        }
        if (this.endpoint2Function != null)
        {
        	this.endpoint2Function.dispose();
        }
        
        if (this.connectionTemplate != null)
        {
	        List<DiagramConnectionPart> connParts =  this.connectionTemplate.getDiagramConnections();
	        connParts.remove(this);
        }
    }
    
	public void refreshEndpoint1()
	{
		if (this.endpoint1Function != null)
		{
			Object value = this.endpoint1Function.value();
			String property = this.endpoint1Def.getProperty().getContent();
			setModelProperty(this.modelElement, property, value);
		}		
	}
	
	public void refreshEndpoint2()
	{
		if (this.endpoint2Function != null)
		{
			Object value = this.endpoint2Function.value();
			String property = this.endpoint2Def.getProperty().getContent();
			setModelProperty(this.modelElement, property, value);
		}		
	}
	
	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();
		if (!(targetObj instanceof IModelElement))
		{
			throw new RuntimeException( "Target not an IModelElement");
		}
		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);
		}    	
	}
	
}




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

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

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

public class DiagramConnectionTemplate 
{
	private SapphireDiagramEditorPart diagramEditor;
	private IDiagramConnectionDef definition;
	private IModelElement modelElement;	
	private ModelProperty modelProperty;
	protected String toolPaletteLabel;
	protected String toolPaletteDesc;
	
	protected 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>();
        
        String propertyName = this.definition.getProperty().getContent();
        this.modelProperty = resolve(this.modelElement, propertyName);
        if (this.modelProperty instanceof ListProperty)
        {
        	ListProperty listProperty = (ListProperty)this.modelProperty;
        	
        	ModelElementList<?> list = this.modelElement.read(listProperty);
            for( IModelElement listEntryModelElement : list )
            {
            	DiagramConnectionPart connection = new DiagramConnectionPart(this);
            	connection.init(this.diagramEditor, listEntryModelElement, definition, 
            			Collections.<String,String>emptyMap());
            	this.diagramConnections.add(connection);
            }
        }
        else if (this.modelProperty instanceof ElementProperty)
        {
        	ElementProperty elementProperty = (ElementProperty)this.modelProperty;
        	if (this.modelElement.read(elementProperty) != null)
        	{
	        	IModelElement localModelElement = this.modelElement.read(elementProperty).element();
	        	DiagramConnectionPart connection = new DiagramConnectionPart(this);
	        	connection.init(this.diagramEditor, localModelElement, definition, 
	        			Collections.<String,String>emptyMap());
	        	
	        	this.diagramConnections.add(connection);
        	}
        }
    }
    
    public List<DiagramConnectionPart> getDiagramConnections()
    {
    	return this.diagramConnections;
    }
    
    public String getToolPaletteLabel()
    {
    	return this.toolPaletteLabel;
    }
    
    public String getToolPaletteDesc()
    {
    	return this.toolPaletteDesc;
    }
    
    public 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 DiagramConnectionPart createNewDiagramConnection(DiagramNodePart srcNode, 
    														DiagramNodePart targetNode)
    {
    	IModelElement newElement = null;
    	if (this.modelProperty instanceof ListProperty)
    	{
    		ListProperty listProperty = (ListProperty)this.modelProperty;
    		ModelElementList<?> list = this.modelElement.read(listProperty);
    		newElement = list.addNewElement();
    	}
    	else if (this.modelProperty instanceof ElementProperty)
    	{
    		// TODO what if the element property does exist?
    		ElementProperty elementProperty = (ElementProperty)this.modelProperty;
    		newElement = this.modelElement.read(elementProperty).element(true);
    	}
    	
    	IDiagramConnectionEndpointDef srcAnchorDef = this.definition.getEndpoint1().element();
    	String srcProperty = srcAnchorDef.getProperty().getContent();
    	String srcExpr = srcAnchorDef.getValue().getContent();
    	Function srcFunc = getNodeReferenceFunction(srcNode, srcExpr);
    	Object srcValue = srcFunc.value();
    	srcFunc.dispose();
    	setModelProperty(newElement, srcProperty, srcValue);
    	
    	IDiagramConnectionEndpointDef targetAnchorDef = this.definition.getEndpoint2().element();
    	String targetProperty = targetAnchorDef.getProperty().getContent();
    	String targetExpr = targetAnchorDef.getValue().getContent();
    	Function targetFunc = getNodeReferenceFunction(targetNode, targetExpr);
    	Object targetValue = targetFunc.value();
    	targetFunc.dispose();
    	setModelProperty(newElement, targetProperty, targetValue);
    	
    	DiagramConnectionPart newConn = new DiagramConnectionPart(this);
    	newConn.init(this.diagramEditor, newElement, this.definition, 
    			Collections.<String,String>emptyMap());
    	this.diagramConnections.add(newConn);
    	return newConn;
    }
    
    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<?>)value).getContent());
    	}    	
    }
    
    protected Function getNodeReferenceFunction(final DiagramNodePart nodePart,
    											final String expression)
    {
        final FunctionContext context = new ModelElementFunctionContext( nodePart.getLocalModelElement() );
        Function result = null;
        
        if( expression != null )
        {
            try
            {
                result = ExpressionLanguageParser.parse( context, expression );
            }
            catch( Exception e )
            {
                SapphireUiFrameworkPlugin.log( e );
                result = null;
            }
        }
        return result;
    }
}




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

import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.el.Function;
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 Function endpointFunction;
	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.labelFunction = initExpression
        ( 
        	this.localDefinition.getLabel().element().getContent().getLocalizedText(), 
            new Runnable()
            {
                public void run()
                {
                }
            }
        );
        this.labelProperty = FunctionUtil.getFunctionProperty(this.modelElement, this.labelFunction);
        
        this.idFunction = initExpression
        ( 
            this.localDefinition.getInstanceId().getLocalizedText(), 
            new Runnable()
            {
                public void run()
                {
                }
            }
        );        

        this.endpointDef = this.localDefinition.getEndpoint().element();
        this.endpointModel = processEndpoint(this.endpointDef);
        this.endpointFunction = initExpression
        (
        	this.endpointModel, 
        	this.endpointDef.getValue().getContent(), 
            new Runnable()
        	{
	            public void run()
	            {
	            	refreshEndpoint2();
	            }
        	}
        );        
    }
    
    @Override
    public IModelElement getEndpoint1()
    {
    	return this.srcNodeModel;
    }
    
    @Override
    public IModelElement getEndpoint2()
    {
    	return this.endpointModel;
    }

    @Override
	public void refreshEndpoint1()
	{
	}
	
    @Override
	public void refreshEndpoint2()
	{
		if (this.endpointFunction != null)
		{
			Object value = this.endpointFunction.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.endpointFunction != null)
    	{
    		this.endpointFunction.dispose();
    	}    	
    }	
}




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

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

import org.eclipse.sapphire.modeling.ElementProperty;
import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ListProperty;
import org.eclipse.sapphire.modeling.ModelElementList;
import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.ModelProperty;
import org.eclipse.sapphire.modeling.annotations.Reference;
import org.eclipse.sapphire.modeling.el.Function;
import org.eclipse.sapphire.ui.diagram.def.IDiagramConnectionEndpointDef;
import org.eclipse.sapphire.ui.diagram.def.IDiagramEmbeddedConnectionDef;

public class DiagramEmbeddedConnectionTemplate extends DiagramConnectionTemplate
{
	private SapphireDiagramEditorPart diagramEditor;
	private DiagramNodeTemplate nodeTemplate;
	private IDiagramEmbeddedConnectionDef definition;
	private IModelElement modelElement;	
		
    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.diagramConnections = new ArrayList<DiagramConnectionPart>();
        
        ModelProperty nodeProperty = this.nodeTemplate.getModelProperty();
        String connPropName = this.definition.getProperty().getContent();
        if (nodeProperty instanceof ListProperty)
        {
        	ListProperty listProperty = (ListProperty)nodeProperty;
        	ModelElementList<?> list = this.modelElement.read(listProperty);
            for (IModelElement srcNodeModel : list)
            {
            	ModelProperty connProp = resolve(srcNodeModel, connPropName);
            	if (connProp instanceof ListProperty)
            	{
            		ListProperty connListProperty = (ListProperty)connProp;
            		ModelElementList<?> connList = srcNodeModel.read(connListProperty);
            		for (IModelElement endpointModel : connList)
            		{
            			DiagramEmbeddedConnectionPart connPart = 
            				new DiagramEmbeddedConnectionPart(this, srcNodeModel);
            			connPart.init(this.diagramEditor, endpointModel, this.definition, 
            					Collections.<String,String>emptyMap());
            			this.diagramConnections.add(connPart);
            		}
            	}
            	else if (connProp instanceof ElementProperty)
            	{
            		ElementProperty elementProperty = (ElementProperty)connProp;
                	if (this.modelElement.read(elementProperty) != null)
                	{            		
                		IModelElement endpointModel = this.modelElement.read(elementProperty).element();
               			DiagramEmbeddedConnectionPart connPart = 
            				new DiagramEmbeddedConnectionPart(this, srcNodeModel);
            			connPart.init(this.diagramEditor, endpointModel, this.definition, 
            					Collections.<String,String>emptyMap());               			
            			this.diagramConnections.add(connPart);                		
                	}
            	}            	
            }
        }    	
    }
        
    @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();
    	
    	String connPropName = this.definition.getProperty().getContent();
    	ModelProperty connProp = resolve(srcNodeModel, connPropName);    	
        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.getModelElement();
    	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 == 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");
    	}
    	
    	String connPropName = this.definition.getProperty().getContent();
    	ModelProperty connProp = resolve(srcNodeModel, connPropName);
    	IModelElement newEndpoint = null;
    	if (connProp instanceof ListProperty)
    	{
    		ListProperty listProperty = (ListProperty)connProp;
    		ModelElementList<?> list = srcNodeModel.read(listProperty);
    		newEndpoint = list.addNewElement();    		
    	}
    	else if (connProp instanceof ElementProperty)
    	{
    		// TODO what if the element property does exist?
    		ElementProperty elementProperty = (ElementProperty)connProp;
    		newEndpoint = this.modelElement.read(elementProperty).element(true);
    	}
    	IDiagramConnectionEndpointDef endpointDef = this.definition.getEndpoint().element();
    	String endpointProperty = endpointDef.getProperty().getContent();
    	String endpointExpr = endpointDef.getValue().getContent();
    	Function endpointFunc = getNodeReferenceFunction(targetNode, endpointExpr);
    	Object endpointValue = endpointFunc.value();
    	endpointFunc.dispose();
    	setModelProperty(newEndpoint, endpointProperty, endpointValue);

		DiagramEmbeddedConnectionPart connPart = 
			new DiagramEmbeddedConnectionPart(this, srcNodeModel);
		connPart.init(this.diagramEditor, newEndpoint, this.definition, 
				Collections.<String,String>emptyMap());               			
		this.diagramConnections.add(connPart);                		
    	
    	return connPart;
    }
        
}




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 = getNodeElement(id);
			if (nodePart != null)
			{
				int x = node.getX().getContent() != null ? node.getX().getContent() : -1;
				int y = node.getY().getContent() != null ? node.getY().getContent() : -1;
				int width = node.getWidth().getContent() != null ? node.getWidth().getContent() : -1;
				int height = node.getHeight().getContent() != null ? node.getHeight().getContent() : -1;
				this.addNode(nodePart, x, y, width, height);
				
				ModelElementList<IDiagramConnectionGeometry> connList = node.getEmbeddedConnectionGeometries();
				for (IDiagramConnectionGeometry connBend : connList)
				{
					String connId = connBend.getConnectionId().getContent();
					DiagramConnectionPart connPart = getConnectionElement(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 = getConnectionElement(connId);
			if (connPart != null)
			{
				ModelElementList<IBendPoint> bps = connBend.getConnectionBendpoints();
				int index = 0;
				for (IBendPoint pt : bps)
				{
					this.addConnectionBendpoint(connPart, index++, pt.getX().getContent(), pt.getY().getContent());
				}
			}			
		}
	}
	
	public void write() throws ResourceStoreException
	{
		this.geometryModel.getDiagramNodeGeometries().clear();
		Iterator<DiagramNodePart> it = this.nodeGeometries.keySet().iterator();
		while (it.hasNext())
		{
			DiagramNodePart nodePart = it.next();
			Bounds bounds = this.nodeGeometries.get(nodePart);
			String id = nodePart.getInstanceId();
			
			if (bounds != null && id != null)
			{
				IDiagramNodeGeometry diagramNode = this.geometryModel.getDiagramNodeGeometries().addNewElement();
				diagramNode.setNodeId(id);
				diagramNode.setX(bounds.x);
				diagramNode.setY(bounds.y);
				diagramNode.setWidth(bounds.width);
				diagramNode.setHeight(bounds.height);
				
				// 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 getNodeElement(String nodeId)
	{
		for (DiagramNodeTemplate nodeTemplate : this.diagramPart.getNodeTemplates())
		{
			for (DiagramNodePart nodePart : nodeTemplate.getDiagramNodes())
			{
				String nodeId2 = nodePart.getInstanceId();
				if (nodeId != null && nodeId2 != null && nodeId.equals(nodeId2))
				{
					return nodePart;
				}
			}
		}
		return null;
	}
	
	private DiagramConnectionPart getConnectionElement(String connId)
	{
		for (DiagramConnectionTemplate connTemplate : this.diagramPart.getConnectionTemplates())
		{
			for (DiagramConnectionPart connPart : connTemplate.getDiagramConnections())
			{
				String connId2 = connPart.getInstanceId();
				if (connId != null && connId2 != null && connId.equals(connId2))
				{
					return connPart;
				}
			}
		}
		return null;
	}

	private DiagramConnectionPart getConnectionElement(DiagramNodePart nodePart, String connId)
	{
		DiagramNodeTemplate nodeTemplate = nodePart.getDiagramNodeTemplate();
		DiagramEmbeddedConnectionTemplate connTemplate = 
			nodeTemplate.getEmbeddedConnectionTemplate();
		if (connTemplate != null)
		{
			List<DiagramConnectionPart> connParts = connTemplate.getDiagramConnections();
			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.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ValueProperty;
import org.eclipse.sapphire.modeling.el.Function;
import org.eclipse.sapphire.ui.SapphirePart;
import org.eclipse.sapphire.ui.SapphireRenderingContext;
import org.eclipse.sapphire.ui.diagram.def.IDiagramNodeDef;

public class DiagramNodePart extends SapphirePart 
{
	private DiagramNodeTemplate nodeTemplate;
	private IDiagramNodeDef definition;
	private IModelElement modelElement;
	private Function labelFunction;
	private Function idFunction;
	private ValueProperty labelProperty;
	
	public DiagramNodePart(DiagramNodeTemplate nodeTemplate)
	{
		this.nodeTemplate = nodeTemplate;
	}
	
    @Override
    protected void init()
    {
        super.init();
        
        this.definition = (IDiagramNodeDef)super.definition;
        this.modelElement = getModelElement();
        this.labelFunction = initExpression
        ( 
            this.definition.getLabel().element().getContent().getLocalizedText(), 
            new Runnable()
            {
                public void run()
                {
                }
            }
        );
        this.labelProperty = FunctionUtil.getFunctionProperty(this.modelElement, this.labelFunction);
        
        this.idFunction = initExpression
        ( 
            this.definition.getInstanceId().getLocalizedText(), 
            new Runnable()
            {
                public void run()
                {
                }
            }
        );
    }
    
    public DiagramNodeTemplate getDiagramNodeTemplate()
    {
    	return this.nodeTemplate;
    }
    
    public IModelElement getLocalModelElement()
    {
        return this.modelElement;
    }    
        
	@Override
	public void render(SapphireRenderingContext context)
	{
		throw new UnsupportedOperationException();
	}

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

	public void setLabel(String newValue)
	{
		if (this.labelProperty != null)
		{
			this.modelElement.write(this.labelProperty, newValue);
		}
	}
	
	public boolean canEditLabel()
	{
		return this.labelProperty != null;
	}
	
	public String getInstanceId()
	{
        String id = null;
        
        if( this.idFunction != null )
        {
            id = (String) this.idFunction.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.sapphire.modeling.ElementProperty;
import org.eclipse.sapphire.modeling.IModelElement;
import org.eclipse.sapphire.modeling.ListProperty;
import org.eclipse.sapphire.modeling.ModelElementList;
import org.eclipse.sapphire.modeling.ModelElementType;
import org.eclipse.sapphire.modeling.ModelProperty;
import org.eclipse.sapphire.ui.diagram.def.IDiagramEmbeddedConnectionDef;
import org.eclipse.sapphire.ui.diagram.def.IDiagramNodeDef;

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




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

import java.util.List;

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

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

}




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

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

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

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

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

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

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

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

	public IModelElement getModelElement() 
	{	
		return this.rootModelElement;
	}
	
	public DiagramNodePart getDiagramNodePart(IModelElement nodeElement)
	{
		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.SapphireEditor;
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.IWorkbenchPart;

@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) 
	{
		if (part instanceof DiagramEditor)
		{
			super.selectionChanged(part, selection);
		}
		else if (part instanceof SapphireEditor)
		{
			SapphireEditor se = (SapphireEditor)part;
			if (part.equals(getSite().getPage().getActiveEditor()) && se.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())
				{
					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())
			{
				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);
	
	public SapphireAddNodeFeature(IFeatureProvider fp)
	{
		super(fp);
	}
	
	public boolean canAdd(IAddContext context) 
	{
		Object newObj = context.getNewObject();
		if (newObj instanceof DiagramNodePart && context.getTargetContainer() instanceof Diagram)
		{
			return true;
		}
		return false;
	}

	public PictogramElement add(IAddContext context)
	{
		DiagramNodePart nodePart = (DiagramNodePart)context.getNewObject();
		final Diagram targetDiagram = (Diagram) context.getTargetContainer();
		
        // 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);

        // 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,
                context.getX(), context.getY(), width, height);
 
            // create link and wire it
            link(containerShape, nodePart);
        		
	        // SHAPE WITH LINE
	        {
	            // create shape for line
	            Shape shape = peCreateService.createShape(containerShape, false);
	 
	            // create and set graphics algorithm
	            Polyline polyline =
	                gaService.createPolyline(shape, new int[] { 0, 20, width, 20 });
	            polyline.setForeground(manageColor(CLASS_FOREGROUND));
	            polyline.setLineWidth(2);
	        }
        }
        else
        {
        	IDiagramNodeImageDef imageDef = nodeDef.getImage().element();
        	Rectangle rectangle = gaService.createRectangle(containerShape);
        	rectangle.setFilled(false);
        	rectangle.setLineVisible(false);
        	gaService.setLocationAndSize(rectangle, context.getX(), context.getY(), 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, context.getX(), context.getY(), width, height);
        
		return containerShape;
	}

}




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

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

public class SapphireCreateConnectionFeature extends AbstractCreateConnectionFeature 
{
	private DiagramConnectionTemplate connectionTemplate;
	
	public SapphireCreateConnectionFeature(IFeatureProvider fp, DiagramConnectionTemplate connectionTemplate)
	{
		super(fp, connectionTemplate.getToolPaletteLabel(), connectionTemplate.getToolPaletteDesc());
		this.connectionTemplate = connectionTemplate;		
	}
	
	public boolean canCreate(ICreateConnectionContext context) 
	{
		// return true if both anchors belong to an IModelElement
		// and those model elements are not identical
		SapphirePart source = getEndpoint(context.getSourceAnchor());
		SapphirePart target = getEndpoint(context.getTargetAnchor());
		if (source instanceof DiagramNodePart && 
				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
			DiagramConnectionPart connectionPart = 
				this.connectionTemplate.createNewDiagramConnection(sourceNode, targetNode);

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

		return newConnection;
	}

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

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




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

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

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

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

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




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

import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.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
	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);
						
			connPart.dispose();
		}
	}
	
	@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
	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);
			
			nodePart.dispose();
		}
	}
	
	@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.algorithms.GraphicsAlgorithm;
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 == nodeElement)
						{
							connectionPart.refreshEndpoint1();
						}
						else if (endpoint2 == nodeElement)
						{
							connectionPart.refreshEndpoint2();
						}
					}
				}
			}
			
		}
				
		// Explicitly update the shape to display the new value in the diagram
		// Note, that this might not be necessary in future versions of Graphiti
		// (currently in discussion)

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

	}

}




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

import org.eclipse.graphiti.features.IFeatureProvider;

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();
				}
			}
		}
		// 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 146-150 Link Here

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

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

Added Link Here

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

Added Link Here

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

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

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/NoResizeConfiguration.java (+17 lines)
1	package org.eclipse.sapphire.ui.diagram.graphiti.features;
2
3	import org.eclipse.graphiti.features.IResizeConfiguration;
4
5	public class NoResizeConfiguration implements IResizeConfiguration
6	{
7	public boolean isVerticalResizeAllowed()
8	{
9	return false;
10	}
11
12	public boolean isHorizontalResizeAllowed()
13	{
14	return false;
15	}
16
17	}

Added Link Here

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

Added Link Here

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

Added Link Here

(-)src/org/eclipse/sapphire/ui/diagram/graphiti/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	}