Source for javax.swing.JOptionPane

   1: /* JOptionPane.java
   2:    Copyright (C) 2004 Free Software Foundation, Inc.
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10: 
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 USA.
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version. */
  37: 
  38: 
  39: package javax.swing;
  40: 
  41: import java.awt.Component;
  42: import java.awt.Dimension;
  43: import java.awt.Frame;
  44: 
  45: import javax.accessibility.Accessible;
  46: import javax.accessibility.AccessibleContext;
  47: import javax.accessibility.AccessibleRole;
  48: import javax.swing.event.InternalFrameAdapter;
  49: import javax.swing.event.InternalFrameEvent;
  50: import javax.swing.plaf.OptionPaneUI;
  51: 
  52: /**
  53:  * This class creates different types of JDialogs and JInternalFrames that can
  54:  * ask users for input or pass on information. JOptionPane can be used by
  55:  * calling one of the show static methods or  by creating an instance of
  56:  * JOptionPane and calling createDialog or createInternalFrame.
  57:  */
  58: public class JOptionPane extends JComponent implements Accessible
  59: {
  60:   /**
  61:    * DOCUMENT ME!
  62:    */
  63:   protected class AccessibleJOptionPane extends JComponent.AccessibleJComponent
  64:   {
  65:     /** DOCUMENT ME! */
  66:     private static final long serialVersionUID = 686071432213084821L;
  67: 
  68:     /**
  69:      * Creates a new AccessibleJOptionPane object.
  70:      */
  71:     protected AccessibleJOptionPane()
  72:     {
  73:     }
  74: 
  75:     /**
  76:      * DOCUMENT ME!
  77:      *
  78:      * @return DOCUMENT ME!
  79:      */
  80:     public AccessibleRole getAccessibleRole()
  81:     {
  82:       return null;
  83:     }
  84:   }
  85: 
  86:   /** DOCUMENT ME! */
  87:   private static final long serialVersionUID = 5231143276678566796L;
  88: 
  89:   /** The value returned when cancel option is selected. */
  90:   public static final int CANCEL_OPTION = 2;
  91: 
  92:   /** The value returned when the dialog is closed without a selection. */
  93:   public static final int CLOSED_OPTION = -1;
  94: 
  95:   /** An option used in confirmation dialog methods. */
  96:   public static final int DEFAULT_OPTION = -1;
  97: 
  98:   /** The value returned when the no option is selected. */
  99:   public static final int NO_OPTION = 1;
 100: 
 101:   /** An option used in confirmation dialog methods. */
 102:   public static final int OK_CANCEL_OPTION = 2;
 103: 
 104:   /** The value returned when the ok option is selected. */
 105:   public static final int OK_OPTION = 0;
 106: 
 107:   /** An option used in confirmation dialog methods. */
 108:   public static final int YES_NO_CANCEL_OPTION = 1;
 109: 
 110:   /** An option used in confirmation dialog methods. */
 111:   public static final int YES_NO_OPTION = 0;
 112: 
 113:   /** The value returned when the yes option is selected. */
 114:   public static final int YES_OPTION = 0;
 115: 
 116:   /** Identifier for the error message type. */
 117:   public static final int ERROR_MESSAGE = 0;
 118: 
 119:   /** Identifier for the information message type. */
 120:   public static final int INFORMATION_MESSAGE = 1;
 121: 
 122:   /** Identifier for the plain message type. */
 123:   public static final int PLAIN_MESSAGE = -1;
 124: 
 125:   /** Identifier for the question message type. */
 126:   public static final int QUESTION_MESSAGE = 3;
 127: 
 128:   /** Identifier for the warning message type. */
 129:   public static final int WARNING_MESSAGE = 2;
 130: 
 131:   /**
 132:    * The identifier for the propertyChangeEvent when the icon property
 133:    * changes.
 134:    */
 135:   public static final String ICON_PROPERTY = "icon";
 136: 
 137:   /**
 138:    * The identifier for the propertyChangeEvent when the initialSelectionValue
 139:    * property changes.
 140:    */
 141:   public static final String INITIAL_SELECTION_VALUE_PROPERTY = "initialSelectionValue";
 142: 
 143:   /**
 144:    * The identifier for the propertyChangeEvent when the initialValue property
 145:    * changes.
 146:    */
 147:   public static final String INITIAL_VALUE_PROPERTY = "initialValue";
 148: 
 149:   /**
 150:    * The identifier for the propertyChangeEvent when the inputValue property
 151:    * changes.
 152:    */
 153:   public static final String INPUT_VALUE_PROPERTY = "inputValue";
 154: 
 155:   /**
 156:    * The identifier for the propertyChangeEvent when the message property
 157:    * changes.
 158:    */
 159:   public static final String MESSAGE_PROPERTY = "message";
 160: 
 161:   /**
 162:    * The identifier for the propertyChangeEvent when the messageType property
 163:    * changes.
 164:    */
 165:   public static final String MESSAGE_TYPE_PROPERTY = "messageType";
 166: 
 167:   /**
 168:    * The identifier for the propertyChangeEvent when the optionType property
 169:    * changes.
 170:    */
 171:   public static final String OPTION_TYPE_PROPERTY = "optionType";
 172: 
 173:   /**
 174:    * The identifier for the propertyChangeEvent when the options property
 175:    * changes.
 176:    */
 177:   public static final String OPTIONS_PROPERTY = "options";
 178: 
 179:   /**
 180:    * The identifier for the propertyChangeEvent when the selectionValues
 181:    * property changes.
 182:    */
 183:   public static final String SELECTION_VALUES_PROPERTY = "selectionValues";
 184: 
 185:   /**
 186:    * The identifier for the propertyChangeEvent when the value property
 187:    * changes.
 188:    */
 189:   public static final String VALUE_PROPERTY = "value";
 190: 
 191:   /**
 192:    * The identifier for the propertyChangeEvent when the wantsInput property
 193:    * changes.
 194:    */
 195:   public static final String WANTS_INPUT_PROPERTY = "wantsInput";
 196: 
 197:   /** The value returned when the inputValue is uninitialized. */
 198:   public static Object UNINITIALIZED_VALUE = "uninitializedValue";
 199: 
 200:   /** The icon displayed in the dialog/internal frame. */
 201:   protected Icon icon;
 202: 
 203:   /** The initial selected value in the input component. */
 204:   protected Object initialSelectionValue;
 205: 
 206:   /** The object that is initially selected for options. */
 207:   protected Object initialValue;
 208: 
 209:   /** The value the user inputs. */
 210:   protected Object inputValue = UNINITIALIZED_VALUE;
 211: 
 212:   /** The message displayed in the dialog/internal frame. */
 213:   protected Object message;
 214: 
 215:   /** The type of message displayed. */
 216:   protected int messageType = PLAIN_MESSAGE;
 217: 
 218:   /**
 219:    * The options (usually buttons) aligned at the bottom for the user to
 220:    * select.
 221:    */
 222:   protected Object[] options;
 223: 
 224:   /** The type of options to display. */
 225:   protected int optionType = DEFAULT_OPTION;
 226: 
 227:   /** The input values the user can select. */
 228:   protected Object[] selectionValues;
 229: 
 230:   /** The value returned by selecting an option. */
 231:   protected Object value = UNINITIALIZED_VALUE;
 232: 
 233:   /** Whether the Dialog/InternalFrame needs input. */
 234:   protected boolean wantsInput;
 235: 
 236:   /** The common frame used when no parent is provided. */
 237:   private static Frame privFrame = SwingUtilities.getOwnerFrame();
 238: 
 239:   /**
 240:    * Creates a new JOptionPane object using a message of "JOptionPane
 241:    * message", using the PLAIN_MESSAGE type and DEFAULT_OPTION.
 242:    */
 243:   public JOptionPane()
 244:   {
 245:     this("JOptionPane message", PLAIN_MESSAGE, DEFAULT_OPTION, null, null, null);
 246:   }
 247: 
 248:   /**
 249:    * Creates a new JOptionPane object using the given message using the
 250:    * PLAIN_MESSAGE type and DEFAULT_OPTION.
 251:    *
 252:    * @param message The message to display.
 253:    */
 254:   public JOptionPane(Object message)
 255:   {
 256:     this(message, PLAIN_MESSAGE, DEFAULT_OPTION, null, null, null);
 257:   }
 258: 
 259:   /**
 260:    * Creates a new JOptionPane object using the given message and messageType
 261:    * and DEFAULT_OPTION.
 262:    *
 263:    * @param message The message to display.
 264:    * @param messageType The type of message.
 265:    */
 266:   public JOptionPane(Object message, int messageType)
 267:   {
 268:     this(message, messageType, DEFAULT_OPTION, null, null, null);
 269:   }
 270: 
 271:   /**
 272:    * Creates a new JOptionPane object using the given message, messageType and
 273:    * optionType.
 274:    *
 275:    * @param message The message to display.
 276:    * @param messageType The type of message.
 277:    * @param optionType The type of options.
 278:    */
 279:   public JOptionPane(Object message, int messageType, int optionType)
 280:   {
 281:     this(message, messageType, optionType, null, null, null);
 282:   }
 283: 
 284:   /**
 285:    * Creates a new JOptionPane object using the given message, messageType,
 286:    * optionType and icon.
 287:    *
 288:    * @param message The message to display.
 289:    * @param messageType The type of message.
 290:    * @param optionType The type of options.
 291:    * @param icon The icon to display.
 292:    */
 293:   public JOptionPane(Object message, int messageType, int optionType, Icon icon)
 294:   {
 295:     this(message, messageType, optionType, icon, null, null);
 296:   }
 297: 
 298:   /**
 299:    * Creates a new JOptionPane object using the given message, messageType,
 300:    * optionType, icon and options.
 301:    *
 302:    * @param message The message to display.
 303:    * @param messageType The type of message.
 304:    * @param optionType The type of options.
 305:    * @param icon The icon to display.
 306:    * @param options The options given.
 307:    */
 308:   public JOptionPane(Object message, int messageType, int optionType,
 309:                      Icon icon, Object[] options)
 310:   {
 311:     this(message, messageType, optionType, icon, options, null);
 312:   }
 313: 
 314:   /**
 315:    * Creates a new JOptionPane object using the given message, messageType,
 316:    * optionType, icon, options and initialValue. The initialValue will be
 317:    * focused initially.
 318:    *
 319:    * @param message The message to display.
 320:    * @param messageType The type of message.
 321:    * @param optionType The type of options.
 322:    * @param icon The icon to display.
 323:    * @param options The options given.
 324:    * @param initialValue The component to focus on initially.
 325:    *
 326:    * @throws IllegalArgumentException If the messageType or optionType are not
 327:    *         legal values.
 328:    */
 329:   public JOptionPane(Object message, int messageType, int optionType,
 330:                      Icon icon, Object[] options, Object initialValue)
 331:   {
 332:     this.message = message;
 333:     if (! validMessageType(messageType))
 334:       throw new IllegalArgumentException("Message Type not legal value.");
 335:     this.messageType = messageType;
 336:     if (! validOptionType(optionType))
 337:       throw new IllegalArgumentException("Option Type not legal value.");
 338:     this.optionType = optionType;
 339:     this.icon = icon;
 340:     this.options = options;
 341:     this.initialValue = initialValue;
 342: 
 343:     setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
 344: 
 345:     updateUI();
 346:     invalidate();
 347:     repaint();
 348:   }
 349: 
 350:   /**
 351:    * This method creates a new JDialog that is either centered around the
 352:    * parent's frame or centered on the screen (if the parent is null). The
 353:    * JDialog will not be resizable and will be modal. Once the JDialog is
 354:    * disposed, the inputValue and value properties will  be set by the
 355:    * optionPane.
 356:    *
 357:    * @param parentComponent The parent of the Dialog.
 358:    * @param title The title in the bar of the JDialog.
 359:    *
 360:    * @return A new JDialog based on the JOptionPane configuration.
 361:    */
 362:   public JDialog createDialog(Component parentComponent, String title)
 363:   {
 364:     Frame toUse = getFrameForComponent(parentComponent);
 365:     if (toUse == null)
 366:       toUse = getRootFrame();
 367: 
 368:     JDialog dialog = new JDialog(toUse, title);
 369:     inputValue = UNINITIALIZED_VALUE;
 370:     value = UNINITIALIZED_VALUE;
 371: 
 372:     // FIXME: This dialog should be centered on the parent
 373:     // or at the center of the screen (if the parent is null)
 374:     // Need getGraphicsConfiguration to return non-null in
 375:     // order for that to work so we know how large the 
 376:     // screen is.
 377:     dialog.getContentPane().add(this);
 378:     dialog.setModal(true);
 379:     dialog.setResizable(false);
 380:     dialog.invalidate();
 381:     dialog.repaint();
 382: 
 383:     return dialog;
 384:   }
 385: 
 386:   /**
 387:    * This method creates a new JInternalFrame that is in the JLayeredPane
 388:    * which contains the parentComponent given. If no suitable JLayeredPane
 389:    * can be found from the parentComponent given, a RuntimeException will be
 390:    * thrown.
 391:    *
 392:    * @param parentComponent The parent to find a JDesktopPane from.
 393:    * @param title The title of the JInternalFrame.
 394:    *
 395:    * @return A new JInternalFrame based on the JOptionPane configuration.
 396:    *
 397:    * @throws RuntimeException If no suitable JDesktopPane is found.
 398:    *
 399:    * @specnote The specification says that the internal frame is placed
 400:    *           in the nearest <code>JDesktopPane</code> that is found in
 401:    *           <code>parent</code>'s ancestors. The behaviour of the JDK
 402:    *           is that it actually looks up the nearest
 403:    *           <code>JLayeredPane</code> in <code>parent</code>'s ancestors.
 404:    *           So do we.
 405:    */
 406:   public JInternalFrame createInternalFrame(Component parentComponent,
 407:                                             String title)
 408:                                      throws RuntimeException
 409:   {
 410:     // Try to find a JDesktopPane.
 411:     JLayeredPane toUse = getDesktopPaneForComponent(parentComponent);
 412:     // If we don't have a JDesktopPane, we try to find a JLayeredPane.
 413:     if (toUse == null)
 414:       toUse = JLayeredPane.getLayeredPaneAbove(parentComponent);
 415:     // If this still fails, we throw a RuntimeException.
 416:     if (toUse == null)
 417:       throw new RuntimeException
 418:         ("parentComponent does not have a valid parent");
 419: 
 420:     JInternalFrame frame = new JInternalFrame(title);
 421: 
 422:     inputValue = UNINITIALIZED_VALUE;
 423:     value = UNINITIALIZED_VALUE;
 424: 
 425:     frame.setContentPane(this);
 426:     frame.setClosable(true);
 427: 
 428:     toUse.add(frame);
 429:     frame.setLayer(JLayeredPane.MODAL_LAYER);
 430: 
 431:     frame.pack();
 432:     frame.setVisible(true);
 433: 
 434:     return frame;
 435:   }
 436: 
 437:   /**
 438:    * DOCUMENT ME!
 439:    *
 440:    * @return DOCUMENT ME!
 441:    */
 442:   public AccessibleContext getAccessibleContext()
 443:   {
 444:     if (accessibleContext == null)
 445:       accessibleContext = new AccessibleJOptionPane();
 446:     return accessibleContext;
 447:   }
 448: 
 449:   /**
 450:    * This method returns the JDesktopPane for the given parentComponent or
 451:    * null if none can be found.
 452:    *
 453:    * @param parentComponent The component to look in.
 454:    *
 455:    * @return The JDesktopPane for the given component or null if none can be
 456:    *         found.
 457:    */
 458:   public static JDesktopPane getDesktopPaneForComponent(Component parentComponent)
 459:   {
 460:     return (JDesktopPane) SwingUtilities.getAncestorOfClass(JDesktopPane.class,
 461:                                                             parentComponent);
 462:   }
 463: 
 464:   /**
 465:    * This method returns the Frame for the given parentComponent or null if
 466:    * none can be found.
 467:    *
 468:    * @param parentComponent The component to look in.
 469:    *
 470:    * @return The Frame for the given component or null if none can be found.
 471:    */
 472:   public static Frame getFrameForComponent(Component parentComponent)
 473:   {
 474:     return (Frame) SwingUtilities.getAncestorOfClass(Frame.class,
 475:                                                      parentComponent);
 476:   }
 477: 
 478:   /**
 479:    * This method returns the icon displayed.
 480:    *
 481:    * @return The icon displayed.
 482:    */
 483:   public Icon getIcon()
 484:   {
 485:     return icon;
 486:   }
 487: 
 488:   /**
 489:    * This method returns the value initially selected from the list of values
 490:    * the user can input.
 491:    *
 492:    * @return The initial selection value.
 493:    */
 494:   public Object getInitialSelectionValue()
 495:   {
 496:     return initialSelectionValue;
 497:   }
 498: 
 499:   /**
 500:    * This method returns the value that is focused from the list of options.
 501:    *
 502:    * @return The initial value from options.
 503:    */
 504:   public Object getInitialValue()
 505:   {
 506:     return initialValue;
 507:   }
 508: 
 509:   /**
 510:    * This method returns the value that the user input.
 511:    *
 512:    * @return The user's input value.
 513:    */
 514:   public Object getInputValue()
 515:   {
 516:     return inputValue;
 517:   }
 518: 
 519:   /**
 520:    * This method returns the maximum characters per line. By default, this is
 521:    * Integer.MAX_VALUE.
 522:    *
 523:    * @return The maximum characters per line.
 524:    */
 525:   public int getMaxCharactersPerLineCount()
 526:   {
 527:     return Integer.MAX_VALUE;
 528:   }
 529: 
 530:   /**
 531:    * This method returns the message displayed.
 532:    *
 533:    * @return The message displayed.
 534:    */
 535:   public Object getMessage()
 536:   {
 537:     return message;
 538:   }
 539: 
 540:   /**
 541:    * This method returns the message type.
 542:    *
 543:    * @return The message type.
 544:    */
 545:   public int getMessageType()
 546:   {
 547:     return messageType;
 548:   }
 549: 
 550:   /**
 551:    * This method returns the options.
 552:    *
 553:    * @return The options.
 554:    */
 555:   public Object[] getOptions()
 556:   {
 557:     return options;
 558:   }
 559: 
 560:   /**
 561:    * This method returns the option type.
 562:    *
 563:    * @return The option type.
 564:    */
 565:   public int getOptionType()
 566:   {
 567:     return optionType;
 568:   }
 569: 
 570:   /**
 571:    * This method returns the Frame used by JOptionPane dialog's that have no
 572:    * parent.
 573:    *
 574:    * @return The Frame used by dialogs that have no parent.
 575:    */
 576:   public static Frame getRootFrame()
 577:   {
 578:     return privFrame;
 579:   }
 580: 
 581:   /**
 582:    * This method returns the selection values.
 583:    *
 584:    * @return The selection values.
 585:    */
 586:   public Object[] getSelectionValues()
 587:   {
 588:     return selectionValues;
 589:   }
 590: 
 591:   /**
 592:    * This method returns the UI used by the JOptionPane.
 593:    *
 594:    * @return The UI used by the JOptionPane.
 595:    */
 596:   public OptionPaneUI getUI()
 597:   {
 598:     return (OptionPaneUI) ui;
 599:   }
 600: 
 601:   /**
 602:    * This method returns an identifier to determine which UI class will act as
 603:    * the UI.
 604:    *
 605:    * @return The UI identifier.
 606:    */
 607:   public String getUIClassID()
 608:   {
 609:     return "OptionPaneUI";
 610:   }
 611: 
 612:   /**
 613:    * This method returns the value that the user selected out of options.
 614:    *
 615:    * @return The value that the user selected out of options.
 616:    */
 617:   public Object getValue()
 618:   {
 619:     return value;
 620:   }
 621: 
 622:   /**
 623:    * This method returns whether this JOptionPane wants input.
 624:    *
 625:    * @return Whether this JOptionPane wants input.
 626:    */
 627:   public boolean getWantsInput()
 628:   {
 629:     return wantsInput;
 630:   }
 631: 
 632:   /**
 633:    * This method returns a String that describes this JOptionPane.
 634:    *
 635:    * @return A String that describes this JOptionPane.
 636:    */
 637:   protected String paramString()
 638:   {
 639:     return "JOptionPane";
 640:   }
 641: 
 642:   /**
 643:    * This method requests focus for the initial value.
 644:    */
 645:   public void selectInitialValue()
 646:   {
 647:     if (ui != null)
 648:       ((OptionPaneUI) ui).selectInitialValue(this);
 649:   }
 650: 
 651:   /**
 652:    * This method changes the icon property.
 653:    *
 654:    * @param newIcon The new icon to use.
 655:    */
 656:   public void setIcon(Icon newIcon)
 657:   {
 658:     if (icon != newIcon)
 659:       {
 660:     Icon old = icon;
 661:     icon = newIcon;
 662:     firePropertyChange(ICON_PROPERTY, old, icon);
 663:       }
 664:   }
 665: 
 666:   /**
 667:    * This method changes the initial selection property.
 668:    *
 669:    * @param newValue The new initial selection.
 670:    */
 671:   public void setInitialSelectionValue(Object newValue)
 672:   {
 673:     if (initialSelectionValue != newValue)
 674:       {
 675:     Object old = initialSelectionValue;
 676:     initialSelectionValue = newValue;
 677:     firePropertyChange(INITIAL_SELECTION_VALUE_PROPERTY, old,
 678:                        initialSelectionValue);
 679:       }
 680:   }
 681: 
 682:   /**
 683:    * This method changes the initial value property.
 684:    *
 685:    * @param newValue The new initial value.
 686:    */
 687:   public void setInitialValue(Object newValue)
 688:   {
 689:     if (initialValue != newValue)
 690:       {
 691:     Object old = initialValue;
 692:     initialValue = newValue;
 693:     firePropertyChange(INITIAL_VALUE_PROPERTY, old, initialValue);
 694:       }
 695:   }
 696: 
 697:   /**
 698:    * This method changes the inputValue property.
 699:    *
 700:    * @param newValue The new inputValue.
 701:    */
 702:   public void setInputValue(Object newValue)
 703:   {
 704:     if (inputValue != newValue)
 705:       {
 706:     Object old = inputValue;
 707:     inputValue = newValue;
 708:     firePropertyChange(INPUT_VALUE_PROPERTY, old, inputValue);
 709:       }
 710:   }
 711: 
 712:   /**
 713:    * This method changes the message property.
 714:    *
 715:    * @param newMessage The new message.
 716:    */
 717:   public void setMessage(Object newMessage)
 718:   {
 719:     if (message != newMessage)
 720:       {
 721:     Object old = message;
 722:     message = newMessage;
 723:     firePropertyChange(MESSAGE_PROPERTY, old, message);
 724:       }
 725:   }
 726: 
 727:   /**
 728:    * This method changes the messageType property.
 729:    *
 730:    * @param newType The new messageType.
 731:    *
 732:    * @throws IllegalArgumentException If the messageType is not valid.
 733:    */
 734:   public void setMessageType(int newType)
 735:   {
 736:     if (! validMessageType(newType))
 737:       throw new IllegalArgumentException("Message Type not legal value.");
 738:     if (newType != messageType)
 739:       {
 740:     int old = messageType;
 741:     messageType = newType;
 742:     firePropertyChange(MESSAGE_TYPE_PROPERTY, old, messageType);
 743:       }
 744:   }
 745: 
 746:   /**
 747:    * This method changes the options property.
 748:    *
 749:    * @param newOptions The new options.
 750:    */
 751:   public void setOptions(Object[] newOptions)
 752:   {
 753:     if (options != newOptions)
 754:       {
 755:     Object[] old = options;
 756:     options = newOptions;
 757:     firePropertyChange(OPTIONS_PROPERTY, old, options);
 758:       }
 759:   }
 760: 
 761:   /**
 762:    * This method changes the optionType property.
 763:    *
 764:    * @param newType The new optionType.
 765:    *
 766:    * @throws IllegalArgumentException If the optionType is not valid.
 767:    */
 768:   public void setOptionType(int newType)
 769:   {
 770:     if (! validOptionType(newType))
 771:       throw new IllegalArgumentException("Option Type not legal value.");
 772:     if (newType != optionType)
 773:       {
 774:     int old = optionType;
 775:     optionType = newType;
 776:     firePropertyChange(OPTION_TYPE_PROPERTY, old, optionType);
 777:       }
 778:   }
 779: 
 780:   /**
 781:    * This method changes the Frame used for JOptionPane dialogs that have no
 782:    * parent.
 783:    *
 784:    * @param newRootFrame The Frame to use for dialogs that have no parent.
 785:    */
 786:   public static void setRootFrame(Frame newRootFrame)
 787:   {
 788:     privFrame = newRootFrame;
 789:   }
 790: 
 791:   /**
 792:    * This method changes the selectionValues property.
 793:    *
 794:    * @param newValues The new selectionValues.
 795:    */
 796:   public void setSelectionValues(Object[] newValues)
 797:   {
 798:     if (newValues != selectionValues)
 799:       {
 800:     if (newValues != null)
 801:       wantsInput = true;
 802:     Object[] old = selectionValues;
 803:     selectionValues = newValues;
 804:     firePropertyChange(SELECTION_VALUES_PROPERTY, old, selectionValues);
 805:       }
 806:   }
 807: 
 808:   /**
 809:    * This method sets the UI used with the JOptionPane.
 810:    *
 811:    * @param ui The UI used with the JOptionPane.
 812:    */
 813:   public void setUI(OptionPaneUI ui)
 814:   {
 815:     super.setUI(ui);
 816:   }
 817: 
 818:   /**
 819:    * This method sets the value has been selected out of options.
 820:    *
 821:    * @param newValue The value that has been selected out of options.
 822:    */
 823:   public void setValue(Object newValue)
 824:   {
 825:     if (value != newValue)
 826:       {
 827:     Object old = value;
 828:     value = newValue;
 829:     firePropertyChange(VALUE_PROPERTY, old, value);
 830:       }
 831:   }
 832: 
 833:   /**
 834:    * This method changes the wantsInput property.
 835:    *
 836:    * @param newValue Whether this JOptionPane requires input.
 837:    */
 838:   public void setWantsInput(boolean newValue)
 839:   {
 840:     if (wantsInput != newValue)
 841:       {
 842:     boolean old = wantsInput;
 843:     wantsInput = newValue;
 844:     firePropertyChange(WANTS_INPUT_PROPERTY, old, wantsInput);
 845:       }
 846:   }
 847: 
 848:   /**
 849:    * This method shows a confirmation dialog with the title "Select an Option"
 850:    * and displays the given message. The parent frame will be the same as the
 851:    * parent frame of the given parentComponent. This method returns the
 852:    * option chosen by the user.
 853:    *
 854:    * @param parentComponent The parentComponent to find a frame in.
 855:    * @param message The message to display.
 856:    *
 857:    * @return The option that was selected.
 858:    */
 859:   public static int showConfirmDialog(Component parentComponent, Object message)
 860:   {
 861:     JOptionPane pane = new JOptionPane(message);
 862:     JDialog dialog = pane.createDialog(parentComponent, "Select an Option");
 863: 
 864:     dialog.pack();
 865:     dialog.show();
 866: 
 867:     return ((Integer) pane.getValue()).intValue();
 868:   }
 869: 
 870:   /**
 871:    * This method shows a confirmation dialog with the given message,
 872:    * optionType and title. The frame that owns the dialog will be the same
 873:    * frame that holds the given parentComponent. This method returns the
 874:    * option that was chosen.
 875:    *
 876:    * @param parentComponent The component to find a frame in.
 877:    * @param message The message displayed.
 878:    * @param title The title of the dialog.
 879:    * @param optionType The optionType.
 880:    *
 881:    * @return The option that was chosen.
 882:    */
 883:   public static int showConfirmDialog(Component parentComponent,
 884:                                       Object message, String title,
 885:                                       int optionType)
 886:   {
 887:     JOptionPane pane = new JOptionPane(message, PLAIN_MESSAGE, optionType);
 888:     JDialog dialog = pane.createDialog(parentComponent, title);
 889:     dialog.pack();
 890:     dialog.show();
 891: 
 892:     return ((Integer) pane.getValue()).intValue();
 893:   }
 894: 
 895:   /**
 896:    * This method shows a confirmation dialog with the given message, title,
 897:    * messageType and optionType. The frame owner will be the same frame as
 898:    * the one that holds the given parentComponent. This method returns the
 899:    * option selected by the user.
 900:    *
 901:    * @param parentComponent The component to find a frame in.
 902:    * @param message The message displayed.
 903:    * @param title The title of the dialog.
 904:    * @param optionType The optionType.
 905:    * @param messageType The messageType.
 906:    *
 907:    * @return The selected option.
 908:    */
 909:   public static int showConfirmDialog(Component parentComponent,
 910:                                       Object message, String title,
 911:                                       int optionType, int messageType)
 912:   {
 913:     JOptionPane pane = new JOptionPane(message, messageType, optionType);
 914:     JDialog dialog = pane.createDialog(parentComponent, title);
 915:     dialog.pack();
 916:     dialog.show();
 917: 
 918:     return ((Integer) pane.getValue()).intValue();
 919:   }
 920: 
 921:   /**
 922:    * This method shows a confirmation dialog with the given message, title,
 923:    * optionType, messageType and icon. The frame owner will be the same as
 924:    * the one that holds the given parentComponent. This method returns the
 925:    * option selected by the user.
 926:    *
 927:    * @param parentComponent The component to find a frame in.
 928:    * @param message The message displayed.
 929:    * @param title The title of the dialog.
 930:    * @param optionType The optionType.
 931:    * @param messageType The messsageType.
 932:    * @param icon The icon displayed.
 933:    *
 934:    * @return The selected option.
 935:    */
 936:   public static int showConfirmDialog(Component parentComponent,
 937:                                       Object message, String title,
 938:                                       int optionType, int messageType,
 939:                                       Icon icon)
 940:   {
 941:     JOptionPane pane = new JOptionPane(message, messageType, optionType, icon);
 942:     JDialog dialog = pane.createDialog(parentComponent, title);
 943:     dialog.pack();
 944:     dialog.show();
 945: 
 946:     return ((Integer) pane.getValue()).intValue();
 947:   }
 948: 
 949:   /**
 950:    * This method will show a QUESTION_MESSAGE input dialog with the given
 951:    * message. No selectionValues is set so the Look and Feel will usually
 952:    * give the user a TextField to fill out. The frame owner will be the same
 953:    * frame that holds the given parentComponent. This method will return the
 954:    * value entered by the user.
 955:    *
 956:    * @param parentComponent The component to find a frame in.
 957:    * @param message The message displayed.
 958:    *
 959:    * @return The value entered by the user.
 960:    */
 961:   public static String showInputDialog(Component parentComponent,
 962:                                        Object message)
 963:   {
 964:     JOptionPane pane = new JOptionPane(message, QUESTION_MESSAGE);
 965:     pane.setWantsInput(true);
 966:     JDialog dialog = pane.createDialog(parentComponent, null);
 967:     dialog.pack();
 968:     dialog.show();
 969: 
 970:     return (String) pane.getInputValue();
 971:   }
 972: 
 973:   /**
 974:    * This method will show a QUESTION_MESSAGE type input dialog with the given
 975:    * message and initialSelectionValue. Since there is no selectionValues
 976:    * set, the Look and Feel will usually give a TextField to fill out. The
 977:    * frame owner will be the same as the one that holds the given
 978:    * parentComponent. This method will return the value entered by the user.
 979:    *
 980:    * @param parentComponent The component to find a frame in.
 981:    * @param message The message to display.
 982:    * @param initialSelectionValue The initially selected value.
 983:    *
 984:    * @return The value the user input.
 985:    */
 986:   public static String showInputDialog(Component parentComponent,
 987:                                        Object message,
 988:                                        Object initialSelectionValue)
 989:   {
 990:     JOptionPane pane = new JOptionPane(message, QUESTION_MESSAGE);
 991:     pane.setInitialSelectionValue(initialSelectionValue);
 992:     pane.setWantsInput(true);
 993:     JDialog dialog = pane.createDialog(parentComponent, null);
 994:     dialog.pack();
 995:     dialog.show();
 996: 
 997:     return (String) pane.getInputValue();
 998:   }
 999: 
1000:   /**
1001:    * This method displays a new input dialog with the given message, title and
1002:    * messageType. Since no selectionValues value is given, the Look and Feel
1003:    * will usually give the user a TextField to input data to. This method
1004:    * returns the value the user inputs.
1005:    *
1006:    * @param parentComponent The component to find a frame in.
1007:    * @param message The message to display.
1008:    * @param title The title of the dialog.
1009:    * @param messageType The messageType.
1010:    *
1011:    * @return The value the user input.
1012:    */
1013:   public static String showInputDialog(Component parentComponent,
1014:                                        Object message, String title,
1015:                                        int messageType)
1016:   {
1017:     JOptionPane pane = new JOptionPane(message, messageType);
1018:     pane.setWantsInput(true);
1019:     JDialog dialog = pane.createDialog(parentComponent, title);
1020:     dialog.pack();
1021:     dialog.show();
1022: 
1023:     return (String) pane.getInputValue();
1024:   }
1025: 
1026:   /**
1027:    * This method shows an input dialog with the given message, title,
1028:    * messageType, icon, selectionValues, and initialSelectionValue. This
1029:    * method returns the value that the user selects.
1030:    *
1031:    * @param parentComponent The component to find a frame in.
1032:    * @param message The message displayed.
1033:    * @param title The title of the dialog.
1034:    * @param messageType The messageType.
1035:    * @param icon The icon displayed.
1036:    * @param selectionValues The list of values to select from.
1037:    * @param initialSelectionValue The initially selected value.
1038:    *
1039:    * @return The user selected value.
1040:    */
1041:   public static Object showInputDialog(Component parentComponent,
1042:                                        Object message, String title,
1043:                                        int messageType, Icon icon,
1044:                                        Object[] selectionValues,
1045:                                        Object initialSelectionValue)
1046:   {
1047:     JOptionPane pane = new JOptionPane(message, messageType);
1048:     pane.setWantsInput(true);
1049:     pane.setIcon(icon);
1050:     pane.setSelectionValues(selectionValues);
1051:     pane.setInitialSelectionValue(initialSelectionValue);
1052:     JDialog dialog = pane.createDialog(parentComponent, title);
1053:     dialog.pack();
1054:     dialog.show();
1055: 
1056:     return (String) pane.getInputValue();
1057:   }
1058: 
1059:   /**
1060:    * This method shows a QUESTION_MESSAGE type input dialog. Since no
1061:    * selectionValues is set, the Look and Feel will usually give the user a
1062:    * TextField to input data to. This method returns the value the user
1063:    * inputs.
1064:    *
1065:    * @param message The message to display.
1066:    *
1067:    * @return The user selected value.
1068:    */
1069:   public static String showInputDialog(Object message)
1070:   {
1071:     JOptionPane pane = new JOptionPane(message, QUESTION_MESSAGE);
1072:     pane.setWantsInput(true);
1073:     JDialog dialog = pane.createDialog(null, null);
1074:     dialog.pack();
1075:     dialog.show();
1076: 
1077:     return (String) pane.getInputValue();
1078:   }
1079: 
1080:   /**
1081:    * This method shows a QUESTION_MESSAGE type input dialog. Since no
1082:    * selectionValues is set, the Look and Feel will usually give the user a
1083:    * TextField to input data to. The input component will be initialized with
1084:    * the initialSelectionValue. This method returns the value the user
1085:    * inputs.
1086:    *
1087:    * @param message The message to display.
1088:    * @param initialSelectionValue The initialSelectionValue.
1089:    *
1090:    * @return The user selected value.
1091:    */
1092:   public static String showInputDialog(Object message,
1093:                                        Object initialSelectionValue)
1094:   {
1095:     JOptionPane pane = new JOptionPane(message, QUESTION_MESSAGE);
1096:     pane.setWantsInput(true);
1097:     pane.setInitialSelectionValue(initialSelectionValue);
1098:     JDialog dialog = pane.createDialog(null, null);
1099:     dialog.pack();
1100:     dialog.show();
1101: 
1102:     return (String) pane.getInputValue();
1103:   }
1104: 
1105:   /**
1106:    * This method shows an internal confirmation dialog with the given message.
1107:    * The internal frame dialog will be placed in the first JDesktopPane
1108:    * ancestor of the given parentComponent. This method will return the value
1109:    * selected.
1110:    *
1111:    * @param parentComponent The parent to find a JDesktopPane in.
1112:    * @param message The message to display.
1113:    *
1114:    * @return The value selected.
1115:    */
1116:   public static int showInternalConfirmDialog(Component parentComponent,
1117:                                               Object message)
1118:   {
1119:     JOptionPane pane = new JOptionPane(message);
1120:     JInternalFrame frame = pane.createInternalFrame(parentComponent, null);
1121: 
1122:     startModal(frame);
1123: 
1124:     return ((Integer) pane.getValue()).intValue();
1125:   }
1126: 
1127:   /**
1128:    * This method shows an internal confirmation dialog with the given message,
1129:    * optionType and title. The internal frame dialog will be placed in the
1130:    * first JDesktopPane ancestor of the given parentComponent.  This method
1131:    * will return the selected value.
1132:    *
1133:    * @param parentComponent The parent to find a JDesktopPane in.
1134:    * @param message The message to display.
1135:    * @param title The title to display.
1136:    * @param optionType The option type.
1137:    *
1138:    * @return The selected value.
1139:    */
1140:   public static int showInternalConfirmDialog(Component parentComponent,
1141:                                               Object message, String title,
1142:                                               int optionType)
1143:   {
1144:     JOptionPane pane = new JOptionPane(message, PLAIN_MESSAGE, optionType);
1145:     JInternalFrame frame = pane.createInternalFrame(parentComponent, title);
1146: 
1147:     startModal(frame);
1148: 
1149:     return ((Integer) pane.getValue()).intValue();
1150:   }
1151: 
1152:   /**
1153:    * This method shows an internal confirmation dialog with the given message,
1154:    * title, optionTypes and icon for the given message type. The internal
1155:    * confirmation dialog will be placed in the first  instance of
1156:    * JDesktopPane ancestor of the given parentComponent.
1157:    *
1158:    * @param parentComponent The component to find a JDesktopPane in.
1159:    * @param message The message to display.
1160:    * @param title The title of the dialog.
1161:    * @param optionType The option type.
1162:    * @param messageType The message type.
1163:    *
1164:    * @return The selected value.
1165:    */
1166:   public static int showInternalConfirmDialog(Component parentComponent,
1167:                                               Object message, String title,
1168:                                               int optionType, int messageType)
1169:   {
1170:     JOptionPane pane = new JOptionPane(message, messageType, optionType);
1171:     JInternalFrame frame = pane.createInternalFrame(parentComponent, title);
1172: 
1173:     startModal(frame);
1174: 
1175:     return ((Integer) pane.getValue()).intValue();
1176:   }
1177: 
1178:   /**
1179:    * This method shows an internal confirmation dialog with the given message,
1180:    * title, option type, message type, and icon. The internal frame dialog
1181:    * will be placed in the first JDesktopPane ancestor  that is found in the
1182:    * given parentComponent. This method returns  the selected value.
1183:    *
1184:    * @param parentComponent The parent to find a JDesktopPane in.
1185:    * @param message The message to display.
1186:    * @param title The title to display.
1187:    * @param optionType The option type.
1188:    * @param messageType The message type.
1189:    * @param icon The icon to display.
1190:    *
1191:    * @return The selected value.
1192:    */
1193:   public static int showInternalConfirmDialog(Component parentComponent,
1194:                                               Object message, String title,
1195:                                               int optionType, int messageType,
1196:                                               Icon icon)
1197:   {
1198:     JOptionPane pane = new JOptionPane(message, messageType, optionType, icon);
1199:     JInternalFrame frame = pane.createInternalFrame(parentComponent, title);
1200: 
1201:     startModal(frame);
1202: 
1203:     return ((Integer) pane.getValue()).intValue();
1204:   }
1205: 
1206:   /**
1207:    * This method shows an internal input dialog with the given message. The
1208:    * internal frame dialog will be placed in the first JDesktopPane ancestor
1209:    * of the given parent component. This method returns the value input by
1210:    * the user.
1211:    *
1212:    * @param parentComponent The parent to find a JDesktopPane in.
1213:    * @param message The message to display.
1214:    *
1215:    * @return The user selected value.
1216:    */
1217:   public static String showInternalInputDialog(Component parentComponent,
1218:                                                Object message)
1219:   {
1220:     JOptionPane pane = new JOptionPane(message);
1221:     pane.setWantsInput(true);
1222:     JInternalFrame frame = pane.createInternalFrame(parentComponent, null);
1223: 
1224:     startModal(frame);
1225: 
1226:     return (String) pane.getInputValue();
1227:   }
1228: 
1229:   /**
1230:    * This method shows an internal input dialog with the given message,  title
1231:    * and message type. The internal input dialog will be placed in the first
1232:    * JDesktopPane ancestor found in the given parent component. This method
1233:    * will return the input value given by the user.
1234:    *
1235:    * @param parentComponent The component to find a JDesktopPane in.
1236:    * @param message The message to display.
1237:    * @param title The title to display.
1238:    * @param messageType The message type.
1239:    *
1240:    * @return The user input value.
1241:    */
1242:   public static String showInternalInputDialog(Component parentComponent,
1243:                                                Object message, String title,
1244:                                                int messageType)
1245:   {
1246:     JOptionPane pane = new JOptionPane(message, messageType);
1247:     pane.setWantsInput(true);
1248:     JInternalFrame frame = pane.createInternalFrame(parentComponent, title);
1249: 
1250:     startModal(frame);
1251: 
1252:     return (String) pane.getInputValue();
1253:   }
1254: 
1255:   /**
1256:    * This method shows an internal input dialog with the given message, title
1257:    * message type, icon, selection value list and initial selection value.
1258:    * The internal frame dialog will be placed in the first JDesktopPane
1259:    * ancestor found in the given parent component. This method returns the
1260:    * input value from the user.
1261:    *
1262:    * @param parentComponent The parent to find a JDesktopPane in.
1263:    * @param message The message to display.
1264:    * @param title The title to display.
1265:    * @param messageType The message type.
1266:    * @param icon The icon to display.
1267:    * @param selectionValues The selection value list.
1268:    * @param initialSelectionValue The initial selection value.
1269:    *
1270:    * @return The user input value.
1271:    */
1272:   public static Object showInternalInputDialog(Component parentComponent,
1273:                                                Object message, String title,
1274:                                                int messageType, Icon icon,
1275:                                                Object[] selectionValues,
1276:                                                Object initialSelectionValue)
1277:   {
1278:     JOptionPane pane = new JOptionPane(message, messageType);
1279:     pane.setWantsInput(true);
1280:     pane.setIcon(icon);
1281:     pane.setSelectionValues(selectionValues);
1282:     pane.setInitialSelectionValue(initialSelectionValue);
1283:     JInternalFrame frame = pane.createInternalFrame(parentComponent, title);
1284: 
1285:     startModal(frame);
1286: 
1287:     return (String) pane.getInputValue();
1288:   }
1289: 
1290:   /**
1291:    * This method shows an internal message dialog with the given message. The
1292:    * internal frame dialog will be placed in the first JDesktopPane ancestor
1293:    * found in the given parent component.
1294:    *
1295:    * @param parentComponent The component to find a JDesktopPane in.
1296:    * @param message The message to display.
1297:    */
1298:   public static void showInternalMessageDialog(Component parentComponent,
1299:                                                Object message)
1300:   {
1301:     JOptionPane pane = new JOptionPane(message);
1302:     JInternalFrame frame = pane.createInternalFrame(parentComponent, null);
1303: 
1304:     startModal(frame);
1305:   }
1306: 
1307:   /**
1308:    * This method shows an internal message dialog with the given message,
1309:    * title and message type. The internal message dialog is placed in the
1310:    * first JDesktopPane ancestor found in the given parent component.
1311:    *
1312:    * @param parentComponent The parent component to find a JDesktopPane in.
1313:    * @param message The message to display.
1314:    * @param title The title to display.
1315:    * @param messageType The message type.
1316:    */
1317:   public static void showInternalMessageDialog(Component parentComponent,
1318:                                                Object message, String title,
1319:                                                int messageType)
1320:   {
1321:     JOptionPane pane = new JOptionPane(message, messageType);
1322:     JInternalFrame frame = pane.createInternalFrame(parentComponent, title);
1323: 
1324:     startModal(frame);
1325:   }
1326: 
1327:   /**
1328:    * This method shows an internal message dialog with the given message,
1329:    * title, message type and icon. The internal message dialog is placed in
1330:    * the first JDesktopPane ancestor found in the given parent component.
1331:    *
1332:    * @param parentComponent The component to find a JDesktopPane in.
1333:    * @param message The message to display.
1334:    * @param title The title to display.
1335:    * @param messageType The message type.
1336:    * @param icon The icon to display.
1337:    */
1338:   public static void showInternalMessageDialog(Component parentComponent,
1339:                                                Object message, String title,
1340:                                                int messageType, Icon icon)
1341:   {
1342:     JOptionPane pane = new JOptionPane(message, messageType);
1343:     pane.setIcon(icon);
1344:     JInternalFrame frame = pane.createInternalFrame(parentComponent, title);
1345: 
1346:     startModal(frame);
1347:   }
1348: 
1349:   /**
1350:    * This method displays an internal option dialog with the given message,
1351:    * title, option type, message type, icon, option list, and initial option
1352:    * value. The internal option dialog is placed in the first JDesktopPane
1353:    * ancestor found in the parent component. This method returns the option
1354:    * selected.
1355:    *
1356:    * @param parentComponent The parent to find a JDesktopPane in.
1357:    * @param message The message displayed.
1358:    * @param title The title displayed.
1359:    * @param optionType The option type.
1360:    * @param messageType The message type.
1361:    * @param icon The icon to display.
1362:    * @param options The array of options.
1363:    * @param initialValue The initial value selected.
1364:    *
1365:    * @return The option that was selected.
1366:    */
1367:   public static int showInternalOptionDialog(Component parentComponent,
1368:                                              Object message, String title,
1369:                                              int optionType, int messageType,
1370:                                              Icon icon, Object[] options,
1371:                                              Object initialValue)
1372:   {
1373:     JOptionPane pane = new JOptionPane(message, messageType, optionType, icon,
1374:                                        options, initialValue);
1375: 
1376:     JInternalFrame frame = pane.createInternalFrame(parentComponent, title);
1377: 
1378:     startModal(frame);
1379: 
1380:     return ((Integer) pane.getValue()).intValue();
1381:   }
1382: 
1383:   /**
1384:    * This method shows an INFORMATION_MESSAGE type message dialog.
1385:    *
1386:    * @param parentComponent The component to find a frame in.
1387:    * @param message The message displayed.
1388:    */
1389:   public static void showMessageDialog(Component parentComponent,
1390:                                        Object message)
1391:   {
1392:     JOptionPane pane = new JOptionPane(message, INFORMATION_MESSAGE);
1393:     JDialog dialog = pane.createDialog(parentComponent, null);
1394:     dialog.pack();
1395:     dialog.show();
1396:   }
1397: 
1398:   /**
1399:    * This method shows a message dialog with the given message, title and
1400:    * messageType.
1401:    *
1402:    * @param parentComponent The component to find a frame in.
1403:    * @param message The message displayed.
1404:    * @param title The title of the dialog.
1405:    * @param messageType The messageType.
1406:    */
1407:   public static void showMessageDialog(Component parentComponent,
1408:                                        Object message, String title,
1409:                                        int messageType)
1410:   {
1411:     JOptionPane pane = new JOptionPane(message, messageType);
1412:     JDialog dialog = pane.createDialog(parentComponent, title);
1413:     dialog.pack();
1414:     dialog.show();
1415:   }
1416: 
1417:   /**
1418:    * This method shows a message dialog with the given message, title,
1419:    * messageType and icon.
1420:    *
1421:    * @param parentComponent The component to find a frame in.
1422:    * @param message The message displayed.
1423:    * @param title The title of the dialog.
1424:    * @param messageType The messageType.
1425:    * @param icon The icon displayed.
1426:    */
1427:   public static void showMessageDialog(Component parentComponent,
1428:                                        Object message, String title,
1429:                                        int messageType, Icon icon)
1430:   {
1431:     JOptionPane pane = new JOptionPane(message, messageType);
1432:     pane.setIcon(icon);
1433:     JDialog dialog = pane.createDialog(parentComponent, title);
1434:     dialog.pack();
1435:     dialog.show();
1436:   }
1437: 
1438:   /**
1439:    * This method shows an option dialog with the given message, title,
1440:    * optionType, messageType, icon, options and initialValue. This method
1441:    * returns the option that was selected.
1442:    *
1443:    * @param parentComponent The component to find a frame in.
1444:    * @param message The message displayed.
1445:    * @param title The title of the dialog.
1446:    * @param optionType The optionType.
1447:    * @param messageType The messageType.
1448:    * @param icon The icon displayed.
1449:    * @param options The options to choose from.
1450:    * @param initialValue The initial value.
1451:    *
1452:    * @return The selected option.
1453:    */
1454:   public static int showOptionDialog(Component parentComponent,
1455:                                      Object message, String title,
1456:                                      int optionType, int messageType,
1457:                                      Icon icon, Object[] options,
1458:                                      Object initialValue)
1459:   {
1460:     JOptionPane pane = new JOptionPane(message, messageType, optionType, icon,
1461:                                        options, initialValue);
1462: 
1463:     JDialog dialog = pane.createDialog(parentComponent, title);
1464:     dialog.pack();
1465:     dialog.show();
1466: 
1467:     return ((Integer) pane.getValue()).intValue();
1468:   }
1469: 
1470:   /**
1471:    * This method resets the UI to the Look and Feel default.
1472:    */
1473:   public void updateUI()
1474:   {
1475:     setUI((OptionPaneUI) UIManager.getUI(this));
1476:     invalidate();
1477:   }
1478: 
1479:   /**
1480:    * This method returns true if the key is a valid messageType.
1481:    *
1482:    * @param key The key to check.
1483:    *
1484:    * @return True if key is valid.
1485:    */
1486:   private boolean validMessageType(int key)
1487:   {
1488:     switch (key)
1489:       {
1490:       case ERROR_MESSAGE:
1491:       case INFORMATION_MESSAGE:
1492:       case PLAIN_MESSAGE:
1493:       case QUESTION_MESSAGE:
1494:       case WARNING_MESSAGE:
1495:     return true;
1496:       }
1497:     return false;
1498:   }
1499: 
1500:   /**
1501:    * This method returns true if the key is a valid optionType.
1502:    *
1503:    * @param key The key to check.
1504:    *
1505:    * @return True if key is valid.
1506:    */
1507:   private boolean validOptionType(int key)
1508:   {
1509:     switch (key)
1510:       {
1511:       case DEFAULT_OPTION:
1512:       case OK_CANCEL_OPTION:
1513:       case YES_NO_CANCEL_OPTION:
1514:       case YES_NO_OPTION:
1515:     return true;
1516:       }
1517:     return false;
1518:   }
1519: 
1520:   /**
1521:    * This helper method makes the JInternalFrame wait until it is notified by
1522:    * an InternalFrameClosing event. This method also adds the given
1523:    * JOptionPane to the JInternalFrame and sizes it according to the
1524:    * JInternalFrame's preferred size.
1525:    *
1526:    * @param f The JInternalFrame to make modal.
1527:    * @param pane The JOptionPane to add to the JInternalFrame.
1528:    */
1529:   private static void startModal(JInternalFrame f)
1530:   {
1531:     synchronized (f)
1532:       {
1533:     final JInternalFrame tmp = f;
1534:     tmp.toFront();
1535: 
1536:     f.addInternalFrameListener(new InternalFrameAdapter()
1537:         {
1538:           public void internalFrameClosed(InternalFrameEvent e)
1539:           {
1540:         synchronized (tmp)
1541:           {
1542:             tmp.removeInternalFrameListener(this);
1543:             tmp.notifyAll();
1544:           }
1545:           }
1546:         });
1547:     try
1548:       {
1549:         while (! f.isClosed())
1550:           f.wait();
1551:       }
1552:     catch (InterruptedException ignored)
1553:       {
1554:       }
1555:       }
1556:   }
1557: }