@itwin/appui-react 3.0.0-dev.100

package/lib/esm/appui-react/frontstage/FrontstageDef.js

@@ -0,0 +1,654 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Frontstage
+ */
+// cSpell:ignore popout
+import * as React from "react";
+import { IModelApp } from "@itwin/core-frontend";
+import { StagePanelLocation, StageUsage, UiError } from "@itwin/appui-abstract";
+import { dockWidgetContainer, findTab, findWidget, floatWidget, isFloatingLocation, isPopoutLocation, isPopoutWidgetLocation, popoutWidgetToChildWindow, setFloatingWidgetContainerBounds, } from "@itwin/appui-layout-react";
+import { ContentGroupProvider } from "../content/ContentGroup";
+import { ContentLayoutManager } from "../content/ContentLayoutManager";
+import { ContentViewManager } from "../content/ContentViewManager";
+import { UiFramework } from "../UiFramework";
+import { ZoneLocation } from "../zones/Zone";
+import { Frontstage } from "./Frontstage";
+import { FrontstageManager } from "./FrontstageManager";
+import { TimeTracker } from "../configurableui/TimeTracker";
+import { PopoutWidget } from "../childwindow/PopoutWidget";
+import { setImmediate } from "timers";
+import { saveFrontstagePopoutWidgetSizeAndPosition } from "../widget-panels/Frontstage";
+import { BentleyStatus } from "@itwin/core-bentley";
+/** FrontstageDef class provides an API for a Frontstage.
+ * @public
+ */
+export class FrontstageDef {
+    constructor() {
+        this._id = "";
+        this._defaultContentId = "";
+        this._isInFooterMode = true;
+        this._isStageClosing = false;
+        this._isApplicationClosing = false;
+        this._version = 0;
+        this._timeTracker = new TimeTracker();
+    }
+    get id() { return this._id; }
+    get defaultTool() { return this._defaultTool; }
+    get defaultContentId() { return this._defaultContentId; }
+    get isInFooterMode() { return this._isInFooterMode; }
+    get applicationData() { return this._applicationData; }
+    get usage() { return this._usage !== undefined ? this._usage : StageUsage.General; }
+    get version() { return this._version; }
+    get contentGroupProvider() { return this._contentGroupProvider; }
+    get topLeft() { return this._topLeft; }
+    get topCenter() { return this._topCenter; }
+    get topRight() { return this._topRight; }
+    get centerLeft() { return this._centerLeft; }
+    get centerRight() { return this._centerRight; }
+    get bottomLeft() { return this._bottomLeft; }
+    get bottomCenter() { return this._bottomCenter; }
+    get bottomRight() { return this._bottomRight; }
+    /** @beta */
+    get topPanel() { return this._topPanel; }
+    /** @beta
+     * @deprecated Only topPanel is supported in UI 2.0 */
+    get topMostPanel() { return this._topMostPanel; }
+    /** @beta */
+    get leftPanel() { return this._leftPanel; }
+    /** @beta */
+    get rightPanel() { return this._rightPanel; }
+    /** @beta */
+    get bottomPanel() { return this._bottomPanel; }
+    /** @beta
+     * @deprecated Only bottomPanel is supported in UI 2.0  */
+    get bottomMostPanel() { return this._bottomMostPanel; }
+    get contentLayoutDef() { return this._contentLayoutDef; }
+    get contentGroup() { return this._contentGroup; }
+    get frontstageProvider() { return this._frontstageProvider; }
+    /** @internal */
+    get nineZone() { return this._nineZone; } // istanbul ignore next
+    set nineZone(props) { this._nineZone = props; }
+    /** @internal */
+    get nineZoneState() { return this._nineZoneState; }
+    set nineZoneState(state) {
+        if (this._nineZoneState === state)
+            return;
+        this._nineZoneState = state;
+        // istanbul ignore else
+        if (!(this._isStageClosing || this._isApplicationClosing)) {
+            FrontstageManager.onFrontstageNineZoneStateChangedEvent.emit({
+                frontstageDef: this,
+                state,
+            });
+        }
+    }
+    /** @internal */
+    get timeTracker() { return this._timeTracker; }
+    /** Created a [[FrontstageDef]] and initialize it */
+    static async create(provider) {
+        const def = new FrontstageDef();
+        def._frontstageProvider = provider;
+        // istanbul ignore else
+        if (provider.frontstage.props)
+            await def.initializeFromProps(provider.frontstage.props);
+        return def;
+    }
+    /** Handles when the Frontstage becomes activated */
+    async _onActivated() { }
+    /** Handles when the Frontstage becomes activated */
+    async onActivated() {
+        this.updateWidgetDefs();
+        if (this._contentGroupProvider && this._initialProps) {
+            this._contentGroup = await this._contentGroupProvider.provideContentGroup(this._initialProps);
+        }
+        // istanbul ignore next
+        if (!this._contentGroup)
+            throw new UiError(UiFramework.loggerCategory(this), `onActivated: Content Group not defined`);
+        this._contentLayoutDef = ContentLayoutManager.getLayoutForGroup(this._contentGroup);
+        FrontstageManager.onContentLayoutActivatedEvent.emit({ contentLayout: this._contentLayoutDef, contentGroup: this._contentGroup });
+        this._timeTracker.startTiming();
+        await this._onActivated();
+    }
+    /** Handles when the Frontstage becomes inactive */
+    async _onDeactivated() { }
+    /** Handles when the Frontstage becomes inactive */
+    async onDeactivated() {
+        for (const control of this._widgetControls) {
+            control.onFrontstageDeactivated();
+        }
+        for (const control of this.contentControls) {
+            control.onFrontstageDeactivated();
+        }
+        // istanbul ignore else
+        if (this.contentGroup)
+            this.contentGroup.onFrontstageDeactivated();
+        if (this.contentGroupProvider)
+            await this.contentGroupProvider.onFrontstageDeactivated();
+        this._timeTracker.stopTiming();
+        this._isStageClosing = true; // this keeps widgets in child windows from automatically re-docking
+        UiFramework.childWindowManager.closeAllChildWindows();
+        await this._onDeactivated();
+        this._isStageClosing = false;
+    }
+    /** @internal */
+    setIsApplicationClosing(value) {
+        this._isApplicationClosing = value;
+    }
+    /** Returns once the contained widgets and content controls are ready to use */
+    async waitUntilReady() {
+        // create an array of control-ready promises
+        const controlReadyPromises = new Array();
+        this._widgetControls.forEach((control) => {
+            controlReadyPromises.push(control.isReady);
+        });
+        // istanbul ignore else
+        if (this.contentLayoutDef) {
+            const usedContentIndexes = this.contentLayoutDef.getUsedContentIndexes();
+            this.contentControls.forEach((control, index) => {
+                // istanbul ignore else
+                if (usedContentIndexes.includes(index))
+                    controlReadyPromises.push(control.isReady);
+            });
+        }
+        await Promise.all(controlReadyPromises);
+        // Frontstage ready
+    }
+    /** Handles when the Frontstage becomes active */
+    _onFrontstageReady() { }
+    /** Handles when the Frontstage becomes active */
+    onFrontstageReady() {
+        for (const control of this._widgetControls) {
+            control.onFrontstageReady();
+        }
+        for (const control of this.contentControls) {
+            control.onFrontstageReady();
+        }
+        // istanbul ignore else
+        if (this.contentGroup)
+            this.contentGroup.onFrontstageReady();
+        this._onFrontstageReady();
+    }
+    /** Starts the default tool for the Frontstage */
+    startDefaultTool() {
+        // Start the default tool
+        // istanbul ignore next
+        if (this.defaultTool && IModelApp.toolAdmin && IModelApp.viewManager) {
+            IModelApp.toolAdmin.defaultToolId = this.defaultTool.toolId;
+            this.defaultTool.execute();
+        }
+    }
+    /** Sets the Content Layout and Content Group */
+    setContentLayoutAndGroup(contentLayoutDef, contentGroup) {
+        this._contentLayoutDef = contentLayoutDef;
+        this._contentGroup = contentGroup;
+    }
+    /** Sets the active view content control to the default or first */
+    async setActiveContent() {
+        let contentControl;
+        let activated = false;
+        if (this.contentGroup && this.defaultContentId) {
+            contentControl = this.contentGroup.getContentControlById(this.defaultContentId);
+        }
+        // istanbul ignore else
+        if (!contentControl && this.contentControls.length >= 0) {
+            contentControl = this.contentControls[0];
+        }
+        if (contentControl) {
+            ContentViewManager.setActiveContent(contentControl.reactNode, true);
+            if (contentControl.viewport) {
+                const status = await IModelApp.viewManager.setSelectedView(contentControl.viewport);
+                activated = status === BentleyStatus.SUCCESS;
+            }
+        }
+        return activated;
+    }
+    /** Sets the active view content control */
+    setActiveView(newContent, oldContent) {
+        if (oldContent)
+            oldContent.onDeactivated();
+        newContent.onActivated();
+        FrontstageManager.onContentControlActivatedEvent.emit({ activeContentControl: newContent, oldContentControl: oldContent });
+    }
+    /** Sets the active view content control based on the selected viewport. */
+    setActiveViewFromViewport(viewport) {
+        const contentControl = this.contentControls.find((control) => control.viewport === viewport);
+        // istanbul ignore else
+        if (contentControl) {
+            ContentViewManager.setActiveContent(contentControl.reactNode, true);
+            return true;
+        }
+        // istanbul ignore next
+        return false;
+    }
+    /** Gets a [[ZoneDef]] based on a given zone id */
+    getZoneDef(zoneId) {
+        let zoneDef;
+        switch (zoneId) {
+            case 1:
+                zoneDef = this.topLeft;
+                break;
+            case 2:
+                zoneDef = this.topCenter;
+                break;
+            case 3:
+                zoneDef = this.topRight;
+                break;
+            case 4:
+                zoneDef = this.centerLeft;
+                break;
+            case 6:
+                zoneDef = this.centerRight;
+                break;
+            case 7:
+                zoneDef = this.bottomLeft;
+                break;
+            case 8:
+                zoneDef = this.bottomCenter;
+                break;
+            case 9:
+                zoneDef = this.bottomRight;
+                break;
+            // istanbul ignore next
+            default:
+                throw new RangeError();
+        }
+        // Zones can be undefined in a Frontstage
+        return zoneDef;
+    }
+    /** Gets a list of [[ZoneDef]]s */
+    get zoneDefs() {
+        const zones = [1, 2, 3, 4, 6, 7, 8, 9];
+        const zoneDefs = [];
+        zones.forEach((zoneId) => {
+            const zoneDef = this.getZoneDef(zoneId);
+            if (zoneDef)
+                zoneDefs.push(zoneDef);
+        });
+        return zoneDefs;
+    }
+    /** Gets a [[StagePanelDef]] based on a given panel location
+     * @beta
+     */
+    getStagePanelDef(location) {
+        let panelDef;
+        switch (location) {
+            case StagePanelLocation.Top:
+                panelDef = this.topPanel;
+                break;
+            case StagePanelLocation.TopMost:
+                panelDef = this.topMostPanel; // eslint-disable-line deprecation/deprecation
+                break;
+            case StagePanelLocation.Left:
+                panelDef = this.leftPanel;
+                break;
+            case StagePanelLocation.Right:
+                panelDef = this.rightPanel;
+                break;
+            case StagePanelLocation.Bottom:
+                panelDef = this.bottomPanel;
+                break;
+            case StagePanelLocation.BottomMost:
+                panelDef = this.bottomMostPanel; // eslint-disable-line deprecation/deprecation
+                break;
+            // istanbul ignore next
+            default:
+                throw new RangeError();
+        }
+        // Panels can be undefined in a Frontstage
+        return panelDef;
+    }
+    /** Gets a list of [[StagePanelDef]]s
+     * @beta
+     */
+    get panelDefs() {
+        const panels = [
+            StagePanelLocation.Left, StagePanelLocation.Right,
+            StagePanelLocation.Top, StagePanelLocation.TopMost,
+            StagePanelLocation.Bottom, StagePanelLocation.BottomMost,
+        ];
+        const panelDefs = [];
+        panels.forEach((location) => {
+            const panelDef = this.getStagePanelDef(location);
+            if (panelDef)
+                panelDefs.push(panelDef);
+        });
+        return panelDefs;
+    }
+    /** Finds a [[WidgetDef]] based on a given id */
+    findWidgetDef(id) {
+        for (const zoneDef of this.zoneDefs) {
+            const widgetDef = zoneDef.findWidgetDef(id);
+            if (widgetDef)
+                return widgetDef;
+        }
+        for (const panelDef of this.panelDefs) {
+            const widgetDef = panelDef.findWidgetDef(id);
+            if (widgetDef)
+                return widgetDef;
+        }
+        // istanbul ignore next
+        return undefined;
+    }
+    /** Gets the list of [[WidgetControl]]s */
+    get _widgetControls() {
+        const widgetControls = new Array();
+        this.zoneDefs.forEach((zoneDef) => {
+            zoneDef.widgetDefs.forEach((widgetDef) => {
+                const widgetControl = widgetDef.widgetControl;
+                if (widgetControl)
+                    widgetControls.push(widgetControl);
+            });
+        });
+        this.panelDefs.forEach((panelDef) => {
+            panelDef.widgetDefs.forEach((widgetDef) => {
+                const widgetControl = widgetDef.widgetControl;
+                // istanbul ignore if
+                if (widgetControl)
+                    widgetControls.push(widgetControl);
+            });
+        });
+        return widgetControls;
+    }
+    /** Gets the list of [[ContentControl]]s */
+    get contentControls() {
+        // istanbul ignore else
+        if (this.contentGroup) {
+            return this.contentGroup.getContentControls();
+        }
+        else {
+            return [];
+        }
+    }
+    /** Initializes a FrontstageDef from FrontstageProps
+     * @internal
+     */
+    async initializeFromProps(props) {
+        this._id = props.id;
+        this._initialProps = props;
+        this._defaultTool = props.defaultTool;
+        if (props.defaultContentId !== undefined)
+            this._defaultContentId = props.defaultContentId;
+        if (props.contentGroup instanceof ContentGroupProvider) {
+            this._contentGroupProvider = props.contentGroup;
+        }
+        else {
+            this._contentGroup = props.contentGroup;
+        }
+        if (props.isInFooterMode !== undefined)
+            this._isInFooterMode = props.isInFooterMode;
+        if (props.applicationData !== undefined)
+            this._applicationData = props.applicationData;
+        this._usage = props.usage;
+        this._version = props.version || 0;
+        // eslint-disable-next-line deprecation/deprecation
+        this._topLeft = Frontstage.createZoneDef(props.contentManipulationTools ? props.contentManipulationTools : props.topLeft, ZoneLocation.TopLeft, props);
+        // eslint-disable-next-line deprecation/deprecation
+        this._topCenter = Frontstage.createZoneDef(props.toolSettings ? props.toolSettings : props.topCenter, ZoneLocation.TopCenter, props);
+        // eslint-disable-next-line deprecation/deprecation
+        this._topRight = Frontstage.createZoneDef(props.viewNavigationTools ? /* istanbul ignore next */ props.viewNavigationTools : props.topRight, ZoneLocation.TopRight, props);
+        // eslint-disable-next-line deprecation/deprecation
+        this._centerLeft = Frontstage.createZoneDef(props.centerLeft, ZoneLocation.CenterLeft, props);
+        // eslint-disable-next-line deprecation/deprecation
+        this._centerRight = Frontstage.createZoneDef(props.centerRight, ZoneLocation.CenterRight, props);
+        // eslint-disable-next-line deprecation/deprecation
+        this._bottomLeft = Frontstage.createZoneDef(props.bottomLeft, ZoneLocation.BottomLeft, props);
+        // eslint-disable-next-line deprecation/deprecation
+        this._bottomCenter = Frontstage.createZoneDef(props.statusBar ? props.statusBar : props.bottomCenter, ZoneLocation.BottomCenter, props);
+        // eslint-disable-next-line deprecation/deprecation
+        this._bottomRight = Frontstage.createZoneDef(props.bottomRight, ZoneLocation.BottomRight, props);
+        // eslint-disable-next-line deprecation/deprecation
+        this._topPanel = Frontstage.createStagePanelDef(StagePanelLocation.Top, props);
+        this._topMostPanel = Frontstage.createStagePanelDef(StagePanelLocation.TopMost, props);
+        this._leftPanel = Frontstage.createStagePanelDef(StagePanelLocation.Left, props);
+        this._rightPanel = Frontstage.createStagePanelDef(StagePanelLocation.Right, props);
+        this._bottomPanel = Frontstage.createStagePanelDef(StagePanelLocation.Bottom, props);
+        this._bottomMostPanel = Frontstage.createStagePanelDef(StagePanelLocation.BottomMost, props);
+    }
+    /** @internal */
+    updateWidgetDefs() {
+        // Tracks provided widgets to prevent duplicates.
+        const widgetDefs = [];
+        // Process panels before zones so in uiVersion="2" extension can explicitly target a widget for a StagePanelSection
+        this.panelDefs.forEach((panelDef) => {
+            panelDef.updateDynamicWidgetDefs(this.id, this.usage, panelDef.location, undefined, widgetDefs, this.applicationData);
+        });
+        this.zoneDefs.forEach((zoneDef) => {
+            zoneDef.updateDynamicWidgetDefs(this.id, this.usage, zoneDef.zoneLocation, undefined, widgetDefs, this.applicationData);
+        });
+    }
+    /** @beta */
+    restoreLayout() {
+        for (const zoneDef of this.zoneDefs) {
+            for (const widgetDef of zoneDef.widgetDefs) {
+                widgetDef.setWidgetState(widgetDef.defaultState);
+            }
+        }
+        for (const panelDef of this.panelDefs) {
+            panelDef.size = panelDef.defaultSize;
+            panelDef.panelState = panelDef.defaultState;
+            for (const widgetDef of panelDef.widgetDefs) {
+                widgetDef.setWidgetState(widgetDef.defaultState);
+            }
+        }
+        FrontstageManager.onFrontstageRestoreLayoutEvent.emit({ frontstageDef: this });
+    }
+    isPopoutWidget(widgetId) {
+        // istanbul ignore else
+        if (this.nineZoneState) {
+            const location = findTab(this.nineZoneState, widgetId);
+            // istanbul ignore else
+            if (location)
+                return isPopoutLocation(location);
+        }
+        return false;
+    }
+    isFloatingWidget(widgetId) {
+        // istanbul ignore else
+        if (this.nineZoneState) {
+            const location = findTab(this.nineZoneState, widgetId);
+            // istanbul ignore else
+            if (location)
+                return isFloatingLocation(location);
+        }
+        return false;
+    }
+    /** Create a new floating panel that contains the widget specified by its Id. Supported only when in
+     *  UI 2.0 or higher.
+     * @param widgetId case sensitive Widget Id
+     * @param point Position of top left corner of floating panel in pixels. If undefined {x:50, y:100} is used.
+     * @param size defines the width and height of the floating panel. If undefined and widget has been floated before
+     * the previous size is used, else {height:400, width:400} is used.
+     * @beta
+     */
+    floatWidget(widgetId, point, size) {
+        // istanbul ignore else
+        if (this.nineZoneState) {
+            const location = findTab(this.nineZoneState, widgetId);
+            if (location) {
+                let popoutWidgetContainerId;
+                if (isPopoutLocation(location)) {
+                    popoutWidgetContainerId = location.popoutWidgetId;
+                }
+                const state = floatWidget(this.nineZoneState, widgetId, point, size);
+                // istanbul ignore else
+                if (state) {
+                    this.nineZoneState = state;
+                    setTimeout(() => {
+                        popoutWidgetContainerId && UiFramework.childWindowManager.closeChildWindow(popoutWidgetContainerId, true);
+                    }, 600);
+                }
+            }
+        }
+    }
+    /** Opens window for specified PopoutWidget container. Used to reopen popout when running in Electron.
+     * @internal */
+    openPopoutWidgetContainer(state, widgetContainerId) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const location = findWidget(state, widgetContainerId);
+        // istanbul ignore else
+        if (location && isPopoutWidgetLocation(location) && 1 === state.widgets[widgetContainerId].tabs.length) {
+            // NOTE: Popout Widget Container will only contain a single WidgetTab
+            const widgetDef = this.findWidgetDef(state.widgets[widgetContainerId].tabs[0]);
+            // istanbul ignore else
+            if (widgetDef) {
+                const tab = state.tabs[widgetDef.id];
+                const popoutContent = (React.createElement(PopoutWidget, { widgetContainerId: widgetContainerId, widgetDef: widgetDef }));
+                const position = {
+                    width: (_b = (_a = tab.preferredPopoutWidgetSize) === null || _a === void 0 ? void 0 : _a.width) !== null && _b !== void 0 ? _b : 600,
+                    height: (_d = (_c = tab.preferredPopoutWidgetSize) === null || _c === void 0 ? void 0 : _c.height) !== null && _d !== void 0 ? _d : 800,
+                    left: (_f = (_e = tab.preferredPopoutWidgetSize) === null || _e === void 0 ? void 0 : _e.x) !== null && _f !== void 0 ? _f : 0,
+                    top: (_h = (_g = tab.preferredPopoutWidgetSize) === null || _g === void 0 ? void 0 : _g.y) !== null && _h !== void 0 ? _h : 0,
+                };
+                UiFramework.childWindowManager.openChildWindow(widgetContainerId, widgetDef.label, popoutContent, position, UiFramework.useDefaultPopoutUrl);
+            }
+        }
+    }
+    /** Create a new popout/child window that contains the widget specified by its Id. Supported only when in
+     *  UI 2.0 or higher.
+     * @param widgetId case sensitive Widget Id
+     * @param point Position of top left corner of floating panel in pixels. If undefined {x:0, y:0} is used.
+     * @param size defines the width and height of the floating panel. If undefined and widget has been floated before
+     * the previous size is used, else {height:800, width:600} is used.
+     * @beta
+     */
+    popoutWidget(widgetId, point, size) {
+        // istanbul ignore else
+        if (this.nineZoneState) {
+            let location = findTab(this.nineZoneState, widgetId);
+            // istanbul ignore else
+            if (location) {
+                if (isPopoutLocation(location))
+                    return;
+                // get the state to apply that will pop-out the specified WidgetTab to child window.
+                const state = popoutWidgetToChildWindow(this.nineZoneState, widgetId, point, size);
+                // istanbul ignore else
+                if (state) {
+                    // now that the state is updated get the id of the container that houses the widgetTab/widgetId
+                    location = findTab(state, widgetId);
+                    // istanbul ignore else
+                    if (location && isPopoutLocation(location)) {
+                        const widgetDef = this.findWidgetDef(widgetId);
+                        // istanbul ignore else
+                        if (widgetDef) {
+                            const widgetContainerId = location.widgetId;
+                            const tab = state.tabs[widgetId];
+                            this.nineZoneState = state;
+                            setImmediate(() => {
+                                const popoutContent = (React.createElement(PopoutWidget, { widgetContainerId: widgetContainerId, widgetDef: widgetDef }));
+                                const position = {
+                                    width: tab.preferredPopoutWidgetSize.width,
+                                    height: tab.preferredPopoutWidgetSize.height,
+                                    left: tab.preferredPopoutWidgetSize.x,
+                                    top: tab.preferredPopoutWidgetSize.y,
+                                };
+                                UiFramework.childWindowManager.openChildWindow(widgetContainerId, widgetDef.label, popoutContent, position, UiFramework.useDefaultPopoutUrl);
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    get isStageClosing() {
+        return this._isStageClosing;
+    }
+    get isApplicationClosing() {
+        return this._isApplicationClosing;
+    }
+    /** @internal */
+    async saveChildWindowSizeAndPosition(childWindowId, childWindow) {
+        // istanbul ignore else
+        if (this.nineZoneState) {
+            const newState = await saveFrontstagePopoutWidgetSizeAndPosition(this.nineZoneState, this.id, this.version, childWindowId, childWindow);
+            this._nineZoneState = newState; // set without triggering new render as only preferred floating position set
+        }
+    }
+    /** @internal */
+    setFloatingWidgetBoundsInternal(floatingWidgetId, bounds, inhibitNineZoneStateChangedEvent = false) {
+        // istanbul ignore else
+        if (this.nineZoneState) {
+            const newState = setFloatingWidgetContainerBounds(this.nineZoneState, floatingWidgetId, bounds);
+            if (inhibitNineZoneStateChangedEvent)
+                this._nineZoneState = newState; // set without triggering new render
+            else
+                this.nineZoneState = newState;
+        }
+    }
+    /** Method used to possibly change a Popout Widget back to a docked widget if the user was the one closing the popout's child
+     * window (i.e. UiFramework.childWindowManager.isClosingChildWindow === false).
+     *  @internal
+     */
+    dockPopoutWidgetContainer(widgetContainerId) {
+        if (this.nineZoneState) {
+            const location = findWidget(this.nineZoneState, widgetContainerId);
+            // Make sure the widgetContainerId is still in popout state. We don't want to set it to docked if the window is being closed because
+            // an API call has moved the widget from a popout state to a floating state.
+            // istanbul ignore else
+            if (location && isPopoutWidgetLocation(location)) {
+                const state = dockWidgetContainer(this.nineZoneState, widgetContainerId, true);
+                state && (this.nineZoneState = state);
+            }
+        }
+    }
+    /** Finds the container with the specified widget and re-docks all widgets
+     * back to the panel zone location that was used when the floating container
+     * was generated. Supported only when in UI 2.0 or higher.
+     * @param widgetId  case sensitive Widget Id.
+     * @beta
+     */
+    dockWidgetContainer(widgetId) {
+        // istanbul ignore else
+        if (this.nineZoneState) {
+            const location = findTab(this.nineZoneState, widgetId);
+            if (location) {
+                const widgetContainerId = location.widgetId;
+                const state = dockWidgetContainer(this.nineZoneState, widgetContainerId, true);
+                state && (this.nineZoneState = state);
+                if (isPopoutLocation(location)) {
+                    UiFramework.childWindowManager.closeChildWindow(location.widgetId, true);
+                }
+            }
+        }
+    }
+    setFloatingWidgetContainerBounds(floatingWidgetId, bounds) {
+        if (!this.nineZoneState || !(floatingWidgetId in this.nineZoneState.floatingWidgets.byId))
+            return false;
+        this.setFloatingWidgetBoundsInternal(floatingWidgetId, bounds);
+        return true;
+    }
+    getFloatingWidgetContainerIds() {
+        if (!this.nineZoneState)
+            return [];
+        return [...this.nineZoneState.floatingWidgets.allIds];
+    }
+    getFloatingWidgetContainerIdByWidgetId(widgetId) {
+        if (!this.nineZoneState)
+            return undefined;
+        const location = findTab(this.nineZoneState, widgetId);
+        // istanbul ignore else
+        if (location && isFloatingLocation(location)) {
+            return location.floatingWidgetId;
+        }
+        // istanbul ignore next
+        return undefined;
+    }
+    getFloatingWidgetContainerBounds(floatingWidgetId) {
+        if (!floatingWidgetId)
+            return undefined;
+        // istanbul ignore else
+        if (this.nineZoneState && (floatingWidgetId in this.nineZoneState.floatingWidgets.byId)) {
+            const foundWidget = document.querySelector(`div.nz-widget-floatingWidget[data-widget-id='${floatingWidgetId}']`);
+            // istanbul ignore next
+            if (foundWidget) {
+                const domRect = foundWidget.getBoundingClientRect();
+                return { left: domRect.left, right: domRect.right, top: domRect.top, bottom: domRect.bottom };
+            }
+            return this.nineZoneState.floatingWidgets.byId[floatingWidgetId].bounds;
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=FrontstageDef.js.map