Source for javax.swing.TransferHandler

   1: /* TransferHandler.java --
   2:    Copyright (C) 2004 Free Software Foundation, Inc.
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10: 
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 USA.
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version. */
  37: 
  38: 
  39: package javax.swing;
  40: 
  41: import java.awt.datatransfer.Clipboard;
  42: import java.awt.datatransfer.DataFlavor;
  43: import java.awt.datatransfer.Transferable;
  44: import java.awt.event.ActionEvent;
  45: import java.awt.event.InputEvent;
  46: import java.io.Serializable;
  47: 
  48: public class TransferHandler implements Serializable
  49: {
  50:   static class TransferAction extends AbstractAction
  51:   {
  52:     private String command;
  53: 
  54:     public TransferAction(String command)
  55:     {
  56:       this.command = command;
  57:     }
  58:     
  59:     public void actionPerformed(ActionEvent event)
  60:     {
  61:       JComponent component = (JComponent) event.getSource();
  62:       TransferHandler transferHandler = component.getTransferHandler();
  63:       Clipboard clipboard = getClipboard(component);
  64: 
  65:       if (command.equals(COMMAND_COPY))
  66:     transferHandler.exportToClipboard(component, clipboard, COPY);
  67:       else if (command.equals(COMMAND_CUT))
  68:     transferHandler.exportToClipboard(component, clipboard, MOVE);
  69:       else if (command.equals(COMMAND_PASTE))
  70:     {
  71:       Transferable transferable = clipboard.getContents(null);
  72: 
  73:       if (transferable != null)
  74:         transferHandler.importData(component, transferable);
  75:     }
  76:     }
  77:   
  78:     private static Clipboard getClipboard(JComponent component)
  79:     {
  80:       SecurityManager sm = System.getSecurityManager();
  81:     
  82:       if (sm != null)
  83:     {
  84:       try
  85:         {
  86:           sm.checkSystemClipboardAccess();
  87: 
  88:           // We may access system clipboard.
  89:           return component.getToolkit().getSystemClipboard();
  90:         }
  91:       catch (SecurityException e)
  92:         {
  93:           // We may not access system clipboard.
  94:         }
  95:     }
  96:     
  97:       // Create VM-local clipboard if non exists yet.
  98:       if (clipboard == null)
  99:         clipboard = new Clipboard("Clipboard");
 100: 
 101:       return clipboard;
 102:     }
 103:   }
 104:   
 105:   private static final long serialVersionUID = -967749805571669910L;
 106: 
 107:   private static final String COMMAND_COPY = "copy";
 108:   private static final String COMMAND_CUT = "cut";
 109:   private static final String COMMAND_PASTE = "paste";
 110:   
 111:   public static final int NONE = 0;
 112:   public static final int COPY = 1;
 113:   public static final int MOVE = 2;
 114:   public static final int COPY_OR_MOVE = 3;
 115: 
 116:   private static Action copyAction = new TransferAction(COMMAND_COPY);
 117:   private static Action cutAction = new TransferAction(COMMAND_CUT);
 118:   private static Action pasteAction = new TransferAction(COMMAND_PASTE);
 119:   
 120:   /**
 121:    * Clipboard if system clipboard may not be used.
 122:    * Package-private to avoid an accessor method.
 123:    */
 124:   static Clipboard clipboard;
 125:   
 126:   private int sourceActions;
 127:   private Icon visualRepresentation;
 128:   
 129:   public static Action getCopyAction()
 130:   {
 131:     return copyAction;
 132:   }
 133: 
 134:   public static Action getCutAction()
 135:   {
 136:     return cutAction;
 137:   }
 138: 
 139:   public static Action getPasteAction()
 140:   {
 141:     return pasteAction;
 142:   }
 143: 
 144:   protected TransferHandler()
 145:   {
 146:     this.sourceActions = NONE;
 147:   }
 148: 
 149:   public TransferHandler(String property)
 150:   {
 151:     this.sourceActions = property != null ? COPY : NONE;
 152:   }
 153: 
 154:   public boolean canImport (JComponent c, DataFlavor[] flavors)
 155:   {
 156:     return false;
 157:   }
 158: 
 159:   protected Transferable createTransferable(JComponent c) 
 160:   {
 161:     return null;
 162:   }
 163: 
 164:   public void exportAsDrag (JComponent c, InputEvent e, int action) 
 165:   {
 166:     // TODO: Implement this properly
 167:   }
 168: 
 169:   protected void exportDone (JComponent c, Transferable data, int action) 
 170:   {
 171:     // TODO: Implement this properly
 172:   }
 173: 
 174:   public void exportToClipboard(JComponent c, Clipboard clip, int action) 
 175:   {
 176:     // TODO: Implement this properly
 177:   } 
 178: 
 179:   public int getSourceActions (JComponent c)
 180:   {
 181:     return sourceActions;
 182:   }
 183: 
 184:   public Icon getVisualRepresentation (Transferable t)
 185:   {
 186:     return visualRepresentation;
 187:   }
 188: 
 189:   public boolean importData (JComponent c, Transferable t) 
 190:   {
 191:     return false;
 192:   }
 193: }