org.eclipse.compare.structuremergeviewer.DiffNode Java Examples

@Override
protected Object prepareInput(IProgressMonitor pm) {
	try {
		ResourceNode ancestor = new ResourceNode(file);
		String ancestorContent = getContent(ancestor);
		String leftContent, rightContent;

		leftContent = this.comparisonFailure.getExpected();
		rightContent = this.comparisonFailure.getActual();
		if (!leftContent.equals(ancestorContent))
			getCompareConfiguration().setProperty(ICompareUIConstants.PROP_ANCESTOR_VISIBLE, Boolean.TRUE);
		CompareItem left = new EditableCompareItem("Left", leftContent, file);
		CompareItem right = new CompareItem("Right", rightContent);
		return new DiffNode(null, Differencer.CHANGE | Differencer.DIRECTION_MASK, ancestor, left, right);
	} catch (Throwable t) {
		LOG.error(t.getMessage(), t);
		Exceptions.throwUncheckedException(t);
		return null;
	}
}
 

private Control createPreviewer(Composite parent) {
	final CompareConfiguration compareConfiguration = new CompareConfiguration();
	compareConfiguration.setLeftLabel("Original " + docTypeName);
	compareConfiguration.setLeftEditable(false);
	compareConfiguration.setRightLabel("Updated " + docTypeName);
	compareConfiguration.setRightEditable(false);
	compareConfiguration.setProperty(CompareConfiguration.IGNORE_WHITESPACE, Boolean.FALSE);
	compareConfiguration.setProperty(PREFIX_SUFFIX_PROPERTY, fPrefixSuffix);

	fViewer = new TextMergeViewer(parent, SWT.NONE, compareConfiguration);
	// add initial input in order to avoid problems when disposing the viewer later:
	fViewer.setInput(new DiffNode(new TargetElementFromString(""), new TargetElementFromString("")));

	Control control = fViewer.getControl();
	control.addDisposeListener(new DisposeListener() {
		@Override
		public void widgetDisposed(DisposeEvent e) {
			compareConfiguration.dispose();
		}
	});
	return control;
}
 

private static void commit(IProgressMonitor pm, DiffNode node) throws CoreException {
	ITypedElement left= node.getLeft();
	if (left instanceof BufferedResourceNode)
		((BufferedResourceNode) left).commit(pm);
		
	ITypedElement right= node.getRight();
	if (right instanceof BufferedResourceNode)
		((BufferedResourceNode) right).commit(pm);

	IDiffElement[] children= node.getChildren();
	if (children != null) {
		for (int i= 0; i < children.length; i++) {
			IDiffElement element= children[i];
			if (element instanceof DiffNode)
				commit(pm, (DiffNode) element);
		}
	}
}
 

private static void commit(IProgressMonitor pm, DiffNode node) throws CoreException {
	ITypedElement left= node.getLeft();
	if (left instanceof BufferedResourceNode)
		((BufferedResourceNode) left).commit(pm);
		
	ITypedElement right= node.getRight();
	if (right instanceof BufferedResourceNode)
		((BufferedResourceNode) right).commit(pm);

	IDiffElement[] children= node.getChildren();
	if (children != null) {
		for (int i= 0; i < children.length; i++) {
			IDiffElement element= children[i];
			if (element instanceof DiffNode)
				commit(pm, (DiffNode) element);
		}
	}
}
 

/**
    * Runs the compare operation and returns the compare result.
    */
protected Object prepareInput(IProgressMonitor monitor){
	initLabels();
	DiffNode diffRoot = new DiffNode(Differencer.NO_CHANGE);
	String localCharset = Utilities.getCharset(resource);
	for (int i = 0; i < logEntries.length; i++) {		
		ITypedElement left = new TypedBufferedContent(resource);
		ResourceRevisionNode right = new ResourceRevisionNode(logEntries[i]);
		try {
			right.setCharset(localCharset);
		} catch (CoreException e) {
		}
		diffRoot.add(new VersionCompareDiffNode(left, right));
	}
	return diffRoot;		
}
 

private DiffNode buildPathNodes(final EObject container, final DiffNode node) {
    final DiffNode parentNode = new DiffNode(Differencer.NO_CHANGE);
    node.setParent(parentNode);
    parentNode.add(node);
    final EObjectNode ancestor = new EObjectNode(container, adapterFactoryLabelProvider);
    parentNode.setAncestor(ancestor);
    if (insertParentNode(parentNode)) {
        return parentNode;
    }
    if (container instanceof Pool) {
        return parentNode;
    }
    if (container instanceof ConnectorParameter) {
        return buildPathNodes(container.eContainer().eContainer(), parentNode);
    }
    return buildPathNodes(container.eContainer(), parentNode);
}
 

private static void commit(IProgressMonitor pm, DiffNode node) throws CoreException {
	ITypedElement left= node.getLeft();
	if (left instanceof BufferedResourceNode)
		((BufferedResourceNode) left).commit(pm);
		
	ITypedElement right= node.getRight();
	if (right instanceof BufferedResourceNode)
		((BufferedResourceNode) right).commit(pm);

	IDiffElement[] children= node.getChildren();
	if (children != null) {
		for (int i= 0; i < children.length; i++) {
			IDiffElement element= children[i];
			if (element instanceof DiffNode)
				commit(pm, (DiffNode) element);
		}
	}
}
 

public void buildTree() {
    for (final ScriptContainer<?> script : scripts) {
        final LeftCompareScript left = new LeftCompareScript(script, adapterFactoryLabelProvider);
        final RightCompareScript right = new RightCompareScript(script, adapterFactoryLabelProvider);
        right.addContentChangeListener(new IContentChangeListener() {

            @Override
            public void contentChanged(final IContentChangeNotifier compareScript) {
                if (compareScript instanceof RightCompareScript) {
                    setDirty(true);
                    if (getViewer() == null || getViewer().getControl().isDisposed()) {
                        return;
                    }
                    getViewer().refresh(true);
                }
            }
        });
        final DiffNode leaf = new DiffNode(null, Differencer.CHANGE, null, left, right);
        final EObject eContainer = script.getModelElement().eContainer();
        Preconditions.checkState(eContainer != null);
        final DiffNode poolNode = buildPathNodes(eContainer, leaf);
        if (((EObjectNode) poolNode.getAncestor()).getElement() instanceof Pool && root.getChildren().length == 0) {
            root.add(poolNode);
        }
    }
}
 

@Override
public Viewer createDiffViewer(final Composite parent) {
    viewer = new DiffTreeViewer(parent, getCompareConfiguration());
    viewer.addOpenListener(new IOpenListener() {

        @Override
        public void open(final OpenEvent event) {
            final IStructuredSelection sel = (IStructuredSelection) event.getSelection();
            final DiffNode obj = (DiffNode) sel.getFirstElement();
            obj.setDontExpand(false);
        }
    });
    viewer.setFilters(getFilters());
    viewer.setLabelProvider(new DiffTreeLabelProvider());
    viewer.setContentProvider(new BonitaScriptRefactoringContentProvider());
    viewer.setInput(root);
    viewer.expandAll();

    return viewer;
}
 

@Override
public void update(ViewerCell cell) {
	StyledString styledString = new StyledString();
	
	DiffNode node = (DiffNode)cell.getElement();
	if (node.getLeft()!=null){
		styledString.append(getText(cell.getElement()),boldgreen);
	} else {
		styledString.append(getText(cell.getElement()));
	}
	cell.setText(styledString.getString());
	cell.setImage(getImage(cell.getElement())) ;
	cell.setStyleRanges(styledString.getStyleRanges());
	
}
 

@Override
protected Object prepareInput(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
	CompareConfiguration configuration = getCompareConfiguration();
	configuration.setLeftLabel(this.left.getName());
	configuration.setRightLabel(this.right.getName());
	return new DiffNode(null, Differencer.CHANGE, null, this.left, this.right);
}
 

@Override
public String getText(Object element) {
	if (element instanceof DiffNode){
		DiffNode node = ((DiffNode)element);
		if (node.getLeft()!=null){
			return node.getName();
		} else {
			return node.getAncestor().getName();
		}
	}
	return null;
}
 

@Override
public Image getImage(Object element) {
	if (element instanceof DiffNode){
		DiffNode node = ((DiffNode)element);
		if (node.getLeft()!=null){
			return node.getImage();
		} else {
			return node.getAncestor().getImage();
		}
	}
	return null;
}
 

private boolean insertParentNode(final DiffNode nodeToInsert) {
    final List<DiffNode> nodes = new ArrayList<DiffNode>();
    getAllNodes(nodes, root);
    for (final DiffNode node : nodes) {
        if (node.getAncestor() != null
                && ((EObjectNode) node.getAncestor()).getElement()
                        .equals(((EObjectNode) nodeToInsert.getAncestor()).getElement())) {
            addChildrenToParent(node, nodeToInsert.getChildren());
            return true;
        }
    }
    return false;
}
 

private void getAllNodes(final List<DiffNode> nodes, final DiffNode root) {
    if (root.hasChildren()) {
        nodes.addAll((Collection<? extends DiffNode>) Arrays.asList(root.getChildren()));
        for (final IDiffElement child : root.getChildren()) {
            getAllNodes(nodes, (DiffNode) child);
        }
    }

}
 

@Override
public Object[] getChildren(Object parentElement) {
    if (((DiffNode) parentElement).hasChildren()) {
        return ((DiffNode) parentElement).getChildren();
    }
    return null;
}
 

@Override
public Object[] getElements(Object inputElement) {
    if (inputElement instanceof DiffNode) {
        return ((DiffNode) inputElement).getChildren();
    }
    return null;
}
 

@Override
protected Object prepareInput(IProgressMonitor pm) {
	CompareItem firstText = new CompareItem("First", this.left);
	CompareItem secondText = new CompareItem("Second", this.right);
	
	return new DiffNode(firstText, secondText);
}
 

/**
 * Overridden to find and expand the first class.
 */
@Override
protected void initialSelection() {
	Object firstClass= null;
	Object o= getRoot();
	if (o != null) {
		Object[] children= getSortedChildren(o);
		if (children != null && children.length > 0) {
			for (int i= 0; i < children.length; i++) {
				o= children[i];
				Object[] sortedChildren= getSortedChildren(o);
				if (sortedChildren != null && sortedChildren.length > 0) {
					for (int j= 0; j < sortedChildren.length; j++) {
						o= sortedChildren[j];
						if (o instanceof DiffNode) {
							DiffNode dn= (DiffNode) o;
							ITypedElement e= dn.getId();
							if (e instanceof JavaNode) {
								JavaNode jn= (JavaNode) e;
								int tc= jn.getTypeCode();
								if (tc == JavaNode.CLASS || tc == JavaNode.INTERFACE) {
									firstClass= dn;
								}
							}
						}
					}
				}
			}
		}
	}
	if (firstClass != null)
		expandToLevel(firstClass, 1);
	else
		expandToLevel(2);
}
 

public void saveChanges(IProgressMonitor pm) throws CoreException {
	super.saveChanges(pm);
	if (fRoot instanceof DiffNode) {
		try {
			commit(pm, (DiffNode) fRoot);
		} finally {		
			setDirty(false);
		}
	}
}
 

public void saveChanges(IProgressMonitor pm) throws CoreException {
	super.saveChanges(pm);
	if (fRoot instanceof DiffNode) {
		try {
			commit(pm, (DiffNode) fRoot);
		} finally {		
			setDirty(false);
		}
	}
}
 

protected Object prepareInput(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
	initLabels();
	MultipleSelectionNode left = new MultipleSelectionNode(localResourceNodes);
	MultipleSelectionNode right = new MultipleSelectionNode(remoteResourceNodes);
       Object differences = new StatusAwareDifferencer().findDifferences(false, monitor,null,null,left,right);
       if (differences instanceof DiffNode) {
       	DiffNode diffNode = (DiffNode)differences;
       	if (!diffNode.hasChildren()) {
       		return null;
       	}
       }
       fRoot = differences;
       return differences;
}
 

public void saveChanges(IProgressMonitor pm) throws CoreException {
	super.saveChanges(pm);
	if (fRoot instanceof DiffNode) {
		try {
			commit(pm, (DiffNode) fRoot);
		} finally {		
			setDirty(false);
		}
	}
}
 

@Override
protected ICompareInput prepareCompareInput(IProgressMonitor monitor)
    throws InvocationTargetException, InterruptedException {
  CompareConfiguration cc = getCompareConfiguration();
  cc.setLeftEditable(true);
  cc.setRightEditable(false);
  cc.setLeftLabel(source.getName());
  cc.setLeftImage(CompareUI.getImage(source));
  cc.setRightLabel(generatedUpdate.getName());
  cc.setRightImage(CompareUI.getImage(source)); // same type
  ITypedElement left = SaveableCompareEditorInput.createFileElement(source);
  ITypedElement right = new LocalDiskContent(generatedUpdate);
  return new DiffNode(left, right);
}
 

private void setCompareViewerInput(int dataIndex) {
	if (fViewer.getControl().isDisposed())
		return;
	if (specChanges.isEmpty())
		return;

	SpecFile specChange = specChanges.get(dataIndex);
	fViewer.setInput(new DiffNode(
			new OriginalElementFromFile(specChange.getFile()),
			new TargetElementFromString(specChange.getNewContent())));
	fViewer.refresh();
}
 

@Override
public boolean hasChildren(Object element) {
    final int length = ((DiffNode) element).getChildren().length;
    return length != 0;
}
 

public DiffNode getRoot() {
    return root;
}
 

public void setRoot(final DiffNode root) {
    this.root = root;
}
 

private void addChildrenToParent(final DiffNode parent, final IDiffElement[] children) {
    for (final IDiffElement child : children) {
        parent.add(child);
    }
}