DockingManager

Nested Class Summary
`static interface`	`DockingManager.FloatingContainerCustomizer` A FloatingContainer customizer so that users can customize the FloatingContainer.
`static interface`	`DockingManager.FrameHandle`
`static interface`	`DockingManager.TabbedPaneCustomizer` A tabbed pane customizer so that users can customize the appearance of tabbed pane.

Field Summary
`static int`	`ACTION_ID_HIDDEN_BY_PARENT`
`static String`	`ACTION_NAME_HIDDEN_BY_PARENT`
`static String`	`CONTEXT_MENU_CLOSE`
`static String`	`CONTEXT_MENU_HIDE_AUTOHIDE`
`static String`	`CONTEXT_MENU_TOGGLE_AUTOHIDE`
`static String`	`CONTEXT_MENU_TOGGLE_DOCKABLE`
`static String`	`CONTEXT_MENU_TOGGLE_FLOATING`
`static String`	`CONTEXT_MENU_TOGGLE_MAXIMIZE`
`static int`	`DOUBLE_CLICK_CUSTOM`
`static int`	`DOUBLE_CLICK_NONE`
`static int`	`DOUBLE_CLICK_TO_AUTOHIDE`
`static int`	`DOUBLE_CLICK_TO_FLOAT`
`static int`	`DOUBLE_CLICK_TO_MAXIMIZE`
`static int`	`FLOATING_CONTAINER_TYPE_DIALOG`
`static int`	`FLOATING_CONTAINER_TYPE_FRAME`
`static int`	`FLOATING_CONTAINER_TYPE_WINDOW`
`static int`	`FULL_OUTLINE_MODE` The outline mode will display heavyweight outline.
`static int`	`HW_OUTLINE_MODE` The outline mode is a heavyweight which paints an outline using the new translucent/shaped windows feature in JDK6u10.
`static int`	`HW_TRANSPARENT_OUTLINE_MODE` The outline mode is a heavyweight which paints a transparent window using the new translucent/shaped windows feature in JDK6u10.
`static int`	`MIX_OUTLINE_MODE` The outline mode will use lightweight outline when inside the main window and use heavyweight outline when outside the main window.
`static int`	`PARTIAL_OUTLINE_MODE` The outline mode will paint the outline directly on the layered pane.
`static String`	`PROPERTY_ACTIVE`
`static String`	`PROPERTY_ACTIVE_WORKSPACE`
`static String`	`PROPERTY_ALLOWED_DOCK_SIDES`
`static String`	`PROPERTY_AUTO_DOCKING`
`static String`	`PROPERTY_AUTO_DOCKING_AS_DEFAULT`
`static String`	`PROPERTY_AUTOHIDABLE`
`static String`	`PROPERTY_AUTOHIDE_ALL_TABS`
`static String`	`PROPERTY_AUTOHIDE_SHOWING_CONTENT_HIDDEN`
`static String`	`PROPERTY_CONTINUOUS_LAYOUT`
`static String`	`PROPERTY_CROSS_DRAGGING_ALLOWED`
`static String`	`PROPERTY_CROSS_DROPPING_ALLOWED`
`static String`	`PROPERTY_CUSTOM_INIT_SPLIT_PRIORITY`
`static String`	`PROPERTY_DOCKED_FRAMES_RESIZABLE`
`static String`	`PROPERTY_DOCKING_MANAGER_GROUP`
`static String`	`PROPERTY_DOUBLE_CLICK_ACTION`
`static String`	`PROPERTY_DRAG_ALL_TABS`
`static String`	`PROPERTY_DRAG_GRIPPER_ONLY`
`static String`	`PROPERTY_EASY_TAB_DOCK`
`static String`	`PROPERTY_FLOAT_ALL_TABS`
`static String`	`PROPERTY_FLOATABLE`
`static String`	`PROPERTY_FLOATING_CONTAINER_TYPE`
`static String`	`PROPERTY_FLOATING_FRAMES_RESIZABLE`
`static String`	`PROPERTY_FRAMEHANDLE_ZORDER`
`static String`	`PROPERTY_FRAMES_MANAGED`
`static String`	`PROPERTY_FRAMES_VISIBLE`
`static String`	`PROPERTY_GROUP_ALLOWED_ON_SIDE_PANE`
`static String`	`PROPERTY_HEAVYWEIGHT_COMPONENT_ENABLED`
`static String`	`PROPERTY_HIDABLE`
`static String`	`PROPERTY_HIDE_ALL_TABS`
`static String`	`PROPERTY_HIDE_FLOATINGFRAMES_ON_SWITCH_OUT_OF_APPLICATION`
`static String`	`PROPERTY_HIDE_FLOATINGFRAMES_WHEN_DEACTIVATE`
`static String`	`PROPERTY_INIT_BOUNDS`
`static String`	`PROPERTY_INIT_CENTER_SPLIT`
`static String`	`PROPERTY_INIT_DELAY`
`static String`	`PROPERTY_INIT_EAST_SPLIT`
`static String`	`PROPERTY_INIT_NORTH_SPLIT`
`static String`	`PROPERTY_INIT_SOUTH_SPLIT`
`static String`	`PROPERTY_INIT_SPLIT_PRIORITY`
`static String`	`PROPERTY_INIT_STATE`
`static String`	`PROPERTY_INIT_WEST_SPLIT`
`static String`	`PROPERTY_MAXIMIZE_ALL_TABS`
`static String`	`PROPERTY_NESTED_FLOATING_ALLOWED`
`static String`	`PROPERTY_OUTLINE_MODE`
`static String`	`PROPERTY_PRESERVE_STATE_ON_DRAGGING`
`static String`	`PROPERTY_PROPORTIONAL_SPLITS`
`static String`	`PROPERTY_REARRANGABLE`
`static String`	`PROPERTY_RESIZABLE`
`static String`	`PROPERTY_SHOW_DIVIDER_GRIPPER`
`static String`	`PROPERTY_SHOW_GRIPPER`
`static String`	`PROPERTY_SHOW_TITLE_ON_OUTLINE`
`static String`	`PROPERTY_SHOW_TITLEBAR`
`static String`	`PROPERTY_SHOW_WORKSPACE`
`static String`	`PROPERTY_SIDE_DOCK_ALLOWED`
`static String`	`PROPERTY_SIDEBAR_ROLLOVER`
`static String`	`PROPERTY_STEP_DELAY`
`static String`	`PROPERTY_STEPS`
`static String`	`PROPERTY_TAB_DOCK_ALLOWED`
`static String`	`PROPERTY_TAB_REORDER_ALLOWED`
`static String`	`PROPERTY_UNDO_LIMIT`
`static String`	`PROPERTY_USE_DECORATED_FLOATING_CONTAINER`
`static String`	`PROPERTY_WITHIN_FRAMEBOUNDS_ONDRAGGING`
`static String`	`PROPERTY_WITHIN_SCREENBOUNDS_ONDRAGGING`
`static int`	`SPLIT_CUSTOM` This is used by setInitSplitPriority method.
`static int`	`SPLIT_EAST_SOUTH_WEST_NORTH` This is used by setInitSplitPriority method.
`static int`	`SPLIT_EAST_WEST_SOUTH_NORTH` This is used by setInitSplitPriority method.
`static int`	`SPLIT_SOUTH_NORTH_EAST_WEST` This is used by setInitSplitPriority method.
`static int`	`SPLIT_WEST_SOUTH_EAST_NORTH` This is used by setInitSplitPriority method.
`static int`	`TRANSPARENT_OUTLINE_MODE` The outline mode is again a lightweight outline which paints a transparent pane as the outline.
`static int`	`UNKNOWN_FRAME_BEHAVIOR_HIDE`
`static int`	`UNKNOWN_FRAME_BEHAVIOR_SHOW_INIT`

Fields inherited from interface com.jidesoft.swing.LayoutPersistence
`ATTRIBUTE_PERSISTENCE_NAME, NODE_LAYOUT_PERSISTENCE`

Method Summary
`void`	`activateFrame(String key)` Activates the frame with the key.
`void`	`activateWorkspace()`
`void`	`addDockableFrameDropListener(DockableFrameDropListener l)` Adds the specified listener to receive dockable frame drop events from this dockable frame.
`void`	`addDockableFrameListener(DockableFrameListener l)` Allows you to add a single DockableFramelistener to all DockableFrames managed by the docking manager.
`void`	`addFrame(DockableFrame f)` Adds this frame to the docking DockingManager.
`void`	`addPropertyChangeListener(PropertyChangeListener listener)`
`void`	`addPropertyChangeListener(String propertyName, PropertyChangeListener listener)` Adds a PropertyChangeListener to the listener list for a specific property.
`void`	`addUndo(String name)` Adds a new undo edit.
`void`	`addUndoableEditListener(UndoableEditListener listener)` Adds an UndoableEditListener.
`void`	`autohideAll()` Auto-hide all frames.
`void`	`autohideFrame(String frameKey, int side, int index)` Autohides the frame with specified frameName at the specified side and index.
`void`	`beginDraggingFrame(JComponent f, int mouseX, int mouseY, double relativeX, double relativeY, boolean single)` This method is normally called when the user has indicated that they will begin dragging a component around.
`void`	`beginResizingFrame(JComponent f, int direction)` This methods is normally called when the user has indicated that they will begin resizing the frame.
`void`	`cancelDragging()` Cancel the dragging.
`AutoHideContainer`	`createAutoHideContainer(int side)` Creates the container for the autohidden dockable frames.
`ContainerContainer`	`createContainerContainer()` Creates the container for the tabbed panes.
`FloatingContainer`	`createFloatingContainer(Window owner)` Creates a FloatingContainer.
`FrameContainer`	`createFrameContainer()` Creates the container for the tabs.
`Workspace`	`createWorkspace()` Creates the workspace.
`FrameContainer`	`customizeFrameContainer(FrameContainer frameContainer)` Customize the FrameContainer created by `createFrameContainer()`.
`void`	`denotifyFrame(String key)` Denotifies the frame using the key of that frame.
`void`	`discardAllUndoEdits()` Discard all undo edits
`void`	`dispose()` Removes all used resources.
`void`	`dockFrame(String frameKey, int side, int index)` Docks the frame with specified frameKey at the specified side and index.
`void`	`dragFrame(JComponent f, int newX, int newY, int mouseModifiers)` The user has moved the frame.
`void`	`endDraggingFrame(JComponent f)` This method signals the end of the dragging session.
`void`	`endResizingFrame(JComponent f)` This method signals the end of the resize session.
`FloatingContainer`	`findFloatingComponentAt(int x, int y)`
`void`	`finishShowingAutohideFrame(String frame)` Notifies that the auto hide showing process has been finished.
`void`	`floatFrame(String frameKey, Rectangle bounds, boolean isSingle)` Float the frame with specified frameKey .
`String`	`getActiveFrameKey()` Gets currently selected frame.
`MouseInputListener`	`getActiveMouseInputListener()` This method should only be used by JIDE.
`Map<String,DockContext>`	`getAllContexts()` Gets the all DockContexts in cache.
`List<String>`	`getAllFrameNames()` Gets a list of the keys of all frames.
`Collection<String>`	`getAllFrames()` Gets a collection of all dockable frames's key.
`int`	`getAllowedDockSides()` Gets the allowed dock sides.
`String[]`	`getAllVisibleFrameKeys()` Gets an array of the keys of all visible frames.
`AutoHideContainer`	`getAutoHideContainer(int side)` Gets the autohide container by side.
`String`	`getAutohideShowingFrame()` Return they frame key that is autohideshowing.
`Container`	`getContentContainer()` Gets the content container.
`DockContext`	`getContextOf(String frameKey)` Gets the dockcontext of the frame.
`int[]`	`getCustomInitSplitPriority()` Gets custom init split priority.
`DockableFrameDropListener[]`	`getDockableFrameDropListeners()` Returns an array of all the `DockableFrameDropListener`s added to this `DockableFrame` with `addDockableFrameDropListener`.
`DockableFrameFactory`	`getDockableFrameFactory()` Gets the dockable frame factory.
`DockableFrameListener[]`	`getDockableFrameListeners()` Returns an array of all the `DockableFrameListener`s added to this `DockingManager` with `addDockableFrameListener`.
`DockedFrameContainer`	`getDockedFrameContainer()` Returns the container that holds the docked window within the main frame.
`int`	`getDoubleClickAction()` Gets the action when user double clicks on the title bar of a dockable frame.
`Component`	`getEscapeKeyTargetComponent()` Gets the escape key target component.
`String`	`getFirstFrameKey()` Gets the first visible dockable frame.
`DockingManager.FloatingContainerCustomizer`	`getFloatingContainerCustomizer()` Gets the FloatingContainerCustomizer.
`int`	`getFloatingContainerType()` Gets the floating container type.
`List<FloatingContainer>`	`getFloatingFrames()` Get all floating frames in current layout.
`DockableFrame`	`getFrame(String key)` Gets the frame with the key.
`DockingManagerGroup`	`getGroup()` Gets the DockingManagerGroup.
`Rectangle`	`getInitBounds()` Gets initial bounds of the main frame.
`int`	`getInitCenterSplit()` Gets the initial center split.
`int`	`getInitDelay()` Gets the initial delay.
`int`	`getInitEastSplit()` Gets the initial east split.
`int`	`getInitNorthSplit()` Gets the initial north split.
`int`	`getInitSouthSplit()` Gets the initial south split.
`int`	`getInitSplitPriority()` Gets the initial split priority.
`int`	`getInitState()` Gets initial state of the main frame.
`int`	`getInitWestSplit()` Gets the initial west split.
`String`	`getLastFrameKey()` Gets the last visible dockable frame.
`JComponent`	`getMainContainer()` Gets the main container.
`String`	`getMaximizedFrameKey()` Gets the maximized frame if any.
`String`	`getNextFrame(String frame)` Gets the next visible dockable frame.
`Color`	`getNotificationBackground()` Gets the notification background.
`int`	`getNotificationDelay()` Gets the delay of ms between two flashes when notifyFrame is called.
`Color`	`getNotificationForeground()` Gets the notification foreground.
`int`	`getNotificationSteps()` Gets the number of flashes when notifyFrame is called.
`List<DockingManager.FrameHandle>`	`getOrderedFrames()`
`int`	`getOutlineMode()` Gets contour outline mode.
`int`	`getOutsideSensitiveAreaSize()` Gets the size of the area outside the DockableHolder where the dock action will happen.
`PopupMenuCustomizer`	`getPopupMenuCustomizer()` Gets the popup menu customizer.
`String`	`getPreviousFrame(String frame)` Gets the previous visible dockable frame.
`PropertyChangeListener[]`	`getPropertyChangeListeners()` Returns an array of all the property change listeners registered on this component.
`PropertyChangeListener[]`	`getPropertyChangeListeners(String propertyName)` Returns an array of all the listeners which have been associated with the named property.
`String`	`getResourceString(String key)` Gets the resource string used in DefaultDockingManager.
`RootPaneContainer`	`getRootPaneContainer()` Gets root pane container.
`int`	`getSensitiveAreaSize()` Gets the size of the area where the dock action will happen.
`int`	`getSnapGridSize()` Gets the snap grid size.
`int`	`getStepDelay()` Gets the delay in each step during animation.
`int`	`getSteps()` Gets how many steps in the animation.
`UndoManager`	`getUndoManager()` Gets the underlying UndoManager.
`int`	`getUnknownFrameBehaviorOnLoading()` Gets the unknown frame behavior on loading.
`Workspace`	`getWorkspace()` Gets workspace.
`boolean`	`handleEvent(AWTEvent event)` Handles the AWTEvent.
`void`	`hideFrame(String key)` Hides the frame with the specified key.
`boolean`	`isActive()` Checks if the DockingManager is considered as active docking manager.
`boolean`	`isAutoActivateFocusOwner()` Deprecated. not in use any more due to new focus management mechanism.
`boolean`	`isAutoDocking()` Auto docking means when a dockable frame is dragged, it will automatically attempt to dock to other docked frames.
`boolean`	`isAutoDockingAsDefault()` Auto docking means when a dockable frame is dragged, it will automatically attempt to dock to other docked frames.
`boolean`	`isAutohidable()` Return true if autohiding is allowed for dockable frames.
`boolean`	`isAutohideAllTabs()` When user press autohide button, will it affect all tabs or just selected tab.
`boolean`	`isAutohideShowingContentHidden()` Checks if the content of dockable frame is hidden during sliding.
`boolean`	`isAutohideShowingInProgress()` Checks if autohide showing has started but not finished.
`boolean`	`isContinuousLayout()` Determines whether the JideSplitPane is set to use a continuous layout.
`boolean`	`isCrossDraggingAllowed()` Whether allows a dockable frame in this DockingManager to be dragged into other DockingManagers.
`boolean`	`isCrossDroppingAllowed()` Whether allows a dockable frame in other DockingManagers to be dragged into this DockingManager.
`boolean`	`isDockedFramesResizable()` If the dockable frame can be resized.
`boolean`	`isDragAllTabs()` Checks if dragging the title bar will drag all the dockable frames in that tabbed pane.
`boolean`	`isDragging()` Check if there is a dragging going on.
`boolean`	`isDragGripperOnly()` When the gripper is visible, if the drag only happens when dragging on the gripper.
`boolean`	`isDropAllowed(DockableFrame source, Component target, int side)` Fires an dockable frame drop event to check if dropping is allowed.
`boolean`	`isEasyTabDock()`
`boolean`	`isFloatable()` Return true if floating is allowed for dockable frames.
`boolean`	`isFloatAllTabs()` When user presses toggle floating button, will it affect all tabs or just selected tab.
`boolean`	`isFloatingFramesResizable()` If the floating dockable frame can be resized.
`boolean`	`isGroupAllowedOnSidePane()` Returns true if group is allowed in side bar.
`boolean`	`isHeavyweightComponentEnabled()`
`boolean`	`isHidable()` Return true if dockable frame is allowed to be hidden.
`boolean`	`isHideAllTabs()` When user presses close button, will it affect all tabs or just selected tab.
`boolean`	`isHideFloatingFramesOnSwitchOutOfApplication()` Checks if floating frames will be hidden when user switches a different application.
`boolean`	`isHideFloatingFramesWhenDeactivate()` Checks if the floating frames should be hidden automatically when the main frame is deactivated.
`boolean`	`isHideNewlyAddedFrames()` Checks if newly added frames should be hidden when the old layout is loaded.
`boolean`	`isMaximizeAllTabs()` When user maximizes a dockable frame, will it maximize all tabs or just selected tab.
`boolean`	`isNestedFloatingAllowed()` Checks if nest floating frames are allowed.
`boolean`	`isPreserveAvailableProperty()` Checks if the unavailable dockable frame will remain unavailable after saveLayout method is called.
`boolean`	`isPreserveStateOnDragging()` Preserving state on dragging means dragging will not cause the frame's state to change.
`boolean`	`isProportionalSplits()` Tells whether this docking manager will create proportional split panes when it creates split panes to hold docked frames.
`boolean`	`isRearrangable()` If the dockable frames can be rearranged.
`boolean`	`isResizable()` Deprecated. replaced by `isFloatingFramesResizable()` and `isDockedFramesResizable()`
`boolean`	`isShowContextMenu()` Checks if the context menu should be shown.
`boolean`	`isShowDividerGripper()`
`boolean`	`isShowGripper()`
`boolean`	`isShowInitial()` A client may specify that the docking layout is to be initialized without showing the window.
`boolean`	`isShowTitleBar()` Checks if the title bar of dockable frame is visible.
`boolean`	`isShowTitleOnOutline()` Checks if the title of the dragging dockable frame is displayed on the outline while dragging.
`boolean`	`isShowWorkspace()`
`boolean`	`isSidebarRollover()` Checks if the rollover effect is on for tabs on side bar.
`boolean`	`isSideDockAllowed()`
`boolean`	`isTabDockAllowed()`
`boolean`	`isTabReorderAllowed()`
`boolean`	`isUseDecoratedFloatingContainer()` Checks if it always use decorated dialog or frame as floating container if the floating container type is dialog or frame.
`boolean`	`isUseGlassPaneEnabled()` Checks if we will use glass pane to change cursor.
`boolean`	`isWithinFrameBoundsOnDragging()` Checks the flag of withinFrameBoundsOnDragging.
`boolean`	`isWithinScreenBoundsOnDragging()` Checks the flag of withinScreenBoundsOnDragging.
`boolean`	`isWorkspaceActive()` Returns a flag to indicate if the workspace is active.
`void`	`maximizeFrame(String key)` Maximized the frame.
`void`	`moveFrame(String frameKey, String destFrameKey)` Move the frame to the destFrame and put them into one tabbed pane.
`void`	`moveFrame(String frameKey, String destFrameKey, int side)` Move the frame to the destFrame's side.
`void`	`notifyFrame(String key)` Notifies the frame using the key of that frame.
`void`	`pauseDragFrame()` Pause the dragging session of a frame.
`void`	`redo()` Redo the last undone operation.
`void`	`removeAllFrames()` Removes all frames from this DockingManager.
`void`	`removeContext(String key)` Removes the DockConext that is saved in the cache.
`void`	`removeDockableFrameDropListener(DockableFrameDropListener l)` Removes the specified dockable frame listener so that it no longer receives dockable frame drop events from this dockable frame.
`void`	`removeDockableFrameListener(DockableFrameListener l)` Removes the DockableFrameListener that will event for all DockableFrames managed by the docking manager.
`void`	`removeExtraContexts()` Removes extra DockContexts that is saved in the cache but the corresponding dockable frames are not in DockingManager anymore.
`void`	`removeFrame(String key)` Removes this frame from DockingManager.
`void`	`removeFrame(String key, boolean keepPreviousState)` Removes a frame from this DockingManager.
`void`	`removeFromHiddenFrames(String key)`
`void`	`removePropertyChangeListener(PropertyChangeListener listener)` Removes a PropertyChangeListener from the listener list.
`void`	`removePropertyChangeListener(String propertyName, PropertyChangeListener listener)` Removes a PropertyChangeListener from the listener list for a specific property.
`void`	`removeUndoableEditListener(UndoableEditListener listener)` Removes UndoableEditListener added before.
`void`	`requestFocusInDockingManager()`
`void`	`resetLayout()` This method is called for every rearragement of the dockable frames.
`void`	`resizingFrame(JComponent f, int newX, int newY, int newWidth, int newHeight)` The user has resized the component.
`void`	`restoreFrame()` Restores the frame from maximized state.
`void`	`setActive(boolean active)` Makes the docking manager active.
`void`	`setActiveMouseInputListener(MouseInputListener listener)` This method should only be used by JIDE.
`void`	`setAllowedDockSides(int allowedDockSides)` Sets allowed dock sides.
`void`	`setAutoActivateFocusOwner(boolean autoActivateFocusOwner)` Deprecated. not in use any more due to new focus management mechanism.
`void`	`setAutoDocking(boolean autoDocking)` Auto docking means when a dockable frame is dragged, it will automatically attempt to dock to other docked frames.
`void`	`setAutoDockingAsDefault(boolean autoDockingAsDefault)` Auto docking means when a dockable frame is dragged, it will automatically attempt to dock to other docked frames.
`void`	`setAutohidable(boolean autohidable)` Enable or disable autohide feature of dockable frames
`void`	`setAutohideAllTabs(boolean autohideAllTabs)` When user presses autohide button, will it affect all tabs or just selected tab.
`void`	`setAutohideShowingContentHidden(boolean hide)` Pass in true if you want the content of dockable frame hidden during sliding.
`void`	`setContinuousLayout(boolean b)` Turns continuous layout on or off.
`void`	`setCrossDraggingAllowed(boolean crossDraggingAllowed)`
`void`	`setCrossDroppingAllowed(boolean crossDroppingAllowed)`
`void`	`setCustomInitSplitPriority(int[] customInitSplitPriority)` Sets custom init split priority.
`void`	`setDockableFrameFactory(DockableFrameFactory dockableFrameFactory)` Sets the dockable frame factory.
`void`	`setDockedFramesResizable(boolean resizable)` Enable or disable the resize of dockable frames.
`void`	`setDoubleClickAction(int doubleClickAction)` Sets the action when user double clicks on the title bar of a dockable frame.
`void`	`setDragAllTabs(boolean dragAllTabs)` Sets if dragging title bar will drag all dockable frames in the tabbed pane.
`void`	`setDragGripperOnly(boolean dragGripperOnly)` Sets the value to allow user to drag on the gripper as well as on the title bar.
`void`	`setEasyTabDock(boolean easyTabDock)` Sets the attribute if dragging and pointing to dockable frame will make it tab dock
`void`	`setEscapeKeyTargetComponent(Component escapeKeyTargetComponent)` Sets the escape key target component.
`void`	`setFloatable(boolean floatable)` Enable or disable floating of dockable frames
`void`	`setFloatAllTabs(boolean floatAllTabs)` Sets the option of floatAllTabs.
`void`	`setFloatingContainerCustomizer(DockingManager.FloatingContainerCustomizer customizer)` Sets the FloatingContainerCustomizer.
`void`	`setFloatingContainerType(int floatingContainerType)` Sets the floating container type.
`void`	`setFloatingFramesResizable(boolean resizable)` Enable or disable the resize of floating dockable frames.
`void`	`setFloatingFramesVisible(boolean show)` Sets all floating frame visible or invisible.
`void`	`setFrameAvailable(String key)` Makes the frame available.
`void`	`setFrameUnavailable(String key)` Makes the frame unavailable.
`void`	`setGroup(DockingManagerGroup group)` Sets the DockingManagerGroup.
`void`	`setGroupAllowedOnSidePane(boolean groupAllowedOnSidePane)` If true, group is allowed in side pane.
`void`	`setHeavyweightComponentEnabled(boolean heavyweightComponentEnabled)` Enables heavyweight component.
`void`	`setHidable(boolean hidable)` Enable or disable hiding of dockable frames
`void`	`setHideAllTabs(boolean closeAllTabs)` Sets the option of closeAllTabs.
`void`	`setHideFloatingFramesOnSwitchOutOfApplication(boolean newValue)` Turn hiding floating frames when we switch to a different application on and off.
`void`	`setHideFloatingFramesWhenDeactivate(boolean hideFloatingFramesWhenDeactivate)` Sets if the floating frames should be hidden automatically when the main frame is deactivated.
`void`	`setHideNewlyAddedFrames(boolean hideNewlyAddedFrames)` Sets the flag to hide newly added frames when the old layout is loaded.
`void`	`setInitBounds(Rectangle initBounds)` Sets the initial bounds of the main frame.
`void`	`setInitCenterSplit(int initCenterSplit)` Sets the initial center split.
`void`	`setInitDelay(int initDelay)` Sets the initial delay.
`void`	`setInitEastSplit(int initEastSplit)` Sets the initial east split.
`void`	`setInitNorthSplit(int initNorthSplit)` Sets the initial north split.
`void`	`setInitSouthSplit(int initSouthSplit)` Sets the initial south split.
`void`	`setInitSplitPriority(int initSplitPriority)` Sets the initial split priority.
`void`	`setInitState(int initState)` Sets the initial state of the main frame.
`void`	`setInitWestSplit(int initWestSplit)` Sets the initial west split.
`void`	`setMaximizeAllTabs(boolean maximizeAllTabs)` Sets the option of maximizeAllTabs.
`void`	`setNestedFloatingAllowed(boolean nestedFloatingAllowed)` Sets if allows nested floating frames.
`void`	`setNotificationBackground(Color notificationBackground)` Sets the notification background.
`void`	`setNotificationDelay(int notificationDelay)` Sets the delay between two flashes when notifyFrame is called.
`void`	`setNotificationForeground(Color notificationForeground)` Sets the notification foreground.
`void`	`setNotificationSteps(int notificationSteps)` Sets the number of flashes when notifyFrame is called.
`void`	`setOutlineMode(int outlineMode)` Sets contour outline mode PARTIAL_OUTLINE_MODE: Always uses light-weighted outline.
`void`	`setOutsideSensitiveAreaSize(int sensitiveSize)` Sets the size of the area outside the DockableHolder where the dock action will happen.
`void`	`setPopupMenuCustomizer(PopupMenuCustomizer customizer)` Sets the popup customizer.
`void`	`setPreserveAvailableProperty(boolean preserve)` Sets the flag if the unavailable dockable frame will remain unavailable after saveLayout method is called.
`void`	`setPreserveStateOnDragging(boolean preserveStateOnDragging)` Sets preserveStateOnDragging flag.
`void`	`setProportionalSplits(boolean b)` Sets whether this docking manager will create proportional split panes when it creates split panes to hold docked frames.
`void`	`setRearrangable(boolean rearrangable)` Enable or disable the rearrangement of dockable frames.
`void`	`setResizable(boolean resizable)` Deprecated. replaced by `setFloatingFramesResizable(boolean)` and `setDockedFramesResizable(boolean)`
`void`	`setSensitiveAreaSize(int sensitiveSize)` Sets the size of the area where the dock action will happen.
`void`	`setShowContextMenu(boolean showContextMenu)` Sets the flag to show context menu or not.
`void`	`setShowDividerGripper(boolean showDividerGripper)` Sets the visibility of gripper for JideSplitPane.
`void`	`setShowGripper(boolean showGripper)` Sets the visibility of gripper.
`void`	`setShowInitial(boolean value)` A client may specify that the docking layout is to be initialized without showing the window.
`void`	`setShowTitleBar(boolean showTitleBar)` Sets the visibility of gripper.
`void`	`setShowTitleOnOutline(boolean show)` Sets the flag if the title will be displayed on the ontline while dragging.
`void`	`setShowWorkspace(boolean show)` Shows or hides workspace area.
`void`	`setSidebarRollover(boolean sidebarRollover)` Sets to true if you want the tabs on side bar has rollover effect.
`void`	`setSideDockAllowed(boolean sideDockAllowed)` Sets the attribute if side docking is allowed.
`void`	`setSnapGridSize(int snapGridSize)` Sets the snap grid size.
`void`	`setStepDelay(int stepDelay)` Sets the delay in each step during animation, in ms.
`void`	`setSteps(int steps)` Sets how many steps in the animation, default is 5 steps.
`void`	`setTabbedPaneCustomizer(DockingManager.TabbedPaneCustomizer customizer)` Set a customizer to customize the tabbed pane where dockable frames are.
`void`	`setTabDockAllowed(boolean tabDockAllowed)` Sets the attribute if tab docking is allowed.
`void`	`setTabReorderAllowed(boolean allowed)` Sets the attribute if tab reordering is allowed.
`void`	`setUndoLimit(int limit)` Set the maximum number of edits this UndoManager will hold.
`void`	`setUnknownFrameBehaviorOnLoading(int unknownFrameBehaviorOnLoading)` Sets the unknown frame behavior on loading.
`void`	`setUseDecoratedFloatingContainer(boolean useDecoratedFloatingContainer)` Sets the flag that if decorated dialog or frame is used as floating container when there is only one dockable frame or several dockable frames in the same tabbed pane.
`void`	`setUseGlassPaneEnabled(boolean useGlassPaneEnabled)` Enables us to use glass pane to for cursor change purpose.
`void`	`setWithinFrameBoundsOnDragging(boolean withinFrameBoundsOnDragging)` Sets the flag if dragging a dockable frame is limited to the main JFrame's bounds.
`void`	`setWithinScreenBoundsOnDragging(boolean withinScreenBoundsOnDragging)` Sets the flag if dragging a dockable frame is limited to the screen's bounds.
`boolean`	`shouldVetoRemovingAllFrames()` Checks if the removeAllFrames() should be vetoed.
`void`	`showContextMenu(Component source, Point point, DockableFrame dockableFrame, boolean onTab)` Show context menu of dockable frames.
`void`	`showFrame(String key)` Sets the frame visible using the key of that frame and activate the frame after showing.
`void`	`showFrame(String key, boolean activate)` Sets the frame visible using the key of that frame.
`void`	`showInitial()` A client may specify that the docking layout is to be initialized without showing the window.
`void`	`startShowingAutohideFrame(String frame, int side, int initDelay)` Starts to show the autohide frame.
`void`	`startShowingAutohideFrameImmediately(String frame, int side)` Stops the autohideframe from show immediately.
`void`	`stopShowingAutohideFrame(int initDelay, boolean forceComplete)` Stops showing the autohide frame.
`void`	`stopShowingAutohideFrameImmediately()` Stops the autohideframe from show immediately.
`void`	`switchRootPaneContainer(RootPaneContainer rootContainer)` Change the root pane container.
`void`	`toggleAutohideState(String key)` Toggle the frame between auto-hide mode and docked mode.
`void`	`toggleDockable(String key)` Toggle dockable attribute sof the frame with the specified key.
`void`	`toggleMaximizeState(String key)` Toggle between maximized and restored state.
`void`	`toggleState(String key, boolean single)` Toggle the frame's state.
`void`	`undo()` Undo the last operation done to docking framework.
`void`	`updateComponentTreeUI()` Call this method with LookAndFeel changes.

Methods inherited from interface com.jidesoft.swing.LayoutPersistence
beginLoadLayoutData, getAvailableLayouts, getLayoutDirectory, getLayoutPersistenceName, getLayoutRawData, getLoadCallback, getSaveCallback, getVersion, getXmlEncoding, isLast, isLayoutAvailable, isLayoutDataVersionValid, isLoadDataSuccessful, isNeedFormatCheck, isXmlFormat, loadInitialLayout, loadInitialLayout, loadInitialLayout, loadLayoutData, loadLayoutDataFrom, loadLayoutDataFromFile, loadLayoutFrom, loadLayoutFrom, removeLayout, resetToDefault, saveLayoutData, saveLayoutDataAs, saveLayoutDataToFile, saveLayoutTo, saveLayoutTo, setLast, setLayoutDirectory, setLayoutPersistenceName, setLayoutRawData, setLoadCallback, setNeedFormatCheck, setProfileKey, setSaveCallback, setUseFrameBounds, setUseFrameState, setUsePref, setVersion, setXmlEncoding, setXmlFormat

Methods inherited from interface com.jidesoft.swing.LayoutPersistence

beginLoadLayoutData, getAvailableLayouts, getLayoutDirectory, getLayoutPersistenceName, getLayoutRawData, getLoadCallback, getSaveCallback, getVersion, getXmlEncoding, isLast, isLayoutAvailable, isLayoutDataVersionValid, isLoadDataSuccessful, isNeedFormatCheck, isXmlFormat, loadInitialLayout, loadInitialLayout, loadInitialLayout, loadLayoutData, loadLayoutDataFrom, loadLayoutDataFromFile, loadLayoutFrom, loadLayoutFrom, removeLayout, resetToDefault, saveLayoutData, saveLayoutDataAs, saveLayoutDataToFile, saveLayoutTo, saveLayoutTo, setLast, setLayoutDirectory, setLayoutPersistenceName, setLayoutRawData, setLoadCallback, setNeedFormatCheck, setProfileKey, setSaveCallback, setUseFrameBounds, setUseFrameState, setUsePref, setVersion, setXmlEncoding, setXmlFormat

Methods inherited from interface com.jidesoft.docking.DeprecatedDockingManager
autohideFrame, createAutoHideMouseListener, dockFrame, doLayout, floatFrame, floatingFrameActivated, floatingFrameDeactivated, getActiveFrame, getAutoHideContaner, getDefaultFocusComponent, getFirstFrame, getLastFrame, getMainFrame, getMaximizedFrame, getNextFrame, getPreviousFrame, handleEscapeKey, hideActiveAutohideFrame, isAllowRequestFocus, isFocusDuringLoadLayout, setAutohideShowingFrame, setDefaultFocusComponent, setFocusDuringLayout, startShowingAutohideFrame, startShowingAutohideFrame, toggleAutohideState, toggleDockable, toggleMaximizeState, toggleState

Methods inherited from interface com.jidesoft.docking.DeprecatedDockingManager

autohideFrame, createAutoHideMouseListener, dockFrame, doLayout, floatFrame, floatingFrameActivated, floatingFrameDeactivated, getActiveFrame, getAutoHideContaner, getDefaultFocusComponent, getFirstFrame, getLastFrame, getMainFrame, getMaximizedFrame, getNextFrame, getPreviousFrame, handleEscapeKey, hideActiveAutohideFrame, isAllowRequestFocus, isFocusDuringLoadLayout, setAutohideShowingFrame, setDefaultFocusComponent, setFocusDuringLayout, startShowingAutohideFrame, startShowingAutohideFrame, toggleAutohideState, toggleDockable, toggleMaximizeState, toggleState

Field Detail

DOUBLE_CLICK_CUSTOM

static final int DOUBLE_CLICK_CUSTOM

See Also:: Constant Field Values

DOUBLE_CLICK_NONE

static final int DOUBLE_CLICK_NONE

See Also:: Constant Field Values

DOUBLE_CLICK_TO_FLOAT

static final int DOUBLE_CLICK_TO_FLOAT

See Also:: Constant Field Values

DOUBLE_CLICK_TO_MAXIMIZE

static final int DOUBLE_CLICK_TO_MAXIMIZE

See Also:: Constant Field Values

DOUBLE_CLICK_TO_AUTOHIDE

static final int DOUBLE_CLICK_TO_AUTOHIDE

See Also:: Constant Field Values

FLOATING_CONTAINER_TYPE_DIALOG

static final int FLOATING_CONTAINER_TYPE_DIALOG

See Also:: Constant Field Values

FLOATING_CONTAINER_TYPE_FRAME

static final int FLOATING_CONTAINER_TYPE_FRAME

See Also:: Constant Field Values

FLOATING_CONTAINER_TYPE_WINDOW

static final int FLOATING_CONTAINER_TYPE_WINDOW

See Also:: Constant Field Values

UNKNOWN_FRAME_BEHAVIOR_SHOW_INIT

static final int UNKNOWN_FRAME_BEHAVIOR_SHOW_INIT

See Also:: Constant Field Values

UNKNOWN_FRAME_BEHAVIOR_HIDE

static final int UNKNOWN_FRAME_BEHAVIOR_HIDE

See Also:: Constant Field Values

PROPERTY_INIT_BOUNDS

static final String PROPERTY_INIT_BOUNDS

See Also:: Constant Field Values

PROPERTY_INIT_STATE

static final String PROPERTY_INIT_STATE

See Also:: Constant Field Values

PROPERTY_HIDABLE

static final String PROPERTY_HIDABLE

See Also:: Constant Field Values

PROPERTY_AUTOHIDABLE

static final String PROPERTY_AUTOHIDABLE

See Also:: Constant Field Values

PROPERTY_FLOATABLE

static final String PROPERTY_FLOATABLE

See Also:: Constant Field Values

PROPERTY_RESIZABLE

static final String PROPERTY_RESIZABLE

See Also:: Constant Field Values

PROPERTY_FLOATING_FRAMES_RESIZABLE

static final String PROPERTY_FLOATING_FRAMES_RESIZABLE

See Also:: Constant Field Values

PROPERTY_DOCKED_FRAMES_RESIZABLE

static final String PROPERTY_DOCKED_FRAMES_RESIZABLE

See Also:: Constant Field Values

PROPERTY_REARRANGABLE

static final String PROPERTY_REARRANGABLE

See Also:: Constant Field Values

PROPERTY_ALLOWED_DOCK_SIDES

static final String PROPERTY_ALLOWED_DOCK_SIDES

See Also:: Constant Field Values

PROPERTY_DOUBLE_CLICK_ACTION

static final String PROPERTY_DOUBLE_CLICK_ACTION

See Also:: Constant Field Values

PROPERTY_CONTINUOUS_LAYOUT

static final String PROPERTY_CONTINUOUS_LAYOUT

See Also:: Constant Field Values

PROPERTY_DRAG_ALL_TABS

static final String PROPERTY_DRAG_ALL_TABS

See Also:: Constant Field Values

PROPERTY_HIDE_ALL_TABS

static final String PROPERTY_HIDE_ALL_TABS

See Also:: Constant Field Values

PROPERTY_FLOAT_ALL_TABS

static final String PROPERTY_FLOAT_ALL_TABS

See Also:: Constant Field Values

PROPERTY_MAXIMIZE_ALL_TABS

static final String PROPERTY_MAXIMIZE_ALL_TABS

See Also:: Constant Field Values

PROPERTY_AUTOHIDE_ALL_TABS

static final String PROPERTY_AUTOHIDE_ALL_TABS

See Also:: Constant Field Values

PROPERTY_TAB_DOCK_ALLOWED

static final String PROPERTY_TAB_DOCK_ALLOWED

See Also:: Constant Field Values

PROPERTY_SIDE_DOCK_ALLOWED

static final String PROPERTY_SIDE_DOCK_ALLOWED

See Also:: Constant Field Values

PROPERTY_TAB_REORDER_ALLOWED

static final String PROPERTY_TAB_REORDER_ALLOWED

See Also:: Constant Field Values

PROPERTY_OUTLINE_MODE

static final String PROPERTY_OUTLINE_MODE

See Also:: Constant Field Values

PROPERTY_SHOW_TITLE_ON_OUTLINE

static final String PROPERTY_SHOW_TITLE_ON_OUTLINE

See Also:: Constant Field Values

PROPERTY_WITHIN_FRAMEBOUNDS_ONDRAGGING

static final String PROPERTY_WITHIN_FRAMEBOUNDS_ONDRAGGING

See Also:: Constant Field Values

PROPERTY_WITHIN_SCREENBOUNDS_ONDRAGGING

static final String PROPERTY_WITHIN_SCREENBOUNDS_ONDRAGGING

See Also:: Constant Field Values

PROPERTY_EASY_TAB_DOCK

static final String PROPERTY_EASY_TAB_DOCK

See Also:: Constant Field Values

PROPERTY_AUTO_DOCKING

static final String PROPERTY_AUTO_DOCKING

See Also:: Constant Field Values

PROPERTY_AUTO_DOCKING_AS_DEFAULT

static final String PROPERTY_AUTO_DOCKING_AS_DEFAULT

See Also:: Constant Field Values

PROPERTY_PRESERVE_STATE_ON_DRAGGING

static final String PROPERTY_PRESERVE_STATE_ON_DRAGGING

See Also:: Constant Field Values

PROPERTY_UNDO_LIMIT

static final String PROPERTY_UNDO_LIMIT

See Also:: Constant Field Values

PROPERTY_INIT_SPLIT_PRIORITY

static final String PROPERTY_INIT_SPLIT_PRIORITY

See Also:: Constant Field Values

PROPERTY_CUSTOM_INIT_SPLIT_PRIORITY

static final String PROPERTY_CUSTOM_INIT_SPLIT_PRIORITY

See Also:: Constant Field Values

PROPERTY_INIT_CENTER_SPLIT

static final String PROPERTY_INIT_CENTER_SPLIT

See Also:: Constant Field Values

PROPERTY_INIT_EAST_SPLIT

static final String PROPERTY_INIT_EAST_SPLIT

See Also:: Constant Field Values

PROPERTY_INIT_NORTH_SPLIT

static final String PROPERTY_INIT_NORTH_SPLIT

See Also:: Constant Field Values

PROPERTY_INIT_SOUTH_SPLIT

static final String PROPERTY_INIT_SOUTH_SPLIT

See Also:: Constant Field Values

PROPERTY_INIT_WEST_SPLIT

static final String PROPERTY_INIT_WEST_SPLIT

See Also:: Constant Field Values

PROPERTY_SHOW_GRIPPER

static final String PROPERTY_SHOW_GRIPPER

See Also:: Constant Field Values

PROPERTY_SHOW_DIVIDER_GRIPPER

static final String PROPERTY_SHOW_DIVIDER_GRIPPER

See Also:: Constant Field Values

PROPERTY_DRAG_GRIPPER_ONLY

static final String PROPERTY_DRAG_GRIPPER_ONLY

See Also:: Constant Field Values

PROPERTY_SHOW_TITLEBAR

static final String PROPERTY_SHOW_TITLEBAR

See Also:: Constant Field Values

PROPERTY_GROUP_ALLOWED_ON_SIDE_PANE

static final String PROPERTY_GROUP_ALLOWED_ON_SIDE_PANE

See Also:: Constant Field Values

PROPERTY_SIDEBAR_ROLLOVER

static final String PROPERTY_SIDEBAR_ROLLOVER

See Also:: Constant Field Values

PROPERTY_AUTOHIDE_SHOWING_CONTENT_HIDDEN

static final String PROPERTY_AUTOHIDE_SHOWING_CONTENT_HIDDEN

See Also:: Constant Field Values

PROPERTY_INIT_DELAY

static final String PROPERTY_INIT_DELAY

See Also:: Constant Field Values

PROPERTY_STEP_DELAY

static final String PROPERTY_STEP_DELAY

See Also:: Constant Field Values

PROPERTY_STEPS

static final String PROPERTY_STEPS

See Also:: Constant Field Values

PROPERTY_NESTED_FLOATING_ALLOWED

static final String PROPERTY_NESTED_FLOATING_ALLOWED

See Also:: Constant Field Values

PROPERTY_HIDE_FLOATINGFRAMES_ON_SWITCH_OUT_OF_APPLICATION

static final String PROPERTY_HIDE_FLOATINGFRAMES_ON_SWITCH_OUT_OF_APPLICATION

See Also:: Constant Field Values

PROPERTY_HIDE_FLOATINGFRAMES_WHEN_DEACTIVATE

static final String PROPERTY_HIDE_FLOATINGFRAMES_WHEN_DEACTIVATE

See Also:: Constant Field Values

PROPERTY_CROSS_DRAGGING_ALLOWED

static final String PROPERTY_CROSS_DRAGGING_ALLOWED

See Also:: Constant Field Values

PROPERTY_CROSS_DROPPING_ALLOWED

static final String PROPERTY_CROSS_DROPPING_ALLOWED

See Also:: Constant Field Values

PROPERTY_USE_DECORATED_FLOATING_CONTAINER

static final String PROPERTY_USE_DECORATED_FLOATING_CONTAINER

See Also:: Constant Field Values

PROPERTY_PROPORTIONAL_SPLITS

static final String PROPERTY_PROPORTIONAL_SPLITS

See Also:: Constant Field Values

PROPERTY_HEAVYWEIGHT_COMPONENT_ENABLED

static final String PROPERTY_HEAVYWEIGHT_COMPONENT_ENABLED

See Also:: Constant Field Values

PROPERTY_ACTIVE_WORKSPACE

static final String PROPERTY_ACTIVE_WORKSPACE

See Also:: Constant Field Values

PROPERTY_SHOW_WORKSPACE

static final String PROPERTY_SHOW_WORKSPACE

See Also:: Constant Field Values

PROPERTY_FRAMES_MANAGED

static final String PROPERTY_FRAMES_MANAGED

See Also:: Constant Field Values

PROPERTY_FRAMES_VISIBLE

static final String PROPERTY_FRAMES_VISIBLE

See Also:: Constant Field Values

PROPERTY_FRAMEHANDLE_ZORDER

static final String PROPERTY_FRAMEHANDLE_ZORDER

See Also:: Constant Field Values

PROPERTY_ACTIVE

static final String PROPERTY_ACTIVE

See Also:: Constant Field Values

PROPERTY_DOCKING_MANAGER_GROUP

static final String PROPERTY_DOCKING_MANAGER_GROUP

See Also:: Constant Field Values

PROPERTY_FLOATING_CONTAINER_TYPE

static final String PROPERTY_FLOATING_CONTAINER_TYPE

See Also:: Constant Field Values

PARTIAL_OUTLINE_MODE

static final int PARTIAL_OUTLINE_MODE

The outline mode will paint the outline directly on the layered pane. It will be fast and light-weight. But on the down side, it will not be displayed if you drag the outline outside the main window or over heavyweight components.

See Also:: Constant Field Values

MIX_OUTLINE_MODE

static final int MIX_OUTLINE_MODE

The outline mode will use lightweight outline when inside the main window and use heavyweight outline when outside the main window.

See Also:: Constant Field Values

FULL_OUTLINE_MODE

static final int FULL_OUTLINE_MODE

The outline mode will display heavyweight outline. It is slightly slower comparing to PARTIAL_OUTLINE_MODE but it still displays outside the main window. It also has a little flickering on any JDKs before JDK 6.

See Also:: Constant Field Values

TRANSPARENT_OUTLINE_MODE

static final int TRANSPARENT_OUTLINE_MODE

The outline mode is again a lightweight outline which paints a transparent pane as the outline. It looks better than all other outline modes. It is as fast as PARTIAL_OUTLINE_MODE but suffers the same problem which cannot be displayed outside the main window.

See Also:: Constant Field Values

HW_TRANSPARENT_OUTLINE_MODE

static final int HW_TRANSPARENT_OUTLINE_MODE

The outline mode is a heavyweight which paints a transparent window using the new translucent/shaped windows feature in JDK6u10. In the other word, JDK6u10 and above is required to use this outline option. If you can use this JDK, this option is probably one of the best choices among all the options.

See Also:: Constant Field Values

HW_OUTLINE_MODE

static final int HW_OUTLINE_MODE

The outline mode is a heavyweight which paints an outline using the new translucent/shaped windows feature in JDK6u10. In the other word, JDK6u10 and above is required to use this outline option. If you can use this JDK, this option is probably one of the best choices among all the options.

See Also:: Constant Field Values

SPLIT_CUSTOM

static final int SPLIT_CUSTOM

This is used by setInitSplitPriority method. In this value is used, we will split the whole window in the order of east, west, south and north.

See Also:: Constant Field Values

SPLIT_EAST_WEST_SOUTH_NORTH

static final int SPLIT_EAST_WEST_SOUTH_NORTH

This is used by setInitSplitPriority method. In this value is used, we will split the whole window in the order of east, west, south and north.

See Also:: Constant Field Values

SPLIT_SOUTH_NORTH_EAST_WEST

static final int SPLIT_SOUTH_NORTH_EAST_WEST

This is used by setInitSplitPriority method. In this value is used, we will split the whole window in the order of south, north, east and west.

See Also:: Constant Field Values

SPLIT_EAST_SOUTH_WEST_NORTH

static final int SPLIT_EAST_SOUTH_WEST_NORTH

This is used by setInitSplitPriority method. In this value is used, we will split the whole window in the order of east, south, west and north.

See Also:: Constant Field Values

SPLIT_WEST_SOUTH_EAST_NORTH

static final int SPLIT_WEST_SOUTH_EAST_NORTH

This is used by setInitSplitPriority method. In this value is used, we will split the whole window in the order of west, south, east and north.

See Also:: Constant Field Values

CONTEXT_MENU_CLOSE

static final String CONTEXT_MENU_CLOSE

See Also:: Constant Field Values

CONTEXT_MENU_HIDE_AUTOHIDE

static final String CONTEXT_MENU_HIDE_AUTOHIDE

See Also:: Constant Field Values

CONTEXT_MENU_TOGGLE_FLOATING

static final String CONTEXT_MENU_TOGGLE_FLOATING

See Also:: Constant Field Values

CONTEXT_MENU_TOGGLE_AUTOHIDE

static final String CONTEXT_MENU_TOGGLE_AUTOHIDE

See Also:: Constant Field Values

CONTEXT_MENU_TOGGLE_MAXIMIZE

static final String CONTEXT_MENU_TOGGLE_MAXIMIZE

See Also:: Constant Field Values

CONTEXT_MENU_TOGGLE_DOCKABLE

static final String CONTEXT_MENU_TOGGLE_DOCKABLE

See Also:: Constant Field Values

ACTION_ID_HIDDEN_BY_PARENT

static final int ACTION_ID_HIDDEN_BY_PARENT

See Also:: Constant Field Values

ACTION_NAME_HIDDEN_BY_PARENT

static final String ACTION_NAME_HIDDEN_BY_PARENT

See Also:: Constant Field Values

Method Detail

addFrame

void addFrame(DockableFrame f)

Adds this frame to the docking DockingManager. A frame that has never been added will use the frame's state to best determine its initial state. If the frame is set to hidden it will be added internally but will be hidden. Alternatively if a frame is added activate/maximize it will be added accordingly.

Parameters:: f - frame to be added

getFrame

DockableFrame getFrame(String key)

Gets the frame with the key. All operations with the docking manager should be done with keys.

Parameters:: key - the key of the dockable frame.
Returns:: frame which has the key

removeFrame

void removeFrame(String key)

Removes this frame from DockingManager.

Parameters:: key - key of frame to be removed

removeFrame

void removeFrame(String key,
                 boolean keepPreviousState)

Removes a frame from this DockingManager. This method has an option to keep previous state. In most cases, you don't want to keep the previous states when removing frame. That's what removeFrame(String) does. However if you just remove the frame and will add it back later, you can keep the state so that when the frame is added back, it has the exact same state as before.

This method is Swing thread-safe.

Parameters:: key - key of frame to be removed; keepPreviousState - true to keep previous state when removing the dockable frame. Otherwise everything related to the dockable frame will be cleared just like it was never added before.

removeAllFrames

void removeAllFrames()

Removes all frames from this DockingManager.

showFrame

void showFrame(String key)

Sets the frame visible using the key of that frame and activate the frame after showing.

Parameters:: key - the key of frame to be shown

showFrame

void showFrame(String key,
               boolean activate)

Sets the frame visible using the key of that frame.

Parameters:: key - the key of frame to be shown; activate - whether activate the frame after showing.

hideFrame

void hideFrame(String key)

Hides the frame with the specified key.

Parameters:: key - the key of frame to be hidden

activateFrame

void activateFrame(String key)

Activates the frame with the key.

Parameters:: key - key of frame to be activated

autohideFrame

void autohideFrame(String frameKey,
                   int side,
                   int index)

Autohides the frame with specified frameName at the specified side and index. Index is the index of group.

Parameters:: frameKey - the key of the frame; side - the side to autohide in; index - the index to autohide in

beginDraggingFrame

void beginDraggingFrame(JComponent f,
                        int mouseX,
                        int mouseY,
                        double relativeX,
                        double relativeY,
                        boolean single)

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 DockingManager to prepare. Normally f will be a DockableFrame.

Parameters:: f - a component to be dragged; mouseX - mouse screen location on X direction; mouseY - mouse screen location on Y direction; relativeX - percentage location of mouse to the component on X direction; relativeY - percentage location of mouse to the component on Y direction; single - drag just one frame or all frames in tabs

dragFrame

void dragFrame(JComponent f,
               int newX,
               int newY,
               int mouseModifiers)

The user has moved the frame. Calls to this method will be preceded by calls to beginDraggingFrame(). Normally f will be a DockableFrame.

Parameters:: f - component to be dragged; newX - new mouse location on X direction; newY - new mouse location on Y direction; mouseModifiers - mouse modifiers from MouseEvent when dragging

pauseDragFrame

void pauseDragFrame()

Pause the dragging session of a frame. It simply hide any indication of it's being dragging. dragFrame will automatically resume the dragging session.

endDraggingFrame

void endDraggingFrame(JComponent f)

This method signals the end of the dragging session. Any state maintained by the DockingManager can be removed here. Normally f will be a DockableFrame.

Parameters:: f - the dragged component.

isDragging

boolean isDragging()

Check if there is a dragging going on.

Returns:: true if dragging.

cancelDragging

void cancelDragging()

Cancel the dragging.

beginResizingFrame

void beginResizingFrame(JComponent f,
                        int direction)

This methods 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 DockingManager to prepare. Normally f will be a DockableFrame.

Parameters:: f - the frame to be resized; direction - the direction that the frame will resize to

resizingFrame

void resizingFrame(JComponent f,
                   int newX,
                   int newY,
                   int newWidth,
                   int newHeight)

The user has resized the component. Calls to this method will be preceded by calls to beginResizingFrame(). Normally f will be a DockableFrame.

Parameters:: f - the frame to be resized; newX - the X of the start point after resizing; newY - the Y of the start point after resizing; newWidth - the width after resizing; newHeight - the height after resizing

endResizingFrame

void endResizingFrame(JComponent f)

This method signals the end of the resize session. Any state maintained by the DockingManager can be removed here. Normally f will be a DockableFrame.

Parameters:: f - the frame to be resized

toggleDockable

void toggleDockable(String key)

Toggle dockable attribute sof the frame with the specified key.

Parameters:: key - frame key

toggleAutohideState

void toggleAutohideState(String key)

Toggle the frame between auto-hide mode and docked mode.

Parameters:: key - key of the frame to be toggled.

getDockedFrameContainer

DockedFrameContainer getDockedFrameContainer()

Returns the container that holds the docked window within the main frame. It doesn't include side bars, doesn't include toolbar or menu bar.

Returns:: main container

getMainContainer

JComponent getMainContainer()

Gets the main container. This is the primary container that holds all components that the docking manager works with.

Returns:: main container

getContentContainer

Container getContentContainer()

Gets the content container. The content container is the container passed as the second parameter of

DefaultDockingManager.DefaultDockingManager(javax.swing.RootPaneContainer,
 java.awt.Container)

Returns:: the content container.

getWorkspace

Workspace getWorkspace()

Gets workspace. Workspace is the area in the middle of the main frame that can used as the main workspace for documents for example.

Returns:: workspace

activateWorkspace

void activateWorkspace()

setShowWorkspace

void setShowWorkspace(boolean show)

Shows or hides workspace area.

Parameters:: show - true to show workspace.

isShowWorkspace

boolean isShowWorkspace()

isWorkspaceActive

boolean isWorkspaceActive()

Returns a flag to indicate if the workspace is active.

Returns:: if the workspace is active.

getActiveFrameKey

String getActiveFrameKey()

Gets currently selected frame.

Returns:: currently selected frame

isDragAllTabs

boolean isDragAllTabs()

Checks if dragging the title bar will drag all the dockable frames in that tabbed pane. By default dragging the title bar of a dockable frame will drag all dockable frames in the tabbed pane. Dragging the tab will only drag one dockable frame. If this flag is false, dragging title bar will just drag one dockable frame.

Returns:: true if all dockable frames in the tabbed pane will be dragged when dragging the title bar.

setDragAllTabs

void setDragAllTabs(boolean dragAllTabs)

Sets if dragging title bar will drag all dockable frames in the tabbed pane.

Parameters:: dragAllTabs - the flag
See Also:: isDragAllTabs()

autohideAll

void autohideAll()

Auto-hide all frames.

isAutohideAllTabs

boolean isAutohideAllTabs()

When user press autohide button, will it affect all tabs or just selected tab.

Returns:: true if it will autohide all tabs.

setAutohideAllTabs

void setAutohideAllTabs(boolean autohideAllTabs)

When user presses autohide button, will it affect all tabs or just selected tab.

Parameters:: autohideAllTabs - true or false.

isHideAllTabs

boolean isHideAllTabs()

When user presses close button, will it affect all tabs or just selected tab.

Returns:: true if it will close all tabs.

setHideAllTabs

void setHideAllTabs(boolean closeAllTabs)

Sets the option of closeAllTabs. If it's true, when user presses close it will close all tabs.

Parameters:: closeAllTabs - true or false.

isFloatAllTabs

boolean isFloatAllTabs()

When user presses toggle floating button, will it affect all tabs or just selected tab.

Returns:: true if it will close all tabs.

setFloatAllTabs

void setFloatAllTabs(boolean floatAllTabs)

Sets the option of floatAllTabs. If it's true, when user presses toggle floating button it will float all tabs.

Parameters:: floatAllTabs - true or false.

isMaximizeAllTabs

boolean isMaximizeAllTabs()

When user maximizes a dockable frame, will it maximize all tabs or just selected tab.

Returns:: true if it will close all tabs.

setMaximizeAllTabs

void setMaximizeAllTabs(boolean maximizeAllTabs)

Sets the option of maximizeAllTabs.

Parameters:: maximizeAllTabs - true or false.

isFloatable

boolean isFloatable()

Return true if floating is allowed for dockable frames.

Returns:: true if floating is allowed

setFloatable

void setFloatable(boolean floatable)

Enable or disable floating of dockable frames

Parameters:: floatable - the flag

isAutohidable

boolean isAutohidable()

Return true if autohiding is allowed for dockable frames.

Returns:: true if autohiding is allowed

setAutohidable

void setAutohidable(boolean autohidable)

Enable or disable autohide feature of dockable frames

Parameters:: autohidable - the flag

isHidable

boolean isHidable()

Return true if dockable frame is allowed to be hidden.

Returns:: true if floating is allowed

setHidable

void setHidable(boolean hidable)

Enable or disable hiding of dockable frames

Parameters:: hidable - the flag

isRearrangable

boolean isRearrangable()

If the dockable frames can be rearranged.

Returns:: Return true if the dockable frames can be rearranged by user.

setRearrangable

void setRearrangable(boolean rearrangable)

Enable or disable the rearrangement of dockable frames.

Parameters:: rearrangable - true if the dockable frames can be rearranged by user.

isResizable

@Deprecated
boolean isResizable()

Deprecated. replaced by isFloatingFramesResizable() and isDockedFramesResizable()

If the dockable frame can be resized.

Returns:: Return true if the dockable frames can be resized by user.

setResizable

@Deprecated
void setResizable(boolean resizable)

Deprecated. replaced by setFloatingFramesResizable(boolean) and setDockedFramesResizable(boolean)

Enable or disable the resize of dockable frames.

Parameters:: resizable - true if the dockable frames can be resized by user.

isFloatingFramesResizable

boolean isFloatingFramesResizable()

If the floating dockable frame can be resized.

Returns:: Return true if the floating dockable frames can be resized by user.
Since:: 3.5.0

setFloatingFramesResizable

void setFloatingFramesResizable(boolean resizable)

Enable or disable the resize of floating dockable frames.

Parameters:: resizable - true if the floating dockable frames can be resized by user.
Since:: 3.5.0

isDockedFramesResizable

boolean isDockedFramesResizable()

If the dockable frame can be resized.

Returns:: Return true if the docked dockable frames can be resized by user.
Since:: 3.5.0

setDockedFramesResizable

void setDockedFramesResizable(boolean resizable)

Enable or disable the resize of dockable frames.

Parameters:: resizable - true if the docked dockable frames can be resized by user.
Since:: 3.5.0

isGroupAllowedOnSidePane

boolean isGroupAllowedOnSidePane()

Returns true if group is allowed in side bar.

Returns:: true or false

setGroupAllowedOnSidePane

void setGroupAllowedOnSidePane(boolean groupAllowedOnSidePane)

If true, group is allowed in side pane. If false, when you autohide several frames inside a tabbed pane, each frame will become one separate entry on the side pane.

Parameters:: groupAllowedOnSidePane - true to allow tab group on the side pane.

isContinuousLayout

boolean isContinuousLayout()

Determines whether the JideSplitPane is set to use a continuous layout.

Returns:: true or false.

setContinuousLayout

void setContinuousLayout(boolean b)

Turns continuous layout on or off.

Parameters:: b - true to turn on continuous layout.

updateComponentTreeUI

void updateComponentTreeUI()

Call this method with LookAndFeel changes.

getAllFrames

Collection<String> getAllFrames()

Gets a collection of all dockable frames's key. You can call getDockableFrame(key) to Gets the actual dockable frame.

It is the same usage as getAllFrameNames(). However the order of frame keys from this method is random. getAllFrameNames() returns the list in the order of when frame is added.

Returns:: the collection of all dockable frames' key.

getAllFrameNames

List<String> getAllFrameNames()

Gets a list of the keys of all frames. It's clone of the list maintained by the DockingManager.

Returns:: the list of all frames The order in the list is the order of when frame is added.

getAllVisibleFrameKeys

String[] getAllVisibleFrameKeys()

Gets an array of the keys of all visible frames. Please note, different from getAllFrameNames(), the order of keys are according to the layout on the screen. The order are docked frames first, the autohide frames, then floating frames. Then among frames of the same mode, it's from left to right and from top to bottom.

Returns:: an array of visible frames' key.

getFirstFrameKey

String getFirstFrameKey()

Gets the first visible dockable frame. We used getAllVisibleFrameKeys() to figure out which is the first one. It is the first one in the array that is returned from getAllVisibleFrameKeys method.

Returns:: the first visible dockable frame.

getLastFrameKey

String getLastFrameKey()

Gets the last visible dockable frame. We used getAllVisibleFrameKeys() to figure out which is the last one. It is the last one in the array that is returned from getAllVisibleFrameKeys method.

Returns:: the last visible dockable frame.

getNextFrame

String getNextFrame(String frame)

Gets the next visible dockable frame. We used getAllVisibleFrameKeys() to figure out which is the next one. It is the next one in the array that is returned from getAllVisibleFrameKeys method. If the frame is the last one, the first frame will be returned. Or if the frame is hidden, this method will return the first frame too. So unless you have no dockable frame at all, this method will never return null.

Parameters:: frame - the current frame.
Returns:: the next visible dockable frame.

getPreviousFrame

String getPreviousFrame(String frame)

Gets the previous visible dockable frame. We used getAllVisibleFrameKeys() to figure out which is the previous one. It is the next one in the array that is returned from getAllVisibleFrameKeys method. If the frame is the first one, the last frame will be returned. Or if the frame is hidden, this method will return the last frame too. So unless you have no dockable frame at all, this method will never return null.

Parameters:: frame - the current frame.
Returns:: the previous visible dockable frame.

getPopupMenuCustomizer

PopupMenuCustomizer getPopupMenuCustomizer()

Gets the popup menu customizer.

Returns:: popup menu customizer

setPopupMenuCustomizer

void setPopupMenuCustomizer(PopupMenuCustomizer customizer)

Sets the popup customizer.

Parameters:: customizer - the popup menu customizer

setTabbedPaneCustomizer

void setTabbedPaneCustomizer(DockingManager.TabbedPaneCustomizer customizer)

Set a customizer to customize the tabbed pane where dockable frames are.

Here is a code example.

 dockingManager.setTabbedPaneCustomizer(new DockingManager.TabbedPaneCustomizer() {
     public void customize(JideTabbedPane tabbedPane) {
         tabbedPane.setTabPlacement(JideTabbedPane.TOP);
         tabbedPane.setHideOneTab(false);
     }
 });

Parameters:: customizer - new tabbed pane customizer

showContextMenu

void showContextMenu(Component source,
                     Point point,
                     DockableFrame dockableFrame,
                     boolean onTab)

Show context menu of dockable frames.

Parameters:: source - source of the event; point - mouse point of the event; dockableFrame - dockable frame; onTab - true if mouse is clicked on tab; or else false.

floatFrame

void floatFrame(String frameKey,
                Rectangle bounds,
                boolean isSingle)

Float the frame with specified frameKey .

Parameters:: frameKey - frame to be floated; bounds - the bounds of float frame; isSingle - true if just make current frame floated, or all frames in the tabs will be floated

dockFrame

void dockFrame(String frameKey,
               int side,
               int index)

Docks the frame with specified frameKey at the specified side and index. Index is the index in the split pane.

Parameters:: frameKey - the key of the dockable frame; side - the side of the dockable frame; index - the index of the dockable frame

toggleState

void toggleState(String key,
                 boolean single)

Toggle the frame's state. If it's docked, change to floating mode; if floating, change to docked mode.

Parameters:: key - the key of the frame to change mode; single - change mode for all frames in the same tabbed pane or just the frame itself.

getAutoHideContainer

AutoHideContainer getAutoHideContainer(int side)

Gets the autohide container by side. Valid side is defined in DockContext such as DockContext.DOCK_SIDE_NORTH, DockContext.DOCK_SIDE_SOUTH, DockContext.DOCK_SIDE_EAST and DockContext.DOCK_SIDE_WEST.

Parameters:: side - the side of the container
Returns:: autohide container

getInitBounds

Rectangle getInitBounds()

Gets initial bounds of the main frame.

Returns:: initial bounds

setInitBounds

void setInitBounds(Rectangle initBounds)

Sets the initial bounds of the main frame.

Parameters:: initBounds - the initialization bounds

getInitState

int getInitState()

Gets initial state of the main frame. State could be the states that are specified in Frame.getExtendedState().

Returns:: the initial state

setInitState

void setInitState(int initState)

Sets the initial state of the main frame. State can be the states that are specified in Frame.getExtendedState().

Parameters:: initState - the initial state

getSensitiveAreaSize

int getSensitiveAreaSize()

Gets the size of the area where the dock action will happen.

Returns:: the sensitive size

setSensitiveAreaSize

void setSensitiveAreaSize(int sensitiveSize)

Sets the size of the area where the dock action will happen.

Parameters:: sensitiveSize - the sensitive size

getOutsideSensitiveAreaSize

int getOutsideSensitiveAreaSize()

Gets the size of the area outside the DockableHolder where the dock action will happen.

Returns:: the sensitive area size

setOutsideSensitiveAreaSize

void setOutsideSensitiveAreaSize(int sensitiveSize)

Sets the size of the area outside the DockableHolder where the dock action will happen.

Parameters:: sensitiveSize - the sensitive size

getOutlineMode

int getOutlineMode()

Gets contour outline mode. It is HW_OUTLINE_MODE by default. However we will return an appropriate outline mode based on the return values from SecurityUtils.isTranslucentWindowFeatureDisabled() and isHeavyweightComponentEnabled().

If the isTranslucentWindowFeatureDisabled is true and isHeavyweightComponentEnabled is true, we will return FULL_OUTLINE_MODE because that's the only outline satisfied both conditions. If only isTranslucentWindowFeatureDisabled is true, we will use TRANSPARENT_OUTLINE_MODE to replace HW_TRANSPARENT_OUTLINE_MODE and FULL_OUTLINE_MODE to replace HW_OUTLINE_MODE and keep other modes. If isTranslucentWindowFeatureDisabled is false but isHeavyweightComponentEnabled is true, we will use HW_OUTLINE_MODE to replace PARTIAL_OUTLINE_MODE, MIX_OUTLINE_MODE or FULL_OUTLINE_MODE and HW_TRANSPARENT_OUTLINE_MODE to replace TRANSPARENT_OUTLINE_MODE. Otherwise, we will use whatever outline mode user sets.

Returns:: the outline mode.

setOutlineMode

void setOutlineMode(int outlineMode)

Sets contour outline mode

PARTIAL_OUTLINE_MODE: Always uses light-weighted outline. As a result, it will display partial outline if outside main JFrame.
MIX_OUTLINE_MODE: Use light-weighted outline when inside the main JFrame and heavy-weighted outline when outside JFrame. It will be flickering free when inside the JFrame. But when it's on the border of JFrame, it will cause some flickering.
FULL_OUTLINE_MODE: Always use heavy-weight outline. As result, it will cause some flickering because of that.
TRANSPARENT_OUTLINE_MODE: Always use light-weight outline using a transparent background.
HW_TRANSPARENT_OUTLINE_MODE: Always use heavy-weight outline using a transparent background.
HW_OUTLINE_MODE: Always use heavy-weight outline using an outline.

Please note, the last two outline mode is only available on JDK6u10 and later.

Parameters:: outlineMode - the new outline mode

getEscapeKeyTargetComponent

Component getEscapeKeyTargetComponent()

Gets the escape key target component. If setEscapeKeyTargetComponent is never called, workspace will be the escape key target component. When the ESC key is pressed in a dockable frame, this component will get focus.

Returns:: the escape key target component.

setEscapeKeyTargetComponent

void setEscapeKeyTargetComponent(Component escapeKeyTargetComponent)

Sets the escape key target component.

Parameters:: escapeKeyTargetComponent - the component

getInitSplitPriority

int getInitSplitPriority()

Gets the initial split priority. Possible values are SPLIT_EAST_WEST_SOUTH_NORTH, SPLIT_SOUTH_NORTH_EAST_WEST. The direction in front has a high priority than those after it. For example, if you initially has two frames, the initial side of one is south and the other one is east. If you use SPLIT_EAST_WEST_SOUTH_NORTH, the east one will cover the whole east side and the south one will cover whatever left. However if you use SPLIT_SOUTH_NORTH_EAST_WEST, the south one will cover the whole south side and the east one will cover whatever left.

Returns:: split priority.

setInitSplitPriority

void setInitSplitPriority(int initSplitPriority)

Sets the initial split priority. Valid values are SPLIT_EAST_WEST_SOUTH_NORTH, SPLIT_SOUTH_NORTH_EAST_WEST. The direction in front has a high priority than those after it. For example, if you initially has two frames, the initial side of one is south and the other one is east. If you use SPLIT_EAST_WEST_SOUTH_NORTH, the east one will cover the whole east side and the south one will cover whatever left. However if you use SPLIT_SOUTH_NORTH_EAST_WEST, the south one will cover the whole south side and the east one will cover whatever left.

Parameters:: initSplitPriority - split priority.

setCustomInitSplitPriority

void setCustomInitSplitPriority(int[] customInitSplitPriority)

Sets custom init split priority. This is only used when setInitPriority is set to SPLIT_CUSTOM. The customInitSplitPriority is an int array of four integers. The int is from 1 to 4. 1 means EAST, 2 means SOUTH, 3 means WEST and 4 means NORTH. Each int means it splits on that side first. For example, setInitSplitPriority to SPLIT_EAST_WEST_SOUTH_NORTH is the same as setCustomInitSplitPriority to {1, 3, 2, 4}. The reason we keep both ways so that for normal users, setInitSplitPriority is good enough. But if you need a very special split priority, you can use setCustomInitSplitPriority to fully customize it.

Parameters:: customInitSplitPriority - new init split priority

getCustomInitSplitPriority

int[] getCustomInitSplitPriority()

Gets custom init split priority. This is only used when setInitPriority is set to SPLIT_CUSTOM.

Returns:: the custom init split priority.

getInitDelay

int getInitDelay()

Gets the initial delay.

Returns:: the initial delay

getInitCenterSplit

int getInitCenterSplit()

Gets the initial center split. During initial layout, assuming there are several dockable frames' initSide are DOCK_SIDE_CENTER. Among them, the ones with the same index will be put into the same tabbed pane. If they have different index, they will be put into a multiple split pane. This flag will control the orientation of the split pane.

Returns:: the orientation of initial split pane in the center.

setInitCenterSplit

void setInitCenterSplit(int initCenterSplit)

Sets the initial center split. Valid values are JideSplitPane.HORIZONTAL_SPLIT and JideSplitPane.VERTICAL_SPLIT.

Parameters:: initCenterSplit - the initial center split
See Also:: getInitCenterSplit()

getInitEastSplit

int getInitEastSplit()

Gets the initial east split. During initial layout, assuming there are several dockable frames' initSide are DOCK_SIDE_EAST. Among them, the ones with the same index will be put into the same tabbed pane. If they have different index, they will be put into a multiple split pane. This flag will control the orientation of the split pane.

Returns:: the orientation of initial split pane in the east.

setInitEastSplit

void setInitEastSplit(int initEastSplit)

Sets the initial east split. Valid values are JideSplitPane.HORIZONTAL_SPLIT and JideSplitPane.VERTICAL_SPLIT. It is JideSplitPane.VERTICAL_SPLIT by default.

Parameters:: initEastSplit - the initial east split
See Also:: getInitEastSplit()

getInitWestSplit

int getInitWestSplit()

Gets the initial west split. During initial layout, assuming there are several dockable frames' initSide are DOCK_SIDE_WEST. Among them, the ones with the same index will be put into the same tabbed pane. If they have different index, they will be put into a multiple split pane. This flag will control the orientation of the split pane.

Returns:: the orientation of initial split pane in the west.

setInitWestSplit

void setInitWestSplit(int initWestSplit)

Sets the initial west split. Valid values are JideSplitPane.HORIZONTAL_SPLIT and JideSplitPane.VERTICAL_SPLIT. It is JideSplitPane.VERTICAL_SPLIT by default.

Parameters:: initWestSplit - the initial west split
See Also:: getInitWestSplit()

getInitNorthSplit

int getInitNorthSplit()

Gets the initial north split. During initial layout, assuming there are several dockable frames' initSide are DOCK_SIDE_NORTH. Among them, the ones with the same index will be put into the same tabbed pane. If they have different index, they will be put into a multiple split pane. This flag will control the orientation of the split pane.

Returns:: the orientation of initial split pane in the north.

setInitNorthSplit

void setInitNorthSplit(int initNorthSplit)

Sets the initial north split. Valid values are JideSplitPane.HORIZONTAL_SPLIT and JideSplitPane.VERTICAL_SPLIT. It is JideSplitPane.HORIZONTAL_SPLIT by default.

Parameters:: initNorthSplit - the initial north split
See Also:: getInitNorthSplit()

getInitSouthSplit

int getInitSouthSplit()

Gets the initial south split. During initial layout, assuming there are several dockable frames' initSide are DOCK_SIDE_SOUTH. Among them, the ones with the same index will be put into the same tabbed pane. If they have different index, they will be put into a multple split pane. This flag will control the orientation of the split pane.

Returns:: the orientation of initial split pane in the south.

setInitSouthSplit

void setInitSouthSplit(int initSouthSplit)

Sets the initial south split. Valid values are JideSplitPane.HORIZONTAL_SPLIT and JideSplitPane.VERTICAL_SPLIT. It is JideSplitPane.HORIZONTAL_SPLIT by default.

Parameters:: initSouthSplit - the init south split setting
See Also:: getInitSouthSplit()

setInitDelay

void setInitDelay(int initDelay)

Sets the initial delay.

Parameters:: initDelay - the initial delay

getStepDelay

int getStepDelay()

Gets the delay in each step during animation.

Returns:: the delay in each step

setStepDelay

void setStepDelay(int stepDelay)

Sets the delay in each step during animation, in ms. Default is 5ms.

Parameters:: stepDelay - the delay in each step

getSteps

int getSteps()

Gets how many steps in the animation.

Returns:: number of the steps

setSteps

void setSteps(int steps)

Sets how many steps in the animation, default is 5 steps.

Parameters:: steps - number of the steps

dispose

void dispose()

Removes all used resources.

isEasyTabDock

boolean isEasyTabDock()

setEasyTabDock

void setEasyTabDock(boolean easyTabDock)

Sets the attribute if dragging and pointing to dockable frame will make it tab dock

Parameters:: easyTabDock - the flag

isTabDockAllowed

boolean isTabDockAllowed()

setTabDockAllowed

void setTabDockAllowed(boolean tabDockAllowed)

Sets the attribute if tab docking is allowed. If the flag is false, user will not be able to tab dock to dockable frame together. However this flag wouldn't affect initial state. If you don't want any tab dock during initialization, you need to make sure dockable frames on the same init side to have different init index.

Parameters:: tabDockAllowed - the flag

isSideDockAllowed

boolean isSideDockAllowed()

setSideDockAllowed

void setSideDockAllowed(boolean sideDockAllowed)

Sets the attribute if side docking is allowed. If the flag is false, user will not be able to dock a dockable frame to the side of another dockable frame or workspace to create a new tabbed pane.

Parameters:: sideDockAllowed - the flag

isTabReorderAllowed

boolean isTabReorderAllowed()

setTabReorderAllowed

void setTabReorderAllowed(boolean allowed)

Sets the attribute if tab reordering is allowed. If the flag is false, user will not be able to drag the tab and reorder the tabs. By default this is true.

Parameters:: allowed - the flag

isNestedFloatingAllowed

boolean isNestedFloatingAllowed()

Checks if nest floating frames are allowed. If this flag is false, when you drag something over a floating frame, nothing will happen just like the floating frame doesn't exist. If this flag is true, you can drag a frame over a floating frame and the outline will change shape to indicate where it will be dropped just like other frames in the main JFrame.

Returns:: true if it's allowed. Otherwise, false

setNestedFloatingAllowed

void setNestedFloatingAllowed(boolean nestedFloatingAllowed)

Sets if allows nested floating frames.

Parameters:: nestedFloatingAllowed - the flag
See Also:: isNestedFloatingAllowed()

isShowGripper

boolean isShowGripper()

setShowGripper

void setShowGripper(boolean showGripper)

Sets the visibility of gripper.

Parameters:: showGripper - true to show gripper.

isShowDividerGripper

boolean isShowDividerGripper()

setShowDividerGripper

void setShowDividerGripper(boolean showDividerGripper)

Sets the visibility of gripper for JideSplitPane.

Parameters:: showDividerGripper - true to show gripper for JideSplitPane.

isDragGripperOnly

boolean isDragGripperOnly()

When the gripper is visible, if the drag only happens when dragging on the gripper.

Returns:: true if grip is visible

setDragGripperOnly

void setDragGripperOnly(boolean dragGripperOnly)

Sets the value to allow user to drag on the gripper as well as on the title bar. This flag only has effect when gripper is visible. If it's true, drag only happens when dragging on gripper. Otherwise, dragging on title bar will start the drag too.

Parameters:: dragGripperOnly - true to show grip

isShowTitleBar

boolean isShowTitleBar()

Checks if the title bar of dockable frame is visible.

Returns:: if the title bar is visible.

setShowTitleBar

void setShowTitleBar(boolean showTitleBar)

Sets the visibility of gripper.

Parameters:: showTitleBar - true to show grip

getContextOf

DockContext getContextOf(String frameKey)

Gets the dockcontext of the frame.

Parameters:: frameKey - the key of the DockableFrame
Returns:: the DockContext of the dockable frame with the specified key.

createAutoHideContainer

AutoHideContainer createAutoHideContainer(int side)

Creates the container for the autohidden dockable frames. It is actually SidePane which we subclass it and called it AutoHideContainer because it contains AutoHidden DockableFrames.

Parameters:: side - the side to create auto hide container
Returns:: container for the tabbed panes.

createContainerContainer

ContainerContainer createContainerContainer()

Creates the container for the tabbed panes. It is an actually JideSplitPane which we subclass it and called it ContainerContainer because it contains FrameContainer.

Returns:: container for the tabbed panes.

createFrameContainer

FrameContainer createFrameContainer()

Creates the container for the tabs. It is an actually JideTabbedPane which we subclass it and called it FrameContainer.

Returns:: container for the tabs.

createFloatingContainer

FloatingContainer createFloatingContainer(Window owner)

Creates a FloatingContainer. By default it will create a different implementation of FloatingContainer depends on system property "docking.floatingContainerType". If "docking.floatingContainerType" equals "dialog", it will create a FloatContainerD

Parameters:: owner - the owner of the floating container
Returns:: a FloatingContainer.

createWorkspace

Workspace createWorkspace()

Creates the workspace.

Returns:: the workspace.

customizeFrameContainer

FrameContainer customizeFrameContainer(FrameContainer frameContainer)

Customize the FrameContainer created by createFrameContainer().

Parameters:: frameContainer - the frame container to be customized
Returns:: the frameContainer.

removeFromHiddenFrames

void removeFromHiddenFrames(String key)

getOrderedFrames

List<DockingManager.FrameHandle> getOrderedFrames()

moveFrame

void moveFrame(String frameKey,
               String destFrameKey)

Move the frame to the destFrame and put them into one tabbed pane. If the frameKey or destFrameKey doesn't exist, IllegalArgumentException will be thrown. if the destFrameKey is in STATE_AUTOHIDE or STATE_AUTOHIDE_SHOWING state, this method will do nothing but return immediately.

Parameters:: frameKey - the key frameKey the dockable frame to be moved; destFrameKey - the frameKey of the destination dockable frame

moveFrame

void moveFrame(String frameKey,
               String destFrameKey,
               int side)

Move the frame to the destFrame's side. If the frameKey or destFrameKey doesn't exist, IllegalArgumentException will be thrown. if the destFrameKey is in STATE_AUTOHIDE or STATE_AUTOHIDE_SHOWING state, this method will do nothing but return immediately.

Parameters:: frameKey - the key of the dockable frame to be moved; destFrameKey - the key of the destination dockable frame; side - dock side. Valid values are DockContext.DOCK_SIDE_EAST, DockContext.DOCK_SIDE_WEST,DockContext.DOCK_SIDE_NORTH, DockContext.DOCK_SIDE_SOUTH or DockContext.DOCK_SIDE_CENTER. If side is DockContext.DOCK_SIDE_CENTER, it will have the same result as moveFrame(String, String).

isSidebarRollover

boolean isSidebarRollover()

Checks if the rollover effect is on for tabs on side bar.

Returns:: true if rollover effect is on.

setSidebarRollover

void setSidebarRollover(boolean sidebarRollover)

Sets to true if you want the tabs on side bar has rollover effect.

Parameters:: sidebarRollover - the flag

setFrameAvailable

void setFrameAvailable(String key)

Makes the frame available.

Usually all dockable frames are added to DockingManager when application is started. However some frames may only be available under certain context. For example, palette window should only be available when editing a GUI form. In this case, you can set the palette to available when GUI form is active. Or else, set it to unavailble.

Set the frame available will restore the last state of the frame when it is set to unavailable.

Parameters:: key - key of dockable frame

setFrameUnavailable

void setFrameUnavailable(String key)

Makes the frame unavailable.

Set the frame unavailable will hide the frame no matter what state it is. However the state will be remembered so that when later it was set to available, that state will be restored. When frame is unavailable, operations to that frame such as showFrame, hideFrame, etc, will have no effect.

Please note, the available/unavailable flag will not be saved into the layout file. As a matter of fact, all frames will become available so that their previous position can be saved precisely. So whenever you call saveLayoutData methods, you need to make those frames unavailable again.

Parameters:: key - key of dockable frame

setFloatingFramesVisible

void setFloatingFramesVisible(boolean show)

Sets all floating frame visible or invisible.

Parameters:: show - the flag

setUndoLimit

void setUndoLimit(int limit)

Set the maximum number of edits this UndoManager will hold. If edits need to be discarded to shrink the limit, they will be told to die in the reverse of the order that they were added.

Parameters:: limit - the maximum number of edits to hold

undo

void undo()

Undo the last operation done to docking framework.

redo

void redo()

Redo the last undone operation.

discardAllUndoEdits

void discardAllUndoEdits()

Discard all undo edits

getUndoManager

UndoManager getUndoManager()

Gets the underlying UndoManager.

Returns:: the underlying UndoManager.

addUndo

void addUndo(String name)

Adds a new undo edit.

Parameters:: name - the name of the new undo edit

addUndoableEditListener

void addUndoableEditListener(UndoableEditListener listener)

Adds an UndoableEditListener. UndoableEditEvent will be fired when a undo edit is added.

Parameters:: listener - the listener

removeUndoableEditListener

void removeUndoableEditListener(UndoableEditListener listener)

Removes UndoableEditListener added before.

Parameters:: listener - the listener

getMaximizedFrameKey

String getMaximizedFrameKey()

Gets the maximized frame if any.

Returns:: the maximized frame. If no frame is maximized, return null.

restoreFrame

void restoreFrame()

Restores the frame from maximized state.

maximizeFrame

void maximizeFrame(String key)

Maximized the frame.

Parameters:: key - the key of the DockableFrame

toggleMaximizeState

void toggleMaximizeState(String key)

Toggle between maximized and restored state.

Parameters:: key - the key of the DockableFrame

getDoubleClickAction

int getDoubleClickAction()

Gets the action when user double clicks on the title bar of a dockable frame. It could be either DOUBLE_CLICK_TO_FLOAT (default) or DOUBLE_CLICK_TO_MAXIMIZE or DOUBLE_CLICK_NONE if you don't want to have any action associated with double click.

Returns:: the action of double click on title bar.

setDoubleClickAction

void setDoubleClickAction(int doubleClickAction)

Sets the action when user double clicks on the title bar of a dockable frame.

Parameters:: doubleClickAction - Either DOUBLE_CLICK_TO_FLOAT or DOUBLE_CLICK_TO_MAXIMIZE or DOUBLE_CLICK_NONE.

isAutoDocking

boolean isAutoDocking()

Auto docking means when a dockable frame is dragged, it will automatically attempt to dock to other docked frames. By default, this flag is true. If this flag is false, it will not try to dock thus every time you drag a docked dockable frame, it will became floating state. The only way to dock back is to click on toggle floating button.

Returns:: if auto docking is enabled.

setAutoDocking

void setAutoDocking(boolean autoDocking)

Parameters:: autoDocking - if auto docking is enabled. Default is true.

isAutoDockingAsDefault

boolean isAutoDockingAsDefault()

Auto docking means when a dockable frame is dragged, it will automatically attempt to dock to other docked frames. However if user holds control key while dragging, it will not attempt to dock. By default, this flag is true. If it is set to false, it will be the opposite - it will attempt to dock only when holding the control key.

Returns:: if auto docking is the default.

setAutoDockingAsDefault

void setAutoDockingAsDefault(boolean autoDockingAsDefault)

Parameters:: autoDockingAsDefault - the flag

isPreserveStateOnDragging

boolean isPreserveStateOnDragging()

Preserving state on dragging means dragging will not cause the frame's state to change. By default, this is flag is false. So when you drag a docked frame to make it floating. Or you can drag a floating frame to make it docked. If this is flag is true, you can't do either of them. The only way to toggle between states is to via the title bar buttons on the dockable frame.

Returns:: the preserveStateOnDragging flag.

setPreserveStateOnDragging

void setPreserveStateOnDragging(boolean preserveStateOnDragging)

Sets preserveStateOnDragging flag.

Parameters:: preserveStateOnDragging - the flag
See Also:: isPreserveStateOnDragging()

notifyFrame

void notifyFrame(String key)

Notifies the frame using the key of that frame.

Parameters:: key - the key of frame to be notified

denotifyFrame

void denotifyFrame(String key)

Denotifies the frame using the key of that frame.

Parameters:: key - the key of frame to be denotified

isHideFloatingFramesWhenDeactivate

boolean isHideFloatingFramesWhenDeactivate()

Checks if the floating frames should be hidden automatically when the main frame is deactivated.

Returns:: true if the floating frames are hidden automatically when the main frame is deactivated.

setHideFloatingFramesWhenDeactivate

void setHideFloatingFramesWhenDeactivate(boolean hideFloatingFramesWhenDeactivate)

Sets if the floating frames should be hidden automatically when the main frame is deactivated.

Parameters:: hideFloatingFramesWhenDeactivate -

removeContext

void removeContext(String key)

Removes the DockConext that is saved in the cache.

Parameters:: key - the DockableFrame key.

removeExtraContexts

void removeExtraContexts()

Removes extra DockContexts that is saved in the cache but the corresponding dockable frames are not in DockingManager anymore.

getAllContexts

Map<String,DockContext> getAllContexts()

Gets the all DockContexts in cache.

Returns:: a Map of all DockContexts.

getAllowedDockSides

int getAllowedDockSides()

Gets the allowed dock sides. The side values are defined in DockContext. The actual value returned is a OR of all possible dock sides. The possible dock sides are DockContext.DOCK_SIDE_NORTH, DockContext.DOCK_SIDE_SOUTH, DockContext.DOCK_SIDE_WEST, and DockContext.DOCK_SIDE_EAST. Or you can use combine values such as DockContext.DOCK_SIDE_HORIZONTAL, DockContext.DOCK_SIDE_VERTICAL or DockContext.DOCK_SIDE_ALL. Please note, DockContext.DOCK_SIDE_CENTER is not a valid value# By default, dragging a dockable frame to workspace is not allowed anyway# If you want to control it, you should use Workspace.setAcceptDockableFrame(boolean).

This setting will only affect user dragging. For example, if you set the allowed dock sides to not allow north side, user won't be able to drag a dockable frame and put it to the north side of the main window or the north side of workspace area. However if a dockable frame's initial side is set to north, it will be put to north. So you as developer need to consciously avoid initial dock sides which you don't allow using this setting.

Returns:: allowed dock sides.

setAllowedDockSides

void setAllowedDockSides(int allowedDockSides)

Sets allowed dock sides.

Parameters:: allowedDockSides -
See Also:: getAllowedDockSides()

shouldVetoRemovingAllFrames

boolean shouldVetoRemovingAllFrames()

Checks if the removeAllFrames() should be vetoed. This method works with shouldVetoHiding() method in dockable frame. You only need to use it when you override shouldVetoHiding() in your dockable frame implementations.

When your application exits, you should call dockingManager.dispose(). However if you override shouldVetoHiding() in your dockable frame implementations, you need call this method first. If this method returns false, you proceed to dispose() method. If it returns true, you should stop the application exiting process.

Returns:: true if the removing all frames process should be vetoed.

isHideFloatingFramesOnSwitchOutOfApplication

boolean isHideFloatingFramesOnSwitchOutOfApplication()

Checks if floating frames will be hidden when user switches a different application.

setHideFloatingFramesOnSwitchOutOfApplication

void setHideFloatingFramesOnSwitchOutOfApplication(boolean newValue)

Turn hiding floating frames when we switch to a different application on and off.

isShowContextMenu

boolean isShowContextMenu()

Checks if the context menu should be shown.

Returns:: true if context menu will be shown. Otherwise false.

setShowContextMenu

void setShowContextMenu(boolean showContextMenu)

Sets the flag to show context menu or not.

Parameters:: showContextMenu - the flag

getDockableFrameFactory

DockableFrameFactory getDockableFrameFactory()

Gets the dockable frame factory. The factory is used in loadInitialLayout()/loadLayout() method. If the dockable frame exists in the layout to be loaded but not added to DockingManager, the factory will be used to create the dockable frame.

Returns:: the dockable frame factory.

setDockableFrameFactory

void setDockableFrameFactory(DockableFrameFactory dockableFrameFactory)

Sets the dockable frame factory.

Parameters:: dockableFrameFactory - the dockable frame factory

isUseDecoratedFloatingContainer

boolean isUseDecoratedFloatingContainer()

Checks if it always use decorated dialog or frame as floating container if the floating container type is dialog or frame.

Returns:: true if the floating container is always decorated. By default, if there is only one dockable frame or several dockable frames in the same tabbed pane, it will use undecorated dialog or frame as floating container.

setUseDecoratedFloatingContainer

void setUseDecoratedFloatingContainer(boolean useDecoratedFloatingContainer)

Sets the flag that if decorated dialog or frame is used as floating container when there is only one dockable frame or several dockable frames in the same tabbed pane.

Parameters:: useDecoratedFloatingContainer - the flag

isProportionalSplits

boolean isProportionalSplits()

Tells whether this docking manager will create proportional split panes when it creates split panes to hold docked frames.

Returns:: true if this docking manager will create proportional split panes. Otherwise false.

setProportionalSplits

void setProportionalSplits(boolean b)

Sets whether this docking manager will create proportional split panes when it creates split panes to hold docked frames.

Parameters:: b - the flag

isHeavyweightComponentEnabled

boolean isHeavyweightComponentEnabled()

Returns:: true if the heavyweight component is enabled.

setHeavyweightComponentEnabled

void setHeavyweightComponentEnabled(boolean heavyweightComponentEnabled)

Enables heavyweight component.

Parameters:: heavyweightComponentEnabled - the flag

isPreserveAvailableProperty

boolean isPreserveAvailableProperty()

Checks if the unavailable dockable frame will remain unavailable after saveLayout method is called.

Returns:: true or false. If true, all unavailable frames will still be unavailable. If false, all unavailable frames will become available.

setPreserveAvailableProperty

void setPreserveAvailableProperty(boolean preserve)

Sets the flag if the unavailable dockable frame will remain unavailable after saveLayout method is called.

Parameters:: preserve - true or false. True to preserve the unavailable flag.

isWithinFrameBoundsOnDragging

boolean isWithinFrameBoundsOnDragging()

Checks the flag of withinFrameBoundsOnDragging. If true, when user drags the dockable frame, the position is limited by the main JFrame's bounds. If false, user will be able to drag dockable frame to float outside the main JFrame.

Returns:: true or false.

setWithinFrameBoundsOnDragging

void setWithinFrameBoundsOnDragging(boolean withinFrameBoundsOnDragging)

Sets the flag if dragging a dockable frame is limited to the main JFrame's bounds. If your application is always maximized to cover the whole user screen, you should set this flag to true.

Parameters:: withinFrameBoundsOnDragging - the flag

isWithinScreenBoundsOnDragging

boolean isWithinScreenBoundsOnDragging()

Checks the flag of withinScreenBoundsOnDragging. If true, when user drags the dockable frame, the position is limited by the screen's bounds. If false, user will be able to drag dockable frame to float outside the screen.

Returns:: true or false.

setWithinScreenBoundsOnDragging

void setWithinScreenBoundsOnDragging(boolean withinScreenBoundsOnDragging)

Sets the flag if dragging a dockable frame is limited to the screen's bounds. If your application is always maximized to cover the whole user screen, you should set this flag to true.

Parameters:: withinScreenBoundsOnDragging - the flag

isCrossDraggingAllowed

boolean isCrossDraggingAllowed()

Whether allows a dockable frame in this DockingManager to be dragged into other DockingManagers.

Returns:: true or false.

setCrossDraggingAllowed

void setCrossDraggingAllowed(boolean crossDraggingAllowed)

isCrossDroppingAllowed

boolean isCrossDroppingAllowed()

Whether allows a dockable frame in other DockingManagers to be dragged into this DockingManager.

Returns:: true or false.

setCrossDroppingAllowed

void setCrossDroppingAllowed(boolean crossDroppingAllowed)

removeDockableFrameDropListener

void removeDockableFrameDropListener(DockableFrameDropListener l)

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

Parameters:: l - the dockable frame drop listener

addDockableFrameDropListener

void addDockableFrameDropListener(DockableFrameDropListener l)

Adds the specified listener to receive dockable frame drop events from this dockable frame.

Parameters:: l - the dockable frame listener

getDockableFrameDropListeners

DockableFrameDropListener[] getDockableFrameDropListeners()

Returns an array of all the DockableFrameDropListeners added to this DockableFrame with addDockableFrameDropListener.

Returns:: all of the DockableFrameDropListeners added or an empty array if no listeners have been added
See Also:: addDockableFrameDropListener(com.jidesoft.docking.event.DockableFrameDropListener)

addDockableFrameListener

void addDockableFrameListener(DockableFrameListener l)

Allows you to add a single DockableFramelistener to all DockableFrames managed by the docking manager. If you just want to listen to the event from a particular DockableFrame, you can use DockableFrame.addDockableFrameListener(com.jidesoft.docking.event.DockableFrameListener) method.

Parameters:: l - the dockable frame listener

removeDockableFrameListener

void removeDockableFrameListener(DockableFrameListener l)

Removes the DockableFrameListener that will event for all DockableFrames managed by the docking manager.

Parameters:: l -

getDockableFrameListeners

DockableFrameListener[] getDockableFrameListeners()

Returns an array of all the DockableFrameListeners added to this DockingManager with addDockableFrameListener.

Returns:: all of the DockableFrameListeners added or an empty array if no listeners have been added
See Also:: addDockableFrameListener(com.jidesoft.docking.event.DockableFrameListener)

isDropAllowed

boolean isDropAllowed(DockableFrame source,
                      Component target,
                      int side)

Fires an dockable frame drop event to check if dropping is allowed.

Parameters:: source - the frame to be dropped; target - the target that the frame to be dropped in; side - the side
Returns:: true if drop is allowed. Otherwise false.

isHideNewlyAddedFrames

boolean isHideNewlyAddedFrames()

Checks if newly added frames should be hidden when the old layout is loaded. It's false by default.

Returns:: true if newly added frame is hidden. Otherwise, false.

setHideNewlyAddedFrames

void setHideNewlyAddedFrames(boolean hideNewlyAddedFrames)

Sets the flag to hide newly added frames when the old layout is loaded. For example, you had frame A, B and C and saved as a layout. Now you added frame D and load the saved layout. If this flag is true, the frame D will be hidden regardless what it's initial state is. If the flag is false, the D could be made visible if the frame's initial state is docked or floating or autohidden.

Parameters:: hideNewlyAddedFrames - the flag

getNotificationBackground

Color getNotificationBackground()

Gets the notification background.

Returns:: the notification background.

setNotificationBackground

void setNotificationBackground(Color notificationBackground)

Sets the notification background. The color is used to flash the tab background when notifyFrame is called.

Parameters:: notificationBackground - the notification background.

getNotificationForeground

Color getNotificationForeground()

Gets the notification foreground.

Returns:: the notification foreground.

setNotificationForeground

void setNotificationForeground(Color notificationForeground)

Sets the notification foreground. The color is used to flash the tab foreground when notifyFrame is called.

Parameters:: notificationForeground - the notification foreground.

getNotificationDelay

int getNotificationDelay()

Gets the delay of ms between two flashes when notifyFrame is called.

Returns:: the delay between two flashes.

setNotificationDelay

void setNotificationDelay(int notificationDelay)

Sets the delay between two flashes when notifyFrame is called.

Parameters:: notificationDelay - the delay.

getNotificationSteps

int getNotificationSteps()

Gets the number of flashes when notifyFrame is called.

Returns:: the number of flashes when notifyFrame is called.

setNotificationSteps

void setNotificationSteps(int notificationSteps)

Sets the number of flashes when notifyFrame is called.

Parameters:: notificationSteps - the number of flashes when notifyFrame is called. -1 means it will never stop until user responses to the notification.

isShowTitleOnOutline

boolean isShowTitleOnOutline()

Checks if the title of the dragging dockable frame is displayed on the outline while dragging.

Returns:: true or false.

setShowTitleOnOutline

void setShowTitleOnOutline(boolean show)

Sets the flag if the title will be displayed on the ontline while dragging. Please note, this flag works only when the outline mode is PARTIAL_OUTLINE_MODE and TRANSPARENT_OUTLINE_MODE.

Parameters:: show -

setAutohideShowingContentHidden

void setAutohideShowingContentHidden(boolean hide)

Pass in true if you want the content of dockable frame hidden during sliding. If all your dockable frames are very efficient when repaint, you can leave this option as false. It will look better if the option is false. Default is true.

Parameters:: hide -

isAutohideShowingContentHidden

boolean isAutohideShowingContentHidden()

Checks if the content of dockable frame is hidden during sliding.

Returns:: true if the content of dockable frame is hidden during sliding

startShowingAutohideFrame

void startShowingAutohideFrame(String frame,
                               int side,
                               int initDelay)

Starts to show the autohide frame. This function will do nothing if the frame is not is the autohide state.

Parameters:: frame - the frame that is showing; side - the side; initDelay - initial delay time

startShowingAutohideFrameImmediately

void startShowingAutohideFrameImmediately(String frame,
                                          int side)

Stops the autohideframe from show immediately.
This method is Swing thread-safe.

Parameters:: frame - the frame that is showing; side - the side

stopShowingAutohideFrame

void stopShowingAutohideFrame(int initDelay,
                              boolean forceComplete)

Stops showing the autohide frame. This will start the close animation after the initial delay.

Parameters:: initDelay - initial delay time; forceComplete - the flag indicating if a mouse over can interrupt and cause the frame to stay open

stopShowingAutohideFrameImmediately

void stopShowingAutohideFrameImmediately()

Stops the autohideframe from show immediately.
This method is Swing thread-safe.

finishShowingAutohideFrame

void finishShowingAutohideFrame(String frame)

Notifies that the auto hide showing process has been finished.

Parameters:: frame - the frame that is showing
Since:: 3.1.1

isAutohideShowingInProgress

boolean isAutohideShowingInProgress()

Checks if autohide showing has started but not finished.

Returns:: true if autohide showing has started but not finished

getAutohideShowingFrame

String getAutohideShowingFrame()

Return they frame key that is autohideshowing. This frame may be open/opening/closing.

Returns:: return they key for a frame that is either showing or opening/closing

addPropertyChangeListener

void addPropertyChangeListener(PropertyChangeListener listener)

removePropertyChangeListener

void removePropertyChangeListener(PropertyChangeListener listener)

Removes a PropertyChangeListener from the listener list. This method should be used to remove PropertyChangeListeners that were registered for all bound properties of this class.

If listener is null, no exception is thrown and no action is performed.

Parameters:: listener - the PropertyChangeListener to be removed
See Also:: addPropertyChangeListener(java.beans.PropertyChangeListener), getPropertyChangeListeners(), removePropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)

getPropertyChangeListeners

PropertyChangeListener[] getPropertyChangeListeners()

Returns an array of all the property change listeners registered on this component.

Returns:: all of this component's PropertyChangeListeners or an empty array if no property change listeners are currently registered
Since:: 1.4
See Also:: addPropertyChangeListener(java.beans.PropertyChangeListener), removePropertyChangeListener(java.beans.PropertyChangeListener), getPropertyChangeListeners(java.lang.String), PropertyChangeSupport.getPropertyChangeListeners()

addPropertyChangeListener

void addPropertyChangeListener(String propertyName,
                               PropertyChangeListener listener)

Adds a PropertyChangeListener to the listener list for a specific property.

Parameters:: propertyName - one of the property names listed above; listener - the PropertyChangeListener to be added
See Also:: removePropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener), getPropertyChangeListeners(java.lang.String), addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)

removePropertyChangeListener

void removePropertyChangeListener(String propertyName,
                                  PropertyChangeListener listener)

Removes a PropertyChangeListener from the listener list for a specific property. This method should be used to remove PropertyChangeListeners that were registered for a specific bound property.

If listener is null, no exception is thrown and no action is performed.

Parameters:: propertyName - a valid property name; listener - the PropertyChangeListener to be removed
See Also:: addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener), getPropertyChangeListeners(java.lang.String), removePropertyChangeListener(java.beans.PropertyChangeListener)

getPropertyChangeListeners

PropertyChangeListener[] getPropertyChangeListeners(String propertyName)

Returns an array of all the listeners which have been associated with the named property.

Parameters:: propertyName - the property name.
Returns:: all of the PropertyChangeListeners associated with the named property or an empty array if no listeners have been added
See Also:: addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener), removePropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener), getPropertyChangeListeners()

switchRootPaneContainer

void switchRootPaneContainer(RootPaneContainer rootContainer)

Change the root pane container. The root pane container is set as a parameter in constructor of DockingManager. However if the content container is moved to another root pane container, you need to call this method to let DockingManager know the change.

We suggest you call saveLayout to a known location before calling this method, then call loadLayout to load the saved layout back after calling to switchRootPaneContainer to make sure dockable frames are laid out correctly in the new root pane container.

Parameters:: rootContainer -

getRootPaneContainer

RootPaneContainer getRootPaneContainer()

Gets root pane container. Root pane container is the JFrame, JWindow, JDialog or JApplet where this manager is installed to.

Specified by:: getRootPaneContainer in interface RootPanePersistence

Returns:: root pane container

isUseGlassPaneEnabled

boolean isUseGlassPaneEnabled()

Checks if we will use glass pane to change cursor.

Returns:: true or false.

setUseGlassPaneEnabled

void setUseGlassPaneEnabled(boolean useGlassPaneEnabled)

Enables us to use glass pane to for cursor change purpose.

Parameters:: useGlassPaneEnabled -

findFloatingComponentAt

FloatingContainer findFloatingComponentAt(int x,
                                          int y)

requestFocusInDockingManager

void requestFocusInDockingManager()

setShowInitial

void setShowInitial(boolean value)

A client may specify that the docking layout is to be initialized without showing the window. In this case, the client is responsible for calling showInitial() every time the window is to be shown after loading layout.

Default is true, show the window at the end of initial layout.

Parameters:: value - true or false.

isShowInitial

boolean isShowInitial()

Returns:: true or false.

showInitial

void showInitial()

isActive

boolean isActive()

Checks if the DockingManager is considered as active docking manager. This is only needed when you have several docking managers in one application. Although each docking manager can have its own active frame, only one frame will be painted as active. That's the one in the active docking manager. Activate one docking manager will deactivate all other docking managers in the same group.

Here is how you add multiple docking managers to a DockingManagerGroup.

 DockingManagerGroup group = new DockingManagerGroup();
 group.add(dockingManager1);
 group.add(dockingManager2);
 ... // you can add more docking managers if you want

Returns:: true or false.
See Also:: DockingManagerGroup

setActive

void setActive(boolean active)

Makes the docking manager active. Activate this docking manager will deactivate all other docking managers in the same group. By default, if a component in a dockable frame receives focus, the docking manager will be activated automatically.

Parameters:: active - true or false.

getGroup

DockingManagerGroup getGroup()

Gets the DockingManagerGroup. If the docking manager is added to DockingManagerGroup, this method will return the group.

Returns:: the DockingManagerGroup.

setGroup

void setGroup(DockingManagerGroup group)

Sets the DockingManagerGroup.

Parameters:: group - the new DockingManagerGroup.

handleEvent

boolean handleEvent(AWTEvent event)

Handles the AWTEvent.

Parameters:: event - the event received
Returns:: true if the event should be consumed

isAutoActivateFocusOwner

@Deprecated
boolean isAutoActivateFocusOwner()

Deprecated. not in use any more due to new focus management mechanism.

Check if the frame is automatically activated when its child component receives the keyboard focus.

Returns:: true or false.

setAutoActivateFocusOwner

@Deprecated
void setAutoActivateFocusOwner(boolean autoActivateFocusOwner)

Deprecated. not in use any more due to new focus management mechanism.

Sets the flag to autoActivateFocusOwner. If it's true, the dockable frame will automatically be activated when its child component receives keyboard focus. On the other hand, when a component in workspace area receives focus, the active dockable frame (if there is one) will be deactivated.

Please note, it'd better if you keep this flag false unless you programmatically request focus on a certain component. For example, here is the right way to use this method. We have to use a FocusListener because requestFocus is processed asynchronously.

 dockingManager.setAutoActivateFocusOwner(true);
 component.addFocusListener(new FocusAdapter() {
     public void focusGained(FocusEvent e) {
         dockingManager.setAutoActivateFocusOwner(false);
         component.removeFocusListener(this);
     }
 });
 component.requestFocus();

Default is true.

Parameters:: autoActivateFocusOwner - true or false.

getFloatingContainerType

int getFloatingContainerType()

Gets the floating container type. It could be FLOATING_CONTAINER_TYPE_DIALOG, FLOATING_CONTAINER_TYPE_FRAME or FLOATING_CONTAINER_TYPE_WINDOW.

Returns:: the floating container type.

setFloatingContainerType

void setFloatingContainerType(int floatingContainerType)

Sets the floating container type. It could be FLOATING_CONTAINER_TYPE_DIALOG, FLOATING_CONTAINER_TYPE_FRAME or FLOATING_CONTAINER_TYPE_WINDOW.

Parameters:: floatingContainerType - the floating container type.

getFloatingContainerCustomizer

DockingManager.FloatingContainerCustomizer getFloatingContainerCustomizer()

Gets the FloatingContainerCustomizer. This customizer will be used to customize the floating container when it is created.

Returns:: the FloatingContainerCustomizer.

setFloatingContainerCustomizer

void setFloatingContainerCustomizer(DockingManager.FloatingContainerCustomizer customizer)

Sets the FloatingContainerCustomizer. This customizer will be used to customize the floating container when it is created.

Parameters:: customizer - the FloatingContainerCustomizer.

getFloatingFrames

List<FloatingContainer> getFloatingFrames()

Get all floating frames in current layout.

Returns:: all floating frames in an array list.

getUnknownFrameBehaviorOnLoading

int getUnknownFrameBehaviorOnLoading()

Gets the unknown frame behavior on loading.

Returns:: the unknown frame behavior
See Also:: setUnknownFrameBehaviorOnLoading(int)

setUnknownFrameBehaviorOnLoading

void setUnknownFrameBehaviorOnLoading(int unknownFrameBehaviorOnLoading)

Sets the unknown frame behavior on loading.

The unknown frame means that, it's an existing frame before loading layout. However, this frame does not exist in the layout file to be loaded.

So far, the value could be UNKNOWN_FRAME_BEHAVIOR_SHOW_INIT or UNKNOWN_FRAME_BEHAVIOR_HIDE. The first option is the traditional behavior that shows the frame respecting its initial mode, side and index. The hide option is a new behavior that hides the frame.

Parameters:: unknownFrameBehaviorOnLoading - the unknown frame behavior

getSnapGridSize

int getSnapGridSize()

Gets the snap grid size.

Returns:: the snap grid size.
See Also:: setSnapGridSize(int)

setSnapGridSize

void setSnapGridSize(int snapGridSize)

Sets the snap grid size.

Snap grid size is used to make dragging a DockableFrame to resize or reposition easier.

By default, the size is 1 pixel.

Parameters:: snapGridSize - the snap grid size

getResourceString

String getResourceString(String key)

Gets the resource string used in DefaultDockingManager. Subclass can override it to provide their own strings.

Parameters:: key - the resource key
Returns:: the localized string.
Since:: 3.5.0

resetLayout

void resetLayout()

This method is called for every rearragement of the dockable frames. By default, it will reset all ContainerContainers, validate ContentContainer, DockedFrameConatiner and Workspace.

setActiveMouseInputListener

void setActiveMouseInputListener(MouseInputListener listener)

This method should only be used by JIDE. We introduced these two methods to workaround a bug in JDK7 where the mouseReleased event was not delivered to the right component.

Parameters:: listener -

getActiveMouseInputListener

MouseInputListener getActiveMouseInputListener()