diff --git a/README.md b/README.md index 80ac712..11ed0f1 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,3 @@ # SwingDemos +Not written by me but useful reference \ No newline at end of file diff --git a/src/GUIDemo.java b/src/GUIDemo.java new file mode 100644 index 0000000..637d9f6 --- /dev/null +++ b/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 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(); + 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 diff --git a/src/HelloWorldGUI1.java b/src/HelloWorldGUI1.java new file mode 100644 index 0000000..0af30d9 --- /dev/null +++ b/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!" ); + } + +} \ No newline at end of file diff --git a/src/HelloWorldGUI2.java b/src/HelloWorldGUI2.java new file mode 100644 index 0000000..21c33bf --- /dev/null +++ b/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); + + } + +} \ No newline at end of file diff --git a/src/HelloWorldGUI3.java b/src/HelloWorldGUI3.java new file mode 100644 index 0000000..72e1a72 --- /dev/null +++ b/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); + + } + +} diff --git a/src/NullLayoutDemo.java b/src/NullLayoutDemo.java new file mode 100644 index 0000000..0baa514 --- /dev/null +++ b/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 + + + + diff --git a/src/RandomStrings.java b/src/RandomStrings.java new file mode 100644 index 0000000..cea1b6b --- /dev/null +++ b/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); + } + +} \ No newline at end of file diff --git a/src/RandomStringsPanel.java b/src/RandomStringsPanel.java new file mode 100644 index 0000000..244e2d8 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/src/SimpleCalc.java b/src/SimpleCalc.java new file mode 100644 index 0000000..370f99b --- /dev/null +++ b/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 diff --git a/src/SimpleDialogDemo.java b/src/SimpleDialogDemo.java new file mode 100644 index 0000000..9dc1a2a --- /dev/null +++ b/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 + diff --git a/src/SliderAndButtonDemo.java b/src/SliderAndButtonDemo.java new file mode 100644 index 0000000..4d98c1e --- /dev/null +++ b/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 + diff --git a/src/SliderDemo.java b/src/SliderDemo.java new file mode 100644 index 0000000..b9d2876 --- /dev/null +++ b/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()); + } + +} diff --git a/src/SliderDemoWithLambda.java b/src/SliderDemoWithLambda.java new file mode 100644 index 0000000..c26ef06 --- /dev/null +++ b/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 + +} diff --git a/src/TextAreaDemo.java b/src/TextAreaDemo.java new file mode 100644 index 0000000..1416610 --- /dev/null +++ b/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); + + } + +} diff --git a/src/ToolBarDemo.java b/src/ToolBarDemo.java new file mode 100644 index 0000000..442929c --- /dev/null +++ b/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; + } + +}