| /******************************************************************************* |
| * Copyright (c) 2000, 2017 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 |
| * |
| *******************************************************************************/ |
| package org.eclipse.dltk.internal.ui.refactoring.reorg; |
| |
| import java.util.ArrayList; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.runtime.Assert; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.dltk.core.DLTKCore; |
| import org.eclipse.dltk.core.IModelElement; |
| import org.eclipse.dltk.core.ISourceModule; |
| import org.eclipse.dltk.core.IType; |
| import org.eclipse.dltk.core.ModelException; |
| import org.eclipse.dltk.core.ScriptModelUtil; |
| import org.eclipse.dltk.internal.core.ExternalScriptFolder; |
| import org.eclipse.dltk.internal.corext.refactoring.reorg.IReorgEnablementPolicy; |
| import org.eclipse.dltk.internal.corext.refactoring.reorg.ModelElementTransfer; |
| import org.eclipse.dltk.internal.corext.refactoring.reorg.ParentChecker; |
| import org.eclipse.dltk.internal.corext.refactoring.reorg.ReorgUtils; |
| import org.eclipse.dltk.internal.corext.refactoring.util.ModelElementUtil; |
| import org.eclipse.dltk.ui.DLTKUIPlugin; |
| import org.eclipse.dltk.ui.ModelElementLabelProvider; |
| import org.eclipse.dltk.ui.actions.SelectionDispatchAction; |
| import org.eclipse.dltk.ui.util.ExceptionHandler; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.viewers.ILabelProvider; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.swt.SWTError; |
| import org.eclipse.swt.dnd.Clipboard; |
| import org.eclipse.swt.dnd.DND; |
| import org.eclipse.swt.dnd.FileTransfer; |
| import org.eclipse.swt.dnd.TextTransfer; |
| import org.eclipse.swt.dnd.Transfer; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.ui.ISharedImages; |
| import org.eclipse.ui.IWorkbenchSite; |
| import org.eclipse.ui.part.ResourceTransfer; |
| |
| public class CopyToClipboardAction extends SelectionDispatchAction { |
| |
| private final Clipboard fClipboard; |
| private SelectionDispatchAction fPasteAction;// may be null |
| private boolean fAutoRepeatOnFailure = false; |
| |
| public CopyToClipboardAction(IWorkbenchSite site, Clipboard clipboard, |
| SelectionDispatchAction pasteAction) { |
| super(site); |
| setText(ReorgMessages.CopyToClipboardAction_0); |
| setDescription(ReorgMessages.CopyToClipboardAction_1); |
| Assert.isNotNull(clipboard); |
| fClipboard = clipboard; |
| fPasteAction = pasteAction; |
| ISharedImages workbenchImages = getWorkbenchSharedImages(); |
| setDisabledImageDescriptor(workbenchImages |
| .getImageDescriptor(ISharedImages.IMG_TOOL_COPY_DISABLED)); |
| setImageDescriptor(workbenchImages |
| .getImageDescriptor(ISharedImages.IMG_TOOL_COPY)); |
| setHoverImageDescriptor(workbenchImages |
| .getImageDescriptor(ISharedImages.IMG_TOOL_COPY)); |
| update(getSelection()); |
| |
| if (DLTKCore.DEBUG) { |
| System.err.println("Add help support here..."); //$NON-NLS-1$ |
| } |
| |
| // PlatformUI.getWorkbench().getHelpSystem().setHelp(this, |
| // IScriptHelpContextIds.COPY_ACTION); |
| } |
| |
| public void setAutoRepeatOnFailure(boolean autorepeatOnFailure) { |
| fAutoRepeatOnFailure = autorepeatOnFailure; |
| } |
| |
| private static ISharedImages getWorkbenchSharedImages() { |
| return DLTKUIPlugin.getDefault().getWorkbench().getSharedImages(); |
| } |
| |
| @Override |
| public void selectionChanged(IStructuredSelection selection) { |
| try { |
| List elements = selection.toList(); |
| IResource[] resources = ReorgUtils.getResources(elements); |
| IModelElement[] modelElements = ReorgUtils |
| .getModelElements(elements); |
| if (elements.size() != resources.length + modelElements.length) |
| setEnabled(false); |
| else |
| setEnabled(canEnable(resources, modelElements)); |
| } catch (ModelException e) { |
| // no ui here - this happens on selection changes |
| // http://bugs.eclipse.org/bugs/show_bug.cgi?id=19253 |
| if (ScriptModelUtil.isExceptionToBeLogged(e)) |
| DLTKUIPlugin.log(e); |
| setEnabled(false); |
| } |
| } |
| |
| @Override |
| public void run(IStructuredSelection selection) { |
| try { |
| List elements = selection.toList(); |
| IResource[] resources = ReorgUtils.getResources(elements); |
| IModelElement[] modelElements = ReorgUtils |
| .getModelElements(elements); |
| if (elements.size() == resources.length + modelElements.length |
| && canEnable(resources, modelElements)) |
| doRun(resources, modelElements); |
| } catch (CoreException e) { |
| ExceptionHandler.handle(e, getShell(), |
| ReorgMessages.CopyToClipboardAction_2, |
| ReorgMessages.CopyToClipboardAction_3); |
| } |
| } |
| |
| private void doRun(IResource[] resources, IModelElement[] modelElements) |
| throws CoreException { |
| new ClipboardCopier(resources, modelElements, fClipboard, getShell(), |
| fAutoRepeatOnFailure).copyToClipboard(); |
| |
| // update the enablement of the paste action |
| // workaround since the clipboard does not support callbacks |
| if (fPasteAction != null && fPasteAction.getSelection() != null) |
| fPasteAction.update(fPasteAction.getSelection()); |
| } |
| |
| private boolean canEnable(IResource[] resources, |
| IModelElement[] modelElements) throws ModelException { |
| return new CopyToClipboardEnablementPolicy(resources, modelElements) |
| .canEnable(); |
| } |
| |
| // ----------------------------------------------------------------------------------------// |
| |
| private static class ClipboardCopier { |
| private final boolean fAutoRepeatOnFailure; |
| private final IResource[] fResources; |
| private final IModelElement[] fScriptElements; |
| private final Clipboard fClipboard; |
| private final Shell fShell; |
| private final ILabelProvider fLabelProvider; |
| |
| private ClipboardCopier(IResource[] resources, |
| IModelElement[] modelElements, Clipboard clipboard, Shell shell, |
| boolean autoRepeatOnFailure) { |
| Assert.isNotNull(resources); |
| Assert.isNotNull(modelElements); |
| Assert.isNotNull(clipboard); |
| Assert.isNotNull(shell); |
| fResources = resources; |
| fScriptElements = modelElements; |
| fClipboard = clipboard; |
| fShell = shell; |
| fLabelProvider = createLabelProvider(); |
| fAutoRepeatOnFailure = autoRepeatOnFailure; |
| } |
| |
| public void copyToClipboard() throws CoreException { |
| // Set<String> fileNames |
| Set<String> fileNames = new HashSet<>( |
| fResources.length + fScriptElements.length); |
| StringBuffer namesBuf = new StringBuffer(); |
| processResources(fileNames, namesBuf); |
| processScriptElements(fileNames, namesBuf); |
| |
| List typesList = ReorgUtils.getElementsOfType(fScriptElements, |
| IModelElement.TYPE); |
| IType types[] = (IType[]) typesList |
| .toArray(new IType[typesList.size()]); |
| ISourceModule[] cusOfMainTypes = ReorgUtils.getSourceModules(types); |
| IResource[] resourcesOfMainTypes = ReorgUtils |
| .getResources(cusOfMainTypes); |
| addFileNames(fileNames, resourcesOfMainTypes); |
| |
| IResource[] cuResources = ReorgUtils |
| .getResources(getSourceModules(fScriptElements)); |
| addFileNames(fileNames, cuResources); |
| |
| IResource[] resourcesForClipboard = ReorgUtils.union(fResources, |
| ReorgUtils.union(cuResources, resourcesOfMainTypes)); |
| IModelElement[] modelElementsForClipboard = ReorgUtils |
| .union(fScriptElements, cusOfMainTypes); |
| |
| // TypedSource[] typedSources= |
| // TypedSource.createTypedSources(modelElementsForClipboard); |
| String[] fileNameArray = fileNames |
| .toArray(new String[fileNames.size()]); |
| copyToClipboard(resourcesForClipboard, fileNameArray, |
| namesBuf.toString(), |
| modelElementsForClipboard/* , typedSources */, 0); |
| } |
| |
| private static IModelElement[] getSourceModules( |
| IModelElement[] modelElements) { |
| List cus = ReorgUtils.getElementsOfType(modelElements, |
| IModelElement.SOURCE_MODULE); |
| return (ISourceModule[]) cus.toArray(new ISourceModule[cus.size()]); |
| } |
| |
| private void processResources(Set fileNames, StringBuffer namesBuf) { |
| for (int i = 0; i < fResources.length; i++) { |
| IResource resource = fResources[i]; |
| addFileName(fileNames, resource); |
| |
| if (i > 0) |
| namesBuf.append('\n'); |
| namesBuf.append(getName(resource)); |
| } |
| } |
| |
| private void processScriptElements(Set fileNames, |
| StringBuffer namesBuf) { |
| for (int i = 0; i < fScriptElements.length; i++) { |
| IModelElement element = fScriptElements[i]; |
| switch (element.getElementType()) { |
| case IModelElement.SCRIPT_PROJECT: |
| case IModelElement.PROJECT_FRAGMENT: |
| case IModelElement.SCRIPT_FOLDER: |
| case IModelElement.SOURCE_MODULE: |
| addFileName(fileNames, ReorgUtils.getResource(element)); |
| break; |
| default: |
| break; |
| } |
| |
| if (fResources.length > 0 || i > 0) |
| namesBuf.append('\n'); |
| namesBuf.append(getName(element)); |
| } |
| } |
| |
| private static void addFileNames(Set fileName, IResource[] resources) { |
| for (int i = 0; i < resources.length; i++) { |
| addFileName(fileName, resources[i]); |
| } |
| } |
| |
| private static void addFileName(Set fileName, IResource resource) { |
| if (resource == null) |
| return; |
| IPath location = resource.getLocation(); |
| if (location != null) { |
| fileName.add(location.toOSString()); |
| } else { |
| // not a file system path. skip file. |
| } |
| } |
| |
| private void copyToClipboard(IResource[] resources, String[] fileNames, |
| String names, IModelElement[] modelElements, |
| /* |
| * TypedSource[] typedSources, |
| */int repeat) { |
| final int repeat_max_count = 10; |
| try { |
| fClipboard.setContents( |
| createDataArray(resources, modelElements, fileNames, |
| names/* , typedSources */), |
| createDataTypeArray(resources, modelElements, |
| fileNames/* , typedSources */)); |
| } catch (SWTError e) { |
| if (e.code != DND.ERROR_CANNOT_SET_CLIPBOARD |
| || repeat >= repeat_max_count) |
| throw e; |
| if (fAutoRepeatOnFailure) { |
| try { |
| Thread.sleep(500); |
| } catch (InterruptedException e1) { |
| // do nothing. |
| } |
| } |
| if (fAutoRepeatOnFailure || MessageDialog.openQuestion(fShell, |
| ReorgMessages.CopyToClipboardAction_4, |
| ReorgMessages.CopyToClipboardAction_5)) |
| copyToClipboard(resources, fileNames, names, |
| modelElements/* , typedSources */, repeat + 1); |
| } |
| } |
| |
| private static Transfer[] createDataTypeArray(IResource[] resources, |
| IModelElement[] modelElements, |
| String[] fileNames/* |
| * , TypedSource[] typedSources |
| */) { |
| List<Transfer> result = new ArrayList<>(4); |
| if (resources.length != 0) |
| result.add(ResourceTransfer.getInstance()); |
| if (modelElements.length != 0) |
| result.add(ModelElementTransfer.getInstance()); |
| if (fileNames.length != 0) |
| result.add(FileTransfer.getInstance()); |
| // if (typedSources.length != 0) |
| // result.add(TypedSourceTransfer.getInstance()); |
| result.add(TextTransfer.getInstance()); |
| return result.toArray(new Transfer[result.size()]); |
| } |
| |
| private static Object[] createDataArray(IResource[] resources, |
| IModelElement[] modelElements, String[] fileNames, |
| String names/* |
| * , TypedSource [ ] typedSources |
| */) { |
| List result = new ArrayList(4); |
| if (resources.length != 0) |
| result.add(resources); |
| if (modelElements.length != 0) |
| result.add(modelElements); |
| if (fileNames.length != 0) |
| result.add(fileNames); |
| // if (typedSources.length != 0) |
| // result.add(typedSources); |
| result.add(names); |
| return result.toArray(); |
| } |
| |
| private static ILabelProvider createLabelProvider() { |
| return new ModelElementLabelProvider( |
| ModelElementLabelProvider.SHOW_VARIABLE |
| + ModelElementLabelProvider.SHOW_PARAMETERS |
| + ModelElementLabelProvider.SHOW_TYPE |
| + ModelElementLabelProvider.SHOW_RETURN_TYPE); |
| } |
| |
| private String getName(IResource resource) { |
| return fLabelProvider.getText(resource); |
| } |
| |
| private String getName(IModelElement modelElement) { |
| return fLabelProvider.getText(modelElement); |
| } |
| } |
| |
| private static class CopyToClipboardEnablementPolicy |
| implements IReorgEnablementPolicy { |
| private final IResource[] fResources; |
| private final IModelElement[] fScriptElements; |
| |
| public CopyToClipboardEnablementPolicy(IResource[] resources, |
| IModelElement[] modelElements) { |
| Assert.isNotNull(resources); |
| Assert.isNotNull(modelElements); |
| fResources = resources; |
| fScriptElements = modelElements; |
| } |
| |
| @Override |
| public boolean canEnable() throws ModelException { |
| if (fResources.length + fScriptElements.length == 0) |
| return false; |
| if (hasProjects() && hasNonProjects()) |
| return false; |
| if (!canCopyAllToClipboard()) |
| return false; |
| if (!new ParentChecker(fResources, fScriptElements) |
| .haveCommonParent()) |
| return false; |
| return true; |
| } |
| |
| private boolean canCopyAllToClipboard() throws ModelException { |
| for (int i = 0; i < fResources.length; i++) { |
| if (!canCopyToClipboard(fResources[i])) |
| return false; |
| } |
| for (int i = 0; i < fScriptElements.length; i++) { |
| if (!canCopyToClipboard(fScriptElements[i])) |
| return false; |
| } |
| return true; |
| } |
| |
| private static boolean canCopyToClipboard(IModelElement element) |
| throws ModelException { |
| if (element == null || !element.exists()) |
| return false; |
| |
| if (ModelElementUtil.isDefaultPackage(element)) |
| return false; |
| |
| if (DLTKCore.DEBUG) { |
| System.err.println("TODO: Add inner element copy action.."); //$NON-NLS-1$ |
| } |
| // TODO: Add copy operation for external script folders.. Posible |
| // this is not required at all. |
| if (element instanceof ExternalScriptFolder) { |
| return false; |
| } |
| if (element.getElementType() > IModelElement.BINARY_MODULE) { |
| return false; |
| } |
| return true; |
| } |
| |
| private static boolean canCopyToClipboard(IResource resource) { |
| return resource != null && resource.exists() |
| && !resource.isPhantom() |
| && resource.getType() != IResource.ROOT; |
| } |
| |
| private boolean hasProjects() { |
| for (int i = 0; i < fResources.length; i++) { |
| if (ReorgUtils.isProject(fResources[i])) |
| return true; |
| } |
| for (int i = 0; i < fScriptElements.length; i++) { |
| if (ReorgUtils.isProject(fScriptElements[i])) |
| return true; |
| } |
| return false; |
| } |
| |
| private boolean hasNonProjects() { |
| for (int i = 0; i < fResources.length; i++) { |
| if (!ReorgUtils.isProject(fResources[i])) |
| return true; |
| } |
| for (int i = 0; i < fScriptElements.length; i++) { |
| if (!ReorgUtils.isProject(fScriptElements[i])) |
| return true; |
| } |
| return false; |
| } |
| } |
| } |
