/*******************************************************************************
 * Copyright (c) 2009, 2017 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 * IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.team.internal.ui.synchronize;

import java.lang.reflect.InvocationTargetException;

import org.eclipse.compare.CompareConfiguration;
import org.eclipse.compare.CompareEditorInput;
import org.eclipse.compare.ICompareContainer;
import org.eclipse.compare.IEditableContent;
import org.eclipse.compare.IPropertyChangeNotifier;
import org.eclipse.compare.IResourceProvider;
import org.eclipse.compare.ITypedElement;
import org.eclipse.compare.structuremergeviewer.Differencer;
import org.eclipse.compare.structuremergeviewer.ICompareInput;
import org.eclipse.compare.structuremergeviewer.ICompareInputChangeListener;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.Adapters;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.ListenerList;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.ImageRegistry;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.team.internal.ui.ITeamUIImages;
import org.eclipse.team.internal.ui.TeamUIMessages;
import org.eclipse.team.internal.ui.TeamUIPlugin;
import org.eclipse.team.internal.ui.history.CompareFileRevisionEditorInput;
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.IEditorDescriptor;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.IPropertyListener;
import org.eclipse.ui.ISaveablesLifecycleListener;
import org.eclipse.ui.ISaveablesSource;
import org.eclipse.ui.IWorkbenchCommandConstants;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchSite;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.Saveable;
import org.eclipse.ui.SaveablesLifecycleEvent;
import org.eclipse.ui.actions.ContributionItemFactory;
import org.eclipse.ui.actions.OpenFileAction;
import org.eclipse.ui.actions.OpenWithMenu;
import org.eclipse.ui.actions.WorkspaceModifyOperation;
import org.eclipse.ui.ide.IGotoMarker;
import org.eclipse.ui.keys.IBindingService;
import org.eclipse.ui.services.IDisposable;
import org.eclipse.ui.texteditor.ITextEditor;

/**
 * A compare editor input that makes use of a {@link Saveable} to manage the
 * save lifecycle of the left and right sides of the comparison. The ancestor
 * part of the comparison is not editable.
 */
public class SaveablesCompareEditorInput extends CompareEditorInput implements
		ISaveablesSource {

	private IPropertyListener fLeftPropertyListener;
	private IPropertyListener fRightPropertyListener;

	private Saveable fLeftSaveable;
	private Saveable fRightSaveable;

	private ITypedElement fAncestorElement;
	private ITypedElement fLeftElement;
	private ITypedElement fRightElement;

	private final IWorkbenchPage page;
	private final ListenerList inputChangeListeners = new ListenerList(
			ListenerList.IDENTITY);
	private ICompareInputChangeListener compareInputChangeListener;

	public SaveablesCompareEditorInput(ITypedElement ancestor,
			ITypedElement left, ITypedElement right, IWorkbenchPage page) {
		super(new CompareConfiguration());
		this.page = page;
		this.fAncestorElement = ancestor;
		this.fLeftElement = left;
		this.fRightElement = right;
	}

	private static ITypedElement getFileElement(ITypedElement element,
			CompareEditorInput editorInput) {
		if (element instanceof LocalResourceTypedElement) {
			return element;
		}
		if (editorInput instanceof CompareFileRevisionEditorInput) {
			return ((CompareFileRevisionEditorInput) editorInput)
					.getLocalElement();
		}
		return null;
	}

	/**
	 * Return a typed element that represents a local file. If the element
	 * returned from this method is used as the left contributor of the compare
	 * input for a {@link SaveableCompareEditorInput}, then the file will be
	 * properly saved when the compare editor input or viewers are saved.
	 *
	 * @param file
	 *            the file
	 * @return a typed element that represents a local file.
	 */
	public static ITypedElement createFileElement(IFile file) {
		return new LocalResourceTypedElement(file);
	}

	private ISaveablesLifecycleListener getSaveablesLifecycleListener(
			IWorkbenchPart part) {
		ISaveablesLifecycleListener listener = Adapters.adapt(part, ISaveablesLifecycleListener.class);
		if (listener == null)
			listener = part.getSite().getService(ISaveablesLifecycleListener.class);
		return listener;
	}

	@Override
	protected void contentsCreated() {
		super.contentsCreated();
		compareInputChangeListener = source -> {
			if (source == getCompareResult()) {
				boolean closed = false;
				if (source.getKind() == Differencer.NO_CHANGE) {
					closed = closeEditor(true);
				}
				if (!closed) {
					// The editor was not 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) fLeftSaveable;
			fLeftPropertyListener = (source, propId) -> {
				if (propId == SaveableComparison.PROP_DIRTY) {
					setLeftDirty(fLeftSaveable.isDirty());
				}
			};
			lscm.addPropertyListener(fLeftPropertyListener);
		}

		if (getRightSaveable() instanceof SaveableComparison) {
			SaveableComparison rscm = (SaveableComparison) fRightSaveable;
			fRightPropertyListener = (source, propId) -> {
				if (propId == SaveableComparison.PROP_DIRTY) {
					setRightDirty(fRightSaveable.isDirty());
				}
			};
			rscm.addPropertyListener(fRightPropertyListener);
		}

		setLeftDirty(fLeftSaveable.isDirty());
		setRightDirty(fRightSaveable.isDirty());
	}

	@Override
	protected void handleDispose() {
		super.handleDispose();
		ICompareInput compareInput = getCompareInput();
		if (compareInput != null)
			compareInput
					.removeCompareInputChangeListener(compareInputChangeListener);
		compareInputChangeListener = null;
		if (fLeftSaveable instanceof SaveableComparison) {
			SaveableComparison scm = (SaveableComparison) fLeftSaveable;
			scm.removePropertyListener(fLeftPropertyListener);
		}
		if (fLeftSaveable instanceof LocalResourceSaveableComparison) {
			LocalResourceSaveableComparison rsc = (LocalResourceSaveableComparison) fLeftSaveable;
			rsc.dispose();
		}
		if (fRightSaveable instanceof SaveableComparison) {
			SaveableComparison scm = (SaveableComparison) fRightSaveable;
			scm.removePropertyListener(fRightPropertyListener);
		}
		if (fRightSaveable instanceof LocalResourceSaveableComparison) {
			LocalResourceSaveableComparison rsc = (LocalResourceSaveableComparison) fRightSaveable;
			rsc.dispose();
		}

		if (getCompareResult() instanceof IDisposable) {
			((IDisposable) getCompareResult()).dispose();
		}
	}

	private String[] getLabels() {
		IResource leftResource = getResource(fLeftElement);
		IResource rightResource = getResource(fRightElement);
		if (leftResource != null && rightResource != null) {
			String leftLabel = leftResource.getFullPath().makeRelative().toString();
			String rightLabel = rightResource.getFullPath().makeRelative().toString();
			if (fAncestorElement != null) {
				IResource ancestorResource = getResource(fAncestorElement);
				if (ancestorResource != null) {
					String ancestorLabel = rightResource.getFullPath().makeRelative().toString();
					return new String[] { ancestorLabel, leftLabel, rightLabel };
				}
			}
			return new String[] { leftLabel, rightLabel };
		}
		if (fAncestorElement != null) {
			return new String[] { fAncestorElement.getName(), fLeftElement.getName(), fRightElement.getName() };
		}
		return new String[] { fLeftElement.getName(), fRightElement.getName() };
	}

	@Override
	public String getToolTipText() {
		String[] labels = getLabels();
		if (labels.length == 3)
			return NLS.bind(TeamUIMessages.SaveablesCompareEditorInput_threeWayTooltip, labels);
		return NLS.bind(TeamUIMessages.SaveablesCompareEditorInput_twoWayTooltip, labels);
	}

	@Override
	public String getTitle() {
		String[] labels = getLabels();
		if (labels.length == 3)
			return NLS.bind(TeamUIMessages.SaveablesCompareEditorInput_threeWayTitle, labels);
		return NLS.bind(TeamUIMessages.SaveablesCompareEditorInput_twoWayTitle, labels);
	}

	private IWorkbenchPage getPage() {
		if (page == null)
			return PlatformUI.getWorkbench().getActiveWorkbenchWindow()
					.getActivePage();
		return page;
	}

	/**
	 * Return the compare input of this editor input.
	 *
	 * @return the compare input of this editor input
	 */
	protected final ICompareInput getCompareInput() {
		return (ICompareInput) getCompareResult();
	}

	/**
	 * Callback from the resource saveable that is invoked when the resource is
	 * saved so that this input can fire a change event for its input.
	 * Subclasses only need this method if the left side of their compare input
	 * is an element returned from
	 * {@link SaveableCompareEditorInput#createFileElement(IFile)}.
	 */
	protected void fireInputChange() {
		((MyDiffNode) getCompareResult()).fireChange();
	}

	protected Saveable getLeftSaveable() {
		if (fLeftSaveable == null) {
			fLeftSaveable = createLeftSaveable();
		}
		return fLeftSaveable;
	}

	protected Saveable getRightSaveable() {
		if (fRightSaveable == null) {
			fRightSaveable = createRightSaveable();
		}
		return fRightSaveable;
	}

	protected Saveable createLeftSaveable() {
		Object compareResult = getCompareResult();
		Assert
				.isNotNull(compareResult,
						"This method cannot be called until after prepareInput is called"); //$NON-NLS-1$
		ITypedElement leftFileElement = getFileElement(getCompareInput()
				.getLeft(), 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 = getFileElement(getCompareInput()
				.getRight(), this);
		return new InternalResourceSaveableComparison(
				(ICompareInput) compareResult, this, rightFileElement);
	}

	@Override
	public Saveable[] getActiveSaveables() {
		if (getCompareResult() == null)
			return new Saveable[0];
		return new Saveable[] { getLeftSaveable(), getRightSaveable() };
	}

	@Override
	public Saveable[] getSaveables() {
		return getActiveSaveables();
	}

	@Override
	public Viewer findContentViewer(Viewer pOldViewer, ICompareInput pInput,
			Composite pParent) {
		Viewer newViewer = super.findContentViewer(pOldViewer, pInput, pParent);
		boolean isNewViewer = newViewer != pOldViewer;
		if (isNewViewer && newViewer instanceof IPropertyChangeNotifier
				&& fLeftSaveable instanceof IPropertyChangeListener
				&& fRightSaveable instanceof IPropertyChangeListener) {
			// Register the model for change events if appropriate
			final IPropertyChangeNotifier dsp = (IPropertyChangeNotifier) newViewer;
			final IPropertyChangeListener lpcl = (IPropertyChangeListener) fLeftSaveable;
			final IPropertyChangeListener rpcl = (IPropertyChangeListener) fRightSaveable;
			dsp.addPropertyChangeListener(lpcl);
			dsp.addPropertyChangeListener(rpcl);
			Control c = newViewer.getControl();
			c.addDisposeListener(e -> {
				dsp.removePropertyChangeListener(lpcl);
				dsp.removePropertyChangeListener(rpcl);
			});
		}
		return newViewer;
	}

	@Override
	public boolean isDirty() {
		if (fLeftSaveable != null && fLeftSaveable.isDirty())
			return true;
		if (fRightSaveable != null && fRightSaveable.isDirty())
			return true;
		return super.isDirty();
	}

	/**
	 * Returns <code>true</code> if the given saveable contains any unsaved
	 * changes. If the saveable doesn't match either left nor right side of the
	 * current editor input {@link CompareEditorInput#isSaveNeeded()} is called.
	 * <p>
	 * This method is preferred to {@link CompareEditorInput#isSaveNeeded()}.
	 *
	 * @param the
	 *            the saveable to check
	 * @return <code>true</code> if there are changes that need to be saved
	 * @since 3.7
	 */
	boolean isSaveNeeded(Saveable saveable) {
		if (saveable == null) {
			return isSaveNeeded();
		}
		if (saveable.equals(fLeftSaveable)) {
			return isLeftSaveNeeded();
		}
		if (saveable.equals(fRightSaveable)) {
			return isRightSaveNeeded();
		}
		// Fallback call returning true if there are unsaved changes in either
		// left or right side
		return isSaveNeeded();
	}

	void setDirty(boolean dirty, Saveable saveable) {
		if (saveable.equals(fLeftSaveable)) {
			setLeftDirty(dirty);
		}
		if (saveable.equals(fRightSaveable)) {
			setRightDirty(dirty);
		}
	}

	void saveChanges(IProgressMonitor monitor, Saveable saveable)
			throws CoreException {
		if (saveable.equals(fLeftSaveable)) {
			flushLeftViewers(monitor);
			return;
		} else if (saveable.equals(fRightSaveable)) {
			flushRightViewers(monitor);
			return;
		}
		Assert.isTrue(false, "invalid saveable parameter"); //$NON-NLS-1$
	}

	/**
	 * Close the editor if it is not dirty. If it is still dirty, let the
	 * content merge viewer handle the compare input change.
	 *
	 * @param checkForUnsavedChanges
	 *            whether to check for unsaved changes
	 * @return <code>true</code> if the editor was closed (note that the close
	 *         may be asynchronous)
	 */
	protected boolean closeEditor(boolean checkForUnsavedChanges) {
		if (isSaveNeeded() && checkForUnsavedChanges) {
			return false;
		} else {
			Runnable runnable = () -> {
				IEditorPart part = getPage().findEditor(
						SaveablesCompareEditorInput.this);
				getPage().closeEditor(part, false);
			};
			if (Display.getCurrent() != null) {
				runnable.run();
			} else {
				Display display = getPage().getWorkbenchWindow().getShell()
						.getDisplay();
				display.asyncExec(runnable);
			}
			return true;
		}
	}

	/**
	 * Prepare the compare input of this editor input. This method is not
	 * intended to be overridden of extended by subclasses (but is not final for
	 * backwards compatibility reasons). The implementation of this method in
	 * this class delegates the creation of the compare input to the
	 * {@link #prepareCompareInput(IProgressMonitor)} method which subclasses
	 * must implement.
	 *
	 * @see org.eclipse.compare.CompareEditorInput#prepareInput(org.eclipse.core.runtime.IProgressMonitor)
	 */
	@Override
	protected Object prepareInput(IProgressMonitor monitor)
			throws InvocationTargetException, InterruptedException {
		final ICompareInput input = prepareCompareInput(monitor);
		if (input != null)
			setTitle(NLS.bind(TeamUIMessages.SyncInfoCompareInput_title,
					new String[] { input.getName() }));
		return input;
	}

	/**
	 * Method called from {@link #prepareInput(IProgressMonitor)} to obtain the input. Its purpose
	 * is to ensure that the input is an instance of {@link ICompareInput}.
	 *
	 * @param monitor a progress monitor
	 * @return the compare input
	 * @throws InvocationTargetException
	 * @throws InterruptedException
	 */
	protected ICompareInput prepareCompareInput(IProgressMonitor monitor)
			throws InvocationTargetException, InterruptedException {
		ICompareInput input = createCompareInput();
		getCompareConfiguration().setLeftEditable(isEditable(input.getLeft()));
		getCompareConfiguration()
				.setRightEditable(isEditable(input.getRight()));
		initLabels();
		return input;
	}

	private boolean isEditable(Object obj) {
		if (obj instanceof IEditableContent) {
			return ((IEditableContent) obj).isEditable();
		}
		return false;
	}

	private void initLabels() {
		CompareConfiguration cc = getCompareConfiguration();

		IResource ancestorResource = getResource(fAncestorElement);
		IResource leftResource = getResource(fLeftElement);
		IResource rightResource = getResource(fRightElement);

		if (ancestorResource != null) {
			String ancestorLabel = ancestorResource.getFullPath()
					.makeRelative().toString();

			cc.setAncestorLabel(ancestorLabel);
		}

		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 fAncestorElement == null ? new MyDiffNode(fLeftElement,
				fRightElement) : new MyDiffNode(fAncestorElement, fLeftElement,
				fRightElement);
	}

	private CompareInputChangeNotifier notifier = new CompareInputChangeNotifier() {
		@Override
		protected IResource[] getResources(ICompareInput input) {
			IResource leftResource = getResource(fLeftElement);
			IResource rightResource = getResource(fRightElement);
			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 };
		}
	};

	private class MyDiffNode extends AbstractCompareInput {
		public MyDiffNode(ITypedElement left, ITypedElement right) {
			super(Differencer.CHANGE, null, left, right);
		}

		public MyDiffNode(ITypedElement ancestor, ITypedElement left,
				ITypedElement right) {
			super(Differencer.CONFLICTING, ancestor, left, right);
		}

		@Override
		public void fireChange() {
			super.fireChange();
		}

		@Override
		protected CompareInputChangeNotifier getChangeNotifier() {
			return notifier;
		}

		@Override
		public boolean needsUpdate() {
			return true;
		}

		@Override
		public void update() {
			fireChange();
		}
	}

	private IResource getResource(ITypedElement pElement) {
		if (pElement instanceof LocalResourceTypedElement
				&& pElement instanceof IResourceProvider) {
			return ((IResourceProvider) pElement).getResource();
		}
		return null;
	}

	@Override
	public void registerContextMenu(final MenuManager pMenuManager,
			final ISelectionProvider pSelectionProvider) {
		super.registerContextMenu(pMenuManager, pSelectionProvider);
		final Saveable lLeftSaveable = getLeftSaveable();
		final ITypedElement lLeftElement = getFileElement(getCompareInput()
				.getLeft(), this);
		if (lLeftSaveable instanceof LocalResourceSaveableComparison) {
			pMenuManager.addMenuListener(manager -> handleMenuAboutToShow(manager, getContainer(), lLeftSaveable, lLeftElement, pSelectionProvider));
		}
		final Saveable lRightSaveable = getRightSaveable();
		final ITypedElement lRightElement = getFileElement(getCompareInput()
				.getRight(), this);
		if (lRightSaveable instanceof LocalResourceSaveableComparison) {
			pMenuManager.addMenuListener(manager -> handleMenuAboutToShow(manager, getContainer(), lRightSaveable, lRightElement, pSelectionProvider));
		}
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see
	 * org.eclipse.compare.CompareEditorInput#addCompareInputChangeListener(
	 * org.eclipse.compare.structuremergeviewer.ICompareInput,
	 * org.eclipse.compare.structuremergeviewer.ICompareInputChangeListener)
	 */
	@Override
	public void addCompareInputChangeListener(ICompareInput input,
			ICompareInputChangeListener listener) {
		if (input == getCompareResult()) {
			inputChangeListeners.add(listener);
		} else {
			super.addCompareInputChangeListener(input, listener);
		}
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see
	 * org.eclipse.compare.CompareEditorInput#removeCompareInputChangeListener
	 * (org.eclipse.compare.structuremergeviewer.ICompareInput,
	 * org.eclipse.compare.structuremergeviewer.ICompareInputChangeListener)
	 */
	@Override
	public void removeCompareInputChangeListener(ICompareInput input,
			ICompareInputChangeListener listener) {
		if (input == getCompareResult()) {
			inputChangeListeners.remove(listener);
		} else {
			super.removeCompareInputChangeListener(input, listener);
		}
	}

	private void propogateInputChange() {
		if (!inputChangeListeners.isEmpty()) {
			Object[] allListeners = inputChangeListeners.getListeners();
			final ICompareInput compareResult = (ICompareInput) getCompareResult();
			for (int i = 0; i < allListeners.length; i++) {
				final ICompareInputChangeListener listener = (ICompareInputChangeListener) allListeners[i];
				SafeRunner.run(new ISafeRunnable() {
					@Override
					public void run() throws Exception {
						listener.compareInputChanged(compareResult);
					}

					@Override
					public void handleException(Throwable exception) {
						// Logged by the safe runner
					}
				});
			}
		}
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see org.eclipse.compare.CompareEditorInput#getTitleImage()
	 */
	@Override
	public Image getTitleImage() {
		ImageRegistry reg = TeamUIPlugin.getPlugin().getImageRegistry();
		Image image = reg.get(ITeamUIImages.IMG_SYNC_VIEW);
		if (image == null) {
			image = getImageDescriptor().createImage();
			reg.put(ITeamUIImages.IMG_SYNC_VIEW, image);
		}
		return image;
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see org.eclipse.ui.IEditorInput#getImageDescriptor()
	 */
	@Override
	public ImageDescriptor getImageDescriptor() {
		return TeamUIPlugin.getImageDescriptor(ITeamUIImages.IMG_SYNC_VIEW);
	}

	@Override
	public boolean canRunAsJob() {
		return true;
	}

	private static String getShowInMenuLabel() {
		String keyBinding = null;

		IBindingService bindingService = PlatformUI.getWorkbench().getAdapter(IBindingService.class);
		if (bindingService != null)
			keyBinding = bindingService
					.getBestActiveBindingFormattedFor(IWorkbenchCommandConstants.NAVIGATE_SHOW_IN_QUICK_MENU);

		if (keyBinding == null)
			keyBinding = ""; //$NON-NLS-1$

		return NLS
				.bind(TeamUIMessages.SaveableCompareEditorInput_0, keyBinding);
	}

	// TODO: add getAdapter for IFile[]

	private class InternalResourceSaveableComparison extends
			LocalResourceSaveableComparison implements
			ISharedDocumentAdapterListener {
		private LocalResourceTypedElement lrte;
		private boolean connected = false;

		public InternalResourceSaveableComparison(ICompareInput input,
				CompareEditorInput editorInput, ITypedElement element) {
			super(input, editorInput, element);
			if (element instanceof LocalResourceTypedElement) {
				lrte = (LocalResourceTypedElement) element;
				if (lrte.isConnected()) {
					registerSaveable(true);
				} else {
					lrte.setSharedDocumentListener(this);
				}
			}
		}

		@Override
		protected void fireInputChange() {
			SaveablesCompareEditorInput.this.fireInputChange();
		}

		@Override
		public void dispose() {
			super.dispose();
			if (lrte != null)
				lrte.setSharedDocumentListener(null);
		}

		@Override
		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));
			}
		}

		@Override
		public void handleDocumentDeleted() {
			// Ignore
		}

		@Override
		public void handleDocumentDisconnected() {
			// Ignore
		}

		@Override
		public void handleDocumentFlushed() {
			// Ignore
		}

		@Override
		public void handleDocumentSaved() {
			// Ignore
		}

		@Override
		public boolean equals(Object obj) {
			if (this == obj)
				return true;

			if (!(obj instanceof Saveable))
				return false;

			Object document = getAdapter(IDocument.class);

			if (document != null) {
				Object otherDocument = ((Saveable) obj)
						.getAdapter(IDocument.class);
				return document.equals(otherDocument);
			}

			if (obj instanceof InternalResourceSaveableComparison) {
				InternalResourceSaveableComparison rscm = (InternalResourceSaveableComparison) obj;
				return rscm.getInput().equals(getInput()) && rscm.lrte.equals(lrte);
			}
			return false;
		}
	}

	public static void handleMenuAboutToShow(IMenuManager manager, ICompareContainer container, Saveable saveable, ITypedElement element, ISelectionProvider provider) {
		if (provider instanceof ITextViewer) {
			final ITextViewer v= (ITextViewer)provider;
			IDocument d= v.getDocument();
			IDocument other= Adapters.adapt(saveable, IDocument.class);
			if (d == other) {
				if (element instanceof IResourceProvider) {
					IResourceProvider rp= (IResourceProvider)element;
					IResource resource= rp.getResource();
					StructuredSelection selection= new StructuredSelection(resource);
					IWorkbenchPart workbenchPart= container.getWorkbenchPart();
					if (workbenchPart != null) {
						final IWorkbenchSite ws= workbenchPart.getSite();

						MenuManager submenu1= new MenuManager(getShowInMenuLabel());
						IContributionItem showInMenu= ContributionItemFactory.VIEWS_SHOW_IN.create(ws.getWorkbenchWindow());
						submenu1.add(showInMenu);
						manager.insertAfter("file", submenu1); //$NON-NLS-1$
						MenuManager submenu2= new MenuManager(TeamUIMessages.OpenWithActionGroup_0);

						// XXX: Internal reference will get fixed during 3.7, see https://bugs.eclipse.org/bugs/show_bug.cgi?id=307026
						submenu2.add(new OpenWithMenu(ws.getPage(), resource) {
							@Override
							protected void openEditor(IEditorDescriptor editorDescriptor, boolean openUsingDescriptor) {
								super.openEditor(editorDescriptor, openUsingDescriptor);
								IEditorPart editor= ws.getPage().getActiveEditor();
								Point selectedRange= v.getSelectedRange();
								revealInEditor(editor, selectedRange.x, selectedRange.y);
							}
						});
						manager.insertAfter("file", submenu2); //$NON-NLS-1$

						// XXX: Internal reference will get fixed during 3.7, see https://bugs.eclipse.org/bugs/show_bug.cgi?id=307026
						OpenFileAction openFileAction= new OpenFileAction(ws.getPage()) {
							@Override
							public void run() {
								super.run();
								IEditorPart editor= ws.getPage().getActiveEditor();
								Point selectedRange= v.getSelectedRange();
								revealInEditor(editor, selectedRange.x, selectedRange.y);
							}
						};
						openFileAction.selectionChanged(selection);
						manager.insertAfter("file", openFileAction); //$NON-NLS-1$
					}
				}
			}
		}
	}

	/**
	 * Selects and reveals the given offset and length in the given editor part.
	 *
	 * @param editor the editor part
	 * @param offset the offset
	 * @param length the length
	 * @since 3.6
	 */
	private static void revealInEditor(IEditorPart editor, final int offset, final int length) {
		if (editor instanceof ITextEditor) {
			((ITextEditor)editor).selectAndReveal(offset, length);
			return;
		}

		// Support for non-text editor - try IGotoMarker interface
		final IGotoMarker gotoMarkerTarget;
		if (editor instanceof IGotoMarker)
			gotoMarkerTarget= (IGotoMarker)editor;
		else
			gotoMarkerTarget= editor != null ? (IGotoMarker)editor.getAdapter(IGotoMarker.class) : null;
		if (gotoMarkerTarget != null) {
			final IEditorInput input= editor.getEditorInput();
			if (input instanceof IFileEditorInput) {
				WorkspaceModifyOperation op= new WorkspaceModifyOperation() {
					@Override
					protected void execute(IProgressMonitor monitor) throws CoreException {
						IMarker marker= null;
						try {
							marker= ((IFileEditorInput)input).getFile().createMarker(IMarker.TEXT);
							marker.setAttribute(IMarker.CHAR_START, offset);
							marker.setAttribute(IMarker.CHAR_END, offset + length);

							gotoMarkerTarget.gotoMarker(marker);

						} finally {
							if (marker != null)
								marker.delete();
						}
					}
				};

				try {
					op.run(null);
				} catch (InvocationTargetException ex) {
					// reveal failed
				} catch (InterruptedException e) {
					Assert.isTrue(false, "this operation can not be canceled"); //$NON-NLS-1$
				}
			}
			return;
		}
	}

}
