diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/.classpath b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/.classpath new file mode 100644 index 00000000..0d4d74fe --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/.classpath @@ -0,0 +1,11 @@ + + + + + + + + + + + diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/.project b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/.project new file mode 100644 index 00000000..85246ff5 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/.project @@ -0,0 +1,34 @@ + + + de.darmstadt.tu.crossing.CrySL.statemachine.diagram + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.pde.ManifestBuilder + + + + + org.eclipse.pde.SchemaBuilder + + + + + org.eclipse.m2e.core.maven2Builder + + + + + + org.eclipse.jdt.core.javanature + org.eclipse.m2e.core.maven2Nature + org.eclipse.pde.PluginNature + + diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/META-INF/MANIFEST.MF b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/META-INF/MANIFEST.MF new file mode 100644 index 00000000..1c02412a --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/META-INF/MANIFEST.MF @@ -0,0 +1,56 @@ +Manifest-Version: 1.0 +Bundle-ManifestVersion: 2 +Bundle-Name: %pluginName +Bundle-SymbolicName: de.darmstadt.tu.crossing.CrySL.statemachine.diagram;singleton:=true +Bundle-Version: 1.0.0.qualifier +Bundle-ClassPath: . +Bundle-Activator: de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin +Bundle-Vendor: %providerName +Bundle-Localization: plugin +Export-Package: de.darmstadt.tu.crossing.statemachine.diagram.edit.parts, + de.darmstadt.tu.crossing.statemachine.diagram.part, + de.darmstadt.tu.crossing.statemachine.diagram.providers +Require-Bundle: de.darmstadt.tu.crossing.CrySL;visibility:=reexport, + org.eclipse.core.runtime, + org.eclipse.core.resources, + org.eclipse.core.expressions, + org.eclipse.jface, + org.eclipse.ui.ide, + org.eclipse.ui.views, + org.eclipse.ui.navigator, + org.eclipse.ui.navigator.resources, + org.eclipse.emf.ecore, + org.eclipse.emf.ecore.xmi, + org.eclipse.core.commands, + org.eclipse.draw2d;visibility:=reexport, + org.eclipse.emf.edit.ui, + org.eclipse.gef;visibility:=reexport, + org.eclipse.gmf.runtime.emf.core, + org.eclipse.gmf.runtime.emf.commands.core, + org.eclipse.emf.compare;bundle-version="3.1.0", + org.eclipse.emf.compare.rcp;bundle-version="2.2.0", + org.eclipse.emf.transaction;bundle-version="1.8.0", + org.eclipse.gmf.runtime.emf.ui.properties, + org.eclipse.gmf.runtime.diagram.ui, + org.eclipse.gmf.runtime.diagram.ui.properties, + org.eclipse.gmf.runtime.diagram.ui.providers, + org.eclipse.gmf.runtime.diagram.ui.providers.ide, + org.eclipse.gmf.runtime.diagram.ui.render, + org.eclipse.gmf.runtime.diagram.ui.resources.editor, + org.eclipse.gmf.runtime.diagram.ui.resources.editor.ide, + org.eclipse.gmf.runtime.draw2d.ui;visibility:=reexport, + org.eclipse.gmf.tooling.runtime, + com.google.guava, + org.eclipse.ocl.ecore;visibility:=reexport, + org.eclipse.emf.validation;visibility:=reexport, + org.eclipse.xtext.builder, + org.eclipse.xtend.lib;bundle-version="2.14.0";resolution:=optional, + org.eclipse.xtext.xbase.lib;bundle-version="2.13.0", + org.eclipse.xtext.common.types.ui, + org.eclipse.xtext.xbase.ui, + org.eclipse.xtext.ui, + org.eclipse.xtext.ui.shared, + org.eclipse.xtext.ui.codetemplates.ui, + org.eclipse.emf.common +Bundle-ActivationPolicy: lazy +Bundle-RequiredExecutionEnvironment: JavaSE-1.8 diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/build.properties b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/build.properties new file mode 100644 index 00000000..1c729bd3 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/build.properties @@ -0,0 +1,4 @@ +source.. = src/main/java/,\ + src/test/java/ +bin.includes = META-INF/,\ + . diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/incomingLinksNavigatorGroup.gif b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/incomingLinksNavigatorGroup.gif new file mode 100644 index 00000000..fca9c53e Binary files /dev/null and b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/incomingLinksNavigatorGroup.gif differ diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/linkSourceNavigatorGroup.gif b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/linkSourceNavigatorGroup.gif new file mode 100644 index 00000000..fca9c53e Binary files /dev/null and b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/linkSourceNavigatorGroup.gif differ diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/linkTargetNavigatorGroup.gif b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/linkTargetNavigatorGroup.gif new file mode 100644 index 00000000..fca9c53e Binary files /dev/null and b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/linkTargetNavigatorGroup.gif differ diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/linksNavigatorGroup.gif b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/linksNavigatorGroup.gif new file mode 100644 index 00000000..fca9c53e Binary files /dev/null and b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/linksNavigatorGroup.gif differ diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/obj16/StatemachineDiagramFile.gif b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/obj16/StatemachineDiagramFile.gif new file mode 100644 index 00000000..0ef9a731 Binary files /dev/null and b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/obj16/StatemachineDiagramFile.gif differ diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/outgoingLinksNavigatorGroup.gif b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/outgoingLinksNavigatorGroup.gif new file mode 100644 index 00000000..fca9c53e Binary files /dev/null and b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/outgoingLinksNavigatorGroup.gif differ diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/wizban/NewStatemachineWizard.gif b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/wizban/NewStatemachineWizard.gif new file mode 100644 index 00000000..be021661 Binary files /dev/null and b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/icons/wizban/NewStatemachineWizard.gif differ diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/messages.properties b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/messages.properties new file mode 100644 index 00000000..0546af86 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/messages.properties @@ -0,0 +1,63 @@ + +# TODO: manually put keys and values +StatemachineCreationWizardTitle=New Statemachine Diagram +StatemachineCreationWizard_DiagramModelFilePageTitle=Create Statemachine Diagram +StatemachineCreationWizard_DiagramModelFilePageDescription=Select file that will contain diagram model. +StatemachineCreationWizard_DomainModelFilePageTitle=Create Statemachine Domain Model +StatemachineCreationWizard_DomainModelFilePageDescription=Select file that will contain domain model. +StatemachineCreationWizardOpenEditorError=Error opening diagram editor +StatemachineCreationWizardCreationError=Creation Problems +StatemachineCreationWizardPageExtensionError=File name should have {0} extension. +StatemachineDiagramEditorUtil_OpenModelResourceErrorDialogTitle=Error +StatemachineDiagramEditorUtil_OpenModelResourceErrorDialogMessage=Failed to load model file {0} +StatemachineDiagramEditorUtil_CreateDiagramProgressTask=Creating diagram and model files +StatemachineDiagramEditorUtil_CreateDiagramCommandLabel=Creating diagram and model +StatemachineDocumentProvider_isModifiable=Updating cache failed +StatemachineDocumentProvider_handleElementContentChanged=Failed to refresh hierarchy for changed resource +StatemachineDocumentProvider_IncorrectInputError=invalid +StatemachineDocumentProvider_NoDiagramInResourceError=Diagram is not present in resource +StatemachineDocumentProvider_DiagramLoadingError=Error loading diagram +StatemachineDocumentProvider_UnsynchronizedFileSaveError=The file has been changed on the file system +StatemachineDocumentProvider_SaveDiagramTask=Saving diagram +StatemachineDocumentProvider_SaveNextResourceTask=Saving {0} +StatemachineDocumentProvider_SaveAsOperation=Saving {0} diagram as +InitDiagramFile_ResourceErrorDialogTitle=Error +InitDiagramFile_ResourceErrorDialogMessage=Model file loading failed +InitDiagramFile_WizardTitle=Initialize new {0} diagram file +InitDiagramFile_OpenModelFileDialogTitle=Select domain model +StatemachineNewDiagramFileWizard_CreationPageName=Initialize new diagram file +StatemachineNewDiagramFileWizard_CreationPageTitle=Diagram file +StatemachineNewDiagramFileWizard_CreationPageDescription=Create new diagram based on {0} model content +StatemachineNewDiagramFileWizard_RootSelectionPageName=Select diagram root element +StatemachineNewDiagramFileWizard_RootSelectionPageTitle=Diagram root element +StatemachineNewDiagramFileWizard_RootSelectionPageDescription=Select semantic model element to be depicted on diagram +StatemachineNewDiagramFileWizard_RootSelectionPageSelectionTitle=Select diagram root element: +StatemachineNewDiagramFileWizard_RootSelectionPageNoSelectionMessage=Diagram root element is not selected +StatemachineNewDiagramFileWizard_RootSelectionPageInvalidSelectionMessage=Invalid diagram root element is selected +StatemachineNewDiagramFileWizard_InitDiagramCommand=Initializing diagram contents +StatemachineNewDiagramFileWizard_IncorrectRootError=Incorrect model object stored as a root resource object +StatemachineDiagramEditor_SavingDeletedFile=The original file "{0}" has been deleted. +StatemachineDiagramEditor_SaveAsErrorTitle=Problem During Save As... +StatemachineDiagramEditor_SaveAsErrorMessage=Save could not be completed. Target file is already open in another editor. +StatemachineDiagramEditor_SaveErrorTitle=Save Problems +StatemachineDiagramEditor_SaveErrorMessage=Could not save file. +StatemachineElementChooserDialog_SelectModelElementTitle=Select model element +ModelElementSelectionPageMessage=Select model element: +ValidateActionMessage=Validate +Statemachine1Group_title=statemachine +State1CreationTool_title=State +State1CreationTool_desc=Create new State +Transition2CreationTool_title=Transition +Transition2CreationTool_desc=Create new Transition + +CommandName_OpenDiagram=Open Diagram +NavigatorGroupName_Statemachine_1000_links=links +NavigatorGroupName_State_2001_incominglinks=incoming links +NavigatorGroupName_State_2001_outgoinglinks=outgoing links +NavigatorGroupName_Transition_4001_target=target +NavigatorGroupName_Transition_4001_source=source +NavigatorActionProvider_OpenDiagramActionName=Open Diagram + +MessageFormatParser_InvalidInputError=Invalid input at {0} +StatemachineModelingAssistantProviderTitle=Select domain model element +StatemachineModelingAssistantProviderMessage=Available domain model elements: diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/plugin.properties b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/plugin.properties new file mode 100644 index 00000000..9b85fecb --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/plugin.properties @@ -0,0 +1,41 @@ +pluginName=Statemachine GMF Diagram +providerName=itemis AG + +editorName=Statemachine Diagram Editing +context.description=Statemachine Diagram Editing +context.name=In Statemachine Diagram Editor +newWizardName=Statemachine Diagram +newWizardDesc=Creates Statemachine diagram. + +initDiagramActionLabel=Initialize statemachine_diagram diagram file +UI_DomainmodelEditor_label = Domainmodel Model Editor + + +navigatorContentName=*.statemachine_diagram diagram contents +domainNavigatorContentName=*.statemachine model contents +update.diagram.name=Update Statemachine diagram +update.diagram.description=Perform Statemachine diagram update + + +# Property Sheet +tab.appearance=Appearance +tab.diagram=Rulers & Grid +tab.domain=Core + +# Preferences +prefpage.org.xtext.example.statemachine.diagram.general=Statemachine Diagram +prefpage.org.xtext.example.statemachine.diagram.appearance=Appearance +prefpage.org.xtext.example.statemachine.diagram.connections=Connections +prefpage.org.xtext.example.statemachine.diagram.printing=Printing +prefpage.org.xtext.example.statemachine.diagram.rulersAndGrid=Rulers And Grid + + +# Providers +metatype.name.Statemachine_1000=Undefined +metatype.name.State_2001=State +metatype.name.Transition_4001=Transition + +# Commands and menu actions +cmdcategory.name=Statemachine Editor Commands +cmdcategory.desc=Statemachine Editor Commands + diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/plugin.xml b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/plugin.xml new file mode 100644 index 00000000..5b4ee268 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/plugin.xml @@ -0,0 +1,506 @@ + + + + + + + + + \ No newline at end of file diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/pom.xml b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/pom.xml new file mode 100644 index 00000000..0a2c480d --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/pom.xml @@ -0,0 +1,36 @@ + + 4.0.0 + + de.darmstadt.tu.crossing.CrySL + de.darmstadt.tu.crossing.CrySL.parent + 2.0.0-SNAPSHOT + + de.darmstadt.tu.crossing.CrySL.staemachine.diagram + eclipse-plugin + + + + + maven-assembly-plugin + + + make-assembly + package + + single + + + + + + jar-with-dependencies + + build + + + + + + diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/commands/StateCreateCommand.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/commands/StateCreateCommand.java new file mode 100644 index 00000000..dcbea894 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/commands/StateCreateCommand.java @@ -0,0 +1,87 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.edit.commands; + +import org.eclipse.core.commands.ExecutionException; +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.gmf.runtime.common.core.command.CommandResult; +import org.eclipse.gmf.runtime.common.core.command.ICommand; +import org.eclipse.gmf.runtime.emf.type.core.IElementType; +import org.eclipse.gmf.runtime.emf.type.core.commands.EditElementCommand; +import org.eclipse.gmf.runtime.emf.type.core.requests.ConfigureRequest; +import org.eclipse.gmf.runtime.emf.type.core.requests.CreateElementRequest; +import org.eclipse.gmf.runtime.notation.View; +import de.darmstadt.tu.crossing.crySL.Expression; +import de.darmstadt.tu.crossing.crySL.Order; +import de.darmstadt.tu.crossing.crySL.CrySLFactory; + +/** + * @generated + */ +public class StateCreateCommand extends EditElementCommand { + + /** + * @generated + */ + public StateCreateCommand(CreateElementRequest req) { + super(req.getLabel(), null, req); + } + + /** + * FIXME: replace with setElementToEdit() + * + * @generated + */ + protected EObject getElementToEdit() { + EObject container = ((CreateElementRequest) getRequest()).getContainer(); + if (container instanceof View) { + container = ((View) container).getElement(); + } + return container; + } + + /** + * @generated + */ + public boolean canExecute() { + return true; + + } + + /** + * @generated NOT + */ + protected CommandResult doExecuteWithResult(IProgressMonitor monitor, IAdaptable info) throws ExecutionException { + Expression newElement = CrySLFactory.eINSTANCE.createSimpleOrder(); + + // Expression newElement = CrySLFactory.eINSTANCE.createExpression(); + + Order owner = (Order) getElementToEdit(); + newElement.setLeft(owner.getLeft()); + newElement.setOrderop(","); + newElement.setRight(owner.getLeft()); + owner.setLeft(newElement); + owner.setRight(newElement); + + doConfigure(newElement, monitor, info); + ((CreateElementRequest) getRequest()).setNewElement(newElement); + return CommandResult.newOKCommandResult(newElement); + + } + + /** + * @generated + */ + protected void doConfigure(Expression newElement, IProgressMonitor monitor, IAdaptable info) + throws ExecutionException { + IElementType elementType = ((CreateElementRequest) getRequest()).getElementType(); + ConfigureRequest configureRequest = new ConfigureRequest(getEditingDomain(), newElement, elementType); + configureRequest.setClientContext(((CreateElementRequest) getRequest()).getClientContext()); + configureRequest.addParameters(getRequest().getParameters()); + ICommand configureCommand = elementType.getEditCommand(configureRequest); + if (configureCommand != null && configureCommand.canExecute()) { + configureCommand.execute(monitor, info); + } + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/commands/TransitionCreateCommand.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/commands/TransitionCreateCommand.java new file mode 100644 index 00000000..3da5a566 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/commands/TransitionCreateCommand.java @@ -0,0 +1,153 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.edit.commands; + +import org.eclipse.core.commands.ExecutionException; +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.gmf.runtime.common.core.command.CommandResult; +import org.eclipse.gmf.runtime.common.core.command.ICommand; +import org.eclipse.gmf.runtime.emf.type.core.IElementType; +import org.eclipse.gmf.runtime.emf.type.core.commands.EditElementCommand; +import org.eclipse.gmf.runtime.emf.type.core.requests.ConfigureRequest; +import org.eclipse.gmf.runtime.emf.type.core.requests.CreateElementRequest; +import org.eclipse.gmf.runtime.emf.type.core.requests.CreateRelationshipRequest; +import de.darmstadt.tu.crossing.crySL.CrySLFactory; +import de.darmstadt.tu.crossing.crySL.Expression; +import de.darmstadt.tu.crossing.crySL.Order; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.policies.StatemachineBaseItemSemanticEditPolicy; + +/** + * @generated + */ +public class TransitionCreateCommand extends EditElementCommand { + + /** + * @generated + */ + private final EObject source; + + /** + * @generated + */ + private final EObject target; + + /** + * @generated + */ + private final Expression container; + + /** + * @generated + */ + public TransitionCreateCommand(CreateRelationshipRequest request, EObject source, EObject target) { + super(request.getLabel(), null, request); + this.source = source; + this.target = target; + container = deduceContainer(source, target); + } + + /** + * @generated + */ + public boolean canExecute() { + if (source == null && target == null) { + return false; + } + if (source != null && (false == source instanceof Expression || false == source instanceof Order)) { + return false; + } + if (target != null && (false == target instanceof Expression || false == source instanceof Order)) { + return false; + } + if (getSource() == null) { + return true; // link creation is in progress; source is not defined yet + } + // target may be null here but it's possible to check constraint + if (getContainer() == null) { + return false; + } + return StatemachineBaseItemSemanticEditPolicy.getLinkConstraints().canCreateTransition_4001(getContainer(), + getSource(), getTarget()); + } + + /** + * @generated + */ + protected CommandResult doExecuteWithResult(IProgressMonitor monitor, IAdaptable info) throws ExecutionException { + if (!canExecute()) { + throw new ExecutionException("Invalid arguments in create link command"); //$NON-NLS-1$ + } + + Expression newElement = CrySLFactory.eINSTANCE.createExpression(); + newElement.setLeft(getContainer().getRight()); + newElement.setRight(getTarget()); + doConfigure(newElement, monitor, info); + ((CreateElementRequest) getRequest()).setNewElement(newElement); + return CommandResult.newOKCommandResult(newElement); + + } + + /** + * @generated + */ + protected void doConfigure(Expression newElement, IProgressMonitor monitor, IAdaptable info) + throws ExecutionException { + IElementType elementType = ((CreateElementRequest) getRequest()).getElementType(); + ConfigureRequest configureRequest = new ConfigureRequest(getEditingDomain(), newElement, elementType); + configureRequest.setClientContext(((CreateElementRequest) getRequest()).getClientContext()); + configureRequest.addParameters(getRequest().getParameters()); + configureRequest.setParameter(CreateRelationshipRequest.SOURCE, getSource()); + configureRequest.setParameter(CreateRelationshipRequest.TARGET, getTarget()); + ICommand configureCommand = elementType.getEditCommand(configureRequest); + if (configureCommand != null && configureCommand.canExecute()) { + configureCommand.execute(monitor, info); + } + } + + /** + * @generated + */ + protected void setElementToEdit(EObject element) { + throw new UnsupportedOperationException(); + } + + /** + * @generated + */ + protected Expression getSource() { + return (Expression) source; + } + + /** + * @generated + */ + protected Expression getTarget() { + return (Expression) target; + } + + /** + * @generated + */ + public Expression getContainer() { + return container; + } + + /** + * Default approach is to traverse ancestors of the source to find instance of + * container. Modify with appropriate logic. + * + * @generated + */ + private static Expression deduceContainer(EObject source, EObject target) { + // Find container element for the new link. + // Climb up by containment hierarchy starting from the source + // and return the first element that is instance of the container class. + for (EObject element = source; element != null; element = element.eContainer()) { + if (element instanceof Expression) { + return (Expression) element; + } + } + return null; + } + +} \ No newline at end of file diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/commands/TransitionReorientCommand.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/commands/TransitionReorientCommand.java new file mode 100644 index 00000000..e9d36cd0 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/commands/TransitionReorientCommand.java @@ -0,0 +1,164 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.edit.commands; + +import org.eclipse.core.commands.ExecutionException; +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.gmf.runtime.common.core.command.CommandResult; +import org.eclipse.gmf.runtime.emf.type.core.commands.EditElementCommand; +import org.eclipse.gmf.runtime.emf.type.core.requests.ReorientRelationshipRequest; +//import de.darmstadt.tu.crossing.crySL.Order; +//import de.darmstadt.tu.crossing.crySL.SimpleOrder; +import de.darmstadt.tu.crossing.crySL.Expression; +import de.darmstadt.tu.crossing.crySL.Order; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.policies.StatemachineBaseItemSemanticEditPolicy; + +/** + * @generated + */ +public class TransitionReorientCommand extends EditElementCommand { + + /** + * @generated + */ + private final int reorientDirection; + + /** + * @generated + */ + private final EObject oldEnd; + + /** + * @generated + */ + private final EObject newEnd; + + /** + * @generated + */ + public TransitionReorientCommand(ReorientRelationshipRequest request) { + super(request.getLabel(), request.getRelationship(), request); + reorientDirection = request.getDirection(); + oldEnd = request.getOldRelationshipEnd(); + newEnd = request.getNewRelationshipEnd(); + } + + /** + * @generated + */ + public boolean canExecute() { + if (false == getElementToEdit() instanceof Expression) { + return false; + } + if (reorientDirection == ReorientRelationshipRequest.REORIENT_SOURCE) { + return canReorientSource(); + } + if (reorientDirection == ReorientRelationshipRequest.REORIENT_TARGET) { + return canReorientTarget(); + } + return false; + } + + /** + * @generated + */ + protected boolean canReorientSource() { + if (!(oldEnd instanceof Expression && newEnd instanceof Expression)) { + return false; + } + Expression target = getLink().getRight(); + if (!(getLink().eContainer() instanceof Expression)) { + return false; + } + Order container = (Order) getLink().eContainer(); + return StatemachineBaseItemSemanticEditPolicy.getLinkConstraints() + .canExistTransition_4001(container, getLink(), getNewSource(), + target); + } + + /** + * @generated + */ + protected boolean canReorientTarget() { + if (!(oldEnd instanceof Expression && newEnd instanceof Expression)) { + return false; + } + Expression source = getLink().getLeft(); + if (!(getLink().eContainer() instanceof Expression)) { + return false; + } + Order container = (Order) getLink().eContainer(); + return StatemachineBaseItemSemanticEditPolicy.getLinkConstraints() + .canExistTransition_4001(container, getLink(), source, + getNewTarget()); + } + + /** + * @generated + */ + protected CommandResult doExecuteWithResult(IProgressMonitor monitor, + IAdaptable info) throws ExecutionException { + if (!canExecute()) { + throw new ExecutionException( + "Invalid arguments in reorient link command"); //$NON-NLS-1$ + } + if (reorientDirection == ReorientRelationshipRequest.REORIENT_SOURCE) { + return reorientSource(); + } + if (reorientDirection == ReorientRelationshipRequest.REORIENT_TARGET) { + return reorientTarget(); + } + throw new IllegalStateException(); + } + + /** + * @generated + */ + protected CommandResult reorientSource() throws ExecutionException { + getLink().setLeft(getNewSource()); + return CommandResult.newOKCommandResult(getLink()); + } + + /** + * @generated + */ + protected CommandResult reorientTarget() throws ExecutionException { + getLink().setRight(getNewTarget()); + return CommandResult.newOKCommandResult(getLink()); + } + + /** + * @generated + */ + protected Expression getLink() { + return (Expression) getElementToEdit(); + } + + /** + * @generated + */ + protected Expression getOldSource() { + return (Expression) oldEnd; + } + + /** + * @generated + */ + protected Expression getNewSource() { + return (Expression) newEnd; + } + + /** + * @generated + */ + protected Expression getOldTarget() { + return (Expression) oldEnd; + } + + /** + * @generated + */ + protected Expression getNewTarget() { + return (Expression) newEnd; + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/helpers/StateEditHelper.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/helpers/StateEditHelper.java new file mode 100644 index 00000000..1edb725b --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/helpers/StateEditHelper.java @@ -0,0 +1,7 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.edit.helpers; + +/** + * @generated + */ +public class StateEditHelper extends StatemachineBaseEditHelper { +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/helpers/StatemachineBaseEditHelper.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/helpers/StatemachineBaseEditHelper.java new file mode 100644 index 00000000..afd21390 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/helpers/StatemachineBaseEditHelper.java @@ -0,0 +1,10 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.edit.helpers; + +import org.eclipse.gmf.tooling.runtime.edit.helpers.GeneratedEditHelperBase; + +/** + * @generated + */ +public class StatemachineBaseEditHelper extends GeneratedEditHelperBase { + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/helpers/StatemachineEditHelper.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/helpers/StatemachineEditHelper.java new file mode 100644 index 00000000..1a703a7c --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/helpers/StatemachineEditHelper.java @@ -0,0 +1,7 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.edit.helpers; + +/** + * @generated + */ +public class StatemachineEditHelper extends StatemachineBaseEditHelper { +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/helpers/TransitionEditHelper.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/helpers/TransitionEditHelper.java new file mode 100644 index 00000000..9df21f34 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/helpers/TransitionEditHelper.java @@ -0,0 +1,7 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.edit.helpers; + +/** + * @generated + */ +public class TransitionEditHelper extends StatemachineBaseEditHelper { +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/parts/OrderEditPart.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/parts/OrderEditPart.java new file mode 100644 index 00000000..bc13b3ea --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/parts/OrderEditPart.java @@ -0,0 +1,54 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.edit.parts; + +import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart; +import org.eclipse.gmf.runtime.diagram.ui.editpolicies.EditPolicyRoles; +import org.eclipse.gmf.runtime.notation.View; +import org.eclipse.gmf.tooling.runtime.edit.policies.reparent.CreationEditPolicyWithCustomReparent; + +import de.darmstadt.tu.crossing.statemachine.diagram.edit.policies.StatemachineCanonicalEditPolicy; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.policies.StatemachineItemSemanticEditPolicy; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry; + +/** + * @generated + */ +public class OrderEditPart extends DiagramEditPart { + + View view; + public static int childcount; + + /** + * @generated + */ + public final static String MODEL_ID = "Order"; //$NON-NLS-1$ + + /** + * @generated + */ + public static final int VISUAL_ID = 1000; + + /** + * @generated + */ + public OrderEditPart(View view) { + super(view); + this.view = view; + childcount = this.getModelChildren().size(); + } + + /** + * @generated + */ + protected void createDefaultEditPolicies() { + super.createDefaultEditPolicies(); + installEditPolicy(EditPolicyRoles.SEMANTIC_ROLE, + new StatemachineItemSemanticEditPolicy()); + installEditPolicy(EditPolicyRoles.CANONICAL_ROLE, + new StatemachineCanonicalEditPolicy()); + installEditPolicy(EditPolicyRoles.CREATION_ROLE, + new CreationEditPolicyWithCustomReparent( + StatemachineVisualIDRegistry.TYPED_INSTANCE)); + // removeEditPolicy(org.eclipse.gmf.runtime.diagram.ui.editpolicies.EditPolicyRoles.POPUPBAR_ROLE); + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/parts/OrderEditPartFactory.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/parts/OrderEditPartFactory.java new file mode 100644 index 00000000..586d50c9 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/parts/OrderEditPartFactory.java @@ -0,0 +1,60 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.edit.parts; + +import org.eclipse.gef.EditPart; +import org.eclipse.gef.EditPartFactory; +import org.eclipse.gef.tools.CellEditorLocator; +import org.eclipse.gmf.runtime.diagram.ui.editparts.ITextAwareEditPart; +import org.eclipse.gmf.runtime.notation.View; +import org.eclipse.gmf.tooling.runtime.directedit.locator.CellEditorLocatorAccess; + +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry; + +/** + * @generated + */ +public class OrderEditPartFactory implements EditPartFactory { + /** + * @generated + */ + public EditPart createEditPart(EditPart context, Object model) { + if (model instanceof View) { + View view = (View) model; + switch (StatemachineVisualIDRegistry.getVisualID(view)) { + + case OrderEditPart.VISUAL_ID: + OrderEditPart orderEditPart = new OrderEditPart(view); + return orderEditPart; + + case StateEditPart.VISUAL_ID: + OrderEditPart parentEditPart = new OrderEditPart(view.getDiagram()); + return new StateEditPart(view, parentEditPart.childcount); + + case StateNameEditPart.VISUAL_ID: + return new StateNameEditPart(view); + + case TransitionEditPart.VISUAL_ID: + return new TransitionEditPart(view); + + case TransitionNameEditPart.VISUAL_ID: + return new TransitionNameEditPart(view); + } + } + return createUnrecognizedEditPart(context, model); + } + + /** + * @generated + */ + private EditPart createUnrecognizedEditPart(EditPart context, Object model) { + // Handle creation of unrecognized child node EditParts here + return null; + } + + /** + * @generated + */ + public static CellEditorLocator getTextCellEditorLocator(ITextAwareEditPart source) { + return CellEditorLocatorAccess.INSTANCE.getTextCellEditorLocator(source); + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/parts/StateEditPart.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/parts/StateEditPart.java new file mode 100644 index 00000000..134d4e51 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/parts/StateEditPart.java @@ -0,0 +1,341 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.edit.parts; + +import java.util.List; + +import org.eclipse.draw2d.FlowLayout; +import org.eclipse.draw2d.IFigure; +import org.eclipse.draw2d.RectangleFigure; +import org.eclipse.draw2d.Shape; +import org.eclipse.draw2d.StackLayout; +import org.eclipse.draw2d.geometry.Dimension; +import org.eclipse.gef.EditPart; +import org.eclipse.gef.EditPolicy; +import org.eclipse.gef.commands.Command; +import org.eclipse.gef.editpolicies.LayoutEditPolicy; +import org.eclipse.gef.requests.CreateRequest; +import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart; +import org.eclipse.gmf.runtime.diagram.ui.editparts.ShapeNodeEditPart; +import org.eclipse.gmf.runtime.diagram.ui.editpolicies.EditPolicyRoles; +import org.eclipse.gmf.runtime.diagram.ui.editpolicies.FlowLayoutEditPolicy; +import org.eclipse.gmf.runtime.draw2d.ui.figures.ConstrainedToolbarLayout; +import org.eclipse.gmf.runtime.draw2d.ui.figures.WrappingLabel; +import org.eclipse.gmf.runtime.gef.ui.figures.DefaultSizeNodeFigure; +import org.eclipse.gmf.runtime.gef.ui.figures.NodeFigure; +import org.eclipse.gmf.runtime.notation.View; +import org.eclipse.swt.SWT; +import org.eclipse.swt.graphics.Color; +import org.eclipse.swt.graphics.Font; +import org.eclipse.swt.widgets.Display; +import org.eclipse.gmf.runtime.diagram.ui.requests.CreateConnectionViewRequest; +import org.eclipse.gmf.runtime.diagram.ui.requests.CreateViewRequest; + +import de.darmstadt.tu.crossing.statemachine.diagram.edit.policies.StateItemSemanticEditPolicy; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry; + +/** + * @generated + */ +public class StateEditPart extends ShapeNodeEditPart { + + /** + * @generated + */ + public static final int VISUAL_ID = 2001; + public static int nodeIndex = 0; + public static int siblingCount; + + /** + * @generated + */ + protected IFigure contentPane; + + /** + * @generated + */ + protected IFigure primaryShape; + + /** + * @generated + */ + public StateEditPart(View view, int siblingCount) { + super(view); + this.siblingCount = siblingCount; + + } + + /** + * @generated + */ + protected void createDefaultEditPolicies() { + super.createDefaultEditPolicies(); + installEditPolicy(EditPolicyRoles.SEMANTIC_ROLE, new StateItemSemanticEditPolicy()); + installEditPolicy(EditPolicy.LAYOUT_ROLE, createLayoutEditPolicy()); + // XXX need an SCR to runtime to have another abstract superclass that would let + // children add reasonable editpolicies + // removeEditPolicy(org.eclipse.gmf.runtime.diagram.ui.editpolicies.EditPolicyRoles.CONNECTION_HANDLES_ROLE); + } + + /** + * @generated + */ + protected LayoutEditPolicy createLayoutEditPolicy() { + + FlowLayoutEditPolicy lep = new FlowLayoutEditPolicy() { + + protected Command createAddCommand(EditPart child, EditPart after) { + return null; + } + + protected Command createMoveChildCommand(EditPart child, EditPart after) { + return null; + } + + protected Command getCreateCommand(CreateRequest request) { + return null; + } + }; + return lep; + } + + /** + * @generated + */ + protected IFigure createNodeShape() { + return primaryShape = new StateFigure(); + + } + + /** + * @generated + */ + public StateFigure getPrimaryShape() { + return (StateFigure) primaryShape; + } + + /** + * @param index + * @generated + */ + protected boolean addFixedChild(EditPart childEditPart, int index) { + if (childEditPart instanceof StateNameEditPart) { + /* + * issue with numerating state labels - Needs to be fixed + */ + int nodeLabel; + if (this.siblingCount > 0) { + nodeLabel = (this.nodeIndex - 1) % (siblingCount); + } else { + nodeLabel = this.nodeIndex; + } + this.nodeIndex = this.nodeIndex + 1; + + ((StateNameEditPart) childEditPart).setLabel(getPrimaryShape().getFigureStateNameFigure(), nodeLabel); + return true; + } + return false; + } + + /** + * @generated + */ + protected boolean removeFixedChild(EditPart childEditPart) { + if (childEditPart instanceof StateNameEditPart) { + return true; + } + return false; + } + + /** + * @generated + */ + protected void addChildVisual(EditPart childEditPart, int index) { + + if (addFixedChild(childEditPart, index)) { + return; + } + super.addChildVisual(childEditPart, -1); + } + + /** + * @generated + */ + protected void removeChildVisual(EditPart childEditPart) { + if (removeFixedChild(childEditPart)) { + return; + } + super.removeChildVisual(childEditPart); + } + + /** + * @generated + */ + protected IFigure getContentPaneFor(IGraphicalEditPart editPart) { + return getContentPane(); + } + + /** + * @generated + */ + protected NodeFigure createNodePlate() { + DefaultSizeNodeFigure result = new DefaultSizeNodeFigure(40, 40); + return result; + } + + /** + * Creates figure for this edit part. + * + * Body of this method does not depend on settings in generation model so you + * may safely remove generated tag and modify it. + * + * @generated + */ + protected NodeFigure createNodeFigure() { + NodeFigure figure = createNodePlate(); + figure.setLayoutManager(new StackLayout()); + IFigure shape = createNodeShape(); + figure.add(shape); + contentPane = setupContentPane(shape); + return figure; + } + + /** + * Default implementation treats passed figure as content pane. Respects layout + * one may have set for generated figure. + * + * @param nodeShape instance of generated figure class + * @generated + */ + protected IFigure setupContentPane(IFigure nodeShape) { + if (nodeShape.getLayoutManager() == null) { + ConstrainedToolbarLayout layout = new ConstrainedToolbarLayout(); + layout.setSpacing(5); + nodeShape.setLayoutManager(layout); + } + return nodeShape; // use nodeShape itself as contentPane + } + + /** + * @generated + */ + public IFigure getContentPane() { + if (contentPane != null) { + return contentPane; + } + return super.getContentPane(); + } + + /** + * @generated + */ + protected void setForegroundColor(Color color) { + if (primaryShape != null) { + primaryShape.setForegroundColor(color); + } + } + + /** + * @generated + */ + protected void setBackgroundColor(Color color) { + if (primaryShape != null) { + primaryShape.setBackgroundColor(color); + } + } + + /** + * @generated + */ + protected void setLineWidth(int width) { + if (primaryShape instanceof Shape) { + ((Shape) primaryShape).setLineWidth(width); + } + } + + /** + * @generated + */ + protected void setLineType(int style) { + if (primaryShape instanceof Shape) { + ((Shape) primaryShape).setLineStyle(style); + } + } + + /** + * @generated + */ + public EditPart getPrimaryChildEditPart() { + return getChildBySemanticHint(StatemachineVisualIDRegistry.getType(StateNameEditPart.VISUAL_ID)); + } + + /** + * @generated + */ + public class StateFigure extends RectangleFigure { + + /** + * @generated + */ + private WrappingLabel fFigureStateNameFigure; + + /** + * @generated + */ + public StateFigure() { + + FlowLayout layoutThis = new FlowLayout(); + layoutThis.setStretchMinorAxis(false); + layoutThis.setMinorAlignment(FlowLayout.ALIGN_LEFTTOP); + + layoutThis.setMajorAlignment(FlowLayout.ALIGN_LEFTTOP); + layoutThis.setMajorSpacing(5); + layoutThis.setMinorSpacing(5); + layoutThis.setHorizontal(true); + + this.setLayoutManager(layoutThis); + + this.setForegroundColor(THIS_FORE); + this.setBackgroundColor(THIS_BACK); + this.setPreferredSize(new Dimension(getMapMode().DPtoLP(40), getMapMode().DPtoLP(40))); + createContents(); + } + + /** + * @generated + */ + private void createContents() { + + fFigureStateNameFigure = new WrappingLabel(); + + fFigureStateNameFigure.setText("<...>"); + + fFigureStateNameFigure.setFont(FFIGURESTATENAMEFIGURE_FONT); + + this.add(fFigureStateNameFigure); + + } + + /** + * @generated + */ + public WrappingLabel getFigureStateNameFigure() { + return fFigureStateNameFigure; + } + + } + + /** + * @generated + */ + static final Color THIS_FORE = new Color(null, 0, 0, 0); + + /** + * @generated + */ + static final Color THIS_BACK = new Color(null, 240, 240, 240); + + /** + * @generated + */ + static final Font FFIGURESTATENAMEFIGURE_FONT = new Font(Display.getCurrent(), "Arial", 12, SWT.NORMAL); + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/parts/StateNameEditPart.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/parts/StateNameEditPart.java new file mode 100644 index 00000000..ecc14775 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/parts/StateNameEditPart.java @@ -0,0 +1,637 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.edit.parts; + +import java.util.Collections; +import java.util.List; + +import org.eclipse.draw2d.IFigure; +import org.eclipse.draw2d.Label; +import org.eclipse.draw2d.geometry.Point; +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.transaction.RunnableWithResult; +import org.eclipse.gef.AccessibleEditPart; +import org.eclipse.gef.EditPolicy; +import org.eclipse.gef.Request; +import org.eclipse.gef.requests.DirectEditRequest; +import org.eclipse.gef.tools.DirectEditManager; +import org.eclipse.gmf.runtime.common.ui.services.parser.IParser; +import org.eclipse.gmf.runtime.common.ui.services.parser.IParserEditStatus; +import org.eclipse.gmf.runtime.common.ui.services.parser.ParserEditStatus; +import org.eclipse.gmf.runtime.common.ui.services.parser.ParserOptions; +import org.eclipse.gmf.runtime.diagram.ui.editparts.CompartmentEditPart; +import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart; +import org.eclipse.gmf.runtime.diagram.ui.editparts.ITextAwareEditPart; +import org.eclipse.gmf.runtime.diagram.ui.editpolicies.LabelDirectEditPolicy; +import org.eclipse.gmf.runtime.diagram.ui.l10n.DiagramColorRegistry; +import org.eclipse.gmf.runtime.diagram.ui.label.ILabelDelegate; +import org.eclipse.gmf.runtime.diagram.ui.label.WrappingLabelDelegate; +import org.eclipse.gmf.runtime.diagram.ui.requests.RequestConstants; +import org.eclipse.gmf.runtime.diagram.ui.tools.TextDirectEditManager; +import org.eclipse.gmf.runtime.draw2d.ui.figures.WrappingLabel; +import org.eclipse.gmf.runtime.emf.core.util.EObjectAdapter; +import org.eclipse.gmf.runtime.emf.ui.services.parser.ISemanticParser; +import org.eclipse.gmf.runtime.notation.FontStyle; +import org.eclipse.gmf.runtime.notation.NotationPackage; +import org.eclipse.gmf.runtime.notation.View; +import org.eclipse.gmf.tooling.runtime.draw2d.labels.SimpleLabelDelegate; +import org.eclipse.gmf.tooling.runtime.edit.policies.DefaultNodeLabelDragPolicy; +import org.eclipse.gmf.tooling.runtime.edit.policies.labels.IRefreshableFeedbackEditPolicy; +import org.eclipse.jface.text.contentassist.IContentAssistProcessor; +import org.eclipse.jface.viewers.ICellEditorValidator; +import org.eclipse.swt.SWT; +import org.eclipse.swt.accessibility.AccessibleEvent; +import org.eclipse.swt.graphics.Color; +import org.eclipse.swt.graphics.FontData; +import org.eclipse.swt.graphics.Image; + +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry; +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineElementTypes; +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineParserProvider; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.policies.StatemachineTextSelectionEditPolicy; + +/** + * @generated + */ +public class StateNameEditPart extends CompartmentEditPart implements + ITextAwareEditPart { + + /** + * @generated + */ + public static final int VISUAL_ID = 5001; + + /** + * @generated + */ + private DirectEditManager manager; + + /** + * @generated + */ + private IParser parser; + + /** + * @generated + */ + private List parserElements; + + /** + * @generated + */ + private String defaultText; + + /** + * @generated + */ + private ILabelDelegate labelDelegate; + + /** + * @generated + */ + public StateNameEditPart(View view) { + super(view); + } + + /** + * @generated + */ + protected void createDefaultEditPolicies() { + super.createDefaultEditPolicies(); + installEditPolicy(EditPolicy.SELECTION_FEEDBACK_ROLE, + new StatemachineTextSelectionEditPolicy()); + installEditPolicy(EditPolicy.DIRECT_EDIT_ROLE, + new LabelDirectEditPolicy()); + installEditPolicy(EditPolicy.PRIMARY_DRAG_ROLE, + new DefaultNodeLabelDragPolicy()); + } + + /** + * @generated + */ + protected String getLabelTextHelper(IFigure figure) { + if (figure instanceof WrappingLabel) { + return ((WrappingLabel) figure).getText(); + } else if (figure instanceof Label) { + return ((Label) figure).getText(); + } else { + return getLabelDelegate().getText(); + } + } + + /** + * @generated + */ + protected void setLabelTextHelper(IFigure figure, String text) { + if (figure instanceof WrappingLabel) { + ((WrappingLabel) figure).setText(text); + } else if (figure instanceof Label) { + ((Label) figure).setText(text); + } else { + getLabelDelegate().setText(text); + } + } + + /** + * @generated + */ + protected Image getLabelIconHelper(IFigure figure) { + if (figure instanceof WrappingLabel) { + return ((WrappingLabel) figure).getIcon(); + } else if (figure instanceof Label) { + return ((Label) figure).getIcon(); + } else { + return getLabelDelegate().getIcon(0); + } + } + + /** + * @generated + */ + protected void setLabelIconHelper(IFigure figure, Image icon) { + if (figure instanceof WrappingLabel) { + ((WrappingLabel) figure).setIcon(icon); + return; + } else if (figure instanceof Label) { + ((Label) figure).setIcon(icon); + return; + } else { + getLabelDelegate().setIcon(icon, 0); + } + } + + /** + * @generated + */ + public void setLabel(WrappingLabel figure, int nodeIndex) { + unregisterVisuals(); + setFigure(figure); + defaultText = getLabelTextHelper(figure); + registerVisuals(); + refreshVisuals(nodeIndex); + } + + /** + * @generated + */ + @SuppressWarnings("rawtypes") + protected List getModelChildren() { + return Collections.EMPTY_LIST; + } + + /** + * @generated + */ + public IGraphicalEditPart getChildBySemanticHint(String semanticHint) { + return null; + } + + /** + * @generated + */ + protected EObject getParserElement() { + return resolveSemanticElement(); + } + + /** + * @generated + */ + protected Image getLabelIcon() { + EObject parserElement = getParserElement(); + if (parserElement == null) { + return null; + } + return StatemachineElementTypes.getImage(parserElement.eClass()); + } + + /** + * @generated + */ + protected String getLabelText() { + String text = null; + EObject parserElement = getParserElement(); + if (parserElement != null && getParser() != null) { + text = getParser().getPrintString( + new EObjectAdapter(parserElement), + getParserOptions().intValue()); + /*if(!text.equals("[]")) { + text = String.valueOf(ordercount); + ordercount = ordercount+1; + }*/ + } + if (text == null || text.length() == 0) { + text = defaultText; + } + + return text; + } + + /** + * @generated + */ + public void setLabelText(String text) { + setLabelTextHelper(getFigure(), text); + refreshSelectionFeedback(); + } + + /** + * @generated + */ + public String getEditText() { + if (getParserElement() == null || getParser() == null) { + return ""; //$NON-NLS-1$ + } + return getParser().getEditString( + new EObjectAdapter(getParserElement()), + getParserOptions().intValue()); + } + + /** + * @generated + */ + protected boolean isEditable() { + return getParser() != null; + } + + /** + * @generated + */ + public ICellEditorValidator getEditTextValidator() { + return new ICellEditorValidator() { + + public String isValid(final Object value) { + if (value instanceof String) { + final EObject element = getParserElement(); + final IParser parser = getParser(); + try { + IParserEditStatus valid = (IParserEditStatus) getEditingDomain() + .runExclusive( + new RunnableWithResult.Impl() { + + public void run() { + setResult(parser + .isValidEditString( + new EObjectAdapter( + element), + (String) value)); + } + }); + return valid.getCode() == ParserEditStatus.EDITABLE ? null + : valid.getMessage(); + } catch (InterruptedException ie) { + ie.printStackTrace(); + } + } + + // shouldn't get here + return null; + } + }; + } + + /** + * @generated + */ + public IContentAssistProcessor getCompletionProcessor() { + if (getParserElement() == null || getParser() == null) { + return null; + } + return getParser().getCompletionProcessor( + new EObjectAdapter(getParserElement())); + } + + /** + * @generated + */ + public ParserOptions getParserOptions() { + return ParserOptions.NONE; + } + + /** + * @generated + */ + public IParser getParser() { + if (parser == null) { + parser = StatemachineParserProvider + .getParser( + StatemachineElementTypes.State_2001, + getParserElement(), + StatemachineVisualIDRegistry + .getType(de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.StateNameEditPart.VISUAL_ID)); + } + return parser; + } + + /** + * @generated + */ + protected DirectEditManager getManager() { + if (manager == null) { + setManager(new TextDirectEditManager(this, null, + OrderEditPartFactory.getTextCellEditorLocator(this))); + } + return manager; + } + + /** + * @generated + */ + protected void setManager(DirectEditManager manager) { + this.manager = manager; + } + + /** + * @generated + */ + protected void performDirectEdit() { + getManager().show(); + } + + /** + * @generated + */ + protected void performDirectEdit(Point eventLocation) { + if (getManager().getClass() == TextDirectEditManager.class) { + ((TextDirectEditManager) getManager()).show(eventLocation + .getSWTPoint()); + } + } + + /** + * @generated + */ + private void performDirectEdit(char initialCharacter) { + if (getManager() instanceof TextDirectEditManager) { + ((TextDirectEditManager) getManager()).show(initialCharacter); + } else // + { + performDirectEdit(); + } + } + + /** + * @generated + */ + protected void performDirectEditRequest(Request request) { + final Request theRequest = request; + try { + getEditingDomain().runExclusive(new Runnable() { + + public void run() { + if (isActive() && isEditable()) { + if (theRequest + .getExtendedData() + .get(RequestConstants.REQ_DIRECTEDIT_EXTENDEDDATA_INITIAL_CHAR) instanceof Character) { + Character initialChar = (Character) theRequest + .getExtendedData() + .get(RequestConstants.REQ_DIRECTEDIT_EXTENDEDDATA_INITIAL_CHAR); + performDirectEdit(initialChar.charValue()); + } else if ((theRequest instanceof DirectEditRequest) + && (getEditText().equals(getLabelText()))) { + DirectEditRequest editRequest = (DirectEditRequest) theRequest; + performDirectEdit(editRequest.getLocation()); + } else { + performDirectEdit(); + } + } + } + }); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + /** + * @param nodeIndex + * @generated + */ + protected void refreshVisuals(int nodeIndex) { + super.refreshVisuals(); + refreshLabel(nodeIndex); + refreshFont(); + refreshFontColor(); + refreshUnderline(); + refreshStrikeThrough(); + } + + /** + * @generated + */ + protected void refreshLabel(int nodeIndex) { + setLabelTextHelper(getFigure(),getLabelText()); + setLabelTextHelper(getFigure(),Integer.toString(nodeIndex)); + + setLabelIconHelper(getFigure(), getLabelIcon()); + refreshSelectionFeedback(); + } + + /** + * @generated + */ + protected void refreshUnderline() { + FontStyle style = (FontStyle) getFontStyleOwnerView().getStyle( + NotationPackage.eINSTANCE.getFontStyle()); + if (style != null && getFigure() instanceof WrappingLabel) { + ((WrappingLabel) getFigure()).setTextUnderline(style.isUnderline()); + } + } + + /** + * @generated + */ + protected void refreshStrikeThrough() { + FontStyle style = (FontStyle) getFontStyleOwnerView().getStyle( + NotationPackage.eINSTANCE.getFontStyle()); + if (style != null && getFigure() instanceof WrappingLabel) { + ((WrappingLabel) getFigure()).setTextStrikeThrough(style + .isStrikeThrough()); + } + } + + /** + * @generated + */ + protected void refreshFont() { + FontStyle style = (FontStyle) getFontStyleOwnerView().getStyle( + NotationPackage.eINSTANCE.getFontStyle()); + if (style != null) { + FontData fontData = new FontData(style.getFontName(), + style.getFontHeight(), (style.isBold() ? SWT.BOLD + : SWT.NORMAL) + | (style.isItalic() ? SWT.ITALIC : SWT.NORMAL)); + setFont(fontData); + } + } + + /** + * @generated + */ + private void refreshSelectionFeedback() { + requestEditPolicyFeedbackRefresh(EditPolicy.PRIMARY_DRAG_ROLE); + requestEditPolicyFeedbackRefresh(EditPolicy.SELECTION_FEEDBACK_ROLE); + } + + /** + * @generated + */ + private void requestEditPolicyFeedbackRefresh(String editPolicyKey) { + Object editPolicy = getEditPolicy(editPolicyKey); + if (editPolicy instanceof IRefreshableFeedbackEditPolicy) { + ((IRefreshableFeedbackEditPolicy) editPolicy).refreshFeedback(); + } + } + + /** + * @generated + */ + protected void setFontColor(Color color) { + getFigure().setForegroundColor(color); + } + + /** + * @generated + */ + protected void addSemanticListeners() { + if (getParser() instanceof ISemanticParser) { + EObject element = resolveSemanticElement(); + parserElements = ((ISemanticParser) getParser()) + .getSemanticElementsBeingParsed(element); + for (int i = 0; i < parserElements.size(); i++) { + addListenerFilter( + "SemanticModel" + i, this, (EObject) parserElements.get(i)); //$NON-NLS-1$ + } + } else { + super.addSemanticListeners(); + } + } + + /** + * @generated + */ + protected void removeSemanticListeners() { + if (parserElements != null) { + for (int i = 0; i < parserElements.size(); i++) { + removeListenerFilter("SemanticModel" + i); //$NON-NLS-1$ + } + } else { + super.removeSemanticListeners(); + } + } + + /** + * @generated + */ + protected AccessibleEditPart getAccessibleEditPart() { + if (accessibleEP == null) { + accessibleEP = new AccessibleGraphicalEditPart() { + + public void getName(AccessibleEvent e) { + e.result = getLabelTextHelper(getFigure()); + } + }; + } + return accessibleEP; + } + + /** + * @generated + */ + private View getFontStyleOwnerView() { + return (View) getModel(); + } + + /** + * @generated + */ + private ILabelDelegate getLabelDelegate() { + if (labelDelegate == null) { + IFigure label = getFigure(); + if (label instanceof WrappingLabel) { + labelDelegate = new WrappingLabelDelegate((WrappingLabel) label); + } else { + labelDelegate = new SimpleLabelDelegate((Label) label); + } + } + return labelDelegate; + } + + /** + * @generated + */ + @Override + public Object getAdapter(Class key) { + if (ILabelDelegate.class.equals(key)) { + return getLabelDelegate(); + } + return super.getAdapter(key); + } + + /** + * @generated + */ + protected void addNotationalListeners() { + super.addNotationalListeners(); + addListenerFilter("PrimaryView", this, getPrimaryView()); //$NON-NLS-1$ + } + + /** + * @generated + */ + protected void removeNotationalListeners() { + super.removeNotationalListeners(); + removeListenerFilter("PrimaryView"); //$NON-NLS-1$ + } + + /** + * @generated + * + * may be removed. + */ +/*protected void handleNotificationEvent(Notification event) { + Object feature = event.getFeature(); + if (NotationPackage.eINSTANCE.getFontStyle_FontColor().equals(feature)) { + Integer c = (Integer) event.getNewValue(); + setFontColor(DiagramColorRegistry.getInstance().getColor(c)); + } else if (NotationPackage.eINSTANCE.getFontStyle_Underline().equals( + feature)) { + refreshUnderline(); + } else if (NotationPackage.eINSTANCE.getFontStyle_StrikeThrough() + .equals(feature)) { + refreshStrikeThrough(); + } else if (NotationPackage.eINSTANCE.getFontStyle_FontHeight().equals( + feature) + || NotationPackage.eINSTANCE.getFontStyle_FontName().equals( + feature) + || NotationPackage.eINSTANCE.getFontStyle_Bold() + .equals(feature) + || NotationPackage.eINSTANCE.getFontStyle_Italic().equals( + feature)) { + refreshFont(); + } else { + if (getParser() != null + && getParser().isAffectingEvent(event, + getParserOptions().intValue())) { + refreshLabel(); + } + if (getParser() instanceof ISemanticParser) { + ISemanticParser modelParser = (ISemanticParser) getParser(); + if (modelParser.areSemanticElementsAffected(null, event)) { + removeSemanticListeners(); + if (resolveSemanticElement() != null) { + addSemanticListeners(); + } + refreshLabel(); + } + } + } + super.handleNotificationEvent(event); + }*/ + + /** + * @generated + */ + protected IFigure createFigure() { + // Parent should assign one using setLabel() method + return null; + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/parts/TransitionEditPart.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/parts/TransitionEditPart.java new file mode 100644 index 00000000..def13565 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/parts/TransitionEditPart.java @@ -0,0 +1,128 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.edit.parts; + +import java.awt.FlowLayout; + +import org.eclipse.draw2d.Connection; +import org.eclipse.draw2d.PolylineDecoration; +import org.eclipse.draw2d.RectangleFigure; +import org.eclipse.draw2d.RotatableDecoration; +import org.eclipse.draw2d.geometry.PointList; +import org.eclipse.gef.EditPart; +import org.eclipse.gmf.runtime.diagram.ui.editparts.ConnectionNodeEditPart; +import org.eclipse.gmf.runtime.diagram.ui.editparts.ITreeBranchEditPart; +import org.eclipse.gmf.runtime.diagram.ui.editpolicies.EditPolicyRoles; +import org.eclipse.gmf.runtime.draw2d.ui.figures.PolylineConnectionEx; +import org.eclipse.gmf.runtime.draw2d.ui.figures.WrappingLabel; +import org.eclipse.gmf.runtime.notation.View; + +import de.darmstadt.tu.crossing.statemachine.diagram.edit.policies.TransitionItemSemanticEditPolicy; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry; + +public class TransitionEditPart extends ConnectionNodeEditPart implements ITreeBranchEditPart { + + /** + * @generated + */ + public static final int VISUAL_ID = 4001; + + /** + * @generated + */ + public TransitionEditPart(View view) { + super(view); + } + + /** + * @generated + */ + protected void createDefaultEditPolicies() { + super.createDefaultEditPolicies(); + installEditPolicy(EditPolicyRoles.SEMANTIC_ROLE, new TransitionItemSemanticEditPolicy()); + } + + /** + * @generated + */ + protected boolean addFixedChild(EditPart childEditPart) { + return false; + } + + /** + * @generated + */ + protected void addChildVisual(EditPart childEditPart, int index) { + if (addFixedChild(childEditPart)) { + return; + } + super.addChildVisual(childEditPart, -1); + } + + /** + * @generated + */ + protected boolean removeFixedChild(EditPart childEditPart) { + return false; + } + + /** + * @generated + */ + protected void removeChildVisual(EditPart childEditPart) { + if (removeFixedChild(childEditPart)) { + return; + } + super.removeChildVisual(childEditPart); + } + + /** + * Creates figure for this edit part. + * + * Body of this method does not depend on settings in generation model + * so you may safely remove generated tag and modify it. + * + * @generated + */ + + protected Connection createConnectionFigure() { + return new TransitionConnection(); + } + + /** + * @generated + */ + public TransitionConnection getPrimaryShape() { + return (TransitionConnection) getFigure(); + } + + /** + * @generated + */ + public class TransitionConnection extends PolylineConnectionEx { + + /** + * @generated + */ + public TransitionConnection() { + this.setLineWidth(1); + + setTargetDecoration(createTargetDecoration()); + } + + /** + * @generated + */ + private RotatableDecoration createTargetDecoration() { + PolylineDecoration df = new PolylineDecoration(); + df.setLineWidth(1); + PointList pl = new PointList(); + pl.addPoint(getMapMode().DPtoLP(-2), getMapMode().DPtoLP(-1)); + pl.addPoint(getMapMode().DPtoLP(0), getMapMode().DPtoLP(0)); + pl.addPoint(getMapMode().DPtoLP(-2), getMapMode().DPtoLP(1)); + df.setTemplate(pl); + df.setScale(getMapMode().DPtoLP(7), getMapMode().DPtoLP(3)); + return df; + } + + } + +} \ No newline at end of file diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/parts/TransitionNameEditPart.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/parts/TransitionNameEditPart.java new file mode 100644 index 00000000..a621321b --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/parts/TransitionNameEditPart.java @@ -0,0 +1,575 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.edit.parts; + +import java.util.Collections; +import java.util.List; + +import org.eclipse.draw2d.IFigure; +import org.eclipse.draw2d.Label; +import org.eclipse.draw2d.geometry.Point; +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.transaction.RunnableWithResult; +import org.eclipse.gef.AccessibleEditPart; +import org.eclipse.gef.EditPolicy; +import org.eclipse.gef.Request; +import org.eclipse.gef.requests.DirectEditRequest; +import org.eclipse.gef.tools.DirectEditManager; +import org.eclipse.gmf.runtime.common.ui.services.parser.IParser; +import org.eclipse.gmf.runtime.common.ui.services.parser.IParserEditStatus; +import org.eclipse.gmf.runtime.common.ui.services.parser.ParserEditStatus; +import org.eclipse.gmf.runtime.common.ui.services.parser.ParserOptions; +import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart; +import org.eclipse.gmf.runtime.diagram.ui.editparts.ITextAwareEditPart; +import org.eclipse.gmf.runtime.diagram.ui.editpolicies.LabelDirectEditPolicy; +import org.eclipse.gmf.runtime.diagram.ui.l10n.DiagramColorRegistry; +import org.eclipse.gmf.runtime.diagram.ui.label.ILabelDelegate; +import org.eclipse.gmf.runtime.diagram.ui.label.WrappingLabelDelegate; +import org.eclipse.gmf.runtime.diagram.ui.requests.RequestConstants; +import org.eclipse.gmf.runtime.diagram.ui.tools.TextDirectEditManager; +import org.eclipse.gmf.runtime.draw2d.ui.figures.WrappingLabel; +import org.eclipse.gmf.runtime.emf.core.util.EObjectAdapter; +import org.eclipse.gmf.runtime.emf.ui.services.parser.ISemanticParser; +import org.eclipse.gmf.runtime.notation.FontStyle; +import org.eclipse.gmf.runtime.notation.NotationPackage; +import org.eclipse.gmf.runtime.notation.View; +import org.eclipse.gmf.tooling.runtime.draw2d.labels.SimpleLabelDelegate; +import org.eclipse.gmf.tooling.runtime.edit.policies.labels.IRefreshableFeedbackEditPolicy; +import org.eclipse.jface.text.contentassist.IContentAssistProcessor; +import org.eclipse.jface.viewers.ICellEditorValidator; +import org.eclipse.swt.SWT; +import org.eclipse.swt.accessibility.AccessibleEvent; +import org.eclipse.swt.graphics.Color; +import org.eclipse.swt.graphics.FontData; +import org.eclipse.swt.graphics.Image; +import org.eclipse.draw2d.ConnectionLocator; + +import org.eclipse.gef.GraphicalEditPart; +import org.eclipse.gef.handles.MoveHandle; +import org.eclipse.gmf.runtime.diagram.ui.editparts.LabelEditPart; +import org.eclipse.gmf.runtime.diagram.ui.editpolicies.NonResizableLabelEditPolicy; + + +import de.darmstadt.tu.crossing.statemachine.diagram.edit.policies.StatemachineTextSelectionEditPolicy; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry; +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineElementTypes; +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineParserProvider; + +/** + * @generated + */ + +public class TransitionNameEditPart extends LabelEditPart implements ITextAwareEditPart { + + /** + * @generated + */ + public static final int VISUAL_ID = 6001; + + /** + * @generated + */ + private DirectEditManager manager; + + /** + * @generated + */ + private IParser parser; + + /** + * @generated + */ + private List parserElements; + + /** + * @generated + */ + private String defaultText; + + /** + * @generated + */ + ILabelDelegate labelDelegate; + + /** + * @generated + */ + static { + registerSnapBackPosition(StatemachineVisualIDRegistry.getType(de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.TransitionNameEditPart.VISUAL_ID), new Point(0, 40)); + } + + /** + * @generated + */ + public TransitionNameEditPart(View view) { + super(view); + } + + /** + * @generated + */ + protected void createDefaultEditPolicies() { + super.createDefaultEditPolicies(); + installEditPolicy(EditPolicy.DIRECT_EDIT_ROLE, new LabelDirectEditPolicy()); + installEditPolicy(EditPolicy.SELECTION_FEEDBACK_ROLE, new StatemachineTextSelectionEditPolicy()); + installEditPolicy(EditPolicy.PRIMARY_DRAG_ROLE, new NonResizableLabelEditPolicy() { + + protected List createSelectionHandles() { + MoveHandle mh = new MoveHandle((GraphicalEditPart) getHost()); + mh.setBorder(null); + return Collections.singletonList(mh); + } + }); + } + + /** + * @generated + */ + public int getKeyPoint() { + return ConnectionLocator.MIDDLE; + } + + /** + * @generated + */ + protected String getLabelTextHelper(IFigure figure) { + if (figure instanceof WrappingLabel) { + return ((WrappingLabel) figure).getText(); + } else { + return ((Label) figure).getText(); + } + } + + /** + * @generated + */ + protected void setLabelTextHelper(IFigure figure, String text) { + if (figure instanceof WrappingLabel) { + ((WrappingLabel) figure).setText(text); + } else { + ((Label) figure).setText(text); + } + } + + /** + * @generated + */ + protected Image getLabelIconHelper(IFigure figure) { + if (figure instanceof WrappingLabel) { + return ((WrappingLabel) figure).getIcon(); + } else { + return ((Label) figure).getIcon(); + } + } + + /** + * @generated + */ + protected void setLabelIconHelper(IFigure figure, Image icon) { + if (figure instanceof WrappingLabel) { + ((WrappingLabel) figure).setIcon(icon); + } else { + ((Label) figure).setIcon(icon); + } + } + + /** + * @generated + */ + public void setLabel(IFigure figure) { + unregisterVisuals(); + setFigure(figure); + defaultText = getLabelTextHelper(figure); + registerVisuals(); + refreshVisuals(); + } + + /** + * @generated + */ + protected List getModelChildren() { + return Collections.EMPTY_LIST; + } + + /** + * @generated + */ + public IGraphicalEditPart getChildBySemanticHint(String semanticHint) { + return null; + } + + /** + * @generated + */ + protected EObject getParserElement() { + return resolveSemanticElement(); + } + + /** + * @generated + */ + protected Image getLabelIcon() { + return null; + } + + /** + * @generated + */ + protected String getLabelText() { + String text = null; + EObject parserElement = getParserElement(); + if (parserElement != null && getParser() != null) { + text = getParser().getPrintString(new EObjectAdapter(parserElement), getParserOptions().intValue()); + } + if (text == null || text.length() == 0) { + text = defaultText; + } + return text; + } + + /** + * @generated + */ + public void setLabelText(String text) { + setLabelTextHelper(getFigure(), text); + refreshFeedback(); + } + + /** + * @generated + */ + public String getEditText() { + if (getParserElement() == null || getParser() == null) { + return ""; //$NON-NLS-1$ + } + return getParser().getEditString(new EObjectAdapter(getParserElement()), getParserOptions().intValue()); + } + + /** + * @generated + */ + protected boolean isEditable() { + return getParser() != null; + } + + /** + * @generated + */ + public ICellEditorValidator getEditTextValidator() { + return new ICellEditorValidator() { + + public String isValid(final Object value) { + if (value instanceof String) { + final EObject element = getParserElement(); + final IParser parser = getParser(); + try { + IParserEditStatus valid = (IParserEditStatus) getEditingDomain().runExclusive(new RunnableWithResult.Impl() { + + public void run() { + setResult(parser.isValidEditString(new EObjectAdapter(element), (String) value)); + } + }); + return valid.getCode() == ParserEditStatus.EDITABLE ? null : valid.getMessage(); + } catch (InterruptedException ie) { + ie.printStackTrace(); + } + } + + // shouldn't get here + return null; + } + }; + } + + /** + * @generated + */ + public IContentAssistProcessor getCompletionProcessor() { + if (getParserElement() == null || getParser() == null) { + return null; + } + return getParser().getCompletionProcessor(new EObjectAdapter(getParserElement())); + } + + /** + * @generated + */ + public ParserOptions getParserOptions() { + return ParserOptions.NONE; + } + + /** + * @generated + */ + public IParser getParser() { + if (parser == null) { + parser = StatemachineParserProvider.getParser(StatemachineElementTypes.Transition_4001, getParserElement(),StatemachineVisualIDRegistry + .getType(de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.TransitionNameEditPart.VISUAL_ID)); + } + return parser; + } + + /** + * @generated + */ + protected DirectEditManager getManager() { + if (manager == null) { + setManager(new TextDirectEditManager(this, null, OrderEditPartFactory.getTextCellEditorLocator(this))); + } + return manager; + } + + /** + * @generated + */ + protected void setManager(DirectEditManager manager) { + this.manager = manager; + } + + /** + * @generated + */ + protected void performDirectEdit() { + getManager().show(); + } + + /** + * @generated + */ + protected void performDirectEdit(Point eventLocation) { + if (getManager().getClass() == TextDirectEditManager.class) { + ((TextDirectEditManager) getManager()).show(eventLocation.getSWTPoint()); + } + } + + /** + * @generated + */ + private void performDirectEdit(char initialCharacter) { + if (getManager() instanceof TextDirectEditManager) { + ((TextDirectEditManager) getManager()).show(initialCharacter); + } else { + performDirectEdit(); + } + } + + /** + * @generated + */ + protected void performDirectEditRequest(Request request) { + final Request theRequest = request; + try { + getEditingDomain().runExclusive(new Runnable() { + + public void run() { + if (isActive() && isEditable()) { + if (theRequest.getExtendedData().get(RequestConstants.REQ_DIRECTEDIT_EXTENDEDDATA_INITIAL_CHAR) instanceof Character) { + Character initialChar = (Character) theRequest.getExtendedData().get(RequestConstants.REQ_DIRECTEDIT_EXTENDEDDATA_INITIAL_CHAR); + performDirectEdit(initialChar.charValue()); + } else if ((theRequest instanceof DirectEditRequest) && (getEditText().equals(getLabelText()))) { + DirectEditRequest editRequest = (DirectEditRequest) theRequest; + performDirectEdit(editRequest.getLocation()); + } else { + performDirectEdit(); + } + } + } + }); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + /** + * @generated + */ + protected void refreshVisuals() { + super.refreshVisuals(); + refreshLabel(); + refreshFont(); + refreshFontColor(); + refreshUnderline(); + refreshStrikeThrough(); + } + + /** + * @generated + */ + protected void refreshLabel() { + setLabelTextHelper(getFigure(), getLabelText()); + setLabelIconHelper(getFigure(), getLabelIcon()); + refreshFeedback(); + } + + /** + * @generated + */ + protected void refreshUnderline() { + FontStyle style = (FontStyle) getFontStyleOwnerView().getStyle(NotationPackage.eINSTANCE.getFontStyle()); + if (style != null && getFigure() instanceof WrappingLabel) { + ((WrappingLabel) getFigure()).setTextUnderline(style.isUnderline()); + } + } + + /** + * @generated + */ + protected void refreshStrikeThrough() { + FontStyle style = (FontStyle) getFontStyleOwnerView().getStyle(NotationPackage.eINSTANCE.getFontStyle()); + if (style != null && getFigure() instanceof WrappingLabel) { + ((WrappingLabel) getFigure()).setTextStrikeThrough(style.isStrikeThrough()); + } + } + + /** + * @generated + */ + protected void refreshFont() { + FontStyle style = (FontStyle) getFontStyleOwnerView().getStyle(NotationPackage.eINSTANCE.getFontStyle()); + if (style != null) { + FontData fontData = new FontData(style.getFontName(), style.getFontHeight(), (style.isBold() ? SWT.BOLD : SWT.NORMAL) | (style.isItalic() ? SWT.ITALIC : SWT.NORMAL)); + setFont(fontData); + } + } + + /** + * @generated + */ + protected void setFontColor(Color color) { + getFigure().setForegroundColor(color); + } + + /** + * @generated + */ + protected void addSemanticListeners() { + if (getParser() instanceof ISemanticParser) { + EObject element = resolveSemanticElement(); + parserElements = ((ISemanticParser) getParser()).getSemanticElementsBeingParsed(element); + for (int i = 0; i < parserElements.size(); i++) { + addListenerFilter("SemanticModel" + i, this, (EObject) parserElements.get(i)); //$NON-NLS-1$ + } + } else { + super.addSemanticListeners(); + } + } + + /** + * @generated + */ + protected void removeSemanticListeners() { + if (parserElements != null) { + for (int i = 0; i < parserElements.size(); i++) { + removeListenerFilter("SemanticModel" + i); //$NON-NLS-1$ + } + } else { + super.removeSemanticListeners(); + } + } + + /** + * @generated + */ + protected AccessibleEditPart getAccessibleEditPart() { + if (accessibleEP == null) { + accessibleEP = new AccessibleGraphicalEditPart() { + + public void getName(AccessibleEvent e) { + e.result = getLabelTextHelper(getFigure()); + } + }; + } + return accessibleEP; + } + + /** + * @generated + */ + private View getFontStyleOwnerView() { + return getPrimaryView(); + } + + /** + * @generated + */ + private void refreshFeedback() { + Object pdEditPolicy = getEditPolicy(EditPolicy.PRIMARY_DRAG_ROLE); + if (pdEditPolicy instanceof IRefreshableFeedbackEditPolicy) { + ((IRefreshableFeedbackEditPolicy) pdEditPolicy).refreshFeedback(); + } + } + + /** + * @generated + */ + private ILabelDelegate getLabelDelegate() { + if (labelDelegate == null) { + IFigure label = getFigure(); + if (label instanceof WrappingLabel) { + labelDelegate = new WrappingLabelDelegate((WrappingLabel) label); + } else { + labelDelegate = new SimpleLabelDelegate((Label) label); + } + } + return labelDelegate; + } + + /** + * @generated + */ + @Override + public Object getAdapter(Class key) { + if (ILabelDelegate.class.equals(key)) { + return getLabelDelegate(); + } + return super.getAdapter(key); + } + + /** + * @generated + */ + protected void handleNotificationEvent(Notification event) { + Object feature = event.getFeature(); + if (NotationPackage.eINSTANCE.getFontStyle_FontColor().equals(feature)) { + Integer c = (Integer) event.getNewValue(); + setFontColor(DiagramColorRegistry.getInstance().getColor(c)); + } else if (NotationPackage.eINSTANCE.getFontStyle_Underline().equals(feature)) { + refreshUnderline(); + } else if (NotationPackage.eINSTANCE.getFontStyle_StrikeThrough().equals(feature)) { + refreshStrikeThrough(); + } else if (NotationPackage.eINSTANCE.getFontStyle_FontHeight().equals(feature) || NotationPackage.eINSTANCE.getFontStyle_FontName().equals(feature) + || NotationPackage.eINSTANCE.getFontStyle_Bold().equals(feature) || NotationPackage.eINSTANCE.getFontStyle_Italic().equals(feature)) { + refreshFont(); + } else { + if (getParser() != null && getParser().isAffectingEvent(event, getParserOptions().intValue())) { + refreshLabel(); + } + if (getParser() instanceof ISemanticParser) { + ISemanticParser modelParser = (ISemanticParser) getParser(); + if (modelParser.areSemanticElementsAffected(null, event)) { + removeSemanticListeners(); + if (resolveSemanticElement() != null) { + addSemanticListeners(); + } + refreshLabel(); + } + } + } + super.handleNotificationEvent(event); + } + + /** + * @generated + */ + protected IFigure createFigure() { + IFigure label = createFigurePrim(); + defaultText = getLabelTextHelper(label); + return label; + } + + /** + * @generated + */ + protected IFigure createFigurePrim() { + return new Label(); + } +} \ No newline at end of file diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/policies/StateItemSemanticEditPolicy.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/policies/StateItemSemanticEditPolicy.java new file mode 100644 index 00000000..848db7e1 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/policies/StateItemSemanticEditPolicy.java @@ -0,0 +1,114 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.edit.policies; + +import java.util.Iterator; + +import org.eclipse.emf.ecore.EAnnotation; +import org.eclipse.gef.commands.Command; +import org.eclipse.gmf.runtime.diagram.core.commands.DeleteCommand; +import org.eclipse.gmf.runtime.emf.commands.core.command.CompositeTransactionalCommand; +import org.eclipse.gmf.runtime.emf.type.core.commands.DestroyElementCommand; +import org.eclipse.gmf.runtime.emf.type.core.requests.CreateRelationshipRequest; +import org.eclipse.gmf.runtime.emf.type.core.requests.DestroyElementRequest; +import org.eclipse.gmf.runtime.emf.type.core.requests.ReorientRelationshipRequest; +import org.eclipse.gmf.runtime.notation.Edge; +import org.eclipse.gmf.runtime.notation.View; + +import de.darmstadt.tu.crossing.statemachine.diagram.edit.commands.TransitionCreateCommand; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.commands.TransitionReorientCommand; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.TransitionEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry; +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineElementTypes; + +/** + * @generated + */ +public class StateItemSemanticEditPolicy extends StatemachineBaseItemSemanticEditPolicy { + + /** + * @generated + */ + public StateItemSemanticEditPolicy() { + super(StatemachineElementTypes.State_2001); + } + + /** + * @generated + */ + protected Command getDestroyElementCommand(DestroyElementRequest req) { + View view = (View) getHost().getModel(); + CompositeTransactionalCommand cmd = new CompositeTransactionalCommand(getEditingDomain(), null); + cmd.setTransactionNestingEnabled(false); + for (Iterator it = view.getTargetEdges().iterator(); it.hasNext();) { + Edge incomingLink = (Edge) it.next(); + if (StatemachineVisualIDRegistry.getVisualID(incomingLink) == TransitionEditPart.VISUAL_ID) { + DestroyElementRequest r = new DestroyElementRequest(incomingLink.getElement(), false); + cmd.add(new DestroyElementCommand(r)); + cmd.add(new DeleteCommand(getEditingDomain(), incomingLink)); + continue; + } + } + for (Iterator it = view.getSourceEdges().iterator(); it.hasNext();) { + Edge outgoingLink = (Edge) it.next(); + if (StatemachineVisualIDRegistry.getVisualID(outgoingLink) == TransitionEditPart.VISUAL_ID) { + DestroyElementRequest r = new DestroyElementRequest(outgoingLink.getElement(), false); + cmd.add(new DestroyElementCommand(r)); + cmd.add(new DeleteCommand(getEditingDomain(), outgoingLink)); + continue; + } + } + EAnnotation annotation = view.getEAnnotation("Shortcut"); //$NON-NLS-1$ + if (annotation == null) { + // there are indirectly referenced children, need extra commands: false + addDestroyShortcutsCommand(cmd, view); + // delete host element + cmd.add(new DestroyElementCommand(req)); + } else { + cmd.add(new DeleteCommand(getEditingDomain(), view)); + } + return getGEFWrapper(cmd.reduce()); + } + + /** + * @generated + */ + protected Command getCreateRelationshipCommand(CreateRelationshipRequest req) { + Command command = req.getTarget() == null ? getStartCreateRelationshipCommand(req) + : getCompleteCreateRelationshipCommand(req); + return command != null ? command : super.getCreateRelationshipCommand(req); + } + + /** + * @generated + */ + protected Command getStartCreateRelationshipCommand(CreateRelationshipRequest req) { + if (StatemachineElementTypes.Transition_4001 == req.getElementType()) { + return getGEFWrapper(new TransitionCreateCommand(req, req.getSource(), req.getTarget())); + } + return null; + } + + /** + * @generated + */ + protected Command getCompleteCreateRelationshipCommand(CreateRelationshipRequest req) { + if (StatemachineElementTypes.Transition_4001 == req.getElementType()) { + return getGEFWrapper(new TransitionCreateCommand(req, req.getSource(), req.getTarget())); + } + return null; + } + + /** + * Returns command to reorient EClass based link. New link target or source + * should be the domain model element associated with this node. + * + * @generated + */ + protected Command getReorientRelationshipCommand(ReorientRelationshipRequest req) { + switch (getVisualID(req)) { + case TransitionEditPart.VISUAL_ID: + return getGEFWrapper(new TransitionReorientCommand(req)); + } + return super.getReorientRelationshipCommand(req); + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/policies/StatemachineBaseItemSemanticEditPolicy.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/policies/StatemachineBaseItemSemanticEditPolicy.java new file mode 100644 index 00000000..9a418574 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/policies/StatemachineBaseItemSemanticEditPolicy.java @@ -0,0 +1,343 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.edit.policies; + +import java.util.Iterator; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.transaction.TransactionalEditingDomain; +import org.eclipse.gef.Request; +import org.eclipse.gef.commands.Command; +import org.eclipse.gef.commands.UnexecutableCommand; +import org.eclipse.gef.requests.ReconnectRequest; +import org.eclipse.gmf.runtime.common.core.command.ICommand; +import org.eclipse.gmf.runtime.common.core.command.ICompositeCommand; +import org.eclipse.gmf.runtime.diagram.core.commands.DeleteCommand; +import org.eclipse.gmf.runtime.diagram.ui.commands.CommandProxy; +import org.eclipse.gmf.runtime.diagram.ui.commands.ICommandProxy; +import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart; +import org.eclipse.gmf.runtime.diagram.ui.editpolicies.SemanticEditPolicy; +import org.eclipse.gmf.runtime.emf.commands.core.command.CompositeTransactionalCommand; +import org.eclipse.gmf.runtime.emf.type.core.IElementType; +import org.eclipse.gmf.runtime.emf.type.core.requests.ConfigureRequest; +import org.eclipse.gmf.runtime.emf.type.core.requests.CreateElementRequest; +import org.eclipse.gmf.runtime.emf.type.core.requests.CreateRelationshipRequest; +import org.eclipse.gmf.runtime.emf.type.core.requests.DestroyElementRequest; +import org.eclipse.gmf.runtime.emf.type.core.requests.DestroyReferenceRequest; +import org.eclipse.gmf.runtime.emf.type.core.requests.DestroyRequest; +import org.eclipse.gmf.runtime.emf.type.core.requests.DuplicateElementsRequest; +import org.eclipse.gmf.runtime.emf.type.core.requests.GetEditContextRequest; +import org.eclipse.gmf.runtime.emf.type.core.requests.IEditCommandRequest; +import org.eclipse.gmf.runtime.emf.type.core.requests.MoveRequest; +import org.eclipse.gmf.runtime.emf.type.core.requests.ReorientReferenceRelationshipRequest; +import org.eclipse.gmf.runtime.emf.type.core.requests.ReorientRelationshipRequest; +import org.eclipse.gmf.runtime.emf.type.core.requests.SetRequest; +import org.eclipse.gmf.runtime.notation.View; +import org.eclipse.gmf.tooling.runtime.edit.helpers.GeneratedEditHelperBase; +import de.darmstadt.tu.crossing.crySL.Expression; +import de.darmstadt.tu.crossing.crySL.Order; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry; +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineElementTypes; +import de.darmstadt.tu.crossing.crySL.Expression; + +/** + * @generated + */ +public class StatemachineBaseItemSemanticEditPolicy extends SemanticEditPolicy { + + /** + * Extended request data key to hold editpart visual id. + * @generated + */ + public static final String VISUAL_ID_KEY = "visual_id"; //$NON-NLS-1$ + + /** + * @generated + */ + private final IElementType myElementType; + + /** + * @generated + */ + protected StatemachineBaseItemSemanticEditPolicy(IElementType elementType) { + myElementType = elementType; + } + + /** + * Extended request data key to hold editpart visual id. + * Add visual id of edited editpart to extended data of the request + * so command switch can decide what kind of diagram element is being edited. + * It is done in those cases when it's not possible to deduce diagram + * element kind from domain element. + * + * @generated + */ + public Command getCommand(Request request) { + if (request instanceof ReconnectRequest) { + Object view = ((ReconnectRequest) request).getConnectionEditPart() + .getModel(); + if (view instanceof View) { + Integer id = new Integer( + StatemachineVisualIDRegistry.getVisualID((View) view)); + request.getExtendedData().put(VISUAL_ID_KEY, id); + } + } + return super.getCommand(request); + } + + /** + * Returns visual id from request parameters. + * @generated + */ + protected int getVisualID(IEditCommandRequest request) { + Object id = request.getParameter(VISUAL_ID_KEY); + return id instanceof Integer ? ((Integer) id).intValue() : -1; + } + + /** + * @generated + */ + protected Command getSemanticCommand(IEditCommandRequest request) { + IEditCommandRequest completedRequest = completeRequest(request); + Command semanticCommand = getSemanticCommandSwitch(completedRequest); + semanticCommand = getEditHelperCommand(completedRequest, + semanticCommand); + if (completedRequest instanceof DestroyRequest) { + DestroyRequest destroyRequest = (DestroyRequest) completedRequest; + return shouldProceed(destroyRequest) ? addDeleteViewCommand( + semanticCommand, destroyRequest) : null; + } + return semanticCommand; + } + + /** + * @generated + */ + protected Command addDeleteViewCommand(Command mainCommand, + DestroyRequest completedRequest) { + Command deleteViewCommand = getGEFWrapper(new DeleteCommand( + getEditingDomain(), (View) getHost().getModel())); + return mainCommand == null ? deleteViewCommand : mainCommand + .chain(deleteViewCommand); + } + + /** + * @generated + */ + private Command getEditHelperCommand(IEditCommandRequest request, + Command editPolicyCommand) { + if (editPolicyCommand != null) { + ICommand command = editPolicyCommand instanceof ICommandProxy ? ((ICommandProxy) editPolicyCommand) + .getICommand() : new CommandProxy(editPolicyCommand); + request.setParameter(GeneratedEditHelperBase.EDIT_POLICY_COMMAND, + command); + } + IElementType requestContextElementType = getContextElementType(request); + request.setParameter(GeneratedEditHelperBase.CONTEXT_ELEMENT_TYPE, + requestContextElementType); + ICommand command = requestContextElementType.getEditCommand(request); + request.setParameter(GeneratedEditHelperBase.EDIT_POLICY_COMMAND, null); + request.setParameter(GeneratedEditHelperBase.CONTEXT_ELEMENT_TYPE, null); + if (command != null) { + if (!(command instanceof CompositeTransactionalCommand)) { + command = new CompositeTransactionalCommand(getEditingDomain(), + command.getLabel()).compose(command); + } + return new ICommandProxy(command); + } + return editPolicyCommand; + } + + /** + * @generated + */ + private IElementType getContextElementType(IEditCommandRequest request) { + IElementType requestContextElementType = StatemachineElementTypes + .getElementType(getVisualID(request)); + return requestContextElementType != null ? requestContextElementType + : myElementType; + } + + /** + * @generated + */ + protected Command getSemanticCommandSwitch(IEditCommandRequest req) { + if (req instanceof CreateRelationshipRequest) { + return getCreateRelationshipCommand((CreateRelationshipRequest) req); + } else if (req instanceof CreateElementRequest) { + return getCreateCommand((CreateElementRequest) req); + } else if (req instanceof ConfigureRequest) { + return getConfigureCommand((ConfigureRequest) req); + } else if (req instanceof DestroyElementRequest) { + return getDestroyElementCommand((DestroyElementRequest) req); + } else if (req instanceof DestroyReferenceRequest) { + return getDestroyReferenceCommand((DestroyReferenceRequest) req); + } else if (req instanceof DuplicateElementsRequest) { + return getDuplicateCommand((DuplicateElementsRequest) req); + } else if (req instanceof GetEditContextRequest) { + return getEditContextCommand((GetEditContextRequest) req); + } else if (req instanceof MoveRequest) { + return getMoveCommand((MoveRequest) req); + } else if (req instanceof ReorientReferenceRelationshipRequest) { + return getReorientReferenceRelationshipCommand((ReorientReferenceRelationshipRequest) req); + } else if (req instanceof ReorientRelationshipRequest) { + return getReorientRelationshipCommand((ReorientRelationshipRequest) req); + } else if (req instanceof SetRequest) { + return getSetCommand((SetRequest) req); + } + return null; + } + + /** + * @generated + */ + protected Command getConfigureCommand(ConfigureRequest req) { + return null; + } + + /** + * @generated + */ + protected Command getCreateRelationshipCommand(CreateRelationshipRequest req) { + return null; + } + + /** + * @generated + */ + protected Command getCreateCommand(CreateElementRequest req) { + return null; + } + + /** + * @generated + */ + protected Command getSetCommand(SetRequest req) { + return null; + } + + /** + * @generated + */ + protected Command getEditContextCommand(GetEditContextRequest req) { + return null; + } + + /** + * @generated + */ + protected Command getDestroyElementCommand(DestroyElementRequest req) { + return null; + } + + /** + * @generated + */ + protected Command getDestroyReferenceCommand(DestroyReferenceRequest req) { + return null; + } + + /** + * @generated + */ + protected Command getDuplicateCommand(DuplicateElementsRequest req) { + return null; + } + + /** + * @generated + */ + protected Command getMoveCommand(MoveRequest req) { + return null; + } + + /** + * @generated + */ + protected Command getReorientReferenceRelationshipCommand( + ReorientReferenceRelationshipRequest req) { + return UnexecutableCommand.INSTANCE; + } + + /** + * @generated + */ + protected Command getReorientRelationshipCommand( + ReorientRelationshipRequest req) { + return UnexecutableCommand.INSTANCE; + } + + /** + * @generated + */ + protected final Command getGEFWrapper(ICommand cmd) { + return new ICommandProxy(cmd); + } + + /** + * Returns editing domain from the host edit part. + * @generated + */ + protected TransactionalEditingDomain getEditingDomain() { + return ((IGraphicalEditPart) getHost()).getEditingDomain(); + } + + /** + * Clean all shortcuts to the host element from the same diagram + * @generated + */ + protected void addDestroyShortcutsCommand(ICompositeCommand cmd, View view) { + assert view.getEAnnotation("Shortcut") == null; //$NON-NLS-1$ + for (Iterator it = view.getDiagram().getChildren().iterator(); it + .hasNext();) { + View nextView = (View) it.next(); + if (nextView.getEAnnotation("Shortcut") == null || !nextView.isSetElement() || nextView.getElement() != view.getElement()) { //$NON-NLS-1$ + continue; + } + cmd.add(new DeleteCommand(getEditingDomain(), nextView)); + } + } + + /** + * @generated + */ + public static LinkConstraints getLinkConstraints() { + LinkConstraints cached = StatemachineDiagramEditorPlugin.getInstance() + .getLinkConstraints(); + if (cached == null) { + StatemachineDiagramEditorPlugin.getInstance().setLinkConstraints( + cached = new LinkConstraints()); + } + return cached; + } + + /** + * @generated + */ + public static class LinkConstraints { + + /** + * @generated + */ + LinkConstraints() { + // use static method #getLinkConstraints() to access instance + } + + /** + * @generated + */ + public boolean canCreateTransition_4001(EObject container, + Expression source, Expression target) { + return canExistTransition_4001(container, null, source, target); + } + + /** + * @generated + */ + public boolean canExistTransition_4001(EObject container, + Expression linkInstance, Expression source, Expression target) { + return true; + } + } + +} + diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/policies/StatemachineCanonicalEditPolicy.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/policies/StatemachineCanonicalEditPolicy.java new file mode 100644 index 00000000..1b4962d8 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/policies/StatemachineCanonicalEditPolicy.java @@ -0,0 +1,435 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.edit.policies; + +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; + +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EStructuralFeature; +import org.eclipse.gef.EditPart; +import org.eclipse.gef.commands.Command; +import org.eclipse.gmf.runtime.diagram.core.util.ViewUtil; +import org.eclipse.gmf.runtime.diagram.ui.commands.DeferredLayoutCommand; +import org.eclipse.gmf.runtime.diagram.ui.commands.ICommandProxy; +import org.eclipse.gmf.runtime.diagram.ui.commands.SetViewMutabilityCommand; +import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart; +import org.eclipse.gmf.runtime.diagram.ui.editpolicies.CanonicalEditPolicy; +import org.eclipse.gmf.runtime.diagram.ui.requests.CreateConnectionViewRequest; +import org.eclipse.gmf.runtime.diagram.ui.requests.CreateViewRequest; +import org.eclipse.gmf.runtime.diagram.ui.requests.CreateViewRequest.ViewDescriptor; +import org.eclipse.gmf.runtime.diagram.ui.requests.RequestConstants; +import org.eclipse.gmf.runtime.emf.core.util.EObjectAdapter; +import org.eclipse.gmf.runtime.emf.type.core.requests.CreateElementRequest; +import org.eclipse.gmf.runtime.notation.Diagram; +import org.eclipse.gmf.runtime.notation.Edge; +import org.eclipse.gmf.runtime.notation.Node; +import org.eclipse.gmf.runtime.notation.View; +import org.eclipse.gmf.tooling.runtime.update.UpdaterLinkDescriptor; +import de.darmstadt.tu.crossing.crySL.CrySLPackage; +import de.darmstadt.tu.crossing.crySL.Event; +import de.darmstadt.tu.crossing.crySL.Expression; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.OrderEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.StateEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.TransitionEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramUpdater; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineLinkDescriptor; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineNodeDescriptor; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry; +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineElementTypes; + +/** + * @generated + */ +public class StatemachineCanonicalEditPolicy extends CanonicalEditPolicy { + + public Domain2Notation domain2NotationMap = new Domain2Notation(); + public EObject initStateObject; + + + /** + * @generated + */ + protected void refreshOnActivate() { + // Need to activate editpart children before invoking the canonical refresh for + // EditParts to add event listeners + List c = getHost().getChildren(); + for (int i = 0; i < c.size(); i++) { + ((EditPart) c.get(i)).activate(); + } + super.refreshOnActivate(); + } + + /** + * @generated + */ + protected EStructuralFeature getFeatureToSynchronize() { + return CrySLPackage.eINSTANCE.getDomainmodel_JavaType(); + } + + /** + * @generated + */ + @SuppressWarnings("rawtypes") + protected List getSemanticChildrenList() { + View viewObject = (View) getHost().getModel(); + LinkedList result = new LinkedList(); + List childDescriptors = StatemachineDiagramUpdater.getStatemachine_1000SemanticChildren(viewObject); + for (StatemachineNodeDescriptor d : childDescriptors) { + if(!(d.getModelElement().eContainer() == null)) { + result.add(d.getModelElement()); + }else { + result.add(initStateObject); + } + } + + return result; + } + + /** + * @generated + */ + protected boolean isOrphaned(Collection semanticChildren, final View view) { + return isMyDiagramElement(view) && !semanticChildren.contains(view.getElement()); + } + + /** + * @generated + */ + private boolean isMyDiagramElement(View view) { + return StateEditPart.VISUAL_ID == StatemachineVisualIDRegistry.getVisualID(view); + } + + /** + * @generated + */ + protected void refreshSemantic() { + if (resolveSemanticElement() == null) { + return; + } + LinkedList createdViews = new LinkedList(); + List childDescriptors = StatemachineDiagramUpdater + .getStatemachine_1000SemanticChildren((View) getHost().getModel()); + if(initStateObject!= null) { + for (StatemachineNodeDescriptor d : childDescriptors) { + if((d.getModelElement().eContainer() == null)) { + childDescriptors.remove(d); + } + } + int visualID = StatemachineVisualIDRegistry.getNodeVisualID(domain2NotationMap.get(initStateObject), initStateObject); + childDescriptors.add(new StatemachineNodeDescriptor(initStateObject, visualID )); + } + LinkedList orphaned = new LinkedList(); + // we care to check only views we recognize as ours + LinkedList knownViewChildren = new LinkedList(); + for (View v : getViewChildren()) { + if (isMyDiagramElement(v)) { + knownViewChildren.add(v); + } + } + // alternative to #cleanCanonicalSemanticChildren(getViewChildren(), + // semanticChildren) + // + // iteration happens over list of desired semantic elements, trying to find best + // matching View, while original CEP + // iterates views, potentially losing view (size/bounds) information - i.e. if + // there are few views to reference same EObject, only last one + // to answer isOrphaned == true will be used for the domain element + // representation, see #cleanCanonicalSemanticChildren() + for (Iterator descriptorsIterator = childDescriptors.iterator(); descriptorsIterator + .hasNext();) { + StatemachineNodeDescriptor next = descriptorsIterator.next(); + String hint = StatemachineVisualIDRegistry.getType(next.getVisualID()); + LinkedList perfectMatch = new LinkedList(); // both semanticElement and hint match that of + // NodeDescriptor + for (View childView : getViewChildren()) { + EObject semanticElement = childView.getElement(); + if (next.getModelElement().equals(semanticElement)) { + if (hint.equals(childView.getType())) { + perfectMatch.add(childView); + // actually, can stop iteration over view children here, but + // may want to use not the first view but last one as a 'real' match (the way + // original CEP does + // with its trick with viewToSemanticMap inside #cleanCanonicalSemanticChildren + } + } + } + if (perfectMatch.size() > 0) { + descriptorsIterator.remove(); // precise match found no need to create anything for the NodeDescriptor + // use only one view (first or last?), keep rest as orphaned for further + // consideration + knownViewChildren.remove(perfectMatch.getFirst()); + } + } + // those left in knownViewChildren are subject to removal - they are our diagram + // elements we didn't find match to, + // or those we have potential matches to, and thus need to be recreated, + // preserving size/location information. + orphaned.addAll(knownViewChildren); + // + ArrayList viewDescriptors = new ArrayList( + childDescriptors.size()); + for (StatemachineNodeDescriptor next : childDescriptors) { + String hint = StatemachineVisualIDRegistry.getType(next.getVisualID()); + IAdaptable elementAdapter = new CanonicalElementAdapter(next.getModelElement(), hint); + CreateViewRequest.ViewDescriptor descriptor = new CreateViewRequest.ViewDescriptor(elementAdapter, + Node.class, hint, ViewUtil.APPEND, false, host().getDiagramPreferencesHint()); + viewDescriptors.add(descriptor); + } + + boolean changed = deleteViews(orphaned.iterator()); + // + CreateViewRequest request = getCreateViewRequest(viewDescriptors); + Command cmd = getCreateViewCommand(request); + if (cmd != null && cmd.canExecute()) { + SetViewMutabilityCommand.makeMutable(new EObjectAdapter(host().getNotationView())).execute(); + executeCommand(cmd); + if (domain2NotationMap.size()==0) { + ViewDescriptor descriptor = request.getViewDescriptors().get(0); + View initView = getView(descriptor); + initStateObject = initView.getElement(); + domain2NotationMap.putView(childDescriptors.get(0).getModelElement(), initView); + } + @SuppressWarnings("unchecked") + List nl = (List) request.getNewObject(); + createdViews.addAll(nl); + } + if (changed || createdViews.size() > 0) { + postProcessRefreshSemantic(createdViews); + } + Collection createdConnectionViews = refreshConnections(initStateObject); + + if (createdViews.size() > 1) { + // perform a layout of the container + DeferredLayoutCommand layoutCmd = new DeferredLayoutCommand(host().getEditingDomain(), createdViews, + host()); + executeCommand(new ICommandProxy(layoutCmd)); + } + + createdViews.addAll(createdConnectionViews); + + makeViewsImmutable(createdViews); + } + + public View getView(ViewDescriptor descriptor) { + + for (Field f : descriptor.getClass().getDeclaredFields()) { + try { + if (f.getName().equals("view")) { + f.setAccessible(true); + View view = (View) f.get(descriptor); + return view; + } + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + } + return null; + + } + + /** + * @generated + */ + private Collection refreshConnections(EObject InitialState) { + Collection linkDescriptors = collectAllLinks(getDiagram(), domain2NotationMap, + InitialState); + Collection existingLinks = new LinkedList(getDiagram().getEdges()); + for (Iterator linksIterator = existingLinks.iterator(); linksIterator.hasNext();) { + Edge nextDiagramLink = (Edge) linksIterator.next(); + int diagramLinkVisualID = StatemachineVisualIDRegistry.getVisualID(nextDiagramLink); + if (diagramLinkVisualID == -1) { + if (nextDiagramLink.getSource() != null && nextDiagramLink.getTarget() != null) { + linksIterator.remove(); + } + continue; + } + EObject diagramLinkObject = nextDiagramLink.getElement(); + EObject diagramLinkSrc = nextDiagramLink.getSource().getElement(); + EObject diagramLinkDst = nextDiagramLink.getTarget().getElement(); + for (Iterator linkDescriptorsIterator = linkDescriptors + .iterator(); linkDescriptorsIterator.hasNext();) { + StatemachineLinkDescriptor nextLinkDescriptor = linkDescriptorsIterator.next(); + if (diagramLinkObject == nextLinkDescriptor.getModelElement() + && diagramLinkSrc == nextLinkDescriptor.getSource() + && diagramLinkDst == nextLinkDescriptor.getDestination() + && diagramLinkVisualID == nextLinkDescriptor.getVisualID()) { + linksIterator.remove(); + linkDescriptorsIterator.remove(); + break; + } + } + } + deleteViews(existingLinks.iterator()); + return createConnections(linkDescriptors, domain2NotationMap); + } + + /** + * @generated + */ + private Collection collectAllLinks(View view, Domain2Notation domain2NotationMap, + EObject initialState) { + if (!OrderEditPart.MODEL_ID.equals(StatemachineVisualIDRegistry.getModelID(view))) { + return Collections.emptyList(); + } + LinkedList result = new LinkedList(); + switch (StatemachineVisualIDRegistry.getVisualID(view)) { + case OrderEditPart.VISUAL_ID: { + if (!domain2NotationMap.containsKey(view.getElement())) { + result.addAll(StatemachineDiagramUpdater.getStatemachine_1000ContainedLinks(view)); + Expression src = (Expression) initialState; + Expression dst = (Expression) result.get(0).getDestination(); + Event label = (Event) result.get(0).getModelElement(); + StatemachineLinkDescriptor initialLinkDescriptor = new StatemachineLinkDescriptor(src, dst, label, + StatemachineElementTypes.Transition_4001, TransitionEditPart.VISUAL_ID); + result.set(0, initialLinkDescriptor); + } + + domain2NotationMap.putView(view.getElement(), view); + // View initStateView = view.getDiagram(); + // domain2NotationMap.putView(initStateView.getElement(),view); + break; + } + case StateEditPart.VISUAL_ID: { + if (!domain2NotationMap.containsKey(view.getElement())) { + result.addAll(StatemachineDiagramUpdater.getState_2001ContainedLinks(view)); + } + domain2NotationMap.putView(view.getElement(), view); + break; + } + case TransitionEditPart.VISUAL_ID: { + if (!domain2NotationMap.containsKey(view.getElement())) { + result.addAll(StatemachineDiagramUpdater.getTransition_4001ContainedLinks(view)); + } + domain2NotationMap.putView(view.getElement(), view); + break; + } + } + for ( + + Iterator children = view.getChildren().iterator(); children.hasNext();) { + result.addAll(collectAllLinks((View) children.next(), domain2NotationMap, initialState)); + } + for (Iterator edges = view.getSourceEdges().iterator(); edges.hasNext();) { + result.addAll(collectAllLinks((View) edges.next(), domain2NotationMap, initialState)); + } + return result; + } + + /** + * @generated + */ + private Collection createConnections(Collection linkDescriptors, + Domain2Notation domain2NotationMap) { + LinkedList adapters = new LinkedList(); + for (StatemachineLinkDescriptor nextLinkDescriptor : linkDescriptors) { + EditPart sourceEditPart = getSourceEditPart(nextLinkDescriptor, domain2NotationMap); + EditPart targetEditPart = getTargetEditPart(nextLinkDescriptor, domain2NotationMap); + if (sourceEditPart == null || targetEditPart == null) { + continue; + } + CreateConnectionViewRequest.ConnectionViewDescriptor descriptor = new CreateConnectionViewRequest.ConnectionViewDescriptor( + nextLinkDescriptor.getSemanticAdapter(), + StatemachineVisualIDRegistry.getType(nextLinkDescriptor.getVisualID()), ViewUtil.APPEND, false, + ((IGraphicalEditPart) getHost()).getDiagramPreferencesHint()); + CreateConnectionViewRequest ccr = new CreateConnectionViewRequest(descriptor); + ccr.setType(RequestConstants.REQ_CONNECTION_START); + ccr.setSourceEditPart(sourceEditPart); + sourceEditPart.getCommand(ccr); + ccr.setTargetEditPart(targetEditPart); + ccr.setType(RequestConstants.REQ_CONNECTION_END); + Command cmd = targetEditPart.getCommand(ccr); + if (cmd != null && cmd.canExecute()) { + executeCommand(cmd); + IAdaptable viewAdapter = (IAdaptable) ccr.getNewObject(); + if (viewAdapter != null) { + adapters.add(viewAdapter); + } + } + } + return adapters; + } + + /** + * @generated + */ + private EditPart getEditPart(EObject domainModelElement, Domain2Notation domain2NotationMap) { + View view = (View) domain2NotationMap.get(domainModelElement); + if (view != null) { + return (EditPart) getHost().getViewer().getEditPartRegistry().get(view); + } else { + + } + return null; + } + + /** + * @generated + */ + private Diagram getDiagram() { + return ((View) getHost().getModel()).getDiagram(); + } + + /** + * @generated + */ + private EditPart getSourceEditPart(UpdaterLinkDescriptor descriptor, Domain2Notation domain2NotationMap) { + return getEditPart(descriptor.getSource(), domain2NotationMap); + } + + /** + * @generated + */ + private EditPart getTargetEditPart(UpdaterLinkDescriptor descriptor, Domain2Notation domain2NotationMap) { + return getEditPart(descriptor.getDestination(), domain2NotationMap); + } + + /** + * @generated + */ + protected final EditPart getHintedEditPart(EObject domainModelElement, Domain2Notation domain2NotationMap, + int hintVisualId) { + View view = (View) domain2NotationMap.getHinted(domainModelElement, + StatemachineVisualIDRegistry.getType(hintVisualId)); + if (view != null) { + return (EditPart) getHost().getViewer().getEditPartRegistry().get(view); + } + return null; + } + + /** + * @generated + */ + @SuppressWarnings("serial") + public + static class Domain2Notation extends HashMap { + /** + * @generated + */ + public boolean containsDomainElement(EObject domainElement) { + return this.containsKey(domainElement); + } + + /** + * @generated + */ + public View getHinted(EObject domainEObject, String hint) { + return this.get(domainEObject); + } + + /** + * @generated + */ + public void putView(EObject domainElement, View view) { + if (!containsKey(view.getElement())) { + this.put(domainElement, view); + } + } + + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/policies/StatemachineItemSemanticEditPolicy.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/policies/StatemachineItemSemanticEditPolicy.java new file mode 100644 index 00000000..31dc3808 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/policies/StatemachineItemSemanticEditPolicy.java @@ -0,0 +1,57 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.edit.policies; + +import org.eclipse.emf.transaction.TransactionalEditingDomain; +import org.eclipse.gef.commands.Command; +import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart; +import org.eclipse.gmf.runtime.emf.commands.core.commands.DuplicateEObjectsCommand; +import org.eclipse.gmf.runtime.emf.type.core.requests.CreateElementRequest; +import org.eclipse.gmf.runtime.emf.type.core.requests.DuplicateElementsRequest; + +import de.darmstadt.tu.crossing.statemachine.diagram.edit.commands.StateCreateCommand; +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineElementTypes; + +/** + * @generated + */ +public class StatemachineItemSemanticEditPolicy extends StatemachineBaseItemSemanticEditPolicy { + + /** + * @generated + */ + public StatemachineItemSemanticEditPolicy() { + super(StatemachineElementTypes.Statemachine_1000); + } + + /** + * @generated + */ + protected Command getCreateCommand(CreateElementRequest req) { + if (StatemachineElementTypes.State_2001 == req.getElementType()) { + return getGEFWrapper(new StateCreateCommand(req)); + } + return super.getCreateCommand(req); + } + + /** + * @generated + */ + protected Command getDuplicateCommand(DuplicateElementsRequest req) { + TransactionalEditingDomain editingDomain = ((IGraphicalEditPart) getHost()).getEditingDomain(); + return getGEFWrapper(new DuplicateAnythingCommand(editingDomain, req)); + } + + /** + * @generated + */ + private static class DuplicateAnythingCommand extends DuplicateEObjectsCommand { + + /** + * @generated + */ + public DuplicateAnythingCommand(TransactionalEditingDomain editingDomain, DuplicateElementsRequest req) { + super(editingDomain, req.getLabel(), req.getElementsToBeDuplicated(), req.getAllDuplicatedElementsMap()); + } + + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/policies/StatemachineTextSelectionEditPolicy.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/policies/StatemachineTextSelectionEditPolicy.java new file mode 100644 index 00000000..24ded689 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/policies/StatemachineTextSelectionEditPolicy.java @@ -0,0 +1,209 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.edit.policies; + +import org.eclipse.draw2d.ColorConstants; +import org.eclipse.draw2d.Figure; +import org.eclipse.draw2d.FigureListener; +import org.eclipse.draw2d.Graphics; +import org.eclipse.draw2d.IFigure; +import org.eclipse.draw2d.Label; +import org.eclipse.draw2d.RectangleFigure; +import org.eclipse.draw2d.geometry.Rectangle; +import org.eclipse.gef.editpolicies.SelectionEditPolicy; +import org.eclipse.gmf.runtime.draw2d.ui.figures.WrappingLabel; +import org.eclipse.gmf.tooling.runtime.edit.policies.labels.IRefreshableFeedbackEditPolicy; + +/** + * @generated + */ +public class StatemachineTextSelectionEditPolicy extends SelectionEditPolicy implements IRefreshableFeedbackEditPolicy { + + /** + * @generated + */ + private IFigure selectionFeedbackFigure; + + /** + * @generated + */ + private IFigure focusFeedbackFigure; + + /** + * @generated + */ + private FigureListener hostPositionListener; + + /** + * @generated + */ + protected void showPrimarySelection() { + if (getHostFigure() instanceof WrappingLabel) { + ((WrappingLabel) getHostFigure()).setSelected(true); + ((WrappingLabel) getHostFigure()).setFocus(true); + } else { + showSelection(); + showFocus(); + } + } + + /** + * @generated + */ + protected void showSelection() { + if (getHostFigure() instanceof WrappingLabel) { + ((WrappingLabel) getHostFigure()).setSelected(true); + ((WrappingLabel) getHostFigure()).setFocus(false); + } else { + hideSelection(); + addFeedback(selectionFeedbackFigure = createSelectionFeedbackFigure()); + getHostFigure().addFigureListener(getHostPositionListener()); + refreshSelectionFeedback(); + hideFocus(); + } + } + + /** + * @generated + */ + protected void hideSelection() { + if (getHostFigure() instanceof WrappingLabel) { + ((WrappingLabel) getHostFigure()).setSelected(false); + ((WrappingLabel) getHostFigure()).setFocus(false); + } else { + if (selectionFeedbackFigure != null) { + removeFeedback(selectionFeedbackFigure); + getHostFigure().removeFigureListener(getHostPositionListener()); + selectionFeedbackFigure = null; + } + hideFocus(); + } + } + + /** + * @generated + */ + protected void showFocus() { + if (getHostFigure() instanceof WrappingLabel) { + ((WrappingLabel) getHostFigure()).setFocus(true); + } else { + hideFocus(); + addFeedback(focusFeedbackFigure = createFocusFeedbackFigure()); + refreshFocusFeedback(); + } + } + + /** + * @generated + */ + protected void hideFocus() { + if (getHostFigure() instanceof WrappingLabel) { + ((WrappingLabel) getHostFigure()).setFocus(false); + } else { + if (focusFeedbackFigure != null) { + removeFeedback(focusFeedbackFigure); + focusFeedbackFigure = null; + } + } + } + + /** + * @generated + */ + protected Rectangle getFeedbackBounds() { + Rectangle bounds; + if (getHostFigure() instanceof Label) { + bounds = ((Label) getHostFigure()).getTextBounds(); + bounds.intersect(getHostFigure().getBounds()); + } else { + bounds = getHostFigure().getBounds().getCopy(); + } + getHostFigure().getParent().translateToAbsolute(bounds); + getFeedbackLayer().translateToRelative(bounds); + return bounds; + } + + /** + * @generated + */ + protected IFigure createSelectionFeedbackFigure() { + if (getHostFigure() instanceof Label) { + Label feedbackFigure = new Label(); + feedbackFigure.setOpaque(true); + feedbackFigure.setBackgroundColor(ColorConstants.menuBackgroundSelected); + feedbackFigure.setForegroundColor(ColorConstants.menuForegroundSelected); + return feedbackFigure; + } else { + RectangleFigure feedbackFigure = new RectangleFigure(); + feedbackFigure.setFill(false); + return feedbackFigure; + } + } + + /** + * @generated + */ + protected IFigure createFocusFeedbackFigure() { + return new Figure() { + + protected void paintFigure(Graphics graphics) { + graphics.drawFocus(getBounds().getResized(-1, -1)); + } + }; + } + + /** + * @generated + */ + protected void updateLabel(Label target) { + Label source = (Label) getHostFigure(); + target.setText(source.getText()); + target.setTextAlignment(source.getTextAlignment()); + target.setFont(source.getFont()); + } + + /** + * @generated + */ + protected void refreshSelectionFeedback() { + if (selectionFeedbackFigure != null) { + if (selectionFeedbackFigure instanceof Label) { + updateLabel((Label) selectionFeedbackFigure); + selectionFeedbackFigure.setBounds(getFeedbackBounds()); + } else { + selectionFeedbackFigure.setBounds(getFeedbackBounds().expand(5, 5)); + } + } + } + + /** + * @generated + */ + protected void refreshFocusFeedback() { + if (focusFeedbackFigure != null) { + focusFeedbackFigure.setBounds(getFeedbackBounds()); + } + } + + /** + * @generated + */ + @Override + public void refreshFeedback() { + refreshSelectionFeedback(); + refreshFocusFeedback(); + } + + /** + * @generated + */ + private FigureListener getHostPositionListener() { + if (hostPositionListener == null) { + hostPositionListener = new FigureListener() { + public void figureMoved(IFigure source) { + refreshFeedback(); + } + }; + } + return hostPositionListener; + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/policies/TransitionItemSemanticEditPolicy.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/policies/TransitionItemSemanticEditPolicy.java new file mode 100644 index 00000000..286fc20a --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/edit/policies/TransitionItemSemanticEditPolicy.java @@ -0,0 +1,29 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.edit.policies; + + +import org.eclipse.gef.commands.Command; +import org.eclipse.gmf.runtime.emf.type.core.commands.DestroyElementCommand; +import org.eclipse.gmf.runtime.emf.type.core.requests.DestroyElementRequest; + +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineElementTypes; + +/** + * @generated + */ +public class TransitionItemSemanticEditPolicy extends StatemachineBaseItemSemanticEditPolicy { + + /** + * @generated + */ + public TransitionItemSemanticEditPolicy() { + super(StatemachineElementTypes.Transition_4001); + } + + /** + * @generated + */ + protected Command getDestroyElementCommand(DestroyElementRequest req) { + return getGEFWrapper(new DestroyElementCommand(req)); + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineAbstractNavigatorItem.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineAbstractNavigatorItem.java new file mode 100644 index 00000000..0645c3ed --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineAbstractNavigatorItem.java @@ -0,0 +1,58 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.navigator; + +import org.eclipse.core.runtime.IAdapterFactory; +import org.eclipse.core.runtime.Platform; +import org.eclipse.core.runtime.PlatformObject; +import org.eclipse.ui.views.properties.tabbed.ITabbedPropertySheetPageContributor; + +/** + * @generated + */ +public abstract class StatemachineAbstractNavigatorItem extends PlatformObject { + + /** + * @generated + */ + static { + final Class[] supportedTypes = new Class[] { ITabbedPropertySheetPageContributor.class }; + final ITabbedPropertySheetPageContributor propertySheetPageContributor = new ITabbedPropertySheetPageContributor() { + public String getContributorId() { + return "de.darmstadt.tu.crossing.CrySL.statemachine.diagram"; //$NON-NLS-1$ + } + }; + Platform.getAdapterManager().registerAdapters(new IAdapterFactory() { + + public Object getAdapter(Object adaptableObject, Class adapterType) { + if (adaptableObject instanceof de.darmstadt.tu.crossing.statemachine.diagram.navigator.StatemachineAbstractNavigatorItem + && adapterType == ITabbedPropertySheetPageContributor.class) { + return propertySheetPageContributor; + } + return null; + } + + public Class[] getAdapterList() { + return supportedTypes; + } + }, de.darmstadt.tu.crossing.statemachine.diagram.navigator.StatemachineAbstractNavigatorItem.class); + } + + /** + * @generated + */ + private Object myParent; + + /** + * @generated + */ + protected StatemachineAbstractNavigatorItem(Object parent) { + myParent = parent; + } + + /** + * @generated + */ + public Object getParent() { + return myParent; + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineDomainNavigatorContentProvider.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineDomainNavigatorContentProvider.java new file mode 100644 index 00000000..d4d3d86a --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineDomainNavigatorContentProvider.java @@ -0,0 +1,232 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.navigator; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; + +import org.eclipse.core.resources.IFile; +import org.eclipse.emf.common.util.URI; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain; +import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider; +import org.eclipse.emf.transaction.TransactionalEditingDomain; +import org.eclipse.emf.workspace.util.WorkspaceSynchronizer; +import org.eclipse.gmf.runtime.emf.core.GMFEditingDomainFactory; +import org.eclipse.jface.viewers.Viewer; +import org.eclipse.ui.IMemento; +import org.eclipse.ui.navigator.ICommonContentExtensionSite; +import org.eclipse.ui.navigator.ICommonContentProvider; + +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin; + +/** + * @generated + */ +public class StatemachineDomainNavigatorContentProvider implements + ICommonContentProvider { + + /** + * @generated + */ + private AdapterFactoryContentProvider myAdapterFctoryContentProvier; + + /** + * @generated + */ + private static final Object[] EMPTY_ARRAY = new Object[0]; + + /** + * @generated + */ + private Viewer myViewer; + + /** + * @generated + */ + private AdapterFactoryEditingDomain myEditingDomain; + + /** + * @generated + */ + private WorkspaceSynchronizer myWorkspaceSynchronizer; + + /** + * @generated + */ + private Runnable myViewerRefreshRunnable; + + /** + * @generated + */ + public StatemachineDomainNavigatorContentProvider() { + myAdapterFctoryContentProvier = new AdapterFactoryContentProvider( + StatemachineDiagramEditorPlugin.getInstance() + .getItemProvidersAdapterFactory()); + TransactionalEditingDomain editingDomain = GMFEditingDomainFactory.INSTANCE + .createEditingDomain(); + myEditingDomain = (AdapterFactoryEditingDomain) editingDomain; + myEditingDomain.setResourceToReadOnlyMap(new HashMap() { + public Object get(Object key) { + if (!containsKey(key)) { + put(key, Boolean.TRUE); + } + return super.get(key); + } + }); + myViewerRefreshRunnable = new Runnable() { + public void run() { + if (myViewer != null) { + myViewer.refresh(); + } + } + }; + myWorkspaceSynchronizer = new WorkspaceSynchronizer(editingDomain, + new WorkspaceSynchronizer.Delegate() { + public void dispose() { + } + + public boolean handleResourceChanged(final Resource resource) { + unloadAllResources(); + asyncRefresh(); + return true; + } + + public boolean handleResourceDeleted(Resource resource) { + unloadAllResources(); + asyncRefresh(); + return true; + } + + public boolean handleResourceMoved(Resource resource, + final URI newURI) { + unloadAllResources(); + asyncRefresh(); + return true; + } + }); + } + + /** + * @generated + */ + public void dispose() { + myWorkspaceSynchronizer.dispose(); + myWorkspaceSynchronizer = null; + myViewerRefreshRunnable = null; + myViewer = null; + unloadAllResources(); + ((TransactionalEditingDomain) myEditingDomain).dispose(); + myEditingDomain = null; + } + + /** + * @generated + */ + public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { + myViewer = viewer; + } + + /** + * @generated + */ + void unloadAllResources() { + for (Resource nextResource : myEditingDomain.getResourceSet() + .getResources()) { + nextResource.unload(); + } + } + + /** + * @generated + */ + void asyncRefresh() { + if (myViewer != null && !myViewer.getControl().isDisposed()) { + myViewer.getControl().getDisplay() + .asyncExec(myViewerRefreshRunnable); + } + } + + /** + * @generated + */ + public Object[] getElements(Object inputElement) { + return getChildren(inputElement); + } + + /** + * @generated + */ + public void restoreState(IMemento aMemento) { + } + + /** + * @generated + */ + public void saveState(IMemento aMemento) { + } + + /** + * @generated + */ + public void init(ICommonContentExtensionSite aConfig) { + } + + /** + * @generated + */ + public Object[] getChildren(Object parentElement) { + if (parentElement instanceof IFile) { + IFile file = (IFile) parentElement; + URI fileURI = URI.createPlatformResourceURI(file.getFullPath() + .toString(), true); + Resource resource = myEditingDomain.getResourceSet().getResource( + fileURI, true); + return wrapEObjects( + myAdapterFctoryContentProvier.getChildren(resource), + parentElement); + } + + if (parentElement instanceof StatemachineDomainNavigatorItem) { + return wrapEObjects( + myAdapterFctoryContentProvier.getChildren(((StatemachineDomainNavigatorItem) parentElement) + .getEObject()), parentElement); + } + return EMPTY_ARRAY; + } + + /** + * @generated + */ + public Object[] wrapEObjects(Object[] objects, Object parentElement) { + Collection result = new ArrayList(); + for (int i = 0; i < objects.length; i++) { + if (objects[i] instanceof EObject) { + result.add(new StatemachineDomainNavigatorItem( + (EObject) objects[i], parentElement, + myAdapterFctoryContentProvier)); + } + } + return result.toArray(); + } + + /** + * @generated + */ + public Object getParent(Object element) { + if (element instanceof StatemachineAbstractNavigatorItem) { + StatemachineAbstractNavigatorItem abstractNavigatorItem = (StatemachineAbstractNavigatorItem) element; + return abstractNavigatorItem.getParent(); + } + return null; + } + + /** + * @generated + */ + public boolean hasChildren(Object element) { + return element instanceof IFile || getChildren(element).length > 0; + } + +} + diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineDomainNavigatorItem.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineDomainNavigatorItem.java new file mode 100644 index 00000000..b5d515ba --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineDomainNavigatorItem.java @@ -0,0 +1,109 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.navigator; + +import org.eclipse.core.runtime.IAdapterFactory; +import org.eclipse.core.runtime.Platform; +import org.eclipse.core.runtime.PlatformObject; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.ui.views.properties.IPropertySource; +import org.eclipse.ui.views.properties.IPropertySourceProvider; + +/** + * @generated + */ +public class StatemachineDomainNavigatorItem extends PlatformObject { + + /** + * @generated + */ + static { + final Class[] supportedTypes = new Class[] { EObject.class, IPropertySource.class }; + Platform.getAdapterManager().registerAdapters(new IAdapterFactory() { + + public Object getAdapter(Object adaptableObject, Class adapterType) { + if (adaptableObject instanceof de.darmstadt.tu.crossing.statemachine.diagram.navigator.StatemachineDomainNavigatorItem) { + de.darmstadt.tu.crossing.statemachine.diagram.navigator.StatemachineDomainNavigatorItem domainNavigatorItem = (de.darmstadt.tu.crossing.statemachine.diagram.navigator.StatemachineDomainNavigatorItem) adaptableObject; + EObject eObject = domainNavigatorItem.getEObject(); + if (adapterType == EObject.class) { + return eObject; + } + if (adapterType == IPropertySource.class) { + return domainNavigatorItem.getPropertySourceProvider().getPropertySource(eObject); + } + } + + return null; + } + + public Class[] getAdapterList() { + return supportedTypes; + } + }, de.darmstadt.tu.crossing.statemachine.diagram.navigator.StatemachineDomainNavigatorItem.class); + } + + /** + * @generated + */ + private Object myParent; + + /** + * @generated + */ + private EObject myEObject; + + /** + * @generated + */ + private IPropertySourceProvider myPropertySourceProvider; + + /** + * @generated + */ + public StatemachineDomainNavigatorItem(EObject eObject, Object parent, + IPropertySourceProvider propertySourceProvider) { + myParent = parent; + myEObject = eObject; + myPropertySourceProvider = propertySourceProvider; + } + + /** + * @generated + */ + public Object getParent() { + return myParent; + } + + /** + * @generated + */ + public EObject getEObject() { + return myEObject; + } + + /** + * @generated + */ + public IPropertySourceProvider getPropertySourceProvider() { + return myPropertySourceProvider; + } + + /** + * @generated + */ + public boolean equals(Object obj) { + if (obj instanceof de.darmstadt.tu.crossing.statemachine.diagram.navigator.StatemachineDomainNavigatorItem) { + return EcoreUtil.getURI(getEObject()).equals(EcoreUtil.getURI( + ((de.darmstadt.tu.crossing.statemachine.diagram.navigator.StatemachineDomainNavigatorItem) obj) + .getEObject())); + } + return super.equals(obj); + } + + /** + * @generated + */ + public int hashCode() { + return EcoreUtil.getURI(getEObject()).hashCode(); + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineDomainNavigatorLabelProvider.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineDomainNavigatorLabelProvider.java new file mode 100644 index 00000000..8f61fa98 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineDomainNavigatorLabelProvider.java @@ -0,0 +1,96 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.navigator; + +import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider; +import org.eclipse.jface.viewers.ILabelProviderListener; +import org.eclipse.swt.graphics.Image; +import org.eclipse.ui.IMemento; +import org.eclipse.ui.navigator.ICommonContentExtensionSite; +import org.eclipse.ui.navigator.ICommonLabelProvider; + +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin; + +/** + * @generated + */ +public class StatemachineDomainNavigatorLabelProvider implements ICommonLabelProvider { + + /** + * @generated + */ + private AdapterFactoryLabelProvider myAdapterFactoryLabelProvider = new AdapterFactoryLabelProvider( + StatemachineDiagramEditorPlugin.getInstance().getItemProvidersAdapterFactory()); + + /** + * @generated + */ + public void init(ICommonContentExtensionSite aConfig) { + } + + /** + * @generated + */ + public Image getImage(Object element) { + if (element instanceof StatemachineDomainNavigatorItem) { + return myAdapterFactoryLabelProvider.getImage(((StatemachineDomainNavigatorItem) element).getEObject()); + } + return null; + } + + /** + * @generated + */ + public String getText(Object element) { + if (element instanceof StatemachineDomainNavigatorItem) { + return myAdapterFactoryLabelProvider.getText(((StatemachineDomainNavigatorItem) element).getEObject()); + } + return null; + } + + /** + * @generated + */ + public void addListener(ILabelProviderListener listener) { + myAdapterFactoryLabelProvider.addListener(listener); + } + + /** + * @generated + */ + public void dispose() { + myAdapterFactoryLabelProvider.dispose(); + } + + /** + * @generated + */ + public boolean isLabelProperty(Object element, String property) { + return myAdapterFactoryLabelProvider.isLabelProperty(element, property); + } + + /** + * @generated + */ + public void removeListener(ILabelProviderListener listener) { + myAdapterFactoryLabelProvider.removeListener(listener); + } + + /** + * @generated + */ + public void restoreState(IMemento aMemento) { + } + + /** + * @generated + */ + public void saveState(IMemento aMemento) { + } + + /** + * @generated + */ + public String getDescription(Object anElement) { + return null; + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorActionProvider.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorActionProvider.java new file mode 100644 index 00000000..8d4290d4 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorActionProvider.java @@ -0,0 +1,169 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.navigator; + +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.emf.common.ui.URIEditorInput; +import org.eclipse.emf.common.util.URI; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.emf.workspace.util.WorkspaceSynchronizer; +import org.eclipse.gmf.runtime.notation.Diagram; +import org.eclipse.gmf.runtime.notation.View; +import org.eclipse.jface.action.Action; +import org.eclipse.jface.action.IMenuManager; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.ui.IActionBars; +import org.eclipse.ui.IEditorInput; +import org.eclipse.ui.IWorkbenchPage; +import org.eclipse.ui.PartInitException; +import org.eclipse.ui.navigator.CommonActionProvider; +import org.eclipse.ui.navigator.ICommonActionConstants; +import org.eclipse.ui.navigator.ICommonActionExtensionSite; +import org.eclipse.ui.navigator.ICommonViewerWorkbenchSite; +import org.eclipse.ui.part.FileEditorInput; + +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.OrderEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.part.Messages; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditor; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry; + +/** + * @generated + */ +public class StatemachineNavigatorActionProvider extends CommonActionProvider { + + /** + * @generated + */ + private boolean myContribute; + + /** + * @generated + */ + private OpenDiagramAction myOpenDiagramAction; + + /** + * @generated + */ + public void init(ICommonActionExtensionSite aSite) { + super.init(aSite); + if (aSite.getViewSite() instanceof ICommonViewerWorkbenchSite) { + myContribute = true; + makeActions((ICommonViewerWorkbenchSite) aSite.getViewSite()); + } else { + myContribute = false; + } + } + + /** + * @generated + */ + private void makeActions(ICommonViewerWorkbenchSite viewerSite) { + myOpenDiagramAction = new OpenDiagramAction(viewerSite); + } + + /** + * @generated + */ + public void fillActionBars(IActionBars actionBars) { + if (!myContribute) { + return; + } + IStructuredSelection selection = (IStructuredSelection) getContext().getSelection(); + myOpenDiagramAction.selectionChanged(selection); + if (myOpenDiagramAction.isEnabled()) { + actionBars.setGlobalActionHandler(ICommonActionConstants.OPEN, myOpenDiagramAction); + } + } + + /** + * @generated + */ + public void fillContextMenu(IMenuManager menu) { + } + + /** + * @generated + */ + private static class OpenDiagramAction extends Action { + + /** + * @generated + */ + private Diagram myDiagram; + + /** + * @generated + */ + private ICommonViewerWorkbenchSite myViewerSite; + + /** + * @generated + */ + public OpenDiagramAction(ICommonViewerWorkbenchSite viewerSite) { + super(Messages.NavigatorActionProvider_OpenDiagramActionName); + myViewerSite = viewerSite; + } + + /** + * @generated + */ + public final void selectionChanged(IStructuredSelection selection) { + myDiagram = null; + if (selection.size() == 1) { + Object selectedElement = selection.getFirstElement(); + if (selectedElement instanceof StatemachineNavigatorItem) { + selectedElement = ((StatemachineNavigatorItem) selectedElement).getView(); + } else if (selectedElement instanceof IAdaptable) { + selectedElement = ((IAdaptable) selectedElement).getAdapter(View.class); + } + if (selectedElement instanceof Diagram) { + Diagram diagram = (Diagram) selectedElement; + if (OrderEditPart.MODEL_ID.equals(StatemachineVisualIDRegistry.getModelID(diagram))) { + myDiagram = diagram; + } + } + } + setEnabled(myDiagram != null); + } + + /** + * @generated + */ + public void run() { + if (myDiagram == null || myDiagram.eResource() == null) { + return; + } + + IEditorInput editorInput = getEditorInput(myDiagram); + IWorkbenchPage page = myViewerSite.getPage(); + try { + page.openEditor(editorInput, StatemachineDiagramEditor.ID); + } catch (PartInitException e) { + StatemachineDiagramEditorPlugin.getInstance().logError("Exception while openning diagram", e); //$NON-NLS-1$ + } + } + + /** + * @generated + */ + private static IEditorInput getEditorInput(Diagram diagram) { + Resource diagramResource = diagram.eResource(); + for (EObject nextEObject : diagramResource.getContents()) { + if (nextEObject == diagram) { + return new FileEditorInput(WorkspaceSynchronizer.getFile(diagramResource)); + } + if (nextEObject instanceof Diagram) { + break; + } + } + URI uri = EcoreUtil.getURI(diagram); + String editorName = uri.lastSegment() + '#' + diagram.eResource().getContents().indexOf(diagram); + IEditorInput editorInput = new URIEditorInput(uri, editorName); + return editorInput; + } + + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorContentProvider.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorContentProvider.java new file mode 100644 index 00000000..0c2eba00 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorContentProvider.java @@ -0,0 +1,407 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.navigator; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.LinkedList; + +import org.eclipse.core.resources.IFile; +import org.eclipse.emf.common.util.URI; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain; +import org.eclipse.emf.transaction.TransactionalEditingDomain; +import org.eclipse.emf.workspace.util.WorkspaceSynchronizer; +import org.eclipse.gmf.runtime.emf.core.GMFEditingDomainFactory; +import org.eclipse.gmf.runtime.notation.Diagram; +import org.eclipse.gmf.runtime.notation.Edge; +import org.eclipse.gmf.runtime.notation.Node; +import org.eclipse.gmf.runtime.notation.View; +import org.eclipse.jface.viewers.Viewer; +import org.eclipse.ui.IMemento; +import org.eclipse.ui.navigator.ICommonContentExtensionSite; +import org.eclipse.ui.navigator.ICommonContentProvider; + +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.OrderEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.StateEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.TransitionEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.part.Messages; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry; + +/** + * @generated + */ +public class StatemachineNavigatorContentProvider implements ICommonContentProvider { + + /** + * @generated + */ + private static final Object[] EMPTY_ARRAY = new Object[0]; + + /** + * @generated + */ + private Viewer myViewer; + + /** + * @generated + */ + private AdapterFactoryEditingDomain myEditingDomain; + + /** + * @generated + */ + private WorkspaceSynchronizer myWorkspaceSynchronizer; + + /** + * @generated + */ + private Runnable myViewerRefreshRunnable; + + /** + * @generated + */ + @SuppressWarnings({ "unchecked", "serial", "rawtypes" }) + public StatemachineNavigatorContentProvider() { + TransactionalEditingDomain editingDomain = GMFEditingDomainFactory.INSTANCE.createEditingDomain(); + myEditingDomain = (AdapterFactoryEditingDomain) editingDomain; + myEditingDomain.setResourceToReadOnlyMap(new HashMap() { + public Object get(Object key) { + if (!containsKey(key)) { + put(key, Boolean.TRUE); + } + return super.get(key); + } + }); + myViewerRefreshRunnable = new Runnable() { + public void run() { + if (myViewer != null) { + myViewer.refresh(); + } + } + }; + myWorkspaceSynchronizer = new WorkspaceSynchronizer(editingDomain, new WorkspaceSynchronizer.Delegate() { + public void dispose() { + } + + public boolean handleResourceChanged(final Resource resource) { + unloadAllResources(); + asyncRefresh(); + return true; + } + + public boolean handleResourceDeleted(Resource resource) { + unloadAllResources(); + asyncRefresh(); + return true; + } + + public boolean handleResourceMoved(Resource resource, final URI newURI) { + unloadAllResources(); + asyncRefresh(); + return true; + } + }); + } + + /** + * @generated + */ + public void dispose() { + myWorkspaceSynchronizer.dispose(); + myWorkspaceSynchronizer = null; + myViewerRefreshRunnable = null; + myViewer = null; + unloadAllResources(); + ((TransactionalEditingDomain) myEditingDomain).dispose(); + myEditingDomain = null; + } + + /** + * @generated + */ + public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { + myViewer = viewer; + } + + /** + * @generated + */ + void unloadAllResources() { + for (Resource nextResource : myEditingDomain.getResourceSet().getResources()) { + nextResource.unload(); + } + } + + /** + * @generated + */ + void asyncRefresh() { + if (myViewer != null && !myViewer.getControl().isDisposed()) { + myViewer.getControl().getDisplay().asyncExec(myViewerRefreshRunnable); + } + } + + /** + * @generated + */ + public Object[] getElements(Object inputElement) { + return getChildren(inputElement); + } + + /** + * @generated + */ + public void restoreState(IMemento aMemento) { + } + + /** + * @generated + */ + public void saveState(IMemento aMemento) { + } + + /** + * @generated + */ + public void init(ICommonContentExtensionSite aConfig) { + } + + /** + * @generated + */ + public Object[] getChildren(Object parentElement) { + if (parentElement instanceof IFile) { + IFile file = (IFile) parentElement; + URI fileURI = URI.createPlatformResourceURI(file.getFullPath().toString(), true); + Resource resource = myEditingDomain.getResourceSet().getResource(fileURI, true); + ArrayList result = new ArrayList(); + ArrayList topViews = new ArrayList(resource.getContents().size()); + for (EObject o : resource.getContents()) { + if (o instanceof View) { + topViews.add((View) o); + } + } + result.addAll(createNavigatorItems(selectViewsByType(topViews, OrderEditPart.MODEL_ID), file, false)); + return result.toArray(); + } + + if (parentElement instanceof StatemachineNavigatorGroup) { + StatemachineNavigatorGroup group = (StatemachineNavigatorGroup) parentElement; + return group.getChildren(); + } + + if (parentElement instanceof StatemachineNavigatorItem) { + StatemachineNavigatorItem navigatorItem = (StatemachineNavigatorItem) parentElement; + if (navigatorItem.isLeaf() || !isOwnView(navigatorItem.getView())) { + return EMPTY_ARRAY; + } + return getViewChildren(navigatorItem.getView(), parentElement); + } + + return EMPTY_ARRAY; + } + + /** + * @generated + */ + private Object[] getViewChildren(View view, Object parentElement) { + switch (StatemachineVisualIDRegistry.getVisualID(view)) { + + case OrderEditPart.VISUAL_ID: { + LinkedList result = new LinkedList(); + Diagram sv = (Diagram) view; + StatemachineNavigatorGroup links = new StatemachineNavigatorGroup( + Messages.NavigatorGroupName_Statemachine_1000_links, "icons/linksNavigatorGroup.gif", //$NON-NLS-1$ + parentElement); + Collection connectedViews; + connectedViews = getChildrenByType(Collections.singleton(sv), + StatemachineVisualIDRegistry.getType(StateEditPart.VISUAL_ID)); + result.addAll(createNavigatorItems(connectedViews, parentElement, false)); + connectedViews = getDiagramLinksByType(Collections.singleton(sv), + StatemachineVisualIDRegistry.getType(TransitionEditPart.VISUAL_ID)); + links.addChildren(createNavigatorItems(connectedViews, links, false)); + if (!links.isEmpty()) { + result.add(links); + } + return result.toArray(); + } + + case StateEditPart.VISUAL_ID: { + LinkedList result = new LinkedList(); + Node sv = (Node) view; + StatemachineNavigatorGroup incominglinks = new StatemachineNavigatorGroup( + Messages.NavigatorGroupName_State_2001_incominglinks, "icons/incomingLinksNavigatorGroup.gif", //$NON-NLS-1$ + parentElement); + StatemachineNavigatorGroup outgoinglinks = new StatemachineNavigatorGroup( + Messages.NavigatorGroupName_State_2001_outgoinglinks, "icons/outgoingLinksNavigatorGroup.gif", //$NON-NLS-1$ + parentElement); + Collection connectedViews; + connectedViews = getIncomingLinksByType(Collections.singleton(sv), + StatemachineVisualIDRegistry.getType(TransitionEditPart.VISUAL_ID)); + incominglinks.addChildren(createNavigatorItems(connectedViews, incominglinks, true)); + connectedViews = getOutgoingLinksByType(Collections.singleton(sv), + StatemachineVisualIDRegistry.getType(TransitionEditPart.VISUAL_ID)); + outgoinglinks.addChildren(createNavigatorItems(connectedViews, outgoinglinks, true)); + if (!incominglinks.isEmpty()) { + result.add(incominglinks); + } + if (!outgoinglinks.isEmpty()) { + result.add(outgoinglinks); + } + return result.toArray(); + } + + case TransitionEditPart.VISUAL_ID: { + LinkedList result = new LinkedList(); + Edge sv = (Edge) view; + StatemachineNavigatorGroup target = new StatemachineNavigatorGroup( + Messages.NavigatorGroupName_Transition_4001_target, "icons/linkTargetNavigatorGroup.gif", //$NON-NLS-1$ + parentElement); + StatemachineNavigatorGroup source = new StatemachineNavigatorGroup( + Messages.NavigatorGroupName_Transition_4001_source, "icons/linkSourceNavigatorGroup.gif", //$NON-NLS-1$ + parentElement); + Collection connectedViews; + connectedViews = getLinksTargetByType(Collections.singleton(sv), + StatemachineVisualIDRegistry.getType(StateEditPart.VISUAL_ID)); + target.addChildren(createNavigatorItems(connectedViews, target, true)); + connectedViews = getLinksSourceByType(Collections.singleton(sv), + StatemachineVisualIDRegistry.getType(StateEditPart.VISUAL_ID)); + source.addChildren(createNavigatorItems(connectedViews, source, true)); + if (!target.isEmpty()) { + result.add(target); + } + if (!source.isEmpty()) { + result.add(source); + } + return result.toArray(); + } + } + return EMPTY_ARRAY; + } + + /** + * @generated + */ + private Collection getLinksSourceByType(Collection edges, String type) { + LinkedList result = new LinkedList(); + for (Edge nextEdge : edges) { + View nextEdgeSource = nextEdge.getSource(); + if (type.equals(nextEdgeSource.getType()) && isOwnView(nextEdgeSource)) { + result.add(nextEdgeSource); + } + } + return result; + } + + /** + * @generated + */ + private Collection getLinksTargetByType(Collection edges, String type) { + LinkedList result = new LinkedList(); + for (Edge nextEdge : edges) { + View nextEdgeTarget = nextEdge.getTarget(); + if (type.equals(nextEdgeTarget.getType()) && isOwnView(nextEdgeTarget)) { + result.add(nextEdgeTarget); + } + } + return result; + } + + /** + * @generated + */ + private Collection getOutgoingLinksByType(Collection nodes, String type) { + LinkedList result = new LinkedList(); + for (View nextNode : nodes) { + result.addAll(selectViewsByType(nextNode.getSourceEdges(), type)); + } + return result; + } + + /** + * @generated + */ + private Collection getIncomingLinksByType(Collection nodes, String type) { + LinkedList result = new LinkedList(); + for (View nextNode : nodes) { + result.addAll(selectViewsByType(nextNode.getTargetEdges(), type)); + } + return result; + } + + /** + * @generated + */ + private Collection getChildrenByType(Collection nodes, String type) { + LinkedList result = new LinkedList(); + for (View nextNode : nodes) { + result.addAll(selectViewsByType(nextNode.getChildren(), type)); + } + return result; + } + + /** + * @generated + */ + private Collection getDiagramLinksByType(Collection diagrams, String type) { + ArrayList result = new ArrayList(); + for (Diagram nextDiagram : diagrams) { + result.addAll(selectViewsByType(nextDiagram.getEdges(), type)); + } + return result; + } + + // TODO refactor as static method + /** + * @generated + */ + private Collection selectViewsByType(Collection views, String type) { + ArrayList result = new ArrayList(); + for (View nextView : views) { + if (type.equals(nextView.getType()) && isOwnView(nextView)) { + result.add(nextView); + } + } + return result; + } + + /** + * @generated + */ + private boolean isOwnView(View view) { + return OrderEditPart.MODEL_ID.equals(StatemachineVisualIDRegistry.getModelID(view)); + } + + /** + * @generated + */ + private Collection createNavigatorItems(Collection views, Object parent, + boolean isLeafs) { + ArrayList result = new ArrayList(views.size()); + for (View nextView : views) { + result.add(new StatemachineNavigatorItem(nextView, parent, isLeafs)); + } + return result; + } + + /** + * @generated + */ + public Object getParent(Object element) { + if (element instanceof StatemachineAbstractNavigatorItem) { + StatemachineAbstractNavigatorItem abstractNavigatorItem = (StatemachineAbstractNavigatorItem) element; + return abstractNavigatorItem.getParent(); + } + return null; + } + + /** + * @generated + */ + public boolean hasChildren(Object element) { + return element instanceof IFile || getChildren(element).length > 0; + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorGroup.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorGroup.java new file mode 100644 index 00000000..d3423a41 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorGroup.java @@ -0,0 +1,97 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.navigator; + +import java.util.Collection; +import java.util.LinkedList; + +/** + * @generated + */ +public class StatemachineNavigatorGroup extends StatemachineAbstractNavigatorItem { + + /** + * @generated + */ + private String myGroupName; + + /** + * @generated + */ + private String myIcon; + + /** + * @generated + */ + private Collection myChildren = new LinkedList(); + + /** + * @generated + */ + StatemachineNavigatorGroup(String groupName, String icon, Object parent) { + super(parent); + myGroupName = groupName; + myIcon = icon; + } + + /** + * @generated + */ + public String getGroupName() { + return myGroupName; + } + + /** + * @generated + */ + public String getIcon() { + return myIcon; + } + + /** + * @generated + */ + public Object[] getChildren() { + return myChildren.toArray(); + } + + /** + * @generated + */ + public void addChildren(Collection children) { + myChildren.addAll(children); + } + + /** + * @generated + */ + public void addChild(Object child) { + myChildren.add(child); + } + + /** + * @generated + */ + public boolean isEmpty() { + return myChildren.size() == 0; + } + + /** + * @generated + */ + public boolean equals(Object obj) { + if (obj instanceof de.darmstadt.tu.crossing.statemachine.diagram.navigator.StatemachineNavigatorGroup) { + de.darmstadt.tu.crossing.statemachine.diagram.navigator.StatemachineNavigatorGroup anotherGroup = (de.darmstadt.tu.crossing.statemachine.diagram.navigator.StatemachineNavigatorGroup) obj; + if (getGroupName().equals(anotherGroup.getGroupName())) { + return getParent().equals(anotherGroup.getParent()); + } + } + return super.equals(obj); + } + + /** + * @generated + */ + public int hashCode() { + return getGroupName().hashCode(); + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorItem.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorItem.java new file mode 100644 index 00000000..ceedff5c --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorItem.java @@ -0,0 +1,95 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.navigator; + +import org.eclipse.core.runtime.IAdapterFactory; +import org.eclipse.core.runtime.Platform; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.gmf.runtime.notation.View; + +/** + * @generated + */ +public class StatemachineNavigatorItem extends + StatemachineAbstractNavigatorItem { + + /** + * @generated + */ + static { + final Class[] supportedTypes = new Class[] { View.class, EObject.class }; + Platform.getAdapterManager().registerAdapters( + new IAdapterFactory() { + + public Object getAdapter(Object adaptableObject, + Class adapterType) { + if (adaptableObject instanceof de.darmstadt.tu.crossing.statemachine.diagram.navigator.StatemachineNavigatorItem + && (adapterType == View.class || adapterType == EObject.class)) { + return ((de.darmstadt.tu.crossing.statemachine.diagram.navigator.StatemachineNavigatorItem) adaptableObject) + .getView(); + } + return null; + } + + public Class[] getAdapterList() { + return supportedTypes; + } + }, + de.darmstadt.tu.crossing.statemachine.diagram.navigator.StatemachineNavigatorItem.class); + } + + /** + * @generated + */ + private View myView; + + /** + * @generated + */ + private boolean myLeaf = false; + + /** + * @generated + */ + public StatemachineNavigatorItem(View view, Object parent, boolean isLeaf) { + super(parent); + myView = view; + myLeaf = isLeaf; + } + + /** + * @generated + */ + public View getView() { + return myView; + } + + /** + * @generated + */ + public boolean isLeaf() { + return myLeaf; + } + + /** + * @generated + */ + public boolean equals(Object obj) { + if (obj instanceof de.darmstadt.tu.crossing.statemachine.diagram.navigator.StatemachineNavigatorItem) { + return EcoreUtil + .getURI(getView()) + .equals(EcoreUtil + .getURI(((de.darmstadt.tu.crossing.statemachine.diagram.navigator.StatemachineNavigatorItem) obj) + .getView())); + } + return super.equals(obj); + } + + /** + * @generated + */ + public int hashCode() { + return EcoreUtil.getURI(getView()).hashCode(); + } + +} + diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorLabelProvider.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorLabelProvider.java new file mode 100644 index 00000000..5d267cb7 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorLabelProvider.java @@ -0,0 +1,237 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.navigator; + +import org.eclipse.gmf.runtime.common.ui.services.parser.IParser; +import org.eclipse.gmf.runtime.common.ui.services.parser.ParserOptions; +import org.eclipse.gmf.runtime.emf.core.util.EObjectAdapter; +import org.eclipse.gmf.runtime.emf.type.core.IElementType; +import org.eclipse.gmf.runtime.notation.View; +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.jface.resource.ImageRegistry; +import org.eclipse.jface.viewers.ITreePathLabelProvider; +import org.eclipse.jface.viewers.LabelProvider; +import org.eclipse.jface.viewers.TreePath; +import org.eclipse.jface.viewers.ViewerLabel; +import org.eclipse.swt.graphics.Image; +import org.eclipse.ui.IMemento; +import org.eclipse.ui.navigator.ICommonContentExtensionSite; +import org.eclipse.ui.navigator.ICommonLabelProvider; + +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.OrderEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.StateEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.StateNameEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.TransitionEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.TransitionNameEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry; +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineElementTypes; +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineParserProvider; + +/** + * @generated + */ +public class StatemachineNavigatorLabelProvider extends LabelProvider + implements ICommonLabelProvider, ITreePathLabelProvider { + + /** + * @generated + */ + static { + StatemachineDiagramEditorPlugin.getInstance().getImageRegistry().put("Navigator?UnknownElement", //$NON-NLS-1$ + ImageDescriptor.getMissingImageDescriptor()); + StatemachineDiagramEditorPlugin.getInstance().getImageRegistry().put("Navigator?ImageNotFound", //$NON-NLS-1$ + ImageDescriptor.getMissingImageDescriptor()); + } + + /** + * @generated + */ + public void updateLabel(ViewerLabel label, TreePath elementPath) { + Object element = elementPath.getLastSegment(); + if (element instanceof StatemachineNavigatorItem + && !isOwnView(((StatemachineNavigatorItem) element).getView())) { + return; + } + label.setText(getText(element)); + label.setImage(getImage(element)); + } + + /** + * @generated + */ + public Image getImage(Object element) { + if (element instanceof StatemachineNavigatorGroup) { + StatemachineNavigatorGroup group = (StatemachineNavigatorGroup) element; + return StatemachineDiagramEditorPlugin.getInstance().getBundledImage(group.getIcon()); + } + + if (element instanceof StatemachineNavigatorItem) { + StatemachineNavigatorItem navigatorItem = (StatemachineNavigatorItem) element; + if (!isOwnView(navigatorItem.getView())) { + return super.getImage(element); + } + return getImage(navigatorItem.getView()); + } + + return super.getImage(element); + } + + /** + * @generated + */ + public Image getImage(View view) { + switch (StatemachineVisualIDRegistry.getVisualID(view)) { + case OrderEditPart.VISUAL_ID: + return getImage("Navigator?Diagram?http://www.darmstadt.de/tu/crossing/CrySL?Order", //$NON-NLS-1$ + StatemachineElementTypes.Statemachine_1000); + case StateEditPart.VISUAL_ID: + return getImage("Navigator?TopLevelNode?http://www.darmstadt.de/tu/crossing/CrySL?Expression", //$NON-NLS-1$ + StatemachineElementTypes.State_2001); + case TransitionEditPart.VISUAL_ID: + return getImage("Navigator?Link?http://www.darmstadt.de/tu/crossing/CrySL?Expression", //$NON-NLS-1$ + StatemachineElementTypes.Transition_4001); + } + return getImage("Navigator?UnknownElement", null); //$NON-NLS-1$ + } + + /** + * @generated + */ + private Image getImage(String key, IElementType elementType) { + ImageRegistry imageRegistry = StatemachineDiagramEditorPlugin.getInstance().getImageRegistry(); + Image image = imageRegistry.get(key); + if (image == null && elementType != null && StatemachineElementTypes.isKnownElementType(elementType)) { + image = StatemachineElementTypes.getImage(elementType); + imageRegistry.put(key, image); + } + + if (image == null) { + image = imageRegistry.get("Navigator?ImageNotFound"); //$NON-NLS-1$ + imageRegistry.put(key, image); + } + return image; + } + + /** + * @generated + */ + public String getText(Object element) { + if (element instanceof StatemachineNavigatorGroup) { + StatemachineNavigatorGroup group = (StatemachineNavigatorGroup) element; + return group.getGroupName(); + } + + if (element instanceof StatemachineNavigatorItem) { + StatemachineNavigatorItem navigatorItem = (StatemachineNavigatorItem) element; + if (!isOwnView(navigatorItem.getView())) { + return null; + } + return getText(navigatorItem.getView()); + } + + return super.getText(element); + } + + /** + * @generated + */ + public String getText(View view) { + if (view.getElement() != null && view.getElement().eIsProxy()) { + return getUnresolvedDomainElementProxyText(view); + } + switch (StatemachineVisualIDRegistry.getVisualID(view)) { + case OrderEditPart.VISUAL_ID: + return getStatemachine_1000Text(view); + case StateEditPart.VISUAL_ID: + return getState_2001Text(view); + case TransitionEditPart.VISUAL_ID: + return getTransition_4001Text(view); + } + return getUnknownElementText(view); + } + + /** + * @generated + */ + private String getStatemachine_1000Text(View view) { + return ""; //$NON-NLS-1$ + } + + /** + * @generated + */ + private String getState_2001Text(View view) { + IParser parser = StatemachineParserProvider.getParser(StatemachineElementTypes.State_2001, + view.getElement() != null ? view.getElement() : view, + StatemachineVisualIDRegistry.getType(StateNameEditPart.VISUAL_ID)); + if (parser != null) { + return parser.getPrintString(new EObjectAdapter(view.getElement() != null ? view.getElement() : view), + ParserOptions.NONE.intValue()); + } else { + StatemachineDiagramEditorPlugin.getInstance().logError("Parser was not found for label " + 5001); //$NON-NLS-1$ + return ""; //$NON-NLS-1$ + } + } + + /** + * @generated + */ + private String getTransition_4001Text(View view) { + IParser parser = StatemachineParserProvider.getParser(StatemachineElementTypes.Transition_4001, + view.getElement() != null ? view.getElement() : view, + StatemachineVisualIDRegistry.getType(TransitionNameEditPart.VISUAL_ID)); + if (parser != null) { + return parser.getPrintString(new EObjectAdapter(view.getElement() != null ? view.getElement() : view), + ParserOptions.NONE.intValue()); + } else { + StatemachineDiagramEditorPlugin.getInstance().logError("Parser was not found for label " + 6001); //$NON-NLS-1$ + return ""; //$NON-NLS-1$ + } + } + + /** + * @generated + */ + private String getUnknownElementText(View view) { + return ""; //$NON-NLS-1$ //$NON-NLS-2$ + } + + /** + * @generated + */ + private String getUnresolvedDomainElementProxyText(View view) { + return ""; //$NON-NLS-1$ //$NON-NLS-2$ + } + + /** + * @generated + */ + public void init(ICommonContentExtensionSite aConfig) { + } + + /** + * @generated + */ + public void restoreState(IMemento aMemento) { + } + + /** + * @generated + */ + public void saveState(IMemento aMemento) { + } + + /** + * @generated + */ + public String getDescription(Object anElement) { + return null; + } + + /** + * @generated + */ + private boolean isOwnView(View view) { + return OrderEditPart.MODEL_ID.equals(StatemachineVisualIDRegistry.getModelID(view)); + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorLinkHelper.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorLinkHelper.java new file mode 100644 index 00000000..3eb51e83 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorLinkHelper.java @@ -0,0 +1,117 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.navigator; + +import org.eclipse.core.resources.IFile; +import org.eclipse.emf.common.ui.URIEditorInput; +import org.eclipse.emf.common.util.URI; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.emf.ecore.resource.ResourceSet; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.emf.workspace.util.WorkspaceSynchronizer; +import org.eclipse.gef.EditPart; +import org.eclipse.gef.GraphicalViewer; +import org.eclipse.gmf.runtime.diagram.ui.parts.DiagramEditor; +import org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.IDiagramDocument; +import org.eclipse.gmf.runtime.notation.Diagram; +import org.eclipse.gmf.runtime.notation.View; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.viewers.StructuredSelection; +import org.eclipse.ui.IEditorInput; +import org.eclipse.ui.IEditorPart; +import org.eclipse.ui.IWorkbenchPage; +import org.eclipse.ui.navigator.ILinkHelper; +import org.eclipse.ui.part.FileEditorInput; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin; + +/** + * @generated + */ +public class StatemachineNavigatorLinkHelper implements ILinkHelper { + + /** + * @generated + */ + private static IEditorInput getEditorInput(Diagram diagram) { + Resource diagramResource = diagram.eResource(); + for (EObject nextEObject : diagramResource.getContents()) { + if (nextEObject == diagram) { + return new FileEditorInput(WorkspaceSynchronizer.getFile(diagramResource)); + } + if (nextEObject instanceof Diagram) { + break; + } + } + URI uri = EcoreUtil.getURI(diagram); + String editorName = uri.lastSegment() + '#' + diagram.eResource().getContents().indexOf(diagram); + IEditorInput editorInput = new URIEditorInput(uri, editorName); + return editorInput; + } + + /** + * @generated + */ + public IStructuredSelection findSelection(IEditorInput anInput) { + IDiagramDocument document = StatemachineDiagramEditorPlugin.getInstance().getDocumentProvider() + .getDiagramDocument(anInput); + if (document == null) { + return StructuredSelection.EMPTY; + } + Diagram diagram = document.getDiagram(); + if (diagram == null || diagram.eResource() == null) { + return StructuredSelection.EMPTY; + } + IFile file = WorkspaceSynchronizer.getFile(diagram.eResource()); + if (file != null) { + StatemachineNavigatorItem item = new StatemachineNavigatorItem(diagram, file, false); + return new StructuredSelection(item); + } + return StructuredSelection.EMPTY; + } + + /** + * @generated + */ + public void activateEditor(IWorkbenchPage aPage, IStructuredSelection aSelection) { + if (aSelection == null || aSelection.isEmpty()) { + return; + } + if (false == aSelection.getFirstElement() instanceof StatemachineAbstractNavigatorItem) { + return; + } + + StatemachineAbstractNavigatorItem abstractNavigatorItem = (StatemachineAbstractNavigatorItem) aSelection + .getFirstElement(); + View navigatorView = null; + if (abstractNavigatorItem instanceof StatemachineNavigatorItem) { + navigatorView = ((StatemachineNavigatorItem) abstractNavigatorItem).getView(); + } else if (abstractNavigatorItem instanceof StatemachineNavigatorGroup) { + StatemachineNavigatorGroup navigatorGroup = (StatemachineNavigatorGroup) abstractNavigatorItem; + if (navigatorGroup.getParent() instanceof StatemachineNavigatorItem) { + navigatorView = ((StatemachineNavigatorItem) navigatorGroup.getParent()).getView(); + } + } + if (navigatorView == null) { + return; + } + IEditorInput editorInput = getEditorInput(navigatorView.getDiagram()); + IEditorPart editor = aPage.findEditor(editorInput); + if (editor == null) { + return; + } + aPage.bringToTop(editor); + if (editor instanceof DiagramEditor) { + DiagramEditor diagramEditor = (DiagramEditor) editor; + ResourceSet diagramEditorResourceSet = diagramEditor.getEditingDomain().getResourceSet(); + EObject selectedView = diagramEditorResourceSet.getEObject(EcoreUtil.getURI(navigatorView), true); + if (selectedView == null) { + return; + } + GraphicalViewer graphicalViewer = (GraphicalViewer) diagramEditor.getAdapter(GraphicalViewer.class); + EditPart selectedEditPart = (EditPart) graphicalViewer.getEditPartRegistry().get(selectedView); + if (selectedEditPart != null) { + graphicalViewer.select(selectedEditPart); + } + } + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorSorter.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorSorter.java new file mode 100644 index 00000000..970df93c --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/navigator/StatemachineNavigatorSorter.java @@ -0,0 +1,27 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.navigator; + +import org.eclipse.jface.viewers.ViewerSorter; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry; + +/** + * @generated + */ +public class StatemachineNavigatorSorter extends ViewerSorter { + + /** + * @generated + */ + private static final int GROUP_CATEGORY = 4003; + + /** + * @generated + */ + public int category(Object element) { + if (element instanceof StatemachineNavigatorItem) { + StatemachineNavigatorItem item = (StatemachineNavigatorItem) element; + return StatemachineVisualIDRegistry.getVisualID(item.getView()); + } + return GROUP_CATEGORY; + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/parsers/MessageFormatParser.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/parsers/MessageFormatParser.java new file mode 100644 index 00000000..7148c712 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/parsers/MessageFormatParser.java @@ -0,0 +1,194 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.parsers; + +import java.text.FieldPosition; +import java.text.MessageFormat; +import java.text.ParsePosition; + +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.emf.ecore.EAttribute; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.gmf.runtime.common.core.command.ICommand; +import org.eclipse.gmf.runtime.common.ui.services.parser.IParserEditStatus; +import org.eclipse.gmf.runtime.common.ui.services.parser.ParserEditStatus; +import org.eclipse.gmf.tooling.runtime.parsers.AbstractAttributeParser; +import org.eclipse.osgi.util.NLS; + +import de.darmstadt.tu.crossing.statemachine.diagram.part.Messages; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin; + +/** + * @generated + */ +public class MessageFormatParser extends AbstractAttributeParser { + + /** + * @generated + */ + private String defaultPattern; + /** + * @generated + */ + private String defaultEditablePattern; + + /** + * @generated + */ + private MessageFormat viewProcessor; + + /** + * @generated + */ + private MessageFormat editorProcessor; + + /** + * @generated + */ + private MessageFormat editProcessor; + + /** + * @generated + */ + public MessageFormatParser(EAttribute[] features) { + super(features); + } + + /** + * @generated + */ + public MessageFormatParser(EAttribute[] features, EAttribute[] editableFeatures) { + super(features, editableFeatures); + } + + /** + * @generated + */ + protected String getDefaultPattern() { + if (defaultPattern == null) { + StringBuffer sb = new StringBuffer(); + for (int i = 0; i < features.length; i++) { + if (i > 0) { + sb.append(' '); + } + sb.append('{'); + sb.append(i); + sb.append('}'); + } + defaultPattern = sb.toString(); + } + return defaultPattern; + } + + /** + * @generated + */ + public void setViewPattern(String viewPattern) { + super.setViewPattern(viewPattern); + viewProcessor = null; + } + + /** + * @generated + */ + public void setEditorPattern(String editorPattern) { + super.setEditorPattern(editorPattern); + editorProcessor = null; + } + + /** + * @generated + */ + protected MessageFormat getViewProcessor() { + if (viewProcessor == null) { + viewProcessor = new MessageFormat(getViewPattern() == null ? getDefaultPattern() : getViewPattern()); + } + return viewProcessor; + } + + /** + * @generated + */ + protected MessageFormat getEditorProcessor() { + if (editorProcessor == null) { + editorProcessor = new MessageFormat( + getEditorPattern() == null ? getDefaultEditablePattern() : getEditorPattern()); + } + return editorProcessor; + } + + /** + * @generated + */ + protected String getDefaultEditablePattern() { + if (defaultEditablePattern == null) { + StringBuffer sb = new StringBuffer(); + for (int i = 0; i < editableFeatures.length; i++) { + if (i > 0) { + sb.append(' '); + } + sb.append('{'); + sb.append(i); + sb.append('}'); + } + defaultEditablePattern = sb.toString(); + } + return defaultEditablePattern; + } + + /** + * @generated + */ + public void setEditPattern(String editPattern) { + super.setEditPattern(editPattern); + editProcessor = null; + } + + /** + * @generated + */ + protected MessageFormat getEditProcessor() { + if (editProcessor == null) { + editProcessor = new MessageFormat( + getEditPattern() == null ? getDefaultEditablePattern() : getEditPattern()); + } + return editProcessor; + } + + /** + * @generated + */ + public String getEditString(IAdaptable adapter, int flags) { + EObject element = (EObject) adapter.getAdapter(EObject.class); + return getEditorProcessor().format(getEditableValues(element), new StringBuffer(), new FieldPosition(0)) + .toString(); + } + + /** + * @generated + */ + public IParserEditStatus isValidEditString(IAdaptable adapter, String editString) { + ParsePosition pos = new ParsePosition(0); + Object[] values = getEditProcessor().parse(editString, pos); + if (values == null) { + return new ParserEditStatus(StatemachineDiagramEditorPlugin.ID, IParserEditStatus.UNEDITABLE, + NLS.bind(Messages.MessageFormatParser_InvalidInputError, new Integer(pos.getErrorIndex()))); + } + return validateNewValues(values); + } + + /** + * @generated + */ + public ICommand getParseCommand(IAdaptable adapter, String newString, int flags) { + Object[] values = getEditProcessor().parse(newString, new ParsePosition(0)); + return getParseCommand(adapter, values, flags); + } + + /** + * @generated + */ + public String getPrintString(IAdaptable adapter, int flags) { + EObject element = (EObject) adapter.getAdapter(EObject.class); + return getViewProcessor().format(getValues(element), new StringBuffer(), new FieldPosition(0)).toString(); + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/DeleteElementAction.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/DeleteElementAction.java new file mode 100644 index 00000000..cbac281f --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/DeleteElementAction.java @@ -0,0 +1,18 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import org.eclipse.gmf.tooling.runtime.actions.DefaultDeleteElementAction; +import org.eclipse.ui.IWorkbenchPart; + +/** + * @generated + */ +public class DeleteElementAction extends DefaultDeleteElementAction { + + /** + * @generated + */ + public DeleteElementAction(IWorkbenchPart part) { + super(part); + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/DiagramEditorContextMenuProvider.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/DiagramEditorContextMenuProvider.java new file mode 100644 index 00000000..1d54979e --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/DiagramEditorContextMenuProvider.java @@ -0,0 +1,68 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.transaction.util.TransactionUtil; +import org.eclipse.gef.EditPartViewer; +import org.eclipse.gmf.runtime.common.ui.services.action.contributionitem.ContributionItemService; +import org.eclipse.gmf.runtime.diagram.ui.actions.ActionIds; +import org.eclipse.gmf.runtime.diagram.ui.providers.DiagramContextMenuProvider; +import org.eclipse.jface.action.IMenuManager; +import org.eclipse.ui.IWorkbenchPart; + +/** + * @generated + */ +public class DiagramEditorContextMenuProvider extends DiagramContextMenuProvider { + + /** + * @generated + */ + private IWorkbenchPart part; + + /** + * @generated + */ + private DeleteElementAction deleteAction; + + /** + * @generated + */ + public DiagramEditorContextMenuProvider(IWorkbenchPart part, EditPartViewer viewer) { + super(part, viewer); + this.part = part; + deleteAction = new DeleteElementAction(part); + deleteAction.init(); + } + + /** + * @generated + */ + public void dispose() { + if (deleteAction != null) { + deleteAction.dispose(); + deleteAction = null; + } + super.dispose(); + } + + /** + * @generated + */ + public void buildContextMenu(final IMenuManager menu) { + getViewer().flush(); + try { + TransactionUtil.getEditingDomain((EObject) getViewer().getContents().getModel()) + .runExclusive(new Runnable() { + + public void run() { + ContributionItemService.getInstance() + .contributeToPopupMenu(DiagramEditorContextMenuProvider.this, part); + menu.remove(ActionIds.ACTION_DELETE_FROM_MODEL); + menu.appendToGroup("editGroup", deleteAction); + } + }); + } catch (Exception e) { + StatemachineDiagramEditorPlugin.getInstance().logError("Error building context menu", e); + } + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/LoadResourceAction.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/LoadResourceAction.java new file mode 100644 index 00000000..e40be0e4 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/LoadResourceAction.java @@ -0,0 +1,18 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import org.eclipse.core.commands.ExecutionEvent; +import org.eclipse.core.commands.ExecutionException; +import org.eclipse.gmf.tooling.runtime.actions.DefaultLoadResourceAction; + +/** + * @generated + */ +public class LoadResourceAction extends DefaultLoadResourceAction { + /** + * @generated + */ + public Object execute(ExecutionEvent event) throws ExecutionException { + return super.execute(event); + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/Messages.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/Messages.java new file mode 100644 index 00000000..c1fccba3 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/Messages.java @@ -0,0 +1,319 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import org.eclipse.osgi.util.NLS; + +/** + * @generated + */ +public class Messages extends NLS { + + /** + * @generated + */ + static { + NLS.initializeMessages("messages", Messages.class); //$NON-NLS-1$ + } + + /** + * @generated + */ + private Messages() { + } + + /** + * @generated + */ + public static String StatemachineCreationWizardTitle; + + /** + * @generated + */ + public static String StatemachineCreationWizard_DiagramModelFilePageTitle; + + /** + * @generated + */ + public static String StatemachineCreationWizard_DiagramModelFilePageDescription; + + /** + * @generated + */ + public static String StatemachineCreationWizard_DomainModelFilePageTitle; + + /** + * @generated + */ + public static String StatemachineCreationWizard_DomainModelFilePageDescription; + + /** + * @generated + */ + public static String StatemachineCreationWizardOpenEditorError; + + /** + * @generated + */ + public static String StatemachineCreationWizardCreationError; + + /** + * @generated + */ + public static String StatemachineCreationWizardPageExtensionError; + + /** + * @generated + */ + public static String StatemachineDiagramEditorUtil_OpenModelResourceErrorDialogTitle; + + /** + * @generated + */ + public static String StatemachineDiagramEditorUtil_OpenModelResourceErrorDialogMessage; + + /** + * @generated + */ + public static String StatemachineDiagramEditorUtil_CreateDiagramProgressTask; + + /** + * @generated + */ + public static String StatemachineDiagramEditorUtil_CreateDiagramCommandLabel; + + /** + * @generated + */ + public static String StatemachineDocumentProvider_isModifiable; + + /** + * @generated + */ + public static String StatemachineDocumentProvider_handleElementContentChanged; + + /** + * @generated + */ + public static String StatemachineDocumentProvider_IncorrectInputError; + + /** + * @generated + */ + public static String StatemachineDocumentProvider_NoDiagramInResourceError; + + /** + * @generated + */ + public static String StatemachineDocumentProvider_DiagramLoadingError; + + /** + * @generated + */ + public static String StatemachineDocumentProvider_UnsynchronizedFileSaveError; + + /** + * @generated + */ + public static String StatemachineDocumentProvider_SaveDiagramTask; + + /** + * @generated + */ + public static String StatemachineDocumentProvider_SaveNextResourceTask; + + /** + * @generated + */ + public static String StatemachineDocumentProvider_SaveAsOperation; + + /** + * @generated + */ + public static String InitDiagramFile_ResourceErrorDialogTitle; + + /** + * @generated + */ + public static String InitDiagramFile_ResourceErrorDialogMessage; + + /** + * @generated + */ + public static String InitDiagramFile_WizardTitle; + + /** + * @generated + */ + public static String InitDiagramFile_OpenModelFileDialogTitle; + + /** + * @generated + */ + public static String StatemachineNewDiagramFileWizard_CreationPageName; + + /** + * @generated + */ + public static String StatemachineNewDiagramFileWizard_CreationPageTitle; + + /** + * @generated + */ + public static String StatemachineNewDiagramFileWizard_CreationPageDescription; + + /** + * @generated + */ + public static String StatemachineNewDiagramFileWizard_RootSelectionPageName; + + /** + * @generated + */ + public static String StatemachineNewDiagramFileWizard_RootSelectionPageTitle; + + /** + * @generated + */ + public static String StatemachineNewDiagramFileWizard_RootSelectionPageDescription; + + /** + * @generated + */ + public static String StatemachineNewDiagramFileWizard_RootSelectionPageSelectionTitle; + + /** + * @generated + */ + public static String StatemachineNewDiagramFileWizard_RootSelectionPageNoSelectionMessage; + + /** + * @generated + */ + public static String StatemachineNewDiagramFileWizard_RootSelectionPageInvalidSelectionMessage; + + /** + * @generated + */ + public static String StatemachineNewDiagramFileWizard_InitDiagramCommand; + + /** + * @generated + */ + public static String StatemachineNewDiagramFileWizard_IncorrectRootError; + + /** + * @generated + */ + public static String StatemachineDiagramEditor_SavingDeletedFile; + + /** + * @generated + */ + public static String StatemachineDiagramEditor_SaveAsErrorTitle; + + /** + * @generated + */ + public static String StatemachineDiagramEditor_SaveAsErrorMessage; + + /** + * @generated + */ + public static String StatemachineDiagramEditor_SaveErrorTitle; + + /** + * @generated + */ + public static String StatemachineDiagramEditor_SaveErrorMessage; + + /** + * @generated + */ + public static String StatemachineElementChooserDialog_SelectModelElementTitle; + + /** + * @generated + */ + public static String ModelElementSelectionPageMessage; + + /** + * @generated + */ + public static String ValidateActionMessage; + + /** + * @generated + */ + public static String Statemachine1Group_title; + + /** + * @generated + */ + public static String State1CreationTool_title; + + /** + * @generated + */ + public static String State1CreationTool_desc; + + /** + * @generated + */ + public static String Transition2CreationTool_title; + + /** + * @generated + */ + public static String Transition2CreationTool_desc; + + /** + * @generated + */ + public static String CommandName_OpenDiagram; + + /** + * @generated + */ + public static String NavigatorGroupName_Statemachine_1000_links; + + /** + * @generated + */ + public static String NavigatorGroupName_State_2001_incominglinks; + + /** + * @generated + */ + public static String NavigatorGroupName_State_2001_outgoinglinks; + + /** + * @generated + */ + public static String NavigatorGroupName_Transition_4001_target; + + /** + * @generated + */ + public static String NavigatorGroupName_Transition_4001_source; + + /** + * @generated + */ + public static String NavigatorActionProvider_OpenDiagramActionName; + + /** + * @generated + */ + public static String MessageFormatParser_InvalidInputError; + + /** + * @generated + */ + public static String StatemachineModelingAssistantProviderTitle; + + /** + * @generated + */ + public static String StatemachineModelingAssistantProviderMessage; + + // TODO: put accessor fields manually +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/ModelElementSelectionPage.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/ModelElementSelectionPage.java new file mode 100644 index 00000000..62abdbc0 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/ModelElementSelectionPage.java @@ -0,0 +1,31 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import org.eclipse.gmf.tooling.runtime.part.DefaultModelElementSelectionPage; + +import de.darmstadt.tu.crossing.statemachine.diagram.part.Messages; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin; + +/** + * Wizard page that allows to select element from model. + * + * @generated + */ +public class ModelElementSelectionPage extends DefaultModelElementSelectionPage { + + /** + * @generated + */ + public ModelElementSelectionPage(String pageName) { + super(StatemachineDiagramEditorPlugin.getInstance().getItemProvidersAdapterFactory(), pageName); + } + + /** + * Override to provide custom model element description. + * + * @generated + */ + protected String getSelectionTitle() { + return Messages.ModelElementSelectionPageMessage; + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineCreationWizard.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineCreationWizard.java new file mode 100644 index 00000000..046e6d14 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineCreationWizard.java @@ -0,0 +1,161 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import java.lang.reflect.InvocationTargetException; + +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.jface.dialogs.ErrorDialog; +import org.eclipse.jface.operation.IRunnableWithProgress; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.wizard.Wizard; +import org.eclipse.ui.INewWizard; +import org.eclipse.ui.IWorkbench; +import org.eclipse.ui.PartInitException; +import org.eclipse.ui.actions.WorkspaceModifyOperation; + +/** + * @generated + */ +public class StatemachineCreationWizard extends Wizard implements INewWizard { + + /** + * @generated + */ + private IWorkbench workbench; + + /** + * @generated + */ + protected IStructuredSelection selection; + + /** + * @generated + */ + protected StatemachineCreationWizardPage diagramModelFilePage; + + /** + * @generated + */ + protected StatemachineCreationWizardPage domainModelFilePage; + + /** + * @generated + */ + protected Resource diagram; + + /** + * @generated + */ + private boolean openNewlyCreatedDiagramEditor = true; + + /** + * @generated + */ + public IWorkbench getWorkbench() { + return workbench; + } + + /** + * @generated + */ + public IStructuredSelection getSelection() { + return selection; + } + + /** + * @generated + */ + public final Resource getDiagram() { + return diagram; + } + + /** + * @generated + */ + public final boolean isOpenNewlyCreatedDiagramEditor() { + return openNewlyCreatedDiagramEditor; + } + + /** + * @generated + */ + public void setOpenNewlyCreatedDiagramEditor(boolean openNewlyCreatedDiagramEditor) { + this.openNewlyCreatedDiagramEditor = openNewlyCreatedDiagramEditor; + } + + /** + * @generated + */ + public void init(IWorkbench workbench, IStructuredSelection selection) { + this.workbench = workbench; + this.selection = selection; + setWindowTitle(Messages.StatemachineCreationWizardTitle); + setDefaultPageImageDescriptor( + StatemachineDiagramEditorPlugin.getBundledImageDescriptor("icons/wizban/NewStatemachineWizard.gif")); //$NON-NLS-1$ + setNeedsProgressMonitor(true); + } + + /** + * @generated + */ + public void addPages() { + diagramModelFilePage = new StatemachineCreationWizardPage("DiagramModelFile", getSelection(), //$NON-NLS-1$ + "statemachine_diagram"); //$NON-NLS-1$ + diagramModelFilePage.setTitle(Messages.StatemachineCreationWizard_DiagramModelFilePageTitle); + diagramModelFilePage.setDescription(Messages.StatemachineCreationWizard_DiagramModelFilePageDescription); + addPage(diagramModelFilePage); + + domainModelFilePage = new StatemachineCreationWizardPage("DomainModelFile", getSelection(), "crysl") { //$NON-NLS-1$ //$NON-NLS-2$ + + public void setVisible(boolean visible) { + if (visible) { + String fileName = diagramModelFilePage.getFileName(); + fileName = fileName.substring(0, fileName.length() - ".statemachine_diagram".length()); //$NON-NLS-1$ + setFileName( + StatemachineDiagramEditorUtil.getUniqueFileName(getContainerFullPath(), fileName, "crysl")); //$NON-NLS-1$ + } + super.setVisible(visible); + } + }; + domainModelFilePage.setTitle(Messages.StatemachineCreationWizard_DomainModelFilePageTitle); + domainModelFilePage.setDescription(Messages.StatemachineCreationWizard_DomainModelFilePageDescription); + addPage(domainModelFilePage); + } + + /** + * @generated + */ + public boolean performFinish() { + IRunnableWithProgress op = new WorkspaceModifyOperation(null) { + + protected void execute(IProgressMonitor monitor) throws CoreException, InterruptedException { + diagram = StatemachineDiagramEditorUtil.createDiagram(diagramModelFilePage.getURI(), + domainModelFilePage.getURI(), monitor); + if (isOpenNewlyCreatedDiagramEditor() && diagram != null) { + try { + StatemachineDiagramEditorUtil.openDiagram(diagram); + } catch (PartInitException e) { + ErrorDialog.openError(getContainer().getShell(), + Messages.StatemachineCreationWizardOpenEditorError, null, e.getStatus()); + } + } + } + }; + try { + getContainer().run(false, true, op); + } catch (InterruptedException e) { + return false; + } catch (InvocationTargetException e) { + if (e.getTargetException() instanceof CoreException) { + ErrorDialog.openError(getContainer().getShell(), Messages.StatemachineCreationWizardCreationError, null, + ((CoreException) e.getTargetException()).getStatus()); + } else { + StatemachineDiagramEditorPlugin.getInstance().logError("Error creating diagram", //$NON-NLS-1$ + e.getTargetException()); + } + return false; + } + return diagram != null; + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineCreationWizardPage.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineCreationWizardPage.java new file mode 100644 index 00000000..5c0d2eac --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineCreationWizardPage.java @@ -0,0 +1,84 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import org.eclipse.core.runtime.IPath; +import org.eclipse.core.runtime.Path; +import org.eclipse.emf.common.util.URI; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.osgi.util.NLS; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.ui.dialogs.WizardNewFileCreationPage; + +/** + * @generated + */ +public class StatemachineCreationWizardPage extends WizardNewFileCreationPage { + + /** + * @generated + */ + private final String fileExtension; + + /** + * @generated + */ + public StatemachineCreationWizardPage(String pageName, IStructuredSelection selection, String fileExtension) { + super(pageName, selection); + this.fileExtension = fileExtension; + } + + /** + * Override to create files with this extension. + * + * @generated + */ + protected String getExtension() { + return fileExtension; + } + + /** + * @generated + */ + public URI getURI() { + return URI.createPlatformResourceURI(getFilePath().toString(), false); + } + + /** + * @generated + */ + protected IPath getFilePath() { + IPath path = getContainerFullPath(); + if (path == null) { + path = new Path(""); //$NON-NLS-1$ + } + String fileName = getFileName(); + if (fileName != null) { + path = path.append(fileName); + } + return path; + } + + /** + * @generated + */ + public void createControl(Composite parent) { + super.createControl(parent); + setFileName( + StatemachineDiagramEditorUtil.getUniqueFileName(getContainerFullPath(), getFileName(), getExtension())); + setPageComplete(validatePage()); + } + + /** + * @generated + */ + protected boolean validatePage() { + if (!super.validatePage()) { + return false; + } + String extension = getExtension(); + if (extension != null && !getFilePath().toString().endsWith("." + extension)) { + setErrorMessage(NLS.bind(Messages.StatemachineCreationWizardPageExtensionError, extension)); + return false; + } + return true; + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDiagramActionBarContributor.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDiagramActionBarContributor.java new file mode 100644 index 00000000..894d2996 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDiagramActionBarContributor.java @@ -0,0 +1,47 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import org.eclipse.gmf.runtime.diagram.ui.parts.DiagramActionBarContributor; +import org.eclipse.jface.action.GroupMarker; +import org.eclipse.jface.action.IAction; +import org.eclipse.jface.action.IMenuManager; +import org.eclipse.ui.IActionBars; +import org.eclipse.ui.IWorkbenchActionConstants; +import org.eclipse.ui.IWorkbenchPage; + +/** + * @generated + */ +public class StatemachineDiagramActionBarContributor extends DiagramActionBarContributor { + + /** + * @generated + */ + protected Class getEditorClass() { + return StatemachineDiagramEditor.class; + } + + /** + * @generated + */ + protected String getEditorId() { + return StatemachineDiagramEditor.ID; + } + + /** + * @generated + */ + public void init(IActionBars bars, IWorkbenchPage page) { + super.init(bars, page); + // print preview + IMenuManager fileMenu = bars.getMenuManager().findMenuUsingPath(IWorkbenchActionConstants.M_FILE); + assert fileMenu != null; + fileMenu.remove("pageSetupAction"); //$NON-NLS-1$ + IMenuManager editMenu = bars.getMenuManager().findMenuUsingPath(IWorkbenchActionConstants.M_EDIT); + assert editMenu != null; + if (editMenu.find("validationGroup") == null) { //$NON-NLS-1$ + editMenu.add(new GroupMarker("validationGroup")); //$NON-NLS-1$ + } + IAction validateAction = new ValidateAction(page); + editMenu.appendToGroup("validationGroup", validateAction); //$NON-NLS-1$ + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDiagramEditor.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDiagramEditor.java new file mode 100644 index 00000000..9ee8f4c6 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDiagramEditor.java @@ -0,0 +1,296 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import org.eclipse.core.resources.IFile; +import org.eclipse.core.resources.IMarker; +import org.eclipse.core.resources.IWorkspaceRoot; +import org.eclipse.core.resources.ResourcesPlugin; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IPath; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.NullProgressMonitor; +import org.eclipse.emf.common.ui.URIEditorInput; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.transaction.TransactionalEditingDomain; +import org.eclipse.emf.workspace.util.WorkspaceSynchronizer; +import org.eclipse.gef.palette.PaletteRoot; +import org.eclipse.gmf.runtime.common.ui.services.marker.MarkerNavigationService; +import org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint; +import org.eclipse.gmf.runtime.diagram.ui.actions.ActionIds; +import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart; +import org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.IDiagramDocument; +import org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.IDocument; +import org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.IDocumentProvider; +import org.eclipse.gmf.runtime.diagram.ui.resources.editor.parts.DiagramDocumentEditor; +import org.eclipse.gmf.runtime.notation.Diagram; +import org.eclipse.jface.dialogs.ErrorDialog; +import org.eclipse.jface.dialogs.IMessageProvider; +import org.eclipse.jface.dialogs.MessageDialog; +import org.eclipse.jface.viewers.ISelection; +import org.eclipse.jface.viewers.StructuredSelection; +import org.eclipse.jface.window.Window; +import org.eclipse.osgi.util.NLS; +import org.eclipse.swt.widgets.Shell; +import org.eclipse.ui.IEditorInput; +import org.eclipse.ui.IEditorMatchingStrategy; +import org.eclipse.ui.IEditorPart; +import org.eclipse.ui.IEditorReference; +import org.eclipse.ui.IFileEditorInput; +import org.eclipse.ui.PlatformUI; +import org.eclipse.ui.dialogs.SaveAsDialog; +import org.eclipse.ui.ide.IGotoMarker; +import org.eclipse.ui.navigator.resources.ProjectExplorer; +import org.eclipse.ui.part.FileEditorInput; +import org.eclipse.ui.part.IShowInTargetList; +import org.eclipse.ui.part.ShowInContext; + +import de.darmstadt.tu.crossing.crySL.Expression; +import de.darmstadt.tu.crossing.statemachine.diagram.navigator.StatemachineNavigatorItem; +import de.darmstadt.tu.crossing.statemachine.xtext.xproperties.FrameworkAdapters; + +/** + * @generated + */ +public class StatemachineDiagramEditor extends DiagramDocumentEditor implements IGotoMarker, IEditorPart { + /** + * @generated + */ + public static final String ID = "de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorID"; //$NON-NLS-1$ + + /** + * @generated + */ + public static final String CONTEXT_ID = "de.darmstadt.tu.crossing.statemachine.diagram.ui.diagramContext"; //$NON-NLS-1$ + + /** + * @generated NOT + */ + public StatemachineDiagramEditor() { + super(true); + FrameworkAdapters.addAdapter(new FrameworkAdapters.IAdapter() { + @Override + public boolean appliesTo(Object element) { + return element instanceof IGraphicalEditPart && getModel(element) instanceof Expression; + } + + @Override + public EObject getModel(Object element) { + return ((IGraphicalEditPart) element).getNotationView().getElement(); + } + + @Override + public TransactionalEditingDomain getEditingDomain(Object element) { + return ((IGraphicalEditPart) element).getEditingDomain(); + } + }); + } + + /** + * @generated + */ + protected String getContextID() { + return CONTEXT_ID; + } + + /** + * @generated + */ + protected PaletteRoot createPaletteRoot(PaletteRoot existingPaletteRoot) { + PaletteRoot root = super.createPaletteRoot(existingPaletteRoot); + new StatemachinePaletteFactory().fillPalette(root); + return root; + } + + /** + * @generated + */ + protected PreferencesHint getPreferencesHint() { + return StatemachineDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT; + } + + /** + * @generated + */ + public String getContributorId() { + return StatemachineDiagramEditorPlugin.ID; + } + + /** + * @generated + */ + @SuppressWarnings("rawtypes") + public Object getAdapter(Class type) { + if (type == IShowInTargetList.class) { + return new IShowInTargetList() { + public String[] getShowInTargetIds() { + return new String[] { ProjectExplorer.VIEW_ID }; + } + }; + } + return super.getAdapter(type); + } + + /** + * @generated + */ + protected IDocumentProvider getDocumentProvider(IEditorInput input) { + if (input instanceof IFileEditorInput || input instanceof URIEditorInput) { + return StatemachineDiagramEditorPlugin.getInstance().getDocumentProvider(); + } + return super.getDocumentProvider(input); + } + + /** + * @generated + */ + public TransactionalEditingDomain getEditingDomain() { + IDocument document = getEditorInput() != null ? getDocumentProvider().getDocument(getEditorInput()) : null; + if (document instanceof IDiagramDocument) { + return ((IDiagramDocument) document).getEditingDomain(); + } + return super.getEditingDomain(); + } + + /** + * @generated + */ + protected void setDocumentProvider(IEditorInput input) { + if (input instanceof IFileEditorInput || input instanceof URIEditorInput) { + setDocumentProvider(StatemachineDiagramEditorPlugin.getInstance().getDocumentProvider()); + } else { + super.setDocumentProvider(input); + } + } + + /** + * @generated + */ + public void gotoMarker(IMarker marker) { + MarkerNavigationService.getInstance().gotoMarker(this, marker); + } + + /** + * @generated + */ + public boolean isSaveAsAllowed() { + return true; + } + + /** + * @generated + */ + public void doSaveAs() { + performSaveAs(new NullProgressMonitor()); + } + + /** + * @generated + */ + protected void performSaveAs(IProgressMonitor progressMonitor) { + Shell shell = getSite().getShell(); + IEditorInput input = getEditorInput(); + SaveAsDialog dialog = new SaveAsDialog(shell); + IFile original = input instanceof IFileEditorInput ? ((IFileEditorInput) input).getFile() : null; + if (original != null) { + dialog.setOriginalFile(original); + } + dialog.create(); + IDocumentProvider provider = getDocumentProvider(); + if (provider == null) { + // editor has been programmatically closed while the dialog was open + return; + } + if (provider.isDeleted(input) && original != null) { + String message = NLS.bind(Messages.StatemachineDiagramEditor_SavingDeletedFile, original.getName()); + dialog.setErrorMessage(null); + dialog.setMessage(message, IMessageProvider.WARNING); + } + if (dialog.open() == Window.CANCEL) { + if (progressMonitor != null) { + progressMonitor.setCanceled(true); + } + return; + } + IPath filePath = dialog.getResult(); + if (filePath == null) { + if (progressMonitor != null) { + progressMonitor.setCanceled(true); + } + return; + } + IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot(); + IFile file = workspaceRoot.getFile(filePath); + final IEditorInput newInput = new FileEditorInput(file); +// Check if the editor is already open + IEditorMatchingStrategy matchingStrategy = getEditorDescriptor().getEditorMatchingStrategy(); + IEditorReference[] editorRefs = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage() + .getEditorReferences(); + for (int i = 0; i < editorRefs.length; i++) { + if (matchingStrategy.matches(editorRefs[i], newInput)) { + MessageDialog.openWarning(shell, Messages.StatemachineDiagramEditor_SaveAsErrorTitle, + Messages.StatemachineDiagramEditor_SaveAsErrorMessage); + return; + } + } + boolean success = false; + try { + provider.aboutToChange(newInput); + getDocumentProvider(newInput).saveDocument(progressMonitor, newInput, + getDocumentProvider().getDocument(getEditorInput()), true); + success = true; + } catch (CoreException x) { + IStatus status = x.getStatus(); + if (status == null || status.getSeverity() != IStatus.CANCEL) { + ErrorDialog.openError(shell, Messages.StatemachineDiagramEditor_SaveErrorTitle, + Messages.StatemachineDiagramEditor_SaveErrorMessage, x.getStatus()); + } + } finally { + provider.changed(newInput); + if (success) { + setInput(newInput); + } + } + if (progressMonitor != null) { + progressMonitor.setCanceled(!success); + } + } + + /** + * @generated + */ + public ShowInContext getShowInContext() { + return new ShowInContext(getEditorInput(), getNavigatorSelection()); + } + + /** + * @generated + */ + private ISelection getNavigatorSelection() { + IDiagramDocument document = getDiagramDocument(); + if (document == null) { + return StructuredSelection.EMPTY; + } + Diagram diagram = document.getDiagram(); + if (diagram == null || diagram.eResource() == null) { + return StructuredSelection.EMPTY; + } + IFile file = WorkspaceSynchronizer.getFile(diagram.eResource()); + if (file != null) { + StatemachineNavigatorItem item = new StatemachineNavigatorItem(diagram, file, false); + return new StructuredSelection(item); + } + return StructuredSelection.EMPTY; + } + + /** + * @generated + */ + protected void configureGraphicalViewer() { + super.configureGraphicalViewer(); + DiagramEditorContextMenuProvider provider = new DiagramEditorContextMenuProvider(this, + getDiagramGraphicalViewer()); + getDiagramGraphicalViewer().setContextMenu(provider); + getSite().registerContextMenu(ActionIds.DIAGRAM_EDITOR_CONTEXT_MENU, provider, getDiagramGraphicalViewer()); + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDiagramEditorPlugin.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDiagramEditorPlugin.java new file mode 100644 index 00000000..d533f2dd --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDiagramEditorPlugin.java @@ -0,0 +1,278 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.core.runtime.IPath; +import org.eclipse.core.runtime.Path; +import org.eclipse.core.runtime.Platform; +import org.eclipse.emf.common.notify.AdapterFactory; +import org.eclipse.emf.edit.provider.ComposedAdapterFactory; +import org.eclipse.emf.edit.provider.IItemLabelProvider; +import org.eclipse.emf.edit.provider.ReflectiveItemProviderAdapterFactory; +import org.eclipse.emf.edit.provider.resource.ResourceItemProviderAdapterFactory; +import org.eclipse.emf.edit.ui.provider.ExtendedImageRegistry; +import org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint; +import org.eclipse.gmf.tooling.runtime.LogHelper; +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.swt.graphics.Image; +import org.eclipse.ui.plugin.AbstractUIPlugin; +import org.osgi.framework.BundleContext; +//import org.xtext.example.statemachine.statemachine.diagram.edit.policies.StatemachineBaseItemSemanticEditPolicy; +//import org.xtext.example.statemachine.statemachine.diagram.providers.ElementInitializers; +//import org.xtext.example.statemachine.statemachine.provider.StatemachineItemProviderAdapterFactory; + +import de.darmstadt.tu.crossing.statemachine.diagram.edit.policies.StatemachineBaseItemSemanticEditPolicy; +import de.darmstadt.tu.crossing.statemachine.diagram.providers.ElementInitializers; +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineItemProviderAdapterFactory; + +/** + * @generated + */ +public class StatemachineDiagramEditorPlugin extends AbstractUIPlugin { + + /** + * @generated + */ + public static final String ID = "de.darmstadt.tu.crossing.CrySL.statemachine.diagram"; //$NON-NLS-1$ + + /** + * @generated + */ + private LogHelper myLogHelper; + + /** + * @generated + */ + public static final PreferencesHint DIAGRAM_PREFERENCES_HINT = new PreferencesHint(ID); + + /** + * @generated + */ + private static StatemachineDiagramEditorPlugin instance; + + /** + * @generated + */ + private ComposedAdapterFactory adapterFactory; + + /** + * @generated + */ + private StatemachineDocumentProvider documentProvider; + + /** + * @generated + */ + private StatemachineBaseItemSemanticEditPolicy.LinkConstraints linkConstraints; + + /** + * @generated + */ + private ElementInitializers initializers; + + /** + * @generated + */ + public StatemachineDiagramEditorPlugin() { + } + + /** + * @generated + */ + public void start(BundleContext context) throws Exception { + super.start(context); + instance = this; + myLogHelper = new LogHelper(this); + PreferencesHint.registerPreferenceStore(DIAGRAM_PREFERENCES_HINT, getPreferenceStore()); + adapterFactory = createAdapterFactory(); + } + + /** + * @generated + */ + public void stop(BundleContext context) throws Exception { + adapterFactory.dispose(); + adapterFactory = null; + linkConstraints = null; + initializers = null; + instance = null; + super.stop(context); + } + + /** + * @generated + */ + public static StatemachineDiagramEditorPlugin getInstance() { + return instance; + } + + /** + * @generated + */ + protected ComposedAdapterFactory createAdapterFactory() { + ArrayList factories = new ArrayList(); + fillItemProviderFactories(factories); + return new ComposedAdapterFactory(factories); + } + + /** + * @generated + */ + protected void fillItemProviderFactories(List factories) { + factories.add(new StatemachineItemProviderAdapterFactory()); + factories.add(new ResourceItemProviderAdapterFactory()); + factories.add(new ReflectiveItemProviderAdapterFactory()); + } + + /** + * @generated + */ + public AdapterFactory getItemProvidersAdapterFactory() { + return adapterFactory; + } + + /** + * @generated + */ + public ImageDescriptor getItemImageDescriptor(Object item) { + IItemLabelProvider labelProvider = (IItemLabelProvider) adapterFactory.adapt(item, IItemLabelProvider.class); + if (labelProvider != null) { + return ExtendedImageRegistry.getInstance().getImageDescriptor(labelProvider.getImage(item)); + } + return null; + } + + /** + * Returns an image descriptor for the image file at the given plug-in relative + * path. + * + * @generated + * @param path the path + * @return the image descriptor + */ + public static ImageDescriptor getBundledImageDescriptor(String path) { + return AbstractUIPlugin.imageDescriptorFromPlugin(ID, path); + } + + /** + * Respects images residing in any plug-in. If path is relative, then this + * bundle is looked up for the image, otherwise, for absolute path, first + * segment is taken as id of plug-in with image + * + * @generated + * @param path the path to image, either absolute (with plug-in id as first + * segment), or relative for bundled images + * @return the image descriptor + */ + public static ImageDescriptor findImageDescriptor(String path) { + final IPath p = new Path(path); + if (p.isAbsolute() && p.segmentCount() > 1) { + return AbstractUIPlugin.imageDescriptorFromPlugin(p.segment(0), + p.removeFirstSegments(1).makeAbsolute().toString()); + } else { + return getBundledImageDescriptor(p.makeAbsolute().toString()); + } + } + + /** + * Returns an image for the image file at the given plug-in relative path. + * Client do not need to dispose this image. Images will be disposed + * automatically. + * + * @generated + * @param path the path + * @return image instance + */ + public Image getBundledImage(String path) { + Image image = getImageRegistry().get(path); + if (image == null) { + getImageRegistry().put(path, getBundledImageDescriptor(path)); + image = getImageRegistry().get(path); + } + return image; + } + + /** + * Returns string from plug-in's resource bundle + * + * @generated + */ + public static String getString(String key) { + return Platform.getResourceString(getInstance().getBundle(), "%" + key); //$NON-NLS-1$ + } + + /** + * @generated + */ + public StatemachineDocumentProvider getDocumentProvider() { + if (documentProvider == null) { + documentProvider = new StatemachineDocumentProvider(); + } + return documentProvider; + } + + /** + * @generated + */ + public StatemachineBaseItemSemanticEditPolicy.LinkConstraints getLinkConstraints() { + return linkConstraints; + } + + /** + * @generated + */ + public void setLinkConstraints(StatemachineBaseItemSemanticEditPolicy.LinkConstraints lc) { + this.linkConstraints = lc; + } + + /** + * @generated + */ + public ElementInitializers getElementInitializers() { + return initializers; + } + + /** + * @generated + */ + public void setElementInitializers(ElementInitializers i) { + this.initializers = i; + } + + /** + * @generated + */ + public void logError(String error) { + getLogHelper().logError(error, null); + } + + /** + * @generated + */ + public void logError(String error, Throwable throwable) { + getLogHelper().logError(error, throwable); + } + + /** + * @generated + */ + public void logInfo(String message) { + getLogHelper().logInfo(message, null); + } + + /** + * @generated + */ + public void logInfo(String message, Throwable throwable) { + getLogHelper().logInfo(message, throwable); + } + + /** + * @generated + */ + public LogHelper getLogHelper() { + return myLogHelper; + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDiagramEditorUtil.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDiagramEditorUtil.java new file mode 100644 index 00000000..a68226b4 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDiagramEditorUtil.java @@ -0,0 +1,414 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.eclipse.core.commands.ExecutionException; +import org.eclipse.core.commands.operations.OperationHistoryFactory; +import org.eclipse.core.resources.IFile; +import org.eclipse.core.resources.IResource; +import org.eclipse.core.resources.ResourcesPlugin; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.core.runtime.IPath; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.NullProgressMonitor; +import org.eclipse.core.runtime.Path; +import org.eclipse.core.runtime.SubProgressMonitor; +import org.eclipse.emf.common.util.URI; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.emf.ecore.xmi.XMLResource; +import org.eclipse.emf.transaction.TransactionalEditingDomain; +import org.eclipse.emf.workspace.util.WorkspaceSynchronizer; +import org.eclipse.gef.EditPart; +import org.eclipse.gmf.runtime.common.core.command.CommandResult; +import org.eclipse.gmf.runtime.diagram.core.services.ViewService; +import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart; +import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart; +import org.eclipse.gmf.runtime.diagram.ui.editparts.IPrimaryEditPart; +import org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramGraphicalViewer; +import org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramWorkbenchPart; +import org.eclipse.gmf.runtime.emf.commands.core.command.AbstractTransactionalCommand; +import org.eclipse.gmf.runtime.emf.core.GMFEditingDomainFactory; +import org.eclipse.gmf.runtime.emf.core.util.EMFCoreUtil; +import org.eclipse.gmf.runtime.notation.Diagram; +import org.eclipse.gmf.runtime.notation.View; +import org.eclipse.gmf.tooling.runtime.part.DefaultDiagramEditorUtil; +import org.eclipse.jface.dialogs.IDialogSettings; +import org.eclipse.jface.wizard.Wizard; +import org.eclipse.jface.wizard.WizardDialog; +import org.eclipse.swt.widgets.Shell; +import org.eclipse.ui.IEditorPart; +import org.eclipse.ui.IWorkbenchPage; +import org.eclipse.ui.PartInitException; +import org.eclipse.ui.PlatformUI; +import org.eclipse.ui.part.FileEditorInput; +//import de.darmstadt.tu.crossing.crySL.Order; +//import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.OrderEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.OrderEditPart; +import de.darmstadt.tu.crossing.crySL.CrySLFactory; +import de.darmstadt.tu.crossing.crySL.Domainmodel; +import de.darmstadt.tu.crossing.crySL.Expression; +import de.darmstadt.tu.crossing.crySL.Order; + +/** + * @generated + */ +public class StatemachineDiagramEditorUtil { + + /** + * @generated + */ + public static Map getSaveOptions() { + HashMap saveOptions = new HashMap(); + saveOptions.put(XMLResource.OPTION_ENCODING, "UTF-8"); //$NON-NLS-1$ + saveOptions.put(Resource.OPTION_SAVE_ONLY_IF_CHANGED, Resource.OPTION_SAVE_ONLY_IF_CHANGED_MEMORY_BUFFER); + return saveOptions; + } + + /** + * @generated + */ + public static boolean openDiagram(Resource diagram) throws PartInitException { + String path = diagram.getURI().toPlatformString(true); + IResource workspaceResource = ResourcesPlugin.getWorkspace().getRoot().findMember(new Path(path)); + if (workspaceResource instanceof IFile) { + IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); + IEditorPart part = page.openEditor(new FileEditorInput((IFile) workspaceResource), + StatemachineDiagramEditor.ID); + return null != page.openEditor(new FileEditorInput((IFile) workspaceResource), + StatemachineDiagramEditor.ID); + } + return false; + } + + /** + * @generated + */ + public static void setCharset(IFile file) { + if (file == null) { + return; + } + try { + file.setCharset("UTF-8", new NullProgressMonitor()); //$NON-NLS-1$ + } catch (CoreException e) { + StatemachineDiagramEditorPlugin.getInstance() + .logError("Unable to set charset for file " + file.getFullPath(), e); //$NON-NLS-1$ + } + } + + /** + * @generated + */ + public static String getUniqueFileName(IPath containerFullPath, String fileName, String extension) { + return DefaultDiagramEditorUtil.getUniqueFileName(containerFullPath, fileName, extension, + DefaultDiagramEditorUtil.EXISTS_IN_WORKSPACE); + } + + /** + * Runs the wizard in a dialog. + * + * @generated + */ + public static void runWizard(Shell shell, Wizard wizard, String settingsKey) { + IDialogSettings pluginDialogSettings = StatemachineDiagramEditorPlugin.getInstance().getDialogSettings(); + IDialogSettings wizardDialogSettings = pluginDialogSettings.getSection(settingsKey); + if (wizardDialogSettings == null) { + wizardDialogSettings = pluginDialogSettings.addNewSection(settingsKey); + } + wizard.setDialogSettings(wizardDialogSettings); + WizardDialog dialog = new WizardDialog(shell, wizard); + dialog.create(); + dialog.getShell().setSize(Math.max(500, dialog.getShell().getSize().x), 500); + dialog.open(); + } + + /** + * This method should be called within a workspace modify operation since it + * creates resources. + * + * @generated + */ + @SuppressWarnings("deprecation") + public static Resource createDiagram(URI diagramURI, URI modelURI, IProgressMonitor progressMonitor) { + /* + * TransactionalEditingDomain editingDomain = GMFEditingDomainFactory.INSTANCE + * .createEditingDomain(); progressMonitor .beginTask( + * Messages.StatemachineDiagramEditorUtil_CreateDiagramProgressTask, 3); final + * Resource diagramResource = editingDomain.getResourceSet() + * .createResource(diagramURI); final Resource modelResource = + * editingDomain.getResourceSet() .createResource(modelURI); final String + * diagramName = diagramURI.lastSegment(); AbstractTransactionalCommand command + * = new AbstractTransactionalCommand( editingDomain, + * Messages.StatemachineDiagramEditorUtil_CreateDiagramCommandLabel, + * Collections.EMPTY_LIST) { protected CommandResult doExecuteWithResult( + * IProgressMonitor monitor, IAdaptable info) throws ExecutionException { //O + * model = createInitialFileModel(); Expression order = createInitialModel(); + * Expression expression = createInitialModel(); + * attachModelToResource(order,expression, modelResource); + * + * Diagram diagram = ViewService .createDiagram( order, OrderEditPart.MODEL_ID, + * StatemachineDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); if (diagram != + * null) { diagramResource.getContents().add(diagram); + * diagram.setName(diagramName); diagram.setElement(order); } + * + * try { modelResource .save(de.darmstadt.tu.crossing.statemachine.diagram.part. + * StatemachineDiagramEditorUtil .getSaveOptions()); diagramResource + * .save(de.darmstadt.tu.crossing.statemachine.diagram.part. + * StatemachineDiagramEditorUtil .getSaveOptions()); } catch (IOException e) { + * + * StatemachineDiagramEditorPlugin.getInstance().logError( + * "Unable to store model and diagram resources", e); //$NON-NLS-1$ } return + * CommandResult.newOKCommandResult(); } }; try { + * OperationHistoryFactory.getOperationHistory().execute(command, new + * SubProgressMonitor(progressMonitor, 1), null); } catch (ExecutionException e) + * { StatemachineDiagramEditorPlugin.getInstance().logError( + * "Unable to create model and diagram", e); //$NON-NLS-1$ } + * setCharset(WorkspaceSynchronizer.getFile(modelResource)); + * setCharset(WorkspaceSynchronizer.getFile(diagramResource)); return + * diagramResource; + */ + TransactionalEditingDomain editingDomain = GMFEditingDomainFactory.INSTANCE.createEditingDomain(); + progressMonitor.beginTask(Messages.StatemachineDiagramEditorUtil_CreateDiagramProgressTask, 3); + final Resource diagramResource = editingDomain.getResourceSet().createResource(diagramURI); + final Resource modelResource = editingDomain.getResourceSet().createResource(modelURI); + final String diagramName = diagramURI.lastSegment(); + AbstractTransactionalCommand command = new AbstractTransactionalCommand(editingDomain, + Messages.StatemachineDiagramEditorUtil_CreateDiagramCommandLabel, Collections.EMPTY_LIST) { + protected CommandResult doExecuteWithResult(IProgressMonitor monitor, IAdaptable info) + throws ExecutionException { + Order model = createInitialModel(); + attachModelToResource(model, modelResource); + + Diagram diagram = ViewService.createDiagram(model, OrderEditPart.MODEL_ID, + StatemachineDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); + if (diagram != null) { + diagramResource.getContents().add(diagram); + diagram.setName(diagramName); + diagram.setElement(model); + } + + try { + modelResource.save(de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorUtil + .getSaveOptions()); + diagramResource + .save(de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorUtil + .getSaveOptions()); + } catch (IOException e) { + + StatemachineDiagramEditorPlugin.getInstance() + .logError("Unable to store model and diagram resources", e); //$NON-NLS-1$ + } + return CommandResult.newOKCommandResult(); + } + }; + try { + OperationHistoryFactory.getOperationHistory().execute(command, new SubProgressMonitor(progressMonitor, 1), + null); + } catch (ExecutionException e) { + StatemachineDiagramEditorPlugin.getInstance().logError("Unable to create model and diagram", e); //$NON-NLS-1$ + } + setCharset(WorkspaceSynchronizer.getFile(modelResource)); + setCharset(WorkspaceSynchronizer.getFile(diagramResource)); + return diagramResource; + } + + /** + * Create a new instance of domain element associated with canvas. + * + * @generated + */ + private static Order createInitialModel() { + return CrySLFactory.eINSTANCE.createOrder(); + } + + private static Domainmodel createInitialFileModel() { + return CrySLFactory.eINSTANCE.createDomainmodel(); + } + + /** + * Store model element in the resource. + * + * @generated + */ + private static void attachModelToResource(Order order, Resource resource) { + resource.getContents().add(order); + // resource.getContents().add(expression); + } + + /** + * @generated + */ + public static void selectElementsInDiagram(IDiagramWorkbenchPart diagramPart, List editParts) { + diagramPart.getDiagramGraphicalViewer().deselectAll(); + + EditPart firstPrimary = null; + for (EditPart nextPart : editParts) { + diagramPart.getDiagramGraphicalViewer().appendSelection(nextPart); + if (firstPrimary == null && nextPart instanceof IPrimaryEditPart) { + firstPrimary = nextPart; + } + } + + if (!editParts.isEmpty()) { + diagramPart.getDiagramGraphicalViewer() + .reveal(firstPrimary != null ? firstPrimary : (EditPart) editParts.get(0)); + } + } + + /** + * @generated + */ + private static int findElementsInDiagramByID(DiagramEditPart diagramPart, EObject element, + List editPartCollector) { + IDiagramGraphicalViewer viewer = (IDiagramGraphicalViewer) diagramPart.getViewer(); + final int intialNumOfEditParts = editPartCollector.size(); + + if (element instanceof View) { // support notation element lookup + EditPart editPart = (EditPart) viewer.getEditPartRegistry().get(element); + if (editPart != null) { + editPartCollector.add(editPart); + return 1; + } + } + + String elementID = EMFCoreUtil.getProxyID(element); + @SuppressWarnings("unchecked") + List associatedParts = viewer.findEditPartsForElement(elementID, IGraphicalEditPart.class); + // perform the possible hierarchy disjoint -> take the top-most parts only + for (EditPart nextPart : associatedParts) { + EditPart parentPart = nextPart.getParent(); + while (parentPart != null && !associatedParts.contains(parentPart)) { + parentPart = parentPart.getParent(); + } + if (parentPart == null) { + editPartCollector.add(nextPart); + } + } + + if (intialNumOfEditParts == editPartCollector.size()) { + if (!associatedParts.isEmpty()) { + editPartCollector.add(associatedParts.get(0)); + } else { + if (element.eContainer() != null) { + return findElementsInDiagramByID(diagramPart, element.eContainer(), editPartCollector); + } + } + } + return editPartCollector.size() - intialNumOfEditParts; + } + + /** + * @generated + */ + public static View findView(DiagramEditPart diagramEditPart, EObject targetElement, + LazyElement2ViewMap lazyElement2ViewMap) { + boolean hasStructuralURI = false; + if (targetElement.eResource() instanceof XMLResource) { + hasStructuralURI = ((XMLResource) targetElement.eResource()).getID(targetElement) == null; + } + + View view = null; + LinkedList editPartHolder = new LinkedList(); + if (hasStructuralURI && !lazyElement2ViewMap.getElement2ViewMap().isEmpty()) { + view = lazyElement2ViewMap.getElement2ViewMap().get(targetElement); + } else if (findElementsInDiagramByID(diagramEditPart, targetElement, editPartHolder) > 0) { + EditPart editPart = editPartHolder.get(0); + view = editPart.getModel() instanceof View ? (View) editPart.getModel() : null; + } + + return (view == null) ? diagramEditPart.getDiagramView() : view; + } + + /** + * XXX This is quite suspicious code (especially editPartTmpHolder) and likely + * to be removed soon + * + * @generated + */ + public static class LazyElement2ViewMap { + /** + * @generated + */ + private Map element2ViewMap; + + /** + * @generated + */ + private View scope; + + /** + * @generated + */ + private Set elementSet; + + /** + * @generated + */ + public LazyElement2ViewMap(View scope, Set elements) { + this.scope = scope; + this.elementSet = elements; + } + + /** + * @generated + */ + public final Map getElement2ViewMap() { + if (element2ViewMap == null) { + element2ViewMap = new HashMap(); + // map possible notation elements to itself as these can't be found by + // view.getElement() + for (EObject element : elementSet) { + if (element instanceof View) { + View view = (View) element; + if (view.getDiagram() == scope.getDiagram()) { + element2ViewMap.put(element, view); // take only those that part of our diagram + } + } + } + + buildElement2ViewMap(scope, element2ViewMap, elementSet); + } + return element2ViewMap; + } + + /** + * @generated + */ + private static boolean buildElement2ViewMap(View parentView, Map element2ViewMap, + Set elements) { + if (elements.size() == element2ViewMap.size()) { + return true; + } + + if (parentView.isSetElement() && !element2ViewMap.containsKey(parentView.getElement()) + && elements.contains(parentView.getElement())) { + element2ViewMap.put(parentView.getElement(), parentView); + if (elements.size() == element2ViewMap.size()) { + return true; + } + } + boolean complete = false; + for (Iterator it = parentView.getChildren().iterator(); it.hasNext() && !complete;) { + complete = buildElement2ViewMap((View) it.next(), element2ViewMap, elements); + } + for (Iterator it = parentView.getSourceEdges().iterator(); it.hasNext() && !complete;) { + complete = buildElement2ViewMap((View) it.next(), element2ViewMap, elements); + } + for (Iterator it = parentView.getTargetEdges().iterator(); it.hasNext() && !complete;) { + complete = buildElement2ViewMap((View) it.next(), element2ViewMap, elements); + } + return complete; + } + } // LazyElement2ViewMap + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDiagramUpdateCommand.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDiagramUpdateCommand.java new file mode 100644 index 00000000..5978d752 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDiagramUpdateCommand.java @@ -0,0 +1,81 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import java.util.Iterator; +import java.util.List; + +import org.eclipse.core.commands.ExecutionEvent; +import org.eclipse.core.commands.ExecutionException; +import org.eclipse.core.commands.IHandler; +import org.eclipse.core.commands.IHandlerListener; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.gef.EditPart; +import org.eclipse.gmf.runtime.diagram.ui.editpolicies.CanonicalEditPolicy; +import org.eclipse.gmf.runtime.notation.View; +import org.eclipse.jface.viewers.ISelection; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.ui.PlatformUI; + +/** + * @generated + */ +public class StatemachineDiagramUpdateCommand implements IHandler { + + /** + * @generated + */ + public void addHandlerListener(IHandlerListener handlerListener) { + } + + /** + * @generated + */ + public void dispose() { + } + + /** + * @generated + */ + public Object execute(ExecutionEvent event) throws ExecutionException { + ISelection selection = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getSelectionService() + .getSelection(); + if (selection instanceof IStructuredSelection) { + IStructuredSelection structuredSelection = (IStructuredSelection) selection; + if (structuredSelection.size() != 1) { + return null; + } + if (structuredSelection.getFirstElement() instanceof EditPart + && ((EditPart) structuredSelection.getFirstElement()).getModel() instanceof View) { + EObject modelElement = ((View) ((EditPart) structuredSelection.getFirstElement()).getModel()) + .getElement(); + List editPolicies = CanonicalEditPolicy.getRegisteredEditPolicies(modelElement); + for (Iterator it = editPolicies.iterator(); it.hasNext();) { + CanonicalEditPolicy nextEditPolicy = (CanonicalEditPolicy) it.next(); + nextEditPolicy.refresh(); + } + + } + } + return null; + } + + /** + * @generated + */ + public boolean isEnabled() { + return true; + } + + /** + * @generated + */ + public boolean isHandled() { + return true; + } + + /** + * @generated + */ + public void removeHandlerListener(IHandlerListener handlerListener) { + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDiagramUpdater.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDiagramUpdater.java new file mode 100644 index 00000000..fea65624 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDiagramUpdater.java @@ -0,0 +1,292 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import java.util.Collection; +import java.util.Collections; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EStructuralFeature; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.gmf.runtime.notation.View; +import org.eclipse.gmf.tooling.runtime.update.DiagramUpdater; +import de.darmstadt.tu.crossing.crySL.Expression; +import de.darmstadt.tu.crossing.crySL.impl.ExpressionImpl; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.OrderEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.StateEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.TransitionEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineElementTypes; +import de.darmstadt.tu.crossing.statemachine.diagram.smgbuilder.StateMachineGraph; +import de.darmstadt.tu.crossing.statemachine.diagram.smgbuilder.StateMachineGraphBuilder; +import de.darmstadt.tu.crossing.statemachine.diagram.smgbuilder.StateNode; +import de.darmstadt.tu.crossing.statemachine.diagram.smgbuilder.TransitionEdge; +import de.darmstadt.tu.crossing.crySL.CrySLPackage; +import de.darmstadt.tu.crossing.crySL.Event; + +/** + * @generated + */ +public class StatemachineDiagramUpdater { + + /** + * @generated + */ + public static List getSemanticChildren(View view) { + switch (StatemachineVisualIDRegistry.getVisualID(view)) { + case OrderEditPart.VISUAL_ID: + return getStatemachine_1000SemanticChildren(view); + } + return Collections.emptyList(); + } + + /** + * @generated + */ + public static List getStatemachine_1000SemanticChildren(View view) { + if (!view.isSetElement()) { + return Collections.emptyList(); + } + Expression modelElement = (Expression) view.getElement(); + + StateMachineGraph smg = buildStateMachineGraph(modelElement); + LinkedList result = new LinkedList(); + + for (StateNode node : smg.getNodes()) { + int visualID = StatemachineVisualIDRegistry.getNodeVisualID(view, smg.getNodeMap().get(node.getName())); + if (visualID == StateEditPart.VISUAL_ID) { + result.add(new StatemachineNodeDescriptor((ExpressionImpl) smg.getNodeMap().get(node.getName()), + visualID)); + continue; + } + } + Collections.reverse(result); + return result; + } + + private static StateMachineGraph buildStateMachineGraph(final Expression order) { + final StateMachineGraphBuilder smgb = new StateMachineGraphBuilder(order); + return smgb.buildSMG(); + } + + /** + * @generated + */ + public static List getContainedLinks(View view) { + switch (StatemachineVisualIDRegistry.getVisualID(view)) { + case OrderEditPart.VISUAL_ID: + return getStatemachine_1000ContainedLinks(view); + case StateEditPart.VISUAL_ID: + return getState_2001ContainedLinks(view); + case TransitionEditPart.VISUAL_ID: + return getTransition_4001ContainedLinks(view); + } + return Collections.emptyList(); + } + + /** + * @generated + */ + public static List getIncomingLinks(View view) { + switch (StatemachineVisualIDRegistry.getVisualID(view)) { + case StateEditPart.VISUAL_ID: + return getState_2001IncomingLinks(view); + case TransitionEditPart.VISUAL_ID: + return getTransition_4001IncomingLinks(view); + } + return Collections.emptyList(); + } + + /** + * @generated + */ + public static List getOutgoingLinks(View view) { + switch (StatemachineVisualIDRegistry.getVisualID(view)) { + case StateEditPart.VISUAL_ID: + return getState_2001OutgoingLinks(view); + case TransitionEditPart.VISUAL_ID: + return getTransition_4001OutgoingLinks(view); + } + return Collections.emptyList(); + } + + /** + * @generated + */ + public static List getStatemachine_1000ContainedLinks(View view) { + Expression modelElement = (Expression) view.getElement(); + LinkedList result = new LinkedList(); + result.addAll(getContainedTypeModelFacetLinks_Transition_4001(modelElement)); + return result; + } + + /** + * @generated + */ + public static List getState_2001ContainedLinks(View view) { + return Collections.emptyList(); + } + + /** + * @generated + */ + public static List getTransition_4001ContainedLinks(View view) { + return Collections.emptyList(); + } + + /** + * @generated + */ + public static List getState_2001IncomingLinks(View view) { + Event modelElement = (Event) view.getElement(); + Map> crossReferences = EcoreUtil.CrossReferencer + .find(view.eResource().getResourceSet().getResources()); + LinkedList result = new LinkedList(); + result.addAll(getIncomingTypeModelFacetLinks_Transition_4001(modelElement, crossReferences)); + return result; + } + + /** + * @generated + */ + public static List getTransition_4001IncomingLinks(View view) { + return Collections.emptyList(); + } + + /** + * @generated + */ + public static List getState_2001OutgoingLinks(View view) { + Event modelElement = (Event) view.getElement(); + LinkedList result = new LinkedList(); + result.addAll(getOutgoingTypeModelFacetLinks_Transition_4001(modelElement)); + return result; + } + + /** + * @generated + */ + public static List getTransition_4001OutgoingLinks(View view) { + return Collections.emptyList(); + } + + /** + * @generated + */ + private static Collection getContainedTypeModelFacetLinks_Transition_4001( + Expression container) { + LinkedList result = new LinkedList(); + StateMachineGraph smg = buildStateMachineGraph(container); + for (TransitionEdge edge : smg.getEdges()) { + if (TransitionEditPart.VISUAL_ID != StatemachineVisualIDRegistry + .getLinkWithClassVisualID(edge.getLabel())) { + continue; + } + Expression src = (Expression) smg.getNodeMap().get(edge.getLeft().getName()); + Expression dst = (Expression) smg.getNodeMap().get(edge.getRight().getName()); + result.add(new StatemachineLinkDescriptor(src, dst, edge.getLabel(), + StatemachineElementTypes.Transition_4001, TransitionEditPart.VISUAL_ID)); + } + + return result; + } + + /** + * @generated + */ + private static Collection getIncomingTypeModelFacetLinks_Transition_4001(Event target, + Map> crossReferences) { + LinkedList result = new LinkedList(); + Collection settings = crossReferences.get(target); + for (EStructuralFeature.Setting setting : settings) { + if (setting.getEStructuralFeature() != CrySLPackage.eINSTANCE.getExpression_Elementop() + || false == setting.getEObject() instanceof Event) { + continue; + } + Event link = (Event) setting.getEObject(); + if (TransitionEditPart.VISUAL_ID != StatemachineVisualIDRegistry.getLinkWithClassVisualID(link)) { + continue; + } + Event src = link; + result.add(new StatemachineLinkDescriptor(src, target, link, StatemachineElementTypes.Transition_4001, + TransitionEditPart.VISUAL_ID)); + } + return result; + } + + /** + * @generated + */ + private static Collection getOutgoingTypeModelFacetLinks_Transition_4001(Event source) { + Expression container = null; + // Find container element for the link. + // Climb up by containment hierarchy starting from the source + // and return the first element that is instance of the container class. + for (EObject element = source; element != null && container == null; element = element.eContainer()) { + if (element instanceof Expression) { + container = (Expression) element; + } + } + if (container == null) { + return Collections.emptyList(); + } + LinkedList result = new LinkedList(); + for (Iterator links = container.getOrderEv().iterator(); links.hasNext();) { + EObject linkObject = (EObject) links.next(); + if (false == linkObject instanceof Event) { + continue; + } + Event link = (Event) linkObject; + if (TransitionEditPart.VISUAL_ID != StatemachineVisualIDRegistry.getLinkWithClassVisualID(link)) { + continue; + } + Event dst = link; + Event src = link; + if (src != source) { + continue; + } + result.add(new StatemachineLinkDescriptor(src, dst, link, StatemachineElementTypes.Transition_4001, + TransitionEditPart.VISUAL_ID)); + } + return result; + } + + /** + * @generated + */ + public static final DiagramUpdater TYPED_INSTANCE = new DiagramUpdater() { + /** + * @generated + */ + @Override + public List getSemanticChildren(View view) { + return StatemachineDiagramUpdater.getSemanticChildren(view); + } + + /** + * @generated + */ + @Override + public List getContainedLinks(View view) { + return StatemachineDiagramUpdater.getContainedLinks(view); + } + + /** + * @generated + */ + @Override + public List getIncomingLinks(View view) { + return StatemachineDiagramUpdater.getIncomingLinks(view); + } + + /** + * @generated + */ + @Override + public List getOutgoingLinks(View view) { + return StatemachineDiagramUpdater.getOutgoingLinks(view); + } + }; + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDocumentProvider.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDocumentProvider.java new file mode 100644 index 00000000..cd4dd257 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineDocumentProvider.java @@ -0,0 +1,1132 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; + +import org.eclipse.core.commands.ExecutionException; +import org.eclipse.core.resources.IFile; +import org.eclipse.core.resources.IResource; +import org.eclipse.core.resources.IResourceStatus; +import org.eclipse.core.resources.IStorage; +import org.eclipse.core.resources.ResourcesPlugin; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.Path; +import org.eclipse.core.runtime.Status; +import org.eclipse.core.runtime.jobs.ISchedulingRule; +import org.eclipse.core.runtime.jobs.MultiRule; +import org.eclipse.emf.common.command.AbstractCommand; +import org.eclipse.emf.common.notify.Adapter; +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.Notifier; +import org.eclipse.emf.common.ui.URIEditorInput; +import org.eclipse.emf.common.util.URI; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.emf.ecore.resource.ResourceSet; +import org.eclipse.emf.ecore.util.EContentAdapter; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.emf.transaction.NotificationFilter; +import org.eclipse.emf.transaction.TransactionalEditingDomain; +import org.eclipse.emf.workspace.util.WorkspaceSynchronizer; +import org.eclipse.gmf.runtime.common.core.command.CommandResult; +import org.eclipse.gmf.runtime.diagram.core.DiagramEditingDomainFactory; +import org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.AbstractDocumentProvider; +import org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.DiagramDocument; +import org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.IDiagramDocument; +import org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.IDiagramDocumentProvider; +import org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.IDocument; +import org.eclipse.gmf.runtime.diagram.ui.resources.editor.internal.EditorStatusCodes; +import org.eclipse.gmf.runtime.diagram.ui.resources.editor.internal.util.DiagramIOUtil; +import org.eclipse.gmf.runtime.emf.commands.core.command.AbstractTransactionalCommand; +import org.eclipse.gmf.runtime.emf.core.resources.GMFResourceFactory; +import org.eclipse.gmf.runtime.notation.Diagram; +import org.eclipse.jface.operation.IRunnableContext; +import org.eclipse.osgi.util.NLS; +import org.eclipse.swt.widgets.Display; +import org.eclipse.ui.IEditorInput; +import org.eclipse.ui.part.FileEditorInput; + +/** + * @generated + */ +public class StatemachineDocumentProvider extends AbstractDocumentProvider + implements IDiagramDocumentProvider { + + /** + * @generated + */ + protected ElementInfo createElementInfo(Object element) + throws CoreException { + if (false == element instanceof FileEditorInput + && false == element instanceof URIEditorInput) { + throw new CoreException( + new Status( + IStatus.ERROR, + StatemachineDiagramEditorPlugin.ID, + 0, + NLS.bind( + Messages.StatemachineDocumentProvider_IncorrectInputError, + new Object[] { + element, + "org.eclipse.ui.part.FileEditorInput", "org.eclipse.emf.common.ui.URIEditorInput" }), //$NON-NLS-1$ //$NON-NLS-2$ + null)); + } + IEditorInput editorInput = (IEditorInput) element; + IDiagramDocument document = (IDiagramDocument) createDocument(editorInput); + + ResourceSetInfo info = new ResourceSetInfo(document, editorInput); + info.setModificationStamp(computeModificationStamp(info)); + info.fStatus = null; + return info; + } + + /** + * @generated + */ + protected IDocument createDocument(Object element) throws CoreException { + if (false == element instanceof FileEditorInput + && false == element instanceof URIEditorInput) { + throw new CoreException( + new Status( + IStatus.ERROR, + StatemachineDiagramEditorPlugin.ID, + 0, + NLS.bind( + Messages.StatemachineDocumentProvider_IncorrectInputError, + new Object[] { + element, + "org.eclipse.ui.part.FileEditorInput", "org.eclipse.emf.common.ui.URIEditorInput" }), //$NON-NLS-1$ //$NON-NLS-2$ + null)); + } + IDocument document = createEmptyDocument(); + setDocumentContent(document, (IEditorInput) element); + setupDocument(element, document); + return document; + } + + /** + * Sets up the given document as it would be provided for the given element. The + * content of the document is not changed. This default implementation is empty. + * Subclasses may reimplement. + * + * @param element the blue-print element + * @param document the document to set up + * @generated + */ + protected void setupDocument(Object element, IDocument document) { + // for subclasses + } + + /** + * @generated + */ + private long computeModificationStamp(ResourceSetInfo info) { + int result = 0; + for (Iterator it = info.getLoadedResourcesIterator(); it + .hasNext();) { + Resource nextResource = it.next(); + IFile file = WorkspaceSynchronizer.getFile(nextResource); + if (file != null) { + if (file.getLocation() != null) { + result += file.getLocation().toFile().lastModified(); + } else { + result += file.getModificationStamp(); + } + } + } + return result; + } + + /** + * @generated + */ + protected IDocument createEmptyDocument() { + DiagramDocument document = new DiagramDocument(); + document.setEditingDomain(createEditingDomain()); + return document; + } + + /** + * @generated + */ + private TransactionalEditingDomain createEditingDomain() { + TransactionalEditingDomain editingDomain = DiagramEditingDomainFactory + .getInstance().createEditingDomain(); + editingDomain.setID("de.darmstadt.tu.crossing.CrySL.statemachine.diagram.EditingDomain"); + //.setID("de.darmstadt.tu.crossing.statemachine.diagram.EditingDomain"); //$NON-NLS-1$ + final NotificationFilter diagramResourceModifiedFilter = NotificationFilter + .createNotifierFilter(editingDomain.getResourceSet()) + .and(NotificationFilter.createEventTypeFilter(Notification.ADD)) + .and(NotificationFilter.createFeatureFilter(ResourceSet.class, + ResourceSet.RESOURCE_SET__RESOURCES)); + editingDomain.getResourceSet().eAdapters().add(new Adapter() { + + private Notifier myTarger; + + public Notifier getTarget() { + return myTarger; + } + + public boolean isAdapterForType(Object type) { + return false; + } + + public void notifyChanged(Notification notification) { + if (diagramResourceModifiedFilter.matches(notification)) { + Object value = notification.getNewValue(); + if (value instanceof Resource) { + ((Resource) value).setTrackingModification(true); + } + } + } + + public void setTarget(Notifier newTarget) { + myTarger = newTarget; + } + + }); + + return editingDomain; + } + + /** + * @generated + */ + protected void setDocumentContent(IDocument document, IEditorInput element) + throws CoreException { + IDiagramDocument diagramDocument = (IDiagramDocument) document; + TransactionalEditingDomain domain = diagramDocument.getEditingDomain(); + if (element instanceof FileEditorInput) { + IStorage storage = ((FileEditorInput) element).getStorage(); + Diagram diagram = DiagramIOUtil.load(domain, storage, true, + getProgressMonitor()); + document.setContent(diagram); + } else if (element instanceof URIEditorInput) { + URI uri = ((URIEditorInput) element).getURI(); + Resource resource = null; + try { + resource = domain.getResourceSet().getResource( + uri.trimFragment(), false); + if (resource == null) { + resource = domain.getResourceSet().createResource( + uri.trimFragment()); + } + if (!resource.isLoaded()) { + try { + Map options = new HashMap( + GMFResourceFactory.getDefaultLoadOptions()); + // @see 171060 + // options.put(org.eclipse.emf.ecore.xmi.XMLResource.OPTION_RECORD_UNKNOWN_FEATURE, Boolean.TRUE); + resource.load(options); + } catch (IOException e) { + resource.unload(); + throw e; + } + } + if (uri.fragment() != null) { + EObject rootElement = resource.getEObject(uri.fragment()); + if (rootElement instanceof Diagram) { + document.setContent((Diagram) rootElement); + return; + } + } else { + for (Iterator it = resource.getContents().iterator(); it + .hasNext();) { + Object rootElement = it.next(); + if (rootElement instanceof Diagram) { + document.setContent((Diagram) rootElement); + return; + } + } + } + throw new RuntimeException( + Messages.StatemachineDocumentProvider_NoDiagramInResourceError); + } catch (Exception e) { + CoreException thrownExcp = null; + if (e instanceof CoreException) { + thrownExcp = (CoreException) e; + } else { + String msg = e.getLocalizedMessage(); + thrownExcp = new CoreException( + new Status( + IStatus.ERROR, + StatemachineDiagramEditorPlugin.ID, + 0, + msg != null ? msg + : Messages.StatemachineDocumentProvider_DiagramLoadingError, + e)); + } + throw thrownExcp; + } + } else { + throw new CoreException( + new Status( + IStatus.ERROR, + StatemachineDiagramEditorPlugin.ID, + 0, + NLS.bind( + Messages.StatemachineDocumentProvider_IncorrectInputError, + new Object[] { + element, + "org.eclipse.ui.part.FileEditorInput", "org.eclipse.emf.common.ui.URIEditorInput" }), //$NON-NLS-1$ //$NON-NLS-2$ + null)); + } + } + + /** + * @generated + */ + public long getModificationStamp(Object element) { + ResourceSetInfo info = getResourceSetInfo(element); + if (info != null) { + return computeModificationStamp(info); + } + return super.getModificationStamp(element); + } + + /** + * @generated + */ + public boolean isDeleted(Object element) { + IDiagramDocument document = getDiagramDocument(element); + if (document != null) { + Resource diagramResource = document.getDiagram().eResource(); + if (diagramResource != null) { + IFile file = WorkspaceSynchronizer.getFile(diagramResource); + return file == null || file.getLocation() == null + || !file.getLocation().toFile().exists(); + } + } + return super.isDeleted(element); + } + + /** + * @generated + */ + public ResourceSetInfo getResourceSetInfo(Object editorInput) { + return (ResourceSetInfo) super.getElementInfo(editorInput); + } + + /** + * @generated + */ + protected void disposeElementInfo(Object element, ElementInfo info) { + if (info instanceof ResourceSetInfo) { + ResourceSetInfo resourceSetInfo = (ResourceSetInfo) info; + resourceSetInfo.dispose(); + } + super.disposeElementInfo(element, info); + } + + /** + * @generated + */ + protected void doValidateState(Object element, Object computationContext) + throws CoreException { + ResourceSetInfo info = getResourceSetInfo(element); + if (info != null) { + LinkedList files2Validate = new LinkedList(); + for (Iterator it = info.getLoadedResourcesIterator(); it + .hasNext();) { + Resource nextResource = it.next(); + IFile file = WorkspaceSynchronizer.getFile(nextResource); + if (file != null && file.isReadOnly()) { + files2Validate.add(file); + } + } + ResourcesPlugin.getWorkspace().validateEdit( + (IFile[]) files2Validate.toArray(new IFile[files2Validate + .size()]), computationContext); + } + + super.doValidateState(element, computationContext); + } + + /** + * @generated + */ + public boolean isReadOnly(Object element) { + ResourceSetInfo info = getResourceSetInfo(element); + if (info != null) { + if (info.isUpdateCache()) { + try { + updateCache(element); + } catch (CoreException ex) { + StatemachineDiagramEditorPlugin.getInstance().logError( + Messages.StatemachineDocumentProvider_isModifiable, + ex); + // Error message to log was initially taken from org.eclipse.gmf.runtime.diagram.ui.resources.editor.ide.internal.l10n.EditorMessages.StorageDocumentProvider_isModifiable + } + } + return info.isReadOnly(); + } + return super.isReadOnly(element); + } + + /** + * @generated + */ + public boolean isModifiable(Object element) { + if (!isStateValidated(element)) { + if (element instanceof FileEditorInput + || element instanceof URIEditorInput) { + return true; + } + } + ResourceSetInfo info = getResourceSetInfo(element); + if (info != null) { + if (info.isUpdateCache()) { + try { + updateCache(element); + } catch (CoreException ex) { + StatemachineDiagramEditorPlugin.getInstance().logError( + Messages.StatemachineDocumentProvider_isModifiable, + ex); + // Error message to log was initially taken from org.eclipse.gmf.runtime.diagram.ui.resources.editor.ide.internal.l10n.EditorMessages.StorageDocumentProvider_isModifiable + } + } + return info.isModifiable(); + } + return super.isModifiable(element); + } + + /** + * @generated + */ + protected void updateCache(Object element) throws CoreException { + ResourceSetInfo info = getResourceSetInfo(element); + if (info != null) { + for (Iterator it = info.getLoadedResourcesIterator(); it + .hasNext();) { + Resource nextResource = it.next(); + IFile file = WorkspaceSynchronizer.getFile(nextResource); + if (file != null && file.isReadOnly()) { + info.setReadOnly(true); + info.setModifiable(false); + return; + } + } + info.setReadOnly(false); + info.setModifiable(true); + return; + } + } + + /** + * @generated + */ + protected void doUpdateStateCache(Object element) throws CoreException { + ResourceSetInfo info = getResourceSetInfo(element); + if (info != null) { + info.setUpdateCache(true); + } + super.doUpdateStateCache(element); + } + + /** + * @generated + */ + public boolean isSynchronized(Object element) { + ResourceSetInfo info = getResourceSetInfo(element); + if (info != null) { + return info.isSynchronized(); + } + return super.isSynchronized(element); + } + + /** + * @generated + */ + protected ISchedulingRule getResetRule(Object element) { + ResourceSetInfo info = getResourceSetInfo(element); + if (info != null) { + LinkedList rules = new LinkedList(); + for (Iterator it = info.getLoadedResourcesIterator(); it + .hasNext();) { + Resource nextResource = it.next(); + IFile file = WorkspaceSynchronizer.getFile(nextResource); + if (file != null) { + rules.add(ResourcesPlugin.getWorkspace().getRuleFactory() + .modifyRule(file)); + } + } + return new MultiRule( + (ISchedulingRule[]) rules.toArray(new ISchedulingRule[rules + .size()])); + } + return null; + } + + /** + * @generated + */ + protected ISchedulingRule getSaveRule(Object element) { + ResourceSetInfo info = getResourceSetInfo(element); + if (info != null) { + LinkedList rules = new LinkedList(); + for (Iterator it = info.getLoadedResourcesIterator(); it + .hasNext();) { + Resource nextResource = it.next(); + IFile file = WorkspaceSynchronizer.getFile(nextResource); + if (file != null) { + rules.add(computeSchedulingRule(file)); + } + } + return new MultiRule( + (ISchedulingRule[]) rules.toArray(new ISchedulingRule[rules + .size()])); + } + return null; + } + + /** + * @generated + */ + protected ISchedulingRule getSynchronizeRule(Object element) { + ResourceSetInfo info = getResourceSetInfo(element); + if (info != null) { + LinkedList rules = new LinkedList(); + for (Iterator it = info.getLoadedResourcesIterator(); it + .hasNext();) { + Resource nextResource = it.next(); + IFile file = WorkspaceSynchronizer.getFile(nextResource); + if (file != null) { + rules.add(ResourcesPlugin.getWorkspace().getRuleFactory() + .refreshRule(file)); + } + } + return new MultiRule( + (ISchedulingRule[]) rules.toArray(new ISchedulingRule[rules + .size()])); + } + return null; + } + + /** + * @generated + */ + protected ISchedulingRule getValidateStateRule(Object element) { + ResourceSetInfo info = getResourceSetInfo(element); + if (info != null) { + LinkedList files = new LinkedList(); + for (Iterator it = info.getLoadedResourcesIterator(); it + .hasNext();) { + Resource nextResource = it.next(); + IFile file = WorkspaceSynchronizer.getFile(nextResource); + if (file != null) { + files.add(file); + } + } + return ResourcesPlugin + .getWorkspace() + .getRuleFactory() + .validateEditRule( + (IFile[]) files.toArray(new IFile[files.size()])); + } + return null; + } + + /** + * @generated + */ + private ISchedulingRule computeSchedulingRule(IResource toCreateOrModify) { + if (toCreateOrModify.exists()) + return ResourcesPlugin.getWorkspace().getRuleFactory() + .modifyRule(toCreateOrModify); + + IResource parent = toCreateOrModify; + do { + /* + * XXX This is a workaround for + * https://bugs.eclipse.org/bugs/show_bug.cgi?id=67601 + * IResourceRuleFactory.createRule should iterate the hierarchy + * itself. + */ + toCreateOrModify = parent; + parent = toCreateOrModify.getParent(); + } while (parent != null && !parent.exists()); + + return ResourcesPlugin.getWorkspace().getRuleFactory() + .createRule(toCreateOrModify); + } + + /** + * @generated + */ + protected void doSynchronize(Object element, IProgressMonitor monitor) + throws CoreException { + ResourceSetInfo info = getResourceSetInfo(element); + if (info != null) { + for (Iterator it = info.getLoadedResourcesIterator(); it + .hasNext();) { + Resource nextResource = it.next(); + handleElementChanged(info, nextResource, monitor); + } + return; + } + super.doSynchronize(element, monitor); + } + + /** + * @generated + */ + protected void doSaveDocument(IProgressMonitor monitor, Object element, + IDocument document, boolean overwrite) throws CoreException { + ResourceSetInfo info = getResourceSetInfo(element); + if (info != null) { + if (!overwrite && !info.isSynchronized()) { + throw new CoreException( + new Status( + IStatus.ERROR, + StatemachineDiagramEditorPlugin.ID, + IResourceStatus.OUT_OF_SYNC_LOCAL, + Messages.StatemachineDocumentProvider_UnsynchronizedFileSaveError, + null)); + } + info.stopResourceListening(); + fireElementStateChanging(element); + try { + monitor.beginTask( + Messages.StatemachineDocumentProvider_SaveDiagramTask, + info.getResourceSet().getResources().size() + 1); //"Saving diagram" + for (Iterator it = info.getLoadedResourcesIterator(); it + .hasNext();) { + Resource nextResource = it.next(); + monitor.setTaskName(NLS + .bind(Messages.StatemachineDocumentProvider_SaveNextResourceTask, + nextResource.getURI())); + if (nextResource.isLoaded() + && !info.getEditingDomain() + .isReadOnly(nextResource)) { + try { + nextResource.save(StatemachineDiagramEditorUtil + .getSaveOptions()); + } catch (IOException e) { + fireElementStateChangeFailed(element); + throw new CoreException(new Status(IStatus.ERROR, + StatemachineDiagramEditorPlugin.ID, + EditorStatusCodes.RESOURCE_FAILURE, + e.getLocalizedMessage(), null)); + } + } + monitor.worked(1); + } + monitor.done(); + info.setModificationStamp(computeModificationStamp(info)); + } catch (RuntimeException x) { + fireElementStateChangeFailed(element); + throw x; + } finally { + info.startResourceListening(); + } + } else { + URI newResoruceURI; + List affectedFiles = null; + if (element instanceof FileEditorInput) { + IFile newFile = ((FileEditorInput) element).getFile(); + affectedFiles = Collections.singletonList(newFile); + newResoruceURI = URI.createPlatformResourceURI(newFile + .getFullPath().toString(), true); + } else if (element instanceof URIEditorInput) { + newResoruceURI = ((URIEditorInput) element).getURI(); + } else { + fireElementStateChangeFailed(element); + throw new CoreException( + new Status( + IStatus.ERROR, + StatemachineDiagramEditorPlugin.ID, + 0, + NLS.bind( + Messages.StatemachineDocumentProvider_IncorrectInputError, + new Object[] { + element, + "org.eclipse.ui.part.FileEditorInput", "org.eclipse.emf.common.ui.URIEditorInput" }), //$NON-NLS-1$ //$NON-NLS-2$ + null)); + } + if (false == document instanceof IDiagramDocument) { + fireElementStateChangeFailed(element); + throw new CoreException( + new Status( + IStatus.ERROR, + StatemachineDiagramEditorPlugin.ID, + 0, + "Incorrect document used: " + document + " instead of org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.IDiagramDocument", null)); //$NON-NLS-1$ //$NON-NLS-2$ + } + IDiagramDocument diagramDocument = (IDiagramDocument) document; + final Resource newResource = diagramDocument.getEditingDomain() + .getResourceSet().createResource(newResoruceURI); + final Diagram diagramCopy = (Diagram) EcoreUtil + .copy(diagramDocument.getDiagram()); + try { + new AbstractTransactionalCommand( + diagramDocument.getEditingDomain(), + NLS.bind( + Messages.StatemachineDocumentProvider_SaveAsOperation, + diagramCopy.getName()), affectedFiles) { + protected CommandResult doExecuteWithResult( + IProgressMonitor monitor, IAdaptable info) + throws ExecutionException { + newResource.getContents().add(diagramCopy); + return CommandResult.newOKCommandResult(); + } + }.execute(monitor, null); + newResource + .save(StatemachineDiagramEditorUtil.getSaveOptions()); + } catch (ExecutionException e) { + fireElementStateChangeFailed(element); + throw new CoreException(new Status(IStatus.ERROR, + StatemachineDiagramEditorPlugin.ID, 0, + e.getLocalizedMessage(), null)); + } catch (IOException e) { + fireElementStateChangeFailed(element); + throw new CoreException(new Status(IStatus.ERROR, + StatemachineDiagramEditorPlugin.ID, 0, + e.getLocalizedMessage(), null)); + } + newResource.unload(); + } + } + + /** + * @generated + */ + protected void handleElementChanged(ResourceSetInfo info, + Resource changedResource, IProgressMonitor monitor) { + IFile file = WorkspaceSynchronizer.getFile(changedResource); + if (file != null) { + try { + file.refreshLocal(IResource.DEPTH_INFINITE, monitor); + } catch (CoreException ex) { + StatemachineDiagramEditorPlugin + .getInstance() + .logError( + Messages.StatemachineDocumentProvider_handleElementContentChanged, + ex); + // Error message to log was initially taken from org.eclipse.gmf.runtime.diagram.ui.resources.editor.ide.internal.l10n.EditorMessages.FileDocumentProvider_handleElementContentChanged + } + } + changedResource.unload(); + + fireElementContentAboutToBeReplaced(info.getEditorInput()); + removeUnchangedElementListeners(info.getEditorInput(), info); + info.fStatus = null; + try { + setDocumentContent(info.fDocument, info.getEditorInput()); + } catch (CoreException e) { + info.fStatus = e.getStatus(); + } + if (!info.fCanBeSaved) { + info.setModificationStamp(computeModificationStamp(info)); + } + addUnchangedElementListeners(info.getEditorInput(), info); + fireElementContentReplaced(info.getEditorInput()); + } + + /** + * @generated + */ + protected void handleElementMoved(IEditorInput input, URI uri) { + if (input instanceof FileEditorInput) { + IFile newFile = ResourcesPlugin + .getWorkspace() + .getRoot() + .getFile( + new Path(URI.decode(uri.path())) + .removeFirstSegments(1)); + fireElementMoved(input, newFile == null ? null + : new FileEditorInput(newFile)); + return; + } + // TODO: append suffix to the URI! (use diagram as a parameter) + fireElementMoved(input, new URIEditorInput(uri)); + } + + /** + * @generated + */ + public IEditorInput createInputWithEditingDomain(IEditorInput editorInput, + TransactionalEditingDomain domain) { + return editorInput; + } + + /** + * @generated + */ + public IDiagramDocument getDiagramDocument(Object element) { + IDocument doc = getDocument(element); + if (doc instanceof IDiagramDocument) { + return (IDiagramDocument) doc; + } + return null; + } + + /** + * @generated + */ + protected IRunnableContext getOperationRunner(IProgressMonitor monitor) { + return null; + } + + /** + * @generated + */ + protected class ResourceSetInfo extends ElementInfo { + + /** + * @generated + */ + private long myModificationStamp = IResource.NULL_STAMP; + + /** + * @generated + */ + private WorkspaceSynchronizer mySynchronizer; + + /** + * @generated + */ + private LinkedList myUnSynchronizedResources = new LinkedList(); + + /** + * @generated + */ + private IDiagramDocument myDocument; + + /** + * @generated + */ + private IEditorInput myEditorInput; + + /** + * @generated + */ + private boolean myUpdateCache = true; + + /** + * @generated + */ + private boolean myModifiable = false; + + /** + * @generated + */ + private boolean myReadOnly = true; + + /** + * @generated + */ + private ResourceSetModificationListener myResourceSetListener; + + /** + * @generated + */ + public ResourceSetInfo(IDiagramDocument document, + IEditorInput editorInput) { + super(document); + myDocument = document; + myEditorInput = editorInput; + startResourceListening(); + myResourceSetListener = new ResourceSetModificationListener(this); + getResourceSet().eAdapters().add(myResourceSetListener); + } + + /** + * @generated + */ + public long getModificationStamp() { + return myModificationStamp; + } + + /** + * @generated + */ + public void setModificationStamp(long modificationStamp) { + myModificationStamp = modificationStamp; + } + + /** + * @generated + */ + public TransactionalEditingDomain getEditingDomain() { + return myDocument.getEditingDomain(); + } + + /** + * @generated + */ + public ResourceSet getResourceSet() { + return getEditingDomain().getResourceSet(); + } + + /** + * @generated + */ + public Iterator getLoadedResourcesIterator() { + return new ArrayList(getResourceSet().getResources()) + .iterator(); + } + + /** + * @generated + */ + public IEditorInput getEditorInput() { + return myEditorInput; + } + + /** + * @generated + */ + public void dispose() { + stopResourceListening(); + getResourceSet().eAdapters().remove(myResourceSetListener); + for (Iterator it = getLoadedResourcesIterator(); it + .hasNext();) { + Resource resource = it.next(); + resource.unload(); + } + getEditingDomain().dispose(); + } + + /** + * @generated + */ + public boolean isSynchronized() { + return myUnSynchronizedResources.size() == 0; + } + + /** + * @generated + */ + public void setUnSynchronized(Resource resource) { + myUnSynchronizedResources.add(resource); + } + + /** + * @generated + */ + public void setSynchronized(Resource resource) { + myUnSynchronizedResources.remove(resource); + } + + /** + * @generated + */ + public final void stopResourceListening() { + mySynchronizer.dispose(); + mySynchronizer = null; + } + + /** + * @generated + */ + public final void startResourceListening() { + mySynchronizer = new WorkspaceSynchronizer(getEditingDomain(), + new SynchronizerDelegate()); + } + + /** + * @generated + */ + public boolean isUpdateCache() { + return myUpdateCache; + } + + /** + * @generated + */ + public void setUpdateCache(boolean update) { + myUpdateCache = update; + } + + /** + * @generated + */ + public boolean isModifiable() { + return myModifiable; + } + + /** + * @generated + */ + public void setModifiable(boolean modifiable) { + myModifiable = modifiable; + } + + /** + * @generated + */ + public boolean isReadOnly() { + return myReadOnly; + } + + /** + * @generated + */ + public void setReadOnly(boolean readOnly) { + myReadOnly = readOnly; + } + + /** + * @generated + */ + private class SynchronizerDelegate implements + WorkspaceSynchronizer.Delegate { + + /** + * @generated + */ + public void dispose() { + } + + /** + * @generated + */ + public boolean handleResourceChanged(final Resource resource) { + synchronized (ResourceSetInfo.this) { + if (ResourceSetInfo.this.fCanBeSaved) { + ResourceSetInfo.this.setUnSynchronized(resource); + return true; + } + } + Display.getDefault().asyncExec(new Runnable() { + public void run() { + handleElementChanged(ResourceSetInfo.this, resource, + null); + } + }); + return true; + } + + /** + * @generated + */ + public boolean handleResourceDeleted(Resource resource) { + synchronized (ResourceSetInfo.this) { + if (ResourceSetInfo.this.fCanBeSaved) { + ResourceSetInfo.this.setUnSynchronized(resource); + return true; + } + } + Display.getDefault().asyncExec(new Runnable() { + public void run() { + fireElementDeleted(ResourceSetInfo.this + .getEditorInput()); + } + }); + return true; + } + + /** + * @generated + */ + public boolean handleResourceMoved(Resource resource, + final URI newURI) { + synchronized (ResourceSetInfo.this) { + if (ResourceSetInfo.this.fCanBeSaved) { + ResourceSetInfo.this.setUnSynchronized(resource); + return true; + } + } + if (myDocument.getDiagram().eResource() == resource) { + Display.getDefault().asyncExec(new Runnable() { + public void run() { + handleElementMoved( + ResourceSetInfo.this.getEditorInput(), + newURI); + } + }); + } else { + handleResourceDeleted(resource); + } + return true; + } + + } + + } + + /** + * @generated + */ + private class ResourceSetModificationListener extends EContentAdapter { + + /** + * @generated + */ + private NotificationFilter myModifiedFilter; + + /** + * @generated + */ + private ResourceSetInfo myInfo; + + /** + * @generated + */ + public ResourceSetModificationListener(ResourceSetInfo info) { + myInfo = info; + myModifiedFilter = NotificationFilter + .createEventTypeFilter(Notification.SET) + .or(NotificationFilter + .createEventTypeFilter(Notification.UNSET)) + .and(NotificationFilter.createFeatureFilter(Resource.class, + Resource.RESOURCE__IS_MODIFIED)); + } + + /** + * @generated + */ + public void notifyChanged(Notification notification) { + if (notification.getNotifier() instanceof ResourceSet) { + super.notifyChanged(notification); + } + if (!notification.isTouch() + && myModifiedFilter.matches(notification)) { + if (notification.getNotifier() instanceof Resource) { + Resource resource = (Resource) notification.getNotifier(); + if (resource.isLoaded()) { + boolean modified = false; + for (Iterator/**/it = myInfo + .getLoadedResourcesIterator(); it.hasNext() + && !modified;) { + Resource nextResource = (Resource) it.next(); + if (nextResource.isLoaded()) { + modified = nextResource.isModified(); + } + } + boolean dirtyStateChanged = false; + synchronized (myInfo) { + if (modified != myInfo.fCanBeSaved) { + myInfo.fCanBeSaved = modified; + dirtyStateChanged = true; + } + if (!resource.isModified()) { + myInfo.setSynchronized(resource); + } + } + if (dirtyStateChanged) { + fireElementDirtyStateChanged( + myInfo.getEditorInput(), modified); + + if (!modified) { + myInfo.setModificationStamp(computeModificationStamp(myInfo)); + } + } + } + } + } + } + + } + +} + diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineInitDiagramFileAction.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineInitDiagramFileAction.java new file mode 100644 index 00000000..b3c7c960 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineInitDiagramFileAction.java @@ -0,0 +1,92 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import org.eclipse.core.resources.IFile; +import org.eclipse.emf.common.util.URI; +import org.eclipse.emf.common.util.WrappedException; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.emf.ecore.resource.ResourceSet; +import org.eclipse.emf.transaction.TransactionalEditingDomain; +import org.eclipse.gmf.runtime.emf.core.GMFEditingDomainFactory; +import org.eclipse.jface.action.IAction; +import org.eclipse.jface.dialogs.MessageDialog; +import org.eclipse.jface.viewers.ISelection; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.wizard.Wizard; +import org.eclipse.osgi.util.NLS; +import org.eclipse.swt.widgets.Shell; +import org.eclipse.ui.IObjectActionDelegate; +import org.eclipse.ui.IWorkbenchPart; + +import de.darmstadt.tu.crossing.crySL.Domainmodel; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.OrderEditPart; + +/** + * @generated + */ +public class StatemachineInitDiagramFileAction implements IObjectActionDelegate { + + /** + * @generated + */ + private IWorkbenchPart targetPart; + + /** + * @generated + */ + private URI domainModelURI; + + /** + * @generated + */ + public void setActivePart(IAction action, IWorkbenchPart targetPart) { + this.targetPart = targetPart; + } + + /** + * @generated + */ + public void selectionChanged(IAction action, ISelection selection) { + domainModelURI = null; + action.setEnabled(false); + if (selection instanceof IStructuredSelection == false || selection.isEmpty()) { + return; + } + IFile file = (IFile) ((IStructuredSelection) selection).getFirstElement(); + domainModelURI = URI.createPlatformResourceURI(file.getFullPath().toString(), true); + action.setEnabled(true); + } + + /** + * @generated + */ + private Shell getShell() { + return targetPart.getSite().getShell(); + } + + /** + * @generated + */ + public void run(IAction action) { + TransactionalEditingDomain editingDomain = GMFEditingDomainFactory.INSTANCE.createEditingDomain(); + ResourceSet resourceSet = editingDomain.getResourceSet(); + EObject crySLRoot = null; + EObject diagramRoot = null; + try { + Resource resource = resourceSet.getResource(domainModelURI, true); + crySLRoot = (EObject) resource.getContents().get(0); + final Domainmodel dm = (Domainmodel) crySLRoot; + diagramRoot = dm.getOrder(); + } catch (WrappedException ex) { + StatemachineDiagramEditorPlugin.getInstance().logError("Unable to load resource: " + domainModelURI, ex); //$NON-NLS-1$ + } + if (diagramRoot == null) { + MessageDialog.openError(getShell(), Messages.InitDiagramFile_ResourceErrorDialogTitle, + Messages.InitDiagramFile_ResourceErrorDialogMessage); + return; + } + Wizard wizard = new StatemachineNewDiagramFileWizard(domainModelURI, diagramRoot, editingDomain); + wizard.setWindowTitle(NLS.bind(Messages.InitDiagramFile_WizardTitle, OrderEditPart.MODEL_ID)); + StatemachineDiagramEditorUtil.runWizard(getShell(), wizard, "InitDiagramFile"); //$NON-NLS-1$ + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineLinkDescriptor.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineLinkDescriptor.java new file mode 100644 index 00000000..4f4ffb19 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineLinkDescriptor.java @@ -0,0 +1,34 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.gmf.runtime.emf.type.core.IElementType; +import org.eclipse.gmf.tooling.runtime.update.UpdaterLinkDescriptor; + +/** + * @generated + */ +public class StatemachineLinkDescriptor extends UpdaterLinkDescriptor { + /** + * @generated + */ + public StatemachineLinkDescriptor(EObject source, EObject destination, IElementType elementType, int linkVID) { + super(source, destination, elementType, linkVID); + } + + /** + * @generated + */ + public StatemachineLinkDescriptor(EObject source, EObject destination, EObject linkElement, + IElementType elementType, int linkVID) { + super(source, destination, linkElement, elementType, linkVID); + } + + public void setSource(EObject source) { + this.setSource(source); + } + + public EObject getLinkElement() { + return getLinkElement(); + } + +} \ No newline at end of file diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineMatchingStrategy.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineMatchingStrategy.java new file mode 100644 index 00000000..475e5ca3 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineMatchingStrategy.java @@ -0,0 +1,34 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import org.eclipse.emf.common.ui.URIEditorInput; +import org.eclipse.ui.IEditorInput; +import org.eclipse.ui.IEditorMatchingStrategy; +import org.eclipse.ui.IEditorReference; +import org.eclipse.ui.PartInitException; + +/** + * @generated + */ +public class StatemachineMatchingStrategy implements IEditorMatchingStrategy { + + /** + * @generated + */ + public boolean matches(IEditorReference editorRef, IEditorInput input) { + IEditorInput editorInput; + try { + editorInput = editorRef.getEditorInput(); + } catch (PartInitException e) { + return false; + } + + if (editorInput.equals(input)) { + return true; + } + if (editorInput instanceof URIEditorInput && input instanceof URIEditorInput) { + return ((URIEditorInput) editorInput).getURI().equals(((URIEditorInput) input).getURI()); + } + return false; + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineNewDiagramFileWizard.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineNewDiagramFileWizard.java new file mode 100644 index 00000000..adc30930 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineNewDiagramFileWizard.java @@ -0,0 +1,191 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import java.io.IOException; +import java.util.LinkedList; + +import org.eclipse.core.commands.ExecutionException; +import org.eclipse.core.commands.operations.OperationHistoryFactory; +import org.eclipse.core.resources.IFile; +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.core.runtime.IPath; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.NullProgressMonitor; +import org.eclipse.core.runtime.Path; +import org.eclipse.emf.common.util.URI; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.emf.ecore.resource.ResourceSet; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.emf.transaction.TransactionalEditingDomain; +import org.eclipse.gmf.runtime.common.core.command.CommandResult; +import org.eclipse.gmf.runtime.diagram.core.services.ViewService; +import org.eclipse.gmf.runtime.diagram.core.services.view.CreateDiagramViewOperation; +import org.eclipse.gmf.runtime.emf.commands.core.command.AbstractTransactionalCommand; +import org.eclipse.gmf.runtime.emf.core.util.EObjectAdapter; +import org.eclipse.gmf.runtime.notation.Diagram; +import org.eclipse.jface.viewers.StructuredSelection; +import org.eclipse.jface.wizard.Wizard; +import org.eclipse.osgi.util.NLS; +import org.eclipse.ui.PartInitException; +import org.eclipse.ui.dialogs.WizardNewFileCreationPage; + +import de.darmstadt.tu.crossing.crySL.Domainmodel; +import de.darmstadt.tu.crossing.crySL.Expression; +//import de.darmstadt.tu.crossing.crySL.Order; +//import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.OrderEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.OrderEditPart; + + +/** + * @generated + */ +public class StatemachineNewDiagramFileWizard extends Wizard { + + /** + * @generated + */ + private WizardNewFileCreationPage myFileCreationPage; + + /** + * @generated + */ + private ModelElementSelectionPage diagramRootElementSelectionPage; + + /** + * @generated + */ + private TransactionalEditingDomain myEditingDomain; + + /** + * @generated + */ + public StatemachineNewDiagramFileWizard(URI domainModelURI, EObject diagramRoot, + TransactionalEditingDomain editingDomain) { + assert domainModelURI != null : "Domain model uri must be specified"; //$NON-NLS-1$ + assert diagramRoot != null : "Doagram root element must be specified"; //$NON-NLS-1$ + assert editingDomain != null : "Editing domain must be specified"; //$NON-NLS-1$ + + myFileCreationPage = new WizardNewFileCreationPage(Messages.StatemachineNewDiagramFileWizard_CreationPageName, + StructuredSelection.EMPTY); + myFileCreationPage.setTitle(Messages.StatemachineNewDiagramFileWizard_CreationPageTitle); + myFileCreationPage.setDescription( + NLS.bind(Messages.StatemachineNewDiagramFileWizard_CreationPageDescription, OrderEditPart.MODEL_ID)); + IPath filePath; + String fileName = URI.decode(domainModelURI.trimFileExtension().lastSegment()); + if (domainModelURI.isPlatformResource()) { + filePath = new Path(domainModelURI.trimSegments(1).toPlatformString(true)); + } else if (domainModelURI.isFile()) { + filePath = new Path(domainModelURI.trimSegments(1).toFileString()); + } else { + // TODO : use some default path + throw new IllegalArgumentException("Unsupported URI: " + domainModelURI); //$NON-NLS-1$ + } + myFileCreationPage.setContainerFullPath(filePath); + myFileCreationPage.setFileName( + StatemachineDiagramEditorUtil.getUniqueFileName(filePath, fileName, "statemachine_diagram")); //$NON-NLS-1$ + + diagramRootElementSelectionPage = new DiagramRootElementSelectionPage( + Messages.StatemachineNewDiagramFileWizard_RootSelectionPageName); + diagramRootElementSelectionPage.setTitle(Messages.StatemachineNewDiagramFileWizard_RootSelectionPageTitle); + diagramRootElementSelectionPage + .setDescription(Messages.StatemachineNewDiagramFileWizard_RootSelectionPageDescription); + diagramRootElementSelectionPage.setModelElement(diagramRoot); + + myEditingDomain = editingDomain; + } + + /** + * @generated + */ + public void addPages() { + addPage(myFileCreationPage); + addPage(diagramRootElementSelectionPage); + } + + /** + * @generated + */ + public boolean performFinish() { + LinkedList affectedFiles = new LinkedList(); + IFile diagramFile = myFileCreationPage.createNewFile(); + StatemachineDiagramEditorUtil.setCharset(diagramFile); + affectedFiles.add(diagramFile); + URI diagramModelURI = URI.createPlatformResourceURI(diagramFile.getFullPath().toString(), true); + ResourceSet resourceSet = myEditingDomain.getResourceSet(); + final Resource diagramResource = resourceSet.createResource(diagramModelURI); + AbstractTransactionalCommand command = new AbstractTransactionalCommand(myEditingDomain, + Messages.StatemachineNewDiagramFileWizard_InitDiagramCommand, affectedFiles) { + + protected CommandResult doExecuteWithResult(IProgressMonitor monitor, IAdaptable info) + throws ExecutionException { + int diagramVID = StatemachineVisualIDRegistry + .getDiagramVisualID(diagramRootElementSelectionPage.getModelElement()); + if (diagramVID != OrderEditPart.VISUAL_ID) { + return CommandResult + .newErrorCommandResult(Messages.StatemachineNewDiagramFileWizard_IncorrectRootError); + } + Diagram diagram = ViewService.createDiagram(diagramRootElementSelectionPage.getModelElement(), + OrderEditPart.MODEL_ID, StatemachineDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); + diagramResource.getContents().add(diagram); + return CommandResult.newOKCommandResult(); + } + }; + try { + OperationHistoryFactory.getOperationHistory().execute(command, new NullProgressMonitor(), null); + diagramResource.save(StatemachineDiagramEditorUtil.getSaveOptions()); + StatemachineDiagramEditorUtil.openDiagram(diagramResource); + } catch (ExecutionException e) { + StatemachineDiagramEditorPlugin.getInstance().logError("Unable to create model and diagram", e); //$NON-NLS-1$ + } catch (IOException ex) { + StatemachineDiagramEditorPlugin.getInstance().logError("Save operation failed for: " + diagramModelURI, ex); //$NON-NLS-1$ + } catch (PartInitException ex) { + StatemachineDiagramEditorPlugin.getInstance().logError("Unable to open editor", ex); //$NON-NLS-1$ + } + return true; + } + + /** + * @generated + */ + private static class DiagramRootElementSelectionPage extends ModelElementSelectionPage { + + /** + * @generated + */ + protected DiagramRootElementSelectionPage(String pageName) { + super(pageName); + } + + /** + * @generated + */ + protected String getSelectionTitle() { + return Messages.StatemachineNewDiagramFileWizard_RootSelectionPageSelectionTitle; + } + + /** + * @generated + */ + protected boolean validatePage() { + if (getModelElement() == null) { + setErrorMessage(Messages.StatemachineNewDiagramFileWizard_RootSelectionPageNoSelectionMessage); + return false; + } + + CreateDiagramViewOperation cvdp = new CreateDiagramViewOperation( + new EObjectAdapter(getModelElement()), + OrderEditPart.MODEL_ID, + StatemachineDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); + boolean result = ViewService + .getInstance() + .provides( + new CreateDiagramViewOperation( + new EObjectAdapter(getModelElement()), + OrderEditPart.MODEL_ID, + StatemachineDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT)); + setErrorMessage(result ? null + : Messages.StatemachineNewDiagramFileWizard_RootSelectionPageInvalidSelectionMessage); + return result; + } + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineNodeDescriptor.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineNodeDescriptor.java new file mode 100644 index 00000000..aafc0c41 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineNodeDescriptor.java @@ -0,0 +1,18 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.gmf.tooling.runtime.update.UpdaterNodeDescriptor; + +/** + * @generated + */ +public class StatemachineNodeDescriptor extends UpdaterNodeDescriptor { + /** + * @generated + */ + public StatemachineNodeDescriptor(EObject modelElement, int visualID) { + super(modelElement, visualID); + } + +} + diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachinePaletteFactory.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachinePaletteFactory.java new file mode 100644 index 00000000..d6637b18 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachinePaletteFactory.java @@ -0,0 +1,64 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import java.util.Collections; + +import org.eclipse.gef.palette.PaletteContainer; +import org.eclipse.gef.palette.PaletteGroup; +import org.eclipse.gef.palette.PaletteRoot; +import org.eclipse.gef.palette.ToolEntry; +import org.eclipse.gmf.tooling.runtime.part.DefaultLinkToolEntry; +import org.eclipse.gmf.tooling.runtime.part.DefaultNodeToolEntry; + +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineElementTypes; + +/** + * @generated + */ +public class StatemachinePaletteFactory { + + /** + * @generated + */ + public void fillPalette(PaletteRoot paletteRoot) { + paletteRoot.add(createStatemachine1Group()); + } + + /** + * Creates "statemachine" palette tool group + * + * @generated + */ + private PaletteContainer createStatemachine1Group() { + PaletteGroup paletteContainer = new PaletteGroup(Messages.Statemachine1Group_title); + paletteContainer.setId("createStatemachine1Group"); //$NON-NLS-1$ + paletteContainer.add(createState1CreationTool()); + paletteContainer.add(createTransition2CreationTool()); + return paletteContainer; + } + + /** + * @generated + */ + private ToolEntry createState1CreationTool() { + DefaultNodeToolEntry entry = new DefaultNodeToolEntry(Messages.State1CreationTool_title, + Messages.State1CreationTool_desc, Collections.singletonList(StatemachineElementTypes.State_2001)); + entry.setId("createState1CreationTool"); //$NON-NLS-1$ + entry.setSmallIcon(StatemachineElementTypes.getImageDescriptor(StatemachineElementTypes.State_2001)); + entry.setLargeIcon(entry.getSmallIcon()); + return entry; + } + + /** + * @generated + */ + private ToolEntry createTransition2CreationTool() { + DefaultLinkToolEntry entry = new DefaultLinkToolEntry(Messages.Transition2CreationTool_title, + Messages.Transition2CreationTool_desc, + Collections.singletonList(StatemachineElementTypes.Transition_4001)); + entry.setId("createTransition2CreationTool"); //$NON-NLS-1$ + entry.setSmallIcon(StatemachineElementTypes.getImageDescriptor(StatemachineElementTypes.Transition_4001)); + entry.setLargeIcon(entry.getSmallIcon()); + return entry; + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineUriEditorInputTester.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineUriEditorInputTester.java new file mode 100644 index 00000000..168b7bdd --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineUriEditorInputTester.java @@ -0,0 +1,22 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import org.eclipse.core.expressions.PropertyTester; +import org.eclipse.emf.common.ui.URIEditorInput; + +/** + * @generated + */ +public class StatemachineUriEditorInputTester extends PropertyTester { + + /** + * @generated + */ + public boolean test(Object receiver, String method, Object[] args, Object expectedValue) { + if (false == receiver instanceof URIEditorInput) { + return false; + } + URIEditorInput editorInput = (URIEditorInput) receiver; + return "statemachine_diagram".equals(editorInput.getURI().fileExtension()); //$NON-NLS-1$ + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineVisualIDRegistry.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineVisualIDRegistry.java new file mode 100644 index 00000000..e5533f20 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/StatemachineVisualIDRegistry.java @@ -0,0 +1,284 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import org.eclipse.core.runtime.Platform; +import org.eclipse.emf.ecore.EAnnotation; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.gmf.runtime.notation.Diagram; +import org.eclipse.gmf.runtime.notation.View; +import org.eclipse.gmf.tooling.runtime.structure.DiagramStructure; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.OrderEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.StateEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.StateNameEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.TransitionEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.TransitionNameEditPart; +import de.darmstadt.tu.crossing.crySL.CrySLPackage; +import de.darmstadt.tu.crossing.crySL.Expression; + +/** + * This registry is used to determine which type of visual object should be + * created for the corresponding Diagram, Node, ChildNode or Link represented by + * a domain model object. + * + * @generated + */ +public class StatemachineVisualIDRegistry { + + /** + * @generated + */ + private static final String DEBUG_KEY = "de.darmstadt.tu.crossing.CrySL.statemachine.diagram/debug/visualID"; //$NON-NLS-1$ + + /** + * @generated + */ + public static int getVisualID(View view) { + if (view instanceof Diagram) { + if (OrderEditPart.MODEL_ID.equals(view.getType())) { + return OrderEditPart.VISUAL_ID; + } else { + return -1; + } + } + return de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry + .getVisualID(view.getType()); + } + + /** + * @generated + */ + public static String getModelID(View view) { + View diagram = view.getDiagram(); + while (view != diagram) { + EAnnotation annotation = view.getEAnnotation("Shortcut"); //$NON-NLS-1$ + if (annotation != null) { + return (String) annotation.getDetails().get("modelID"); //$NON-NLS-1$ + } + view = (View) view.eContainer(); + } + return diagram != null ? diagram.getType() : null; + } + + /** + * @generated + */ + public static int getVisualID(String type) { + try { + return Integer.parseInt(type); + } catch (NumberFormatException e) { + if (Boolean.TRUE.toString().equalsIgnoreCase(Platform.getDebugOption(DEBUG_KEY))) { + StatemachineDiagramEditorPlugin.getInstance() + .logError("Unable to parse view type as a visualID number: " + type); + } + } + return -1; + } + + /** + * @generated + */ + public static String getType(int visualID) { + return Integer.toString(visualID); + } + + /** + * @generated + */ + public static int getDiagramVisualID(EObject domainElement) { + if (domainElement == null) { + return -1; + } + if (CrySLPackage.eINSTANCE.getOrder().isSuperTypeOf(domainElement.eClass()) + && isDiagram((Expression) domainElement)) { + return OrderEditPart.VISUAL_ID; + } + return -1; + } + + /** + * @generated + */ + public static int getNodeVisualID(View containerView, EObject domainElement) { + if (domainElement == null) { + return -1; + } + String containerModelID = de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry + .getModelID(containerView); + if (!OrderEditPart.MODEL_ID.equals(containerModelID)) { + return -1; + } + int containerVisualID; + if (OrderEditPart.MODEL_ID.equals(containerModelID)) { + containerVisualID = de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry + .getVisualID(containerView); + } else { + if (containerView instanceof Diagram) { + containerVisualID = OrderEditPart.VISUAL_ID; + } else { + return -1; + } + } + switch (containerVisualID) { + case OrderEditPart.VISUAL_ID: + if (CrySLPackage.eINSTANCE.getExpression().isSuperTypeOf(domainElement.eClass())) { + return StateEditPart.VISUAL_ID; + } + break; + } + return -1; + } + + /** + * @generated + */ + public static boolean canCreateNode(View containerView, int nodeVisualID) { + String containerModelID = de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry + .getModelID(containerView); + if (!OrderEditPart.MODEL_ID.equals(containerModelID)) { + return false; + } + int containerVisualID; + if (OrderEditPart.MODEL_ID.equals(containerModelID)) { + containerVisualID = de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry + .getVisualID(containerView); + } else { + if (containerView instanceof Diagram) { + containerVisualID = OrderEditPart.VISUAL_ID; + } else { + return false; + } + } + switch (containerVisualID) { + case OrderEditPart.VISUAL_ID: + if (StateEditPart.VISUAL_ID == nodeVisualID) { + return true; + } + break; + case StateEditPart.VISUAL_ID: + if (StateNameEditPart.VISUAL_ID == nodeVisualID) { + return true; + } + break; + case TransitionEditPart.VISUAL_ID: + if (TransitionNameEditPart.VISUAL_ID == nodeVisualID) { + return true; + } + break; + } + return false; + } + + /** + * @generated + */ + public static int getLinkWithClassVisualID(EObject domainElement) { + if (domainElement == null) { + return -1; + } + if (CrySLPackage.eINSTANCE.getEvent().isSuperTypeOf(domainElement.eClass())) { + return TransitionEditPart.VISUAL_ID; + } + return -1; + } + + /** + * User can change implementation of this method to handle some specific + * situations not covered by default logic. + * + * @generated + */ + private static boolean isDiagram(Expression element) { + return true; + } + + /** + * @generated + */ + public static boolean checkNodeVisualID(View containerView, EObject domainElement, int candidate) { + if (candidate == -1) { + // unrecognized id is always bad + return false; + } + int basic = getNodeVisualID(containerView, domainElement); + return basic == candidate; + } + + /** + * @generated + */ + public static boolean isCompartmentVisualID(int visualID) { + return false; + } + + /** + * @generated + */ + public static boolean isSemanticLeafVisualID(int visualID) { + switch (visualID) { + case OrderEditPart.VISUAL_ID: + return false; + case StateEditPart.VISUAL_ID: + return true; + default: + break; + } + return false; + } + + /** + * @generated + */ + public static final DiagramStructure TYPED_INSTANCE = new DiagramStructure() { + /** + * @generated + */ + @Override + public int getVisualID(View view) { + return de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry.getVisualID(view); + } + + /** + * @generated + */ + @Override + public String getModelID(View view) { + return de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry.getModelID(view); + } + + /** + * @generated + */ + @Override + public int getNodeVisualID(View containerView, EObject domainElement) { + return de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry + .getNodeVisualID(containerView, domainElement); + } + + /** + * @generated + */ + @Override + public boolean checkNodeVisualID(View containerView, EObject domainElement, int candidate) { + return de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry + .checkNodeVisualID(containerView, domainElement, candidate); + } + + /** + * @generated + */ + @Override + public boolean isCompartmentVisualID(int visualID) { + return de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry + .isCompartmentVisualID(visualID); + } + + /** + * @generated + */ + @Override + public boolean isSemanticLeafVisualID(int visualID) { + return de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry + .isSemanticLeafVisualID(visualID); + } + }; + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/ValidateAction.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/ValidateAction.java new file mode 100644 index 00000000..a199a898 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/part/ValidateAction.java @@ -0,0 +1,267 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.part; + +import java.lang.reflect.InvocationTargetException; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Set; + +import org.eclipse.core.resources.IFile; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.NullProgressMonitor; +import org.eclipse.emf.common.util.Diagnostic; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.util.Diagnostician; +import org.eclipse.emf.transaction.TransactionalEditingDomain; +import org.eclipse.emf.transaction.util.TransactionUtil; +import org.eclipse.emf.validation.model.EvaluationMode; +import org.eclipse.emf.validation.model.IConstraintStatus; +import org.eclipse.emf.validation.service.IBatchValidator; +import org.eclipse.emf.validation.service.ModelValidationService; +import org.eclipse.emf.workspace.util.WorkspaceSynchronizer; +import org.eclipse.gef.EditPartViewer; +import org.eclipse.gmf.runtime.diagram.ui.OffscreenEditPartFactory; +import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart; +import org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramWorkbenchPart; +import org.eclipse.gmf.runtime.emf.core.util.EMFCoreUtil; +import org.eclipse.gmf.runtime.notation.View; +import org.eclipse.jface.action.Action; +import org.eclipse.jface.operation.IRunnableWithProgress; +import org.eclipse.ui.IEditorPart; +import org.eclipse.ui.IWorkbenchPage; +import org.eclipse.ui.IWorkbenchPart; +import org.eclipse.ui.PlatformUI; +import org.eclipse.ui.actions.WorkspaceModifyDelegatingOperation; + +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineMarkerNavigationProvider; +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineValidationProvider; + +/** + * @generated + */ +public class ValidateAction extends Action { + + /** + * @generated + */ + private IWorkbenchPage page; + + /** + * @generated + */ + public ValidateAction(IWorkbenchPage page) { + setText(Messages.ValidateActionMessage); + this.page = page; + } + + /** + * @generated + */ + public void run() { + IWorkbenchPart workbenchPart = page.getActivePart(); + if (workbenchPart instanceof IDiagramWorkbenchPart) { + final IDiagramWorkbenchPart part = (IDiagramWorkbenchPart) workbenchPart; + try { + new WorkspaceModifyDelegatingOperation(new IRunnableWithProgress() { + + public void run(IProgressMonitor monitor) throws InterruptedException, InvocationTargetException { + runValidation(part.getDiagramEditPart(), part.getDiagram()); + } + }).run(new NullProgressMonitor()); + } catch (Exception e) { + StatemachineDiagramEditorPlugin.getInstance().logError("Validation action failed", e); //$NON-NLS-1$ + } + } + } + + /** + * @generated + */ + public static void runValidation(View view) { + try { + if (StatemachineDiagramEditorUtil.openDiagram(view.eResource())) { + IEditorPart editorPart = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage() + .getActiveEditor(); + if (editorPart instanceof IDiagramWorkbenchPart) { + runValidation(((IDiagramWorkbenchPart) editorPart).getDiagramEditPart(), view); + } else { + runNonUIValidation(view); + } + } + } catch (Exception e) { + StatemachineDiagramEditorPlugin.getInstance().logError("Validation action failed", e); //$NON-NLS-1$ + } + } + + /** + * @generated + */ + public static void runNonUIValidation(View view) { + DiagramEditPart diagramEditPart = OffscreenEditPartFactory.getInstance() + .createDiagramEditPart(view.getDiagram()); + runValidation(diagramEditPart, view); + } + + /** + * @generated + */ + public static void runValidation(DiagramEditPart diagramEditPart, View view) { + final DiagramEditPart fpart = diagramEditPart; + final View fview = view; + TransactionalEditingDomain txDomain = TransactionUtil.getEditingDomain(view); + StatemachineValidationProvider.runWithConstraints(txDomain, new Runnable() { + + public void run() { + validate(fpart, fview); + } + }); + } + + /** + * @generated + */ + private static Diagnostic runEMFValidator(View target) { + if (target.isSetElement() && target.getElement() != null) { + return new Diagnostician() { + + public String getObjectLabel(EObject eObject) { + return EMFCoreUtil.getQualifiedName(eObject, true); + } + }.validate(target.getElement()); + } + return Diagnostic.OK_INSTANCE; + } + + /** + * @generated + */ + private static void validate(DiagramEditPart diagramEditPart, View view) { + IFile target = view.eResource() != null ? WorkspaceSynchronizer.getFile(view.eResource()) : null; + if (target != null) { + StatemachineMarkerNavigationProvider.deleteMarkers(target); + } + Diagnostic diagnostic = runEMFValidator(view); + createMarkers(target, diagnostic, diagramEditPart); + IBatchValidator validator = (IBatchValidator) ModelValidationService.getInstance() + .newValidator(EvaluationMode.BATCH); + validator.setIncludeLiveConstraints(true); + if (view.isSetElement() && view.getElement() != null) { + IStatus status = validator.validate(view.getElement()); + createMarkers(target, status, diagramEditPart); + } + } + + /** + * @generated + */ + private static void createMarkers(IFile target, IStatus validationStatus, DiagramEditPart diagramEditPart) { + if (validationStatus.isOK()) { + return; + } + final IStatus rootStatus = validationStatus; + List allStatuses = new ArrayList(); + StatemachineDiagramEditorUtil.LazyElement2ViewMap element2ViewMap = new StatemachineDiagramEditorUtil.LazyElement2ViewMap( + diagramEditPart.getDiagramView(), + collectTargetElements(rootStatus, new HashSet(), allStatuses)); + for (Iterator it = allStatuses.iterator(); it.hasNext();) { + IConstraintStatus nextStatus = (IConstraintStatus) it.next(); + View view = StatemachineDiagramEditorUtil.findView(diagramEditPart, nextStatus.getTarget(), + element2ViewMap); + addMarker(diagramEditPart.getViewer(), target, view.eResource().getURIFragment(view), + EMFCoreUtil.getQualifiedName(nextStatus.getTarget(), true), nextStatus.getMessage(), + nextStatus.getSeverity()); + } + } + + /** + * @generated + */ + private static void createMarkers(IFile target, Diagnostic emfValidationStatus, DiagramEditPart diagramEditPart) { + if (emfValidationStatus.getSeverity() == Diagnostic.OK) { + return; + } + final Diagnostic rootStatus = emfValidationStatus; + List allDiagnostics = new ArrayList(); + StatemachineDiagramEditorUtil.LazyElement2ViewMap element2ViewMap = new StatemachineDiagramEditorUtil.LazyElement2ViewMap( + diagramEditPart.getDiagramView(), + collectTargetElements(rootStatus, new HashSet(), allDiagnostics)); + for (Iterator it = emfValidationStatus.getChildren().iterator(); it.hasNext();) { + Diagnostic nextDiagnostic = (Diagnostic) it.next(); + List data = nextDiagnostic.getData(); + if (data != null && !data.isEmpty() && data.get(0) instanceof EObject) { + EObject element = (EObject) data.get(0); + View view = StatemachineDiagramEditorUtil.findView(diagramEditPart, element, element2ViewMap); + addMarker(diagramEditPart.getViewer(), target, view.eResource().getURIFragment(view), + EMFCoreUtil.getQualifiedName(element, true), nextDiagnostic.getMessage(), + diagnosticToStatusSeverity(nextDiagnostic.getSeverity())); + } + } + } + + /** + * @generated + */ + private static void addMarker(EditPartViewer viewer, IFile target, String elementId, String location, + String message, int statusSeverity) { + if (target == null) { + return; + } + StatemachineMarkerNavigationProvider.addMarker(target, elementId, location, message, statusSeverity); + } + + /** + * @generated + */ + private static int diagnosticToStatusSeverity(int diagnosticSeverity) { + if (diagnosticSeverity == Diagnostic.OK) { + return IStatus.OK; + } else if (diagnosticSeverity == Diagnostic.INFO) { + return IStatus.INFO; + } else if (diagnosticSeverity == Diagnostic.WARNING) { + return IStatus.WARNING; + } else if (diagnosticSeverity == Diagnostic.ERROR || diagnosticSeverity == Diagnostic.CANCEL) { + return IStatus.ERROR; + } + return IStatus.INFO; + } + + /** + * @generated + */ + private static Set collectTargetElements(IStatus status, Set targetElementCollector, + List allConstraintStatuses) { + if (status instanceof IConstraintStatus) { + targetElementCollector.add(((IConstraintStatus) status).getTarget()); + allConstraintStatuses.add(status); + } + if (status.isMultiStatus()) { + IStatus[] children = status.getChildren(); + for (int i = 0; i < children.length; i++) { + collectTargetElements(children[i], targetElementCollector, allConstraintStatuses); + } + } + return targetElementCollector; + } + + /** + * @generated + */ + private static Set collectTargetElements(Diagnostic diagnostic, Set targetElementCollector, + List allDiagnostics) { + List data = diagnostic.getData(); + EObject target = null; + if (data != null && !data.isEmpty() && data.get(0) instanceof EObject) { + target = (EObject) data.get(0); + targetElementCollector.add(target); + allDiagnostics.add(diagnostic); + } + if (diagnostic.getChildren() != null && !diagnostic.getChildren().isEmpty()) { + for (Iterator it = diagnostic.getChildren().iterator(); it.hasNext();) { + collectTargetElements((Diagnostic) it.next(), targetElementCollector, allDiagnostics); + } + } + return targetElementCollector; + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/preferences/DiagramAppearancePreferencePage.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/preferences/DiagramAppearancePreferencePage.java new file mode 100644 index 00000000..50287f36 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/preferences/DiagramAppearancePreferencePage.java @@ -0,0 +1,17 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.preferences; + +import org.eclipse.gmf.runtime.diagram.ui.preferences.AppearancePreferencePage; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin; + +/** + * @generated + */ +public class DiagramAppearancePreferencePage extends AppearancePreferencePage { + + /** + * @generated + */ + public DiagramAppearancePreferencePage() { + setPreferenceStore(StatemachineDiagramEditorPlugin.getInstance().getPreferenceStore()); + } +} \ No newline at end of file diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/preferences/DiagramConnectionsPreferencePage.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/preferences/DiagramConnectionsPreferencePage.java new file mode 100644 index 00000000..b78cbc56 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/preferences/DiagramConnectionsPreferencePage.java @@ -0,0 +1,17 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.preferences; + +import org.eclipse.gmf.runtime.diagram.ui.preferences.ConnectionsPreferencePage; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin; + +/** + * @generated + */ +public class DiagramConnectionsPreferencePage extends ConnectionsPreferencePage { + + /** + * @generated + */ + public DiagramConnectionsPreferencePage() { + setPreferenceStore(StatemachineDiagramEditorPlugin.getInstance().getPreferenceStore()); + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/preferences/DiagramGeneralPreferencePage.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/preferences/DiagramGeneralPreferencePage.java new file mode 100644 index 00000000..a933b0d7 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/preferences/DiagramGeneralPreferencePage.java @@ -0,0 +1,17 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.preferences; + +import org.eclipse.gmf.runtime.diagram.ui.preferences.DiagramsPreferencePage; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin; + +/** + * @generated + */ +public class DiagramGeneralPreferencePage extends DiagramsPreferencePage { + + /** + * @generated + */ + public DiagramGeneralPreferencePage() { + setPreferenceStore(StatemachineDiagramEditorPlugin.getInstance().getPreferenceStore()); + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/preferences/DiagramPreferenceInitializer.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/preferences/DiagramPreferenceInitializer.java new file mode 100644 index 00000000..13ae4e74 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/preferences/DiagramPreferenceInitializer.java @@ -0,0 +1,31 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.preferences; + +import org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer; +import org.eclipse.jface.preference.IPreferenceStore; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin; + +/** + * @generated + */ +public class DiagramPreferenceInitializer extends AbstractPreferenceInitializer { + + /** + * @generated + */ + public void initializeDefaultPreferences() { + IPreferenceStore store = getPreferenceStore(); + DiagramGeneralPreferencePage.initDefaults(store); + DiagramAppearancePreferencePage.initDefaults(store); + DiagramConnectionsPreferencePage.initDefaults(store); + DiagramPrintingPreferencePage.initDefaults(store); + DiagramRulersAndGridPreferencePage.initDefaults(store); + + } + + /** + * @generated + */ + protected IPreferenceStore getPreferenceStore() { + return StatemachineDiagramEditorPlugin.getInstance().getPreferenceStore(); + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/preferences/DiagramPrintingPreferencePage.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/preferences/DiagramPrintingPreferencePage.java new file mode 100644 index 00000000..f44882e2 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/preferences/DiagramPrintingPreferencePage.java @@ -0,0 +1,17 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.preferences; + +import org.eclipse.gmf.runtime.diagram.ui.preferences.PrintingPreferencePage; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin; + +/** + * @generated + */ +public class DiagramPrintingPreferencePage extends PrintingPreferencePage { + + /** + * @generated + */ + public DiagramPrintingPreferencePage() { + setPreferenceStore(StatemachineDiagramEditorPlugin.getInstance().getPreferenceStore()); + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/preferences/DiagramRulersAndGridPreferencePage.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/preferences/DiagramRulersAndGridPreferencePage.java new file mode 100644 index 00000000..51f82a33 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/preferences/DiagramRulersAndGridPreferencePage.java @@ -0,0 +1,17 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.preferences; + +import org.eclipse.gmf.runtime.diagram.ui.preferences.RulerGridPreferencePage; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin; + +/** + * @generated + */ +public class DiagramRulersAndGridPreferencePage extends RulerGridPreferencePage { + + /** + * @generated + */ + public DiagramRulersAndGridPreferencePage() { + setPreferenceStore(StatemachineDiagramEditorPlugin.getInstance().getPreferenceStore()); + } +} \ No newline at end of file diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/ElementInitializers.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/ElementInitializers.java new file mode 100644 index 00000000..407ebfd7 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/ElementInitializers.java @@ -0,0 +1,24 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.providers; + +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin; + +/** + * @generated + */ +public class ElementInitializers { + + protected ElementInitializers() { + // use #getInstance to access cached instance + } + + /** + * @generated + */ + public static ElementInitializers getInstance() { + ElementInitializers cached = StatemachineDiagramEditorPlugin.getInstance().getElementInitializers(); + if (cached == null) { + StatemachineDiagramEditorPlugin.getInstance().setElementInitializers(cached = new ElementInitializers()); + } + return cached; + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineEditPartProvider.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineEditPartProvider.java new file mode 100644 index 00000000..98b4c710 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineEditPartProvider.java @@ -0,0 +1,21 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.providers; + +import org.eclipse.gmf.tooling.runtime.providers.DefaultEditPartProvider; + +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.OrderEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.OrderEditPartFactory; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry; + +/** + * @generated + */ +public class StatemachineEditPartProvider extends DefaultEditPartProvider { + + /** + * @generated + */ + public StatemachineEditPartProvider() { + super(new OrderEditPartFactory(), StatemachineVisualIDRegistry.TYPED_INSTANCE, OrderEditPart.MODEL_ID); + } + +} \ No newline at end of file diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineElementTypes.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineElementTypes.java new file mode 100644 index 00000000..e9ebea5a --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineElementTypes.java @@ -0,0 +1,181 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.providers; + +import java.util.HashSet; +import java.util.IdentityHashMap; +import java.util.Map; +import java.util.Set; + +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.emf.ecore.ENamedElement; +import org.eclipse.gmf.runtime.emf.type.core.ElementTypeRegistry; +import org.eclipse.gmf.runtime.emf.type.core.IElementType; +import org.eclipse.gmf.tooling.runtime.providers.DiagramElementTypeImages; +import org.eclipse.gmf.tooling.runtime.providers.DiagramElementTypes; +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.swt.graphics.Image; +import de.darmstadt.tu.crossing.crySL.CrySLPackage; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.OrderEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.StateEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.TransitionEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin; + +/** + * @generated + */ +public class StatemachineElementTypes { + + /** + * @generated + */ + private StatemachineElementTypes() { + } + + /** + * @generated + */ + private static Map elements; + + /** + * @generated + */ + private static DiagramElementTypeImages elementTypeImages = new DiagramElementTypeImages( + StatemachineDiagramEditorPlugin.getInstance().getItemProvidersAdapterFactory()); + + /** + * @generated + */ + private static Set KNOWN_ELEMENT_TYPES; + + /** + * @generated + */ + public static final IElementType Statemachine_1000 = getElementType( + "de.darmstadt.tu.crossing.CrySL.statemachine.diagram.Statemachine_1000"); + + /** + * @generated + */ + public static final IElementType State_2001 = getElementType( + "de.darmstadt.tu.crossing.CrySL.statemachine.diagram.State_2001"); //$NON-NLS-1$ + /** + * @generated + */ + public static final IElementType Transition_4001 = getElementType( + "de.darmstadt.tu.crossing.CrySL.statemachine.diagram.Transition_4001"); //$NON-NLS-1$ + + /** + * @generated + */ + public static ImageDescriptor getImageDescriptor(ENamedElement element) { + return elementTypeImages.getImageDescriptor(element); + } + + /** + * @generated + */ + public static Image getImage(ENamedElement element) { + return elementTypeImages.getImage(element); + } + + /** + * @generated + */ + public static ImageDescriptor getImageDescriptor(IAdaptable hint) { + return getImageDescriptor(getElement(hint)); + } + + /** + * @generated + */ + public static Image getImage(IAdaptable hint) { + return getImage(getElement(hint)); + } + + /** + * Returns 'type' of the ecore object associated with the hint. + * + * @generated + */ + public static ENamedElement getElement(IAdaptable hint) { + Object type = hint.getAdapter(IElementType.class); + if (elements == null) { + elements = new IdentityHashMap(); + + elements.put(Statemachine_1000, CrySLPackage.eINSTANCE.getOrder()); + + elements.put(State_2001, CrySLPackage.eINSTANCE.getExpression_Elementop()); + + elements.put(Transition_4001, CrySLPackage.eINSTANCE.getExpression_OrderEv()); + } + return (ENamedElement) elements.get(type); + } + + /** + * @generated + */ + private static IElementType getElementType(String id) { + return ElementTypeRegistry.getInstance().getType(id); + } + + /** + * @generated + */ + public static boolean isKnownElementType(IElementType elementType) { + if (KNOWN_ELEMENT_TYPES == null) { + KNOWN_ELEMENT_TYPES = new HashSet(); + KNOWN_ELEMENT_TYPES.add(Statemachine_1000); + KNOWN_ELEMENT_TYPES.add(State_2001); + KNOWN_ELEMENT_TYPES.add(Transition_4001); + } + return KNOWN_ELEMENT_TYPES.contains(elementType); + } + + /** + * @generated + */ + public static IElementType getElementType(int visualID) { + switch (visualID) { + case OrderEditPart.VISUAL_ID: + return Statemachine_1000; + case StateEditPart.VISUAL_ID: + return State_2001; + case TransitionEditPart.VISUAL_ID: + return Transition_4001; + } + return null; + } + + /** + * @generated + */ + public static final DiagramElementTypes TYPED_INSTANCE = new DiagramElementTypes(elementTypeImages) { + + /** + * @generated + */ + @Override + public boolean isKnownElementType(IElementType elementType) { + return de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineElementTypes + .isKnownElementType(elementType); + } + + /** + * @generated + */ + @Override + public IElementType getElementTypeForVisualId(int visualID) { + return de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineElementTypes + .getElementType(visualID); + } + + /** + * @generated + */ + @Override + public ENamedElement getDefiningNamedElement(IAdaptable elementTypeAdapter) { + return de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineElementTypes + .getElement(elementTypeAdapter); + } + }; + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineIconProvider.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineIconProvider.java new file mode 100644 index 00000000..5c99ac09 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineIconProvider.java @@ -0,0 +1,18 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.providers; + +import org.eclipse.gmf.runtime.common.ui.services.icon.IIconProvider; +import org.eclipse.gmf.tooling.runtime.providers.DefaultElementTypeIconProvider; + +/** + * @generated + */ +public class StatemachineIconProvider extends DefaultElementTypeIconProvider implements IIconProvider { + + /** + * @generated + */ + public StatemachineIconProvider() { + super(StatemachineElementTypes.TYPED_INSTANCE); + } + +} \ No newline at end of file diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineItemProviderAdapterFactory.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineItemProviderAdapterFactory.java new file mode 100644 index 00000000..e6651e1a --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineItemProviderAdapterFactory.java @@ -0,0 +1,141 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.providers; + +import java.util.ArrayList; +import java.util.Collection; + +import org.eclipse.emf.common.notify.Adapter; +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.Notifier; + +import org.eclipse.emf.edit.provider.ChangeNotifier; +import org.eclipse.emf.edit.provider.ComposeableAdapterFactory; +import org.eclipse.emf.edit.provider.ComposedAdapterFactory; +import org.eclipse.emf.edit.provider.IChangeNotifier; +import org.eclipse.emf.edit.provider.IDisposable; +import org.eclipse.emf.edit.provider.IEditingDomainItemProvider; +import org.eclipse.emf.edit.provider.IItemLabelProvider; +import org.eclipse.emf.edit.provider.IItemPropertySource; +import org.eclipse.emf.edit.provider.INotifyChangedListener; +import org.eclipse.emf.edit.provider.IStructuredItemContentProvider; +import org.eclipse.emf.edit.provider.ITreeItemContentProvider; + +import de.darmstadt.tu.crossing.crySL.util.CrySLAdapterFactory; + +/** + * This is the factory that is used to provide the interfaces needed to support + * Viewers. The adapters generated by this factory convert EMF adapter + * notifications into calls to {@link #fireNotifyChanged fireNotifyChanged}. The + * adapters also support Eclipse property sheets. Note that most of the adapters + * are shared among multiple instances. + * + * @generated + */ +public class StatemachineItemProviderAdapterFactory extends CrySLAdapterFactory + implements ComposeableAdapterFactory, IChangeNotifier, IDisposable { + /** + * This keeps track of the root adapter factory that delegates to this adapter + * factory. + * + * @generated + */ + protected ComposedAdapterFactory parentAdapterFactory; + + /** + * This is used to implement + * {@link org.eclipse.emf.edit.provider.IChangeNotifier}. + * + * @generated + */ + protected IChangeNotifier changeNotifier = new ChangeNotifier(); + + /** + * This keeps track of all the supported types checked by + * {@link #isFactoryForType isFactoryForType}. + * + * @generated + */ + protected Collection supportedTypes = new ArrayList(); + + /** + * This constructs an instance. + * + * @generated + */ + public StatemachineItemProviderAdapterFactory() { + supportedTypes.add(IEditingDomainItemProvider.class); + supportedTypes.add(IStructuredItemContentProvider.class); + supportedTypes.add(ITreeItemContentProvider.class); + supportedTypes.add(IItemLabelProvider.class); + supportedTypes.add(IItemPropertySource.class); + } + + @Override + public boolean isFactoryForType(Object type) { + // TODO Auto-generated method stub + return false; + } + + @Override + public Object adapt(Object object, Object type) { + // TODO Auto-generated method stub + return null; + } + + @Override + public Adapter adapt(Notifier target, Object type) { + // TODO Auto-generated method stub + return null; + } + + @Override + public Adapter adaptNew(Notifier target, Object type) { + // TODO Auto-generated method stub + return null; + } + + @Override + public void adaptAllNew(Notifier notifier) { + // TODO Auto-generated method stub + + } + + @Override + public void dispose() { + // TODO Auto-generated method stub + + } + + @Override + public void fireNotifyChanged(Notification notification) { + // TODO Auto-generated method stub + + } + + @Override + public void addListener(INotifyChangedListener notifyChangedListener) { + // TODO Auto-generated method stub + + } + + @Override + public void removeListener(INotifyChangedListener notifyChangedListener) { + // TODO Auto-generated method stub + + } + + @Override + public ComposeableAdapterFactory getRootAdapterFactory() { + // TODO Auto-generated method stub + return null; + } + + @Override + public void setParentAdapterFactory(ComposedAdapterFactory parentAdapterFactory) { + // TODO Auto-generated method stub + + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineMarkerNavigationProvider.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineMarkerNavigationProvider.java new file mode 100644 index 00000000..0a188573 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineMarkerNavigationProvider.java @@ -0,0 +1,83 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.providers; + +import java.util.Arrays; +import java.util.Map; + +import org.eclipse.core.resources.IFile; +import org.eclipse.core.resources.IMarker; +import org.eclipse.core.resources.IResource; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.gef.EditPart; +import org.eclipse.gmf.runtime.diagram.ui.parts.DiagramEditor; +import org.eclipse.gmf.runtime.emf.ui.providers.marker.AbstractModelMarkerNavigationProvider; + +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorUtil; + +/** + * @generated + */ +public class StatemachineMarkerNavigationProvider extends AbstractModelMarkerNavigationProvider { + + /** + * @generated + */ + public static final String MARKER_TYPE = StatemachineDiagramEditorPlugin.ID + ".diagnostic"; //$NON-NLS-1$ + + /** + * @generated + */ + protected void doGotoMarker(IMarker marker) { + String elementId = marker.getAttribute(org.eclipse.gmf.runtime.common.core.resources.IMarker.ELEMENT_ID, null); + if (elementId == null || !(getEditor() instanceof DiagramEditor)) { + return; + } + DiagramEditor editor = (DiagramEditor) getEditor(); + Map editPartRegistry = editor.getDiagramGraphicalViewer().getEditPartRegistry(); + EObject targetView = editor.getDiagram().eResource().getEObject(elementId); + if (targetView == null) { + return; + } + EditPart targetEditPart = (EditPart) editPartRegistry.get(targetView); + if (targetEditPart != null) { + StatemachineDiagramEditorUtil.selectElementsInDiagram(editor, + Arrays.asList(new EditPart[] { targetEditPart })); + } + } + + /** + * @generated + */ + public static void deleteMarkers(IResource resource) { + try { + resource.deleteMarkers(MARKER_TYPE, true, IResource.DEPTH_ZERO); + } catch (CoreException e) { + StatemachineDiagramEditorPlugin.getInstance().logError("Failed to delete validation markers", e); //$NON-NLS-1$ + } + } + + /** + * @generated + */ + public static IMarker addMarker(IFile file, String elementId, String location, String message, int statusSeverity) { + IMarker marker = null; + try { + marker = file.createMarker(MARKER_TYPE); + marker.setAttribute(IMarker.MESSAGE, message); + marker.setAttribute(IMarker.LOCATION, location); + marker.setAttribute(org.eclipse.gmf.runtime.common.ui.resources.IMarker.ELEMENT_ID, elementId); + int markerSeverity = IMarker.SEVERITY_INFO; + if (statusSeverity == IStatus.WARNING) { + markerSeverity = IMarker.SEVERITY_WARNING; + } else if (statusSeverity == IStatus.ERROR || statusSeverity == IStatus.CANCEL) { + markerSeverity = IMarker.SEVERITY_ERROR; + } + marker.setAttribute(IMarker.SEVERITY, markerSeverity); + } catch (CoreException e) { + StatemachineDiagramEditorPlugin.getInstance().logError("Failed to create validation marker", e); //$NON-NLS-1$ + } + return marker; + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineModelingAssistantProvider.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineModelingAssistantProvider.java new file mode 100644 index 00000000..0233f52e --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineModelingAssistantProvider.java @@ -0,0 +1,95 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.providers; + +import java.util.Collection; +import java.util.HashSet; +import java.util.Iterator; + +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider; +import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart; +import org.eclipse.gmf.runtime.emf.type.core.ElementTypeRegistry; +import org.eclipse.gmf.runtime.emf.type.core.IElementType; +import org.eclipse.gmf.runtime.emf.ui.services.modelingassistant.ModelingAssistantProvider; +import org.eclipse.gmf.runtime.notation.Diagram; +import org.eclipse.jface.viewers.ILabelProvider; +import org.eclipse.jface.window.Window; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Shell; +import org.eclipse.ui.dialogs.ElementListSelectionDialog; + +import de.darmstadt.tu.crossing.statemachine.diagram.part.Messages; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin; + +/** + * @generated + */ +public class StatemachineModelingAssistantProvider extends ModelingAssistantProvider { + + /** + * @generated + */ + public EObject selectExistingElementForSource(IAdaptable target, IElementType relationshipType) { + return selectExistingElement(target, getTypesForSource(target, relationshipType)); + } + + /** + * @generated + */ + public EObject selectExistingElementForTarget(IAdaptable source, IElementType relationshipType) { + return selectExistingElement(source, getTypesForTarget(source, relationshipType)); + } + + /** + * @generated + */ + protected EObject selectExistingElement(IAdaptable host, Collection types) { + if (types.isEmpty()) { + return null; + } + IGraphicalEditPart editPart = (IGraphicalEditPart) host.getAdapter(IGraphicalEditPart.class); + if (editPart == null) { + return null; + } + Diagram diagram = (Diagram) editPart.getRoot().getContents().getModel(); + HashSet elements = new HashSet(); + for (Iterator it = diagram.getElement().eAllContents(); it.hasNext();) { + EObject element = it.next(); + if (isApplicableElement(element, types)) { + elements.add(element); + } + } + if (elements.isEmpty()) { + return null; + } + return selectElement((EObject[]) elements.toArray(new EObject[elements.size()])); + } + + /** + * @generated + */ + protected boolean isApplicableElement(EObject element, Collection types) { + IElementType type = ElementTypeRegistry.getInstance().getElementType(element); + return types.contains(type); + } + + /** + * @generated + */ + protected EObject selectElement(EObject[] elements) { + Shell shell = Display.getCurrent().getActiveShell(); + ILabelProvider labelProvider = new AdapterFactoryLabelProvider( + StatemachineDiagramEditorPlugin.getInstance().getItemProvidersAdapterFactory()); + ElementListSelectionDialog dialog = new ElementListSelectionDialog(shell, labelProvider); + dialog.setMessage(Messages.StatemachineModelingAssistantProviderMessage); + dialog.setTitle(Messages.StatemachineModelingAssistantProviderTitle); + dialog.setMultipleSelection(false); + dialog.setElements(elements); + EObject selected = null; + if (dialog.open() == Window.OK) { + selected = (EObject) dialog.getFirstResult(); + } + return selected; + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineParserProvider.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineParserProvider.java new file mode 100644 index 00000000..a5c8cfa0 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineParserProvider.java @@ -0,0 +1,141 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.providers; + +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.emf.ecore.EAttribute; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.gmf.runtime.common.core.service.AbstractProvider; +import org.eclipse.gmf.runtime.common.core.service.IOperation; +import org.eclipse.gmf.runtime.common.ui.services.parser.GetParserOperation; +import org.eclipse.gmf.runtime.common.ui.services.parser.IParser; +import org.eclipse.gmf.runtime.common.ui.services.parser.IParserProvider; +import org.eclipse.gmf.runtime.common.ui.services.parser.ParserService; +import org.eclipse.gmf.runtime.emf.type.core.IElementType; +import org.eclipse.gmf.runtime.emf.ui.services.parser.ParserHintAdapter; +import org.eclipse.gmf.runtime.notation.View; +import de.darmstadt.tu.crossing.crySL.CrySLPackage; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.StateNameEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.TransitionNameEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.parsers.MessageFormatParser; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry; + +/** + * @generated + */ +public class StatemachineParserProvider extends AbstractProvider implements + IParserProvider { + + /** + * @generated + */ + private IParser stateName_5001Parser; + private IParser transitionName_6001Parser; + + /** + * @generated + */ + //check thiss + private IParser getStateName_5001Parser() { + if (stateName_5001Parser == null) { + EAttribute[] features = new EAttribute[] { CrySLPackage.eINSTANCE.getSuperType_Name() }; + MessageFormatParser parser = new MessageFormatParser(features); + stateName_5001Parser = parser; + } + return stateName_5001Parser; + } + + + /** + * @generated + */ + private IParser getTransitionName_6001Parser() { + if (transitionName_6001Parser == null) { + EAttribute[] features = new EAttribute[] { CrySLPackage.eINSTANCE.getSuperType_Name() }; + MessageFormatParser parser = new MessageFormatParser(features); + transitionName_6001Parser = parser; + } + return transitionName_6001Parser; + } + /** + * @generated + */ + protected IParser getParser(int visualID) { + switch (visualID) { + case StateNameEditPart.VISUAL_ID: + return getStateName_5001Parser(); + case TransitionNameEditPart.VISUAL_ID: + return getTransitionName_6001Parser(); + } + + return null; + } + + /** + * Utility method that consults ParserService + * @generated + */ + public static IParser getParser(IElementType type, EObject object, + String parserHint) { + return ParserService.getInstance().getParser( + new HintAdapter(type, object, parserHint)); + } + + /** + * @generated + */ + public IParser getParser(IAdaptable hint) { + String vid = (String) hint.getAdapter(String.class); + if (vid != null) { + return getParser(StatemachineVisualIDRegistry.getVisualID(vid)); + } + View view = (View) hint.getAdapter(View.class); + if (view != null) { + return getParser(StatemachineVisualIDRegistry.getVisualID(view)); + } + return null; + } + + /** + * @generated + */ + public boolean provides(IOperation operation) { + if (operation instanceof GetParserOperation) { + IAdaptable hint = ((GetParserOperation) operation).getHint(); + if (StatemachineElementTypes.getElement(hint) == null) { + return false; + } + return getParser(hint) != null; + } + return false; + } + + /** + * @generated + */ + private static class HintAdapter extends ParserHintAdapter { + + /** + * @generated + */ + private final IElementType elementType; + + /** + * @generated + */ + public HintAdapter(IElementType type, EObject object, String parserHint) { + super(object, parserHint); + assert type != null; + elementType = type; + } + + /** + * @generated + */ + public Object getAdapter(Class adapter) { + if (IElementType.class.equals(adapter)) { + return elementType; + } + return super.getAdapter(adapter); + } + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineValidationProvider.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineValidationProvider.java new file mode 100644 index 00000000..8a4e0b64 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineValidationProvider.java @@ -0,0 +1,68 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.providers; + +import org.eclipse.emf.transaction.TransactionalEditingDomain; +import org.eclipse.gmf.runtime.notation.View; + +//import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.OrderEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.OrderEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineDiagramEditorPlugin; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry; + +/** + * @generated + */ +public class StatemachineValidationProvider { + + /** + * @generated + */ + private static boolean constraintsActive = false; + + /** + * @generated + */ + public static boolean shouldConstraintsBePrivate() { + return false; + } + + /** + * @generated + */ + public static void runWithConstraints(TransactionalEditingDomain editingDomain, Runnable operation) { + final Runnable op = operation; + Runnable task = new Runnable() { + public void run() { + try { + constraintsActive = true; + op.run(); + } finally { + constraintsActive = false; + } + } + }; + if (editingDomain != null) { + try { + editingDomain.runExclusive(task); + } catch (Exception e) { + StatemachineDiagramEditorPlugin.getInstance().logError("Validation failed", e); //$NON-NLS-1$ + } + } else { + task.run(); + } + } + + /** + * @generated + */ + static boolean isInDefaultEditorContext(Object object) { + if (shouldConstraintsBePrivate() && !constraintsActive) { + return false; + } + if (object instanceof View) { + return constraintsActive + && OrderEditPart.MODEL_ID.equals(StatemachineVisualIDRegistry.getModelID((View) object)); + } + return true; + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineViewProvider.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineViewProvider.java new file mode 100644 index 00000000..f34db765 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/StatemachineViewProvider.java @@ -0,0 +1,420 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.providers; + +import java.util.ArrayList; + +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.emf.ecore.EAnnotation; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EcoreFactory; +import org.eclipse.emf.transaction.util.TransactionUtil; +import org.eclipse.gmf.runtime.common.core.service.AbstractProvider; +import org.eclipse.gmf.runtime.common.core.service.IOperation; +import org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint; +import org.eclipse.gmf.runtime.diagram.core.providers.IViewProvider; +import org.eclipse.gmf.runtime.diagram.core.services.view.CreateDiagramViewOperation; +import org.eclipse.gmf.runtime.diagram.core.services.view.CreateEdgeViewOperation; +import org.eclipse.gmf.runtime.diagram.core.services.view.CreateNodeViewOperation; +import org.eclipse.gmf.runtime.diagram.core.services.view.CreateViewForKindOperation; +import org.eclipse.gmf.runtime.diagram.core.services.view.CreateViewOperation; +import org.eclipse.gmf.runtime.diagram.core.util.ViewUtil; +import org.eclipse.gmf.runtime.diagram.ui.preferences.IPreferenceConstants; +import org.eclipse.gmf.runtime.draw2d.ui.figures.FigureUtilities; +import org.eclipse.gmf.runtime.emf.core.util.EMFCoreUtil; +import org.eclipse.gmf.runtime.emf.type.core.IElementType; +import org.eclipse.gmf.runtime.emf.type.core.IHintedType; +import org.eclipse.gmf.runtime.notation.Connector; +import org.eclipse.gmf.runtime.notation.DecorationNode; +import org.eclipse.gmf.runtime.notation.Diagram; +import org.eclipse.gmf.runtime.notation.Edge; +import org.eclipse.gmf.runtime.notation.FontStyle; +import org.eclipse.gmf.runtime.notation.MeasurementUnit; +import org.eclipse.gmf.runtime.notation.Node; +import org.eclipse.gmf.runtime.notation.NotationFactory; +import org.eclipse.gmf.runtime.notation.NotationPackage; +import org.eclipse.gmf.runtime.notation.RelativeBendpoints; +import org.eclipse.gmf.runtime.notation.Routing; +import org.eclipse.gmf.runtime.notation.Shape; +import org.eclipse.gmf.runtime.notation.View; +import org.eclipse.gmf.runtime.notation.datatype.RelativeBendpoint; +import org.eclipse.jface.preference.IPreferenceStore; +import org.eclipse.jface.preference.PreferenceConverter; +import org.eclipse.swt.SWT; +import org.eclipse.swt.graphics.FontData; +import org.eclipse.gmf.runtime.notation.Location; + +//import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.OrderEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.OrderEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.StateEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.StateNameEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.TransitionEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.TransitionNameEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry; + + +/** + * @generated + */ +public class StatemachineViewProvider extends AbstractProvider implements + IViewProvider { + + /** + * @generated + */ + public final boolean provides(IOperation operation) { + if (operation instanceof CreateViewForKindOperation) { + return provides((CreateViewForKindOperation) operation); + } + assert operation instanceof CreateViewOperation; + if (operation instanceof CreateDiagramViewOperation) { + return provides((CreateDiagramViewOperation) operation); + } else if (operation instanceof CreateEdgeViewOperation) { + return provides((CreateEdgeViewOperation) operation); + } else if (operation instanceof CreateNodeViewOperation) { + return provides((CreateNodeViewOperation) operation); + } + return false; + } + + /** + * @generated + */ + protected boolean provides(CreateViewForKindOperation op) { + /* + if (op.getViewKind() == Node.class) + return getNodeViewClass(op.getSemanticAdapter(), op.getContainerView(), op.getSemanticHint()) != null; + if (op.getViewKind() == Edge.class) + return getEdgeViewClass(op.getSemanticAdapter(), op.getContainerView(), op.getSemanticHint()) != null; + */ + return true; + } + + /** + * @generated + */ + protected boolean provides(CreateDiagramViewOperation op) { + return OrderEditPart.MODEL_ID.equals(op.getSemanticHint()) + && StatemachineVisualIDRegistry + .getDiagramVisualID(getSemanticElement(op + .getSemanticAdapter())) != -1; + } + + /** + * @generated + */ + protected boolean provides(CreateNodeViewOperation op) { + if (op.getContainerView() == null) { + return false; + } + IElementType elementType = getSemanticElementType(op + .getSemanticAdapter()); + EObject domainElement = getSemanticElement(op.getSemanticAdapter()); + int visualID; + if (op.getSemanticHint() == null) { + // Semantic hint is not specified. Can be a result of call from CanonicalEditPolicy. + // In this situation there should be NO elementType, visualID will be determined + // by VisualIDRegistry.getNodeVisualID() for domainElement. + if (elementType != null || domainElement == null) { + return false; + } + visualID = StatemachineVisualIDRegistry.getNodeVisualID( + op.getContainerView(), domainElement); + } else { + visualID = StatemachineVisualIDRegistry.getVisualID(op + .getSemanticHint()); + if (elementType != null) { + if (!StatemachineElementTypes.isKnownElementType(elementType) + || (!(elementType instanceof IHintedType))) { + return false; // foreign element type + } + String elementTypeHint = ((IHintedType) elementType) + .getSemanticHint(); + if (!op.getSemanticHint().equals(elementTypeHint)) { + return false; // if semantic hint is specified it should be the same as in element type + } + if (domainElement != null + && visualID != StatemachineVisualIDRegistry + .getNodeVisualID(op.getContainerView(), + domainElement)) { + return false; // visual id for node EClass should match visual id from element type + } + } else { + if (!OrderEditPart.MODEL_ID + .equals(StatemachineVisualIDRegistry.getModelID(op + .getContainerView()))) { + return false; // foreign diagram + } + switch (visualID) { + case StateEditPart.VISUAL_ID: + if (domainElement == null + || visualID != StatemachineVisualIDRegistry + .getNodeVisualID(op.getContainerView(), + domainElement)) { + return false; // visual id in semantic hint should match visual id for domain element + } + break; + default: + return false; + } + } + } + return StateEditPart.VISUAL_ID == visualID; + } + + /** + * @generated + */ + protected boolean provides(CreateEdgeViewOperation op) { + IElementType elementType = getSemanticElementType(op + .getSemanticAdapter()); + if (!StatemachineElementTypes.isKnownElementType(elementType) + || (!(elementType instanceof IHintedType))) { + return false; // foreign element type + } + String elementTypeHint = ((IHintedType) elementType).getSemanticHint(); + if (elementTypeHint == null + || (op.getSemanticHint() != null && !elementTypeHint.equals(op + .getSemanticHint()))) { + return false; // our hint is visual id and must be specified, and it should be the same as in element type + } + int visualID = StatemachineVisualIDRegistry + .getVisualID(elementTypeHint); + EObject domainElement = getSemanticElement(op.getSemanticAdapter()); + if (domainElement != null + && visualID != StatemachineVisualIDRegistry + .getLinkWithClassVisualID(domainElement)) { + return false; // visual id for link EClass should match visual id from element type + } + return true; + } + + /** + * @generated + */ + public Diagram createDiagram(IAdaptable semanticAdapter, + String diagramKind, PreferencesHint preferencesHint) { + Diagram diagram = NotationFactory.eINSTANCE.createDiagram(); + diagram.getStyles().add(NotationFactory.eINSTANCE.createDiagramStyle()); + diagram.setType(OrderEditPart.MODEL_ID); + diagram.setElement(getSemanticElement(semanticAdapter)); + diagram.setMeasurementUnit(MeasurementUnit.PIXEL_LITERAL); + return diagram; + } + + /** + * @generated + */ + public Node createNode(IAdaptable semanticAdapter, View containerView, + String semanticHint, int index, boolean persisted, + PreferencesHint preferencesHint) { + final EObject domainElement = getSemanticElement(semanticAdapter); + final int visualID; + if (semanticHint == null) { + visualID = StatemachineVisualIDRegistry.getNodeVisualID( + containerView, domainElement); + } else { + visualID = StatemachineVisualIDRegistry.getVisualID(semanticHint); + } + switch (visualID) { + case StateEditPart.VISUAL_ID: + return createState_2001(domainElement, containerView, index, + persisted, preferencesHint); + } + // can't happen, provided #provides(CreateNodeViewOperation) is correct + return null; + } + + /** + * @generated + */ + public Edge createEdge(IAdaptable semanticAdapter, View containerView, + String semanticHint, int index, boolean persisted, + PreferencesHint preferencesHint) { + IElementType elementType = getSemanticElementType(semanticAdapter); + String elementTypeHint = ((IHintedType) elementType).getSemanticHint(); + switch (StatemachineVisualIDRegistry.getVisualID(elementTypeHint)) { + case TransitionEditPart.VISUAL_ID: + return createTransition_4001(getSemanticElement(semanticAdapter), + containerView, index, persisted, preferencesHint); + } + // can never happen, provided #provides(CreateEdgeViewOperation) is correct + return null; + } + + /** + * @generated + */ + public Node createState_2001(EObject domainElement, View containerView, + int index, boolean persisted, PreferencesHint preferencesHint) { + Node node = NotationFactory.eINSTANCE.createNode(); + node.getStyles() + .add(NotationFactory.eINSTANCE.createDescriptionStyle()); + node.getStyles().add(NotationFactory.eINSTANCE.createFontStyle()); + node.setLayoutConstraint(NotationFactory.eINSTANCE.createBounds()); + node.setType(StatemachineVisualIDRegistry + .getType(StateEditPart.VISUAL_ID)); + ViewUtil.insertChildView(containerView, node, index, persisted); + node.setElement(domainElement); + stampShortcut(containerView, node); + // initializeFromPreferences + final IPreferenceStore prefStore = (IPreferenceStore) preferencesHint + .getPreferenceStore(); + FontStyle nodeFontStyle = (FontStyle) node + .getStyle(NotationPackage.Literals.FONT_STYLE); + if (nodeFontStyle != null) { + FontData fontData = PreferenceConverter.getFontData(prefStore, + IPreferenceConstants.PREF_DEFAULT_FONT); + nodeFontStyle.setFontName(fontData.getName()); + nodeFontStyle.setFontHeight(fontData.getHeight()); + nodeFontStyle.setBold((fontData.getStyle() & SWT.BOLD) != 0); + nodeFontStyle.setItalic((fontData.getStyle() & SWT.ITALIC) != 0); + org.eclipse.swt.graphics.RGB fontRGB = PreferenceConverter + .getColor(prefStore, IPreferenceConstants.PREF_FONT_COLOR); + nodeFontStyle.setFontColor(FigureUtilities.RGBToInteger(fontRGB) + .intValue()); + } + Node label5001 = createLabel(node, + StatemachineVisualIDRegistry + .getType(StateNameEditPart.VISUAL_ID)); + return node; + } + + /** + * @generated + */ + public Edge createTransition_4001(EObject domainElement, + View containerView, int index, boolean persisted, + PreferencesHint preferencesHint) { + /* Connector edge = NotationFactory.eINSTANCE.createConnector(); + edge.getStyles().add(NotationFactory.eINSTANCE.createFontStyle()); + RelativeBendpoints bendpoints = NotationFactory.eINSTANCE + .createRelativeBendpoints(); + ArrayList points = new ArrayList( + 2); + points.add(new RelativeBendpoint()); + points.add(new RelativeBendpoint()); + bendpoints.setPoints(points); + edge.setBendpoints(bendpoints); + ViewUtil.insertChildView(containerView, edge, index, persisted); + edge.setType(StatemachineVisualIDRegistry + .getType(TransitionEditPart.VISUAL_ID)); + edge.setElement(domainElement); + // initializePreferences + final IPreferenceStore prefStore = (IPreferenceStore) preferencesHint + .getPreferenceStore(); + + org.eclipse.swt.graphics.RGB lineRGB = PreferenceConverter.getColor( + prefStore, IPreferenceConstants.PREF_LINE_COLOR); + ViewUtil.setStructuralFeatureValue(edge, + NotationPackage.eINSTANCE.getLineStyle_LineColor(), + FigureUtilities.RGBToInteger(lineRGB)); + FontStyle edgeFontStyle = (FontStyle) edge + .getStyle(NotationPackage.Literals.FONT_STYLE); + if (edgeFontStyle != null) { + FontData fontData = PreferenceConverter.getFontData(prefStore, + IPreferenceConstants.PREF_DEFAULT_FONT); + edgeFontStyle.setFontName(fontData.getName()); + edgeFontStyle.setFontHeight(fontData.getHeight()); + edgeFontStyle.setBold((fontData.getStyle() & SWT.BOLD) != 0); + edgeFontStyle.setItalic((fontData.getStyle() & SWT.ITALIC) != 0); + org.eclipse.swt.graphics.RGB fontRGB = PreferenceConverter + .getColor(prefStore, IPreferenceConstants.PREF_FONT_COLOR); + edgeFontStyle.setFontColor(FigureUtilities.RGBToInteger(fontRGB) + .intValue()); + } + Routing routing = Routing.get(prefStore + .getInt(IPreferenceConstants.PREF_LINE_STYLE)); + if (routing != null) { + ViewUtil.setStructuralFeatureValue(edge, + NotationPackage.eINSTANCE.getRoutingStyle_Routing(), + routing); + } + Node label6001 = createLabel(edge, + StatemachineVisualIDRegistry + .getType(TransitionNameEditPart.VISUAL_ID)); + return edge;*/ + + Connector edge = NotationFactory.eINSTANCE.createConnector(); + edge.getStyles().add(NotationFactory.eINSTANCE.createFontStyle()); + RelativeBendpoints bendpoints = NotationFactory.eINSTANCE.createRelativeBendpoints(); + ArrayList points = new ArrayList(2); + points.add(new RelativeBendpoint()); + points.add(new RelativeBendpoint()); + bendpoints.setPoints(points); + edge.setBendpoints(bendpoints); + ViewUtil.insertChildView(containerView, edge, index, persisted); + edge.setType(StatemachineVisualIDRegistry.getType(TransitionEditPart.VISUAL_ID)); + edge.setElement(domainElement); + // initializePreferences + final IPreferenceStore prefStore = (IPreferenceStore) preferencesHint.getPreferenceStore(); + + org.eclipse.swt.graphics.RGB lineRGB = PreferenceConverter.getColor(prefStore, IPreferenceConstants.PREF_LINE_COLOR); + ViewUtil.setStructuralFeatureValue(edge, NotationPackage.eINSTANCE.getLineStyle_LineColor(), FigureUtilities.RGBToInteger(lineRGB)); + FontStyle edgeFontStyle = (FontStyle) edge.getStyle(NotationPackage.Literals.FONT_STYLE); + if (edgeFontStyle != null) { + FontData fontData = PreferenceConverter.getFontData(prefStore, IPreferenceConstants.PREF_DEFAULT_FONT); + edgeFontStyle.setFontName(fontData.getName()); + edgeFontStyle.setFontHeight(fontData.getHeight()); + edgeFontStyle.setBold((fontData.getStyle() & SWT.BOLD) != 0); + edgeFontStyle.setItalic((fontData.getStyle() & SWT.ITALIC) != 0); + org.eclipse.swt.graphics.RGB fontRGB = PreferenceConverter.getColor(prefStore, IPreferenceConstants.PREF_FONT_COLOR); + edgeFontStyle.setFontColor(FigureUtilities.RGBToInteger(fontRGB).intValue()); + } + Node TransitionName_6001 = createLabel(edge, StatemachineVisualIDRegistry.getType(TransitionNameEditPart.VISUAL_ID)); + TransitionName_6001.setLayoutConstraint(NotationFactory.eINSTANCE.createLocation()); + Location location6001 = (Location) TransitionName_6001.getLayoutConstraint(); + location6001.setX(0); + location6001.setY(40); + return edge; + + } + + /** + * @generated + */ + private void stampShortcut(View containerView, Node target) { + if (!OrderEditPart.MODEL_ID.equals(StatemachineVisualIDRegistry + .getModelID(containerView))) { + EAnnotation shortcutAnnotation = EcoreFactory.eINSTANCE + .createEAnnotation(); + shortcutAnnotation.setSource("Shortcut"); //$NON-NLS-1$ + shortcutAnnotation.getDetails().put( + "modelID", OrderEditPart.MODEL_ID); //$NON-NLS-1$ + target.getEAnnotations().add(shortcutAnnotation); + } + } + + /** + * @generated + */ + private Node createLabel(View owner, String hint) { + DecorationNode rv = NotationFactory.eINSTANCE.createDecorationNode(); + rv.setType(hint); + ViewUtil.insertChildView(owner, rv, ViewUtil.APPEND, true); + return rv; + } + + /** + * @generated + */ + private EObject getSemanticElement(IAdaptable semanticAdapter) { + if (semanticAdapter == null) { + return null; + } + EObject eObject = (EObject) semanticAdapter.getAdapter(EObject.class); + if (eObject != null) { + return EMFCoreUtil.resolve( + TransactionUtil.getEditingDomain(eObject), eObject); + } + return null; + } + + /** + * @generated + */ + private IElementType getSemanticElementType(IAdaptable semanticAdapter) { + if (semanticAdapter == null) { + return null; + } + return (IElementType) semanticAdapter.getAdapter(IElementType.class); + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/assistants/StatemachineModelingAssistantProviderOfStateEditPart.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/assistants/StatemachineModelingAssistantProviderOfStateEditPart.java new file mode 100644 index 00000000..2087dee6 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/assistants/StatemachineModelingAssistantProviderOfStateEditPart.java @@ -0,0 +1,117 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.providers.assistants; + +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; + +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart; +import org.eclipse.gmf.runtime.emf.type.core.IElementType; + +import de.darmstadt.tu.crossing.statemachine.diagram.edit.parts.StateEditPart; +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineElementTypes; +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineModelingAssistantProvider; + +/** + * @generated + */ +public class StatemachineModelingAssistantProviderOfStateEditPart extends StatemachineModelingAssistantProvider { + + /** + * @generated + */ + @Override + public List getRelTypesOnSource(IAdaptable source) { + IGraphicalEditPart sourceEditPart = (IGraphicalEditPart) source.getAdapter(IGraphicalEditPart.class); + return doGetRelTypesOnSource((StateEditPart) sourceEditPart); + } + + /** + * @generated + */ + public List doGetRelTypesOnSource(StateEditPart source) { + List types = new ArrayList(1); + types.add(StatemachineElementTypes.Transition_4001); + return types; + } + + /** + * @generated + */ + @Override + public List getRelTypesOnSourceAndTarget(IAdaptable source, IAdaptable target) { + IGraphicalEditPart sourceEditPart = (IGraphicalEditPart) source.getAdapter(IGraphicalEditPart.class); + IGraphicalEditPart targetEditPart = (IGraphicalEditPart) target.getAdapter(IGraphicalEditPart.class); + return doGetRelTypesOnSourceAndTarget((StateEditPart) sourceEditPart, targetEditPart); + } + + /** + * @generated + */ + public List doGetRelTypesOnSourceAndTarget(StateEditPart source, IGraphicalEditPart targetEditPart) { + List types = new LinkedList(); + if (targetEditPart instanceof StateEditPart) { + types.add(StatemachineElementTypes.Transition_4001); + } + return types; + } + + /** + * @generated + */ + @Override + public List getTypesForTarget(IAdaptable source, IElementType relationshipType) { + IGraphicalEditPart sourceEditPart = (IGraphicalEditPart) source.getAdapter(IGraphicalEditPart.class); + return doGetTypesForTarget((StateEditPart) sourceEditPart, relationshipType); + } + + /** + * @generated + */ + public List doGetTypesForTarget(StateEditPart source, IElementType relationshipType) { + List types = new ArrayList(); + if (relationshipType == StatemachineElementTypes.Transition_4001) { + types.add(StatemachineElementTypes.State_2001); + } + return types; + } + + /** + * @generated + */ + @Override + public List getRelTypesOnTarget(IAdaptable target) { + IGraphicalEditPart targetEditPart = (IGraphicalEditPart) target.getAdapter(IGraphicalEditPart.class); + return doGetRelTypesOnTarget((StateEditPart) targetEditPart); + } + + /** + * @generated + */ + public List doGetRelTypesOnTarget(StateEditPart target) { + List types = new ArrayList(1); + types.add(StatemachineElementTypes.Transition_4001); + return types; + } + + /** + * @generated + */ + @Override + public List getTypesForSource(IAdaptable target, IElementType relationshipType) { + IGraphicalEditPart targetEditPart = (IGraphicalEditPart) target.getAdapter(IGraphicalEditPart.class); + return doGetTypesForSource((StateEditPart) targetEditPart, relationshipType); + } + + /** + * @generated + */ + public List doGetTypesForSource(StateEditPart target, IElementType relationshipType) { + List types = new ArrayList(); + if (relationshipType == StatemachineElementTypes.Transition_4001) { + types.add(StatemachineElementTypes.State_2001); + } + return types; + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/assistants/StatemachineModelingAssistantProviderOfStatemachineEditPart.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/assistants/StatemachineModelingAssistantProviderOfStatemachineEditPart.java new file mode 100644 index 00000000..4c9e54bd --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/providers/assistants/StatemachineModelingAssistantProviderOfStatemachineEditPart.java @@ -0,0 +1,27 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.providers.assistants; + +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.gmf.runtime.emf.type.core.IElementType; + +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineElementTypes; +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineModelingAssistantProvider; + +/** + * @generated + */ +public class StatemachineModelingAssistantProviderOfStatemachineEditPart extends StatemachineModelingAssistantProvider { + + /** + * @generated + */ + @Override + public List getTypesForPopupBar(IAdaptable host) { + List types = new ArrayList(1); + types.add(StatemachineElementTypes.State_2001); + return types; + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/sheet/StatemachinePropertySection.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/sheet/StatemachinePropertySection.java new file mode 100644 index 00000000..fa59e2ab --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/sheet/StatemachinePropertySection.java @@ -0,0 +1,22 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.sheet; + +import org.eclipse.gmf.tooling.runtime.sheet.DefaultPropertySection; +import org.eclipse.ui.views.properties.IPropertySourceProvider; + +/** + * @generated + */ +public class StatemachinePropertySection extends DefaultPropertySection implements IPropertySourceProvider { + + /** + * Modify/unwrap selection. + * + * @generated + */ + @Override + protected Object transformSelection(Object selected) { + selected = /* super. */transformSelectionToDomain(selected); + return selected; + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/sheet/StatemachineSheetLabelProvider.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/sheet/StatemachineSheetLabelProvider.java new file mode 100644 index 00000000..1ba97903 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/sheet/StatemachineSheetLabelProvider.java @@ -0,0 +1,80 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.sheet; + +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.gmf.runtime.emf.type.core.IElementType; +import org.eclipse.gmf.runtime.notation.View; +import org.eclipse.jface.viewers.BaseLabelProvider; +import org.eclipse.jface.viewers.ILabelProvider; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.swt.graphics.Image; +import de.darmstadt.tu.crossing.statemachine.diagram.navigator.StatemachineNavigatorGroup; +import de.darmstadt.tu.crossing.statemachine.diagram.part.StatemachineVisualIDRegistry; +import de.darmstadt.tu.crossing.statemachine.diagram.providers.StatemachineElementTypes; + +/** + * @generated + */ +public class StatemachineSheetLabelProvider extends BaseLabelProvider implements + ILabelProvider { + + /** + * @generated + */ + public String getText(Object element) { + element = unwrap(element); + if (element instanceof StatemachineNavigatorGroup) { + return ((StatemachineNavigatorGroup) element).getGroupName(); + } + IElementType etype = getElementType(getView(element)); + return etype == null ? "" : etype.getDisplayName(); + } + + /** + * @generated + */ + public Image getImage(Object element) { + IElementType etype = getElementType(getView(unwrap(element))); + return etype == null ? null : StatemachineElementTypes.getImage(etype); + } + + /** + * @generated + */ + private Object unwrap(Object element) { + if (element instanceof IStructuredSelection) { + return ((IStructuredSelection) element).getFirstElement(); + } + return element; + } + + /** + * @generated + */ + private View getView(Object element) { + if (element instanceof View) { + return (View) element; + } + if (element instanceof IAdaptable) { + return (View) ((IAdaptable) element).getAdapter(View.class); + } + return null; + } + + /** + * @generated + */ + private IElementType getElementType(View view) { + // For intermediate views climb up the containment hierarchy to find the one associated with an element type. + while (view != null) { + int vid = StatemachineVisualIDRegistry.getVisualID(view); + IElementType etype = StatemachineElementTypes.getElementType(vid); + if (etype != null) { + return etype; + } + view = view.eContainer() instanceof View ? (View) view.eContainer() + : null; + } + return null; + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/CrySLEvent.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/CrySLEvent.java new file mode 100644 index 00000000..763598aa --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/CrySLEvent.java @@ -0,0 +1,25 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.smgbuilder; + +import java.lang.reflect.InvocationTargetException; + +import org.eclipse.emf.common.notify.Adapter; +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.common.util.TreeIterator; +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EOperation; +import org.eclipse.emf.ecore.EReference; +import org.eclipse.emf.ecore.EStructuralFeature; +import org.eclipse.emf.ecore.resource.Resource; + +import de.darmstadt.tu.crossing.crySL.Event; +import de.darmstadt.tu.crossing.crySL.impl.EventImpl; + +public class CrySLEvent extends EventImpl { + + + public CrySLEvent() { + super(); + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/CrySLMethod.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/CrySLMethod.java new file mode 100644 index 00000000..7c485e18 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/CrySLMethod.java @@ -0,0 +1,110 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.smgbuilder; + +import java.io.Serializable; +import java.util.List; +import java.util.Map.Entry; + +public class CrySLMethod implements Serializable { + + private static final long serialVersionUID = 1L; + private final String methodName; + private final Entry retObject; + private final List> parameters; + private final List backward; + + public CrySLMethod(String methName, List> pars, List backw, Entry returnObject) { + methodName = methName; + parameters = pars; + backward = backw; + retObject = returnObject; + } + + /** + * @return the FQ methodName + */ + public String getMethodName() { + return methodName; + } + + /** + * @return the short methodName + */ + public String getShortMethodName() { + return methodName.substring(methodName.lastIndexOf(".") + 1); + } + + + /** + * @return the parameters + */ + public List> getParameters() { + return parameters; + } + + /** + * @return the backward + */ + public List getBackward() { + return backward; + } + + + public Entry getRetObject() { + return retObject; + } + public String toString() { + return getName(); + } + + public String getName() { + StringBuilder stmntBuilder = new StringBuilder(); + String returnValue = retObject.getKey(); + if (!"_".equals(returnValue)) { + stmntBuilder.append(returnValue); + stmntBuilder.append(" = "); + } + + stmntBuilder.append(this.methodName); + stmntBuilder.append("("); + + + for (Entry par: parameters) { + stmntBuilder.append(" "); + stmntBuilder.append(par.getKey()); +// if (backward != null && backward.size() == parameters.size()) { +// stmntBuilder.append(" ("); +// stmntBuilder.append(backward.get(parameters.indexOf(par))); +// stmntBuilder.append("),"); +// } + } + + stmntBuilder.append(");"); + return stmntBuilder.toString(); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((backward == null) ? 0 : backward.hashCode()); + result = prime * result + ((methodName == null) ? 0 : methodName.hashCode()); + result = prime * result + ((parameters == null) ? 0 : parameters.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (!(obj instanceof CrySLMethod)) { + return false; + } + CrySLMethod other = (CrySLMethod) obj; + return this.getMethodName().equals(other.getMethodName()) && parameters.equals(other.parameters); + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/CryslReaderUtils.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/CryslReaderUtils.java new file mode 100644 index 00000000..18cad675 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/CryslReaderUtils.java @@ -0,0 +1,77 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.smgbuilder; + +import java.util.AbstractMap.SimpleEntry; +import java.io.File; +import java.util.ArrayList; +import java.util.List; +import java.util.Map.Entry; + +import de.darmstadt.tu.crossing.crySL.Aggregate; +import de.darmstadt.tu.crossing.crySL.Event; +import de.darmstadt.tu.crossing.crySL.Method; +import de.darmstadt.tu.crossing.crySL.ObjectDecl; +import de.darmstadt.tu.crossing.crySL.Par; +import de.darmstadt.tu.crossing.crySL.ParList; +import de.darmstadt.tu.crossing.crySL.SuperType; +import de.darmstadt.tu.crossing.statemachine.diagram.smgbuilder.CrySLMethod; + +public class CryslReaderUtils { + protected static Event resolveAggregateToMethodeNames(final Event leaf) { + if (leaf instanceof Aggregate) { + final Aggregate ev = (Aggregate) leaf; + return ev; + } else { + final ArrayList statements = new ArrayList<>(); + CrySLMethod stringifyMethodSignature = stringifyMethodSignature(leaf); + if (stringifyMethodSignature != null) { + statements.add(stringifyMethodSignature); + } + return leaf; + } + } + + protected static CrySLMethod stringifyMethodSignature(final Event lab) { + if (!(lab instanceof SuperType)) { + return null; + } + final Method method = ((SuperType) lab).getMeth(); + + String methodName = method.getMethName().getSimpleName(); + if (methodName == null) { + methodName = ((de.darmstadt.tu.crossing.crySL.Domainmodel) (method.eContainer().eContainer().eContainer())).getJavaType().getSimpleName(); + } + final String qualifiedName = + ((de.darmstadt.tu.crossing.crySL.Domainmodel) (method.eContainer().eContainer().eContainer())).getJavaType().getQualifiedName() + "." + methodName; // method.getMethName().getQualifiedName(); + // qualifiedName = removeSPI(qualifiedName); + final List> pars = new ArrayList<>(); + final de.darmstadt.tu.crossing.crySL.Object returnValue = method.getLeftSide(); + Entry returnObject = null; + if (returnValue != null && returnValue.getName() != null) { + final ObjectDecl v = ((ObjectDecl) returnValue.eContainer()); + returnObject = new SimpleEntry<>(returnValue.getName(), v.getObjectType().getQualifiedName() + ((v.getArray() != null) ? v.getArray() : "")); + } else { + returnObject = new SimpleEntry<>("_", "void"); + } + final ParList parList = method.getParList(); + if (parList != null) { + for (final Par par : parList.getParameters()) { + String parValue = "_"; + if (par.getVal() != null && par.getVal().getName() != null) { + final ObjectDecl objectDecl = (ObjectDecl) par.getVal().eContainer(); + parValue = par.getVal().getName(); + final String parType = objectDecl.getObjectType().getIdentifier() + ((objectDecl.getArray() != null) ? objectDecl.getArray() : ""); + pars.add(new SimpleEntry<>(parValue, parType)); + } else { + pars.add(new SimpleEntry<>(parValue, "AnyType")); + } + } + } + return new CrySLMethod(qualifiedName, pars, new ArrayList(), returnObject); + } + + public static File getResourceFromWithin(final String inputPath) { + return new File(inputPath); + } +} + + diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/StateMachineGraph.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/StateMachineGraph.java new file mode 100644 index 00000000..f4e16b95 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/StateMachineGraph.java @@ -0,0 +1,131 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.smgbuilder; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Set; + +import org.eclipse.core.internal.expressions.Expressions; +import org.eclipse.gmf.runtime.common.core.command.CommandResult; +import org.eclipse.gmf.runtime.emf.type.core.requests.CreateElementRequest; + +import de.darmstadt.tu.crossing.crySL.CrySLFactory; +import de.darmstadt.tu.crossing.crySL.Expression; +import de.darmstadt.tu.crossing.crySL.Order; +import de.darmstadt.tu.crossing.crySL.SimpleOrder; +import de.darmstadt.tu.crossing.crySL.impl.ExpressionImpl; + +public final class StateMachineGraph{ + /** + * + */ + private static final long serialVersionUID = 1L; + private final Set nodes; + private final List edges; + + private final HashMap nodemaps; + public StateMachineGraph() { + nodes = new HashSet(); + edges = new ArrayList(); + nodemaps = new HashMap(); + } + + public Boolean addEdge(TransitionEdge edge) { + final StateNode right = edge.getRight(); + final StateNode left = edge.getLeft(); + if(edge.getLeft().getName().equals("init")) { + //remove initial node (Order) and put an expression instead of it + Expression newElement = CrySLFactory.eINSTANCE.createExpression(); + nodemaps.put("init", newElement); + + } + if (!(nodes.parallelStream().anyMatch(e -> e.equals(left)) || nodes.parallelStream().anyMatch(e -> e.equals(right)))) { + return false; + } + if (edges.contains(edge)) { + return false; + } + edges.add(edge); + return true; + } + + public void wrapUpCreation() { + getAcceptingStates().parallelStream().forEach(e -> { + e.setHopsToAccepting(0); + updateHops(e); + }); + } + + private void updateHops(StateNode node) { + int newPath = node.getHopsToAccepting() + 1; + getAllTransitions().parallelStream().forEach(e -> { + StateNode theNewRight = e.getLeft(); + if (e.getRight().equals(node) && theNewRight.getHopsToAccepting() > newPath) { + theNewRight.setHopsToAccepting(newPath); + updateHops(theNewRight); + } + }); + } + + public Boolean addNode(StateNode node, Expression expression) { + for (StateNode innerNode : nodes) { + if (innerNode.getName().equals(node.getName())) { + return false; + } + } + nodes.add(node); + nodemaps.put(node.getName(), expression); + return true; + } + + public String toString() { + StringBuilder graphSB = new StringBuilder(); + for (StateNode node : nodes) { + graphSB.append(node.toString()); + graphSB.append(System.lineSeparator()); + } + + for (TransitionEdge te : edges) { + graphSB.append(te.toString()); + graphSB.append(System.lineSeparator()); + } + + return graphSB.toString(); + } + + public Set getNodes() { + return nodes; + } + + public HashMap getNodeMap() { + return nodemaps; + } + + public List getEdges() { + return edges; + } + + public TransitionEdge getInitialTransition() { + return edges.get(0); + } + + public Collection getAcceptingStates() { + Collection accNodes = new ArrayList(); + for (StateNode node : nodes) { + if (node.getAccepting()) { + accNodes.add(node); + } + } + + return accNodes; + } + + public Collection getAllTransitions() { + return getEdges(); + } + +} + diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/StateMachineGraphBuilder.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/StateMachineGraphBuilder.java new file mode 100644 index 00000000..24cc1df3 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/StateMachineGraphBuilder.java @@ -0,0 +1,477 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.smgbuilder; + +import java.util.AbstractMap.SimpleEntry; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Optional; +import java.util.stream.Collectors; +import com.google.common.collect.HashMultimap; +import com.google.common.collect.Multimap; + +import de.darmstadt.tu.crossing.crySL.Event; +import de.darmstadt.tu.crossing.crySL.Expression; +import de.darmstadt.tu.crossing.crySL.Order; +import de.darmstadt.tu.crossing.crySL.SimpleOrder; +import de.darmstadt.tu.crossing.crySL.impl.EventImpl; +import de.darmstadt.tu.crossing.statemachine.diagram.smgbuilder.StateMachineGraph; +import de.darmstadt.tu.crossing.statemachine.diagram.smgbuilder.StateNode; +import de.darmstadt.tu.crossing.statemachine.diagram.smgbuilder.TransitionEdge; + +public class StateMachineGraphBuilder { + + private final Expression head; + private final StateMachineGraph result = new StateMachineGraph(); + private int nodeNameCounter = 0; + + public StateMachineGraphBuilder(final Expression order) { + this.head = order; + this.result.addNode(new StateNode("init", true, true), order); + + } + + private StateNode addRegularEdge(final Expression leaf, final StateNode prevNode, final StateNode nextNode) { + return addRegularEdge(leaf, prevNode, nextNode, false); + } + + private StateNode addRegularEdge(final Expression leaf, final StateNode prevNode, final StateNode nextNode, final Boolean isStillAccepting) { + final Event label = CryslReaderUtils.resolveAggregateToMethodeNames(leaf.getOrderEv().get(0)); + return addRegularEdge(leaf,label, prevNode, nextNode, isStillAccepting); + } + + + private StateNode addRegularEdge(Expression leaf,final Event label, final StateNode prevNode, StateNode nextNode, final Boolean isStillAccepting) { + if (nextNode == null) { + nextNode = getNewNode(); + this.result.addNode(nextNode, leaf); + } + if (!isStillAccepting) { + prevNode.setAccepting(false); + } + boolean added = this.result.addEdge(new TransitionEdge(label, prevNode, nextNode)); + return nextNode; + } + + public StateMachineGraph buildSMG() { + StateNode initialNode = null; + for (final StateNode n : this.result.getNodes()) { + initialNode = n; + } + if (this.head != null) { + processHead(this.head, 0, HashMultimap.create(), initialNode); + } else { + //see the implementation in CryptoAnalysis StateMachineGraphBuilder + // may be required to keep it as it is. + //this.result.addEdge(new TransitionEdge(new ArrayList(), initialNode, initialNode)); + this.result.addEdge(new TransitionEdge(new CrySLEvent(), initialNode, initialNode)); + } + return this.result; + } + + private StateNode getNewNode() { + return new StateNode(String.valueOf(this.nodeNameCounter++), false, true); + } + + private List getOutgoingEdges(final StateNode curNode, final StateNode notTo) { + final List outgoingEdges = new ArrayList<>(); + for (final TransitionEdge comp : this.result.getAllTransitions()) { + if (comp.getLeft().equals(curNode) && !(comp.getRight().equals(curNode) || comp.getRight().equals(notTo))) { + outgoingEdges.add(comp); + } + } + return outgoingEdges; + } + + private StateNode isGeneric(final String el, final int level, final Multimap> leftOvers) { + for (final Entry entry : leftOvers.get(level)) { + if (el.equals(entry.getKey())) { + return entry.getValue(); + } + } + return null; + } + + private StateNode isOr(final int level, final Multimap> leftOvers) { + return isGeneric("|", level, leftOvers); + } + + private StateNode isQM(final int level, final Multimap> leftOvers) { + return isGeneric("?", level, leftOvers); + } + + private StateNode process(final Expression curLevel, final int level, final Multimap> leftOvers, StateNode prevNode) { + final Expression left = curLevel.getLeft(); + final Expression right = curLevel.getRight(); + final String leftElOp = (left != null) ? left.getElementop() : ""; + final String rightElOp = (right != null) ? right.getElementop() : ""; + final String orderOp = curLevel.getOrderop(); + // case 1 = left & right = non-leaf + // case 2 = left = non-leaf & right = leaf + // case 3 = left = leaf & right = non-leaf + // case 4 = left = leaf & right = leaf + + if (left == null && right == null) { + addRegularEdge(left, prevNode, null); + } else if ((left instanceof Order || left instanceof SimpleOrder) && (right instanceof Order || right instanceof SimpleOrder)) { + final StateNode leftPrev = prevNode; + prevNode = process(left, level + 1, leftOvers, prevNode); + + final StateNode rightPrev = prevNode; + StateNode returnToNode = null; + if ("|".equals(orderOp)) { + leftOvers.put(level + 1, new HashMap.SimpleEntry<>(orderOp, prevNode)); + prevNode = process(right, level + 1, leftOvers, leftPrev); + } else if ((returnToNode = isOr(level, leftOvers)) != null) { + prevNode = process(right, level + 1, leftOvers, returnToNode); + } else { + prevNode = process(right, level + 1, leftOvers, prevNode); + } + + if (rightElOp != null && ("+".equals(rightElOp) || "*".equals(rightElOp))) { + final List outgoingEdges = new ArrayList(); + if ("|".equals(orderOp)) { + final List tmpOutgoingEdges = getOutgoingEdges(leftPrev, null); + for (final TransitionEdge outgoingEdge : tmpOutgoingEdges) { + if (isReachable(outgoingEdge.to(), prevNode, new ArrayList())) { + outgoingEdges.addAll(getOutgoingEdges(outgoingEdge.to(), prevNode)); + } + } + for (final TransitionEdge outgoingEdge : outgoingEdges) { + if (isReachable(prevNode, outgoingEdge.from(), new ArrayList())) { + addRegularEdge(right,outgoingEdge.getLabel(), prevNode, outgoingEdge.from(), true); + } + } + + } else { + outgoingEdges.addAll(getOutgoingEdges(rightPrev, prevNode)); + for (final TransitionEdge outgoingEdge : outgoingEdges) { + addRegularEdge(right,outgoingEdge.getLabel(), prevNode, outgoingEdge.to(), true); + } + } + } + + if (leftElOp != null && ("?".equals(leftElOp) || "*".equals(leftElOp))) { + addRegularEdge(right, leftPrev, prevNode, true); + } + + } else if ((left instanceof Order || left instanceof SimpleOrder) && !(right instanceof Order || right instanceof SimpleOrder)) { + StateNode leftPrev = prevNode; + + Optional> optionalOrLevel = leftOvers.get(level).stream().filter(e -> "|".equals(e.getKey())).findFirst(); + if (optionalOrLevel.isPresent()) { + Entry orLevel = optionalOrLevel.get(); + StateNode p = orLevel.getValue(); + List orEdges = getOutgoingEdges(prevNode, null); + if (!orEdges.isEmpty()) { + Optional edge = orEdges.stream().filter(e -> e.getRight().equals(p)).findFirst(); + if (edge.isPresent() && edge.get().getLabel().equals(CryslReaderUtils.resolveAggregateToMethodeNames(getLeftMostChild(left).getOrderEv().get(0)))) { + leftOvers.put(level + 1, orLevel); + } + } + } + prevNode = process(left, level + 1, leftOvers, prevNode); + + if (rightElOp != null && ("?".equals(rightElOp) || "*".equals(rightElOp))) { + leftOvers.put(level - 1, new HashMap.SimpleEntry<>(rightElOp, prevNode)); + prevNode = addRegularEdge(right, prevNode, null, true); + } else { + prevNode = addRegularEdge(right, prevNode, null); + } + + if (rightElOp != null && ("+".equals(rightElOp) || "*".equals(rightElOp))) { + addRegularEdge(right, prevNode, prevNode, true); + } + + } else if (!(left instanceof Order || left instanceof SimpleOrder) && (right instanceof Order || right instanceof SimpleOrder)) { + StateNode leftPrev = prevNode; + prevNode = addRegularEdge(left, prevNode, null); + + if (leftElOp != null && ("+".equals(leftElOp) || "*".equals(leftElOp))) { + addRegularEdge(left, prevNode, prevNode, true); + } + + if (rightElOp != null && ("?".equals(rightElOp) || "*".equals(rightElOp))) { + leftOvers.put(level - 1, new HashMap.SimpleEntry<>(rightElOp, prevNode)); + } + final StateNode rightPrev = prevNode; + if ("|".equals(orderOp)) { + leftOvers.put(level + 1, new HashMap.SimpleEntry<>(orderOp, prevNode)); + prevNode = process(right, level + 1, leftOvers, leftPrev); + } else { + prevNode = process(right, level + 1, leftOvers, prevNode); + } + + if (rightElOp != null && ("+".equals(rightElOp) || "*".equals(rightElOp))) { + final List outgoingEdges = getOutgoingEdges(rightPrev, prevNode); + for (final TransitionEdge outgoingEdge : outgoingEdges) { + addRegularEdge(right,outgoingEdge.getLabel(), prevNode, outgoingEdge.to(), true); + } + } + + if (leftElOp != null && ("?".equals(leftElOp) || "*".equals(leftElOp))) { + addRegularEdge(right, leftPrev, prevNode, true); + } + + } else if (!(left instanceof Order || left instanceof SimpleOrder) && !(right instanceof Order || right instanceof SimpleOrder)) { + StateNode leftPrev = null; + leftPrev = prevNode; + + boolean sameName = false; + List orEdges = getOutgoingEdges(prevNode, null); + Optional> alternative = leftOvers.get(level).stream().filter(e -> "|".equals(e.getKey())).findFirst(); + if (alternative.isPresent()) { + Entry orLevel = alternative.get(); + StateNode p = orLevel.getValue(); + if (!orEdges.isEmpty()) { + Optional edge = orEdges.stream().filter(e -> e.getRight().equals(p)).findFirst(); + if (edge.isPresent() && edge.get().getLabel().equals(CryslReaderUtils.resolveAggregateToMethodeNames(getLeftMostChild(left).getOrderEv().get(0)))) { + sameName = true; + prevNode = p; + leftOvers.remove(level, orLevel); + } + } + } + if (!sameName) { + prevNode = addRegularEdge(left, prevNode, null); + } + + StateNode returnToNode = isOr(level, leftOvers); + if (leftElOp != null && ("+".equals(leftElOp) || "*".equals(leftElOp))) { + addRegularEdge(left, prevNode, prevNode, true); + } + + if (rightElOp != null && ("?".equals(rightElOp) || "*".equals(rightElOp))) { + leftOvers.put(level - 1, new HashMap.SimpleEntry<>(rightElOp, prevNode)); + } + if (returnToNode != null || "|".equals(orderOp)) { + if ("|".equals(orderOp)) { + addRegularEdge(right, leftPrev, prevNode); + } + if ((returnToNode = isOr(level, leftOvers)) != null) { + prevNode = addRegularEdge(right, prevNode, returnToNode); + } + } else { + prevNode = addRegularEdge(right, prevNode, null); + } + + if (rightElOp != null && ("+".equals(rightElOp) || "*".equals(rightElOp))) { + addRegularEdge(right, prevNode, prevNode, true); + } + + if (leftElOp != null && ("?".equals(leftElOp) || "*".equals(leftElOp))) { + addRegularEdge(right, leftPrev, prevNode, true); + } + + if (sameName) { + setAcceptingState(alternative.get().getValue()); + } + + } + leftOvers.removeAll(level); + return prevNode; + } + + private boolean isReachable(final StateNode stateNode, final StateNode prevNode, final List skippable) { + for (final TransitionEdge edge : getOutgoingEdges(stateNode, stateNode)) { + if (edge.to().equals(prevNode)) { + return true; + } else if (!skippable.contains(edge.to())) { + skippable.add(edge.to()); + return isReachable(edge.to(), prevNode, skippable); + } + } + return false; + } + + private void processHead(final Expression curLevel, final int level, final Multimap> leftOvers, StateNode prevNode) { + final Expression left = curLevel.getLeft(); + final Expression right = curLevel.getRight(); + final String leftElOp = (left != null) ? left.getElementop() : ""; + final String rightElOp = (right != null) ? right.getElementop() : ""; + final String orderOp = curLevel.getOrderop(); + + if (left == null && right == null) { + final String elOp = curLevel.getElementop(); + if ("*".equals(elOp) || "?".equals(elOp)) { + prevNode = addRegularEdge(curLevel, prevNode, null, true); + } else { + addRegularEdge(curLevel, prevNode, null); + } + if ("*".equals(elOp) || "+".equals(elOp)) { + addRegularEdge(curLevel, prevNode, prevNode, true); + } + } else if ((left instanceof Order || left instanceof SimpleOrder) && (right instanceof Order || right instanceof SimpleOrder)) { + final StateNode leftPrev = prevNode; + prevNode = process(left, level + 1, leftOvers, prevNode); + final StateNode rightPrev = prevNode; + if ("|".equals(orderOp)) { + prevNode = process(right, level + 1, leftOvers, leftPrev); + } else { + prevNode = process(right, level + 1, leftOvers, prevNode); + } + for (Entry a : leftOvers.get(level).stream().filter(e -> "?".equals(e.getKey())).collect(Collectors.toList())) { + if ("*".equals(rightElOp) || "?".equals(rightElOp)) { + setAcceptingState(a.getValue()); + for (TransitionEdge l : getOutgoingEdges(rightPrev, null)) { + addRegularEdge(right, l.getLabel(), a.getValue(), l.getRight(), true); + } + } + } + + if ("*".equals(rightElOp) || "?".equals(rightElOp)) { + setAcceptingState(rightPrev); + } + if (rightElOp != null && ("+".equals(rightElOp) || "*".equals(rightElOp))) { + final String orderop = right.getOrderop(); + List outgoingEdges = null; + if (orderop != null && "|".equals(orderop)) { + outgoingEdges = getOutgoingEdges(rightPrev, null); + } else { + outgoingEdges = getOutgoingEdges(rightPrev, prevNode); + } + for (final TransitionEdge outgoingEdge : outgoingEdges) { + addRegularEdge(right, outgoingEdge.getLabel(), prevNode, outgoingEdge.to(), true); + } + } + + if (leftElOp != null && ("?".equals(leftElOp) || "*".equals(leftElOp))) { + addRegularEdge(right, leftPrev, prevNode, true); + } + } else if ((left instanceof Order || left instanceof SimpleOrder) && !(right instanceof Order || right instanceof SimpleOrder)) { + final StateNode leftPrev = prevNode; + prevNode = process(left, level + 1, leftOvers, prevNode); + final StateNode rightPrev = prevNode; + if ("|".equals(orderOp)) { + prevNode = addRegularEdge(right, leftPrev, prevNode); + } else { + prevNode = addRegularEdge(right, prevNode, null); + } + for (Entry a : leftOvers.get(level).stream().filter(e -> "*".equals(e.getKey())).collect(Collectors.toList())) { + addRegularEdge(right, a.getValue(), prevNode, true); + } + boolean isOptional = "*".equals(rightElOp) || "?".equals(rightElOp); + if (isOptional) { + setAcceptingState(rightPrev); + if ("?".equals(left.getRight().getElementop()) || "*".equals(left.getRight().getElementop())) { + final List outgoingEdges = getOutgoingEdges(leftPrev, null); + for (final TransitionEdge outgoingEdge : outgoingEdges) { + setAcceptingState(outgoingEdge.to()); + } + } + } + + if (rightElOp != null && ("+".equals(rightElOp) || "*".equals(rightElOp))) { + final List outgoingEdges = getOutgoingEdges(rightPrev, null); + for (final TransitionEdge outgoingEdge : outgoingEdges) { + addRegularEdge(right, outgoingEdge.getLabel(), prevNode, outgoingEdge.to(), true); + } + } + if (leftOvers.containsKey(level)) { + for (Entry entry : leftOvers.get(level).stream().filter(e -> "*".equals(e.getKey()) || "?".equals(e.getKey())).collect(Collectors.toList())) { + addRegularEdge(right, entry.getValue(), prevNode, isOptional); + } + } + StateNode returnToNode = null; + if ((returnToNode = isQM(level, leftOvers)) != null) { + addRegularEdge(right, returnToNode, prevNode, true); + } + } else if (!(left instanceof Order || left instanceof SimpleOrder) && (right instanceof Order || right instanceof SimpleOrder)) { + StateNode leftPrev = null; + leftPrev = prevNode; + prevNode = addRegularEdge(left, prevNode, null); + + if (leftElOp != null && ("+".equals(leftElOp) || "*".equals(leftElOp))) { + addRegularEdge(left, prevNode, prevNode); + } + + final StateNode rightPrev = prevNode; + StateNode returnToNode = null; + if (rightElOp != null && ("?".equals(rightElOp) || "*".equals(rightElOp))) { + setAcceptingState(rightPrev); + } + if ("|".equals(orderOp)) { + setAcceptingState(prevNode); + SimpleEntry entry = new HashMap.SimpleEntry<>(orderOp, prevNode); + leftOvers.put(level + 1, entry); + prevNode = process(right, level + 1, leftOvers, leftPrev); + + } else if ((returnToNode = isOr(level, leftOvers)) != null) { + prevNode = process(right, level + 1, leftOvers, returnToNode); + } else { + prevNode = process(right, level + 1, leftOvers, prevNode); + } + + if (rightElOp != null && ("+".equals(rightElOp) || "*".equals(rightElOp))) { + final List outgoingEdges = getOutgoingEdges(rightPrev, null); + for (final TransitionEdge outgoingEdge : outgoingEdges) { + addRegularEdge(right, outgoingEdge.getLabel(), prevNode, outgoingEdge.to(), true); + } + } + + if (leftElOp != null && ("?".equals(leftElOp) || "*".equals(leftElOp))) { + setAcceptingState(leftPrev); + final List outgoingEdges = getOutgoingEdges(rightPrev, null); + for (final TransitionEdge outgoingEdge : outgoingEdges) { + setAcceptingState(outgoingEdge.to()); + addRegularEdge(right, outgoingEdge.getLabel(), leftPrev, outgoingEdge.to(), true); + } + } + if (rightElOp != null && ("?".equals(rightElOp) || "*".equals(rightElOp))) { + setAcceptingState(rightPrev); + if (leftOvers.containsKey(level)) { + leftOvers.get(level).stream().filter(e -> "*".equals(e.getKey()) || "?".equals(e.getKey())).forEach(e -> setAcceptingState(e.getValue())); + } + } + + } else if (!(left instanceof Order || left instanceof SimpleOrder) && !(right instanceof Order || right instanceof SimpleOrder)) { + StateNode leftPrev = null; + leftPrev = prevNode; + StateNode returnToNode = isOr(level, leftOvers); + + final boolean leftOptional = "?".equals(leftElOp) || "*".equals(leftElOp); + prevNode = addRegularEdge(left, prevNode, null, leftOptional); + + if (leftElOp != null && ("+".equals(leftElOp) || "*".equals(leftElOp))) { + addRegularEdge(left, prevNode, prevNode, true); + } + + final boolean rightoptional = "?".equals(rightElOp) || "*".equals(rightElOp); + if (returnToNode != null || "|".equals(orderOp)) { + if ("|".equals(orderOp)) { + addRegularEdge(right, leftPrev, prevNode, rightoptional); + } + if ((returnToNode = isOr(level, leftOvers)) != null) { + prevNode = addRegularEdge(right, prevNode, returnToNode, rightoptional); + } + } else { + prevNode = addRegularEdge(right, prevNode, null, rightoptional); + } + + if (rightElOp != null && ("+".equals(rightElOp) || "*".equals(rightElOp))) { + addRegularEdge(right, prevNode, prevNode, true); + } + + if (leftElOp != null && ("?".equals(leftElOp) || "*".equals(leftElOp))) { + addRegularEdge(right, leftPrev, prevNode, true); + } + } + } + + private void setAcceptingState(final StateNode prevNode) { + prevNode.setAccepting(true); + } + + private Expression getLeftMostChild(Expression ex) { + if (ex.getOrderEv().size() > 0) { + return ex; + } + if (ex.getLeft() != null) { + return getLeftMostChild(ex.getLeft()); + } + return null; + } + + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/StateNode.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/StateNode.java new file mode 100644 index 00000000..3428382f --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/StateNode.java @@ -0,0 +1,112 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.smgbuilder; + + +public class StateNode implements java.io.Serializable { + + /** + * + */ + private static final long serialVersionUID = 1L; + + private final String name; + + private Boolean init = false; + private Boolean accepting = false; + private int hopsToAccepting = Integer.MAX_VALUE; + + public StateNode(String _name) { + name = _name; + } + + public StateNode(String _name, Boolean _init) { + this(_name); + init = _init; + } + + public StateNode(String _name, Boolean _init, Boolean _accepting) { + this(_name, _init); + accepting = _accepting; + } + + public String getName() { + return name; + } + + public Boolean getInit() { + return init; + } + + public Boolean getAccepting() { + return accepting; + } + + public void setAccepting(Boolean _accepting) { + accepting = _accepting; + } + + public String toString() { + StringBuilder nodeSB = new StringBuilder(); + nodeSB.append("Name: "); + nodeSB.append(name); + nodeSB.append(" ("); + if (!accepting) { + nodeSB.append(hopsToAccepting + "hops to "); + } + nodeSB.append("accepting)"); + return nodeSB.toString(); + } + + public boolean isErrorState() { + return !accepting; + } + + public boolean isInitialState() { + return init; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((accepting == null) ? 0 : accepting.hashCode()); + result = prime * result + ((init == null) ? 0 : init.hashCode()); + result = prime * result + ((name == null) ? 0 : name.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + StateNode other = (StateNode) obj; + if (accepting == null) { + if (other.accepting != null) + return false; + } else if (!accepting.equals(other.accepting)) + return false; + if (init == null) { + if (other.init != null) + return false; + } else if (!init.equals(other.init)) + return false; + if (name == null) { + if (other.name != null) + return false; + } else if (!name.equals(other.name)) + return false; + return true; + } + + public void setHopsToAccepting(int hops) { + hopsToAccepting = hops; + } + + public int getHopsToAccepting() { + return hopsToAccepting; + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/Transition.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/Transition.java new file mode 100644 index 00000000..9ac4fab5 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/Transition.java @@ -0,0 +1,11 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.smgbuilder; + +import java.util.List; + +import de.darmstadt.tu.crossing.crySL.Event; + +public interface Transition{ + State from(); + State to(); + Event getLabel(); +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/TransitionEdge.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/TransitionEdge.java new file mode 100644 index 00000000..d37a4c21 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/diagram/smgbuilder/TransitionEdge.java @@ -0,0 +1,90 @@ +package de.darmstadt.tu.crossing.statemachine.diagram.smgbuilder; + +import java.util.List; + +import de.darmstadt.tu.crossing.crySL.Event; + +public class TransitionEdge implements Transition, java.io.Serializable { + + private static final long serialVersionUID = 1L; + private StateNode left = null; + private StateNode right = null; + private Event method = null; + + // see the implementation in CryptoAnalysis TransitionEdge + // may be it is required to keep it as in CryptoAnalysis. + public TransitionEdge(Event _method, StateNode _left, StateNode _right) { + left = _left; + right = _right; + method = _method; + } + + public StateNode getLeft() { + return left; + } + + public StateNode getRight() { + return right; + } + + public Event getLabel() { + return method; + } + + public String toString() { + StringBuilder edgeSB = new StringBuilder(); + edgeSB.append("Left: "); + edgeSB.append(this.left.getName()); + edgeSB.append(" ===="); + edgeSB.append(method); + edgeSB.append("====> Right:"); + edgeSB.append(this.right.getName()); + return edgeSB.toString(); + } + + public StateNode from() { + return left; + } + + public StateNode to() { + return right; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((method == null) ? 0 : method.hashCode()); + result = prime * result + ((left == null) ? 0 : left.hashCode()); + result = prime * result + ((right == null) ? 0 : right.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + TransitionEdge other = (TransitionEdge) obj; + if (method == null) { + if (other.method != null) + return false; + } else if (!method.equals(other.method)) + return false; + if (left == null) { + if (other.left != null) + return false; + } else if (!left.equals(other.left)) + return false; + if (right == null) { + if (other.right != null) + return false; + } else if (!right.equals(other.right)) + return false; + return true; + } + +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/EObjectSelectionListener.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/EObjectSelectionListener.java new file mode 100644 index 00000000..590737ff --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/EObjectSelectionListener.java @@ -0,0 +1,153 @@ +/** + * Copyright (c) 2015 itemis AG (http://www.itemis.eu) 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 + */ +package de.darmstadt.tu.crossing.statemachine.xtext.xproperties; + +import com.google.common.base.Objects; +import java.util.ArrayList; +import java.util.function.Consumer; +import org.eclipse.emf.common.notify.Adapter; +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.impl.AdapterImpl; +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.transaction.TransactionalEditingDomain; +import org.eclipse.jface.viewers.ISelection; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.ui.IEditorPart; +import org.eclipse.ui.ISelectionListener; +import org.eclipse.ui.ISelectionService; +import org.eclipse.ui.IWorkbenchPart; +import org.eclipse.ui.IWorkbenchWindow; +import org.eclipse.ui.PlatformUI; +import org.eclipse.xtend.lib.annotations.AccessorType; +import org.eclipse.xtend.lib.annotations.Accessors; +import org.eclipse.xtext.xbase.lib.Procedures.Procedure3; +import org.eclipse.xtext.xbase.lib.Pure; +import de.darmstadt.tu.crossing.statemachine.xtext.xproperties.FrameworkAdapters; + +@SuppressWarnings("all") +class EObjectSelectionListener implements ISelectionListener { + private final ArrayList> stateChangeListeners = new ArrayList>(); + + @Accessors(AccessorType.PUBLIC_GETTER) + private EObject selectedObject; + + @Accessors(AccessorType.PUBLIC_GETTER) + private IEditorPart currentEditor; + + @Accessors(AccessorType.PUBLIC_GETTER) + private TransactionalEditingDomain editingDomain; + + private Adapter adapter; + + public EObjectSelectionListener() { + final IWorkbenchWindow workbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow(); + final ISelectionService selectionService = workbenchWindow.getSelectionService(); + selectionService.addSelectionListener(this); + this.selectionChanged(workbenchWindow.getActivePage().getActivePart(), selectionService.getSelection()); + } + + public TransactionalEditingDomain dispose() { + TransactionalEditingDomain _xblockexpression = null; + { + final ISelectionService selectionService = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getSelectionService(); + selectionService.removeSelectionListener(this); + this.stateChangeListeners.clear(); + this.selectedObject = null; + this.currentEditor = null; + _xblockexpression = this.editingDomain = null; + } + return _xblockexpression; + } + + public boolean addStateChangeListener(final Procedure3 listener) { + return this.stateChangeListeners.add(listener); + } + + @Override + public void selectionChanged(final IWorkbenchPart part, final ISelection selection) { + if ((part instanceof IEditorPart)) { + this.currentEditor = ((IEditorPart)part); + if ((selection instanceof IStructuredSelection)) { + final Object element = ((IStructuredSelection) selection).getFirstElement(); + final FrameworkAdapters.IAdapter adapter = FrameworkAdapters.getAdapter(element); + if ((adapter != null)) { + this.handleSelection(adapter.getModel(element), adapter.getEditingDomain(element)); + return; + } + } + this.editingDomain = null; + this.handleSelection(null, null); + } + } + + private boolean handleSelection(final EObject object, final TransactionalEditingDomain editingDomain) { + boolean _xifexpression = false; + if ((object != this.selectedObject)) { + boolean _xblockexpression = false; + { + boolean _notEquals = (!Objects.equal(this.selectedObject, null)); + if (_notEquals) { + EList _eAdapters = this.selectedObject.eAdapters(); + _eAdapters.remove(this.adapter); + } + this.selectedObject = object; + final Consumer> _function = new Consumer>() { + @Override + public void accept(final Procedure3 it) { + it.apply(object, null, editingDomain); + } + }; + this.stateChangeListeners.forEach(_function); + boolean _xifexpression_1 = false; + if ((object != null)) { + boolean _xblockexpression_1 = false; + { + this.adapter = new AdapterImpl() { + @Override + public void notifyChanged(final Notification msg) { + int _eventType = msg.getEventType(); + boolean _notEquals = (_eventType != Notification.REMOVING_ADAPTER); + if (_notEquals) { + final Consumer> _function = new Consumer>() { + @Override + public void accept(final Procedure3 it) { + it.apply(object, msg, editingDomain); + } + }; + EObjectSelectionListener.this.stateChangeListeners.forEach(_function); + } + } + }; + EList _eAdapters_1 = object.eAdapters(); + _xblockexpression_1 = _eAdapters_1.add(this.adapter); + } + _xifexpression_1 = _xblockexpression_1; + } + _xblockexpression = _xifexpression_1; + } + _xifexpression = _xblockexpression; + } + return _xifexpression; + } + + @Pure + public EObject getSelectedObject() { + return this.selectedObject; + } + + @Pure + public IEditorPart getCurrentEditor() { + return this.currentEditor; + } + + @Pure + public TransactionalEditingDomain getEditingDomain() { + return this.editingDomain; + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/EditedResourceProvider.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/EditedResourceProvider.java new file mode 100644 index 00000000..4dcbfdfe --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/EditedResourceProvider.java @@ -0,0 +1,45 @@ +/** + * Copyright (c) 2015 itemis AG (http://www.itemis.eu) 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 + */ +package de.darmstadt.tu.crossing.statemachine.xtext.xproperties; + +import com.google.inject.Inject; +import org.eclipse.emf.common.util.URI; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.xtend.lib.annotations.AccessorType; +import org.eclipse.xtend.lib.annotations.Accessors; +import org.eclipse.xtext.resource.FileExtensionProvider; +import org.eclipse.xtext.resource.XtextResource; +import org.eclipse.xtext.resource.XtextResourceSet; +import org.eclipse.xtext.ui.editor.embedded.IEditedResourceProvider; +import org.eclipse.xtext.xbase.lib.IterableExtensions; +import org.eclipse.xtext.xbase.lib.Pure; + +@SuppressWarnings("all") +public class EditedResourceProvider implements IEditedResourceProvider { + @Inject + private FileExtensionProvider fileExtensionProvider; + + @Accessors(AccessorType.PUBLIC_GETTER) + private XtextResource resource; + + @Override + public XtextResource createResource() { + final XtextResourceSet resourceSet = new XtextResourceSet(); + String _head = IterableExtensions.head(this.fileExtensionProvider.getFileExtensions()); + String _plus = ("embeddedResource." + _head); + final URI uri = URI.createURI(_plus); + Resource _createResource = resourceSet.createResource(uri); + this.resource = ((XtextResource) _createResource); + return this.resource; + } + + @Pure + public XtextResource getResource() { + return this.resource; + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/EmbeddedResourceValidator.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/EmbeddedResourceValidator.java new file mode 100644 index 00000000..91723b4d --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/EmbeddedResourceValidator.java @@ -0,0 +1,163 @@ +/** + * Copyright (c) 2015 itemis AG (http://www.itemis.eu) 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 + */ +package de.darmstadt.tu.crossing.statemachine.xtext.xproperties; + +import com.google.inject.Inject; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.xtend.lib.annotations.Accessors; +import org.eclipse.xtext.diagnostics.Severity; +import org.eclipse.xtext.nodemodel.ICompositeNode; +import org.eclipse.xtext.nodemodel.util.NodeModelUtils; +import org.eclipse.xtext.service.OperationCanceledManager; +import org.eclipse.xtext.util.CancelIndicator; +import org.eclipse.xtext.util.IAcceptor; +import org.eclipse.xtext.util.ITextRegion; +import org.eclipse.xtext.validation.CheckMode; +import org.eclipse.xtext.validation.CheckType; +import org.eclipse.xtext.validation.Issue; +import org.eclipse.xtext.validation.ResourceValidatorImpl; +import org.eclipse.xtext.xbase.lib.Functions.Function0; +import org.eclipse.xtext.xbase.lib.IterableExtensions; +import org.eclipse.xtext.xbase.lib.ObjectExtensions; +import org.eclipse.xtext.xbase.lib.Procedures.Procedure1; +import org.eclipse.xtext.xbase.lib.Pure; +import de.darmstadt.tu.crossing.statemachine.xtext.xproperties.IModelMerger; + +@SuppressWarnings("all") +public class EmbeddedResourceValidator extends ResourceValidatorImpl { + @Inject + private OperationCanceledManager operationCanceledManager; + + @Inject + private IModelMerger modelMerger; + + @Accessors + private EObject originalObject; + + @Accessors + private Function0 embeddedTextProvider; + + @Accessors + private Function0 visibleRegionProvider; + + @Override + protected void validate(final Resource resource, final CheckMode mode, final CancelIndicator monitor, final IAcceptor acceptor) { + super.validate(resource, mode, monitor, acceptor); + this.operationCanceledManager.checkCanceled(monitor); + if ((this.originalObject == null)) { + return; + } + final ITextRegion visibleRegion = this.visibleRegionProvider.apply(); + final EObject embeddedModel = IterableExtensions.head(resource.getContents()); + final EObject matchingObject = this.modelMerger.findMatchingObject(embeddedModel, this.originalObject); + if ((matchingObject == null)) { + this.error("The selected element cannot be removed or renamed in this view.", + visibleRegion.getOffset(), visibleRegion.getLength(), acceptor); + } else { + final ICompositeNode selectedNode = NodeModelUtils.getNode(matchingObject); + if ((selectedNode != null)) { + final String embeddedText = this.embeddedTextProvider.apply(); + final int selectedOffset = selectedNode.getOffset(); + int _offset = visibleRegion.getOffset(); + boolean _greaterThan = (selectedOffset > _offset); + if (_greaterThan) { + final String prefix = embeddedText.substring(visibleRegion.getOffset(), selectedOffset); + final int start = this.nonWhitespaceStart(prefix); + if ((start >= 0)) { + int _offset_1 = visibleRegion.getOffset(); + int _plus = (_offset_1 + start); + int _nonWhitespaceEnd = this.nonWhitespaceEnd(prefix); + int _minus = (_nonWhitespaceEnd - start); + this.error("Only the content of the selected element may be edited in this view.", _plus, _minus, acceptor); + } + } + int _length = selectedNode.getLength(); + final int selectedEndOffset = (selectedOffset + _length); + int _offset_2 = visibleRegion.getOffset(); + int _length_1 = visibleRegion.getLength(); + final int visibleEndOffset = (_offset_2 + _length_1); + if ((selectedEndOffset < visibleEndOffset)) { + final String suffix = embeddedText.substring(selectedEndOffset, visibleEndOffset); + final int start_1 = this.nonWhitespaceStart(suffix); + if ((start_1 >= 0)) { + int _nonWhitespaceEnd_1 = this.nonWhitespaceEnd(suffix); + int _minus_1 = (_nonWhitespaceEnd_1 - start_1); + this.error("Only the content of the selected element may be edited in this view.", + (selectedEndOffset + start_1), _minus_1, acceptor); + } + } + } + } + } + + private int nonWhitespaceStart(final String s) { + for (int i = 0; (i < s.length()); i++) { + boolean _isWhitespace = Character.isWhitespace(s.charAt(i)); + boolean _not = (!_isWhitespace); + if (_not) { + return i; + } + } + return (-1); + } + + private int nonWhitespaceEnd(final String s) { + for (int i = (s.length() - 1); (i >= 0); i--) { + boolean _isWhitespace = Character.isWhitespace(s.charAt(i)); + boolean _not = (!_isWhitespace); + if (_not) { + return (i + 1); + } + } + return (-1); + } + + protected void error(final String message, final int offset, final int length, final IAcceptor acceptor) { + Issue.IssueImpl _issueImpl = new Issue.IssueImpl(); + final Procedure1 _function = new Procedure1() { + @Override + public void apply(final Issue.IssueImpl issue) { + issue.setType(CheckType.FAST); + issue.setSeverity(Severity.ERROR); + issue.setMessage(message); + issue.setOffset(Integer.valueOf(offset)); + issue.setLength(Integer.valueOf(length)); + } + }; + Issue.IssueImpl _doubleArrow = ObjectExtensions.operator_doubleArrow(_issueImpl, _function); + acceptor.accept(_doubleArrow); + } + + @Pure + public EObject getOriginalObject() { + return this.originalObject; + } + + public void setOriginalObject(final EObject originalObject) { + this.originalObject = originalObject; + } + + @Pure + public Function0 getEmbeddedTextProvider() { + return this.embeddedTextProvider; + } + + public void setEmbeddedTextProvider(final Function0 embeddedTextProvider) { + this.embeddedTextProvider = embeddedTextProvider; + } + + @Pure + public Function0 getVisibleRegionProvider() { + return this.visibleRegionProvider; + } + + public void setVisibleRegionProvider(final Function0 visibleRegionProvider) { + this.visibleRegionProvider = visibleRegionProvider; + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/FrameworkAdapters.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/FrameworkAdapters.java new file mode 100644 index 00000000..2048949d --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/FrameworkAdapters.java @@ -0,0 +1,67 @@ +/** + * Copyright (c) 2015 itemis AG (http://www.itemis.eu) 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 + */ +package de.darmstadt.tu.crossing.statemachine.xtext.xproperties; + +import com.google.common.base.Objects; +import java.util.ArrayList; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.transaction.TransactionalEditingDomain; +import org.eclipse.xtext.xbase.lib.Functions.Function1; +import org.eclipse.xtext.xbase.lib.IterableExtensions; + +@SuppressWarnings("all") +public final class FrameworkAdapters { + public interface IAdapter { + public abstract boolean appliesTo(final Object element); + + public abstract EObject getModel(final Object element); + + public abstract TransactionalEditingDomain getEditingDomain(final Object element); + } + + private FrameworkAdapters() { + } + + private static final ArrayList adapters = new ArrayList(); + + public static boolean addAdapter(final FrameworkAdapters.IAdapter adapter) { + boolean _xsynchronizedexpression = false; + synchronized (FrameworkAdapters.adapters) { + boolean _xifexpression = false; + final Function1 _function = new Function1() { + @Override + public Boolean apply(final FrameworkAdapters.IAdapter it) { + Class _class = it.getClass(); + Class _class_1 = adapter.getClass(); + return Boolean.valueOf(Objects.equal(_class, _class_1)); + } + }; + boolean _exists = IterableExtensions.exists(FrameworkAdapters.adapters, _function); + boolean _not = (!_exists); + if (_not) { + _xifexpression = FrameworkAdapters.adapters.add(adapter); + } + _xsynchronizedexpression = _xifexpression; + } + return _xsynchronizedexpression; + } + + public static FrameworkAdapters.IAdapter getAdapter(final Object element) { + FrameworkAdapters.IAdapter _xsynchronizedexpression = null; + synchronized (FrameworkAdapters.adapters) { + final Function1 _function = new Function1() { + @Override + public Boolean apply(final FrameworkAdapters.IAdapter it) { + return Boolean.valueOf(it.appliesTo(element)); + } + }; + _xsynchronizedexpression = IterableExtensions.findFirst(FrameworkAdapters.adapters, _function); + } + return _xsynchronizedexpression; + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/GenericModelMerger.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/GenericModelMerger.java new file mode 100644 index 00000000..a4d31820 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/GenericModelMerger.java @@ -0,0 +1,177 @@ +/** + * Copyright (c) 2015 itemis AG (http://www.itemis.eu) 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 + */ +package de.darmstadt.tu.crossing.statemachine.xtext.xproperties; + +import com.google.common.collect.Iterables; +import java.util.Collection; +import java.util.List; +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.util.BasicMonitor; +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.compare.Comparison; +import org.eclipse.emf.compare.Diff; +import org.eclipse.emf.compare.EMFCompare; +import org.eclipse.emf.compare.merge.BatchMerger; +import org.eclipse.emf.compare.merge.IMerger; +import org.eclipse.emf.compare.rcp.EMFCompareRCPPlugin; +import org.eclipse.emf.compare.scope.DefaultComparisonScope; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EReference; +import org.eclipse.emf.ecore.EStructuralFeature; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.xtext.xbase.lib.Functions.Function1; +import org.eclipse.xtext.xbase.lib.IterableExtensions; +import de.darmstadt.tu.crossing.statemachine.xtext.xproperties.IModelMerger; + +@SuppressWarnings("all") +public class GenericModelMerger implements IModelMerger { + @Override + public EObject findMatchingObject(final EObject model, final EObject object) { + Resource _eResource = model.eResource(); + Resource _eResource_1 = object.eResource(); + final DefaultComparisonScope scope = new DefaultComparisonScope(_eResource, _eResource_1, null); + final Comparison comparison = EMFCompare.builder().build().compare(scope); + return comparison.getMatch(object).getLeft(); + } + + protected List findMatchingObjects(final EObject model, final Collection objects) { + boolean _isEmpty = objects.isEmpty(); + if (_isEmpty) { + throw new IllegalArgumentException(); + } + Resource _eResource = model.eResource(); + Resource _eResource_1 = IterableExtensions.head(objects).eResource(); + final DefaultComparisonScope scope = new DefaultComparisonScope(_eResource, _eResource_1, null); + final Comparison comparison = EMFCompare.builder().build().compare(scope); + final Function1 _function = new Function1() { + @Override + public EObject apply(final EObject object) { + return comparison.getMatch(object).getLeft(); + } + }; + return IterableExtensions.toList(IterableExtensions.filterNull(IterableExtensions.map(objects, _function))); + } + + @Override + public void merge(final EObject source, final EObject destination) { + final DefaultComparisonScope scope = new DefaultComparisonScope(destination, source, null); + final Comparison comparison = EMFCompare.builder().build().compare(scope); + IMerger.Registry _mergerRegistry = EMFCompareRCPPlugin.getDefault().getMergerRegistry(); + final BatchMerger merger = new BatchMerger(_mergerRegistry); + EList _differences = comparison.getDifferences(); + BasicMonitor _basicMonitor = new BasicMonitor(); + merger.copyAllRightToLeft(_differences, _basicMonitor); + } + + @Override + public void apply(final Notification notification, final EObject destination) { + final Object feature = notification.getFeature(); + if ((feature instanceof EStructuralFeature)) { + GenericModelMerger.assertNot(((feature instanceof EReference) && ((EReference) feature).isContainer())); + int _eventType = notification.getEventType(); + switch (_eventType) { + case Notification.ADD: + GenericModelMerger.assertThat(((EStructuralFeature)feature).isMany()); + Object _eGet = destination.eGet(((EStructuralFeature)feature)); + final Collection collection = ((Collection) _eGet); + if ((feature instanceof EReference)) { + boolean _isContainment = ((EReference)feature).isContainment(); + if (_isContainment) { + Object _newValue = notification.getNewValue(); + collection.add(EcoreUtil.copy(((EObject) _newValue))); + } else { + Object _newValue_1 = notification.getNewValue(); + collection.add(this.findMatchingObject(destination, ((EObject) _newValue_1))); + } + } else { + collection.add(notification.getNewValue()); + } + break; + case Notification.ADD_MANY: + GenericModelMerger.assertThat(((EStructuralFeature)feature).isMany()); + Object _eGet_1 = destination.eGet(((EStructuralFeature)feature)); + final Collection collection_1 = ((Collection) _eGet_1); + if ((feature instanceof EReference)) { + boolean _isContainment_1 = ((EReference)feature).isContainment(); + if (_isContainment_1) { + Object _newValue_2 = notification.getNewValue(); + final Function1 _function = new Function1() { + @Override + public EObject apply(final EObject it) { + return EcoreUtil.copy(it); + } + }; + Iterables.addAll(collection_1, IterableExtensions.map(((Collection) _newValue_2), _function)); + } else { + Object _newValue_3 = notification.getNewValue(); + collection_1.addAll(this.findMatchingObjects(destination, ((Collection) _newValue_3))); + } + } else { + Object _newValue_4 = notification.getNewValue(); + collection_1.addAll(((Collection) _newValue_4)); + } + break; + case Notification.REMOVE: + GenericModelMerger.assertThat(((EStructuralFeature)feature).isMany()); + Object _eGet_2 = destination.eGet(((EStructuralFeature)feature)); + final Collection collection_2 = ((Collection) _eGet_2); + if ((feature instanceof EReference)) { + Object _oldValue = notification.getOldValue(); + collection_2.remove(this.findMatchingObject(destination, ((EObject) _oldValue))); + } else { + collection_2.remove(notification.getOldValue()); + } + break; + case Notification.REMOVE_MANY: + GenericModelMerger.assertThat(((EStructuralFeature)feature).isMany()); + Object _eGet_3 = destination.eGet(((EStructuralFeature)feature)); + final Collection collection_3 = ((Collection) _eGet_3); + if ((feature instanceof EReference)) { + Object _oldValue_1 = notification.getOldValue(); + collection_3.removeAll(this.findMatchingObjects(destination, ((Collection) _oldValue_1))); + } else { + Object _oldValue_2 = notification.getOldValue(); + collection_3.removeAll(((Collection) _oldValue_2)); + } + break; + case Notification.SET: + GenericModelMerger.assertNot(((EStructuralFeature)feature).isMany()); + if ((feature instanceof EReference)) { + boolean _isContainment_2 = ((EReference)feature).isContainment(); + if (_isContainment_2) { + Object _newValue_5 = notification.getNewValue(); + destination.eSet(((EStructuralFeature)feature), EcoreUtil.copy(((EObject) _newValue_5))); + } else { + Object _newValue_6 = notification.getNewValue(); + destination.eSet(((EStructuralFeature)feature), this.findMatchingObject(destination, ((EObject) _newValue_6))); + } + } else { + destination.eSet(((EStructuralFeature)feature), notification.getNewValue()); + } + break; + case Notification.UNSET: + GenericModelMerger.assertNot(((EStructuralFeature)feature).isMany()); + destination.eUnset(((EStructuralFeature)feature)); + break; + } + } else { + throw new UnsupportedOperationException((("Feature " + feature) + " not supported.")); + } + } + + private static void assertThat(final boolean b) { + if ((!b)) { + throw new AssertionError(); + } + } + + private static void assertNot(final boolean b) { + GenericModelMerger.assertThat((!b)); + } +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/IModelMerger.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/IModelMerger.java new file mode 100644 index 00000000..d31f8f2c --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/IModelMerger.java @@ -0,0 +1,23 @@ +/** + * Copyright (c) 2015 itemis AG (http://www.itemis.eu) 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 + */ +package de.darmstadt.tu.crossing.statemachine.xtext.xproperties; + +import com.google.inject.ImplementedBy; +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.ecore.EObject; +import de.darmstadt.tu.crossing.statemachine.xtext.xproperties.GenericModelMerger; + +@ImplementedBy(GenericModelMerger.class) +@SuppressWarnings("all") +public interface IModelMerger { + public abstract EObject findMatchingObject(final EObject model, final EObject object); + + public abstract void merge(final EObject source, final EObject destination); + + public abstract void apply(final Notification notification, final EObject destination); +} diff --git a/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/TextPropertiesViewPart.java b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/TextPropertiesViewPart.java new file mode 100644 index 00000000..037feee8 --- /dev/null +++ b/de.darmstadt.tu.crossing.CrySL.statemachine.diagram/src/main/java/de/darmstadt/tu/crossing/statemachine/xtext/xproperties/TextPropertiesViewPart.java @@ -0,0 +1,367 @@ +/** + * Copyright (c) 2015 itemis AG (http://www.itemis.eu) 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 + */ +package de.darmstadt.tu.crossing.statemachine.xtext.xproperties; + +import com.google.common.base.Objects; +import com.google.inject.Inject; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.concurrent.Callable; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.function.Consumer; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.emf.common.command.CommandStack; +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.transaction.RecordingCommand; +import org.eclipse.emf.transaction.TransactionalEditingDomain; +import org.eclipse.jface.action.IStatusLineManager; +import org.eclipse.jface.text.IRegion; +import org.eclipse.swt.custom.StyledText; +import org.eclipse.swt.graphics.Font; +import org.eclipse.swt.graphics.Resource; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Display; +import org.eclipse.ui.IActionBars; +import org.eclipse.ui.part.ViewPart; +import org.eclipse.xtext.diagnostics.Severity; +import org.eclipse.xtext.resource.SaveOptions; +import org.eclipse.xtext.serializer.ISerializer; +import org.eclipse.xtext.ui.editor.XtextSourceViewer; +import org.eclipse.xtext.ui.editor.embedded.EmbeddedEditor; +import org.eclipse.xtext.ui.editor.embedded.EmbeddedEditorFactory; +import org.eclipse.xtext.ui.editor.embedded.EmbeddedEditorModelAccess; +import org.eclipse.xtext.ui.editor.validation.IValidationIssueProcessor; +import org.eclipse.xtext.util.ITextRegion; +import org.eclipse.xtext.util.TextRegion; +import org.eclipse.xtext.validation.Issue; +import org.eclipse.xtext.xbase.lib.CollectionLiterals; +import org.eclipse.xtext.xbase.lib.Exceptions; +import org.eclipse.xtext.xbase.lib.Functions.Function0; +import org.eclipse.xtext.xbase.lib.Functions.Function1; +import org.eclipse.xtext.xbase.lib.IterableExtensions; +import org.eclipse.xtext.xbase.lib.Procedures.Procedure3; +import de.darmstadt.tu.crossing.statemachine.xtext.xproperties.EObjectSelectionListener; +import de.darmstadt.tu.crossing.statemachine.xtext.xproperties.EditedResourceProvider; +import de.darmstadt.tu.crossing.statemachine.xtext.xproperties.EmbeddedResourceValidator; +import de.darmstadt.tu.crossing.statemachine.xtext.xproperties.IModelMerger; + +@SuppressWarnings("all") +public class TextPropertiesViewPart extends ViewPart { + @Inject + private EditedResourceProvider resourceProvider; + + @Inject + private IModelMerger modelMerger; + + @Inject + private EmbeddedEditorFactory editorFactory; + + @Inject + private EmbeddedResourceValidator resourceValidator; + + @Inject + private ISerializer serializer; + + private final ArrayList swtResources = new ArrayList(); + + private final ExecutorService executorService = Executors.newCachedThreadPool(); + + private EObjectSelectionListener selectionListener; + + private XtextSourceViewer viewer; + + private EmbeddedEditorModelAccess modelAccess; + + private EObject currentViewedObject; + + private TransactionalEditingDomain editingDomain; + + private String lastMergedContent; + + private boolean refreshing; + + private boolean mergingBack; + + private Thread clearStatusThread; + + private List validationErrors; + + @Override + public void createPartControl(final Composite parent) { + final IValidationIssueProcessor _function = new IValidationIssueProcessor() { + @Override + public void processIssues(final List issues, final IProgressMonitor monitor) { + final Function1 _function = new Function1() { + @Override + public Boolean apply(final Issue it) { + Severity _severity = it.getSeverity(); + return Boolean.valueOf(Objects.equal(_severity, Severity.ERROR)); + } + }; + TextPropertiesViewPart.this.validationErrors = IterableExtensions.toList(IterableExtensions.filter(issues, _function)); + final Callable _function_1 = new Callable() { + @Override + public String call() throws Exception { + return TextPropertiesViewPart.this.documentChanged(); + } + }; + TextPropertiesViewPart.this.executorService.submit(_function_1); + } + }; + final EmbeddedEditor editor = this.editorFactory.newEditor(this.resourceProvider).showErrorAndWarningAnnotations().withResourceValidator(this.resourceValidator).processIssuesBy(_function).withParent(parent); + this.modelAccess = editor.createPartialEditor(); + this.viewer = editor.getViewer(); + StyledText _textWidget = this.viewer.getTextWidget(); + _textWidget.setFont(this.getFont()); + final Function0 _function_1 = new Function0() { + @Override + public String apply() { + return TextPropertiesViewPart.this.modelAccess.getSerializedModel(); + } + }; + this.resourceValidator.setEmbeddedTextProvider(_function_1); + final Function0 _function_2 = new Function0() { + @Override + public ITextRegion apply() { + TextRegion _xblockexpression = null; + { + final IRegion region = TextPropertiesViewPart.this.viewer.getVisibleRegion(); + int _offset = region.getOffset(); + int _length = region.getLength(); + _xblockexpression = new TextRegion(_offset, _length); + } + return _xblockexpression; + } + }; + this.resourceValidator.setVisibleRegionProvider(_function_2); + EObjectSelectionListener _eObjectSelectionListener = new EObjectSelectionListener(); + this.selectionListener = _eObjectSelectionListener; + final Procedure3 _function_3 = new Procedure3() { + @Override + public void apply(final EObject object, final Notification notification, final TransactionalEditingDomain editingDomain) { + TextPropertiesViewPart.this.refresh(object, notification); + TextPropertiesViewPart.this.editingDomain = editingDomain; + } + }; + this.selectionListener.addStateChangeListener(_function_3); + this.refresh(this.selectionListener.getSelectedObject(), null); + this.editingDomain = this.selectionListener.getEditingDomain(); + } + + protected Font getFont() { + Display _display = this.getViewSite().getShell().getDisplay(); + final Font font = new Font(_display, "Courier", 14, 0); + this.swtResources.add(font); + return font; + } + + @Override + public void dispose() { + if (this.selectionListener!=null) { + this.selectionListener.dispose(); + } + final Consumer _function = new Consumer() { + @Override + public void accept(final Resource it) { + it.dispose(); + } + }; + this.swtResources.forEach(_function); + this.swtResources.clear(); + this.executorService.shutdown(); + super.dispose(); + } + + protected void refresh(final EObject object, final Notification notification) { + if ((this.refreshing || this.mergingBack)) { + return; + } + this.refreshing = true; + try { + if (((object == this.currentViewedObject) && (notification != null))) { + final EObject mergeResult = this.mergeForward(object, notification); + if ((mergeResult != null)) { + final String uriFragment = mergeResult.eResource().getURIFragment(mergeResult); + final String serializedModel = this.serializer.serialize(mergeResult.eContainer(), SaveOptions.newBuilder().format().getOptions()); + this.modelAccess.updateModel(serializedModel, uriFragment); + this.lastMergedContent = this.modelAccess.getEditablePart(); + return; + } + } + if ((this.currentViewedObject != null)) { + final String content = this.modelAccess.getEditablePart(); + boolean _notEquals = (!Objects.equal(content, this.lastMergedContent)); + if (_notEquals) { + EObject mergeSource = null; + if (((object != this.currentViewedObject) && this.validationErrors.isEmpty())) { + mergeSource = this.mergeBack(this.currentViewedObject, this.editingDomain); + } + if ((mergeSource == null)) { + this.handleDiscardedChanges(); + } + } + } + this.resourceValidator.setOriginalObject(object); + if ((object == null)) { + this.lastMergedContent = ""; + this.modelAccess.updateModel(this.lastMergedContent); + } else { + final String uriFragment_1 = object.eResource().getURIFragment(object); + final String serializedModel_1 = this.serializer.serialize(object.eContainer(), SaveOptions.newBuilder().format().getOptions()); + this.modelAccess.updateModel(serializedModel_1, uriFragment_1); + this.viewer.setSelectedRange(0, 0); + this.lastMergedContent = this.modelAccess.getEditablePart(); + } + this.currentViewedObject = object; + } finally { + this.refreshing = false; + } + } + + protected String documentChanged() { + String _xifexpression = null; + if (((((!this.refreshing) && (!this.mergingBack)) && (this.currentViewedObject != null)) && this.validationErrors.isEmpty())) { + String _xblockexpression = null; + { + this.mergingBack = true; + String _xtrycatchfinallyexpression = null; + try { + String _xblockexpression_1 = null; + { + final EObject mergeSource = this.mergeBack(this.currentViewedObject, this.editingDomain); + String _xifexpression_1 = null; + if ((mergeSource != null)) { + _xifexpression_1 = this.lastMergedContent = this.modelAccess.getEditablePart(); + } + _xblockexpression_1 = _xifexpression_1; + } + _xtrycatchfinallyexpression = _xblockexpression_1; + } finally { + this.mergingBack = false; + } + _xblockexpression = _xtrycatchfinallyexpression; + } + _xifexpression = _xblockexpression; + } + return _xifexpression; + } + + protected EObject mergeForward(final EObject object, final Notification notification) { + final EObject modelCopy = this.resourceProvider.getResource().getParseResult().getRootASTElement(); + final EObject copy = this.modelMerger.findMatchingObject(modelCopy, object); + if (((copy == null) || (copy.eContainer() == null))) { + return null; + } + try { + this.modelMerger.apply(notification, copy); + return copy; + } catch (final Throwable _t) { + if (_t instanceof UnsupportedOperationException) { + return null; + } else { + throw Exceptions.sneakyThrow(_t); + } + } + } + + protected EObject mergeBack(final EObject object, final TransactionalEditingDomain editingDomain) { + final EObject modelCopy = this.resourceProvider.getResource().getParseResult().getRootASTElement(); + final EObject copy = this.modelMerger.findMatchingObject(modelCopy, object); + if (((copy == null) || (copy.eContainer() == null))) { + return null; + } + CommandStack _commandStack = editingDomain.getCommandStack(); + _commandStack.execute(new RecordingCommand(editingDomain, "Text Changes") { + @Override + protected void doExecute() { + TextPropertiesViewPart.this.modelMerger.merge(copy, object); + } + }); + return copy; + } + + protected Future handleDiscardedChanges() { + Future _xblockexpression = null; + { + if ((this.clearStatusThread != null)) { + this.clearStatusThread.interrupt(); + } + final Display display = this.getViewSite().getShell().getDisplay(); + IActionBars _actionBars = this.getViewSite().getActionBars(); + IActionBars _actionBars_1 = this.selectionListener.getCurrentEditor().getEditorSite().getActionBars(); + final List actionBars = Collections.unmodifiableList(CollectionLiterals.newArrayList(_actionBars, _actionBars_1)); + final Runnable _function = new Runnable() { + @Override + public void run() { + final Consumer _function = new Consumer() { + @Override + public void accept(final IActionBars it) { + IStatusLineManager _statusLineManager = it.getStatusLineManager(); + _statusLineManager.setErrorMessage("Warning: The previous text changes have been discarded due to validation errors."); + } + }; + actionBars.forEach(_function); + } + }; + display.asyncExec(_function); + final Function1 _function_1 = new Function1() { + @Override + public Object apply(final Object it) { + Object _xtrycatchfinallyexpression = null; + try { + TextPropertiesViewPart.this.clearStatusThread = Thread.currentThread(); + Thread.sleep(5000); + final Runnable _function = new Runnable() { + @Override + public void run() { + final Consumer _function = new Consumer() { + @Override + public void accept(final IActionBars it) { + IStatusLineManager _statusLineManager = it.getStatusLineManager(); + _statusLineManager.setErrorMessage(null); + } + }; + actionBars.forEach(_function); + } + }; + display.syncExec(_function); + } catch (final Throwable _t) { + if (_t instanceof InterruptedException) { + _xtrycatchfinallyexpression = null; + } else { + throw Exceptions.sneakyThrow(_t); + } + } finally { + Thread _currentThread = Thread.currentThread(); + boolean _equals = Objects.equal(TextPropertiesViewPart.this.clearStatusThread, _currentThread); + if (_equals) { + TextPropertiesViewPart.this.clearStatusThread = null; + } + } + return _xtrycatchfinallyexpression; + } + }; + _xblockexpression = this.executorService.submit( + ((Runnable) new Runnable() { + public void run() { + _function_1.apply(null); + } + })); + } + return _xblockexpression; + } + + @Override + public void setFocus() { + this.viewer.getControl().setFocus(); + } +} diff --git a/pom.xml b/pom.xml index 26c8b17d..dae2c1ed 100644 --- a/pom.xml +++ b/pom.xml @@ -1,291 +1,293 @@ - - 4.0.0 - de.darmstadt.tu.crossing.CrySL - 2.0.0-SNAPSHOT - de.darmstadt.tu.crossing.CrySL.parent - pom - - - 1.4.0 - 2.16.0 - windows-1252 - 1.8 - 1.8 - - - - de.darmstadt.tu.crossing.CrySL - de.darmstadt.tu.crossing.CrySL.ide - de.darmstadt.tu.crossing.CrySL.ui - de.darmstadt.tu.crossing.CrySL.target - de.darmstadt.tu.crossing.CrySL.feature - de.darmstadt.tu.crossing.CrySL.repository - de.darmstadt.tu.crossing.CrySL.tests - - - - - org.eclipse.tycho - tycho-maven-plugin - ${tycho-version} - true - - - org.eclipse.tycho - target-platform-configuration - ${tycho-version} - - - - de.darmstadt.tu.crossing.CrySL - de.darmstadt.tu.crossing.CrySL.target - ${project.version} - - - - - macosx - cocoa - x86_64 - - - win32 - win32 - x86_64 - - - linux - gtk - x86_64 - - - - - - - - - - - org.eclipse.xtend - xtend-maven-plugin - 2.15.0 - - - - compile - xtend-install-debug-info - testCompile - xtend-test-install-debug-info - - - - - xtend-gen - - - - org.eclipse.m2e - lifecycle-mapping - 1.0.0 - - - - - - - org.apache.maven.plugins - - - maven-resources-plugin - - - [2.4.3,) - - - resources - testResources - - - - - - - - - - org.codehaus.mojo - - - build-helper-maven-plugin - - - [1.9.1,) - - - add-resource - add-source - add-test-resource - add-test-source - - - - - - - - - - org.eclipse.tycho - - - tycho-compiler-plugin - - - [0.23.1,) - - - compile - - - - - - - - - - org.eclipse.tycho - - - tycho-packaging-plugin - - - [0.23.1,) - - - build-qualifier - build-qualifier-aggregator - validate-id - validate-version - - - - - - - - - - - - - org.eclipse.tycho - tycho-compiler-plugin - ${tycho-version} - - -err:-forbidden - - - - org.sonatype.plugins - nexus-staging-maven-plugin - 1.6.8 - true - - soot-snapshot - https://soot-build.cs.uni-paderborn.de/nexus/repository/soot-snapshot - - - - maven-assembly-plugin - - - make-assembly - package - - single - - - - - - jar-with-dependencies - - build - - - - - - - - - true - soot-snapshot - Soot snapshot repository - https://soot-build.cs.uni-paderborn.de/nexus/repository/soot-snapshot - default - - - - - - codehaus-snapshots - disable dead 'Codehaus Snapshots' repository, see https://bugs.eclipse.org/bugs/show_bug.cgi?id=481478 - http://nexus.codehaus.org/snapshots/ - - false - - - false - - - - eclipse-photon - p2 - http://download.eclipse.org/releases/2019-06 - - - - maven.eclipse.org - http://maven.eclipse.org/nexus/content/groups/public/ - - - xtext - p2 - http://download.eclipse.org/modeling/tmf/xtext/updates/composite/releases/ - - - - - - codehaus-snapshots - disable dead 'Codehaus Snapshots' repository, see https://bugs.eclipse.org/bugs/show_bug.cgi?id=481478 - http://nexus.codehaus.org/snapshots/ - - false - - - false - - - - jboss-public-repository-group - JBoss Public Repository Group - http://repository.jboss.org/nexus/content/groups/public/ - - - jboss-snapshots-repository - JBoss Snapshots Repository - https://repository.jboss.org/nexus/content/repositories/snapshots/ - - - - - - + + + 4.0.0 + de.darmstadt.tu.crossing.CrySL + 2.0.0-SNAPSHOT + de.darmstadt.tu.crossing.CrySL.parent + pom + + + 1.4.0 + 2.16.0 + windows-1252 + 1.8 + 1.8 + + + + de.darmstadt.tu.crossing.CrySL + de.darmstadt.tu.crossing.CrySL.ide + de.darmstadt.tu.crossing.CrySL.ui + de.darmstadt.tu.crossing.CrySL.target + de.darmstadt.tu.crossing.CrySL.feature + de.darmstadt.tu.crossing.CrySL.repository + de.darmstadt.tu.crossing.CrySL.tests + de.darmstadt.tu.crossing.CrySL.statemachine.diagram + + + + + org.eclipse.tycho + tycho-maven-plugin + ${tycho-version} + true + + + org.eclipse.tycho + target-platform-configuration + ${tycho-version} + + + + de.darmstadt.tu.crossing.CrySL + de.darmstadt.tu.crossing.CrySL.target + ${project.version} + + + + + macosx + cocoa + x86_64 + + + win32 + win32 + x86_64 + + + linux + gtk + x86_64 + + + + + + + + + + + org.eclipse.xtend + xtend-maven-plugin + 2.15.0 + + + + compile + xtend-install-debug-info + testCompile + xtend-test-install-debug-info + + + + + xtend-gen + + + + org.eclipse.m2e + lifecycle-mapping + 1.0.0 + + + + + + + org.apache.maven.plugins + + + maven-resources-plugin + + + [2.4.3,) + + + resources + testResources + + + + + + + + + + org.codehaus.mojo + + + build-helper-maven-plugin + + + [1.9.1,) + + + add-resource + add-source + add-test-resource + add-test-source + + + + + + + + + + org.eclipse.tycho + + + tycho-compiler-plugin + + + [0.23.1,) + + + compile + + + + + + + + + + org.eclipse.tycho + + + tycho-packaging-plugin + + + [0.23.1,) + + + build-qualifier + build-qualifier-aggregator + validate-id + validate-version + + + + + + + + + + + + + org.eclipse.tycho + tycho-compiler-plugin + ${tycho-version} + + -err:-forbidden + + + + org.sonatype.plugins + nexus-staging-maven-plugin + 1.6.8 + true + + soot-snapshot + https://soot-build.cs.uni-paderborn.de/nexus/repository/soot-snapshot + + + + maven-assembly-plugin + + + make-assembly + package + + single + + + + + + jar-with-dependencies + + build + + + + + + + + + true + soot-snapshot + Soot snapshot repository + https://soot-build.cs.uni-paderborn.de/nexus/repository/soot-snapshot + default + + + + + + codehaus-snapshots + disable dead 'Codehaus Snapshots' repository, see https://bugs.eclipse.org/bugs/show_bug.cgi?id=481478 + http://nexus.codehaus.org/snapshots/ + + false + + + false + + + + eclipse-photon + p2 + http://download.eclipse.org/releases/2019-06 + + + + maven.eclipse.org + http://maven.eclipse.org/nexus/content/groups/public/ + + + xtext + p2 + http://download.eclipse.org/modeling/tmf/xtext/updates/composite/releases/ + + + + + + codehaus-snapshots + disable dead 'Codehaus Snapshots' repository, see https://bugs.eclipse.org/bugs/show_bug.cgi?id=481478 + http://nexus.codehaus.org/snapshots/ + + false + + + false + + + + jboss-public-repository-group + JBoss Public Repository Group + http://repository.jboss.org/nexus/content/groups/public/ + + + jboss-snapshots-repository + JBoss Snapshots Repository + https://repository.jboss.org/nexus/content/repositories/snapshots/ + + + + + + \ No newline at end of file