Package Summary Overview Summary

### class:DefaultDesktopManager [NONE]
- All Implemented Interfaces: Serializable, DesktopManager
      public class DefaultDesktopManager
      extends Object
      implements DesktopManager, Serializable
This is an implementation of the `DesktopManager`. It currently implements the basic behaviors for managing `JInternalFrame`s in an arbitrary parent. `JInternalFrame`s that are not children of a `JDesktop` will use this component to handle their desktop-like actions. This class provides a policy for the various JInternalFrame methods, it is not meant to be called directly rather the various JInternalFrame methods will call into the DesktopManager. Since: 1.2 See Also: `JDesktopPane`, `JInternalFrame`

### constructor:DefaultDesktopManager() [NONE]
- #### DefaultDesktopManager
      public DefaultDesktopManager()

### method:openFrame(javax.swing.JInternalFrame) [NONE]
- #### openFrame
      public void openFrame(JInternalFrame f)
Normally this method will not be called. If it is, it tries to determine the appropriate parent from the desktopIcon of the frame. Will remove the desktopIcon from its parent if it successfully adds the frame. Specified by: `openFrame` in interface `DesktopManager` Parameters: `f` - the `JInternalFrame` to be displayed

### method:closeFrame(javax.swing.JInternalFrame) [NONE]
- #### closeFrame
      public void closeFrame(JInternalFrame f)
Removes the frame, and, if necessary, the `desktopIcon`, from its parent. Specified by: `closeFrame` in interface `DesktopManager` Parameters: `f` - the `JInternalFrame` to be removed

### method:maximizeFrame(javax.swing.JInternalFrame) [NONE]
- #### maximizeFrame
      public void maximizeFrame(JInternalFrame f)
Resizes the frame to fill its parents bounds. Specified by: `maximizeFrame` in interface `DesktopManager` Parameters: `f` - the frame to be resized

### method:minimizeFrame(javax.swing.JInternalFrame) [NONE]
- #### minimizeFrame
      public void minimizeFrame(JInternalFrame f)
Restores the frame back to its size and position prior to a `maximizeFrame` call. Specified by: `minimizeFrame` in interface `DesktopManager` Parameters: `f` - the `JInternalFrame` to be restored

### method:iconifyFrame(javax.swing.JInternalFrame) [NONE]
- #### iconifyFrame
      public void iconifyFrame(JInternalFrame f)
Removes the frame from its parent and adds its `desktopIcon` to the parent. Specified by: `iconifyFrame` in interface `DesktopManager` Parameters: `f` - the `JInternalFrame` to be iconified

### method:deiconifyFrame(javax.swing.JInternalFrame) [NONE]
- #### deiconifyFrame
      public void deiconifyFrame(JInternalFrame f)
Removes the desktopIcon from its parent and adds its frame to the parent. Specified by: `deiconifyFrame` in interface `DesktopManager` Parameters: `f` - the `JInternalFrame` to be de-iconified

### method:activateFrame(javax.swing.JInternalFrame) [NONE]
- #### activateFrame
      public void activateFrame(JInternalFrame f)
This will activate f moving it to the front. It will set the current active frame's (if any) `IS_SELECTED_PROPERTY` to `false`. There can be only one active frame across all Layers. Specified by: `activateFrame` in interface `DesktopManager` Parameters: `f` - the `JInternalFrame` to be activated

### method:deactivateFrame(javax.swing.JInternalFrame) [NONE]
- #### deactivateFrame
      public void deactivateFrame(JInternalFrame f)
Description copied from interface: `DesktopManager` Generally, indicate that this frame has lost focus. This is usually called after the JInternalFrame's IS_SELECTED_PROPERTY has been set to false. Specified by: `deactivateFrame` in interface `DesktopManager` Parameters: `f` - the `JInternalFrame` to be deactivated

### method:beginDraggingFrame(javax.swing.JComponent) [NONE]
- #### beginDraggingFrame
      public void beginDraggingFrame(JComponent f)
Description copied from interface: `DesktopManager` This method is normally called when the user has indicated that they will begin dragging a component around. This method should be called prior to any dragFrame() calls to allow the DesktopManager to prepare any necessary state. Normally f will be a JInternalFrame. Specified by: `beginDraggingFrame` in interface `DesktopManager` Parameters: `f` - the `JComponent` being dragged

### method:dragFrame(javax.swing.JComponent, int, int) [NONE]
- #### dragFrame
      public void dragFrame(JComponent f,
                            int newX,
                            int newY)
Moves the visible location of the frame being dragged to the location specified. The means by which this occurs can vary depending on the dragging algorithm being used. The actual logical location of the frame might not change until `endDraggingFrame` is called. Specified by: `dragFrame` in interface `DesktopManager` Parameters: `f` - the `JComponent` being dragged `newX` - the new x-coordinate `newY` - the new y-coordinate

### method:endDraggingFrame(javax.swing.JComponent) [NONE]
- #### endDraggingFrame
      public void endDraggingFrame(JComponent f)
Description copied from interface: `DesktopManager` This method signals the end of the dragging session. Any state maintained by the DesktopManager can be removed here. Normally f will be a JInternalFrame. Specified by: `endDraggingFrame` in interface `DesktopManager` Parameters: `f` - the `JComponent` being dragged

### method:beginResizingFrame(javax.swing.JComponent, int) [NONE]
- #### beginResizingFrame
      public void beginResizingFrame(JComponent f,
                                     int direction)
Description copied from interface: `DesktopManager` This method is normally called when the user has indicated that they will begin resizing the frame. This method should be called prior to any resizeFrame() calls to allow the DesktopManager to prepare any necessary state. Normally f will be a JInternalFrame. Specified by: `beginResizingFrame` in interface `DesktopManager` Parameters: `f` - the `JComponent` being resized

### method:resizeFrame(javax.swing.JComponent, int, int, int, int) [NONE]
- #### resizeFrame
      public void resizeFrame(JComponent f,
                              int newX,
                              int newY,
                              int newWidth,
                              int newHeight)
Calls `setBoundsForFrame` with the new values. Specified by: `resizeFrame` in interface `DesktopManager` Parameters: `f` - the component to be resized `newX` - the new x-coordinate `newY` - the new y-coordinate `newWidth` - the new width `newHeight` - the new height

### method:endResizingFrame(javax.swing.JComponent) [NONE]
- #### endResizingFrame
      public void endResizingFrame(JComponent f)
Description copied from interface: `DesktopManager` This method signals the end of the resize session. Any state maintained by the DesktopManager can be removed here. Normally f will be a JInternalFrame. Specified by: `endResizingFrame` in interface `DesktopManager` Parameters: `f` - the `JComponent` being resized

### method:setBoundsForFrame(javax.swing.JComponent, int, int, int, int) [NONE]
- #### setBoundsForFrame
      public void setBoundsForFrame(JComponent f,
                                    int newX,
                                    int newY,
                                    int newWidth,
                                    int newHeight)
This moves the `JComponent` and repaints the damaged areas. Specified by: `setBoundsForFrame` in interface `DesktopManager` Parameters: `f` - the `JComponent` being moved or resized `newX` - the new x-coordinate `newY` - the new y-coordinate `newWidth` - the new width `newHeight` - the new height

### method:removeIconFor(javax.swing.JInternalFrame) [NONE]
- #### removeIconFor
      protected void removeIconFor(JInternalFrame f)
Convenience method to remove the desktopIcon of f is necessary. Parameters: `f` - the `JInternalFrame` for which to remove the `desktopIcon`

### method:getBoundsForIconOf(javax.swing.JInternalFrame) [NONE]
- #### getBoundsForIconOf
      protected Rectangle getBoundsForIconOf(JInternalFrame f)
The `iconifyFrame()` code calls this to determine the proper bounds for the desktopIcon. Parameters: `f` - the `JInternalFrame` of interest Returns: a `Rectangle` containing bounds for the `desktopIcon`

### method:setPreviousBounds(javax.swing.JInternalFrame, java.awt.Rectangle) [NONE]
- #### setPreviousBounds
      protected void setPreviousBounds(JInternalFrame f,
                                       Rectangle r)
Stores the bounds of the component just before a maximize call. Parameters: `f` - the component about to be resized `r` - the normal bounds to be saved away

### method:getPreviousBounds(javax.swing.JInternalFrame) [NONE]
- #### getPreviousBounds
      protected Rectangle getPreviousBounds(JInternalFrame f)
Gets the normal bounds of the component prior to the component being maximized. Parameters: `f` - the `JInternalFrame` of interest Returns: the normal bounds of the component

### method:setWasIcon(javax.swing.JInternalFrame, java.lang.Boolean) [NONE]
- #### setWasIcon
      protected void setWasIcon(JInternalFrame f,
                                Boolean value)
Sets that the component has been iconized and the bounds of the `desktopIcon` are valid. Parameters: `f` - the `JInternalFrame` of interest `value` - a `Boolean` signifying if component has been iconized

### method:wasIcon(javax.swing.JInternalFrame) [NONE]
- #### wasIcon
      protected boolean wasIcon(JInternalFrame f)
Returns `true` if the component has been iconized and the bounds of the `desktopIcon` are valid, otherwise returns `false`. Parameters: `f` - the `JInternalFrame` of interest Returns: `true` if the component has been iconized; otherwise returns `false`