李清华 201772020113《面向对象程序设计（java）》第十四周学习总结

 1 package calculator;
 2 
 3 import java.awt.*;
 4 import javax.swing.*;
 5 
 6 /**
 7  * @version 1.34 2015-06-12
 8  * @author Cay Horstmann
 9  */
10 public class Calculator
11 {
12    public static void main(String[] args)
13    {
14       EventQueue.invokeLater(() -> {
15          CalculatorFrame frame = new CalculatorFrame();
16          frame.setTitle("Calculator");
17          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
18          frame.setVisible(true);
19       });
20    }
21 }

 1 package calculator;
 2 
 3 import javax.swing.*;
 4 
 5 /**
 6  * 一个带有计算器面板的框架。
 7  */
 8 public class CalculatorFrame extends JFrame
 9 {
10    public CalculatorFrame()
11    {
12       add(new CalculatorPanel());
13       pack();
14    }
15 }

  1 package calculator;
  2 
  3 import java.awt.*;
  4 import java.awt.event.*;
  5 import javax.swing.*;
  6 
  7 /**
  8  * 具有计算器按钮和结果显示的面板。
  9  */
 10 public class CalculatorPanel extends JPanel
 11 {
 12    private JButton display;
 13    private JPanel panel;
 14    private double result;
 15    private String lastCommand;
 16    private boolean start;
 17 
 18    public CalculatorPanel()
 19    {
 20       //为容器设置边框布局管理器
 21       setLayout(new BorderLayout());
 22 
 23       result = 0;
 24       lastCommand = "=";
 25       start = true;
 26 
 27       //  添加页面显示
 28 
 29       display = new JButton("0");
 30       display.setEnabled(false);
 31       add(display, BorderLayout.NORTH);
 32 
 33       ActionListener insert = new InsertAction();
 34       ActionListener command = new CommandAction();
 35 
 36       // 在4×4网格中添加按钮
 37 
 38       panel = new JPanel();
 39       panel.setLayout(new GridLayout(4, 4));
 40 
 41       addButton("7", insert);
 42       addButton("8", insert);
 43       addButton("9", insert);
 44       addButton("/", command);
 45 
 46       addButton("4", insert);
 47       addButton("5", insert);
 48       addButton("6", insert);
 49       addButton("*", command);
 50 
 51       addButton("1", insert);
 52       addButton("2", insert);
 53       addButton("3", insert);
 54       addButton("-", command);
 55 
 56       addButton("0", insert);
 57       addButton(".", insert);
 58       addButton("=", command);
 59       addButton("+", command);
 60 
 61       add(panel, BorderLayout.CENTER);
 62    }
 63 
 64    /**
 65     * 向中心面板添加一个按钮
 66     * @param 标注按钮标签 
 67     * @param 监听器按钮侦听器
 68     */
 69    private void addButton(String label, ActionListener listener)
 70    {
 71       JButton button = new JButton(label);
 72       button.addActionListener(listener);
 73       panel.add(button);
 74    }
 75 
 76    /**
 77     * 此操作将按钮操作字符串插入到显示文本的末尾
 78     */
 79    private class InsertAction implements ActionListener
 80    {
 81       public void actionPerformed(ActionEvent event)
 82       {
 83          String input = event.getActionCommand();
 84          if (start)
 85          {
 86             display.setText("");
 87             start = false;
 88          }
 89          display.setText(display.getText() + input);
 90       }
 91    }
 92 
 93    /**
 94     * 此操作执行按钮操作字符串所表示的命令。
 95     */
 96    private class CommandAction implements ActionListener
 97    {
 98       public void actionPerformed(ActionEvent event)
 99       {
100          String command = event.getActionCommand();
101 
102          //解决了负数的输入，一旦输入“-”号就直接跳转到计算部分
103          if (start)
104          {
105             if (command.equals("-"))
106             {
107                display.setText(command);
108                start = false;
109             }
110             else lastCommand = command;
111          }
112          else
113          {
114             calculate(Double.parseDouble(display.getText()));
115             lastCommand = command;
116             start = true;
117          }
118       }
119    }
120 
121    /**
122      * 执行悬而未决的计算
123     * @param x值与先前结果一起累积。 
124     */
125    public void calculate(double x)
126    {
127       if (lastCommand.equals("+")) result += x;
128       else if (lastCommand.equals("-")) result -= x;
129       else if (lastCommand.equals("*")) result *= x;
130       else if (lastCommand.equals("/")) result /= x;
131       else if (lastCommand.equals("=")) result = x;
132       display.setText("" + result);//将结果转化成字符串显示
133    }
134 }

 1 package text;
 2 
 3 import java.awt.*;
 4 import javax.swing.*;
 5 
 6 /**
 7  * @version 1.41 2015-06-12
 8  * @author Cay Horstmann
 9  */
10 public class TextComponentTest
11 {
12    public static void main(String[] args)
13    {
14       EventQueue.invokeLater(() -> {
15          JFrame frame = new TextComponentFrame();
16          frame.setTitle("TextComponentTest");
17          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
18          frame.setVisible(true);
19       });
20    }
21 }

 1 package text;
 2 
 3 import java.awt.BorderLayout;
 4 import java.awt.GridLayout;
 5 
 6 import javax.swing.JButton;
 7 import javax.swing.JFrame;
 8 import javax.swing.JLabel;
 9 import javax.swing.JPanel;
10 import javax.swing.JPasswordField;
11 import javax.swing.JScrollPane;
12 import javax.swing.JTextArea;
13 import javax.swing.JTextField;
14 import javax.swing.SwingConstants;
15 
16 /**
17  * 具有文本文本组件的框架。
18  */
19 public class TextComponentFrame extends JFrame
20 {
21    public static final int TEXTAREA_ROWS = 8;
22    public static final int TEXTAREA_COLUMNS = 20;
23 
24    public TextComponentFrame()
25    {
26       JTextField textField = new JTextField();
27       JPasswordField passwordField = new JPasswordField();
28 
29       JPanel northPanel = new JPanel();
30       northPanel.setLayout(new GridLayout(2, 2));
31       //SwingConstants通常用于在屏幕上定位或定向组件的常量的集合
32       northPanel.add(new JLabel("User name: ", SwingConstants.RIGHT));
33       northPanel.add(textField);
34       northPanel.add(new JLabel("Password: ", SwingConstants.RIGHT));
35       northPanel.add(passwordField);
36 
37       add(northPanel, BorderLayout.NORTH);
38       //构造一个文本显示区域
39       JTextArea textArea = new JTextArea(TEXTAREA_ROWS, TEXTAREA_COLUMNS);
40       //设置一个只要超过textArea就会显示的滚动条
41       JScrollPane scrollPane = new JScrollPane(textArea);
42 
43       add(scrollPane, BorderLayout.CENTER);
44 
45       // 添加按钮将文本追加到文本区域 
46       JPanel southPanel = new JPanel();
47 
48       JButton insertButton = new JButton("Insert");
49       southPanel.add(insertButton);
50       insertButton.addActionListener(event ->
51          textArea.append("User name: " + textField.getText() + " Password: "
52             + new String(passwordField.getPassword()) + "\n"));
53 
54       add(southPanel, BorderLayout.SOUTH);
55       pack();
56    }
57 }

 1 package checkBox;
 2 
 3 import java.awt.*;
 4 import javax.swing.*;
 5 
 6 /**
 7  * @version 1.34 2015-06-12
 8  * @author Cay Horstmann
 9  */
10 public class CheckBoxTest
11 {
12    public static void main(String[] args)
13    {
14       EventQueue.invokeLater(() -> {
15          JFrame frame = new CheckBoxFrame();
16          frame.setTitle("CheckBoxTest");
17          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
18          frame.setVisible(true);
19       });
20    }
21 }

 1 package checkBox;
 2 
 3 import java.awt.*;
 4 import java.awt.event.*;
 5 import javax.swing.*;
 6 
 7 /**
 8  * 带有样本文本标签的框和用于选择字体的复选框 
 9  * attributes.
10  */
11 public class CheckBoxFrame extends JFrame
12 {
13    private JLabel label;
14    private JCheckBox bold;
15    private JCheckBox italic;
16    private static final int FONTSIZE = 24;
17 
18    public CheckBoxFrame()
19    {
20       // 添加示例文本标签
21 
22       label = new JLabel("The quick brown fox jumps over the lazy dog.");
23       label.setFont(new Font("Serif", Font.BOLD, FONTSIZE));
24       add(label, BorderLayout.CENTER);
25 
26       // 此侦听器设置字体属性 
27       // 到复选框状态的标签
28 
29       ActionListener listener = event -> {
30          int mode = 0;
31          if (bold.isSelected()) mode += Font.BOLD;
32          if (italic.isSelected()) mode += Font.ITALIC;
33          label.setFont(new Font("Serif", mode, FONTSIZE));
34       };
35 
36       // 添加复选框
37 
38       JPanel buttonPanel = new JPanel();
39 
40       bold = new JCheckBox("Bold");
41       bold.addActionListener(listener);
42       bold.setSelected(true);
43       buttonPanel.add(bold);
44 
45       italic = new JCheckBox("Italic");
46       italic.addActionListener(listener);
47       buttonPanel.add(italic);
48 
49       add(buttonPanel, BorderLayout.SOUTH);
50       pack();
51    }
52 }

 1 package radioButton;
 2 
 3 import java.awt.*;
 4 import javax.swing.*;
 5 
 6 /**
 7  * @version 1.34 2015-06-12
 8  * @author Cay Horstmann
 9  */
10 public class RadioButtonTest
11 {
12    public static void main(String[] args)
13    {
14       EventQueue.invokeLater(() -> {
15          JFrame frame = new RadioButtonFrame();
16          frame.setTitle("RadioButtonTest");
17          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
18          frame.setVisible(true);
19       });
20    }
21 }

 1 package radioButton;
 2 
 3 import java.awt.*;
 4 import java.awt.event.*;
 5 import javax.swing.*;
 6 
 7 /**
 8  * 带有样本文本标签和单选按钮以选择字体大小的框架。
 9  */
10 public class RadioButtonFrame extends JFrame
11 {
12    private JPanel buttonPanel;
13    private ButtonGroup group;
14    private JLabel label;
15    private static final int DEFAULT_SIZE = 36;
16 
17    public RadioButtonFrame()
18    {      
19       // 添加示例文本标签。
20 
21       label = new JLabel("The quick brown fox jumps over the lazy dog.");
22       label.setFont(new Font("Serif", Font.PLAIN, DEFAULT_SIZE));
23       add(label, BorderLayout.CENTER);
24 
25       // 添加单选按钮
26       buttonPanel = new JPanel();
27       group = new ButtonGroup();
28 
29       addRadioButton("Small", 8);
30       addRadioButton("Medium", 12);
31       addRadioButton("Large", 18);
32       addRadioButton("Extra large", 36);
33 
34       add(buttonPanel, BorderLayout.SOUTH);
35       pack();
36    }
37 
38    /**
39     * 添加一个设置示例文本字体大小的单选按钮。
40     * @param 命名按钮上出现的字符串
41     * @param 设置此按钮设置的字体大小 
42     */
43    public void addRadioButton(String name, int size)
44    {
45       boolean selected = size == DEFAULT_SIZE;
46       JRadioButton button = new JRadioButton(name, selected);
47       group.add(button);
48       buttonPanel.add(button);
49 
50       // 此侦听器设置标签字体大小。
51 
52       ActionListener listener = event -> label.setFont(new Font("Serif", Font.PLAIN, size));
53 
54       button.addActionListener(listener);
55    }
56 }

 1 package border;
 2 
 3 import java.awt.*;
 4 import javax.swing.*;
 5 
 6 /**
 7  * @version 1.34 2015-06-13
 8  * @author Cay Horstmann
 9  */
10 public class BorderTest
11 {
12    public static void main(String[] args)
13    {
14       EventQueue.invokeLater(() -> {
15          JFrame frame = new BorderFrame();
16          frame.setTitle("BorderTest");
17          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
18          frame.setVisible(true);
19       });
20    }
21 }

 1 package border;
 2 
 3 import java.awt.*;
 4 import javax.swing.*;
 5 import javax.swing.border.*;
 6 
 7 /**
 8  * 用单选按钮选择边框样式的框架。
 9  */
10 public class BorderFrame extends JFrame
11 {
12    private JPanel demoPanel;
13    private JPanel buttonPanel;
14    private ButtonGroup group;
15 
16    public BorderFrame()
17    {
18       demoPanel = new JPanel();
19       buttonPanel = new JPanel();
20       group = new ButtonGroup();
21       //设置不同的边框类型按钮
22       addRadioButton("Lowered bevel", BorderFactory.createLoweredBevelBorder());
23       addRadioButton("Raised bevel", BorderFactory.createRaisedBevelBorder());
24       addRadioButton("Etched", BorderFactory.createEtchedBorder());
25       addRadioButton("Line", BorderFactory.createLineBorder(Color.BLUE));
26       addRadioButton("Matte", BorderFactory.createMatteBorder(10, 10, 10, 10, Color.BLUE));
27       addRadioButton("Empty", BorderFactory.createEmptyBorder());
28 
29       Border etched = BorderFactory.createEtchedBorder();
30       Border titled = BorderFactory.createTitledBorder(etched, "Border types");
31       buttonPanel.setBorder(titled);
32 
33       setLayout(new GridLayout(2, 1));
34       add(buttonPanel);
35       add(demoPanel);
36       pack();
37    }
38 
39    public void addRadioButton(String buttonName, Border b)
40    {
41       JRadioButton button = new JRadioButton(buttonName);
42       button.addActionListener(event -> demoPanel.setBorder(b));
43       group.add(button);
44       buttonPanel.add(button);
45    }
46 }

 1 package comboBox;
 2 
 3 import java.awt.*;
 4 import javax.swing.*;
 5 
 6 /**
 7  * @version 1.35 2015-06-12
 8  * @author Cay Horstmann
 9  */
10 public class ComboBoxTest
11 {
12    public static void main(String[] args)
13    {
14       //lambda表达式
15        EventQueue.invokeLater(() -> {
16          JFrame frame = new ComboBoxFrame();//构造frame框架对象
17          frame.setTitle("ComboBoxTest");//设置标题
18          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置用户在此窗体上发起 "close" 时默认执行的操作。
19          frame.setVisible(true);//设置框架是否可见
20       });
21    }
22 }

 1 package comboBox;
 2 
 3 import java.awt.BorderLayout;
 4 import java.awt.Font;
 5 
 6 import javax.swing.JComboBox;
 7 import javax.swing.JFrame;
 8 import javax.swing.JLabel;
 9 import javax.swing.JPanel;
10 
11 /**
12  * 具有样本文本标签和选择字体面的组合框的框架。
13  * 组合框：将按钮或可编辑字段与下拉列表组合的组件。
14  * 用户可以从下拉列表中选择值，下拉列表在用户请求时显示。
15  * 如果使组合框处于可编辑状态，则组合框将包括用户可在其中键入值的可编辑字段。 
16  */
17 public class ComboBoxFrame extends JFrame
18 {
19     //设置ComboBoxFrame的私有属性
20    private JComboBox<String> faceCombo;
21    private JLabel label;
22    private static final int DEFAULT_SIZE = 24;
23 
24    public ComboBoxFrame()
25    {
26       // 添加示例文本标签
27 
28       label = new JLabel("The quick brown fox jumps over the lazy dog.");
29       //设置字体
30       label.setFont(new Font("Serif", Font.PLAIN, DEFAULT_SIZE));
31       //把字体选择按钮添加到边框布局管理器的中间
32       add(label, BorderLayout.CENTER);
33 
34       // 构造组合框对象并添加项目名称 
35 
36       faceCombo = new JComboBox<>();
37       //把五种字体添加到选项列表中
38       faceCombo.addItem("Serif");
39       faceCombo.addItem("SansSerif");
40       faceCombo.addItem("Monospaced");
41       faceCombo.addItem("Dialog");
42       faceCombo.addItem("DialogInput");
43 
44       //  组合框监听器将标签字体更改为所选的名称（添加监听器，使用lambda表达式）
45 
46       faceCombo.addActionListener(event ->
47       //设置标签的字体
48          label.setFont(
49             //getItemAt用于返回指定索引处的列表项；getSelectedIndex用于返回当前选择的选项
50             new Font(faceCombo.getItemAt(faceCombo.getSelectedIndex()), 
51                Font.PLAIN, DEFAULT_SIZE)));
52 
53       // 将组合框添加到边框边框的面板上
54 
55       JPanel comboPanel = new JPanel();
56       comboPanel.add(faceCombo);
57       add(comboPanel, BorderLayout.SOUTH);
58       pack();
59    }
60 }

 1 package slider;
 2 
 3 import java.awt.*;
 4 import javax.swing.*;
 5 
 6 /**
 7  * @version 1.15 2015-06-12
 8  * @author Cay Horstmann
 9  */
10 public class SliderTest
11 {
12    public static void main(String[] args)
13    {
14       EventQueue.invokeLater(() -> {
15          SliderFrame frame = new SliderFrame();
16          frame.setTitle("SliderTest");
17          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
18          frame.setVisible(true);
19       });
20    }
21 }

  1 package slider;
  2 
  3 import java.awt.*;
  4 import java.util.*;
  5 import javax.swing.*;
  6 import javax.swing.event.*;
  7 
  8 /**
  9  * 一个具有许多滑块和文本字段的滑块值的框架。
 10  */
 11 public class SliderFrame extends JFrame
 12 {
 13    private JPanel sliderPanel;
 14    private JTextField textField;
 15    private ChangeListener listener;
 16 
 17    public SliderFrame()
 18    {
 19       sliderPanel = new JPanel();
 20       sliderPanel.setLayout(new GridBagLayout());
 21 
 22       // 所有滑块的公用侦听器
 23       listener = event -> {
 24          // 当滑块值改变时更新文本字段
 25          JSlider source = (JSlider) event.getSource();
 26          textField.setText("" + source.getValue());
 27       };
 28 
 29       //添加普通滑块
 30 
 31       JSlider slider = new JSlider();
 32       addSlider(slider, "Plain");
 33 
 34       // 添加有主和小蜱的滑块 
 35 
 36       slider = new JSlider();
 37       slider.setPaintTicks(true);
 38       slider.setMajorTickSpacing(20);
 39       slider.setMinorTickSpacing(5);
 40       addSlider(slider, "Ticks");
 41 
 42       // 添加一个滑动到滴答的滑块 
 43 
 44       slider = new JSlider();
 45       slider.setPaintTicks(true);
 46       slider.setSnapToTicks(true);
 47       slider.setMajorTickSpacing(20);
 48       slider.setMinorTickSpacing(5);
 49       addSlider(slider, "Snap to ticks");
 50 
 51       // 添加没有磁道的滑块 
 52 
 53       slider = new JSlider();
 54       slider.setPaintTicks(true);
 55       slider.setMajorTickSpacing(20);
 56       slider.setMinorTickSpacing(5);
 57       slider.setPaintTrack(false);
 58       addSlider(slider, "No track");
 59 
 60       // 添加倒置滑块 
 61 
 62       slider = new JSlider();
 63       slider.setPaintTicks(true);
 64       slider.setMajorTickSpacing(20);
 65       slider.setMinorTickSpacing(5);
 66       slider.setInverted(true);
 67       addSlider(slider, "Inverted");
 68 
 69       // 添加带有数字标签的滑块 
 70 
 71       slider = new JSlider();
 72       slider.setPaintTicks(true);
 73       slider.setPaintLabels(true);
 74       slider.setMajorTickSpacing(20);
 75       slider.setMinorTickSpacing(5);
 76       addSlider(slider, "Labels");
 77 
 78       // 添加带有字母标签的滑块 
 79 
 80       slider = new JSlider();
 81       slider.setPaintLabels(true);
 82       slider.setPaintTicks(true);
 83       slider.setMajorTickSpacing(20);
 84       slider.setMinorTickSpacing(5);
 85 
 86       Dictionary<Integer, Component> labelTable = new Hashtable<>();
 87       labelTable.put(0, new JLabel("A"));
 88       labelTable.put(20, new JLabel("B"));
 89       labelTable.put(40, new JLabel("C"));
 90       labelTable.put(60, new JLabel("D"));
 91       labelTable.put(80, new JLabel("E"));
 92       labelTable.put(100, new JLabel("F"));
 93 
 94       slider.setLabelTable(labelTable);
 95       addSlider(slider, "Custom labels");
 96 
 97       //添加带有图标标签的滑块
 98 
 99       slider = new JSlider();
100       slider.setPaintTicks(true);
101       slider.setPaintLabels(true);
102       slider.setSnapToTicks(true);
103       slider.setMajorTickSpacing(20);
104       slider.setMinorTickSpacing(20);
105 
106       labelTable = new Hashtable<Integer, Component>();
107 
108       // 添加卡片图像 
109 
110       labelTable.put(0, new JLabel(new ImageIcon("nine.gif")));
111       labelTable.put(20, new JLabel(new ImageIcon("ten.gif")));
112       labelTable.put(40, new JLabel(new ImageIcon("jack.gif")));
113       labelTable.put(60, new JLabel(new ImageIcon("queen.gif")));
114       labelTable.put(80, new JLabel(new ImageIcon("king.gif")));
115       labelTable.put(100, new JLabel(new ImageIcon("ace.gif")));
116 
117       slider.setLabelTable(labelTable);
118       addSlider(slider, "Icon labels");
119 
120       // 添加显示滑块值的文本字段
121 
122       textField = new JTextField();
123       add(sliderPanel, BorderLayout.CENTER);
124       add(textField, BorderLayout.SOUTH);
125       pack();
126    }
127 
128    /**
129     * 向滑块面板添加滑块并钩住听者
130     * @param S滑块
131     * @param 描述滑块描述 
132     */
133    public void addSlider(JSlider s, String description)
134    {
135       s.addChangeListener(listener);
136       JPanel panel = new JPanel();
137       panel.add(s);
138       panel.add(new JLabel(description));
139       panel.setAlignmentX(Component.LEFT_ALIGNMENT);
140       GridBagConstraints gbc = new GridBagConstraints();
141       gbc.gridy = sliderPanel.getComponentCount();
142       gbc.anchor = GridBagConstraints.WEST;
143       sliderPanel.add(panel, gbc);
144    }
145 }

 1 package menu;
 2 
 3 import java.awt.*;
 4 import javax.swing.*;
 5 
 6 /**
 7  * @version 1.24 2012-06-12
 8  * @author Cay Horstmann
 9  */
10 public class MenuTest
11 {
12    public static void main(String[] args)
13    {
14       EventQueue.invokeLater(() -> {
15          JFrame frame = new MenuFrame();
16          frame.setTitle("MenuTest");
17          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
18          frame.setVisible(true);
19       });
20    }
21 }

  1 package menu;
  2 
  3 import java.awt.event.*;
  4 import javax.swing.*;
  5 
  6 /**
  7  * 一个带有示例菜单栏的框架。
  8  */
  9 public class MenuFrame extends JFrame
 10 {
 11    private static final int DEFAULT_WIDTH = 300;
 12    private static final int DEFAULT_HEIGHT = 200;
 13    private Action saveAction;
 14    private Action saveAsAction;
 15    private JCheckBoxMenuItem readonlyItem;
 16    private JPopupMenu popup;
 17 
 18    /**
 19     * 将动作名称打印到Studio.OUT的示例动作。
 20     */
 21    class TestAction extends AbstractAction
 22    {
 23       public TestAction(String name)
 24       {
 25          super(name);
 26       }
 27 
 28       public void actionPerformed(ActionEvent event)
 29       {
 30          System.out.println(getValue(Action.NAME) + " selected.");
 31       }
 32    }
 33 
 34    public MenuFrame()
 35    {
 36       setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
 37 
 38       JMenu fileMenu = new JMenu("File");
 39       fileMenu.add(new TestAction("New"));
 40 
 41       //演示加速器
 42 
 43       JMenuItem openItem = fileMenu.add(new TestAction("Open"));
 44       openItem.setAccelerator(KeyStroke.getKeyStroke("ctrl O"));
 45 
 46       fileMenu.addSeparator();
 47 
 48       saveAction = new TestAction("Save");
 49       JMenuItem saveItem = fileMenu.add(saveAction);
 50       saveItem.setAccelerator(KeyStroke.getKeyStroke("ctrl S"));
 51 
 52       saveAsAction = new TestAction("Save As");
 53       fileMenu.add(saveAsAction);
 54       fileMenu.addSeparator();
 55 
 56       fileMenu.add(new AbstractAction("Exit")
 57          {
 58             public void actionPerformed(ActionEvent event)
 59             {
 60                System.exit(0);
 61             }
 62          });
 63 
 64       // 演示复选框和单选按钮菜单 
 65 
 66       readonlyItem = new JCheckBoxMenuItem("Read-only");
 67       readonlyItem.addActionListener(new ActionListener()
 68          {
 69             public void actionPerformed(ActionEvent event)
 70             {
 71                boolean saveOk = !readonlyItem.isSelected();
 72                saveAction.setEnabled(saveOk);
 73                saveAsAction.setEnabled(saveOk);
 74             }
 75          });
 76 
 77       ButtonGroup group = new ButtonGroup();
 78 
 79       JRadioButtonMenuItem insertItem = new JRadioButtonMenuItem("Insert");
 80       insertItem.setSelected(true);
 81       JRadioButtonMenuItem overtypeItem = new JRadioButtonMenuItem("Overtype");
 82 
 83       group.add(insertItem);
 84       group.add(overtypeItem);
 85 
 86       // 演示图标 
 87 
 88       Action cutAction = new TestAction("Cut");
 89       cutAction.putValue(Action.SMALL_ICON, new ImageIcon("cut.gif"));
 90       Action copyAction = new TestAction("Copy");
 91       copyAction.putValue(Action.SMALL_ICON, new ImageIcon("copy.gif"));
 92       Action pasteAction = new TestAction("Paste");
 93       pasteAction.putValue(Action.SMALL_ICON, new ImageIcon("paste.gif"));
 94 
 95       JMenu editMenu = new JMenu("Edit");
 96       editMenu.add(cutAction);
 97       editMenu.add(copyAction);
 98       editMenu.add(pasteAction);
 99 
100       // 演示嵌套菜单 
101 
102       JMenu optionMenu = new JMenu("Options");
103 
104       optionMenu.add(readonlyItem);
105       optionMenu.addSeparator();
106       optionMenu.add(insertItem);
107       optionMenu.add(overtypeItem);
108 
109       editMenu.addSeparator();
110       editMenu.add(optionMenu);
111 
112       // 助记符演示
113 
114       JMenu helpMenu = new JMenu("Help");
115       helpMenu.setMnemonic(‘H‘);
116 
117       JMenuItem indexItem = new JMenuItem("Index");
118       indexItem.setMnemonic(‘I‘);
119       helpMenu.add(indexItem);
120 
121       // 还可以将助记键添加到动作中。
122       Action aboutAction = new TestAction("About");
123       aboutAction.putValue(Action.MNEMONIC_KEY, new Integer(‘A‘));
124       helpMenu.add(aboutAction);
125       
126       //将所有顶级菜单添加到菜单栏
127 
128       JMenuBar menuBar = new JMenuBar();
129       setJMenuBar(menuBar);
130 
131       menuBar.add(fileMenu);
132       menuBar.add(editMenu);
133       menuBar.add(helpMenu);
134 
135       //演示弹出窗口 
136 
137       popup = new JPopupMenu();
138       popup.add(cutAction);
139       popup.add(copyAction);
140       popup.add(pasteAction);
141 
142       JPanel panel = new JPanel();
143       panel.setComponentPopupMenu(popup);
144       add(panel);
145    }
146 }

 1 package toolBar;
 2 
 3 import java.awt.*;
 4 import javax.swing.*;
 5 
 6 /**
 7  * @version 1.14 2015-06-12
 8  * @author Cay Horstmann
 9  */
10 public class ToolBarTest
11 {
12    public static void main(String[] args)
13    {
14       EventQueue.invokeLater(() -> {
15          ToolBarFrame frame = new ToolBarFrame();
16          frame.setTitle("ToolBarTest");
17          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
18          frame.setVisible(true);
19       });
20    }
21 }

 1 package toolBar;
 2 
 3 import java.awt.*;
 4 import java.awt.event.*;
 5 import javax.swing.*;
 6 
 7 /**
 8  * 带有工具栏和菜单的框架，用于颜色变化。
 9  */
10 public class ToolBarFrame extends JFrame
11 {
12    private static final int DEFAULT_WIDTH = 300;
13    private static final int DEFAULT_HEIGHT = 200;
14    private JPanel panel;
15 
16    public ToolBarFrame()
17    {
18       setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
19 
20       // 添加颜色变化面板 
21 
22       panel = new JPanel();
23       add(panel, BorderLayout.CENTER);
24 
25       // 设置动作 
26 
27       Action blueAction = new ColorAction("Blue", new ImageIcon("blue-ball.gif"), Color.BLUE);
28       Action yellowAction = new ColorAction("Yellow", new ImageIcon("yellow-ball.gif"),
29             Color.YELLOW);
30       Action redAction = new ColorAction("Red", new ImageIcon("red-ball.gif"), Color.RED);
31 
32       Action exitAction = new AbstractAction("Exit", new ImageIcon("exit.gif"))
33          {
34             public void actionPerformed(ActionEvent event)
35             {
36                System.exit(0);
37             }
38          };
39       exitAction.putValue(Action.SHORT_DESCRIPTION, "Exit");
40 
41       //填充工具栏 
42 
43       JToolBar bar = new JToolBar();
44       bar.add(blueAction);
45       bar.add(yellowAction);
46       bar.add(redAction);
47       bar.addSeparator();
48       bar.add(exitAction);
49       add(bar, BorderLayout.NORTH);
50 
51       // 填充菜单
52 
53       JMenu menu = new JMenu("Color");
54       menu.add(yellowAction);
55       menu.add(blueAction);
56       menu.add(redAction);
57       menu.add(exitAction);
58       JMenuBar menuBar = new JMenuBar();
59       menuBar.add(menu);
60       setJMenuBar(menuBar);
61    }
62 
63    /**
64     *颜色动作将帧的背景设置为给定的颜色。
65     */
66    class ColorAction extends AbstractAction
67    {
68       public ColorAction(String name, Icon icon, Color c)
69       {
70          putValue(Action.NAME, name);
71          putValue(Action.SMALL_ICON, icon);
72          putValue(Action.SHORT_DESCRIPTION, name + " background");
73          putValue("Color", c);
74       }
75 
76       public void actionPerformed(ActionEvent event)
77       {
78          Color c = (Color) getValue("Color");
79          panel.setBackground(c);
80       }
81    }
82 }

 1 package gridbag;
 2 
 3 import java.awt.EventQueue;
 4 
 5 import javax.swing.JFrame;
 6 
 7 /**
 8  * @version 1.35 2015-06-12
 9  * @author Cay Horstmann
10  */
11 public class GridBagLayoutTest
12 {
13    public static void main(String[] args)
14    {
15       EventQueue.invokeLater(() ->           {
16                JFrame frame = new FontFrame();
17                frame.setTitle("GridBagLayoutTest");
18                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
19                frame.setVisible(true);
20          });
21    }
22 }

 1 package gridbag;
 2 
 3 import java.awt.Font;
 4 import java.awt.GridBagLayout;
 5 import java.awt.event.ActionListener;
 6 
 7 import javax.swing.BorderFactory;
 8 import javax.swing.JCheckBox;
 9 import javax.swing.JComboBox;
10 import javax.swing.JFrame;
11 import javax.swing.JLabel;
12 import javax.swing.JTextArea;
13 
14 /**
15  * A frame that uses a grid bag layout to arrange font selection components.
16  */
17 public class FontFrame extends JFrame
18 {
19    public static final int TEXT_ROWS = 10;
20    public static final int TEXT_COLUMNS = 20;
21 
22    private JComboBox<String> face;
23    private JComboBox<Integer> size;
24    private JCheckBox bold;
25    private JCheckBox italic;
26    private JTextArea sample;
27 
28    public FontFrame()
29    {
30       GridBagLayout layout = new GridBagLayout();
31       setLayout(layout);
32 
33       ActionListener listener = event -> updateSample();
34 
35       // construct components
36 
37       JLabel faceLabel = new JLabel("Face: ");
38 
39       face = new JComboBox<>(new String[] { "Serif", "SansSerif", "Monospaced",
40             "Dialog", "DialogInput" });
41 
42       face.addActionListener(listener);
43 
44       JLabel sizeLabel = new JLabel("Size: ");
45 
46       size = new JComboBox<>(new Integer[] { 8, 10, 12, 15, 18, 24, 36, 48 });
47 
48       size.addActionListener(listener);
49 
50       bold = new JCheckBox("Bold");
51       bold.addActionListener(listener);
52 
53       italic = new JCheckBox("Italic");
54       italic.addActionListener(listener);
55 
56       sample = new JTextArea(TEXT_ROWS, TEXT_COLUMNS);
57       sample.setText("The quick brown fox jumps over the lazy dog");
58       sample.setEditable(false);
59       sample.setLineWrap(true);
60       sample.setBorder(BorderFactory.createEtchedBorder());
61 
62       // add components to grid, using GBC convenience class
63 
64       add(faceLabel, new GBC(0, 0).setAnchor(GBC.EAST));
65       add(face, new GBC(1, 0).setFill(GBC.HORIZONTAL).setWeight(100, 0)
66             .setInsets(1));
67       add(sizeLabel, new GBC(0, 1).setAnchor(GBC.EAST));
68       add(size, new GBC(1, 1).setFill(GBC.HORIZONTAL).setWeight(100, 0)
69             .setInsets(1));
70       add(bold, new GBC(0, 2, 2, 1).setAnchor(GBC.CENTER).setWeight(100, 100));
71       add(italic, new GBC(0, 3, 2, 1).setAnchor(GBC.CENTER).setWeight(100, 100));
72       add(sample, new GBC(2, 0, 1, 4).setFill(GBC.BOTH).setWeight(100, 100));
73       pack();
74       updateSample();
75    }
76 
77    public void updateSample()
78    {
79       String fontFace = (String) face.getSelectedItem();
80       int fontStyle = (bold.isSelected() ? Font.BOLD : 0)
81             + (italic.isSelected() ? Font.ITALIC : 0);
82       int fontSize = size.getItemAt(size.getSelectedIndex());
83       Font font = new Font(fontFace, fontStyle, fontSize);
84       sample.setFont(font);
85       sample.repaint();
86    }
87 }

  1 package gridbag;
  2 
  3 import java.awt.*;
  4 
  5 /**
  6  * This class simplifies the use of the GridBagConstraints class.
  7  * @version 1.01 2004-05-06
  8  * @author Cay Horstmann
  9  */
 10 public class GBC extends GridBagConstraints
 11 {
 12    /**
 13     * Constructs a GBC with a given gridx and gridy position and all other grid
 14     * bag constraint values set to the default.
 15     * @param gridx the gridx position
 16     * @param gridy the gridy position
 17     */
 18    public GBC(int gridx, int gridy)
 19    {
 20       this.gridx = gridx;
 21       this.gridy = gridy;
 22    }
 23 
 24    /**
 25     * Constructs a GBC with given gridx, gridy, gridwidth, gridheight and all
 26     * other grid bag constraint values set to the default.
 27     * @param gridx the gridx position
 28     * @param gridy the gridy position
 29     * @param gridwidth the cell span in x-direction
 30     * @param gridheight the cell span in y-direction
 31     */
 32    public GBC(int gridx, int gridy, int gridwidth, int gridheight)
 33    {
 34       this.gridx = gridx;
 35       this.gridy = gridy;
 36       this.gridwidth = gridwidth;
 37       this.gridheight = gridheight;
 38    }
 39 
 40    /**
 41     * Sets the anchor.
 42     * @param anchor the anchor value
 43     * @return this object for further modification
 44     */
 45    public GBC setAnchor(int anchor)
 46    {
 47       this.anchor = anchor;
 48       return this;
 49    }
 50 
 51    /**
 52     * Sets the fill direction.
 53     * @param fill the fill direction
 54     * @return this object for further modification
 55     */
 56    public GBC setFill(int fill)
 57    {
 58       this.fill = fill;
 59       return this;
 60    }
 61 
 62    /**
 63     * Sets the cell weights.
 64     * @param weightx the cell weight in x-direction
 65     * @param weighty the cell weight in y-direction
 66     * @return this object for further modification
 67     */
 68    public GBC setWeight(double weightx, double weighty)
 69    {
 70       this.weightx = weightx;
 71       this.weighty = weighty;
 72       return this;
 73    }
 74 
 75    /**
 76     * Sets the insets of this cell.
 77     * @param distance the spacing to use in all directions
 78     * @return this object for further modification
 79     */
 80    public GBC setInsets(int distance)
 81    {
 82       this.insets = new Insets(distance, distance, distance, distance);
 83       return this;
 84    }
 85 
 86    /**
 87     * Sets the insets of this cell.
 88     * @param top the spacing to use on top
 89     * @param left the spacing to use to the left
 90     * @param bottom the spacing to use on the bottom
 91     * @param right the spacing to use to the right
 92     * @return this object for further modification
 93     */
 94    public GBC setInsets(int top, int left, int bottom, int right)
 95    {
 96       this.insets = new Insets(top, left, bottom, right);
 97       return this;
 98    }
 99 
100    /**
101     * Sets the internal padding
102     * @param ipadx the internal padding in x-direction
103     * @param ipady the internal padding in y-direction
104     * @return this object for further modification
105     */
106    public GBC setIpad(int ipadx, int ipady)
107    {
108       this.ipadx = ipadx;
109       this.ipady = ipady;
110       return this;
111    }
112 }

 1 package groupLayout;
 2 
 3 import java.awt.EventQueue;
 4 
 5 import javax.swing.JFrame;
 6 
 7 /**
 8  * @version 1.01 2015-06-12
 9  * @author Cay Horstmann
10  */
11 public class GroupLayoutTest
12 {
13    public static void main(String[] args)
14    {
15       EventQueue.invokeLater(() -> {
16          JFrame frame = new FontFrame();
17          frame.setTitle("GroupLayoutTest");
18          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
19          frame.setVisible(true);
20       });
21    }
22 }

  1 package groupLayout;
  2 
  3 import java.awt.Font;
  4 import java.awt.event.ActionListener;
  5 
  6 import javax.swing.BorderFactory;
  7 import javax.swing.GroupLayout;
  8 import javax.swing.JCheckBox;
  9 import javax.swing.JComboBox;
 10 import javax.swing.JFrame;
 11 import javax.swing.JLabel;
 12 import javax.swing.JScrollPane;
 13 import javax.swing.JTextArea;
 14 import javax.swing.LayoutStyle;
 15 import javax.swing.SwingConstants;
 16 
 17 /**
 18  * A frame that uses a group layout to arrange font selection components.
 19  */
 20 public class FontFrame extends JFrame
 21 {
 22    public static final int TEXT_ROWS = 10;
 23    public static final int TEXT_COLUMNS = 20;
 24 
 25    private JComboBox<String> face;
 26    private JComboBox<Integer> size;
 27    private JCheckBox bold;
 28    private JCheckBox italic;
 29    private JScrollPane pane;
 30    private JTextArea sample;
 31 
 32    public FontFrame()
 33    {
 34       ActionListener listener = event -> updateSample(); 
 35 
 36       // construct components
 37 
 38       JLabel faceLabel = new JLabel("Face: ");
 39 
 40       face = new JComboBox<>(new String[] { "Serif", "SansSerif", "Monospaced", "Dialog",
 41             "DialogInput" });
 42 
 43       face.addActionListener(listener);
 44 
 45       JLabel sizeLabel = new JLabel("Size: ");
 46 
 47       size = new JComboBox<>(new Integer[] { 8, 10, 12, 15, 18, 24, 36, 48 });
 48 
 49       size.addActionListener(listener);
 50 
 51       bold = new JCheckBox("Bold");
 52       bold.addActionListener(listener);
 53 
 54       italic = new JCheckBox("Italic");
 55       italic.addActionListener(listener);
 56 
 57       sample = new JTextArea(TEXT_ROWS, TEXT_COLUMNS);
 58       sample.setText("The quick brown fox jumps over the lazy dog");
 59       sample.setEditable(false);
 60       sample.setLineWrap(true);
 61       sample.setBorder(BorderFactory.createEtchedBorder());
 62 
 63       pane = new JScrollPane(sample);
 64 
 65       GroupLayout layout = new GroupLayout(getContentPane());
 66       setLayout(layout);
 67       layout.setHorizontalGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)
 68             .addGroup(
 69                   layout.createSequentialGroup().addContainerGap().addGroup(
 70                         layout.createParallelGroup(GroupLayout.Alignment.LEADING).addGroup(
 71                               GroupLayout.Alignment.TRAILING,
 72                               layout.createSequentialGroup().addGroup(
 73                                     layout.createParallelGroup(GroupLayout.Alignment.TRAILING)
 74                                           .addComponent(faceLabel).addComponent(sizeLabel))
 75                                     .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED)
 76                                     .addGroup(
 77                                           layout.createParallelGroup(
 78                                                 GroupLayout.Alignment.LEADING, false)
 79                                                 .addComponent(size).addComponent(face)))
 80                               .addComponent(italic).addComponent(bold)).addPreferredGap(
 81                         LayoutStyle.ComponentPlacement.RELATED).addComponent(pane)
 82                         .addContainerGap()));
 83 
 84       layout.linkSize(SwingConstants.HORIZONTAL, new java.awt.Component[] { face, size });
 85 
 86       layout.setVerticalGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)
 87             .addGroup(
 88                   layout.createSequentialGroup().addContainerGap().addGroup(
 89                         layout.createParallelGroup(GroupLayout.Alignment.LEADING).addComponent(
 90                               pane, GroupLayout.Alignment.TRAILING).addGroup(
 91                               layout.createSequentialGroup().addGroup(
 92                                     layout.createParallelGroup(GroupLayout.Alignment.BASELINE)
 93                                           .addComponent(face).addComponent(faceLabel))
 94                                     .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED)
 95                                     .addGroup(
 96                                           layout.createParallelGroup(
 97                                                 GroupLayout.Alignment.BASELINE).addComponent(size)
 98                                                 .addComponent(sizeLabel)).addPreferredGap(
 99                                           LayoutStyle.ComponentPlacement.RELATED).addComponent(
100                                           italic, GroupLayout.DEFAULT_SIZE,
101                                           GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
102                                     .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED)
103                                     .addComponent(bold, GroupLayout.DEFAULT_SIZE,
104                                           GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)))
105                         .addContainerGap()));
106       pack();
107    }
108    
109    public void updateSample()
110    {
111       String fontFace = (String) face.getSelectedItem();
112       int fontStyle = (bold.isSelected() ? Font.BOLD : 0)
113             + (italic.isSelected() ? Font.ITALIC : 0);
114       int fontSize = size.getItemAt(size.getSelectedIndex());
115       Font font = new Font(fontFace, fontStyle, fontSize);
116       sample.setFont(font);
117       sample.repaint();
118    }
119 }

 1 package circleLayout;
 2 
 3 import java.awt.*;
 4 import javax.swing.*;
 5 
 6 /**
 7  * @version 1.33 2015-06-12
 8  * @author Cay Horstmann
 9  */
10 public class CircleLayoutTest
11 {
12    public static void main(String[] args)
13    {
14       EventQueue.invokeLater(() -> {
15          JFrame frame = new CircleLayoutFrame();
16          frame.setTitle("CircleLayoutTest");
17          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
18          frame.setVisible(true);
19       });
20    }
21 }

 1 package circleLayout;
 2 
 3 import javax.swing.*;
 4 
 5 /**
 6  * A frame that shows buttons arranged along a circle.
 7  */
 8 public class CircleLayoutFrame extends JFrame
 9 {
10    public CircleLayoutFrame()
11    {
12       setLayout(new CircleLayout());
13       add(new JButton("Yellow"));
14       add(new JButton("Blue"));
15       add(new JButton("Red"));
16       add(new JButton("Green"));
17       add(new JButton("Orange"));
18       add(new JButton("Fuchsia"));
19       add(new JButton("Indigo"));
20       pack();
21    }
22 }

  1 package circleLayout;
  2 
  3 import java.awt.*;
  4 
  5 /**
  6  * A layout manager that lays out components along a circle.
  7  */
  8 public class CircleLayout implements LayoutManager
  9 {
 10    private int minWidth = 0;
 11    private int minHeight = 0;
 12    private int preferredWidth = 0;
 13    private int preferredHeight = 0;
 14    private boolean sizesSet = false;
 15    private int maxComponentWidth = 0;
 16    private int maxComponentHeight = 0;
 17 
 18    public void addLayoutComponent(String name, Component comp)
 19    {
 20    }
 21 
 22    public void removeLayoutComponent(Component comp)
 23    {
 24    }
 25 
 26    public void setSizes(Container parent)
 27    {
 28       if (sizesSet) return;
 29       int n = parent.getComponentCount();
 30 
 31       preferredWidth = 0;
 32       preferredHeight = 0;
 33       minWidth = 0;
 34       minHeight = 0;
 35       maxComponentWidth = 0;
 36       maxComponentHeight = 0;
 37 
 38       // compute the maximum component widths and heights
 39       // and set the preferred size to the sum of the component sizes.
 40       for (int i = 0; i < n; i++)
 41       {
 42          Component c = parent.getComponent(i);
 43          if (c.isVisible())
 44          {
 45             Dimension d = c.getPreferredSize();
 46             maxComponentWidth = Math.max(maxComponentWidth, d.width);
 47             maxComponentHeight = Math.max(maxComponentHeight, d.height);
 48             preferredWidth += d.width;
 49             preferredHeight += d.height;
 50          }
 51       }
 52       minWidth = preferredWidth / 2;
 53       minHeight = preferredHeight / 2;
 54       sizesSet = true;
 55    }
 56 
 57    public Dimension preferredLayoutSize(Container parent)
 58    {
 59       setSizes(parent);
 60       Insets insets = parent.getInsets();
 61       int width = preferredWidth + insets.left + insets.right;
 62       int height = preferredHeight + insets.top + insets.bottom;
 63       return new Dimension(width, height);
 64    }
 65 
 66    public Dimension minimumLayoutSize(Container parent)
 67    {
 68       setSizes(parent);
 69       Insets insets = parent.getInsets();
 70       int width = minWidth + insets.left + insets.right;
 71       int height = minHeight + insets.top + insets.bottom;
 72       return new Dimension(width, height);
 73    }
 74 
 75    public void layoutContainer(Container parent)
 76    {
 77       setSizes(parent);
 78 
 79       // compute center of the circle
 80 
 81       Insets insets = parent.getInsets();
 82       int containerWidth = parent.getSize().width - insets.left - insets.right;
 83       int containerHeight = parent.getSize().height - insets.top - insets.bottom;
 84 
 85       int xcenter = insets.left + containerWidth / 2;
 86       int ycenter = insets.top + containerHeight / 2;
 87 
 88       // compute radius of the circle
 89 
 90       int xradius = (containerWidth - maxComponentWidth) / 2;
 91       int yradius = (containerHeight - maxComponentHeight) / 2;
 92       int radius = Math.min(xradius, yradius);
 93 
 94       // lay out components along the circle
 95 
 96       int n = parent.getComponentCount();
 97       for (int i = 0; i < n; i++)
 98       {
 99          Component c = parent.getComponent(i);
100          if (c.isVisible())
101          {
102             double angle = 2 * Math.PI * i / n;
103 
104             // center point of component
105             int x = xcenter + (int) (Math.cos(angle) * radius);
106             int y = ycenter + (int) (Math.sin(angle) * radius);
107 
108             // move component so that its center is (x, y)
109             // and its size is its preferred size
110             Dimension d = c.getPreferredSize();
111             c.setBounds(x - d.width / 2, y - d.height / 2, d.width, d.height);
112          }
113       }
114    }
115 }

 1 package optionDialog;
 2 
 3 import java.awt.*;
 4 import javax.swing.*;
 5 
 6 /**
 7  * @version 1.34 2015-06-12
 8  * @author Cay Horstmann
 9  */
10 public class OptionDialogTest
11 {
12    public static void main(String[] args)
13    {
14       EventQueue.invokeLater(() -> {
15          JFrame frame = new OptionDialogFrame();
16          frame.setTitle("OptionDialogTest");
17          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
18          frame.setVisible(true);
19       });
20    }
21 }

  1 package optionDialog;
  2 
  3 import java.awt.*;
  4 import java.awt.event.*;
  5 import java.awt.geom.*;
  6 import java.util.*;
  7 import javax.swing.*;
  8 
  9 /**
 10  * A frame that contains settings for selecting various option dialogs.
 11  */
 12 public class OptionDialogFrame extends JFrame
 13 {
 14    private ButtonPanel typePanel;
 15    private ButtonPanel messagePanel;
 16    private ButtonPanel messageTypePanel;
 17    private ButtonPanel optionTypePanel;
 18    private ButtonPanel optionsPanel;
 19    private ButtonPanel inputPanel;
 20    private String messageString = "Message";
 21    private Icon messageIcon = new ImageIcon("blue-ball.gif");
 22    private Object messageObject = new Date();
 23    private Component messageComponent = new SampleComponent();
 24 
 25    public OptionDialogFrame()
 26    {
 27       JPanel gridPanel = new JPanel();
 28       gridPanel.setLayout(new GridLayout(2, 3));
 29 
 30       typePanel = new ButtonPanel("Type", "Message", "Confirm", "Option", "Input");
 31       messageTypePanel = new ButtonPanel("Message Type", "ERROR_MESSAGE", "INFORMATION_MESSAGE",
 32             "WARNING_MESSAGE", "QUESTION_MESSAGE", "PLAIN_MESSAGE");
 33       messagePanel = new ButtonPanel("Message", "String", "Icon", "Component", "Other", 
 34             "Object[]");
 35       optionTypePanel = new ButtonPanel("Confirm", "DEFAULT_OPTION", "YES_NO_OPTION",
 36             "YES_NO_CANCEL_OPTION", "OK_CANCEL_OPTION");
 37       optionsPanel = new ButtonPanel("Option", "String[]", "Icon[]", "Object[]");
 38       inputPanel = new ButtonPanel("Input", "Text field", "Combo box");
 39 
 40       gridPanel.add(typePanel);
 41       gridPanel.add(messageTypePanel);
 42       gridPanel.add(messagePanel);
 43       gridPanel.add(optionTypePanel);
 44       gridPanel.add(optionsPanel);
 45       gridPanel.add(inputPanel);
 46 
 47       // add a panel with a Show button
 48 
 49       JPanel showPanel = new JPanel();
 50       JButton showButton = new JButton("Show");
 51       showButton.addActionListener(new ShowAction());
 52       showPanel.add(showButton);
 53 
 54       add(gridPanel, BorderLayout.CENTER);
 55       add(showPanel, BorderLayout.SOUTH);
 56       pack();
 57    }
 58 
 59    /**
 60     * Gets the currently selected message.
 61     * @return a string, icon, component, or object array, depending on the Message panel selection
 62     */
 63    public Object getMessage()
 64    {
 65       String s = messagePanel.getSelection();
 66       if (s.equals("String")) return messageString;
 67       else if (s.equals("Icon")) return messageIcon;
 68       else if (s.equals("Component")) return messageComponent;
 69       else if (s.equals("Object[]")) return new Object[] { messageString, messageIcon,
 70             messageComponent, messageObject };
 71       else if (s.equals("Other")) return messageObject;
 72       else return null;
 73    }
 74 
 75    /**
 76     * Gets the currently selected options.
 77     * @return an array of strings, icons, or objects, depending on the Option panel selection
 78     */
 79    public Object[] getOptions()
 80    {
 81       String s = optionsPanel.getSelection();
 82       if (s.equals("String[]")) return new String[] { "Yellow", "Blue", "Red" };
 83       else if (s.equals("Icon[]")) return new Icon[] { new ImageIcon("yellow-ball.gif"),
 84             new ImageIcon("blue-ball.gif"), new ImageIcon("red-ball.gif") };
 85       else if (s.equals("Object[]")) return new Object[] { messageString, messageIcon,
 86             messageComponent, messageObject };
 87       else return null;
 88    }
 89 
 90    /**
 91     * Gets the selected message or option type
 92     * @param panel the Message Type or Confirm panel
 93     * @return the selected XXX_MESSAGE or XXX_OPTION constant from the JOptionPane class
 94     */
 95    public int getType(ButtonPanel panel)
 96    {
 97       String s = panel.getSelection();
 98       try
 99       {
100          return JOptionPane.class.getField(s).getInt(null);
101       }
102       catch (Exception e)
103       {
104          return -1;
105       }
106    }
107 
108    /**
109     * The action listener for the Show button shows a Confirm, Input, Message, or Option dialog
110     * depending on the Type panel selection.
111     */
112    private class ShowAction implements ActionListener
113    {
114       public void actionPerformed(ActionEvent event)
115       {
116          if (typePanel.getSelection().equals("Confirm")) JOptionPane.showConfirmDialog(
117                OptionDialogFrame.this, getMessage(), "Title", getType(optionTypePanel),
118                getType(messageTypePanel));
119          else if (typePanel.getSelection().equals("Input"))
120          {
121             if (inputPanel.getSelection().equals("Text field")) JOptionPane.showInputDialog(
122                   OptionDialogFrame.this, getMessage(), "Title", getType(messageTypePanel));
123             else JOptionPane.showInputDialog(OptionDialogFrame.this, getMessage(), "Title",
124                   getType(messageTypePanel), null, new String[] { "Yellow", "Blue", "Red" },
125                   "Blue");
126          }
127          else if (typePanel.getSelection().equals("Message")) JOptionPane.showMessageDialog(
128                OptionDialogFrame.this, getMessage(), "Title", getType(messageTypePanel));
129          else if (typePanel.getSelection().equals("Option")) JOptionPane.showOptionDialog(
130                OptionDialogFrame.this, getMessage(), "Title", getType(optionTypePanel),
131                getType(messageTypePanel), null, getOptions(), getOptions()[0]);
132       }
133    }
134 }
135 
136 /**
137  * A component with a painted surface
138  */
139 
140 class SampleComponent extends JComponent
141 {
142    public void paintComponent(Graphics g)
143    {
144       Graphics2D g2 = (Graphics2D) g;
145       Rectangle2D rect = new Rectangle2D.Double(0, 0, getWidth() - 1, getHeight() - 1);
146       g2.setPaint(Color.YELLOW);
147       g2.fill(rect);
148       g2.setPaint(Color.BLUE);
149       g2.draw(rect);
150    }
151 
152    public Dimension getPreferredSize()
153    {
154       return new Dimension(10, 10);
155    }
156 }

 1 package optionDialog;
 2 
 3 import javax.swing.*;
 4 
 5 /**
 6  * A panel with radio buttons inside a titled border.
 7  */
 8 public class ButtonPanel extends JPanel
 9 {
10    private ButtonGroup group;
11 
12    /**
13     * Constructs a button panel.
14     * @param title the title shown in the border
15     * @param options an array of radio button labels
16     */
17    public ButtonPanel(String title, String... options)
18    {
19       setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(), title));
20       setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
21       group = new ButtonGroup();
22 
23       // make one radio button for each option
24       for (String option : options)
25       {
26          JRadioButton b = new JRadioButton(option);
27          b.setActionCommand(option);
28          add(b);
29          group.add(b);
30          b.setSelected(option == options[0]);
31       }
32    }
33 
34    /**
35     * Gets the currently selected option.
36     * @return the label of the currently selected radio button.
37     */
38    public String getSelection()
39    {
40       return group.getSelection().getActionCommand();
41    }
42 }

 1 package dialog;
 2 
 3 import java.awt.*;
 4 import javax.swing.*;
 5 
 6 /**
 7  * @version 1.34 2012-06-12
 8  * @author Cay Horstmann
 9  */
10 public class DialogTest
11 {
12    public static void main(String[] args)
13    {
14       EventQueue.invokeLater(() -> {
15          JFrame frame = new DialogFrame();
16          frame.setTitle("DialogTest");
17          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
18          frame.setVisible(true);
19       });
20    }
21 }

 1 package dialog;
 2 
 3 import javax.swing.JFrame;
 4 import javax.swing.JMenu;
 5 import javax.swing.JMenuBar;
 6 import javax.swing.JMenuItem;
 7 
 8 /**
 9  * A frame with a menu whose File->About action shows a dialog.
10  */
11 public class DialogFrame extends JFrame
12 {
13    private static final int DEFAULT_WIDTH = 300;
14    private static final int DEFAULT_HEIGHT = 200;
15    private AboutDialog dialog;
16 
17    public DialogFrame()
18    {
19       setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
20 
21       // Construct a File menu.
22 
23       JMenuBar menuBar = new JMenuBar();
24       setJMenuBar(menuBar);
25       JMenu fileMenu = new JMenu("File");
26       menuBar.add(fileMenu);
27 
28       // Add About and Exit menu items.
29 
30       // The About item shows the About dialog.
31 
32       JMenuItem aboutItem = new JMenuItem("About");
33       aboutItem.addActionListener(event -> {
34          if (dialog == null) // first time
35             dialog = new AboutDialog(DialogFrame.this);
36          dialog.setVisible(true); // pop up dialog
37       });
38       fileMenu.add(aboutItem);
39 
40       // The Exit item exits the program.
41 
42       JMenuItem exitItem = new JMenuItem("Exit");
43       exitItem.addActionListener(event -> System.exit(0));
44       fileMenu.add(exitItem);
45    }
46 }

 1 package dialog;
 2 
 3 import java.awt.BorderLayout;
 4 
 5 import javax.swing.JButton;
 6 import javax.swing.JDialog;
 7 import javax.swing.JFrame;
 8 import javax.swing.JLabel;
 9 import javax.swing.JPanel;
10 
11 /**
12  * A sample modal dialog that displays a message and waits for the user to click the OK button.
13  */
14 public class AboutDialog extends JDialog
15 {
16    public AboutDialog(JFrame owner)
17    {
18       super(owner, "About DialogTest", true);
19 
20       // add HTML label to center
21 
22       add(
23             new JLabel(
24                   "<html><h1><i>Core Java</i></h1><hr>By Cay Horstmann</html>"),
25             BorderLayout.CENTER);
26 
27       // OK button closes the dialog
28 
29       JButton ok = new JButton("OK");
30       ok.addActionListener(event -> setVisible(false));
31 
32       // add OK button to southern border
33 
34       JPanel panel = new JPanel();
35       panel.add(ok);
36       add(panel, BorderLayout.SOUTH);
37 
38       pack();
39    }
40 }

 1 package dataExchange;
 2 
 3 import java.awt.*;
 4 import javax.swing.*;
 5 
 6 /**
 7  * @version 1.34 2015-06-12
 8  * @author Cay Horstmann
 9  */
10 public class DataExchangeTest
11 {
12    public static void main(String[] args)
13    {
14       EventQueue.invokeLater(() -> {
15          JFrame frame = new DataExchangeFrame();
16          frame.setTitle("DataExchangeTest");
17          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
18          frame.setVisible(true);
19       });
20    }
21 }

  1 package dataExchange;
  2 
  3 import java.awt.BorderLayout;
  4 import java.awt.Component;
  5 import java.awt.Frame;
  6 import java.awt.GridLayout;
  7 
  8 import javax.swing.JButton;
  9 import javax.swing.JDialog;
 10 import javax.swing.JLabel;
 11 import javax.swing.JPanel;
 12 import javax.swing.JPasswordField;
 13 import javax.swing.JTextField;
 14 import javax.swing.SwingUtilities;
 15 
 16 /**
 17  * A password chooser that is shown inside a dialog
 18  */
 19 public class PasswordChooser extends JPanel
 20 {
 21    private JTextField username;
 22    private JPasswordField password;
 23    private JButton okButton;
 24    private boolean ok;
 25    private JDialog dialog;
 26 
 27    public PasswordChooser()
 28    {
 29       setLayout(new BorderLayout());
 30 
 31       // construct a panel with user name and password fields
 32 
 33       JPanel panel = new JPanel();
 34       panel.setLayout(new GridLayout(2, 2));
 35       panel.add(new JLabel("User name:"));
 36       panel.add(username = new JTextField(""));
 37       panel.add(new JLabel("Password:"));
 38       panel.add(password = new JPasswordField(""));
 39       add(panel, BorderLayout.CENTER);
 40 
 41       // create Ok and Cancel buttons that terminate the dialog
 42 
 43       okButton = new JButton("Ok");
 44       okButton.addActionListener(event -> {
 45          ok = true;
 46          dialog.setVisible(false);
 47       });
 48 
 49       JButton cancelButton = new JButton("Cancel");
 50       cancelButton.addActionListener(event -> dialog.setVisible(false));
 51 
 52       // add buttons to southern border
 53 
 54       JPanel buttonPanel = new JPanel();
 55       buttonPanel.add(okButton);
 56       buttonPanel.add(cancelButton);
 57       add(buttonPanel, BorderLayout.SOUTH);
 58    }
 59 
 60    /**
 61     * Sets the dialog defaults.
 62     * @param u the default user information
 63     */
 64    public void setUser(User u)
 65    {
 66       username.setText(u.getName());
 67    }
 68 
 69    /**
 70     * Gets the dialog entries.
 71     * @return a User object whose state represents the dialog entries
 72     */
 73    public User getUser()
 74    {
 75       return new User(username.getText(), password.getPassword());
 76    }
 77 
 78    /**
 79     * Show the chooser panel in a dialog
 80     * @param parent a component in the owner frame or null
 81     * @param title the dialog window title
 82     */
 83    public boolean showDialog(Component parent, String title)
 84    {
 85       ok = false;
 86 
 87       // locate the owner frame
 88 
 89       Frame owner = null;
 90       if (parent instanceof Frame)
 91          owner = (Frame) parent;
 92       else
 93          owner = (Frame) SwingUtilities.getAncestorOfClass(Frame.class, parent);
 94 
 95       // if first time, or if owner has changed, make new dialog
 96 
 97       if (dialog == null || dialog.getOwner() != owner)
 98       {
 99          dialog = new JDialog(owner, true);
100          dialog.add(this);
101          dialog.getRootPane().setDefaultButton(okButton);
102          dialog.pack();
103       }
104 
105       // set title and show dialog
106 
107       dialog.setTitle(title);
108       dialog.setVisible(true);
109       return ok;
110    }
111 }

 1 package dataExchange;
 2 
 3 import java.awt.*;
 4 import java.awt.event.*;
 5 import javax.swing.*;
 6 
 7 /**
 8  * A frame with a menu whose File->Connect action shows a password dialog.
 9  */
10 public class DataExchangeFrame extends JFrame
11 {
12    public static final int TEXT_ROWS = 20;
13    public static final int TEXT_COLUMNS = 40;
14    private PasswordChooser dialog = null;
15    private JTextArea textArea;
16 
17    public DataExchangeFrame()
18    {
19       // construct a File menu
20 
21       JMenuBar mbar = new JMenuBar();
22       setJMenuBar(mbar);
23       JMenu fileMenu = new JMenu("File");
24       mbar.add(fileMenu);
25 
26       // add Connect and Exit menu items
27 
28       JMenuItem connectItem = new JMenuItem("Connect");
29       connectItem.addActionListener(new ConnectAction());
30       fileMenu.add(connectItem);
31 
32       // The Exit item exits the program
33 
34       JMenuItem exitItem = new JMenuItem("Exit");
35       exitItem.addActionListener(event -> System.exit(0));
36       fileMenu.add(exitItem);
37 
38       textArea = new JTextArea(TEXT_ROWS, TEXT_COLUMNS);
39       add(new JScrollPane(textArea), BorderLayout.CENTER);
40       pack();
41    }
42 
43    /**
44     * The Connect action pops up the password dialog.
45     */
46    private class ConnectAction implements ActionListener
47    {
48       public void actionPerformed(ActionEvent event)
49       {
50          // if first time, construct dialog
51 
52          if (dialog == null) dialog = new PasswordChooser();
53 
54          // set default values
55          dialog.setUser(new User("yourname", null));
56 
57          // pop up dialog
58          if (dialog.showDialog(DataExchangeFrame.this, "Connect"))
59          {
60             // if accepted, retrieve user input
61             User u = dialog.getUser();
62             textArea.append("user name = " + u.getName() + ", password = "
63                   + (new String(u.getPassword())) + "\n");
64          }
65       }
66    }
67 }

 1 package dataExchange;
 2 
 3 /**
 4  * A user has a name and password. For security reasons, the password is stored as a char[], not a
 5  * String.
 6  */
 7 public class User
 8 {
 9    private String name;
10    private char[] password;
11 
12    public User(String aName, char[] aPassword)
13    {
14       name = aName;
15       password = aPassword;
16    }
17 
18    public String getName()
19    {
20       return name;
21    }
22 
23    public char[] getPassword()
24    {
25       return password;
26    }
27 
28    public void setName(String aName)
29    {
30       name = aName;
31    }
32 
33    public void setPassword(char[] aPassword)
34    {
35       password = aPassword;
36    }
37 }

package fileChooser;

import java.awt.*;
import javax.swing.*;

/**
 * @version 1.25 2015-06-12
 * @author Cay Horstmann
 */
public class FileChooserTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         JFrame frame = new ImageViewerFrame();
         frame.setTitle("FileChooserTest");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

package fileChooser;

import java.io.*;
import javax.swing.*;
import javax.swing.filechooser.*;
import javax.swing.filechooser.FileFilter;

/**
 * A file view that displays an icon for all files that match a file filter.
 */
public class FileIconView extends FileView
{
   private FileFilter filter;
   private Icon icon;

   /**
    * Constructs a FileIconView.
    * @param aFilter a file filter--all files that this filter accepts will be shown 
    * with the icon.
    * @param anIcon--the icon shown with all accepted files.
    */
   public FileIconView(FileFilter aFilter, Icon anIcon)
   {
      filter = aFilter;
      icon = anIcon;
   }

   public Icon getIcon(File f)
   {
      if (!f.isDirectory() && filter.accept(f)) return icon;
      else return null;
   }
}

package fileChooser;

import java.awt.*;
import java.io.*;

import javax.swing.*;

/**
 * A file chooser accessory that previews images.
 */
public class ImagePreviewer extends JLabel
{
   /**
    * Constructs an ImagePreviewer.
    * @param chooser the file chooser whose property changes trigger an image
    *        change in this previewer
    */
   public ImagePreviewer(JFileChooser chooser)
   {
      setPreferredSize(new Dimension(100, 100));
      setBorder(BorderFactory.createEtchedBorder());

      chooser.addPropertyChangeListener(event -> {
         if (event.getPropertyName() == JFileChooser.SELECTED_FILE_CHANGED_PROPERTY)
         {
            // the user has selected a new file
            File f = (File) event.getNewValue();
            if (f == null)
            {
               setIcon(null);
               return;
            }

            // read the image into an icon
            ImageIcon icon = new ImageIcon(f.getPath());

            // if the icon is too large to fit, scale it
            if (icon.getIconWidth() > getWidth())
               icon = new ImageIcon(icon.getImage().getScaledInstance(
                     getWidth(), -1, Image.SCALE_DEFAULT));

            setIcon(icon);
         }
      });
   }
}

package fileChooser;

import java.io.*;

import javax.swing.*;
import javax.swing.filechooser.*;
import javax.swing.filechooser.FileFilter;

/**
 * A frame that has a menu for loading an image and a display area for the
 * loaded image.
 */
public class ImageViewerFrame extends JFrame
{
   private static final int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 400;
   private JLabel label;
   private JFileChooser chooser;

   public ImageViewerFrame()
   {
      setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);

      // set up menu bar
      JMenuBar menuBar = new JMenuBar();
      setJMenuBar(menuBar);

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

      JMenuItem openItem = new JMenuItem("Open");
      menu.add(openItem);
      openItem.addActionListener(event -> {
         chooser.setCurrentDirectory(new File("."));

         // show file chooser dialog
            int result = chooser.showOpenDialog(ImageViewerFrame.this);

            // if image file accepted, set it as icon of the label
            if (result == JFileChooser.APPROVE_OPTION)
            {
               String name = chooser.getSelectedFile().getPath();
               label.setIcon(new ImageIcon(name));
               pack();
            }
         });

      JMenuItem exitItem = new JMenuItem("Exit");
      menu.add(exitItem);
      exitItem.addActionListener(event -> System.exit(0));

      // use a label to display the images
      label = new JLabel();
      add(label);

      // set up file chooser
      chooser = new JFileChooser();

      // accept all image files ending with .jpg, .jpeg, .gif
      FileFilter filter = new FileNameExtensionFilter(
            "Image files", "jpg", "jpeg", "gif");
      chooser.setFileFilter(filter);

      chooser.setAccessory(new ImagePreviewer(chooser));

      chooser.setFileView(new FileIconView(filter, new ImageIcon("palette.gif")));
   }
}

package colorChooser;

import java.awt.*;
import javax.swing.*;

/**
 * @version 1.04 2015-06-12
 * @author Cay Horstmann
 */
public class ColorChooserTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         JFrame frame = new ColorChooserFrame();
         frame.setTitle("ColorChooserTest");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

package colorChooser;

import java.awt.Color;
import java.awt.Frame;
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.JPanel;

/**
 * A panel with buttons to pop up three types of color choosers
 */
public class ColorChooserPanel extends JPanel
{
   public ColorChooserPanel()
   {
      JButton modalButton = new JButton("Modal");
      modalButton.addActionListener(new ModalListener());
      add(modalButton);

      JButton modelessButton = new JButton("Modeless");
      modelessButton.addActionListener(new ModelessListener());
      add(modelessButton);

      JButton immediateButton = new JButton("Immediate");
      immediateButton.addActionListener(new ImmediateListener());
      add(immediateButton);
   }

   /**
    * This listener pops up a modal color chooser
    */
   private class ModalListener implements ActionListener
   {
      public void actionPerformed(ActionEvent event)
      {
         Color defaultColor = getBackground();
         Color selected = JColorChooser.showDialog(ColorChooserPanel.this, "Set background",
               defaultColor);
         if (selected != null) setBackground(selected);
      }
   }

   /**
    * This listener pops up a modeless color chooser. The panel color is changed when the user
    * clicks the OK button.
    */
   private class ModelessListener implements ActionListener
   {
      private JDialog dialog;
      private JColorChooser chooser;

      public ModelessListener()
      {
         chooser = new JColorChooser();
         dialog = JColorChooser.createDialog(ColorChooserPanel.this, "Background Color",
               false /* not modal */, chooser, 
               event -> setBackground(chooser.getColor()), 
               null /* no Cancel button listener */);
      }

      public void actionPerformed(ActionEvent event)
      {
         chooser.setColor(getBackground());
         dialog.setVisible(true);
      }
   }

   /**
    * This listener pops up a modeless color chooser. The panel color is changed immediately when
    * the user picks a new color.
    */
   private class ImmediateListener implements ActionListener
   {
      private JDialog dialog;
      private JColorChooser chooser;

      public ImmediateListener()
      {
         chooser = new JColorChooser();
         chooser.getSelectionModel().addChangeListener(
               event -> setBackground(chooser.getColor()));

         dialog = new JDialog((Frame) null, false /* not modal */);
         dialog.add(chooser);
         dialog.pack();
      }

      public void actionPerformed(ActionEvent event)
      {
         chooser.setColor(getBackground());
         dialog.setVisible(true);
      }
   }
}

package colorChooser;

import javax.swing.*;

/**
 * A frame with a color chooser panel
 */
public class ColorChooserFrame extends JFrame
{
   private static final int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 200;

   public ColorChooserFrame()
   {      
      setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);

      // add color chooser panel to frame

      ColorChooserPanel panel = new ColorChooserPanel();
      add(panel);
   }
}