Initial commit of navigator ui provider

plugins/org.yakindu.sct.ui.navigator/.classpath

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

plugins/org.yakindu.sct.ui.navigator/.project

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.yakindu.sct.ui.navigator</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

plugins/org.yakindu.sct.ui.navigator/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,8 @@
+#Tue Aug 02 12:11:32 CEST 2011
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.6

plugins/org.yakindu.sct.ui.navigator/META-INF/MANIFEST.MF

@@ -0,0 +1,29 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: Ui
+Bundle-SymbolicName: org.yakindu.sct.ui.navigator;singleton:=true
+Bundle-Version: 1.0.0.qualifier
+Bundle-Activator: org.yakindu.sct.ui.UIActivator
+Bundle-Vendor: YAKINDU
+Require-Bundle: org.eclipse.ui,
+ org.eclipse.core.runtime,
+ org.eclipse.ui.navigator;bundle-version="3.5.100",
+ org.eclipse.core.resources;bundle-version="3.7.100",
+ org.eclipse.emf;bundle-version="2.6.0",
+ org.eclipse.emf.ecore;bundle-version="2.7.0",
+ org.eclipse.emf.edit;bundle-version="2.7.0",
+ org.eclipse.emf.edit.ui;bundle-version="2.7.0",
+ org.eclipse.emf.transaction;bundle-version="1.4.0",
+ org.eclipse.emf.workspace;bundle-version="1.4.0",
+ org.eclipse.gmf.runtime.emf.core;bundle-version="1.4.1",
+ org.eclipse.ui.views.properties.tabbed;bundle-version="3.5.200",
+ org.yakindu.sct.model.sgraph;bundle-version="1.0.0",
+ org.yakindu.sct.model.stext;bundle-version="1.0.0",
+ org.yakindu.sct.ui.editor;bundle-version="1.0.0",
+ org.eclipse.gmf.runtime.diagram.core;bundle-version="1.4.1",
+ org.eclipse.gmf.runtime.diagram.ui;bundle-version="1.5.0",
+ org.eclipse.ui.ide;bundle-version="3.7.0",
+ org.eclipse.gmf.runtime.diagram.ui.resources.editor;bundle-version="1.4.1",
+ de.itemis.xtext.utils.jface;bundle-version="1.0.0"
+Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-ActivationPolicy: lazy

plugins/org.yakindu.sct.ui.navigator/build.properties

@@ -0,0 +1,5 @@
+source.. = src/
+output.. = bin/
+bin.includes = META-INF/,\
+               .,\
+               plugin.xml

plugins/org.yakindu.sct.ui.navigator/plugin.xml

@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.4"?>
+<plugin>
+   <extension point="org.eclipse.ui.navigator.viewer" id="navigator-viewbinding">
+      <viewerContentBinding viewerId="org.eclipse.ui.navigator.ProjectExplorer">
+         <includes>
+            <contentExtension pattern="org.yakindu.sct.ui.navigator.resourceContent"/>
+                <contentExtension pattern="org.yakindu.sct.ui.navigator.navigatorLinkHelper"/>
+         </includes>
+      </viewerContentBinding>
+   </extension>
+ <extension point="org.eclipse.ui.navigator.navigatorContent" id="navigator-content">
+      <navigatorContent
+            id="org.yakindu.sct.ui.navigator.resourceContent" 
+            name="Statechart Content" 
+            priority="normal" 
+            contentProvider="org.yakindu.sct.ui.navigator.StatechartNavigatorContentProvider" 
+            labelProvider="org.yakindu.sct.ui.navigator.StatechartNavigatorLabelProvider"
+            activeByDefault="true">
+         <triggerPoints>
+    	          <instanceof value="org.eclipse.core.resources.IFile"/>
+        	      <test
+                     forcePluginActivation="true"
+                     property="org.eclipse.core.resources.extension"
+                     value="sct"/>
+         </triggerPoints>
+      </navigatorContent>
+       <actionProvider
+            id="org.eclipse.ui.navigator.navigatorActionProvider"
+            class="org.yakindu.sct.ui.navigator.NavigatorActionProvider">
+         <enablement>
+         </enablement>
+      </actionProvider>
+   </extension>
+     <extension point="org.eclipse.ui.navigator.linkHelper" id="navigator-linkhelper">
+      <linkHelper
+            id="org.yakindu.sct.ui.navigator.navigatorLinkHelper"
+            class="org.yakindu.sct.ui.navigator.NavigatorLinkHelper">
+         <editorInputEnablement>
+               <instanceof value="org.eclipse.emf.common.ui.URIEditorInput"/>
+         </editorInputEnablement>
+         <selectionEnablement>
+            <instanceof value="org.yakindu.sct.ui.navigator.AbstractNavigatorItem"/>
+         </selectionEnablement>
+      </linkHelper>
+   </extension>
+</plugin>

plugins/org.yakindu.sct.ui.navigator/src/org/yakindu/sct/ui/UIActivator.java

@@ -0,0 +1,50 @@
+package org.yakindu.sct.ui;
+
+import org.eclipse.ui.plugin.AbstractUIPlugin;
+import org.osgi.framework.BundleContext;
+
+/**
+ * The activator class controls the plug-in life cycle
+ */
+public class UIActivator extends AbstractUIPlugin {
+
+	// The plug-in ID
+	public static final String PLUGIN_ID = "org.yakindu.sct.ui"; //$NON-NLS-1$
+
+	// The shared instance
+	private static UIActivator plugin;
+	
+	/**
+	 * The constructor
+	 */
+	public UIActivator() {
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
+	 */
+	public void start(BundleContext context) throws Exception {
+		super.start(context);
+		plugin = this;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)
+	 */
+	public void stop(BundleContext context) throws Exception {
+		plugin = null;
+		super.stop(context);
+	}
+
+	/**
+	 * Returns the shared instance
+	 *
+	 * @return the shared instance
+	 */
+	public static UIActivator getDefault() {
+		return plugin;
+	}
+
+}

plugins/org.yakindu.sct.ui.navigator/src/org/yakindu/sct/ui/navigator/AbstractNavigatorItem.java

@@ -0,0 +1,46 @@
+package org.yakindu.sct.ui.navigator;
+
+import org.eclipse.core.runtime.IAdapterFactory;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.core.runtime.PlatformObject;
+import org.eclipse.ui.views.properties.tabbed.ITabbedPropertySheetPageContributor;
+
+@SuppressWarnings("rawtypes")
+public abstract class AbstractNavigatorItem extends PlatformObject {
+
+	public static final String ID = "org.yakindu.sct.ui.editor.editor.StatechartDiagramEditor";
+
+	static {
+		final Class[] supportedTypes = new Class[] { ITabbedPropertySheetPageContributor.class };
+		final ITabbedPropertySheetPageContributor propertySheetPageContributor = new ITabbedPropertySheetPageContributor() {
+			public String getContributorId() {
+				return ID;
+			}
+		};
+		Platform.getAdapterManager().registerAdapters(new IAdapterFactory() {
+
+			public Object getAdapter(Object adaptableObject, Class adapterType) {
+				if (adaptableObject instanceof AbstractNavigatorItem
+						&& adapterType == ITabbedPropertySheetPageContributor.class) {
+					return propertySheetPageContributor;
+				}
+				return null;
+			}
+
+			public Class[] getAdapterList() {
+				return supportedTypes;
+			}
+		}, AbstractNavigatorItem.class);
+	}
+
+	private Object myParent;
+
+	protected AbstractNavigatorItem(Object parent) {
+		myParent = parent;
+	}
+
+	public Object getParent() {
+		return myParent;
+	}
+
+}

plugins/org.yakindu.sct.ui.navigator/src/org/yakindu/sct/ui/navigator/DomainNavigatorItem.java

@@ -0,0 +1,113 @@
+package org.yakindu.sct.ui.navigator;
+
+import org.eclipse.core.runtime.IAdapterFactory;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.core.runtime.PlatformObject;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.ui.views.properties.IPropertySource;
+import org.eclipse.ui.views.properties.IPropertySourceProvider;
+
+@SuppressWarnings("rawtypes")
+public class DomainNavigatorItem extends PlatformObject {
+
+	static {
+		final Class[] supportedTypes = new Class[] { EObject.class,
+				IPropertySource.class };
+		Platform.getAdapterManager().registerAdapters(
+				new IAdapterFactory() {
+
+					public Object getAdapter(Object adaptableObject,
+							Class adapterType) {
+						if (adaptableObject instanceof DomainNavigatorItem) {
+							DomainNavigatorItem domainNavigatorItem = (DomainNavigatorItem) adaptableObject;
+							EObject eObject = domainNavigatorItem.getEObject();
+							if (adapterType == EObject.class) {
+								return eObject;
+							}
+							if (adapterType == IPropertySource.class) {
+								return domainNavigatorItem
+										.getPropertySourceProvider()
+										.getPropertySource(eObject);
+							}
+						}
+
+						return null;
+					}
+
+					public Class[] getAdapterList() {
+						return supportedTypes;
+					}
+				},
+				DomainNavigatorItem.class);
+	}
+
+	/**
+	 * @generated
+	 */
+	private Object myParent;
+
+	/**
+	 * @generated
+	 */
+	private EObject myEObject;
+
+	/**
+	 * @generated
+	 */
+	private IPropertySourceProvider myPropertySourceProvider;
+
+	/**
+	 * @generated
+	 */
+	public DomainNavigatorItem(EObject eObject, Object parent,
+			IPropertySourceProvider propertySourceProvider) {
+		myParent = parent;
+		myEObject = eObject;
+		myPropertySourceProvider = propertySourceProvider;
+	}
+
+	/**
+	 * @generated
+	 */
+	public Object getParent() {
+		return myParent;
+	}
+
+	/**
+	 * @generated
+	 */
+	public EObject getEObject() {
+		return myEObject;
+	}
+
+	/**
+	 * @generated
+	 */
+	public IPropertySourceProvider getPropertySourceProvider() {
+		return myPropertySourceProvider;
+	}
+
+	/**
+	 * @generated
+	 */
+	public boolean equals(Object obj) {
+		if (obj instanceof DomainNavigatorItem) {
+			return EcoreUtil
+					.getURI(getEObject())
+					.equals(
+							EcoreUtil
+									.getURI(((DomainNavigatorItem) obj)
+											.getEObject()));
+		}
+		return super.equals(obj);
+	}
+
+	/**
+	 * @generated
+	 */
+	public int hashCode() {
+		return EcoreUtil.getURI(getEObject()).hashCode();
+	}
+
+}

plugins/org.yakindu.sct.ui.navigator/src/org/yakindu/sct/ui/navigator/NavigatorActionProvider.java

@@ -0,0 +1,130 @@
+package org.yakindu.sct.ui.navigator;
+
+import java.util.Iterator;
+
+import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.emf.common.ui.URIEditorInput;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.workspace.util.WorkspaceSynchronizer;
+import org.eclipse.gmf.runtime.notation.Diagram;
+import org.eclipse.gmf.runtime.notation.View;
+import org.eclipse.jface.action.Action;
+import org.eclipse.jface.action.IMenuManager;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.ui.IActionBars;
+import org.eclipse.ui.IEditorInput;
+import org.eclipse.ui.IWorkbenchPage;
+import org.eclipse.ui.PartInitException;
+import org.eclipse.ui.navigator.CommonActionProvider;
+import org.eclipse.ui.navigator.ICommonActionConstants;
+import org.eclipse.ui.navigator.ICommonActionExtensionSite;
+import org.eclipse.ui.navigator.ICommonViewerWorkbenchSite;
+import org.eclipse.ui.part.FileEditorInput;
+
+public class NavigatorActionProvider extends CommonActionProvider {
+
+	private boolean myContribute;
+
+	private OpenDiagramAction myOpenDiagramAction;
+
+	public static final String ID = "org.yakindu.sct.ui.editor.editor.StatechartDiagramEditor";
+
+	public void init(ICommonActionExtensionSite aSite) {
+		super.init(aSite);
+		if (aSite.getViewSite() instanceof ICommonViewerWorkbenchSite) {
+			myContribute = true;
+			makeActions((ICommonViewerWorkbenchSite) aSite.getViewSite());
+		} else {
+			myContribute = false;
+		}
+	}
+
+	private void makeActions(ICommonViewerWorkbenchSite viewerSite) {
+		myOpenDiagramAction = new OpenDiagramAction(viewerSite);
+	}
+
+	public void fillActionBars(IActionBars actionBars) {
+		if (!myContribute) {
+			return;
+		}
+		IStructuredSelection selection = (IStructuredSelection) getContext()
+				.getSelection();
+		myOpenDiagramAction.selectionChanged(selection);
+		if (myOpenDiagramAction.isEnabled()) {
+			actionBars.setGlobalActionHandler(ICommonActionConstants.OPEN,
+					myOpenDiagramAction);
+		}
+	}
+
+	public void fillContextMenu(IMenuManager menu) {
+	}
+
+	private class OpenDiagramAction extends Action {
+
+		private Diagram myDiagram;
+
+		private ICommonViewerWorkbenchSite myViewerSite;
+
+		public OpenDiagramAction(ICommonViewerWorkbenchSite viewerSite) {
+			super("Open Diagram");
+			myViewerSite = viewerSite;
+		}
+
+		public final void selectionChanged(IStructuredSelection selection) {
+			myDiagram = null;
+			if (selection.size() == 1) {
+				Object selectedElement = selection.getFirstElement();
+				if (selectedElement instanceof NavigatorItem) {
+					selectedElement = ((NavigatorItem) selectedElement)
+							.getView();
+				} else if (selectedElement instanceof IAdaptable) {
+					selectedElement = ((IAdaptable) selectedElement)
+							.getAdapter(View.class);
+				}
+				if (selectedElement instanceof Diagram) {
+					Diagram diagram = (Diagram) selectedElement;
+					myDiagram = diagram;
+				}
+			}
+			setEnabled(myDiagram != null);
+		}
+
+		public void run() {
+			if (myDiagram == null || myDiagram.eResource() == null) {
+				return;
+			}
+
+			IEditorInput editorInput = getEditorInput();
+			IWorkbenchPage page = myViewerSite.getPage();
+			try {
+				page.openEditor(editorInput, ID);
+			} catch (PartInitException e) {
+
+				e.printStackTrace();
+			}
+		}
+
+		private IEditorInput getEditorInput() {
+			for (Iterator<EObject> it = myDiagram.eResource().getContents().iterator(); it
+					.hasNext();) {
+				EObject nextEObject = (EObject) it.next();
+				if (nextEObject == myDiagram) {
+					return new FileEditorInput(
+							WorkspaceSynchronizer.getFile(myDiagram.eResource()));
+				}
+				if (nextEObject instanceof Diagram) {
+					break;
+				}
+			}
+			URI uri = EcoreUtil.getURI(myDiagram);
+			String editorName = uri.lastSegment()
+					+ "#" + myDiagram.eResource().getContents().indexOf(myDiagram); //$NON-NLS-1$
+			IEditorInput editorInput = new URIEditorInput(uri, editorName);
+			return editorInput;
+		}
+
+	}
+
+}

plugins/org.yakindu.sct.ui.navigator/src/org/yakindu/sct/ui/navigator/NavigatorGroup.java

@@ -0,0 +1,59 @@
+package org.yakindu.sct.ui.navigator;
+
+import java.util.Collection;
+import java.util.LinkedList;
+@SuppressWarnings("rawtypes")
+
+public class NavigatorGroup extends AbstractNavigatorItem {
+
+	private String myGroupName;
+
+	private String myIcon;
+
+	private Collection<Object> myChildren = new LinkedList<Object>();
+
+	NavigatorGroup(String groupName, String icon, Object parent) {
+		super(parent);
+		myGroupName = groupName;
+		myIcon = icon;
+	}
+
+	public String getGroupName() {
+		return myGroupName;
+	}
+
+	public String getIcon() {
+		return myIcon;
+	}
+
+	public Object[] getChildren() {
+		return myChildren.toArray();
+	}
+
+	public void addChildren(Collection children) {
+		myChildren.addAll(children);
+	}
+
+	public void addChild(Object child) {
+		myChildren.add(child);
+	}
+
+	public boolean isEmpty() {
+		return myChildren.size() == 0;
+	}
+
+	public boolean equals(Object obj) {
+		if (obj instanceof NavigatorGroup) {
+			NavigatorGroup anotherGroup = (NavigatorGroup)obj;
+			if (getGroupName().equals(anotherGroup.getGroupName())) {
+				return getParent().equals(anotherGroup.getParent());
+			}
+		}
+		return super.equals(obj);
+	}
+	
+	public int hashCode() {
+		return getGroupName().hashCode();
+	}
+
+}

plugins/org.yakindu.sct.ui.navigator/src/org/yakindu/sct/ui/navigator/NavigatorItem.java

@@ -0,0 +1,60 @@
+package org.yakindu.sct.ui.navigator;
+
+import org.eclipse.core.runtime.IAdapterFactory;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.gmf.runtime.notation.View;
+
+@SuppressWarnings("rawtypes")
+public class NavigatorItem extends AbstractNavigatorItem {
+
+	static {
+		final Class[] supportedTypes = new Class[] { View.class, EObject.class };
+		Platform.getAdapterManager().registerAdapters(new IAdapterFactory() {
+
+			public Object getAdapter(Object adaptableObject, Class adapterType) {
+				if (adaptableObject instanceof NavigatorItem
+						&& (adapterType == View.class || adapterType == EObject.class)) {
+					return ((NavigatorItem) adaptableObject).getView();
+				}
+				return null;
+			}
+
+			public Class[] getAdapterList() {
+				return supportedTypes;
+			}
+		}, NavigatorItem.class);
+	}
+
+	private View myView;
+
+	private boolean myLeaf = false;
+
+	public NavigatorItem(View view, Object parent, boolean isLeaf) {
+		super(parent);
+		myView = view;
+		myLeaf = isLeaf;
+	}
+
+	public View getView() {
+		return myView;
+	}
+
+	public boolean isLeaf() {
+		return myLeaf;
+	}
+
+	public boolean equals(Object obj) {
+		if (obj instanceof NavigatorItem) {
+			return EcoreUtil.getURI(getView()).equals(
+					EcoreUtil.getURI(((NavigatorItem) obj).getView()));
+		}
+		return super.equals(obj);
+	}
+
+	public int hashCode() {
+		return EcoreUtil.getURI(getView()).hashCode();
+	}
+
+}

plugins/org.yakindu.sct.ui.navigator/src/org/yakindu/sct/ui/navigator/NavigatorLinkHelper.java

@@ -0,0 +1,111 @@
+package org.yakindu.sct.ui.navigator;
+
+import java.util.Iterator;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.emf.common.ui.URIEditorInput;
+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.ecore.util.EcoreUtil;
+import org.eclipse.emf.workspace.util.WorkspaceSynchronizer;
+import org.eclipse.gef.EditPart;
+import org.eclipse.gef.GraphicalViewer;
+import org.eclipse.gmf.runtime.diagram.ui.parts.DiagramEditor;
+import org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.IDiagramDocument;
+import org.eclipse.gmf.runtime.diagram.ui.resources.editor.parts.DiagramDocumentEditor;
+import org.eclipse.gmf.runtime.notation.Diagram;
+import org.eclipse.gmf.runtime.notation.View;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.viewers.StructuredSelection;
+import org.eclipse.ui.IEditorInput;
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.IWorkbenchPage;
+import org.eclipse.ui.navigator.ILinkHelper;
+import org.eclipse.ui.part.FileEditorInput;
+
+import de.itemis.xtext.utils.jface.viewers.util.ActiveEditorResolver;
+
+public class NavigatorLinkHelper implements ILinkHelper {
+
+	public NavigatorLinkHelper() {
+		System.out.println("CREATED!!!!!!!!!!!!!!!");
+	}
+	
+	
+	private static IEditorInput getEditorInput(Diagram diagram) {
+		Resource diagramResource = diagram.eResource();
+		for (Iterator<EObject> it = diagramResource.getContents().iterator(); it.hasNext();) {
+			EObject nextEObject = (EObject)it.next();
+			if (nextEObject == diagram) {
+				return new FileEditorInput(WorkspaceSynchronizer.getFile(diagramResource));
+			}
+			if (nextEObject instanceof Diagram) {
+				break;
+			}
+		}
+		URI uri = EcoreUtil.getURI(diagram);
+		String editorName = uri.lastSegment() + "#" + diagram.eResource().getContents().indexOf(diagram);
+		IEditorInput editorInput = new URIEditorInput(uri, editorName);
+		return editorInput;
+	}
+
+	public IStructuredSelection findSelection(IEditorInput anInput) {
+		IEditorPart activeEditor = ActiveEditorResolver.getActiveEditor();
+		if(activeEditor instanceof DiagramDocumentEditor){
+			Diagram diagram = ((DiagramDocumentEditor) activeEditor)
+					.getDiagram();
+			IFile file = WorkspaceSynchronizer.getFile(diagram.eResource());
+			if (file != null) {
+				NavigatorItem item = new NavigatorItem(diagram, file, false);
+				return new StructuredSelection(item);
+			}
+		}
+		return StructuredSelection.EMPTY;
+	}
+
+	public void activateEditor(IWorkbenchPage aPage, IStructuredSelection aSelection) {
+		if (aSelection == null || aSelection.isEmpty()) {
+			return;
+		}
+		if (false == aSelection.getFirstElement() instanceof AbstractNavigatorItem) {
+			return;
+		}
+
+		AbstractNavigatorItem abstractNavigatorItem = (AbstractNavigatorItem)aSelection.getFirstElement();
+		View navigatorView = null;
+		if (abstractNavigatorItem instanceof NavigatorItem) {
+			navigatorView = ((NavigatorItem)abstractNavigatorItem).getView();
+		} else if (abstractNavigatorItem instanceof NavigatorGroup) {
+			NavigatorGroup navigatorGroup = (NavigatorGroup)abstractNavigatorItem;
+			if (navigatorGroup.getParent() instanceof NavigatorItem) {
+				navigatorView = ((NavigatorItem)navigatorGroup.getParent()).getView();
+			}
+		}
+		if (navigatorView == null) {
+			return;
+		}
+		IEditorInput editorInput = getEditorInput(navigatorView.getDiagram());
+		IEditorPart editor = aPage.findEditor(editorInput);
+		if (editor == null) {
+			return;
+		}
+		aPage.bringToTop(editor);
+		if (editor instanceof DiagramEditor) {
+			DiagramEditor diagramEditor = (DiagramEditor)editor;
+			ResourceSet diagramEditorResourceSet = diagramEditor.getEditingDomain().getResourceSet();
+			EObject selectedView = diagramEditorResourceSet.getEObject(EcoreUtil.getURI(navigatorView), true);
+			if (selectedView == null) {
+				return;
+			}
+			GraphicalViewer graphicalViewer = (GraphicalViewer)diagramEditor
+					.getAdapter(GraphicalViewer.class);
+			EditPart selectedEditPart = (EditPart)graphicalViewer.getEditPartRegistry().get(selectedView);
+			if (selectedEditPart != null) {
+				graphicalViewer.select(selectedEditPart);
+			}
+		}
+	}
+
+}

plugins/org.yakindu.sct.ui.navigator/src/org/yakindu/sct/ui/navigator/StatechartNavigatorActionProvider.java

@@ -0,0 +1,8 @@
+package org.yakindu.sct.ui.navigator;
+
+import org.eclipse.ui.navigator.CommonActionProvider;
+
+public class StatechartNavigatorActionProvider extends CommonActionProvider {
+
+	
+}

plugins/org.yakindu.sct.ui.navigator/src/org/yakindu/sct/ui/navigator/StatechartNavigatorContentProvider.java

@@ -0,0 +1,181 @@
+package org.yakindu.sct.ui.navigator;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+
+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.edit.domain.AdapterFactoryEditingDomain;
+import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
+import org.eclipse.emf.transaction.TransactionalEditingDomain;
+import org.eclipse.emf.workspace.util.WorkspaceSynchronizer;
+import org.eclipse.gmf.runtime.emf.core.GMFEditingDomainFactory;
+import org.eclipse.jface.viewers.Viewer;
+import org.eclipse.ui.IMemento;
+import org.eclipse.ui.navigator.ICommonContentExtensionSite;
+import org.eclipse.ui.navigator.ICommonContentProvider;
+import org.yakindu.sct.ui.navigator.utils.ComposedAdapterFactoryUtil;
+
+public class StatechartNavigatorContentProvider implements
+		ICommonContentProvider {
+
+	private AdapterFactoryContentProvider myAdapterFctoryContentProvier;
+
+	private static final Object[] EMPTY_ARRAY = new Object[0];
+
+	private Viewer myViewer;
+
+	private AdapterFactoryEditingDomain myEditingDomain;
+
+	private WorkspaceSynchronizer myWorkspaceSynchronizer;
+
+	private Runnable myViewerRefreshRunnable;
+
+	public StatechartNavigatorContentProvider() {
+
+		myAdapterFctoryContentProvier = new AdapterFactoryContentProvider(
+				ComposedAdapterFactoryUtil.FACTORY);
+
+		TransactionalEditingDomain editingDomain = GMFEditingDomainFactory.INSTANCE
+				.createEditingDomain();
+		myEditingDomain = (AdapterFactoryEditingDomain) editingDomain;
+		myEditingDomain.setResourceToReadOnlyMap(new HashMap() {
+			public Object get(Object key) {
+				if (!containsKey(key)) {
+					put(key, Boolean.TRUE);
+				}
+				return super.get(key);
+			}
+		});
+		myViewerRefreshRunnable = new Runnable() {
+			public void run() {
+				if (myViewer != null) {
+					myViewer.refresh();
+				}
+			}
+		};
+		myWorkspaceSynchronizer = new WorkspaceSynchronizer(editingDomain,
+				new WorkspaceSynchronizer.Delegate() {
+					public void dispose() {
+					}
+
+					public boolean handleResourceChanged(final Resource resource) {
+						for (Iterator<Resource> it = myEditingDomain.getResourceSet()
+								.getResources().iterator(); it.hasNext();) {
+							Resource nextResource = (Resource) it.next();
+							nextResource.unload();
+						}
+						if (myViewer != null) {
+							myViewer.getControl().getDisplay()
+									.asyncExec(myViewerRefreshRunnable);
+						}
+						return true;
+					}
+
+					public boolean handleResourceDeleted(Resource resource) {
+						for (Iterator<Resource> it = myEditingDomain.getResourceSet()
+								.getResources().iterator(); it.hasNext();) {
+							Resource nextResource = (Resource) it.next();
+							nextResource.unload();
+						}
+						if (myViewer != null) {
+							myViewer.getControl().getDisplay()
+									.asyncExec(myViewerRefreshRunnable);
+						}
+						return true;
+					}
+
+					public boolean handleResourceMoved(Resource resource,
+							final URI newURI) {
+						for (Iterator<Resource> it = myEditingDomain.getResourceSet()
+								.getResources().iterator(); it.hasNext();) {
+							Resource nextResource = (Resource) it.next();
+							nextResource.unload();
+						}
+						if (myViewer != null) {
+							myViewer.getControl().getDisplay()
+									.asyncExec(myViewerRefreshRunnable);
+						}
+						return true;
+					}
+				});
+	}
+
+	public void dispose() {
+		myWorkspaceSynchronizer.dispose();
+		myWorkspaceSynchronizer = null;
+		myViewerRefreshRunnable = null;
+		for (Iterator<Resource> it = myEditingDomain.getResourceSet().getResources()
+				.iterator(); it.hasNext();) {
+			Resource resource = (Resource) it.next();
+			resource.unload();
+		}
+		((TransactionalEditingDomain) myEditingDomain).dispose();
+		myEditingDomain = null;
+	}
+
+	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
+		myViewer = viewer;
+	}
+
+	public Object[] getElements(Object inputElement) {
+		return getChildren(inputElement);
+	}
+
+	public void restoreState(IMemento aMemento) {
+	}
+
+	public void saveState(IMemento aMemento) {
+	}
+
+	public void init(ICommonContentExtensionSite aConfig) {
+	}
+
+	public Object[] getChildren(Object parentElement) {
+		if (parentElement instanceof IFile) {
+			IFile file = (IFile) parentElement;
+			URI fileURI = URI.createPlatformResourceURI(file.getFullPath()
+					.toString(), true);
+			Resource resource = myEditingDomain.getResourceSet().getResource(
+					fileURI, true);
+			return wrapEObjects(
+					myAdapterFctoryContentProvier.getChildren(resource),
+					parentElement);
+		}
+
+		if (parentElement instanceof DomainNavigatorItem) {
+			return wrapEObjects(
+					myAdapterFctoryContentProvier.getChildren(((DomainNavigatorItem) parentElement)
+							.getEObject()), parentElement);
+		}
+		return EMPTY_ARRAY;
+	}
+
+	public Object[] wrapEObjects(Object[] objects, Object parentElement) {
+		Collection<DomainNavigatorItem> result = new ArrayList<DomainNavigatorItem>();
+		for (int i = 0; i < objects.length; i++) {
+			if (objects[i] instanceof EObject) {
+				result.add(new DomainNavigatorItem((EObject) objects[i],
+						parentElement, myAdapterFctoryContentProvier));
+			}
+		}
+		return result.toArray();
+	}
+
+	public Object getParent(Object element) {
+		if (element instanceof AbstractNavigatorItem) {
+			AbstractNavigatorItem abstractNavigatorItem = (AbstractNavigatorItem) element;
+			return abstractNavigatorItem.getParent();
+		}
+		return null;
+	}
+
+	public boolean hasChildren(Object element) {
+		return element instanceof IFile || getChildren(element).length > 0;
+	}
+
+}

plugins/org.yakindu.sct.ui.navigator/src/org/yakindu/sct/ui/navigator/StatechartNavigatorLabelProvider.java

@@ -0,0 +1,91 @@
+package org.yakindu.sct.ui.navigator;
+
+import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider;
+import org.eclipse.jface.viewers.ILabelProviderListener;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.ui.IMemento;
+import org.eclipse.ui.navigator.ICommonContentExtensionSite;
+import org.eclipse.ui.navigator.ICommonLabelProvider;
+import org.yakindu.sct.ui.navigator.utils.ComposedAdapterFactoryUtil;
+
+public class StatechartNavigatorLabelProvider implements ICommonLabelProvider {
+
+	private AdapterFactoryLabelProvider myAdapterFactoryLabelProvider = new AdapterFactoryLabelProvider(
+			ComposedAdapterFactoryUtil.FACTORY);
+
+	/**
+	 * @generated
+	 */
+	public void init(ICommonContentExtensionSite aConfig) {
+	}
+
+	/**
+	 * @generated
+	 */
+	public Image getImage(Object element) {
+		if (element instanceof DomainNavigatorItem) {
+			return myAdapterFactoryLabelProvider
+					.getImage(((DomainNavigatorItem) element).getEObject());
+		}
+		return null;
+	}
+
+	/**
+	 * @generated
+	 */
+	public String getText(Object element) {
+		if (element instanceof DomainNavigatorItem) {
+			return myAdapterFactoryLabelProvider
+					.getText(((DomainNavigatorItem) element).getEObject());
+		}
+		return null;
+	}
+
+	/**
+	 * @generated
+	 */
+	public void addListener(ILabelProviderListener listener) {
+		myAdapterFactoryLabelProvider.addListener(listener);
+	}
+
+	/**
+	 * @generated
+	 */
+	public void dispose() {
+		myAdapterFactoryLabelProvider.dispose();
+	}
+
+	/**
+	 * @generated
+	 */
+	public boolean isLabelProperty(Object element, String property) {
+		return myAdapterFactoryLabelProvider.isLabelProperty(element, property);
+	}
+
+	/**
+	 * @generated
+	 */
+	public void removeListener(ILabelProviderListener listener) {
+		myAdapterFactoryLabelProvider.removeListener(listener);
+	}
+
+	/**
+	 * @generated
+	 */
+	public void restoreState(IMemento aMemento) {
+	}
+
+	/**
+	 * @generated
+	 */
+	public void saveState(IMemento aMemento) {
+	}
+
+	/**
+	 * @generated
+	 */
+	public String getDescription(Object anElement) {
+		return null;
+	}
+
+}

plugins/org.yakindu.sct.ui.navigator/src/org/yakindu/sct/ui/navigator/utils/ComposedAdapterFactoryUtil.java

@@ -0,0 +1,20 @@
+package org.yakindu.sct.ui.navigator.utils;
+
+import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
+import org.eclipse.emf.edit.provider.ReflectiveItemProviderAdapterFactory;
+import org.eclipse.emf.edit.provider.resource.ResourceItemProviderAdapterFactory;
+import org.yakindu.sct.model.sgraph.util.SGraphAdapterFactory;
+import org.yakindu.sct.model.stext.stext.util.StextAdapterFactory;
+
+public class ComposedAdapterFactoryUtil {
+
+	public static final ComposedAdapterFactory FACTORY;
+	static {
+		FACTORY = new ComposedAdapterFactory();
+		FACTORY.addAdapterFactory(new ResourceItemProviderAdapterFactory());
+		FACTORY.addAdapterFactory(new ReflectiveItemProviderAdapterFactory());
+		FACTORY.addAdapterFactory(new SGraphAdapterFactory());
+		FACTORY.addAdapterFactory(new StextAdapterFactory());
+
+	}
+}