CompareWithEachOtherAction.label= &Each Other

CompareWithEachOtherAction.tooltip= Compare the Selected Resources

         <action

               class="org.eclipse.team.internal.ui.actions.CompareAction"

               enablesFor="2+"

               id="org.eclipse.team.ui.compareWithEachOther"

               label="%CompareWithEachOtherAction.label"

               menubarPath="compareWithMenu/compareWithGroup"

               overrideActionId="compareWithEachOther"

               tooltip="CompareWithEachOtherAction.tooltip">

         </action>

/*******************************************************************************

 * Copyright (c) 2007 IBM Corporation 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:

 * IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.team.internal.ui.synchronize;

import java.lang.reflect.InvocationTargetException;

import org.eclipse.compare.*;

import org.eclipse.compare.structuremergeviewer.*;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.runtime.Assert;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.jface.util.IPropertyChangeListener;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.osgi.util.NLS;

import org.eclipse.swt.events.DisposeEvent;

import org.eclipse.swt.events.DisposeListener;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.team.internal.ui.mapping.AbstractCompareInput;

import org.eclipse.team.internal.ui.mapping.CompareInputChangeNotifier;

import org.eclipse.team.internal.ui.synchronize.EditableSharedDocumentAdapter.ISharedDocumentAdapterListener;

import org.eclipse.team.ui.mapping.SaveableComparison;

import org.eclipse.team.ui.synchronize.SaveableCompareEditorInput;

import org.eclipse.ui.*;

import org.eclipse.ui.services.IDisposable;

public class TwoSidesSaveableCompareEditorInput extends

		SaveableCompareEditorInput {

	private ICompareInputChangeListener compareInputChangeListener;

	private IPropertyListener propertyListener;

	private Saveable leftSaveable;

	private Saveable rightSaveable;

	private ITypedElement left;

	private ITypedElement right;

	private static ITypedElement getLeftFileElement(ICompareInput input,

			CompareEditorInput editorInput) {

		if (input.getLeft() instanceof LocalResourceTypedElement) {

			return (LocalResourceTypedElement) input.getLeft();

		}

//		if (editorInput instanceof CompareFileRevisionEditorInput) {

//			return ((CompareFileRevisionEditorInput) editorInput).getLocalElement();

//		}

		return null;

	}

	private static ITypedElement getRightFileElement(ICompareInput input,

			CompareEditorInput editorInput) {

		if (input.getRight() instanceof LocalResourceTypedElement) {

			return (LocalResourceTypedElement) input.getRight();

		}

//		if (editorInput instanceof CompareFileRevisionEditorInput) {

//			return ((CompareFileRevisionEditorInput) editorInput).getLocalElement();

//		}

		return null;

	}

	private class InternalResourceSaveableComparison extends LocalResourceSaveableComparison implements ISharedDocumentAdapterListener {

		private LocalResourceTypedElement lrte;

		private boolean connected = false;

		public InternalResourceSaveableComparison(

				ICompareInput input, CompareEditorInput editorInput, ITypedElement typedElement) {

			super(input, editorInput, typedElement);

			ITypedElement element = typedElement;

			if (element instanceof LocalResourceTypedElement) {

				lrte = (LocalResourceTypedElement) element;

				if (lrte.isConnected()) {

					registerSaveable(true);

				} else {

					lrte.setSharedDocumentListener(this);

				}

			}

		}

		protected void fireInputChange() {

			TwoSidesSaveableCompareEditorInput.this.fireInputChange();

		}

		public void dispose() {

			super.dispose();

			if (lrte != null)

				lrte.setSharedDocumentListener(null);

		}

		public void handleDocumentConnected() {

			if (connected)

				return;

			connected = true;

			registerSaveable(false);

			if (lrte != null)

				lrte.setSharedDocumentListener(null);

		}

		private void registerSaveable(boolean init) {

			ICompareContainer container = getContainer();

			IWorkbenchPart part = container.getWorkbenchPart();

			if (part != null) {

				ISaveablesLifecycleListener lifecycleListener= getSaveablesLifecycleListener(part);

				// Remove this saveable from the lifecycle listener

				if (!init)

					lifecycleListener.handleLifecycleEvent(

							new SaveablesLifecycleEvent(part, SaveablesLifecycleEvent.POST_CLOSE, new Saveable[] { this }, false));

				// Now fix the hashing so it uses the connected document

				initializeHashing();

				// Finally, add this saveable back to the listener

				lifecycleListener.handleLifecycleEvent(

						new SaveablesLifecycleEvent(part, SaveablesLifecycleEvent.POST_OPEN, new Saveable[] { this }, false));

			}

		}

		public void handleDocumentDeleted() {

			// Ignore

		}

		public void handleDocumentDisconnected() {

			// Ignore

		}

		public void handleDocumentFlushed() {

			// Ignore

		}

		public void handleDocumentSaved() {

			// Ignore

		}

	}

	public TwoSidesSaveableCompareEditorInput(ITypedElement left,

			ITypedElement right, IWorkbenchPage page) {

		super(new CompareConfiguration(), page);

		this.left = left;

		this.right = right;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.compare.CompareEditorInput#contentsCreated()

	 */

	protected void contentsCreated() {

		super.contentsCreated();

		compareInputChangeListener = new ICompareInputChangeListener() {

			public void compareInputChanged(ICompareInput source) {

				if (source == getCompareResult()) {

					boolean closed = false;

					if (source.getKind() == Differencer.NO_CHANGE) {

						closed = closeEditor(true);

					}

					if (!closed) {

						// The editor was closed either because the compare input still has changes

						// or because the editor input is dirty. In either case, fire the changes

						// to the registered listeners

						propogateInputChange();

					}

				}

			}

		};

		getCompareInput().addCompareInputChangeListener(compareInputChangeListener);

		if (getLeftSaveable() instanceof SaveableComparison) {

			SaveableComparison lscm = (SaveableComparison) leftSaveable;

			propertyListener = new IPropertyListener() {

				public void propertyChanged(Object source, int propId) {

					if (propId == SaveableComparison.PROP_DIRTY) {

						setDirty(leftSaveable.isDirty());

					}

				}

			};

			lscm.addPropertyListener(propertyListener);

		}

		if (getRightSaveable() instanceof SaveableComparison) {

			SaveableComparison rscm = (SaveableComparison) rightSaveable;

			propertyListener = new IPropertyListener() {

				public void propertyChanged(Object source, int propId) {

					if (propId == SaveableComparison.PROP_DIRTY) {

						setDirty(rightSaveable.isDirty());

					}

				}

			};

			rscm.addPropertyListener(propertyListener);

		}

		setDirty(leftSaveable.isDirty() || rightSaveable.isDirty());

	}

	/* (non-Javadoc)

	 * @see org.eclipse.compare.CompareEditorInput#handleDispose()

	 */

	protected void handleDispose() {

		super.handleDispose();

		ICompareInput compareInput = getCompareInput();

		if (compareInput != null)

			compareInput.removeCompareInputChangeListener(compareInputChangeListener);

		if (leftSaveable instanceof SaveableComparison) {

			SaveableComparison scm = (SaveableComparison) leftSaveable;

			scm.removePropertyListener(propertyListener);

		}

		if (leftSaveable instanceof LocalResourceSaveableComparison) {

			LocalResourceSaveableComparison rsc = (LocalResourceSaveableComparison) leftSaveable;

			rsc.dispose();

		}

		if (rightSaveable instanceof SaveableComparison) {

			SaveableComparison scm = (SaveableComparison) rightSaveable;

			scm.removePropertyListener(propertyListener);

		}

		if (rightSaveable instanceof LocalResourceSaveableComparison) {

			LocalResourceSaveableComparison rsc = (LocalResourceSaveableComparison) rightSaveable;

			rsc.dispose();

		}

		if (getCompareResult() instanceof IDisposable) {

			((IDisposable) getCompareResult()).dispose();

		}

	}

	public String getToolTipText() {

		IResource leftResource = getLeftResource();

		IResource rightResource = getRightResource();

		if (leftResource != null && rightResource != null) {

			String leftLabel = leftResource.getFullPath().makeRelative()

					.toString();

			String rightLabel = rightResource.getFullPath().makeRelative()

					.toString();

			return NLS

					.bind(

							"Two-way compare of {0} with {1}", new String[] { leftLabel, rightLabel }); //$NON-NLS-1$

		}

		return NLS

				.bind(

						"Two-way compare of {0} with {1}", new String[] { left.getName(), right.getName() }); //$NON-NLS-1$

	}

	protected void fireInputChange() {

			((MyDiffNode)getCompareResult()).fireChange();

	}

	protected Saveable getLeftSaveable() {

		if (leftSaveable == null) {

			leftSaveable = createLeftSaveable();

		}

		return leftSaveable;

	}

	protected Saveable getRightSaveable() {

		if (rightSaveable == null) {

			rightSaveable = createRightSaveable();

		}

		return rightSaveable;

	}

	protected Saveable createLeftSaveable() {

		Object compareResult = getCompareResult();

		Assert.isNotNull(compareResult, "This method cannot be called until after prepareInput is called"); //$NON-NLS-1$

		ITypedElement leftFileElement = getLeftFileElement((ICompareInput)compareResult, this);

		return new InternalResourceSaveableComparison((ICompareInput)compareResult, this, leftFileElement);

	}

	protected Saveable createRightSaveable() {

		Object compareResult = getCompareResult();

		Assert.isNotNull(compareResult, "This method cannot be called until after prepareInput is called"); //$NON-NLS-1$

		ITypedElement rightFileElement = getRightFileElement((ICompareInput)compareResult, this);

		return new InternalResourceSaveableComparison((ICompareInput)compareResult, this, rightFileElement);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.ISaveablesSource#getActiveSaveables()

	 */

	public Saveable[] getActiveSaveables() {

		if (getCompareResult() == null)

			return new Saveable[0];

		return new Saveable[] { getLeftSaveable(), getRightSaveable() };

	}

	/* (non-Javadoc)

	 * @see org.eclipse.compare.CompareEditorInput#findContentViewer(org.eclipse.jface.viewers.Viewer, org.eclipse.compare.structuremergeviewer.ICompareInput, org.eclipse.swt.widgets.Composite)

	 */

	public Viewer findContentViewer(Viewer oldViewer, ICompareInput input, Composite parent) {

		Viewer newViewer = super.findContentViewer(oldViewer, input, parent);

		boolean isNewViewer= newViewer != oldViewer;

		if (isNewViewer && newViewer instanceof IPropertyChangeNotifier

				&& leftSaveable instanceof IPropertyChangeListener

				&& rightSaveable instanceof IPropertyChangeListener) {

			// Register the model for change events if appropriate

			final IPropertyChangeNotifier dsp= (IPropertyChangeNotifier) newViewer;

			final IPropertyChangeListener lpcl = (IPropertyChangeListener) leftSaveable;

			final IPropertyChangeListener rpcl = (IPropertyChangeListener) rightSaveable;

			dsp.addPropertyChangeListener(lpcl);

			dsp.addPropertyChangeListener(rpcl);

			Control c= newViewer.getControl();

			c.addDisposeListener(

				new DisposeListener() {

					public void widgetDisposed(DisposeEvent e) {

						dsp.removePropertyChangeListener(lpcl);

						dsp.removePropertyChangeListener(rpcl);

					}

				}

			);

		}

		return newViewer;

	}

	public boolean isDirty() {

		if (leftSaveable != null && leftSaveable.isDirty())

			return true;

		if (rightSaveable != null && rightSaveable.isDirty())

			return true;

		return super.isDirty();

	}

	protected ICompareInput prepareCompareInput(IProgressMonitor monitor)

			throws InvocationTargetException, InterruptedException {

		ICompareInput input = createCompareInput();

		getCompareConfiguration().setLeftEditable(isLeftEditable(input)); 

		getCompareConfiguration().setRightEditable(isRightEditable(input));

		// both are local

//		ensureContentsCached(getLeftRevision(), getRightRevision(), monitor);

		initLabels(input);

		return input;

	}

	private boolean isLeftEditable(ICompareInput input) {

		Object left = input.getLeft();

		if (left instanceof IEditableContent) {

			return ((IEditableContent) left).isEditable();

		}

		return false;

	}

	private boolean isRightEditable(ICompareInput input) {

		Object right = input.getRight();

		if (right instanceof IEditableContent) {

			return ((IEditableContent) right).isEditable();

		}

		return false;

	}

	private void initLabels(ICompareInput input) {

		CompareConfiguration cc = getCompareConfiguration();

		IResource leftResource = getLeftResource();

		IResource rightResource = getRightResource();

		if (leftResource != null && rightResource != null) {

			String leftLabel = leftResource.getFullPath().makeRelative()

					.toString();

			String rightLabel = rightResource.getFullPath().makeRelative()

					.toString();

			cc.setLeftLabel(leftLabel);

			cc.setRightLabel(rightLabel);

		}

	}

	private ICompareInput createCompareInput() {

		return new MyDiffNode(left, right);

	}

	CompareInputChangeNotifier notifier = new CompareInputChangeNotifier() {

		protected IResource[] getResources(ICompareInput input) {

			IResource leftResource = getLeftResource();

			IResource rightResource = getRightResource();

			if (leftResource == null && rightResource == null)

				return new IResource[0];

			if (leftResource == null && rightResource != null)

				return new IResource[] { rightResource };

			if (leftResource != null && rightResource == null)

				return new IResource[] { leftResource };

			return new IResource[] { leftResource, rightResource };

		}

	};

	public class MyDiffNode extends AbstractCompareInput {

		public MyDiffNode(ITypedElement left, ITypedElement right) {

			super(Differencer.CHANGE, null, left, right);

		}

		public void fireChange() {

			super.fireChange();

		}

		protected CompareInputChangeNotifier getChangeNotifier() {

			return notifier;

		}

		public boolean needsUpdate() {

			return true;

		}

		public void update() {

			fireChange();

		}

	}

	private IResource getLeftResource() {

		if (left instanceof LocalResourceTypedElement

				&& left instanceof IResourceProvider) {

			return ((IResourceProvider) left).getResource();

		}

		return null;

	}

	private IResource getRightResource() {

		if (right instanceof LocalResourceTypedElement

				&& right instanceof IResourceProvider) {

			return ((IResourceProvider) right).getResource();

		}

		return null;

	}

}

/*******************************************************************************

 * Copyright (c) 2007 IBM Corporation 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:

 * IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.team.internal.ui.actions;

import java.lang.reflect.InvocationTargetException;

import org.eclipse.compare.*;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IResource;

import org.eclipse.jface.action.IAction;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.team.internal.ui.synchronize.TwoSidesSaveableCompareEditorInput;

import org.eclipse.team.ui.synchronize.SaveableCompareEditorInput;

import org.eclipse.ui.*;

public class CompareAction extends TeamAction {

	protected void execute(IAction action) throws InvocationTargetException,

			InterruptedException {

		IResource[] selectedResources = getSelectedResources();

		if (selectedResources.length == 2) {

			ITypedElement left = null;

			if (selectedResources[0] != null) {

				left = getElementFor(selectedResources[0]);

			}

			ITypedElement right = null;

			if (selectedResources[1] != null) {

				right = getElementFor(selectedResources[1]);

			}

			openInCompare(left, right);

		}

	}

	//XXX: from CompareRevisionAction*

	private void openInCompare(ITypedElement left, ITypedElement right) {

		IWorkbenchPage workBenchPage = getTargetPage();

		CompareEditorInput input = createCompareEditorInput(left, right, workBenchPage);

		IEditorPart editor = CompareRevisionAction.findReusableCompareEditor(workBenchPage);

		if (editor != null) {

			IEditorInput otherInput = editor.getEditorInput();

			if (otherInput.equals(input)) {

				// simply provide focus to editor

				workBenchPage.activate(editor);

			} else {

				// if editor is currently not open on that input either re-use

				// existing

				CompareUI.reuseCompareEditor(input, (IReusableEditor) editor);

				workBenchPage.activate(editor);

			}

		} else {

			CompareUI.openCompareEditor(input);

		}

	}

	protected TwoSidesSaveableCompareEditorInput createCompareEditorInput(

			ITypedElement left, ITypedElement right, IWorkbenchPage page) {

		return new TwoSidesSaveableCompareEditorInput(left,

				right, page);

	}

	public void selectionChanged(IAction action, ISelection selection) {

		super.selectionChanged(action, selection);

	}

	//XXX: from CompareRevisionAction

	private ITypedElement getElementFor(IResource resource) {

		return SaveableCompareEditorInput.createFileElement((IFile)resource);

	}

}