Annotation View, first working version

refs 1841

org.fortiss.tooling.base.ui/trunk/plugin.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.4"?>
 <plugin>
+   <extension-point id="annotationViewPart" name="Annotation View Part" schema="schema/annotationViewPart.exsd"/>
    <extension
          point="org.eclipse.ui.preferencePages">
       <page
@@ -9,5 +10,14 @@
             name="Fortiss Tooling">
       </page>
    </extension>
+   <extension
+         point="org.eclipse.ui.views">
+      <view
+            class="org.fortiss.tooling.base.ui.annotation.DummyAnnotationView"
+            id="org.fortiss.tooling.base.ui.annotationBase"
+            name="Annotation"
+            restorable="true">
+      </view>
+   </extension>
 
 </plugin>

org.fortiss.tooling.base.ui/trunk/schema/annotationViewPart.exsd

+<?xml version='1.0' encoding='UTF-8'?>
+<!-- Schema file written by PDE -->
+<schema targetNamespace="org.fortiss.tooling.base.ui" xmlns="http://www.w3.org/2001/XMLSchema">
+<annotation>
+      <appinfo>
+         <meta.schema plugin="org.fortiss.tooling.base.ui" id="annotationViewPart" name="Annotation View Part"/>
+      </appinfo>
+      <documentation>
+         [Enter description of this extension point.]
+      </documentation>
+   </annotation>
+
+   <include schemaLocation="schema://org.fortiss.tooling.kernel/schema/modelElement.exsd"/>
+
+   <element name="extension">
+      <annotation>
+         <appinfo>
+            <meta.element />
+         </appinfo>
+      </annotation>
+      <complexType>
+         <sequence>
+            <element ref="annotationViewPart" minOccurs="1" maxOccurs="unbounded"/>
+         </sequence>
+         <attribute name="point" type="string" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="id" type="string">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="name" type="string">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+               <appinfo>
+                  <meta.attribute translatable="true"/>
+               </appinfo>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <element name="annotationViewPart">
+      <complexType>
+         <sequence>
+            <element ref="modelElementClass"/>
+         </sequence>
+         <attribute name="binding" type="string" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+               <appinfo>
+                  <meta.attribute kind="java" basedOn=":org.fortiss.tooling.base.ui.annotation.IAnnotationValueProvider"/>
+               </appinfo>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <annotation>
+      <appinfo>
+         <meta.section type="since"/>
+      </appinfo>
+      <documentation>
+         [Enter the first release in which this extension point appears.]
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appinfo>
+         <meta.section type="examples"/>
+      </appinfo>
+      <documentation>
+         [Enter extension point usage example here.]
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appinfo>
+         <meta.section type="apiinfo"/>
+      </appinfo>
+      <documentation>
+         [Enter API information here.]
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appinfo>
+         <meta.section type="implementation"/>
+      </appinfo>
+      <documentation>
+         [Enter information about supplied implementation of this extension point.]
+      </documentation>
+   </annotation>
+
+
+</schema>

org.fortiss.tooling.base.ui/trunk/src/org/fortiss/tooling/base/ui/annotation/AnnotationEntry.java

+/*--------------------------------------------------------------------------+
+$Id$
+|                                                                          |
+| Copyright 2014 ForTISS GmbH                     |
+|                                                                          |
+| Licensed under the Apache License, Version 2.0 (the "License");          |
+| you may not use this file except in compliance with the License.         |
+| You may obtain a copy of the License at                                  |
+|                                                                          |
+|    http://www.apache.org/licenses/LICENSE-2.0                            |
+|                                                                          |
+| Unless required by applicable law or agreed to in writing, software      |
+| distributed under the License is distributed on an "AS IS" BASIS,        |
+| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
+| See the License for the specific language governing permissions and      |
+| limitations under the License.                                           |
++--------------------------------------------------------------------------*/
+package org.fortiss.tooling.base.ui.annotation;
+
+import org.fortiss.tooling.base.model.element.IAnnotatedSpecification;
+import org.fortiss.tooling.base.model.element.IModelElement;
+
+/**
+ * Class for an annotation entry in the annotation view table
+ * 
+ * @author eder
+ * @author $Author$
+ * @version $Rev$
+ * @ConQAT.Rating RED Hash:
+ */
+public class AnnotationEntry<T extends IAnnotatedSpecification> {
+
+	/** Model Element */
+	private IModelElement modelElement;
+
+	/** Specification of the model element */
+	private IAnnotatedSpecification specification;
+
+	/** Value Provider to handle the specification */
+	private IAnnotationValueProvider<T> valueProvider;
+
+	/** Constructor */
+	public AnnotationEntry(IModelElement modelElement, IAnnotatedSpecification specification,
+			IAnnotationValueProvider<T> valueProvider) {
+		this.modelElement = modelElement;
+		this.specification = specification;
+		this.valueProvider = valueProvider;
+	}
+
+	/** Returns the string representaion of the annotation value */
+	public String getSpecificationValue() {
+		return valueProvider.getValue((T)specification);
+	}
+
+	/** Returns modelElement. */
+	public IModelElement getModelElement() {
+		return modelElement;
+	}
+
+	/** Returns specification. */
+	public IAnnotatedSpecification getSpecification() {
+		return specification;
+	}
+
+	/** Returns the annotation name */
+	public String getAnnotationName() {
+		return valueProvider.getAnnotationName();
+	}
+
+	/** Returns the class of the specification */
+	public Class<IAnnotatedSpecification> getSpecificationClass() {
+		return (Class<IAnnotatedSpecification>)specification.getClass();
+	}
+}

org.fortiss.tooling.base.ui/trunk/src/org/fortiss/tooling/base/ui/annotation/AnnotationValueService.java

+/*--------------------------------------------------------------------------+
+$Id$
+|                                                                          |
+| Copyright 2014 ForTISS GmbH                     |
+|                                                                          |
+| Licensed under the Apache License, Version 2.0 (the "License");          |
+| you may not use this file except in compliance with the License.         |
+| You may obtain a copy of the License at                                  |
+|                                                                          |
+|    http://www.apache.org/licenses/LICENSE-2.0                            |
+|                                                                          |
+| Unless required by applicable law or agreed to in writing, software      |
+| distributed under the License is distributed on an "AS IS" BASIS,        |
+| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
+| See the License for the specific language governing permissions and      |
+| limitations under the License.                                           |
++--------------------------------------------------------------------------*/
+package org.fortiss.tooling.base.ui.annotation;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+import org.fortiss.tooling.base.model.element.IAnnotatedSpecification;
+import org.fortiss.tooling.base.model.element.IModelElement;
+import org.fortiss.tooling.kernel.model.IProjectRootElement;
+import org.fortiss.tooling.kernel.service.base.EObjectAwareServiceBase;
+import org.fortiss.tooling.kernel.utils.EcoreUtils;
+import org.fortiss.tooling.kernel.utils.KernelModelElementUtils;
+
+/**
+ * 
+ * @author eder
+ * @author $Author$
+ * @version $Rev$
+ * @ConQAT.Rating RED Hash:
+ */
+public class AnnotationValueService extends
+		EObjectAwareServiceBase<IAnnotationValueProvider<IAnnotatedSpecification>> implements
+		IAnnotationValueService {
+
+	/** The compositor extension point ID. */
+	private static final String EXTENSION_POINT_NAME =
+			"org.fortiss.tooling.base.ui.annotationViewPart";
+
+	/** The compositor configuration element name. */
+	private static final String CONFIGURATION_ELEMENT_NAME = "annotationViewPart";
+
+	/** The handler class attribute name. */
+	private static final String HANDLER_CLASS_ATTRIBUTE_NAME = "binding";
+
+	/**
+	 * 
+	 */
+	public AnnotationValueService() {
+		super();
+	}
+
+	/** {@inheritDoc} */
+	@Override
+	public List<AnnotationEntry<? extends IAnnotatedSpecification>> getValues(
+			final IModelElement element) {
+		if(element == null) {
+			return Collections.emptyList();
+		}
+		final List<AnnotationEntry<? extends IAnnotatedSpecification>> result =
+				new ArrayList<AnnotationEntry<? extends IAnnotatedSpecification>>();// Collections.emptyMap();
+		final List<IAnnotationValueProvider<IAnnotatedSpecification>> registeredHandlers =
+				getRegisteredHandlers(element.getClass());
+		if(registeredHandlers != null && !registeredHandlers.isEmpty()) {
+
+			// getAllChildren(element, clazz, exceptions)
+
+			// TreeIterator<EObject> eAllContents = element.eAllContents();
+			// EList<EObject> eContents = element.eContents();
+			// List<? extends IModelElement> allChildren =
+			// getAllChildren(element, element.getClass(), null);
+			// final IAnnotationValueProvider<IAnnotatedSpecification> annotationProvider =
+			// registeredHandlers.get(0);
+			KernelModelElementUtils.runAsCommand(element, new Runnable() {
+
+				@Override
+				public void run() {
+					EObject root = element;
+					while(!(root instanceof IProjectRootElement)) {
+						root = root.eContainer();
+					}
+					final List<? extends IModelElement> childrenWithType =
+							EcoreUtils.getChildrenWithType(root, element.getClass());
+					for(IAnnotationValueProvider<IAnnotatedSpecification> annotationProvider : registeredHandlers) {
+
+						List<? extends IModelElement> allChildren =
+								getAllChildren(root, element.getClass(),
+										annotationProvider.filterOut());
+
+						for(final IModelElement e : allChildren) {
+							EList<IAnnotatedSpecification> annotatedSpecifications =
+									EcoreUtils.pickInstanceOf(IAnnotatedSpecification.class,
+											e.getSpecifications());
+							IAnnotatedSpecification annotatedSpec = null;
+							for(IAnnotatedSpecification spec : annotatedSpecifications) {
+								if(spec.getClass().isInstance(annotationProvider)) {
+									annotatedSpec = spec;
+								}
+							}
+
+							if(annotatedSpec == null) {
+								annotatedSpec = annotationProvider.addNewSpecToModelElement(e);
+							}
+
+							AnnotationEntry<? extends IAnnotatedSpecification> entry =
+									new AnnotationEntry<IAnnotatedSpecification>(e, annotatedSpec,
+											annotationProvider);
+							result.add(entry);
+							// if(annotatedSpec.getClass().isInstance(annotationProvider)) {
+							// result.put(e, annotationProvider.getValues(annotatedSpec));
+							// }
+
+						}
+					}
+				}
+			});
+			return result;
+		}
+		return result;
+	}
+
+	private <S, T> List<T> getAllChildren(EObject element, Class<? extends IModelElement> class1,
+			List<Class<? extends EObject>> filterOut) {
+
+		List<T> results = new ArrayList<T>();
+		getAllChildren2(element, class1, filterOut, results);
+		// EList<EObject> eContents = element.eContents();
+		// for(EObject o : eContents) {
+		// if(o.getClass().isInstance(clazz))
+		// getAllChildren((IModelElement)o, clazz, exceptions).add((T)o);
+		// else {
+		// if(o instanceof IModelElement)
+		// getAllChildren((IModelElement)o, clazz, exceptions);
+		// }
+		// }
+
+		return results;
+
+	}
+
+	private <T, S> void getAllChildren2(EObject element, Class<? extends IModelElement> class1,
+			List<Class<? extends EObject>> filterOut, final List<T> results) {
+
+		EList<EObject> eContents = element.eContents();
+		for(EObject o : eContents) {
+			if(class1.isInstance(o)) {
+				results.add((T)o);
+				getAllChildren2(o, class1, filterOut, results);
+			} else {
+				boolean filter = false;
+				for(Class<?> c : filterOut) {
+					if(c.isInstance(o))
+						filter = true;
+				}
+				if(!filter)
+					getAllChildren2(o, class1, filterOut, results);
+			}
+		}
+	}
+
+	/** {@inheritDoc} */
+	@Override
+	protected String getExtensionPointName() {
+		return EXTENSION_POINT_NAME;
+	}
+
+	/** {@inheritDoc} */
+	@Override
+	protected String getConfigurationElementName() {
+		return CONFIGURATION_ELEMENT_NAME;
+	}
+
+	/** {@inheritDoc} */
+	@Override
+	protected String getHandlerClassAttribute() {
+		return HANDLER_CLASS_ATTRIBUTE_NAME;
+	}
+
+	/** {@inheritDoc} */
+	@Override
+	protected boolean requiresUniqueHandler() {
+		return false;
+	}
+
+}

org.fortiss.tooling.base.ui/trunk/src/org/fortiss/tooling/base/ui/annotation/AnnotationViewPartBase.java

@@ -78,8 +78,7 @@ public abstract class AnnotationViewPartBase<T extends EObject, V extends IAnnot
 				currentlySelectedObject = (T)editPart.getModel();
 		}
 
-		if(currentlySelectedObject instanceof EObject &&
-				isAcceptedSelection(currentlySelectedObject)) {
+		if(isAcceptedSelection(currentlySelectedObject)) {
 			addAll();
 			annotatedSpecification = extractAnnotatedSpecification();
 			onUpdateView();

org.fortiss.tooling.base.ui/trunk/src/org/fortiss/tooling/base/ui/annotation/AnnotationViewPartBase2.java

+/*--------------------------------------------------------------------------+
+$Id$
+|                                                                          |
+| Copyright 2014 ForTISS GmbH                     |
+|                                                                          |
+| Licensed under the Apache License, Version 2.0 (the "License");          |
+| you may not use this file except in compliance with the License.         |
+| You may obtain a copy of the License at                                  |
+|                                                                          |
+|    http://www.apache.org/licenses/LICENSE-2.0                            |
+|                                                                          |
+| Unless required by applicable law or agreed to in writing, software      |
+| distributed under the License is distributed on an "AS IS" BASIS,        |
+| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
+| See the License for the specific language governing permissions and      |
+| limitations under the License.                                           |
++--------------------------------------------------------------------------*/
+package org.fortiss.tooling.base.ui.annotation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.ui.ISelectionListener;
+import org.eclipse.ui.IWorkbenchPart;
+import org.eclipse.ui.part.ViewPart;
+import org.fortiss.tooling.base.model.element.IAnnotatedSpecification;
+import org.fortiss.tooling.base.model.element.IModelElement;
+import org.fortiss.tooling.base.ui.editpart.DiagramEditPartBase;
+import org.fortiss.tooling.base.ui.editpart.ElementEditPartBase;
+import org.fortiss.tooling.kernel.ui.util.SelectionUtils;
+
+/**
+ * 
+ * @author eder
+ * @author $Author$
+ * @version $Rev$
+ * @ConQAT.Rating RED Hash:
+ */
+public abstract class AnnotationViewPartBase2 extends ViewPart implements ISelectionListener {
+
+	private IModelElement currentlySelectedObject;
+	protected List<AnnotationEntry<? extends IAnnotatedSpecification>> values =
+			new ArrayList<AnnotationEntry<? extends IAnnotatedSpecification>>();
+
+	/** {@inheritDoc} */
+	@Override
+	public void selectionChanged(IWorkbenchPart part, ISelection selection) {
+		currentlySelectedObject = null;
+		currentlySelectedObject = SelectionUtils.checkAndPickFirst(selection, IModelElement.class);
+
+		if(currentlySelectedObject == null) {
+			ElementEditPartBase<?> editPart =
+					SelectionUtils.checkAndPickFirst(selection, ElementEditPartBase.class);
+			if(editPart != null)
+				currentlySelectedObject = (IModelElement)editPart.getModel();
+			else {
+				DiagramEditPartBase<?> diagramPart =
+						SelectionUtils.checkAndPickFirst(selection, DiagramEditPartBase.class);
+				if(diagramPart != null)
+					currentlySelectedObject = (IModelElement)diagramPart.getModel();
+			}
+		}
+
+		values = IAnnotationValueService.INSTANCE.getValues(currentlySelectedObject);
+	}
+
+	/** {@inheritDoc} */
+	@Override
+	public void createPartControl(Composite parent) {
+		getSite().getWorkbenchWindow().getSelectionService().addSelectionListener(this);
+	}
+
+	/** {@inheritDoc} */
+	@Override
+	public void setFocus() {
+
+	}
+
+}

org.fortiss.tooling.base.ui/trunk/src/org/fortiss/tooling/base/ui/annotation/DummyAnnotationView.java

+/*--------------------------------------------------------------------------+
+$Id$
+|                                                                          |
+| Copyright 2014 ForTISS GmbH                     |
+|                                                                          |
+| Licensed under the Apache License, Version 2.0 (the "License");          |
+| you may not use this file except in compliance with the License.         |
+| You may obtain a copy of the License at                                  |
+|                                                                          |
+|    http://www.apache.org/licenses/LICENSE-2.0                            |
+|                                                                          |
+| Unless required by applicable law or agreed to in writing, software      |
+| distributed under the License is distributed on an "AS IS" BASIS,        |
+| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
+| See the License for the specific language governing permissions and      |
+| limitations under the License.                                           |
++--------------------------------------------------------------------------*/
+package org.fortiss.tooling.base.ui.annotation;
+
+import java.util.HashMap;
+import java.util.Map.Entry;
+
+import org.eclipse.jface.viewers.ArrayContentProvider;
+import org.eclipse.jface.viewers.ColumnLabelProvider;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.TableViewer;
+import org.eclipse.jface.viewers.TableViewerColumn;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.FillLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Table;
+import org.eclipse.ui.IWorkbenchPart;
+import org.fortiss.tooling.base.model.element.IAnnotatedSpecification;
+import org.fortiss.tooling.kernel.model.INamedCommentedElement;
+
+/**
+ * 
+ * @author eder
+ * @author $Author$
+ * @version $Rev$
+ * @ConQAT.Rating RED Hash:
+ */
+public class DummyAnnotationView extends AnnotationViewPartBase2 {
+
+	/** mapping of {@link IAnnotatedSpecification} -> TableViewerColumn */
+	private HashMap<Class<? extends IAnnotatedSpecification>, TableViewerColumn> columns =
+			new HashMap<Class<? extends IAnnotatedSpecification>, TableViewerColumn>();
+
+	/** The table viewer */
+	private TableViewer tableViewer;
+
+	/** {@inheritDoc} */
+	@Override
+	public void createPartControl(Composite parent) {
+		super.createPartControl(parent);
+		Composite c = new Composite(parent, SWT.NULL);
+		c.setLayout(new FillLayout(SWT.HORIZONTAL));
+
+		tableViewer = new TableViewer(c, SWT.BORDER | SWT.FULL_SELECTION);
+		Table table = tableViewer.getTable();
+		table.setHeaderVisible(true);
+		table.setLinesVisible(true);
+
+		final TableViewerColumn firstColumn = new TableViewerColumn(tableViewer, SWT.NONE);
+		firstColumn.getColumn().setText("IModelElement");
+		firstColumn.getColumn().setWidth(100);
+
+		tableViewer.setContentProvider(new ArrayContentProvider());
+		firstColumn.setLabelProvider(new ColumnLabelProvider() {
+			/** {@inheritDoc} */
+			@Override
+			public String getText(Object element) {
+				AnnotationEntry<?> entry = (AnnotationEntry<?>)element;
+				String modelElementName = entry.getModelElement().getClass().getSimpleName();
+				modelElementName = modelElementName.replace("Impl", "");
+				firstColumn.getColumn().setText(modelElementName);
+				return ((INamedCommentedElement)entry.getModelElement()).getName();// toString();
+
+			}
+		});
+
+	}
+
+	/** {@inheritDoc} */
+	@Override
+	public void selectionChanged(IWorkbenchPart part, ISelection selection) {
+		super.selectionChanged(part, selection);
+
+		for(Entry<Class<? extends IAnnotatedSpecification>, TableViewerColumn> e : columns
+				.entrySet()) {
+			e.getValue().getColumn().dispose();
+		}
+		columns.clear();
+
+		for(AnnotationEntry<? extends IAnnotatedSpecification> entry : values) {
+			if(!isExistingColumn(entry.getSpecification())) {
+				TableViewerColumn column = new TableViewerColumn(tableViewer, SWT.NONE);
+				column.getColumn().setText(entry.getAnnotationName());
+				column.getColumn().setWidth(100);
+				columns.put(entry.getSpecification().getClass(), column);
+				column.setLabelProvider(new ColumnLabelProvider2());
+			}
+
+		}
+
+		if(!tableViewer.getTable().isDisposed())
+			tableViewer.setInput(values);
+
+	}
+
+	/** Checks if column for given specification already exists */
+	private boolean isExistingColumn(IAnnotatedSpecification specification) {
+		if(columns.containsKey(specification.getClass()))
+			return true;
+		return false;
+	}
+
+	private class ColumnLabelProvider2 extends ColumnLabelProvider {
+
+		/** {@inheritDoc} */
+		@Override
+		public String getText(Object element) {
+			AnnotationEntry<?> entry = (AnnotationEntry<?>)element;
+			return entry.getSpecificationValue();
+		}
+	}
+
+	// FIXME
+	// public final class ExampleEditingSupport extends EditingSupport {
+	//
+	// private ComboBoxViewerCellEditor cellEditor = null;
+	//
+	// private ExampleEditingSupport(ColumnViewer viewer) {
+	// super(viewer);
+	// cellEditor =
+	// new ComboBoxViewerCellEditor((Composite)getViewer().getControl(), SWT.READ_ONLY);
+	// cellEditor.setLabelProvider(new LabelProvider());
+	// cellEditor.setContentProvider(new ArrayContentProvider());
+	// cellEditor.setInput(Value.values());
+	// }
+	//
+	// @Override
+	// protected CellEditor getCellEditor(Object element) {
+	// return cellEditor;
+	// }
+	//
+	// @Override
+	// protected boolean canEdit(Object element) {
+	// return true;
+	// }
+	//
+	// @Override
+	// protected Object getValue(Object element) {
+	// if(element instanceof ExampleData) {
+	// ExampleData data = (ExampleData)element;
+	// return data.getData();
+	// }
+	// return null;
+	// }
+	//
+	// @Override
+	// protected void setValue(Object element, Object value) {
+	// if(element instanceof ExampleData && value instanceof Value) {
+	// ExampleData data = (ExampleData)element;
+	// Value newValue = (Value)value;
+	// /* only set new value if it differs from old one */
+	// if(!data.getData().equals(newValue)) {
+	// data.setData(newValue);
+	// }
+	// }
+	// }
+	//
+	// }
+	//
+	// public static enum Value {
+	// value1, value2, value3;
+	// }
+	//
+	// public class ExampleData {
+	//
+	// private String label;
+	// private Value value;
+	//
+	// public ExampleData(String label, Value data) {
+	// this.label = label;
+	// this.value = data;
+	// }
+	//
+	// public String getLabel() {
+	// return label;
+	// }
+	//
+	// public void setLabel(String label) {
+	// this.label = label;
+	// }
+	//
+	// public Value getData() {
+	// return value;
+	// }
+	//
+	// public void setData(Value data) {
+	// this.value = data;
+	// }
+	//
+	// }
+}

org.fortiss.tooling.base.ui/trunk/src/org/fortiss/tooling/base/ui/annotation/IAnnotationModelElementIterator.java

+/*--------------------------------------------------------------------------+
+$Id$
+|                                                                          |
+| Copyright 2014 ForTISS GmbH                     |
+|                                                                          |
+| Licensed under the Apache License, Version 2.0 (the "License");          |
+| you may not use this file except in compliance with the License.         |
+| You may obtain a copy of the License at                                  |
+|                                                                          |
+|    http://www.apache.org/licenses/LICENSE-2.0                            |
+|                                                                          |
+| Unless required by applicable law or agreed to in writing, software      |
+| distributed under the License is distributed on an "AS IS" BASIS,        |
+| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
+| See the License for the specific language governing permissions and      |
+| limitations under the License.                                           |
++--------------------------------------------------------------------------*/
+package org.fortiss.tooling.base.ui.annotation;
+
+/**
+ * 
+ * @author eder
+ * @author $Author$
+ * @version $Rev$
+ * @ConQAT.Rating RED Hash:
+ */
+public interface IAnnotationModelElementIterator {
+
+}

org.fortiss.tooling.base.ui/trunk/src/org/fortiss/tooling/base/ui/annotation/IAnnotationValueProvider.java

+/*--------------------------------------------------------------------------+
+$Id$
+|                                                                          |
+| Copyright 2014 ForTISS GmbH                     |
+|                                                                          |
+| Licensed under the Apache License, Version 2.0 (the "License");          |
+| you may not use this file except in compliance with the License.         |
+| You may obtain a copy of the License at                                  |
+|                                                                          |
+|    http://www.apache.org/licenses/LICENSE-2.0                            |
+|                                                                          |
+| Unless required by applicable law or agreed to in writing, software      |
+| distributed under the License is distributed on an "AS IS" BASIS,        |
+| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
+| See the License for the specific language governing permissions and      |
+| limitations under the License.                                           |
++--------------------------------------------------------------------------*/
+package org.fortiss.tooling.base.ui.annotation;
+
+import java.util.List;
+
+import org.eclipse.emf.ecore.EObject;
+import org.fortiss.tooling.base.model.element.IAnnotatedSpecification;
+import org.fortiss.tooling.base.model.element.IModelElement;
+import org.fortiss.tooling.kernel.service.base.IEObjectAware;
+
+/**
+ * Interface for {@link IAnnotatedSpecification}s
+ * 
+ * @author eder
+ * @author $Author$
+ * @version $Rev$
+ * @ConQAT.Rating RED Hash:
+ */
+public interface IAnnotationValueProvider<T extends IAnnotatedSpecification> extends
+		IEObjectAware<IModelElement> {
+
+	// List<Annotation> annotations = new ArrayList<Annotation>();
+
+	/** Returns the specific value */
+	public String getValue(T specification);
+
+	public void setValue(String value, T specification);
+
+	/** Returns the specific type of T */
+	// public Class<? extends IAnnotatedSpecification> getAnnotatedSpecClazz();
+
+	public T addNewSpecToModelElement(IModelElement element);
+
+	public Class<T> getClazz();
+
+	public String getAnnotationName();
+
+	public List<Class<? extends EObject>> filterOut();
+
+}

org.fortiss.tooling.base.ui/trunk/src/org/fortiss/tooling/base/ui/annotation/IAnnotationValueService.java

+/*--------------------------------------------------------------------------+
+$Id$
+|                                                                          |
+| Copyright 2014 ForTISS GmbH                     |
+|                                                                          |
+| Licensed under the Apache License, Version 2.0 (the "License");          |
+| you may not use this file except in compliance with the License.         |
+| You may obtain a copy of the License at                                  |
+|                                                                          |
+|    http://www.apache.org/licenses/LICENSE-2.0                            |
+|                                                                          |
+| Unless required by applicable law or agreed to in writing, software      |
+| distributed under the License is distributed on an "AS IS" BASIS,        |
+| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
+| See the License for the specific language governing permissions and      |
+| limitations under the License.                                           |
++--------------------------------------------------------------------------*/
+package org.fortiss.tooling.base.ui.annotation;
+
+import java.util.List;
+
+import org.fortiss.tooling.base.model.element.IAnnotatedSpecification;
+import org.fortiss.tooling.base.model.element.IModelElement;
+
+/**
+ * 
+ * @author eder
+ * @author $Author$
+ * @version $Rev$
+ * @ConQAT.Rating RED Hash:
+ */
+public interface IAnnotationValueService {
+
+	/** Singleton instance */
+	public static final IAnnotationValueService INSTANCE = new AnnotationValueService();
+
+	/** Return the annotated values of the given element */
+	List<AnnotationEntry<? extends IAnnotatedSpecification>> getValues(IModelElement element);
+
+}

org.fortiss.tooling.base/trunk/model/base.ecore

@@ -142,7 +142,8 @@
         <details key="documentation" value="Super class of model element specifications, which should be excluded from the navigator view."/>
       </eAnnotations>
     </eClassifiers>
-    <eClassifiers xsi:type="ecore:EClass" name="IAnnotatedSpecification" eSuperTypes="#//element/IModelElementSpecification">
+    <eClassifiers xsi:type="ecore:EClass" name="IAnnotatedSpecification" interface="true"
+        eSuperTypes="#//element/IModelElementSpecification platform:/resource/org.fortiss.tooling.kernel/model/kernel.ecore#//INamedElement">
       <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
         <details key="documentation" value="Super class of hidden model element specifications that represent annotations."/>
       </eAnnotations>
@@ -153,6 +154,10 @@
         <details key="documentation" value="An array of model element specifications."/>
       </eAnnotations>
     </eClassifiers>
+    <eClassifiers xsi:type="ecore:EClass" name="Annotation">
+      <eStructuralFeatures xsi:type="ecore:EAttribute" name="name" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
+          defaultValueLiteral="annotation"/>
+    </eClassifiers>
   </eSubpackages>
   <eSubpackages name="layout" nsURI="http://www.fortiss.org/tooling/base/model/layout"
       nsPrefix="org-fortiss-tooling-base-model-layout">

org.fortiss.tooling.base/trunk/model/base.genmodel

@@ -49,6 +49,9 @@
       </genClasses>
       <genClasses image="false" ecoreClass="base.ecore#//element/IHiddenSpecification"/>
       <genClasses ecoreClass="base.ecore#//element/IAnnotatedSpecification"/>
+      <genClasses ecoreClass="base.ecore#//element/Annotation">
+        <genFeatures createChild="false" ecoreFeature="ecore:EAttribute base.ecore#//element/Annotation/name"/>
+      </genClasses>
     </nestedGenPackages>
     <nestedGenPackages prefix="Layout" basePackage="org.fortiss.tooling.base.model"
         disposableProviderFactory="true" ecorePackage="base.ecore#//layout">