Source for javax.swing.JOptionPane

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