/*******************************************************************************
* 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();
}
}