Added first implementation of breakpoint support

plugins/org.yakindu.sct.simulation.core/META-INF/MANIFEST.MF

@@ -17,6 +17,7 @@ Require-Bundle: org.eclipse.core.runtime,
 Bundle-RequiredExecutionEnvironment: J2SE-1.5
 Bundle-ActivationPolicy: lazy
 Export-Package: org.yakindu.sct.simulation.core,
+ org.yakindu.sct.simulation.core.breakpoints,
  org.yakindu.sct.simulation.core.debugmodel,
  org.yakindu.sct.simulation.core.extensions,
  org.yakindu.sct.simulation.core.hmr,
@@ -24,3 +25,7 @@ Export-Package: org.yakindu.sct.simulation.core,
  org.yakindu.sct.simulation.core.runtime,
  org.yakindu.sct.simulation.core.runtime.impl,
  org.yakindu.sct.simulation.core.util
+Import-Package: com.google.inject;version="1.3.0",
+ org.eclipse.debug.internal.ui.viewers.model.provisional,
+ org.eclipse.emf.edit.ui.provider,
+ org.yakindu.sct.model.sgraph.provider

plugins/org.yakindu.sct.simulation.core/plugin.xml

@@ -3,6 +3,7 @@
 <plugin>
    <extension-point id="org.yakindu.sct.simulation.core.executionfactory" name="ExecutionFactory" schema="schema/executionfactory.exsd"/>
 
+	<!-- Launch configuration -->
 	<extension point="org.eclipse.debug.core.launchConfigurationTypes">
     	<launchConfigurationType
           delegate="org.yakindu.sct.simulation.core.launch.StatechartLaunchConfigurationDelegate"
@@ -11,4 +12,21 @@
           name="YAKINDU Statechart">
     	</launchConfigurationType>
 	</extension>
+	<!-- Breakpoints -->
+	<extension point="org.eclipse.debug.core.breakpoints">
+   		<breakpoint 
+      		markerType="org.yakindu.sct.simulation.core.breakpoints"
+      		class="org.yakindu.sct.simulation.core.breakpoints.SCTBreakpoint"
+      		id="org.yakindu.sct.simulation.core.sct.breakpoints">
+   		</breakpoint>
+	</extension>
+ <extension
+       id="breakpoints"
+       point="org.eclipse.core.resources.markers">
+    <super type="org.eclipse.debug.core.breakpointMarker"/>
+    <persistent value="true"/>
+      <attribute name="message"/>
+      <attribute name="elementId"/>
+      <attribute name="expression"/>
+ </extension>
 </plugin>

plugins/org.yakindu.sct.simulation.core/src/org/yakindu/sct/simulation/core/breakpoints/SCTBreakpoint.java

@@ -0,0 +1,115 @@
+/**
+ * Copyright (c) 2013 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * Contributors:
+ * 	committers of YAKINDU - initial API and implementation
+ * 
+ */
+package org.yakindu.sct.simulation.core.breakpoints;
+
+import java.util.Collections;
+
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.debug.core.model.Breakpoint;
+import org.eclipse.debug.core.model.IBreakpoint;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.emf.ecore.resource.URIConverter;
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.workspace.util.WorkspaceSynchronizer;
+
+/**
+ * 
+ * @author andreas muelder - Initial contribution and API
+ * 
+ */
+public class SCTBreakpoint extends Breakpoint {
+
+	public static final String BREAKPOINT_ID = "org.yakindu.sct.debug.core.breakpoints";
+	public static final String MARKER_ID = "org.yakindu.sct.simulation.core.breakpoints";
+
+	public static final String EOBJECT_URI = " org.yakindu.sct.simulation.core.breakpoint.eobjectrui";
+	private static final String ELEMENT_ID = "elementId";
+	private static final String EXPRESSION = " org.yakindu.sct.simulation.core.breakpoints.expression";
+
+	private transient EObject semanticObject;
+
+	public SCTBreakpoint() {
+		// Default c'tor to restore from marker
+	}
+
+	public SCTBreakpoint(EObject semanticObject) {
+		this.semanticObject = semanticObject;
+		createMarker(semanticObject);
+	}
+
+	private void createMarker(EObject semanticObject) {
+		try {
+			IMarker marker = WorkspaceSynchronizer.getFile(semanticObject.eResource()).createMarker(MARKER_ID);
+			setMarker(marker);
+			setEnabled(true);
+			ensureMarker().setAttribute(IBreakpoint.ID, BREAKPOINT_ID);
+			setAttribute(IMarker.MESSAGE, semanticObject.eClass().getInstanceTypeName() + " Breakpoint");
+			setAttribute(EOBJECT_URI, EcoreUtil.getURI(semanticObject).toString());
+		} catch (CoreException e) {
+			e.printStackTrace();
+		}
+	}
+
+	public String getModelIdentifier() {
+		return BREAKPOINT_ID;
+	}
+
+	public EObject getSemanticObject() {
+		if (semanticObject == null) {
+			try {
+				initSemanticObject();
+			} catch (CoreException e) {
+				e.printStackTrace();
+			}
+		}
+		return semanticObject;
+	}
+
+	protected void initSemanticObject() throws CoreException {
+		ResourceSet set = new ResourceSetImpl();
+		String objectUri = getMarker().getAttribute(EOBJECT_URI, "");
+		URI uri = URI.createURI(objectUri);
+		if (URIConverter.INSTANCE.exists(uri, Collections.emptyMap())) {
+			semanticObject = set.getEObject(uri, true);
+		} else
+			delete();
+	}
+
+	public void setSemanticObject(EObject semanticObject) {
+		this.semanticObject = semanticObject;
+	}
+
+	public void setNotationViewURI(String uri) {
+		try {
+			setAttribute(ELEMENT_ID, uri);
+		} catch (CoreException e) {
+			e.printStackTrace();
+		}
+	}
+
+	public void setExpression(String expression) {
+		try {
+			setAttribute(EXPRESSION, expression);
+		} catch (CoreException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+	public String getExpression() {
+		return getMarker().getAttribute(EXPRESSION, "");
+	}
+
+}

plugins/org.yakindu.sct.simulation.core/src/org/yakindu/sct/simulation/core/debugmodel/SCTDebugTarget.java

@@ -29,14 +29,18 @@ import org.eclipse.debug.core.model.IMemoryBlock;
 import org.eclipse.debug.core.model.IProcess;
 import org.eclipse.debug.core.model.IThread;
 import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.emf.workspace.util.WorkspaceSynchronizer;
 import org.yakindu.sct.commons.WorkspaceClassLoaderFactory;
+import org.yakindu.sct.model.sexec.Reaction;
 import org.yakindu.sct.model.sexec.Trace;
+import org.yakindu.sct.model.sexec.TraceReactionWillFire;
 import org.yakindu.sct.model.sexec.TraceStateEntered;
 import org.yakindu.sct.model.sexec.TraceStateExited;
 import org.yakindu.sct.model.sgraph.Region;
 import org.yakindu.sct.model.sgraph.RegularState;
 import org.yakindu.sct.model.sgraph.Statechart;
+import org.yakindu.sct.simulation.core.breakpoints.SCTBreakpoint;
 import org.yakindu.sct.simulation.core.extensions.ExecutionFactoryExtensions;
 import org.yakindu.sct.simulation.core.extensions.ExecutionFactoryExtensions.ExecutionFactoryDescriptor;
 import org.yakindu.sct.simulation.core.launch.IStatechartLaunchParameters;
@@ -52,8 +56,8 @@ import org.yakindu.sct.simulation.core.runtime.impl.EventDrivenExecutionFacadeCo
  * @author andreas muelder - Initial contribution and API
  * 
  */
-public class SCTDebugTarget extends SCTDebugElement implements IDebugTarget,
-		IStatechartLaunchParameters, IExecutionTraceListener {
+public class SCTDebugTarget extends SCTDebugElement implements IDebugTarget, IStatechartLaunchParameters,
+		IExecutionTraceListener {
 
 	private ILaunch launch;
 
@@ -69,30 +73,28 @@ public class SCTDebugTarget extends SCTDebugElement implements IDebugTarget,
 
 	private IExecutionFacadeController controller;
 
-	public SCTDebugTarget(ILaunch launch, Statechart statechart)
-			throws CoreException {
+	private IExecutionFacadeFactory factory;
+
+	public SCTDebugTarget(ILaunch launch, Statechart statechart) throws CoreException {
 		super(null, statechart.eResource().getURI().toPlatformString(true));
 		this.launch = launch;
 		this.statechart = statechart;
 		threads = new ArrayList<SCTDebugThread>();
-		DebugPlugin.getDefault().getBreakpointManager()
-				.addBreakpointListener(this);
+		DebugPlugin.getDefault().getBreakpointManager().addBreakpointListener(this);
 		createExecutionModel(statechart);
 	}
 
-	private void createExecutionModel(Statechart statechart)
-			throws CoreException {
-		IExecutionFacadeFactory factory = getExecutionFacadeFactory(statechart);
+	protected void createExecutionModel(Statechart statechart) throws CoreException {
+		factory = getExecutionFacadeFactory(statechart);
 		facade = factory.createExecutionFacade(statechart);
 		facade.addTraceListener(this);
-		initFacadeCallbacks(WorkspaceSynchronizer.getFile(
-				statechart.eResource()).getProject());
+		initFacadeCallbacks(WorkspaceSynchronizer.getFile(statechart.eResource()).getProject());
 		initFacadeController();
 	}
 
-	private void initFacadeCallbacks(IProject project) {
-		ClassLoader classLoader = new WorkspaceClassLoaderFactory()
-				.createClassLoader(project, getClass().getClassLoader());
+	protected void initFacadeCallbacks(IProject project) {
+		ClassLoader classLoader = new WorkspaceClassLoaderFactory().createClassLoader(project, getClass()
+				.getClassLoader());
 		ILaunchConfiguration config = launch.getLaunchConfiguration();
 		try {
 			String classes = config.getAttribute(OPERATION_CLASS, "");
@@ -105,25 +107,16 @@ public class SCTDebugTarget extends SCTDebugElement implements IDebugTarget,
 					Class<?> loadClass = classLoader.loadClass(string);
 					facade.addCallbackObject(loadClass.newInstance());
 				}
-		} catch (CoreException e) {
-			e.printStackTrace();
-		} catch (ClassNotFoundException e) {
-			e.printStackTrace();
-		} catch (InstantiationException e) {
-			e.printStackTrace();
-		} catch (IllegalAccessException e) {
+		} catch (Exception e) {
 			e.printStackTrace();
 		}
 	}
 
-	private void initFacadeController() throws CoreException {
-		boolean isCycleBased = launch.getLaunchConfiguration().getAttribute(
-				IS_CYCLE_BASED, DEFAULT_IS_CYCLE_BASED);
+	protected void initFacadeController() throws CoreException {
+		boolean isCycleBased = launch.getLaunchConfiguration().getAttribute(IS_CYCLE_BASED, DEFAULT_IS_CYCLE_BASED);
 		if (isCycleBased) {
-			long cyclePeriod = launch.getLaunchConfiguration().getAttribute(
-					CYCLE_PERIOD, DEFAULT_CYCLE_PERIOD);
-			controller = new CycleBasedExecutionFacadeController(this,
-					cyclePeriod);
+			long cyclePeriod = launch.getLaunchConfiguration().getAttribute(CYCLE_PERIOD, DEFAULT_CYCLE_PERIOD);
+			controller = new CycleBasedExecutionFacadeController(this, cyclePeriod);
 		} else {
 			controller = new EventDrivenExecutionFacadeController(this);
 		}
@@ -153,8 +146,7 @@ public class SCTDebugTarget extends SCTDebugElement implements IDebugTarget,
 
 	public IThread[] getThreads() throws DebugException {
 		// Collect all active regions
-		Set<RegularState> activeLeafStates = facade.getExecutionContext()
-				.getActiveLeafStates();
+		Set<RegularState> activeLeafStates = facade.getExecutionContext().getActiveLeafStates();
 		List<Region> activeRegions = new ArrayList<Region>();
 		for (RegularState vertex : activeLeafStates) {
 			activeRegions.add(vertex.getParentRegion());
@@ -176,8 +168,7 @@ public class SCTDebugTarget extends SCTDebugElement implements IDebugTarget,
 				}
 			}
 			if (!found) {
-				threads.add(new SCTDebugThread(this, facade,
-						getResourceString(), region));
+				threads.add(new SCTDebugThread(this, facade, getResourceString(), region));
 			}
 		}
 		return threads.toArray(new IThread[] {});
@@ -192,7 +183,7 @@ public class SCTDebugTarget extends SCTDebugElement implements IDebugTarget,
 	}
 
 	public boolean supportsBreakpoint(IBreakpoint breakpoint) {
-		return false;
+		return true;
 	}
 
 	public boolean canTerminate() {
@@ -261,8 +252,7 @@ public class SCTDebugTarget extends SCTDebugElement implements IDebugTarget,
 		return false;
 	}
 
-	public IMemoryBlock getMemoryBlock(long startAddress, long length)
-			throws DebugException {
+	public IMemoryBlock getMemoryBlock(long startAddress, long length) throws DebugException {
 		return null;
 	}
 
@@ -292,13 +282,38 @@ public class SCTDebugTarget extends SCTDebugElement implements IDebugTarget,
 	}
 
 	public void traceStepExecuted(Trace trace) {
-		if (trace instanceof TraceStateEntered
-				|| trace instanceof TraceStateExited)
+		if (trace instanceof TraceStateEntered || trace instanceof TraceStateExited)
 			fireChangeEvent(DebugEvent.CONTENT);
+		if (trace instanceof TraceReactionWillFire) {
+			if (launch.getLaunchMode().equals("debug"))
+				evaluateBreakpoints(trace);
+		}
+	}
+
+	private void evaluateBreakpoints(Trace trace) {
+		try {
+			Reaction reaction = ((TraceReactionWillFire) trace).getReaction();
+			EObject sourceElement = reaction.getSourceElement();
+			IBreakpoint[] breakpoints = DebugPlugin.getDefault().getBreakpointManager()
+					.getBreakpoints(SCTBreakpoint.BREAKPOINT_ID);
+			for (IBreakpoint iBreakpoint : breakpoints) {
+				if (!iBreakpoint.isEnabled())
+					continue;
+				if (iBreakpoint instanceof SCTBreakpoint) {
+					SCTBreakpoint sctBreakpoint = (SCTBreakpoint) iBreakpoint;
+					if (EcoreUtil.equals(sctBreakpoint.getSemanticObject(), sourceElement)) {
+						// TODO: Evaluate Breakpoint Condition
+						suspend();
+						fireEvent(new DebugEvent(this, DebugEvent.BREAKPOINT));
+					}
+				}
+			}
+		} catch (CoreException e1) {
+			e1.printStackTrace();
+		}
 	}
 
 	public Statechart getStatechart() {
 		return statechart;
 	}
-
 }

plugins/org.yakindu.sct.simulation.core/src/org/yakindu/sct/simulation/core/runtime/IExecutionFacadeFactory.java

@@ -11,6 +11,7 @@
 package org.yakindu.sct.simulation.core.runtime;
 
 import org.yakindu.sct.model.sgraph.Statechart;
+import org.yakindu.sct.model.sgraph.Statement;
 
 /**
  * 
@@ -22,5 +23,8 @@ public interface IExecutionFacadeFactory {
 	public IExecutionFacade createExecutionFacade(Statechart statechart);
 	
 	public boolean isApplicable(Statechart statechart);
+	
+	//TODO:
+	public boolean evaluate(Statement expression, IExecutionContext context);
 
 }

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

@@ -25,10 +25,14 @@ Require-Bundle: org.eclipse.ui,
  com.google.inject,
  org.eclipse.xtext.xbase.lib,
  org.apache.commons.lang;bundle-version="2.4.0",
- org.yakindu.sct.commons;bundle-version="1.0.0"
+ org.yakindu.sct.commons;bundle-version="1.0.0",
+ org.yakindu.sct.ui.integration.stext;bundle-version="2.1.1",
+ org.eclipse.xtext;bundle-version="2.4.2"
 Bundle-RequiredExecutionEnvironment: J2SE-1.5
 Bundle-ActivationPolicy: lazy
-Import-Package: org.eclipse.ui.dialogs
+Import-Package: org.eclipse.emf.edit.ui.provider,
+ org.eclipse.ui.dialogs,
+ org.yakindu.sct.model.sgraph.provider
 Export-Package: org.yakindu.sct.simulation.ui,
  org.yakindu.sct.simulation.ui.launch,
  org.yakindu.sct.simulation.ui.launch.tabs

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

@@ -122,4 +122,86 @@
           class="org.yakindu.sct.simulation.ui.preferences.PreferenceInitializer">
     </initializer>
  </extension>
+ 
+ 
+ 
+ <!-- Toggle breakpoint action -->
+<extension point="org.eclipse.ui.commands">
+ 	<command
+       defaultHandler="org.yakindu.sct.simulation.ui.breakpoints.ToggleBreakpointCommand"
+       id="org.yakindu.sct.simulation.ui.breakpoints.ToggleBreakpointCommand"
+       name="Toggle breakpoint">
+	</command>
+</extension>
+
+<extension
+       point="org.eclipse.ui.menus">
+    <menuContribution
+          allPopups="false"
+          locationURI="popup:org.eclipse.gmf.runtime.diagram.ui.DiagramEditorContextMenu">
+          <command
+                commandId="org.yakindu.sct.simulation.ui.breakpoints.ToggleBreakpointCommand"
+                label="Toggle Breakpoint"
+                style="push">
+             <visibleWhen
+                checkEnabled="false">
+             <with
+                   variable="selection">
+                <iterate
+                      ifEmpty="false"
+                      operator="and">
+                      <or>
+                   <instanceof
+                         value="org.yakindu.sct.ui.editor.editparts.TransitionEditPart">
+                   </instanceof>
+                  <!--
+                    <instanceof
+                         value="org.yakindu.sct.ui.editor.editparts.StateEditPart">
+                   </instanceof>
+                   -->
+                   </or>
+                </iterate>
+             </with>
+          </visibleWhen>
+          </command>
+    </menuContribution>
+ </extension>
+ <!-- Debug Model Presentation -->
+	<extension point = "org.eclipse.debug.ui.debugModelPresentations"> 
+       <debugModelPresentation 
+           class = "org.yakindu.sct.simulation.ui.breakpoints.SCTDebugModelPresentation"
+           id = "org.yakindu.sct.debug.core.breakpoints">
+       </debugModelPresentation> 
+   </extension>  
+  <!-- Breakpoint Decoration Provider -->
+   <extension id="breakpointDecoratorProvider" name="BreakpointDecorations" point="org.eclipse.gmf.runtime.diagram.ui.decoratorProviders">
+      <decoratorProvider class="org.yakindu.sct.simulation.ui.breakpoints.BreakpointDecorationProvider">
+         <Priority name="Medium"/>
+         <object class="org.eclipse.gmf.runtime.diagram.ui.editparts.IPrimaryEditPart(org.eclipse.gmf.runtime.diagram.ui)" id="PRIMARY_VIEW"/>
+         <context decoratorTargets="PRIMARY_VIEW"/>
+      </decoratorProvider>
+   </extension>
+  <!-- Breakpoint Detail Pane factory 
+  <extension point="org.eclipse.debug.ui.detailPaneFactories">
+       <detailFactories
+             class="org.yakindu.sct.simulation.ui.breakpoints.SCTDetailPaneFactory"
+             id="sctDetailPane">
+             <enablement>
+       		   <with
+                variable="selection">
+             <count
+                   value="1">
+             </count>
+             <iterate>
+                <instanceof
+                      value="org.yakindu.sct.simulation.core.breakpoints.SCTBreakpoint">
+                </instanceof>
+             </iterate>
+          </with>
+       </enablement>
+       </detailFactories>
+</extension>
+-->
+   
+  
 </plugin>

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/SimulationActivator.java

@@ -11,8 +11,10 @@
 package org.yakindu.sct.simulation.ui;
 
 import org.eclipse.debug.core.DebugPlugin;
+import org.eclipse.debug.core.model.IBreakpoint;
 import org.eclipse.ui.plugin.AbstractUIPlugin;
 import org.osgi.framework.BundleContext;
+import org.yakindu.sct.simulation.core.breakpoints.SCTBreakpoint;
 import org.yakindu.sct.simulation.core.hmr.SCTHotModelReplacementManager;
 import org.yakindu.sct.simulation.ui.dialogs.HotModelReplacementListener;
 import org.yakindu.sct.simulation.ui.perspective.SCTPerspectiveManager;
@@ -40,17 +42,20 @@ public class SimulationActivator extends AbstractUIPlugin {
 	public void start(BundleContext context) throws Exception {
 		super.start(context);
 		plugin = this;
-		SCTHotModelReplacementManager.INSTANCE
-				.addReplacementListener(hotModelReplacementListener);
+		SCTHotModelReplacementManager.INSTANCE.addReplacementListener(hotModelReplacementListener);
 		DebugPlugin.getDefault().getLaunchManager().addLaunchListener(manager);
+		IBreakpoint[] breakpoints = DebugPlugin.getDefault().getBreakpointManager().getBreakpoints(SCTBreakpoint.BREAKPOINT_ID);
+		for (IBreakpoint iBreakpoint : breakpoints) {
+			System.out.println(iBreakpoint);
+			
+		}
 
 	}
 
 	public void stop(BundleContext context) throws Exception {
 		plugin = null;
 		super.stop(context);
-		SCTHotModelReplacementManager.INSTANCE
-				.removeReplacementListener(hotModelReplacementListener);
+		SCTHotModelReplacementManager.INSTANCE.removeReplacementListener(hotModelReplacementListener);
 		DebugPlugin.getDefault().getLaunchManager().addLaunchListener(manager);
 	}
 

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/SimulationImages.java

@@ -12,21 +12,25 @@ import org.eclipse.swt.graphics.Image;
 public enum SimulationImages {
 
 	EVENT("icons/Event.gif"),
-	
+
 	TIMEEVENT("icons/TimeEvent.gif"),
-	
+
 	EVENT_ENABLED("icons/Event_enabled.gif"),
-	
+
 	EVENT_DISABLED("icons/Event_disabled.gif"),
 
 	VARIABLE("icons/Variable.gif"),
-	
+
 	SCOPE("icons/Scope.gif"),
-	
+
 	COLLAPSE_ALL("icons/collapseall.gif"),
-	
+
 	EXPAND_ALL("icons/expandall.gif"),
+
+	BREAKPOINT_ENABLED("icons/brkp_obj.gif"),
 	
+	BREAKPOINT_DISABLED("icons/brkpd_obj.gif"),
+
 	LAUNCHER_ICON("icons/Statechart-Launcher-16.png");
 
 	private final String path;
@@ -42,8 +46,7 @@ public enum SimulationImages {
 	 * @return an {@link Image}
 	 */
 	public Image image() {
-		final ImageRegistry imageRegistry = SimulationActivator.getDefault()
-				.getImageRegistry();
+		final ImageRegistry imageRegistry = SimulationActivator.getDefault().getImageRegistry();
 		Image image = imageRegistry.get(path);
 		if (image == null) {
 			addImageDescriptor();
@@ -59,8 +62,7 @@ public enum SimulationImages {
 	 * @return an {@link ImageDescriptor}
 	 */
 	public ImageDescriptor imageDescriptor() {
-		final ImageRegistry imageRegistry = SimulationActivator.getDefault()
-				.getImageRegistry();
+		final ImageRegistry imageRegistry = SimulationActivator.getDefault().getImageRegistry();
 		ImageDescriptor imageDescriptor = imageRegistry.getDescriptor(path);
 		if (imageDescriptor == null) {
 			addImageDescriptor();
@@ -72,8 +74,7 @@ public enum SimulationImages {
 
 	private void addImageDescriptor() {
 		final SimulationActivator plugin = SimulationActivator.getDefault();
-		final ImageDescriptor id = ImageDescriptor.createFromURL(plugin
-				.getBundle().getEntry(path));
+		final ImageDescriptor id = ImageDescriptor.createFromURL(plugin.getBundle().getEntry(path));
 		plugin.getImageRegistry().put(path, id);
 	}
 

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/breakpoints/BreakpointDecorationProvider.java

@@ -0,0 +1,91 @@
+/**
+ * Copyright (c) 2013 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * Contributors:
+ * 	committers of YAKINDU - initial API and implementation
+ * 
+ */
+package org.yakindu.sct.simulation.ui.breakpoints;
+
+import java.util.List;
+
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.debug.core.model.IBreakpoint;
+import org.eclipse.draw2d.Label;
+import org.eclipse.gmf.runtime.diagram.core.util.ViewUtil;
+import org.eclipse.gmf.runtime.diagram.ui.services.decorator.IDecoratorTarget;
+import org.eclipse.gmf.runtime.notation.Edge;
+import org.eclipse.gmf.runtime.notation.View;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.ui.IEditorPart;
+import org.yakindu.sct.simulation.core.breakpoints.SCTBreakpoint;
+import org.yakindu.sct.simulation.ui.SimulationImages;
+import org.yakindu.sct.ui.editor.editor.StatechartDiagramEditor;
+
+import de.itemis.gmf.runtime.commons.decorators.AbstractMarkerBasedDecorationProvider;
+
+/**
+ * Provides breakpoint decoration.
+ * 
+ * @author andreas muelder - Initial contribution and API
+ * 
+ */
+public class BreakpointDecorationProvider extends AbstractMarkerBasedDecorationProvider {
+
+	@Override
+	protected boolean shouldInstall(IEditorPart part) {
+		return part instanceof StatechartDiagramEditor;
+	}
+
+	@Override
+	protected String getDecoratorKey() {
+		return "org.yakindu.sct.simulation.ui.breakpoints";
+	}
+
+	@Override
+	protected StatusDecorator createStatusDecorator(IDecoratorTarget decoratorTarget) {
+		return new BreakpointStatusDecorator(decoratorTarget);
+	}
+
+	public static class BreakpointStatusDecorator extends StatusDecorator {
+
+		public BreakpointStatusDecorator(IDecoratorTarget decoratorTarget) {
+			super(decoratorTarget);
+		}
+
+		private Image getImage(IMarker marker) {
+			boolean enabled = marker.getAttribute(IBreakpoint.ENABLED, false);
+			return enabled ? SimulationImages.BREAKPOINT_ENABLED.image() : SimulationImages.BREAKPOINT_DISABLED.image();
+		}
+
+		@Override
+		protected String getMarkerType() {
+			return SCTBreakpoint.MARKER_ID;
+		}
+
+		@Override
+		protected void createDecorators(View view, List<IMarker> markers) {
+			String elementId = ViewUtil.getIdStr(view);
+			if (elementId == null) {
+				return;
+			}
+			for (IMarker marker : markers) {
+				String attribute = marker.getAttribute(org.eclipse.gmf.runtime.common.ui.resources.IMarker.ELEMENT_ID,
+						"");
+				if (attribute.equals(elementId)) {
+					if (view instanceof Edge) {
+						setDecoration(getDecoratorTarget().addConnectionDecoration(getImage(marker), 75, true));
+					} else {
+						setDecoration(getDecoratorTarget().addShapeDecoration(getImage(marker),
+								IDecoratorTarget.Direction.NORTH_WEST, 0, true));
+					}
+					Label toolTip = new Label(marker.getAttribute(IMarker.MESSAGE, ""), getImage(marker));
+					getDecoration().setToolTip(toolTip);
+				}
+			}
+		}
+	}
+}

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/breakpoints/SCTBreakpointDetailPane.java

@@ -0,0 +1,109 @@
+/**
+ * Copyright (c) 2013 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * Contributors:
+ * 	committers of YAKINDU - initial API and implementation
+ * 
+ */
+package org.yakindu.sct.simulation.ui.breakpoints;
+
+import org.eclipse.debug.ui.IDetailPane;
+import org.eclipse.draw2d.ColorConstants;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.jface.layout.GridDataFactory;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.custom.StyledText;
+import org.eclipse.swt.events.FocusEvent;
+import org.eclipse.swt.events.FocusListener;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.ui.IWorkbenchPartSite;
+import org.yakindu.sct.model.sgraph.SGraphPackage;
+import org.yakindu.sct.model.sgraph.Statechart;
+import org.yakindu.sct.model.sgraph.Statement;
+import org.yakindu.sct.simulation.core.breakpoints.SCTBreakpoint;
+import org.yakindu.sct.ui.integration.stext.ExpressionExpressionProvider;
+
+import de.itemis.xtext.utils.jface.viewers.ContextElementAdapter;
+import de.itemis.xtext.utils.jface.viewers.ContextElementAdapter.IContextElementProvider;
+import de.itemis.xtext.utils.jface.viewers.StyledTextXtextAdapter;
+
+/**
+ * 
+ * @author andreas muelder - Initial contribution and API
+ * 
+ */
+public class SCTBreakpointDetailPane implements IDetailPane, IContextElementProvider {
+
+	public static final String SCT_BREAKPOINT_PANE = "sctBreakpointPane";
+	private StyledTextXtextAdapter adapter;
+	private Statechart statechart;
+	private SCTBreakpoint sctBreakpoint;
+
+	public void init(IWorkbenchPartSite partSite) {
+		
+	}
+
+	public Control createControl(Composite parent) {
+		parent.setBackground(ColorConstants.white);
+		final StyledText txt = new StyledText(parent, SWT.BORDER | SWT.MULTI);
+		txt.addFocusListener(new FocusListener() {
+
+			public void focusLost(FocusEvent e) {
+				sctBreakpoint.setExpression((Statement) adapter.getFakeResourceContext().getFakeResource()
+						.getParseResult().getRootASTElement());
+			}
+
+			public void focusGained(FocusEvent e) {
+
+			}
+		});
+		ExpressionExpressionProvider provider = new ExpressionExpressionProvider();
+		adapter = new StyledTextXtextAdapter(provider.getInjector());
+		adapter.getFakeResourceContext().getFakeResource().eAdapters().add(new ContextElementAdapter(this));
+		adapter.adapt(txt);
+		GridDataFactory.fillDefaults().grab(true, true).applyTo(txt);
+		return txt;
+	}
+
+	public void dispose() {
+
+	}
+
+	public void display(IStructuredSelection selection) {
+		sctBreakpoint = (SCTBreakpoint) selection.getFirstElement();
+		if (sctBreakpoint == null)
+			return;
+		EObject semanticObject = sctBreakpoint.getSemanticObject();
+		Resource resource = semanticObject.eResource();
+		statechart = (Statechart) EcoreUtil.getObjectByType(resource.getContents(), SGraphPackage.Literals.STATECHART);
+
+	}
+
+	public boolean setFocus() {
+		return false;
+	}
+
+	public String getID() {
+		return SCT_BREAKPOINT_PANE;
+	}
+
+	public String getName() {
+		return "SCT Breakpoint Details";
+	}
+
+	public String getDescription() {
+		return null;
+	}
+
+	public EObject getContextObject() {
+		return statechart;
+	}
+
+}

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/breakpoints/SCTDebugModelPresentation.java

@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) 2013 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * Contributors:
+ * 	committers of YAKINDU - initial API and implementation
+ * 
+ */
+package org.yakindu.sct.simulation.ui.breakpoints;
+
+import org.eclipse.debug.core.model.IValue;
+import org.eclipse.debug.ui.IDebugModelPresentation;
+import org.eclipse.debug.ui.IValueDetailListener;
+import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider;
+import org.eclipse.gmf.runtime.diagram.ui.commands.CreateOrSelectElementCommand.LabelProvider;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.ui.IEditorInput;
+import org.yakindu.sct.model.sgraph.provider.SGraphItemProviderAdapterFactory;
+import org.yakindu.sct.simulation.core.breakpoints.SCTBreakpoint;
+import org.yakindu.sct.ui.editor.editor.StatechartDiagramEditor;
+
+/**
+ * 
+ * @author andreas muelder - Initial contribution and API
+ * 
+ */
+public class SCTDebugModelPresentation extends LabelProvider implements IDebugModelPresentation {
+
+	private AdapterFactoryLabelProvider labelProvider;
+
+	public SCTDebugModelPresentation() {
+		labelProvider = new AdapterFactoryLabelProvider(new SGraphItemProviderAdapterFactory());
+	}
+
+	public String getEditorId(IEditorInput input, Object element) {
+		return StatechartDiagramEditor.ID;
+	}
+
+	public Image getImage(Object element) {
+		return labelProvider.getImage(((SCTBreakpoint) element).getSemanticObject());
+	}
+
+	public String getText(Object element) {
+		return labelProvider.getText(((SCTBreakpoint) element).getSemanticObject());
+	}
+
+	public IEditorInput getEditorInput(Object element) {
+		return null;
+	}
+
+	public void computeDetail(IValue value, IValueDetailListener listener) {
+		// Nothing to do
+	}
+
+	public void setAttribute(String attribute, Object value) {
+		// Nothing to do
+	}
+
+}

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/breakpoints/SCTDetailPaneFactory.java

@@ -0,0 +1,48 @@
+package org.yakindu.sct.simulation.ui.breakpoints;
+
+import static org.yakindu.sct.simulation.ui.breakpoints.SCTBreakpointDetailPane.SCT_BREAKPOINT_PANE;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.eclipse.debug.ui.IDetailPane;
+import org.eclipse.debug.ui.IDetailPaneFactory;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.yakindu.sct.simulation.core.breakpoints.SCTBreakpoint;
+
+public class SCTDetailPaneFactory implements IDetailPaneFactory {
+
+	public Set<String> getDetailPaneTypes(IStructuredSelection selection) {
+		Set<String> possibleIDs = new HashSet<String>(1);
+		Object object = unwrap(selection);
+		if (object instanceof SCTBreakpoint)
+			possibleIDs.add(SCT_BREAKPOINT_PANE);
+		return possibleIDs;
+	}
+
+	public String getDefaultDetailPane(IStructuredSelection selection) {
+		return null;
+	}
+
+	public IDetailPane createDetailPane(String paneID) {
+		if (SCT_BREAKPOINT_PANE.equals(paneID)) {
+			return new SCTBreakpointDetailPane();
+		}
+		return null;
+	}
+
+	public String getDetailPaneName(String paneID) {
+		return SCT_BREAKPOINT_PANE;
+	}
+
+	public String getDetailPaneDescription(String paneID) {
+		return null;
+	}
+
+	public Object unwrap(ISelection selection) {
+		IStructuredSelection structuredSelection = (IStructuredSelection) selection;
+		return structuredSelection.getFirstElement();
+	}
+
+}

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/breakpoints/ToggleBreakpointCommand.java

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2013 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * Contributors:
+ * 	committers of YAKINDU - initial API and implementation
+ * 
+ */
+package org.yakindu.sct.simulation.ui.breakpoints;
+
+import org.eclipse.core.commands.AbstractHandler;
+import org.eclipse.core.commands.ExecutionEvent;
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.debug.core.DebugPlugin;
+import org.eclipse.debug.core.model.IBreakpoint;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.ui.handlers.HandlerUtil;
+import org.yakindu.sct.simulation.core.breakpoints.SCTBreakpoint;
+
+/**
+ * 
+ * @author andreas muelder - Initial contribution and API
+ * 
+ */
+public class ToggleBreakpointCommand extends AbstractHandler {
+
+	public Object execute(ExecutionEvent event) throws ExecutionException {
+		ISelection selection = HandlerUtil.getCurrentSelection(event);
+		IGraphicalEditPart selectedEditPart = unwrap(selection);
+		EObject object = selectedEditPart.resolveSemanticElement();
+		SCTBreakpoint existingBreakpoint = findExistingBreakpoint(object);
+		if (existingBreakpoint != null) {
+			try {
+				existingBreakpoint.delete();
+				return null;
+			} catch (CoreException e) {
+				e.printStackTrace();
+			}
+		}
+
+		SCTBreakpoint breakpoint = new SCTBreakpoint(object);
+		breakpoint.setNotationViewURI(EcoreUtil.getURI(selectedEditPart.getNotationView()).fragment().toString());
+		try {
+			DebugPlugin.getDefault().getBreakpointManager().addBreakpoint(breakpoint);
+		} catch (CoreException e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+
+	protected SCTBreakpoint findExistingBreakpoint(EObject object) {
+		IBreakpoint[] breakpoints = DebugPlugin.getDefault().getBreakpointManager()
+				.getBreakpoints(SCTBreakpoint.BREAKPOINT_ID);
+		for (IBreakpoint iBreakpoint : breakpoints) {
+			if (iBreakpoint instanceof SCTBreakpoint) {
+				EObject semanticObject = ((SCTBreakpoint) iBreakpoint).getSemanticObject();
+				if (object.equals(semanticObject)) {
+					return (SCTBreakpoint) iBreakpoint;
+				}
+			}
+		}
+		return null;
+
+	}
+
+	public IGraphicalEditPart unwrap(ISelection selection) {
+		IStructuredSelection structuredSelection = (IStructuredSelection) selection;
+		Object firstElement = structuredSelection.getFirstElement();
+		if (firstElement == null)
+			return null;
+		return ((IGraphicalEditPart) firstElement);
+	}
+}

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/launch/tabs/StatechartLaunchConfigurationTab.java

@@ -10,12 +10,15 @@
  */
 package org.yakindu.sct.simulation.ui.launch.tabs;
 
+import java.util.ArrayList;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IResourceVisitor;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.debug.core.ILaunchConfiguration;
@@ -43,8 +46,7 @@ import org.yakindu.sct.simulation.ui.SimulationImages;
  * @author andreas muelder - Initial contribution and API
  * 
  */
-public class StatechartLaunchConfigurationTab extends JavaLaunchTab implements
-		IStatechartLaunchParameters {
+public class StatechartLaunchConfigurationTab extends JavaLaunchTab implements IStatechartLaunchParameters {
 
 	private Text modelfile;
 	private Text cyclePeriod;
@@ -74,8 +76,7 @@ public class StatechartLaunchConfigurationTab extends JavaLaunchTab implements
 		propertyGroup.setLayout(new GridLayout(1, false));
 		operationClass = new Text(propertyGroup, SWT.BORDER);
 		operationClass.addListener(SWT.Modify, new UpdateListener());
-		GridDataFactory.fillDefaults().grab(true, false)
-				.applyTo(operationClass);
+		GridDataFactory.fillDefaults().grab(true, false).applyTo(operationClass);
 	}
 
 	private void createExecutionTypeControls(Composite parent) {
@@ -122,9 +123,17 @@ public class StatechartLaunchConfigurationTab extends JavaLaunchTab implements
 		browse.setText("Search");
 		browse.addSelectionListener(new SelectionAdapter() {
 			public void widgetSelected(SelectionEvent e) {
-				ResourceListSelectionDialog dialog = new ResourceListSelectionDialog(
-						getShell(), ResourcesPlugin.getWorkspace().getRoot(),
-						IResource.FILE);
+				ResourceListSelectionDialog dialog = new ResourceListSelectionDialog(getShell(),
+						getStatechartResources()) {
+					@Override
+					protected String adjustPattern() {
+						String pattern = super.adjustPattern();
+						if (pattern.equals("")) {
+							return "*";
+						}
+						return pattern;
+					}
+				};
 				dialog.setTitle("Select Statechart model");
 				dialog.setMessage("Please select the YAKINDU statechart model file you want to execute.");
 				if (dialog.open() == 0) {
@@ -133,6 +142,23 @@ public class StatechartLaunchConfigurationTab extends JavaLaunchTab implements
 					modelfile.setText((file.getFullPath().toString()));
 				}
 			}
+
+			private IResource[] getStatechartResources() {
+				final List<IResource> resources = new ArrayList<IResource>();
+				try {
+					ResourcesPlugin.getWorkspace().getRoot().accept(new IResourceVisitor() {
+						public boolean visit(IResource resource) throws CoreException {
+							if ("sct".equalsIgnoreCase(resource.getFileExtension())) {
+								resources.add(resource);
+							}
+							return true;
+						}
+					});
+				} catch (CoreException e) {
+					e.printStackTrace();
+				}
+				return resources.toArray(new IResource[0]);
+			}
 		});
 		GridDataFactory.fillDefaults().applyTo(browse);
 	}
@@ -142,16 +168,11 @@ public class StatechartLaunchConfigurationTab extends JavaLaunchTab implements
 
 	public void initializeFrom(ILaunchConfiguration configuration) {
 		try {
-			modelfile.setText(configuration.getAttribute(FILE_NAME,
-					DEFAULT_FILE_NAME));
-			operationClass.setText(configuration.getAttribute(OPERATION_CLASS,
-					DEFAULT_OPERATION_CLASS));
-			cyclePeriod.setText(String.valueOf(configuration.getAttribute(
-					CYCLE_PERIOD, DEFAULT_CYCLE_PERIOD)));
-			btnCycle.setSelection(configuration.getAttribute(IS_CYCLE_BASED,
-					DEFAULT_IS_CYCLE_BASED));
-			btnEvent.setSelection(configuration.getAttribute(IS_EVENT_DRIVEN,
-					DEFAULT_IS_EVENT_DRIVEN));
+			modelfile.setText(configuration.getAttribute(FILE_NAME, DEFAULT_FILE_NAME));
+			operationClass.setText(configuration.getAttribute(OPERATION_CLASS, DEFAULT_OPERATION_CLASS));
+			cyclePeriod.setText(String.valueOf(configuration.getAttribute(CYCLE_PERIOD, DEFAULT_CYCLE_PERIOD)));
+			btnCycle.setSelection(configuration.getAttribute(IS_CYCLE_BASED, DEFAULT_IS_CYCLE_BASED));
+			btnEvent.setSelection(configuration.getAttribute(IS_EVENT_DRIVEN, DEFAULT_IS_EVENT_DRIVEN));
 			cyclePeriod.setEnabled(btnCycle.getSelection());
 		} catch (CoreException e) {
 			e.printStackTrace();
@@ -184,7 +205,7 @@ public class StatechartLaunchConfigurationTab extends JavaLaunchTab implements
 	protected Set<String> getOperationClasses() {
 		String operationClasses = this.operationClass.getText();
 		Set<String> result = new HashSet<String>();
-		if ( operationClasses.trim().length() > 0 ) {
+		if (operationClasses.trim().length() > 0) {
 			String[] split = operationClasses.split(",");
 			for (String string : split) {
 				result.add(string.trim());
@@ -215,27 +236,22 @@ public class StatechartLaunchConfigurationTab extends JavaLaunchTab implements
 		if (operationClasses.size() > 0) {
 			for (String clazz : operationClasses) {
 				// check if class exists
-				IProject project = ResourcesPlugin.getWorkspace().getRoot()
-						.findMember(model).getProject();
+				IProject project = ResourcesPlugin.getWorkspace().getRoot().findMember(model).getProject();
 				if (project != null) {
-					ClassLoader classLoader = new WorkspaceClassLoaderFactory()
-							.createClassLoader(project, getClass()
-									.getClassLoader());
+					ClassLoader classLoader = new WorkspaceClassLoaderFactory().createClassLoader(project, getClass()
+							.getClassLoader());
 					try {
 						Class<?> loadClass = classLoader.loadClass(clazz);
 						loadClass.newInstance();
 					} catch (ClassNotFoundException e) {
-						setErrorMessage("Class " + clazz
-								+ " not found in project " + project.getName()
-								+ "!");
+						setErrorMessage("Class " + clazz + " not found in project " + project.getName() + "!");
 						return false;
 					} catch (InstantiationException e) {
 						setErrorMessage("Could not instantiate class " + clazz
 								+ "! (No default constructor available?) ");
 						return false;
 					} catch (IllegalAccessException e) {
-						setErrorMessage("Could not access class constructor for class"
-								+ clazz + "!");
+						setErrorMessage("Could not access class constructor for class" + clazz + "!");
 						return false;
 					}
 				}
@@ -263,8 +279,7 @@ public class StatechartLaunchConfigurationTab extends JavaLaunchTab implements
 	private class UpdateListener implements Listener {
 
 		public void handleEvent(Event event) {
-			StatechartLaunchConfigurationTab.this
-					.updateLaunchConfigurationDialog();
+			StatechartLaunchConfigurationTab.this.updateLaunchConfigurationDialog();
 		}
 
 	}