bundles/org.simantics.modeling.ui/src/org/simantics/modeling/ui/modelBrowser/handlers/StandardCopyHandler.java

   1 /*******************************************************************************
   2  * Copyright (c) 2007 VTT Technical Research Centre of Finland and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *     VTT Technical Research Centre of Finland - initial API and implementation
  10  *******************************************************************************/
  11 package org.simantics.modeling.ui.modelBrowser.handlers;
  12
  13 import gnu.trove.set.hash.THashSet;
  14
  15 import java.util.Collections;
  16 import java.util.List;
  17 import java.util.Set;
  18
  19 import org.eclipse.core.commands.AbstractHandler;
  20 import org.eclipse.core.commands.ExecutionEvent;
  21 import org.eclipse.core.commands.ExecutionException;
  22 import org.eclipse.core.runtime.IProgressMonitor;
  23 import org.eclipse.core.runtime.IStatus;
  24 import org.eclipse.core.runtime.SubMonitor;
  25 import org.eclipse.core.runtime.jobs.Job;
  26 import org.eclipse.jface.action.IStatusLineManager;
  27 import org.eclipse.jface.viewers.ISelection;
  28 import org.eclipse.jface.viewers.StructuredSelection;
  29 import org.eclipse.swt.dnd.Clipboard;
  30 import org.eclipse.swt.dnd.TextTransfer;
  31 import org.eclipse.swt.dnd.Transfer;
  32 import org.eclipse.swt.widgets.Control;
  33 import org.eclipse.swt.widgets.Display;
  34 import org.eclipse.swt.widgets.Shell;
  35 import org.eclipse.swt.widgets.Tree;
  36 import org.eclipse.swt.widgets.TreeItem;
  37 import org.eclipse.ui.PlatformUI;
  38 import org.eclipse.ui.handlers.HandlerUtil;
  39 import org.simantics.Simantics;
  40 import org.simantics.browsing.ui.BuiltinKeys;
  41 import org.simantics.browsing.ui.GraphExplorer;
  42 import org.simantics.browsing.ui.NodeContext;
  43 import org.simantics.db.ReadGraph;
  44 import org.simantics.db.Resource;
  45 import org.simantics.db.common.request.ReadRequest;
  46 import org.simantics.db.common.utils.Logger;
  47 import org.simantics.db.exception.DatabaseException;
  48 import org.simantics.db.layer0.SelectionHints;
  49 import org.simantics.db.layer0.adapter.CopyHandler;
  50 import org.simantics.db.layer0.util.ClipboardUtils;
  51 import org.simantics.db.layer0.util.SimanticsClipboardImpl;
  52 import org.simantics.db.layer0.variable.Variable;
  53 import org.simantics.ui.utils.ResourceAdaptionUtils;
  54 import org.simantics.utils.datastructures.hints.IHintContext;
  55 import org.simantics.utils.ui.ISelectionUtils;
  56 import org.simantics.utils.ui.SWTUtils;
  57 import org.simantics.utils.ui.SWTUtils.ControlFilter;
  58 import org.simantics.utils.ui.workbench.WorkbenchUtils;
  59
  60 public class StandardCopyHandler extends AbstractHandler {
  61
  62     private static IStatusLineManager status;
  63
  64     private static List<Variable> getVariables(ISelection selection) {
  65         NodeContext context = ISelectionUtils.getSinglePossibleKey(selection, SelectionHints.KEY_MAIN, NodeContext.class);
  66         if(context == null) return Collections.emptyList();
  67         Object input = context.getConstant(BuiltinKeys.INPUT);
  68         IHintContext hints = input instanceof IHintContext ? (IHintContext) input : null;
  69         if(hints == null) return Collections.emptyList();
  70         Variable var = hints.getHint(SelectionHints.KEY_SELECTION_PROPERTY);
  71         if(var == null) return Collections.emptyList();
  72         else return Collections.singletonList(var);
  73     }
  74
  75     private boolean copyText(ISelection selection) {
  76         if(selection instanceof StructuredSelection) {
  77                 StructuredSelection sel = (StructuredSelection)selection;
  78                 if(sel.size() == 1) {
  79                         Object element = sel.getFirstElement();
  80                         if(element instanceof String) {
  81                                 setSystemClipboardText((String) element);
  82                         }
  83                 }
  84         }
  85         return false;
  86     }
  87
  88     @Override
  89     public Object execute(ExecutionEvent event) throws ExecutionException {
  90
  91         status = WorkbenchUtils.getStatusLine( HandlerUtil.getActiveSite(event) );
  92         ISelection selection = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getSelectionService().getSelection();
  93
  94         // If the selection is plain text copy it into system clipboard and be happy
  95         if(copyText(selection)) return null;
  96
  97         formatSelectionToClipboardText(event);
  98         final Resource[] rs = ResourceAdaptionUtils.toResources(selection);
  99         Job job = new Job("Copy resources") {
 100
 101             @Override
 102             protected IStatus run(IProgressMonitor monitor) {
 103                 monitor.beginTask("Copy resources to clipboard", 1);
 104                 copyResourcesToClipboard(rs, selection, SubMonitor.convert(monitor, 1));
 105                 return null;
 106             }
 107         };
 108         job.setUser(true);
 109         job.schedule();
 110
 111         return null;
 112     }
 113
 114     public static String copyResourcesToClipboard(final Resource[] rs, ISelection selection, IProgressMonitor monitor) {
 115
 116         if(rs == null || rs.length == 0) {
 117             // This support was added for copying of properties (variables)
 118             final List<Variable> variables = getVariables(selection);
 119             if(!variables.isEmpty()) {
 120                 final SimanticsClipboardImpl builder = new SimanticsClipboardImpl();
 121                 for(Variable var : variables) {
 122                     builder.addContent(Collections.singleton(ClipboardUtils.createVariable(Simantics.getSession(), var)), monitor);
 123                 }
 124                 Simantics.setClipboard(builder);
 125                 setCopyMessage(builder.getContents().size(), "variable");
 126                 return null;
 127             }
 128             setCopyMessage(0, "");
 129             return null;
 130         }
 131
 132         try {
 133             final SimanticsClipboardImpl builder = new SimanticsClipboardImpl();
 134             Simantics.getSession().syncRequest(new ReadRequest() {
 135                 @Override
 136                 public void run(ReadGraph graph) throws DatabaseException {
 137                     for (Resource r : rs) {
 138                         CopyHandler handler = graph.adapt(r, CopyHandler.class);
 139                         handler.copyToClipboard(graph, builder, monitor);
 140                     }
 141                 }
 142             });
 143             Simantics.setClipboard(builder);
 144             setCopyMessage(builder.getContents().size(), "resource");
 145         } catch (DatabaseException e) {
 146             Logger.defaultLogError(e);
 147         }
 148
 149         return null;
 150     }
 151
 152     private static void setCopyMessage(int count, String elementName) {
 153         if (count > 1)
 154             setStatus("Copied " + count + " " + elementName + "s to clipboard");
 155         else if (count == 1)
 156             setStatus("Copied " + elementName + " to clipboard");
 157         else
 158             setStatus("Nothing to copy.");
 159     }
 160
 161     private static void setStatus(String message) {
 162         if (status != null)
 163             status.setMessage(message);
 164     }
 165
 166     private boolean formatSelectionToClipboardText(ExecutionEvent event) {
 167         Shell shell = HandlerUtil.getActiveShell(event);
 168         Tree tree = shell == null ? null : tryGetExplorer(shell.getDisplay().getFocusControl());
 169         if (tree == null)
 170             return false;
 171
 172         TreeItem[] selection = tree.getSelection();
 173         if (selection.length == 0)
 174             return false;
 175
 176         StringBuilder sb = format(selection, new StringBuilder());
 177         if (sb.length() > 0) {
 178             setSystemClipboardText(sb.toString());
 179             return true;
 180         }
 181         return false;
 182     }
 183
 184     private static StringBuilder format(TreeItem[] selection, StringBuilder sb) {
 185         Set<TreeItem> items = new THashSet<TreeItem>(selection.length);
 186         for (TreeItem item : selection)
 187             items.add(item);
 188         for (TreeItem item : selection) {
 189             int cc = item.getParent().getColumnCount();
 190             int indent = indentLevel(item, items);
 191             for (int i = 0; i < indent; ++i)
 192                 sb.append('\t');
 193             boolean first = true;
 194             for (int c = 0; c < cc; ++c) {
 195                 String ct = item.getText(c);
 196                 if (!first) {
 197                     sb.append('\t');
 198                 }
 199                 first = false;
 200                 sb.append(ct);
 201             }
 202             sb.append('\n');
 203         }
 204         return sb;
 205     }
 206
 207     private static int indentLevel(TreeItem item, Set<TreeItem> items) {
 208         TreeItem p = item.getParentItem();
 209         for (int i = 1; ; p = p.getParentItem()) {
 210             if (p == null)
 211                 return 0;
 212             if (items.contains(p))
 213                 return i;
 214         }
 215     }
 216
 217     private static Tree tryGetExplorer(Control control) {
 218         return SWTUtils.tryGetObject(control, new ControlFilter<Tree>() {
 219             @Override
 220             public Tree accept(Control control) {
 221                 if (!control.isDisposed()
 222                         && control instanceof Tree
 223                         && control.getData(GraphExplorer.KEY_GRAPH_EXPLORER) != null)
 224                     return (Tree) control;
 225                 return null;
 226             }
 227         });
 228     }
 229
 230     private static void setSystemClipboardText(String text) {
 231         Clipboard clipboard = new Clipboard(Display.getCurrent());
 232         clipboard.setContents(new Object[]{ text }, new Transfer[] { TextTransfer.getInstance() });
 233         clipboard.dispose();
 234     }
 235
 236 }