org.eclnt.workplace

## Class WorkpageContainer

- 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`

Copyright © CaptainCasa Gmbh. All Rights Reserved.