Clean-up

teetime.configuration.klighd/.classpath

-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="src" path="xtend-gen"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-	<classpathentry combineaccessrules="false" kind="src" path="/teetime.configuration.model"/>
-	<classpathentry kind="output" path="bin"/>
-</classpath>

teetime.configuration.klighd/.project

-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>teetime.configuration.klighd</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>
-		<buildCommand>
-			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-		<nature>org.eclipse.pde.PluginNature</nature>
-		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
-	</natures>
-</projectDescription>

teetime.configuration.klighd/.settings/org.eclipse.jdt.core.prefs

-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
-org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.8
-org.eclipse.jdt.core.compiler.debug.lineNumber=generate
-org.eclipse.jdt.core.compiler.debug.localVariable=generate
-org.eclipse.jdt.core.compiler.debug.sourceFile=generate
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.source=1.8

teetime.configuration.klighd/META-INF/MANIFEST.MF

-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: teetime.configuration.klighd
-Bundle-Vendor: My Company
-Bundle-Version: 1.0.0.qualifier
-Bundle-SymbolicName: teetime.configuration.klighd; singleton:=true
-Bundle-ActivationPolicy: lazy
-Require-Bundle: javax.inject,
- com.google.guava,
- com.google.inject,
- org.eclipse.xtext.xbase.lib,
- de.cau.cs.kieler.core.krendering,
- de.cau.cs.kieler.core.krendering.extensions,
- de.cau.cs.kieler.kiml,
- de.cau.cs.kieler.klay.layered,
- de.cau.cs.kieler.klighd,
- de.cau.cs.kieler.klighd.piccolo,
- de.cau.cs.kieler.klighd.ui,
- de.cau.cs.kieler.klighd.ui.contrib3x,
- de.cau.cs.kieler.kiml.graphviz.layouter;resolution:=optional,
- org.eclipse.ui,
- org.eclipse.ui.ide.application,
- org.eclipse.ui.navigator.resources,
- org.eclipse.ui.views.log,
- org.eclipse.core.resources,
- org.eclipse.emf,
- org.eclipse.xtext.ui;resolution:=optional
-Import-Package: teetime.model.configuration
-Bundle-RequiredExecutionEnvironment: JavaSE-1.8

teetime.configuration.klighd/build.properties

-source.. = src//,\
-           xtend-gen/
-bin.includes = META-INF/,\
-               .,\
-               plugin.xml

teetime.configuration.klighd/plugin.xml

-<?xml version="1.0" encoding="UTF-8"?>
-<?eclipse version="3.4"?>
-<plugin>
-   <extension
-         point="de.cau.cs.kieler.klighd.diagramSyntheses">
-   <diagramSynthesis
-         class="de.cau.cs.kieler.klighd.syntheses.GuiceBasedSynthesisFactory:teetime.configuration.klighd.DiagramSynthesis"
-         id="teetime.configuration.klighd.DiagramSynthesis">
-   </diagramSynthesis>
-   </extension>
-<extension
-      point="org.eclipse.ui.commands">
-   <category
-         description="Configuration diagrams"
-         id="teetime.configuration.klighd.ConfigurationDiagrams"
-         name="ConfigurationDiagrams">
-   </category>
-   <command
-         categoryId="teetime.configuration.klighd.ConfigurationDiagrams"
-         defaultHandler="teetime.configuration.klighd.OpenDiagramHandler"
-         description="Primitive helper command that opens KLighD-based Configuration diagrams."
-         id="teetime.configuration.klighd.openConfigurationDiagram"
-         name="Open Configuration diagram">
-   </command>
-</extension>
-
-<extension
-      point="org.eclipse.ui.menus">
-   <menuContribution
-         locationURI="popup:org.eclipse.ui.popup.any?before=additions">
-      <command
-            commandId="teetime.configuration.klighd.openConfigurationDiagram"
-            label="Open Configuration diagram"
-            style="push">
-         <visibleWhen
-               checkEnabled="false">
-            <or>
-               <and>
-                  <with
-                        variable="activeEditor">
-                     <instanceof
-                           value="org.eclipse.xtext.ui.editor.XtextEditor">
-                     </instanceof>
-                  </with>
-                  <with
-                        variable="activeEditorInput">
-                     <adapt type="org.eclipse.core.resources.IResource">
-                         <test
-                               forcePluginActivation="false"
-                               property="org.eclipse.core.resources.extension"
-                               value="configuration">
-                         </test>
-                     </adapt>
-                  </with>
-               </and>
-               <iterate ifEmpty="false" operator="or">
-                  <or>
-                     <instanceof
-                         value="teetime.model.configuration.Configuration">
-                     </instanceof>
-                     <adapt type="org.eclipse.core.resources.IResource">
-                         <test
-                               forcePluginActivation="false"
-                               property="org.eclipse.core.resources.extension"
-                               value="configuration">
-                         </test>
-                     </adapt>
-                  </or>
-               </iterate>
-            </or>
-         </visibleWhen>
-      </command>
-   </menuContribution>
-</extension>
-
-</plugin>

teetime.configuration.klighd/src/teetime/configuration/klighd/DiagramSynthesis.xtend

-package teetime.configuration.klighd
-
-import de.cau.cs.kieler.core.kgraph.KEdge
-import de.cau.cs.kieler.core.kgraph.KNode
-import de.cau.cs.kieler.core.krendering.KRenderingFactory
-import de.cau.cs.kieler.core.krendering.extensions.KColorExtensions
-import de.cau.cs.kieler.core.krendering.extensions.KContainerRenderingExtensions
-import de.cau.cs.kieler.core.krendering.extensions.KEdgeExtensions
-import de.cau.cs.kieler.core.krendering.extensions.KLabelExtensions
-import de.cau.cs.kieler.core.krendering.extensions.KNodeExtensions
-import de.cau.cs.kieler.core.krendering.extensions.KPolylineExtensions
-import de.cau.cs.kieler.core.krendering.extensions.KPortExtensions
-import de.cau.cs.kieler.core.krendering.extensions.KRenderingExtensions
-import de.cau.cs.kieler.kiml.options.Direction
-import de.cau.cs.kieler.kiml.options.EdgeRouting
-import de.cau.cs.kieler.kiml.options.LayoutOptions
-import de.cau.cs.kieler.kiml.options.PortConstraints
-import de.cau.cs.kieler.kiml.options.PortSide
-import de.cau.cs.kieler.klighd.SynthesisOption
-import de.cau.cs.kieler.klighd.syntheses.AbstractDiagramSynthesis
-import de.cau.cs.kieler.klighd.util.KlighdProperties
-import javax.inject.Inject
-import teetime.model.configuration.Configuration
-import teetime.model.configuration.Pipe
-import teetime.model.configuration.Stage
-import de.cau.cs.kieler.core.krendering.LineJoin
-import de.cau.cs.kieler.klay.layered.properties.Properties
-import de.cau.cs.kieler.klay.layered.p4nodes.bk.CompactionStrategy
-import de.cau.cs.kieler.core.krendering.KLineStyle
-import de.cau.cs.kieler.core.krendering.LineStyle
-
-class DiagramSynthesis extends AbstractDiagramSynthesis<Configuration> {
-
-	@Inject extension KNodeExtensions
-	@Inject extension KEdgeExtensions
-	@Inject extension KPortExtensions
-	@Inject extension KRenderingExtensions
-	@Inject extension KContainerRenderingExtensions
-	@Inject extension KPolylineExtensions
-	@Inject extension KColorExtensions
-
-	private static val SynthesisOption SHOW_STATE = SynthesisOption::createCheckOption("Stage state", true)
-	private static val SynthesisOption SHOW_THREADS = SynthesisOption::createCheckOption("Thread assignment", true)
-
-	private val colorings = <Stage, KNode>newHashMap
-	private val falseStages = <Stage>newHashSet
-
-	override public getDisplayedSynthesisOptions() {
-		return newLinkedList(
-			SynthesisOption::createSeparator("Visualization options"),
-			SHOW_STATE,
-			SHOW_THREADS
-		);
-	}
-
-	override KNode transform(Configuration model) {
-
-		val root = model.createNode().associateWith(model);
-		var KNode color
-
-		for (stage : model.stages) {
-			if (stage.inputPorts.size == 0 || stage.isIsActive) {
-				color = createThreadNode(root)
-				paintStages(stage, color)
-			}
-		}
-
-		model.stages.forEach [
-			val node = transformStage(model)
-			if (SHOW_THREADS.booleanValue) {
-				colorings.get(it).children += node
-			} else {
-				root.children += node
-			}
-		]
-
-		root.setLayoutOption(LayoutOptions::DIRECTION, Direction::RIGHT)
-		root.addLayoutParam(Properties::COMPACTION_STRATEGY, CompactionStrategy::IMPROVE_STRAIGHTNESS)
-
-		return root;
-	}
-
-	private def KNode createThreadNode(KNode root) {
-		val node = createNode
-		if (SHOW_THREADS.booleanValue) {
-			node.setLayoutOption(LayoutOptions::DIRECTION, Direction::RIGHT)
-			node.addLayoutParam(Properties::COMPACTION_STRATEGY, CompactionStrategy::IMPROVE_STRAIGHTNESS)
-			node.addRectangle() => [
-				background = "lightgray".color
-			]
-			root.children += node
-		}
-		node
-	}
-
-	private def create node : stage.createNode() transformStage(Stage stage, Configuration model) {
-		node.associateWith(stage);
-		node.addRoundedRectangle(4, 4, 1) => [
-			it.setShadow("black".color, 3)
-			val text = it.addText(stage.id).associateWith(stage.id).setSurroundingSpace(8, 0, 8, 0) => [
-				it.setProperty(KlighdProperties.VISIBILITY_SCALE_LOWER_BOUND, 0.70);
-			]
-			if (!(stage.isIsActive || stage.inputPorts.size == 0) && SHOW_STATE.booleanValue) {
-				it.lineStyle = LineStyle::DASH
-//				it.lineWidth = 2
-//				text.foreground = "gray40".color
-				text.fontItalic = true
-//				foreground = "gray40".color
-			}
-			if (falseStages.contains(stage)) {
-				it.background = "#FF5555".color
-			}
-		]
-		node.setMinimalNodeSize(100, 50)
-		val outgoingPipes = stage.outputPorts.map[it.pipe]
-		node.outgoingEdges.addAll(outgoingPipes.map[transformPipe(model)])
-	}
-
-	private def KEdge transformPipe(Pipe pipe, Configuration model) {
-		val edge = pipe.createEdge.associateWith(pipe)
-		if (pipe.isInterThread && SHOW_THREADS.booleanValue) {
-			val sourceThreadNode = colorings.get(pipe.sourcePort.eContainer as Stage)
-			val sourceThreadPort = createPort => [
-				sourceThreadNode.ports += it;
-			]
-
-			val targetThreadNode = colorings.get(pipe.targetPort.eContainer as Stage)
-			val targetThreadPort = createPort => [
-				targetThreadNode.ports += it;
-			]
-
-			edge.addPolyline(1)
-			edge.target = sourceThreadNode
-			edge.targetPort = sourceThreadPort
-
-			createEdge => [
-				source = sourceThreadNode
-				sourcePort = sourceThreadPort
-				sourceThreadPort.edges += it
-				addPolyline(1)
-				target = targetThreadNode
-				targetPort = targetThreadPort
-//				target = transformStage(pipe.targetPort.eContainer as Stage, model)
-			]
-
-			createEdge => [
-				source = targetThreadNode
-				sourcePort = targetThreadPort
-				targetThreadPort.edges += it
-				addPolyline(1).addHeadArrowDecorator
-				target = transformStage(pipe.targetPort.eContainer as Stage, model)
-			]
-		} else {
-			edge.addPolyline(1).addHeadArrowDecorator
-			edge.target = transformStage(pipe.targetPort.eContainer as Stage, model)
-		}
-		return edge
-	}
-
-	private def void paintStages(Stage stage, KNode color) {
-		if (colorings.containsKey(stage)) {
-			if(colorings.get(stage) != color) falseStages.add(stage)
-//				throw new IllegalArgumentException("Invalid thread assignment - " + stage.id + " needs to be active.")
-			return
-		} else {
-			colorings.put(stage, color)
-			stage.outputPorts.forEach [
-				if (!(it.pipe.targetPort.eContainer as Stage).isActive) {
-					paintStages(it.pipe.targetPort.eContainer as Stage, color)
-				}
-			]
-		}
-	}
-
-	private def Boolean isInterThread(Pipe pipe) {
-		val first = pipe.sourcePort.eContainer as Stage
-		val second = pipe.targetPort.eContainer as Stage
-		return colorings.get(first) != colorings.get(second)
-	}
-
-}

teetime.configuration.klighd/src/teetime/configuration/klighd/OpenDiagramHandler.java

-package teetime.configuration.klighd;
-
-import org.eclipse.core.commands.AbstractHandler;
-import org.eclipse.core.commands.ExecutionEvent;
-import org.eclipse.core.commands.ExecutionException;
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-import org.eclipse.jface.dialogs.MessageDialog;
-import org.eclipse.jface.text.ITextSelection;
-import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.jface.viewers.IStructuredSelection;
-import org.eclipse.ui.IEditorPart;
-import org.eclipse.ui.handlers.HandlerUtil;
-import org.eclipse.ui.statushandlers.StatusManager;
-
-import de.cau.cs.kieler.klighd.IDiagramWorkbenchPart;
-import de.cau.cs.kieler.klighd.ui.DiagramViewManager;
-
-/**
- * A simple handler for opening diagrams.
- */
-public class OpenDiagramHandler extends AbstractHandler {
-
-    /**
-     * {@inheritDoc}
-     */
-    public Object execute(final ExecutionEvent event) throws ExecutionException {
-        final ISelection selection = HandlerUtil.getCurrentSelection(event);
-
-        if (selection instanceof ITextSelection) {
-            IEditorPart activeEditor = HandlerUtil.getActiveEditor(event);
-            
-            // because of the visibility expressions in the plugin.xml guarding the menu contributions
-            //  we can conclude to have a selection stemming from an XtextEditor; thus...
-            IDiagramWorkbenchPart diagramPart = DiagramViewManager.createView(
-                    "teetime.configuration.klighd.ConfigurationDiagram", "Configuration Diagram",
-                    XtextEditorUtil.getXtextModelAccessProxy(activeEditor));
-        
-            
-            if (diagramPart != null) {
-                XtextEditorUtil.registerSelectionListener(activeEditor, diagramPart);
-            }
-        
-        } else if (selection instanceof IStructuredSelection) {
-            final IStructuredSelection sSelection  = (IStructuredSelection) selection;
-
-            final Object firstElement = sSelection.getFirstElement();
-            final Object model;
-
-            if (firstElement instanceof IFile) {
-                try {
-                    final ResourceSet rs = new ResourceSetImpl();
-                    final Resource r = rs.getResource(URI.createPlatformResourceURI(
-                            ((IFile) firstElement).getFullPath().toString(), true), true);
-                    EcoreUtil.resolveAll(r);
-
-                    if (r.getContents().size() > 0) {
-                        model = r.getContents().get(0);
-                        r.unload();
-                    } else {
-                        r.unload();
-                        return null;
-                    }
-
-                } catch (Exception e) {
-                    final String message = "Could not load selected file.";
-                    StatusManager.getManager().handle(
-                            new Status(IStatus.ERROR, this.getClass().getCanonicalName(), message, e),
-                            StatusManager.SHOW);
-                    return null;
-                }
-            } else {
-                model = firstElement;
-            }
-
-            DiagramViewManager.createView(
-                    "teetime.configuration.klighd.ConfigurationDiagram", "Configuration Diagram", model);
-        } else {
-            MessageDialog.openInformation(HandlerUtil.getActiveShell(event), "Unsupported element",
-                    "KLighD diagram synthesis is unsupported for the current selection "
-                            + selection.toString() + ".");
-        }
-        return null;
-    }
-}

teetime.configuration.klighd/src/teetime/configuration/klighd/XtextEditorUtil.java

-package teetime.configuration.klighd;
-
-import java.util.Map;
-
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.ui.IEditorPart;
-import org.eclipse.ui.IPartListener;
-import org.eclipse.ui.ISelectionListener;
-import org.eclipse.ui.IWorkbenchPage;
-import org.eclipse.ui.IWorkbenchPart;
-import org.eclipse.xtext.nodemodel.INode;
-import org.eclipse.xtext.nodemodel.util.NodeModelUtils;
-import org.eclipse.xtext.resource.XtextResource;
-import org.eclipse.xtext.ui.editor.XtextEditor;
-import org.eclipse.xtext.util.concurrent.IUnitOfWork;
-
-import com.google.common.base.Function;
-import com.google.common.collect.Iterators;
-import com.google.common.collect.Maps;
-
-import de.cau.cs.kieler.klighd.IDiagramWorkbenchPart;
-import de.cau.cs.kieler.klighd.IKlighdSelection;
-import de.cau.cs.kieler.klighd.ISourceProxy;
-import de.cau.cs.kieler.klighd.ui.parts.DiagramViewPart;
-
-public class XtextEditorUtil {
-
-    /**
-     * Factory method providing an implementation of {@link ISourceProxy} enabling the execution of
-     * KLighD operations properly within Xtext's {@link IUnitOfWork IUnitOfWorks}.
-     *
-     * @param editorPart
-     *            the {@link XtextEditor} whose model shall be accessed
-     * @return the desired {@link ISourceProxy} implementation
-     */
-    public static ISourceProxy getXtextModelAccessProxy(final IEditorPart editorPart) {
-        if (!(editorPart instanceof XtextEditor)) {
-            // if a non-Xtext editor is given don't to anything;
-            return null;
-        }
-
-        final XtextEditor xtextEditor = (XtextEditor) editorPart;
-
-        // because Xtext editors protect the model (resource) by a transaction mechanism
-        //  an instance of ISourceProxy is returned instead of returning the model directly
-        return new ISourceProxy() {
-
-            // The implementation of 'execute(...)' implements Xtext's transaction mechanism;
-            // KLighD will invoke this method and provide a function wrapping the KLighD internal
-            //  functionality; the function's result must be returned by 'execute(...)' method
-
-            public <T> T execute(final Function<Object, T> function) {
-                if (xtextEditor.getDocument() == null) {
-                    // stop if for some reason there's no document (shouldn't happen)
-                    return null;
-                }
-
-                // perform a read operation on the model and execute KLighD's tasks
-                return xtextEditor.getDocument().readOnly(new IUnitOfWork<T, XtextResource>() {
-
-                    public T exec(final XtextResource res) throws Exception {
-                        // return just 'null' if there's no model within the resource
-                        //  otherwise apply the function provided by KLighD
-                        return res.getContents().isEmpty() ? null :
-                            function.apply(res.getContents().get(0));
-                    }
-                });
-            }
-        };
-    }
-
-    private static final Map<XtextEditor, ISelectionListener> selectionListeners = Maps.newHashMap();
-
-
-    /**
-     * Registers an {@link ISelectionListener} dedicated to {@code diagramPart}
-     * in the Eclipse selection service. This selection listener listens for selections
-     * in {@code diagramPart} and is in charge of highlighting the corresponding
-     * declarations in {@code editorPart}, which is supposed to be an {@link XtextEditor}.<br>
-     * <br>
-     * The registered listeners are tracked and de-registered if {@code editorPart} is closed.
-     *
-     * @param editorPart
-     *            is supposed to be a valid {@link XtextEditor}
-     * @param diagramPart
-     *            the diagram view part to be listened for selection changes
-     */
-    public static void registerSelectionListener(IEditorPart editorPart, IDiagramWorkbenchPart diagramPart) {
-        if (!(editorPart instanceof XtextEditor)) {
-            return;
-        }
-
-        final XtextEditor xtextEditor = (XtextEditor) editorPart;
-
-        // the selection listeners are installed corresponding to the 'xtextEditors'
-        //  that provide the source (domain) models
-        // if there is already a listener tracked with the given editor, we're done
-        if (selectionListeners.containsKey(xtextEditor)) {
-            return;
-        }
-
-        // otherwise instantiate a new listener, ...
-        final ISelectionListener selectionListener = new ISelectionListener() {
-
-            @Override
-            public void selectionChanged(IWorkbenchPart part, ISelection selection) {
-                // first check for the correct selection type (just for safety purposes)
-                if (!(selection instanceof IKlighdSelection)) {
-                    return;
-                }
-
-                final IKlighdSelection klighdSelection = (IKlighdSelection) selection;
-
-                // obtain the first selected diagram element and ask KLighD
-                //  (i.e. the diagram's ViewContext) for the corresponding source element
-                final Object selectedDomainElement = klighdSelection.getViewContext().getSourceElement(
-                        Iterators.getNext(klighdSelection.diagramElementsIterator(), null));
-
-                // try to highlight the corresponding definition if 'selectedDomainElement' is
-                //  a valid model element, i.e. non null, for example
-                if (selectedDomainElement instanceof EObject) {
-                    highlightSelection(xtextEditor, (EObject) selectedDomainElement);
-                }
-            }
-        };
-
-        // ... keep it in mind, ...
-        selectionListeners.put(xtextEditor, selectionListener);
-
-        // ... compose the partId from primary and secondary id as required by the selection service
-        //  (the KLighD DiagramViewPart is a multi view; black magic ... *hoo*), ...
-        final String partId = DiagramViewPart.VIEW_ID + ":" + diagramPart.getPartId();
-
-        // ... and register the listener in the platform.
-        final IWorkbenchPage diagramPartPage = diagramPart.getSite().getPage();
-        diagramPartPage.addSelectionListener(partId, selectionListener);
-
-        // For properly de-installing the selection listener we need to keep track of the editor. If
-        //  gets closed the selection listener gets obsolete as there's nothing to highlight any more.
-        // Thus, we register an IPartListener that listens for the closure of the editor.
-        // It reveals the selection listener to be removed from the memory map, removes it from the
-        //  platform (selection service), and finally de-installes itself.
-
-        final IWorkbenchPage editorPartPage = xtextEditor.getSite().getPage();
-        editorPartPage.addPartListener(new IPartListener() {
-
-            @Override
-            public void partClosed(IWorkbenchPart part) {
-                if (part == xtextEditor) {
-                    final ISelectionListener l = selectionListeners.remove(xtextEditor);
-                    diagramPartPage.removeSelectionListener(partId, l);
-                    editorPartPage.removePartListener(this);
-                }
-            }
-
-            @Override
-            public void partOpened(IWorkbenchPart part) {
-            }
-
-            @Override
-            public void partDeactivated(IWorkbenchPart part) {
-            }
-
-            @Override
-            public void partBroughtToTop(IWorkbenchPart part) {
-            }
-
-            @Override
-            public void partActivated(IWorkbenchPart part) {
-            }
-        });
-    }
-
-
-    private static void highlightSelection(XtextEditor xtextEditor, EObject element) {
-
-        // ask 'xtextEditor' for the position of 'element's definition
-        final Integer[] elementData = xtextEditor.getDocument().readOnly(
-                new IUnitOfWork<Integer[], XtextResource>() {
-
-                    public Integer[] exec(final XtextResource state) throws Exception {
-
-                        final INode node = NodeModelUtils.findActualNodeFor(element);
-                        return node == null ? null
-                                : new Integer[] { node.getOffset(), node.getLength() };
-                    }
-                });
-
-        if (elementData == null) {
-            return;
-        }
-
-        // set the selection to that area
-        xtextEditor.getInternalSourceViewer().setSelectedRange(elementData[0], elementData[1]);
-        xtextEditor.getInternalSourceViewer().revealRange(elementData[0], elementData[1]);
-
-        // bring the editor to foreground
-        xtextEditor.getSite().getPage().bringToTop(xtextEditor);
-    }
-}

teetime.configuration.model.edit/.classpath

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

teetime.configuration.model.edit/.project

-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>teetime.configuration.model.edit</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.jdt.core.javanature</nature>
-		<nature>org.eclipse.pde.PluginNature</nature>
-	</natures>
-</projectDescription>

teetime.configuration.model.edit/META-INF/MANIFEST.MF

-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %pluginName
-Bundle-SymbolicName: teetime.configuration.model.edit;singleton:=true
-Bundle-Version: 1.0.0.qualifier
-Bundle-ClassPath: .
-Bundle-Activator: teetime.model.configuration.provider.ConfigurationEditPlugin$Implementation
-Bundle-Vendor: %providerName
-Bundle-Localization: plugin
-Bundle-RequiredExecutionEnvironment: JavaSE-1.8
-Export-Package: teetime.model.configuration.provider
-Require-Bundle: org.eclipse.core.runtime,
- teetime.configuration.model;visibility:=reexport,
- org.eclipse.emf.edit;visibility:=reexport
-Bundle-ActivationPolicy: lazy

teetime.configuration.model.edit/build.properties

-#
-
-bin.includes = .,\
-               icons/,\
-               META-INF/,\
-               plugin.xml,\
-               plugin.properties
-jars.compile.order = .
-source.. = src/
-output.. = bin/