obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 1820 insertions, 0 deletions

diff --git a/libjava/classpath/javax/swing/JInternalFrame.java b/libjava/classpath/javax/swing/JInternalFrame.java
new file mode 100644
index 000000000..511bc6ed4
--- /dev/null
+++ b/libjava/classpath/javax/swing/JInternalFrame.java
@@ -0,0 +1,1820 @@
+/* JInternalFrame.java --
+   Copyright (C) 2002, 2004, 2005, 2006,  Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package javax.swing;
+
+import java.awt.BorderLayout;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Graphics;
+import java.awt.IllegalComponentStateException;
+import java.awt.KeyboardFocusManager;
+import java.awt.LayoutManager;
+import java.awt.Rectangle;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyVetoException;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.accessibility.AccessibleValue;
+import javax.swing.event.InternalFrameEvent;
+import javax.swing.event.InternalFrameListener;
+import javax.swing.plaf.DesktopIconUI;
+import javax.swing.plaf.InternalFrameUI;
+
+/**
+ * This class implements a Swing widget that looks and acts like a native
+ * frame. The frame can be dragged, resized, closed, etc. Typically,
+ * JInternalFrames are placed in JDesktopPanes. The actions that the
+ * JInternalFrame performs (maximizing, minimizing, etc.) are performed by a
+ * DesktopManager. As with regular frames, components are added by calling
+ * frame.getContentPane().add.
+ */
+public class JInternalFrame extends JComponent implements Accessible,
+                                                          WindowConstants,
+                                                          RootPaneContainer
+{
+
+  private static final long serialVersionUID = -5425177187760785402L;
+
+  /**
+   * Provides the accessibility features for the <code>JInternalFrame</code>
+   * component.
+   */
+  protected class AccessibleJInternalFrame extends AccessibleJComponent
+    implements AccessibleValue
+  {
+    private static final long serialVersionUID = 5931936924175476797L;
+
+    /**
+     * Creates a new <code>AccessibleJInternalFrame</code> instance.
+     */
+    protected AccessibleJInternalFrame()
+    {
+      super();
+    }
+
+    /**
+     * Returns the frame title.
+     *
+     * @return The frame title.
+     */
+    public String getAccessibleName()
+    {
+      return getTitle();
+    }
+
+    /**
+     * Returns the accessible role for the <code>JInternalFrame</code>
+     * component.
+     *
+     * @return {@link AccessibleRole#INTERNAL_FRAME}.
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.INTERNAL_FRAME;
+    }
+
+    /**
+     * Returns an object that provides access to the current, minimum and
+     * maximum values for the {@link JInternalFrame}.  Since this class
+     * implements {@link AccessibleValue}, it returns itself.
+     *
+     * @return The accessible value.
+     */
+    public AccessibleValue getAccessibleValue()
+    {
+      return this;
+    }
+
+    /**
+     * Returns the current layer for the {@link JInternalFrame} component,
+     * as an {@link Integer}.
+     *
+     * @return The layer for the {@link JInternalFrame} component.
+     */
+    public Number getCurrentAccessibleValue()
+    {
+      return new Integer(getLayer());
+    }
+
+    /**
+     * Returns the maximum permitted accessible value.
+     *
+     * @return <code>Integer(Integer.MAX_VALUE)</code>.
+     */
+    public Number getMaximumAccessibleValue()
+    {
+      return new Integer(Integer.MAX_VALUE);
+    }
+
+    /**
+     * Returns the minimum permitted accessible value.
+     *
+     * @return <code>Integer(Integer.MIN_VALUE)</code>.
+     */
+    public Number getMinimumAccessibleValue()
+    {
+      return new Integer(Integer.MIN_VALUE);
+    }
+
+    /**
+     * Sets the layer for the internal frame.
+     *
+     * @param n  the layer (see the constants defined in {@link JLayeredPane}).
+     *
+     * @return <code>true</code> if the value is set, and <code>false</code>
+     *         if it was not set.
+     */
+    public boolean setCurrentAccessibleValue(Number n)
+    {
+      if (n == null)
+        return false;
+      setLayer(n.intValue());
+      return true;
+    }
+  }
+
+  /**
+   * This class represents the JInternalFrame while it is iconified.
+   */
+  public static class JDesktopIcon extends JComponent implements Accessible
+  {
+    /**
+     * Provides the accessibility features for the <code>JDesktopIcon</code>
+     * component.
+     */
+    protected class AccessibleJDesktopIcon extends AccessibleJComponent
+      implements AccessibleValue
+    {
+      private static final long serialVersionUID = 5035560458941637802L;
+
+      /**
+       * Creates a new <code>AccessibleJDesktopIcon</code> instance.
+       */
+      protected AccessibleJDesktopIcon()
+      {
+        super();
+      }
+
+      /**
+       * Returns the accessible role for the <code>JDesktopIcon</code>
+       * component.
+       *
+       * @return {@link AccessibleRole#DESKTOP_ICON}.
+       */
+      public AccessibleRole getAccessibleRole()
+      {
+        return AccessibleRole.DESKTOP_ICON;
+      }
+
+      /**
+       * Returns an object that provides access to the current, minimum and
+       * maximum values for the {@link JDesktopIcon}.  Since this class
+       * implements {@link AccessibleValue}, it returns itself.
+       *
+       * @return The accessible value.
+       */
+      public AccessibleValue getAccessibleValue()
+      {
+        return this;
+      }
+
+      /**
+       * Returns the current layer for the {@link JInternalFrame} component
+       * represented by this <code>JDesktopIcon</code>, as an {@link Integer}.
+       *
+       * @return The layer.
+       */
+      public Number getCurrentAccessibleValue()
+      {
+        return new Integer(frame.getLayer());
+      }
+
+      /**
+       * Returns the maximum permitted accessible value.
+       *
+       * @return <code>Integer(Integer.MAX_VALUE)</code>.
+       */
+      public Number getMaximumAccessibleValue()
+      {
+        return new Integer(Integer.MAX_VALUE);
+      }
+
+      /**
+       * Returns the minimum permitted accessible value.
+       *
+       * @return <code>Integer(Integer.MIN_VALUE)</code>.
+       */
+      public Number getMinimumAccessibleValue()
+      {
+        return new Integer(Integer.MIN_VALUE);
+      }
+
+      /**
+       * Sets the layer for the internal frame represented by this
+       * <code>JDesktopIcon</code> component.
+       *
+       * @param n  the layer (see the constants defined in
+       *           {@link JLayeredPane}).
+       *
+       * @return <code>true</code> if the value is set, and <code>false</code>
+       *         if it was not set.
+       */
+      public boolean setCurrentAccessibleValue(Number n)
+      {
+        if (n == null)
+          return false;
+        frame.setLayer(n.intValue());
+        return true;
+      }
+    }
+
+    private static final long serialVersionUID = 4672973344731387687L;
+
+    /** The JInternalFrame this DesktopIcon represents. */
+    JInternalFrame frame;
+
+    /**
+     * Creates a new JDesktopIcon object for representing the given frame.
+     *
+     * @param f The JInternalFrame to represent.
+     */
+    public JDesktopIcon(JInternalFrame f)
+    {
+      frame = f;
+      updateUI();
+    }
+
+  /**
+   * Returns the object that provides accessibility features for this
+   * <code>JDesktopIcon</code> component.
+   *
+   * @return The accessible context (an instance of
+   *         {@link AccessibleJDesktopIcon}).
+   */
+    public AccessibleContext getAccessibleContext()
+    {
+      if (accessibleContext == null)
+        accessibleContext = new AccessibleJDesktopIcon();
+      return accessibleContext;
+    }
+
+    /**
+     * This method returns the JDesktopPane this JDesktopIcon is in.
+     *
+     * @return The JDesktopPane this JDesktopIcon is in.
+     */
+    public JDesktopPane getDesktopPane()
+    {
+      JDesktopPane p = (JDesktopPane) SwingUtilities.getAncestorOfClass(JDesktopPane.class,
+                                                                        this);
+      return p;
+    }
+
+    /**
+     * This method returns the JInternalFrame this JDesktopIcon represents.
+     *
+     * @return The JInternalFrame this JDesktopIcon represents.
+     */
+    public JInternalFrame getInternalFrame()
+    {
+      return frame;
+    }
+
+    /**
+     * This method returns the UI that is responsible for the JDesktopIcon.
+     *
+     * @return The UI that is responsible for the JDesktopIcon.
+     */
+    public DesktopIconUI getUI()
+    {
+      return (DesktopIconUI) ui;
+    }
+
+    /**
+     * This method returns the String identifier that is used to determine
+     * which class is used for JDesktopIcon's UI.
+     *
+     * @return A String identifier for the UI class.
+     */
+    public String getUIClassID()
+    {
+      return "DesktopIconUI";
+    }
+
+    /**
+     * This method sets the JInternalFrame that this JDesktopIcon represents.
+     *
+     * @param f The JInternalFrame that this JDesktopIcon represents.
+     */
+    public void setInternalFrame(JInternalFrame f)
+    {
+      frame = f;
+    }
+
+    /**
+     * This method sets the UI used for this JDesktopIcon.
+     *
+     * @param ui The UI to use.
+     */
+    public void setUI(DesktopIconUI ui)
+    {
+      super.setUI(ui);
+    }
+
+    /**
+     * This method restores the UI property to the defaults.
+     */
+    public void updateUI()
+    {
+      setUI((DesktopIconUI) UIManager.getUI(this));
+    }
+  }
+
+  /**
+   * The property fired in a PropertyChangeEvent when the contentPane property
+   * changes.
+   */
+  public static final String CONTENT_PANE_PROPERTY = "contentPane";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the frameIcon property
+   * changes.
+   */
+  public static final String FRAME_ICON_PROPERTY = "frameIcon";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the glassPane property
+   * changes.
+   */
+  public static final String GLASS_PANE_PROPERTY = "glassPane";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the closed property
+   * changes.
+   */
+  public static final String IS_CLOSED_PROPERTY = "closed";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the icon property
+   * changes.
+   */
+  public static final String IS_ICON_PROPERTY = "icon";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the maximum property
+   * changes.
+   */
+  public static final String IS_MAXIMUM_PROPERTY = "maximum";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the selected property
+   * changes.
+   */
+  public static final String IS_SELECTED_PROPERTY = "selected";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the layeredPane property
+   * changes.
+   */
+  public static final String LAYERED_PANE_PROPERTY = "layeredPane";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the jMenuBar property
+   * changes.
+   */
+  public static final String MENU_BAR_PROPERTY = "JMenuBar";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the rootPane property
+   * changes.
+   */
+  public static final String ROOT_PANE_PROPERTY = "rootPane";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the title property
+   * changes.
+   */
+  public static final String TITLE_PROPERTY = "title";
+
+  /** Whether the JInternalFrame is closable. */
+  protected boolean closable;
+
+  /** Whether the JInternalFrame can be iconified. */
+  protected boolean iconable;
+
+  /** Whether the JInternalFrame is closed. */
+  protected boolean isClosed;
+
+  /** Whether the JInternalFrame has been iconified. */
+  protected boolean isIcon;
+
+  /** Whether the JInternalFrame has been maximized. */
+  protected boolean isMaximum;
+
+  /** Whether the JInternalFrame is the active frame. */
+  protected boolean isSelected;
+
+  /** Whether the JInternalFrame can be maximized. */
+  protected boolean maximizable;
+
+  /**
+   * Whether the JInternalFrame has rootPaneChecking enabled.
+   *
+   * @specnote Should be false to comply with J2SE 5.0
+   */
+  protected boolean rootPaneCheckingEnabled = false;
+
+  /** Whether the JInternalFrame is resizable. */
+  protected boolean resizable;
+
+  /**
+   * The JDesktopIcon that represents the JInternalFrame while it is
+   * iconified.
+   */
+  protected JDesktopIcon desktopIcon;
+
+  /** The icon used in the JMenuBar in the TitlePane. */
+  protected Icon frameIcon;
+
+  /** The rootPane of the JInternalFrame. */
+  protected JRootPane rootPane;
+
+  /** The title on the TitlePane of the JInternalFrame. */
+  protected String title;
+
+  /** The bounds of the JInternalFrame before it was maximized. */
+  private transient Rectangle storedBounds;
+
+  /** The Component that receives focus by default. */
+  private transient Component defaultFocus;
+
+  /** The default close action taken, */
+  private transient int defaultCloseOperation = DISPOSE_ON_CLOSE;
+
+  /** Whether the JInternalFrame has become visible for the very first time. */
+  private transient boolean isFirstTimeVisible = true;
+
+  /** DOCUMENT ME! */
+  private transient boolean wasIcon = false;
+
+  /**
+   * Creates a new JInternalFrame object that has an empty string for its
+   * title, and is non-resizable, non-maximizable, non-iconifiable, and
+   * non-closable.
+   */
+  public JInternalFrame()
+  {
+    this("", false, false, false, false);
+  }
+
+  /**
+   * Creates a new JInternalFrame object with the given title and is
+   * non-resizable, non-maximizable, non-iconifiable, and non-closable.
+   *
+   * @param title The title displayed in the JInternalFrame.
+   */
+  public JInternalFrame(String title)
+  {
+    this(title, false, false, false, false);
+  }
+
+  /**
+   * Creates a new JInternalFrame object with the given title and resizable
+   * properties. The JInternalFrame is non-maximizable, non-iconifiable, and
+   * non-closable.
+   *
+   * @param title The title displayed in the JInternalFrame.
+   * @param resizable Whether the JInternalFrame is resizable.
+   */
+  public JInternalFrame(String title, boolean resizable)
+  {
+    this(title, resizable, false, false, false);
+  }
+
+  /**
+   * Creates a new JInternalFrame object with the given title, resizable, and
+   * closable properties. The JInternalFrame is non-maximizable and
+   * non-iconifiable.
+   *
+   * @param title The title displayed in the JInternalFrame.
+   * @param resizable Whether the JInternalFrame is resizable.
+   * @param closable Whether the JInternalFrame is closable.
+   */
+  public JInternalFrame(String title, boolean resizable, boolean closable)
+  {
+    this(title, resizable, closable, false, false);
+  }
+
+  /**
+   * Creates a new JInternalFrame object with the given title, resizable,
+   * closable and maximizable properties. The JInternalFrame is
+   * non-iconifiable.
+   *
+   * @param title The title displayed in the JInternalFrame.
+   * @param resizable Whether the JInternalFrame is resizable.
+   * @param closable Whether the JInternalFrame is closable.
+   * @param maximizable Whether the JInternalFrame is maximizable.
+   */
+  public JInternalFrame(String title, boolean resizable, boolean closable,
+                        boolean maximizable)
+  {
+    this(title, resizable, closable, maximizable, false);
+  }
+
+  /**
+   * Creates a new JInternalFrame object with the given title, resizable,
+   * closable, maximizable and iconifiable properties.
+   *
+   * @param title The title displayed in the JInternalFrame.
+   * @param resizable Whether the JInternalFrame is resizable.
+   * @param closable Whether the JInternalFrame is closable.
+   * @param maximizable Whether the JInternalFrame is maximizable.
+   * @param iconifiable Whether the JInternalFrame is iconifiable.
+   */
+  public JInternalFrame(String title, boolean resizable, boolean closable,
+                        boolean maximizable, boolean iconifiable)
+  {
+    this.title = title;
+    this.resizable = resizable;
+    this.closable = closable;
+    this.maximizable = maximizable;
+    this.iconable = iconifiable;
+    isMaximum = false;
+    setRootPane(createRootPane());
+    // JInternalFrames are invisible and opaque by default.
+    setVisible(false);
+    setOpaque(true);
+    desktopIcon = new JDesktopIcon(this);
+    updateUI();
+    setRootPaneCheckingEnabled(true); // Done the init stage, now adds go to content pane.
+  }
+
+  /**
+   * This method adds Components to this Container. For JInternalFrames,
+   * instead of calling add directly on the JInternalFrame, it should be
+   * called with JInternalFrame.getContentPane().add. If root pane checking
+   * is enabled, calling this method will cause an exception to be thrown.
+   *
+   * @param comp The Component to add.
+   * @param constraints The constraints on the Component added.
+   * @param index The position to place the Component.
+   *
+   * @throws Error DOCUMENT ME!
+   */
+  protected void addImpl(Component comp, Object constraints, int index)
+  {
+    // If we're in the initialization stage use super.add. Here we add the
+    // rootPane as well as the title bar and other stuff.
+    // Otherwise pass the add onto the content pane.
+    if (isRootPaneCheckingEnabled())
+      getContentPane().add(comp, constraints, index);
+    else
+      super.addImpl(comp,constraints, index);
+  }
+
+  /**
+   * This method adds an InternalFrameListener to this JInternalFrame.
+   *
+   * @param l The listener to add.
+   */
+  public void addInternalFrameListener(InternalFrameListener l)
+  {
+    listenerList.add(InternalFrameListener.class, l);
+  }
+
+  /**
+   * This method is used to create a root pane for the JInternalFrame. This
+   * method is called by the constructors.
+   *
+   * @return A root pane for the JInternalFrame to use.
+   */
+  protected JRootPane createRootPane()
+  {
+    return new JRootPane();
+  }
+
+  /**
+   * This method makes this JInternalFrame invisible, unselected and closed.
+   * If this JInternalFrame is not closed already, it will fire an
+   * INTERNAL_FRAME_CLoSED event. This method is similar to setClosed but it
+   * doesn't give vetoable listeners a chance to veto and it will not fire an
+   * INTERNAL_FRAME_CLOSING event.
+   */
+  public void dispose()
+  {
+    if (isVisible())
+      setVisible(false);
+    if (isSelected())
+      {
+        try
+          {
+            setSelected(false);
+          }
+        catch (PropertyVetoException e)
+          {
+            // Do nothing if they don't want to be unselected.
+          }
+      }
+    if (! isClosed)
+      {
+        firePropertyChange(IS_CLOSED_PROPERTY, Boolean.FALSE, Boolean.TRUE);
+        isClosed = true;
+      }
+    fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSED);
+  }
+
+  /**
+   * This method is used for closing this JInternalFrame. It fires an
+   * INTERNAL_FRAME_CLOSING event and then performs the action specified by
+   * the default close operation.
+   */
+  public void doDefaultCloseAction()
+  {
+    fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSING);
+    switch (getDefaultCloseOperation())
+      {
+      case HIDE_ON_CLOSE:
+            setVisible(false);
+            break;
+      case DISPOSE_ON_CLOSE:
+            dispose();
+            break;
+      }
+  }
+
+  /**
+   * This method fires an InternalFrameEvent to the listeners.
+   *
+   * @param id The type of event being fired. See InternalFrameEvent.
+   */
+  protected void fireInternalFrameEvent(int id)
+  {
+    Object[] ifListeners = listenerList.getListenerList();
+    InternalFrameEvent evt = new InternalFrameEvent(this, id);
+    switch (id)
+      {
+      case InternalFrameEvent.INTERNAL_FRAME_CLOSING:
+        for (int i = ifListeners.length - 2; i >= 0; i -= 2)
+          {
+            if (ifListeners[i] == InternalFrameListener.class)
+              ((InternalFrameListener) ifListeners[i + 1])
+              .internalFrameClosing(evt);
+          }
+        break;
+      case InternalFrameEvent.INTERNAL_FRAME_ACTIVATED:
+        for (int i = ifListeners.length - 2; i >= 0; i -= 2)
+          {
+            if (ifListeners[i] == InternalFrameListener.class)
+              ((InternalFrameListener) ifListeners[i + 1])
+              .internalFrameActivated(evt);
+          }
+        break;
+      case InternalFrameEvent.INTERNAL_FRAME_CLOSED:
+        for (int i = ifListeners.length - 2; i >= 0; i -= 2)
+          {
+            if (ifListeners[i] == InternalFrameListener.class)
+              ((InternalFrameListener) ifListeners[i + 1]).internalFrameClosed(evt);
+          }
+        break;
+      case InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED:
+        for (int i = ifListeners.length - 2; i >= 0; i -= 2)
+          {
+            if (ifListeners[i] == InternalFrameListener.class)
+              ((InternalFrameListener) ifListeners[i + 1])
+              .internalFrameDeactivated(evt);
+          }
+        break;
+      case InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED:
+        for (int i = ifListeners.length - 2; i >= 0; i -= 2)
+          {
+            if (ifListeners[i] == InternalFrameListener.class)
+              ((InternalFrameListener) ifListeners[i + 1])
+              .internalFrameDeiconified(evt);
+          }
+        break;
+      case InternalFrameEvent.INTERNAL_FRAME_ICONIFIED:
+        for (int i = ifListeners.length - 2; i >= 0; i -= 2)
+          {
+            if (ifListeners[i] == InternalFrameListener.class)
+              ((InternalFrameListener) ifListeners[i + 1])
+              .internalFrameIconified(evt);
+          }
+        break;
+      case InternalFrameEvent.INTERNAL_FRAME_OPENED:
+        for (int i = ifListeners.length - 2; i >= 0; i -= 2)
+          {
+            if (ifListeners[i] == InternalFrameListener.class)
+              ((InternalFrameListener) ifListeners[i + 1]).internalFrameOpened(evt);
+          }
+        break;
+      }
+  }
+
+  /**
+   * Returns the object that provides accessibility features for this
+   * <code>JInternalFrame</code> component.
+   *
+   * @return The accessible context (an instance of
+   *     {@link AccessibleJInternalFrame}).
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJInternalFrame();
+    return accessibleContext;
+  }
+
+  /**
+   * This method returns the Content Pane for this JInternalFrame.
+   *
+   * @return The Content Pane for this JInternalFrame.
+   */
+  public Container getContentPane()
+  {
+    return getRootPane().getContentPane();
+  }
+
+  /**
+   * Returns a code for the default action taken when this
+   * <code>JInternalFrame</code> is closed.
+   *
+   * @return The action code (usually one of
+   *     {@link WindowConstants#DO_NOTHING_ON_CLOSE},
+   *     {@link WindowConstants#HIDE_ON_CLOSE}, or
+   *     {@link WindowConstants#DISPOSE_ON_CLOSE}).
+   *
+   * @see #setDefaultCloseOperation(int)
+   * @see #doDefaultCloseAction()
+   */
+  public int getDefaultCloseOperation()
+  {
+    return defaultCloseOperation;
+  }
+
+  /**
+   * Returns the <code>JDesktopIcon</code> that represents this
+   * <code>JInternalFrame</code> while it is iconified.
+   *
+   * @return The desktop icon component.
+   */
+  public JDesktopIcon getDesktopIcon()
+  {
+    return desktopIcon;
+  }
+
+  /**
+   * This method searches this JInternalFrame ancestors for an instance of
+   * JDesktopPane. If one is found, it is returned. If none is found, then it
+   * will search the JDesktopIcon for a JDesktopPane.
+   *
+   * @return The JDesktopPane that this JInternalFrame belongs to.
+   */
+  public JDesktopPane getDesktopPane()
+  {
+    JDesktopPane value = (JDesktopPane) SwingUtilities.getAncestorOfClass(JDesktopPane.class,
+                                                                          this);
+    if (value == null && desktopIcon != null)
+      value = desktopIcon.getDesktopPane();
+    return value;
+  }
+
+  /**
+   * This method returns null because this must always be the root of a focus
+   * traversal.
+   *
+   * @return always null
+   *
+   * @since 1.4
+   */
+  public final Container getFocusCycleRootAncestor()
+  {
+    // as defined.
+    return null;
+  }
+
+  /**
+   * This method returns the child Component that will receive focus if this
+   * JInternalFrame is selected.
+   *
+   * @return The child Component that will receive focus.
+   */
+  public Component getFocusOwner()
+  {
+    if (isSelected())
+      {
+        Component focus = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
+        if (SwingUtilities.isDescendingFrom(focus, this))
+          {
+            defaultFocus = focus;
+            return focus;
+          }
+      }
+    return null;
+  }
+
+  /**
+   * This method returns the Frame Icon (the icon used in the JInternalFrame
+   * TitlePane and iconified frame).
+   *
+   * @return The Frame Icon.
+   */
+  public Icon getFrameIcon()
+  {
+    return frameIcon;
+  }
+
+  /**
+   * This method returns the Glass Pane used with this JInternalFrame.
+   *
+   * @return The Glass Pane used with this JInternalFrame.
+   */
+  public Component getGlassPane()
+  {
+    return getRootPane().getGlassPane();
+  }
+
+  /**
+   * This method returns an array of InternalFrameListeners that are listening
+   * to this JInternalFrame.
+   *
+   * @return An array of InternalFrameListeners that are listening to this
+   *         JInternalFrame.
+   */
+  public InternalFrameListener[] getInternalFrameListeners()
+  {
+    return (InternalFrameListener[]) listenerList.getListeners(InternalFrameListener.class);
+  }
+
+  /**
+   * This method returns the JMenuBar for this JInternalFrame.
+   *
+   * @return The JMenuBar for this JInternalFrame.
+   */
+  public JMenuBar getJMenuBar()
+  {
+    return getRootPane().getJMenuBar();
+  }
+
+  /**
+   * This method returns the layer that this JInternalFrame resides in.
+   *
+   * @return The layer that this JInternalFrame resides in.
+   */
+  public int getLayer()
+  {
+    return JLayeredPane.getLayer(this);
+  }
+
+  /**
+   * This method returns the LayeredPane for this JInternalFrame.
+   *
+   * @return The LayeredPane for this JInternalFrame.
+   */
+  public JLayeredPane getLayeredPane()
+  {
+    return getRootPane().getLayeredPane();
+  }
+
+  /**
+   * This method is deprecated. This method returns the JMenuBar for this
+   * JInternalFrame.
+   *
+   * @return The JMenuBar for this JInternalFrame.
+   *
+   * @deprecated 1.0.3
+   */
+  public JMenuBar getMenuBar()
+  {
+    return getJMenuBar();
+  }
+
+  /**
+   * This method returns the child Component that will receive focus when the
+   * JInternalFrame is selected. If the JInternalFrame is selected, this
+   * method returns getFocusOwner(). Otherwise, it will return the child
+   * Component that most recently requested focus. If that is null, then the
+   * initial focus Component is returned. If that is null, then the default
+   * focus component is returned.
+   *
+   * @return The most recent focus owner.
+   */
+  public Component getMostRecentFocusOwner()
+  {
+    if (isSelected())
+      return getFocusOwner();
+    else
+      return defaultFocus;
+  }
+
+  /**
+   * This method returns the bounds of the JInternalFrame if it is not
+   * maximized. If it is maximized, it returns the bounds of the
+   * JInternalFrame before it was maximized (the bounds that it will be
+   * restored to).
+   *
+   * @return A Rectangle that contains this JInternalFrame's normal bounds (or
+   *         just its bounds if it is not maximized).
+   */
+  public Rectangle getNormalBounds()
+  {
+    if (storedBounds == null)
+      return getBounds();
+    else
+      return storedBounds;
+  }
+
+  /**
+   * This method returns the Root Pane for this JInternalFrame.
+   *
+   * @return The Root Pane for this JInternalFrame.
+   */
+  public JRootPane getRootPane()
+  {
+    return rootPane;
+  }
+
+  /**
+   * Returns the frame's title.
+   *
+   * @return The frame's title (can be <code>null</code>).
+   *
+   * @see #setTitle(String)
+   */
+  public String getTitle()
+  {
+    return title;
+  }
+
+  /**
+   * This method returns the UI used to represent the JInternalFrame.
+   *
+   * @return The UI used to represent the JInternalFrame.
+   */
+  public InternalFrameUI getUI()
+  {
+    return (InternalFrameUI) ui;
+  }
+
+  /**
+   * This method returns a String identifier that is used to determine which
+   * class acts as the JInternalFrame's UI.
+   *
+   * @return A String identifier to determine a UI class.
+   */
+  public String getUIClassID()
+  {
+    return "InternalFrameUI";
+  }
+
+  /**
+   * This method returns null.
+   *
+   * @return null.
+   */
+  public final String getWarningString()
+  {
+    // as defined.
+    return null;
+  }
+
+  /**
+   * This method deselects this JInternalFrame and hides it.
+   */
+  public void hide()
+  {
+    if (isIcon())
+      getDesktopIcon().hide();
+    super.hide();
+  }
+
+  /**
+   * This method returns whether this JInternalFrame is closable.
+   *
+   * @return Whether this JInternalFrame is closable.
+   */
+  public boolean isClosable()
+  {
+    return closable;
+  }
+
+  /**
+   * This method returns whether this JInternalFrame has been closed.
+   *
+   * @return Whether this JInternalFrame is closed.
+   */
+  public boolean isClosed()
+  {
+    return isClosed;
+  }
+
+  /**
+   * This must always return true.
+   *
+   * @return always true
+   *
+   * @since 1.4
+   */
+  public final boolean isFocusCycleRoot()
+  {
+    return true;
+  }
+
+  /**
+   * This method returns whether this JInternalFrame is currently iconified.
+   *
+   * @return Whether this JInternalFrame is currently iconified.
+   */
+  public boolean isIcon()
+  {
+    return isIcon;
+  }
+
+  /**
+   * This method returns whether the JInternalFrame can be iconified.
+   *
+   * @return Whether the JInternalFrame can be iconified.
+   */
+  public boolean isIconifiable()
+  {
+    return iconable;
+  }
+
+  /**
+   * This method returns whether this JInternalFrame can be maximized.
+   *
+   * @return Whether this JInternalFrame can be maximized.
+   */
+  public boolean isMaximizable()
+  {
+    return maximizable;
+  }
+
+  /**
+   * This method returns whether this JInternalFrame is currently maximized.
+   *
+   * @return Whether this JInternalFrame is maximized.
+   */
+  public boolean isMaximum()
+  {
+    return isMaximum;
+  }
+
+  /**
+   * This method returns whether this JInternalFrame is resizable.
+   *
+   * @return Whether this JInternalFrame is resizable.
+   */
+  public boolean isResizable()
+  {
+    return resizable;
+  }
+
+  /**
+   * This method returns whether root pane checking is enabled. If root pane
+   * checking is enabled, then calls to addImpl and setLayout will throw
+   * exceptions.
+   *
+   * @return Whether root pane checking is enabled.
+   */
+  protected boolean isRootPaneCheckingEnabled()
+  {
+    return rootPaneCheckingEnabled;
+  }
+
+  /**
+   * This method returns whether this JInternalFrame is selected.
+   *
+   * @return Whether this JInternalFrame is selected.
+   */
+  public boolean isSelected()
+  {
+    return isSelected;
+  }
+
+  /**
+   * A helper method that moves this JInternalFrame to the back if the parent
+   * is a JLayeredPane.
+   */
+  public void moveToBack()
+  {
+    Container p = getParent();
+    if (p instanceof JLayeredPane)
+      ((JLayeredPane) p).moveToBack(this);
+  }
+
+  /**
+   * A helper method that moves this JInternalFrame to the front if the parent
+   * is a JLayeredPane.
+   */
+  public void moveToFront()
+  {
+    Container p = getParent();
+    if (p != null && p instanceof JLayeredPane)
+      ((JLayeredPane) p).moveToFront(this);
+  }
+
+  /**
+   * This method causes the children of this JInternalFrame to be laid out.
+   * Before it begins, if this JInternalFrame is an icon, then it will be
+   * deiconified. If it is maximized, then it will be restored. If either
+   * operation fails, then this method will return.
+   */
+  public void pack()
+  {
+    try
+      {
+        if (isIcon())
+          setIcon(false);
+        else if (isMaximum())
+          setMaximum(false);
+      }
+    catch (PropertyVetoException e)
+      {
+        // Do nothing if they don't want to be restored first.
+      }
+    setSize(getPreferredSize());
+    validate();
+  }
+
+  /**
+   * This method is overridden to allow for speedier painting while this
+   * JInternalFramme is being dragged.
+   *
+   * @param g The Graphics object to paint with.
+   */
+  protected void paintComponent(Graphics g)
+  {
+    super.paintComponent(g);
+  }
+
+  /**
+   * An implementation dependent string describing the current state of this
+   * <code>JInternalFrame</code> instance.
+   *
+   * @return A string describing the current state of this
+   *     <code>JInternalFrame</code> instance.
+   */
+  protected String paramString()
+  {
+    return super.paramString() + ",title=" + getTitle();
+  }
+
+  /**
+   * This method removes the given Component from the Container.
+   *
+   * @param comp The Component to remove.
+   */
+  public void remove(Component comp)
+  {
+    // If we're removing the root pane, use super.remove.  Otherwise
+    // pass it on to the content pane instead.
+    if (comp==rootPane || ! isRootPaneCheckingEnabled())
+      super.remove(comp);
+    else
+      getContentPane().remove(comp);
+  }
+
+  /**
+   * This method removes an InternalFrameListener from this JInternalFrame.
+   *
+   * @param l The listener to remove.
+   */
+  public void removeInternalFrameListener(InternalFrameListener l)
+  {
+    listenerList.remove(InternalFrameListener.class, l);
+  }
+
+  /**
+   * This method resizes and positions this JInternalFrame. It also forces a
+   * relayout of the Container.
+   *
+   * @param x The x position of this JInternalFrame.
+   * @param y The y position of this JInternalFrame.
+   * @param width The width of this JInternalFrame.
+   * @param height The height of this JInternalFrame.
+   */
+  public void reshape(int x, int y, int width, int height)
+  {
+    super.reshape(x, y, width, height);
+    revalidate();
+  }
+
+  /**
+   * This method gives focus to the last child Component that had focus. This
+   * is used by the UI when this JInternalFrame is activated.
+   */
+  public void restoreSubcomponentFocus()
+  {
+    Component c = getMostRecentFocusOwner();
+    if (c != null)
+      c.requestFocus();
+  }
+
+  /**
+   * This method sets whether this JInternalFrame can be closed.
+   *
+   * @param b Whether this JInternalFrame can be closed.
+   */
+  public void setClosable(boolean b)
+  {
+    if (closable != b)
+      {
+        closable = b;
+        firePropertyChange("closable", ! closable, closable);
+      }
+  }
+
+  /**
+   * This method closes the JInternalFrame if the given boolean is true. If it
+   * is false, then the result of this method is unspecified. If the
+   * JInternalFrame is closed, this method does nothing. This method will
+   * first fire an INTERNAL_FRAME_CLOSING event and give a chance for veto
+   * listeners to cancel the close. If no listener vetoes the change, the
+   * closed property is set to true and the JInternalFrame is hidden and
+   * unselected. The method will finish by firing an INTERNAL_FRAME_CLOSED
+   * event.
+   *
+   * @param b Whether the JInternalFrame will be closed.
+   *
+   * @throws PropertyVetoException If a VetoableChangeListener vetoes the change.
+   */
+  public void setClosed(boolean b) throws PropertyVetoException
+  {
+    if (b && ! isClosed())
+      {
+        fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSING);
+        fireVetoableChange(IS_CLOSED_PROPERTY, false, true);
+
+        isClosed = b;
+        dispose();
+
+        firePropertyChange(IS_CLOSED_PROPERTY, false, true);
+      }
+  }
+
+  /**
+   * This method sets the Container to be used as a Content Pane for this
+   * JInternalFrame.
+   *
+   * @param c The Container to use as a Content Pane.
+   */
+  public void setContentPane(Container c)
+  {
+    if (c != getContentPane())
+      {
+        Container old = getContentPane();
+        getRootPane().setContentPane(c);
+        firePropertyChange(CONTENT_PANE_PROPERTY, old, c);
+      }
+  }
+
+  /**
+   * Sets a code for the action to be taken when this
+   * <code>JInternalFrame</code> is closed.  Note that no validation is
+   * performed on the <code>operation</code> code, any integer will be
+   * accepted (nevertheless, you should pass in one of the listed values).
+   *
+   * @param operation  one of {@link WindowConstants#DO_NOTHING_ON_CLOSE},
+   *   {@link WindowConstants#HIDE_ON_CLOSE} or
+   *   {@link WindowConstants#DISPOSE_ON_CLOSE}.
+   *
+   * @see #getDefaultCloseOperation()
+   * @see #doDefaultCloseAction()
+   */
+  public void setDefaultCloseOperation(int operation)
+  {
+    /* Reference implementation allows invalid operations to be specified.
+       In that case, behaviour defaults to DO_NOTHING_ON_CLOSE.
+       processWindowEvent handles the behaviour. getDefaultCloseOperation
+       must return the invalid operator code. */
+    defaultCloseOperation = operation;
+  }
+
+  /**
+   * Sets the <code>JDesktopIcon</code> instance that represents this
+   * <code>JInternalFrame</code> while it is iconified and, if the new icon is
+   * not the same instance as the existing icon, sends a
+   * {@link PropertyChangeEvent} (with the property name
+   * <code>"desktopIcon"</code>) to all registered listeners..
+   *
+   * @param d  the icon.
+   *
+   * @see #getDesktopIcon()
+   */
+  public void setDesktopIcon(JDesktopIcon d)
+  {
+    if (desktopIcon != d)
+      {
+        JDesktopIcon oldIcon = desktopIcon;
+        desktopIcon = d;
+        firePropertyChange("desktopIcon", oldIcon, d);
+      }
+  }
+
+  /**
+   * This method does nothing because this must be the root of a focus
+   * traversal cycle.
+   *
+   * @param focusCycleRoot Not used.
+   */
+  public final void setFocusCycleRoot(boolean focusCycleRoot)
+  {
+    // Do nothing
+  }
+
+  /**
+   * This method sets the Icon to be used in two places. The first is icon
+   * that is painted at the top left corner of the JInternalFrame when it is
+   * not iconified (clicking on that icon will activate the TitlePane
+   * JMenuBar). When the JInternalFrame is iconified, it will be the icon
+   * displayed in the JDesktopIcon. If no icon is set, the JInternalFrame
+   * will use a Look and Feel default.
+   *
+   * @param icon The Icon used in the TitlePane JMenuBar and iconified frames.
+   */
+  public void setFrameIcon(Icon icon)
+  {
+    if (icon != frameIcon)
+      {
+        Icon old = frameIcon;
+        frameIcon = icon;
+        firePropertyChange(FRAME_ICON_PROPERTY, old, frameIcon);
+      }
+  }
+
+  /**
+   * This method sets the Glass Pane used with this JInternalFrame.
+   *
+   * @param glass The Glass Pane to use with this JInternalFrame.
+   */
+  public void setGlassPane(Component glass)
+  {
+    if (glass != getGlassPane())
+      {
+        Component old = getGlassPane();
+        getRootPane().setGlassPane(glass);
+        firePropertyChange(GLASS_PANE_PROPERTY, old, glass);
+      }
+  }
+
+  /**
+   * This method iconifies or deiconifies this JInternalFrame given the
+   * boolean argument. If the JInternalFrame becomes iconified, it will fire
+   * an INTERNAL_FRAME_ICONIFIED event. If the JInternalFrame becomes
+   * deiconified, it will fire anINTERNAL_FRAME_DEICONIFIED event.
+   *
+   * @param b Whether this JInternalFrame is to be iconified or deiconified.
+   *
+   * @throws PropertyVetoException DOCUMENT ME!
+   */
+  public void setIcon(boolean b) throws PropertyVetoException
+  {
+    if (b != isIcon())
+      {
+        fireVetoableChange(IS_ICON_PROPERTY, b, isIcon);
+
+        isIcon = b;
+
+        firePropertyChange(IS_ICON_PROPERTY, ! isIcon, isIcon);
+        if (b)
+          fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_ICONIFIED);
+        else
+          fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED);
+      }
+  }
+
+  /**
+   * This method sets whether the JInternalFrame can be iconified. (This means
+   * that the JInternalFrame can be turned into an icon if minimized).
+   *
+   * @param b Whether the JInternalFrame can be iconified.
+   */
+  public void setIconifiable(boolean b)
+  {
+    if (iconable != b)
+      {
+        iconable = b;
+        firePropertyChange("iconable", ! iconable, iconable);
+      }
+  }
+
+  /**
+   * This method sets the JMenuBar to be used with this JInternalFrame.
+   *
+   * @param b The JMenuBar to be used with this JInternalFrame.
+   */
+  public void setJMenuBar(JMenuBar b)
+  {
+    JMenuBar old = getJMenuBar();
+    getRootPane().setJMenuBar(b);
+    firePropertyChange(MENU_BAR_PROPERTY, old, b);
+  }
+
+  /**
+   * A helper method that set the layer that this JInternalFrame resides in.
+   * Using this version of the method means that the user should not set it
+   * to values that are already defined in JLayeredPane. If predefined values
+   * are to be used, the user should use the setLayer(Integer) version.
+   *
+   * @param layer The layer to place this JInternalFrame in.
+   */
+  public void setLayer(int layer)
+  {
+    setLayer(new Integer(layer));
+  }
+
+  /**
+   * A helper method that sets the layer that this JInternalFrame resides in.
+   * Calling this version of the method should use layer values that are
+   * already defined in JLayeredPane.
+   *
+   * @param layer The layer to place this JInternalFrame in.
+   */
+  public void setLayer(Integer layer)
+  {
+    Container p = getParent();
+    if (p instanceof JLayeredPane)
+      {
+        JLayeredPane lp = (JLayeredPane) p;
+        lp.setLayer(this, layer.intValue(), lp.getPosition(this));
+      }
+    else
+      {
+        JLayeredPane.putLayer(this, layer.intValue());
+        if (p != null)
+          p.repaint(getX(), getY(), getWidth(), getHeight());
+      }
+  }
+
+  /**
+   * This method sets the JLayeredPane to use with this JInternalFrame.
+   *
+   * @param layered The JLayeredPane to use as a layeredPane.
+   */
+  public void setLayeredPane(JLayeredPane layered)
+  {
+    if (layered == null)
+      throw new IllegalComponentStateException("LayeredPane must not be null");
+
+    if (layered != getLayeredPane())
+      {
+        JLayeredPane old = getLayeredPane();
+        getRootPane().setLayeredPane(layered);
+        firePropertyChange(LAYERED_PANE_PROPERTY, old, layered);
+      }
+  }
+
+  /**
+   * This method sets whether the JInternalFrame can be maximized.
+   *
+   * @param b Whether this JInternalFrame can be maximized.
+   */
+  public void setMaximizable(boolean b)
+  {
+    if (maximizable != b)
+      {
+        maximizable = b;
+        firePropertyChange("maximizable", ! maximizable, maximizable);
+      }
+  }
+
+  /**
+   * This method sets the Layout Manager used in the JInternalFrame. SetLayout
+   * should not be called on the JInternalFrame directly. Instead, it should
+   * be called with JInternalFrame.getContentPane().setLayout. Calls to this
+   * method with root pane checking enabled will cause exceptions to be
+   * thrown.
+   *
+   * @param manager The Layout Manager to be used with the JInternalFrame.
+   *
+   * @throws Error If rootPaneChecking is enabled.
+   */
+  public void setLayout(LayoutManager manager)
+  {
+    // Check if we're in initialization stage.  If so, call super.setLayout
+    // otherwise, valid calls go to the content pane.
+    if (isRootPaneCheckingEnabled())
+      getContentPane().setLayout(manager);
+    else
+      super.setLayout(manager);
+  }
+
+  /**
+   * This method sets the JInternalFrame to maximized (if the given argument
+   * is true) or restores the JInternalFrame to its normal bounds otherwise.
+   *
+   * @param b Whether this JInteralFrame will be maximized or restored.
+   *
+   * @throws PropertyVetoException If a VetoableChangeListener vetoes the change.
+   */
+  public void setMaximum(boolean b) throws PropertyVetoException
+  {
+    if (b != isMaximum)
+      {
+        fireVetoableChange(IS_MAXIMUM_PROPERTY, isMaximum, b);
+        isMaximum = b;
+        firePropertyChange(IS_MAXIMUM_PROPERTY, ! isMaximum, isMaximum);
+      }
+  }
+
+  /**
+   * This method is deprecated. This method sets the JMenuBar used with this
+   * JInternalFrame.
+   *
+   * @param m The JMenuBar to use with this JInternalFrame.
+   *
+   * @deprecated 1.0.3
+   */
+  public void setMenuBar(JMenuBar m)
+  {
+    setJMenuBar(m);
+  }
+
+  /**
+   * This method sets the bounds that this JInternalFrame will be restored to.
+   *
+   * @param r The bounds that this JInternalFrame will be restored to.
+   */
+  public void setNormalBounds(Rectangle r)
+  {
+    storedBounds = r;
+  }
+
+  /**
+   * This method sets whether the JInternalFrame can be resized by a user
+   * action (like dragging at the frame borders).
+   *
+   * @param b Whether this JInternalFramer can be resized.
+   */
+  public void setResizable(boolean b)
+  {
+    if (b != resizable)
+      {
+        resizable = b;
+        firePropertyChange("resizable", ! resizable, resizable);
+      }
+  }
+
+  /**
+   * This method sets the Root Pane for this JInternalFrame.
+   *
+   * @param root The Root Pane for this JInternalFrame.
+   */
+  protected void setRootPane(JRootPane root)
+  {
+    if (rootPane != null)
+      remove(rootPane);
+
+    JRootPane old = rootPane;
+    rootPane = root;
+
+    if (rootPane != null)
+      {
+        boolean checkingEnabled = isRootPaneCheckingEnabled();
+        try
+          {
+            setRootPaneCheckingEnabled(false);
+            add(rootPane, BorderLayout.CENTER);
+          }
+        finally
+          {
+            setRootPaneCheckingEnabled(checkingEnabled);
+          }
+      }
+    firePropertyChange(ROOT_PANE_PROPERTY, old, rootPane);
+  }
+
+  /**
+   * This method sets whether root pane checking is enabled. If root pane
+   * checking is enabled, then calls to addImpl and setLayout will throw
+   * exceptions.
+   *
+   * @param enabled Whether root pane checking is enabled.
+   */
+  protected void setRootPaneCheckingEnabled(boolean enabled)
+  {
+    rootPaneCheckingEnabled = enabled;
+  }
+
+  /**
+   * This method sets whether this JInternalFrame is the selected frame in the
+   * JDesktopPane (or other container). When selected, a JInternalFrame will
+   * have focus and paint its TitlePane differently (usually a different
+   * colour). If this method selects the frame, this JInternalFrame will fire
+   * an INTERNAL_FRAME_ACTIVATED event. If it deselects this frame, it will
+   * fire an INTERNAL_FRAME_DEACTIVATED event.
+   *
+   * @param selected Whether this JInternalFrame will become selected or
+   *        deselected.
+   *
+   * @throws PropertyVetoException If a VetoableChangeListener vetoes the change.
+   */
+  public void setSelected(boolean selected) throws PropertyVetoException
+  {
+    if (selected != isSelected
+        && (! selected || (isIcon ? desktopIcon.isShowing() : isShowing())))
+      {
+        fireVetoableChange(IS_SELECTED_PROPERTY, isSelected, selected);
+
+        if (! selected)
+          defaultFocus = getMostRecentFocusOwner();
+
+        isSelected = selected;
+        firePropertyChange(IS_SELECTED_PROPERTY, ! isSelected, isSelected);
+
+        if (isSelected)
+          fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_ACTIVATED);
+        else
+          fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED);
+
+        if (selected)
+          restoreSubcomponentFocus();
+
+        repaint();
+      }
+  }
+
+  /**
+   * Sets the title for the <code>JInternalFrame</code> and sends a
+   * {@link PropertyChangeEvent} (with the property name
+   * {@link #TITLE_PROPERTY}) to all registered listeners.
+   *
+   * @param title  the new title (<code>null</code> permitted).
+   *
+   * @see #getTitle()
+   */
+  public void setTitle(String title)
+  {
+    String old = this.title;
+    this.title = title;
+    firePropertyChange(TITLE_PROPERTY, old, this.title);
+  }
+
+  /**
+   * This method displays the JInternalFrame. If it is not visible, this
+   * method will bring this JInternalFrame to the front, make it visible and
+   * select it. If this is the first time this JInternalFrame is made
+   * visible, an INTERNAL_FRAME_OPENED event will be fired.
+   */
+  public void show()
+  {
+    if (! isVisible())
+      {
+        if (isFirstTimeVisible)
+          {
+            isFirstTimeVisible = false;
+            fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_OPENED);
+          }
+
+        getDesktopIcon().setVisible(true);
+
+        toFront();
+        super.show();
+
+        if (isIcon())
+          return;
+
+        if (! isSelected())
+          {
+            try
+              {
+                setSelected(true);
+              }
+            catch (PropertyVetoException e)
+              {
+                // Do nothing. if they don't want to be selected.
+              }
+          }
+      }
+  }
+
+  /**
+   * This method is used to set the UI responsible for the JInternalFrame.
+   *
+   * @param ui The UI responsible for the JInternalFrame.
+   */
+  public void setUI(InternalFrameUI ui)
+  {
+    // We must temporarily go into init mode so that the UI can directly
+    // manipulate the JInternalFrame.
+    boolean old = isRootPaneCheckingEnabled();
+    setRootPaneCheckingEnabled(false);
+    super.setUI(ui);
+    setRootPaneCheckingEnabled(old);
+  }
+
+  /**
+   * This method causes the JInternalFrame to be brough to back in the
+   * z-order.
+   */
+  public void toBack()
+  {
+    moveToBack();
+  }
+
+  /**
+   * This method causes the JInternalFrame to be brought to front in the
+   * z-order.
+   */
+  public void toFront()
+  {
+    moveToFront();
+  }
+
+  /**
+   * This method resets the UI to the Look and Feel defaults.
+   */
+  public void updateUI()
+  {
+    // We must go into the init stage when updating the UI, so the UI can
+    // set layout and components directly on the internal frame, not its
+    // content pane.
+        boolean old = isRootPaneCheckingEnabled();
+    setRootPaneCheckingEnabled(false);
+    setUI((InternalFrameUI) UIManager.getUI(this));
+    setRootPaneCheckingEnabled(old);
+  }
+
+  /**
+   * This helper method allows JInternalFrames to signal that they were
+   * iconned for the first time.
+   *
+   * @param b Whether the JInternalFrame was iconned.
+   * @param ID The identifier of the property change event to fire if the
+   *        JInternalFrame is iconned for the first time.
+   */
+  void setWasIcon(boolean b, String ID)
+  {
+    if (b && ! wasIcon)
+      {
+        wasIcon = b;
+        firePropertyChange(ID, ! b, b);
+      }
+  }
+
+  /**
+   * This helper method returns whether the JInternalFrame has been iconned
+   * once already.
+   *
+   * @return Whether the JInternalFrame has been iconned once already.
+   */
+  boolean getWasIcon()
+  {
+    return wasIcon;
+  }
+
+  /**
+   * This method is a convenience method to fire vetoable property changes.
+   *
+   * @param name The identifier of the property change.
+   * @param oldValue The old value.
+   * @param newValue The new value.
+   *
+   * @throws PropertyVetoException Fired if a vetoable change listener vetoes
+   *         the change.
+   */
+  private void fireVetoableChange(String name, boolean oldValue,
+                                  boolean newValue)
+                           throws PropertyVetoException
+  {
+    super.fireVetoableChange(name, Boolean.valueOf(oldValue), Boolean.valueOf(newValue));
+  }
+}