Welcome to The Definitive Guide to Java Swing Third Edtion’s documentation!¶

class AnActionListener implements ActionListener {
  public void actionPerformed(ActionEvent actionEvent) {
    System.out.println("I was selected.");
  }
}

ActionListener actionListener = new AnActionListener();

ActionListener actionListener = new ActionListener() {
  public void actionPerformed(ActionEvent actionEvent) {
    System.out.println("I was selected.");
  }
};

button.addActionListener(actionListener);

public class YourClass implements ActionListener {
  ... // Other code for your class
  public void actionPerformed(ActionEvent actionEvent) {
    System.out.println("I was selected.");
  }
  // Code within some method
   JButton button = new JButton(...);
   button.addActionListener(this);
  // More code within some method
}

public void mousePressed(MouseEvent mouseEvent) {
  int modifiers = mouseEvent.getModifiers();
  if ((modifiers & InputEvent.BUTTON2_MASK) == InputEvent.BUTTON2_MASK) {
    System.out.println("Middle button pressed.");
  }
}

SwingUtilities.isLeftMouseButton(MouseEvent mouseEvent)
SwingUtilities.isMiddleMouseButton(MouseEvent mouseEvent)
SwingUtilities.isRightMouseButton(MouseEvent mouseEvent)

if (SwingUtilities.isMiddleMouseButton(mouseEvent)) {
  System.out.println("Middle button released.");
}

/**
 *
 */
package swingstudy.ch02;

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.InputEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;

/**
 * @author lenovo
 *
 */
public class ButtonSample2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Button Sample");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                JButton button =  new JButton("Select Me");

                ActionListener actionListener = new ActionListener() {
                    public void actionPerformed(ActionEvent event) {
                        System.out.println("I was selected");
                    }
                };

                MouseListener mouseListener = new MouseAdapter() {
                    public void mousePressed(MouseEvent event) {
                        int modifiers = event.getModifiers();

                        if((modifiers & InputEvent.BUTTON1_MASK) == InputEvent.BUTTON1_MASK) {
                            System.out.println("Left button is pressed");
                        }

                        if((modifiers & InputEvent.BUTTON2_MASK) == InputEvent.BUTTON2_MASK) {
                            System.out.println("Middle button is pressed");
                        }

                        if((modifiers & InputEvent.BUTTON3_MASK) == InputEvent.BUTTON3_MASK) {
                            System.out.println("Right button is pressed");
                        }
                    }

                    public void mouseReleased(MouseEvent event) {
                        if(SwingUtilities.isLeftMouseButton(event)) {
                            System.out.println("Left button is released");
                        }

                        if(SwingUtilities.isMiddleMouseButton(event)) {
                            System.out.println("Middle button is released");
                        }

                        if(SwingUtilities.isRightMouseButton(event)) {
                            System.out.println("Right button is released");
                        }
                    }
                };

                button.addActionListener(actionListener);
                button.addMouseListener(mouseListener);

                frame.add(button, BorderLayout.SOUTH);
                frame.setSize(300,100);
                frame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

/**
 *
 */
package swingstudy.ch02;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.Random;

import javax.swing.JButton;
import javax.swing.JFrame;

/**
 * @author lenovo
 *
 */
public class ButtonSample3 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Button Sample");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                final JButton button1 = new JButton("Select Me");
                final JButton button2 = new JButton("No Select Me");

                final Random random = new Random();

                ActionListener actionListener = new ActionListener(){
                    public void actionPerformed(ActionEvent event) {
                        JButton button = (JButton)event.getSource();
                        int red = random.nextInt(255);
                        int green = random.nextInt(255);
                        int blue = random.nextInt(255);
                        button.setBackground(new Color(red, green, blue));
                    }
                };

                PropertyChangeListener propertyChangeListener = new PropertyChangeListener() {
                    public void propertyChange(PropertyChangeEvent event) {
                        String property = event.getPropertyName();
                        if("background".equals(property)) {
                            button2.setBackground((Color)event.getNewValue());
                        }
                    }
                };

                button1.addActionListener(actionListener);
                button1.addPropertyChangeListener(propertyChangeListener);
                button2.addActionListener(actionListener);

                frame.add(button1, BorderLayout.NORTH);
                frame.add(button2, BorderLayout.SOUTH);
                frame.setSize(300, 100);
                frame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

private ActionListener actionListenerList = null;
public void addActionListener(ActionListener actionListener) {
  actionListenerList = AWTEventMulticaster.add(
    actionListenerList, actionListener);
}
public void removeActionListener(ActionListener actionListener) {
  actionListenerList = AWTEventMulticaster.remove(
    actionListenerList, actionListener);
}

/**
 *
 */
package swingstudy.ch02;

import java.awt.AWTEventMulticaster;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

import javax.swing.JComponent;

/**
 * @author lenovo
 *
 */
public class KeyTextComponent extends JComponent{

    private ActionListener actionListenerList = null;

    public KeyTextComponent() {
        setBackground(Color.CYAN);
        KeyListener internalKeyListener = new KeyAdapter() {
            public void keyPressed(KeyEvent event) {
                if(actionListenerList != null) {
                    int keyCode = event.getKeyCode();
                    String keyText = event.getKeyText(keyCode);
                    ActionEvent actionEvent = new ActionEvent(this, ActionEvent.ACTION_PERFORMED, keyText);
                    actionListenerList.actionPerformed(actionEvent);
                }
            }
        };

        MouseListener internalMouseListener = new MouseAdapter() {
            public void mousePressed(MouseEvent event) {
                requestFocusInWindow();
            }
        };

        addKeyListener(internalKeyListener);
        addMouseListener(internalMouseListener);
    }

    public void addActionListener(ActionListener actionListener) {
        actionListenerList = AWTEventMulticaster.add(actionListenerList, actionListener);
    }

    public void removeActionListener(ActionListener actionListener) {
        actionListenerList = AWTEventMulticaster.remove(actionListenerList, actionListener);
    }

    public boolean isFocusable() {
        return true;
    }
}

/**
 *
 */
package swingstudy.ch02;

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JFrame;
import javax.swing.JTextField;

/**
 * @author lenovo
 *
 */
public class KeyTextTester {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Key Text Sample");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                KeyTextComponent keyTextComponent = new KeyTextComponent();
                final JTextField textField = new JTextField();

                ActionListener actionListener =  new ActionListener() {
                    public void actionPerformed(ActionEvent event) {
                        String keyText = event.getActionCommand();
                        textField.setText(keyText);
                    }
                };

                keyTextComponent.addActionListener(actionListener);

                frame.add(keyTextComponent, BorderLayout.CENTER);
                frame.add(textField, BorderLayout.SOUTH);
                frame.setSize(300, 200);
                frame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

EventListenerList actionListenerList = new EventListenerList();
public void addActionListener(ActionListener actionListener) {
  actionListenerList.add(ActionListener.class, actionListener);
}
public void removeActionListener(ActionListener actionListener) {
  actionListenerList.remove(ActionListener.class, actionListener);
}

protected void fireActionPerformed(ActionEvent actionEvent) {
  EventListener listenerList[] =
    actionListenerList.getListeners(ActionListener.class);
  for (int i=0, n=listenerList.length; i<n; i++) {
    ((ActionListener)listenerList[i]).actionPerformed(actionEvent);
  }
}

/**
 *
 */
package swingstudy.ch02;

import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.EventListener;

import javax.swing.JComponent;
import javax.swing.event.EventListenerList;

/**
 * @author lenovo
 *
 */
public class KeyTextComponent2 extends JComponent{

    private EventListenerList actionListenerList = new EventListenerList();

    public KeyTextComponent2() {
        setBackground(Color.CYAN);

        KeyListener internalKeyListener = new KeyAdapter() {
            public void keyPressed(KeyEvent event) {
                if(actionListenerList != null) {
                    int keyCode = event.getKeyCode();
                    String keyText = event.getKeyText(keyCode);
                    ActionEvent actionEvent = new ActionEvent(this, ActionEvent.ACTION_PERFORMED, keyText);
                    fireActionPerformed(actionEvent);
                }
            }
        };

        MouseListener internalMouseListener = new MouseAdapter() {
            public void mousePressed(MouseEvent event) {
                requestFocusInWindow();
            }
        };

        addKeyListener(internalKeyListener);
        addMouseListener(internalMouseListener);
    }

    public void addActionListener(ActionListener actionListener) {
        actionListenerList.add(ActionListener.class, actionListener);
    }

    public void removeActionListener(ActionListener actionListener) {
        actionListenerList.remove(ActionListener.class, actionListener);
    }

    public void fireActionPerformed(ActionEvent event) {
        EventListener[] listenerList = actionListenerList.getListeners(ActionListener.class);
        for(int i=0, n=listenerList.length; i<n; i++) {
            ((ActionListener)listenerList[i]).actionPerformed(event);
        }
    }

    public boolean isFocusable() {
        return true;
    }
}

/**
 *
 */
package swingstudy.ch02;

import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.Timer;

/**
 * @author lenovo
 *
 */
public class TimerSample {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                ActionListener actionListener = new ActionListener() {
                    public void actionPerformed(ActionEvent event) {
                        System.out.println("Hello world timer");
                    }
                };

                Timer timer =  new Timer(500, actionListener);
                timer.start();
            }
        };

        EventQueue.invokeLater(runner);
    }

}

public interface Action implements ActionListener {
  // Constants
  public final static String ACCELERATOR_KEY;
  public final static String ACTION_COMMAND_KEY;
  public final static String DEFAULT;
  public final static String LONG_DESCRIPTION;
  public final static String MNEMONIC_KEY;
  public final static String NAME;
  public final static String SHORT_DESCRIPTION;
  public final static String SMALL_ICON;  // Listeners
  public void addPropertyChangeListener(PropertyChangeListener listener);
  public void removePropertyChangeListener(PropertyChangeListener listener);
  // Properties
  public boolean isEnabled();
  public void setEnabled(boolean newValue);
  // Other methods
  public Object getValue(String key);
  public void putValue(String key, Object value);
}

import java.awt.event.*;
import javax.swing.*;
public class PrintHelloAction extends AbstractAction {
  private static final Icon printIcon = new ImageIcon("Print.gif");
  PrintHelloAction() {
    super("Print", printIcon);
    putValue(Action.SHORT_DESCRIPTION, "Hello, World");
  }
  public void actionPerformed(ActionEvent actionEvent) {
    System.out.println("Hello, World");
  }
}

Action printAction = new PrintHelloAction();
menu.add(new JMenuItem(printAction));
toolbar.add(new JButton(printAction));

/**
 *
 */
package swingstudy.ch02;

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.Action;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JToolBar;

/**
 * @author lenovo
 *
 */
public class ActionTester {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Action Sample");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                final Action printAction = new PrintHelloAction();

                JMenuBar menuBar = new JMenuBar();
                JMenu menu = new JMenu("File");
                menuBar.add(menu);
                menu.add(new JMenuItem(printAction));

                JToolBar toolBar = new JToolBar();
                toolBar.add(new JButton(printAction));

                JButton enableButton = new JButton("Enable");
                ActionListener enableActionListener = new ActionListener() {
                    public void actionPerformed(ActionEvent event) {
                        printAction.setEnabled(true);
                    }
                };
                enableButton.addActionListener(enableActionListener);

                JButton disableButton = new JButton("Disable");
                ActionListener disableActionListener = new ActionListener() {
                    public void actionPerformed(ActionEvent event) {
                        printAction.setEnabled(false);
                    }
                };
                disableButton.addActionListener(disableActionListener);

                JButton relabelButton = new JButton("Relabel");
                ActionListener relabelActionListener = new ActionListener() {
                    public void actionPerformed(ActionEvent event) {
                        printAction.putValue(Action.NAME, "Hello, World");
                    }
                };
                relabelButton.addActionListener(relabelActionListener);

                JPanel buttonPanel = new JPanel();
                buttonPanel.add(enableButton);
                buttonPanel.add(disableButton);
                buttonPanel.add(relabelButton);

                frame.setJMenuBar(menuBar);

                frame.add(toolBar, BorderLayout.SOUTH);
                frame.add(buttonPanel, BorderLayout.NORTH);

                frame.setSize(300, 200);
                frame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

public static KeyStroke getKeyStroke(char keyChar)
public static KeyStroke getKeyStroke(String representation)
public static KeyStroke getKeyStroke(int keyCode, int modifiers)
public static KeyStroke getKeyStroke(int keyCode, int modifiers,
  boolean onKeyRelease)
public static KeyStroke getKeyStrokeForEvent(KeyEvent keyEvent)

KeyStroke space = KeyStroke.getKeyStroke('Z');

KeyStroke controlAlt7 = KeyStroke.getKeyStroke("control alt 7");

KeyStroke enter = KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0, true);
KeyStroke shiftF4 = KeyStroke.getKeyStroke(KeyEvent.VK_F4, InputEvent.SHIFT_MASK);

KeyStroke fromKeyEvent = KeyStroke.getKeyStrokeForEvent(keyEvent);

component.getInputMap().put(keystroke, string)

component.getActionMap.put(string, action)

/**
 *
 */
package swingstudy.ch02;

import java.awt.EventQueue;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.ActionMap;
import javax.swing.InputMap;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.KeyStroke;

/**
 * @author lenovo
 *
 */
public class KeyStrokeSample {

    private static final String ACTION_KEY = "theAction";

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("KeyStroke Sample");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                JButton buttonA = new JButton("<html><center>FOCUSED<br>control alt 7");
                JButton buttonB = new JButton("<html><center>FOCUS/RELEASE<br>VK_ENTER");
                JButton buttonC = new JButton("<html><center>ANCESTOR<br>VK_F4+SHIFT_MASK");
                JButton buttonD = new JButton("<html><center>WINDOW<br>' '");

                Action actionListener = new AbstractAction() {
                    public void actionPerformed(ActionEvent event) {
                        JButton source = (JButton)event.getSource();
                        System.out.println("Activated: "+source.getText());
                    }
                };

                KeyStroke controlAlt7 = KeyStroke.getKeyStroke("control alt 7");
                InputMap inputMap = buttonA.getInputMap();
                inputMap.put(controlAlt7, ACTION_KEY);
                ActionMap actionMap = buttonA.getActionMap();
                actionMap.put(ACTION_KEY, actionListener);

                KeyStroke enter = KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0, true);
                inputMap = buttonB.getInputMap();
                inputMap.put(enter, ACTION_KEY);
                buttonB.setActionMap(actionMap);

                KeyStroke shiftF4 = KeyStroke.getKeyStroke(KeyEvent.VK_F4, InputEvent.SHIFT_MASK);
                inputMap = buttonC.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
                inputMap.put(shiftF4, ACTION_KEY);
                buttonC.setActionMap(actionMap);

                KeyStroke space = KeyStroke.getKeyStroke(' ');
                inputMap = buttonD.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
                inputMap.put(space, ACTION_KEY);
                buttonD.setActionMap(actionMap);

                frame.setLayout(new GridLayout(2,2));
                frame.add(buttonA);
                frame.add(buttonB);
                frame.add(buttonC);
                frame.add(buttonD);

                frame.setSize(400, 200);
                frame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

import java.awt.*;
import java.awt.event.*;
public class MouseEnterFocusMover extends MouseAdapter {
  public void mouseEntered(MouseEvent mouseEvent) {
    Component component = mouseEvent.getComponent();
    if (!component.hasFocus()) {
      component.requestFocusInWindow();
    }
  }
}

package swingstudy.ch02;

import java.awt.KeyboardFocusManager;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class ActionFocusMover implements ActionListener {

    @Override
    public void actionPerformed(ActionEvent event) {
        // TODO Auto-generated method stub
        KeyboardFocusManager manager = KeyboardFocusManager.getCurrentKeyboardFocusManager();
        manager.focusNextComponent();
    }

}

package swingstudy.ch02;

import java.awt.EventQueue;
import java.awt.GridLayout;
import java.awt.event.ActionListener;
import java.awt.event.MouseListener;

import javax.swing.JButton;
import javax.swing.JFrame;

public class FocusSample {

    public static void main(String[] args) {
        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Focus Sample");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                ActionListener actionListener = new ActionFocusMover();
                MouseListener mouseListener = new MouseEnterFocusMover();

                frame.setLayout(new GridLayout(3,3));

                for(int i=1; i<10; i++) {
                    JButton button = new JButton(Integer.toString(i));
                    button.addActionListener(actionListener);
                    button.addMouseListener(mouseListener);
                    if((i%2)==0) {
                        button.setFocusable(false);
                    }
                    frame.add(button);
                }

                frame.setSize(300, 200);
                frame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }
}

package swingstudy.ch02;

import java.awt.EventQueue;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.GridLayout;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;


public class FocusCycleSample {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Focus Cycle Sample");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                frame.setLayout(new GridBagLayout());
                GridBagConstraints constraints = new GridBagConstraints();
                constraints.weightx = 1.0;
                constraints.weighty = 1.0;
                constraints.gridwidth = 1;
                constraints.gridheight = 1;
                constraints.fill = GridBagConstraints.BOTH;

                // Row One
                constraints.gridy = 0;
                for(int i=0; i<3; i++) {
                    JButton button = new JButton(""+i);
                    constraints.gridx = i;
                    frame.add(button, constraints);
                }

                // Row Two
                JPanel panel = new JPanel();
                panel.setFocusCycleRoot(true);
                panel.setFocusTraversalPolicyProvider(true);
                panel.setLayout(new GridLayout(1,3));
                for(int i=0; i<3; i++) {
                    JButton button =  new JButton(""+(i+3));
                    panel.add(button);
                }
                constraints.gridx = 0;
                constraints.gridy = 1;
                constraints.gridwidth = 3;
                frame.add(panel, constraints);

                // Row Three
                constraints.gridy = 2;
                constraints.gridwidth = 1;
                for(int i=0; i<3; i++) {
                    JButton button = new JButton(""+(i+6));
                    constraints.gridx = i;
                    frame.add(button, constraints);
                }

                frame.setSize(300, 200);
                frame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

getComponentAfter(Container aContainer, Component aComponent)
getComponentBefore(Container aContainer, Component aComponent)
getDefaultComponent(Container aContainer)
getFirstComponent(Container aContainer)
getInitialComponent(Window window)
getLastComponent(Container aContainer)

package swingstudy.ch02;

import java.awt.Component;
import java.awt.Container;
import java.awt.EventQueue;
import java.awt.FocusTraversalPolicy;
import java.awt.GridLayout;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.SortingFocusTraversalPolicy;

public class NextComponentSample {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Reverse Sample");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                frame.setLayout(new GridLayout(3,3));

                for(int i=9; i>0; i--) {
                    JButton button = new JButton(Integer.toString(i));
                    frame.add(button, 0);
                }

                final Container contentPane = frame.getContentPane();
                Comparator<Component> comp = new Comparator<Component>() {
                    public int compare(Component c1, Component c2) {
                        Component comps[] = contentPane.getComponents();
                        List list = Arrays.asList(comps);
                        int first = list.indexOf(c1);
                        int second = list.indexOf(c2);

                        return second-first;
                    }
                };

                FocusTraversalPolicy policy = new SortingFocusTraversalPolicy(comp);
                frame.setFocusTraversalPolicy(policy);

                frame.setSize(300, 200);
                frame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

Set<AWTKeyStroke> set = component.getFocusTraversalKeys(
  KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS);
KeyStroke stroke = KeyStroket.getKeyStroke("F3");
set.add(stroke);
component.setFocusTraversalKeys(KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, set);

package swingstudy.ch02;

import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.InputVerifier;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JTextField;

public class VerifierSample {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Verifier Sample");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                JTextField textField1 = new JTextField();
                JTextField textField2 = new JTextField();
                JTextField textField3 = new JTextField();

                InputVerifier verifier = new InputVerifier() {
                    public boolean verify(JComponent comp) {
                        boolean returnValue;
                        JTextField textField = (JTextField)comp;
                        try {
                            Integer.parseInt(textField.getText());
                            returnValue = true;
                        }
                        catch (NumberFormatException e) {
                            returnValue = false;
                        }
                        return returnValue;
                    }
                };

                textField1.setInputVerifier(verifier);
                textField3.setInputVerifier(verifier);

                frame.add(textField1, BorderLayout.NORTH);
                frame.add(textField2, BorderLayout.CENTER);
                frame.add(textField3, BorderLayout.SOUTH);

                frame.setSize(300, 100);
                frame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

public class MyComponent extends JPanel {
  protected void paintComponent(Graphics g) {
    super.paintComponent(g);
    // Customize after calling super.paintComponent(g)
  }
  ...
}

Component comp = ...
RepaintManager manager = RepaintManager.currentManager(null);
Image htmlImage = manager.getOffscreenBuffer(comp, comp.getWidth(),
  comp.getHeight());
// or
Image volatileImage = manager.getVolatileOffscreenBuffer(comp, comp.getWidth(),
  comp.getHeight());

public synchronized void addDirtyRegion(JComponent component, int x, int y,
  int width, int height)
public Rectangle getDirtyRegion(JComponent component)
public void markCompletelyClean(JComponent component)
public void markCompletelyDirty(JComponent component)

UIManager.put("Button.background", Color.BLACK);
UIManager.put("Button.foreground", Color.RED);

public static boolean getBoolean(Object key)
public static Border getBorder(Object key)
public static Color getColor(Object key)
public static Dimension getDimension(Object key)
public static Font getFont(Object key)
public static Icon getIcon(Object key)
public static Insets getInsets(Object key)
public static int getInt(Object key)
public static String getString(Object key)
public static ComponentUI getUI(JComponent target)

public final void putClientProperty(Object key, Object value)
public final Object getClientProperty(Object key)

tree.putClientProperty("JTree.lineStyle", "None")

public interface PropertyChangeListener extends EventListener {
  public void propertyChange(PropertyChangeEvent propertyChangeEvent);
}

package swingstudy.ch04;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;

import javax.swing.Action;
import javax.swing.Icon;
import javax.swing.JButton;

public class ActionChangedListener implements PropertyChangeListener {

    private JButton button;

    public ActionChangedListener(JButton button) {
        this.button = button;
    }

    @Override
    public void propertyChange(PropertyChangeEvent e) {
        // TODO Auto-generated method stub

        String propertyName = e.getPropertyName();
        if(e.getPropertyName().equals(Action.NAME)) {
            String text = (String)e.getNewValue();
            button.setText(text);
            button.repaint();
        }
        else if(propertyName.equals("enabled")) {
            Boolean enabledState = (Boolean)e.getNewValue();
            button.setEnabled(enabledState.booleanValue());
            button.repaint();
        }
        else if(propertyName.equals(Action.SMALL_ICON)) {
            Icon icon = (Icon)e.getNewValue();
            button.setIcon(icon);
            button.invalidate();
            button.repaint();
        }
    }

}

public interface VetoableChangeListener extends EventListener {
  public void vetoableChange(PropertyChangeEvent propertyChangeEvent)
    throws PropertyVetoException;
}

public interface  AncestorListener extends EventListener {
  public void ancestorAdded(AncestorEvent ancestorEvent);
  public void ancestorMoved(AncestorEvent ancestorEvent);
  public void ancestorRemoved(AncestorEvent ancestorEvent);
}

package swingstudy.ch04;

import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.event.AncestorEvent;
import javax.swing.event.AncestorListener;

public class AncestorSample {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Ancestor Sample");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                AncestorListener ancestorListener = new AncestorListener() {
                    public void ancestorAdded(AncestorEvent event) {
                        System.out.println("Added");
                    }
                    public void ancestorMoved(AncestorEvent event) {
                        System.out.println("Moved");
                    }
                    public void ancestorRemoved(AncestorEvent event) {
                        System.out.println("Removed");
                    }
                };

                frame.getRootPane().addAncestorListener(ancestorListener);
                frame.setSize(300, 200);
                frame.setVisible(true);
                frame.getRootPane().setVisible(false);
                frame.getRootPane().setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

component.setToolTipText("<html>Tooltip<br>Message");

JButton b = new JButton("Hello, World") {
  public JToolTip createToolTip() {
    JToolTip tip = super.createToolTip();
    tip.setBackground(Color.YELLOW);
    tip.setForeground(Color.RED);
    return tip;
  }
};

JButton button = new JButton("Hello, World") {
  public JToolTip createToolTip() {
    JToolTip tip = super.createToolTip();
    tip.setBackground(Color.YELLOW);
    tip.setForeground(Color.RED);
    return tip;
  }
  public boolean contains(int x, int y) {
    if (x < 50) {
      setToolTipText("Got Green Eggs?");
    }  else {
      setToolTipText("Got Ham?");
    }
    return super.contains(x, y);
  }
};

public void registerComponent(JComponent component)
public void unregisterComponent(JComponent component)

JTree tree = new JTree(...);
ToolTipManager.sharedInstance().registerComponent(tree);
TreeCellRenderer renderer = new ATreeCellRenderer(...);
tree.setCellRenderer(renderer);
...
public class ATreeCellRenderer implements TreeCellRenderer {
...
  public Component getTreeCellRendererComponent(JTree tree, Object value,
    boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
  ...
    renderer.setToolTipText("Some Tip");
    return renderer;
  }
}

public JLabel()
JLabel label = new JLabel();

public JLabel(Icon image)
Icon icon = new ImageIcon("dog.jpg");
JLabel label = new JLabel(icon);

public JLabel(Icon image, int horizontalAlignment)
Icon icon = new ImageIcon("dog.jpg");
JLabel label = new JLabel(icon, JLabel.RIGHT);

public JLabel(String text)
JLabel label = new JLabel("Dog");

public JLabel(String text, int horizontalAlignment)
JLabel label = new JLabel("Dog", JLabel.RIGHT);

public JLabel(String text, Icon icon, int horizontalAlignment)
Icon icon = new ImageIcon("dog.jpg");
JLabel label = new JLabel("Dog", icon, JLabel.RIGHT);

JLabel label = new JLabel("Username");
JTextField textField = new JTextField();
label.setDisplayedMnemonic(KeyEvent.VK_U);
label.setLabelFor(textField);

package swingstudy.ch04;

import java.awt.Color;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.Polygon;

import javax.swing.Icon;

public class DiamondIcon implements Icon {

    private Color color;
    private boolean selected;
    private int width;
    private int height;
    private Polygon polygon;
    private static final int DEFAULT_WIDTH = 10;
    private static final int DEFAULT_HEIGHT = 10;

    public DiamondIcon(Color color) {
        this(color, true, DEFAULT_WIDTH, DEFAULT_HEIGHT);
    }

    public DiamondIcon(Color color, boolean selected) {
        this(color, selected, DEFAULT_WIDTH, DEFAULT_HEIGHT);
    }

    public DiamondIcon(Color color, boolean selected, int width, int height) {
        this.color = color;
        this.selected = selected;
        this.width = width;
        this.height = height;
        initPolygon();
    }

    private void initPolygon() {
        polygon = new Polygon();
        int halfWidth = width/2;
        int halfHeight = height/2;
        polygon.addPoint(0, halfHeight);
        polygon.addPoint(halfWidth, 0);
        polygon.addPoint(width, halfHeight);
        polygon.addPoint(halfWidth, height);
    }
    @Override
    public int getIconHeight() {
        // TODO Auto-generated method stub
        return height;
    }

    @Override
    public int getIconWidth() {
        // TODO Auto-generated method stub
        return width;
    }

    @Override
    public void paintIcon(Component c, Graphics g, int x, int y) {
        // TODO Auto-generated method stub
        g.setColor(color);
        g.translate(x, y);
        if(selected) {
            g.fillPolygon(polygon);
        }
        else {
            g.drawPolygon(polygon);
        }
        g.translate(-x, -y);
    }

}

public ImageIcon()
Icon icon = new ImageIcon();
icon.setImage(anImage);

public ImageIcon(Image image)
Icon icon = new ImageIcon(anImage);

public ImageIcon(String filename)
Icon icon = new ImageIcon(filename);

public ImageIcon(URL location)
Icon icon = new ImageIcon(url);

public ImageIcon(byte imageData[])
Icon icon = new ImageIcon(aByteArray);

public ImageIcon(Image image, String description)
Icon icon = new ImageIcon(anImage, "Duke");

public ImageIcon(String filename, String description)
Icon icon = new ImageIcon(filename, filename);public ImageIcon(URL location, String description)
Icon icon = new ImageIcon(url, location.getFile());

public ImageIcon(URL location, String description)
Icon icon = new ImageIcon(url, location.getFile());

public ImageIcon(byte imageData[], String description)
Icon icon = new ImageIcon(aByteArray, "Duke");

Icon icon = new ImageIcon("Warn.gif");
JLabel label3 = new JLabel("Warning", icon, JLabel.CENTER)

ImageIcon imageIcon = new ImageIcon(...);
Image image = imageIcon.getImage();

package swingstudy.ch04;

import java.awt.Image;
import java.awt.Toolkit;
import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

public class ImageLoader {

    private ImageLoader() {

    }

    public static Image getImage(Class relativeClass, String filename) {
        Image returnValue = null;
        InputStream is = relativeClass.getResourceAsStream(filename);
        if(is != null) {
            BufferedInputStream bis = new BufferedInputStream(is);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            try {
                int ch;
                while ((ch = bis.read()) != -1) {
                    baos.write(ch);
                }
                returnValue = Toolkit.getDefaultToolkit().createImage(baos.toByteArray());
            }
            catch(IOException e) {
                System.err.println("Error loading: "+filename);
            }
        }
        return returnValue;
    }
}

Image warnImage = ImageLoader.getImage(LabelJarSample.class, "Warn.gif");
Icon warnIcon = new ImageIcon(warnImage);
JLabel label2 = new JLabel(warnIcon);

Image normalImage = ...
Image grayImage = GrayFilter.createDisabledImage(normalImage)

Icon warningIcon = new ImageIcon(grayImage);
JLabel warningLabel = new JLabel(warningIcon);

public interface ButtonModel extends ItemSelectable {
  // Properties
  public String getActionCommand();
  public void setActionCommand(String newValue);
  public boolean isArmed();
  public void setArmed(boolean newValue);
  public boolean isEnabled();
  public void setEnabled(boolean newValue);
  public void setGroup(ButtonGroup newValue);
  public int getMnemonic();
  public void setMnemonic(int newValue);
  public boolean isPressed();
  public void setPressed(boolean newValue);
  public boolean isRollover();
  public void setRollover(boolean newValue);
  public boolean isSelected();
  public void setSelected(boolean newValue);
  // Listeners
  public void addActionListener(ActionListener listener);
  public void removeActionListener(ActionListener listener);
  public void addChangeListener(ChangeListener listener);
  public void removeChangeListener(ChangeListener listener);
  public void addItemListener(ItemListener listener);
  public void removeItemListener(ItemListener listener);
}

AbstractButton button1 = new JButton("Warning");
button1.setMnemonic(KeyEvent.VK_W);
content.add(button1);

import javax.swing.*;
import java.beans.*;
public class AbstractButtonPropertyChangeListener
    implements PropertyChangeListener {
  public void propertyChange(PropertyChangeEvent e) {
    String propertyName = e.getPropertyName();
    if (e.getPropertyName().equals(AbstractButton.TEXT_CHANGED_PROPERTY)) {
      String newText = (String) e.getNewValue();
      String oldText = (String) e.getOldValue();
      System.out.println(oldText + " changed to " + newText);
    }  else if (e.getPropertyName().equals(AbstractButton.ICON_CHANGED_PROPERTY)) {
      Icon icon = (Icon) e.getNewValue();
      if (icon instanceof ImageIcon) {
        System.out.println("New icon is an image");
      }
    }
  }
}

public JButton()
JButton button = new JButton();

public JButton(Icon image)
Icon icon = new ImageIcon("dog.jpg");
JButton button = new JButton(icon);

public JButton(String text)
JButton button = new JButton("Dog");

public JButton(String text, Icon icon)
Icon icon = new ImageIcon("dog.jpg");
JButton button = new JButton("Dog", icon);

public JButton(Action action)
Action action = ...;
JButton button = new JButton(action);

package swingstudy.ch04;

import java.awt.EventQueue;
import java.awt.GridLayout;
import java.awt.event.KeyEvent;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JRootPane;

public class DefaultButton {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("DefaultButton");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                frame.setLayout(new GridLayout(2,2,10,10));

                JButton button1 = new JButton("Text Button");
                button1.setMnemonic(KeyEvent.VK_B);
                frame.add(button1);

                JButton button2 = new JButton("WarnIcon");
                frame.add(button2);

                JButton button3 = new JButton("Warn");
                frame.add(button3);

                String htmlButton = "<html><sup>HTML</sup><sub><em>Button</em></sub><br>"+
                    "<font color\"#FF0080\"><u>Multi-line</u></font>";
                JButton button4 = new JButton(htmlButton);
                frame.add(button4);

                JRootPane rootPane = frame.getRootPane();
                rootPane.setDefaultButton(button2);

                frame.setSize(300, 200);
                frame.setVisible(true);
            }
        };
        EventQueue.invokeLater(runner);
    }

}

package swingstudy.ch04;

import java.awt.EventQueue;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JRootPane;

public class ActionButtonSample {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("DefaultButton");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                frame.setLayout(new GridLayout(2,2,10,10));

                ActionListener actionListener = new ActionListener() {
                    public void actionPerformed(ActionEvent event) {
                        String command = event.getActionCommand();
                        System.out.println("Selected: "+command);
                    }
                };

                JButton button1 = new JButton("Text Button");
                button1.setMnemonic(KeyEvent.VK_B);
                button1.setActionCommand("First");
                button1.addActionListener(actionListener);
                frame.add(button1);

                JButton button2 = new JButton("WarnIcon");
                button2.setActionCommand("Second");
                button2.addActionListener(actionListener);
                frame.add(button2);

                JButton button3 = new JButton("Warn");
                button3.setActionCommand("Third");
                button3.addActionListener(actionListener);
                frame.add(button3);

                String htmlButton = "<html><sup>HTML</sup><sub><em>Button</em></sub><br>"+
                    "<font color\"#FF0080\"><u>Multi-line</u></font>";
                JButton button4 = new JButton(htmlButton);
                button4.setActionCommand("Fourth");
                button4.addActionListener(actionListener);
                frame.add(button4);

                JRootPane rootPane = frame.getRootPane();
                rootPane.setDefaultButton(button2);

                frame.setSize(300, 200);
                frame.setVisible(true);
            }
        };
        EventQueue.invokeLater(runner);
    }

}

public JPanel()
JPanel panel = new JPanel();

public JPanel(boolean isDoubleBuffered)
JPanel panel = new JPanel(false);

public JPanel(LayoutManager manager)
JPanel panel = new JPanel(new GridLayout(2,2));

public JPanel(LayoutManager manager, boolean isDoubleBuffered)
JPanel panel = new JPanel(new GridLayout(2,2), false);

JPanel panel = new JPanel();
JButton okButton = new JButton("OK");
panel.add(okButton);
JButton cancelButton = new JButton("Cancel");
panel.add(cancelButton);

package swingstudy.ch04;

import java.awt.Color;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.GridLayout;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class OvalPanel extends JPanel {

    Color color;

    public OvalPanel() {
        this(Color.black);
    }

    public OvalPanel(Color color) {
        this.color = color;
    }

    public void paintComponent(Graphics g) {
        int width = getWidth();
        int height = getHeight();
        g.setColor(color);
        g.drawOval(0, 0, width, height);
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Oval Sample");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                frame.setLayout(new GridLayout(2,2));

                Color colors[] = {Color.RED, Color.BLUE, Color.GREEN, Color.YELLOW };

                for (int i=0;i<4;i++) {
                    OvalPanel panel = new OvalPanel(colors[i]);
                    frame.add(panel);
                }

                frame.setSize(300, 200);
                frame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

public JToggleButton()
JToggleButton aToggleButton = new JToggleButton();

public JToggleButton(Icon icon)
JToggleButton aToggleButton = new JToggleButton(new DiamondIcon(Color.PINK))

public JToggleButton(Icon icon, boolean selected)
JToggleButton aToggleButton = new JToggleButton(new DiamondIcon(Color.PINK), true);

public JToggleButton(String text)
JToggleButton aToggleButton = new JToggleButton("Sicilian");

public JToggleButton(String text, boolean selected)
JToggleButton aToggleButton = new JToggleButton("Thin Crust", true);

public JToggleButton(String text, Icon icon)
JToggleButton aToggleButton = new JToggleButton("Thick Crust",
  new DiamondIcon(Color.PINK));

public JToggleButton(String text, Icon icon, boolean selected)
JToggleButton aToggleButton = new JToggleButton("Stuffed Crust",
  new DiamondIcon(Color.PINK), true);

public JToggleButton(Action action)
Action action = ...;
JToggleButton aToggleButton = new JToggleButton(action);

ActionListener actionListener = new ActionListener() {
  public void actionPerformed(ActionEvent actionEvent) {
    AbstractButton abstractButton = (AbstractButton)actionEvent.getSource();
    boolean selected = abstractButton.getModel().isSelected();
    System.out.println("Action - selected=" + selected + "\ n");
  }
};

ItemListener itemListener = new ItemListener() {
  public void itemStateChanged(ItemEvent itemEvent) {
    int state = itemEvent.getStateChange();
    if (state == ItemEvent.SELECTED) {
      System.out.println("Selected");
    }  else {
      System.out.println("Deselected");
    }
  }
};

ChangeListener changeListener = new ChangeListener() {
  public void stateChanged(ChangeEvent changeEvent) {
    AbstractButton abstractButton = (AbstractButton)changeEvent.getSource();
    ButtonModel buttonModel = abstractButton.getModel();
    boolean armed = buttonModel.isArmed();
    boolean pressed = buttonModel.isPressed();
    boolean selected = buttonModel.isSelected();
    System.out.println("Changed: " + armed + "/" + pressed + "/" + selected);
  }
};

package swingstudy.ch04;

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;

import javax.swing.AbstractButton;
import javax.swing.ButtonModel;
import javax.swing.JFrame;
import javax.swing.JToggleButton;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

public class SelectingToggle {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Selecting Toggle");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                JToggleButton toggleButton = new JToggleButton("Toggle Button");

                ActionListener actionListener = new ActionListener() {
                    public void actionPerformed(ActionEvent event) {
                        AbstractButton abstractButton = (AbstractButton)event.getSource();
                        boolean selected = abstractButton.getModel().isSelected();
                        System.out.println("Action - selected="+selected+"\n");
                    }
                };

                ChangeListener changeListener = new ChangeListener() {
                    public void stateChanged(ChangeEvent event) {
                        AbstractButton abstractButton = (AbstractButton)event.getSource();
                        ButtonModel buttonModel = abstractButton.getModel();
                        boolean armed = buttonModel.isArmed();
                        boolean pressed = buttonModel.isPressed();
                        boolean selected = buttonModel.isSelected();
                        System.out.println("Changed: "+armed +"/"+pressed+"/"+selected);
                    }
                };

                ItemListener itemListener = new ItemListener() {
                    public void itemStateChanged(ItemEvent event) {
                        int state = event.getStateChange();
                        if(state == ItemEvent.SELECTED) {
                            System.out.println("Selected");
                        }
                        else {
                            System.out.println("Deselected");
                        }
                    }
                };

                toggleButton.addActionListener(actionListener);
                toggleButton.addChangeListener(changeListener);
                toggleButton.addItemListener(itemListener);

                frame.add(toggleButton, BorderLayout.NORTH);
                frame.setSize(300, 125);
                frame.setVisible(true);
            }
        };
        EventQueue.invokeLater(runner);
    }

}

public JCheckBox()
JCheckBox aCheckBox = new JCheckBox();

public JCheckBox(Icon icon)
JCheckBox aCheckBox = new JCheckBox(new DiamondIcon(Color.RED, false));
aCheckBox.setSelectedIcon(new DiamondIcon(Color.PINK, true));

public JCheckBox(Icon icon, boolean selected)
JCheckBox aCheckBox = new JCheckBox(new DiamondIcon(Color.RED, false), true);
aCheckBox.setSelectedIcon(new DiamondIcon(Color.PINK, true));

public JCheckBox(String text)
JCheckBox aCheckBox = new JCheckBox("Spinach");

public JCheckBox(String text, boolean selected)
JCheckBox aCheckBox = new JCheckBox("Onions", true);

public JCheckBox(String text, Icon icon)
JCheckBox aCheckBox = new JCheckBox("Garlic", new DiamondIcon(Color.RED, false));
aCheckBox.setSelectedIcon(new DiamondIcon(Color.PINK, true));

public JCheckBox(String text, Icon icon, boolean selected)
JCheckBox aCheckBox = new JCheckBox("Anchovies", new DiamondIcon(Color.RED,
  false), true);
aCheckBox.setSelectedIcon(new DiamondIcon(Color.PINK, true));

public JCheckBox(Action action)
Action action = ...;
JCheckBox aCheckBox = new JCheckBox(action);

package net.ariel.ch05;

import java.awt.Color;
import java.awt.Component;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.GridLayout;
import java.awt.Image;

import javax.swing.AbstractButton;
import javax.swing.ButtonModel;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JCheckBox;
import javax.swing.JFrame;

import net.ariel.ch04.DiamondIcon;

public class IconCheckBoxSample {

    private static class CheckBoxIcon implements Icon {
        private ImageIcon checkedIcon = new ImageIcon("plus.png");
        private ImageIcon uncheckedIcon = new ImageIcon("minus.png");

        public void paintIcon(Component component, Graphics g, int x, int y) {
            AbstractButton abstractButton = (AbstractButton)component;
            ButtonModel buttonModel = abstractButton.getModel();
            g.translate(x, y);
            ImageIcon imageIcon = buttonModel.isSelected() ? checkedIcon : uncheckedIcon;
            Image image = imageIcon.getImage();
            g.drawImage(image, 0, 0, component);
            g.translate(-x, -y);
        }

        public int getIconWidth() {
            return 20;
        }

        public int getIconHeight() {
            return 20;
        }
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame =  new JFrame("Iconizing CheckBox");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                Icon checked = new DiamondIcon(Color.BLACK, true);
                Icon unchecked = new DiamondIcon(Color.BLACK, false);

                JCheckBox aCheckBox1 = new JCheckBox("Pizza", unchecked);
                JCheckBox aCheckBox2 = new JCheckBox("Calzone");
                aCheckBox2.setIcon(unchecked);
                aCheckBox2.setSelectedIcon(checked);

                Icon checkBoxIcon = new CheckBoxIcon();
                JCheckBox aCheckBox3 = new JCheckBox("Anchovies", checkBoxIcon);
                JCheckBox aCheckBox4 = new JCheckBox("Stuffed Crust", checked);

                frame.setLayout(new GridLayout(0, 1));
                frame.add(aCheckBox1);
                frame.add(aCheckBox2);
                frame.add(aCheckBox3);
                frame.add(aCheckBox4);

                frame.setSize(300, 200);
                frame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

ActionListener actionListener = new ActionListener() {
   public void actionPerformed(ActionEvent actionEvent) {
     AbstractButton abstractButton = (AbstractButton)actionEvent.getSource();
     boolean selected = abstractButton.getModel().isSelected();
     String newLabel = (selected ? SELECTED_LABEL : DESELECTED_LABEL);
     abstractButton.setText(newLabel);
   }
};

ItemListener itemListener = new ItemListener() {
   public void itemStateChanged(ItemEvent itemEvent) {
     AbstractButton abstractButton = (AbstractButton)itemEvent.getSource();
     Color foreground = abstractButton.getForeground();
     Color background = abstractButton.getBackground();
     int state = itemEvent.getStateChange();
     if (state == ItemEvent.SELECTED) {
       abstractButton.setForeground(background);
       abstractButton.setBackground(foreground);
     }
   }
};

package net.ariel.ch05;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.KeyEvent;

import javax.swing.AbstractButton;
import javax.swing.ButtonModel;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

public class SelectingCheckBox {

    private static String DESELECTED_LABEL = "Deselected";
    private static String SELECTED_LABEL = "Selected";
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Selecting CheckBox");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                JCheckBox checkBox = new JCheckBox(DESELECTED_LABEL);

                ActionListener actionListener = new ActionListener() {
                    public void actionPerformed(ActionEvent event) {
                        AbstractButton abstractButton = (AbstractButton)event.getSource();
                        boolean selected = abstractButton.isSelected();
                        String newLabel = (selected ? SELECTED_LABEL : DESELECTED_LABEL);
                        abstractButton.setText(newLabel);
                    }
                };

                ChangeListener changeListener = new ChangeListener() {
                    public void stateChanged(ChangeEvent event) {
                        AbstractButton abstractButton = (AbstractButton)event.getSource();
                        ButtonModel buttonModel = abstractButton.getModel();
                        boolean armed = buttonModel.isArmed();
                        boolean pressed = buttonModel.isPressed();
                        boolean selected = buttonModel.isSelected();
                        System.out.println("Changed: "+armed+"/"+pressed+"/"+selected);
                    }
                };

                ItemListener itemListener = new ItemListener() {
                    public void itemStateChanged(ItemEvent event) {
                        AbstractButton abstractButton = (AbstractButton)event.getSource();
                        Color foreground = abstractButton.getForeground();
                        Color background = abstractButton.getBackground();
                        int state = event.getStateChange();
                        if(state == ItemEvent.SELECTED) {
                            abstractButton.setForeground(background);
                            abstractButton.setBackground(foreground);
                        }
                    }
                };

                checkBox.addActionListener(actionListener);
                checkBox.addChangeListener(changeListener);
                checkBox.addItemListener(itemListener);

                checkBox.setMnemonic(KeyEvent.VK_S);

                frame.add(checkBox, BorderLayout.NORTH);

                frame.setSize(300, 100);
                frame.setVisible(true);
            }
        };
        EventQueue.invokeLater(runner);
    }

}

public JRadioButton()
JRadioButton aRadioButton = new JRadioButton();

public JRadioButton(Icon icon)
JRadioButton aRadioButton = new JRadioButton(new DiamondIcon(Color.CYAN, false));
aRadioButton.setSelectedIcon(new DiamondIcon(Color.BLUE, true));

public JRadioButton(Icon icon, boolean selected)
JRadioButton aRadioButton = new JRadioButton(new DiamondIcon(Color.CYAN, false),
  true);
aRadioButton.setSelectedIcon(new DiamondIcon(Color.BLUE, true));

public JRadioButton(String text)
JRadioButton aRadioButton = new JRadioButton("4 slices");

public JRadioButton(String text, boolean selected)
JRadioButton aRadioButton = new JRadioButton("8 slices", true);

public JRadioButton(String text, Icon icon)
JRadioButton aRadioButton = new JRadioButton("12 slices",
  new DiamondIcon(Color.CYAN, false));
aRadioButton.setSelectedIcon(new DiamondIcon(Color.BLUE, true));

public JRadioButton(String text, Icon icon, boolean selected)
JRadioButton aRadioButton = new JRadioButton("16 slices",
  new DiamondIcon(Color.CYAN, false), true);
aRadioButton.setSelectedIcon(new DiamondIcon(Color.BLUE, true));

public JRadioButton(Action action)
Action action = ...;
JRadioButton aRadioButton = new JRadioButton(action);

JPanel aPanel = new JPanel(new GridLayout(0,1));

Border border = BorderFactory.createTitledBorder("Slice Count");
aPanel.setBorder(border)

ButtonGroup aGroup = new ButtonGroup();

JRadioButton aRadioButton = new JRadioButton();
aPanel.add(aRadioButton);
aGroup.add(aRadioButton);

package net.ariel.ch05;

import java.awt.Container;
import java.awt.GridLayout;

import javax.swing.BorderFactory;
import javax.swing.ButtonGroup;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.border.Border;

public class RadioButtonUtils {

    private RadioButtonUtils() {

    }

    public static Container createRadioButtonGrouping(String elements[], String title) {
        JPanel panel = new JPanel(new GridLayout(0,1));

        if(title != null) {
            Border border = BorderFactory.createTitledBorder(title);
            panel.setBorder(border);
        }

        ButtonGroup group = new ButtonGroup();
        JRadioButton aRadioButton;

        for(int i=0, n=elements.length; i<n; i++) {
            aRadioButton = new JRadioButton(elements[i]);
            panel.add(aRadioButton);
            group.add(aRadioButton);
        }

        return panel;
    }
}

/**
 *
 */
package net.ariel.ch05;

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.EventQueue;

import javax.swing.JFrame;

/**
 * @author mylxiaoyi
 *
 */
public class GroupRadio {

    private static final String sliceOptions[] = {
        "4 slices", "8 slices", "12 slices", "16 slices"
    };
    private static final String crustOptions[] = {
        "Sicilian", "Thin Crust", "Thick Crust", "Stuffed Crust"
    };
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Grouping Example");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                Container sliceContainer = RadioButtonUtils.createRadioButtonGrouping(sliceOptions, "Slice Count");
                Container crustContainer = RadioButtonUtils.createRadioButtonGrouping(crustOptions, "Crust Type");

                frame.add(sliceContainer, BorderLayout.WEST);
                frame.add(crustContainer, BorderLayout.EAST);

                frame.setSize(300, 200);
                frame.setVisible(true);
            }
        };
        EventQueue.invokeLater(runner);
    }

}

public static Container createRadionButtonGrouping(String elements[], String title, ActionListener actionListener) {
    JPanel panel = new JPanel(new GridLayout(0, 1));

    if(title != null) {
        Border border = BorderFactory.createTitledBorder(title);
        panel.setBorder(border);
    }

    ButtonGroup group = new ButtonGroup();
    JRadioButton aRadioButton;

    for(int i=0, n=elements.length; i<n; i++) {
        aRadioButton = new JRadioButton(elements[i]);
        panel.add(aRadioButton);
        group.add(aRadioButton);
        if(actionListener != null) {
            aRadioButton.addActionListener(actionListener);
        }
    }

    return panel;
}

ActionListener sliceActionListener = new ActionListener() {
   public void actionPerformed(ActionEvent actionEvent) {
     AbstractButton aButton = (AbstractButton)actionEvent.getSource();
     System.out.println("Selected: " + aButton.getText());
   }
};
Container sliceContainer =
   RadioButtonUtils.createRadioButtonGrouping(sliceOptions, "Slice Count",
     sliceActionListener);

ActionListener crustActionListener = new ActionListener() {
   String lastSelected;
   public void actionPerformed(ActionEvent actionEvent) {
     AbstractButton aButton = (AbstractButton)actionEvent.getSource();
     String label = aButton.getText();
     String msgStart;
     if (label.equals(lastSelected)) {
       msgStart = "Reselected: ";
     } else {
       msgStart = "Selected: ";
     }
     lastSelected = label;
     System.out.println(msgStart + label);
   }
};

public static Enumeration<String> getSelectedEllements(Container container) {
    Vector<String> selections = new Vector<String>();
    Component components[] = container.getComponents();
    for(int i=0, n=components.length; i<n; i++) {
        if(components[i] instanceof AbstractButton) {
            AbstractButton button = (AbstractButton)components[i];
            if(button.isSelected()) {
                selections.addElement(button.getText());
            }
        }
    }

    return selections.elements();
}

final Container crustContainer =
     RadioButtonUtils.createRadioButtonGrouping(crustOptions, "Crust Type");
ActionListener buttonActionListener = new ActionListener() {
   public void actionPerformed(ActionEvent actionEvent) {
     Enumeration selected = RadioButtonUtils.getSelectedElements(crustContainer);
     while (selected.hasMoreElements()) {
       System.out.println ("Selected -> " + selected.nextElement());
     }
   }
};
JButton button = new JButton ("Order Pizza");
button.addActionListener(buttonActionListener);

ItemListener itemListener = new ItemListener() {
   String lastSelected;
   public void itemStateChanged(ItemEvent itemEvent) {
     AbstractButton aButton = (AbstractButton)itemEvent.getSource();
     int state = itemEvent.getStateChange();
     String label = aButton.getText();
     String msgStart;
     if (state == ItemEvent.SELECTED) {
       if (label.equals(lastSelected)) {
         msgStart = "Reselected -> ";
       } else {
         msgStart = "Selected -> ";
       }
       lastSelected = label;
     } else {
       msgStart = "Deselected -> ";
     }
     System.out.println(msgStart + label);
   }
};

/**
 *
 */
package net.ariel.ch05;

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.util.Enumeration;

import javax.swing.AbstractButton;
import javax.swing.ButtonModel;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

/**
 * @author mylxiaoyi
 *
 */
public class GroupActionRadio {

    private static final String sliceOptions[] = {
        "4 slices", "8 slices", "12 slices", "16 slices"
    };
    private static final String crustOptions[] = {
        "Sicilian", "Thin Crust", "Thick Crust", "Stuffed Crust"
    };
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Grouping Example");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                ActionListener sliceActionListener = new ActionListener() {
                    public void actionPerformed(ActionEvent event) {
                        AbstractButton aButton = (AbstractButton)event.getSource();
                        System.out.println("Selected: "+aButton.getText());
                    }
                };
                Container sliceContainer = RadioButtonUtils.createRadioButtonGrouping(sliceOptions, "Slice Count", sliceActionListener);

                ActionListener crustActionListener = new ActionListener() {
                    String lastSelected;
                    public void actionPerformed(ActionEvent event) {
                        AbstractButton aButton = (AbstractButton)event.getSource();
                        String label = aButton.getText();
                        String msgStart;
                        if(label.equals(lastSelected)) {
                            msgStart = "Reselected: ";
                        }
                        else {
                            msgStart = "Selected: ";
                        }
                        lastSelected = label;
                        System.out.println(msgStart + label);
                    }
                };

                ItemListener itemListener = new ItemListener() {
                    String lastSelected;
                    public void itemStateChanged(ItemEvent event) {
                        AbstractButton aButton = (AbstractButton)event.getSource();
                        int state = event.getStateChange();
                        String label = aButton.getText();
                        String msgStart;
                        if(state == ItemEvent.SELECTED) {
                            if(label.equals(lastSelected)) {
                                msgStart = "Reselected -> ";
                            }
                            else {
                                msgStart = "Selected -> ";
                            }
                            lastSelected = label;
                        }
                        else {
                            msgStart = "Deselected -> ";
                        }
                        System.out.println(msgStart + label);
                    }
                };

                ChangeListener changeListener = new ChangeListener() {
                    public void stateChanged(ChangeEvent event) {
                        AbstractButton aButton = (AbstractButton)event.getSource();
                        ButtonModel aModel = aButton.getModel();
                        boolean armed = aModel.isArmed();
                        boolean pressed = aModel.isPressed();
                        boolean selected = aModel.isSelected();
                        System.out.println("Changed: "+armed+"/"+pressed+"/"+selected);
                    }
                };

                final Container crustContainer = RadioButtonUtils.createRadioButtonGrouping(crustOptions, "Crust Type", crustActionListener, itemListener, changeListener);

                ActionListener buttonActionListener = new ActionListener() {
                    public void actionPerformed(ActionEvent event) {
                        Enumeration<String> selected = RadioButtonUtils.getSelectedElements(crustContainer);
                        while(selected.hasMoreElements()) {
                            System.out.println("Selected -> "+selected.nextElement());
                        }
                    }
                };

                JButton button = new JButton("Order Pizza");
                button.addActionListener(buttonActionListener);

                frame.add(sliceContainer, BorderLayout.WEST);
                frame.add(crustContainer, BorderLayout.EAST);
                frame.add(button, BorderLayout.SOUTH);
                frame.setSize(300, 200);
                frame.setVisible(true);

            }
        };
        EventQueue.invokeLater(runner);
    }

}

/**
 *
 */
package net.ariel.ch05;

import java.awt.Component;
import java.awt.Container;
import java.awt.event.ActionListener;
import java.awt.event.ItemListener;
import java.util.Enumeration;
import java.util.Vector;

import javax.swing.AbstractButton;
import javax.swing.BorderFactory;
import javax.swing.ButtonGroup;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.border.Border;
import javax.swing.event.ChangeListener;

/**
 * @author mylxiaoyi
 *
 */
public class RadioButtonUtils2 {

    private RadioButtonUtils2() {

    }

    public static Enumeration<String> getSelectedElements(Container container) {
        Vector<String> selections = new Vector<String>();
        Component components[] = container.getComponents();
        for(int i=0, n=components.length; i<n; i++) {
            if(components[i] instanceof AbstractButton) {
                AbstractButton button = (AbstractButton)components[i];
                if(button.isSelected()) {
                    selections.addElement(button.getText());
                }
            }
        }

        return selections.elements();
    }

    public static Container createRadioButtonGrouping(String elements[]) {
        return createRadioButtonGrouping(elements, null, null, null, null);
    }

    public static Container createRadioButtonGrouping(String elements[], String title) {
        return createRadioButtonGrouping(elements, title, null, null, null);
    }

    public static Container createRadioButtonGrouping(String elements[], String title, ItemListener itemListener) {
        return createRadioButtonGrouping(elements, title, null, itemListener, null);
    }

    public static Container createRadioButtonGrouping(String elements[], String title, ActionListener actionListener) {
        return createRadioButtonGrouping(elements, title, actionListener, null, null);
    }

    public static Container createRadioButtonGrouping(String elements[], String title, ActionListener actionListener, ItemListener itemListener) {
        return createRadioButtonGrouping(elements, title, actionListener, itemListener, null);
    }

    public static Container createRadioButtonGrouping(String elements[], String title, ActionListener actionListener, ItemListener itemListener, ChangeListener changeListener) {
        JPanel panel = new JPanel();

        if(title != null) {
            Border border = BorderFactory.createTitledBorder(title);
            panel.setBorder(border);
        }

        ButtonGroup group =  new ButtonGroup();
        JRadioButton aRadioButton;
        for(int i=0, n=elements.length; i<n; i++) {
            aRadioButton = new JRadioButton(elements[i]);
            panel.add(aRadioButton);
            group.add(aRadioButton);
            if(actionListener != null) {
                aRadioButton.addActionListener(actionListener);
            }
            if(itemListener != null) {
                aRadioButton.addItemListener(itemListener);
            }
            if(changeListener != null) {
                aRadioButton.addChangeListener(changeListener);
            }
        }

        return panel;
    }
}

JMenu fileMenu = new JMenu("File");
menuBar.add(fileMenu);
JMenu editMenu = new JMenu("Edit");
menuBar.add(editMenu);

menuBar.add(editMenu);
menuBar.add(fileMenu, 0);

bar.remove(edit);
bar.remove(0);

import java.awt.*;
import javax.swing.*;
public class VerticalMenuBar extends JMenuBar {
  private static final LayoutManager grid = new GridLayout(0,1);
  public VerticalMenuBar() {
    setLayout(grid);
  }
}

public interface SingleSelectionModel {
  // Listeners
  public void addChangeListener(ChangeListener listener);
  public void removeChangeListener(ChangeListener listener);
  // Properties
  public int getSelectedIndex();
  public void setSelectedIndex(int index);
  public boolean isSelected();
  // Other Methods
  public void clearSelection();
}

public JMenuItem()
JMenuItem jMenuItem = new JMenuItem();

public JMenuItem(Icon icon)
Icon atIcon = new ImageIcon("at.gif");
JMenuItem jMenuItem = new JMenuItem(atIcon);

public JMenuItem(String text)
JMenuItem jMenuItem = new JMenuItem("Cut");

public JMenuItem(String text, Icon icon)
Icon atIcon = new ImageIcon("at.gif");
JMenuItem jMenuItem = new JMenuItem("Options", atIcon);

public JMenuItem(String text, int mnemonic)
JMenuItem jMenuItem = new JMenuItem("Cut", KeyEvent.VK_T);

public JMenuItem(Action action)
Action action = ...;
JMenuItem jMenuItem = new JMenuItem(action);

KeyStroke ctrlXKeyStroke = KeyStroke.getKeyStroke("control X");
cutMenuItem.setAccelerator(ctrlXKeyStroke);

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

public interface MenuKeyListener extends EventListener {
  public void menuKeyPressed(MenuKeyEvent e);
  public void menuKeyReleased(MenuKeyEvent e);
  public void menuKeyTyped(MenuKeyEvent e);
}

public class MenuKeyEvent extends KeyEvent {
  public MenuKeyEvent(Component source, int id, long when, int modifiers,
    int keyCode, char keyChar, MenuElement path[], MenuSelectionManager mgr);
  public MenuSelectionManager getMenuSelectionManager();
  public MenuElement[] getPath();
}

public interface MenuDragMouseListener extends EventListener {
  public void menuDragMouseDragged(MenuDragMouseEvent e);
  public void menuDragMouseEntered(MenuDragMouseEvent e);
  public void menuDragMouseExited(MenuDragMouseEvent e);
  public void menuDragMouseReleased(MenuDragMouseEvent e);
}

public class MenuDragMouseEvent extends MouseEvent {
  public MenuDragMouseEvent(Component source, int id, long when, int modifiers,
    int x, int y, int clickCount, boolean popupTrigger, MenuElement path[],
    MenuSelectionManager mgr);
  public MenuSelectionManager getMenuSelectionManager();
  public MenuElement[] getPath();
}

public JMenu()
JMenu jMenu = new JMenu();
public JMenu(String label)
JMenu jMenu = new JMenu("File");
public JMenu(String label, boolean useTearOffs)
public JMenu(Action action)
Action action = ...;
JMenu jMenu = new JMenu(action);

public JMenuItem add(JMenuItem menuItem);
public JMenuItem add(String label);
public Component add(Component component);
public Component add(Component component, int index);
public JMenuItem add(Action action);
public void addSeparator();

JMenu fileMenu = new JMenu("File");
JMenuItem newMenuItem = new JMenuItem("New");
fileMenu.add(newMenuItem);
JMenuItem openMenuItem = new JMenuItem("Open");
fileMenu.add(openMenuItem);
JMenuItem closeMenuItem = new JMenuItem("Close");
fileMenu.add(closeMenuItem);
fileMenu.addSeparator();
JMenuItem saveMenuItem = new JMenuItem("Save");
fileMenu.add(saveMenuItem);
fileMenu.addSeparator();
JMenuItem exitMenuItem = new JMenuItem("Exit");
fileMenu.add(exitMenuItem);

public JMenuItem insert(JMenuItem menuItem, int pos);
public JMenuItem insert(Action a, int pos);
public void insertSeparator(int pos);

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class ShowAction extends AbstractAction {
  Component parentComponent;
  public ShowAction(Component parentComponent) {
    super("About");
    putValue(Action.MNEMONIC_KEY, new Integer(KeyEvent.VK_A));
    this.parentComponent = parentComponent;
  }
  public void actionPerformed(ActionEvent actionEvent) {
    Runnable runnable = new Runnable() {
       public void run() {
         JOptionPane.showMessageDialog(
           parentComponent, "About Swing",
           "About Box V2.0", JOptionPane.INFORMATION_MESSAGE);
       }
    };
    EventQueue.invokeLater(runnable);
  }
}

Action showAction = new ShowAction(aComponent);
JMenuItem fileAbout = new JMenuItem(showAction);
fileMenu.add(fileAbout);
JMenuItem editAbout = new JMenuItem(showAction);
editMenu.add(editAbout);

public interface MenuListener extends EventListener {
  public void menuCanceled(MenuEvent e);
  public void menuDeselected(MenuEvent e);
  public void menuSelected(MenuEvent e);
}

public class MenuEvent extends EventObject {
  public MenuEvent(Object source);
}

public JSeparator()
JSeparator jSeparator = new JSeparator();
public JSeparator(int orientation)
JSeparator jSeparator = new JSeparator(JSeparator.VERTICAL);

public JPopupMenu()
JPopupMenu jPopupMenu = new JPopupMenu();
public JPopupMenu(String title)
JPopupMenu jPopupMenu = new JPopupMenu("Welcome");

public JMenuItem add(JMenuItem menuItem);
public JMenuItem add(String label);
public JMenuItem add(Action action);
public void addSeparator();

public Component add(Component component);

JPopupMenu popupenu = new JPopupMenu();
ActionListener anActionListener = ...;
// The first way
JMenuItem firstItem = new JMenuItem("Hello");
firstItem.addActionListener(anActionListener);
popupMenu.add(firstItem);
// The second way
JMenuItem secondItem = popupMenu.add("World");
secondItem.addActionListener(anActionListener);

public JMenuItem insert(Component component, int position);
public JMenuItem insert(Action action, int position);

JPopupMenu popupMenu = ...;
aComponent.setComponentPopupMenu(popupMenu);

// From now on, all JPopupMenus will be heavyweight
JPopupMenu.setDefaultLightWeightPopupEnabled(false);

public class PopupMenuEvent extends EventObject {
  public PopupMenuEvent(Object source);
}

public interface PopupMenuListener extends EventListener {
  public void popupMenuCanceled(PopupMenuEvent e);
  public void popupMenuWillBecomeInvisible(PopupMenuEvent e);
  public void popupMenuWillBecomeVisible(PopupMenuEvent e);
}

JSeparator popupSeparator =new JPopupMenu.Separator();

/**
 *
 */
package net.ariel.ch06;

import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.event.PopupMenuEvent;
import javax.swing.event.PopupMenuListener;

/**
 * @author mylxiaoyi
 *
 */
public class PopupSample {

    // Define ActionListener
    static class PopupActionListener implements ActionListener {
        public void actionPerformed(ActionEvent event) {
            System.out.println("Selected: "+event.getActionCommand());
        }
    }

    // Define PopupMenuListener
    static class MyPopupMenuListener implements PopupMenuListener {
        public void popupMenuCanceled(PopupMenuEvent event) {
            System.out.println("Canceled");
        }
        public void popupMenuWillBecomeInvisible(PopupMenuEvent event) {
            System.out.println("Becoming Invisible");
        }
        public void popupMenuWillBecomeVisible(PopupMenuEvent event) {
            System.out.println("Becoming Visible");
        }
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                // Create frame
                JFrame frame = new JFrame("PopupMenu Sample");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                ActionListener acitonListener = new PopupActionListener();
                PopupMenuListener popupMenuListener = new MyPopupMenuListener();

                // Create popup menu, attach popup menu listener
                JPopupMenu popupMenu = new JPopupMenu("Title");
                popupMenu.addPopupMenuListener(popupMenuListener);

                // Cut
                JMenuItem cutMenuItem = new JMenuItem("Cut");
                cutMenuItem.addActionListener(acitonListener);
                popupMenu.add(cutMenuItem);

                // Copy
                JMenuItem copyMenuItem = new JMenuItem("Copy");
                copyMenuItem.addActionListener(acitonListener);
                popupMenu.add(copyMenuItem);

                // Paste
                JMenuItem pasteMenuItem = new JMenuItem("Paste");
                pasteMenuItem.addActionListener(acitonListener);
                popupMenu.add(pasteMenuItem);

                // Separator
                popupMenu.addSeparator();

                // Find
                JMenuItem findMenuItem = new JMenuItem("Find");
                findMenuItem.addActionListener(acitonListener);
                popupMenu.add(findMenuItem);

                JButton label = new JButton();
                frame.add(label);
                label.setComponentPopupMenu(popupMenu);

                frame.setSize(350, 250);
                frame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

public JCheckBoxMenuItem()
JCheckBoxMenuItem jCheckBoxMenuItem = new JCheckBoxMenuItem();

public JCheckBoxMenuItem(String text)
JCheckBoxMenuItem jCheckBoxMenuItem = new JCheckBoxMenuItem("Boy");

public JCheckBoxMenuItem(Icon icon)
Icon boyIcon = new ImageIcon("boy-r.jpg");
JCheckBoxMenuItem jCheckBoxMenuItem = new JCheckBoxMenuItem(boyIcon);

public JCheckBoxMenuItem(String text, Icon icon)
JCheckBoxMenuItem jCheckBoxMenuItem = new JCheckBoxMenuItem("Boy", boyIcon);

public JCheckBoxMenuItem(String text, boolean state)
JCheckBoxMenuItem jCheckBoxMenuItem = new JCheckBoxMenuItem("Girl", true);

public JCheckBoxMenuItem(String text, Icon icon, boolean state)
Icon girlIcon = new ImageIcon("girl-r.jpg");
JCheckBoxMenuItem jCheckBoxMenuItem = new JCheckBoxMenuItem("Girl", girlIcon, true);

public JCheckBoxMenuItem(Action action)
Action action = ...;
JCheckBoxMenuItem jCheckBoxMenuItem = new JCheckBoxMenuItem(action);

ActionListener aListener = new ActionListener() {
   public void actionPerformed(ActionEvent event) {
     Icon girlIcon = new ImageIcon("girl-r.jpg");
     Icon boyIcon = new ImageIcon("boy-r.jpg");
     AbstractButton aButton = (AbstractButton)event.getSource();
     boolean selected = aButton.getModel().isSelected();
     String newLabel;
     Icon newIcon;
     if (selected) {
       newLabel = "Girl";
       newIcon = girlIcon;
     } else {
       newLabel = "Boy";
       newIcon = boyIcon;
     }
     aButton.setText(newLabel);
     aButton.setIcon(newIcon);
   }
};

ItemListener iListener = new ItemListener() {
   public void itemStateChanged(ItemEvent event) {
     Icon girlIcon = new ImageIcon("girl-r.jpg");
     Icon boyIcon = new ImageIcon("boy-r.jpg");
     AbstractButton aButton = (AbstractButton)event.getSource();
     int state = event.getStateChange();
     String newLabel;
     Icon newIcon;
     if (state == ItemEvent.SELECTED) {
       newLabel = "Girl";
       newIcon = girlIcon;
     } else {
       newLabel = "Boy";
       newIcon = boyIcon;
     }
     aButton.setText(newLabel);
     aButton.setIcon(newIcon);
   }
};

UIManager.put("CheckBoxMenuItem.checkIcon", someIcon);

package net.ariel.ch06;

import java.awt.Color;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.Polygon;

import javax.swing.AbstractButton;
import javax.swing.Icon;

public class DiamondAbstractButtonStateIcon implements Icon {

    private final int width = 10;
    private final int height = 10;
    private Color color;
    private Polygon polygon;

    public DiamondAbstractButtonStateIcon(Color color) {
        this.color = color;
        initPolygon();
    }

    private void initPolygon() {
        polygon = new Polygon();
        int halfWidth = width/2;
        int halfHeight = height/2;
        polygon.addPoint(0, halfHeight);
        polygon.addPoint(halfWidth, 0);
        polygon.addPoint(width, halfHeight);
        polygon.addPoint(halfWidth, height);
    }
    @Override
    public int getIconHeight() {
        // TODO Auto-generated method stub
        return height;
    }

    @Override
    public int getIconWidth() {
        // TODO Auto-generated method stub
        return height;
    }

    @Override
    public void paintIcon(Component component, Graphics g, int x, int y) {
        // TODO Auto-generated method stub

        boolean selected = false;
        g.setColor(color);
        g.translate(x, y);
        if(component instanceof AbstractButton) {
            AbstractButton abstractButton = (AbstractButton)component;
            selected = abstractButton.isSelected();
        }
        if(selected) {
            g.fillPolygon(polygon);
        }
        else {
            g.drawPolygon(polygon);
        }
        g.translate(-x, -y);
    }

}

public JCheckBoxMenuItem()
JCheckBoxMenuItem jCheckBoxMenuItem = new JCheckBoxMenuItem();
public JCheckBoxMenuItem(String text)
JCheckBoxMenuItem jCheckBoxMenuItem = new JCheckBoxMenuItem("Boy");
public JCheckBoxMenuItem(Icon icon)
Icon boyIcon = new ImageIcon("boy-r.jpg");
JCheckBoxMenuItem jCheckBoxMenuItem = new JCheckBoxMenuItem(boyIcon);
public JCheckBoxMenuItem(String text, Icon icon)
JCheckBoxMenuItem jCheckBoxMenuItem = new JCheckBoxMenuItem("Boy", boyIcon);
public JCheckBoxMenuItem(String text, boolean state)
JCheckBoxMenuItem jCheckBoxMenuItem = new JCheckBoxMenuItem("Girl", true);
public JCheckBoxMenuItem(String text, Icon icon, boolean state)
Icon girlIcon = new ImageIcon("girl-r.jpg");
JCheckBoxMenuItem jCheckBoxMenuItem = new JCheckBoxMenuItem("Girl", girlIcon, true);
public JCheckBoxMenuItem(Action action)
Action action = ...;
JCheckBoxMenuItem jCheckBoxMenuItem = new JCheckBoxMenuItem(action);

/**
 *
 */
package net.ariel.ch06;

import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.KeyEvent;

import javax.swing.AbstractButton;
import javax.swing.ButtonGroup;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JRadioButtonMenuItem;

/**
 * @author mylxiaoyi
 *
 */
public class RadioButtonSample {

    static Icon threeIcon = new ImageIcon("3.gif");
    static Icon fourIcon = new ImageIcon("4.gif");
    static Icon fiveIcon = new ImageIcon("5.gif");
    static Icon sixIcon = new ImageIcon("6.gif");

    public static class ButtonActionListener implements ActionListener {
        public void actionPerformed(ActionEvent event) {
            AbstractButton aButton = (AbstractButton)event.getSource();
            boolean selected = aButton.getModel().isSelected();
            System.out.println(event.getActionCommand()+" - selected? "+selected);
        }
    }

    public static class ButtonItemListener implements ItemListener {
        public void itemStateChanged(ItemEvent event) {
            AbstractButton aButton = (AbstractButton)event.getSource();
            int state = event.getStateChange();
            String selected = ((state == event.SELECTED)?"selected":"not selected");
            System.out.println(aButton.getText()+" - selected? "+selected);
        }
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                final ActionListener actionListener = new ButtonActionListener();
                final ItemListener itemListener = new ButtonItemListener();

                JFrame frame = new JFrame("Radio Menu Example");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                JMenuBar menuBar = new JMenuBar();
                JMenu menu = new JMenu("Menu");
                ButtonGroup buttonGroup = new ButtonGroup();
                menu.setMnemonic(KeyEvent.VK_M);

                JRadioButtonMenuItem emptyMenuItem = new JRadioButtonMenuItem();
                emptyMenuItem.setActionCommand("Empty");
                emptyMenuItem.addActionListener(actionListener);
                buttonGroup.add(emptyMenuItem);
                menu.add(emptyMenuItem);

                JRadioButtonMenuItem oneMenuItem = new JRadioButtonMenuItem("Partridge");
                oneMenuItem.addActionListener(actionListener);
                buttonGroup.add(oneMenuItem);
                menu.add(oneMenuItem);

                JRadioButtonMenuItem twoMenuItem = new JRadioButtonMenuItem("Turtle Dove", true);
                twoMenuItem.addActionListener(actionListener);
                buttonGroup.add(twoMenuItem);
                menu.add(twoMenuItem);

                JRadioButtonMenuItem threeMenuItem = new JRadioButtonMenuItem("French Hens", threeIcon);
                threeMenuItem.addItemListener(itemListener);
                buttonGroup.add(threeMenuItem);
                menu.add(threeMenuItem);

                JRadioButtonMenuItem fourMenuItem = new JRadioButtonMenuItem("Calling Birds", fourIcon, true);
                fourMenuItem.addActionListener(actionListener);
                buttonGroup.add(fourMenuItem);
                menu.add(fourMenuItem);

                JRadioButtonMenuItem fiveMenuItem = new JRadioButtonMenuItem(fiveIcon);
                fiveMenuItem.addActionListener(actionListener);
                fiveMenuItem.setActionCommand("Rings");
                buttonGroup.add(fiveMenuItem);
                menu.add(fiveMenuItem);

                JRadioButtonMenuItem sixMenuItem = new JRadioButtonMenuItem(sixIcon, true);
                sixMenuItem.addActionListener(actionListener);
                sixMenuItem.setActionCommand("Geese");
                buttonGroup.add(sixMenuItem);
                menu.add(sixMenuItem);

                menuBar.add(menu);

                frame.setJMenuBar(menuBar);
                frame.setSize(350, 250);
                frame.setVisible(true);
            }
        };
        EventQueue.invokeLater(runner);
    }

}

public interface MenuElement {
  public Component getComponent();
  public MenuElement[] getSubElements();
  public void menuSelectionChanged(boolean isInclude);
  public void processKeyEvent(KeyEvent event, MenuElement path[],
    MenuSelectionManager mgr);
  public void processMouseEvent(MouseEvent event, MenuElement path[],
    MenuSelectionManager mgr);
}

/**
 *
 */
package net.ariel.ch06;

import java.awt.Color;
import java.awt.Component;
import java.awt.Point;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;

import javax.swing.Action;
import javax.swing.ButtonModel;
import javax.swing.JToggleButton;
import javax.swing.MenuElement;
import javax.swing.MenuSelectionManager;
import javax.swing.event.MouseInputListener;

/**
 * @author mylxiaoyi
 *
 */
public class JToggleButtonMenuItem extends JToggleButton implements MenuElement {

    Color savedForeground = null;
    private static MenuElement NO_SUB_ELEMENTS[] = new MenuElement[0];

    public JToggleButtonMenuItem() {
        init();
    }

    public JToggleButtonMenuItem(String label) {
        super(label);
        init();
    }

    public JToggleButtonMenuItem(Action action) {
        super(action);
        init();
    }

    private void init() {
        updateUI();
        setRequestFocusEnabled(false);

        // Borrows heavily from BasicMenuUI
        MouseInputListener mouseInputListener = new MouseInputListener() {
            // If mouse release over this menu item, activate it
            public void mouseReleased(MouseEvent event) {
                MenuSelectionManager menuSelectionManager = MenuSelectionManager.defaultManager();
                Point point = event.getPoint();
                if((point.x >= 0) && (point.x < getWidth()) && (point.y >= 0) && (point.y < getHeight())) {
                    menuSelectionManager.clearSelectedPath();
                    // Component automatically handles "selection" at this point
                    // doClick(0); // not necessary
                }
                else {
                    menuSelectionManager.processMouseEvent(event);
                }
            }

            @Override
            public void mouseClicked(MouseEvent event) {
                // TODO Auto-generated method stub

            }

            // if mouse moves over menu item, add to selection path, so it becomes armed
            @Override
            public void mouseEntered(MouseEvent event) {
                // TODO Auto-generated method stub
                MenuSelectionManager menuSelectionManager = MenuSelectionManager.defaultManager();
                menuSelectionManager.setSelectedPath(getPath());
            }

            // when mouse moves away from menu item, disarm it and select something else
            @Override
            public void mouseExited(MouseEvent event) {
                // TODO Auto-generated method stub
                MenuSelectionManager menuSelectionManager = MenuSelectionManager.defaultManager();
                MenuElement path[] = menuSelectionManager.getSelectedPath();
                if(path.length > 1) {
                    MenuElement[] newPath = new MenuElement[path.length-1];
                    for(int i=0, c=path.length-1; i<c; i++) {
                        newPath[i] = path[i];
                    }
                    menuSelectionManager.setSelectedPath(newPath);
                }
            }

            @Override
            public void mousePressed(MouseEvent event) {
                // TODO Auto-generated method stub

            }

            // pass along drag events
            @Override
            public void mouseDragged(MouseEvent event) {
                // TODO Auto-generated method stub
                MenuSelectionManager.defaultManager().processMouseEvent(event);
            }

            @Override
            public void mouseMoved(MouseEvent event) {
                // TODO Auto-generated method stub

            }
        };
        addMouseListener(mouseInputListener);
        addMouseMotionListener(mouseInputListener);
    }
    /* (non-Javadoc)
     * @see javax.swing.MenuElement#getComponent()
     */
    @Override
    public Component getComponent() {
        // TODO Auto-generated method stub
        return this;
    }

    /* (non-Javadoc)
     * @see javax.swing.MenuElement#getSubElements()
     */
    @Override
    public MenuElement[] getSubElements() {
        // TODO Auto-generated method stub
        return NO_SUB_ELEMENTS;
    }

    /* (non-Javadoc)
     * @see javax.swing.MenuElement#menuSelectionChanged(boolean)
     */
    @Override
    public void menuSelectionChanged(boolean isIncluded) {
        // TODO Auto-generated method stub
        ButtonModel model = getModel();
        // only change armed state if different
        if(model.isArmed() != isIncluded) {
            model.setArmed(isIncluded);
        }

        if(isIncluded) {
            savedForeground = getForeground();
            if(!savedForeground.equals(Color.BLUE)) {
                setForeground(Color.BLUE);
            }
            else {
                // in case foreground blue, use something different
                setForeground(Color.BLUE);
            }
        }
        else {
            setForeground(savedForeground);
            // if null, get foreground from installed look and feel
            if(savedForeground == null) {
                updateUI();
            }
        }
    }

    /* (non-Javadoc)
     * @see javax.swing.MenuElement#processKeyEvent(java.awt.event.KeyEvent, javax.swing.MenuElement[], javax.swing.MenuSelectionManager)
     */
    @Override
    public void processKeyEvent(KeyEvent event, MenuElement[] path,
            MenuSelectionManager manager) {
        // TODO Auto-generated method stub
        // if user presses space while menu item armed, select it
        if(getModel().isArmed()) {
            int keyChar = event.getKeyChar();
            if(keyChar == KeyEvent.VK_SPACE) {
                manager.clearSelectedPath();
                System.out.println("Selected: JToggleButtonMenuItem, by KeyEvent");
                doClick(0); // inheried from AbstractButton
            }
        }
    }

    /* (non-Javadoc)
     * @see javax.swing.MenuElement#processMouseEvent(java.awt.event.MouseEvent, javax.swing.MenuElement[], javax.swing.MenuSelectionManager)
     */
    @Override
    public void processMouseEvent(MouseEvent event, MenuElement[] path,
            MenuSelectionManager manager) {
        // TODO Auto-generated method stub
        // for when mose dragged over menu and button released
        if(event.getID() == MouseEvent.MOUSE_RELEASED) {
            manager.clearSelectedPath();
            System.out.println("Selected: JToggleButtonMenuItem, by MouseEvent");
            doClick(0);
        }
    }

    // borrows heavily from BasicMenuItemUI.getPath()
    private MenuElement[] getPath() {
        MenuSelectionManager menuSelectionManager = MenuSelectionManager.defaultManager();
        MenuElement oldPath[] = menuSelectionManager.getSelectedPath();
        MenuElement newPath[];
        int oldPathLength = oldPath.length;
        if(oldPathLength == 0)
            return new MenuElement[0];
        Component parent = getParent();
        if(oldPath[oldPathLength-1].getComponent() == parent) {
            // going deeper under the parent menu
            newPath = new MenuElement[oldPathLength+1];
            System.arraycopy(oldPath, 0, newPath, 0, oldPathLength);
            newPath[oldPathLength] = this;
        }
        else {
            // sibling/child menu item currently selected
            int newPathPosition;
            for(newPathPosition = oldPath.length-1; newPathPosition >= 0; newPathPosition--) {
                if(oldPath[newPathPosition].getComponent() == parent) {
                    break;
                }
            }
            newPath = new MenuElement[newPathPosition+2];
            System.arraycopy(oldPath, 0, newPath, 0, newPathPosition+1);
            newPath[newPathPosition+1] = this;
        }
        return newPath;
    }
}

JToggleButtonMenuItem toggleItem = new JToggleButtonMenuItem("Balloon Help");
editMenu.add(toggleItem);

PopupFactory factory = PopupFactory.getSharedInstance();
Popup popup = factory.getPopup(owner, contents, x, y);

package net.ariel.ch06;

import java.awt.Component;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.Popup;
import javax.swing.PopupFactory;
import javax.swing.Timer;

public class ButtonPopupSample {

    static final Random random = new Random();

    // define ActionListener
    static class ButtonActionListener implements ActionListener {
        public void actionPerformed(ActionEvent event) {
            System.out.println("Selected: "+event.getActionCommand());
        }
    };

    // define show popu ActionListener
    static class ShowPopupActionListener implements ActionListener {
        private Component component;
        ShowPopupActionListener(Component component) {
            this.component = component;
        }
        public synchronized void actionPerformed(ActionEvent event) {
            JButton button = new JButton("Hello, world");
            ActionListener listener = new ButtonActionListener();
            button.addActionListener(listener);
            PopupFactory factory = PopupFactory.getSharedInstance();
            int x = random.nextInt(200);
            int y = random.nextInt(200);
            final Popup popup = factory.getPopup(component, button, x, y);
            popup.show();
            ActionListener hider = new ActionListener() {
                public void actionPerformed(ActionEvent event) {
                    popup.hide();
                }
            };
            // hide popup in 3 seconds
            Timer timer = new Timer(3000, hider);
            timer.start();
        }
    };
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                // create frame
                JFrame frame = new JFrame("Button Popup Sample");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                ActionListener actionListener =  new ShowPopupActionListener(frame);

                JButton start = new JButton("Pick Me for Popup");
                start.addActionListener(actionListener);
                frame.add(start);

                frame.setSize(350, 250);
                frame.setVisible(true);
            }
        };
        EventQueue.invokeLater(runner);
    }

}

public JToolBar()
JToolBar jToolBar = new JToolBar();
public JToolBar(int orientation)
JToolBar jToolBar = new JToolBar(JToolBar.VERTICAL);
public JToolBar(String name)
JToolBar jToolBar = new JToolBar("Window Title");
public JToolBar(String name,int orientation)
JToolBar jToolBar = new JToolBar("Window Title", ToolBar.VERTICAL);

public JButton add(Action action);
public void addSeparator();
public void addSeparator(Dimension size);

public void remove(Component component)

package net.ariel.ch06;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.Action;
import javax.swing.Icon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JToolBar;

import net.ariel.ch04.DiamondIcon;

public class ToolBarSample {

    private static final int COLOR_POSITION = 0;
    private static final int STRING_POSITION = 1;
    static Object buttonColors[][] = {
        {Color.RED, "RED"},
        {Color.BLUE, "BLUE"},
        {Color.GREEN, "GREEN"},
        {Color.BLACK, "BLACK"},
        null, // separator
        {Color.CYAN, "CYAN"}
    };

    public static class TheActionListener implements ActionListener {
        public void actionPerformed(ActionEvent event) {
            System.out.println(event.getActionCommand());
        }
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("JToolBar Example");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                ActionListener actionListener = new TheActionListener();

                JToolBar toolbar = new JToolBar();
                toolbar.setRollover(true);

                for(Object[] color: buttonColors) {
                    if(color == null) {
                        toolbar.addSeparator();
                    }
                    else {
                        Icon icon = new DiamondIcon((Color)color[COLOR_POSITION], true, 20, 20);
                        JButton button = new JButton(icon);
                        button.setActionCommand((String)color[STRING_POSITION]);
                        button.addActionListener(actionListener);
                        toolbar.add(button);
                    }
                }
                Action action = new ShowAction(frame);
                JButton button = new JButton(action);
                toolbar.add(button);

                Container contentPane = frame.getContentPane();
                contentPane.add(toolbar, BorderLayout.NORTH);
                JTextArea textArea = new JTextArea();
                JScrollPane pane = new JScrollPane(textArea);
                contentPane.add(pane, BorderLayout.CENTER);
                frame.setSize(350, 150);
                frame.setVisible(true);
            }
        };
        EventQueue.invokeLater(runner);
    }

}

public JToolBar.Separator()
JSeparator toolBarSeparator = new JToolBar.Separator();
public JToolBar.Separator(Dimension size)
Dimension dimension = new Dimension(10, 10);
JSeparator toolBarSeparator = new JToolBar.Separator(dimension);

public void paintBorder(Component c, Graphics g, int x, int y, int
  width, int height)

public void paintBorder(Component c, Graphics g, int x, int y, int width,
    int height) {
  Insets insets = getBorderInsets(c);
  Color color = c.getForeground();
  Color brighterColor = color.brighter();
// Translate coordinate space
  g.translate(x, y);
// Top
  g.setColor(color);
  g.fillRect(0, 0, width, insets.top);
// Left
  g.setColor(brighterColor);
  g.fillRect(0, insets.top, insets.left, height-insets.top-insets.bottom);
// Bottom
  g.setColor(color);
  g.fillRect(0, height-insets.bottom, width, insets.bottom);
// Right
  g.setColor(brighterColor);
  g.fillRect(width-insets.right, insets.top, insets.right,
    height-insets.top-insets.bottom);
// Translate coordinate space back
  g.translate(-x, -y);
}

public Insets getBorderInsets(Component c)

public boolean isBorderOpaque()

public class BorderFactory {
  public static Border createBevelBorder(int type);
  public static Border createBevelBorder(int type, Color highlight,
    Color shadow);
  public static Border createBevelBorder(int type, Color highlightOuter,
    Color highlightInner, Color shadowOuter, Color shadowInner);
  public static CompoundBorder createCompoundBorder();
  public static CompoundBorder createCompoundBorder(Border outside,
    Border inside);
  public static Border createEmptyBorder();
  public static Border createEmptyBorder(int top, int left, int bottom,
    int right);
  public static Border createEtchedBorder();
  public static Border createEtchedBorder(Color highlight, Color shadow);
  public static Border createEtchedBorder(int type);
  public static Border createEtchedBorder(int type, Color highlight,
    Color shadow);
  public static Border createLineBorder(Color color);
  public static Border createLineBorder(Color color, int thickness);
  public static Border createLoweredBevelBorder();
  public static MatteBorder createMatteBorder(int top, int left, int bottom,
    int right, Color color);
  public static MatteBorder createMatteBorder(int top, int left, int bottom,
    int right, Icon icon);
  public static Border createRaisedBevelBorder();
  public static TitledBorder createTitledBorder(Border border);
  public static TitledBorder createTitledBorder(Border border, String title);
  public static TitledBorder createTitledBorder(Border border, String title,
    int justification, int position);
  public static TitledBorder createTitledBorder(Border border, String title,
    int justification, int position, Font font);
  public static TitledBorder createTitledBorder(Border border, String title,
    int justification, int position, Font font, Color color);
  public static TitledBorder createTitledBorder(String title);
}

Border lineBorder = BorderFactory.createLineBorder(Color.RED);

public AbstractBorder()

public Insets getBorderInsets(Component c)

public boolean isBorderOpaque()

public void paintBorder(Component c, Graphics g, int x, int y,
  int width, int height)

public Insets getBorderInsets(Component c, Insets insets)

public static Border createEmptyBorder()
Border emptyBorder = BorderFactory.createEmptyBorder();
public static Border createEmptyBorder(int top, int left, int bottom, int right)
Border emptyBorder = BorderFactory.createEmptyBorder(5, 10, 5, 10);
public EmptyBorder(Insets insets)
Insets insets = new Insets(5, 10, 5, 10);
Border EmptyBorder = new EmptyBorder(insets);
public EmptyBorder(int top, int left, int bottom, int right)
Border EmptyBorder = new EmptyBorder(5, 10, 5, 10);

public LineBorder(Color color)
Border lineBorder = new LineBorder (Color.RED);

public LineBorder(Color color, int thickness)
Border lineBorder = new LineBorder (Color.RED, 5);

public LineBorder (Color color, int thickness, boolean roundedCorners)
Border lineBorder = new LineBorder (Color.RED, 5, true);

public static Border createBlackLineBorder()
Border blackLine = LineBorder.createBlackLineBorder();

public static Border createGrayLineBorder()
Border grayLine = LineBorder.createGrayLineBorder();

public static Border createLineBorder(Color color)
Border lineBorder = BorderFactory.createLineBorder(Color.RED);

public static Border createLineBorder(Color color, int thickness)
Border lineBorder = BorderFactory.createLineBorder(Color.RED, 5);

public BevelBorder(int bevelType)
Border bevelBorder = new BevelBorder(BevelBorder.RAISED);

public static Border createBevelBorder(int bevelType)
Border bevelBorder = BorderFactory.createBevelBorder(BevelBorder.RAISED);

public static Border createLoweredBevelBorder()
Border bevelBorder = BorderFactory.createLoweredBevelBorder();

public static Border createRaisedBevelBorder()
Border bevelBorder = BorderFactory.createRaisedBevelBorder();

public BevelBorder(int bevelType, Color highlight, Color shadow)
Border bevelBorder = new BevelBorder(BevelBorder.RAISED, Color.PINK, Color.RED);

public static Border createBevelBorder(int bevelType, Color highlight, Color shadow)
Border bevelBorder = BorderFactory.createBevelBorder(BevelBorder.RAISED,
  Color.PINK, Color.RED);

public BevelBorder(int bevelType, Color highlightOuter, Color highlightInner,
  Color shadowOuter, Color shadowInner)
Border bevelBorder = new BevelBorder(BevelBorder.RAISED, Color.PINK,
  Color.PINK.brighter(), Color.RED, Color.RED.darker());

public static Border createBevelBorder(int bevelType, Color highlightOuter,
  Color highlightInner, Color shadowOuter, Color shadowInner)
Border bevelBorder = BorderFactory.createBevelBorder(BevelBorder.RAISED,
  Color.PINK, Color.PINK.brighter(), Color.RED, Color.RED.darker());

public SoftBevelBorder(int bevelType)
Border softBevelBorder = new SoftBevelBorder(SoftBevelBorder.RAISED);
public SoftBevelBorder(int bevelType, Color highlight, Color shadow)
Border softBevelBorder = new SoftBevelBorder(SoftBevelBorder.RAISED, Color.RED,
  Color.PINK);
public SoftBevelBorder(int bevelType, Color highlightOuter, Color highlightInner,
  Color shadowOuter, Color shadowInner)
Border softBevelBorder = new SoftBevelBorder(SoftBevelBorder.RAISED, Color.RED,
  Color.RED.darker(), Color.PINK, Color.PINK.brighter());

public EtchedBorder()
Border etchedBorder = new EtchedBorder();

public EtchedBorder(int etchType)
Border etchedBorder = new EtchedBorder(EtchedBorder.RAISED);

public EtchedBorder(Color highlight, Color shadow)
Border etchedBorder = new EtchedBorder(Color.RED, Color.PINK);

public EtchedBorder(int etchType, Color highlight, Color shadow)
Border etchedBorder = new EtchedBorder(EtchedBorder.RAISED, Color.RED,
  Color.PINK);

public static Border createEtchedBorder()
Border etchedBorder = BorderFactory.createEtchedBorder();

public static Border createEtchedBorder(Color highlight, Color shadow)
Border etchedBorder = BorderFactory.createEtchedBorder(Color.RED, Color.PINK);

public static Border createEtchedBorder(EtchedBorder.RAISED)
Border etchedBorder = BorderFactory.createEtchedBorder(Color.RED, Color.PINK);

public static Border createEtchedBorder(int type, Color highlight, Color shadow)
Border etchedBorder = BorderFactory.createEtchedBorder(EtchedBorder.RAISED,
  Color.RED, Color.PINK);

public MatteBorder(int top, int left, int bottom, int right, Color color)
Border matteBorder = new MatteBorder(5, 10, 5, 10, Color.GREEN);

public MatteBorder(int top, int left, int bottom, int right, Icon icon)
Icon diamondIcon = new DiamondIcon(Color.RED);
Border matteBorder = new MatteBorder(5, 10, 5, 10, diamondIcon);

public MatteBorder(Icon icon)
Icon diamondIcon = new DiamondIcon(Color.RED);
Border matteBorder = new MatteBorder(diamondIcon);

public MatteBorder(Insets insets, Color color)
Insets insets = new Insets(5, 10, 5, 10);
Border matteBorder = new MatteBorder(insets,  Color.RED);

public MatteBorder(Insets insets, Icon icon)
Insets insets = new Insets(5, 10, 5, 10);
Icon diamondIcon = new DiamondIcon(Color.RED);
Border matteBorder = new MatteBorder(insets, diamondIcon);

public static MatteBorder createMatteBorder(int top, int left, int bottom,
  int right, Color color)
Border matteBorder = BorderFactory.createMatteBorder(5, 10, 5, 10, Color.GREEN);

public static MatteBorder createMatteBorder(int top, int left, int bottom,
  int right, Icon icon)
Icon diamondIcon = new DiamondIcon(Color.RED);
Border matteBorder = BorderFactory.createMatteBorder(5, 10, 5, 10, diamondIcon);

public CompoundBorder()
public static CompoundBorder createCompoundBorder()
public CompoundBorder(Border outside, Border inside)
Border compoundBorder = new CompoundBorder(lineBorder, matteBorder);
public static CompoundBorder createCompoundBorder(Border outside, Border inside)
Border compoundBorder = BorderFactory.createCompoundBorder(lineBorder,
  matteBorder);

public TitledBorder(Border border)
Border titledBorder = new TitledBorder(lineBorder);

public static TitledBorder createTitledBorder(Border border)
Border titledBorder = BorderFactory.createTitledBorder(lineBorder);

public TitledBorder(String title)
Border titledBorder = new TitledBorder("Hello");

public static TitledBorder createTitledBorder(String title)
Border titledBorder = BorderFactory.createTitledBorder("Hello");

public TitledBorder(Border border, String title)
Border titledBorder = new TitledBorder(lineBorder, "Hello");

public static TitledBorder createTitledBorder(Border border, String title)
Border titledBorder = BorderFactory.createTitledBorder(lineBorder, "Hello");

public TitledBorder(Border border, String title, int justification, int position)
Border titledBorder = new TitledBorder(lineBorder, "Hello", TitledBorder.LEFT,
  TitledBorder.BELOW_BOTTOM);

public static TitledBorder createTitledBorder(Border border, String title,
  int justification, int position)
Border titledBorder = BorderFactory.createTitledBorder(lineBorder, "Hello",
  TitledBorder.LEFT, TitledBorder.BELOW_BOTTOM);

public TitledBorder(Border border, String title, int justification, int position,
  Font font)
Font font = new Font("Serif", Font.ITALIC, 12);
Border titledBorder = new TitledBorder(lineBorder, "Hello", TitledBorder.LEFT,
  TitledBorder.BELOW_BOTTOM, font);

public static TitledBorder createTitledBorder(Border border, String title,
  int justification, int position, Font font)
Font font = new Font("Serif", Font.ITALIC, 12);
Border titledBorder = BorderFactory.createTitledBorder(lineBorder, "Hello",
  TitledBorder.LEFT, TitledBorder.BELOW_BOTTOM, font);

public TitledBorder(Border border, String title, int justification, int position,
  Font font, Color color)
Font font = new Font("Serif", Font.ITALIC, 12);
Border titledBorder = new TitledBorder(lineBorder, "Hello", TitledBorder.LEFT,
  TitledBorder.BELOW_BOTTOM, font, Color.RED);

public static TitledBorder createTitledBorder(Border border, String title,
  int justification, int position, Font font, Color color)
Font font = new Font("Serif", Font.ITALIC, 12);
Border titledBorder = BorderFactory.createTitledBorder(lineBorder, "Hello",
  TitledBorder.LEFT, TitledBorder.BELOW_BOTTOM, font, Color.RED);

package swingstudy.ch07;

import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.border.TitledBorder;

public class DoubleTitle {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Double Title");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                TitledBorder topBorder = BorderFactory.createTitledBorder("Top");
                topBorder.setTitlePosition(TitledBorder.TOP);

                TitledBorder doubleBorder = new TitledBorder(topBorder, "Bottom", TitledBorder.RIGHT, TitledBorder.BOTTOM);

                JButton doubleButton = new JButton();
                doubleButton.setBorder(doubleBorder);

                frame.add(doubleButton, BorderLayout.CENTER);
                frame.setSize(300, 100);
                frame.setVisible(true);
            }
        };
        EventQueue.invokeLater(runner);
    }

}

package swingstudy.ch08;

import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JRootPane;

public class AdornSample {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Adornment Example");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setUndecorated(true);
                frame.getRootPane().setWindowDecorationStyle(JRootPane.FRAME);
                frame.setSize(300, 100);
                frame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

public interface RootPaneContainer {
  // Properties
  public Container getContentPane();
  public void setContentPane(Container contentPane);
  public Component getGlassPane();
  public void setGlassPane(Component glassPane);
  public JLayeredPane getLayeredPane();
  public void setLayeredPane(JLayeredPane layeredPane);
  public JRootPane getRootPane();
}

public Component getGlassPane() {
  return getRootPane().getGlassPane();
}
public void setGlassPane(Component glassPane) {
  getRootPane().setGlassPane(glassPane);
}

Integer layer = new Integer(20);
aLayeredPane.add(aComponent, layer);

aLayeredPane.setLayer(aComponent, 10);
aLayeredPane.add(aComponent);

public JFrame()
JFrame frame = new JFrame();

public JFrame(String title)
JFrame frame = new JFrame("Title Bar");

public JFrame(GraphicsConfiguration config)
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice gsd[] = ge.getScreenDevices();
GraphicsConfiguration gc[] = gsd[0].getConfigurations();
JFrame frame = new JFrame(gc[0]);

public JFrame(String title, GraphicsConfiguration config)
GraphicsConfiguration gc = ...;
JFrame frame = new JFrame("Title Bar", gc);

aFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

package swingstudy.ch08;

import java.awt.EventQueue;

import javax.swing.JFrame;

public class AdornSample2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame.setDefaultLookAndFeelDecorated(true);
                JFrame frame = new JFrame("Adornment Sample");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setSize(300,200);
                frame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

JRootPane rootPane = aJFrame.getRootPane();
Container contentPane = rootPane.getContentPane();
contentPane.add(...);

aJFrame.getContentPane().add(...);
</syntaxhighlihgt>

如果我们尝试直接向JFrame添加组件，则会抛出运行时错误。

由于许多建议（或是抱怨？），Sun最终决定将add()方法修改为代理：

<syntaxhighlight lang="java">
// J2SE 5.0
aJFrame.add(...);

JPanel content = (JPanel)frame.getContentPane();
KeyStroke stroke = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0);
content.registerKeyboardAction(actionListener, stroke,
  JComponent.WHEN_IN_FOCUSED_WINDOW);

protected void frameInit()
protected JRootPane createRootPane()
</syntaxhighlihgt>

通过在子类中重写这些方法，我们可以自定义初始外观以及窗体或是其JRootPane的行为。例如，在列表8-3中所示的ExitableJFrame类的例子中，默认的关闭操作被初始化EXIT_ON_CLOSE状态。无需要为每一个创建的窗体调用setDefaultCloseOperation()方法，我们可以使用这个类进行替换。因为JFrame被继承，我们并不需要在其构造函数中添加frameInit()方法的调用。其父类自动调用这个方法。

<syntaxhighlight lang="java">

package swingstudy.ch08;

import javax.swing.JFrame;

public class ExitableFrame extends JFrame {

    public ExitableFrame() {

    }

    public ExitableFrame(String title) {
        super(title);
    }

    protected void frameInit() {
        super.frameInit();
        setDefaultCloseOperation(EXIT_ON_CLOSE);
    }
}

public JWindow()
JWindow window = new JWindow();
public JWindow(Frame owner)
JWindow window = new JWindow(aFrame);
public JWindow(GraphicsConfiguration config)
GraphicsConfiguration gc = ...;
JWindow window = new JWindow(gc);
public JWindow(Window owner)
JWindow window = new JWindow(anotherWindow);
public JWindow(Window owner, GraphicsConfiguration config)
GraphicsConfiguration gc = ...;
JWindow window = new JWindow(anotherWindow, gc);

protected void windowInit()
protected JRootPane createRootPane()

public JDialog()
JDialog dialog = new JDialog();

public JDialog(Dialog owner)
JDialog dialog = new JDialog(anotherDialog);

public JDialog(Dialog owner, boolean modal)
JDialog dialog = new JDialog(anotherDialog, true);

public JDialog(Dialog owner, String title)
JDialog dialog = new JDialog(anotherDialog, "Hello");

public JDialog(Dialog owner, String title, boolean modal)
JDialog dialog = new JDialog(anotherDialog, "Hello", true);

public JDialog(Dialog owner, String title, boolean modal, GraphicsConfiguration gc)
GraphicsConfiguration gc = ...;
JDialog dialog = new JDialog(anotherDialog, "Hello", true, gc);

public JDialog(Frame owner)
JDialog dialog = new JDialog(aFrame);

public JDialog(Frame owner, String windowTitle)
JDialog dialog = new JDialog(aFrame, "Hello");

public JDialog(Frame owner, boolean modal)
JDialog dialog = new JDialog(aFrame, false);

public JDialog(Frame owner, String title, boolean modal)
JDialog dialog = new JDialog(aFrame, "Hello", true);

public JDialog(Frame owner, String title, boolean modal, GraphicsConfiguration gc)
GraphicsConfiguration gc = ...;
JDialog dialog = new JDialog(aFrame, "Hello", true, gc);

package swingstudy.ch08;

import java.awt.Dialog;
import java.awt.Frame;
import java.awt.GraphicsConfiguration;
import java.awt.event.ActionEvent;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.InputMap;
import javax.swing.JComponent;
import javax.swing.JDialog;
import javax.swing.JRootPane;
import javax.swing.KeyStroke;

public class EscapeDialog extends JDialog {

    public EscapeDialog() {
        this((Frame)null, false);
    }

    public EscapeDialog(Frame owner) {
        this(owner, false);
    }

    public EscapeDialog(Frame owner, boolean modal) {
        this(owner, null, modal);
    }

    public EscapeDialog(Frame owner, String title) {
        this(owner, title, false);
    }

    public EscapeDialog(Frame owner, String title, boolean modal) {
        super(owner, title, modal);
    }

    public EscapeDialog(Frame owner, String title, boolean modal, GraphicsConfiguration gc) {
        super(owner, title, modal, gc);
    }

    public EscapeDialog(Dialog owner) {
        this(owner, false);
    }

    public EscapeDialog(Dialog owner, boolean modal) {
        this(owner, null, modal);
    }

    public EscapeDialog(Dialog owner, String title) {
        this(owner, title, false);
    }

    public EscapeDialog(Dialog owner, String title, boolean modal) {
        super(owner, title, modal);
    }

    public EscapeDialog(Dialog owner, String title, boolean modal, GraphicsConfiguration gc) {
        super(owner, title, modal, gc);
    }

    protected JRootPane createRootPane() {
        JRootPane rootPane = new JRootPane();
        KeyStroke stroke = KeyStroke.getKeyStroke("ESCAPE");
        Action actionListener = new AbstractAction() {
            public void actionPerformed(ActionEvent event) {
                setVisible(false);
            }
        };
        InputMap inputMap = rootPane.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
        inputMap.put(stroke, "ESCAPE");
        rootPane.getActionMap().put("ESCAPE", actionListener);

        return rootPane;
    }

}

protected void dialogInit()
protected JRootPane createRootPane()

public JInternalFrame()
JInternalFrame frame = new JInternalFrame();

public JInternalFrame(String title)
JInternalFrame frame = new JInternalFrame("The Title");

public JInternalFrame(String title, boolean resizable)
JInternalFrame frame = new JInternalFrame("The Title", true);

public JInternalFrame(String title, boolean resizable, boolean closable)
JInternalFrame frame = new JInternalFrame("The Title", false, true);

public JInternalFrame(String title, boolean resizable, boolean
  closable, boolean maximizable)
JInternalFrame frame = new JInternalFrame("The Title", true, false, true);

public JInternalFrame(String title, boolean resizable, boolean
  closable, boolean maximizable, boolean iconifiable)
JInternalFrame frame = new JInternalFrame("The Title", false, true, false, true);

try {
  // Try to iconify internal frame
  internalFrame.setIcon(false);
}  catch (PropertyVetoException propertyVetoException) {
  System.out.println("Rejected");
}

package swingstudy.ch08;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;

import javax.swing.JInternalFrame;

public class InternalFramePropertyChangeHandler implements
        PropertyChangeListener {

    @Override
    public void propertyChange(PropertyChangeEvent event) {
        // TODO Auto-generated method stub

        String propertyName = event.getPropertyName();
        if(propertyName.equals(JInternalFrame.IS_ICON_PROPERTY)) {
            System.out.println("Icon property changed. React.");
        }
    }

}

  public interface InternalFrameListener extends EventListener {
  public void internalFrameActivated(InternalFrameEvent internalFrameEvent);
  public void internalFrameClosed(InternalFrameEvent internalFrameEvent);
  public void internalFrameClosing(InternalFrameEvent internalFrameEvent);
  public void internalFrameDeactivated(InternalFrameEvent internalFrameEvent);
  public void internalFrameDeiconified(InternalFrameEvent internalFrameEvent);
  public void internalFrameIconified(InternalFrameEvent internalFrameEvent);
  public void internalFrameOpened(InternalFrameEvent internalFrameEvent);
}

package swingstudy.ch08;

import javax.swing.JInternalFrame;
import javax.swing.event.InternalFrameAdapter;
import javax.swing.event.InternalFrameEvent;

public class InternalFrameIconifyListener extends InternalFrameAdapter {

    public void internalFrameIconified(InternalFrameEvent event) {
        JInternalFrame source = (JInternalFrame)event.getSource();
        System.out.println("Iconified: "+source.getTitle());
    }

    public void internalFrameDeiconified(InternalFrameEvent event) {
        JInternalFrame source = (JInternalFrame)event.getSource();
        System.out.println("Deiconified: "+source.getTitle());
    }
}

JInternalFrame palette = new JInternalFrame("Palette", true, false, true, false);
palette.setBounds(150, 0, 100, 100);
palette.putClientProperty("JInternalFrame.isPalette", Boolean.TRUE);
desktop.add(palette, JDesktopPane.PALETTE_LAYER);

desktop.add(anInternalFrame);

package swingstudy.ch08;

import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.JDesktopPane;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;
import javax.swing.JLabel;
import javax.swing.event.InternalFrameListener;

public class DesktopSample {

    /**
     * @param args
     */
    public static void main(final String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                String title = (args.length==0 ? "Desktop Sample" : args[0]);
                JFrame frame = new JFrame(title);
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                JDesktopPane desktop = new JDesktopPane();
                JInternalFrame internalFrames[] = {
                        new JInternalFrame("Can Do All", true, true, true, true),
                        new JInternalFrame("Not Resizable", false, true, true, true),
                        new JInternalFrame("Not Closable", true, false, true, true),
                        new JInternalFrame("Not Maximizable", true, true, false, true),
                        new JInternalFrame("Not Iconifiable", true, true, true, false)
                };

                InternalFrameListener internalFrameListener = new InternalFrameIconifyListener();

                int pos = 0;
                for(JInternalFrame internalFrame: internalFrames) {
                    // Add to desktop
                    desktop.add(internalFrame);

                    // Position and size
                    internalFrame.setBounds(pos*25, pos*25, 200, 100);
                    pos++;

                    // Add listener for iconification events
                    internalFrame.addInternalFrameListener(internalFrameListener);

                    JLabel label = new JLabel(internalFrame.getTitle(), JLabel.CENTER);
                    internalFrame.add(label, BorderLayout.CENTER);

                    // Make visible
                    internalFrame.setVisible(true);

                }

                JInternalFrame palette = new JInternalFrame("Palette", true, false, true, false);
                palette.setBounds(350, 150, 100, 100);
                palette.putClientProperty("JInternalFrame.isPalette", Boolean.TRUE);
                desktop.add(palette, JDesktopPane.PALETTE_LAYER);
                palette.setVisible(true);

                desktop.setDragMode(JDesktopPane.OUTLINE_DRAG_MODE);

                frame.add(desktop, BorderLayout.CENTER);
                frame.setSize(500, 300);
                frame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

public interface DesktopManager {
  public void activateFrame(JInternalFrame frame);
  public void beginDraggingFrame(JComponent frame);
  public void beginResizingFrame(JComponent frame, int direction);
  public void closeFrame(JInternalFrame frame);
  public void deactivateFrame(JInternalFrame frame);
  public void deiconifyFrame(JInternalFrame frame);
  public void dragFrame(JComponent frame, int newX, int newY);
  public void endDraggingFrame(JComponent frame);
  public void endResizingFrame(JComponent frame);
  public void iconifyFrame(JInternalFrame frame);
  public void maximizeFrame(JInternalFrame frame);
  public void minimizeFrame(JInternalFrame frame);
  public void openFrame(JInternalFrame frame);
  public void resizeFrame(JComponent frame, int newX, int newY, int newWidth,
    int newHeight);
  public void setBoundsForFrame(JComponent frame, int newX, int newY, int newWidth,
    int newHeight);
}

getDesktopPane().getDesktopManager().iconifyFrame(anInternalFrame);

public JOptionPane()
JOptionPane optionPane = new JOptionPane();

public JOptionPane(Object message)
JOptionPane optionPane = new JOptionPane("Printing complete");

public JOptionPane(Object message, int messageType)
JOptionPane optionPane = new JOptionPane("Printer out of paper",
  JOptionPane.WARNING_MESSAGE);

public JOptionPane(Object message, int messageType, int optionType)
JOptionPane optionPane = new JOptionPane("Continue printing?",
  JOptionPane.QUESTION_MESSAGE, JOptionPane.YES_NO_OPTION);

public JOptionPane(Object message, int messageType, int optionType,
  Icon icon)
Icon printerIcon = new ImageIcon("printer.jpg");
JOptionPane optionPane = new JOptionPane("Continue printing?",
  JOptionPane.QUESTION_MESSAGE, JOptionPane.YES_NO_OPTION, printerIcon);

public JOptionPane(Object message, int messageType, int optionType, Icon icon,
  Object options[ ])
Icon greenIcon = new DiamondIcon(Color.GREEN);
Icon redIcon = new DiamondIcon(Color.RED);
Object optionArray[] = new Object[] { greenIcon, redIcon} ;
JOptionPane optionPane = new JOptionPane("Continue printing?",
  JOptionPane.QUESTION_MESSAGE, JOptionPane.YES_NO_OPTION, printerIcon,
  optionArray);

public JOptionPane(Object message, int messageType, int optionType, Icon icon,
  Object options[], Object initialValue)
JOptionPane optionPane = new JOptionPane("Continue printing?",
  JOptionPane.QUESTION_MESSAGE, JOptionPane.YES_NO_OPTION, printerIcon,
  optionArray, redIcon);

public JDialog createDialog(Component parentComponent, String title)
public JInternalFrame createInternalFrame(Component parentComponent, String title)

JOptionPane optionPane = new JOptionPane("Continue printing?",
  JOptionPane.QUESTION_MESSAGE, JOptionPane.YES_NO_OPTION);
JDialog dialog = optionPane.createDialog(source, "Manual Creation");
dialog.setVisible(true);

package swingstudy.ch09;

import javax.swing.JOptionPane;

public final class OptionPaneUtils {

    private OptionPaneUtils() {

    }

    public static int getSelection(JOptionPane optionPane) {
        // Default return value, signals nothing selected
        int returnValue = JOptionPane.CLOSED_OPTION;

        // Get selected value
        Object selectedValue = optionPane.getValue();
        // if none, then nothing selected
        if(selectedValue != null) {
            Object options[] = optionPane.getOptions();
            if(options == null) {
                // default buttons, no array specified
                if(selectedValue instanceof Integer) {
                    returnValue = ((Integer)selectedValue).intValue();
                }
            }
            else {
                // array of option buttons specified
                for(int i=0, n=options.length; i<n; i++) {
                    if(options[i].equals(selectedValue)) {
                        returnValue = i;
                        break; // out of for loop
                    }
                }
            }
        }
        return returnValue;
    }
}

int selection = OptionPaneUtils.getSelection(optionPane);
switch (selection) {
  case ...: ...
    break;
  case ...: ...
    break;
  default: ...
}

public static String showInputDialog(Component parentComponent, Object message, String title, int messageType)

JOptionPane.showConfirmDialog(parent, "Continue printing?");
JOptionPane.showInternalConfirmDialog(desktop, "Continue printing?");

JOptionPane.showInputDialog(parent, "Enter printer name:");
// Moons of Neptune
String smallList[] = {
  "Naiad", "Thalassa", "Despina", "Galatea", "Larissa", "Proteus",
  "Triton", "Nereid"} ;
JOptionPane.showInternalInputDialog(desktop, "Pick a printer", "Input",
  JOptionPane.QUESTION_MESSAGE, null, smallList, "Triton");
// Twenty of the moons of Saturn
String bigList[] = {"Pan", "Atlas", "Prometheus", "Pandora", "Epimetheus",
  "Janus", "Mimas", "Enceladus", "Telesto", "Tethys", "Calypso", "Dione",
  "Helene", "Rhea", "Titan", "Hyperion", "Iapetus", "Phoebe", "Skadi",
  "Mundilfari"};
JOptionPane.showInputDialog(parent, "Pick a printer", "Input",
  JOptionPane.QUESTION_MESSAGE, null, bigList, "Titan");

Icon greenIcon = new DiamondIcon(Color.GREEN);
Icon redIcon = new DiamondIcon(Color.RED);
Object iconArray[] = { greenIcon, redIcon} ;
JOptionPane.showOptionDialog(source, "Continue printing?", "Select an Option",
  JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, iconArray,
  iconArray[1]);
Icon blueIcon = new DiamondIcon(Color.BLUE);
Object stringArray[] = { "Do It", "No Way"} ;
JOptionPane.showInternalOptionDialog(desktop, "Continue printing?",
  "Select an Option", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE,
blueIcon, stringArray, stringArray[0]);

public static JOptionPane getNarrowOptionPane(int maxCharacterPerLineCount) {
    // our inner class definition
    class NarrowOptionPane extends JOptionPane {
        int maxCharacterPerLineCount;

        NarrowOptionPane(int maxCharacterPerLineCount) {
            this.maxCharacterPerLineCount = maxCharacterPerLineCount;
        }

        public int getMaxCharacterPerLineCount() {
            return maxCharacterPerLineCount;
        }
    }
    return new NarrowOptionPane(maxCharacterPerLineCount);
}

String msg = "this is a really long message ... this is a really long message";
JOptionPane optionPane = OptionPaneUtils.getNarrowOptionPane(72);
optionPane.setMessage(msg);
optionPane.setMessageType(JOptionPane.INFORMATION_MESSAGE);
JDialog dialog = optionPane.createDialog(source, "Width 72");
dialog.setVisible(true);

String multiLineMsg[] = { "Hello,", "World"} ;
JOptionPane.showMessageDialog(source, multiLineMsg);

Object complexMsg[] = {
   "Above Message", new DiamondIcon(Color.RED), new JButton("Hello"),
  new JSlider(), new DiamondIcon(Color.BLUE), "Below Message"} ;

public static JSlider getSlider(final JOptionPane optionPane) {
    JSlider slider = new JSlider();
    slider.setMajorTickSpacing(10);
    slider.setPaintTicks(true);
    slider.setPaintLabels(true);
    ChangeListener chageListener =  new ChangeListener() {
        public void stateChanged(ChangeEvent event) {
            JSlider theSlider = (JSlider)event.getSource();
            if(!theSlider.getValueIsAdjusting()) {
                optionPane.setInputValue(new Integer(theSlider.getValue()));
            }
        }
    };
    slider.addChangeListener(chageListener);
    return slider;
}

JOptionPane optionPane = new JOptionPane();
JSlider slider = OptionPaneUtils.getSlider(optionPane);
optionPane.setMessage(new Object[] { "Select a value: " , slider} );
optionPane.setMessageType(JOptionPane.QUESTION_MESSAGE);
optionPane.setOptionType(JOptionPane.OK_CANCEL_OPTION);
JDialog dialog = optionPane.createDialog(source, "My Slider");
dialog.setVisible(true);
System.out.println ("Input: " + optionPane.getInputValue());

public static JButton getButton(final JOptionPane optionPane, String text, Icon icon) {
    final JButton button = new JButton(text, icon);
    ActionListener actionListener = new ActionListener() {
        public void actionPerformed(ActionEvent event) {
            // return current text label, instead of argument to method
            optionPane.setValue(button.getText());
        }
    };
    button.addActionListener(actionListener);
    return button;
}

JOptionPane optionPane = new JOptionPane();
optionPane.setMessage("I got an icon and a text label");
optionPane.setMessageType(JOptionPane.INFORMATION_MESSAGE);
Icon icon = new DiamondIcon (Color.BLUE);
JButton jButton = OptionPaneUtils.getButton(optionPane, "OK", icon);
optionPane.setOptions(new Object[] {jButton} );
JDialog dialog = optionPane.createDialog(source, "Icon/Text Button");
dialog.setVisible(true);

// Set JOptionPane button labels to French
UIManager.put("OptionPane.cancelButtonText", "Annuler");
UIManager.put("OptionPane.noButtonText", "Non");
UIManager.put("OptionPane.okButtonText", "D'accord");
UIManager.put("OptionPane.yesButtonText", "Oui");

int result = JOptionPane.showConfirmDialog(
  aFrame, "Est-ce que vous avez 18 ans ou plus?", "Choisisez une option",
  JOptionPane.YES_NO_CANCEL_OPTION);

public ProgressMonitor(Component parentComponent, Object message, String note,
  int minimum, int maximum)

ProgressMonitor monitor = new ProgressMonitor(
  parent, "Loading Progress", "Getting Started...", 0, 200);

progress += 5;
monitor.setProgress(progress);

monitor.setNote("Loaded " + progress + " files");

if (monitor.isCanceled()) {
// Task canceled - cleanup
  ...
}  else {
// Continue doing task
  ...
}

package swingstudy.ch09;

import java.awt.Component;
import java.awt.EventQueue;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.ProgressMonitor;
import javax.swing.Timer;

public class SampleProgress {

    static ProgressMonitor monitor;
    static int progress;
    static Timer timer;

    static class ProgressMonitorHandler implements ActionListener {
        // Called by Timer
        public void actionPerformed(ActionEvent event) {
            if(monitor == null) {
                return ;
            }
            if(monitor.isCanceled()) {
                System.out.println("Monitor canceled");
                timer.stop();
            }
            else {
                progress += 3;
                monitor.setProgress(progress);
                monitor.setNote("Load "+progress+" files");
            }
        }
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("ProgressMonitor Sample");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setLayout(new GridLayout(0,1));

                // define start button
                JButton startButton = new JButton("Start");
                ActionListener startActionListener = new ActionListener() {
                    public void actionPerformed(ActionEvent event) {
                        Component parent = (Component)event.getSource();
                        monitor = new ProgressMonitor(parent, "Loading Progress", "Getting Started...", 0, 200);
                        progress = 0;
                    }
                };
                startButton.addActionListener(startActionListener);
                frame.add(startButton);

                // define manual increase button
                // pressing this button increases progress by 5
                JButton increaseButton = new JButton("Manual Increase");
                ActionListener increaseActionListener = new ActionListener() {
                    public void actionPerformed(ActionEvent event) {
                        if(monitor == null)
                            return ;
                        if(monitor.isCanceled()) {
                            System.out.println("Monitor cancled");
                        }
                        else {
                            progress += 5;
                            monitor.setProgress(progress);
                            monitor.setNote("Loaded "+progress+" files");
                        }
                    }
                };
                increaseButton.addActionListener(increaseActionListener);
                frame.add(increaseButton);

                // define automatic increase button
                // start timer to increase progress by 3 every 250 ms
                JButton autoIncreaseButton = new JButton("Automatic Increase");
                ActionListener autoIncreaseActionListener = new ActionListener() {
                    public void actionPerformed(ActionEvent event) {
                        if(monitor != null) {
                            if(timer == null) {
                                timer = new Timer(250, new ProgressMonitorHandler());
                            }
                            timer.start();
                        }
                    }
                };
                autoIncreaseButton.addActionListener(autoIncreaseActionListener);
                frame.add(autoIncreaseButton);

                frame.setSize(300, 200);
                frame.setVisible(true);
            }
        };
        EventQueue.invokeLater(runner);
    }

}

public ProgressMonitorInputStream(
  Component parentComponent, Object message, InputStream inputStream)

FileInputStream fis = new FileInputStream(filename);
ProgressMonitorInputStream pmis =
  new ProgressMonitorInputStream(parent, "Reading " + filename, fis);

package swingstudy.ch09;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.InterruptedIOException;

import javax.swing.JLabel;
import javax.swing.ProgressMonitorInputStream;

public class ProgressInputSample {

    public static final int NORMAL = 0;
    public static final int BAD_FILE = 1;
    public static final int CANCELED = NORMAL;
    public static final int PROBLEM = 2;

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        int returnValue = NORMAL;
        if(args.length != 1) {
            System.err.println("Usage:");
            System.err.println("java ProgressInputSample filename");
        }
        else {
            try {
                FileInputStream fis = new FileInputStream(args[0]);
                JLabel filenameLabel = new JLabel(args[0], JLabel.RIGHT);
                Object message[] = {"Reading:", filenameLabel};
                ProgressMonitorInputStream pmis = new ProgressMonitorInputStream(null, message, fis);
                InputStreamReader isr = new InputStreamReader(pmis);
                BufferedReader br = new BufferedReader(isr);
                String line;
                while((line = br.readLine()) != null) {
                    System.out.println(line);
                }
                br.close();
            }
            catch(FileNotFoundException exception) {
                System.err.println("Bad File "+exception);
                returnValue = BAD_FILE;
            }
            catch(InterruptedIOException exception) {
                System.err.println("Canceled");
                returnValue = CANCELED;
            }
            catch(IOException exception) {
                System.err.println("I/O Exception "+exception);
                returnValue = PROBLEM;
            }
        }
        System.exit(returnValue);
    }

}

public JColorChooser()
JColorChooser colorChooser = new JColorChooser();

public JColorChooser(Color initialColor)
JColorChooser colorChooser =
  new JColorChooser(aComponent.getBackground());

public JColorChooser(ColorSelectionModel model)
JColorChooser colorChooser = new JColorChooser(aColorSelectionModel);

package swingstudy.ch09;

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.awt.Font;

import javax.swing.BorderFactory;
import javax.swing.JColorChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;

public class ColorSample {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("JColorChooser Popup");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                final JLabel label = new JLabel("I Love Swing", JLabel.CENTER);
                label.setFont(new Font("Serif", Font.BOLD | Font.ITALIC, 48));
                frame.add(label, BorderLayout.SOUTH);

                final JColorChooser colorChooser = new JColorChooser(label.getBackground());
                colorChooser.setBorder(BorderFactory.createTitledBorder("Pick Foreground Color"));

                frame.add(colorChooser, BorderLayout.CENTER);

                frame.pack();
                frame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

public interface ColorSelectionModel {
  // Listeners
  public void addChangeListener(ChangeListener listener);
  public void removeChangeListener(ChangeListener listener);
  // Properties
  public Color getSelectedColor();
  public void setSelectedColor(Color newValue);
}

ColorSelectionModel model = colorChooser.getSelectionModel();
ChangeListener changeListener = new ChangeListener() {
  public void stateChanged(ChangeEvent changeEvent) {
    Color newForegroundColor = colorChooser.getColor();
    label.setForeground(newForegroundColor);
  }
};
model.addChangeListener(changeListener);

public static Color showDialog(Component parentComponent,
  String title, Color initialColor)

Color initialBackground = button.getBackground();
Color background = JColorChooser.showDialog(
  null, "Change Button Background", initialBackground);
if (background != null) {
  button.setBackground(background);
}

package swingstudy.ch09;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JColorChooser;
import javax.swing.JFrame;

public class ColorSamplePopup {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("JColorChooser Sample Popup");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                final JButton button = new JButton("Pick to Change Background");

                ActionListener actionListener = new ActionListener() {
                    public void actionPerformed(ActionEvent event) {
                        Color initialBackground = button.getBackground();
                        Color background = JColorChooser.showDialog(null, "Change Button Background", initialBackground);
                        if(background != null) {
                            button.setBackground(background);
                        }
                    }
                };

                button.addActionListener(actionListener);

                frame.add(button, BorderLayout.CENTER);

                frame.setSize(300, 100);
                frame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

public static JDialog createDialog(Component parentComponent, String title,
  boolean modal, JColorChooser chooserPane, ActionListener okListener,
  ActionListener cancelListener)

package swingstudy.ch09;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JColorChooser;
import javax.swing.JDialog;
import javax.swing.JFrame;

public class CreateColorSamplePopup {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("JColorChooser Create Popup Sample");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                final JButton button = new JButton("Pick to Change Background");

                ActionListener actionListener = new ActionListener() {
                    public void actionPerformed(ActionEvent event) {
                        Color initialBackground = button.getBackground();

                        final JColorChooser colorChooser = new JColorChooser(initialBackground);

                        // for okay selection, change button background to selected color
                        ActionListener okActionListener = new ActionListener() {
                            public void actionPerformed(ActionEvent event) {
                                Color newColor = colorChooser.getColor();
                                if(newColor.equals(button.getForeground())) {
                                    System.out.println("Color change rejected");
                                }
                                else {
                                    button.setBackground(newColor);
                                }
                            }
                        };

                        // for cancel selection, change button background to red
                        ActionListener cancelActionListener = new ActionListener() {
                            public void actionPerformed(ActionEvent event) {
                                button.setBackground(Color.RED);
                            }
                        };

                        final JDialog dialog = JColorChooser.createDialog(null, "Change Button Background", true, colorChooser, okActionListener, cancelActionListener);

                        // wait for current event dispatching to complete before showing
                        Runnable showDialog = new Runnable() {
                            public void run() {
                                dialog.setVisible(true);
                            }
                        };

                        EventQueue.invokeLater(showDialog);
                    }
                };

                button.addActionListener(actionListener);
                frame.add(button, BorderLayout.CENTER);

                frame.setSize(300, 100);
                frame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

colorChooser.setPreviewPanel(new JPanel());

final JLabel previewLabel = new JLabel("I Love Swing", JLabel.CENTER);
previewLabel.setFont(new Font("Serif", Font.BOLD | Font.ITALIC, 48));
previewLabel.setSize(previewLabel.getPreferredSize());
previewLabel.setBorder(BorderFactory.createEmptyBorder(0,0,1,0));
colorChooser.setPreviewPanel(previewLabel);

public void addChooserPanel(AbstractColorChooserPanel panel)

public AbstractColorChooserPanel removeChooserPanel(AbstractColorChooserPanel panel)

setChooserPanels(AbstractColorChooserPanel panels[ ])

public abstract class AbstractColorChooserPanel extends JPanel {
  public AbstractColorChooserPanel();
  protected abstract void buildChooser();
  protected Color getColorFromModel();
  public ColorSelectionModel getColorSelectionModel();
  public int getDisplayMnemonicIndex();
  public abstract String getDisplayName();
  public abstract Icon getLargeDisplayIcon();
  public int getMnemonic();
  public abstract Icon getSmallDisplayIcon();
  public void installChooserPanel(JColorChooser);
  public void paint(Graphics);
  public void uninstallChooserPanel(JColorChooser);
  public abstract void updateChooser();
}

SystemColorChooserPanel newChooser = new SystemColorChooserPanel();
AbstractColorChooserPanel chooserPanels[] = {newChooser};
colorChooser.setChooserPanels(chooserPanels);

public String getDisplayName() {
  return "SystemColor";
}

public Icon getSmallDisplayIcon() {
  return new DiamondIcon(Color.BLUE);
}
public Icon getLargeDisplayIcon() {
  return new DiamondIcon(Color.GREEN);
}

protected void buildChooser() {
  comboBox = new JComboBox(labels);
  comboBox.addItemListener(this);
  add(comboBox);
}

public void itemStateChanged(ItemEvent itemEvent) {
  int state = itemEvent.getStateChange();
  if (state == ItemEvent.SELECTED) {
    int position = findColorLabel(itemEvent.getItem());
    // Last position is bad (not selectable)
    if ((position != NOT_FOUND) && (position != labels.length-1)) {
      ColorSelectionModel selectionModel = getColorSelectionModel();
      selectionModel.setSelectedColor(colors[position]);
    }
  }
}

public void updateChooser() {
  Color color = getColorFromModel();
  setColor(color);
}

// Change combo box to match color, if possible
private void setColor(Color newColor) {
  int position = findColorPosition(newColor);
  comboBox.setSelectedIndex(position);
}

AbstractColorChooserPanel newChooser = new SystemColorChooserPanel();
colorChooser.addChooserPanel(newChooser);

package swingstudy.ch09;

import java.awt.Color;
import java.awt.SystemColor;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;

import javax.swing.Icon;
import javax.swing.JComboBox;
import javax.swing.colorchooser.AbstractColorChooserPanel;
import javax.swing.colorchooser.ColorSelectionModel;

import swingstudy.ch04.DiamondIcon;

public class SystemColorChooserPanel extends AbstractColorChooserPanel implements ItemListener{

    private static int NOT_FOUND = -1;

    JComboBox comboBox;
    String labels[] = {
        "BLACK",
        "BLUE",
        "CYAN",
        "DARK_GRAY",
        "GRAY",
        "GREEN",
        "LIGHT_GRAY",
        "MAGENTA",
        "ORANGE",
        "PINK",
        "RED",
        "WHITE",
        "YELLOW",
        "activeCaption",
        "activeCaptionBorder",
        "activeCaptionText",
        "control",
        "controlDkShadow",
        "controlHighlight",
                "controlLtHighlight",
        "controlShadow",
        "controlText",
        "desktop",
        "inactiveCaption",
        "inactiveCaptionBorder",
        "inactiveCaptionText",
        "info",
        "infoText",
        "menu",
        "menuText",
        "scrollbar",
        "text",
        "textHighlight",
        "textHighlightText",
        "textInactiveText",
        "textText",
        "window",
        "windowBorder",
        "windowText",
        "<Custom>"
    };

    Color colors[] = {
        Color.BLACK,
        Color.BLUE,
        Color.CYAN,
        Color.DARK_GRAY,
        Color.GRAY,
        Color.GREEN,
        Color.LIGHT_GRAY,
        Color.MAGENTA,
        Color.ORANGE,
        Color.PINK,
        Color.RED,
        Color.WHITE,
        Color.YELLOW,
        SystemColor.activeCaption,
        SystemColor.activeCaptionBorder,
        SystemColor.activeCaptionText,
        SystemColor.control,
        SystemColor.controlDkShadow,
        SystemColor.controlHighlight,
        SystemColor.controlLtHighlight,
        SystemColor.controlShadow,
        SystemColor.controlText,
        SystemColor.desktop,
        SystemColor.inactiveCaption,
        SystemColor.inactiveCaptionBorder,
        SystemColor.inactiveCaptionText,
        SystemColor.info,
        SystemColor.infoText,
        SystemColor.menu,
        SystemColor.menuText,
        SystemColor.scrollbar,
        SystemColor.text,
        SystemColor.textHighlight,
        SystemColor.textHighlightText,
        SystemColor.textInactiveText,
        SystemColor.textText,
        SystemColor.window,
        SystemColor.windowBorder,
        SystemColor.windowText,
        null
    };

    // change combo box to match color, if possible
    private void setColor(Color newColor) {
        int position = findColorPosition(newColor);
        comboBox.setSelectedIndex(position);
    }

    // given a label, find the position of the label in the list
    private int findColorLabel(Object label) {
        String stringLabel = label.toString();
        int position = NOT_FOUND;
        for(int i=0, n=labels.length; i<n; i++) {
            if(stringLabel.equals(labels[i])) {
                position = i;
                break;
            }
        }
        return position;
    }

    // given a color, find the position whose color matches
    // this could result in a position different from original if two are equal
    // since actual color is same, this is considered to be okay
    private int findColorPosition(Color color) {
        int position =  colors.length-1;
        // cannot use equals() to compare Color and SystemColor
        int colorRGB = color.getRGB();
        for(int i=0, n=colors.length; i<n; i++) {
            if((colors[i] != null) && (colorRGB == colors[i].getRGB())) {
                position = i;
                break;
            }
        }
        return position;
    }

    public void itemStateChanged(ItemEvent event) {
        int state = event.getStateChange();
        if(state == event.SELECTED) {
            int position = findColorLabel(event.getItem());
            // last position is bad(not selectable)
            if((position != NOT_FOUND) && (position != labels.length-1)) {
                ColorSelectionModel selectionModel = getColorSelectionModel();
                selectionModel.setSelectedColor(colors[position]);
            }
        }
    }

    public String getDisplayName() {
        return "SystemColor";
    }

    public Icon getSmallDisplayIcon() {
        return new DiamondIcon(Color.BLUE);
    }

    public Icon getLargeDisplayIcon() {
        return new DiamondIcon(Color.GREEN);
    }

    protected void buildChooser() {
        comboBox =  new JComboBox(labels);
        comboBox.addItemListener(this);
        add(comboBox);
    }

    public void updateChooser() {
        Color color = getColorFromModel();
        setColor(color);
    }
}

package swingstudy.ch09;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JColorChooser;
import javax.swing.JDialog;
import javax.swing.JFrame;

public class CustomPanelPopup {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("JColorChooser Custome Panel Sample");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                final JButton button = new JButton("Pick to Change Background");

                ActionListener actionListener = new ActionListener() {
                    public void actionPerformed(ActionEvent event) {
                        Color initialBackground = button.getBackground();

                        final JColorChooser colorChooser = new JColorChooser(initialBackground);
                        SystemColorChooserPanel newChooser = new SystemColorChooserPanel();

                        // AbstractColorchooserPanel chooserPanels[] = {newChooser};
                        // colorChooser.setChooserPanels(chooserPanels);
                        colorChooser.addChooserPanel(newChooser);

                        // for okay button, change button background to selected color
                        ActionListener okActionListener = new ActionListener() {
                            public void actionPerformed(ActionEvent event) {
                                Color newColor = colorChooser.getColor();
                                if(newColor.equals(button.getForeground())) {
                                    System.out.println("Color change rejected");
                                }
                                else {
                                    button.setBackground(newColor);
                                }
                            }
                        };

                        // for cancel button, change button background to red
                        ActionListener cancelActionlistener = new ActionListener() {
                            public void actionPerformed(ActionEvent event) {
                                button.setBackground(Color.RED);
                            }
                        };

                        final JDialog dialog = JColorChooser.createDialog(null, "Change Button Background", true, colorChooser, okActionListener, cancelActionlistener);

                        // wait for current event dispatching to complete before showing
                        Runnable showDialog = new Runnable() {
                            public void run() {
                                dialog.setVisible(true);
                            }
                        };
                        EventQueue.invokeLater(showDialog);
                    }
                };

                button.addActionListener(actionListener);
                frame.add(button, BorderLayout.CENTER);

                frame.setSize(300, 100);
                frame.setVisible(true);
            }
        };
        EventQueue.invokeLater(runner);
    }

}

colorChooser.setPreviewPanel(new JPanel());

public JFileChooser()
JFileChooser fileChooser = new JFileChooser();

public JFileChooser(File currentDirectory)
File currentDirectory = new File("."); // starting directory of program
JFileChooser fileChooser = new JFileChooser(currentDirectory);

public JFileChooser(File currentDirectory, FileSystemView fileSystemView)
FileSystemView fileSystemView = new SomeFileSystemView(...);
JFileChooser fileChooser = new JFileChooser(currentDirectory, fileSystemView);

public JFileChooser(FileSystemView fileSystemView)
JFileChooser fileChooser = new JFileChooser(fileSystemView);

public JFileChooser(String currentDirectoryPath)
String currentDirectoryPath = "."; // starting directory of program
JFileChooser fileChooser = new JFileChooser(currentDirectoryPath);

public JFileChooser(String currentDirectoryPath, FileSystemView fileSystemView)
JFileChooser fileChooser = new JFileChooser(currentDirectoryPath, fileSystemView);

package swingstudy.ch09;

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.awt.Font;

import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;

public class FileSamplePanel {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("JFileChooser Popup");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                final JLabel directoryLabel = new JLabel("");
                directoryLabel.setFont(new Font("Serif", Font.BOLD | Font.ITALIC, 36));
                frame.add(directoryLabel, BorderLayout.NORTH);

                final JLabel filenameLabel = new JLabel("");
                filenameLabel.setFont(new Font("Serif", Font.BOLD | Font.ITALIC, 36));
                frame.add(filenameLabel, BorderLayout.SOUTH);

                JFileChooser fileChooser = new JFileChooser(".");
                fileChooser.setControlButtonsAreShown(false);
                frame.add(fileChooser, BorderLayout.CENTER);

                frame.pack();
                frame.setVisible(true);

            }
        };

        EventQueue.invokeLater(runner);
    }

}

// create ActionListener
ActionListener actionListener = new ActionListener() {
    public void actionPerformed(ActionEvent event) {
        JFileChooser theFileChooser = (JFileChooser)event.getSource();
        String command = event.getActionCommand();
        if(command.equals(JFileChooser.APPROVE_SELECTION)) {
            File selectedFile = theFileChooser.getSelectedFile();
            directoryLabel.setText(selectedFile.getParent());
            filenameLabel.setText(selectedFile.getName());
        }
        else if(command.equals(JFileChooser.CANCEL_SELECTION)) {
            directoryLabel.setText("");
            filenameLabel.setText("");
        }
    }
};

fileChooser.addActionListener(actionListener);

JFileChooser fileChooser = new JFileChooser(".");
int status = fileChooser.showOpenDialog(null);
if (status == JFileChooser.APPROVE_OPTION) {
  File selectedFile = fileChooser.getSelectedFile();
  directoryLabel.setText(selectedFile.getParent());
  filenameLabel.setText(selectedFile.getName());
}  else if (status == JFileChooser.CANCEL_OPTION) {
  directoryLabel.setText(" ");
  filenameLabel.setText(" ");
}

public abstract class FileFilter {
  public FileFilter();
  public abstract String getDescription();
  public abstract boolean accept(File file);
}

package swingstudy.ch09;

import java.io.File;

import javax.swing.filechooser.FileFilter;

public class ExtensionFileFilter extends FileFilter {

    String description;
    String extensions[];

    public ExtensionFileFilter(String description, String extension) {
        this(description, new String[] {extension} );
    }

    public ExtensionFileFilter(String description, String extensions[]) {
        if(description == null) {
            // since no description, use first extension and # of extensions as description
            this.description = extensions[0]+"{ "+extensions.length+"} ";
        }
        else {
            this.description = description;
        }

        // convert array to lowercase
        // don't alter original entries
        this.extensions = (String[])extensions.clone();
        toLower(this.extensions);
    }

    private void toLower(String array[]) {
        for(int i=0, n=array.length; i<n; i++) {
            array[i] = array[i].toLowerCase();
        }
    }

    // ignore case, always accept directories
    // character before extension must be a period
    @Override
    public boolean accept(File file) {
        // TODO Auto-generated method stub
        if(file.isDirectory()) {
            return true;
        }
        else {
            String path = file.getAbsolutePath().toLowerCase();
            for(int i=0, n=extensions.length; i<n; i++) {
                String extension = extensions[i];
                if(path.endsWith(extension) && (path.charAt(path.length()-extension.length()-1)=='.')) {
                    return true;
                }
            }
        }
        return false;
    }

    @Override
    public String getDescription() {
        // TODO Auto-generated method stub
        return description;
    }

}

FileFilter jpegFilter =
  new ExtensionFileFilter(null, new String[]{ "JPG", "JPEG"} );
fileChooser.addChoosableFileFilter(jpegFilter);
FileFilter gifFilter = new ExtensionFileFilter("gif", new String[]{ "gif"} );
fileChooser.addChoosableFileFilter(gifFilter);

aFileChooser.setFileHidingEnabled(false);

fileChooser.setAccessory(new LabelAccessory(fileChooser));

package swingstudy.ch09;

import java.awt.Dimension;
import java.awt.Image;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.File;

import javax.swing.ImageIcon;
import javax.swing.JFileChooser;
import javax.swing.JLabel;

public class LabelAccessory extends JLabel implements PropertyChangeListener {

    private static final int PREFERRED_WIDTH = 125;
    private static final int PREFERRED_HEIGHT = 100;

    public LabelAccessory(JFileChooser chooser) {
        setVerticalAlignment(JLabel.CENTER);
        setHorizontalAlignment(JLabel.CENTER);
        chooser.addPropertyChangeListener(this);
        setPreferredSize(new Dimension(PREFERRED_WIDTH, PREFERRED_HEIGHT));
    }

    @Override
    public void propertyChange(PropertyChangeEvent event) {
        String changeName = event.getPropertyName();
        if(changeName.equals(JFileChooser.SELECTED_FILE_CHANGED_PROPERTY)){
            File file = (File)event.getNewValue();
            if(file != null) {
                ImageIcon icon = new ImageIcon(file.getPath());
                if(icon.getIconWidth() > PREFERRED_WIDTH) {
                    icon = new ImageIcon(icon.getImage().getScaledInstance(PREFERRED_WIDTH, -1, Image.SCALE_DEFAULT));
                    if(icon.getIconHeight() > PREFERRED_HEIGHT) {
                        icon = new ImageIcon(icon.getImage().getScaledInstance(-1, PREFERRED_HEIGHT, Image.SCALE_DEFAULT));
                    }
                }
                setIcon(icon);
            }
        }
    }
}

public abstract class FileSystemView {
  // Constructors
  public FileSystemView();  // Properties
  // Properties
  public File getDefaultDirectory();
  public File getHomeDirectory();
  public File[] getRoots();
  // Class Methods
  public static FileSystemView getFileSystemView();
  // Other Methods
  public File createFileObject(File directory, String filename);
  public File createFileObject(String path);
  protected File createFileSystemRoot(File file);
  public abstract File createNewFolder(File containingDir) throws IOException;
  public File getChild(File parent, String filename);
  public File[] getFiles(File directory, boolean useFileHiding);
  public File getParentDirectory(File file);
  public String getSystemDisplayName(File file);
  public Icon getSystemIcon(File file);
  public String getSystemTypeDescription(File file);
  public boolean isComputerNode(File file);
  public boolean isDrive(File file);
  public boolean isFileSystem(File file);
  public boolean isFileSystemRoot(File file);
  public boolean isFloppyDrive(File file);
  public boolean isHiddenFile(File file);
  public boolean isParent(File folder, File file);
  public boolean isRoot(File file);
  public Boolean isTraversable(File file);
}

public abstract class FileView {
  public FileView();
  public String getDescription(File file);
  public Icon getIcon(File file);
  public String getName(File file);
  public String getTypeDescription(File file);
  public Boolean isTraversable(File file);
}

fileChooser.setFileView(new JavaFileView());

package swingstudy.ch09;

import java.awt.Color;
import java.io.File;

import javax.swing.Icon;
import javax.swing.filechooser.FileView;

import swingstudy.ch04.DiamondIcon;

public class JavaFileView extends FileView {

    Icon javaIcon =new DiamondIcon(Color.BLUE);
    Icon classIcon = new DiamondIcon(Color.GREEN);
    Icon htmlIcon = new DiamondIcon(Color.RED);
    Icon jarIcon = new DiamondIcon(Color.PINK);

    public String getName(File file) {
        String filename = file.getName();
        if(filename.endsWith(".java")) {
            String name = filename +" : "+file.length();
            return name;
        }
        return null;
    }

    public String getTypeDescription(File file) {
        String typeDescription = null;
        String filename = file.getName().toLowerCase();

        if(filename.endsWith(".java")) {
            typeDescription = "Java Source";
        }
        else if(filename.endsWith(".class")) {
            typeDescription = "Java Class File";
        }
        else if(filename.endsWith(".jar")) {
            typeDescription = "Java Archive";
        }
        else if(filename.endsWith(".html") || filename.endsWith(".htm")) {
            typeDescription = "Applet Loader";
        }

        return typeDescription;
    }

    public Icon getIcon(File file) {
        if(file.isDirectory()) {
            return null;
        }
        Icon icon = null;
        String filename = file.getName().toLowerCase();
        if(filename.endsWith(".java")) {
            icon = javaIcon;
        }
        else if(filename.endsWith(".class")) {
            icon = classIcon;
        }
        else if(filename.endsWith(".jar")) {
            icon = jarIcon;
        }
        else if(filename.endsWith(".html") || filename.endsWith(".htm")) {
            icon = htmlIcon;
        }

        return icon;
    }
}

public interface LayoutManager {
  public void addLayoutComponent(String name, Component comp);
  public void layoutContainer(Container parent);
  public Dimension minimumLayoutSize(Container parent);
  public Dimension preferredLayoutSize(Container parent);
  public void removeLayoutComponent(Component comp);
}

public interface LayoutManager2 {
  public void addLayoutComponent(Component comp, Object constraints);
  public float getLayoutAlignmentX(Container target);
  public float getLayoutAlignmentY(Container target);
  public void invalidateLayout(Container target);
  public Dimension maximumLayoutSize(Container target);
}

public GridBagConstraints()
public GridBagConstraints(int gridx, int gridy, int gridwidth, int gridheight,
  double weightx, double weighty, int anchor, int fill, Insets insets, int ipadx,
  int ipady)

JPanel panel = new JPanel();
LayoutManager layout = new BoxLayout (panel, BoxLayout.X_AXIS);
panel.setLayout(layout);

package swingstudy.ch10;

import java.awt.Component;
import java.awt.Container;
import java.awt.EventQueue;
import java.awt.FlowLayout;

import javax.swing.BorderFactory;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class YAxisAlignX {

    private static Container makeIt(String title, float alignment) {
        String labels[] = {"--", "----", "------", "--------"};

        JPanel container = new JPanel();
        container.setBorder(BorderFactory.createTitledBorder(title));
        BoxLayout layout = new BoxLayout(container, BoxLayout.Y_AXIS);
        container.setLayout(layout);

        for(int i=0, n=labels.length; i<n; i++) {
            JButton button = new JButton(labels[i]);
            button.setAlignmentX(alignment);
            container.add(button);
        }
        return container;
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Alignment Example");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                Container panel1 = makeIt("Left", Component.LEFT_ALIGNMENT);
                Container panel2 = makeIt("Center", Component.CENTER_ALIGNMENT);
                Container panel3 = makeIt("Right", Component.RIGHT_ALIGNMENT);

                frame.setLayout(new FlowLayout());
                frame.add(panel1);
                frame.add(panel2);
                frame.add(panel3);

                frame.pack();
                frame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

package swingstudy.ch10;

import java.awt.Component;
import java.awt.Container;
import java.awt.EventQueue;
import java.awt.GridLayout;

import javax.swing.BorderFactory;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class XAxisAlignY {

    private static Container makeIt(String title, float alignment) {
        String labels[] = {"-", "-", "-"};

        JPanel container = new JPanel();
        container.setBorder(BorderFactory.createTitledBorder(title));
        BoxLayout layout = new BoxLayout(container, BoxLayout.X_AXIS);
        container.setLayout(layout);

        for(int i=0, n=labels.length; i<n; i++) {
            JButton button = new JButton(labels[i]);
            button.setAlignmentY(alignment);
            container.add(button);
        }
        return container;
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Alignment Example");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                Container panel1 = makeIt("Top", Component.TOP_ALIGNMENT);
                Container panel2 = makeIt("Center", Component.CENTER_ALIGNMENT);
                Container panel3 = makeIt("Bottom", Component.BOTTOM_ALIGNMENT);

                frame.setLayout(new GridLayout(1,3));
                frame.add(panel1);
                frame.add(panel2);
                frame.add(panel3);

                frame.setSize(423, 171);
                frame.setVisible(true);
            }
        };
        EventQueue.invokeLater(runner);
    }

}

public Box(int direction)
Box horizontalBox = new Box(BoxLayout.X_AXIS);
Box verticalBox   = new Box(BoxLayout.Y_AXIS);
public static Box createHorizontalBox()
Box horizontalBox = Box.createHorizontalBox();
public static Box createVerticalBox()
Box verticalBox   = Box.createVerticalBox();

package swingstudy.ch11;

import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.Box;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;

public class BoxSample {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame verticalFrame = new JFrame("Vertical");
                verticalFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                Box verticalBox = Box.createVerticalBox();
                verticalBox.add(new JLabel("Top"));
                verticalBox.add(new JTextField("Middle"));
                verticalBox.add(new JButton("Bottom"));
                verticalFrame.add(verticalBox, BorderLayout.CENTER);
                verticalFrame.setSize(150, 150);
                verticalFrame.setVisible(true);

                JFrame horizontalFrame = new JFrame("Horizontal");
                horizontalFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                Box horizontalBox = Box.createHorizontalBox();
                horizontalBox.add(new JLabel("Left"));
                horizontalBox.add(new JTextField("Middle"));
                horizontalBox.add(new JButton("Right"));
                horizontalFrame.add(horizontalBox, BorderLayout.CENTER);
                horizontalFrame.setSize(150, 150);
                horizontalFrame.setVisible(true);
            }
        };

        EventQueue.invokeLater(runner);
    }

}

public class Box.Filler extends Component implements Accessible {
  // Constructors
  public Filler(Dimension minSize, Dimension prefSize, Dimension maxSize);
  // Properties
  public AccessibleContext getAccessibleContext();
  public Dimension getMaximumSize();
  public Dimension getMinimumSize();
  public Dimension getPreferredSize();
  // Others
  protected AccessibleContext accessibleContext;
  public void changeShape(Dimension minSize, Dimension prefSize, Dimension maxSize);
}

public static Component createGlue()
// Direction independent
Component glue = Box.createGlue();
aBox.add(glue);
public static Component createHorizontalGlue();
// Direction dependent: horizontal
Component horizontalGlue = Box.createHorizontalGlue();
aBox.add(horizontalGlue);
public static Component createVerticalGlue()
// Direction dependent: vertical
Component verticalGlue  = Box.createVerticalGlue();
aBox.add(verticalGlue);

public static Component createRigidArea(Dimension dimension)
// Two-dimensional
Component rigidArea = Box. createRigidArea(new Dimension(10, 10));
aBox.add(rigidArea);
public static Component createHorizontalStrut(int width)
// One-dimensional: horizontal
Component horizontalStrut = Box. createHorizontalStrut(10);
aBox.add(horizontalStrut);
public static Component createVerticalStrut(int height)
// One-dimensional: vertical
Component verticalStrut   = Box. createVerticalStrut(10);
aBox.add(verticalStrut);

public JSplitPane()
JSplitPane splitPane = new JSplitPane();

public JSplitPane(int newOrientation)
JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);

public JSplitPane(int newOrientation, boolean newContinuousLayout)
JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, true);

public JSplitPane(int newOrientation, Component newLeftComponent,
  Component newRightComponent)
JComponent topComponent = new JButton("Top Button");
JComponent bottomComponent = new JButton("Bottom Button");
JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT,
  topComponent, bottomComponent);

public JSplitPane(int newOrientation, boolean newContinuousLayout,
  Component newLeftComponent, Component newRightComponent)
JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, true,
  topComponent, bottomComponent);

JComponent leftButton = new JButton("Left");
JComponent rightButton = new JButton("Right");
JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
splitPane.setLeftComponent(leftButton);
splitPane.setRightComponent(rightButton);

JComponent topButton = new JButton("Left");
JComponent bottomButton = new JButton("Right");
JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
splitPane.setTopComponent(topButton);
splitPane.setBottomComponent(bottomButton);

HierarchyListener hierarchyListener = new HierarchyListener() {
  public void hierarchyChanged(HierarchyEvent e) {
    long flags = e.getChangeFlags();
    if ((flags & HierarchyEvent.SHOWING_CHANGED) ==
         HierarchyEvent.SHOWING_CHANGED) {
      splitPane.setDividerLocation(.75);
    }
  }
};
splitPane.addHierarchyListener(hierarchyListener);

package swingstudy.ch11;

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;

import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JSplitPane;

import swingstudy.ch04.OvalPanel;

public class PropertySplit {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Property Split");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                // create/configure split pane
                JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
                splitPane.setContinuousLayout(true);
                splitPane.setOneTouchExpandable(true);

                // create top component
                JComponent topComponent = new OvalPanel();
                splitPane.setTopComponent(topComponent);

                // create bottom component
                JComponent bottomComponent = new OvalPanel();
                splitPane.setBottomComponent(bottomComponent);

                // create PropertyChangeListener
                PropertyChangeListener propertyChangeListener = new PropertyChangeListener() {
                    public void propertyChange(PropertyChangeEvent event) {
                        JSplitPane sourceSplitPane = (JSplitPane)event.getSource();
                        String propertyName = event.getPropertyName();
                        if(propertyName.equals(JSplitPane.LAST_DIVIDER_LOCATION_PROPERTY)){
                            int current = sourceSplitPane.getDividerLocation();
                            System.out.println("Current: "+current);
                            Integer last = (Integer)event.getNewValue();
                            System.out.println("Last: "+last);
                            Integer priorLast = (Integer)event.getOldValue();
                            System.out.println("Prior last: "+priorLast);
                        }
                    }
                };
                // attach listener
                splitPane.addPropertyChangeListener(propertyChangeListener);

                frame.add(splitPane, BorderLayout.CENTER);
                frame.setSize(300, 150);
                frame.setVisible(true);
            }
        };
        EventQueue.invokeLater(runner);
    }

}

public JTabbedPane()
JTabbedPane tabbedPane = new JTabbedPane();
public JTabbedPane(int tabPlacement)
JTabbedPane tabbedPane = new JTabbedPane(JTabbedPane.RIGHT);
public JTabbedPane(int tabPlacement, int tabLayoutPolicy)
JTabbedPane tabbedPane =
  new JTabbedPane(JTabbedPane.RIGHT, JTabbedPane.SCROLL_TAB_LAYOUT);

• public void addTab(String title, Component component)
• public void addTab(String title, Icon icon, Component component)
• public void addTab(String title, Icon icon, Component component, String tip)
• public void insertTab(String title, Icon icon, Component component, String tip,
int index)

• public void setTitleAt(int index, String title)
• public void setIconAt(int index, Icon icon)
• public void setMnemonicAt(int index, int mnemonic)
• public void setDisplayedMnemonicIndexAt(int index, int mnemonicIndex)
• public void setToolTipTextAt(int index, String text)
• public void setComponentAt(int index, Component component)

• public void setBackgroundAt(int index, Color background)
• public void setForegroundAt(int index, Color foreground)
• public void setEnabledAt(int index, boolean enabled)
• public void setDisabledIconAt(int index, Icon disabledIcon)

package swingstudy.ch11;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.event.KeyEvent;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTabbedPane;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

import swingstudy.ch04.DiamondIcon;

public class TabSample {

    static Color colors[] = {Color.RED, Color.ORANGE, Color.YELLOW, Color.GREEN, Color.BLUE, Color.MAGENTA};
    static void add(JTabbedPane tabbedPane, String label, int mnemonic) {
        int count = tabbedPane.getTabCount();
        JButton button = new JButton(label);
        button.setBackground(colors[count]);
        tabbedPane.addTab(label, new DiamondIcon(colors[count]), button, label);
        tabbedPane.setMnemonicAt(count, mnemonic);
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Tabbed Pane Sample");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                JTabbedPane tabbedPane = new JTabbedPane();
                tabbedPane.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);
                String titles[] = {"General", "Security", "Content", "Connection", "Programs", "Advanced"};
                int mnemonics[] = {KeyEvent.VK_G, KeyEvent.VK_S, KeyEvent.VK_C, KeyEvent.VK_0, KeyEvent.VK_P, KeyEvent.VK_A};
                for(int i=0, n=titles.length; i<n; i++) {
                    add(tabbedPane, titles[i], mnemonics[i]);
                }

                ChangeListener changeListener = new ChangeListener() {
                    public void stateChanged(ChangeEvent event) {
                        JTabbedPane sourceTabbedPane = (JTabbedPane)event.getSource();
                        int index = sourceTabbedPane.getSelectedIndex();
                        System.out.println("Tab changed to: "+sourceTabbedPane.getTitleAt(index));
                    }
                };
                tabbedPane.addChangeListener(changeListener);

                frame.add(tabbedPane, BorderLayout.CENTER);
                frame.setSize(400, 150);
                frame.setVisible(true);
            }
        };
        EventQueue.invokeLater(runner);
    }

}

public JScrollPane()
JScrollPane scrollPane = new JScrollPane();
public JScrollPane(Component view)
Icon icon = new ImageIcon("largeImage.jpg");
JLabel imageLabel = new JLabel(icon);
JScrollPane scrollPane = new JScrollPane(imageLabel);
public JScrollPane(int verticalScrollBarPolicy, int horizontalScrollBarPolicy)
JScrollPane scrollPane = new
  JScrollPane(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
  JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
public JScrollPane(Component view, int verticalScrollBarPolicy,
  int horizontalScrollBarPolicy)
JScrollPane scrollPane = new JScrollPane(imageLabel,
  JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
  JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);

scrollPane.setViewportView(dogLabel);

scrollPane.getViewport().setView(dogLabel);

JList list = new JList(...);
JScrollPane scrollPane = new JScrollPane(list);
aFrame.add(scrollPane, BorderLayout.CENTER);

public interface Scrollable {
  public Dimension getPreferredScrollableViewportSize();
  public boolean getScrollableTracksViewportHeight();
  public boolean getScrollableTracksViewportWidth();
  public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation,
    int direction);
  public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation,
    int direction);
}

package swingstudy.ch11;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JScrollBar;
import javax.swing.JScrollPane;

public class JScrollPaneToTopAction implements ActionListener {

    JScrollPane scrollPane;

    public JScrollPaneToTopAction(JScrollPane scrollPane) {
        if(scrollPane == null) {
            throw new IllegalArgumentException("JScrollPaneToTopAction: null JScrollPane");
        }
        this.scrollPane = scrollPane;
    }
    @Override
    public void actionPerformed(ActionEvent event) {
        // TODO Auto-generated method stub
        JScrollBar verticalScrollBar = scrollPane.getVerticalScrollBar();
        JScrollBar horizontalScrollBar = scrollPane.getHorizontalScrollBar();
        verticalScrollBar.setValue(verticalScrollBar.getMinimum());
        horizontalScrollBar.setValue(horizontalScrollBar.getMinimum());
    }

}

package swingstudy.ch11;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Point;
import java.awt.event.ActionEvent;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.ActionMap;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.InputMap;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JViewport;
import javax.swing.KeyStroke;

public class MoveViewSample {

    public static final int INCREASE = 0; // direction
    public static final int DECREASE = 1; // direction
    public static final int X_AXIS = 0; // axis
    public static final int Y_AXIS = 1; // axis
    public static final int UNIT = 0;   // type
    public static final int BLOCK = 1;  // type

    static class MoveAction extends AbstractAction {
        JViewport viewport;
        int direction;
        int axis;
        int type;
        public MoveAction(JViewport viewport, int direction, int axis, int type) {
            if(viewport == null) {
                throw new IllegalArgumentException("null viewport not permitted");
            }
            this.viewport = viewport;
            this.direction = direction;
            this.axis = axis;
            this.type = type;
        }

        public void actionPerformed(ActionEvent event) {
            Dimension extentSize = viewport.getExtentSize();
            int horizontalMoveSize = 0;
            int verticalMoveSize = 0;
            if(axis == X_AXIS) {
                if(type == UNIT) {
                    horizontalMoveSize = 1;
                }
                else {
                    // type == BLOCK
                    horizontalMoveSize = extentSize.width;
                }
            }
            else {
                // axis == Y_AXIS
                if(type == UNIT) {
                    verticalMoveSize = 1;
                }
                else {
                    // type = BLOCK
                    verticalMoveSize = extentSize.height;
                }
            }
            if(direction == DECREASE) {
                horizontalMoveSize = -horizontalMoveSize;
                verticalMoveSize = -verticalMoveSize;
            }
            // translate origin by some amount
            Point origin = viewport.getViewPosition();
            origin.x += horizontalMoveSize;
            origin.y += verticalMoveSize;
            // set new viewing origin
            viewport.setViewPosition(origin);
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Runnable runner = new Runnable() {
            public void run() {
                JFrame frame = new JFrame("JViewport Sample");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                Icon icon = new ImageIcon("dog.jpg");
                JLabel dogLabel = new JLabel(icon);
                JViewport viewport =  new JViewport();
                viewport.setView(dogLabel);

                InputMap inputMap = viewport.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
                ActionMap actionMap = viewport.getActionMap();

                // up key moves view up unit
                Action upKeyAction = new MoveAction(viewport, DECREASE, Y_AXIS, UNIT);
                KeyStroke upKey = KeyStroke.getKeyStroke("UP");
                inputMap.put(upKey, "up");
                actionMap.put("up", upKeyAction);

                // down key moves view down unit
                Action downKeyAction = new MoveAction(viewport, INCREASE, Y_AXIS, UNIT);
                KeyStroke downKey = KeyStroke.getKeyStroke("DOWN");
                inputMap.put(downKey, "down");
                actionMap.put("down", downKeyAction);

                // left key moves view left unit
                Action leftKeyAction = new MoveAction(viewport, DECREASE, X_AXIS, UNIT);
                KeyStroke leftKey = KeyStroke.getKeyStroke("LEFT");
                inputMap.put(leftKey, "left");
                actionMap.put("left", leftKeyAction);

                // right key mvoes view right unit
                Action rightKeyAction = new MoveAction(viewport, INCREASE, X_AXIS, UNIT);
                KeyStroke rightKey = KeyStroke.getKeyStroke("RIGHT");
                inputMap.put(rightKey, "right");
                actionMap.put("right", rightKeyAction);

                // pgup key moves view up block
                Action pgUpKeyAction = new MoveAction(viewport, DECREASE, Y_AXIS, BLOCK);
                KeyStroke pgUpKey = KeyStroke.getKeyStroke("PAGE_UP");
                inputMap.put(pgUpKey, "pgUp");
                actionMap.put("pgUp", pgUpKeyAction);

                // pgdn key moves view down block
                Action pgDnKeyAction = new MoveAction(viewport, INCREASE, Y_AXIS, BLOCK);
                KeyStroke pgDnKey = KeyStroke.getKeyStroke("PAGE_DOWN");
                inputMap.put(pgDnKey, "pgDn");
                actionMap.put("pgDn", pgDnKeyAction);

                // shift-pgup key moves view left block
                Action shiftPgUpKeyAction = new MoveAction(viewport, DECREASE, X_AXIS, BLOCK);
                KeyStroke shiftPgUpKey = KeyStroke.getKeyStroke("shift PAGE_UP");
                inputMap.put(shiftPgUpKey, "shiftPgUp");
                actionMap.put("shiftPgUp", shiftPgUpKeyAction);

                // shift-pgdn key moves view right block
                Action shiftPgDnKeyAction = new MoveAction(viewport, INCREASE, X_AXIS, BLOCK);
                KeyStroke shiftPgDnKey = KeyStroke.getKeyStroke("shift PAGE_DOWN");
                inputMap.put(shiftPgDnKey, "shiftPgDn");
                actionMap.put("shiftPgDn", shiftPgDnKeyAction);

                frame.add(viewport, BorderLayout.CENTER);
                frame.setSize(300, 200);
                frame.setVisible(true);
            }
        };
        EventQueue.invokeLater(runner);
    }

}