org.eclipse.mylyn.reviews.r4e.ui/src/org/eclipse/mylyn/reviews/r4e/ui/internal/editors/EditorProxy.java - r4e/org.eclipse.mylyn.reviews.r4e - Git at Google

 // $codepro.audit.disable com.instantiations.assist.eclipse.analysis.audit.rule.effectivejava.alwaysOverridetoString.alwaysOverrideToString, useForLoop, com.instantiations.assist.eclipse.analysis.deserializeabilitySecurity, com.instantiations.assist.eclipse.analysis.disallowReturnMutable, com.instantiations.assist.eclipse.analysis.enforceCloneableUsageSecurity
 /*******************************************************************************
  * Copyright (c) 2010, 2013 Ericsson AB 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
  *
  * Description:
  *
  * This class is used to access various eclipse editors from R4E model elements
  *
  * Contributors:
  *   Sebastien Dubois - Created for Mylyn Review R4E project
  *
  ******************************************************************************/

 package org.eclipse.mylyn.reviews.r4e.ui.internal.editors;

 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Iterator;

 import org.eclipse.compare.CompareEditorInput;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.core.runtime.content.IContentType;
 import org.eclipse.jface.text.ITextOperationTarget;
 import org.eclipse.jface.text.TextSelection;
 import org.eclipse.jface.text.source.SourceViewer;
 import org.eclipse.jface.util.OpenStrategy;
 import org.eclipse.jface.viewers.ISelection;
 import org.eclipse.jface.viewers.IStructuredSelection;
 import org.eclipse.mylyn.reviews.r4e.core.model.R4EFileVersion;
 import org.eclipse.mylyn.reviews.r4e.ui.R4EUIPlugin;
 import org.eclipse.mylyn.reviews.r4e.ui.internal.model.IR4EUIModelElement;
 import org.eclipse.mylyn.reviews.r4e.ui.internal.model.IR4EUIPosition;
 import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIAnomalyBasic;
 import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIComment;
 import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIContent;
 import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIFileContext;
 import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIReviewItem;
 import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUITextPosition;
 import org.eclipse.mylyn.reviews.r4e.ui.internal.utils.CommandUtils;
 import org.eclipse.mylyn.reviews.r4e.ui.internal.utils.UIUtils;
 import org.eclipse.ui.IEditorDescriptor;
 import org.eclipse.ui.IEditorPart;
 import org.eclipse.ui.IEditorReference;
 import org.eclipse.ui.IEditorRegistry;
 import org.eclipse.ui.IReusableEditor;
 import org.eclipse.ui.IStorageEditorInput;
 import org.eclipse.ui.IWorkbenchPage;
 import org.eclipse.ui.PartInitException;
 import org.eclipse.ui.PlatformUI;
 import org.eclipse.ui.texteditor.ITextEditor;

 /**
  * @author Sebastien Dubois
  * @version $Revision: 1.0 $
  */
 public class EditorProxy {

 	// ------------------------------------------------------------------------
 	// Constants
 	// ------------------------------------------------------------------------

 	/**
 	 * Field DEFAULT_EDITOR_NAME. (value is ""org.eclipse.ui.DefaultTextEditor"")
 	 */
 	private static final String DEFAULT_EDITOR_NAME = "org.eclipse.ui.DefaultTextEditor";

 	// ------------------------------------------------------------------------
 	// Methods
 	// ------------------------------------------------------------------------

 	/**
 	 * Method openEditor. Open the editor
 	 *
 	 * @param aPage
 	 *            IWorkbenchPage - the current workbench page
 	 * @param aSelection
 	 *            ISelection - the currently selected model element
 	 * @param aForceSingleEditor
 	 *            boolean - flag to force single editor
 	 * @throws CoreException
 	 */
 	public static IEditorPart openEditor(IWorkbenchPage aPage, ISelection aSelection, boolean aForceSingleEditor) {

 		IEditorPart editor = null;

 		if (aSelection.isEmpty() || !(aSelection instanceof IStructuredSelection)) {
 			return editor;
 		}

 		Object element = null;
 		IR4EUIPosition position = null;

 		R4EUIFileContext context = null;

 		for (final Iterator<?> iterator = ((IStructuredSelection) aSelection).iterator(); iterator.hasNext();) {

 			element = iterator.next();
 			if (!(element instanceof IR4EUIModelElement)) {
 				continue;
 			}

 			//Depending on which element was selected in the tree, we make the target file editable
 			//The file is editable if it was opened from the anomaly or comment level, otherwise it is not
 			//Check to get the position we should put the cursor on and the highlight range in the editor
 			if (element instanceof R4EUIAnomalyBasic) {
 				position = ((R4EUIAnomalyBasic) element).getPosition();
 			} else if (element instanceof R4EUIComment) {
 				position = ((R4EUIAnomalyBasic) ((R4EUIComment) element).getParent()).getPosition();
 			} else if (element instanceof R4EUIContent) {
 				position = ((R4EUIContent) element).getPosition();
 			}

 			//Find the parent FileContextElement
 			while (!(element instanceof R4EUIFileContext)) {
 				element = ((IR4EUIModelElement) element).getParent();
 				if (null == element) {
 					return editor;
 				}
 			}
 			context = ((R4EUIFileContext) element);

 			//If the files are the same (or do not exist), open the single editor
 			if (null == context.getBaseFileVersion()
 					|| null == context.getTargetFileVersion()
 					|| context.getBaseFileVersion()
 							.getVersionID()
 							.equals(context.getTargetFileVersion().getVersionID())) {
 				aForceSingleEditor = true;
 			}

 			//Check if the base file is set, if so, we will use the compare editor.  Otherwise we use the normal editor of the appropriate type
 			if (context.isFileVersionsComparable() && !aForceSingleEditor) {
 				editor = openCompareEditor(aPage, context);
 			} else {
 				editor = openSingleEditor(aPage, context, position);
 			}
 		}
 		return editor;
 	}

 	/**
 	 * Method openReviewItemCompareEditor. Open the compare editor to compare Review Items
 	 *
 	 * @param aPage
 	 *            IWorkbenchPage - the current workbench page
 	 * @param aTargetItem
 	 *            R4EUIReviewItem - the currently selected target (newer) Review Item
 	 * @param aBaseItem
 	 *            R4EUIReviewItem - the currently selected base (older) Review Item
 	 * @throws CoreException
 	 */
 	public static IEditorPart openReviewItemCompareEditor(IWorkbenchPage aPage, R4EUIReviewItem aTargetItem,
 			R4EUIReviewItem aBaseItem) {

 		//Reuse editor if it is already open on the same input
 		CompareEditorInput input = null;
 		IEditorPart editor = findReusableReviewItemCompareEditor(aPage, aTargetItem, aBaseItem);

 		if (null != editor) {
 			//First try to activate current editor.  If it is not possible to display the element in the editor, reuse it if possible, or worse case close and re-open it
 			aPage.activate(editor);
 			if (!UIUtils.selectElementInEditor((R4EReviewItemCompareEditorInput) editor.getEditorInput())) {
 				//Reuse editor whenever possible, otherwise close and re-open it
 				if (editor instanceof IReusableEditor) {
 					aPage.reuseEditor((IReusableEditor) editor, new R4EReviewItemCompareEditorInput(aTargetItem,
 							aBaseItem));
 					//NOTE:  The position is set in editor in R4ECompareEditorInput#createContents TODO
 					return editor;
 				} else {
 					aPage.closeEditor(editor, true); //Close current editor
 				}
 			} else {
 				return editor;
 			}
 		}

 		input = new R4EReviewItemCompareEditorInput(aTargetItem, aBaseItem);

 		R4EUIPlugin.Ftracer.traceInfo("Open compare editor on Review Items "
 				+ ((null != aTargetItem) ? aTargetItem.getItem().getId() : "") + " (Target) and "
 				+ ((null != aBaseItem) ? aBaseItem.getItem().getId() : "") + " (Base)");
 		try {
 			editor = aPage.openEditor(input, "org.eclipse.compare.CompareEditor", OpenStrategy.activateOnOpen());
 		} catch (PartInitException e) {
 			R4EUIPlugin.Ftracer.traceError("Exception: " + e.toString() + " (" + e.getMessage() + ")");
 			R4EUIPlugin.getDefault().logError("Exception: " + e.toString(), e);
 		}
 		//NOTE:  The position is set in editor in R4ECompareEditorInput#createContents TODO
 		return editor;
 	}

 	/**
 	 * Method openSingleEditor. Open the single-mode default editor for the file type
 	 *
 	 * @param aPage
 	 *            IWorkbenchPage - the current workbench page
 	 * @param aContext
 	 *            R4EUIFileContext - the file context
 	 * @param aPosition
 	 *            IR4EUIPosition - the position to go to in the file
 	 * @return IEditorPart
 	 */
 	private static IEditorPart openSingleEditor(IWorkbenchPage aPage, R4EUIFileContext aContext,
 			IR4EUIPosition aPosition) {

 		R4EFileVersion version;
 		IEditorPart editor = null;
 		if (null != aContext.getTargetFileVersion()) {
 			version = aContext.getTargetFileVersion();
 		} else if (null != aContext.getBaseFileVersion()) {
 			//File was removed, open the base then
 			version = aContext.getBaseFileVersion();
 		} else {
 			//Show the error, the file was in another project and was not
 			//found when creating the commit review item
 			String error = "Base and target file version not found for this review item";
 			R4EUIPlugin.Ftracer.traceError("Exception: " + error);
 			CoreException exception = new CoreException(new Status(IStatus.ERROR, R4EUIPlugin.PLUGIN_ID, error));
 			//Display the error, but do not log in the error log
 			UIUtils.displayCoreErrorDialog(exception, false);
 			return editor;
 		}

 		try {
 			IStorageEditorInput editorInput = null;

 			//NOTE:  We use the workspace file as input if it is in sync with the file to review,
 			//		 otherwise we use the file to review that is included in the review repository
 			if (CommandUtils.useWorkspaceResource(version)) {
 				editorInput = new R4EFileEditorInput(version);
 			} else {
 				editorInput = new R4EFileRevisionEditorInput(version);
 			}
 			final String id = getEditorId(editorInput.getName(),
 					getContentType(editorInput.getName(), editorInput.getStorage().getContents()));
 			editor = aPage.openEditor(editorInput, id, OpenStrategy.activateOnOpen());
 			final ITextOperationTarget target = (ITextOperationTarget) editor.getAdapter(ITextOperationTarget.class);
 			if (target instanceof SourceViewer) {
 				final SourceViewer sourceViewer = (SourceViewer) target;
 				UIUtils.getSingleAnnotationSupport(sourceViewer, aContext);
 			}

 			//Set highlighted selection and reset cursor if possible
 			if (editor instanceof ITextEditor && aPosition instanceof R4EUITextPosition) {
 				final int offset = ((R4EUITextPosition) aPosition).getOffset();
 				final int length = ((R4EUITextPosition) aPosition).getLength();
 				((ITextEditor) editor).setHighlightRange(offset, length, true);
 				final TextSelection selectedText = new TextSelection(offset, length);
 				((ITextEditor) editor).getSelectionProvider().setSelection(selectedText);
 			}
 		} catch (CoreException e) {
 			UIUtils.displayCoreErrorDialog(e);
 		}
 		return editor;
 	}

 	/**
 	 * Method openCompareEditor. Open the compare-mode default editor for the file types
 	 *
 	 * @param aPage
 	 *            IWorkbenchPage - the current workbench page
 	 * @param aContext
 	 *            R4EUIFileContext - the file Context (base and target) to open
 	 * @return IEditorPart
 	 */
 	private static IEditorPart openCompareEditor(IWorkbenchPage aPage, R4EUIFileContext aContext) {
 		//Reuse editor if it is already open on the same input
 		CompareEditorInput input = null;
 		IEditorPart editor = findReusableFileContextCompareEditor(aPage, aContext.getTargetFileVersion(),
 				aContext.getBaseFileVersion());

 		if (null != editor) {
 			//First try to activate current editor.  If it is not possible to display the element in the editor, reuse it if possible, or worse case close and re-open it
 			aPage.activate(editor);
 			if (!UIUtils.selectElementInEditor((R4EFileContextCompareEditorInput) editor.getEditorInput())) {
 				//Reuse editor whenever possible, otherwise close and re-open it
 				if (editor instanceof IReusableEditor) {
 					aPage.reuseEditor((IReusableEditor) editor, new R4EFileContextCompareEditorInput(aContext));
 					//NOTE:  The position is set in editor in R4ECompareEditorInput#createContents
 					return editor;
 				} else {
 					aPage.closeEditor(editor, true); //Close current editor
 				}
 			} else {
 				return editor;
 			}
 		}
 		input = new R4EFileContextCompareEditorInput(aContext);

 		R4EUIPlugin.Ftracer.traceInfo("Open compare editor on files "
 				+ ((null != aContext.getTargetFileVersion()) ? aContext.getTargetFileVersion().getName() : "")
 				+ " (Target) and "
 				+ ((null != aContext.getBaseFileVersion()) ? aContext.getBaseFileVersion().getName() : "") + " (Base)");
 		try {
 			editor = aPage.openEditor(input, "org.eclipse.compare.CompareEditor", OpenStrategy.activateOnOpen());
 		} catch (PartInitException e) {
 			R4EUIPlugin.Ftracer.traceError("Exception: " + e.toString() + " (" + e.getMessage() + ")");
 			R4EUIPlugin.getDefault().logError("Exception: " + e.toString(), e);
 		}
 		//NOTE:  The position is set in editor in R4ECompareEditorInput#createContents
 		return editor;
 	}

 	/**
 	 * Method findReusableCompareEditor. Find the appropriate file context compare editor based on the file types
 	 *
 	 * @param aPage
 	 *            IWorkbenchPage - the current workbench page
 	 * @param aTargetFile
 	 *            R4EFileVersion - the target file version
 	 * @param aBaseFile
 	 *            R4EFileVersion - the base (or reference) file version
 	 * @return IEditorPart - the editor to use
 	 */
 	public static IEditorPart findReusableFileContextCompareEditor(IWorkbenchPage aPage, R4EFileVersion aTargetFile,
 			R4EFileVersion aBaseFile) {

 		final IEditorReference[] editorRefs = aPage.getEditorReferences();
 		IEditorPart part = null;
 		R4EFileContextCompareEditorInput input = null;
 		// first loop looking for an editor with the same input
 		for (IEditorReference editorRef : editorRefs) {
 			part = editorRef.getEditor(false);
 			if (null != part && part instanceof IReusableEditor) {
 				// check if the editor input type complies with the types given by the caller
 				if (R4EFileContextCompareEditorInput.class.isInstance(part.getEditorInput())) {
 					//Now check if the input files are the same as with the found editor
 					input = (R4EFileContextCompareEditorInput) part.getEditorInput();
 					R4EFileVersion leftVersion = input.getCurrentDiffNode().getTargetVersion();
 					R4EFileVersion rightVersion = input.getCurrentDiffNode().getBaseVersion();

 					//Case:  No input in editor, that should never happen but guard here just in case
 					if (null == leftVersion && null == rightVersion) {
 						return null;
 					}

 					//Case:  No target file and base is the same
 					if (null == leftVersion && null == aTargetFile && null != rightVersion && null != aBaseFile
 							&& rightVersion.equals(aBaseFile)) {
 						return part;
 					}

 					//Case:  No base file and target is the same
 					if (null == rightVersion && null == aBaseFile && null != leftVersion && null != aTargetFile
 							&& leftVersion.equals(aTargetFile)) {
 						return part;
 					}

 					//Case: Base and target are the same
 					if (null != leftVersion && null != rightVersion && null != aBaseFile && null != aTargetFile) {
 						if (CommandUtils.isSameFileVersion(leftVersion, aTargetFile)
 								&& CommandUtils.isSameFileVersion(rightVersion, aBaseFile)) {
 							return part;
 						}
 					}
 				}
 			}
 		}
 		// no re-usable editor found
 		return null;
 	}

 	/**
 	 * Method findReusableCompareEditor. Find the appropriate Review Item compare editor based on the file types
 	 *
 	 * @param aPage
 	 *            IWorkbenchPage - the current workbench page
 	 * @param aTargetItem
 	 *            R4EUIReviewItem - the target review item
 	 * @param aBaseItem
 	 *            R4EUIReviewItem - the base (or reference) review item
 	 * @return IEditorPart - the editor to use
 	 */
 	public static IEditorPart findReusableReviewItemCompareEditor(IWorkbenchPage aPage, R4EUIReviewItem aTargetItem,
 			R4EUIReviewItem aBaseItem) {

 		final IEditorReference[] editorRefs = aPage.getEditorReferences();
 		IEditorPart part = null;
 		R4EReviewItemCompareEditorInput input = null;
 		// first loop looking for an editor with the same input
 		for (IEditorReference editorRef : editorRefs) {
 			part = editorRef.getEditor(false);
 			if (null != part && part instanceof IReusableEditor) {
 				// check if the editor input type complies with the types given by the caller
 				if (R4EReviewItemCompareEditorInput.class.isInstance(part.getEditorInput())) {
 					//Now check if the input files are the same as with the found editor
 					input = (R4EReviewItemCompareEditorInput) part.getEditorInput();
 					if ((aBaseItem == null || aBaseItem.equals(input.getBaseReviewItem()))
 							&& aTargetItem.equals(input.getTargetReviewItem())) {
 						return part;
 					}
 				}
 			}
 		}
 		// no re-usable editor found
 		return null;
 	}

 	/**
 	 * Method getReviewItemCompareEditorPart. Find the appropriate editor for this review item
 	 *
 	 * @param aPage
 	 *            IWorkbenchPage - the current workbench page
 	 * @param aItem
 	 *            R4EUIReviewItem - the target review item
 	 * @return IEditorPart - the editor to use
 	 */
 	public static IEditorPart getReviewItemCompareEditorPart(IWorkbenchPage aPage, R4EUIReviewItem aItem) {
 		final IEditorReference[] editorRefs = aPage.getEditorReferences();
 		IEditorPart part = null;
 		R4EReviewItemCompareEditorInput input = null;
 		// first loop looking for an editor with the same input
 		for (IEditorReference editorRef : editorRefs) {
 			part = editorRef.getEditor(false);
 			if (null != part && part instanceof IReusableEditor) {
 				// check if the editor input type complies with the types given by the caller
 				if (R4EReviewItemCompareEditorInput.class.isInstance(part.getEditorInput())) {
 					//Now check if the input review item is the same as with the found editor
 					input = (R4EReviewItemCompareEditorInput) part.getEditorInput();
 					if (aItem.equals(input.getTargetReviewItem()) || aItem.equals(input.getBaseReviewItem())) {
 						return part;
 					}
 				}
 			}
 		}
 		// no re-usable editor found
 		return null;
 	}

 	/**
 	 * Method findReusableEditor. Find the appropriate editor based on the file types
 	 *
 	 * @param aPage
 	 *            IWorkbenchPage - the current workbench page
 	 * @param aFile
 	 *            R4EFileVersion - the target file version
 	 * @return IEditorPart - the editor to use
 	 */
 	public static IEditorPart findReusableEditor(IWorkbenchPage aPage, R4EFileVersion aFileVersion) {

 		final IEditorReference[] editorRefs = aPage.getEditorReferences();
 		IEditorPart part = null;
 		// first loop looking for an editor with the same input
 		for (IEditorReference editorRef : editorRefs) {
 			part = editorRef.getEditor(false);
 			if (null != part) {
 				// check if the editor input type complies with the types given by the caller
 				if (R4EFileEditorInput.class.isInstance(part.getEditorInput())) {
 					//Now check if the input files are the same as with the found editor
 					R4EFileEditorInput input = (R4EFileEditorInput) part.getEditorInput();

 					//Case:  No input in editor, that should never happen but guard here just in case
 					if (null != input) {

 						//Get the file version
 						R4EFileVersion fileVersion = input.getFileVersion();
 						if (null != fileVersion && null != aFileVersion
 								&& CommandUtils.isSameFileVersion(fileVersion, aFileVersion)) {
 							return part;
 						}
 					}
 				} else if (R4EFileRevisionEditorInput.class.isInstance(part.getEditorInput())) {
 					//Now check if the input files are the same as with the found editor
 					R4EFileRevisionEditorInput input = (R4EFileRevisionEditorInput) part.getEditorInput();

 					//Case:  No input in editor, that should never happen but guard here just in case
 					if (null != input) {

 						//Get the file version
 						R4EFileVersion fileVersion = input.getFileVersion();
 						if (null != fileVersion && null != aFileVersion
 								&& CommandUtils.isSameFileVersion(fileVersion, aFileVersion)) {
 							return part;
 						}
 					}
 				}
 			}
 		}
 		// no re-usable editor found
 		return null;
 	}

 	/**
 	 * Method getEditorId.
 	 *
 	 * @param aFileName
 	 *            String
 	 * @param aType
 	 *            IContentType
 	 * @return String
 	 */
 	private static String getEditorId(String aFileName, IContentType aType) {
 		final IEditorRegistry registry = PlatformUI.getWorkbench().getEditorRegistry();
 		final IEditorDescriptor descriptor = registry.getDefaultEditor(aFileName, aType);
 		String id = null;
 		if (null == descriptor || descriptor.isOpenExternal()) {
 			id = DEFAULT_EDITOR_NAME;
 		} else {
 			id = descriptor.getId();
 		}
 		return id;
 	}

 	/**
 	 * Method getContentType.
 	 *
 	 * @param aFileName
 	 *            String
 	 * @param aContents
 	 *            InputStream
 	 * @return IContentType
 	 */
 	private static IContentType getContentType(String aFileName, InputStream aContents) {
 		IContentType type = null;
 		if (null != aContents) {
 			try {
 				type = Platform.getContentTypeManager().findContentTypeFor(aContents, aFileName);
 			} catch (IOException e) {
 				R4EUIPlugin.Ftracer.traceError("Exception: " + e.toString() + " (" + e.getMessage() + ")");
 				R4EUIPlugin.getDefault().logError("Exception: " + e.toString(), e);
 			}
 		}
 		if (null == type) {
 			type = Platform.getContentTypeManager().findContentTypeFor(aFileName);
 		}
 		return type;
 	}
 }
	// $codepro.audit.disable com.instantiations.assist.eclipse.analysis.audit.rule.effectivejava.alwaysOverridetoString.alwaysOverrideToString, useForLoop, com.instantiations.assist.eclipse.analysis.deserializeabilitySecurity, com.instantiations.assist.eclipse.analysis.disallowReturnMutable, com.instantiations.assist.eclipse.analysis.enforceCloneableUsageSecurity
	/*******************************************************************************
	* Copyright (c) 2010, 2013 Ericsson AB 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
	*
	* Description:
	*
	* This class is used to access various eclipse editors from R4E model elements
	*
	* Contributors:
	* Sebastien Dubois - Created for Mylyn Review R4E project
	*
	******************************************************************************/

	package org.eclipse.mylyn.reviews.r4e.ui.internal.editors;

	import java.io.IOException;
	import java.io.InputStream;
	import java.util.Iterator;

	import org.eclipse.compare.CompareEditorInput;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.Platform;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.core.runtime.content.IContentType;
	import org.eclipse.jface.text.ITextOperationTarget;
	import org.eclipse.jface.text.TextSelection;
	import org.eclipse.jface.text.source.SourceViewer;
	import org.eclipse.jface.util.OpenStrategy;
	import org.eclipse.jface.viewers.ISelection;
	import org.eclipse.jface.viewers.IStructuredSelection;
	import org.eclipse.mylyn.reviews.r4e.core.model.R4EFileVersion;
	import org.eclipse.mylyn.reviews.r4e.ui.R4EUIPlugin;
	import org.eclipse.mylyn.reviews.r4e.ui.internal.model.IR4EUIModelElement;
	import org.eclipse.mylyn.reviews.r4e.ui.internal.model.IR4EUIPosition;
	import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIAnomalyBasic;
	import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIComment;
	import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIContent;
	import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIFileContext;
	import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIReviewItem;
	import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUITextPosition;
	import org.eclipse.mylyn.reviews.r4e.ui.internal.utils.CommandUtils;
	import org.eclipse.mylyn.reviews.r4e.ui.internal.utils.UIUtils;
	import org.eclipse.ui.IEditorDescriptor;
	import org.eclipse.ui.IEditorPart;
	import org.eclipse.ui.IEditorReference;
	import org.eclipse.ui.IEditorRegistry;
	import org.eclipse.ui.IReusableEditor;
	import org.eclipse.ui.IStorageEditorInput;
	import org.eclipse.ui.IWorkbenchPage;
	import org.eclipse.ui.PartInitException;
	import org.eclipse.ui.PlatformUI;
	import org.eclipse.ui.texteditor.ITextEditor;

	/**
	* @author Sebastien Dubois
	* @version $Revision: 1.0 $
	*/
	public class EditorProxy {

	// ------------------------------------------------------------------------
	// Constants
	// ------------------------------------------------------------------------

	/**
	* Field DEFAULT_EDITOR_NAME. (value is ""org.eclipse.ui.DefaultTextEditor"")
	*/
	private static final String DEFAULT_EDITOR_NAME = "org.eclipse.ui.DefaultTextEditor";

	// ------------------------------------------------------------------------
	// Methods
	// ------------------------------------------------------------------------

	/**
	* Method openEditor. Open the editor
	*
	* @param aPage
	* IWorkbenchPage - the current workbench page
	* @param aSelection
	* ISelection - the currently selected model element
	* @param aForceSingleEditor
	* boolean - flag to force single editor
	* @throws CoreException
	*/
	public static IEditorPart openEditor(IWorkbenchPage aPage, ISelection aSelection, boolean aForceSingleEditor) {

	IEditorPart editor = null;

	if (aSelection.isEmpty() \|\| !(aSelection instanceof IStructuredSelection)) {
	return editor;
	}

	Object element = null;
	IR4EUIPosition position = null;

	R4EUIFileContext context = null;

	for (final Iterator<?> iterator = ((IStructuredSelection) aSelection).iterator(); iterator.hasNext();) {

	element = iterator.next();
	if (!(element instanceof IR4EUIModelElement)) {
	continue;
	}

	//Depending on which element was selected in the tree, we make the target file editable
	//The file is editable if it was opened from the anomaly or comment level, otherwise it is not
	//Check to get the position we should put the cursor on and the highlight range in the editor
	if (element instanceof R4EUIAnomalyBasic) {
	position = ((R4EUIAnomalyBasic) element).getPosition();
	} else if (element instanceof R4EUIComment) {
	position = ((R4EUIAnomalyBasic) ((R4EUIComment) element).getParent()).getPosition();
	} else if (element instanceof R4EUIContent) {
	position = ((R4EUIContent) element).getPosition();
	}

	//Find the parent FileContextElement
	while (!(element instanceof R4EUIFileContext)) {
	element = ((IR4EUIModelElement) element).getParent();
	if (null == element) {
	return editor;
	}
	}
	context = ((R4EUIFileContext) element);

	//If the files are the same (or do not exist), open the single editor
	if (null == context.getBaseFileVersion()
	\|\| null == context.getTargetFileVersion()
	\|\| context.getBaseFileVersion()
	.getVersionID()
	.equals(context.getTargetFileVersion().getVersionID())) {
	aForceSingleEditor = true;
	}

	//Check if the base file is set, if so, we will use the compare editor. Otherwise we use the normal editor of the appropriate type
	if (context.isFileVersionsComparable() && !aForceSingleEditor) {
	editor = openCompareEditor(aPage, context);
	} else {
	editor = openSingleEditor(aPage, context, position);
	}
	}
	return editor;
	}

	/**
	* Method openReviewItemCompareEditor. Open the compare editor to compare Review Items
	*
	* @param aPage
	* IWorkbenchPage - the current workbench page
	* @param aTargetItem
	* R4EUIReviewItem - the currently selected target (newer) Review Item
	* @param aBaseItem
	* R4EUIReviewItem - the currently selected base (older) Review Item
	* @throws CoreException
	*/
	public static IEditorPart openReviewItemCompareEditor(IWorkbenchPage aPage, R4EUIReviewItem aTargetItem,
	R4EUIReviewItem aBaseItem) {

	//Reuse editor if it is already open on the same input
	CompareEditorInput input = null;
	IEditorPart editor = findReusableReviewItemCompareEditor(aPage, aTargetItem, aBaseItem);

	if (null != editor) {
	//First try to activate current editor. If it is not possible to display the element in the editor, reuse it if possible, or worse case close and re-open it
	aPage.activate(editor);
	if (!UIUtils.selectElementInEditor((R4EReviewItemCompareEditorInput) editor.getEditorInput())) {
	//Reuse editor whenever possible, otherwise close and re-open it
	if (editor instanceof IReusableEditor) {
	aPage.reuseEditor((IReusableEditor) editor, new R4EReviewItemCompareEditorInput(aTargetItem,
	aBaseItem));
	//NOTE: The position is set in editor in R4ECompareEditorInput#createContents TODO
	return editor;
	} else {
	aPage.closeEditor(editor, true); //Close current editor
	}
	} else {
	return editor;
	}
	}

	input = new R4EReviewItemCompareEditorInput(aTargetItem, aBaseItem);

	R4EUIPlugin.Ftracer.traceInfo("Open compare editor on Review Items "
	+ ((null != aTargetItem) ? aTargetItem.getItem().getId() : "") + " (Target) and "
	+ ((null != aBaseItem) ? aBaseItem.getItem().getId() : "") + " (Base)");
	try {
	editor = aPage.openEditor(input, "org.eclipse.compare.CompareEditor", OpenStrategy.activateOnOpen());
	} catch (PartInitException e) {
	R4EUIPlugin.Ftracer.traceError("Exception: " + e.toString() + " (" + e.getMessage() + ")");
	R4EUIPlugin.getDefault().logError("Exception: " + e.toString(), e);
	}
	//NOTE: The position is set in editor in R4ECompareEditorInput#createContents TODO
	return editor;
	}

	/**
	* Method openSingleEditor. Open the single-mode default editor for the file type
	*
	* @param aPage
	* IWorkbenchPage - the current workbench page
	* @param aContext
	* R4EUIFileContext - the file context
	* @param aPosition
	* IR4EUIPosition - the position to go to in the file
	* @return IEditorPart
	*/
	private static IEditorPart openSingleEditor(IWorkbenchPage aPage, R4EUIFileContext aContext,
	IR4EUIPosition aPosition) {

	R4EFileVersion version;
	IEditorPart editor = null;
	if (null != aContext.getTargetFileVersion()) {
	version = aContext.getTargetFileVersion();
	} else if (null != aContext.getBaseFileVersion()) {
	//File was removed, open the base then
	version = aContext.getBaseFileVersion();
	} else {
	//Show the error, the file was in another project and was not
	//found when creating the commit review item
	String error = "Base and target file version not found for this review item";
	R4EUIPlugin.Ftracer.traceError("Exception: " + error);
	CoreException exception = new CoreException(new Status(IStatus.ERROR, R4EUIPlugin.PLUGIN_ID, error));
	//Display the error, but do not log in the error log
	UIUtils.displayCoreErrorDialog(exception, false);
	return editor;
	}

	try {
	IStorageEditorInput editorInput = null;

	//NOTE: We use the workspace file as input if it is in sync with the file to review,
	// otherwise we use the file to review that is included in the review repository
	if (CommandUtils.useWorkspaceResource(version)) {
	editorInput = new R4EFileEditorInput(version);
	} else {
	editorInput = new R4EFileRevisionEditorInput(version);
	}
	final String id = getEditorId(editorInput.getName(),
	getContentType(editorInput.getName(), editorInput.getStorage().getContents()));
	editor = aPage.openEditor(editorInput, id, OpenStrategy.activateOnOpen());
	final ITextOperationTarget target = (ITextOperationTarget) editor.getAdapter(ITextOperationTarget.class);
	if (target instanceof SourceViewer) {
	final SourceViewer sourceViewer = (SourceViewer) target;
	UIUtils.getSingleAnnotationSupport(sourceViewer, aContext);
	}

	//Set highlighted selection and reset cursor if possible
	if (editor instanceof ITextEditor && aPosition instanceof R4EUITextPosition) {
	final int offset = ((R4EUITextPosition) aPosition).getOffset();
	final int length = ((R4EUITextPosition) aPosition).getLength();
	((ITextEditor) editor).setHighlightRange(offset, length, true);
	final TextSelection selectedText = new TextSelection(offset, length);
	((ITextEditor) editor).getSelectionProvider().setSelection(selectedText);
	}
	} catch (CoreException e) {
	UIUtils.displayCoreErrorDialog(e);
	}
	return editor;
	}

	/**
	* Method openCompareEditor. Open the compare-mode default editor for the file types
	*
	* @param aPage
	* IWorkbenchPage - the current workbench page
	* @param aContext
	* R4EUIFileContext - the file Context (base and target) to open
	* @return IEditorPart
	*/
	private static IEditorPart openCompareEditor(IWorkbenchPage aPage, R4EUIFileContext aContext) {
	//Reuse editor if it is already open on the same input
	CompareEditorInput input = null;
	IEditorPart editor = findReusableFileContextCompareEditor(aPage, aContext.getTargetFileVersion(),
	aContext.getBaseFileVersion());

	if (null != editor) {
	//First try to activate current editor. If it is not possible to display the element in the editor, reuse it if possible, or worse case close and re-open it
	aPage.activate(editor);
	if (!UIUtils.selectElementInEditor((R4EFileContextCompareEditorInput) editor.getEditorInput())) {
	//Reuse editor whenever possible, otherwise close and re-open it
	if (editor instanceof IReusableEditor) {
	aPage.reuseEditor((IReusableEditor) editor, new R4EFileContextCompareEditorInput(aContext));
	//NOTE: The position is set in editor in R4ECompareEditorInput#createContents
	return editor;
	} else {
	aPage.closeEditor(editor, true); //Close current editor
	}
	} else {
	return editor;
	}
	}
	input = new R4EFileContextCompareEditorInput(aContext);

	R4EUIPlugin.Ftracer.traceInfo("Open compare editor on files "
	+ ((null != aContext.getTargetFileVersion()) ? aContext.getTargetFileVersion().getName() : "")
	+ " (Target) and "
	+ ((null != aContext.getBaseFileVersion()) ? aContext.getBaseFileVersion().getName() : "") + " (Base)");
	try {
	editor = aPage.openEditor(input, "org.eclipse.compare.CompareEditor", OpenStrategy.activateOnOpen());
	} catch (PartInitException e) {
	R4EUIPlugin.Ftracer.traceError("Exception: " + e.toString() + " (" + e.getMessage() + ")");
	R4EUIPlugin.getDefault().logError("Exception: " + e.toString(), e);
	}
	//NOTE: The position is set in editor in R4ECompareEditorInput#createContents
	return editor;
	}

	/**
	* Method findReusableCompareEditor. Find the appropriate file context compare editor based on the file types
	*
	* @param aPage
	* IWorkbenchPage - the current workbench page
	* @param aTargetFile
	* R4EFileVersion - the target file version
	* @param aBaseFile
	* R4EFileVersion - the base (or reference) file version
	* @return IEditorPart - the editor to use
	*/
	public static IEditorPart findReusableFileContextCompareEditor(IWorkbenchPage aPage, R4EFileVersion aTargetFile,
	R4EFileVersion aBaseFile) {

	final IEditorReference[] editorRefs = aPage.getEditorReferences();
	IEditorPart part = null;
	R4EFileContextCompareEditorInput input = null;
	// first loop looking for an editor with the same input
	for (IEditorReference editorRef : editorRefs) {
	part = editorRef.getEditor(false);
	if (null != part && part instanceof IReusableEditor) {
	// check if the editor input type complies with the types given by the caller
	if (R4EFileContextCompareEditorInput.class.isInstance(part.getEditorInput())) {
	//Now check if the input files are the same as with the found editor
	input = (R4EFileContextCompareEditorInput) part.getEditorInput();
	R4EFileVersion leftVersion = input.getCurrentDiffNode().getTargetVersion();
	R4EFileVersion rightVersion = input.getCurrentDiffNode().getBaseVersion();

	//Case: No input in editor, that should never happen but guard here just in case
	if (null == leftVersion && null == rightVersion) {
	return null;
	}

	//Case: No target file and base is the same
	if (null == leftVersion && null == aTargetFile && null != rightVersion && null != aBaseFile
	&& rightVersion.equals(aBaseFile)) {
	return part;
	}

	//Case: No base file and target is the same
	if (null == rightVersion && null == aBaseFile && null != leftVersion && null != aTargetFile
	&& leftVersion.equals(aTargetFile)) {
	return part;
	}

	//Case: Base and target are the same
	if (null != leftVersion && null != rightVersion && null != aBaseFile && null != aTargetFile) {
	if (CommandUtils.isSameFileVersion(leftVersion, aTargetFile)
	&& CommandUtils.isSameFileVersion(rightVersion, aBaseFile)) {
	return part;
	}
	}
	}
	}
	}
	// no re-usable editor found
	return null;
	}

	/**
	* Method findReusableCompareEditor. Find the appropriate Review Item compare editor based on the file types
	*
	* @param aPage
	* IWorkbenchPage - the current workbench page
	* @param aTargetItem
	* R4EUIReviewItem - the target review item
	* @param aBaseItem
	* R4EUIReviewItem - the base (or reference) review item
	* @return IEditorPart - the editor to use
	*/
	public static IEditorPart findReusableReviewItemCompareEditor(IWorkbenchPage aPage, R4EUIReviewItem aTargetItem,
	R4EUIReviewItem aBaseItem) {

	final IEditorReference[] editorRefs = aPage.getEditorReferences();
	IEditorPart part = null;
	R4EReviewItemCompareEditorInput input = null;
	// first loop looking for an editor with the same input
	for (IEditorReference editorRef : editorRefs) {
	part = editorRef.getEditor(false);
	if (null != part && part instanceof IReusableEditor) {
	// check if the editor input type complies with the types given by the caller
	if (R4EReviewItemCompareEditorInput.class.isInstance(part.getEditorInput())) {
	//Now check if the input files are the same as with the found editor
	input = (R4EReviewItemCompareEditorInput) part.getEditorInput();
	if ((aBaseItem == null \|\| aBaseItem.equals(input.getBaseReviewItem()))
	&& aTargetItem.equals(input.getTargetReviewItem())) {
	return part;
	}
	}
	}
	}
	// no re-usable editor found
	return null;
	}

	/**
	* Method getReviewItemCompareEditorPart. Find the appropriate editor for this review item
	*
	* @param aPage
	* IWorkbenchPage - the current workbench page
	* @param aItem
	* R4EUIReviewItem - the target review item
	* @return IEditorPart - the editor to use
	*/
	public static IEditorPart getReviewItemCompareEditorPart(IWorkbenchPage aPage, R4EUIReviewItem aItem) {
	final IEditorReference[] editorRefs = aPage.getEditorReferences();
	IEditorPart part = null;
	R4EReviewItemCompareEditorInput input = null;
	// first loop looking for an editor with the same input
	for (IEditorReference editorRef : editorRefs) {
	part = editorRef.getEditor(false);
	if (null != part && part instanceof IReusableEditor) {
	// check if the editor input type complies with the types given by the caller
	if (R4EReviewItemCompareEditorInput.class.isInstance(part.getEditorInput())) {
	//Now check if the input review item is the same as with the found editor
	input = (R4EReviewItemCompareEditorInput) part.getEditorInput();
	if (aItem.equals(input.getTargetReviewItem()) \|\| aItem.equals(input.getBaseReviewItem())) {
	return part;
	}
	}
	}
	}
	// no re-usable editor found
	return null;
	}

	/**
	* Method findReusableEditor. Find the appropriate editor based on the file types
	*
	* @param aPage
	* IWorkbenchPage - the current workbench page
	* @param aFile
	* R4EFileVersion - the target file version
	* @return IEditorPart - the editor to use
	*/
	public static IEditorPart findReusableEditor(IWorkbenchPage aPage, R4EFileVersion aFileVersion) {

	final IEditorReference[] editorRefs = aPage.getEditorReferences();
	IEditorPart part = null;
	// first loop looking for an editor with the same input
	for (IEditorReference editorRef : editorRefs) {
	part = editorRef.getEditor(false);
	if (null != part) {
	// check if the editor input type complies with the types given by the caller
	if (R4EFileEditorInput.class.isInstance(part.getEditorInput())) {
	//Now check if the input files are the same as with the found editor
	R4EFileEditorInput input = (R4EFileEditorInput) part.getEditorInput();

	//Case: No input in editor, that should never happen but guard here just in case
	if (null != input) {

	//Get the file version
	R4EFileVersion fileVersion = input.getFileVersion();
	if (null != fileVersion && null != aFileVersion
	&& CommandUtils.isSameFileVersion(fileVersion, aFileVersion)) {
	return part;
	}
	}
	} else if (R4EFileRevisionEditorInput.class.isInstance(part.getEditorInput())) {
	//Now check if the input files are the same as with the found editor
	R4EFileRevisionEditorInput input = (R4EFileRevisionEditorInput) part.getEditorInput();

	//Case: No input in editor, that should never happen but guard here just in case
	if (null != input) {

	//Get the file version
	R4EFileVersion fileVersion = input.getFileVersion();
	if (null != fileVersion && null != aFileVersion
	&& CommandUtils.isSameFileVersion(fileVersion, aFileVersion)) {
	return part;
	}
	}
	}
	}
	}
	// no re-usable editor found
	return null;
	}

	/**
	* Method getEditorId.
	*
	* @param aFileName
	* String
	* @param aType
	* IContentType
	* @return String
	*/
	private static String getEditorId(String aFileName, IContentType aType) {
	final IEditorRegistry registry = PlatformUI.getWorkbench().getEditorRegistry();
	final IEditorDescriptor descriptor = registry.getDefaultEditor(aFileName, aType);
	String id = null;
	if (null == descriptor \|\| descriptor.isOpenExternal()) {
	id = DEFAULT_EDITOR_NAME;
	} else {
	id = descriptor.getId();
	}
	return id;
	}

	/**
	* Method getContentType.
	*
	* @param aFileName
	* String
	* @param aContents
	* InputStream
	* @return IContentType
	*/
	private static IContentType getContentType(String aFileName, InputStream aContents) {
	IContentType type = null;
	if (null != aContents) {
	try {
	type = Platform.getContentTypeManager().findContentTypeFor(aContents, aFileName);
	} catch (IOException e) {
	R4EUIPlugin.Ftracer.traceError("Exception: " + e.toString() + " (" + e.getMessage() + ")");
	R4EUIPlugin.getDefault().logError("Exception: " + e.toString(), e);
	}
	}
	if (null == type) {
	type = Platform.getContentTypeManager().findContentTypeFor(aFileName);
	}
	return type;
	}
	}