1

Swing text components don't have a context menu with cut/copy/paste/etc. I want to add one so it behaves more fluently and like a native app. I've written a menu for this and it works fine. I add it to each text box using:

someTextBox.setComponentPopupMenu(TextContextMenu.INSTANCE);

The thing is, adding this everywhere is annoying. Secondly, if I forget it for a text box somewhere, the application is inconsistent. Thirdly, I can't add it for text boxes where I don't control the creation code, like the ones from JOptionPane.showInputDialog or JFileChooser dialogs.

Is there any way to override the default context menu of JTextComponent application-wide? I know this would be a form of spooky action at a distance but I'm okay with that. Comments on the menu itself are also welcome.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.text.JTextComponent;

public class TextContextMenu extends JPopupMenu implements ActionListener {
    public static final TextContextMenu INSTANCE = new TextContextMenu();
    private final JMenuItem itemCut;
    private final JMenuItem itemCopy;
    private final JMenuItem itemPaste;
    private final JMenuItem itemDelete;
    private final JMenuItem itemSelectAll;

    private TextContextMenu() {
        itemCut = newItem("Cut", 'T');
        itemCopy = newItem("Copy", 'C');
        itemPaste = newItem("Paste", 'P');
        itemDelete = newItem("Delete", 'D');
        addSeparator();
        itemSelectAll = newItem("Select All", 'A');
    }

    private JMenuItem newItem(String text, char mnemonic) {
        JMenuItem item = new JMenuItem(text, mnemonic);
        item.addActionListener(this);
        return add(item);
    }

    @Override
    public void show(Component invoker, int x, int y) {
        JTextComponent tc = (JTextComponent)invoker;
        boolean changeable = tc.isEditable() && tc.isEnabled();
        itemCut.setVisible(changeable);
        itemPaste.setVisible(changeable);
        itemDelete.setVisible(changeable);
        super.show(invoker, x, y);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        JTextComponent tc = (JTextComponent)getInvoker();
        tc.requestFocus();

        boolean haveSelection = tc.getSelectionStart() != tc.getSelectionEnd();
        if (e.getSource() == itemCut) {
            if (!haveSelection) tc.selectAll();
            tc.cut();
        } else if (e.getSource() == itemCopy) {
            if (!haveSelection) tc.selectAll();
            tc.copy();
        } else if (e.getSource() == itemPaste) {
            tc.paste();
        } else if (e.getSource() == itemDelete) {
            if (!haveSelection) tc.selectAll();
            tc.replaceSelection("");
        } else if (e.getSource() == itemSelectAll) {
            tc.selectAll();
        }
    }
}
Boann
  • 48,794
  • 16
  • 117
  • 146
  • 1
    make your own `class JTextComponentWithMenu extends JTextComponent` and use it instead. In its constructor you can add the `setComponentPopupMenu(TextContextMenu.INSTANCE);` call. – DSquare Oct 17 '13 at 10:54
  • You need to customize the Look and Feel (L&F) you use. – Sergiy Medvynskyy Oct 17 '13 at 11:02
  • @DSquare I would have to subclass JTextField, JTextPane, and JTextArea, I'd still have to remember it for every text box, and it still wouldn't work for standard dialogs. – Boann Oct 17 '13 at 12:27

3 Answers3

5

I've figured out how to do this application-wide, including on JFileChoosers and showInputDialog and things! I'm not sure how sane and proper it is but it works. It (ab)uses the pluggable look and feel system. JTextComponent calls updateUI during its constructor, which provides the opportunity to call setComponentPopupMenu when the L&F gets asked for its UI delegate.

If you change the look and feel for already-open windows, each component's updateUI method will be called again. To prevent setting the default menu again, the code below stores the property of whether a text box has already been initialized or not using JComponent.putClientProperty.

The net effect is it behaves just as though each JTextComponent itself was calling setComponentPopupMenu just one time during its constructor. Thus, it is easy to override this for special text boxes which want no menu or want a different menu: just call setComponentPopupMenu again. E.g, from a textfield subclass constructor or from the calling code that creates a window and its widgets.

This is the code to run once at application startup:

UIManager.addAuxiliaryLookAndFeel(new LookAndFeel() {
    private final UIDefaults defaults = new UIDefaults() {
        @Override
        public javax.swing.plaf.ComponentUI getUI(JComponent c) {
            if (c instanceof javax.swing.text.JTextComponent) {
                if (c.getClientProperty(this) == null) {
                    c.setComponentPopupMenu(TextContextMenu.INSTANCE);
                    c.putClientProperty(this, Boolean.TRUE);
                }
            }
            return null;
        }
    };
    @Override public UIDefaults getDefaults() { return defaults; };
    @Override public String getID() { return "TextContextMenu"; }
    @Override public String getName() { return getID(); }
    @Override public String getDescription() { return getID(); }
    @Override public boolean isNativeLookAndFeel() { return false; }
    @Override public boolean isSupportedLookAndFeel() { return true; }
});
Boann
  • 48,794
  • 16
  • 117
  • 146
  • +1 that's the most elegant approach :-) Just beware: there is a faint possibility that internal lookup of stuff (f.i. audioMaps if available) doesn't work because the default delegates try to find instances of BasicLookAndFeel without taking an auxLAF into account. This slight probability forced us at SwingX to abandon this, though there is still some code in the unused source folder. – kleopatra Oct 17 '13 at 15:00
  • 1
    Unfortunately, this method appears incompatible with JavaHelp. Whenever I install this auxiliary look and feel, multiple errors similar to the following are written to System.err the first time a help screen is accessed: `Multiplexing LAF: no ComponentUI class for: javax.help.JHelpContentViewer` Oddly, this doesn't seem to affect the actual functionality of JavaHelp, but it does throw the user for a loop because they're notified that errors have been written to the error log. – Kevin Rahe Mar 10 '15 at 14:15
1

You have two choices:

  1. If your application have an own customized Look and Feel you can simply do it in installUI(JComponent c) method in your TextUI(s).

  2. If you have no own L&F, you must traverse the Component tree, find all instances of JTextComponent, and add your context menu. I would make it as a static helper method. For dialogs and frames you need a basic class, which redefines the method setVisible() to add the context menu for all text components. All your custom dialogs or frame must extend the basic dialog/frame.

Sergiy Medvynskyy
  • 11,160
  • 1
  • 32
  • 48
  • Option 1 sounds like the proper route but I want to allow any of the pluggable look & feels to work, so I'm not sure if it's possible. I considered option 2. It could help in some cases, but there's at least one JTextField subclass (a key binding chooser) in my application which must not have this menu. For a component to unset or change its context menu won't work if the default text context menu is being initialized so late. It inverts the problem from one of tracking which boxes need the default menu to tracking which ones don't. – Boann Oct 17 '13 at 12:27
  • Using your hint about look & feels I've found a proper solution now (below). Thanks :) – Boann Oct 17 '13 at 14:51
1

Because of the conflict I ran into with JavaHelp, I needed a different solution. What I came up with is a variation of choice 2. in the second answer, where I do the work when a class is instantiated rather than on a call to setVisible().

public static void installDefaultTextContextMenus( Container aContainer )
    {
        if ( aContainer != null )
        {
            if ( aContainer instanceof JFrame )
            {
                aContainer = ((JFrame)aContainer).getContentPane();
            }
            else if ( aContainer instanceof JDialog )
            {
                aContainer = ((JDialog)aContainer).getContentPane();
            }
            Component[] lComponents = aContainer.getComponents();
            for ( int lCompNum = 0; lCompNum < lComponents.length; ++lCompNum )
            {
                lComponents[ lCompNum ].getClass();
                if ( ( lComponents[ lCompNum ] instanceof JPanel ) ||
                     ( lComponents[ lCompNum ] instanceof JInternalFrame ) ||
                     ( lComponents[ lCompNum ] instanceof JScrollPane ) ||
                     ( lComponents[ lCompNum ] instanceof JSplitPane ) ||
                     ( lComponents[ lCompNum ] instanceof JTabbedPane ) ||
                     ( lComponents[ lCompNum ] instanceof Panel ) ||
                     ( lComponents[ lCompNum ] instanceof ScrollPane ) ||
                     ( lComponents[ lCompNum ] instanceof JViewport ) ||
                     ( lComponents[ lCompNum ] instanceof JFrame ) ||
                     ( lComponents[ lCompNum ] instanceof JDialog ) )
                {
                    installDefaultTextContextMenus( (Container)lComponents[ lCompNum ] );
                }
                else if ( lComponents[ lCompNum ] instanceof JTextComponent )
                {
                    ((JTextComponent)lComponents[ lCompNum ]).setComponentPopupMenu( TextContextMenu.INSTANCE );
                }
                else if ( lComponents[ lCompNum ] instanceof JComboBox )
                {
                    Component lEditorComp = ((JComboBox)lComponents[ lCompNum ]).getEditor().getEditorComponent();
                    if ( lEditorComp instanceof JTextComponent )
                    {
                        ((JTextComponent)lEditorComp).setComponentPopupMenu( TextContextMenu.INSTANCE );
                    }
                }
            }
        }
    }

The method will traverse practically any tree of Swing components. Luckily I already had a common method used to decorate all of my application's top-level JFrames, to which I was able to add a call to this method. I did have to add a call to this method for each instantiation of a frame or dialog not handled by my top-level menu, however.

Kevin Rahe
  • 1,609
  • 3
  • 19
  • 27