WorkpageContainer (CaptainCasa Enterprise Client)

java.lang.Object
- org.eclnt.workplace.WorkpageContainer

All Implemented Interfaces:

java.io.Serializable, IWorkpageContainer
```
public class WorkpageContainer
extends java.lang.Object
implements IWorkpageContainer, java.io.Serializable
```
Container managing multiple workpages. Each workpage either is opened in the content area of the workplace or is shown as modeless popup.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`WorkpageContainer.MyModelessPopupListener`
`class`	`WorkpageContainer.SubWorkpageContainers`
`class`	`WorkpageContainer.WorkpageInfo`
`class`	`WorkpageContainer.WorkpageInfoMap`

Constructor Summary

Constructors
Constructor and Description
`WorkpageContainer(IWorkpageDispatcher dispatcher)` This constructor is used for the main workpage container.
`WorkpageContainer(IWorkpageDispatcher dispatcher, boolean withPreparingWorkplaceForCurrentUser)` This constructor may be used if you want to switch off the usage of the default workplace management.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addWorkpage(IWorkpage workpage)` Adds the new workpage to the workpage container.
`void`	`addWorkpageAndKeepInBackground(IWorkpage workpage)` Adds the new workpage to the workpage container.
`void`	`addWorkpageAndKeepInBackgroundLOCAL(IWorkpage workpage)`
`ModelessPopup`	`addWorkpageAsPopup(IWorkpage workpage)` Adds the new workpage to the workpage container.
`void`	`addWorkpageContainerListener(IWorkpageContainerListener workpageContainerListener)`
`boolean`	`checkIfWorkpageIsOpenedInPopup(IWorkpage workpage)`
`void`	`closeAllWorkpages()` Closes all workpages using the forced mode for closing.
`void`	`closeAllWorkpages(boolean forcedMode, java.lang.Runnable afterCloseOperation)` Closes all workpages.
`void`	`closeAllWorkpagesBesidesCurrent()`
`void`	`closeAllWorkpagesLeftOfCurrent()`
`void`	`closeAllWorkpagesRightOfCurrent()`
`void`	`closeWorkpage(IWorkpage workpage)` Closes a workpage.
`void`	`closeWorkpage(IWorkpage workpage, boolean alsoCloseWorkpageWithNoCloseSupported)` Same as `IWorkpageContainer.closeWorkpage(IWorkpage)` with additional parameter to check what to do with workpages that are defined to be without support of closing (i.e. inteface IWorkpage.isCloseSupported() returns false.
`void`	`closeWorkpageForced(IWorkpage workpage)` Closes a workpage - forced mode.
`void`	`closeWorkpageForced(IWorkpage workpage, boolean alsoCloseWorkpageWithNoCloseSupported)` Same as `IWorkpageContainer.closeWorkpageForced(IWorkpage)` with additional parameter to check what to do with workpages that are defined to be without support of closing (i.e. inteface IWorkpage.isCloseSupported() returns false.
`void`	`closeWorkpages(java.util.List<IWorkpage> workpagesToBeClosed, boolean forcedMode, java.lang.Runnable afterCloseOperation)`
`java.util.List<WorkpageStartInfo>`	`exportCurrentWorkpages()` Exports all workpages that were started via IWorkpageStartInfo into one list.
`java.util.List<IWorkpage>`	`getAllWorkpages()` Returns list of all workpages the user has currently opened in the current workpage container. - Please note: there may be (better: there typically are) mulitple workpage containers, each one holding workpages.
`java.util.List<IWorkpage>`	`getAllWorkpagesIncludingSubWorkpageContainers()` Returns list of all workpages, but now not restricted to "this" container, but to "this" container and the ones that are kept below.
`Trigger`	`getAnimationValue()`
`java.lang.String`	`getContentReplaceForWorkpage(IWorkpage wp)`
`java.lang.String`	`getContentReplaceNoDrillDown(IWorkpage wp)`
`java.lang.String`	`getCurrentContentReplace()`
`java.lang.String`	`getCurrentContentReplaceNoDrillDown()`
`java.lang.String`	`getCurrentJspPage()`
`IWorkpage`	`getCurrentlySelectedWorkpage()` Returns the workpage that is currently selected within the workpage selector.
`IWorkpage`	`getCurrentWorkpage()` Returns the workpage that is currently shown within the content area of the workplace.
`java.lang.String`	`getCurrentWorkpageClientNameCloseIcon()`
`java.lang.String`	`getCurrentWorkpageClientNamePopupIcon()`
`int`	`getDefaultPopupHeight()`
`int`	`getDefaultPopupWidth()`
`DYNAMICCONTENTBinding`	`getDynMenuContent()`
`java.lang.String`	`getEmptyPage()`
`boolean`	`getEnabledCloseAll()`
`boolean`	`getEnabledCloseAllLeft()`
`boolean`	`getEnabledCloseAllRight()`
`boolean`	`getEnabledCloseOthers()`
`int`	`getFocusCounter()`
`WorkplaceFunctionSearchUI`	`getFunctionSearchUI()` Page bean for searching functions within the current function tree.
`WorkplaceFunctionsManager`	`getFunctionsManager()` Each workpage container has one functions manager - managing the function tree(s).
`WorkplaceFunctionsManager`	`getFunctionsManagerWithoutInitialization()`
`WorkplaceHistory`	`getHistory()` The workplace includes some management of the history of its content.
`boolean`	`getHotKeyIsolation()`
`boolean`	`getOpenWorkpagePopupsAsFrame()`
`java.lang.String`	`getOwnSubContainerId()` A workplace may contain several workpage containers.
`WorkplacePerspectiveManager`	`getPerspectiveManager()`
`WorkplacePerspectiveManager`	`getPerspectiveManagerWithoutInitialization()`
`IWorkpageContainerRenderer`	`getRenderer()`
`java.lang.String`	`getRendererClassName()`
`WorkpageContainer`	`getRootWorkpageContainer()`
`boolean`	`getShowPopupWorkpagesInSelector()`
`java.util.Map<java.lang.String,? extends IWorkpageContainer>`	`getSubContainers()` A workplace may have several workpage containers - each of them holding workpages.
`java.lang.String`	`getSubWorkpageContainerIdForWorkpage(IWorkpage workpage)` A workpage container may be separated into sub-workpage containers.
`WorkpageContainer.SubWorkpageContainers`	`getSubWorkpageContainers()`
`boolean`	`getTabbedLineEnabled()`
`int`	`getTabbedLineIndex()`
`WorkplaceTileManager`	`getTileManager()` Each workplace has one tile manager - a tile being the graphical representation of a workpage container.
`WorkplaceTileManager`	`getTileManagerWithoutInitialization()`
`java.lang.String`	`getUniqueId()` A workpage container instance is assigned a unique technical id when it is created.
`boolean`	`getUpdateOnInnerEventOnly()`
`boolean`	`getWithTabSelectorCloseIcons()`
`boolean`	`getWithWorkpageDragDrop()`
`java.util.Set<IWorkpageContainerListener>`	`getWorkpageContainerListeners()`
`IWorkpageDispatcher`	`getWorkpageDispatcher()`
`IWorkpage`	`getWorkpageForId(java.lang.String id)` Check if a workpage already is available for a passed workpage id.
`IWorkpage`	`getWorkpageForUniqueTechnicalId(java.lang.String techId)`
`java.lang.String`	`getWorkpagePopupDefaultBgpaint()`
`WorkpageContainer.WorkpageInfoMap`	`getWpim()`
`static void`	`initialize()` Called as part of CaptainCasa runtime initialization.
`static void`	`initImplicitLoadingForCurrentUser(boolean withPreparingWorkplaceForCurrentUser)` By default the workplace management initializes it's environment on its own, calling function `prepareWorkplaceForCurrentUser()` automatically.
`boolean`	`isCurrentWorkpageBlocked()`
`boolean`	`isCurrentWorkpageCloseSupported()`
`boolean`	`isCurrentWorkpageDecorated()`
`boolean`	`isCurrentWorkpagePopupSupported()`
`ModelessPopup`	`isolateWorkpageIntoModelessPopup(IWorkpage workpage)` Isolate workpage as modeless popup.
`void`	`maximizeWorkpage(IWorkpage workpage, boolean value)` Maximize size of workpage.
`void`	`moveIsolatedWorkpageBackIntoContentArea(IWorkpage workpage)` Brings back a workpage that is isolated as modeless popup back into its content area.
`void`	`moveWorkpage(IWorkpage wp, WorkpageContainer toWpc)`
`void`	`moveWorkpage(java.lang.String wpTechId, java.lang.String toWorkpageContainerId)` Moves an existing workpage into an other workpage container.
`void`	`moveWorkpageIntoContentArea(IWorkpage workpage)` Take a page from modeless display back into content area.
`void`	`onCloseAllWorkpages(ActionEvent ae)`
`void`	`onCloseCurrentWorkpage(ActionEvent ae)`
`void`	`onCloseWorkpage(ActionEvent ae)`
`void`	`onHideAllPopups(ActionEvent ae)`
`void`	`onOpenCurrentPageAsModelessPopup(ActionEvent ae)`
`void`	`onPageAction(ActionEvent ae)`
`void`	`onSwitchToLeft(ActionEvent ae)`
`void`	`onSwitchToRight(ActionEvent ae)`
`void`	`onTabbedLineAction(ActionEvent ae)`
`void`	`onTabbedLineTabAction(ActionEvent ae)`
`void`	`prepareWorkplaceForCurrentUser()` Central method for loading all workplace related information within the current workplace.
`void`	`removeWorkpageContainerListener(IWorkpageContainerListener workpageContainerListner)`
`void`	`removeWorkpageInfo(IWorkpage workpage)`
`void`	`renderPopupMenuIntoNode(IWorkpage wp, ROWDYNAMICCONTENTBinding.ComponentNode node)`
`void`	`renderWorkpageNode(IWorkpage wp, ROWDYNAMICCONTENTBinding.ComponentNode parentNode, java.lang.String parentNodeId)`
`void`	`setDefaultPopupHeight(int defaultPopupHeight)` Defines the height of the popup when isolating a workpage into a window of its own.
`void`	`setDefaultPopupWidth(int defaultPopupWidth)` Defines the width of the popup when isolating a workpage into a window of its own.
`void`	`setEmptyPage(java.lang.String jspPage)` The page that is shown when no workpage is available within the workpage container.
`void`	`setHistory(WorkplaceHistory history)`
`void`	`setHotKeyIsolation(boolean hotkeyisolation)` If set to true then the workpage areas are isolated areas for hotkey processing.
`void`	`setMaxNumberOfWorkpages(int maxNumberOfWorkpages)` With this method you may restrict the number of parallelly running workpages to a certain limit.
`void`	`setMaxNumberOfWorkpagesExceededMessage(java.lang.String message)` This is the message that is popped up once a user exceeds the limit of "maxNumberOfWorkpages".
`void`	`setOpenWorkpagePopupsAsFrame(boolean value)` By default isolated workpages are opened as dialog.
`void`	`setRendererClassName(java.lang.String value)` The content renderer of the workpage container can be customized by passing the class name of the renderer.
`void`	`setShowPopupWorkpagesInSelector(boolean showPopupWorkpagesInSelector)` By default workpages that are isolated into an own popup are not shown in the selector.
`void`	`setTabbedLine(TABBEDLINEComponent tabbedLine)` Internally used,
`void`	`setTabbedLineIndex(int tabbedLineIndex)`
`void`	`setUpdateOnInnerEventOnly(boolean value)` If set to true, then a workpage is only updated on an event that is coming from the workpage itself.
`void`	`setWithTabSelectorCloseIcons(boolean withTabSelectorCloseIcons)` Defines if close icons are rendered into the selector's tab components.
`void`	`setWithWorkpageDragDrop(boolean withWorkpageDragDrop)` Defines if the user is able to drag/drop workpages in order to shift workpages from one workpage container to the next.
`void`	`setWorkpagePopupDefaultBgpaint(java.lang.String workpagePopupDefaultBgpaint)` Defines the BGPAINT of isolated workpage popups.
`void`	`setWorkpageSelectorEnabled(IWorkpage workpage, boolean tabbedLineEnabled)` You may disable/enable the tab-navigation of a workpage's tabbed line.
`protected void`	`showAsContentPage(IWorkpage wp)`
`void`	`switchToWorkpage(IWorkpage wp)` Switches to the workpage that is passed as parameter.
`void`	`throwWorkpageProcessingEvent(WorkpageProcessingEvent event)` Throws an event and triggers the delegation of the event to all other workpage instances.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - WorkpageContainer
```
public WorkpageContainer(IWorkpageDispatcher dispatcher)
```
    This constructor is used for the main workpage container.
  - WorkpageContainer
```
public WorkpageContainer(IWorkpageDispatcher dispatcher,
                         boolean withPreparingWorkplaceForCurrentUser)
```
    This constructor may be used if you want to switch off the usage of the default workplace management. The default workplace management reads the runtime configuration for the current user and creates a corresponding workplace perspective.
- Method Detail
  - initialize
```
public static void initialize()
```
    Called as part of CaptainCasa runtime initialization.
  - initImplicitLoadingForCurrentUser
```
public static void initImplicitLoadingForCurrentUser(boolean withPreparingWorkplaceForCurrentUser)
```
    By default the workplace management initializes it's environment on its own, calling function prepareWorkplaceForCurrentUser() automatically. This function expects the user data (interface IUserAccess to be available, so that certain workplace functions (e.g. building up function tree, loading persisted workplace history, ...) that are user-specific use the right user.
    
    In certain situations you may avoid this automated initialization and explicitly call the function prepareWorkplaceForCurrentUser() on your own. Example: the user comes from some explicit logon screen, which was not yet processed.
    
    This method is automatically called during the server start-up - using the value that is defined in system.xml. You may re-call any time later and override the value.
  - prepareWorkplaceForCurrentUser
```
public void prepareWorkplaceForCurrentUser()
```
    Central method for loading all workplace related information within the current workplace. This method needs to be called whenever the user changes (e.g. after logon).
    
    Specified by:
    
    prepareWorkplaceForCurrentUser in interface IWorkpageContainer
  - setRendererClassName
```
public void setRendererClassName(java.lang.String value)
```
    Description copied from interface: IWorkpageContainer
    
    The content renderer of the workpage container can be customized by passing the class name of the renderer. The renderer class must either implement IWorkpageContainerRenderer or IWorkpageContainerPartialRenderer.
    
    Specified by:
    
    setRendererClassName in interface IWorkpageContainer
  - getRendererClassName
```
public java.lang.String getRendererClassName()
```
    Specified by:
    
    getRendererClassName in interface IWorkpageContainer
  - getDynMenuContent
```
public DYNAMICCONTENTBinding getDynMenuContent()
```
  - getRenderer
```
public IWorkpageContainerRenderer getRenderer()
```
    Specified by:
    
    getRenderer in interface IWorkpageContainer
  - getHistory
```
public WorkplaceHistory getHistory()
```
    Description copied from interface: IWorkpageContainer
    
    The workplace includes some management of the history of its content. This is the method to access the corresponding functions.
    
    Specified by:
    
    getHistory in interface IWorkpageContainer
  - setHistory
```
public void setHistory(WorkplaceHistory history)
```
  - getWorkpagePopupDefaultBgpaint
```
public java.lang.String getWorkpagePopupDefaultBgpaint()
```
  - setWorkpagePopupDefaultBgpaint
```
public void setWorkpagePopupDefaultBgpaint(java.lang.String workpagePopupDefaultBgpaint)
```
    Description copied from interface: IWorkpageContainer
    
    Defines the BGPAINT of isolated workpage popups.
    
    Specified by:
    
    setWorkpagePopupDefaultBgpaint in interface IWorkpageContainer
  - getHotKeyIsolation
```
public boolean getHotKeyIsolation()
```
    Specified by:
    
    getHotKeyIsolation in interface IWorkpageContainer
  - setHotKeyIsolation
```
public void setHotKeyIsolation(boolean hotkeyisolation)
```
    Description copied from interface: IWorkpageContainer
    
    If set to true then the workpage areas are isolated areas for hotkey processing. THis means that the a hotkey is only processed within the workpage in which it was triggered. There is no double-processing of hotkeys because of two workpages being shown in parallel.
    
    Specified by:
    
    setHotKeyIsolation in interface IWorkpageContainer
  - getShowPopupWorkpagesInSelector
```
public boolean getShowPopupWorkpagesInSelector()
```
  - setShowPopupWorkpagesInSelector
```
public void setShowPopupWorkpagesInSelector(boolean showPopupWorkpagesInSelector)
```
    Description copied from interface: IWorkpageContainer
    
    By default workpages that are isolated into an own popup are not shown in the selector. You can override this behavior by passing the value "true".
    
    Specified by:
    
    setShowPopupWorkpagesInSelector in interface IWorkpageContainer
  - getWithTabSelectorCloseIcons
```
public boolean getWithTabSelectorCloseIcons()
```
  - setWithTabSelectorCloseIcons
```
public void setWithTabSelectorCloseIcons(boolean withTabSelectorCloseIcons)
```
    Description copied from interface: IWorkpageContainer
    
    Defines if close icons are rendered into the selector's tab components. Default is "true".
    
    Specified by:
    
    setWithTabSelectorCloseIcons in interface IWorkpageContainer
  - getWorkpageDispatcher
```
public IWorkpageDispatcher getWorkpageDispatcher()
```
  - getUniqueId
```
public java.lang.String getUniqueId()
```
    Description copied from interface: IWorkpageContainer
    
    A workpage container instance is assigned a unique technical id when it is created. This id is stable during the lifecycle of the workpage container. Please pay attention: this is a technical id "only"! The id that is assigned to the workpage container within the workplace setup is available via IWorkpageContainer.getOwnSubContainerId().
    
    Specified by:
    
    getUniqueId in interface IWorkpageContainer
  - addWorkpageContainerListener
```
public void addWorkpageContainerListener(IWorkpageContainerListener workpageContainerListener)
```
  - removeWorkpageContainerListener
```
public void removeWorkpageContainerListener(IWorkpageContainerListener workpageContainerListner)
```
  - getWorkpageContainerListeners
```
public java.util.Set<IWorkpageContainerListener> getWorkpageContainerListeners()
```
  - getTileManagerWithoutInitialization
```
public WorkplaceTileManager getTileManagerWithoutInitialization()
```
  - getTileManager
```
public WorkplaceTileManager getTileManager()
```
    Description copied from interface: IWorkpageContainer
    
    Each workplace has one tile manager - a tile being the graphical representation of a workpage container. The tile manager is a funciton on top of the workpage container and separates the screen into tiles, in each of the tiles a workpage container is started. The user may configure the tiles by dragging and dropping content from one tile to the next.
    
    Specified by:
    
    getTileManager in interface IWorkpageContainer
  - getFunctionsManagerWithoutInitialization
```
public WorkplaceFunctionsManager getFunctionsManagerWithoutInitialization()
```
  - getFunctionsManager
```
public WorkplaceFunctionsManager getFunctionsManager()
```
    Description copied from interface: IWorkpageContainer
    
    Each workpage container has one functions manager - managing the function tree(s).
    
    Specified by:
    
    getFunctionsManager in interface IWorkpageContainer
  - getPerspectiveManagerWithoutInitialization
```
public WorkplacePerspectiveManager getPerspectiveManagerWithoutInitialization()
```
  - getPerspectiveManager
```
public WorkplacePerspectiveManager getPerspectiveManager()
```
  - getFunctionSearchUI
```
public WorkplaceFunctionSearchUI getFunctionSearchUI()
```
    Description copied from interface: IWorkpageContainer
    
    Page bean for searching functions within the current function tree.
    
    Specified by:
    
    getFunctionSearchUI in interface IWorkpageContainer
  - getSubWorkpageContainers
```
public WorkpageContainer.SubWorkpageContainers getSubWorkpageContainers()
```
  - getSubContainers
```
public java.util.Map<java.lang.String,? extends IWorkpageContainer> getSubContainers()
```
    Description copied from interface: IWorkpageContainer
    
    A workplace may have several workpage containers - each of them holding workpages. Internally there is one top workpage container (the own with IWorkpageContainer.getOwnSubContainerId() returning null), which owns sub containers (each of them returning an explicit id/name in IWorkpageContainer.getOwnSubContainerId().
    
    Specified by:
    
    getSubContainers in interface IWorkpageContainer
  - getOpenWorkpagePopupsAsFrame
```
public boolean getOpenWorkpagePopupsAsFrame()
```
    Specified by:
    
    getOpenWorkpagePopupsAsFrame in interface IWorkpageContainer
  - setOpenWorkpagePopupsAsFrame
```
public void setOpenWorkpagePopupsAsFrame(boolean value)
```
    Description copied from interface: IWorkpageContainer
    
    By default isolated workpages are opened as dialog. Dialogs do not appear within the task bar of the operating system - and do not allow to be pushed behind the workplace page. - If passing "true" as parameter then isolated workpages are opened as frame - i.e. they are a fully featured window that appears in the task bar of the operating system as well and that can be pushed into the background by the user.
    
    Specified by:
    
    setOpenWorkpagePopupsAsFrame in interface IWorkpageContainer
  - getOwnSubContainerId
```
public java.lang.String getOwnSubContainerId()
```
    Description copied from interface: IWorkpageContainer
    
    A workplace may contain several workpage containers. The main workpage container is started with an id of null. All other ones do own some id. The id is either set in the configuration of the workplace or - if the workpage container is created at runtime - is created by the workplace management internally.
    
    Specified by:
    
    getOwnSubContainerId in interface IWorkpageContainer
  - getRootWorkpageContainer
```
public WorkpageContainer getRootWorkpageContainer()
```
  - getDefaultPopupWidth
```
public int getDefaultPopupWidth()
```
  - setDefaultPopupWidth
```
public void setDefaultPopupWidth(int defaultPopupWidth)
```
    Defines the width of the popup when isolating a workpage into a window of its own.
    
    Specified by:
    
    setDefaultPopupWidth in interface IWorkpageContainer
  - getDefaultPopupHeight
```
public int getDefaultPopupHeight()
```
  - setDefaultPopupHeight
```
public void setDefaultPopupHeight(int defaultPopupHeight)
```
    Defines the height of the popup when isolating a workpage into a window of its own.
    
    Specified by:
    
    setDefaultPopupHeight in interface IWorkpageContainer
  - getUpdateOnInnerEventOnly
```
public boolean getUpdateOnInnerEventOnly()
```
  - setUpdateOnInnerEventOnly
```
public void setUpdateOnInnerEventOnly(boolean value)
```
    Description copied from interface: IWorkpageContainer
    
    If set to true, then a workpage is only updated on an event that is coming from the workpage itself. This corresponds to ROWINCLUDE-UPDATEONINNEREVENTONLY attribute. - Default is "false". You may set to "true" for performance reasons, but need then to handle cases of cross workpage synchronization on your own. Please check documentation of ROWINCLUDE for more information.
    
    Specified by:
    
    setUpdateOnInnerEventOnly in interface IWorkpageContainer
  - setEmptyPage
```
public void setEmptyPage(java.lang.String jspPage)
```
    Description copied from interface: IWorkpageContainer
    
    The page that is shown when no workpage is available within the workpage container.
    
    Specified by:
    
    setEmptyPage in interface IWorkpageContainer
  - getWpim
```
public WorkpageContainer.WorkpageInfoMap getWpim()
```
  - getSubWorkpageContainerIdForWorkpage
```
public java.lang.String getSubWorkpageContainerIdForWorkpage(IWorkpage workpage)
```
    Description copied from interface: IWorkpageContainer
    
    A workpage container may be separated into sub-workpage containers. This functions returns back the id of the sub workpage container. If the workpage is running in the main workpage container, then null is returned.
    
    Specified by:
    
    getSubWorkpageContainerIdForWorkpage in interface IWorkpageContainer
  - setMaxNumberOfWorkpages
```
public void setMaxNumberOfWorkpages(int maxNumberOfWorkpages)
```
    Description copied from interface: IWorkpageContainer
    
    With this method you may restrict the number of parallelly running workpages to a certain limit. If not set then any number of workpages can be opened.
    
    Specified by:
    
    setMaxNumberOfWorkpages in interface IWorkpageContainer
  - setMaxNumberOfWorkpagesExceededMessage
```
public void setMaxNumberOfWorkpagesExceededMessage(java.lang.String message)
```
    Description copied from interface: IWorkpageContainer
    
    This is the message that is popped up once a user exceeds the limit of "maxNumberOfWorkpages". By default an own message is shown, but you can define your own one using this method.
    
    Specified by:
    
    setMaxNumberOfWorkpagesExceededMessage in interface IWorkpageContainer
  - moveIsolatedWorkpageBackIntoContentArea
```
public void moveIsolatedWorkpageBackIntoContentArea(IWorkpage workpage)
```
    Description copied from interface: IWorkpageContainer
    
    Brings back a workpage that is isolated as modeless popup back into its content area.
    
    Specified by:
    
    moveIsolatedWorkpageBackIntoContentArea in interface IWorkpageContainer
  - moveWorkpageIntoContentArea
```
public void moveWorkpageIntoContentArea(IWorkpage workpage)
```
    Take a page from modeless display back into content area.
    
    Specified by:
    
    moveWorkpageIntoContentArea in interface IWorkpageContainer
  - maximizeWorkpage
```
public void maximizeWorkpage(IWorkpage workpage,
                             boolean value)
```
    Description copied from interface: IWorkpageContainer
    
    Maximize size of workpage.
    
    Specified by:
    
    maximizeWorkpage in interface IWorkpageContainer
  - getFocusCounter
```
public int getFocusCounter()
```
  - addWorkpageAsPopup
```
public ModelessPopup addWorkpageAsPopup(IWorkpage workpage)
```
    Description copied from interface: IWorkpageContainer
    
    Adds the new workpage to the workpage container.
    
    Specified by:
    
    addWorkpageAsPopup in interface IWorkpageContainer
  - addWorkpageAndKeepInBackground
```
public void addWorkpageAndKeepInBackground(IWorkpage workpage)
```
    Description copied from interface: IWorkpageContainer
    
    Adds the new workpage to the workpage container. If there is already one existing workpage then the new workpage is not switched to to the front.
    
    Specified by:
    
    addWorkpageAndKeepInBackground in interface IWorkpageContainer
  - addWorkpageAndKeepInBackgroundLOCAL
```
public void addWorkpageAndKeepInBackgroundLOCAL(IWorkpage workpage)
```
  - addWorkpage
```
public void addWorkpage(IWorkpage workpage)
```
    Description copied from interface: IWorkpageContainer
    
    Adds the new workpage to the workpage container.
    
    Specified by:
    
    addWorkpage in interface IWorkpageContainer
  - getAnimationValue
```
public Trigger getAnimationValue()
```
  - getCurrentJspPage
```
public java.lang.String getCurrentJspPage()
```
  - getEmptyPage
```
public java.lang.String getEmptyPage()
```
    Specified by:
    
    getEmptyPage in interface IWorkpageContainer
  - getContentReplaceForWorkpage
```
public java.lang.String getContentReplaceForWorkpage(IWorkpage wp)
```
  - renderWorkpageNode
```
public void renderWorkpageNode(IWorkpage wp,
                               ROWDYNAMICCONTENTBinding.ComponentNode parentNode,
                               java.lang.String parentNodeId)
```
  - renderPopupMenuIntoNode
```
public void renderPopupMenuIntoNode(IWorkpage wp,
                                    ROWDYNAMICCONTENTBinding.ComponentNode node)
```
  - getCurrentContentReplace
```
public java.lang.String getCurrentContentReplace()
```
  - getContentReplaceNoDrillDown
```
public java.lang.String getContentReplaceNoDrillDown(IWorkpage wp)
```
  - getCurrentContentReplaceNoDrillDown
```
public java.lang.String getCurrentContentReplaceNoDrillDown()
```
  - getCurrentlySelectedWorkpage
```
public IWorkpage getCurrentlySelectedWorkpage()
```
    Description copied from interface: IWorkpageContainer
    
    Returns the workpage that is currently selected within the workpage selector. This function must only be called when using the ROWWORKPAGESELECTOR component.
    
    Specified by:
    
    getCurrentlySelectedWorkpage in interface IWorkpageContainer
  - getCurrentWorkpage
```
public IWorkpage getCurrentWorkpage()
```
    Description copied from interface: IWorkpageContainer
    
    Returns the workpage that is currently shown within the content area of the workplace.
    
    Specified by:
    
    getCurrentWorkpage in interface IWorkpageContainer
  - isCurrentWorkpageDecorated
```
public boolean isCurrentWorkpageDecorated()
```
  - isCurrentWorkpagePopupSupported
```
public boolean isCurrentWorkpagePopupSupported()
```
  - isCurrentWorkpageCloseSupported
```
public boolean isCurrentWorkpageCloseSupported()
```
  - isCurrentWorkpageBlocked
```
public boolean isCurrentWorkpageBlocked()
```
  - getCurrentWorkpageClientNamePopupIcon
```
public java.lang.String getCurrentWorkpageClientNamePopupIcon()
```
  - getCurrentWorkpageClientNameCloseIcon
```
public java.lang.String getCurrentWorkpageClientNameCloseIcon()
```
  - setWithWorkpageDragDrop
```
public void setWithWorkpageDragDrop(boolean withWorkpageDragDrop)
```
    Description copied from interface: IWorkpageContainer
    
    Defines if the user is able to drag/drop workpages in order to shift workpages from one workpage container to the next.
    
    Specified by:
    
    setWithWorkpageDragDrop in interface IWorkpageContainer
  - getWithWorkpageDragDrop
```
public boolean getWithWorkpageDragDrop()
```
    Specified by:
    
    getWithWorkpageDragDrop in interface IWorkpageContainer
  - getWorkpageForUniqueTechnicalId
```
public IWorkpage getWorkpageForUniqueTechnicalId(java.lang.String techId)
```
  - getWorkpageForId
```
public IWorkpage getWorkpageForId(java.lang.String id)
```
    Description copied from interface: IWorkpageContainer
    
    Check if a workpage already is available for a passed workpage id.
    
    Specified by:
    
    getWorkpageForId in interface IWorkpageContainer
  - showAsContentPage
```
protected void showAsContentPage(IWorkpage wp)
```
  - switchToWorkpage
```
public void switchToWorkpage(IWorkpage wp)
```
    Description copied from interface: IWorkpageContainer
    
    Switches to the workpage that is passed as parameter.
    
    Specified by:
    
    switchToWorkpage in interface IWorkpageContainer
  - setTabbedLine
```
public void setTabbedLine(TABBEDLINEComponent tabbedLine)
```
    Internally used,
  - getTabbedLineIndex
```
public int getTabbedLineIndex()
```
  - setTabbedLineIndex
```
public void setTabbedLineIndex(int tabbedLineIndex)
```
  - getTabbedLineEnabled
```
public boolean getTabbedLineEnabled()
```
  - setWorkpageSelectorEnabled
```
public void setWorkpageSelectorEnabled(IWorkpage workpage,
                                       boolean tabbedLineEnabled)
```
    Description copied from interface: IWorkpageContainer
    
    You may disable/enable the tab-navigation of a workpage's tabbed line.
    
    Specified by:
    
    setWorkpageSelectorEnabled in interface IWorkpageContainer
  - getEnabledCloseAll
```
public boolean getEnabledCloseAll()
```
  - getEnabledCloseAllLeft
```
public boolean getEnabledCloseAllLeft()
```
  - getEnabledCloseAllRight
```
public boolean getEnabledCloseAllRight()
```
  - getEnabledCloseOthers
```
public boolean getEnabledCloseOthers()
```
  - onTabbedLineTabAction
```
public void onTabbedLineTabAction(ActionEvent ae)
```
  - onSwitchToLeft
```
public void onSwitchToLeft(ActionEvent ae)
```
  - onSwitchToRight
```
public void onSwitchToRight(ActionEvent ae)
```
  - onCloseAllWorkpages
```
public void onCloseAllWorkpages(ActionEvent ae)
```
  - onTabbedLineAction
```
public void onTabbedLineAction(ActionEvent ae)
```
  - moveWorkpage
```
public void moveWorkpage(java.lang.String wpTechId,
                         java.lang.String toWorkpageContainerId)
```
    Moves an existing workpage into an other workpage container.
    
    Parameters:
    
    wpTechId - (Technical) id of the workpage.
    
    workpageContainerId - Workpage container id, into which the workpage needs to be moved.
  - moveWorkpage
```
public void moveWorkpage(IWorkpage wp,
                         WorkpageContainer toWpc)
```
  - closeAllWorkpages
```
public void closeAllWorkpages()
```
    Description copied from interface: IWorkpageContainer
    
    Closes all workpages using the forced mode for closing. This means before calling this method you should inform the user that all data changes within the workpaged get lost.
    
    Specified by:
    
    closeAllWorkpages in interface IWorkpageContainer
  - closeAllWorkpagesBesidesCurrent
```
public void closeAllWorkpagesBesidesCurrent()
```
  - closeAllWorkpagesLeftOfCurrent
```
public void closeAllWorkpagesLeftOfCurrent()
```
  - closeAllWorkpagesRightOfCurrent
```
public void closeAllWorkpagesRightOfCurrent()
```
  - closeAllWorkpages
```
public void closeAllWorkpages(boolean forcedMode,
                              java.lang.Runnable afterCloseOperation)
```
    Description copied from interface: IWorkpageContainer
    
    Closes all workpages. Dependent from the forcedMode the closing will either be done "forced" (i.e. no intervention possible by workpage lifecycle listener) or will be done "normally".
    
    Specified by:
    
    closeAllWorkpages in interface IWorkpageContainer
    
    afterCloseOperation - After closing all workpages you may want a certain operation to be executed - this is the afterCloseOperation. In case of passing parameter "forcedMode" as "true", this operation is immediately run. Otherwise the closing of workpages may be interrupted (e.g. by some workpages asking the user if to save data, or do other things...). In this case the afterCloseOperation is run when all workpages are closed.
  - closeWorkpages
```
public void closeWorkpages(java.util.List<IWorkpage> workpagesToBeClosed,
                           boolean forcedMode,
                           java.lang.Runnable afterCloseOperation)
```
  - onCloseWorkpage
```
public void onCloseWorkpage(ActionEvent ae)
```
  - onCloseCurrentWorkpage
```
public void onCloseCurrentWorkpage(ActionEvent ae)
```
  - onPageAction
```
public void onPageAction(ActionEvent ae)
```
  - onOpenCurrentPageAsModelessPopup
```
public void onOpenCurrentPageAsModelessPopup(ActionEvent ae)
```
  - isolateWorkpageIntoModelessPopup
```
public ModelessPopup isolateWorkpageIntoModelessPopup(IWorkpage workpage)
```
    Description copied from interface: IWorkpageContainer
    
    Isolate workpage as modeless popup.
    
    Specified by:
    
    isolateWorkpageIntoModelessPopup in interface IWorkpageContainer
  - closeWorkpage
```
public void closeWorkpage(IWorkpage workpage,
                          boolean alsoCloseWorkpageWithNoCloseSupported)
```
    Description copied from interface: IWorkpageContainer
    
    Same as IWorkpageContainer.closeWorkpage(IWorkpage) with additional parameter to check what to do with workpages that are defined to be without support of closing (i.e. inteface IWorkpage.isCloseSupported() returns false.
    
    Specified by:
    
    closeWorkpage in interface IWorkpageContainer
  - closeWorkpage
```
public void closeWorkpage(IWorkpage workpage)
```
    Description copied from interface: IWorkpageContainer
    
    Closes a workpage. This is the official way to close a workpage - going through the workpage container. Do not close a page on workplage level.
    
    Specified by:
    
    closeWorkpage in interface IWorkpageContainer
  - closeWorkpageForced
```
public void closeWorkpageForced(IWorkpage workpage,
                                boolean alsoCloseWorkpageWithNoCloseSupported)
```
    Description copied from interface: IWorkpageContainer
    
    Same as IWorkpageContainer.closeWorkpageForced(IWorkpage) with additional parameter to check what to do with workpages that are defined to be without support of closing (i.e. inteface IWorkpage.isCloseSupported() returns false.
    
    Specified by:
    
    closeWorkpageForced in interface IWorkpageContainer
  - closeWorkpageForced
```
public void closeWorkpageForced(IWorkpage workpage)
```
    Description copied from interface: IWorkpageContainer
    
    Closes a workpage - forced mode. The application must not ask for unsaved data etc. anymore.
    
    Specified by:
    
    closeWorkpageForced in interface IWorkpageContainer
  - onHideAllPopups
```
public void onHideAllPopups(ActionEvent ae)
```
  - checkIfWorkpageIsOpenedInPopup
```
public boolean checkIfWorkpageIsOpenedInPopup(IWorkpage workpage)
```
    Specified by:
    
    checkIfWorkpageIsOpenedInPopup in interface IWorkpageContainer
  - getAllWorkpages
```
public java.util.List<IWorkpage> getAllWorkpages()
```
    Description copied from interface: IWorkpageContainer
    
    Returns list of all workpages the user has currently opened in the current workpage container. - Please note: there may be (better: there typically are) mulitple workpage containers, each one holding workpages.
    
    Specified by:
    
    getAllWorkpages in interface IWorkpageContainer
  - getAllWorkpagesIncludingSubWorkpageContainers
```
public java.util.List<IWorkpage> getAllWorkpagesIncludingSubWorkpageContainers()
```
    Description copied from interface: IWorkpageContainer
    
    Returns list of all workpages, but now not restricted to "this" container, but to "this" container and the ones that are kept below.
    
    Specified by:
    
    getAllWorkpagesIncludingSubWorkpageContainers in interface IWorkpageContainer
  - removeWorkpageInfo
```
public void removeWorkpageInfo(IWorkpage workpage)
```
  - throwWorkpageProcessingEvent
```
public void throwWorkpageProcessingEvent(WorkpageProcessingEvent event)
```
    Description copied from interface: IWorkpageContainer
    
    Throws an event and triggers the delegation of the event to all other workpage instances.
    
    Specified by:
    
    throwWorkpageProcessingEvent in interface IWorkpageContainer
  - exportCurrentWorkpages
```
public java.util.List<WorkpageStartInfo> exportCurrentWorkpages()
```
    Exports all workpages that were started via IWorkpageStartInfo into one list. This list can be used for restarting the workpages later on.
    
    Specified by:
    
    exportCurrentWorkpages in interface IWorkpageContainer

Class WorkpageContainer

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

WorkpageContainer

WorkpageContainer

Method Detail

initialize

initImplicitLoadingForCurrentUser

prepareWorkplaceForCurrentUser

setRendererClassName

getRendererClassName

getDynMenuContent

getRenderer

getHistory

setHistory

getWorkpagePopupDefaultBgpaint

setWorkpagePopupDefaultBgpaint

getHotKeyIsolation

setHotKeyIsolation

getShowPopupWorkpagesInSelector

setShowPopupWorkpagesInSelector

getWithTabSelectorCloseIcons

setWithTabSelectorCloseIcons

getWorkpageDispatcher

getUniqueId

addWorkpageContainerListener

removeWorkpageContainerListener

getWorkpageContainerListeners

getTileManagerWithoutInitialization

getTileManager

getFunctionsManagerWithoutInitialization

getFunctionsManager

getPerspectiveManagerWithoutInitialization

getPerspectiveManager

getFunctionSearchUI

getSubWorkpageContainers

getSubContainers

getOpenWorkpagePopupsAsFrame

setOpenWorkpagePopupsAsFrame

getOwnSubContainerId

getRootWorkpageContainer

getDefaultPopupWidth

setDefaultPopupWidth

getDefaultPopupHeight

setDefaultPopupHeight

getUpdateOnInnerEventOnly

setUpdateOnInnerEventOnly

setEmptyPage

getWpim

getSubWorkpageContainerIdForWorkpage

setMaxNumberOfWorkpages

setMaxNumberOfWorkpagesExceededMessage

moveIsolatedWorkpageBackIntoContentArea

moveWorkpageIntoContentArea

maximizeWorkpage

getFocusCounter

addWorkpageAsPopup

addWorkpageAndKeepInBackground

addWorkpageAndKeepInBackgroundLOCAL

addWorkpage

getAnimationValue

getCurrentJspPage

getEmptyPage

getContentReplaceForWorkpage

renderWorkpageNode

renderPopupMenuIntoNode

getCurrentContentReplace

getContentReplaceNoDrillDown

getCurrentContentReplaceNoDrillDown

getCurrentlySelectedWorkpage

getCurrentWorkpage

isCurrentWorkpageDecorated

isCurrentWorkpagePopupSupported

isCurrentWorkpageCloseSupported

isCurrentWorkpageBlocked

getCurrentWorkpageClientNamePopupIcon

getCurrentWorkpageClientNameCloseIcon