add files

README.md

@@ -1,2 +1,3 @@
 # SwingDemos
 
+Not written by me but useful reference

src/GUIDemo.java

@@ -0,0 +1,116 @@
+import javax.swing.*;    // make the Swing GUI classes available
+import java.awt.*;       // used for Color and GridLayout classes
+import java.awt.event.*; // used for ActionEvent and  ActionListener classes
+
+/**
+ * This simple program demonstrates several GUI components that are available in the
+ * Swing GUI library.  The program shows a window containing a button, a text input
+ * box, a combo box (pop-up menu), and a text area.  The text area is used for
+ * a "transcript" that records interactions of the user with the other components.
+ */
+public class GUIDemo extends JPanel implements ActionListener {
+
+    /**
+     * This main routine allows this class to be run as an application.  The main
+     * routine simply creates a window containing a panel of type GUIDemo.
+     */
+    public static void main(String[] args) {
+        JFrame window = new JFrame("GUI Demo");
+        window.setContentPane( new GUIDemo() );
+        window.pack();
+        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        window.setResizable(false);
+        window.setLocation(150,100);
+        window.setVisible(true);
+    }
+
+    //-----------------------------------------------------------------------------------
+
+    private JTextArea transcript; // a message will be posted to this text area
+                                  // each time an event is generated by some
+                                  // some user action
+    
+    private JComboBox<String> combobox; // The pop-up menu.
+
+    /**
+     * This constructor adds several GUI components to the panel and sets
+     * itself up to listen for action events from some of them.
+     */
+    public GUIDemo() {
+
+        setBorder(BorderFactory.createLineBorder(Color.GRAY, 3));
+        setBackground(Color.WHITE);
+
+        setLayout(new GridLayout(1, 2, 3, 3));
+            // I will put the transcript area in the right half of the
+            // panel. The left half will be occupied by a grid of
+            // four lines. Each line contains a component and
+            // a label for that component.
+
+        transcript = new JTextArea();
+        transcript.setEditable(false);
+        transcript.setMargin(new Insets(4, 4, 4, 4));
+        JPanel left = new JPanel();
+        left.setLayout(new GridLayout(4, 2, 3, 10));
+        left.setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8));
+        add(left);
+        add(new JScrollPane(transcript));
+
+        JLabel lab = new JLabel("Push Button:   ", JLabel.RIGHT);
+        left.add(lab);
+        JButton b = new JButton("Click Me!");
+        b.addActionListener(this);
+        left.add(b);
+
+        lab = new JLabel("Checkbox:   ", JLabel.RIGHT);
+        left.add(lab);
+        JCheckBox c = new JCheckBox("Click me!");
+        c.addActionListener(this);
+        left.add(c);
+
+        lab = new JLabel("Text Field:   ", JLabel.RIGHT);
+        left.add(lab);
+        JTextField t = new JTextField("Type here!");
+        t.addActionListener(this);
+        left.add(t);
+
+        lab = new JLabel("Pop-up Menu:   ", JLabel.RIGHT);
+        left.add(lab);
+        combobox = new JComboBox<String>();
+        combobox.addItem("First Option");
+        combobox.addItem("Second Option");
+        combobox.addItem("Third Option");
+        combobox.addItem("Fourth Option");
+        combobox.addActionListener(this);
+        left.add(combobox);
+
+    }
+
+    private void post(String message) { // add a line to the transcript
+        transcript.append(message + "\n\n");
+    }
+
+    /**
+     * Respond to an ActionEvent from one of the GUI components in the panel.
+     * In each case, a message about the event is posted to the transcript.
+     * (This method is part of the ActionListener interface.)
+     */
+    public void actionPerformed(ActionEvent evt) {
+        Object target = evt.getSource(); // which component produced this event?
+        if (target instanceof JButton) {
+            post("Button was clicked.");
+        } else if (target instanceof JTextField) {
+            post("Pressed return in TextField\nwith contents:\n    "
+                    + evt.getActionCommand());
+        } else if (target instanceof JCheckBox) {
+            if (((JCheckBox) target).isSelected())
+                post("Checkbox was turned on.");
+            else
+                post("Checkbox was turned off.");
+        } else if (target == combobox) {
+            Object item = combobox.getSelectedItem();
+            post("Item \"" + item + "\" selected\nfrom pop-up menu.");
+        }
+    }
+
+} // end class GUIDemo

src/HelloWorldGUI1.java

@@ -0,0 +1,9 @@
+import javax.swing.JOptionPane;
+
+public class HelloWorldGUI1 {
+   
+   public static void main(String[] args) {
+      JOptionPane.showMessageDialog( null, "Hello World!" );
+   }
+
+}

src/HelloWorldGUI2.java

@@ -0,0 +1,40 @@
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+
+public class HelloWorldGUI2 {
+   
+   private static class HelloWorldDisplay extends JPanel {
+      public void paintComponent(Graphics g) {
+         super.paintComponent(g);
+         g.drawString( "Hello World!", 20, 30 );
+      }
+   }
+   
+   private static class ButtonHandler implements ActionListener {
+      public void actionPerformed(ActionEvent e) {
+         System.exit(0);
+      }
+   }
+   
+   public static void main(String[] args) {
+      
+      HelloWorldDisplay displayPanel = new HelloWorldDisplay();
+      JButton okButton = new JButton("OK");
+      ButtonHandler listener = new ButtonHandler();
+      okButton.addActionListener(listener);
+
+      JPanel content = new JPanel();
+      content.setLayout(new BorderLayout());
+      content.add(displayPanel, BorderLayout.CENTER);
+      content.add(okButton, BorderLayout.SOUTH);
+
+      JFrame window = new JFrame("GUI Test");
+      window.setContentPane(content);
+      window.setSize(250,100);
+      window.setLocation(100,100);
+      window.setVisible(true);
+
+   }
+   
+}

src/HelloWorldGUI3.java

@@ -0,0 +1,38 @@
+import java.awt.*;
+import javax.swing.*;
+
+/**
+ *  Create and show a window that displays the message "Hello World",
+ *  with an "OK" button.  The program ends when the user clicks the button.
+ *  The GUI is constructed in the main() routine, which is not the best
+ *  way to do things.  This program is a first example of using GUI components.
+ */
+public class HelloWorldGUI3 {
+
+    private static class HelloWorldDisplay extends JPanel {
+        public void paintComponent(Graphics g) {
+            super.paintComponent(g);
+            g.drawString( "Hello World!", 20, 30 );
+        }
+    }
+
+    public static void main(String[] args) {
+
+        HelloWorldDisplay displayPanel = new HelloWorldDisplay();
+        JButton okButton = new JButton("OK");
+        okButton.addActionListener( e -> System.exit(0) );
+
+        JPanel content = new JPanel();
+        content.setLayout(new BorderLayout());
+        content.add(displayPanel, BorderLayout.CENTER);
+        content.add(okButton, BorderLayout.SOUTH);
+
+        JFrame window = new JFrame("GUI Test");
+        window.setContentPane(content);
+        window.setSize(250,100);
+        window.setLocation(100,100);
+        window.setVisible(true);
+
+    }
+
+}

src/NullLayoutDemo.java

@@ -0,0 +1,155 @@
+
+/**
+ * This program demonstrates how to do your own layout.  The layout
+ * manager for the panel is set to null.  The setBounds() method
+ * of each component is called to set the size and position of the
+ * component.
+ *
+ * It is assumed that the panel is 520 pixels wide and 420 pixels high!
+ * If you want to deal with other sizes, you should implement the
+ * ComponentListener interface, and compute the sizes and positions of 
+ * the components in terms of the actual width and height of the panel
+ * in response to a resize event.
+ */
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+
+public class NullLayoutDemo extends JPanel implements ActionListener {
+
+    /**
+     * Main routine just opens a window that shows a NullLayoutDemo
+     */
+    public static void main(String[] args) {
+        JFrame window = new JFrame("Null Layout Demo");
+        NullLayoutDemo content = new NullLayoutDemo();
+        window.setContentPane(content);
+        window.pack();  // Use preferred size of content to set size of window.
+        window.setResizable(false);  // User can't change the window's size.
+        window.setLocation(100,100);
+        window.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
+        window.setVisible(true);
+    }
+
+    //-------------------------------------------------------------------------
+
+    Checkerboard board;  // A checkerboard.  The Checkerboard class is 
+                         //    nested inside the NullLayoutDemo class.
+
+    JButton resignButton;      // Two buttons.
+    JButton newGameButton;
+
+    JLabel message;   // A label for displaying messages to the user.
+
+    int clickCount;   // Counts how many times the button was clicked.
+
+
+    /**
+     * The constructor sets the layout manager for the panel to be null.
+     * It adds four components to the panel and sets their bounds explicitly.
+     * It is assumed that the panel has a fixed size of 520-by-420 pixels;
+     * it sets the preferred size of the panel to be that size.
+     */
+    public NullLayoutDemo() {
+
+        setLayout(null);  // I will do the layout myself!
+
+        setBackground(new Color(0,120,0));  // A dark green background.
+
+        setBorder( BorderFactory.createEtchedBorder() ); 
+
+        setPreferredSize( new Dimension(520,420) );
+
+        /* Create the components and add them to this panel.  If you
+             don't add them to a container, they won't appear, even if
+             you set their bounds! */
+
+        board = new Checkerboard();
+            // (Checkerboard is a subclass of JPanel, defined below as a static
+            //  nested class inside the main class.)
+        add(board);
+
+        newGameButton = new JButton("New Game");
+        newGameButton.addActionListener(this);
+        add(newGameButton);
+
+        resignButton = new JButton("Resign");
+        resignButton.addActionListener(this);
+        add(resignButton);
+
+        message = new JLabel("Click \"New Game\" to begin.");
+        message.setForeground( new Color(100,255,100) ); // Light green.
+        message.setFont(new Font("Serif", Font.BOLD, 14));
+        add(message);
+
+        /* Set the position and size of each component by calling
+             its setBounds() method. */
+
+        board.setBounds(20,20,324,324);
+        newGameButton.setBounds(370, 120, 120, 30);
+        resignButton.setBounds(370, 200, 120, 30);
+        message.setBounds(20, 370, 380, 30);
+
+    }
+
+
+    /**
+     * Respond to a click on the button by changing the displayed message.
+     * The message tells how many times the button has been clicked.
+     */
+    public void actionPerformed(ActionEvent evt) {
+        String buttonText = evt.getActionCommand();
+        clickCount++;
+        if (clickCount == 1)
+            message.setText("First click:  \"" + buttonText + "\" was clicked.");
+        else
+            message.setText("Click no. " + clickCount + ":  \"" 
+                    + buttonText + "\" was clicked.");
+    }
+
+
+
+    /**
+     * This canvas displays a 320-by-320 checkerboard pattern with
+     * a 2-pixel black border.  It is assumed that the size of the
+     * board is set to exactly 324-by-324 pixels.  This size is 
+     * set as the preferred size of the board.
+     */
+    private static class Checkerboard extends JPanel {
+
+        public Checkerboard() {
+            setPreferredSize( new Dimension(324, 324) );
+        }
+
+        public void paintComponent(Graphics g) {
+
+            // Draw a 2-pixel black border around the edges of the board.
+            // (There is no need to call super.paintComponent() since
+            // this method paints the entire surface of the component.)
+
+            g.setColor(Color.BLACK);
+            g.drawRect(0, 0, getSize().width - 1, getSize().height - 1);
+            g.drawRect(1, 1, getSize().width - 3, getSize().height - 3);
+
+            // Draw  checkerboard pattern in gray and lightGray.
+
+            for (int row = 0; row < 8; row++) {
+                for (int col = 0; col < 8; col++) {
+                    if ( row % 2 == col % 2 )
+                        g.setColor(Color.LIGHT_GRAY);
+                    else
+                        g.setColor(Color.GRAY);
+                    g.fillRect(2 + col*40, 2 + row*40, 40, 40);
+                }
+            }
+        }
+
+    } // end nested class Checkerboard
+
+
+} // end class NullLayoutDemo
+
+
+
+

src/RandomStrings.java

@@ -0,0 +1,15 @@
+import javax.swing.JFrame;
+
+public class RandomStrings {
+    
+    public static void main(String[] args) {
+        JFrame window = new JFrame("Java!");
+        RandomStringsPanel content = new RandomStringsPanel();
+        window.setContentPane(content);
+        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        window.setLocation(120,70);
+        window.setSize(350,250);
+        window.setVisible(true);
+    }
+
+}

src/RandomStringsPanel.java

@@ -0,0 +1,101 @@
+import java.awt.*;
+import javax.swing.JPanel;
+
+/**
+ * This panel displays 25 copies of a message.  The color and 
+ * position of each message is selected at random.  The font
+ * of each message is randomly chosen from among five possible
+ * fonts.  The messages are displayed on a black background.
+ * Note:  The style of drawing used here is poor, because every
+ * time the paintComponent() method is called, new random values are
+ * used.  This means that a different picture will be drawn each time.  
+ */
+public class RandomStringsPanel extends JPanel {
+
+    private String message;  // The message to be displayed.  This can be set in
+                             // the constructor.  If no value is provided in the
+                             // constructor, then the string "Java!" is used.
+
+    private Font font1, font2, font3, font4, font5;  // The five fonts.
+
+    /**
+     * Default constructor creates a panel that displays the message "Java!".
+     */
+    public RandomStringsPanel() {
+        this(null);  // Call the other constructor, with parameter null.
+    }
+
+    /**
+     * Constructor creates a panel to display 25 copies of a specified message.
+     * @param messageString The message to be displayed.  If this is null,
+     * then the default message "Java!" is displayed.
+     */
+    public RandomStringsPanel(String messageString) {
+
+        message = messageString;
+        if (message == null)
+            message = "Java!";
+
+        font1 = new Font("Serif", Font.BOLD, 14);
+        font2 = new Font("SansSerif", Font.BOLD + Font.ITALIC, 24);
+        font3 = new Font("Monospaced", Font.PLAIN, 30);
+        font4 = new Font("Dialog", Font.PLAIN, 36);
+        font5 = new Font("Serif", Font.ITALIC, 48);
+
+        setBackground(Color.BLACK);
+
+    }
+
+    /**
+     * The paintComponent method is responsible for drawing the content of the panel.
+     * It draws 25 copies of the message string, using a random color, font, and
+     * position for each string.
+     */
+    public void paintComponent(Graphics g) {
+
+        super.paintComponent(g);  // Call the paintComponent method from the 
+                                  // superclass, JPanel.  This simply fills the 
+                                  // entire panel with the background color, black.
+        
+        Graphics2D g2 = (Graphics2D)g;  // (To make the text smoother.)
+        g2.setRenderingHint( RenderingHints.KEY_ANTIALIASING, 
+                                RenderingHints.VALUE_ANTIALIAS_ON );
+
+        int width = getWidth();
+        int height = getHeight();
+
+        for (int i = 0; i < 25; i++) {
+
+            // Draw one string.  First, set the font to be one of the five
+            // available fonts, at random.  
+
+            int fontNum = (int)(5*Math.random()) + 1;
+			switch (fontNum) {
+				case 1 -> g.setFont(font1);
+				case 2 -> g.setFont(font2);
+				case 3 -> g.setFont(font3);
+				case 4 -> g.setFont(font4);
+				case 5 -> g.setFont(font5);
+			}
+
+            // Set the color to a bright, saturated color, with random hue.
+
+            float hue = (float)Math.random();
+            g.setColor( Color.getHSBColor(hue, 1.0F, 1.0F) );
+
+            // Select the position of the string, at random.
+
+            int x,y;
+            x = -50 + (int)(Math.random()*(width+40));
+            y = (int)(Math.random()*(height+20));
+
+            // Draw the message.
+
+            g.drawString(message,x,y);
+
+        } // end for
+
+    } // end paintComponent()
+
+
+}  // end class RandomStringsPanel

src/SimpleCalc.java

@@ -0,0 +1,179 @@
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+
+/**
+ * In this program, the user can type in two real numbers.  The
+ * user can click on buttons labeled +, - , *, and / to perform
+ * basic arithmetic operations on the numbers.  When the user
+ * clicks on a button the answer is displayed. 
+ * This class also contains a main() routine, so that
+ * it can be run as a stand-alone application.
+ */
+public class SimpleCalc extends JPanel implements ActionListener {
+
+    /**
+     * This main() routine makes it possible to run the SimpleCalc class
+     * as a stand-alone application. 
+     */
+    public static void main(String[] args) {
+        JFrame window = new JFrame("Simple Calculator");
+        SimpleCalc content = new SimpleCalc();
+        window.setContentPane(content);
+        window.pack();  // Sizes window to preferred size of contents.
+        window.setLocation(100,100);
+        window.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
+        window.setVisible(true);
+    }
+
+    //-------------------------------------------------------------------------
+
+
+    private JTextField xInput, yInput;  // Input boxes for the numbers.
+
+    private JLabel answer;  // JLabel for displaying the answer, or an 
+                            //    error message if appropriate.
+
+
+    public SimpleCalc() {
+
+        /* Assign a background color to the panel and its
+             content panel.  This color will show through in the gaps
+             between components. */
+
+        setBackground(Color.GRAY);
+
+        /* Add an empty border around the panel, which will also
+         * appear in the gray background color. */
+
+        setBorder( BorderFactory.createEmptyBorder(5,5,5,5) );
+
+        /* Create the input boxes, and make sure that the background
+             color is white.  (They are likely to be white by default.) */
+
+        xInput = new JTextField("0", 10);
+        xInput.setBackground(Color.WHITE);
+        yInput = new JTextField("0", 10);
+        yInput.setBackground(Color.WHITE);
+
+        /* Create panels to hold the input boxes and labels "x =" and
+             "y = ".  These panels use the default FlowLayout layout manager. */
+
+        JPanel xPanel = new JPanel();
+        xPanel.add( new JLabel(" x = "));
+        xPanel.add(xInput);
+
+        JPanel yPanel = new JPanel();
+        yPanel.add( new JLabel(" y = "));
+        yPanel.add(yInput);
+
+        /* Create a panel to hold the four buttons for the four
+             operations.  A GridLayout is used so that the buttons
+             will all have the same size and will fill the panel. 
+             The main panel serves as ActionListener for the buttons. */
+
+        JPanel buttonPanel = new JPanel();
+        buttonPanel.setLayout(new GridLayout(1,4));
+
+        JButton plus = new JButton("+");
+        plus.addActionListener(this);
+        buttonPanel.add(plus);
+
+        JButton minus = new JButton("-");
+        minus.addActionListener(this);
+        buttonPanel.add(minus);
+
+        JButton times = new JButton("*");
+        times.addActionListener(this);
+        buttonPanel.add(times);
+
+        JButton divide = new JButton("/");
+        divide.addActionListener(this);
+        buttonPanel.add(divide);
+
+        /* Create the label for displaying the answer in red
+             on a white background.  The label is set to be
+             "opaque" to make sure that the white background
+             is painted. */
+
+        answer = new JLabel("x + y = 0", JLabel.CENTER);
+        answer.setForeground(Color.RED);
+        answer.setBackground(Color.WHITE);
+        answer.setOpaque(true);
+
+        /* Set up the layout for the main panel, using a GridLayout,
+             and add all the components that have been created. */
+
+        setLayout(new GridLayout(4,1,3,3));
+        add(xPanel);
+        add(yPanel);
+        add(buttonPanel);
+        add(answer);
+
+    }  // end constructor
+
+
+    /**
+     * When the user clicks a button, get the numbers from the input boxes 
+     * and perform the operation indicated by the button.  Put the result in
+     * the answer label.  If an error occurs, an error message is put in the label.
+     */
+    public void actionPerformed(ActionEvent evt) {
+
+        double x, y;  // The numbers from the input boxes.
+
+        /* Get a number from the xInput JTextField.  Use 
+             xInput.getText() to get its contents as a String.
+             Convert this String to a double.  The try...catch
+             statement will check for errors in the String.  If 
+             the string is not a legal number, the error message
+             "Illegal data for x." is put into the answer and
+             the actionPerformed() method ends. */
+
+        try {
+            String xStr = xInput.getText();
+            x = Double.parseDouble(xStr);
+        }
+        catch (NumberFormatException e) {
+                // The string xStr is not a legal number.
+            answer.setText("Illegal data for x.");
+            xInput.requestFocusInWindow();
+            return;
+        }
+
+        /* Get a number from yInput in the same way. */
+
+        try {
+            String yStr = yInput.getText();
+            y = Double.parseDouble(yStr);
+        }
+        catch (NumberFormatException e) {
+            answer.setText("Illegal data for y.");
+            yInput.requestFocusInWindow();
+            return;
+        }
+
+        /* Perform the operation based on the action command
+             from the button.  Note that division by zero produces
+             an error message. */
+
+        String op = evt.getActionCommand();
+        if (op.equals("+"))
+            answer.setText( "x + y = " + (x+y) );
+        else if (op.equals("-"))
+            answer.setText( "x - y = " + (x-y) );
+        else if (op.equals("*"))
+            answer.setText( "x * y = " + (x*y) );
+        else if (op.equals("/")) {
+            if (y == 0)
+                answer.setText("Can't divide by zero!");
+            else
+                answer.setText( "x / y = " + (x/y) );
+        }
+
+    } // end actionPerformed()
+
+
+}  // end class SimpleCalc

src/SimpleDialogDemo.java

@@ -0,0 +1,155 @@
+
+/**
+ * This program demonstrates four easy-to-use routines for showing 
+ * a dialog box and, in three cases, getting back some information 
+ * from the user.  The methods are:
+ *  
+ *       JOptionPane.showMessageDialog
+ *       JOptionPane.showConfirmDialog
+ *       JOptionPane.showInputDialog
+ *       JColorChooser.showDialog
+ */
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+
+public class SimpleDialogDemo extends JPanel implements ActionListener {
+
+    /**
+     * A main routine allows this class to be run as an application.
+     */
+    public static void main(String[] args) {
+        JFrame window = new JFrame("Four Simple Dialogs");
+        SimpleDialogDemo content = new SimpleDialogDemo();
+        window.setContentPane(content);
+        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        window.setLocation(250,200);
+        window.pack();
+        window.setResizable(false);
+        window.setVisible(true);
+    }
+
+    //---------------------------------------------------------------------
+
+   JLabel message;  // A label for giving some feedback to the user.
+                    // It appears at the top of the panel.
+
+   Color selectedColor = Color.GRAY; // This color will be used as the
+                                     // initial color in the color chooser.
+                                     // It is used to remember the user's
+                                     // color choice, so that the color 
+                                     // chooser can show the same color,
+                                     // if it is opened twice.
+                                   
+
+   public SimpleDialogDemo() {
+          // Set up the panel with a message label and four buttons.
+          // Each button will open a different type of dialog.
+
+       setBackground(Color.GRAY);
+       setBackground(Color.GRAY);
+       setLayout( new GridLayout(3,1,3,3) );
+       message = new JLabel("Click a button to open a dialog", JLabel.CENTER);
+       message.setForeground(new Color(180,0,0));
+       message.setBackground(Color.WHITE);
+       message.setOpaque(true);
+       add(message);
+
+       JPanel buttonBar;
+       JButton button;
+
+       buttonBar = new JPanel();
+       buttonBar.setLayout(new GridLayout(1,2,3,3));
+       buttonBar.setBackground(Color.GRAY);
+       add(buttonBar);
+       button = new JButton("Message Dialog");
+       button.addActionListener(this);
+       buttonBar.add(button);
+       button = new JButton("Confirm Dialog");
+       button.addActionListener(this);
+       buttonBar.add(button);
+
+       buttonBar = new JPanel();
+       buttonBar.setLayout(new GridLayout(1,2,3,3));
+       buttonBar.setBackground(Color.GRAY);
+       add(buttonBar);
+       button = new JButton("Input Dialog");
+       button.addActionListener(this);
+       buttonBar.add(button);
+       button = new JButton("Color Chooser");
+       button.addActionListener(this);
+       buttonBar.add(button);
+       
+       setBorder(BorderFactory.createLineBorder(Color.GRAY,3));
+
+   } // end constructor
+   
+ 
+   /**
+    * Respond to a button click by showing a dialog and setting the 
+    * message label to describe the user's response.
+    */
+   public void actionPerformed(ActionEvent evt) {
+
+      String command = evt.getActionCommand();
+
+      if (command.equals("Message Dialog")) {
+         message.setText("Displaying message dialog.");
+         JOptionPane.showMessageDialog(this,
+             "This is an example of JOptionPane.showMessageDialog.");
+         message.setText("You closed the message dialog.");
+      }
+
+      else if (command.equals("Confirm Dialog")) {
+         message.setText("Displaying confirm dialog.");
+         int response = JOptionPane.showConfirmDialog(this,
+             "This is an example of JOptionPane.showConfirmDialog.\n" 
+               + "Click any button to indicate your response.");
+         switch(response) {
+            case JOptionPane.YES_OPTION: 
+               message.setText("You clicked \"Yes\".");
+               break;
+            case JOptionPane.NO_OPTION: 
+               message.setText("You clicked \"No\".");
+               break;
+            case JOptionPane.CANCEL_OPTION: 
+               message.setText("You clicked \"Cancel\".");
+               break;
+            case JOptionPane.CLOSED_OPTION: 
+               message.setText("You closed the box without making a selection.");
+         }
+      }
+
+      else if (command.equals("Input Dialog")) {
+         message.setText("Displaying input dialog.");
+         String response = JOptionPane.showInputDialog(this,
+             "This is an example of JOptionPane.showInputDialog.\n" 
+               + "Type your response, and click a button.");
+         if (response == null)
+            message.setText("You canceled the input.");
+         else if (response.trim().length() == 0)
+            message.setText("You left the input box empty.");
+         else
+            message.setText("You entered \"" + response + "\".");
+      }
+
+      else if (command.equals("Color Chooser")) {
+         message.setText("Displaying color chooser dialog.");
+         Color c = JColorChooser.showDialog(this,"Select a Color",selectedColor);
+         if (c == null)
+            message.setText("You canceled without selecting a color.");
+         else {
+            selectedColor = c;  // Remember selected color for next time.
+            int r = c.getRed();
+            int g = c.getGreen();
+            int b = c.getBlue();
+            message.setText("You selected RGB = (" + r + "," + g + "," + b + ").");
+         }
+      }
+
+   } // end actionPerformed()
+
+
+} // end class SimpleDialogDemo
+

src/SliderAndButtonDemo.java

@@ -0,0 +1,138 @@
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import javax.swing.event.*;
+
+/**
+ * This program is a simple demo of using a JLabel, some JSliders, and some buttons 
+ * and laying them out in a GridLayout.  This class contains a main() routine,
+ * so that it can also be run as a stand-alone application.
+ *  */
+public class SliderAndButtonDemo extends JPanel implements ActionListener, ChangeListener {
+
+
+    /**
+     * The main() routine simply opens a window that shows a panel of type
+     * SliderAndButtonDemo.  Note that the main() routine uses the pack()
+     * method of the JFrame, so that the size of the panel will be
+     * equal to its preferred size.
+     */
+    public static void main(String[] args) {
+        JFrame window = new JFrame("Slider and Button Demo");
+        SliderAndButtonDemo content = new SliderAndButtonDemo();
+        window.setContentPane(content);
+        window.pack();
+        window.setLocation(100,100);
+        window.setResizable(false);
+        window.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
+        window.setVisible(true);
+    }
+
+
+    //---------------------------------------------------------------------
+    
+    /* Declare some controls as global variables so that they can be used
+     * in the event-handling methods.  Note that the buttons don't have to
+     * be global.
+     */
+
+    private JLabel displayLabel;   // label displaying "Hello World
+    private JSlider bgColorSlider; // controls background color of label
+    private JSlider fgColorSlider; // controls foreground color of label
+    
+
+    /**
+     * The constructor creates components, sets up listening, and adds
+     * the components to the panel.
+     */
+    public SliderAndButtonDemo() {
+        
+        setBorder(BorderFactory.createEmptyBorder(6,6,6,6));
+
+        /* Create the display label, with properties to match the
+               values of the sliders and with a BOLD font. */
+
+        displayLabel = new JLabel("Hello World!", JLabel.CENTER);
+        displayLabel.setOpaque(true);
+        displayLabel.setBackground( new Color(100,100,100) );
+        displayLabel.setForeground( Color.RED );
+        displayLabel.setFont( new Font("Serif", Font.BOLD, 30) );
+        displayLabel.setBorder(BorderFactory.createEmptyBorder(0,8,0,8));
+
+        /* Create the sliders, and set up the panel to listen for
+           ChangeEvents that are generated by the sliders. */
+
+        bgColorSlider = new JSlider(0,255,100);
+        bgColorSlider.addChangeListener(this);
+
+        fgColorSlider = new JSlider(0,100,0);
+        fgColorSlider.addChangeListener(this);
+        
+        /* Create three buttons to control the font style, and set up the
+           panel to listen for ActionEvents from the buttons. */
+        
+        JButton plainButton = new JButton("Plain Font");
+        plainButton.addActionListener(this);
+        JButton italicButton = new JButton("Italic Font");
+        italicButton.addActionListener(this);
+        JButton boldButton = new JButton("Bold Font");
+        boldButton.addActionListener(this);
+
+
+        /* Set the layout for the panel, and add the six components. 
+               Use a GridLayout with 3 rows and 2 columns, and with
+               5 pixels between components. */
+
+        setLayout(new GridLayout(3,2,5,5));
+        add(displayLabel);
+        add(plainButton);
+        add(bgColorSlider);
+        add(italicButton);
+        add(fgColorSlider);
+        add(boldButton);
+
+    } // end constructor
+
+    /**
+     * This method will be called when the user  clicks one of the buttons.
+     * The method just changes the label's font to the style specified by
+     * the button.
+     */
+    public void actionPerformed(ActionEvent evt) {
+        String cmd = evt.getActionCommand();
+        if (cmd.equals("Plain Font")) {
+            displayLabel.setFont( new Font("Serif", Font.PLAIN, 30) );
+        }
+        else if (cmd.equals("Italic Font")) {
+            displayLabel.setFont( new Font("Serif", Font.ITALIC, 30) );
+        }
+        else if (cmd.equals("Bold Font")) {
+            displayLabel.setFont( new Font("Serif", Font.BOLD, 30) );
+        }
+    }
+
+    /**
+     * This method is called when the value is changed on either of the
+     * sliders.  It sets the foreground or background color of the label
+     * to match the value on the slider that has changed. 
+     */
+    public void stateChanged(ChangeEvent evt) {
+        if (evt.getSource() == bgColorSlider) {
+            int bgVal = bgColorSlider.getValue();
+            displayLabel.setBackground( new Color(bgVal,bgVal,bgVal) );
+                // NOTE:  The background color is a shade of gray,
+                //        determined by the setting on the slider.
+        }
+        else {
+            float hue = fgColorSlider.getValue()/100.0f;
+            displayLabel.setForeground( Color.getHSBColor(hue, 1.0f, 1.0f) );
+                // Note:  The foreground color ranges through all the colors
+                // of the spectrum.
+        }
+    }
+
+
+} // end class SliderAndButtonDemo
+

src/SliderDemo.java

@@ -0,0 +1,68 @@
+
+// A little program that demonstrates JSliders.
+
+import java.awt.*;
+
+import javax.swing.*;
+import javax.swing.event.*;
+
+public class SliderDemo extends JPanel implements ChangeListener {
+
+    /**
+     * A main routine allows this class to be run as an application.
+     */
+    public static void main(String[] args) {
+        JFrame window = new JFrame("Slider Demo");
+        SliderDemo content = new SliderDemo();
+        window.setContentPane(content);
+        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        window.setLocation(120,70);
+        window.setSize(350,200);
+        window.setVisible(true);
+    }
+
+    //---------------------------------------------------------------------
+
+    JSlider slider1, slider2, slider3;  // The sliders.
+
+    JLabel label; // A label for reporting changes in the sliders' values.
+
+    public SliderDemo() {
+
+        setLayout(new GridLayout(4,1));
+        setBorder(BorderFactory.createCompoundBorder(
+                       BorderFactory.createLineBorder(Color.DARK_GRAY, 2),
+                       BorderFactory.createEmptyBorder(8,8,8,8)));
+
+        label = new JLabel("Try dragging the sliders!", JLabel.CENTER);
+        add(label);
+
+        slider1 = new JSlider(0,10,0);
+        slider1.addChangeListener(this);
+        add(slider1);
+
+        slider2 = new JSlider();
+        slider2.addChangeListener(this);
+        slider2.setMajorTickSpacing(25);
+        slider2.setMinorTickSpacing(5);
+        slider2.setPaintTicks(true);
+        add(slider2);
+
+        slider3 = new JSlider(2000,2100,2014);
+        slider3.addChangeListener(this);
+        slider3.setLabelTable(slider3.createStandardLabels(50));
+        slider3.setPaintLabels(true);
+        add(slider3);
+
+    }  // end constructor
+
+    public void stateChanged(ChangeEvent evt) {
+        if (evt.getSource() == slider1)
+            label.setText("Slider one changed to " + slider1.getValue());
+        else if (evt.getSource() == slider2)
+            label.setText("Slider two changed to " + slider2.getValue());
+        else if (evt.getSource() == slider3)
+            label.setText("Slider three changed to " + slider3.getValue());
+    }
+
+}

src/SliderDemoWithLambda.java

@@ -0,0 +1,62 @@
+
+// A little program that demonstrates JSliders.  This is an alternative
+// version of SliderDemo.java that uses lambda expressions to define
+// the ChangeListeners are registered with the sliders.
+
+import java.awt.*;
+import javax.swing.*;
+
+public class SliderDemoWithLambda extends JPanel  {
+
+    /**
+     * A main routine allows this class to be run as an application.
+     */
+    public static void main(String[] args) {
+        JFrame window = new JFrame("Slider Demo");
+        SliderDemoWithLambda content = new SliderDemoWithLambda();
+        window.setContentPane(content);
+        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        window.setLocation(120,70);
+        window.setSize(350,200);
+        window.setVisible(true);
+    }
+
+    //---------------------------------------------------------------------
+
+    JSlider slider1, slider2, slider3;  // The sliders.
+
+    JLabel label; // A label for reporting changes in the sliders' values.
+
+    public SliderDemoWithLambda() {
+
+        setLayout(new GridLayout(4,1));
+        setBorder(BorderFactory.createCompoundBorder(
+                       BorderFactory.createLineBorder(Color.DARK_GRAY, 2),
+                       BorderFactory.createEmptyBorder(8,8,8,8)));
+
+        label = new JLabel("Try dragging the sliders!", JLabel.CENTER);
+        add(label);
+
+        slider1 = new JSlider(0,10,0);
+        slider1.addChangeListener( 
+                evt -> label.setText("Slider one changed to " + slider1.getValue()) );
+        add(slider1);
+
+        slider2 = new JSlider();
+        slider2.addChangeListener( 
+                evt -> label.setText("Slider two changed to " + slider2.getValue()) );
+        slider2.setMajorTickSpacing(25);
+        slider2.setMinorTickSpacing(5);
+        slider2.setPaintTicks(true);
+        add(slider2);
+
+        slider3 = new JSlider(2000,2100,2014);
+        slider3.addChangeListener( 
+                evt -> label.setText("Slider three changed to " + slider3.getValue()) );
+        slider3.setLabelTable(slider3.createStandardLabels(50));
+        slider3.setPaintLabels(true);
+        add(slider3);
+
+    }  // end constructor
+
+}

src/TextAreaDemo.java

@@ -0,0 +1,54 @@
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Insets;
+
+import javax.swing.BorderFactory;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
+
+/**
+ * This program simply demonstrates using a JTextArea in a JScrollPane.
+ */
+public class TextAreaDemo extends JPanel {
+    
+
+    /**
+     * A main routine allows this class to be run as an application.
+     */
+    public static void main(String[] args) {
+        JFrame window = new JFrame("TextArea Demo");
+        TextAreaDemo content = new TextAreaDemo();
+        window.setContentPane(content);
+        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        window.setLocation(120,70);
+        window.setSize(400,250);
+        window.setVisible(true);
+    }
+
+    //---------------------------------------------------------------------
+
+    public TextAreaDemo() {
+        
+        String text = "So, naturalists observe, a flea\n"
+            + "Has smaller fleas that on him prey;\n"
+            + "And these have smaller still to bite 'em;\n"
+            + "And so proceed ad infinitum.\n\n"
+            + "                              --Jonathan Swift";
+        
+        JTextArea textArea = new JTextArea();
+        JScrollPane scrollPane = new JScrollPane(textArea);
+        
+        textArea.setText(text);
+        textArea.setFont( new Font("Serif", Font.PLAIN, 24 ));
+        textArea.setMargin( new Insets(7,7,7,7) );
+        
+        setLayout(new BorderLayout());
+        setBorder(BorderFactory.createLineBorder(Color.BLACK, 2));
+        add(scrollPane, BorderLayout.CENTER);
+        
+    }
+
+}

src/ToolBarDemo.java

@@ -0,0 +1,234 @@
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.image.BufferedImage;
+
+import javax.swing.*;
+
+
+/**
+ * Demonstrates a toolbar and the use of image icons on buttons.  The toolbar
+ * contains a radio group with three JRadioButtons and a button, all of which
+ * use custom icons.  The actual program just lets the user draw curves
+ * in three different colors.  This class can be run as a stand-alone program.
+ */
+public class ToolBarDemo extends JPanel {
+
+    /**
+     * The main routine simply opens a window that shows a ToolBarDemo panel.
+     */
+    public static void main(String[] args) {
+        JFrame window = new JFrame("ToolBarDemo");
+        ToolBarDemo content = new ToolBarDemo();
+        window.setContentPane(content);
+        window.pack();  
+        window.setResizable(false); 
+        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
+        window.setLocation( (screenSize.width - window.getWidth())/2,
+                (screenSize.height - window.getHeight())/2 );
+        window.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
+        window.setVisible(true);
+    }
+
+
+
+    /**
+     * Defines the display area of the program, where the user can draw curves
+     * in various colors.  (This class demonstrates resizing an off-screen canvas
+     * when the size of the display changes.  The size can change if the user
+     * drags the toolbar out of the window or to a new position.)
+     */
+    private class Display extends JPanel implements MouseListener, MouseMotionListener {
+
+        private BufferedImage OSC;  // Off-screen canvas.
+        private Color currentColor = Color.RED;  // Current drawing color.
+        private int prevX, prevY;  // Previous mouse position, during mouse drags.
+        private BasicStroke stroke;  // Stroke used for drawing.
+
+        Display() { // constructor.
+            addMouseListener(this);
+            addMouseMotionListener(this);
+            setPreferredSize(new Dimension(300,300));
+            stroke = new BasicStroke(3,BasicStroke.CAP_ROUND,BasicStroke.JOIN_ROUND);
+        }
+
+        void setCurrentColor(Color c) {  // change current drawing color
+            currentColor = c;
+        }
+
+        void clear() { // clear the drawing area by filling it with white
+            if (OSC != null) {
+                Graphics g = OSC.getGraphics();
+                g.setColor(Color.WHITE);
+                g.fillRect(0,0,getWidth(),getHeight());
+                g.dispose();
+                repaint();
+            }
+        }
+
+        public void paintComponent(Graphics g) { // just copies OSC to screen
+            checkImage();
+            g.drawImage(OSC,0,0,null);
+        }
+
+        void checkImage() {  // create or resize OSC if necessary
+            if (OSC == null) {
+                // Create the OSC, with a size to match the size of the panel.
+                OSC = new BufferedImage(getWidth(),getHeight(),BufferedImage.TYPE_INT_RGB);
+                clear();
+            }
+            else if (OSC.getWidth() != getWidth() || OSC.getHeight() != getHeight()) {
+                // OSC size does not match the panel's size, so create a new OSC and
+                // copy the picture in the old OSC to the new one.  This will scale
+                // the current image to fit the new size.
+                BufferedImage newOSC;
+                newOSC = new BufferedImage(getWidth(),getHeight(),BufferedImage.TYPE_INT_RGB);
+                Graphics g = newOSC.getGraphics();
+                g.drawImage(OSC,0,0,getWidth(),getHeight(),null);
+                g.dispose();
+                OSC = newOSC;
+            }
+        }
+
+        public void mousePressed(MouseEvent e) {
+            prevX = e.getX();
+            prevY = e.getY();
+        }
+        public void mouseDragged(MouseEvent e) {
+            Graphics2D g2 = (Graphics2D)OSC.getGraphics();
+            g2.setColor(currentColor);
+            g2.setStroke(stroke);
+            g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+            g2.drawLine(prevX,prevY,e.getX(),e.getY());
+            g2.dispose();
+            repaint();
+            prevX = e.getX();
+            prevY = e.getY();
+        }
+        public void mouseReleased(MouseEvent e) { }
+        public void mouseMoved(MouseEvent e) { }
+        public void mouseClicked(MouseEvent e) { }
+        public void mouseEntered(MouseEvent e) { }
+        public void mouseExited(MouseEvent e) { }
+    }
+
+
+    private Display display;  // The display area of the program.
+
+
+    /**
+     * Constructor adds a display and a toolbar to the program.  The
+     * advice for using a toolbar is to place the toolbar in one of
+     * the edge positions of a BorderLayout, and to put nothing in any
+     * of the other three edge positions.  The user might be able
+     * to drag the toolbar from one edge position to another.
+     */
+    public ToolBarDemo() {
+
+        setLayout(new BorderLayout(2,2));
+        setBackground(Color.GRAY);
+        setBorder(BorderFactory.createLineBorder(Color.GRAY,2));
+
+        display = new Display();
+        add(display, BorderLayout.CENTER);
+
+        JToolBar toolbar = new JToolBar();
+        add(toolbar, BorderLayout.NORTH);
+
+        ButtonGroup group = new ButtonGroup();
+        toolbar.add( makeColorRadioButton(Color.RED,group,true) );
+        toolbar.add( makeColorRadioButton(Color.GREEN,group,false) );
+        toolbar.add( makeColorRadioButton(Color.BLUE,group,false) );
+        toolbar.addSeparator(new Dimension(20,20));
+
+        toolbar.add( makeClearButton() );
+
+    }
+
+
+    /**
+     * Create a JRadioButton and add it to a specified button group.  The button
+     * is meant for selecting a drawing color in the display.  The color is used to 
+     * create two custom icons, one for the unselected state of the button and one
+     * for the selected state.  These icons are used instead of the usual
+     * radio button icons.
+     * @param c the color of the button, and the color to be used for drawing.
+     *    (Note that c has to be "final" since it is used in the anonymous inner
+     *    class that defines the response to ActionEvents on the button.)
+     * @param grp the ButtonGroup to which the radio button will be added.
+     * @param selected if true, then the state of the button is set to selected.
+     * @return the radio button that was just created.
+     */
+    private JRadioButton makeColorRadioButton(final Color c, ButtonGroup grp, boolean selected) {
+
+        /* Create an ImageIcon for the normal, unselected state of the button,
+           using a BufferedImage that is drawn here from scratch. */
+
+        BufferedImage image = new BufferedImage(30,30,BufferedImage.TYPE_INT_RGB);
+        Graphics g = image.getGraphics();
+        g.setColor(Color.LIGHT_GRAY);
+        g.fillRect(0,0,30,30);
+        g.setColor(c);
+        g.fill3DRect(1, 1, 24, 24, true);
+        g.dispose();
+        Icon unselectedIcon = new ImageIcon(image);
+
+        /* Create an ImageIcon for the selected state of the button. */
+
+        image = new BufferedImage(30,30,BufferedImage.TYPE_INT_RGB);
+        g = image.getGraphics();
+        g.setColor(Color.DARK_GRAY);
+        g.fillRect(0,0,30,30);
+        g.setColor(c);
+        g.fill3DRect(3, 3, 24, 24, false);
+        g.dispose();
+        Icon selectedIcon = new ImageIcon(image);
+
+        /* Create and configure the button. */
+
+        JRadioButton button = new JRadioButton(unselectedIcon);
+        button.setSelectedIcon(selectedIcon);
+        button.addActionListener( new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                // The action for this button sets the current drawing color
+                // in the display to c.
+                display.setCurrentColor(c);
+            }
+        });
+        grp.add(button);
+        if (selected)
+            button.setSelected(true);
+
+        return button;
+    } // end makeColorRadioButton
+
+
+    /**
+     * Create a JButton that can be used to clear the display.  The button has
+     * no text and its icon is a custom icon that shows a big X.  The icon is
+     * created by drawing it on a Buffered image and using that image to 
+     * create an ImageIcon.  The button has tooltip text "Clear the Display".
+     */
+    private JButton makeClearButton() {
+        BufferedImage image = new BufferedImage(24,24,BufferedImage.TYPE_INT_RGB);
+        Graphics2D g2 = (Graphics2D)image.getGraphics();
+        g2.setColor(Color.LIGHT_GRAY);
+        g2.fillRect(0,0,24,24);
+        g2.setStroke( new BasicStroke(3));
+        g2.setColor(Color.BLACK);
+        g2.drawLine(4,4,20,20);
+        g2.drawLine(4,20,20,4);
+        g2.dispose();
+        Icon clearIcon = new ImageIcon(image);
+
+        Action clearAction = new AbstractAction(null,clearIcon) {
+            public void actionPerformed(ActionEvent evt) {
+                display.clear();
+            }
+        };
+        clearAction.putValue(Action.SHORT_DESCRIPTION, "Clear the Display");
+        JButton button = new JButton(clearAction);
+
+        return button;
+    }
+
+}