org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javaeditor/ClipboardOperationAction.java - jdt/eclipse.jdt.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2011 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.jdt.internal.ui.javaeditor;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.ResourceBundle;

 import org.eclipse.swt.SWTError;
 import org.eclipse.swt.custom.BusyIndicator;
 import org.eclipse.swt.dnd.ByteArrayTransfer;
 import org.eclipse.swt.dnd.Clipboard;
 import org.eclipse.swt.dnd.DND;
 import org.eclipse.swt.dnd.RTFTransfer;
 import org.eclipse.swt.dnd.TextTransfer;
 import org.eclipse.swt.dnd.Transfer;
 import org.eclipse.swt.dnd.TransferData;
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.swt.widgets.Shell;

 import org.eclipse.core.runtime.Assert;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Status;

 import org.eclipse.jface.operation.IRunnableWithProgress;
 import org.eclipse.jface.viewers.ISelection;

 import org.eclipse.jface.text.IRewriteTarget;
 import org.eclipse.jface.text.ITextOperationTarget;
 import org.eclipse.jface.text.ITextSelection;
 import org.eclipse.jface.text.Region;

 import org.eclipse.ui.IEditorPart;
 import org.eclipse.ui.IWorkbenchCommandConstants;
 import org.eclipse.ui.IWorkbenchPage;
 import org.eclipse.ui.IWorkbenchPartSite;
 import org.eclipse.ui.PlatformUI;
 import org.eclipse.ui.progress.IProgressService;
 import org.eclipse.ui.progress.IWorkbenchSiteProgressService;

 import org.eclipse.ui.texteditor.IAbstractTextEditorHelpContextIds;
 import org.eclipse.ui.texteditor.ITextEditor;
 import org.eclipse.ui.texteditor.ITextEditorExtension3;
 import org.eclipse.ui.texteditor.TextEditorAction;

 import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jdt.core.IJavaElement;
 import org.eclipse.jdt.core.ITypeRoot;
 import org.eclipse.jdt.core.Signature;
 import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jdt.core.dom.IBinding;
 import org.eclipse.jdt.core.dom.ITypeBinding;
 import org.eclipse.jdt.core.dom.ImportDeclaration;
 import org.eclipse.jdt.core.dom.Name;
 import org.eclipse.jdt.core.dom.SimpleName;
 import org.eclipse.jdt.core.dom.rewrite.ImportRewrite;

 import org.eclipse.jdt.internal.corext.codemanipulation.ImportReferencesCollector;
 import org.eclipse.jdt.internal.corext.codemanipulation.StubUtility;
 import org.eclipse.jdt.internal.corext.dom.Bindings;
 import org.eclipse.jdt.internal.corext.util.JavaModelUtil;

 import org.eclipse.jdt.ui.JavaUI;
 import org.eclipse.jdt.ui.PreferenceConstants;
 import org.eclipse.jdt.ui.SharedASTProvider;

 import org.eclipse.jdt.internal.ui.IJavaStatusConstants;
 import org.eclipse.jdt.internal.ui.JavaPlugin;
 import org.eclipse.jdt.internal.ui.JavaUIMessages;


 /**
  * Action for cut/copy and paste with support for adding imports on paste.
  */
 public final class ClipboardOperationAction extends TextEditorAction {

 	public static class ClipboardData {
 		private String fOriginHandle;
 		private String[] fTypeImports;
 		private String[] fStaticImports;

 		public ClipboardData(IJavaElement origin, String[] typeImports, String[] staticImports) {
 			Assert.isNotNull(origin);
 			Assert.isNotNull(typeImports);
 			Assert.isNotNull(staticImports);

 			fTypeImports= typeImports;
 			fStaticImports= staticImports;
 			fOriginHandle= origin.getHandleIdentifier();
 		}

 		public ClipboardData(byte[] bytes) throws IOException {
 			DataInputStream dataIn = new DataInputStream(new ByteArrayInputStream(bytes));
 			try {
 				fOriginHandle= dataIn.readUTF();
 				fTypeImports= readArray(dataIn);
 				fStaticImports= readArray(dataIn);
 			} finally {
 				dataIn.close();
 			}
 		}

 		private static String[] readArray(DataInputStream dataIn) throws IOException {
 			int count= dataIn.readInt();

 			String[] array= new String[count];
 			for (int i = 0; i < count; i++) {
 				array[i]= dataIn.readUTF();
 			}
 			return array;
 		}

 		private static void writeArray(DataOutputStream dataOut, String[] array) throws IOException {
 			dataOut.writeInt(array.length);
 			for (int i = 0; i < array.length; i++) {
 				dataOut.writeUTF(array[i]);
 			}
 		}

 		public String[] getTypeImports() {
 			return fTypeImports;
 		}

 		public String[] getStaticImports() {
 			return fStaticImports;
 		}

 		public boolean isFromSame(IJavaElement elem) {
 			return fOriginHandle.equals(elem.getHandleIdentifier());
 		}

 		public byte[] serialize() throws IOException {
 			ByteArrayOutputStream out = new ByteArrayOutputStream();
 			DataOutputStream dataOut = new DataOutputStream(out);
 			try {
 				dataOut.writeUTF(fOriginHandle);
 				writeArray(dataOut, fTypeImports);
 				writeArray(dataOut, fStaticImports);
 			} finally {
 				dataOut.close();
 				out.close();
 			}

 			return out.toByteArray();
 		}
 	}


 	private static class ClipboardTransfer extends ByteArrayTransfer {

 		private static final String TYPE_NAME = "source-with-imports-transfer-format" + System.currentTimeMillis(); //$NON-NLS-1$

 		private static final int TYPEID = registerType(TYPE_NAME);

 		/* (non-Javadoc)
 		 * @see org.eclipse.swt.dnd.Transfer#getTypeIds()
 		 */
 		@Override
 		protected int[] getTypeIds() {
 			return new int[] { TYPEID };
 		}

 		/* (non-Javadoc)
 		 * @see org.eclipse.swt.dnd.Transfer#getTypeNames()
 		 */
 		@Override
 		protected String[] getTypeNames() {
 			return new String[] { TYPE_NAME };
 		}

 		/* (non-Javadoc)
 		 * @see org.eclipse.swt.dnd.Transfer#javaToNative(java.lang.Object, org.eclipse.swt.dnd.TransferData)
 		 */
 		@Override
 		protected void javaToNative(Object data, TransferData transferData) {
 			if (data instanceof ClipboardData) {
 				try {
 					super.javaToNative(((ClipboardData) data).serialize(), transferData);
 				} catch (IOException e) {
 					//it's best to send nothing if there were problems
 				}
 			}
 		}

 		/* (non-Javadoc)
 		 * Method declared on Transfer.
 		 */
 		@Override
 		protected Object nativeToJava(TransferData transferData) {
 			byte[] bytes = (byte[]) super.nativeToJava(transferData);
 			if (bytes != null) {
 				try {
 					return new ClipboardData(bytes);
 				} catch (IOException e) {
 				}
 			}
 			return null;
 		}

 	}

 	private static final ClipboardTransfer fgTransferInstance = new ClipboardTransfer();

 	/** The text operation code */
 	private int fOperationCode= -1;
 	/** The text operation target */
 	private ITextOperationTarget fOperationTarget;


 	/**
 	 * Creates the action.
 	 * @param bundle the resource bundle
 	 * @param prefix a prefix to be prepended to the various resource keys
 	 *   (described in <code>ResourceAction</code> constructor), or
 	 *   <code>null</code> if none
 	 * @param editor the text editor
 	 * @param operationCode the operation code
 	 */
 	public ClipboardOperationAction(ResourceBundle bundle, String prefix, ITextEditor editor, int operationCode) {
 		super(bundle, prefix, editor);
 		fOperationCode= operationCode;

 		if (operationCode == ITextOperationTarget.CUT) {
 			setHelpContextId(IAbstractTextEditorHelpContextIds.CUT_ACTION);
 			setActionDefinitionId(IWorkbenchCommandConstants.EDIT_CUT);
 		} else if (operationCode == ITextOperationTarget.COPY) {
 			setHelpContextId(IAbstractTextEditorHelpContextIds.COPY_ACTION);
 			setActionDefinitionId(IWorkbenchCommandConstants.EDIT_COPY);
 		} else if (operationCode == ITextOperationTarget.PASTE) {
 			setHelpContextId(IAbstractTextEditorHelpContextIds.PASTE_ACTION);
 			setActionDefinitionId(IWorkbenchCommandConstants.EDIT_PASTE);
 		} else {
 			Assert.isTrue(false, "Invalid operation code"); //$NON-NLS-1$
 		}
 		update();
 	}

 	private boolean isReadOnlyOperation() {
 		return fOperationCode == ITextOperationTarget.COPY;
 	}


 	/* (non-Javadoc)
 	 * @see org.eclipse.jface.action.IAction#run()
 	 */
 	@Override
 	public void run() {
 		if (fOperationCode == -1 || fOperationTarget == null)
 			return;

 		ITextEditor editor= getTextEditor();
 		if (editor == null)
 			return;

 		if (!isReadOnlyOperation() && !validateEditorInputState())
 			return;

 		BusyIndicator.showWhile(getDisplay(), new Runnable() {
 			public void run() {
 				internalDoOperation();
 			}
 		});
 	}

 	private Shell getShell() {
 		ITextEditor editor= getTextEditor();
 		if (editor != null) {
 			IWorkbenchPartSite site= editor.getSite();
 			Shell shell= site.getShell();
 			if (shell != null && !shell.isDisposed()) {
 				return shell;
 			}
 		}
 		return null;
 	}

 	private Display getDisplay() {
 		Shell shell= getShell();
 		if (shell != null) {
 			return shell.getDisplay();
 		}
 		return null;
 	}

 	/**
 	 * Returns whether the Smart Insert Mode is selected.
 	 *
 	 * @return <code>true</code> if the Smart Insert Mode is selected
 	 * @since 3.7
 	 */
 	private boolean isSmartInsertMode() {
 		IWorkbenchPage page= JavaPlugin.getActivePage();
 		if (page != null) {
 			IEditorPart part= page.getActiveEditor();
 			if (part instanceof ITextEditorExtension3) {
 				ITextEditorExtension3 extension= (ITextEditorExtension3)part;
 				return extension.getInsertMode() == ITextEditorExtension3.SMART_INSERT;
 			} else if (part != null && EditorUtility.isCompareEditorInput(part.getEditorInput())) {
 				ITextEditorExtension3 extension= (ITextEditorExtension3)part.getAdapter(ITextEditorExtension3.class);
 				if (extension != null)
 					return extension.getInsertMode() == ITextEditorExtension3.SMART_INSERT;
 			}
 		}
 		return false;
 	}

 	protected final void internalDoOperation() {
 		if (PreferenceConstants.getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_IMPORTS_ON_PASTE) && isSmartInsertMode()) {
 			if (fOperationCode == ITextOperationTarget.PASTE) {
 				doPasteWithImportsOperation();
 			} else {
 				doCutCopyWithImportsOperation();
 			}
 		} else {
 			fOperationTarget.doOperation(fOperationCode);
 		}
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ui.texteditor.IUpdate#update()
 	 */
 	@Override
 	public void update() {
 		super.update();

 		if (!isReadOnlyOperation() && !canModifyEditor()) {
 			setEnabled(false);
 			return;
 		}

 		ITextEditor editor= getTextEditor();
 		if (fOperationTarget == null && editor!= null && fOperationCode != -1)
 			fOperationTarget= (ITextOperationTarget) editor.getAdapter(ITextOperationTarget.class);

 		boolean isEnabled= (fOperationTarget != null && fOperationTarget.canDoOperation(fOperationCode));
 		setEnabled(isEnabled);
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ui.texteditor.TextEditorAction#setEditor(org.eclipse.ui.texteditor.ITextEditor)
 	 */
 	@Override
 	public void setEditor(ITextEditor editor) {
 		super.setEditor(editor);
 		fOperationTarget= null;
 	}


 	private void doCutCopyWithImportsOperation() {
 		ITextEditor editor= getTextEditor();
 		ITypeRoot inputElement= JavaUI.getEditorInputTypeRoot(editor.getEditorInput());
 		ISelection selection= editor.getSelectionProvider().getSelection();

 		Object clipboardData= null;
 		if (inputElement != null && selection instanceof ITextSelection && !selection.isEmpty()) {
 			ITextSelection textSelection= (ITextSelection) selection;
 			if (isNonTrivialSelection(textSelection)) {
 				clipboardData= getClipboardData(inputElement, textSelection.getOffset(), textSelection.getLength());
 			}
 		}

 		fOperationTarget.doOperation(fOperationCode);

 		if (clipboardData != null) {
 			/*
 			 * We currently make assumptions about what the styled text widget sets,
 			 * see https://bugs.eclipse.org/bugs/show_bug.cgi?id=61876
 			 */
 			Clipboard clipboard= new Clipboard(getDisplay());
 			try {
 				Object textData= clipboard.getContents(TextTransfer.getInstance());
 				/*
 				 * Don't add if we didn't get any text data from the clipboard, see:
 				 * - https://bugs.eclipse.org/bugs/show_bug.cgi?id=70077
 				 * - https://bugs.eclipse.org/bugs/show_bug.cgi?id=200743
 				 */
 				if (textData == null)
 					return;

 				ArrayList<Object> datas= new ArrayList<Object>(3);
 				ArrayList<ByteArrayTransfer> transfers= new ArrayList<ByteArrayTransfer>(3);
 				datas.add(textData);
 				transfers.add(TextTransfer.getInstance());

 				Object rtfData= clipboard.getContents(RTFTransfer.getInstance());
 				if (rtfData != null) {
 					datas.add(rtfData);
 					transfers.add(RTFTransfer.getInstance());
 				}

 				datas.add(clipboardData);
 				transfers.add(fgTransferInstance);

 				Transfer[] dataTypes= transfers.toArray(new Transfer[transfers.size()]);
 				Object[] data= datas.toArray();
 				setClipboardContents(clipboard, data, dataTypes);
 			} finally {
 				clipboard.dispose();
 			}
 		}
 	}

 	private void setClipboardContents(Clipboard clipboard, Object[] datas, Transfer[] transfers) {
 		try {
 			clipboard.setContents(datas, transfers);
 		} catch (SWTError e) {
 			if (e.code != DND.ERROR_CANNOT_SET_CLIPBOARD) {
 				throw e;
 			}
 			// silently fail.  see e.g. https://bugs.eclipse.org/bugs/show_bug.cgi?id=65975
 		}
 	}

 	private boolean isNonTrivialSelection(ITextSelection selection) {
 		if (selection.getLength() < 30) {
 			String text= selection.getText();
 			if (text != null) {
 				for (int i= 0; i < text.length(); i++) {
 					if (!Character.isJavaIdentifierPart(text.charAt(i))) {
 						return true;
 					}
 				}
 			}
 			return false;
 		}
 		return true;
 	}


 	private ClipboardData getClipboardData(ITypeRoot inputElement, int offset, int length) {
 		CompilationUnit astRoot= SharedASTProvider.getAST(inputElement, SharedASTProvider.WAIT_ACTIVE_ONLY, null);
 		if (astRoot == null) {
 			return null;
 		}

 		// do process import if selection spans over import declaration or package
 		List<ImportDeclaration> list= astRoot.imports();
 		if (!list.isEmpty()) {
 			if (offset < ((ASTNode) list.get(list.size() - 1)).getStartPosition()) {
 				return null;
 			}
 		} else if (astRoot.getPackage() != null) {
 			if (offset < ((ASTNode) astRoot.getPackage()).getStartPosition()) {
 				return null;
 			}
 		}

 		ArrayList<SimpleName> typeImportsRefs= new ArrayList<SimpleName>();
 		ArrayList<SimpleName> staticImportsRefs= new ArrayList<SimpleName>();

 		ImportReferencesCollector.collect(astRoot, inputElement.getJavaProject(), new Region(offset, length), typeImportsRefs, staticImportsRefs);

 		if (typeImportsRefs.isEmpty() && staticImportsRefs.isEmpty()) {
 			return null;
 		}

 		HashSet<String> namesToImport= new HashSet<String>(typeImportsRefs.size());
 		for (int i= 0; i < typeImportsRefs.size(); i++) {
 			Name curr= typeImportsRefs.get(i);
 			IBinding binding= curr.resolveBinding();
 			if (binding != null && binding.getKind() == IBinding.TYPE) {
 				ITypeBinding typeBinding= (ITypeBinding) binding;
 				if (typeBinding.isArray()) {
 					typeBinding= typeBinding.getElementType();
 				}
 				if (typeBinding.isTypeVariable() || typeBinding.isCapture() || typeBinding.isWildcardType()) { // can be removed when bug 98473 is fixed
 					continue;
 				}

 				if (typeBinding.isMember() || typeBinding.isTopLevel()) {
 					String name= Bindings.getRawQualifiedName(typeBinding);
 					if (name.length() > 0) {
 						namesToImport.add(name);
 					}
 				}
 			}
 		}

 		HashSet<String> staticsToImport= new HashSet<String>(staticImportsRefs.size());
 		for (int i= 0; i < staticImportsRefs.size(); i++) {
 			Name curr= staticImportsRefs.get(i);
 			IBinding binding= curr.resolveBinding();
 			if (binding != null) {
 				StringBuffer buf= new StringBuffer(Bindings.getImportName(binding));
 				if (binding.getKind() == IBinding.METHOD) {
 					buf.append("()"); //$NON-NLS-1$
 				}
 				staticsToImport.add(buf.toString());
 			}
 		}


 		if (namesToImport.isEmpty() && staticsToImport.isEmpty()) {
 			return null;
 		}

 		String[] typeImports= namesToImport.toArray(new String[namesToImport.size()]);
 		String[] staticImports= staticsToImport.toArray(new String[staticsToImport.size()]);
 		return new ClipboardData(inputElement, typeImports, staticImports);
 	}

 	private void doPasteWithImportsOperation() {
 		ITextEditor editor= getTextEditor();
 		IJavaElement inputElement= JavaUI.getEditorInputTypeRoot(editor.getEditorInput());

 		Clipboard clipboard= new Clipboard(getDisplay());
 		try {
 			ClipboardData importsData= (ClipboardData)clipboard.getContents(fgTransferInstance);
 			if (importsData != null && inputElement instanceof ICompilationUnit && !importsData.isFromSame(inputElement)) {
 				// combine operation and adding of imports
 				IRewriteTarget target= (IRewriteTarget)editor.getAdapter(IRewriteTarget.class);
 				if (target != null) {
 					target.beginCompoundChange();
 				}
 				try {
 					fOperationTarget.doOperation(fOperationCode);
 					addImports((ICompilationUnit)inputElement, importsData);
 				} catch (CoreException e) {
 					JavaPlugin.log(e);
 				} finally {
 					if (target != null) {
 						target.endCompoundChange();
 					}
 				}
 			} else {
 				fOperationTarget.doOperation(fOperationCode);
 			}
 		} finally {
 			clipboard.dispose();
 		}
 	}

 	private void addImports(final ICompilationUnit unit, ClipboardData data) throws CoreException {
 		final ImportRewrite rewrite= StubUtility.createImportRewrite(unit, true);
 		String[] imports= data.getTypeImports();
 		for (int i= 0; i < imports.length; i++) {
 			rewrite.addImport(imports[i]);
 		}
 		String[] staticImports= data.getStaticImports();
 		for (int i= 0; i < staticImports.length; i++) {
 			String name= Signature.getSimpleName(staticImports[i]);
 			boolean isField= !name.endsWith("()"); //$NON-NLS-1$
 			if (!isField) {
 				name= name.substring(0, name.length() - 2);
 			}
 			String qualifier= Signature.getQualifier(staticImports[i]);
 			rewrite.addStaticImport(qualifier, name, isField);
 		}

 		try {
 			getProgressService().busyCursorWhile(new IRunnableWithProgress() {
 				public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
 					try {
 						JavaModelUtil.applyEdit(unit, rewrite.rewriteImports(monitor), false, null);
 					} catch (CoreException e) {
 						throw new InvocationTargetException(e);
 					}
 				}
 			});
 		} catch (InvocationTargetException e) {
 			Throwable cause= e.getCause();
 			if (cause instanceof CoreException)
 				throw (CoreException) cause;
 			throw new CoreException(new Status(IStatus.ERROR, JavaUI.ID_PLUGIN, IJavaStatusConstants.INTERNAL_ERROR, JavaUIMessages.JavaPlugin_internal_error, cause));
 		} catch (InterruptedException e) {
 			// Canceled by the user
 		}
 	}

 	private IProgressService getProgressService() {
 		IEditorPart editor= getTextEditor();
 		if (editor != null) {
 			IWorkbenchPartSite site= editor.getSite();
 			if (site != null)
 				return (IWorkbenchSiteProgressService) editor.getSite().getAdapter(IWorkbenchSiteProgressService.class);
 		}
 		return PlatformUI.getWorkbench().getProgressService();
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2000, 2011 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.jdt.internal.ui.javaeditor;

	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.DataInputStream;
	import java.io.DataOutputStream;
	import java.io.IOException;
	import java.lang.reflect.InvocationTargetException;
	import java.util.ArrayList;
	import java.util.HashSet;
	import java.util.List;
	import java.util.ResourceBundle;

	import org.eclipse.swt.SWTError;
	import org.eclipse.swt.custom.BusyIndicator;
	import org.eclipse.swt.dnd.ByteArrayTransfer;
	import org.eclipse.swt.dnd.Clipboard;
	import org.eclipse.swt.dnd.DND;
	import org.eclipse.swt.dnd.RTFTransfer;
	import org.eclipse.swt.dnd.TextTransfer;
	import org.eclipse.swt.dnd.Transfer;
	import org.eclipse.swt.dnd.TransferData;
	import org.eclipse.swt.widgets.Display;
	import org.eclipse.swt.widgets.Shell;

	import org.eclipse.core.runtime.Assert;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.Status;

	import org.eclipse.jface.operation.IRunnableWithProgress;
	import org.eclipse.jface.viewers.ISelection;

	import org.eclipse.jface.text.IRewriteTarget;
	import org.eclipse.jface.text.ITextOperationTarget;
	import org.eclipse.jface.text.ITextSelection;
	import org.eclipse.jface.text.Region;

	import org.eclipse.ui.IEditorPart;
	import org.eclipse.ui.IWorkbenchCommandConstants;
	import org.eclipse.ui.IWorkbenchPage;
	import org.eclipse.ui.IWorkbenchPartSite;
	import org.eclipse.ui.PlatformUI;
	import org.eclipse.ui.progress.IProgressService;
	import org.eclipse.ui.progress.IWorkbenchSiteProgressService;

	import org.eclipse.ui.texteditor.IAbstractTextEditorHelpContextIds;
	import org.eclipse.ui.texteditor.ITextEditor;
	import org.eclipse.ui.texteditor.ITextEditorExtension3;
	import org.eclipse.ui.texteditor.TextEditorAction;

	import org.eclipse.jdt.core.ICompilationUnit;
	import org.eclipse.jdt.core.IJavaElement;
	import org.eclipse.jdt.core.ITypeRoot;
	import org.eclipse.jdt.core.Signature;
	import org.eclipse.jdt.core.dom.ASTNode;
	import org.eclipse.jdt.core.dom.CompilationUnit;
	import org.eclipse.jdt.core.dom.IBinding;
	import org.eclipse.jdt.core.dom.ITypeBinding;
	import org.eclipse.jdt.core.dom.ImportDeclaration;
	import org.eclipse.jdt.core.dom.Name;
	import org.eclipse.jdt.core.dom.SimpleName;
	import org.eclipse.jdt.core.dom.rewrite.ImportRewrite;

	import org.eclipse.jdt.internal.corext.codemanipulation.ImportReferencesCollector;
	import org.eclipse.jdt.internal.corext.codemanipulation.StubUtility;
	import org.eclipse.jdt.internal.corext.dom.Bindings;
	import org.eclipse.jdt.internal.corext.util.JavaModelUtil;

	import org.eclipse.jdt.ui.JavaUI;
	import org.eclipse.jdt.ui.PreferenceConstants;
	import org.eclipse.jdt.ui.SharedASTProvider;

	import org.eclipse.jdt.internal.ui.IJavaStatusConstants;
	import org.eclipse.jdt.internal.ui.JavaPlugin;
	import org.eclipse.jdt.internal.ui.JavaUIMessages;


	/**
	* Action for cut/copy and paste with support for adding imports on paste.
	*/
	public final class ClipboardOperationAction extends TextEditorAction {

	public static class ClipboardData {
	private String fOriginHandle;
	private String[] fTypeImports;
	private String[] fStaticImports;

	public ClipboardData(IJavaElement origin, String[] typeImports, String[] staticImports) {
	Assert.isNotNull(origin);
	Assert.isNotNull(typeImports);
	Assert.isNotNull(staticImports);

	fTypeImports= typeImports;
	fStaticImports= staticImports;
	fOriginHandle= origin.getHandleIdentifier();
	}

	public ClipboardData(byte[] bytes) throws IOException {
	DataInputStream dataIn = new DataInputStream(new ByteArrayInputStream(bytes));
	try {
	fOriginHandle= dataIn.readUTF();
	fTypeImports= readArray(dataIn);
	fStaticImports= readArray(dataIn);
	} finally {
	dataIn.close();
	}
	}

	private static String[] readArray(DataInputStream dataIn) throws IOException {
	int count= dataIn.readInt();

	String[] array= new String[count];
	for (int i = 0; i < count; i++) {
	array[i]= dataIn.readUTF();
	}
	return array;
	}

	private static void writeArray(DataOutputStream dataOut, String[] array) throws IOException {
	dataOut.writeInt(array.length);
	for (int i = 0; i < array.length; i++) {
	dataOut.writeUTF(array[i]);
	}
	}

	public String[] getTypeImports() {
	return fTypeImports;
	}

	public String[] getStaticImports() {
	return fStaticImports;
	}

	public boolean isFromSame(IJavaElement elem) {
	return fOriginHandle.equals(elem.getHandleIdentifier());
	}

	public byte[] serialize() throws IOException {
	ByteArrayOutputStream out = new ByteArrayOutputStream();
	DataOutputStream dataOut = new DataOutputStream(out);
	try {
	dataOut.writeUTF(fOriginHandle);
	writeArray(dataOut, fTypeImports);
	writeArray(dataOut, fStaticImports);
	} finally {
	dataOut.close();
	out.close();
	}

	return out.toByteArray();
	}
	}


	private static class ClipboardTransfer extends ByteArrayTransfer {

	private static final String TYPE_NAME = "source-with-imports-transfer-format" + System.currentTimeMillis(); //$NON-NLS-1$

	private static final int TYPEID = registerType(TYPE_NAME);

	/* (non-Javadoc)
	* @see org.eclipse.swt.dnd.Transfer#getTypeIds()
	*/
	@Override
	protected int[] getTypeIds() {
	return new int[] { TYPEID };
	}

	/* (non-Javadoc)
	* @see org.eclipse.swt.dnd.Transfer#getTypeNames()
	*/
	@Override
	protected String[] getTypeNames() {
	return new String[] { TYPE_NAME };
	}

	/* (non-Javadoc)
	* @see org.eclipse.swt.dnd.Transfer#javaToNative(java.lang.Object, org.eclipse.swt.dnd.TransferData)
	*/
	@Override
	protected void javaToNative(Object data, TransferData transferData) {
	if (data instanceof ClipboardData) {
	try {
	super.javaToNative(((ClipboardData) data).serialize(), transferData);
	} catch (IOException e) {
	//it's best to send nothing if there were problems
	}
	}
	}

	/* (non-Javadoc)
	* Method declared on Transfer.
	*/
	@Override
	protected Object nativeToJava(TransferData transferData) {
	byte[] bytes = (byte[]) super.nativeToJava(transferData);
	if (bytes != null) {
	try {
	return new ClipboardData(bytes);
	} catch (IOException e) {
	}
	}
	return null;
	}

	}

	private static final ClipboardTransfer fgTransferInstance = new ClipboardTransfer();

	/** The text operation code */
	private int fOperationCode= -1;
	/** The text operation target */
	private ITextOperationTarget fOperationTarget;


	/**
	* Creates the action.
	* @param bundle the resource bundle
	* @param prefix a prefix to be prepended to the various resource keys
	* (described in <code>ResourceAction</code> constructor), or
	* <code>null</code> if none
	* @param editor the text editor
	* @param operationCode the operation code
	*/
	public ClipboardOperationAction(ResourceBundle bundle, String prefix, ITextEditor editor, int operationCode) {
	super(bundle, prefix, editor);
	fOperationCode= operationCode;

	if (operationCode == ITextOperationTarget.CUT) {
	setHelpContextId(IAbstractTextEditorHelpContextIds.CUT_ACTION);
	setActionDefinitionId(IWorkbenchCommandConstants.EDIT_CUT);
	} else if (operationCode == ITextOperationTarget.COPY) {
	setHelpContextId(IAbstractTextEditorHelpContextIds.COPY_ACTION);
	setActionDefinitionId(IWorkbenchCommandConstants.EDIT_COPY);
	} else if (operationCode == ITextOperationTarget.PASTE) {
	setHelpContextId(IAbstractTextEditorHelpContextIds.PASTE_ACTION);
	setActionDefinitionId(IWorkbenchCommandConstants.EDIT_PASTE);
	} else {
	Assert.isTrue(false, "Invalid operation code"); //$NON-NLS-1$
	}
	update();
	}

	private boolean isReadOnlyOperation() {
	return fOperationCode == ITextOperationTarget.COPY;
	}


	/* (non-Javadoc)
	* @see org.eclipse.jface.action.IAction#run()
	*/
	@Override
	public void run() {
	if (fOperationCode == -1 \|\| fOperationTarget == null)
	return;

	ITextEditor editor= getTextEditor();
	if (editor == null)
	return;

	if (!isReadOnlyOperation() && !validateEditorInputState())
	return;

	BusyIndicator.showWhile(getDisplay(), new Runnable() {
	public void run() {
	internalDoOperation();
	}
	});
	}

	private Shell getShell() {
	ITextEditor editor= getTextEditor();
	if (editor != null) {
	IWorkbenchPartSite site= editor.getSite();
	Shell shell= site.getShell();
	if (shell != null && !shell.isDisposed()) {
	return shell;
	}
	}
	return null;
	}

	private Display getDisplay() {
	Shell shell= getShell();
	if (shell != null) {
	return shell.getDisplay();
	}
	return null;
	}

	/**
	* Returns whether the Smart Insert Mode is selected.
	*
	* @return <code>true</code> if the Smart Insert Mode is selected
	* @since 3.7
	*/
	private boolean isSmartInsertMode() {
	IWorkbenchPage page= JavaPlugin.getActivePage();
	if (page != null) {
	IEditorPart part= page.getActiveEditor();
	if (part instanceof ITextEditorExtension3) {
	ITextEditorExtension3 extension= (ITextEditorExtension3)part;
	return extension.getInsertMode() == ITextEditorExtension3.SMART_INSERT;
	} else if (part != null && EditorUtility.isCompareEditorInput(part.getEditorInput())) {
	ITextEditorExtension3 extension= (ITextEditorExtension3)part.getAdapter(ITextEditorExtension3.class);
	if (extension != null)
	return extension.getInsertMode() == ITextEditorExtension3.SMART_INSERT;
	}
	}
	return false;
	}

	protected final void internalDoOperation() {
	if (PreferenceConstants.getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_IMPORTS_ON_PASTE) && isSmartInsertMode()) {
	if (fOperationCode == ITextOperationTarget.PASTE) {
	doPasteWithImportsOperation();
	} else {
	doCutCopyWithImportsOperation();
	}
	} else {
	fOperationTarget.doOperation(fOperationCode);
	}
	}

	/* (non-Javadoc)
	* @see org.eclipse.ui.texteditor.IUpdate#update()
	*/
	@Override
	public void update() {
	super.update();

	if (!isReadOnlyOperation() && !canModifyEditor()) {
	setEnabled(false);
	return;
	}

	ITextEditor editor= getTextEditor();
	if (fOperationTarget == null && editor!= null && fOperationCode != -1)
	fOperationTarget= (ITextOperationTarget) editor.getAdapter(ITextOperationTarget.class);

	boolean isEnabled= (fOperationTarget != null && fOperationTarget.canDoOperation(fOperationCode));
	setEnabled(isEnabled);
	}

	/* (non-Javadoc)
	* @see org.eclipse.ui.texteditor.TextEditorAction#setEditor(org.eclipse.ui.texteditor.ITextEditor)
	*/
	@Override
	public void setEditor(ITextEditor editor) {
	super.setEditor(editor);
	fOperationTarget= null;
	}


	private void doCutCopyWithImportsOperation() {
	ITextEditor editor= getTextEditor();
	ITypeRoot inputElement= JavaUI.getEditorInputTypeRoot(editor.getEditorInput());
	ISelection selection= editor.getSelectionProvider().getSelection();

	Object clipboardData= null;
	if (inputElement != null && selection instanceof ITextSelection && !selection.isEmpty()) {
	ITextSelection textSelection= (ITextSelection) selection;
	if (isNonTrivialSelection(textSelection)) {
	clipboardData= getClipboardData(inputElement, textSelection.getOffset(), textSelection.getLength());
	}
	}

	fOperationTarget.doOperation(fOperationCode);

	if (clipboardData != null) {
	/*
	* We currently make assumptions about what the styled text widget sets,
	* see https://bugs.eclipse.org/bugs/show_bug.cgi?id=61876
	*/
	Clipboard clipboard= new Clipboard(getDisplay());
	try {
	Object textData= clipboard.getContents(TextTransfer.getInstance());
	/*
	* Don't add if we didn't get any text data from the clipboard, see:
	* - https://bugs.eclipse.org/bugs/show_bug.cgi?id=70077
	* - https://bugs.eclipse.org/bugs/show_bug.cgi?id=200743
	*/
	if (textData == null)
	return;

	ArrayList<Object> datas= new ArrayList<Object>(3);
	ArrayList<ByteArrayTransfer> transfers= new ArrayList<ByteArrayTransfer>(3);
	datas.add(textData);
	transfers.add(TextTransfer.getInstance());

	Object rtfData= clipboard.getContents(RTFTransfer.getInstance());
	if (rtfData != null) {
	datas.add(rtfData);
	transfers.add(RTFTransfer.getInstance());
	}

	datas.add(clipboardData);
	transfers.add(fgTransferInstance);

	Transfer[] dataTypes= transfers.toArray(new Transfer[transfers.size()]);
	Object[] data= datas.toArray();
	setClipboardContents(clipboard, data, dataTypes);
	} finally {
	clipboard.dispose();
	}
	}
	}

	private void setClipboardContents(Clipboard clipboard, Object[] datas, Transfer[] transfers) {
	try {
	clipboard.setContents(datas, transfers);
	} catch (SWTError e) {
	if (e.code != DND.ERROR_CANNOT_SET_CLIPBOARD) {
	throw e;
	}
	// silently fail. see e.g. https://bugs.eclipse.org/bugs/show_bug.cgi?id=65975
	}
	}

	private boolean isNonTrivialSelection(ITextSelection selection) {
	if (selection.getLength() < 30) {
	String text= selection.getText();
	if (text != null) {
	for (int i= 0; i < text.length(); i++) {
	if (!Character.isJavaIdentifierPart(text.charAt(i))) {
	return true;
	}
	}
	}
	return false;
	}
	return true;
	}


	private ClipboardData getClipboardData(ITypeRoot inputElement, int offset, int length) {
	CompilationUnit astRoot= SharedASTProvider.getAST(inputElement, SharedASTProvider.WAIT_ACTIVE_ONLY, null);
	if (astRoot == null) {
	return null;
	}

	// do process import if selection spans over import declaration or package
	List<ImportDeclaration> list= astRoot.imports();
	if (!list.isEmpty()) {
	if (offset < ((ASTNode) list.get(list.size() - 1)).getStartPosition()) {
	return null;
	}
	} else if (astRoot.getPackage() != null) {
	if (offset < ((ASTNode) astRoot.getPackage()).getStartPosition()) {
	return null;
	}
	}

	ArrayList<SimpleName> typeImportsRefs= new ArrayList<SimpleName>();
	ArrayList<SimpleName> staticImportsRefs= new ArrayList<SimpleName>();

	ImportReferencesCollector.collect(astRoot, inputElement.getJavaProject(), new Region(offset, length), typeImportsRefs, staticImportsRefs);

	if (typeImportsRefs.isEmpty() && staticImportsRefs.isEmpty()) {
	return null;
	}

	HashSet<String> namesToImport= new HashSet<String>(typeImportsRefs.size());
	for (int i= 0; i < typeImportsRefs.size(); i++) {
	Name curr= typeImportsRefs.get(i);
	IBinding binding= curr.resolveBinding();
	if (binding != null && binding.getKind() == IBinding.TYPE) {
	ITypeBinding typeBinding= (ITypeBinding) binding;
	if (typeBinding.isArray()) {
	typeBinding= typeBinding.getElementType();
	}
	if (typeBinding.isTypeVariable() \|\| typeBinding.isCapture() \|\| typeBinding.isWildcardType()) { // can be removed when bug 98473 is fixed
	continue;
	}

	if (typeBinding.isMember() \|\| typeBinding.isTopLevel()) {
	String name= Bindings.getRawQualifiedName(typeBinding);
	if (name.length() > 0) {
	namesToImport.add(name);
	}
	}
	}
	}

	HashSet<String> staticsToImport= new HashSet<String>(staticImportsRefs.size());
	for (int i= 0; i < staticImportsRefs.size(); i++) {
	Name curr= staticImportsRefs.get(i);
	IBinding binding= curr.resolveBinding();
	if (binding != null) {
	StringBuffer buf= new StringBuffer(Bindings.getImportName(binding));
	if (binding.getKind() == IBinding.METHOD) {
	buf.append("()"); //$NON-NLS-1$
	}
	staticsToImport.add(buf.toString());
	}
	}


	if (namesToImport.isEmpty() && staticsToImport.isEmpty()) {
	return null;
	}

	String[] typeImports= namesToImport.toArray(new String[namesToImport.size()]);
	String[] staticImports= staticsToImport.toArray(new String[staticsToImport.size()]);
	return new ClipboardData(inputElement, typeImports, staticImports);
	}

	private void doPasteWithImportsOperation() {
	ITextEditor editor= getTextEditor();
	IJavaElement inputElement= JavaUI.getEditorInputTypeRoot(editor.getEditorInput());

	Clipboard clipboard= new Clipboard(getDisplay());
	try {
	ClipboardData importsData= (ClipboardData)clipboard.getContents(fgTransferInstance);
	if (importsData != null && inputElement instanceof ICompilationUnit && !importsData.isFromSame(inputElement)) {
	// combine operation and adding of imports
	IRewriteTarget target= (IRewriteTarget)editor.getAdapter(IRewriteTarget.class);
	if (target != null) {
	target.beginCompoundChange();
	}
	try {
	fOperationTarget.doOperation(fOperationCode);
	addImports((ICompilationUnit)inputElement, importsData);
	} catch (CoreException e) {
	JavaPlugin.log(e);
	} finally {
	if (target != null) {
	target.endCompoundChange();
	}
	}
	} else {
	fOperationTarget.doOperation(fOperationCode);
	}
	} finally {
	clipboard.dispose();
	}
	}

	private void addImports(final ICompilationUnit unit, ClipboardData data) throws CoreException {
	final ImportRewrite rewrite= StubUtility.createImportRewrite(unit, true);
	String[] imports= data.getTypeImports();
	for (int i= 0; i < imports.length; i++) {
	rewrite.addImport(imports[i]);
	}
	String[] staticImports= data.getStaticImports();
	for (int i= 0; i < staticImports.length; i++) {
	String name= Signature.getSimpleName(staticImports[i]);
	boolean isField= !name.endsWith("()"); //$NON-NLS-1$
	if (!isField) {
	name= name.substring(0, name.length() - 2);
	}
	String qualifier= Signature.getQualifier(staticImports[i]);
	rewrite.addStaticImport(qualifier, name, isField);
	}

	try {
	getProgressService().busyCursorWhile(new IRunnableWithProgress() {
	public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
	try {
	JavaModelUtil.applyEdit(unit, rewrite.rewriteImports(monitor), false, null);
	} catch (CoreException e) {
	throw new InvocationTargetException(e);
	}
	}
	});
	} catch (InvocationTargetException e) {
	Throwable cause= e.getCause();
	if (cause instanceof CoreException)
	throw (CoreException) cause;
	throw new CoreException(new Status(IStatus.ERROR, JavaUI.ID_PLUGIN, IJavaStatusConstants.INTERNAL_ERROR, JavaUIMessages.JavaPlugin_internal_error, cause));
	} catch (InterruptedException e) {
	// Canceled by the user
	}
	}

	private IProgressService getProgressService() {
	IEditorPart editor= getTextEditor();
	if (editor != null) {
	IWorkbenchPartSite site= editor.getSite();
	if (site != null)
	return (IWorkbenchSiteProgressService) editor.getSite().getAdapter(IWorkbenchSiteProgressService.class);
	}
	return PlatformUI.getWorkbench().getProgressService();
	}

	}