libjava/javax/swing/JInternalFrame.java

   1 /* JInternalFrame.java --
   2    Copyright (C) 2002, 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., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 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.Container;
  43 import java.awt.Graphics;
  44 import java.awt.KeyboardFocusManager;
  45 import java.awt.LayoutManager;
  46 import java.awt.Rectangle;
  47 import java.beans.PropertyVetoException;
  48
  49 import javax.accessibility.Accessible;
  50 import javax.accessibility.AccessibleContext;
  51 import javax.accessibility.AccessibleRole;
  52 import javax.accessibility.AccessibleValue;
  53 import javax.swing.event.InternalFrameEvent;
  54 import javax.swing.event.InternalFrameListener;
  55 import javax.swing.plaf.DesktopIconUI;
  56 import javax.swing.plaf.InternalFrameUI;
  57
  58 /**
  59  * This class implements a Swing widget that looks and acts like a native
  60  * frame. The frame can be dragged, resized, closed, etc. Typically,
  61  * JInternalFrames are placed in JDesktopPanes. The actions that the
  62  * JInternalFrame performs (maximizing, minimizing, etc.) are performed by a
  63  * DesktopManager. As with regular frames, components are added by calling
  64  * frame.getContentPane().add.
  65  */
  66 public class JInternalFrame extends JComponent implements Accessible,
  67                                                           WindowConstants,
  68                                                           RootPaneContainer
  69 {
  70   /** DOCUMENT ME! */
  71   private static final long serialVersionUID = -5425177187760785402L;
  72
  73   /**
  74    * DOCUMENT ME!
  75    */
  76   protected class AccessibleJInternalFrame extends AccessibleJComponent
  77     implements AccessibleValue
  78   {
  79     /**
  80      * Creates a new AccessibleJInternalFrame object.
  81      */
  82     protected AccessibleJInternalFrame()
  83     {
  84       super();
  85     }
  86
  87     /**
  88      * DOCUMENT ME!
  89      *
  90      * @return DOCUMENT ME!
  91      */
  92     public String getAccessibleName()
  93     {
  94       return null;
  95     }
  96
  97     /**
  98      * DOCUMENT ME!
  99      *
 100      * @return DOCUMENT ME!
 101      */
 102     public AccessibleRole getAccessibleRole()
 103     {
 104       return null;
 105     }
 106
 107     /**
 108      * DOCUMENT ME!
 109      *
 110      * @return DOCUMENT ME!
 111      */
 112     public AccessibleValue getAccessibleValue()
 113     {
 114       return null;
 115     }
 116
 117     /**
 118      * DOCUMENT ME!
 119      *
 120      * @return DOCUMENT ME!
 121      */
 122     public Number getCurrentAccessibleValue()
 123     {
 124       return null;
 125     }
 126
 127     /**
 128      * DOCUMENT ME!
 129      *
 130      * @return DOCUMENT ME!
 131      */
 132     public Number getMaximumAccessibleValue()
 133     {
 134       return null;
 135     }
 136
 137     /**
 138      * DOCUMENT ME!
 139      *
 140      * @return DOCUMENT ME!
 141      */
 142     public Number getMinimumAccessibleValue()
 143     {
 144       return null;
 145     }
 146
 147     /**
 148      * DOCUMENT ME!
 149      *
 150      * @param n DOCUMENT ME!
 151      *
 152      * @return DOCUMENT ME!
 153      */
 154     public boolean setCurrentAccessibleValue(Number n)
 155     {
 156       return false;
 157     }
 158   }
 159
 160   /**
 161    * This class represents the JInternalFrame while it is iconified.
 162    */
 163   public static class JDesktopIcon extends JComponent implements Accessible
 164   {
 165     /**
 166      * DOCUMENT ME!
 167      */
 168     protected class AccessibleJDesktopIcon extends AccessibleJComponent
 169       implements AccessibleValue
 170     {
 171       /**
 172        * Creates a new AccessibleJDesktopIcon object.
 173        */
 174       protected AccessibleJDesktopIcon()
 175       {
 176         super();
 177       }
 178
 179       /**
 180        * DOCUMENT ME!
 181        *
 182        * @return DOCUMENT ME!
 183        */
 184       public AccessibleRole getAccessibleRole()
 185       {
 186         return null;
 187       }
 188
 189       /**
 190        * DOCUMENT ME!
 191        *
 192        * @return DOCUMENT ME!
 193        */
 194       public AccessibleValue getAccessibleValue()
 195       {
 196         return null;
 197       }
 198
 199       /**
 200        * DOCUMENT ME!
 201        *
 202        * @return DOCUMENT ME!
 203        */
 204       public Number getCurrentAccessibleValue()
 205       {
 206         return null;
 207       }
 208
 209       /**
 210        * DOCUMENT ME!
 211        *
 212        * @return DOCUMENT ME!
 213        */
 214       public Number getMaximumAccessibleValue()
 215       {
 216         return null;
 217       }
 218
 219       /**
 220        * DOCUMENT ME!
 221        *
 222        * @return DOCUMENT ME!
 223        */
 224       public Number getMinimumAccessibleValue()
 225       {
 226         return null;
 227       }
 228
 229       /**
 230        * DOCUMENT ME!
 231        *
 232        * @param n DOCUMENT ME!
 233        *
 234        * @return DOCUMENT ME!
 235        */
 236       public boolean setCurrentAccessibleValue(Number n)
 237       {
 238         return false;
 239       }
 240     }
 241
 242     /** The JInternalFrame this DesktopIcon represents. */
 243     JInternalFrame frame;
 244
 245     /**
 246      * Creates a new JDesktopIcon object for representing the given frame.
 247      *
 248      * @param f The JInternalFrame to represent.
 249      */
 250     public JDesktopIcon(JInternalFrame f)
 251     {
 252       frame = f;
 253       updateUI();
 254     }
 255
 256     /**
 257      * DOCUMENT ME!
 258      *
 259      * @return DOCUMENT ME!
 260      */
 261     public AccessibleContext getAccessibleContext()
 262     {
 263       if (accessibleContext == null)
 264         accessibleContext = new AccessibleJDesktopIcon();
 265       return accessibleContext;
 266     }
 267
 268     /**
 269      * This method returns the JDesktopPane this JDesktopIcon is in.
 270      *
 271      * @return The JDesktopPane this JDesktopIcon is in.
 272      */
 273     public JDesktopPane getDesktopPane()
 274     {
 275       JDesktopPane p = (JDesktopPane) SwingUtilities.getAncestorOfClass(JDesktopPane.class,
 276                                                                         this);
 277       return p;
 278     }
 279
 280     /**
 281      * This method returns the JInternalFrame this JDesktopIcon represents.
 282      *
 283      * @return The JInternalFrame this JDesktopIcon represents.
 284      */
 285     public JInternalFrame getInternalFrame()
 286     {
 287       return frame;
 288     }
 289
 290     /**
 291      * This method returns the UI that is responsible for the JDesktopIcon.
 292      *
 293      * @return The UI that is responsible for the JDesktopIcon.
 294      */
 295     public DesktopIconUI getUI()
 296     {
 297       return (DesktopIconUI) ui;
 298     }
 299
 300     /**
 301      * This method returns the String identifier that is used to determine
 302      * which class is used for JDesktopIcon's UI.
 303      *
 304      * @return A String identifier for the UI class.
 305      */
 306     public String getUIClassID()
 307     {
 308       return "DesktopIconUI";
 309     }
 310
 311     /**
 312      * This method sets the JInternalFrame that this JDesktopIcon represents.
 313      *
 314      * @param f The JInternalFrame that this JDesktopIcon represents.
 315      */
 316     public void setInternalFrame(JInternalFrame f)
 317     {
 318       frame = f;
 319     }
 320
 321     /**
 322      * This method sets the UI used for this JDesktopIcon.
 323      *
 324      * @param ui The UI to use.
 325      */
 326     public void setUI(DesktopIconUI ui)
 327     {
 328       super.setUI(ui);
 329     }
 330
 331     /**
 332      * This method restores the UI property to the defaults.
 333      */
 334     public void updateUI()
 335     {
 336       setUI((DesktopIconUI) UIManager.getUI(this));
 337     }
 338   }
 339
 340   /**
 341    * The property fired in a PropertyChangeEvent when the contentPane property
 342    * changes.
 343    */
 344   public static final String CONTENT_PANE_PROPERTY = "contentPane";
 345
 346   /**
 347    * The property fired in a PropertyChangeEvent when the frameIcon property
 348    * changes.
 349    */
 350   public static final String FRAME_ICON_PROPERTY = "frameIcon";
 351
 352   /**
 353    * The property fired in a PropertyChangeEvent when the glassPane property
 354    * changes.
 355    */
 356   public static final String GLASS_PANE_PROPERTY = "glassPane";
 357
 358   /**
 359    * The property fired in a PropertyChangeEvent when the closed property
 360    * changes.
 361    */
 362   public static final String IS_CLOSED_PROPERTY = "closed";
 363
 364   /**
 365    * The property fired in a PropertyChangeEvent when the icon property
 366    * changes.
 367    */
 368   public static final String IS_ICON_PROPERTY = "icon";
 369
 370   /**
 371    * The property fired in a PropertyChangeEvent when the maximum property
 372    * changes.
 373    */
 374   public static final String IS_MAXIMUM_PROPERTY = "maximum";
 375
 376   /**
 377    * The property fired in a PropertyChangeEvent when the selected property
 378    * changes.
 379    */
 380   public static final String IS_SELECTED_PROPERTY = "selected";
 381
 382   /**
 383    * The property fired in a PropertyChangeEvent when the layeredPane property
 384    * changes.
 385    */
 386   public static final String LAYERED_PANE_PROPERTY = "layeredPane";
 387
 388   /**
 389    * The property fired in a PropertyChangeEvent when the jMenuBar property
 390    * changes.
 391    */
 392   public static final String MENU_BAR_PROPERTY = "JMenuBar";
 393
 394   /**
 395    * The property fired in a PropertyChangeEvent when the rootPane property
 396    * changes.
 397    */
 398   public static final String ROOT_PANE_PROPERTY = "rootPane";
 399
 400   /**
 401    * The property fired in a PropertyChangeEvent when the title property
 402    * changes.
 403    */
 404   public static final String TITLE_PROPERTY = "title";
 405
 406   /** Whether the JInternalFrame is closable. */
 407   protected boolean closable;
 408
 409   /** Whether the JInternalFrame can be iconified. */
 410   protected boolean iconable;
 411
 412   /** Whether the JInternalFrame is closed. */
 413   protected boolean isClosed;
 414
 415   /** Whether the JInternalFrame has been iconified. */
 416   protected boolean isIcon;
 417
 418   /** Whether the JInternalFrame has been maximized. */
 419   protected boolean isMaximum;
 420
 421   /** Whether the JInternalFrame is the active frame. */
 422   protected boolean isSelected;
 423
 424   /** Whether the JInternalFrame can be maximized. */
 425   protected boolean maximizable;
 426
 427   /** Whether the JInternalFrame has rootPaneChecking enabled. */
 428   protected boolean rootPaneCheckingEnabled = true;
 429
 430   /** Whether the JInternalFrame is resizable. */
 431   protected boolean resizable;
 432
 433   /**
 434    * The JDesktopIcon that represents the JInternalFrame while it is
 435    * iconified.
 436    */
 437   protected JDesktopIcon desktopIcon;
 438
 439   /** The icon used in the JMenuBar in the TitlePane. */
 440   protected Icon frameIcon;
 441
 442   /** The rootPane of the JInternalFrame. */
 443   protected JRootPane rootPane;
 444
 445   /** The title on the TitlePane of the JInternalFrame. */
 446   protected String title;
 447
 448   /** The bounds of the JInternalFrame before it was maximized. */
 449   private transient Rectangle storedBounds;
 450
 451   /** The Component that receives focus by default. */
 452   private transient Component defaultFocus;
 453
 454   /** The default close action taken, */
 455   private transient int defaultCloseOperation = DISPOSE_ON_CLOSE;
 456
 457   /** Whether the JInternalFrame has become visible for the very first time. */
 458   private transient boolean isFirstTimeVisible = true;
 459
 460   /**
 461    * Whether the JInternalFrame is in the transition from being a maximized
 462    * frame back to a regular sized frame.
 463    */
 464   private transient boolean maxTransition = false;
 465
 466   /** DOCUMENT ME! */
 467   private transient boolean wasIcon = false;
 468
 469   /**
 470    * Creates a new JInternalFrame object that has no title, and is
 471    * non-resizable, non-maximizable, non-iconifiable, and non-closable.
 472    */
 473   public JInternalFrame()
 474   {
 475     this(null, false, false, false, false);
 476   }
 477
 478   /**
 479    * Creates a new JInternalFrame object with the given title and is
 480    * non-resizable, non-maximizable, non-iconifiable, and non-closable.
 481    *
 482    * @param title The title displayed in the JInternalFrame.
 483    */
 484   public JInternalFrame(String title)
 485   {
 486     this(title, false, false, false, false);
 487   }
 488
 489   /**
 490    * Creates a new JInternalFrame object with the given title and resizable
 491    * properties. The JInternalFrame is non-maximizable, non-iconifiable, and
 492    * non-closable.
 493    *
 494    * @param title The title displayed in the JInternalFrame.
 495    * @param resizable Whether the JInternalFrame is resizable.
 496    */
 497   public JInternalFrame(String title, boolean resizable)
 498   {
 499     this(title, resizable, false, false, false);
 500   }
 501
 502   /**
 503    * Creates a new JInternalFrame object with the given title, resizable, and
 504    * closable properties. The JInternalFrame is non-maximizable and
 505    * non-iconifiable.
 506    *
 507    * @param title The title displayed in the JInternalFrame.
 508    * @param resizable Whether the JInternalFrame is resizable.
 509    * @param closable Whether the JInternalFrame is closable.
 510    */
 511   public JInternalFrame(String title, boolean resizable, boolean closable)
 512   {
 513     this(title, resizable, closable, false, false);
 514   }
 515
 516   /**
 517    * Creates a new JInternalFrame object with the given title, resizable,
 518    * closable and maximizable properties. The JInternalFrame is
 519    * non-iconifiable.
 520    *
 521    * @param title The title displayed in the JInternalFrame.
 522    * @param resizable Whether the JInternalFrame is resizable.
 523    * @param closable Whether the JInternalFrame is closable.
 524    * @param maximizable Whether the JInternalFrame is maximizable.
 525    */
 526   public JInternalFrame(String title, boolean resizable, boolean closable,
 527                         boolean maximizable)
 528   {
 529     this(title, resizable, closable, maximizable, false);
 530   }
 531
 532   /**
 533    * Creates a new JInternalFrame object with the given title, resizable,
 534    * closable, maximizable and iconifiable properties.
 535    *
 536    * @param title The title displayed in the JInternalFrame.
 537    * @param resizable Whether the JInternalFrame is resizable.
 538    * @param closable Whether the JInternalFrame is closable.
 539    * @param maximizable Whether the JInternalFrame is maximizable.
 540    * @param iconifiable Whether the JInternalFrame is iconifiable.
 541    */
 542   public JInternalFrame(String title, boolean resizable, boolean closable,
 543                         boolean maximizable, boolean iconifiable)
 544   {
 545     this.title = title;
 546     this.resizable = resizable;
 547     this.closable = closable;
 548     this.maximizable = maximizable;
 549     this.iconable = iconifiable;
 550     storedBounds = new Rectangle();
 551
 552     setRootPaneCheckingEnabled(false);
 553     setRootPane(createRootPane());
 554
 555     updateUI();
 556     setRootPaneCheckingEnabled(true);
 557   }
 558
 559   /**
 560    * This method adds Components to this Container. For JInternalFrames,
 561    * instead of calling add directly on the JInternalFrame, it should be
 562    * called with JInternalFrame.getContentPane().add. If root pane checking
 563    * is enabled, calling this method will cause an exception to be thrown.
 564    *
 565    * @param comp The Component to add.
 566    * @param constraints The constraints on the Component added.
 567    * @param index The position to place the Component.
 568    *
 569    * @throws Error DOCUMENT ME!
 570    */
 571   protected void addImpl(Component comp, Object constraints, int index)
 572   {
 573     if (isRootPaneCheckingEnabled())
 574       throw new Error("Do not use add() on JInternalPane directly. Use getContentPane().add() instead");
 575
 576     super.addImpl(comp, constraints, index);
 577   }
 578
 579   /**
 580    * This method adds an InternalFrameListener to this JInternalFrame.
 581    *
 582    * @param l The listener to add.
 583    */
 584   public void addInternalFrameListener(InternalFrameListener l)
 585   {
 586     listenerList.add(InternalFrameListener.class, l);
 587   }
 588
 589   /**
 590    * This method is used to create a root pane for the JInternalFrame. This
 591    * method is called by the constructors.
 592    *
 593    * @return A root pane for the JInternalFrame to use.
 594    */
 595   protected JRootPane createRootPane()
 596   {
 597     return new JRootPane();
 598   }
 599
 600   /**
 601    * This method makes this JInternalFrame invisible, unselected and closed.
 602    * If this JInternalFrame is not closed already, it will fire an
 603    * INTERNAL_FRAME_CLoSED event. This method is similar to setClosed but it
 604    * doesn't give vetoable listeners a chance to veto and it will not fire an
 605    * INTERNAL_FRAME_CLOSING event.
 606    */
 607   public void dispose()
 608   {
 609     hide();
 610     JDesktopPane pane = getDesktopPane();
 611     if (pane != null)
 612       pane.setSelectedFrame(null);
 613     else
 614       {
 615         try
 616           {
 617             setSelected(false);
 618           }
 619         catch (PropertyVetoException e)
 620           {
 621             // Do nothing if they don't want to be unselected.
 622           }
 623       }
 624     isClosed = true;
 625     fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSED);
 626     removeNotify();
 627   }
 628
 629   /**
 630    * This method is used for closing this JInternalFrame. It fires an
 631    * INTERNAL_FRAME_CLOSING event and then performs the action specified by
 632    * the default close operation.
 633    */
 634   public void doDefaultCloseAction()
 635   {
 636     fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSING);
 637     switch (getDefaultCloseOperation())
 638       {
 639       case HIDE_ON_CLOSE:
 640         hide();
 641         break;
 642       case DISPOSE_ON_CLOSE:
 643         dispose();
 644         break;
 645       }
 646   }
 647
 648   /**
 649    * This method fires an InternalFrameEvent to the listeners.
 650    *
 651    * @param id The type of event being fired. See InternalFrameEvent.
 652    */
 653   protected void fireInternalFrameEvent(int id)
 654   {
 655     Object[] ifListeners = listenerList.getListenerList();
 656     InternalFrameEvent evt = new InternalFrameEvent(this, id);
 657     switch (id)
 658       {
 659       case InternalFrameEvent.INTERNAL_FRAME_CLOSING:
 660         for (int i = ifListeners.length - 2; i >= 0; i -= 2)
 661           {
 662             if (ifListeners[i] == InternalFrameListener.class)
 663               ((InternalFrameListener) ifListeners[i + 1])
 664               .internalFrameClosing(evt);
 665           }
 666         break;
 667       case InternalFrameEvent.INTERNAL_FRAME_ACTIVATED:
 668         for (int i = ifListeners.length - 2; i >= 0; i -= 2)
 669           {
 670             if (ifListeners[i] == InternalFrameListener.class)
 671               ((InternalFrameListener) ifListeners[i + 1])
 672               .internalFrameActivated(evt);
 673           }
 674         break;
 675       case InternalFrameEvent.INTERNAL_FRAME_CLOSED:
 676         for (int i = ifListeners.length - 2; i >= 0; i -= 2)
 677           {
 678             if (ifListeners[i] == InternalFrameListener.class)
 679               ((InternalFrameListener) ifListeners[i + 1]).internalFrameClosed(evt);
 680           }
 681         break;
 682       case InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED:
 683         for (int i = ifListeners.length - 2; i >= 0; i -= 2)
 684           {
 685             if (ifListeners[i] == InternalFrameListener.class)
 686               ((InternalFrameListener) ifListeners[i + 1])
 687               .internalFrameDeactivated(evt);
 688           }
 689         break;
 690       case InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED:
 691         for (int i = ifListeners.length - 2; i >= 0; i -= 2)
 692           {
 693             if (ifListeners[i] == InternalFrameListener.class)
 694               ((InternalFrameListener) ifListeners[i + 1])
 695               .internalFrameDeiconified(evt);
 696           }
 697         break;
 698       case InternalFrameEvent.INTERNAL_FRAME_ICONIFIED:
 699         for (int i = ifListeners.length - 2; i >= 0; i -= 2)
 700           {
 701             if (ifListeners[i] == InternalFrameListener.class)
 702               ((InternalFrameListener) ifListeners[i + 1])
 703               .internalFrameIconified(evt);
 704           }
 705         break;
 706       case InternalFrameEvent.INTERNAL_FRAME_OPENED:
 707         for (int i = ifListeners.length - 2; i >= 0; i -= 2)
 708           {
 709             if (ifListeners[i] == InternalFrameListener.class)
 710               ((InternalFrameListener) ifListeners[i + 1]).internalFrameOpened(evt);
 711           }
 712         break;
 713       }
 714   }
 715
 716   /**
 717    * DOCUMENT ME!
 718    *
 719    * @return DOCUMENT ME!
 720    */
 721   public AccessibleContext getAccessibleContext()
 722   {
 723     if (accessibleContext == null)
 724       accessibleContext = new AccessibleJInternalFrame();
 725     return accessibleContext;
 726   }
 727
 728   /**
 729    * This method returns the Content Pane for this JInternalFrame.
 730    *
 731    * @return The Content Pane for this JInternalFrame.
 732    */
 733   public Container getContentPane()
 734   {
 735     return getRootPane().getContentPane();
 736   }
 737
 738   /**
 739    * This method returns the default action taken when this JInternalFrame is
 740    * closed.
 741    *
 742    * @return The default action taken when this JInternalFrame is closed.
 743    */
 744   public int getDefaultCloseOperation()
 745   {
 746     return defaultCloseOperation;
 747   }
 748
 749   /**
 750    * This method returns the JDesktopIcon that represents this JInternalFrame
 751    * while it is iconified.
 752    *
 753    * @return The JDesktopIcon that represents this JInternalFrame while it is
 754    *         iconified.
 755    */
 756   public JDesktopIcon getDesktopIcon()
 757   {
 758     if (desktopIcon == null)
 759       desktopIcon = new JDesktopIcon(this);
 760     return desktopIcon;
 761   }
 762
 763   /**
 764    * This method searches this JInternalFrame ancestors for an instance of
 765    * JDesktopPane. If one is found, it is returned. If none is found, then it
 766    * will search the JDesktopIcon for a JDesktopPane.
 767    *
 768    * @return The JDesktopPane that this JInternalFrame belongs to.
 769    */
 770   public JDesktopPane getDesktopPane()
 771   {
 772     JDesktopPane value = (JDesktopPane) SwingUtilities.getAncestorOfClass(JDesktopPane.class,
 773                                                                           this);
 774     if (value == null && desktopIcon != null)
 775       value = desktopIcon.getDesktopPane();
 776     return value;
 777   }
 778
 779   /**
 780    * This method returns null because this must always be the root of a focus
 781    * traversal.
 782    *
 783    * @return always null
 784    *
 785    * @since 1.4
 786    */
 787   public final Container getFocusCycleRootAncestor()
 788   {
 789     // as defined.
 790     return null;
 791   }
 792
 793   /**
 794    * This method returns the child Component that will receive focus if this
 795    * JInternalFrame is selected.
 796    *
 797    * @return The child Component that will receive focus.
 798    */
 799   public Component getFocusOwner()
 800   {
 801     if (isSelected())
 802       {
 803         Component focus = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
 804         if (SwingUtilities.isDescendingFrom(focus, this))
 805           {
 806             defaultFocus = focus;
 807             return focus;
 808           }
 809       }
 810     return null;
 811   }
 812
 813   /**
 814    * This method returns the Frame Icon (the icon used in the JInternalFrame
 815    * TitlePane and iconified frame).
 816    *
 817    * @return The Frame Icon.
 818    */
 819   public Icon getFrameIcon()
 820   {
 821     return frameIcon;
 822   }
 823
 824   /**
 825    * This method returns the Glass Pane used with this JInternalFrame.
 826    *
 827    * @return The Glass Pane used with this JInternalFrame.
 828    */
 829   public Component getGlassPane()
 830   {
 831     return getRootPane().getGlassPane();
 832   }
 833
 834   /**
 835    * This method returns an array of InternalFrameListeners that are listening
 836    * to this JInternalFrame.
 837    *
 838    * @return An array of InternalFrameListeners that are listening to this
 839    *         JInternalFrame.
 840    */
 841   public InternalFrameListener[] getInternalFrameListeners()
 842   {
 843     return (InternalFrameListener[]) listenerList.getListeners(InternalFrameListener.class);
 844   }
 845
 846   /**
 847    * This method returns the JMenuBar for this JInternalFrame.
 848    *
 849    * @return The JMenuBar for this JInternalFrame.
 850    */
 851   public JMenuBar getJMenuBar()
 852   {
 853     return getRootPane().getJMenuBar();
 854   }
 855
 856   /**
 857    * This method returns the layer that this JInternalFrame resides in.
 858    *
 859    * @return The layer that this JInternalFrame resides in.
 860    */
 861   public int getLayer()
 862   {
 863     JDesktopPane pane = getDesktopPane();
 864     if (pane != null)
 865       return pane.getLayer(this);
 866     return -1;
 867   }
 868
 869   /**
 870    * This method returns the LayeredPane for this JInternalFrame.
 871    *
 872    * @return The LayeredPane for this JInternalFrame.
 873    */
 874   public JLayeredPane getLayeredPane()
 875   {
 876     return getRootPane().getLayeredPane();
 877   }
 878
 879   /**
 880    * This method is deprecated. This method returns the JMenuBar for this
 881    * JInternalFrame.
 882    *
 883    * @return The JMenuBar for this JInternalFrame.
 884    *
 885    * @deprecated 1.0.3
 886    */
 887   public JMenuBar getMenuBar()
 888   {
 889     return getJMenuBar();
 890   }
 891
 892   /**
 893    * This method returns the child Component that will receive focus when the
 894    * JInternalFrame is selected. If the JInternalFrame is selected, this
 895    * method returns getFocusOwner(). Otherwise, it will return the child
 896    * Component that most recently requested focus. If that is null, then the
 897    * initial focus Component is returned. If that is null, then the default
 898    * focus component is returned.
 899    *
 900    * @return The most recent focus owner.
 901    */
 902   public Component getMostRecentFocusOwner()
 903   {
 904     if (isSelected())
 905       return getFocusOwner();
 906     else
 907       return defaultFocus;
 908   }
 909
 910   /**
 911    * This method returns the bounds of the JInternalFrame if it is not
 912    * maximized. If it is maximized, it returns the bounds of the
 913    * JInternalFrame before it was maximized (the bounds that it will be
 914    * restored to).
 915    *
 916    * @return A Rectangle that contains this JInternalFrame's normal bounds (or
 917    *         just its bounds if it is not maximized).
 918    */
 919   public Rectangle getNormalBounds()
 920   {
 921     if (! isMaximum() && ! maxTransition)
 922       return getBounds();
 923     else
 924       return storedBounds;
 925   }
 926
 927   /**
 928    * This method returns the Root Pane for this JInternalFrame.
 929    *
 930    * @return The Root Pane for this JInternalFrame.
 931    */
 932   public JRootPane getRootPane()
 933   {
 934     return rootPane;
 935   }
 936
 937   /**
 938    * This method sets the title of the JInternalFrame.
 939    *
 940    * @return The String displayed in the TitlePane of this JInternalFrame.
 941    */
 942   public String getTitle()
 943   {
 944     return title;
 945   }
 946
 947   /**
 948    * This method returns the UI used to represent the JInternalFrame.
 949    *
 950    * @return The UI used to represent the JInternalFrame.
 951    */
 952   public InternalFrameUI getUI()
 953   {
 954     return (InternalFrameUI) ui;
 955   }
 956
 957   /**
 958    * This method returns a String identifier that is used to determine which
 959    * class acts as the JInternalFrame's UI.
 960    *
 961    * @return A String identifier to determine a UI class.
 962    */
 963   public String getUIClassID()
 964   {
 965     return "InternalFrameUI";
 966   }
 967
 968   /**
 969    * This method returns null.
 970    *
 971    * @return null.
 972    */
 973   public final String getWarningString()
 974   {
 975     // as defined.
 976     return null;
 977   }
 978
 979   /**
 980    * This method deselects this JInternalFrame and hides it.
 981    */
 982   public void hide()
 983   {
 984     JDesktopPane pane = getDesktopPane();
 985     if (pane != null)
 986       pane.setSelectedFrame(null);
 987     else
 988       {
 989         try
 990           {
 991             setSelected(false);
 992           }
 993         catch (PropertyVetoException e)
 994           {
 995             // Do nothing.
 996           }
 997       }
 998     super.hide();
 999   }
1000
1001   /**
1002    * This method returns whether this JInternalFrame is closable.
1003    *
1004    * @return Whether this JInternalFrame is closable.
1005    */
1006   public boolean isClosable()
1007   {
1008     return closable;
1009   }
1010
1011   /**
1012    * This method returns whether this JInternalFrame has been closed.
1013    *
1014    * @return Whether this JInternalFrame is closed.
1015    */
1016   public boolean isClosed()
1017   {
1018     return isClosed;
1019   }
1020
1021   /**
1022    * This must always return true.
1023    *
1024    * @return always true
1025    *
1026    * @since 1.4
1027    */
1028   public final boolean isFocusCycleRoot()
1029   {
1030     return true;
1031   }
1032
1033   /**
1034    * This method returns whether this JInternalFrame is currently iconified.
1035    *
1036    * @return Whether this JInternalFrame is currently iconified.
1037    */
1038   public boolean isIcon()
1039   {
1040     return isIcon;
1041   }
1042
1043   /**
1044    * This method returns whether the JInternalFrame can be iconified.
1045    *
1046    * @return Whether the JInternalFrame can be iconified.
1047    */
1048   public boolean isIconifiable()
1049   {
1050     return iconable;
1051   }
1052
1053   /**
1054    * This method returns whether this JInternalFrame can be maximized.
1055    *
1056    * @return Whether this JInternalFrame can be maximized.
1057    */
1058   public boolean isMaximizable()
1059   {
1060     return maximizable;
1061   }
1062
1063   /**
1064    * This method returns whether this JInternalFrame is currently maximized.
1065    *
1066    * @return Whether this JInternalFrame is maximized.
1067    */
1068   public boolean isMaximum()
1069   {
1070     return isMaximum;
1071   }
1072
1073   /**
1074    * This method returns whether this JInternalFrame is resizable.
1075    *
1076    * @return Whether this JInternalFrame is resizable.
1077    */
1078   public boolean isResizable()
1079   {
1080     return resizable;
1081   }
1082
1083   /**
1084    * This method returns whether root pane checking is enabled. If root pane
1085    * checking is enabled, then calls to addImpl and setLayout will throw
1086    * exceptions.
1087    *
1088    * @return Whether root pane checking is enabled.
1089    */
1090   protected boolean isRootPaneCheckingEnabled()
1091   {
1092     return rootPaneCheckingEnabled;
1093   }
1094
1095   /**
1096    * This method returns whether this JInternalFrame is selected.
1097    *
1098    * @return Whether this JInternalFrame is selected.
1099    */
1100   public boolean isSelected()
1101   {
1102     return isSelected;
1103   }
1104
1105   /**
1106    * A helper method that moves this JInternalFrame to the back if the parent
1107    * is a JLayeredPane.
1108    */
1109   public void moveToBack()
1110   {
1111     if (getParent() instanceof JLayeredPane)
1112       ((JLayeredPane) getParent()).moveToBack(this);
1113   }
1114
1115   /**
1116    * A helper method that moves this JInternalFrame to the front if the parent
1117    * is a JLayeredPane.
1118    */
1119   public void moveToFront()
1120   {
1121     if (getParent() instanceof JLayeredPane)
1122       ((JLayeredPane) getParent()).moveToFront(this);
1123   }
1124
1125   /**
1126    * This method causes the children of this JInternalFrame to be laid out.
1127    * Before it begins, if this JInternalFrame is an icon, then it will be
1128    * deiconified. If it is maximized, then it will be restored. If either
1129    * operation fails, then this method will return.
1130    */
1131   public void pack()
1132   {
1133     try
1134       {
1135         if (isIcon())
1136           setIcon(false);
1137         else if (isMaximum())
1138           setMaximum(false);
1139       }
1140     catch (PropertyVetoException e)
1141       {
1142         // Do nothing if they don't want to be restored first.
1143       }
1144     doLayout();
1145   }
1146
1147   /**
1148    * This method is overridden to allow for speedier painting while this
1149    * JInternalFramme is being dragged.
1150    *
1151    * @param g The Graphics object to paint with.
1152    */
1153   protected void paintComponent(Graphics g)
1154   {
1155     super.paintComponent(g);
1156   }
1157
1158   /**
1159    * This method returns a String describing this JInternalFrame.
1160    *
1161    * @return A String describing this JInternalFrame.
1162    */
1163   protected String paramString()
1164   {
1165     return "JInternalFrame";
1166   }
1167
1168   /**
1169    * This method removes the given Component from the Container.
1170    *
1171    * @param comp The Component to remove.
1172    */
1173   public void remove(Component comp)
1174   {
1175     super.remove(comp);
1176   }
1177
1178   /**
1179    * This method removes an InternalFrameListener from this JInternalFrame.
1180    *
1181    * @param l The listener to remove.
1182    */
1183   public void removeInternalFrameListener(InternalFrameListener l)
1184   {
1185     listenerList.remove(InternalFrameListener.class, l);
1186   }
1187
1188   /**
1189    * This method resizes and positions this JInternalFrame. It also forces a
1190    * relayout of the Container.
1191    *
1192    * @param x The x position of this JInternalFrame.
1193    * @param y The y position of this JInternalFrame.
1194    * @param width The width of this JInternalFrame.
1195    * @param height The height of this JInternalFrame.
1196    */
1197   public void reshape(int x, int y, int width, int height)
1198   {
1199     super.reshape(x, y, width, height);
1200     invalidate();
1201     doLayout();
1202   }
1203
1204   /**
1205    * This method gives focus to the last child Component that had focus. This
1206    * is used by the UI when this JInternalFrame is activated.
1207    */
1208   public void restoreSubcomponentFocus()
1209   {
1210     Component c = getMostRecentFocusOwner();
1211     if (c != null)
1212       c.requestFocus();
1213   }
1214
1215   /**
1216    * This method sets whether this JInternalFrame can be closed.
1217    *
1218    * @param b Whether this JInternalFrame can be closed.
1219    */
1220   public void setClosable(boolean b)
1221   {
1222     closable = b;
1223   }
1224
1225   /**
1226    * This method closes the JInternalFrame if the given boolean is true. If it
1227    * is false, then the result of this method is unspecified. If the
1228    * JInternalFrame is closed, this method does nothing. This method will
1229    * first fire an INTERNAL_FRAME_CLOSING event and give a chance for veto
1230    * listeners to cancel the close. If no listener vetoes the change, the
1231    * closed property is set to true and the JInternalFrame is hidden and
1232    * unselected. The method will finish by firing an INTERNAL_FRAME_CLOSED
1233    * event.
1234    *
1235    * @param b Whether the JInternalFrame will be closed.
1236    *
1237    * @throws PropertyVetoException If a VetoableChangeListener vetoes the change.
1238    */
1239   public void setClosed(boolean b) throws PropertyVetoException
1240   {
1241     if (b && ! isClosed())
1242       {
1243         fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSING);
1244         fireVetoableChange(IS_CLOSED_PROPERTY, false, true);
1245
1246         isClosed = b;
1247
1248         firePropertyChange(IS_CLOSED_PROPERTY, false, true);
1249         fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSED);
1250       }
1251   }
1252
1253   /**
1254    * This method sets the Container to be used as a Content Pane for this
1255    * JInternalFrame.
1256    *
1257    * @param c The Container to use as a Content Pane.
1258    */
1259   public void setContentPane(Container c)
1260   {
1261     if (c != getContentPane())
1262       {
1263         Container old = getContentPane();
1264         getRootPane().setContentPane(c);
1265         firePropertyChange(CONTENT_PANE_PROPERTY, old, c);
1266       }
1267   }
1268
1269   /**
1270    * This method sets the action taken when this JInternalFrame is closed.
1271    *
1272    * @param operation One of DO_NOTHING_ON_CLOSE, HIDE_ON_CLOSE or
1273    *        DISPOSE_ON_CLOSE.
1274    *
1275    * @throws Error If the given operation is not one of the allowed modes.
1276    */
1277   public void setDefaultCloseOperation(int operation)
1278   {
1279     if (operation != DO_NOTHING_ON_CLOSE
1280         && operation != HIDE_ON_CLOSE
1281         && operation != DISPOSE_ON_CLOSE)
1282       throw new Error("Close operation must be one of DO_NOTHING_ON_CLOSE, HIDE_ON_CLOSE, or DISPOSE_ON_CLOSE");
1283     defaultCloseOperation = operation;
1284   }
1285
1286   /**
1287    * This method sets the JDesktopIcon that represents this JInternalFrame
1288    * while it is iconified.
1289    *
1290    * @param d The JDesktopIcon that represents this JInternalFrame while it is
1291    *        iconified.
1292    */
1293   public void setDesktopIcon(JDesktopIcon d)
1294   {
1295     d.setInternalFrame(this);
1296     desktopIcon = d;
1297   }
1298
1299   /**
1300    * This method does nothing because this must be the root of a focus
1301    * traversal cycle.
1302    *
1303    * @param focusCycleRoot Not used.
1304    */
1305   public final void setFocusCycleRoot(boolean focusCycleRoot)
1306   {
1307     // Do nothing
1308   }
1309
1310   /**
1311    * This method sets the Icon to be used in two places. The first is icon
1312    * that is painted at the top left corner of the JInternalFrame when it is
1313    * not iconified (clicking on that icon will activate the TitlePane
1314    * JMenuBar). When the JInternalFrame is iconified, it will be the icon
1315    * displayed in the JDesktopIcon. If no icon is set, the JInternalFrame
1316    * will use a Look and Feel default.
1317    *
1318    * @param icon The Icon used in the TitlePane JMenuBar and iconified frames.
1319    */
1320   public void setFrameIcon(Icon icon)
1321   {
1322     if (icon != frameIcon)
1323       {
1324         Icon old = frameIcon;
1325         frameIcon = icon;
1326         firePropertyChange(FRAME_ICON_PROPERTY, old, frameIcon);
1327       }
1328   }
1329
1330   /**
1331    * This method sets the Glass Pane used with this JInternalFrame.
1332    *
1333    * @param glass The Glass Pane to use with this JInternalFrame.
1334    */
1335   public void setGlassPane(Component glass)
1336   {
1337     if (glass != getGlassPane())
1338       {
1339         Component old = getGlassPane();
1340         getRootPane().setGlassPane(glass);
1341         firePropertyChange(GLASS_PANE_PROPERTY, old, glass);
1342       }
1343   }
1344
1345   /**
1346    * This method iconifies or deiconifies this JInternalFrame given the
1347    * boolean argument. If the JInternalFrame becomes iconified, it will fire
1348    * an INTERNAL_FRAME_ICONIFIED event. If the JInternalFrame becomes
1349    * deiconified, it will fire anINTERNAL_FRAME_DEICONIFIED event.
1350    *
1351    * @param b Whether this JInternalFrame is to be iconified or deiconified.
1352    *
1353    * @throws PropertyVetoException DOCUMENT ME!
1354    */
1355   public void setIcon(boolean b) throws PropertyVetoException
1356   {
1357     if (b != isIcon())
1358       {
1359         fireVetoableChange(IS_ICON_PROPERTY, b, isIcon);
1360
1361         isIcon = b;
1362
1363         firePropertyChange(IS_ICON_PROPERTY, ! isIcon, isIcon);
1364         if (b)
1365           fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_ICONIFIED);
1366         else
1367           fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED);
1368       }
1369   }
1370
1371   /**
1372    * This method sets whether the JInternalFrame can be iconified. (This means
1373    * that the JInternalFrame can be turned into an icon if minimized).
1374    *
1375    * @param b Whether the JInternalFrame can be iconified.
1376    */
1377   public void setIconifiable(boolean b)
1378   {
1379     iconable = b;
1380   }
1381
1382   /**
1383    * This method sets the JMenuBar to be used with this JInternalFrame.
1384    *
1385    * @param b The JMenuBar to be used with this JInternalFrame.
1386    */
1387   public void setJMenuBar(JMenuBar b)
1388   {
1389     getRootPane().setJMenuBar(b);
1390   }
1391
1392   /**
1393    * A helper method that set the layer that this JInternalFrame resides in.
1394    * Using this version of the method means that the user should not set it
1395    * to values that are already defined in JLayeredPane. If predefined values
1396    * are to be used, the user should use the setLayer(Integer) version.
1397    *
1398    * @param layer The layer to place this JInternalFrame in.
1399    */
1400   public void setLayer(int layer)
1401   {
1402     setLayer(new Integer(layer));
1403   }
1404
1405   /**
1406    * A helper method that sets the layer that this JInternalFrame resides in.
1407    * Calling this version of the method should use layer values that are
1408    * already defined in JLayeredPane.
1409    *
1410    * @param layer The layer to place this JInternalFrame in.
1411    */
1412   public void setLayer(Integer layer)
1413   {
1414     JDesktopPane p = getDesktopPane();
1415     if (p != null)
1416       {
1417         int pos = p.getPosition(this);
1418         p.setLayer(this, layer.intValue(), pos);
1419       }
1420   }
1421
1422   /**
1423    * This method sets the JLayeredPane to use with this JInternalFrame.
1424    *
1425    * @param layered The JLayeredPane to use as a layeredPane.
1426    */
1427   public void setLayeredPane(JLayeredPane layered)
1428   {
1429     if (layered != getLayeredPane())
1430       {
1431         JLayeredPane old = getLayeredPane();
1432         getRootPane().setLayeredPane(layered);
1433         firePropertyChange(LAYERED_PANE_PROPERTY, old, layered);
1434       }
1435   }
1436
1437   /**
1438    * This method sets whether the JInternalFrame can be maximized.
1439    *
1440    * @param b Whether this JInternalFrame can be maximized.
1441    */
1442   public void setMaximizable(boolean b)
1443   {
1444     maximizable = b;
1445   }
1446
1447   /**
1448    * This method sets the Layout Manager used in the JInternalFrame. SetLayout
1449    * should not be called on the JInternalFrame directly. Instead, it should
1450    * be called with JInternalFrame.getContentPane().setLayout. Calls to this
1451    * method with root pane checking enabled will cause exceptions to be
1452    * thrown.
1453    *
1454    * @param manager The Layout Manager to be used with the JInternalFrame.
1455    *
1456    * @throws Error If rootPaneChecking is enabled.
1457    */
1458   public void setLayout(LayoutManager manager)
1459   {
1460     if (isRootPaneCheckingEnabled())
1461       throw new Error("Cannot set layout. Use getContentPane().setLayout() instead.");
1462     super.setLayout(manager);
1463   }
1464
1465   /**
1466    * This method sets the JInternalFrame to maximized (if the given argument
1467    * is true) or restores the JInternalFrame to its normal bounds otherwise.
1468    *
1469    * @param b Whether this JInteralFrame will be maximized or restored.
1470    *
1471    * @throws PropertyVetoException If a VetoableChangeListener vetoes the change.
1472    */
1473   public void setMaximum(boolean b) throws PropertyVetoException
1474   {
1475     if (b != isMaximum())
1476       {
1477         fireVetoableChange(IS_MAXIMUM_PROPERTY, b, isMaximum);
1478         isMaximum = b;
1479         if (b)
1480           setNormalBounds(getBounds());
1481         maxTransition = ! b;
1482         firePropertyChange(IS_MAXIMUM_PROPERTY, ! isMaximum, isMaximum);
1483         maxTransition = false;
1484       }
1485   }
1486
1487   /**
1488    * This method is deprecated. This method sets the JMenuBar used with this
1489    * JInternalFrame.
1490    *
1491    * @param m The JMenuBar to use with this JInternalFrame.
1492    *
1493    * @deprecated 1.0.3
1494    */
1495   public void setMenuBar(JMenuBar m)
1496   {
1497     setJMenuBar(m);
1498   }
1499
1500   /**
1501    * This method sets the bounds that this JInternalFrame will be restored to.
1502    *
1503    * @param r The bounds that this JInternalFrame will be restored to.
1504    */
1505   public void setNormalBounds(Rectangle r)
1506   {
1507     storedBounds.setBounds(r.x, r.y, r.width, r.height);
1508   }
1509
1510   /**
1511    * This method sets whether the JInternalFrame can be resized by a user
1512    * action (like dragging at the frame borders).
1513    *
1514    * @param b Whether this JInternalFramer can be resized.
1515    */
1516   public void setResizable(boolean b)
1517   {
1518     resizable = b;
1519   }
1520
1521   /**
1522    * This method sets the Root Pane for this JInternalFrame.
1523    *
1524    * @param root The Root Pane for this JInternalFrame.
1525    */
1526   protected void setRootPane(JRootPane root)
1527   {
1528     if (rootPane != null)
1529       remove(rootPane);
1530
1531     rootPane = root;
1532     add(root);
1533   }
1534
1535   /**
1536    * This method sets whether root pane checking is enabled. If root pane
1537    * checking is enabled, then calls to addImpl and setLayout will throw
1538    * exceptions.
1539    *
1540    * @param enabled Whether root pane checking is enabled.
1541    */
1542   protected void setRootPaneCheckingEnabled(boolean enabled)
1543   {
1544     rootPaneCheckingEnabled = enabled;
1545   }
1546
1547   /**
1548    * This method sets whether this JInternalFrame is the selected frame in the
1549    * JDesktopPane (or other container). When selected, a JInternalFrame will
1550    * have focus and paint its TitlePane differently (usually a different
1551    * colour). If this method selects the frame, this JInternalFrame will fire
1552    * an INTERNAL_FRAME_ACTIVATED event. If it deselects this frame, it will
1553    * fire an INTERNAL_FRAME_DEACTIVATED event.
1554    *
1555    * @param selected Whether this JInternalFrame will become selected or
1556    *        deselected.
1557    *
1558    * @throws PropertyVetoException If a VetoableChangeListener vetoes the change.
1559    */
1560   public void setSelected(boolean selected) throws PropertyVetoException
1561   {
1562     if (selected != isSelected())
1563       {
1564         fireVetoableChange(IS_SELECTED_PROPERTY, selected, isSelected);
1565
1566         if (! selected)
1567           defaultFocus = getMostRecentFocusOwner();
1568
1569         isSelected = selected;
1570
1571         if (selected)
1572           restoreSubcomponentFocus();
1573
1574         firePropertyChange(IS_SELECTED_PROPERTY, ! isSelected, isSelected);
1575
1576         if (isSelected)
1577           fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_ACTIVATED);
1578         else
1579           fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED);
1580       }
1581   }
1582
1583   /**
1584    * This method sets the title displayed in the TitlePane of this
1585    * JInternalFrame.
1586    *
1587    * @param title The title displayed.
1588    */
1589   public void setTitle(String title)
1590   {
1591     if (title == null && this.title == null)
1592       return;
1593     if (title == null || this.title == null || ! this.title.equals(title))
1594       {
1595         String old = title;
1596         this.title = title;
1597         firePropertyChange(TITLE_PROPERTY, old, this.title);
1598       }
1599   }
1600
1601   /**
1602    * This method displays the JInternalFrame. If it is not visible, this
1603    * method will bring this JInternalFrame to the front, make it visible and
1604    * select it. If this is the first time this JInternalFrame is made
1605    * visible, an INTERNAL_FRAME_OPENED event will be fired.
1606    */
1607   public void show()
1608   {
1609     if (! isVisible())
1610       {
1611         moveToFront();
1612         super.show();
1613
1614         JDesktopPane pane = getDesktopPane();
1615         if (pane != null)
1616           pane.setSelectedFrame(this);
1617         else
1618           {
1619             try
1620               {
1621                 setSelected(true);
1622               }
1623             catch (PropertyVetoException e)
1624               {
1625                 // Do nothing. if they don't want to be selected.
1626               }
1627           }
1628         if (isFirstTimeVisible)
1629           {
1630             isFirstTimeVisible = false;
1631             fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_OPENED);
1632           }
1633       }
1634   }
1635
1636   /**
1637    * This method is used to set the UI responsible for the JInternalFrame.
1638    *
1639    * @param ui The UI responsible for the JInternalFrame.
1640    */
1641   public void setUI(InternalFrameUI ui)
1642   {
1643     super.setUI(ui);
1644   }
1645
1646   /**
1647    * This method causes the JInternalFrame to be brough to back in the
1648    * z-order.
1649    */
1650   public void toBack()
1651   {
1652     moveToBack();
1653   }
1654
1655   /**
1656    * This method causes the JInternalFrame to be brought to front in the
1657    * z-order.
1658    */
1659   public void toFront()
1660   {
1661     moveToFront();
1662   }
1663
1664   /**
1665    * This method resets the UI to the Look and Feel defaults.
1666    */
1667   public void updateUI()
1668   {
1669     setUI((InternalFrameUI) UIManager.getUI(this));
1670   }
1671
1672   /**
1673    * This helper method allows JInternalFrames to signal that they were
1674    * iconned for the first time.
1675    *
1676    * @param b Whether the JInternalFrame was iconned.
1677    * @param ID The identifier of the property change event to fire if the
1678    *        JInternalFrame is iconned for the first time.
1679    */
1680   void setWasIcon(boolean b, String ID)
1681   {
1682     if (b && ! wasIcon)
1683       {
1684         wasIcon = b;
1685         firePropertyChange(ID, ! b, b);
1686       }
1687   }
1688
1689   /**
1690    * This helper method returns whether the JInternalFrame has been iconned
1691    * once already.
1692    *
1693    * @return Whether the JInternalFrame has been iconned once already.
1694    */
1695   boolean getWasIcon()
1696   {
1697     return wasIcon;
1698   }
1699
1700   /**
1701    * This method is a convenience method to fire vetoable property changes.
1702    *
1703    * @param name The identifier of the property change.
1704    * @param oldValue The old value.
1705    * @param newValue The new value.
1706    *
1707    * @throws PropertyVetoException Fired if a vetoable change listener vetoes
1708    *         the change.
1709    */
1710   private void fireVetoableChange(String name, boolean oldValue,
1711                                   boolean newValue)
1712                            throws PropertyVetoException
1713   {
1714     super.fireVetoableChange(name, Boolean.valueOf(oldValue), Boolean.valueOf(newValue));
1715   }
1716 }