Warning: Serialized objects of this class will not be compatible with future Swing releases. The current serialization support is appropriate for short term storage or RMI between applications running the same version of Swing. As of 1.4, support for long term storage of all JavaBeans^TM has been added to the java.beans package. Please see {@link java.beans.XMLEncoder}. 

Warning: Serialized objects of this class will not be compatible with future Swing releases. The current serialization support is appropriate for short term storage or RMI between applications running the same version of Swing. As of 1.4, support for long term storage of all JavaBeans^TM has been added to the java.beans package. Please see {@link java.beans.XMLEncoder}. 

Also see:

JRootPane
RootPaneContainer

Also see:

isRootPaneCheckingEnabled
setRootPaneCheckingEnabled
javax.swing.RootPaneContainer

Also see:

maximizable

Also see:

JInternalFrame.JDesktopIcon
setIconifiable

Also see:

isIcon()

Also see:

iconable

 public JInternalFrame() 
{
        this("", false, false, false, false);
}

Creates a non-resizable, non-closable, non-maximizable, non-iconifiable JInternalFrame with no title.

 public JInternalFrame(String title) 
{
        this(title, false, false, false, false);
}

Creates a non-resizable, non-closable, non-maximizable, non-iconifiable JInternalFrame with the specified title. Note that passing in a null title results in unspecified behavior and possibly an exception.

Parameters:

title - the non-null String to display in the title bar

 public JInternalFrame(String title,
    boolean resizable) 
{
        this(title, resizable, false, false, false);
}

Creates a non-closable, non-maximizable, non-iconifiable JInternalFrame with the specified title and resizability.

Parameters:

title - the String to display in the title bar

resizable - if true, the internal frame can be resized

 public JInternalFrame(String title,
    boolean resizable,
    boolean closable) 
{
        this(title, resizable, closable, false, false);
}

Creates a non-maximizable, non-iconifiable JInternalFrame with the specified title, resizability, and closability.

Parameters:

title - the String to display in the title bar

resizable - if true, the internal frame can be resized

closable - if true, the internal frame can be closed

 public JInternalFrame(String title,
    boolean resizable,
    boolean closable,
    boolean maximizable) 
{
        this(title, resizable, closable, maximizable, false);
}

Creates a non-iconifiable JInternalFrame with the specified title, resizability, closability, and maximizability.

Parameters:

title - the String to display in the title bar

resizable - if true, the internal frame can be resized

closable - if true, the internal frame can be closed

maximizable - if true, the internal frame can be maximized

 public JInternalFrame(String title,
    boolean resizable,
    boolean closable,
    boolean maximizable,
    boolean iconifiable) 
{
        setRootPane(createRootPane());
        setLayout(new BorderLayout());
        this.title = title;
        this.resizable = resizable;
        this.closable = closable;
        this.maximizable = maximizable;
        isMaximum = false;
        this.iconable = iconifiable;
        isIcon = false;
        setVisible(false);
        setRootPaneCheckingEnabled(true);
        desktopIcon = new JDesktopIcon(this);
        updateUI();
        sun.awt.SunToolkit.checkAndSetPolicy(this, true);
        addPropertyChangeListenerIfNecessary();
}

Creates a JInternalFrame with the specified title, resizability, closability, maximizability, and iconifiability. All JInternalFrame constructors use this one.

Parameters:

title - the String to display in the title bar

resizable - if true, the internal frame can be resized

closable - if true, the internal frame can be closed

maximizable - if true, the internal frame can be maximized

iconifiable - if true, the internal frame can be iconified

 protected  void addImpl(Component comp,
    Object constraints,
    int index) 
{
        if(isRootPaneCheckingEnabled()) {
            getContentPane().add(comp, constraints, index);
        }
        else {
            super.addImpl(comp, constraints, index);
        }
}

Adds the specified child Component. This method is overridden to conditionally forward calls to the contentPane. By default, children are added to the contentPane instead of the frame, refer to javax.swing.RootPaneContainer for details.

 public  void addInternalFrameListener(InternalFrameListener l) 
{
  // remind: sync ??
      listenerList.add(InternalFrameListener.class, l);
      // remind: needed?
      enableEvents(0);   // turn on the newEventsOnly flag in Component.
}

Adds the specified listener to receive internal frame events from this internal frame.

  void compWriteObjectNotify() 
{
      // need to disable rootpane checking for InternalFrame: 4172083
      boolean old = isRootPaneCheckingEnabled();
      try {
        setRootPaneCheckingEnabled(false);
        super.compWriteObjectNotify();
      }
      finally {
        setRootPaneCheckingEnabled(old);
      }
}

 protected JRootPane createRootPane() 
{
        return new JRootPane();
}

Called by the constructor to set up the JRootPane.

 public  void dispose() 
{
        if (isVisible()) {
            setVisible(false);
        }
        if (isSelected()) {
            try {
                setSelected(false);
            } catch (PropertyVetoException pve) {}
        }
        if (!isClosed) {
          firePropertyChange(IS_CLOSED_PROPERTY, Boolean.FALSE, Boolean.TRUE);
          isClosed = true;
        }
        fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSED);
}

Makes this internal frame invisible, unselected, and closed. If the frame is not already closed, this method fires an INTERNAL_FRAME_CLOSED event. The results of invoking this method are similar to setClosed(true), but dispose always succeeds in closing the internal frame and does not fire an INTERNAL_FRAME_CLOSING event.

 public  void doDefaultCloseAction() 
{
        fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSING);
        switch(defaultCloseOperation) {
          case DO_NOTHING_ON_CLOSE:
            break;
          case HIDE_ON_CLOSE:
            setVisible(false);
            if (isSelected())
                try {
                    setSelected(false);
                } catch (PropertyVetoException pve) {}
            /* should this activate the next frame? that's really
               desktopmanager's policy... */
            break;
          case DISPOSE_ON_CLOSE:
              try {
                fireVetoableChange(IS_CLOSED_PROPERTY, Boolean.FALSE,
                                   Boolean.TRUE);
                isClosed = true;
                setVisible(false);
                firePropertyChange(IS_CLOSED_PROPERTY, Boolean.FALSE,
                                   Boolean.TRUE);
                dispose();
              } catch (PropertyVetoException pve) {}
              break;
          default:
              break;
        }
}

Fires an INTERNAL_FRAME_CLOSING event and then performs the action specified by the internal frame's default close operation. This method is typically invoked by the look-and-feel-implemented action handler for the internal frame's close button.

 protected  void fireInternalFrameEvent(int id) 
{
      Object[] listeners = listenerList.getListenerList();
      InternalFrameEvent e = null;
      for (int i = listeners.length -2; i  >=0; i -= 2){
        if (listeners[i] == InternalFrameListener.class){
          if (e == null){
            e = new InternalFrameEvent(this, id);
            //      System.out.println("InternalFrameEvent: " + e.paramString());
          }
          switch(e.getID()) {
          case InternalFrameEvent.INTERNAL_FRAME_OPENED:
            ((InternalFrameListener)listeners[i+1]).internalFrameOpened(e);
            break;
          case InternalFrameEvent.INTERNAL_FRAME_CLOSING:
            ((InternalFrameListener)listeners[i+1]).internalFrameClosing(e);
            break;
          case InternalFrameEvent.INTERNAL_FRAME_CLOSED:
            ((InternalFrameListener)listeners[i+1]).internalFrameClosed(e);
            break;
          case InternalFrameEvent.INTERNAL_FRAME_ICONIFIED:
            ((InternalFrameListener)listeners[i+1]).internalFrameIconified(e);
            break;
          case InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED:
            ((InternalFrameListener)listeners[i+1]).internalFrameDeiconified(e);
            break;
          case InternalFrameEvent.INTERNAL_FRAME_ACTIVATED:
            ((InternalFrameListener)listeners[i+1]).internalFrameActivated(e);
            break;
          case InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED:
            ((InternalFrameListener)listeners[i+1]).internalFrameDeactivated(e);
            break;
          default:
            break;
          }
        }
      }
      /* we could do it off the event, but at the moment, that's not how
         I'm implementing it */
      //      if (id == InternalFrameEvent.INTERNAL_FRAME_CLOSING) {
      //          doDefaultCloseAction();
      //      }
}

Fires an internal frame event.

 public AccessibleContext getAccessibleContext() 
{
        if (accessibleContext == null) {
            accessibleContext = new AccessibleJInternalFrame();
        }
        return accessibleContext;
}

Gets the AccessibleContext associated with this JInternalFrame. For internal frames, the AccessibleContext takes the form of an AccessibleJInternalFrame object. A new AccessibleJInternalFrame instance is created if necessary.

 public Container getContentPane() 
{
        return getRootPane().getContentPane();
}

Returns the content pane for this internal frame.

 public int getDefaultCloseOperation() 
{
        return defaultCloseOperation;
}

Returns the default operation that occurs when the user initiates a "close" on this internal frame.

 public JInternalFrame.JDesktopIcon getDesktopIcon() 
{
        return desktopIcon;
}

Returns the JDesktopIcon used when this JInternalFrame is iconified.

 public JDesktopPane getDesktopPane() 
{
        Container p;
        // Search upward for desktop
        p = getParent();
        while(p != null && !(p instanceof JDesktopPane))
            p = p.getParent();
        if(p == null) {
           // search its icon parent for desktop
           p = getDesktopIcon().getParent();
           while(p != null && !(p instanceof JDesktopPane))
                p = p.getParent();
        }
        return (JDesktopPane)p;
}

Convenience method that searches the ancestor hierarchy for a JDesktop instance. If JInternalFrame finds none, the desktopIcon tree is searched.

 public final Container getFocusCycleRootAncestor() 
{
        return null;
}

Always returns null because JInternalFrames must always be roots of a focus traversal cycle.

 public Component getFocusOwner() 
{
        if (isSelected()) {
            return lastFocusOwner;
        }
        return null;
}

If this JInternalFrame is active, returns the child that has focus. Otherwise, returns null.

 public Icon getFrameIcon() 
{
        return frameIcon;
}

Returns the image displayed in the title bar of this internal frame (usually in the top-left corner).

 public Component getGlassPane() 
{
        return getRootPane().getGlassPane();
}

Returns the glass pane for this internal frame.

 public InternalFrameListener[] getInternalFrameListeners() 
{
        return (InternalFrameListener[])listenerList.getListeners(
                InternalFrameListener.class);
}

Returns an array of all the InternalFrameListeners added to this JInternalFrame with addInternalFrameListener.

 public JMenuBar getJMenuBar() 
{
        return getRootPane().getJMenuBar();
}

Returns the current JMenuBar for this JInternalFrame, or null if no menu bar has been set.

 public Cursor getLastCursor() 
{
        return lastCursor;
}

Returns the last Cursor that was set by the setCursor method that is not a resizable Cursor.

 public int getLayer() 
{
        return JLayeredPane.getLayer(this);
}

Convenience method for getting the layer attribute of this component.

 public JLayeredPane getLayeredPane() 
{
        return getRootPane().getLayeredPane();
}

Returns the layered pane for this internal frame.

 public JMenuBar getMenuBar() 
{
      return getRootPane().getMenuBar();
}

Returns the current JMenuBar for this JInternalFrame, or null if no menu bar has been set.

 public Component getMostRecentFocusOwner() 
{
        if (isSelected()) {
            return getFocusOwner();
        }
        if (lastFocusOwner != null) {
            return lastFocusOwner;
        }
        FocusTraversalPolicy policy = getFocusTraversalPolicy();
        if (policy instanceof InternalFrameFocusTraversalPolicy) {
            return ((InternalFrameFocusTraversalPolicy)policy).
                getInitialComponent(this);
        }
        Component toFocus = policy.getDefaultComponent(this);
        if (toFocus != null) {
            return toFocus;
        }
        return getContentPane();
}

Returns the child component of this JInternalFrame that will receive the focus when this JInternalFrame is selected. If this JInternalFrame is currently selected, this method returns the same component as the getFocusOwner method. If this JInternalFrame is not selected, then the child component that most recently requested focus will be returned. If no child component has ever requested focus, then this JInternalFrame's initial focusable component is returned. If no such child exists, then this JInternalFrame's default component to focus is returned.

 public Rectangle getNormalBounds() 
{
      /* we used to test (!isMaximum) here, but since this
         method is used by the property listener for the
         IS_MAXIMUM_PROPERTY, it ended up getting the wrong
         answer... Since normalBounds get set to null when the
         frame is restored, this should work better */
      if (normalBounds != null) {
        return normalBounds;
      } else {
        return getBounds();
      }
}

If the JInternalFrame is not in maximized state, returns getBounds(); otherwise, returns the bounds that the JInternalFrame would be restored to.

 public JRootPane getRootPane() 
{
        return rootPane;
}

Returns the rootPane object for this internal frame.

 public String getTitle() 
{
        return title;
}

Returns the title of the JInternalFrame.

 public InternalFrameUI getUI() 
{
        return (InternalFrameUI)ui;
}

Returns the look-and-feel object that renders this component.

 public String getUIClassID() 
{
        return uiClassID;
}

Returns the name of the look-and-feel class that renders this component.

 public final String getWarningString() 
{
        return null;
}

Gets the warning string that is displayed with this internal frame. Since an internal frame is always secure (since it's fully contained within a window that might need a warning string) this method always returns null.

 public  void hide() 
{
        if (isIcon()) {
            getDesktopIcon().setVisible(false);
        }
        super.hide();
}

 public boolean isClosable() 
{
        return closable;
}

Returns whether this JInternalFrame can be closed by some user action.

 public boolean isClosed() 
{
        return isClosed;
}

Returns whether this JInternalFrame is currently closed.

 public final boolean isFocusCycleRoot() 
{
        return true;
}

Always returns true because all JInternalFrames must be roots of a focus traversal cycle.

 public boolean isIcon() 
{
        return isIcon;
}

Returns whether the JInternalFrame is currently iconified.

 public boolean isIconifiable() 
{
        return iconable;
}

Gets the iconable property, which by default is false.

 public boolean isMaximizable() 
{
        return maximizable;
}

Gets the value of the maximizable property.

 public boolean isMaximum() 
{
        return isMaximum;
}

Returns whether the JInternalFrame is currently maximized.

 public boolean isResizable() 
{
        // don't allow resizing when maximized.
        return isMaximum ? false : resizable;
}

Returns whether the JInternalFrame can be resized by some user action.

 protected boolean isRootPaneCheckingEnabled() 
{
        return rootPaneCheckingEnabled;
}

Returns whether calls to add and setLayout are forwarded to the contentPane.

 public boolean isSelected() 
{
        return isSelected;
}

Returns whether the JInternalFrame is the currently "selected" or active frame.

 public  void moveToBack() 
{
        if (isIcon()) {
            if (getDesktopIcon().getParent() instanceof JLayeredPane) {
                ((JLayeredPane)getDesktopIcon().getParent()).
                    moveToBack(getDesktopIcon());
            }
        }
        else if (getParent() instanceof JLayeredPane) {
            ((JLayeredPane)getParent()).moveToBack(this);
        }
}

Convenience method that moves this component to position -1 if its parent is a JLayeredPane.

 public  void moveToFront() 
{
        if (isIcon()) {
            if (getDesktopIcon().getParent() instanceof JLayeredPane) {
                ((JLayeredPane)getDesktopIcon().getParent()).
                    moveToFront(getDesktopIcon());
            }
        }
        else if (getParent() instanceof JLayeredPane) {
            ((JLayeredPane)getParent()).moveToFront(this);
        }
}

Convenience method that moves this component to position 0 if its parent is a JLayeredPane.

 public  void pack() 
{
        try {
            if (isIcon()) {
                setIcon(false);
            } else if (isMaximum()) {
                setMaximum(false);
            }
        } catch(PropertyVetoException e) {
            return;
        }
        setSize(getPreferredSize());
        validate();
}

Causes subcomponents of this JInternalFrame to be laid out at their preferred size. Internal frames that are iconized or maximized are first restored and then packed. If the internal frame is unable to be restored its state is not changed and will not be packed.

 protected  void paintComponent(Graphics g) 
{
                     
      if (isDragging) {
        //         System.out.println("ouch");
         danger = true;
      }
      super.paintComponent(g);
}

Overridden to allow optimized painting when the internal frame is being dragged.

 protected String paramString() 
{
        String rootPaneString = (rootPane != null ?
                                 rootPane.toString() : "");
        String rootPaneCheckingEnabledString = (rootPaneCheckingEnabled ?
                                                "true" : "false");
        String closableString = (closable ? "true" : "false");
        String isClosedString = (isClosed ? "true" : "false");
        String maximizableString = (maximizable ? "true" : "false");
        String isMaximumString = (isMaximum ? "true" : "false");
        String iconableString = (iconable ? "true" : "false");
        String isIconString = (isIcon ? "true" : "false");
        String resizableString = (resizable ? "true" : "false");
        String isSelectedString = (isSelected ? "true" : "false");
        String frameIconString = (frameIcon != null ?
                                  frameIcon.toString() : "");
        String titleString = (title != null ?
                              title : "");
        String desktopIconString = (desktopIcon != null ?
                                    desktopIcon.toString() : "");
        String openedString = (opened ? "true" : "false");
        String defaultCloseOperationString;
        if (defaultCloseOperation == HIDE_ON_CLOSE) {
            defaultCloseOperationString = "HIDE_ON_CLOSE";
        } else if (defaultCloseOperation == DISPOSE_ON_CLOSE) {
            defaultCloseOperationString = "DISPOSE_ON_CLOSE";
        } else if (defaultCloseOperation == DO_NOTHING_ON_CLOSE) {
            defaultCloseOperationString = "DO_NOTHING_ON_CLOSE";
        } else defaultCloseOperationString = "";
        return super.paramString() +
        ",closable=" + closableString +
        ",defaultCloseOperation=" + defaultCloseOperationString +
        ",desktopIcon=" + desktopIconString +
        ",frameIcon=" + frameIconString +
        ",iconable=" + iconableString +
        ",isClosed=" + isClosedString +
        ",isIcon=" + isIconString +
        ",isMaximum=" + isMaximumString +
        ",isSelected=" + isSelectedString +
        ",maximizable=" + maximizableString +
        ",opened=" + openedString +
        ",resizable=" + resizableString +
        ",rootPane=" + rootPaneString +
        ",rootPaneCheckingEnabled=" + rootPaneCheckingEnabledString +
        ",title=" + titleString;
}

Returns a string representation of this JInternalFrame. This method is intended to be used only for debugging purposes, and the content and format of the returned string may vary between implementations. The returned string may be empty but may not be null.

 public  void remove(Component comp) 
{
        int oldCount = getComponentCount();
        super.remove(comp);
        if (oldCount == getComponentCount()) {
            getContentPane().remove(comp);
        }
}

Removes the specified component from the container. If comp is not a child of the JInternalFrame this will forward the call to the contentPane.

 public  void removeInternalFrameListener(InternalFrameListener l) 
{
  // remind: sync??
      listenerList.remove(InternalFrameListener.class, l);
}

Removes the specified internal frame listener so that it no longer receives internal frame events from this internal frame.

 public  void reshape(int x,
    int y,
    int width,
    int height) 
{
        super.reshape(x, y, width, height);
        validate();
        repaint();
}

Moves and resizes this component. Unlike other components, this implementation also forces re-layout, so that frame decorations such as the title bar are always redisplayed.

 public  void restoreSubcomponentFocus() 
{
        if (isIcon()) {
            SwingUtilities2.compositeRequestFocus(getDesktopIcon());
        }
        else {
            // FocusPropertyChangeListener will eventually update
            // lastFocusOwner. As focus requests are asynchronous
            // lastFocusOwner may be accessed before it has been correctly
            // updated. To avoid any problems, lastFocusOwner is immediately
            // set, assuming the request will succeed.
            lastFocusOwner = getMostRecentFocusOwner();
            if (lastFocusOwner == null) {
                // Make sure focus is restored somewhere, so that
                // we don't leave a focused component in another frame while
                // this frame is selected.
                lastFocusOwner = getContentPane();
            }
            lastFocusOwner.requestFocus();
        }
}

Requests the internal frame to restore focus to the last subcomponent that had focus. This is used by the UI when the user selected this internal frame -- for example, by clicking on the title bar.

 public  void setClosable(boolean b) 
{
        Boolean oldValue = closable ? Boolean.TRUE : Boolean.FALSE;
        Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;
        closable = b;
        firePropertyChange("closable", oldValue, newValue);
}

Sets whether this JInternalFrame can be closed by some user action.

 public  void setClosed(boolean b) throws PropertyVetoException 
{
        if (isClosed == b) {
            return;
        }
        Boolean oldValue = isClosed ? Boolean.TRUE : Boolean.FALSE;
        Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;
        if (b) {
          fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSING);
        }
        fireVetoableChange(IS_CLOSED_PROPERTY, oldValue, newValue);
        isClosed = b;
        if (isClosed) {
          setVisible(false);
        }
        firePropertyChange(IS_CLOSED_PROPERTY, oldValue, newValue);
        if (isClosed) {
          dispose();
        } else if (!opened) {
          /* this bogus -- we haven't defined what
             setClosed(false) means. */
          //        fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_OPENED);
          //            opened = true;
        }
}

Closes this internal frame if the argument is true. Do not invoke this method with a false argument; the result of invoking setClosed(false) is unspecified.

If the internal frame is already closed, this method does nothing and returns immediately. Otherwise, this method begins by firing an INTERNAL_FRAME_CLOSING event. Then this method sets the closed property to true unless a listener vetoes the property change. This method finishes by making the internal frame invisible and unselected, and then firing an INTERNAL_FRAME_CLOSED event.

Note: To reuse an internal frame that has been closed, you must add it to a container (even if you never removed it from its previous container). Typically, this container will be the JDesktopPane that previously contained the internal frame.

 public  void setContentPane(Container c) 
{
        Container oldValue = getContentPane();
        getRootPane().setContentPane(c);
        firePropertyChange(CONTENT_PANE_PROPERTY, oldValue, c);
}

Sets this JInternalFrame's contentPane property.

 public  void setCursor(Cursor cursor) 
{
        if (cursor == null) {
            lastCursor = null;
            super.setCursor(cursor);
            return;
        }
        int type = cursor.getType();
        if (!(type == Cursor.SW_RESIZE_CURSOR  ||
              type == Cursor.SE_RESIZE_CURSOR  ||
              type == Cursor.NW_RESIZE_CURSOR  ||
              type == Cursor.NE_RESIZE_CURSOR  ||
              type == Cursor.N_RESIZE_CURSOR   ||
              type == Cursor.S_RESIZE_CURSOR   ||
              type == Cursor.W_RESIZE_CURSOR   ||
              type == Cursor.E_RESIZE_CURSOR)) {
            lastCursor = cursor;
        }
        super.setCursor(cursor);
}

{@inheritDoc}

 public  void setDefaultCloseOperation(int operation) 
{
        this.defaultCloseOperation = operation;
}

Sets the operation that will happen by default when the user initiates a "close" on this internal frame. The possible choices are:

DO_NOTHING_ON_CLOSE

Do nothing. This requires the program to handle the operation in the windowClosing method of a registered InternalFrameListener object.

HIDE_ON_CLOSE

Automatically make the internal frame invisible.

DISPOSE_ON_CLOSE

Automatically dispose of the internal frame.

The default value is DISPOSE_ON_CLOSE. Before performing the specified close operation, the internal frame fires an INTERNAL_FRAME_CLOSING event.

 public  void setDesktopIcon(JInternalFrame.JDesktopIcon d) 
{
        JDesktopIcon oldValue = getDesktopIcon();
        desktopIcon = d;
        firePropertyChange("desktopIcon", oldValue, d);
}

Sets the JDesktopIcon associated with this JInternalFrame.

 public final  void setFocusCycleRoot(boolean focusCycleRoot) 
{

}

Does nothing because JInternalFrames must always be roots of a focus traversal cycle.

 public  void setFrameIcon(Icon icon) 
{
        Icon oldIcon = frameIcon;
        frameIcon = icon;
        firePropertyChange(FRAME_ICON_PROPERTY, oldIcon, icon);
}

Sets an image to be displayed in the titlebar of this internal frame (usually in the top-left corner). This image is not the desktopIcon object, which is the image displayed in the JDesktop when this internal frame is iconified. Passing null to this function is valid, but the look and feel can choose the appropriate behavior for that situation, such as displaying no icon or a default icon for the look and feel.

 public  void setGlassPane(Component glass) 
{
        Component oldValue = getGlassPane();
        getRootPane().setGlassPane(glass);
        firePropertyChange(GLASS_PANE_PROPERTY, oldValue, glass);
}

Sets this JInternalFrame's glassPane property.

 public  void setIcon(boolean b) throws PropertyVetoException 
{
        if (isIcon == b) {
            return;
        }
        /* If an internal frame is being iconified before it has a
           parent, (e.g., client wants it to start iconic), create the
           parent if possible so that we can place the icon in its
           proper place on the desktop. I am not sure the call to
           validate() is necessary, since we are not going to display
           this frame yet */
        firePropertyChange("ancestor", null, getParent());
        Boolean oldValue = isIcon ? Boolean.TRUE : Boolean.FALSE;
        Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;
        fireVetoableChange(IS_ICON_PROPERTY, oldValue, newValue);
        isIcon = b;
        firePropertyChange(IS_ICON_PROPERTY, oldValue, newValue);
        if (b)
          fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_ICONIFIED);
        else
          fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED);
}

Iconifies or de-iconifies this internal frame, if the look and feel supports iconification. If the internal frame's state changes to iconified, this method fires an INTERNAL_FRAME_ICONIFIED event. If the state changes to de-iconified, an INTERNAL_FRAME_DEICONIFIED event is fired.

 public  void setIconifiable(boolean b) 
{
        Boolean oldValue = iconable ? Boolean.TRUE : Boolean.FALSE;
        Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;
        iconable = b;
        firePropertyChange("iconable", oldValue, newValue);
}

Sets the iconable property, which must be true for the user to be able to make the JInternalFrame an icon. Some look and feels might not implement iconification; they will ignore this property.

 public  void setJMenuBar(JMenuBar m) 
{
        JMenuBar oldValue = getMenuBar();
        getRootPane().s