diff options
Diffstat (limited to 'plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui')
6 files changed, 982 insertions, 0 deletions
diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/provider/BaseDiagramProvider.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/provider/BaseDiagramProvider.java new file mode 100644 index 000000000..0c14f1a28 --- /dev/null +++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/provider/BaseDiagramProvider.java @@ -0,0 +1,115 @@ +/** + * Copyright (c) 2011 protos software gmbh (http://www.protos.de). + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * CONTRIBUTORS: + * Juergen Haug (initial contribution) + */ +package org.eclipse.etrice.ui.behavior.fsm.provider; + +import com.google.common.base.Objects; +import com.google.common.collect.ArrayListMultimap; +import com.google.common.collect.Iterables; +import com.google.common.collect.Multimap; +import com.google.inject.Injector; +import java.util.Collection; +import java.util.Map; +import java.util.function.BiConsumer; +import java.util.function.Consumer; +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EStructuralFeature; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.emf.ecore.resource.ResourceSet; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.etrice.core.fsm.fSM.ModelComponent; +import org.eclipse.etrice.ui.behavior.fsm.editor.AbstractFSMDiagramTypeProvider; +import org.eclipse.etrice.ui.common.base.support.DiagramAccessBase; +import org.eclipse.graphiti.mm.pictograms.Diagram; +import org.eclipse.graphiti.mm.pictograms.PictogramElement; +import org.eclipse.graphiti.mm.pictograms.PictogramLink; +import org.eclipse.graphiti.services.Graphiti; +import org.eclipse.graphiti.services.ILinkService; +import org.eclipse.xtext.xbase.lib.CollectionLiterals; +import org.eclipse.xtext.xbase.lib.Functions.Function1; +import org.eclipse.xtext.xbase.lib.IterableExtensions; + +/** + * Provides the {@linkplain PictogramElement} objects of the base class diagram. + * This is a reverse mapping from room business objects to linked base diagram pictograms. + */ +@SuppressWarnings("all") +public class BaseDiagramProvider { + private final Diagram baseDiagram; + + private final Multimap<EObject, PictogramElement> baseDiagramBusinessObjs = ArrayListMultimap.<EObject, PictogramElement>create(); + + public BaseDiagramProvider(final AbstractFSMDiagramTypeProvider diagramTypeProvider) { + Injector _injector = diagramTypeProvider.getInjector(); + final DiagramAccessBase diagramAccess = _injector.<DiagramAccessBase>getInstance(DiagramAccessBase.class); + ILinkService _linkService = Graphiti.getLinkService(); + Diagram _diagram = diagramTypeProvider.getDiagram(); + EObject _businessObjectForLinkedPictogramElement = _linkService.getBusinessObjectForLinkedPictogramElement(_diagram); + final ModelComponent mc = ((ModelComponent) _businessObjectForLinkedPictogramElement); + Diagram _diagram_1 = diagramTypeProvider.getDiagram(); + Resource _eResource = _diagram_1.eResource(); + final ResourceSet rs = _eResource.getResourceSet(); + Diagram _xifexpression = null; + ModelComponent _base = mc.getBase(); + boolean _notEquals = (!Objects.equal(_base, null)); + if (_notEquals) { + ModelComponent _base_1 = mc.getBase(); + _xifexpression = diagramAccess.getDiagram(_base_1, rs); + } + this.baseDiagram = _xifexpression; + boolean _notEquals_1 = (!Objects.equal(this.baseDiagram, null)); + if (_notEquals_1) { + Map<EObject, Collection<EStructuralFeature.Setting>> _find = EcoreUtil.ExternalCrossReferencer.find(this.baseDiagram); + final BiConsumer<EObject, Collection<EStructuralFeature.Setting>> _function = new BiConsumer<EObject, Collection<EStructuralFeature.Setting>>() { + @Override + public void accept(final EObject targetEObj, final Collection<EStructuralFeature.Setting> eFeatureSetting) { + final Function1<EStructuralFeature.Setting, EObject> _function = new Function1<EStructuralFeature.Setting, EObject>() { + @Override + public EObject apply(final EStructuralFeature.Setting it) { + return it.getEObject(); + } + }; + Iterable<EObject> _map = IterableExtensions.<EStructuralFeature.Setting, EObject>map(eFeatureSetting, _function); + Iterable<PictogramLink> _filter = Iterables.<PictogramLink>filter(_map, PictogramLink.class); + final Function1<PictogramLink, PictogramElement> _function_1 = new Function1<PictogramLink, PictogramElement>() { + @Override + public PictogramElement apply(final PictogramLink it) { + return it.getPictogramElement(); + } + }; + Iterable<PictogramElement> _map_1 = IterableExtensions.<PictogramLink, PictogramElement>map(_filter, _function_1); + final Consumer<PictogramElement> _function_2 = new Consumer<PictogramElement>() { + @Override + public void accept(final PictogramElement pe) { + BaseDiagramProvider.this.baseDiagramBusinessObjs.put(targetEObj, pe); + } + }; + _map_1.forEach(_function_2); + } + }; + _find.forEach(_function); + EList<Resource> _resources = rs.getResources(); + Resource _eResource_1 = this.baseDiagram.eResource(); + _resources.remove(_eResource_1); + } + } + + public Collection<PictogramElement> getPictograms(final EObject roomObj) { + Collection<PictogramElement> _xifexpression = null; + boolean _equals = Objects.equal(roomObj, null); + if (_equals) { + _xifexpression = CollectionLiterals.<PictogramElement>emptyList(); + } else { + _xifexpression = this.baseDiagramBusinessObjs.get(roomObj); + } + return _xifexpression; + } +} diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/provider/GenModelProvider.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/provider/GenModelProvider.java new file mode 100644 index 000000000..a1364f618 --- /dev/null +++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/provider/GenModelProvider.java @@ -0,0 +1,117 @@ +/** + * Copyright (c) 2011 protos software gmbh (http://www.protos.de). + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * CONTRIBUTORS: + * Juergen Haug (initial contribution) + */ +package org.eclipse.etrice.ui.behavior.fsm.provider; + +import com.google.common.base.Objects; +import com.google.inject.Injector; +import java.util.Map; +import org.eclipse.emf.common.util.TreeIterator; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.etrice.core.fsm.fSM.ModelComponent; +import org.eclipse.etrice.core.fsm.fSM.StateGraph; +import org.eclipse.etrice.core.fsm.fSM.StateGraphNode; +import org.eclipse.etrice.core.fsm.fSM.TransitionBase; +import org.eclipse.etrice.core.genmodel.fsm.BasicFsmGenBuilder; +import org.eclipse.etrice.core.genmodel.fsm.fsmgen.FSMGenElement; +import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph; +import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer; +import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link; +import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node; +import org.eclipse.etrice.ui.behavior.fsm.editor.AbstractFSMDiagramTypeProvider; +import org.eclipse.graphiti.dt.IDiagramTypeProvider; +import org.eclipse.graphiti.mm.pictograms.Diagram; +import org.eclipse.graphiti.services.Graphiti; +import org.eclipse.graphiti.services.ILinkService; +import org.eclipse.xtext.xbase.lib.CollectionLiterals; +import org.eclipse.xtext.xbase.lib.IteratorExtensions; +import org.eclipse.xtext.xbase.lib.ObjectExtensions; +import org.eclipse.xtext.xbase.lib.Procedures.Procedure1; + +@SuppressWarnings("all") +public class GenModelProvider { + private final BasicFsmGenBuilder builder; + + private final IDiagramTypeProvider fsmDiagramProvider; + + private Map<EObject, FSMGenElement> graphMap = CollectionLiterals.<EObject, FSMGenElement>newHashMap(); + + private GraphContainer modelInstance = null; + + public GenModelProvider(final AbstractFSMDiagramTypeProvider fsmDiagramProvider) { + this.fsmDiagramProvider = fsmDiagramProvider; + Injector _injector = fsmDiagramProvider.getInjector(); + BasicFsmGenBuilder _basicFsmGenBuilder = new BasicFsmGenBuilder(_injector); + this.builder = _basicFsmGenBuilder; + } + + public void updateModel() { + ILinkService _linkService = Graphiti.getLinkService(); + Diagram _diagram = this.fsmDiagramProvider.getDiagram(); + EObject _businessObjectForLinkedPictogramElement = _linkService.getBusinessObjectForLinkedPictogramElement(_diagram); + final Procedure1<EObject> _function = new Procedure1<EObject>() { + @Override + public void apply(final EObject it) { + GraphContainer _xifexpression = null; + if ((it instanceof ModelComponent)) { + _xifexpression = GenModelProvider.this.builder.createTransformedModel(((ModelComponent)it)); + } else { + _xifexpression = null; + } + GenModelProvider.this.modelInstance = _xifexpression; + } + }; + ObjectExtensions.<EObject>operator_doubleArrow(_businessObjectForLinkedPictogramElement, _function); + boolean _notEquals = (!Objects.equal(this.modelInstance, null)); + if (_notEquals) { + this.graphMap.clear(); + TreeIterator<EObject> _eAllContents = this.modelInstance.eAllContents(); + final Procedure1<EObject> _function_1 = new Procedure1<EObject>() { + @Override + public void apply(final EObject it) { + boolean _matched = false; + if (it instanceof Graph) { + _matched=true; + StateGraph _stateGraph = ((Graph)it).getStateGraph(); + GenModelProvider.this.graphMap.put(_stateGraph, ((FSMGenElement)it)); + } + if (!_matched) { + if (it instanceof Node) { + _matched=true; + StateGraphNode _stateGraphNode = ((Node)it).getStateGraphNode(); + GenModelProvider.this.graphMap.put(_stateGraphNode, ((FSMGenElement)it)); + } + } + if (!_matched) { + if (it instanceof Link) { + _matched=true; + TransitionBase _transition = ((Link)it).getTransition(); + GenModelProvider.this.graphMap.put(_transition, ((FSMGenElement)it)); + } + } + } + }; + IteratorExtensions.<EObject>forEach(_eAllContents, _function_1); + } + } + + public GraphContainer getModel() { + boolean _equals = Objects.equal(this.modelInstance, null); + if (_equals) { + this.updateModel(); + } + return this.modelInstance; + } + + public <T extends FSMGenElement> T getCasted(final EObject roomObj) { + FSMGenElement _get = this.graphMap.get(roomObj); + return ((T) _get); + } +} diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/BaseDiagramPositionProvider.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/BaseDiagramPositionProvider.java new file mode 100644 index 000000000..0cde9a2f5 --- /dev/null +++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/BaseDiagramPositionProvider.java @@ -0,0 +1,386 @@ +/** + * Copyright (c) 2011 protos software gmbh (http://www.protos.de). + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * CONTRIBUTORS: + * Juergen Haug (initial contribution) + */ +package org.eclipse.etrice.ui.behavior.fsm.support; + +import com.google.common.base.Objects; +import com.google.common.collect.Iterables; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.etrice.core.fsm.fSM.InitialTransition; +import org.eclipse.etrice.core.fsm.fSM.ModelComponent; +import org.eclipse.etrice.core.fsm.fSM.RefinedState; +import org.eclipse.etrice.core.fsm.fSM.RefinedTransition; +import org.eclipse.etrice.core.fsm.fSM.State; +import org.eclipse.etrice.core.fsm.fSM.StateGraph; +import org.eclipse.etrice.core.fsm.fSM.StateGraphNode; +import org.eclipse.etrice.core.fsm.fSM.TrPoint; +import org.eclipse.etrice.core.fsm.fSM.Transition; +import org.eclipse.etrice.ui.behavior.fsm.provider.BaseDiagramProvider; +import org.eclipse.etrice.ui.behavior.fsm.support.IPositionProvider; +import org.eclipse.etrice.ui.behavior.fsm.support.StateSupport; +import org.eclipse.etrice.ui.behavior.fsm.support.TrPointSupport; +import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm; +import org.eclipse.graphiti.mm.algorithms.Text; +import org.eclipse.graphiti.mm.algorithms.styles.Point; +import org.eclipse.graphiti.mm.pictograms.Anchor; +import org.eclipse.graphiti.mm.pictograms.Connection; +import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator; +import org.eclipse.graphiti.mm.pictograms.FreeFormConnection; +import org.eclipse.graphiti.mm.pictograms.PictogramElement; +import org.eclipse.graphiti.services.Graphiti; +import org.eclipse.graphiti.services.ILinkService; +import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor; +import org.eclipse.xtext.xbase.lib.CollectionLiterals; +import org.eclipse.xtext.xbase.lib.Functions.Function1; +import org.eclipse.xtext.xbase.lib.IterableExtensions; +import org.eclipse.xtext.xbase.lib.ListExtensions; +import org.eclipse.xtext.xbase.lib.ObjectExtensions; +import org.eclipse.xtext.xbase.lib.Procedures.Procedure1; + +/** + * IPositionProvider based on {@linkplain BaseDiagramProvider} + * Logic copied from DefaultPositionProvider + */ +@FinalFieldsConstructor +@SuppressWarnings("all") +public class BaseDiagramPositionProvider implements IPositionProvider { + private final BaseDiagramProvider baseDiagram; + + public int getMargin(final StateGraphNode node) { + int _switchResult = (int) 0; + boolean _matched = false; + if (node instanceof State) { + _matched=true; + _switchResult = StateSupport.MARGIN; + } + if (!_matched) { + if (node instanceof TrPoint) { + _matched=true; + _switchResult = TrPointSupport.MARGIN; + } + } + if (!_matched) { + _switchResult = 0; + } + return _switchResult; + } + + public int getMargin(final StateGraph graph) { + return 0; + } + + private IPositionProvider.PosAndSize toPosAndSize(final PictogramElement pe, final int margin) { + IPositionProvider.PosAndSize _xblockexpression = null; + { + EObject _eContainer = pe.eContainer(); + GraphicsAlgorithm _graphicsAlgorithm = ((PictogramElement) _eContainer).getGraphicsAlgorithm(); + EList<GraphicsAlgorithm> _graphicsAlgorithmChildren = _graphicsAlgorithm.getGraphicsAlgorithmChildren(); + final GraphicsAlgorithm borderGa = IterableExtensions.<GraphicsAlgorithm>head(_graphicsAlgorithmChildren); + final GraphicsAlgorithm ga = pe.getGraphicsAlgorithm(); + int _x = ga.getX(); + int _width = borderGa.getWidth(); + double _divide = (_x / ((double) _width)); + double _multiply = (_divide * this.sx); + final double x = (_multiply + margin); + int _y = ga.getY(); + int _height = borderGa.getHeight(); + double _divide_1 = (_y / ((double) _height)); + double _multiply_1 = (_divide_1 * this.sy); + final double y = (_multiply_1 + margin); + int _width_1 = ga.getWidth(); + int _minus = (_width_1 - (2 * margin)); + int _width_2 = borderGa.getWidth(); + double _divide_2 = (_minus / ((double) _width_2)); + final double width = (_divide_2 * this.sx); + int _height_1 = ga.getHeight(); + int _minus_1 = (_height_1 - (2 * margin)); + int _height_2 = borderGa.getHeight(); + double _divide_3 = (_minus_1 / ((double) _height_2)); + final double height = (_divide_3 * this.sy); + _xblockexpression = new IPositionProvider.PosAndSize(((int) x), ((int) y), ((int) width), ((int) height)); + } + return _xblockexpression; + } + + @Override + public IPositionProvider.PosAndSize getGraphPosAndSize(final StateGraph sg) { + IPositionProvider.PosAndSize _xblockexpression = null; + { + Collection<PictogramElement> _pictograms = this.baseDiagram.getPictograms(sg); + final Function1<PictogramElement, Boolean> _function = new Function1<PictogramElement, Boolean>() { + @Override + public Boolean apply(final PictogramElement it) { + EObject _parentBo = BaseDiagramPositionProvider.this.getParentBo(it); + return Boolean.valueOf((_parentBo instanceof ModelComponent)); + } + }; + final PictogramElement pe = IterableExtensions.<PictogramElement>findFirst(_pictograms, _function); + IPositionProvider.PosAndSize _xifexpression = null; + boolean _notEquals = (!Objects.equal(pe, null)); + if (_notEquals) { + IPositionProvider.PosAndSize _xblockexpression_1 = null; + { + GraphicsAlgorithm _graphicsAlgorithm = pe.getGraphicsAlgorithm(); + EList<GraphicsAlgorithm> _graphicsAlgorithmChildren = _graphicsAlgorithm.getGraphicsAlgorithmChildren(); + final GraphicsAlgorithm visibleGa = IterableExtensions.<GraphicsAlgorithm>head(_graphicsAlgorithmChildren); + GraphicsAlgorithm _graphicsAlgorithm_1 = pe.getGraphicsAlgorithm(); + int _x = _graphicsAlgorithm_1.getX(); + GraphicsAlgorithm _graphicsAlgorithm_2 = pe.getGraphicsAlgorithm(); + int _y = _graphicsAlgorithm_2.getY(); + int _width = visibleGa.getWidth(); + int _height = visibleGa.getHeight(); + _xblockexpression_1 = new IPositionProvider.PosAndSize(_x, _y, _width, _height); + } + _xifexpression = _xblockexpression_1; + } + _xblockexpression = _xifexpression; + } + return _xblockexpression; + } + + @Override + public List<IPositionProvider.Pos> getPoints(final Transition trans) { + ArrayList<IPositionProvider.Pos> _xblockexpression = null; + { + PictogramElement _xifexpression = null; + if ((trans instanceof RefinedTransition)) { + Transition _target = ((RefinedTransition)trans).getTarget(); + Collection<PictogramElement> _pictograms = this.baseDiagram.getPictograms(_target); + _xifexpression = IterableExtensions.<PictogramElement>head(_pictograms); + } else { + Collection<PictogramElement> _pictograms_1 = this.baseDiagram.getPictograms(trans); + _xifexpression = IterableExtensions.<PictogramElement>head(_pictograms_1); + } + final PictogramElement pe = _xifexpression; + ArrayList<IPositionProvider.Pos> _newArrayList = CollectionLiterals.<IPositionProvider.Pos>newArrayList(); + final Procedure1<ArrayList<IPositionProvider.Pos>> _function = new Procedure1<ArrayList<IPositionProvider.Pos>>() { + @Override + public void apply(final ArrayList<IPositionProvider.Pos> pointList) { + if ((pe instanceof Connection)) { + EObject _eContainer = trans.eContainer(); + final IPositionProvider.PosAndSize graphPosAndSize = BaseDiagramPositionProvider.this.getGraphPosAndSize(((StateGraph) _eContainer)); + EList<ConnectionDecorator> _connectionDecorators = ((Connection)pe).getConnectionDecorators(); + final Function1<ConnectionDecorator, GraphicsAlgorithm> _function = new Function1<ConnectionDecorator, GraphicsAlgorithm>() { + @Override + public GraphicsAlgorithm apply(final ConnectionDecorator it) { + return it.getGraphicsAlgorithm(); + } + }; + List<GraphicsAlgorithm> _map = ListExtensions.<ConnectionDecorator, GraphicsAlgorithm>map(_connectionDecorators, _function); + Iterable<Text> _filter = Iterables.<Text>filter(_map, Text.class); + final Text text = IterableExtensions.<Text>head(_filter); + boolean _notEquals = (!Objects.equal(text, null)); + if (_notEquals) { + int _x = text.getX(); + int _width = graphPosAndSize.getWidth(); + double _divide = (_x / ((double) _width)); + double _multiply = (_divide * BaseDiagramPositionProvider.this.sx); + int _y = text.getY(); + int _height = graphPosAndSize.getHeight(); + double _divide_1 = (_y / ((double) _height)); + double _multiply_1 = (_divide_1 * BaseDiagramPositionProvider.this.sy); + IPositionProvider.Pos _pos = new IPositionProvider.Pos( + ((int) _multiply), + ((int) _multiply_1)); + pointList.add(_pos); + if ((pe instanceof FreeFormConnection)) { + EList<Point> _bendpoints = ((FreeFormConnection)pe).getBendpoints(); + final Function1<Point, IPositionProvider.Pos> _function_1 = new Function1<Point, IPositionProvider.Pos>() { + @Override + public IPositionProvider.Pos apply(final Point it) { + int _x = text.getX(); + int _width = graphPosAndSize.getWidth(); + double _divide = (_x / ((double) _width)); + double _multiply = (_divide * BaseDiagramPositionProvider.this.sx); + double _plus = (_multiply + BaseDiagramPositionProvider.this.x); + int _y = text.getY(); + int _height = graphPosAndSize.getHeight(); + double _divide_1 = (_y / ((double) _height)); + double _multiply_1 = (_divide_1 * BaseDiagramPositionProvider.this.sy); + double _plus_1 = (_multiply_1 + BaseDiagramPositionProvider.this.y); + return new IPositionProvider.Pos( + ((int) _plus), + ((int) _plus_1)); + } + }; + List<IPositionProvider.Pos> _map_1 = ListExtensions.<Point, IPositionProvider.Pos>map(_bendpoints, _function_1); + Iterables.<IPositionProvider.Pos>addAll(pointList, _map_1); + } + } + } + } + }; + _xblockexpression = ObjectExtensions.<ArrayList<IPositionProvider.Pos>>operator_doubleArrow(_newArrayList, _function); + } + return _xblockexpression; + } + + @Override + public IPositionProvider.PosAndSize getPosition(final StateGraphNode node) { + IPositionProvider.PosAndSize _xifexpression = null; + if ((node instanceof RefinedState)) { + State _target = ((RefinedState)node).getTarget(); + Collection<PictogramElement> _pictograms = this.baseDiagram.getPictograms(_target); + final Function1<PictogramElement, Boolean> _function = new Function1<PictogramElement, Boolean>() { + @Override + public Boolean apply(final PictogramElement it) { + EObject _parentBo = BaseDiagramPositionProvider.this.getParentBo(it); + return Boolean.valueOf((_parentBo instanceof StateGraph)); + } + }; + PictogramElement _findFirst = IterableExtensions.<PictogramElement>findFirst(_pictograms, _function); + IPositionProvider.PosAndSize _posAndSize = null; + if (_findFirst!=null) { + int _margin = this.getMargin(node); + _posAndSize=this.toPosAndSize(_findFirst, _margin); + } + _xifexpression = _posAndSize; + } else { + Collection<PictogramElement> _pictograms_1 = this.baseDiagram.getPictograms(node); + final Function1<PictogramElement, Boolean> _function_1 = new Function1<PictogramElement, Boolean>() { + @Override + public Boolean apply(final PictogramElement it) { + EObject _parentBo = BaseDiagramPositionProvider.this.getParentBo(it); + return Boolean.valueOf((_parentBo instanceof StateGraph)); + } + }; + PictogramElement _findFirst_1 = IterableExtensions.<PictogramElement>findFirst(_pictograms_1, _function_1); + IPositionProvider.PosAndSize _posAndSize_1 = null; + if (_findFirst_1!=null) { + int _margin_1 = this.getMargin(node); + _posAndSize_1=this.toPosAndSize(_findFirst_1, _margin_1); + } + _xifexpression = _posAndSize_1; + } + return _xifexpression; + } + + @Override + public StateGraph getInitialPoint(final StateGraph stateGraph) { + EList<Transition> _transitions = stateGraph.getTransitions(); + Iterable<InitialTransition> _filter = Iterables.<InitialTransition>filter(_transitions, InitialTransition.class); + InitialTransition _head = IterableExtensions.<InitialTransition>head(_filter); + Collection<PictogramElement> _pictograms = this.baseDiagram.getPictograms(_head); + final PictogramElement initTransPe = IterableExtensions.<PictogramElement>head(_pictograms); + if ((initTransPe instanceof Connection)) { + ILinkService _linkService = Graphiti.getLinkService(); + Anchor _start = ((Connection)initTransPe).getStart(); + final EObject sourceAnchorBo = _linkService.getBusinessObjectForLinkedPictogramElement(_start); + if ((sourceAnchorBo instanceof StateGraph)) { + return ((StateGraph)sourceAnchorBo); + } + } + return null; + } + + @Override + public IPositionProvider.PosAndSize getPosition(final StateGraph graph) { + Collection<PictogramElement> _pictograms = this.baseDiagram.getPictograms(graph); + final Function1<PictogramElement, Boolean> _function = new Function1<PictogramElement, Boolean>() { + @Override + public Boolean apply(final PictogramElement it) { + EObject _parentBo = BaseDiagramPositionProvider.this.getParentBo(it); + return Boolean.valueOf((_parentBo instanceof StateGraph)); + } + }; + PictogramElement _findFirst = IterableExtensions.<PictogramElement>findFirst(_pictograms, _function); + IPositionProvider.PosAndSize _posAndSize = null; + if (_findFirst!=null) { + int _margin = this.getMargin(graph); + _posAndSize=this.toPosAndSize(_findFirst, _margin); + } + return _posAndSize; + } + + @Override + public <T extends StateGraphNode> List<IPositionProvider.PosAndSize> getPositions(final List<T> items) { + final Function1<T, IPositionProvider.PosAndSize> _function = new Function1<T, IPositionProvider.PosAndSize>() { + @Override + public IPositionProvider.PosAndSize apply(final T it) { + Collection<PictogramElement> _pictograms = BaseDiagramPositionProvider.this.baseDiagram.getPictograms(it); + PictogramElement _head = IterableExtensions.<PictogramElement>head(_pictograms); + IPositionProvider.PosAndSize _posAndSize = null; + if (_head!=null) { + int _margin = BaseDiagramPositionProvider.this.getMargin(it); + _posAndSize=BaseDiagramPositionProvider.this.toPosAndSize(_head, _margin); + } + return _posAndSize; + } + }; + return ListExtensions.<T, IPositionProvider.PosAndSize>map(items, _function); + } + + @Override + public double[] getSubPosition(final StateGraphNode subNode) { + Collection<PictogramElement> _pictograms = this.baseDiagram.getPictograms(subNode); + final Function1<PictogramElement, Boolean> _function = new Function1<PictogramElement, Boolean>() { + @Override + public Boolean apply(final PictogramElement it) { + EObject _parentBo = BaseDiagramPositionProvider.this.getParentBo(it); + return Boolean.valueOf((_parentBo instanceof State)); + } + }; + final PictogramElement pe = IterableExtensions.<PictogramElement>findFirst(_pictograms, _function); + boolean _notEquals = (!Objects.equal(pe, null)); + if (_notEquals) { + EObject _eContainer = pe.eContainer(); + final PictogramElement parentPe = ((PictogramElement) _eContainer); + GraphicsAlgorithm _graphicsAlgorithm = pe.getGraphicsAlgorithm(); + int _x = _graphicsAlgorithm.getX(); + GraphicsAlgorithm _graphicsAlgorithm_1 = parentPe.getGraphicsAlgorithm(); + int _width = _graphicsAlgorithm_1.getWidth(); + int _minus = (_width - (2 * StateSupport.MARGIN)); + final double relX = (((double) _x) / _minus); + GraphicsAlgorithm _graphicsAlgorithm_2 = pe.getGraphicsAlgorithm(); + int _y = _graphicsAlgorithm_2.getY(); + GraphicsAlgorithm _graphicsAlgorithm_3 = parentPe.getGraphicsAlgorithm(); + int _height = _graphicsAlgorithm_3.getHeight(); + int _minus_1 = (_height - (2 * StateSupport.MARGIN)); + final double relY = (((double) _y) / _minus_1); + return new double[] { relX, relY }; + } + return null; + } + + private int x; + + private int y; + + @Override + public void setPosition(final int x, final int y) { + this.x = x; + this.y = y; + } + + private double sx; + + private double sy; + + @Override + public void setScale(final double sx, final double sy) { + this.sx = sx; + this.sy = sy; + } + + private EObject getParentBo(final PictogramElement pe) { + ILinkService _linkService = Graphiti.getLinkService(); + EObject _eContainer = pe.eContainer(); + return _linkService.getBusinessObjectForLinkedPictogramElement(((PictogramElement) _eContainer)); + } + + public BaseDiagramPositionProvider(final BaseDiagramProvider baseDiagram) { + super(); + this.baseDiagram = baseDiagram; + } +} diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/BaseDiagramProvider.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/BaseDiagramProvider.java new file mode 100644 index 000000000..bd075bba4 --- /dev/null +++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/BaseDiagramProvider.java @@ -0,0 +1,151 @@ +/** + * Copyright (c) 2011 protos software gmbh (http://www.protos.de). + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * CONTRIBUTORS: + * Juergen Haug (initial contribution) + */ +package org.eclipse.etrice.ui.behavior.fsm.support; + +import com.google.common.base.Objects; +import com.google.common.collect.Iterables; +import com.google.inject.Injector; +import java.util.Collection; +import java.util.Map; +import java.util.function.BiConsumer; +import java.util.function.Consumer; +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EStructuralFeature; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.emf.ecore.resource.ResourceSet; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.etrice.core.fsm.fSM.ModelComponent; +import org.eclipse.etrice.core.fsm.fSM.State; +import org.eclipse.etrice.core.fsm.fSM.StateGraph; +import org.eclipse.etrice.ui.behavior.fsm.editor.AbstractFSMDiagramTypeProvider; +import org.eclipse.etrice.ui.common.base.support.DiagramAccessBase; +import org.eclipse.graphiti.mm.pictograms.Diagram; +import org.eclipse.graphiti.mm.pictograms.PictogramElement; +import org.eclipse.graphiti.mm.pictograms.PictogramLink; +import org.eclipse.graphiti.services.Graphiti; +import org.eclipse.graphiti.services.ILinkService; +import org.eclipse.xtext.xbase.lib.CollectionLiterals; +import org.eclipse.xtext.xbase.lib.Functions.Function1; +import org.eclipse.xtext.xbase.lib.IterableExtensions; + +/** + * Provides the {@linkplain PictogramElement} objects of the base class diagram. + * This is a reverse 1:1 mapping from room business objects to linked base diagram pictograms. + */ +@SuppressWarnings("all") +public class BaseDiagramProvider { + private final DiagramAccessBase diagramAccess; + + private final Map<EObject, PictogramElement> baseGraphElement = CollectionLiterals.<EObject, PictogramElement>newHashMap(); + + private final Map<EObject, PictogramElement> baseStateElement = CollectionLiterals.<EObject, PictogramElement>newHashMap(); + + private final Map<EObject, PictogramElement> initialPointElement = CollectionLiterals.<EObject, PictogramElement>newHashMap(); + + public BaseDiagramProvider(final AbstractFSMDiagramTypeProvider diagramTypeProvider) { + Injector _injector = diagramTypeProvider.getInjector(); + DiagramAccessBase _instance = _injector.<DiagramAccessBase>getInstance(DiagramAccessBase.class); + this.diagramAccess = _instance; + ILinkService _linkService = Graphiti.getLinkService(); + Diagram _diagram = diagramTypeProvider.getDiagram(); + EObject _businessObjectForLinkedPictogramElement = _linkService.getBusinessObjectForLinkedPictogramElement(_diagram); + final ModelComponent mc = ((ModelComponent) _businessObjectForLinkedPictogramElement); + Diagram _diagram_1 = diagramTypeProvider.getDiagram(); + Resource _eResource = _diagram_1.eResource(); + final ResourceSet rs = _eResource.getResourceSet(); + ModelComponent _base = mc.getBase(); + boolean _notEquals = (!Objects.equal(_base, null)); + if (_notEquals) { + ModelComponent _base_1 = mc.getBase(); + final Diagram baseDiagram = this.diagramAccess.getDiagram(_base_1, rs); + boolean _notEquals_1 = (!Objects.equal(baseDiagram, null)); + if (_notEquals_1) { + this.mapPositions(baseDiagram); + EList<Resource> _resources = rs.getResources(); + Resource _eResource_1 = baseDiagram.eResource(); + _resources.remove(_eResource_1); + } + } + } + + public void mapPositions(final Diagram diagram) { + Map<EObject, Collection<EStructuralFeature.Setting>> _find = EcoreUtil.ExternalCrossReferencer.find(diagram); + final BiConsumer<EObject, Collection<EStructuralFeature.Setting>> _function = new BiConsumer<EObject, Collection<EStructuralFeature.Setting>>() { + @Override + public void accept(final EObject targetEObj, final Collection<EStructuralFeature.Setting> eFeatureSetting) { + final Function1<EStructuralFeature.Setting, EObject> _function = new Function1<EStructuralFeature.Setting, EObject>() { + @Override + public EObject apply(final EStructuralFeature.Setting it) { + return it.getEObject(); + } + }; + Iterable<EObject> _map = IterableExtensions.<EStructuralFeature.Setting, EObject>map(eFeatureSetting, _function); + Iterable<PictogramLink> _filter = Iterables.<PictogramLink>filter(_map, PictogramLink.class); + final Function1<PictogramLink, PictogramElement> _function_1 = new Function1<PictogramLink, PictogramElement>() { + @Override + public PictogramElement apply(final PictogramLink it) { + return it.getPictogramElement(); + } + }; + Iterable<PictogramElement> _map_1 = IterableExtensions.<PictogramLink, PictogramElement>map(_filter, _function_1); + final Consumer<PictogramElement> _function_2 = new Consumer<PictogramElement>() { + @Override + public void accept(final PictogramElement pe) { + ILinkService _linkService = Graphiti.getLinkService(); + EObject _eContainer = pe.eContainer(); + EObject _businessObjectForLinkedPictogramElement = _linkService.getBusinessObjectForLinkedPictogramElement(((PictogramElement) _eContainer)); + final boolean isState = (_businessObjectForLinkedPictogramElement instanceof State); + final boolean isInitialPoint = ((targetEObj instanceof StateGraph) && (!(pe.eContainer() instanceof Diagram))); + if (isState) { + BaseDiagramProvider.this.baseStateElement.put(targetEObj, pe); + } else { + if (isInitialPoint) { + BaseDiagramProvider.this.initialPointElement.put(targetEObj, pe); + } else { + BaseDiagramProvider.this.baseGraphElement.put(targetEObj, pe); + } + } + } + }; + _map_1.forEach(_function_2); + } + }; + _find.forEach(_function); + } + + public PictogramElement getBaseGraphPictogram(final EObject roomObj) { + PictogramElement _xifexpression = null; + boolean _notEquals = (!Objects.equal(roomObj, null)); + if (_notEquals) { + _xifexpression = this.baseGraphElement.get(roomObj); + } + return _xifexpression; + } + + public PictogramElement getBaseStatePictogram(final EObject roomObj) { + PictogramElement _xifexpression = null; + boolean _notEquals = (!Objects.equal(roomObj, null)); + if (_notEquals) { + _xifexpression = this.baseStateElement.get(roomObj); + } + return _xifexpression; + } + + public PictogramElement getInitialPointPictogram(final EObject roomObj) { + PictogramElement _xifexpression = null; + boolean _notEquals = (!Objects.equal(roomObj, null)); + if (_notEquals) { + _xifexpression = this.initialPointElement.get(roomObj); + } + return _xifexpression; + } +} diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/GenModelStateGraphContext.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/GenModelStateGraphContext.java new file mode 100644 index 000000000..c79d40e8b --- /dev/null +++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/GenModelStateGraphContext.java @@ -0,0 +1,182 @@ +/** + * Copyright (c) 2011 protos software gmbh (http://www.protos.de). + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * CONTRIBUTORS: + * Juergen Haug (initial contribution) + */ +package org.eclipse.etrice.ui.behavior.fsm.support; + +import com.google.common.base.Objects; +import com.google.common.collect.Iterables; +import java.util.List; +import org.eclipse.emf.common.util.EList; +import org.eclipse.etrice.core.fsm.fSM.ChoicePoint; +import org.eclipse.etrice.core.fsm.fSM.InitialTransition; +import org.eclipse.etrice.core.fsm.fSM.State; +import org.eclipse.etrice.core.fsm.fSM.StateGraph; +import org.eclipse.etrice.core.fsm.fSM.StateGraphNode; +import org.eclipse.etrice.core.fsm.fSM.TrPoint; +import org.eclipse.etrice.core.fsm.fSM.Transition; +import org.eclipse.etrice.core.fsm.fSM.TransitionBase; +import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Graph; +import org.eclipse.etrice.core.genmodel.fsm.fsmgen.GraphContainer; +import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link; +import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Node; +import org.eclipse.etrice.ui.behavior.fsm.editor.AbstractFSMDiagramTypeProvider; +import org.eclipse.etrice.ui.behavior.fsm.provider.BaseDiagramProvider; +import org.eclipse.etrice.ui.behavior.fsm.provider.GenModelProvider; +import org.eclipse.etrice.ui.behavior.fsm.support.BaseDiagramPositionProvider; +import org.eclipse.etrice.ui.behavior.fsm.support.IPositionProvider; +import org.eclipse.etrice.ui.behavior.fsm.support.IStateGraphContext; +import org.eclipse.xtext.xbase.lib.Functions.Function1; +import org.eclipse.xtext.xbase.lib.IterableExtensions; +import org.eclipse.xtext.xbase.lib.ListExtensions; + +/** + * StateGraphContext based on newfsmgen. + */ +@SuppressWarnings("all") +public class GenModelStateGraphContext implements IStateGraphContext { + private final GenModelProvider genModel; + + private final BaseDiagramPositionProvider baseDiagram; + + private final Graph graph; + + public GenModelStateGraphContext(final AbstractFSMDiagramTypeProvider diagramTypeProvider) { + GenModelProvider _genModelProvider = diagramTypeProvider.getGenModelProvider(); + this.genModel = _genModelProvider; + BaseDiagramProvider _baseDiagramProvider = new BaseDiagramProvider(diagramTypeProvider); + BaseDiagramPositionProvider _baseDiagramPositionProvider = new BaseDiagramPositionProvider(_baseDiagramProvider); + this.baseDiagram = _baseDiagramPositionProvider; + GraphContainer _model = this.genModel.getModel(); + Graph _graph = _model.getGraph(); + this.graph = _graph; + } + + public GenModelStateGraphContext(final Graph graph, final GenModelStateGraphContext other) { + this.genModel = other.genModel; + this.baseDiagram = other.baseDiagram; + this.graph = graph; + } + + @Override + public List<ChoicePoint> getChPoints() { + EList<Node> _nodes = this.graph.getNodes(); + final Function1<Node, StateGraphNode> _function = new Function1<Node, StateGraphNode>() { + @Override + public StateGraphNode apply(final Node it) { + return it.getStateGraphNode(); + } + }; + List<StateGraphNode> _map = ListExtensions.<Node, StateGraphNode>map(_nodes, _function); + Iterable<ChoicePoint> _filter = Iterables.<ChoicePoint>filter(_map, ChoicePoint.class); + return IterableExtensions.<ChoicePoint>toList(_filter); + } + + @Override + public List<IStateGraphContext> getChildren() { + EList<Node> _nodes = this.graph.getNodes(); + final Function1<Node, Boolean> _function = new Function1<Node, Boolean>() { + @Override + public Boolean apply(final Node it) { + Graph _subgraph = it.getSubgraph(); + return Boolean.valueOf((!Objects.equal(_subgraph, null))); + } + }; + Iterable<Node> _filter = IterableExtensions.<Node>filter(_nodes, _function); + final Function1<Node, IStateGraphContext> _function_1 = new Function1<Node, IStateGraphContext>() { + @Override + public IStateGraphContext apply(final Node it) { + Graph _subgraph = it.getSubgraph(); + GenModelStateGraphContext _genModelStateGraphContext = new GenModelStateGraphContext(_subgraph, GenModelStateGraphContext.this); + return ((IStateGraphContext) _genModelStateGraphContext); + } + }; + Iterable<IStateGraphContext> _map = IterableExtensions.<Node, IStateGraphContext>map(_filter, _function_1); + return IterableExtensions.<IStateGraphContext>toList(_map); + } + + @Override + public StateGraph getInitialPoint() { + StateGraph _xifexpression = null; + EList<Link> _links = this.graph.getLinks(); + final Function1<Link, TransitionBase> _function = new Function1<Link, TransitionBase>() { + @Override + public TransitionBase apply(final Link it) { + return it.getTransition(); + } + }; + List<TransitionBase> _map = ListExtensions.<Link, TransitionBase>map(_links, _function); + Iterable<InitialTransition> _filter = Iterables.<InitialTransition>filter(_map, InitialTransition.class); + boolean _isEmpty = IterableExtensions.isEmpty(_filter); + boolean _not = (!_isEmpty); + if (_not) { + _xifexpression = this.graph.getStateGraph(); + } + return _xifexpression; + } + + @Override + public State getParentState() { + Node _node = this.graph.getNode(); + StateGraphNode _stateGraphNode = _node.getStateGraphNode(); + return ((State) _stateGraphNode); + } + + @Override + public IPositionProvider getPositionProvider() { + return this.baseDiagram; + } + + @Override + public StateGraph getStateGraph() { + return this.graph.getStateGraph(); + } + + @Override + public List<State> getStates() { + EList<Node> _nodes = this.graph.getNodes(); + final Function1<Node, StateGraphNode> _function = new Function1<Node, StateGraphNode>() { + @Override + public StateGraphNode apply(final Node it) { + return it.getStateGraphNode(); + } + }; + List<StateGraphNode> _map = ListExtensions.<Node, StateGraphNode>map(_nodes, _function); + Iterable<State> _filter = Iterables.<State>filter(_map, State.class); + return IterableExtensions.<State>toList(_filter); + } + + @Override + public List<TrPoint> getTrPoints() { + EList<Node> _nodes = this.graph.getNodes(); + final Function1<Node, StateGraphNode> _function = new Function1<Node, StateGraphNode>() { + @Override + public StateGraphNode apply(final Node it) { + return it.getStateGraphNode(); + } + }; + List<StateGraphNode> _map = ListExtensions.<Node, StateGraphNode>map(_nodes, _function); + Iterable<TrPoint> _filter = Iterables.<TrPoint>filter(_map, TrPoint.class); + return IterableExtensions.<TrPoint>toList(_filter); + } + + @Override + public List<Transition> getTransitions() { + EList<Link> _links = this.graph.getLinks(); + final Function1<Link, TransitionBase> _function = new Function1<Link, TransitionBase>() { + @Override + public TransitionBase apply(final Link it) { + return it.getTransition(); + } + }; + List<TransitionBase> _map = ListExtensions.<Link, TransitionBase>map(_links, _function); + Iterable<Transition> _filter = Iterables.<Transition>filter(_map, Transition.class); + return IterableExtensions.<Transition>toList(_filter); + } +} diff --git a/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/util/DiagramExtensions.java b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/util/DiagramExtensions.java new file mode 100644 index 000000000..bb3e077d6 --- /dev/null +++ b/plugins/org.eclipse.etrice.ui.behavior.fsm/xtend-gen/org/eclipse/etrice/ui/behavior/fsm/support/util/DiagramExtensions.java @@ -0,0 +1,31 @@ +/** + * Copyright (c) 2011 protos software gmbh (http://www.protos.de). + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * CONTRIBUTORS: + * Juergen Haug (initial contribution) + */ +package org.eclipse.etrice.ui.behavior.fsm.support.util; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.graphiti.features.context.IPictogramElementContext; +import org.eclipse.graphiti.mm.pictograms.PictogramElement; +import org.eclipse.graphiti.services.Graphiti; +import org.eclipse.graphiti.services.ILinkService; + +@SuppressWarnings("all") +public class DiagramExtensions { + public static <T extends PictogramElement> T getCastedPe(final IPictogramElementContext ctx) { + PictogramElement _pictogramElement = ctx.getPictogramElement(); + return ((T) _pictogramElement); + } + + public static <T extends EObject> T getCastedBo(final PictogramElement pe) { + ILinkService _linkService = Graphiti.getLinkService(); + EObject _businessObjectForLinkedPictogramElement = _linkService.getBusinessObjectForLinkedPictogramElement(pe); + return ((T) _businessObjectForLinkedPictogramElement); + } +} |