Scott Violet's Blog

August 2006 Archives

Cut, Copy and Paste

As usual, for those wishing to cut to the chase, here's the app:

Many Swing components provide cut, copy and paste support. For example, JTextField supports cut, copy and paste out the box. This is hardly revolutionary; todays developers expect such behavior out of the box.

Swing's cut, copy and paste support is provided by javax.swing.TransferHandler. TransferHandler provides Actions for cut, copy and paste. Unfortunately the enabled state of the actions is not updated based on context, and the actions target the source of the event. In other words, the actions provided by TransferHandler are not appropriate for use on menus or toolbars.

While the Actions provided by TransferHandler have limited usage, the remaining portions of TransferHandler are imminently more useful (even more so in 1.6). Rather than reinvent the wheel, I'll provide new Actions that target TransferHandler.

Here's the list of requirements for cut, copy and paste actions:

• The actions should track the permanent focus owner. For example, you would not want the copy action to target a menu when it has focus.
• The paste action should only be enabled if the clipboard has a data flavor supported by the component.
• The cut and copy actions need to update based on the selection of the component. For example, if a text field has focus, the cut and copy actions should only be enabled if the selection is not empty. *

Targetting the focused component is easily done with the KeyboardFocusManager. The KeyboardFocusManager maintains a bound property for the permanent focus owner. To listen for changes one need only install a PropertyChangeListener. The following code illustrates this:

  PropertyChangeListener focusListener = new PropertyChangeListener {
    public void propertyChange(PropertyChangeEvent e) {
      if (e.getPropertyName() == "permanentFocusOwner") {
        // The permanent focus owner has changed.
        newPermanentFocusOwner((Component)e.getNewValue());
      }
    }
  };
  KeyboardFocusManager.getCurrentKeyboardFocusManager().
      addPropertyChangeListener(focusListener);

  FlavorListener flavorListener = new FlavorListener {
    public void flavorsChanged(FlavorEvent e) {
      flavorsChanged();
    }
  };
  Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
  clipboard.addFlavorListener(flavorListener);

  CutCopyPasteHelper.registerDataFlavors(component,  DataFlavor...dataFlavors);

Once you've enabled paste on the component and registered the set of flavors, CutCopyPasteHelper has all the information needed to update the paste action appropriately for you.

The cut and copy actions are simpler. These are updated based on the focused component, and whether or not you've enabled cut and copy. For example, a text field with an empty selection would disable the cut and copy actions. On the other hand, a text field with a non-empty selection would enable the cut and copy actions. CutCopyPasteHelper provides the setCutEnabled and setCopyEnabled methods for this.

Many Swing components provide keyboard bindings that target the actions provided by TransferHandler. CutCopyPasteHelper provides replacements for these actions. For a component to use CutCopyPasteHelper actions you must change the bindings registered on each component to target CutCopyPasteHelper. This is done using the ActionMap and InputMap. CutCopyPasteHelper provides the registerCutCopyPasteBindings that takes care of this.

Here's a cheat sheet for using these actions with a component:

1. Provide a TransferHandler for the component.
2. Replace the bindings provided by Swing using the registerCutCopyPasteBindings method.
3. Register the set of data flavors supported during paste by way of the registerDataFlavors method.
4. Install a listener on the component that updates the cut and copy state based on the component's selection. The cut and copy state is changed using the setCutEnabled and setCopyEnabled methods.

  // Step 1
  // Install the TransferHandler.
  entryList.setTransferHandler(new ListTransferHandler());

  // Step 2
  // Register key bindings that target the cut, copy, and paste actions
  // provided by CutCopyPasteHelper.
  CutCopyPasteHelper.registerCutCopyPasteBindings(entryList, true);

  // Step 3
  // Register the data flavors on the list:
  CutCopyPasteHelper.registerDataFlavors(entryList,
                PASSWORD_ENTRY_DATA_FLAVOR);
  // Enable paste
  CutCopyPasteHelper.setPasteEnabled(entryList, true);

  // Step 4
  // Install listener to update cut/copy state based on selection
  ListSelectionListener selectionListener = new ListSelectionListener {
    public void valueChanged(ListSelectionEvent e) {
      if (!e.getValueIsAdjusting()) {
        boolean hasSelection = (entryList.getMinSelectionIndex() != -1);
        CutCopyPasteHelper.setCopyEnabled(entryList, hasSelection);
        CutCopyPasteHelper.setCutEnabled(entryList, hasSelection);
      }
    }
  };
  entryList.addListSelectionListener(new ListSelectionHandler());

* Selection

The Sandbox

Early on I mentioned I wanted it to be trivial to wire these actions up to existing components. I've done the work for the text components. As this blog is now gargantuan in size, I'll save that for a later blog. In the mean time, here's the latest source for the password store app, and source for fabric. For those that look at the source, you'll see a bunch of stuff I haven't gotten to. That's for a later day as well... Oh, and yes, CutCopyPasteHelper will eventually makes it's way into Swing in some form or another.

    -Scott

This work is licensed under a Creative Commons License.