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:     /**
  79:      * Get the system cliboard. If not available, create and return the VM-local
  80:      * clipboard.
  81:      * 
  82:      * @param component a component, used to get the toolkit.
  83:      * @return the clipboard
  84:      */
  85:     private static Clipboard getClipboard(JComponent component)
  86:     {
  87:       // Avoid throwing exception if the system clipboard access failed
  88:       // in the past.
  89:       if (clipboard != null)
  90:         return clipboard;
  91:       else
  92:         {
  93:           try
  94:             {
  95:               SecurityManager sm = System.getSecurityManager();
  96:               if (sm != null)
  97:                 sm.checkSystemClipboardAccess();
  98: 
  99:               // We may access system clipboard.
 100:               return component.getToolkit().getSystemClipboard();
 101:             }
 102:           catch (Exception e)
 103:             {
 104:               // We may not access system clipboard.
 105:               // Create VM-local clipboard if none exists yet.
 106:               clipboard = new Clipboard("Clipboard");
 107:               return clipboard;
 108:             }
 109:         }
 110:     }
 111:   }
 112:   
 113:   private static final long serialVersionUID = -967749805571669910L;
 114: 
 115:   private static final String COMMAND_COPY = "copy";
 116:   private static final String COMMAND_CUT = "cut";
 117:   private static final String COMMAND_PASTE = "paste";
 118:   
 119:   public static final int NONE = 0;
 120:   public static final int COPY = 1;
 121:   public static final int MOVE = 2;
 122:   public static final int COPY_OR_MOVE = 3;
 123: 
 124:   private static Action copyAction = new TransferAction(COMMAND_COPY);
 125:   private static Action cutAction = new TransferAction(COMMAND_CUT);
 126:   private static Action pasteAction = new TransferAction(COMMAND_PASTE);
 127:   
 128:   /**
 129:    * Clipboard if system clipboard may not be used.
 130:    * Package-private to avoid an accessor method.
 131:    */
 132:   static Clipboard clipboard;
 133:   
 134:   private int sourceActions;
 135:   private Icon visualRepresentation;
 136:   
 137:   public static Action getCopyAction()
 138:   {
 139:     return copyAction;
 140:   }
 141: 
 142:   public static Action getCutAction()
 143:   {
 144:     return cutAction;
 145:   }
 146: 
 147:   public static Action getPasteAction()
 148:   {
 149:     return pasteAction;
 150:   }
 151: 
 152:   protected TransferHandler()
 153:   {
 154:     this.sourceActions = NONE;
 155:   }
 156: 
 157:   public TransferHandler(String property)
 158:   {
 159:     this.sourceActions = property != null ? COPY : NONE;
 160:   }
 161: 
 162:   public boolean canImport (JComponent c, DataFlavor[] flavors)
 163:   {
 164:     return false;
 165:   }
 166: 
 167:   protected Transferable createTransferable(JComponent c) 
 168:   {
 169:     return null;
 170:   }
 171: 
 172:   public void exportAsDrag (JComponent c, InputEvent e, int action) 
 173:   {
 174:     // TODO: Implement this properly
 175:   }
 176: 
 177:   protected void exportDone (JComponent c, Transferable data, int action) 
 178:   {
 179:     // TODO: Implement this properly
 180:   }
 181: 
 182:   public void exportToClipboard(JComponent c, Clipboard clip, int action) 
 183:   {
 184:     // TODO: Implement this properly
 185:   } 
 186: 
 187:   public int getSourceActions (JComponent c)
 188:   {
 189:     return sourceActions;
 190:   }
 191: 
 192:   public Icon getVisualRepresentation (Transferable t)
 193:   {
 194:     return visualRepresentation;
 195:   }
 196: 
 197:   public boolean importData (JComponent c, Transferable t) 
 198:   {
 199:     return false;
 200:   }
 201: }