| /******************************************************************************* |
| * Copyright (c) 2007, 2016 THALES GLOBAL SERVICES and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Obeo - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.sirius.diagram.business.internal.experimental.sync; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.emf.common.util.BasicEList; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.sirius.business.api.logger.RuntimeLoggerManager; |
| import org.eclipse.sirius.common.tools.DslCommonPlugin; |
| import org.eclipse.sirius.common.tools.api.interpreter.EvaluationException; |
| import org.eclipse.sirius.common.tools.api.interpreter.IInterpreter; |
| import org.eclipse.sirius.common.tools.api.interpreter.IInterpreterSiriusVariables; |
| import org.eclipse.sirius.common.tools.api.util.StringUtil; |
| import org.eclipse.sirius.diagram.AbstractDNode; |
| import org.eclipse.sirius.diagram.DDiagram; |
| import org.eclipse.sirius.diagram.DDiagramElement; |
| import org.eclipse.sirius.diagram.DDiagramElementContainer; |
| import org.eclipse.sirius.diagram.DEdge; |
| import org.eclipse.sirius.diagram.DNode; |
| import org.eclipse.sirius.diagram.DNodeContainer; |
| import org.eclipse.sirius.diagram.DNodeList; |
| import org.eclipse.sirius.diagram.DNodeListElement; |
| import org.eclipse.sirius.diagram.DSemanticDiagram; |
| import org.eclipse.sirius.diagram.DiagramFactory; |
| import org.eclipse.sirius.diagram.DiagramPackage; |
| import org.eclipse.sirius.diagram.DragAndDropTarget; |
| import org.eclipse.sirius.diagram.EdgeStyle; |
| import org.eclipse.sirius.diagram.EdgeTarget; |
| import org.eclipse.sirius.diagram.NodeStyle; |
| import org.eclipse.sirius.diagram.WorkspaceImage; |
| import org.eclipse.sirius.diagram.business.api.componentization.DiagramDescriptionMappingsManager; |
| import org.eclipse.sirius.diagram.business.api.componentization.DiagramMappingsManager; |
| import org.eclipse.sirius.diagram.business.api.helper.SiriusDiagramHelper; |
| import org.eclipse.sirius.diagram.business.api.helper.display.DisplayMode; |
| import org.eclipse.sirius.diagram.business.api.helper.display.DisplayService; |
| import org.eclipse.sirius.diagram.business.api.helper.display.DisplayServiceManager; |
| import org.eclipse.sirius.diagram.business.api.helper.graphicalfilters.HideFilterHelper; |
| import org.eclipse.sirius.diagram.business.api.query.ContainerMappingQuery; |
| import org.eclipse.sirius.diagram.business.api.query.DiagramDescriptionMappingManagerQuery; |
| import org.eclipse.sirius.diagram.business.api.query.IEdgeMappingQuery; |
| import org.eclipse.sirius.diagram.business.internal.componentization.mappings.DiagramDescriptionMappingsManagerImpl; |
| import org.eclipse.sirius.diagram.business.internal.metamodel.helper.DiagramElementMappingHelper; |
| import org.eclipse.sirius.diagram.business.internal.metamodel.helper.LayerHelper; |
| import org.eclipse.sirius.diagram.business.internal.metamodel.helper.MappingHelper; |
| import org.eclipse.sirius.diagram.business.internal.metamodel.helper.StyleHelper; |
| import org.eclipse.sirius.diagram.description.AbstractNodeMapping; |
| import org.eclipse.sirius.diagram.description.ContainerMapping; |
| import org.eclipse.sirius.diagram.description.DescriptionPackage; |
| import org.eclipse.sirius.diagram.description.DiagramDescription; |
| import org.eclipse.sirius.diagram.description.DiagramElementMapping; |
| import org.eclipse.sirius.diagram.description.EdgeMapping; |
| import org.eclipse.sirius.diagram.description.IEdgeMapping; |
| import org.eclipse.sirius.diagram.description.MappingBasedDecoration; |
| import org.eclipse.sirius.diagram.description.NodeMapping; |
| import org.eclipse.sirius.diagram.description.style.ContainerStyleDescription; |
| import org.eclipse.sirius.diagram.description.style.EdgeStyleDescription; |
| import org.eclipse.sirius.diagram.description.style.EllipseNodeDescription; |
| import org.eclipse.sirius.diagram.description.style.LozengeNodeDescription; |
| import org.eclipse.sirius.diagram.description.style.NodeStyleDescription; |
| import org.eclipse.sirius.diagram.description.style.SquareDescription; |
| import org.eclipse.sirius.diagram.description.style.WorkspaceImageDescription; |
| import org.eclipse.sirius.ecore.extender.business.api.accessor.ModelAccessor; |
| import org.eclipse.sirius.ext.base.Option; |
| import org.eclipse.sirius.ext.base.Options; |
| import org.eclipse.sirius.tools.api.interpreter.IInterpreterMessages; |
| import org.eclipse.sirius.tools.api.profiler.SiriusTasksKey; |
| import org.eclipse.sirius.viewpoint.DSemanticDecorator; |
| import org.eclipse.sirius.viewpoint.Decoration; |
| import org.eclipse.sirius.viewpoint.Style; |
| import org.eclipse.sirius.viewpoint.ViewpointFactory; |
| import org.eclipse.sirius.viewpoint.description.DecorationDescription; |
| import org.eclipse.sirius.viewpoint.description.SemanticBasedDecoration; |
| import org.eclipse.sirius.viewpoint.description.Viewpoint; |
| import org.eclipse.sirius.viewpoint.description.style.BasicLabelStyleDescription; |
| import org.eclipse.sirius.viewpoint.description.style.LabelStyleDescription; |
| import org.eclipse.sirius.viewpoint.description.style.StyleDescription; |
| import org.eclipse.sirius.viewpoint.description.style.StylePackage; |
| import org.eclipse.sirius.viewpoint.description.style.TooltipStyleDescription; |
| |
| import com.google.common.base.Objects; |
| import com.google.common.collect.ImmutableSet; |
| import com.google.common.collect.Iterables; |
| |
| /** |
| * This class is able to synchronize diagram elements and styles. |
| * |
| * @author cbrun |
| */ |
| public class DDiagramElementSynchronizer { |
| |
| private final IInterpreter interpreter; |
| |
| private final DSemanticDiagram diagram; |
| |
| private final ModelAccessor accessor; |
| |
| private final StyleHelper styleHelper; |
| |
| private final MappingHelper mappingHelper; |
| |
| /** |
| * Create a new synchronizer for the given diagram. |
| * |
| * @param diagram |
| * diagram to synchronize. |
| * @param interpreter |
| * current interpreter. |
| * @param accessor |
| * model accessor |
| */ |
| public DDiagramElementSynchronizer(final DSemanticDiagram diagram, final IInterpreter interpreter, final ModelAccessor accessor) { |
| super(); |
| this.diagram = diagram; |
| this.interpreter = interpreter; |
| this.accessor = accessor; |
| this.styleHelper = new StyleHelper(interpreter); |
| this.mappingHelper = new MappingHelper(interpreter); |
| } |
| |
| /** |
| * Create completely a new Node with its style and so on from a candidate. |
| * |
| * @param mappingManager |
| * the manager used to handle return the Mappings to consider |
| * regarding the enablement of Viewpoints. |
| * @param candidate |
| * the node candidate, it contains the mapping and the semantic |
| * target. |
| * @param isBorder |
| * true if the element is a border one. |
| * @return newly created node. |
| */ |
| public AbstractDNode createNewNode(DiagramMappingsManager mappingManager, final AbstractDNodeCandidate candidate, final boolean isBorder) { |
| return createNewNode(mappingManager, candidate, isBorder, -1); |
| } |
| |
| /** |
| * Build a new Node from a candidate. |
| * |
| * @param mappingManager |
| * the manager used to handle return the Mappings to consider |
| * regarding the enablement of Viewpoints. |
| * @param candidate |
| * the node candidate, it contains the mapping and the semantic |
| * target. |
| * @param isBorder |
| * true if the element is a border one. |
| * @param insertionIndex |
| * the insertion index. give a negative value if you don't care |
| * @return newly created node. |
| */ |
| public AbstractDNode createNewNode(DiagramMappingsManager mappingManager, final AbstractDNodeCandidate candidate, final boolean isBorder, final int insertionIndex) { |
| final DragAndDropTarget container = candidate.getViewContainer(); |
| final AbstractDNode newNode = createAbstractNode(container, candidate, isBorder); |
| if (insertionIndex > 0) { |
| SiriusDiagramHelper.addNodeInContainer(container, isBorder, newNode, insertionIndex); |
| } else { |
| SiriusDiagramHelper.addNodeInContainer(container, isBorder, newNode); |
| } |
| refresh(newNode); |
| refreshSemanticElements(newNode, candidate.getMapping()); |
| createStyle(newNode, candidate.getMapping()); |
| computeVisibilityOnCreation(mappingManager, newNode); |
| return newNode; |
| } |
| |
| /** |
| * Build a new Node from a candidate. |
| * |
| * @param container |
| * the object who will contain the new node. |
| * @param candidate |
| * the node candidate, it contains the mapping and the semantic |
| * target. |
| * @param border |
| * true if the element is a border one. |
| * @return newly created node. |
| */ |
| private AbstractDNode createAbstractNode(final DragAndDropTarget container, final AbstractDNodeCandidate candidate, final boolean border) { |
| AbstractDNode result = null; |
| if (candidate.getMapping() instanceof NodeMapping) { |
| final NodeMapping mapping = (NodeMapping) candidate.getMapping(); |
| if (container instanceof DNodeList) { |
| if (!border) { |
| final DNodeListElement newNode = DiagramFactory.eINSTANCE.createDNodeListElement(); |
| newNode.setTarget(candidate.getSemantic()); |
| newNode.setActualMapping(mapping); |
| result = newNode; |
| } else { |
| final DNode newNode = DiagramFactory.eINSTANCE.createDNode(); |
| newNode.setTarget(candidate.getSemantic()); |
| newNode.setActualMapping(mapping); |
| result = newNode; |
| } |
| } else { |
| final DNode newNode = DiagramFactory.eINSTANCE.createDNode(); |
| newNode.setTarget(candidate.getSemantic()); |
| newNode.setActualMapping(mapping); |
| result = newNode; |
| |
| } |
| |
| } else if (candidate.getMapping() instanceof ContainerMapping) { |
| final ContainerMapping mapping = (ContainerMapping) candidate.getMapping(); |
| DDiagramElementContainer newContainer = null; |
| if (new ContainerMappingQuery(mapping).isListContainer()) { |
| newContainer = DiagramFactory.eINSTANCE.createDNodeList(); |
| } else { |
| // Other behaviors : ContainerLayout.FreeForm/VerticalStack |
| DNodeContainer nodeContainer = DiagramFactory.eINSTANCE.createDNodeContainer(); |
| nodeContainer.setChildrenPresentation(mapping.getChildrenPresentation()); |
| newContainer = nodeContainer; |
| } |
| newContainer.setTarget(candidate.getSemantic()); |
| newContainer.setActualMapping(mapping); |
| result = newContainer; |
| } |
| return result; |
| } |
| |
| /** |
| * Compute a mappings to edge target map for a given diagram. |
| * |
| * @param enabledVp |
| * the list of viewpoints to consider |
| * |
| * @return the requested map |
| */ |
| public Map<DiagramElementMapping, Collection<EdgeTarget>> computeMappingsToEdgeTargets(Collection<Viewpoint> enabledVp) { |
| final Map<DiagramElementMapping, Collection<EdgeTarget>> mappingsToEdgeTargets = new HashMap<DiagramElementMapping, Collection<EdgeTarget>>(); |
| |
| final DiagramDescription description = diagram.getDescription(); |
| |
| final DiagramDescriptionMappingsManager mappingsManager = new DiagramDescriptionMappingsManagerImpl(description); |
| mappingsManager.computeMappings(enabledVp); |
| final Set<DiagramElementMapping> allMappings = new DiagramDescriptionMappingManagerQuery(mappingsManager).computeAllMappings(); |
| final Iterable<NodeMapping> allNodeMappings = Iterables.filter(allMappings, NodeMapping.class); |
| final Iterable<ContainerMapping> allContainerMappings = Iterables.filter(allMappings, ContainerMapping.class); |
| final Iterable<EdgeMapping> allEdgeMappings = Iterables.filter(allMappings, EdgeMapping.class); |
| |
| for (final NodeMapping nodeMapping : allNodeMappings) { |
| final List<DNode> nodes = diagram.getNodesFromMapping(nodeMapping); |
| if (!nodes.isEmpty()) { |
| mappingsToEdgeTargets.put(nodeMapping, DDiagramElementSynchronizer.convertNodesAndContainersToEdgeTarget(nodes)); |
| } |
| } |
| |
| for (final ContainerMapping containerMapping : allContainerMappings) { |
| final List<DDiagramElementContainer> containers = diagram.getContainersFromMapping(containerMapping); |
| if (!containers.isEmpty()) { |
| mappingsToEdgeTargets.put(containerMapping, DDiagramElementSynchronizer.convertNodesAndContainersToEdgeTarget(containers)); |
| } |
| } |
| |
| for (final EdgeMapping edgeMapping : allEdgeMappings) { |
| final List<DEdge> edges = diagram.getEdgesFromMapping(edgeMapping); |
| if (!edges.isEmpty()) { |
| mappingsToEdgeTargets.put(edgeMapping, DDiagramElementSynchronizer.convertNodesAndContainersToEdgeTarget(edges)); |
| } |
| } |
| |
| return mappingsToEdgeTargets; |
| } |
| |
| private static Collection<EdgeTarget> convertNodesAndContainersToEdgeTarget(final Collection<? extends DDiagramElement> diagramElements) { |
| return ImmutableSet.copyOf(Iterables.filter(diagramElements, EdgeTarget.class)); |
| } |
| |
| /** |
| * Create completely a new Edge with it style path and so on from a |
| * candidate and the mappings maps. |
| * |
| * @param mappingManager |
| * the manager used to handle return the Mappings to consider |
| * regarding the enablement of Viewpoints. |
| * @param candidate |
| * the edge candidate |
| * @param mappingsToEdgeTargets |
| * mappings to edge targets map |
| * @param edgeToMappingBasedDecoration |
| * a map with for key a mapping and for value the associated |
| * decorations |
| * @param edgeToSemanticBasedDecoration |
| * a map with for key a domain class as string and for value the |
| * associated decorations |
| * @return the created edge |
| */ |
| public DEdge createNewEdge(DiagramMappingsManager mappingManager, final DEdgeCandidate candidate, final Map<DiagramElementMapping, Collection<EdgeTarget>> mappingsToEdgeTargets, |
| final Map<EdgeMapping, Collection<MappingBasedDecoration>> edgeToMappingBasedDecoration, final Map<String, Collection<SemanticBasedDecoration>> edgeToSemanticBasedDecoration) { |
| |
| DslCommonPlugin.PROFILER.startWork(SiriusTasksKey.CREATE_MISSING_EDGES_KEY); |
| DEdge newEdge = createEdge(candidate); |
| diagram.getOwnedDiagramElements().add(newEdge); |
| |
| Option<EdgeMapping> edgeMapping = new IEdgeMappingQuery(candidate.getMapping()).getEdgeMapping(); |
| if (edgeMapping.some()) { |
| refreshSemanticElements(newEdge, edgeMapping.get()); |
| createStyle(newEdge, edgeMapping.get(), diagram); |
| refresh(newEdge); |
| updatePath(newEdge, edgeMapping.get(), mappingsToEdgeTargets); |
| } |
| |
| computeEdgeDecorations(newEdge, edgeToMappingBasedDecoration, edgeToSemanticBasedDecoration); |
| computeVisibilityOnCreation(mappingManager, newEdge); |
| |
| DslCommonPlugin.PROFILER.stopWork(SiriusTasksKey.CREATE_MISSING_EDGES_KEY); |
| return newEdge; |
| } |
| |
| /** |
| * Create a new Edge from a candidate. |
| * |
| * @param candidate |
| * the edge candidate containing the mapping and the edge |
| * semantic target (among other things). |
| * @return the newly created edge. |
| */ |
| private DEdge createEdge(final DEdgeCandidate candidate) { |
| final DEdge newEdge = DiagramFactory.eINSTANCE.createDEdge(); |
| newEdge.setTarget(candidate.getSemantic()); |
| newEdge.setActualMapping(candidate.getMapping()); |
| newEdge.setSourceNode(candidate.getSourceView()); |
| newEdge.setTargetNode(candidate.getTargetView()); |
| return newEdge; |
| } |
| |
| private void computeVisibilityOnCreation(DiagramMappingsManager mappingManager, final DDiagramElement element) { |
| final DisplayService service = DisplayServiceManager.INSTANCE.getDisplayService(DisplayMode.CREATION); |
| if (service == null) { |
| return; |
| } |
| |
| DslCommonPlugin.PROFILER.startWork(SiriusTasksKey.IS_VISIBLE_KEY); |
| element.setVisible(service.computeVisibility(mappingManager, diagram, element)); |
| if (!service.computeLabelVisibility(diagram, element)) { |
| HideFilterHelper.INSTANCE.hideLabel(element); |
| } |
| DslCommonPlugin.PROFILER.stopWork(SiriusTasksKey.IS_VISIBLE_KEY); |
| } |
| |
| /** |
| * Compute edge decorations. |
| * |
| * @param edge |
| * the edge |
| * @param edgeToMappingBasedDecoration |
| * a map with for key a mapping and for value the associated |
| * decorations |
| * @param edgeToSemanticBasedDecoration |
| * a map with for key a domain class as string and for value the |
| * associated decorations |
| */ |
| public void computeEdgeDecorations(final DEdge edge, final Map<EdgeMapping, Collection<MappingBasedDecoration>> edgeToMappingBasedDecoration, |
| final Map<String, Collection<SemanticBasedDecoration>> edgeToSemanticBasedDecoration) { |
| /* semantic based decorations */ |
| IEdgeMapping actualMapping = edge.getActualMapping(); |
| final Option<EdgeMapping> edgeMapping = new IEdgeMappingQuery(actualMapping).getEdgeMapping(); |
| if (edgeMapping.some() && edgeMapping.get().isUseDomainElement() && edgeToSemanticBasedDecoration.containsKey(edgeMapping.get().getDomainClass())) { |
| final Collection<SemanticBasedDecoration> semanticBasedDecorations = edgeToSemanticBasedDecoration.get(edgeMapping.get().getDomainClass()); |
| for (final SemanticBasedDecoration semanticBasedDecoration : semanticBasedDecorations) { |
| this.addDecoration(edge, semanticBasedDecoration); |
| } |
| } |
| /* mapping based decoration */ |
| if (edgeToMappingBasedDecoration.containsKey(actualMapping)) { |
| final Collection<MappingBasedDecoration> mappingBasedDecorations = edgeToMappingBasedDecoration.get(actualMapping); |
| for (final MappingBasedDecoration mappingBasedDecoration : mappingBasedDecorations) { |
| this.addDecoration(edge, mappingBasedDecoration); |
| } |
| } |
| } |
| |
| /** |
| * Refresh an edge computing it's new size and style. |
| * |
| * @param edge |
| * edge to be refreshed. |
| */ |
| protected void refresh(final DEdge edge) { |
| EObject containerVariable = null; |
| if (edge.eContainer() instanceof DSemanticDecorator) { |
| containerVariable = ((DSemanticDecorator) edge.eContainer()).getTarget(); |
| } |
| // Recompute the conditional style |
| this.interpreter.setVariable(IInterpreterSiriusVariables.DIAGRAM, this.diagram); |
| this.interpreter.setVariable(IInterpreterSiriusVariables.VIEW, edge); |
| this.interpreter.setVariable(IInterpreterSiriusVariables.SOURCE_VIEW, edge.getSourceNode()); |
| this.interpreter.setVariable(IInterpreterSiriusVariables.TARGET_VIEW, edge.getTargetNode()); |
| |
| this.mappingHelper.affectAndRefreshStyle(edge.getDiagramElementMapping(), edge, edge.getTarget(), containerVariable, (DDiagram) edge.eContainer()); |
| |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.DIAGRAM); |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.VIEW); |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.SOURCE_VIEW); |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.TARGET_VIEW); |
| |
| final EdgeStyle edgeStyle = edge.getOwnedStyle(); |
| if (edgeStyle != null) { |
| final EdgeStyleDescription edgeStyleDescription = (EdgeStyleDescription) edgeStyle.getDescription(); |
| // LABEL |
| refreshCenterLabel(edge, edgeStyleDescription); |
| refreshBeginLabel(edge, edgeStyleDescription); |
| refreshEndLabel(edge, edgeStyleDescription); |
| } |
| |
| // semantic elements |
| final Option<EdgeMapping> actualMapping = new IEdgeMappingQuery(edge.getActualMapping()).getEdgeMapping(); |
| if (actualMapping.some()) { |
| refreshSemanticElements(edge, actualMapping.get()); |
| } |
| |
| // clean decorations |
| cleanDecoration(edge); |
| } |
| |
| /** |
| * @param edge |
| * @param edgeStyleDescription |
| */ |
| private void refreshEndLabel(final DEdge edge, final EdgeStyleDescription edgeStyleDescription) { |
| if (edgeStyleDescription.getEndLabelStyleDescription() != null && !StringUtil.isEmpty(edgeStyleDescription.getEndLabelStyleDescription().getLabelExpression())) { |
| final String label = computeLabel(edge, edgeStyleDescription.getEndLabelStyleDescription()); |
| edge.setEndLabel(label); |
| if (!("".equals(edge.getEndLabel()) && label == null) && !StringUtil.equals(edge.getEndLabel(), label)) { //$NON-NLS-1$ |
| // This is a workaround for a CDO issue in legacy mode |
| // (https://bugs.eclipse.org/bugs/show_bug.cgi?id=404152) |
| edge.setEndLabel(label); |
| } |
| } else if (!StringUtil.isEmpty(edge.getEndLabel())) { |
| edge.setEndLabel(""); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * @param edge |
| * @param edgeStyleDescription |
| */ |
| private void refreshBeginLabel(final DEdge edge, final EdgeStyleDescription edgeStyleDescription) { |
| if (edgeStyleDescription.getBeginLabelStyleDescription() != null && !StringUtil.isEmpty(edgeStyleDescription.getBeginLabelStyleDescription().getLabelExpression())) { |
| final String label = computeLabel(edge, edgeStyleDescription.getBeginLabelStyleDescription()); |
| if (!("".equals(edge.getBeginLabel()) && label == null) && !StringUtil.equals(edge.getBeginLabel(), label)) { //$NON-NLS-1$ |
| // This is a workaround for a CDO issue in legacy mode |
| // (https://bugs.eclipse.org/bugs/show_bug.cgi?id=404152) |
| edge.setBeginLabel(label); |
| } |
| } else if (!StringUtil.isEmpty(edge.getBeginLabel())) { |
| edge.setBeginLabel(""); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * @param edge |
| * @param edgeStyleDescription |
| */ |
| private void refreshCenterLabel(final DEdge edge, final EdgeStyleDescription edgeStyleDescription) { |
| if (edgeStyleDescription.getCenterLabelStyleDescription() != null && !StringUtil.isEmpty(edgeStyleDescription.getCenterLabelStyleDescription().getLabelExpression())) { |
| final String label = computeLabel(edge, edgeStyleDescription.getCenterLabelStyleDescription()); |
| if (!("".equals(edge.getName()) && label == null) && !StringUtil.equals(edge.getName(), label)) { //$NON-NLS-1$ |
| // This is a workaround for a CDO issue in legacy mode |
| // (https://bugs.eclipse.org/bugs/show_bug.cgi?id=404152) |
| edge.setName(label); |
| } |
| } else if (!StringUtil.isEmpty(edge.getName())) { |
| edge.setName(""); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * Refresh a DDiagramElement computing it's label, size and style. |
| * |
| * @param dde |
| * node to be refreshed. |
| */ |
| public void refresh(final DDiagramElement dde) { |
| if (accessor.getPermissionAuthority().canEditInstance(dde)) { |
| if (dde instanceof DNode) { |
| refresh((DNode) dde); |
| } else if (dde instanceof DNodeListElement) { |
| refresh((DNodeListElement) dde); |
| } else if (dde instanceof DDiagramElementContainer) { |
| refresh((DDiagramElementContainer) dde); |
| } else if (dde instanceof DEdge) { |
| refresh((DEdge) dde); |
| } |
| } |
| } |
| |
| /** |
| * Refresh a list element. |
| * |
| * @param newNode |
| * list element to be refreshed. |
| */ |
| protected void refresh(final DNodeListElement newNode) { |
| final DSemanticDecorator container = (DSemanticDecorator) newNode.eContainer(); |
| if (container != null) { |
| final NodeStyleDescription style = (NodeStyleDescription) this.mappingHelper.getBestStyleDescription(newNode.getActualMapping(), newNode.getTarget(), newNode, container.getTarget(), |
| diagram); |
| if (style != null) { |
| refreshLabel(newNode, style); |
| refreshTooltip(newNode, style); |
| } |
| } |
| if (newNode.getOwnedStyle() != null) { |
| Option<NodeStyle> noPreviousStyle = Options.newNone(); |
| styleHelper.refreshStyle(newNode.getOwnedStyle(), noPreviousStyle); |
| } |
| refreshSemanticElements(newNode, newNode.getDiagramElementMapping()); |
| } |
| |
| /** |
| * Refresh a container. |
| * |
| * @param container |
| * element to be refreshed. |
| */ |
| protected void refresh(final DDiagramElementContainer container) { |
| final DSemanticDecorator cContainer = (DSemanticDecorator) container.eContainer(); |
| ContainerMapping containerMapping = container.getActualMapping(); |
| if (cContainer != null) { |
| ContainerStyleDescription containerStyleDescription = null; |
| if (hasSafeTarget(container) && hasSafeTarget(cContainer)) { |
| containerStyleDescription = (ContainerStyleDescription) this.mappingHelper.getBestStyleDescription(containerMapping, container.getTarget(), container, cContainer.getTarget(), diagram); |
| } |
| if (containerStyleDescription != null) { |
| refreshLabel(container, containerStyleDescription); |
| refreshTooltip(container, containerStyleDescription); |
| refreshStyle(container, containerMapping); |
| } |
| } |
| // clean decorations |
| cleanDecoration(container); |
| refreshSemanticElements(container, containerMapping); |
| } |
| |
| private void cleanDecoration(final DDiagramElement element) { |
| Iterator<Decoration> it = element.getDecorations().iterator(); |
| while (it.hasNext()) { |
| Decoration decoration = it.next(); |
| final DecorationDescription description = decoration.getDescription(); |
| if (!diagram.getActivatedLayers().contains(LayerHelper.getParentLayer(description)) |
| || !checkDecoratorPrecondition(element.getTarget(), (DSemanticDecorator) element.eContainer(), description)) { |
| it.remove(); |
| } |
| } |
| } |
| |
| /** |
| * Refresh a {@link DNode}. |
| * |
| * @param newNode |
| * node to be refreshed. |
| */ |
| protected void refresh(final DNode newNode) { |
| final DSemanticDecorator container = (DSemanticDecorator) newNode.eContainer(); |
| if (container != null) { |
| NodeStyleDescription nodeStyleDescription = null; |
| NodeMapping nodeMapping = newNode.getActualMapping(); |
| if (hasSafeTarget(newNode) && hasSafeTarget(container)) { |
| nodeStyleDescription = (NodeStyleDescription) this.mappingHelper.getBestStyleDescription(nodeMapping, newNode.getTarget(), newNode, container.getTarget(), diagram); |
| } |
| if (nodeStyleDescription != null) { |
| if (newNode.getResizeKind() != nodeStyleDescription.getResizeKind()) { |
| newNode.setResizeKind(nodeStyleDescription.getResizeKind()); |
| } |
| |
| // Don't set width and height here for Ellipse, Lozenge, Square |
| // or WorkspaceImage styles |
| boolean customSizeRefresh = nodeStyleDescription instanceof EllipseNodeDescription || nodeStyleDescription instanceof LozengeNodeDescription |
| || nodeStyleDescription instanceof SquareDescription || nodeStyleDescription instanceof WorkspaceImageDescription; |
| |
| if (!StringUtil.isEmpty(nodeStyleDescription.getSizeComputationExpression()) && !customSizeRefresh) { |
| styleHelper.setComputedSize(newNode, nodeStyleDescription); |
| } |
| |
| refreshLabel(newNode, nodeStyleDescription); |
| refreshTooltip(newNode, nodeStyleDescription); |
| refreshStyle(newNode, nodeMapping); |
| } |
| } |
| |
| // clean decorations |
| cleanDecoration(newNode); |
| refreshSemanticElements(newNode, newNode.getDiagramElementMapping()); |
| } |
| |
| private void refreshLabel(final DDiagramElement dde, LabelStyleDescription labelStyleDescription) { |
| if (!StringUtil.isEmpty(labelStyleDescription.getLabelExpression())) { |
| String computedLabel = computeLabel(dde, labelStyleDescription); |
| if (!("".equals(dde.getName()) && computedLabel == null) && !StringUtil.equals(dde.getName(), computedLabel)) { //$NON-NLS-1$ |
| // This is a workaround for a CDO issue in legacy mode |
| // (https://bugs.eclipse.org/bugs/show_bug.cgi?id=404152) |
| dde.setName(computedLabel); |
| } |
| } |
| } |
| |
| private void refreshTooltip(final DDiagramElement elt, final TooltipStyleDescription style) { |
| if (!StringUtil.isEmpty(style.getTooltipExpression())) { |
| final String oldValue = elt.getTooltipText(); |
| final String newValue = computeTooltip(elt, style); |
| if (!Objects.equal(newValue, oldValue)) { |
| elt.setTooltipText(newValue); |
| } |
| } |
| } |
| |
| /** |
| * Refreshes a node style. |
| * |
| * @param node |
| * Node which style is to be refreshed. |
| * @param mapping |
| * Mapping that is to be used to compute the best style for this |
| * node. |
| */ |
| public void refreshStyle(final AbstractDNode node, final AbstractNodeMapping mapping) { |
| EObject containerVariable = null; |
| if (node.eContainer() != null) { |
| this.interpreter.setVariable(IInterpreterSiriusVariables.CONTAINER_VIEW, node.eContainer()); |
| if (node.eContainer() instanceof DSemanticDecorator) { |
| containerVariable = ((DSemanticDecorator) node.eContainer()).getTarget(); |
| this.interpreter.setVariable(IInterpreterSiriusVariables.CONTAINER, containerVariable); |
| |
| } |
| } |
| this.interpreter.setVariable(IInterpreterSiriusVariables.VIEWPOINT, this.diagram); |
| this.interpreter.setVariable(IInterpreterSiriusVariables.DIAGRAM, this.diagram); |
| this.interpreter.setVariable(IInterpreterSiriusVariables.VIEW, node); |
| |
| StyleDescription bestStyleDescription = null; |
| if (hasSafeTarget(node)) { |
| bestStyleDescription = this.mappingHelper.getBestStyleDescription(mapping, node.getTarget(), node, containerVariable, diagram); |
| } |
| Style style = node.getStyle(); |
| if (style != null) { |
| Style bestStyle = this.mappingHelper.getBestStyle(mapping, node.getTarget(), node, containerVariable, diagram); |
| // In case the current Style is a customized |
| if (bestStyleDescription != null && !isSameDescription(bestStyleDescription, style, bestStyle)) { |
| final Style currentStyle = style; |
| if (isCustomizedWorkspaceImageWorkspacePath(currentStyle)) { |
| styleHelper.refreshStyle(style); |
| } else { |
| styleHelper.setAndRefreshStyle(node, currentStyle, styleHelper.createStyle(bestStyleDescription)); |
| } |
| } else { |
| styleHelper.refreshStyle(style); |
| } |
| } else { |
| styleHelper.setAndRefreshStyle(node, null, styleHelper.createStyle(bestStyleDescription)); |
| } |
| |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.VIEW); |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.DIAGRAM); |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.VIEWPOINT); |
| if (node.eContainer() != null) { |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.CONTAINER_VIEW); |
| if (node.eContainer() instanceof DSemanticDecorator) { |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.CONTAINER); |
| } |
| } |
| } |
| |
| private boolean isCustomizedWorkspaceImageWorkspacePath(Style style) { |
| boolean isCustomizedWorkspaceImageWorkspacePath = false; |
| if (style instanceof WorkspaceImage) { |
| WorkspaceImage workspaceImage = (WorkspaceImage) style; |
| isCustomizedWorkspaceImageWorkspacePath = workspaceImage.getCustomFeatures().contains(DiagramPackage.Literals.WORKSPACE_IMAGE__WORKSPACE_PATH.getName()); |
| } |
| return isCustomizedWorkspaceImageWorkspacePath; |
| } |
| |
| /** |
| * |
| * @param bestStyleDescription |
| * the description |
| * @param style |
| * the current style |
| * @param bestStyle |
| * the best style |
| * @return if the description is the same type as the style |
| */ |
| private boolean isSameDescription(StyleDescription bestStyleDescription, Style style, Style bestStyle) { |
| return bestStyleDescription == style.getDescription() && bestStyle.eClass().equals(style.eClass()); |
| } |
| |
| /** |
| * Refreshes an edge style. |
| * |
| * @param edge |
| * Edge which style is to be refreshed. |
| * @param mapping |
| * Mapping that is to be used to compute the best style for this |
| * node. |
| * @param parentDiagram |
| * the parent diagram of the edge |
| */ |
| public void refreshStyle(final DEdge edge, final EdgeMapping mapping, final DDiagram parentDiagram) { |
| this.interpreter.setVariable(IInterpreterSiriusVariables.DIAGRAM, this.diagram); |
| this.interpreter.setVariable(IInterpreterSiriusVariables.VIEW, edge); |
| this.interpreter.setVariable(IInterpreterSiriusVariables.SOURCE_VIEW, edge.getSourceNode()); |
| this.interpreter.setVariable(IInterpreterSiriusVariables.TARGET_VIEW, edge.getTargetNode()); |
| |
| EObject containerVariable = null; |
| if (edge.eContainer() instanceof DSemanticDecorator) { |
| containerVariable = ((DSemanticDecorator) edge.eContainer()).getTarget(); |
| } |
| StyleDescription bestStyleDescription = null; |
| if (edge.getTarget() != null) { |
| bestStyleDescription = this.mappingHelper.getBestStyleDescription(mapping, edge.getTarget(), edge, containerVariable, parentDiagram); |
| } |
| if (bestStyleDescription != null && bestStyleDescription != edge.getStyle().getDescription()) { |
| final Style currentStyle = edge.getStyle(); |
| styleHelper.setAndRefreshStyle(edge, currentStyle, styleHelper.createStyle(bestStyleDescription)); |
| } else if (edge.getStyle() != null) { |
| styleHelper.refreshStyle(edge.getStyle()); |
| } |
| |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.DIAGRAM); |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.VIEW); |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.SOURCE_VIEW); |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.TARGET_VIEW); |
| } |
| |
| /** |
| * Creates a node style. |
| * |
| * @param node |
| * node to refresh. |
| * @param mapping |
| * mapping to use to compute the style. |
| */ |
| public void createStyle(final AbstractDNode node, final AbstractNodeMapping mapping) { |
| EObject containerVariable = null; |
| if (node.eContainer() != null) { |
| this.interpreter.setVariable(IInterpreterSiriusVariables.CONTAINER_VIEW, node.eContainer()); |
| if (node.eContainer() instanceof DSemanticDecorator) { |
| containerVariable = ((DSemanticDecorator) node.eContainer()).getTarget(); |
| this.interpreter.setVariable(IInterpreterSiriusVariables.CONTAINER, containerVariable); |
| } |
| } |
| this.interpreter.setVariable(IInterpreterSiriusVariables.VIEWPOINT, this.diagram); |
| this.interpreter.setVariable(IInterpreterSiriusVariables.DIAGRAM, this.diagram); |
| this.interpreter.setVariable(IInterpreterSiriusVariables.VIEW, node); |
| |
| this.mappingHelper.affectAndRefreshStyle(mapping, node, node.getTarget(), containerVariable, diagram); |
| |
| if (node.eContainer() != null) { |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.CONTAINER_VIEW); |
| if (node.eContainer() instanceof DSemanticDecorator) { |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.CONTAINER); |
| } |
| } |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.VIEW); |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.DIAGRAM); |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.VIEWPOINT); |
| } |
| |
| /** |
| * Creates an edge style. |
| * |
| * @param edge |
| * edge to refresh. |
| * |
| * @param mapping |
| * mapping to use to compute the new style. |
| * @param parentDiagram |
| * the parent diagram of the edge |
| */ |
| public void createStyle(final DEdge edge, final EdgeMapping mapping, final DDiagram parentDiagram) { |
| this.interpreter.setVariable(IInterpreterSiriusVariables.DIAGRAM, this.diagram); |
| this.interpreter.setVariable(IInterpreterSiriusVariables.VIEW, edge); |
| this.interpreter.setVariable(IInterpreterSiriusVariables.SOURCE_VIEW, edge.getSourceNode()); |
| this.interpreter.setVariable(IInterpreterSiriusVariables.TARGET_VIEW, edge.getTargetNode()); |
| |
| if (edge.getStyle() == null || edge.getStyle().getCustomFeatures().isEmpty()) { |
| EObject containerVariable = null; |
| if (edge.eContainer() instanceof DSemanticDecorator) { |
| containerVariable = ((DSemanticDecorator) edge.eContainer()).getTarget(); |
| } |
| this.mappingHelper.affectAndRefreshStyle(mapping, edge, edge.getTarget(), containerVariable, parentDiagram); |
| } else { |
| if (edge.getStyle().getCustomFeatures().isEmpty()) { |
| Option<EdgeStyle> noPreviousStyle = Options.newNone(); |
| styleHelper.refreshStyle(edge.getOwnedStyle(), noPreviousStyle); |
| } else { |
| styleHelper.refreshStyle(edge.getOwnedStyle(), Options.newSome(edge.getOwnedStyle())); |
| } |
| } |
| |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.DIAGRAM); |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.VIEW); |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.SOURCE_VIEW); |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.TARGET_VIEW); |
| } |
| |
| private String computeLabel(final DDiagramElement view, final EObject descriptionObject) { |
| String result = IInterpreterMessages.DEFAULT_NAME_ON_FACTORY_EXCEPTION; |
| |
| if (descriptionObject instanceof BasicLabelStyleDescription) { |
| result = DiagramElementMappingHelper.computeLabel(view, (BasicLabelStyleDescription) descriptionObject, this.diagram, interpreter); |
| } |
| |
| return result; |
| } |
| |
| private String computeTooltip(final DSemanticDecorator view, final EObject descriptionObject) { |
| String result = StylePackage.eINSTANCE.getTooltipStyleDescription_TooltipExpression().getDefaultValueLiteral(); |
| |
| if (descriptionObject instanceof TooltipStyleDescription) { |
| String tooltipExpression = ((TooltipStyleDescription) descriptionObject).getTooltipExpression(); |
| |
| try { |
| interpreter.setVariable(IInterpreterSiriusVariables.VIEW, view); |
| result = interpreter.evaluateString(view.getTarget(), tooltipExpression); |
| } catch (final EvaluationException e) { |
| RuntimeLoggerManager.INSTANCE.error(descriptionObject, StylePackage.eINSTANCE.getTooltipStyleDescription_TooltipExpression(), e); |
| } finally { |
| interpreter.unSetVariable(IInterpreterSiriusVariables.VIEW); |
| } |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Create the edge path if needed path. |
| * |
| * @param edge |
| * edge to update. |
| * @param mapping |
| * the edge mapping used for the path computing. |
| * @param mappingsToEdgeTargets |
| * map for the Mapping eobject to view elements. |
| */ |
| public void updatePath(final DEdge edge, final EdgeMapping mapping, final Map<DiagramElementMapping, Collection<EdgeTarget>> mappingsToEdgeTargets) { |
| if (mapping.getPathExpression() != null && !StringUtil.isEmpty(mapping.getPathExpression()) && mapping.getPathNodeMapping() != null) { |
| |
| List<EObject> pathSemanticCandidates = Collections.<EObject> emptyList(); |
| // variables. |
| interpreter.setVariable(IInterpreterSiriusVariables.VIEWPOINT, diagram); |
| interpreter.setVariable(IInterpreterSiriusVariables.DIAGRAM, diagram); |
| interpreter.setVariable(IInterpreterSiriusVariables.ELEMENT, edge.getTarget()); |
| if (edge.getSourceNode() instanceof DSemanticDecorator) { |
| interpreter.setVariable(IInterpreterSiriusVariables.SOURCE, ((DSemanticDecorator) edge.getSourceNode()).getTarget()); |
| } |
| if (edge.getTargetNode() instanceof DSemanticDecorator) { |
| interpreter.setVariable(IInterpreterSiriusVariables.TARGET, ((DSemanticDecorator) edge.getTargetNode()).getTarget()); |
| } |
| |
| try { |
| pathSemanticCandidates = new ArrayList<EObject>(interpreter.evaluateCollection(edge.getTarget(), mapping.getPathExpression())); |
| } catch (final EvaluationException e) { |
| RuntimeLoggerManager.INSTANCE.error(mapping, DescriptionPackage.eINSTANCE.getEdgeMapping_PathExpression(), e); |
| } finally { |
| interpreter.unSetVariable(IInterpreterSiriusVariables.VIEWPOINT); |
| interpreter.unSetVariable(IInterpreterSiriusVariables.DIAGRAM); |
| interpreter.unSetVariable(IInterpreterSiriusVariables.ELEMENT); |
| interpreter.unSetVariable(IInterpreterSiriusVariables.SOURCE); |
| interpreter.unSetVariable(IInterpreterSiriusVariables.TARGET); |
| } |
| |
| final Map<EObject, EdgeTarget> availableElements = getAvailableElements(mappingsToEdgeTargets, mapping.getPathNodeMapping()); |
| |
| final Collection<EObject> semanticAvailableElements = availableElements.keySet(); |
| |
| EList<EdgeTarget> newPath = new BasicEList<EdgeTarget>(); |
| |
| for (final EObject pathSemanticCandidate : pathSemanticCandidates) { |
| if (semanticAvailableElements.contains(pathSemanticCandidate)) { |
| newPath.add(availableElements.get(pathSemanticCandidate)); |
| } |
| } |
| |
| if (!newPath.isEmpty() && !edge.getPath().equals(newPath)) { |
| edge.getPath().clear(); |
| edge.getPath().addAll(newPath); |
| } |
| } |
| } |
| |
| private Map<EObject, EdgeTarget> getAvailableElements(final Map<DiagramElementMapping, Collection<EdgeTarget>> mappingsToEdgeTargets, final Collection<AbstractNodeMapping> mappings) { |
| final Map<EObject, EdgeTarget> semanticToEdgeTargets = new HashMap<EObject, EdgeTarget>(); |
| for (final DiagramElementMapping availableMapping : mappings) { |
| final Collection<EdgeTarget> edgeTargets = mappingsToEdgeTargets.get(availableMapping); |
| if (edgeTargets != null) { |
| for (final EdgeTarget edgeTarget : edgeTargets) { |
| if (edgeTarget instanceof DSemanticDecorator) { |
| semanticToEdgeTargets.put(((DSemanticDecorator) edgeTarget).getTarget(), edgeTarget); |
| } |
| } |
| } |
| } |
| return semanticToEdgeTargets; |
| } |
| |
| /** |
| * Add a decoration to a DdiagramElement. |
| * |
| * @param element |
| * element to decorate |
| * @param decorationDescription |
| * description of the decoration |
| */ |
| public void addDecoration(final DDiagramElement element, final DecorationDescription decorationDescription) { |
| for (final Decoration decoration : new ArrayList<Decoration>(element.getDecorations())) { |
| if (EcoreUtil.equals(decorationDescription, decoration.getDescription())) { |
| return; |
| } |
| } |
| // new decoration |
| if (checkDecoratorPrecondition(element.getTarget(), (DSemanticDecorator) element.eContainer(), decorationDescription)) { |
| final Decoration decoration = ViewpointFactory.eINSTANCE.createDecoration(); |
| decoration.setDescription(decorationDescription); |
| element.getDecorations().add(decoration); |
| } |
| } |
| |
| private boolean checkDecoratorPrecondition(final EObject semantic, final DSemanticDecorator container, final DecorationDescription decorationDescription) { |
| DslCommonPlugin.PROFILER.startWork(SiriusTasksKey.CHECK_PRECONDITION_KEY); |
| boolean result = false; |
| if (decorationDescription != null && !decorationDescription.eIsProxy()) { |
| result = true; |
| final String preconditionExpression = decorationDescription.getPreconditionExpression(); |
| if (!StringUtil.isEmpty(preconditionExpression)) { |
| this.interpreter.setVariable(IInterpreterSiriusVariables.CONTAINER_VIEW, container); |
| this.interpreter.setVariable(IInterpreterSiriusVariables.CONTAINER, container != null ? container.getTarget() : null); |
| this.interpreter.setVariable(IInterpreterSiriusVariables.VIEWPOINT, this.diagram); |
| this.interpreter.setVariable(IInterpreterSiriusVariables.DIAGRAM, this.diagram); |
| try { |
| result = interpreter.evaluateBoolean(semantic, preconditionExpression); |
| } catch (final EvaluationException e) { |
| RuntimeLoggerManager.INSTANCE.error(decorationDescription, org.eclipse.sirius.viewpoint.description.DescriptionPackage.eINSTANCE.getDecorationDescription_PreconditionExpression(), |
| e); |
| } |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.CONTAINER_VIEW); |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.CONTAINER); |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.VIEWPOINT); |
| this.interpreter.unSetVariable(IInterpreterSiriusVariables.DIAGRAM); |
| } |
| } |
| DslCommonPlugin.PROFILER.stopWork(SiriusTasksKey.CHECK_PRECONDITION_KEY); |
| return result; |
| } |
| |
| private void refreshSemanticElements(final DDiagramElement element, final DiagramElementMapping mapping) { |
| DiagramElementMappingHelper.refreshSemanticElements(mapping, element, this.interpreter); |
| } |
| |
| /** |
| * Check if the target of this decorator is not null and is in a eResource. |
| * |
| * @param decorator |
| * The decorator to check |
| * @return true if the target is OK, false otherwise. |
| */ |
| private boolean hasSafeTarget(DSemanticDecorator semDec) { |
| EObject target = semDec.getTarget(); |
| return target != null && (target.eContainer() != null || target.eResource() != null); |
| } |
| } |
