extends JDialog to create your own dialog : JDialog « Swing « Java Tutorial






/*
 * Copyright (c) 1995 - 2008 Sun Microsystems, Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   - Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   - Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 *   - Neither the name of Sun Microsystems nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;

import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.ButtonGroup;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JTabbedPane;
import javax.swing.JTextField;
import javax.swing.border.Border;

/*
 * DialogDemo.java requires these files: CustomDialog.java images/middle.gif
 */
public class DialogDemo extends JPanel {
  JLabel label;
  ImageIcon icon = createImageIcon("images/middle.gif");
  JFrame frame;
  String simpleDialogDesc = "Some simple message dialogs";
  String iconDesc = "A JOptionPane has its choice of icons";
  String moreDialogDesc = "Some more dialogs";
  CustomDialog customDialog;

  /** Creates the GUI shown inside the frame's content pane. */
  public DialogDemo(JFrame frame) {
    super(new BorderLayout());
    this.frame = frame;
    customDialog = new CustomDialog(frame, "geisel", this);
    customDialog.pack();

    // Create the components.
    JPanel frequentPanel = createSimpleDialogBox();
    JPanel featurePanel = createFeatureDialogBox();
    JPanel iconPanel = createIconDialogBox();
    label = new JLabel("Click the \"Show it!\" button"
        + " to bring up the selected dialog.", JLabel.CENTER);

    // Lay them out.
    Border padding = BorderFactory.createEmptyBorder(20, 20, 5, 20);
    frequentPanel.setBorder(padding);
    featurePanel.setBorder(padding);
    iconPanel.setBorder(padding);

    JTabbedPane tabbedPane = new JTabbedPane();
    tabbedPane.addTab("Simple Modal Dialogs", null, frequentPanel,
        simpleDialogDesc); // tooltip text
    tabbedPane.addTab("More Dialogs", null, featurePanel, moreDialogDesc); // tooltip
                                                                            // text
    tabbedPane.addTab("Dialog Icons", null, iconPanel, iconDesc); // tooltip
                                                                  // text

    add(tabbedPane, BorderLayout.CENTER);
    add(label, BorderLayout.PAGE_END);
    label.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
  }

  /** Sets the text displayed at the bottom of the frame. */
  void setLabel(String newText) {
    label.setText(newText);
  }

  /** Returns an ImageIcon, or null if the path was invalid. */
  protected static ImageIcon createImageIcon(String path) {
    java.net.URL imgURL = DialogDemo.class.getResource(path);
    if (imgURL != null) {
      return new ImageIcon(imgURL);
    } else {
      System.err.println("Couldn't find file: " + path);
      return null;
    }
  }

  /** Creates the panel shown by the first tab. */
  private JPanel createSimpleDialogBox() {
    final int numButtons = 4;
    JRadioButton[] radioButtons = new JRadioButton[numButtons];
    final ButtonGroup group = new ButtonGroup();

    JButton showItButton = null;

    final String defaultMessageCommand = "default";
    final String yesNoCommand = "yesno";
    final String yeahNahCommand = "yeahnah";
    final String yncCommand = "ync";

    radioButtons[0] = new JRadioButton("OK (in the L&F's words)");
    radioButtons[0].setActionCommand(defaultMessageCommand);

    radioButtons[1] = new JRadioButton("Yes/No (in the L&F's words)");
    radioButtons[1].setActionCommand(yesNoCommand);

    radioButtons[2] = new JRadioButton("Yes/No "
        + "(in the programmer's words)");
    radioButtons[2].setActionCommand(yeahNahCommand);

    radioButtons[3] = new JRadioButton("Yes/No/Cancel "
        + "(in the programmer's words)");
    radioButtons[3].setActionCommand(yncCommand);

    for (int i = 0; i < numButtons; i++) {
      group.add(radioButtons[i]);
    }
    radioButtons[0].setSelected(true);

    showItButton = new JButton("Show it!");
    showItButton.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        String command = group.getSelection().getActionCommand();

        // ok dialog
        if (command == defaultMessageCommand) {
          JOptionPane.showMessageDialog(frame,
              "Eggs aren't supposed to be green.");

          // yes/no dialog
        } else if (command == yesNoCommand) {
          int n = JOptionPane.showConfirmDialog(frame,
              "Would you like green eggs and ham?", "An Inane Question",
              JOptionPane.YES_NO_OPTION);
          if (n == JOptionPane.YES_OPTION) {
            setLabel("Ewww!");
          } else if (n == JOptionPane.NO_OPTION) {
            setLabel("Me neither!");
          } else {
            setLabel("Come on -- tell me!");
          }

          // yes/no (not in those words)
        } else if (command == yeahNahCommand) {
          Object[] options = { "Yes, please", "No way!" };
          int n = JOptionPane.showOptionDialog(frame,
              "Would you like green eggs and ham?", "A Silly Question",
              JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null,
              options, options[0]);
          if (n == JOptionPane.YES_OPTION) {
            setLabel("You're kidding!");
          } else if (n == JOptionPane.NO_OPTION) {
            setLabel("I don't like them, either.");
          } else {
            setLabel("Come on -- 'fess up!");
          }

          // yes/no/cancel (not in those words)
        } else if (command == yncCommand) {
          Object[] options = { "Yes, please", "No, thanks", "No eggs, no ham!" };
          int n = JOptionPane.showOptionDialog(frame,
              "Would you like some green eggs to go " + "with that ham?",
              "A Silly Question", JOptionPane.YES_NO_CANCEL_OPTION,
              JOptionPane.QUESTION_MESSAGE, null, options, options[2]);
          if (n == JOptionPane.YES_OPTION) {
            setLabel("Here you go: green eggs and ham!");
          } else if (n == JOptionPane.NO_OPTION) {
            setLabel("OK, just the ham, then.");
          } else if (n == JOptionPane.CANCEL_OPTION) {
            setLabel("Well, I'm certainly not going to eat them!");
          } else {
            setLabel("Please tell me what you want!");
          }
        }
        return;
      }
    });

    return createPane(simpleDialogDesc + ":", radioButtons, showItButton);
  }

  /**
   * Used by createSimpleDialogBox and createFeatureDialogBox to create a pane
   * containing a description, a single column of radio buttons, and the Show
   * it! button.
   */
  private JPanel createPane(String description, JRadioButton[] radioButtons,
      JButton showButton) {

    int numChoices = radioButtons.length;
    JPanel box = new JPanel();
    JLabel label = new JLabel(description);

    box.setLayout(new BoxLayout(box, BoxLayout.PAGE_AXIS));
    box.add(label);

    for (int i = 0; i < numChoices; i++) {
      box.add(radioButtons[i]);
    }

    JPanel pane = new JPanel(new BorderLayout());
    pane.add(box, BorderLayout.PAGE_START);
    pane.add(showButton, BorderLayout.PAGE_END);
    return pane;
  }

  /**
   * Like createPane, but creates a pane with 2 columns of radio buttons. The
   * number of buttons passed in *must* be even.
   */
  private JPanel create2ColPane(String description,
      JRadioButton[] radioButtons, JButton showButton) {
    JLabel label = new JLabel(description);
    int numPerColumn = radioButtons.length / 2;

    JPanel grid = new JPanel(new GridLayout(0, 2));
    for (int i = 0; i < numPerColumn; i++) {
      grid.add(radioButtons[i]);
      grid.add(radioButtons[i + numPerColumn]);
    }

    JPanel box = new JPanel();
    box.setLayout(new BoxLayout(box, BoxLayout.PAGE_AXIS));
    box.add(label);
    grid.setAlignmentX(0.0f);
    box.add(grid);

    JPanel pane = new JPanel(new BorderLayout());
    pane.add(box, BorderLayout.PAGE_START);
    pane.add(showButton, BorderLayout.PAGE_END);

    return pane;
  }

  /*
   * Creates the panel shown by the 3rd tab. These dialogs are implemented using
   * showMessageDialog, but you can specify the icon (using similar code) for
   * any other kind of dialog, as well.
   */
  private JPanel createIconDialogBox() {
    JButton showItButton = null;

    final int numButtons = 6;
    JRadioButton[] radioButtons = new JRadioButton[numButtons];
    final ButtonGroup group = new ButtonGroup();

    final String plainCommand = "plain";
    final String infoCommand = "info";
    final String questionCommand = "question";
    final String errorCommand = "error";
    final String warningCommand = "warning";
    final String customCommand = "custom";

    radioButtons[0] = new JRadioButton("Plain (no icon)");
    radioButtons[0].setActionCommand(plainCommand);

    radioButtons[1] = new JRadioButton("Information icon");
    radioButtons[1].setActionCommand(infoCommand);

    radioButtons[2] = new JRadioButton("Question icon");
    radioButtons[2].setActionCommand(questionCommand);

    radioButtons[3] = new JRadioButton("Error icon");
    radioButtons[3].setActionCommand(errorCommand);

    radioButtons[4] = new JRadioButton("Warning icon");
    radioButtons[4].setActionCommand(warningCommand);

    radioButtons[5] = new JRadioButton("Custom icon");
    radioButtons[5].setActionCommand(customCommand);

    for (int i = 0; i < numButtons; i++) {
      group.add(radioButtons[i]);
    }
    radioButtons[0].setSelected(true);

    showItButton = new JButton("Show it!");
    showItButton.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        String command = group.getSelection().getActionCommand();

        // no icon
        if (command == plainCommand) {
          JOptionPane.showMessageDialog(frame,
              "Eggs aren't supposed to be green.", "A plain message",
              JOptionPane.PLAIN_MESSAGE);
          // information icon
        } else if (command == infoCommand) {
          JOptionPane.showMessageDialog(frame,
              "Eggs aren't supposed to be green.",
              "Inane informational dialog", JOptionPane.INFORMATION_MESSAGE);

          // XXX: It doesn't make sense to make a question with
          // XXX: only one button.
          // XXX: See "Yes/No (but not in those words)" for a better solution.
          // question icon
        } else if (command == questionCommand) {
          JOptionPane.showMessageDialog(frame,
              "You shouldn't use a message dialog " + "(like this)\n"
                  + "for a question, OK?", "Inane question",
              JOptionPane.QUESTION_MESSAGE);
          // error icon
        } else if (command == errorCommand) {
          JOptionPane.showMessageDialog(frame,
              "Eggs aren't supposed to be green.", "Inane error",
              JOptionPane.ERROR_MESSAGE);
          // warning icon
        } else if (command == warningCommand) {
          JOptionPane.showMessageDialog(frame,
              "Eggs aren't supposed to be green.", "Inane warning",
              JOptionPane.WARNING_MESSAGE);
          // custom icon
        } else if (command == customCommand) {
          JOptionPane.showMessageDialog(frame,
              "Eggs aren't supposed to be green.", "Inane custom dialog",
              JOptionPane.INFORMATION_MESSAGE, icon);
        }
      }
    });

    return create2ColPane(iconDesc + ":", radioButtons, showItButton);
  }

  /** Creates the panel shown by the second tab. */
  private JPanel createFeatureDialogBox() {
    final int numButtons = 5;
    JRadioButton[] radioButtons = new JRadioButton[numButtons];
    final ButtonGroup group = new ButtonGroup();

    JButton showItButton = null;

    final String pickOneCommand = "pickone";
    final String textEnteredCommand = "textfield";
    final String nonAutoCommand = "nonautooption";
    final String customOptionCommand = "customoption";
    final String nonModalCommand = "nonmodal";

    radioButtons[0] = new JRadioButton("Pick one of several choices");
    radioButtons[0].setActionCommand(pickOneCommand);

    radioButtons[1] = new JRadioButton("Enter some text");
    radioButtons[1].setActionCommand(textEnteredCommand);

    radioButtons[2] = new JRadioButton("Non-auto-closing dialog");
    radioButtons[2].setActionCommand(nonAutoCommand);

    radioButtons[3] = new JRadioButton("Input-validating dialog "
        + "(with custom message area)");
    radioButtons[3].setActionCommand(customOptionCommand);

    radioButtons[4] = new JRadioButton("Non-modal dialog");
    radioButtons[4].setActionCommand(nonModalCommand);

    for (int i = 0; i < numButtons; i++) {
      group.add(radioButtons[i]);
    }
    radioButtons[0].setSelected(true);

    showItButton = new JButton("Show it!");
    showItButton.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        String command = group.getSelection().getActionCommand();

        // pick one of many
        if (command == pickOneCommand) {
          Object[] possibilities = { "ham", "spam", "yam" };
          String s = (String) JOptionPane.showInputDialog(frame,
              "Complete the sentence:\n" + "\"Green eggs and...\"",
              "Customized Dialog", JOptionPane.PLAIN_MESSAGE, icon,
              possibilities, "ham");

          // If a string was returned, say so.
          if ((s != null) && (s.length() > 0)) {
            setLabel("Green eggs and... " + s + "!");
            return;
          }

          // If you're here, the return value was null/empty.
          setLabel("Come on, finish the sentence!");

          // text input
        } else if (command == textEnteredCommand) {
          String s = (String) JOptionPane
              .showInputDialog(frame, "Complete the sentence:\n"
                  + "\"Green eggs and...\"", "Customized Dialog",
                  JOptionPane.PLAIN_MESSAGE, icon, null, "ham");

          // If a string was returned, say so.
          if ((s != null) && (s.length() > 0)) {
            setLabel("Green eggs and... " + s + "!");
            return;
          }

          // If you're here, the return value was null/empty.
          setLabel("Come on, finish the sentence!");

          // non-auto-closing dialog
        } else if (command == nonAutoCommand) {
          final JOptionPane optionPane = new JOptionPane(
              "The only way to close this dialog is by\n"
                  + "pressing one of the following buttons.\n"
                  + "Do you understand?", JOptionPane.QUESTION_MESSAGE,
              JOptionPane.YES_NO_OPTION);

          // You can't use pane.createDialog() because that
          // method sets up the JDialog with a property change
          // listener that automatically closes the window
          // when a button is clicked.
          final JDialog dialog = new JDialog(frame, "Click a button", true);
          dialog.setContentPane(optionPane);
          dialog.setDefaultCloseOperation(JDialog.DO_NOTHING_ON_CLOSE);
          dialog.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent we) {
              setLabel("Thwarted user attempt to close window.");
            }
          });
          optionPane.addPropertyChangeListener(new PropertyChangeListener() {
            public void propertyChange(PropertyChangeEvent e) {
              String prop = e.getPropertyName();

              if (dialog.isVisible() && (e.getSource() == optionPane)
                  && (JOptionPane.VALUE_PROPERTY.equals(prop))) {
                // If you were going to check something
                // before closing the window, you'd do
                // it here.
                dialog.setVisible(false);
              }
            }
          });
          dialog.pack();
          dialog.setLocationRelativeTo(frame);
          dialog.setVisible(true);

          int value = ((Integer) optionPane.getValue()).intValue();
          if (value == JOptionPane.YES_OPTION) {
            setLabel("Good.");
          } else if (value == JOptionPane.NO_OPTION) {
            setLabel("Try using the window decorations "
                + "to close the non-auto-closing dialog. " + "You can't!");
          } else {
            setLabel("Window unavoidably closed (ESC?).");
          }

          // non-auto-closing dialog with custom message area
          // NOTE: if you don't intend to check the input,
          // then just use showInputDialog instead.
        } else if (command == customOptionCommand) {
          customDialog.setLocationRelativeTo(frame);
          customDialog.setVisible(true);

          String s = customDialog.getValidatedText();
          if (s != null) {
            // The text is valid.
            setLabel("Congratulations!  " + "You entered \"" + s + "\".");
          }

          // non-modal dialog
        } else if (command == nonModalCommand) {
          // Create the dialog.
          final JDialog dialog = new JDialog(frame, "A Non-Modal Dialog");

          // Add contents to it. It must have a close button,
          // since some L&Fs (notably Java/Metal) don't provide one
          // in the window decorations for dialogs.
          JLabel label = new JLabel("<html><p align=center>"
              + "This is a non-modal dialog.<br>"
              + "You can have one or more of these up<br>"
              + "and still use the main window.");
          label.setHorizontalAlignment(JLabel.CENTER);
          Font font = label.getFont();
          label.setFont(label.getFont().deriveFont(font.PLAIN, 14.0f));

          JButton closeButton = new JButton("Close");
          closeButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
              dialog.setVisible(false);
              dialog.dispose();
            }
          });
          JPanel closePanel = new JPanel();
          closePanel.setLayout(new BoxLayout(closePanel, BoxLayout.LINE_AXIS));
          closePanel.add(Box.createHorizontalGlue());
          closePanel.add(closeButton);
          closePanel.setBorder(BorderFactory.createEmptyBorder(0, 0, 5, 5));

          JPanel contentPane = new JPanel(new BorderLayout());
          contentPane.add(label, BorderLayout.CENTER);
          contentPane.add(closePanel, BorderLayout.PAGE_END);
          contentPane.setOpaque(true);
          dialog.setContentPane(contentPane);

          // Show it.
          dialog.setSize(new Dimension(300, 150));
          dialog.setLocationRelativeTo(frame);
          dialog.setVisible(true);
        }
      }
    });

    return createPane(moreDialogDesc + ":", radioButtons, showItButton);
  }

  /**
   * Create the GUI and show it. For thread safety, this method should be
   * invoked from the event-dispatching thread.
   */
  private static void createAndShowGUI() {
    // Create and set up the window.
    JFrame frame = new JFrame("DialogDemo");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    // Create and set up the content pane.
    DialogDemo newContentPane = new DialogDemo(frame);
    newContentPane.setOpaque(true); // content panes must be opaque
    frame.setContentPane(newContentPane);

    // Display the window.
    frame.pack();
    frame.setVisible(true);
  }

  public static void main(String[] args) {
    // Schedule a job for the event-dispatching thread:
    // creating and showing this application's GUI.
    javax.swing.SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        createAndShowGUI();
      }
    });
  }

}

/*
 * Copyright (c) 1995 - 2008 Sun Microsystems, Inc. All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *  - Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *  - Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *  - Neither the name of Sun Microsystems nor the names of its contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/* 1.4 example used by DialogDemo.java. */
class CustomDialog extends JDialog implements ActionListener,
    PropertyChangeListener {
  private String typedText = null;
  private JTextField textField;
  private DialogDemo dd;

  private String magicWord;
  private JOptionPane optionPane;

  private String btnString1 = "Enter";
  private String btnString2 = "Cancel";

  /**
   * Returns null if the typed string was invalid; otherwise, returns the string
   * as the user entered it.
   */
  public String getValidatedText() {
    return typedText;
  }

  /** Creates the reusable dialog. */
  public CustomDialog(Frame aFrame, String aWord, DialogDemo parent) {
    super(aFrame, true);
    dd = parent;

    magicWord = aWord.toUpperCase();
    setTitle("Quiz");

    textField = new JTextField(10);

    // Create an array of the text and components to be displayed.
    String msgString1 = "What was Dr. SEUSS's real last name?";
    String msgString2 = "(The answer is \"" + magicWord + "\".)";
    Object[] array = { msgString1, msgString2, textField };

    // Create an array specifying the number of dialog buttons
    // and their text.
    Object[] options = { btnString1, btnString2 };

    // Create the JOptionPane.
    optionPane = new JOptionPane(array, JOptionPane.QUESTION_MESSAGE,
        JOptionPane.YES_NO_OPTION, null, options, options[0]);

    // Make this dialog display it.
    setContentPane(optionPane);

    // Handle window closing correctly.
    setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
    addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent we) {
        /*
         * Instead of directly closing the window, we're going to change the
         * JOptionPane's value property.
         */
        optionPane.setValue(new Integer(JOptionPane.CLOSED_OPTION));
      }
    });

    // Ensure the text field always gets the first focus.
    addComponentListener(new ComponentAdapter() {
      public void componentShown(ComponentEvent ce) {
        textField.requestFocusInWindow();
      }
    });

    // Register an event handler that puts the text into the option pane.
    textField.addActionListener(this);

    // Register an event handler that reacts to option pane state changes.
    optionPane.addPropertyChangeListener(this);
  }

  /** This method handles events for the text field. */
  public void actionPerformed(ActionEvent e) {
    optionPane.setValue(btnString1);
  }

  /** This method reacts to state changes in the option pane. */
  public void propertyChange(PropertyChangeEvent e) {
    String prop = e.getPropertyName();

    if (isVisible()
        && (e.getSource() == optionPane)
        && (JOptionPane.VALUE_PROPERTY.equals(prop) || JOptionPane.INPUT_VALUE_PROPERTY
            .equals(prop))) {
      Object value = optionPane.getValue();

      if (value == JOptionPane.UNINITIALIZED_VALUE) {
        // ignore reset
        return;
      }

      // Reset the JOptionPane's value.
      // If you don't do this, then if the user
      // presses the same button next time, no
      // property change event will be fired.
      optionPane.setValue(JOptionPane.UNINITIALIZED_VALUE);

      if (btnString1.equals(value)) {
        typedText = textField.getText();
        String ucText = typedText.toUpperCase();
        if (magicWord.equals(ucText)) {
          // we're done; clear and dismiss the dialog
          clearAndHide();
        } else {
          // text was invalid
          textField.selectAll();
          JOptionPane.showMessageDialog(CustomDialog.this, "Sorry, \""
              + typedText + "\" " + "isn't a valid response.\n"
              + "Please enter " + magicWord + ".", "Try again",
              JOptionPane.ERROR_MESSAGE);
          typedText = null;
          textField.requestFocusInWindow();
        }
      } else { // user closed dialog or clicked cancel
        dd.setLabel("It's OK.  " + "We won't force you to type " + magicWord
            + ".");
        typedText = null;
        clearAndHide();
      }
    }
  }

  /** This method clears the dialog and hides it. */
  public void clearAndHide() {
    textField.setText(null);
    setVisible(false);
  }
}








14.74.JDialog
14.74.1.Dialog Introduction
14.74.2.A Simple Modal DialogA Simple Modal Dialog
14.74.3.JDialog is specify that pressing the Escape key cancels the dialog.JDialog is specify that pressing the Escape key cancels the dialog.
14.74.4.Address DialogAddress Dialog
14.74.5.Set Default Close Operation for Dialog
14.74.6.Extending JDialog
14.74.7.extends JDialog to create your own dialog
14.74.8.The base class for standard dialogs.
14.74.9.A dialog that presents the user with a sequence of steps for completing a task.
14.74.10.Positions the specified dialog at a position relative to its parent.
14.74.11.A dialog allow selection and a font and its associated info.
14.74.12.Font Chooser extends javax.swing.JDialog
14.74.13.FontChooser by Noah w
14.74.14.Dialog Panel