| /******************************************************************************* |
| * Copyright (c) 2013, 2016 Obeo 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 |
| * Philip Langer - adaptation for refactoring regarding SizeChange |
| * Simon Delisle - bug 511047 |
| *******************************************************************************/ |
| package org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram; |
| |
| import static com.google.common.base.Predicates.and; |
| import static com.google.common.base.Predicates.instanceOf; |
| import static com.google.common.base.Predicates.or; |
| import static org.eclipse.emf.compare.merge.AbstractMerger.isInTerminalState; |
| import static org.eclipse.emf.compare.utils.EMFComparePredicates.ofKind; |
| import static org.eclipse.emf.compare.utils.EMFComparePredicates.onFeature; |
| import static org.eclipse.emf.compare.utils.EMFComparePredicates.valueIs; |
| |
| import com.google.common.base.Predicate; |
| import com.google.common.base.Predicates; |
| import com.google.common.collect.Collections2; |
| import com.google.common.collect.HashMultimap; |
| import com.google.common.collect.Iterables; |
| import com.google.common.collect.Iterators; |
| import com.google.common.collect.Lists; |
| import com.google.common.collect.Multimap; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.EventObject; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.ResourceBundle; |
| |
| import org.eclipse.draw2d.IFigure; |
| import org.eclipse.draw2d.Polyline; |
| import org.eclipse.draw2d.PolylineConnection; |
| import org.eclipse.draw2d.RectangleFigure; |
| import org.eclipse.draw2d.geometry.Point; |
| import org.eclipse.draw2d.geometry.Rectangle; |
| import org.eclipse.emf.common.command.Command; |
| import org.eclipse.emf.common.command.CommandStack; |
| import org.eclipse.emf.compare.Diff; |
| import org.eclipse.emf.compare.DifferenceKind; |
| import org.eclipse.emf.compare.DifferenceState; |
| import org.eclipse.emf.compare.Match; |
| import org.eclipse.emf.compare.command.impl.CopyCommand; |
| import org.eclipse.emf.compare.diagram.ide.ui.internal.accessor.IDiagramDiffAccessor; |
| import org.eclipse.emf.compare.diagram.ide.ui.internal.accessor.IDiagramNodeAccessor; |
| import org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.figures.DecoratorFigure; |
| import org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.figures.EdgeFigure; |
| import org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.figures.NodeFigure; |
| import org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.figures.NodeListFigure; |
| import org.eclipse.emf.compare.diagram.internal.extensions.CoordinatesChange; |
| import org.eclipse.emf.compare.diagram.internal.extensions.DiagramDiff; |
| import org.eclipse.emf.compare.diagram.internal.extensions.Hide; |
| import org.eclipse.emf.compare.diagram.internal.extensions.Show; |
| import org.eclipse.emf.compare.ide.ui.internal.configuration.EMFCompareConfiguration; |
| import org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.EMFCompareContentMergeViewer; |
| import org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.tree.TreeContentMergeViewerContentProvider; |
| import org.eclipse.emf.compare.internal.utils.DiffUtil; |
| import org.eclipse.emf.compare.rcp.ui.mergeviewer.IMergeViewer; |
| import org.eclipse.emf.compare.rcp.ui.mergeviewer.IMergeViewer.MergeViewerSide; |
| import org.eclipse.emf.compare.utils.ReferenceUtil; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.gef.ConnectionEditPart; |
| import org.eclipse.gef.EditPart; |
| import org.eclipse.gef.GraphicalEditPart; |
| import org.eclipse.gef.LayerConstants; |
| import org.eclipse.gef.editparts.AbstractGraphicalEditPart; |
| import org.eclipse.gef.editparts.LayerManager; |
| import org.eclipse.gmf.runtime.diagram.ui.editparts.ListCompartmentEditPart; |
| import org.eclipse.gmf.runtime.diagram.ui.editparts.ListItemEditPart; |
| import org.eclipse.gmf.runtime.notation.Diagram; |
| import org.eclipse.gmf.runtime.notation.Edge; |
| import org.eclipse.gmf.runtime.notation.NotationPackage; |
| import org.eclipse.gmf.runtime.notation.View; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.graphics.GC; |
| import org.eclipse.swt.widgets.Composite; |
| |
| /** |
| * Specialized {@link org.eclipse.compare.contentmergeviewer.ContentMergeViewer} that uses |
| * {@link org.eclipse.jface.viewers.TreeViewer} to display left, right and ancestor {@link EObject}. |
| * |
| * @author <a href="mailto:cedric.notot@obeo.fr">Cedric Notot</a> |
| */ |
| @SuppressWarnings("restriction") |
| public class DiagramContentMergeViewer extends EMFCompareContentMergeViewer { |
| |
| /** |
| * Interface for the management of decorators. |
| * |
| * @author <a href="mailto:cedric.notot@obeo.fr">Cedric Notot</a> |
| */ |
| private interface IDecoratorManager { |
| |
| /** |
| * It hides the revealed decorators. |
| */ |
| void hideAll(); |
| |
| /** |
| * From a given difference, it hides the related decorators. |
| * |
| * @param difference |
| * The difference. |
| */ |
| void hideDecorators(Diff difference); |
| |
| /** |
| * From a given difference, it reveals the related decorators. |
| * |
| * @param difference |
| * The difference. |
| */ |
| void revealDecorators(Diff difference); |
| |
| /** |
| * From a given difference, it removes the related decorators from cash. |
| * |
| * @param difference |
| * The difference. |
| */ |
| void removeDecorators(Diff difference); |
| |
| /** |
| * It removes all the displayed decorators from cache. |
| */ |
| void removeAll(); |
| } |
| |
| /** |
| * Decorator manager to create, hide or reveal decorator figures related to deleted or added graphical |
| * objects. |
| * |
| * @author <a href="mailto:cedric.notot@obeo.fr">Cedric Notot</a> |
| */ |
| private abstract class AbstractDecoratorManager implements IDecoratorManager { |
| |
| /** |
| * Decorator represented by a <code>figure</code> on a <code>layer</code>, from the given |
| * <code>side</code> of the merge viewer. An edit part may be linked to the <code>figure</code> in |
| * some cases.<br> |
| * The decorator is related to a <code>difference</code> and it is binded with the reference view and |
| * figure. |
| * |
| * @author <a href="mailto:cedric.notot@obeo.fr">Cedric Notot</a> |
| */ |
| protected abstract class AbstractDecorator { |
| |
| /** The reference <code>View</code> for this decorator. */ |
| protected View fOriginView; |
| |
| /** The reference <code>IFigure</code> for this decorator. */ |
| protected IFigure fOriginFigure; |
| |
| /** The <code>IFigure</code> representing this decorator. */ |
| protected IFigure fFigure; |
| |
| /** |
| * The <code>DecoratorFigure</code> representing this decorator. It references |
| * {@link AbstractDecorator#fFigure} through the accessor {@link DecoratorFigure#getMainFigure()}. |
| */ |
| protected DecoratorFigure fDecoratorFigure; |
| |
| /** The layer on which the <code>figure</code> has to be drawn. */ |
| protected IFigure fLayer; |
| |
| /** The side of the merge viewer on which the <code>figure</code> has to be drawn. */ |
| protected MergeViewerSide fSide; |
| |
| /** The difference related to this phantom. */ |
| protected Diff fDifference; |
| |
| /** The edit part of the figure representing this phantom. May be null. */ |
| protected EditPart fEditPart; |
| |
| /** |
| * Getter. |
| * |
| * @return the originView {@link AbstractDecorator#fOriginView}. |
| */ |
| public View getOriginView() { |
| return fOriginView; |
| } |
| |
| /** |
| * Setter. |
| * |
| * @param originView |
| * {@link AbstractDecorator#fOriginView}. |
| */ |
| public void setOriginView(View originView) { |
| this.fOriginView = originView; |
| } |
| |
| /** |
| * Getter. |
| * |
| * @return the originFigure {@link AbstractDecorator#fOriginFigure}. |
| */ |
| public IFigure getOriginFigure() { |
| return fOriginFigure; |
| } |
| |
| /** |
| * Setter. |
| * |
| * @param originFigure |
| * {@link AbstractDecorator#fOriginFigure}. |
| */ |
| public void setOriginFigure(IFigure originFigure) { |
| this.fOriginFigure = originFigure; |
| } |
| |
| /** |
| * Getter. |
| * |
| * @return the figure {@link AbstractDecorator#fFigure}. |
| */ |
| public IFigure getFigure() { |
| return fFigure; |
| } |
| |
| /** |
| * Getter. |
| * |
| * @return the decorator figure {@link AbstractDecorator#fDecoratorFigure}. |
| */ |
| public DecoratorFigure getDecoratorFigure() { |
| return fDecoratorFigure; |
| } |
| |
| /** |
| * Setter. |
| * |
| * @param figure |
| * {@link AbstractDecorator#fFigure}. |
| */ |
| public void setFigure(IFigure figure) { |
| this.fFigure = figure; |
| } |
| |
| /** |
| * Setter. |
| * |
| * @param figure |
| * {@link AbstractDecorator#fFigure}. |
| */ |
| public void setDecoratorFigure(DecoratorFigure figure) { |
| this.fDecoratorFigure = figure; |
| setFigure(figure.getMainFigure()); |
| } |
| |
| /** |
| * Getter. |
| * |
| * @return the layer {@link AbstractDecorator#fLayer}. |
| */ |
| public IFigure getLayer() { |
| return fLayer; |
| } |
| |
| /** |
| * Setter. |
| * |
| * @param layer |
| * {@link AbstractDecorator#fLayer}. |
| */ |
| public void setLayer(IFigure layer) { |
| this.fLayer = layer; |
| } |
| |
| /** |
| * Getter. |
| * |
| * @return the side {@link AbstractDecorator#fSide}. |
| */ |
| public MergeViewerSide getSide() { |
| return fSide; |
| } |
| |
| /** |
| * Setter. |
| * |
| * @param side |
| * {@link AbstractDecorator#fSide}. |
| */ |
| public void setSide(MergeViewerSide side) { |
| this.fSide = side; |
| } |
| |
| /** |
| * Getter. |
| * |
| * @return the difference {@link AbstractDecorator#fDifference}. |
| */ |
| public Diff getDifference() { |
| return fDifference; |
| } |
| |
| /** |
| * Setter. |
| * |
| * @param difference |
| * {@link AbstractDecorator#fDifference}. |
| */ |
| public void setDifference(Diff difference) { |
| this.fDifference = difference; |
| } |
| |
| /** |
| * Getter. |
| * |
| * @return the editPart {@link AbstractDecorator#fEditPart}. |
| */ |
| public EditPart getEditPart() { |
| return fEditPart; |
| } |
| |
| /** |
| * Setter. |
| * |
| * @param editPart |
| * {@link AbstractDecorator#fEditPart}. |
| */ |
| public void setEditPart(EditPart editPart) { |
| this.fEditPart = editPart; |
| } |
| |
| } |
| |
| /** |
| * From a given difference, it hides the related decorators. |
| * |
| * @param difference |
| * The difference. |
| */ |
| public void hideDecorators(Diff difference) { |
| Collection<? extends AbstractDecorator> oldDecorators = getDecorators(difference); |
| if (oldDecorators != null && !oldDecorators.isEmpty() |
| && getCompareConfiguration().getComparison() != null) { |
| handleDecorators(oldDecorators, false, true); |
| } |
| } |
| |
| /** |
| * From a given difference, it reveals the related decorators. |
| * |
| * @param difference |
| * The difference. |
| */ |
| public void revealDecorators(Diff difference) { |
| |
| Collection<? super AbstractDecorator> decorators = (Collection<? super AbstractDecorator>)getDecorators( |
| difference); |
| |
| // Create decorators only if they do not already exist and if the selected difference is a good |
| // candidate for that. |
| if ((decorators == null || decorators.isEmpty()) && isGoodCandidate(difference)) { |
| |
| DiagramDiff diagramDiff = (DiagramDiff)difference; |
| |
| List<View> referenveViews = getReferenceViews(diagramDiff); |
| |
| for (View referenceView : referenveViews) { |
| IFigure referenceFigure = getFigure(referenceView); |
| |
| if (referenceFigure != null) { |
| MergeViewerSide targetSide = getTargetSide( |
| getCompareConfiguration().getComparison().getMatch(referenceView), |
| referenceView); |
| |
| if (decorators == null) { |
| decorators = new ArrayList<AbstractDecorator>(); |
| } |
| |
| AbstractDecorator decorator = createAndRegisterDecorator(difference, referenceView, |
| referenceFigure, targetSide); |
| if (decorator != null) { |
| decorators.add(decorator); |
| } |
| } |
| |
| } |
| |
| } |
| |
| // The selected difference is a good candidate and decorators exist for it |
| if (decorators != null && !decorators.isEmpty()) { |
| revealDecorators((Collection<? extends AbstractDecorator>)decorators); |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.IDecoratorManager#removeDecorators(org.eclipse.emf.compare.Diff) |
| */ |
| public abstract void removeDecorators(Diff difference); |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.IDecoratorManager#removeAll() |
| */ |
| public abstract void removeAll(); |
| |
| /** |
| * It reveals the given decorators. |
| * |
| * @param decorators |
| * The main decorators. |
| */ |
| protected void revealDecorators(Collection<? extends AbstractDecorator> decorators) { |
| handleDecorators(decorators, true, true); |
| } |
| |
| /** |
| * Get the figure related to the given view. |
| * |
| * @param view |
| * The view. |
| * @return the figure. |
| */ |
| protected IFigure getFigure(View view) { |
| MergeViewerSide side = getSide(view); |
| GraphicalEditPart originEditPart = (GraphicalEditPart)getViewer(side).getEditPart(view); |
| if (originEditPart != null) { |
| return originEditPart.getFigure(); |
| } |
| return null; |
| } |
| |
| /** |
| * It manages the display of the given decorators.<br> |
| * |
| * @param decorators |
| * The decorators to handle. |
| * @param isAdd |
| * True if it has to be revealed, False otherwise. |
| * @param areMain |
| * It indicates if the given decorators to handle are considered as the main ones (the ones |
| * directly linked to the selected difference). |
| */ |
| protected void handleDecorators(Collection<? extends AbstractDecorator> decorators, boolean isAdd, |
| boolean areMain) { |
| for (AbstractDecorator decorator : decorators) { |
| handleDecorator(decorator, isAdd, areMain); |
| } |
| } |
| |
| /** |
| * It manages the display of the given decorator. |
| * |
| * @param decorator |
| * The decorator to handle. |
| * @param isAdd |
| * True if it has to be revealed, False otherwise. |
| * @param isMain |
| * It indicates if the given decorator to handle is considered as the main one (the one |
| * directly linked to the selected difference). |
| */ |
| protected void handleDecorator(AbstractDecorator decorator, boolean isAdd, boolean isMain) { |
| IFigure layer = decorator.getLayer(); |
| IFigure figure = decorator.getFigure(); |
| if (isAdd) { |
| handleAddDecorator(decorator, layer, figure, isMain); |
| } else if (layer.getChildren().contains(figure)) { |
| handleDeleteDecorator(decorator, layer, figure); |
| } |
| } |
| |
| /** |
| * It manages the reveal of the given decorator. |
| * |
| * @param decorator |
| * The decorator. |
| * @param parent |
| * The parent figure which has to get the figure to reveal (<code>toAdd</code>) |
| * @param toAdd |
| * The figure to reveal. |
| * @param isMain |
| * It indicates if the given decorator to reveal is considered as the main one (the one |
| * directly linked to the selected difference). |
| */ |
| protected void handleAddDecorator(AbstractDecorator decorator, IFigure parent, IFigure toAdd, |
| boolean isMain) { |
| if (decorator.getEditPart() != null) { |
| decorator.getEditPart().activate(); |
| } |
| if (!parent.getChildren().contains(toAdd)) { |
| parent.add(toAdd); |
| } |
| } |
| |
| /** |
| * It manages the hiding of the given decorator. |
| * |
| * @param decorator |
| * The decorator. |
| * @param parent |
| * The parent figure which has to get the figure to hide (<code>toDelete</code>) |
| * @param toDelete |
| * The figure to hide. |
| */ |
| protected void handleDeleteDecorator(AbstractDecorator decorator, IFigure parent, IFigure toDelete) { |
| if (decorator.getEditPart() != null) { |
| decorator.getEditPart().deactivate(); |
| } |
| if (parent.getChildren().contains(toDelete)) { |
| parent.remove(toDelete); |
| } |
| } |
| |
| /** |
| * It checks if the given difference is a good candidate to manage decorators.<br> |
| * |
| * @see {@link PhantomManager#goodCandidate()}. |
| * @param difference |
| * The difference. |
| * @return True if it is a good candidate, False otherwise. |
| */ |
| private boolean isGoodCandidate(Diff difference) { |
| return goodCandidate().apply(difference); |
| } |
| |
| /** |
| * Get the layer on the given side, from the reference view.<br> |
| * |
| * @see @ link PhantomManager#getIDLayer(View)} . |
| * @param referenceView |
| * The reference view. |
| * @param side |
| * The side where the layer has to be found. |
| * @return The layer figure or null if the edit part of the diagram is not found. |
| */ |
| protected IFigure getLayer(View referenceView, MergeViewerSide side) { |
| Diagram referenceDiagram = referenceView.getDiagram(); |
| Diagram targetDiagram = (Diagram)getMatchView(referenceDiagram, side); |
| DiagramMergeViewer targetViewer = getViewer(side); |
| EditPart editPart = targetViewer.getEditPart(targetDiagram); |
| if (editPart != null) { |
| return LayerManager.Helper.find(editPart).getLayer(getIDLayer(referenceView)); |
| } |
| return null; |
| } |
| |
| /** |
| * Get the layer ID to use from the reference view.<br> |
| * If the reference view is an edge, it is the {@link LayerConstants.CONNECTION_LAYER} which is used, |
| * {@link LayerConstants.SCALABLE_LAYERS} otherwise. |
| * |
| * @param referenceView |
| * The reference view. |
| * @return The ID of the layer. |
| */ |
| protected Object getIDLayer(View referenceView) { |
| if (referenceView instanceof Edge) { |
| return LayerConstants.CONNECTION_LAYER; |
| } else { |
| return LayerConstants.SCALABLE_LAYERS; |
| } |
| } |
| |
| /** |
| * It translates the coordinates of the given bounds, from the reference figure and the root of this |
| * one, to absolute coordinates. |
| * |
| * @param referenceFigure |
| * The reference figure. |
| * @param rootReferenceFigure |
| * The root of the reference figure. |
| * @param boundsToTranslate |
| * The bounds to translate. |
| */ |
| protected void translateCoordinates(IFigure referenceFigure, IFigure rootReferenceFigure, |
| Rectangle boundsToTranslate) { |
| IFigure referenceParentFigure = referenceFigure.getParent(); |
| if (referenceParentFigure != null && referenceFigure != rootReferenceFigure) { |
| // rootReferenceFigure may be located to (-x,0)... We consider that the root reference is |
| // always (0,0) |
| if (referenceParentFigure.isCoordinateSystem() |
| && referenceParentFigure != rootReferenceFigure) { |
| boundsToTranslate.x += referenceParentFigure.getBounds().x; |
| boundsToTranslate.y += referenceParentFigure.getBounds().y; |
| } |
| translateCoordinates(referenceParentFigure, rootReferenceFigure, boundsToTranslate); |
| } |
| } |
| |
| /** |
| * It checks that the given view represents an element of a list. |
| * |
| * @param view |
| * The view. |
| * @return True it it is an element of a list. |
| */ |
| protected boolean isNodeList(View view) { |
| DiagramMergeViewer viewer = getViewer(getSide(view)); |
| EditPart part = viewer.getEditPart(view); |
| return isNodeList(part); |
| } |
| |
| /** |
| * It checks that the given part represents an element of a list. |
| * |
| * @param part |
| * The part. |
| * @return True it it represents an element of a list. |
| */ |
| private boolean isNodeList(EditPart part) { |
| return part instanceof ListItemEditPart || isInListContainer(part); |
| |
| } |
| |
| /** |
| * It checks that the given part is in one representing a list container. |
| * |
| * @param part |
| * The part. |
| * @return True it it is in a part representing a list container. |
| */ |
| private boolean isInListContainer(EditPart part) { |
| EditPart parent = part.getParent(); |
| while (parent != null) { |
| if (parent instanceof ListCompartmentEditPart) { |
| return true; |
| } |
| parent = parent.getParent(); |
| } |
| return false; |
| } |
| |
| /** |
| * Get the predicate to know the differences concerned by the display of decorators. |
| * |
| * @return The predicate. |
| */ |
| protected abstract Predicate<Diff> goodCandidate(); |
| |
| /** |
| * Get the views which have to be used as reference to build the related decorators from the given |
| * difference of the value concerned by the difference.<br> |
| * |
| * @param difference |
| * The difference. |
| * @return The list of reference views. |
| */ |
| protected abstract List<View> getReferenceViews(DiagramDiff difference); |
| |
| /** |
| * Get the side where decorators have to be drawn, according to the given reference view and its |
| * match.<br> |
| * |
| * @param match |
| * The match of the reference view. |
| * @param referenceView |
| * The reference view. |
| * @return The side for phantoms. |
| */ |
| protected abstract MergeViewerSide getTargetSide(Match match, View referenceView); |
| |
| /** |
| * It creates new decorators and registers them. |
| * |
| * @param diff |
| * The related difference used as index for the main decorator. |
| * @param referenceView |
| * The reference view as base for creation of the decorator. |
| * @param referenceFigure |
| * The reference figure as base for creation of the decorator. |
| * @param targetSide |
| * The side where the decorator has to be created. |
| * @return The list of main decorators. |
| */ |
| protected abstract AbstractDecorator createAndRegisterDecorator(Diff diff, View referenceView, |
| IFigure referenceFigure, MergeViewerSide targetSide); |
| |
| /** |
| * Get the main decorators related to the given difference. |
| * |
| * @param difference |
| * The difference. |
| * @return The list of main decorators. |
| */ |
| protected abstract Collection<? extends AbstractDecorator> getDecorators(Diff difference); |
| |
| } |
| |
| /** |
| * Phantom manager to create, hide or reveal phantom figures related to deleted or added graphical |
| * objects. |
| * |
| * @author <a href="mailto:cedric.notot@obeo.fr">Cedric Notot</a> |
| */ |
| private class PhantomManager extends AbstractDecoratorManager { |
| |
| /** |
| * Phantom represented by a <code>figure</code> on a <code>layer</code>, from the given |
| * <code>side</code> of the merge viewer. An edit part may be linked to the <code>figure</code> in |
| * some cases.<br> |
| * The phantom is related to a <code>difference</code> and it is binded with the reference view and |
| * figure. |
| * |
| * @author <a href="mailto:cedric.notot@obeo.fr">Cedric Notot</a> |
| */ |
| private class Phantom extends AbstractDecorator { |
| |
| /** |
| * Constructor. |
| * |
| * @param layer |
| * {@link Phantom#fLayer}. |
| * @param side |
| * {@link Phantom#fSide}. |
| * @param originView |
| * {@link Phantom#fOriginView}. |
| * @param originFigure |
| * {@link Phantom#fOriginFigure}. |
| * @param diff |
| * {@link Phantom#fDifference}. |
| */ |
| Phantom(IFigure layer, MergeViewerSide side, View originView, IFigure originFigure, Diff diff) { |
| setLayer(layer); |
| setSide(side); |
| setOriginView(originView); |
| setOriginFigure(originFigure); |
| setDifference(diff); |
| } |
| |
| /** |
| * Get the decorator dependencies of this one. The dependencies are the decorator ancestors plus |
| * the extremities of an edge decorator.<br> |
| * DO NOT CALL in an iterate of {@link PhantomManager#fPhantomRegistry} |
| * |
| * @return The list of found decorators. |
| */ |
| public List<? extends AbstractDecorator> getDependencies() { |
| List<AbstractDecorator> result = new ArrayList<AbstractDecorator>(); |
| result.addAll(getAncestors()); |
| if (fOriginView instanceof Edge) { |
| View source = ((Edge)fOriginView).getSource(); |
| View target = ((Edge)fOriginView).getTarget(); |
| result.addAll(getOrCreateRelatedPhantoms(source, fSide)); |
| result.addAll(getOrCreateRelatedPhantoms(target, fSide)); |
| } |
| return result; |
| } |
| |
| /** |
| * Get the ancestor decorators of this one. |
| * |
| * @return The list of the ancestors. |
| */ |
| private List<? extends AbstractDecorator> getAncestors() { |
| List<AbstractDecorator> result = new ArrayList<AbstractDecorator>(); |
| EObject parentOriginView = fOriginView.eContainer(); |
| while (parentOriginView != null) { |
| result.addAll(getOrCreateRelatedPhantoms(parentOriginView, fSide)); |
| parentOriginView = parentOriginView.eContainer(); |
| } |
| return result; |
| } |
| } |
| |
| /** Registry of created phantoms, indexed by difference. */ |
| private final Map<Diff, Phantom> fPhantomRegistry = new HashMap<Diff, Phantom>(); |
| |
| /** Predicate witch checks that the given difference is an ADD or DELETE of a graphical object. */ |
| private Predicate<Diff> isAddOrDelete = and(instanceOf(DiagramDiff.class), |
| or(ofKind(DifferenceKind.ADD), ofKind(DifferenceKind.DELETE))); |
| |
| /** Predicate witch checks that the given difference is a HIDE or REVEAL of a graphical object. */ |
| private Predicate<Diff> isHideOrReveal = or(instanceOf(Show.class), instanceOf(Hide.class)); |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram. |
| * DiagramContentMergeViewer.AbstractDecoratorManager#goodCandidate()<br> |
| * Only the diagram differences ADD/REVEAL or DELETE/HIDE are concerned by this display. |
| */ |
| @Override |
| protected Predicate<Diff> goodCandidate() { |
| return new Predicate<Diff>() { |
| public boolean apply(Diff difference) { |
| return Predicates.or(isAddOrDelete, isHideOrReveal).apply(difference) |
| && difference.getState() == DifferenceState.UNRESOLVED; |
| } |
| }; |
| } |
| |
| /** |
| * From the given view, get or create the related phantoms in the given side. |
| * |
| * @param referenceView |
| * The given view. |
| * @param side |
| * The given side. |
| * @return The list of phantoms. |
| */ |
| private List<Phantom> getOrCreateRelatedPhantoms(EObject referenceView, MergeViewerSide side) { |
| List<Phantom> result = new ArrayList<Phantom>(); |
| Collection<Diff> changes = Collections2.filter( |
| getCompareConfiguration().getComparison().getDifferences(referenceView), goodCandidate()); |
| for (Diff change : changes) { |
| Phantom phantom = fPhantomRegistry.get(change); |
| if (phantom == null) { |
| IFigure referenceFigure = PhantomManager.this.getFigure((View)referenceView); |
| if (referenceFigure != null) { |
| phantom = createAndRegisterDecorator(change, (View)referenceView, referenceFigure, |
| side); |
| } |
| } |
| if (phantom != null) { |
| result.add(phantom); |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.AbstractDecoratorManager#getReferenceViews(org.eclipse.emf.compare.diagram.DiagramDiff) |
| */ |
| @Override |
| protected List<View> getReferenceViews(DiagramDiff difference) { |
| List<View> result = new ArrayList<View>(); |
| |
| Match match = getCompareConfiguration().getComparison().getMatch(difference.getView()); |
| |
| EObject originObj = match.getOrigin(); |
| EObject leftObj = match.getLeft(); |
| EObject rightObj = match.getRight(); |
| |
| if (leftObj instanceof View || rightObj instanceof View) { |
| View referenceView = getReferenceView((View)originObj, (View)leftObj, (View)rightObj); |
| // It may be null if it is hidden |
| if (referenceView != null) { |
| result.add(referenceView); |
| } |
| } |
| |
| return result; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram. |
| * DiagramContentMergeViewer.AbstractDecoratorManager#getTargetSide(org.eclipse.emf.compare. |
| * Match, org.eclipse.gmf.runtime.notation.View)<br> |
| * If the left object is null, a phantom should be drawn instead. Else, it means that the right |
| * object is null and a phantom should be displayed on the right side. |
| */ |
| @Override |
| protected MergeViewerSide getTargetSide(Match match, View referenceView) { |
| MergeViewerSide targetSide = null; |
| if (!isFigureExist((View)match.getLeft())) { |
| targetSide = MergeViewerSide.LEFT; |
| } else { |
| targetSide = MergeViewerSide.RIGHT; |
| } |
| return targetSide; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.AbstractDecoratorManager#createAndRegisterDecorator(org.eclipse.emf.compare.Diff, |
| * org.eclipse.gmf.runtime.notation.View, org.eclipse.draw2d.IFigure, |
| * org.eclipse.emf.compare.rcp.ui.mergeviewer.IMergeViewer.MergeViewerSide) |
| */ |
| @Override |
| protected Phantom createAndRegisterDecorator(Diff diff, View referenceView, IFigure referenceFigure, |
| MergeViewerSide targetSide) { |
| Phantom phantom = createPhantom(diff, referenceView, referenceFigure, targetSide); |
| if (phantom != null) { |
| fPhantomRegistry.put(diff, phantom); |
| } |
| return phantom; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.AbstractDecoratorManager#removeDecorators(org.eclipse.emf.compare.Diff) |
| */ |
| @Override |
| public void removeDecorators(Diff difference) { |
| fPhantomRegistry.remove(difference); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.AbstractDecoratorManager#removeAll() |
| */ |
| @Override |
| public void removeAll() { |
| fPhantomRegistry.clear(); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.AbstractDecoratorManager#getDecorators(org.eclipse.emf.compare.Diff) |
| */ |
| @Override |
| protected List<Phantom> getDecorators(Diff difference) { |
| List<Phantom> result = new ArrayList<DiagramContentMergeViewer.PhantomManager.Phantom>(); |
| Phantom phantom = fPhantomRegistry.get(difference); |
| if (phantom != null) { |
| result.add(phantom); |
| } |
| return result; |
| } |
| |
| /** |
| * {@inheritDoc}.<br> |
| * DO NOT CALL on a phantom within an iteration on the phantom registry. |
| * {@link PhantomManager#fPhantomRegistry} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.AbstractDecoratorManager#handleDecorator(org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.AbstractDecoratorManager.AbstractDecorator, |
| * boolean) |
| */ |
| @Override |
| protected void handleDecorator(AbstractDecorator decorator, boolean isAdd, boolean isMain) { |
| super.handleDecorator(decorator, isAdd, isMain); |
| // Display the dependencies (context) of this decorator |
| for (AbstractDecorator ancestor : ((Phantom)decorator).getDependencies()) { |
| super.handleDecorator(ancestor, isAdd, false); |
| } |
| } |
| |
| @Override |
| protected void handleAddDecorator(AbstractDecorator decorator, IFigure parent, IFigure toAdd, |
| boolean isMain) { |
| super.handleAddDecorator(decorator, parent, toAdd, isMain); |
| // Set the highlight of the figure |
| if (isMain) { |
| decorator.getDecoratorFigure().highlight(); |
| getViewer(decorator.getSide()).getGraphicalViewer().reveal(toAdd); |
| } else { |
| decorator.getDecoratorFigure().unhighlight(); |
| } |
| } |
| |
| /** |
| * It checks that the given view graphically exists. |
| * |
| * @param view |
| * The view. |
| * @return True if it exists. |
| */ |
| private boolean isFigureExist(View view) { |
| return view != null && view.isVisible(); |
| } |
| |
| /** |
| * Get the view which has to be used as reference to build a phantom.<br> |
| * The reference is the non null object among the given objects. In case of delete object, in the |
| * context of three-way comparison, the reference will be the ancestor one (<code>originObj</code>). |
| * |
| * @param originObj |
| * The ancestor object. |
| * @param leftView |
| * The left object. |
| * @param rightView |
| * The right object. |
| * @return The reference object. |
| */ |
| private View getReferenceView(View originObj, View leftView, View rightView) { |
| View referenceView; |
| if (isFigureExist(originObj)) { |
| referenceView = originObj; |
| } else if (isFigureExist(leftView)) { |
| referenceView = leftView; |
| } else { |
| referenceView = rightView; |
| } |
| return referenceView; |
| } |
| |
| /** |
| * It creates a new phantom from the given difference, view and figure. |
| * |
| * @param diff |
| * The related difference used as index for the main phantom. |
| * @param referenceView |
| * The reference view as base for creation of the phantom. |
| * @param referenceFigure |
| * The reference figure as base for creation of the phantom. |
| * @param side |
| * The side where the phantom has to be created. |
| * @return The phantom or null if the target layer is not found. |
| */ |
| private Phantom createPhantom(Diff diff, View referenceView, IFigure referenceFigure, |
| MergeViewerSide side) { |
| |
| IFigure targetLayer = getLayer(referenceView, side); |
| if (targetLayer != null) { |
| MergeViewerSide referenceSide = getSide(referenceView); |
| |
| Rectangle rect = referenceFigure.getBounds().getCopy(); |
| |
| IFigure referenceLayer = getLayer(referenceView, referenceSide); |
| translateCoordinates(referenceFigure, referenceLayer, rect); |
| |
| DecoratorFigure ghost = null; |
| |
| Phantom phantom = new Phantom(targetLayer, side, referenceView, referenceFigure, diff); |
| |
| // Container "list" case |
| if (isNodeList(referenceView)) { |
| |
| int index = getIndex(diff, referenceView, side); |
| |
| IFigure referenceParentFigure = referenceFigure.getParent(); |
| Rectangle referenceParentBounds = referenceParentFigure.getBounds().getCopy(); |
| translateCoordinates(referenceParentFigure, referenceLayer, referenceParentBounds); |
| |
| View parentView = (View)getMatchView(referenceView.eContainer(), side); |
| if (parentView != null) { |
| int nbElements = getVisibleViews(parentView).size(); |
| // CHECKSTYLE:OFF |
| if (index > nbElements) { |
| // CHECKSTYLE:ON |
| index = nbElements; |
| } |
| } |
| |
| // FIXME: The add of decorators modifies the physical coordinates of elements |
| // FIXME: Compute position from the y position of the first child + sum of height of the |
| // children. |
| int pos = rect.height * index + referenceParentBounds.y + 1; |
| Map<String, Object> parameters = new HashMap<String, Object>(); |
| parameters.put(NodeListFigure.PARAM_Y_POS, Integer.valueOf(pos)); |
| |
| ghost = new NodeListFigure(diff, isThreeWay(), getCompareColor(), referenceFigure, rect, |
| true, parameters); |
| |
| // Edge case |
| } else if (referenceView instanceof Edge) { |
| // If the edge phantom ties shapes where their coordinates changed |
| if (hasAnExtremityChange((Edge)referenceView, side)) { |
| EditPart edgeEditPart = createEdgeEditPart((Edge)referenceView, referenceSide, side); |
| // CHECKSTYLE:OFF |
| if (edgeEditPart instanceof GraphicalEditPart) { |
| // CHECKSTYLE:ON |
| phantom.setEditPart(edgeEditPart); |
| |
| IFigure fig = ((GraphicalEditPart)edgeEditPart).getFigure(); |
| fig.getChildren().clear(); |
| ghost = new DecoratorFigure(diff, isThreeWay(), getCompareColor(), |
| referenceFigure, fig, true); |
| |
| } |
| // Else, it creates only a polyline connection figure with the same properties as the |
| // reference |
| } else { |
| if (referenceFigure instanceof PolylineConnection) { |
| ghost = new EdgeFigure(diff, isThreeWay(), getCompareColor(), referenceFigure, |
| rect, true); |
| } |
| } |
| } |
| |
| // Default case: Nodes |
| if (ghost == null) { |
| ghost = new NodeFigure(diff, isThreeWay(), getCompareColor(), referenceFigure, rect, |
| true); |
| } |
| |
| phantom.setDecoratorFigure(ghost); |
| |
| translateWhenInsideContainerChange(phantom); |
| |
| return phantom; |
| } |
| |
| return null; |
| |
| } |
| |
| /** |
| * Get the index of the phantom to draw. |
| * |
| * @param diff |
| * The related difference used as index for the main phantom. |
| * @param referenceView |
| * The reference view to compute the phantom. |
| * @param side |
| * The side where the phantom has to be drawn. |
| * @return The index in the list where the phantom has to be drawn. |
| */ |
| private int getIndex(Diff diff, View referenceView, MergeViewerSide side) { |
| // Case for invisible objects |
| if (diff instanceof Hide || diff instanceof Show) { |
| List<Object> source = null; |
| List<Object> target = null; |
| Object newElement = null; |
| Match match = diff.getMatch(); |
| List<Object> leftList = ReferenceUtil.getAsList(match.getLeft().eContainer(), |
| NotationPackage.Literals.VIEW__PERSISTED_CHILDREN); |
| List<Object> rightList = ReferenceUtil.getAsList(match.getRight().eContainer(), |
| NotationPackage.Literals.VIEW__PERSISTED_CHILDREN); |
| if (diff instanceof Hide) { |
| source = rightList; |
| target = leftList; |
| newElement = diff.getMatch().getRight(); |
| } else { |
| source = leftList; |
| target = rightList; |
| newElement = diff.getMatch().getLeft(); |
| } |
| Iterable<Object> ignoredElements = Iterables.filter(target, new Predicate() { |
| public boolean apply(Object input) { |
| return input instanceof View && !((View)input).isVisible(); |
| } |
| }); |
| return DiffUtil.findInsertionIndex(getCompareConfiguration().getComparison(), ignoredElements, |
| source, target, newElement); |
| } |
| // Case for deleted objects |
| Diff refiningDiff = Iterators.find(diff.getRefinedBy().iterator(), and(valueIs(referenceView), |
| onFeature(NotationPackage.Literals.VIEW__PERSISTED_CHILDREN.getName()))); |
| |
| return DiffUtil.findInsertionIndex(getCompareConfiguration().getComparison(), refiningDiff, |
| side == MergeViewerSide.LEFT); |
| } |
| |
| /** |
| * Get the visible view under the given parent view. |
| * |
| * @param parent |
| * The parent view. |
| * @return The list of views. |
| */ |
| private List<View> getVisibleViews(View parent) { |
| return (List<View>)Lists |
| .newArrayList(Iterators.filter(parent.getChildren().iterator(), new Predicate<Object>() { |
| public boolean apply(Object input) { |
| return input instanceof View && ((View)input).isVisible(); |
| } |
| })); |
| } |
| |
| /** |
| * It translates and resizes the figure of the given phantom when this one is nested in a container |
| * which is subjected to a coordinates change. |
| * |
| * @param phantom |
| * The phantom. |
| */ |
| private void translateWhenInsideContainerChange(Phantom phantom) { |
| boolean isCandidate = false; |
| Diff diff = phantom.getDifference(); |
| if (diff instanceof DiagramDiff) { |
| EObject parent = ((DiagramDiff)diff).getView().eContainer(); |
| while (parent instanceof View && !isCandidate) { |
| isCandidate = Iterables.any( |
| getCompareConfiguration().getComparison().getDifferences(parent), |
| instanceOf(CoordinatesChange.class)); |
| parent = parent.eContainer(); |
| } |
| } |
| if (isCandidate) { |
| View referenceView = phantom.getOriginView(); |
| View parentReferenceView = (View)referenceView.eContainer(); |
| if (parentReferenceView != null) { |
| View parentView = (View)getMatchView(parentReferenceView, phantom.getSide()); |
| IFigure parentFigure = getFigure(parentView); |
| if (parentFigure != null) { |
| Rectangle parentRect = parentFigure.getBounds().getCopy(); |
| translateCoordinates(parentFigure, getLayer(parentReferenceView, getSide(parentView)), |
| parentRect); |
| |
| IFigure parentReferenceFigure = getFigure(parentReferenceView); |
| // CHECKSTYLE:OFF |
| if (parentReferenceFigure != null) { |
| Rectangle parentReferenceRect = parentReferenceFigure.getBounds().getCopy(); |
| translateCoordinates(parentReferenceFigure, |
| getLayer(parentReferenceView, getSide(parentReferenceView)), |
| parentReferenceRect); |
| |
| int deltaX = parentRect.x - parentReferenceRect.x; |
| int deltaY = parentRect.y - parentReferenceRect.y; |
| int deltaWidth = parentRect.width - parentReferenceRect.width; |
| int deltaHeight = parentRect.height - parentReferenceRect.height; |
| |
| IFigure figure = phantom.getFigure(); |
| |
| Rectangle rect = figure.getBounds().getCopy(); |
| rect.x += deltaX; |
| rect.y += deltaY; |
| rect.width += deltaWidth; |
| if (!(figure instanceof Polyline)) { |
| rect.height += deltaHeight; |
| } |
| figure.setBounds(rect); |
| |
| if (figure instanceof Polyline) { |
| |
| Point firstPoint = ((Polyline)figure).getPoints().getFirstPoint().getCopy(); |
| Point lastPoint = ((Polyline)figure).getPoints().getLastPoint().getCopy(); |
| |
| firstPoint.x += deltaX; |
| firstPoint.y += deltaY; |
| |
| lastPoint.x += deltaX + deltaWidth; |
| lastPoint.y += deltaY; |
| |
| ((Polyline)figure).setEndpoints(firstPoint, lastPoint); |
| |
| } |
| } |
| // CHECKSTYLE:ON |
| } |
| } |
| } |
| } |
| |
| /** |
| * It checks that the given edge is linked to graphical objects subjected to coordinate changes, on |
| * the given side. |
| * |
| * @param edge |
| * The edge to check. |
| * @param targetSide |
| * The side to check extremities (side of the phantom). |
| * @return True if an extremity at least changed its location, False otherwise. |
| */ |
| private boolean hasAnExtremityChange(Edge edge, MergeViewerSide targetSide) { |
| View referenceSource = edge.getSource(); |
| View referenceTarget = edge.getTarget(); |
| return hasChange(referenceSource, targetSide) || hasChange(referenceTarget, targetSide); |
| } |
| |
| /** |
| * It checks that the coordinates of the given view changed between left and right, from the given |
| * side. |
| * |
| * @param referenceView |
| * The view to check. |
| * @param targetSide |
| * The side to focus. |
| * @return True if the view changed its location, False otherwise. |
| */ |
| private boolean hasChange(View referenceView, MergeViewerSide targetSide) { |
| View extremity = (View)getMatchView(referenceView, targetSide); |
| // Look for a related change coordinates on the extremity of the edge reference. |
| Collection<Diff> diffs = Collections2.filter( |
| getCompareConfiguration().getComparison().getDifferences(referenceView), |
| instanceOf(CoordinatesChange.class)); |
| if (diffs.isEmpty()) { |
| // Look for a related change coordinates on the matching extremity (other side) of the edge |
| // reference. |
| diffs = Collections2.filter( |
| getCompareConfiguration().getComparison().getDifferences(extremity), |
| instanceOf(CoordinatesChange.class)); |
| } |
| return !diffs.isEmpty(); |
| } |
| |
| /** |
| * It creates and returns a new edit part from the given edge. This edit part listens to the reference |
| * edge but is attached to the controllers of the target (phantom) side. |
| * |
| * @param referenceEdge |
| * The edge as base of the edit part. |
| * @param referenceSide |
| * The side of this edge. |
| * @param targetSide |
| * The side where the edit part has to be created to draw the related phantom. |
| * @return The new edit part. |
| */ |
| private EditPart createEdgeEditPart(Edge referenceEdge, MergeViewerSide referenceSide, |
| MergeViewerSide targetSide) { |
| EditPart edgeEditPartReference = getViewer(referenceSide).getEditPart(referenceEdge); |
| EditPart edgeEditPart = null; |
| if (edgeEditPartReference instanceof ConnectionEditPart) { |
| |
| edgeEditPart = getOrCreatePhantomEditPart(referenceEdge, referenceSide, targetSide); |
| |
| if (edgeEditPart instanceof ConnectionEditPart) { |
| EditPart edgeSourceEp = getOrCreateExtremityPhantomEditPart( |
| ((ConnectionEditPart)edgeEditPartReference).getSource(), referenceSide, |
| targetSide); |
| |
| ((ConnectionEditPart)edgeEditPart).setSource(edgeSourceEp); |
| |
| EditPart edgeTargetEp = getOrCreateExtremityPhantomEditPart( |
| ((ConnectionEditPart)edgeEditPartReference).getTarget(), referenceSide, |
| targetSide); |
| |
| ((ConnectionEditPart)edgeEditPart).setTarget(edgeTargetEp); |
| } |
| } |
| return edgeEditPart; |
| } |
| |
| /** |
| * From the given edit part, it retrieves the matched one, from the given target side. If the |
| * retrieved edit part is not linked to a GMF object, in the target side, a phantom GEF edit part is |
| * returned which will locate a rectangle invisible figure in the same location as the related |
| * phantom. |
| * |
| * @param referenceEdgeExtremityEp |
| * The reference edit part for one of the extremities of an edge. |
| * @param referenceSide |
| * The side of the reference. |
| * @param targetSide |
| * The other side, where the phantom has to be drawn. |
| * @return The phantom edit part used to attach the extremity of an edge phantom. |
| */ |
| private EditPart getOrCreateExtremityPhantomEditPart(EditPart referenceEdgeExtremityEp, |
| MergeViewerSide referenceSide, MergeViewerSide targetSide) { |
| View referenceExtremityView = (View)referenceEdgeExtremityEp.getModel(); |
| |
| EditPart edgeExtremityEp = getOrCreatePhantomEditPart(referenceExtremityView, referenceSide, |
| targetSide); |
| |
| if (isPhantomEditPart((AbstractGraphicalEditPart)edgeExtremityEp)) { |
| |
| final AbstractGraphicalEditPart edgeExtremityEpParent = (AbstractGraphicalEditPart)edgeExtremityEp |
| .getParent(); |
| |
| List<Phantom> phantoms = getOrCreateRelatedPhantoms(referenceExtremityView, targetSide); |
| if (!phantoms.isEmpty()) { |
| Phantom phantomToTarget = phantoms.get(0); |
| final IFigure figureToTarget = phantomToTarget.getFigure(); |
| |
| edgeExtremityEp = new org.eclipse.gmf.runtime.diagram.ui.editparts.GraphicalEditPart( |
| referenceExtremityView) { |
| @Override |
| protected void createDefaultEditPolicies() { |
| } |
| |
| @Override |
| protected IFigure createFigure() { |
| RectangleFigure fig = new RectangleFigure(); |
| fig.setBounds(figureToTarget.getBounds()); |
| fig.setParent(edgeExtremityEpParent.getFigure()); |
| return fig; |
| } |
| }; |
| |
| edgeExtremityEp.setParent(edgeExtremityEpParent); |
| } |
| |
| ((AbstractGraphicalEditPart)edgeExtremityEp).activate(); |
| ((AbstractGraphicalEditPart)edgeExtremityEp).getFigure(); |
| } |
| |
| return edgeExtremityEp; |
| } |
| |
| /** |
| * It checks if the given edit part is related to a phantom edit part (created for nothing, without |
| * link to a GMF object in the target side). |
| * |
| * @param editPart |
| * The edit part to check. |
| * @return True if it is a phantom edit part, false otherwise. |
| */ |
| private boolean isPhantomEditPart(AbstractGraphicalEditPart editPart) { |
| Rectangle targetBounds = editPart.getFigure().getBounds(); |
| return targetBounds.x == 0 && targetBounds.y == 0 && targetBounds.width == 0 |
| && targetBounds.height == 0; |
| } |
| |
| /** |
| * It creates and returns a new edit part from the given view. This edit part listens the reference |
| * view but is attached to the controllers of the target (phantom) side. |
| * |
| * @param referenceView |
| * The view as base of the edit part. |
| * @param referenceSide |
| * The side of this view. |
| * @param targetSide |
| * The side where the edit part has to be created to draw the related phantom. |
| * @return The new edit part. |
| */ |
| private EditPart getOrCreatePhantomEditPart(EObject referenceView, MergeViewerSide referenceSide, |
| MergeViewerSide targetSide) { |
| EditPart editPartParent = null; |
| EditPart editPart = null; |
| EditPart editPartReference = getViewer(referenceSide).getEditPart(referenceView); |
| EditPart editPartReferenceParent = editPartReference.getParent(); |
| Object referenceViewParent = editPartReferenceParent.getModel(); |
| if (!(referenceViewParent instanceof EObject)) { |
| referenceViewParent = referenceView.eContainer(); |
| } |
| View viewParent = (View)getMatchView((EObject)referenceViewParent, targetSide); |
| if (viewParent != null) { |
| editPartParent = getViewer(targetSide).getEditPart(viewParent); |
| } |
| if (editPartParent == null) { |
| editPartParent = getOrCreatePhantomEditPart((EObject)referenceViewParent, referenceSide, |
| targetSide); |
| |
| } |
| if (editPartParent != null) { |
| View view = (View)getMatchView(referenceView, targetSide); |
| if (view != null) { |
| editPart = getViewer(targetSide).getEditPart(view); |
| } |
| if (editPart == null) { |
| |
| editPart = getViewer(targetSide).getGraphicalViewer().getEditPartFactory() |
| .createEditPart(editPartParent, referenceView); |
| editPart.setParent(editPartParent); |
| getViewer(targetSide).getGraphicalViewer().getEditPartRegistry().put(referenceView, |
| editPart); |
| |
| } |
| |
| } |
| return editPart; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.IDecoratorManager#hideAll() |
| */ |
| public void hideAll() { |
| for (Phantom phantom : fPhantomRegistry.values()) { |
| handleDeleteDecorator(phantom, phantom.getLayer(), phantom.getFigure()); |
| } |
| } |
| } |
| |
| /** |
| * Marker manager to create, hide or reveal marker figures related to deleted or added graphical objects. |
| * |
| * @author <a href="mailto:cedric.notot@obeo.fr">Cedric Notot</a> |
| */ |
| private class MarkerManager extends AbstractDecoratorManager { |
| |
| /** |
| * Marker represented by a <code>figure</code> on a <code>layer</code>, from the given |
| * <code>side</code> of the merge viewer. An edit part may be linked to the <code>figure</code> in |
| * some cases.<br> |
| * The marker is related to a <code>difference</code> and it is binded with the reference view and |
| * figure. |
| * |
| * @author <a href="mailto:cedric.notot@obeo.fr">Cedric Notot</a> |
| */ |
| private class Marker extends AbstractDecorator { |
| |
| /** |
| * Constructor. |
| * |
| * @param layer |
| * {@link Marker#fLayer}. |
| * @param side |
| * {@link Marker#fSide}. |
| * @param originView |
| * {@link Marker#fOriginView}. |
| * @param originFigure |
| * {@link Marker#fOriginFigure}. |
| * @param diff |
| * {@link Marker#fDifference}. |
| */ |
| Marker(IFigure layer, MergeViewerSide side, View originView, IFigure originFigure, Diff diff) { |
| setLayer(layer); |
| setSide(side); |
| setOriginView(originView); |
| setOriginFigure(originFigure); |
| setDifference(diff); |
| } |
| } |
| |
| /** Registry of created markers, indexed by difference. */ |
| private Multimap<Diff, Marker> fMarkerRegistry = HashMultimap.create(); |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.AbstractDecoratorManager#getReferenceViews(org.eclipse.emf.compare.diagram.DiagramDiff) |
| */ |
| @Override |
| protected List<View> getReferenceViews(DiagramDiff difference) { |
| List<View> result = new ArrayList<View>(); |
| Match matchValue = getCompareConfiguration().getComparison().getMatch(difference.getView()); |
| if (matchValue != null) { |
| if (matchValue.getLeft() != null) { |
| result.add((View)matchValue.getLeft()); |
| } |
| if (matchValue.getRight() != null) { |
| result.add((View)matchValue.getRight()); |
| } |
| if (getCompareConfiguration().getComparison().isThreeWay()) { |
| switch (difference.getKind()) { |
| case DELETE: |
| case CHANGE: |
| case MOVE: |
| result.add((View)matchValue.getOrigin()); |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.AbstractDecoratorManager#getTargetSide(org.eclipse.emf.compare.Match, |
| * org.eclipse.gmf.runtime.notation.View) |
| */ |
| @Override |
| protected MergeViewerSide getTargetSide(Match match, View referenceView) { |
| return getSide(referenceView); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.AbstractDecoratorManager#createAndRegisterDecorator(org.eclipse.emf.compare.Diff, |
| * org.eclipse.gmf.runtime.notation.View, org.eclipse.draw2d.IFigure, |
| * org.eclipse.emf.compare.rcp.ui.mergeviewer.IMergeViewer.MergeViewerSide) |
| */ |
| @Override |
| protected Marker createAndRegisterDecorator(Diff diff, View referenceView, IFigure referenceFigure, |
| MergeViewerSide targetSide) { |
| Marker marker = createMarker(diff, referenceView, referenceFigure, targetSide); |
| if (marker != null) { |
| fMarkerRegistry.put(diff, marker); |
| } |
| return marker; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.AbstractDecoratorManager#removeDecorators(org.eclipse.emf.compare.Diff) |
| */ |
| @Override |
| public void removeDecorators(Diff difference) { |
| fMarkerRegistry.removeAll(difference); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.AbstractDecoratorManager#removeAll() |
| */ |
| @Override |
| public void removeAll() { |
| fMarkerRegistry.clear(); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.AbstractDecoratorManager#getDecorators(org.eclipse.emf.compare.Diff) |
| */ |
| @Override |
| protected Collection<Marker> getDecorators(Diff difference) { |
| return fMarkerRegistry.get(difference); |
| } |
| |
| @Override |
| protected void handleAddDecorator(AbstractDecorator decorator, IFigure parent, IFigure toAdd, |
| boolean isMain) { |
| super.handleAddDecorator(decorator, parent, toAdd, isMain); |
| DiagramMergeViewer viewer = getViewer(decorator.getSide()); |
| EditPart editPart = viewer.getEditPart(decorator.getOriginView()); |
| if (editPart != null) { |
| viewer.getGraphicalViewer().reveal(editPart); |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram. |
| * DiagramContentMergeViewer.AbstractDecoratorManager#goodCandidate()<br> |
| * All graphical differences are concerned. |
| */ |
| @Override |
| protected Predicate<Diff> goodCandidate() { |
| return new Predicate<Diff>() { |
| public boolean apply(Diff difference) { |
| return instanceOf(DiagramDiff.class).apply(difference); |
| } |
| }; |
| } |
| |
| /** |
| * It creates a new marker from the given difference, view and figure. |
| * |
| * @param diff |
| * The related difference used as index for the main marker. |
| * @param referenceView |
| * The reference view as base for creation of the marker. |
| * @param referenceFigure |
| * The reference figure as base for creation of the marker. |
| * @param side |
| * The side where the marker has to be created. |
| * @return The phantom or null if the target layer is not found. |
| */ |
| private Marker createMarker(Diff diff, View referenceView, IFigure referenceFigure, |
| MergeViewerSide side) { |
| |
| IFigure referenceLayer = getLayer(referenceView, side); |
| if (referenceLayer != null) { |
| Rectangle referenceBounds = referenceFigure.getBounds().getCopy(); |
| translateCoordinates(referenceFigure, referenceLayer, referenceBounds); |
| |
| DecoratorFigure markerFigure = null; |
| |
| Marker marker = new Marker(referenceLayer, side, referenceView, referenceFigure, diff); |
| |
| if (isNodeList(referenceView)) { |
| markerFigure = new NodeListFigure(diff, isThreeWay(), getCompareColor(), referenceFigure, |
| referenceBounds, false); |
| } else if (referenceView instanceof Edge && referenceFigure instanceof PolylineConnection) { |
| markerFigure = new EdgeFigure(diff, isThreeWay(), getCompareColor(), referenceFigure, |
| referenceBounds, false); |
| } |
| |
| // Default case: Nodes |
| if (markerFigure == null) { |
| markerFigure = new NodeFigure(diff, isThreeWay(), getCompareColor(), referenceFigure, |
| referenceBounds, false); |
| } |
| |
| marker.setDecoratorFigure(markerFigure); |
| return marker; |
| } |
| |
| return null; |
| |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.IDecoratorManager#hideAll() |
| */ |
| public void hideAll() { |
| for (Marker marker : fMarkerRegistry.values()) { |
| handleDeleteDecorator(marker, marker.getLayer(), marker.getFigure()); |
| } |
| } |
| |
| } |
| |
| /** |
| * Decorator manager to create, hide or reveal all decorator figures related to graphical changes. |
| * |
| * @author <a href="mailto:cedric.notot@obeo.fr">Cedric Notot</a> |
| */ |
| private class DecoratorsManager implements IDecoratorManager { |
| /** Phantoms manager. */ |
| private IDecoratorManager fPhantomManager = new PhantomManager(); |
| |
| /** Markers manager. */ |
| private IDecoratorManager fMarkerManager = new MarkerManager(); |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.IDecoratorManager#hideDecorators(org.eclipse.emf.compare.Diff) |
| */ |
| public void hideDecorators(Diff difference) { |
| fMarkerManager.hideDecorators(difference); |
| fPhantomManager.hideDecorators(difference); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.IDecoratorManager#revealDecorators(org.eclipse.emf.compare.Diff) |
| */ |
| public void revealDecorators(Diff difference) { |
| fMarkerManager.revealDecorators(difference); |
| fPhantomManager.revealDecorators(difference); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.IDecoratorManager#hideAll() |
| */ |
| public void hideAll() { |
| fMarkerManager.hideAll(); |
| fPhantomManager.hideAll(); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.IDecoratorManager#removeDecorators(org.eclipse.emf.compare.Diff) |
| */ |
| public void removeDecorators(Diff difference) { |
| fMarkerManager.removeDecorators(difference); |
| fPhantomManager.removeDecorators(difference); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.diagram.DiagramContentMergeViewer.IDecoratorManager#removeAll() |
| */ |
| public void removeAll() { |
| fMarkerManager.removeAll(); |
| fPhantomManager.removeAll(); |
| } |
| |
| } |
| |
| /** |
| * Bundle name of the property file containing all displayed strings. |
| */ |
| private static final String BUNDLE_NAME = DiagramContentMergeViewer.class.getName(); |
| |
| /** The phantom manager to use in the context of this viewer. */ |
| private final DecoratorsManager fDecoratorsManager = new DecoratorsManager(); |
| |
| /** The current "opened" difference. */ |
| private Diff fCurrentSelectedDiff; |
| |
| /** |
| * Creates a new {@link DiagramContentMergeViewer} by calling the super constructor with the given |
| * parameters. |
| * <p> |
| * It calls {@link #buildControl(Composite)} as stated in its javadoc. |
| * <p> |
| * {@link #setContentProvider(org.eclipse.jface.viewers.IContentProvider) content provider} to properly |
| * display ancestor, left and right parts. |
| * |
| * @param parent |
| * the parent composite to build the UI in |
| * @param config |
| * the {@link EMFCompareConfiguration} |
| */ |
| public DiagramContentMergeViewer(Composite parent, EMFCompareConfiguration config) { |
| super(SWT.NONE, ResourceBundle.getBundle(BUNDLE_NAME), config); |
| buildControl(parent); |
| setContentProvider(new TreeContentMergeViewerContentProvider(config)); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.EMFCompareContentMergeViewer#getAncestorMergeViewer() |
| */ |
| @SuppressWarnings("unchecked") |
| // see createMergeViewer() to see it is safe |
| @Override |
| public DiagramMergeViewer getAncestorMergeViewer() { |
| return (DiagramMergeViewer)super.getAncestorMergeViewer(); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.EMFCompareContentMergeViewer#getLeftMergeViewer() |
| */ |
| @SuppressWarnings("unchecked") |
| // see createMergeViewer() to see it is safe |
| @Override |
| public DiagramMergeViewer getLeftMergeViewer() { |
| return (DiagramMergeViewer)super.getLeftMergeViewer(); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.EMFCompareContentMergeViewer#getRightMergeViewer() |
| */ |
| @SuppressWarnings("unchecked") |
| // see createMergeViewer() to see it is safe |
| @Override |
| public DiagramMergeViewer getRightMergeViewer() { |
| return (DiagramMergeViewer)super.getRightMergeViewer(); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.compare.contentmergeviewer.ContentMergeViewer#getContents(boolean) |
| */ |
| @Override |
| protected byte[] getContents(boolean left) { |
| return null; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.DiagramCompareContentMergeViewer#createMergeViewer(org.eclipse.swt.widgets.Composite, |
| * org.eclipse.emf.compare.rcp.ui.mergeviewer.IMergeViewer.MergeViewerSide) |
| */ |
| @Override |
| protected IMergeViewer createMergeViewer(Composite parent, MergeViewerSide side) { |
| final DiagramMergeViewer diagramMergeViewer = new DiagramMergeViewer(parent, side, |
| getCompareConfiguration()); |
| return diagramMergeViewer; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.DiagramCompareContentMergeViewer#paintCenter(org.eclipse.swt.graphics.GC) |
| */ |
| @Override |
| protected void paintCenter(GC g) { |
| |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.diagram.ide.ui.internal.contentmergeviewer.DiagramCompareContentMergeViewer#updateContent(java.lang.Object, |
| * java.lang.Object, java.lang.Object) |
| */ |
| @Override |
| protected void updateContent(Object ancestor, Object left, Object right) { |
| |
| // Delete decorators at each selection of a difference (force the computation) |
| fDecoratorsManager.hideAll(); |
| fDecoratorsManager.removeAll(); |
| |
| super.updateContent(ancestor, left, right); |
| |
| getLeftMergeViewer().getGraphicalViewer().flush(); |
| getRightMergeViewer().getGraphicalViewer().flush(); |
| getAncestorMergeViewer().getGraphicalViewer().flush(); |
| |
| if (left instanceof IDiagramNodeAccessor) { |
| // Compute and display the decorators related to the selected difference (if not merged and |
| // different from the current one) |
| if (left instanceof IDiagramDiffAccessor) { |
| IDiagramDiffAccessor input = (IDiagramDiffAccessor)left; |
| |
| Diff diff = input.getDiff(); // equivalent to getInput().getTarget() |
| |
| if (!isInTerminalState(diff) && diff != fCurrentSelectedDiff) { |
| fDecoratorsManager.revealDecorators(diff); |
| } |
| |
| fCurrentSelectedDiff = diff; |
| } else { |
| fCurrentSelectedDiff = null; |
| } |
| } |
| |
| updateToolItems(); |
| |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.EMFCompareContentMergeViewer#commandStackChanged(java.util.EventObject) |
| */ |
| @Override |
| public void commandStackChanged(EventObject event) { |
| super.commandStackChanged(event); |
| |
| // Delete decorators at each change of the input models (after merging or CTRL-Z, CTRL-Y) |
| Object source = event.getSource(); |
| if (source instanceof CommandStack) { |
| Command command = ((CommandStack)source).getMostRecentCommand(); |
| if (command instanceof CopyCommand) { |
| Iterator<DiagramDiff> diffs = Iterators.filter(command.getAffectedObjects().iterator(), |
| DiagramDiff.class); |
| if (diffs.hasNext()) { |
| // force the computation for the next decorator reveal. |
| fDecoratorsManager.hideAll(); |
| fDecoratorsManager.removeAll(); |
| } |
| } |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.EMFCompareContentMergeViewer#getDiffFrom(org.eclipse.emf.compare.rcp.ui.mergeviewer.IMergeViewer) |
| */ |
| @Override |
| protected Diff getDiffFrom(IMergeViewer viewer) { |
| return fCurrentSelectedDiff; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.compare.ide.ui.internal.contentmergeviewer.EMFCompareContentMergeViewer#createControls(org.eclipse.swt.widgets.Composite) |
| */ |
| @Override |
| protected void createControls(Composite composite) { |
| super.createControls(composite); |
| getAncestorMergeViewer().removeSelectionChangedListener(this); |
| getLeftMergeViewer().removeSelectionChangedListener(this); |
| getRightMergeViewer().removeSelectionChangedListener(this); |
| } |
| |
| /** |
| * Utility method to retrieve the {@link DiagramMergeViewer} from the given side. |
| * |
| * @param side |
| * The side to focus. |
| * @return The viewer. |
| */ |
| private DiagramMergeViewer getViewer(MergeViewerSide side) { |
| DiagramMergeViewer result = null; |
| switch (side) { |
| case LEFT: |
| result = getLeftMergeViewer(); |
| break; |
| case RIGHT: |
| result = getRightMergeViewer(); |
| break; |
| case ANCESTOR: |
| result = getAncestorMergeViewer(); |
| break; |
| default: |
| } |
| return result; |
| } |
| |
| /** |
| * Utility method to know the side where is located the given view. |
| * |
| * @param view |
| * The view. |
| * @return The side of the view. |
| */ |
| private MergeViewerSide getSide(View view) { |
| MergeViewerSide result = null; |
| Match match = getCompareConfiguration().getComparison().getMatch(view); |
| if (match.getLeft() == view) { |
| result = MergeViewerSide.LEFT; |
| } else if (match.getRight() == view) { |
| result = MergeViewerSide.RIGHT; |
| } else if (match.getOrigin() == view) { |
| result = MergeViewerSide.ANCESTOR; |
| } |
| return result; |
| } |
| |
| /** |
| * Utility method to get the object matching with the given one, to the given side. |
| * |
| * @param object |
| * The object as base of the lookup. |
| * @param side |
| * The side where the potential matching object has to be retrieved. |
| * @return The matching object. |
| */ |
| private EObject getMatchView(EObject object, MergeViewerSide side) { |
| Match match = getCompareConfiguration().getComparison().getMatch(object); |
| return getMatchView(match, side); |
| } |
| |
| /** |
| * Utility method to get the object in the given side from the given match. |
| * |
| * @param match |
| * The match. |
| * @param side |
| * The side where the potential matching object has to be retrieved. |
| * @return The matching object. |
| */ |
| private EObject getMatchView(Match match, MergeViewerSide side) { |
| EObject result = null; |
| switch (side) { |
| case LEFT: |
| result = match.getLeft(); |
| break; |
| case RIGHT: |
| result = match.getRight(); |
| break; |
| case ANCESTOR: |
| result = match.getOrigin(); |
| break; |
| default: |
| } |
| return result; |
| } |
| |
| } |
