MenuY.java Source code

Java tutorial

Introduction

Here is the source code for MenuY.java

Source

/*
Definitive Guide to Swing for Java 2, Second Edition
By John Zukowski       
ISBN: 1-893115-78-X
Publisher: APress
*/

import java.awt.Event;
import java.awt.GridLayout;
import java.awt.LayoutManager;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;

import javax.swing.AbstractAction;
import javax.swing.AbstractButton;
import javax.swing.Action;
import javax.swing.ButtonGroup;
import javax.swing.ButtonModel;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.JRadioButtonMenuItem;
import javax.swing.KeyStroke;
import javax.swing.MenuElement;
import javax.swing.MenuSelectionManager;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.event.MenuEvent;
import javax.swing.event.MenuKeyEvent;
import javax.swing.event.MenuKeyListener;
import javax.swing.event.MenuListener;

public class MenuY {
    static class MenuActionListener implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            System.out.println("Selected: " + e.getActionCommand());
        }
    }

    static class MyMenuListener implements MenuListener {
        public void menuCanceled(MenuEvent e) {
            System.out.println("Canceled");
        }

        public void menuDeselected(MenuEvent e) {
            System.out.println("Deselected");
        }

        public void menuSelected(MenuEvent e) {
            System.out.println("Selected");
        }
    }

    static class MyChangeListener implements ChangeListener {
        public void stateChanged(ChangeEvent event) {
            Object source = event.getSource();
            if (source instanceof AbstractButton) {
                AbstractButton aButton = (AbstractButton) source;
                ButtonModel aModel = aButton.getModel();
                boolean armed = aModel.isArmed();
                boolean pressed = aModel.isPressed();
                boolean selected = aModel.isSelected();
                System.out.println("Changed " + aButton.getText() + ": " + armed + "/" + pressed + "/" + selected);
                /*
                 * } else if (source instanceof MenuSelectionManager) {
                 * MenuSelectionManager manager = (MenuSelectionManager)source;
                 * MenuElement path[] = manager.getSelectedPath(); for (int i=0,
                 * n=path.length; i <n; i++) { MenuElement item =
                 * (MenuElement)path[i]; System.out.print ("-->" +
                 * item.getClass().getName()); } System.out.println();
                 */}
        }
    }

    static class MyMenuKeyListener implements MenuKeyListener {
        public void menuKeyPressed(MenuKeyEvent e) {
            printInfo("Pressed", e);
        }

        public void menuKeyReleased(MenuKeyEvent e) {
            printInfo("Released", e);
        }

        public void menuKeyTyped(MenuKeyEvent e) {
            printInfo("Typed", e);
        }

        private void printInfo(String eventType, MenuKeyEvent e) {
            System.out.print(eventType + ":");
            MenuElement path[] = e.getPath();
            /*
             * for (int i=0, n=path.length; i <n; i++) { MenuElement item =
             * (MenuElement)path[i]; System.out.print ("==>" +
             * item.getClass().getName()); }
             */System.out.println();
        }
    }

    public static void main(String args[]) {
        ActionListener actionListener = new MenuActionListener();
        MenuKeyListener menuKeyListener = new MyMenuKeyListener();
        ChangeListener cListener = new MyChangeListener();
        MenuListener menuListener = new MyMenuListener();
        MenuSelectionManager manager = MenuSelectionManager.defaultManager();
        manager.addChangeListener(cListener);
        JFrame frame = new JFrame("MenuSample Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JMenuBar bar = new VerticalMenuBar();
        //    JMenuBar bar = new JMenuBar();

        // File Menu, F - Mnemonic
        JMenu file = new JMenu("File");
        file.setMnemonic(KeyEvent.VK_F);
        file.addChangeListener(cListener);
        file.addMenuListener(menuListener);
        file.addMenuKeyListener(menuKeyListener);
        JPopupMenu popupMenu = file.getPopupMenu();
        popupMenu.setLayout(new GridLayout(3, 3));
        bar.add(file);

        // File->New, N - Mnemonic
        JMenuItem newItem = new JMenuItem("New", KeyEvent.VK_N);
        newItem.addActionListener(actionListener);
        newItem.addChangeListener(cListener);
        newItem.addMenuKeyListener(menuKeyListener);
        file.add(newItem);

        // File->Open, O - Mnemonic
        JMenuItem openItem = new JMenuItem("Open", KeyEvent.VK_O);
        openItem.addActionListener(actionListener);
        openItem.addChangeListener(cListener);
        openItem.addMenuKeyListener(menuKeyListener);
        file.add(openItem);

        // File->Close, C - Mnemonic
        JMenuItem closeItem = new JMenuItem("Close", KeyEvent.VK_C);
        closeItem.addActionListener(actionListener);
        closeItem.addChangeListener(cListener);
        closeItem.addMenuKeyListener(menuKeyListener);
        file.add(closeItem);

        // Separator
        file.addSeparator();

        // File->Save, S - Mnemonic
        JMenuItem saveItem = new JMenuItem("Save", KeyEvent.VK_S);
        saveItem.addActionListener(actionListener);
        saveItem.addChangeListener(cListener);
        saveItem.addMenuKeyListener(menuKeyListener);
        file.add(saveItem);

        // Separator
        file.addSeparator();

        // File->Exit, X - Mnemonic
        JMenuItem exitItem = new JMenuItem("Exit", KeyEvent.VK_X);
        exitItem.addActionListener(actionListener);
        exitItem.addChangeListener(cListener);
        exitItem.addMenuKeyListener(menuKeyListener);
        file.add(exitItem);

        // Edit Menu, E - Mnemonic
        JMenu edit = new JMenu("Edit");
        edit.setMnemonic(KeyEvent.VK_E);
        edit.addChangeListener(cListener);
        edit.addMenuListener(menuListener);
        edit.addMenuKeyListener(menuKeyListener);
        bar.add(edit);

        // Edit->Cut, T - Mnemonic, CTRL-X - Accelerator
        JMenuItem cutItem = new JMenuItem("Cut", KeyEvent.VK_T);
        cutItem.addActionListener(actionListener);
        cutItem.addChangeListener(cListener);
        cutItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_X, Event.CTRL_MASK));
        cutItem.addMenuKeyListener(menuKeyListener);
        edit.add(cutItem);

        // Edit->Copy, C - Mnemonic, CTRL-C - Accelerator
        JMenuItem copyItem = new JMenuItem("Copy", KeyEvent.VK_C);
        copyItem.addActionListener(actionListener);
        copyItem.addChangeListener(cListener);
        copyItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C, Event.CTRL_MASK));
        copyItem.addMenuKeyListener(menuKeyListener);
        copyItem.setEnabled(false);
        edit.add(copyItem);

        // Edit->Paste, P - Mnemonic, CTRL-V - Accelerator, Disabled
        JMenuItem pasteItem = new JMenuItem("Paste", KeyEvent.VK_P);
        pasteItem.addActionListener(actionListener);
        pasteItem.addChangeListener(cListener);
        pasteItem.addMenuKeyListener(menuKeyListener);
        pasteItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_V, Event.CTRL_MASK));
        pasteItem.setEnabled(false);
        edit.add(pasteItem);

        // Separator
        edit.addSeparator();

        // Edit->Find, F - Mnemonic, F3 - Accelerator
        JMenuItem findItem = new JMenuItem("Find", KeyEvent.VK_F);
        findItem.addActionListener(actionListener);
        findItem.addChangeListener(cListener);
        findItem.addMenuKeyListener(menuKeyListener);
        findItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F3, 0));
        edit.add(findItem);

        // Edit->Options Submenu, O - Mnemonic, at.gif - Icon Image File
        Icon atIcon = new ImageIcon("at.gif");
        Action findAction = new AbstractAction("Options", atIcon) {
            ActionListener actionListener = new MenuActionListener();

            public void actionPerformed(ActionEvent e) {
                actionListener.actionPerformed(e);
            }
        };
        findAction.putValue(Action.MNEMONIC_KEY, new Integer(KeyEvent.VK_O));
        JMenuItem jMenuItem = new JMenuItem(findAction);

        JMenu findOptions = new JMenu(findAction);
        findOptions.addChangeListener(cListener);
        findOptions.addMenuListener(menuListener);
        findOptions.addMenuKeyListener(menuKeyListener);

        // ButtonGrou for radio buttons
        ButtonGroup directionGroup = new ButtonGroup();

        // Edit->Options->Forward, F - Mnemonic, in group
        JRadioButtonMenuItem forward = new JRadioButtonMenuItem("Forward", true);
        forward.addActionListener(actionListener);
        forward.addChangeListener(cListener);
        forward.addMenuKeyListener(menuKeyListener);
        forward.setMnemonic(KeyEvent.VK_F);
        findOptions.add(forward);
        directionGroup.add(forward);

        // Edit->Options->Backward, B - Mnemonic, in group
        JRadioButtonMenuItem backward = new JRadioButtonMenuItem("Backward");
        backward.addActionListener(actionListener);
        backward.addChangeListener(cListener);
        backward.addMenuKeyListener(menuKeyListener);
        backward.setMnemonic(KeyEvent.VK_B);
        findOptions.add(backward);
        directionGroup.add(backward);

        // Separator
        findOptions.addSeparator();

        // Edit->Options->Case Sensitive, C - Mnemonic
        JCheckBoxMenuItem caseItem = new JCheckBoxMenuItem("Case Sensitive");
        caseItem.addActionListener(actionListener);
        caseItem.addChangeListener(cListener);
        caseItem.addMenuKeyListener(menuKeyListener);
        caseItem.setMnemonic(KeyEvent.VK_C);
        findOptions.add(caseItem);
        edit.add(findOptions);

        frame.setJMenuBar(bar);
        //    frame.getContentPane().add(bar, BorderLayout.EAST);
        frame.setSize(350, 250);
        frame.setVisible(true);
    }
}

class VerticalMenuBar extends JMenuBar {
    private static final LayoutManager grid = new GridLayout(0, 1);

    public VerticalMenuBar() {
        setLayout(grid);
    }
}