@finsemble/finsemble-ui 1.0.0-beta-6 → 1.0.0-beta-9

package/platform/services/window/Docking/dockableWindow.js

@@ -0,0 +1,1239 @@
+import BoxMath from "./boxMath";
+import DockableBox from "./dockableBox";
+import { System } from "../../../../common/system";
+import { checkIfBoundsAreEqual, wrapWithTimeout } from "../../../../common/util";
+import StorageClient from "../../../../clients/storageClient";
+import { clone } from "../../../../common/util";
+import { MOVE_REASON, WINDOWSTATE } from "../../../../common/constants";
+import { adjustBoundsToBeOnMonitorAsync } from "../../../../common/Monitors";
+import { RouterClient } from "../../../../clients/routerClient";
+import { Logger } from "../../../../clients/logger";
+import { defaultDockingOptions, } from "./types";
+import pLimit from "p-limit";
+import uuidv4 from "uuid-random";
+import _throttle from "lodash/throttle";
+const BOUNDS_CHANGING = "bounds-change-request";
+const BOUNDS_CHANGED = "bounds-changed";
+const SYSTEM_BOUNDS_CHANGED = "system-bounds-changed";
+const warningsSent = {
+    disableFrame: false,
+    setOpacity: false,
+    addEventListener: false,
+    removeEventListener: false,
+};
+function NullStandardCallback(err) {
+    err;
+}
+export class DockableWindow extends DockableBox {
+    /**
+     * Do not construct DockableWindow directly. Use the factory
+     *
+     * @param {*} win Window object; WebWindow, ExternalWindow, etc.
+     * @param {bounds} bounds initial bounds for the window.
+     * @param {object} dependencies Dependency object that provides the calculator, System, and Logger.
+     * @param {DockingCalculator} dependencies.calculator
+     * @param {System} dependencies.System
+     * @param {Logger} dependencies.Logger
+     */
+    constructor(win, bounds, calculator) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+        super(bounds);
+        this.snappedWindows = [];
+        this.resizeThrottlePeriod = 5;
+        this.lastBoundsAdjustment = Date.now();
+        // Needed for dockable components that don't have a static grabber on the side of the component (mostly for when there are dockable windows). When a user undocks the component, they can undock it from anywhere in the components header bar, this will center the window on the undock, so that when the window shrinks back to its old size, the mouse will be in the center
+        this.shouldOffsetByMouse = false;
+        this.isDockableComponent = false;
+        this.monitorDockablePositions = {};
+        this.ignoreSnappingRequests = false;
+        this.dockedDimensions = null;
+        this.isHidden = false;
+        this.onboundschanged = 0;
+        this.name = (_a = win.name) !== null && _a !== void 0 ? _a : "undefined";
+        Logger.system.debug("dockableWindow constructing", this.name);
+        this.calculator = calculator;
+        this.win = win;
+        this.bufferSize = 15;
+        this.guid = uuidv4();
+        this.top = bounds.top;
+        this.left = bounds.left;
+        this.right = bounds.right;
+        this.bottom = bounds.bottom;
+        this.width = bounds.width || 0;
+        this.height = bounds.height || 0;
+        this.hasDashbarData = false;
+        this.opacity = 1;
+        this.groupNames = [];
+        this.buildDefaultDockingOptions = this.buildDefaultDockingOptions.bind(this);
+        this.onBoundsChanged = this.onBoundsChanged.bind(this);
+        this.onBoundsChanging = this.onBoundsChanging.bind(this);
+        this.requestBoundsChange = this.requestBoundsChange.bind(this);
+        this.getDockedStringFromLocation = this.getDockedStringFromLocation.bind(this);
+        this.hiddenUnclaimSpace = this.hiddenUnclaimSpace.bind(this);
+        this.unhiddenClaimSpace = this.unhiddenClaimSpace.bind(this);
+        this.onSystemMovedWindow = this.onSystemMovedWindow.bind(this);
+        this.restored = this.restored.bind(this);
+        this.maximized = this.maximized.bind(this);
+        this.dock = this.dock.bind(this);
+        this.undock = this.undock.bind(this);
+        this.animate = this.animatePositionAndHeight;
+        // The default is to allow grouping. But if it is disabled using any of the various methods, disable it.
+        this.canGroup =
+            (_t = (_m = (_f = (_b = win.canGroup) !== null && _b !== void 0 ? _b : (_e = (_d = (_c = win === null || win === void 0 ? void 0 : win.windowDescriptor) === null || _c === void 0 ? void 0 : _c.customData) === null || _d === void 0 ? void 0 : _d.window) === null || _e === void 0 ? void 0 : _e.canGroup) !== null && _f !== void 0 ? _f : (_l = (_k = (_j = (_h = (_g = win === null || win === void 0 ? void 0 : win.windowDescriptor) === null || _g === void 0 ? void 0 : _g.customData) === null || _h === void 0 ? void 0 : _h.foreign) === null || _j === void 0 ? void 0 : _j.services) === null || _k === void 0 ? void 0 : _k.dockingService) === null || _l === void 0 ? void 0 : _l.canGroup) !== null && _m !== void 0 ? _m : (_s = (_r = (_q = (_p = (_o = win === null || win === void 0 ? void 0 : win.windowDescriptor) === null || _o === void 0 ? void 0 : _o.customData) === null || _p === void 0 ? void 0 : _p.foreign) === null || _q === void 0 ? void 0 : _q.services) === null || _r === void 0 ? void 0 : _r.windowService) === null || _s === void 0 ? void 0 : _s.allowGrouping) !== null && _t !== void 0 ? _t : true;
+        // Disable the frame so that users cannot move the window. Only we move the window after we verify that their intended movement shouldn't result in a snap.
+        this.setOpacity = _throttle(this.setOpacity, 100, { trailing: true });
+        this.monitor = this.calculator.getMonitorForWindow(this);
+        this.disableFrame();
+        // Changing the visibility of the taskbar icon is a long process. It involves
+        // many asynchronous calls. In order to make sure a call sequence of
+        // hide, show, show, hide results in a hidden taskbar icon, we put show and hide on a queue.
+        this.changeTaskbarVisibilityQueue = pLimit(1);
+        // A DockableWindow can refuse tabbing or tiling requests with the right config props
+        this.allowTiling = (_u = win.tiling) !== null && _u !== void 0 ? _u : true;
+        this.allowTabbing = (_v = win.tabbing) !== null && _v !== void 0 ? _v : false;
+        this.canMinimize = win.minimize !== undefined;
+        // If the windowOptions say to show the taskbar icon, respect that. Default to true.
+        // This value is checked inside of showTaskbarIcon()
+        this.shouldShowTaskbarIcon = (_x = (_w = win.windowOptions) === null || _w === void 0 ? void 0 : _w.showTaskbarIcon) !== null && _x !== void 0 ? _x : true;
+        this.dockingOptions = win.dockingOptions;
+    }
+    /**
+     * Creates DockableWindow instances.
+     */
+    static factory(win, bounds, calculator) {
+        const dockableWindow = new DockableWindow(win, bounds, calculator);
+        dockableWindow.initialize();
+        return dockableWindow;
+    }
+    setMonitorDockablePosition(options) {
+        const { dockable } = options;
+        if (Array.isArray(dockable)) {
+            dockable.forEach((option) => {
+                option = option.toUpperCase();
+                if (option === "TOP")
+                    this.monitorDockablePositions.TOP = 0;
+                if (option === "LEFT")
+                    this.monitorDockablePositions.LEFT = 1;
+                if (option === "RIGHT")
+                    this.monitorDockablePositions.RIGHT = 2;
+                if (option === "BOTTOM")
+                    this.monitorDockablePositions.BOTTOM = 3;
+            });
+            this.monitorDockablePositions.NONE = 4;
+        }
+        else {
+            // If options.dockable is not supplied, or it is just 'true' that means this window can dock everywhere
+            this.monitorDockablePositions = {
+                TOP: 0,
+                LEFT: 1,
+                RIGHT: 2,
+                BOTTOM: 3,
+                NONE: 4,
+            };
+        }
+    }
+    computeDockingDefaults(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const spawnData = (_d = (_c = (_b = (_a = this.win) === null || _a === void 0 ? void 0 : _a.windowDescriptor) === null || _b === void 0 ? void 0 : _b.customData) === null || _c === void 0 ? void 0 : _c.spawnData) !== null && _d !== void 0 ? _d : null;
+        const dockingDefaults = options !== null ? this.buildDefaultDockingOptions(options) : defaultDockingOptions;
+        this.isDockableComponent = dockingDefaults.isDockable;
+        this.hasDashbarData = (_f = (((_e = spawnData === null || spawnData === void 0 ? void 0 : spawnData.dashbar) === null || _e === void 0 ? void 0 : _e.height) && !Number.isNaN(spawnData.dashbar.height))) !== null && _f !== void 0 ? _f : false;
+        const isUndocked = ((_g = this.win.dockingOptions) === null || _g === void 0 ? void 0 : _g.dockable) && this.win.dockingOptions.undockedParams !== undefined;
+        const isDocked = ((_h = this.win.dockingOptions) === null || _h === void 0 ? void 0 : _h.dockable) && ((_j = this.win.dockingOptions) === null || _j === void 0 ? void 0 : _j.dockedParams) !== undefined;
+        if (isUndocked) {
+            options.undockedParams = {
+                width: dockingDefaults.undockedWidth,
+                height: dockingDefaults.undockedHeight,
+            };
+            if (this.hasDashbarData)
+                options.undockedParams.height = options.undockedParams.height + spawnData.dashbar.height;
+            options.maxHeight = options.undockedParams.height;
+        }
+        if (isDocked) {
+            dockingDefaults.dockedHeight = this.win.dockingOptions.dockedParams.height;
+            if (this.hasDashbarData)
+                dockingDefaults.dockedHeight = dockingDefaults.dockedHeight + spawnData.dashbar.height;
+            options.dockedParams = {
+                width: dockingDefaults.dockedWidth,
+                height: dockingDefaults.dockedHeight,
+            };
+        }
+        if (this.isDockableComponent)
+            this.setMonitorDockablePosition(options);
+        // pass through from the windowWrap. This property is added during the registration. Options include, min/max height/width, whether the window is dockable, whether it starts docked, etc.
+        this.dockedPosition = this.monitorDockablePositions.NONE;
+        this.dockedDimensions = {
+            width: dockingDefaults.dockedWidth,
+            height: dockingDefaults.dockedHeight,
+        };
+        return dockingDefaults;
+    }
+    // options is pass-by-reference
+    setminMaxWidths(options) {
+        const { minWidth = 0, minHeight = 0, maxWidth = 0, maxHeight = 0 } = this.win.windowDescriptor;
+        // Checking for greater than 0 since -1 and 0 both disable the bound containment.
+        if (minWidth > 0)
+            options.minWidth = minWidth;
+        if (minHeight > 0)
+            options.minHeight = minHeight;
+        if (maxWidth > 0)
+            options.maxWidth = maxWidth;
+        if (maxHeight > 0)
+            options.maxHeight = maxHeight;
+    }
+    async initialize() {
+        var _a, _b, _c;
+        // This is triggered on a window move which is done by the user dragging a held down mouse over a window. In other words, this is only !finishedMove when a user is moving the window
+        // DH 3/6/2019 Setting the "markDirty" param to false ensures instantiating
+        // the DockableWindow doesn't mistakenly mark the workspace dirty.
+        this.win._stopMove();
+        this.setBoundingBoxes();
+        this.addListeners();
+        let options = (_a = this.win.dockingOptions) !== null && _a !== void 0 ? _a : null;
+        this.ignoreSnappingRequests = (options === null || options === void 0 ? void 0 : options.ignoreSnappingRequests) || (options === null || options === void 0 ? void 0 : options.ephemeral);
+        this.shouldShowTaskbarIcon = (_b = options === null || options === void 0 ? void 0 : options.showTaskbarIcon) !== null && _b !== void 0 ? _b : true;
+        // this should work only for native and WPF apps
+        if (options && this.win.windowType === "NativeWindow" && this.win.windowDescriptor)
+            this.setminMaxWidths(options);
+        const dockingDefaults = this.computeDockingDefaults(options);
+        // If overwriteDockedOptions is true we should expect there to be some information regarding this component in memory. That saved information will provide bounds for where the window should spawn
+        const startsDocked = typeof (options === null || options === void 0 ? void 0 : options.startsDocked) === "string" ? options.startsDocked.toUpperCase() : "NONE";
+        if (this.isDockableComponent && (options === null || options === void 0 ? void 0 : options.overwriteDockedOptions)) {
+            const locValue = await this.recallDockedPosition({ startsDocked, dockingDefaults });
+            options.locValue = locValue;
+            this.undockedPosition = options.undockedParams;
+            this.dockedParams = options.dockedParams;
+        }
+        else if (dockingDefaults.isDocked && this.monitorDockablePositions.hasOwnProperty(startsDocked)) {
+            this.dockedPosition = this.monitorDockablePositions[startsDocked];
+            this.undockedPosition = {
+                width: dockingDefaults.undockedWidth,
+                height: dockingDefaults.undockedHeight,
+            };
+        }
+        else if (this.win.componentType === "Toolbar") {
+            // The dockable options could be disabled in Toolbar config. At that case needs to show Toolbar window.
+            this.show();
+            return;
+        }
+        this.win.isDocked = this.dockedPosition !== this.monitorDockablePositions.NONE;
+        // If the registering window is dockable, and wants to 'start docked' we need to determine which of the dockable positions it requests to start docked in. If the position is found, we call to dock it which will set the appropriate variables and move any launched windows out of its space.
+        if (this.win.isDocked) {
+            // We only dock the window if it's visible. If it's hidden, we don't want to claim space.
+            const locValue = (_c = options.locValue) !== null && _c !== void 0 ? _c : this.getDockedStringFromLocation();
+            if (locValue)
+                await this.dockToMonitor(locValue);
+        }
+        if (this.isDockableComponent && (options === null || options === void 0 ? void 0 : options.overwriteDockedOptions)) {
+            // now that window is up, make sure the monitor data is saved (also saved when bounds change or monitors change)
+            this.saveDockableData();
+        }
+    }
+    async dockToMonitor(locValue) {
+        var _a;
+        const monitor = this.calculator.getMonitorForWindow(this);
+        const windowBounds = {
+            top: this.top,
+            bottom: this.bottom,
+            left: this.left,
+            right: this.right,
+            width: this.width,
+            height: this.height,
+        };
+        const { err } = await this.setBounds(windowBounds);
+        if (err) {
+            Logger.system.error("Error moving dockable component to default docked position");
+        }
+        this.dockedHeight = (_a = this.dockedParams.height) !== null && _a !== void 0 ? _a : 0;
+        this.snappedEdge = locValue;
+        if (this.win.windowOptions.nativeWindowHandle) {
+            /*
+                JC 6/24/20: Initial docking needs to be delayed to ensure assimilation has
+                started up and is ready to receive requests. I've seen this fail many times
+                because assimilation wasn't ready
+            */
+            const delayDock = setTimeout(() => {
+                clearTimeout(delayDock);
+                monitor.dockWindowToMonitor(this, this, this.undockedPosition.width, this.undockedPosition.height, true);
+            }, 1500);
+        }
+        else {
+            Logger.system.error("Failed to initialize a docked window. Cannot find native window handle");
+        }
+    }
+    async recallBounds() {
+        // first look in component state for cached toolbar location -- this is only for backwards compatability with vertions before 3.9
+        let { err, data: result } = await this.win.getComponentState({});
+        Logger.system.debug("MONITOR: getComponentState", err, result);
+        const noBoundsInComponentState = err || !result || !result.hasOwnProperty("window-bounds") || result["window-bounds"] == null;
+        // for backwards compatability check if bounds data in component state, if not then check in storage
+        if (noBoundsInComponentState) {
+            Logger.system.debug("MONITOR: read monitor-docked data from storage", err, result);
+            // get data from storage -- this is the normal path
+            const { err: err2, data } = await StorageClient.getStandardized({
+                topic: this.name,
+                key: this.name,
+            });
+            if (err2)
+                Logger.system.warn("WARNING: Attempt to retrieve toolbar storage failed.", err2);
+            else
+                result = data;
+        }
+        else {
+            Logger.system.debug("MONITOR: using monitor-docked data from component state", err, result);
+            // since the bounds data is in component state only for backwords compatability, use it this time then remove it so that going forward the lastest values will be picked up from storage.
+            this.win.setComponentState({
+                field: "window-bounds",
+                value: null,
+            });
+        }
+        Logger.system.debug("MONITOR: DockableWindow get results", err, result);
+        return result !== null && result !== void 0 ? result : null;
+    }
+    // windowBounds is pass by reference
+    getLocValue(windowBounds) {
+        var _a;
+        Logger.system.debug("MONITOR: changed");
+        const serviceMonitors = this.calculator.getMonitors();
+        let monitorToDockTo;
+        Object.keys(serviceMonitors).forEach((monKey) => {
+            const mon = serviceMonitors[monKey];
+            if (mon.rawMonitor.deviceId && mon.rawMonitor.deviceId === (windowBounds === null || windowBounds === void 0 ? void 0 : windowBounds.monitor)) {
+                monitorToDockTo = mon.rawMonitor.availableRect;
+            }
+        });
+        if (!monitorToDockTo) {
+            monitorToDockTo = (_a = this.primaryMonitor) === null || _a === void 0 ? void 0 : _a.availableRect;
+        }
+        if (windowBounds.width >= monitorToDockTo.width) {
+            this.width = monitorToDockTo.width;
+        }
+        if (windowBounds.height >= monitorToDockTo.height) {
+            this.height = monitorToDockTo.height;
+        }
+        const locValue = this.getDockedStringFromLocation();
+        Logger.system.debug("MONITOR: changed switch", windowBounds);
+        // Depending on the docked location of the window, we need to reset its
+        // bounds according to the monitor's new bounds
+        switch (locValue) {
+            case "top":
+                windowBounds.top = monitorToDockTo.top;
+                windowBounds.bottom = windowBounds.top + windowBounds.height;
+                break;
+            case "bottom":
+                windowBounds.bottom = monitorToDockTo.bottom;
+                windowBounds.top = windowBounds.bottom - windowBounds.height;
+                break;
+            case "left":
+                windowBounds.left = monitorToDockTo.left;
+                windowBounds.right = windowBounds.left + windowBounds.width;
+                break;
+            case "right":
+                windowBounds.right = monitorToDockTo.right;
+                windowBounds.left = windowBounds.right - windowBounds.width;
+                break;
+            default:
+                Logger.system.error("Initializing docked window docked to an unknown position");
+                break;
+        }
+        Logger.system.debug("MONITOR: changed after switch", windowBounds);
+        windowBounds.left = windowBounds.left <= monitorToDockTo.left ? monitorToDockTo.left : windowBounds.left;
+        windowBounds.right = windowBounds.right >= monitorToDockTo.right ? monitorToDockTo.right : windowBounds.right;
+        delete this.primaryMonitor;
+        return locValue;
+    }
+    async recallDockedPosition({ startsDocked, dockingDefaults, }) {
+        var _a;
+        const dockedLocation = await this.recallBounds();
+        const visible = typeof (dockedLocation === null || dockedLocation === void 0 ? void 0 : dockedLocation.visible) === "boolean" ? dockedLocation.visible : true;
+        const windowBounds = (dockedLocation === null || dockedLocation === void 0 ? void 0 : dockedLocation["window-bounds"]) !== null ? dockedLocation === null || dockedLocation === void 0 ? void 0 : dockedLocation["window-bounds"] : null;
+        const savedMonitorData = (_a = dockedLocation === null || dockedLocation === void 0 ? void 0 : dockedLocation.monitorData) !== null && _a !== void 0 ? _a : null;
+        // If all the saved data is available, then check if monitor changed since last restart;
+        // else since all the data isn't available, assume the monitors did not change since last restart;
+        const savedDataAvailable = windowBounds && savedMonitorData;
+        const monitorChanged = savedDataAvailable ? await this.monitorChanged(savedMonitorData) : false;
+        // if could not find bounds data either in window state or in storage, then use default settings.
+        if (!windowBounds) {
+            Logger.system.debug("MONITOR: DockableWindow using defaults.");
+            if (this.monitorDockablePositions[startsDocked])
+                this.dockedPosition = this.monitorDockablePositions[startsDocked];
+            else
+                this.dockedPosition = this.monitorDockablePositions.TOP;
+            this.undockedPosition = {
+                width: dockingDefaults.undockedWidth,
+                height: dockingDefaults.undockedHeight,
+            };
+            this.show();
+            return null;
+        }
+        // since have window Bounds, check if in visible space.  If not in visible space then will adjust bounds to be visible
+        const boundsToCheck = clone(windowBounds);
+        boundsToCheck.isDocked = windowBounds.dockedPosition !== this.monitorDockablePositions.NONE;
+        Logger.system.debug("MONITOR: DockableWindow status", dockedLocation, monitorChanged, boundsToCheck, windowBounds);
+        this.dockedPosition = windowBounds.dockedPosition;
+        // If the monitors have changed since this window was last loaded (and docked on the last Finsemble run)
+        // determine if that monitor still exists (maybe the taskbar has moved or the resolution was changed).
+        // If so, try to put the window back in the same place but remaining on the monitor
+        const locValue = monitorChanged ? this.getLocValue(windowBounds) : null;
+        this.top = windowBounds.top;
+        this.bottom = windowBounds.bottom;
+        this.left = windowBounds.left;
+        this.right = windowBounds.right;
+        this.width = windowBounds.width;
+        this.height = windowBounds.height;
+        // move undocked toolbar to its previously saved location
+        this.setBounds(windowBounds, () => {
+            // NOTE: there is a bug related to the "hidden" event that prevents visible state from being saved, so initial visiblity will alway be true until bug fixed
+            if (visible) {
+                this.isHidden = false;
+                this.show();
+                // observed problem with toolbar not being on top, so bring to front to
+                this.win._bringToFront({});
+            }
+        });
+        return locValue;
+    }
+    /**
+     * Returns turn if the current monitor dimensions are different from the previous monitor dimensions
+     * @param {array} previousMonitorData the previous monitor info (an array of monitors)
+     */
+    async monitorChanged(previousMonitorData) {
+        const monitorInfo = await System.getMonitorInfo();
+        const monitorData = [monitorInfo.primaryMonitor, ...monitorInfo.nonPrimaryMonitors];
+        let changed = false;
+        // Cache primary monitor for temporary retrieval in docking initialization
+        this.primaryMonitor = monitorInfo.primaryMonitor;
+        if (monitorData && previousMonitorData && monitorData.length == previousMonitorData.length) {
+            changed = monitorData.some((monitor, i) => {
+                if (monitor.availableRect.top != previousMonitorData[i].availableRect.top)
+                    return true;
+                if (monitor.availableRect.bottom != previousMonitorData[i].availableRect.bottom)
+                    return true;
+                if (monitor.availableRect.left != previousMonitorData[i].availableRect.left)
+                    return true;
+                return monitor.availableRect.right != previousMonitorData[i].availableRect.right;
+            });
+        }
+        else {
+            changed = true;
+        }
+        Logger.system.debug("MONITOR: DockableWindow.monitorChanged", "monitorData", monitorData, "previousMonitorData", previousMonitorData, changed ? "changed" : "not changed");
+        return changed;
+    }
+    /**
+     * Returns turn if the toolber handle (i.e. what the user can grab to move toolbar) is visible on one of the current monitors (based on the toolbars current bounds
+     * @param {array} currentBounds the toolbars current bounds
+     */
+    isToolbarVisible(currentBounds) {
+        const isToolbarVisiblePromiseResolver = (resolve) => {
+            System.getMonitorInfo((monitorInfo) => {
+                var _a, _b;
+                const monitorData = [monitorInfo.primaryMonitor, ...monitorInfo.nonPrimaryMonitors];
+                let isVisible = false;
+                // calculate the approximate bounds of the toolbar "handle", based on the current toolbar bounds;
+                // if these four points are within a single monitor then visible;
+                // this function is not exact since toolbar might span monitors but close enough until we rearchitect -- at worst will just move toolbar to default position;
+                // note the rightReference is calculated in relation to the left bounds
+                const topReference = ((_a = currentBounds.top) !== null && _a !== void 0 ? _a : 0) + 5;
+                const bottomReference = ((_b = currentBounds.bottom) !== null && _b !== void 0 ? _b : 0) - 5;
+                const leftReference = currentBounds.left + 5;
+                const rightReference = currentBounds.left + 20;
+                for (let i = 0; i < monitorData.length; i++) {
+                    let topOK = false;
+                    let bottomOK = false;
+                    let leftOK = false;
+                    let rightOK = false;
+                    // since claimed space may change monitor dimensions, must compare against availableRect (which is independent of claimed space)
+                    if (topReference >= monitorData[i].monitor.scaledRect.top)
+                        topOK = true;
+                    if (bottomReference <= monitorData[i].monitor.scaledRect.bottom)
+                        bottomOK = true;
+                    if (leftReference >= monitorData[i].monitor.scaledRect.left)
+                        leftOK = true;
+                    if (rightReference <= monitorData[i].monitor.scaledRect.right)
+                        rightOK = true;
+                    isVisible = topOK && bottomOK && leftOK && rightOK;
+                    if (isVisible)
+                        break;
+                }
+                Logger.system.debug("MONITOR: DockableWindow.isToolbarVisible", "monitorData", monitorData, "currentBounds", currentBounds, isVisible ? "isVisible" : "not visible");
+                Logger.system.debug("MONITOR: DockableWindow.isToolbarVisible T-B-L-R=", topReference.toString(), bottomReference.toString(), leftReference.toString(), rightReference.toString());
+                resolve(isVisible);
+            });
+        };
+        return new Promise(isToolbarVisiblePromiseResolver);
+    }
+    /**
+     * Returns a string representation of the docked location
+     */
+    getDockedStringFromLocation() {
+        var _a;
+        let locValue = null;
+        for (let i = 0; i < Object.keys(this.monitorDockablePositions).length; i++) {
+            const key = Object.keys(this.monitorDockablePositions)[i];
+            if (this.monitorDockablePositions[key] === this.dockedPosition) {
+                locValue = key.toUpperCase();
+                break;
+            }
+        }
+        return (_a = locValue === null || locValue === void 0 ? void 0 : locValue.toLowerCase()) !== null && _a !== void 0 ? _a : null;
+    }
+    /**
+     * Function to respond to finWindow bounds-changed events. Currently we only respond to this event in some cases.
+     * Aero_key: Sets bounds after an aero snap action is initiated (windows key + arrow key). Only triggers if Aero is enabled.
+     * System_restored: Triggered when a window is restored from minimized outside of Finsemble. This code block should only be hit if the
+            monitor configuration has changed after a window is minimized and the window's old restore position would be partially off-monitor.
+            The OS does not change the bounds of minimized windows, so they only action we can take	is to force it on monitor.
+     * @param {object} e The event
+     */
+    onSystemMovedWindow(e) {
+        const incomingBounds = clone(e.data);
+        let bounds;
+        switch (e.data.action) {
+            case MOVE_REASON.AERO_KEY:
+                // If the user is moving the window (and not the OS) these movements will be handled elsewhere
+                if (!this.win.finishedMove)
+                    return;
+                Logger.system.log("aero_key: aero key action occurred", e.data.action);
+                if (this.calculator.enableWindowsAeroSnap) {
+                    bounds = incomingBounds;
+                }
+                else {
+                    bounds = this.getBounds();
+                }
+                Logger.system.verbose(`aero_key: aero key action occurred. Action: ${e.data.action}, bounds: ${bounds}`);
+                // Docking listens for a restoreFromMaximize message on the router.
+                // That doesn't happen when aero-snap triggers a restore after the window is maximized.
+                // Here we manually change the underlying window's windowState
+                Logger.system.debug("setting window state back to NORMAL with win: ", this.win);
+                this.win.windowState = WINDOWSTATE.NORMAL;
+                // Update the Finsemble bounds after aero snap
+                // For groups, break the group and and only aero snap the selected window.
+                this.setBounds(bounds, () => {
+                    this.calculator.removeWindowFromAllGroups(this, true);
+                    this.calculator.buildSnapRelationships(this);
+                    this.calculator.updateGroupData();
+                });
+                break;
+            // Triggered when a window is restored outside of finsemble (such as from the taskbar), and the previous window position would now be off-monitor
+            // From Electron 9 the window restore position gets updated when a monitor change event occurs that would put it off monitor.
+            // Finsemble's bounds need to be updated to match that position.
+            // Groups also must be moved relative to one window in the group as the OS may break a group if it is partially off monitor or on a scaling change.
+            case MOVE_REASON.SYSTEM_RESTORED: {
+                const group = this.calculator.getMovableGroup(this.name);
+                if (group) {
+                    Logger.system.verbose(`dockableWindow.onSystemMovedWindow system_restored: Window ${this.name} is in a group, updated bounds for restore ${JSON.stringify(incomingBounds)}`);
+                    if (group.groupState === group.GROUPSTATES.MINIMIZED) {
+                        group.restoreAll();
+                    }
+                    group.deferSystemMove({ name: this.name, bounds: incomingBounds }, this.calculator);
+                }
+                else {
+                    Logger.system.verbose(`dockableWindow.onSystemMovedWindow system_restored: Window ${this.name} is restoring to new position: ${JSON.stringify(incomingBounds)}`);
+                    this.setBounds(incomingBounds);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    /**
+     * Builds default docking options for dockable windows
+     * @param {object} options Taken from the incoming config
+     * @return {object} The docking defaults
+     */
+    buildDefaultDockingOptions(options) {
+        // Building a default options object based on the incoming config props. Since windows can have different dockable areas and different starting docked positions, we must build starting props based on those options.
+        const hasUndockedParams = this.win.hasOwnProperty("dockingOptions") && this.win.dockingOptions.hasOwnProperty("undockedParams");
+        const hasDockedParams = this.win.hasOwnProperty("dockingOptions") && this.win.dockingOptions.hasOwnProperty("dockedParams");
+        return {
+            isDockable: !!(options !== null &&
+                (options.dockable === true || (Array.isArray(options.dockable) && Array.from(options.dockable).length > 0))),
+            undockedWidth: hasUndockedParams ? this.win.dockingOptions.undockedParams.width : 300,
+            undockedHeight: hasUndockedParams ? this.win.dockingOptions.undockedParams.height : 30,
+            isDocked: !!(options !== null && options.hasOwnProperty("startsDocked")),
+            dockedWidth: hasDockedParams ? this.win.dockingOptions.dockedParams.width : 300,
+            dockedHeight: hasDockedParams ? this.win.dockingOptions.dockedParams.height : 39,
+            height: 0,
+        };
+    }
+    /**
+     * Function to handle chain of events when a dockable component type is docked
+     *
+     * @param {object} monitor Information about the monitor the component was docked to
+     * @param {string} location A string containing the location to dock to: "TOP", "LEFT", "BOTTOM", and "RIGHT" are the acceptable values
+     */
+    dock(monitor, oldBounds, location) {
+        var _a, _b;
+        if (this.isDockableComponent) {
+            let dockPos = -1;
+            this.undockedPosition = {
+                width: (_a = oldBounds.width) !== null && _a !== void 0 ? _a : 0,
+                height: (_b = oldBounds.height) !== null && _b !== void 0 ? _b : 0,
+            };
+            Logger.system.debug("MONITOR: DockableWindow.dock", "undockedPosition", this.undockedPosition);
+            // Assuming the re-assignment of positions/size doesn't need to take place
+            // we don't need a switch here
+            switch (location) {
+                case this.monitorDockablePositions.TOP:
+                    dockPos = this.monitorDockablePositions.TOP;
+                    break;
+                case this.monitorDockablePositions.LEFT:
+                    dockPos = this.monitorDockablePositions.LEFT;
+                    break;
+                case this.monitorDockablePositions.RIGHT:
+                    dockPos = this.monitorDockablePositions.RIGHT;
+                    break;
+                case this.monitorDockablePositions.BOTTOM:
+                    dockPos = this.monitorDockablePositions.BOTTOM;
+                    break;
+                default:
+                    break;
+            }
+            this.dockedPosition = dockPos;
+            this.win.isDocked = true;
+        }
+    }
+    /**
+     * Function to handle chain of events when a dockable component type is undocked
+     */
+    undock(isClosing = false) {
+        if (this.isDockableComponent) {
+            // Only change state if we are not closing
+            if (!isClosing) {
+                this.win.isDocked = false;
+                this.dockedPosition = this.monitorDockablePositions.NONE;
+            }
+            this.monitor.undockWindowFromMonitor(this, isClosing);
+        }
+    }
+    saveDockableData() {
+        const bounds = {
+            top: this.top,
+            bottom: this.bottom,
+            left: this.left,
+            right: this.right,
+            width: this.width,
+            height: this.height,
+            isDockable: this.win.isDocked,
+            dockedPosition: this.dockedPosition,
+            monitor: this.monitor.rawMonitor.deviceId || null,
+        };
+        // this needs to be saved in here because something causes this to reverse in the callback below
+        const visible = !this.isHidden;
+        // must save the monitor date since if monitors changed since last restart then toolbar will use default settings (otherwise might have problems with visibility)
+        System.getMonitorInfo((monitorInfo) => {
+            const monitorData = [monitorInfo.primaryMonitor, ...monitorInfo.nonPrimaryMonitors];
+            Logger.system.debug("MONITOR: DockableWindow saveDockableData. Visible will always be saved as true.", monitorData, visible.toString(), (!this.isHidden).toString(), bounds);
+            // Always save true for visible because we don't want the toolbar to come back hidden
+            // Save if the dashbar is enabled as the bounds are based on that state. If the config changes this state on a later boot
+            // we need to know if those bounds should be updated to match the toolbar's state in config.
+            StorageClient.save({
+                topic: this.name,
+                key: this.name,
+                value: {
+                    visible: true,
+                    "window-bounds": bounds,
+                    monitorData,
+                    dashbarEnabled: this.hasDashbarData,
+                },
+            });
+        });
+    }
+    /**
+     * @function {function name}
+     * @return {type} {description}
+     */
+    onBoundsChanged() {
+        Logger.system.debug("MONITOR: onBoundsChanged", this.isDockableComponent);
+        this.resizeHandle = null;
+        const timestamp = Date.now();
+        // This would be true if the window was maximized when the move request that triggered mouseDown was requested.
+        // It should only be changed if, on mouse down the window is maximized.
+        this.shouldOffsetByMouse = false;
+        this.onboundschanged = timestamp;
+        this.lastBoundsAdjustment = timestamp;
+        this.monitor = this.calculator.getMonitorForWindow(this);
+        this.calculator.onMouseUp();
+        this.win._stopMove();
+        if (this.isDockableComponent || this.win.componentType == "Toolbar") {
+            Logger.system.debug("MONITOR: onBoundsChanged saveDockableData");
+            this.saveDockableData();
+        }
+    }
+    hiddenUnclaimSpace() {
+        if (this.win.isDocked && !this.isHidden) {
+            this.isHidden = true;
+            this.monitor.undockWindowFromMonitor(this);
+        }
+    }
+    unhiddenClaimSpace() {
+        var _a, _b, _c, _d;
+        if (this.win.isDocked && this.isHidden) {
+            if (typeof this.monitor.dockWindowToMonitor === "function") {
+                this.monitor.dockWindowToMonitor(this, this, (_a = this.undockedPosition) === null || _a === void 0 ? void 0 : _a.width, (_b = this.undockedPosition) === null || _b === void 0 ? void 0 : _b.height);
+            }
+            else {
+                Logger.system.error("Toolbar was unhidden but cannot call to re-claim space.", { monitor: this.monitor });
+                return;
+            }
+            // Docking claims the space, but windows places the docked window outside of its own space.
+            // Push it back
+            const { left, right, top, bottom, width } = this.monitor.rawMonitor.monitorRect;
+            const dockedBounds = {
+                width: (_c = this.dockedDimensions) === null || _c === void 0 ? void 0 : _c.width,
+                height: (_d = this.dockedDimensions) === null || _d === void 0 ? void 0 : _d.height,
+                left: 0,
+                right: 0,
+                bottom: 0,
+                top: 0,
+            };
+            const edge = this.getDockedStringFromLocation();
+            switch (edge) {
+                case "top":
+                    dockedBounds.left = left;
+                    dockedBounds.right = right;
+                    dockedBounds.top = top;
+                    dockedBounds.bottom = top + this.height;
+                    dockedBounds.width = width !== null && width !== void 0 ? width : 0;
+                    break;
+                case "bottom":
+                    dockedBounds.left = left;
+                    dockedBounds.right = right;
+                    dockedBounds.bottom = bottom;
+                    dockedBounds.top = bottom - this.height;
+                    dockedBounds.width = width !== null && width !== void 0 ? width : 0;
+                    break;
+                case "left":
+                case "right":
+                    break;
+                default:
+                    Logger.system.warn("Unable to determine docking edge");
+                    break;
+            }
+            const moveWindowIntoClaimedSpace = setTimeout(() => {
+                clearTimeout(moveWindowIntoClaimedSpace);
+                this.setBounds(dockedBounds);
+            }, 1500);
+        }
+        this.isHidden = false;
+    }
+    /**
+     * @function {function name}
+     * @param  {type} request  {description}
+     * @param  {type} callback {description}
+     * @return {type} {description}
+     */
+    async onBoundsChanging(event, cb) {
+        this.win.removeEventListener(BOUNDS_CHANGING, this.onBoundsChanging);
+        const request = event.data || event;
+        request.name = event.source;
+        this.win._startMove(request.changeType);
+        try {
+            request.timestamp = Date.now();
+        }
+        catch (e) {
+            return;
+        }
+        const position = await System.getMousePosition();
+        const finishMove = () => {
+            this.lastBoundsAdjustment = Date.now();
+            this.win.addEventListener(BOUNDS_CHANGING, this.onBoundsChanging);
+        };
+        let invalidateRequest = false;
+        const shouldThrottle = request.timestamp < this.lastBoundsAdjustment + this.resizeThrottlePeriod;
+        // Note: this conditional here is for testing. Node is faster than JS or something.
+        // In node, we need to also exclude requests that came in at the same time as the request we last processed.
+        // I think they sometimes send multiple events and in my testing, that never happens.
+        // Truthfully though I don't know why this bit has to be different in the different environments.
+        // But I do remember losing a day when I ported this stuff from test-world. Don't delete it. --Brad
+        // @ts-ignore fin object referenced for testing env
+        if (typeof fin === "undefined") {
+            invalidateRequest = shouldThrottle || request.timestamp < this.lastBoundsAdjustment;
+        }
+        else {
+            invalidateRequest = shouldThrottle || request.timestamp <= this.lastBoundsAdjustment;
+        }
+        if (invalidateRequest) {
+            Logger.system.debug("DOCKING: Invalid request", "TIMESTAMPS:", JSON.stringify(request.timestamp), JSON.stringify(this.lastBoundsAdjustment));
+            this.win.addEventListener(BOUNDS_CHANGING, this.onBoundsChanging);
+            cb === null || cb === void 0 ? void 0 : cb();
+            return;
+        }
+        if (this.win.windowState === WINDOWSTATE.MAXIMIZED) {
+            /**
+             * This is a way to lock out any processing until we finish processing the first move request
+             * that comes in when a window is maximized.
+             *
+             * Events more or less get 'queued' by the underlying container. As quickly as they can, our container
+             * will consume OS-level events and bubble them up to this layer. We have code in this file
+             * here that says "Hey, this request came in prior to the last time I made a change. I'm going to drop
+             * this request . You're invalid. Goodbye." The thing we trigger off of is `lastBoundsAdjustment`.
+             * This value is set _after_ we process the current move request.
+             *
+             * Maximize is special though. As soon as our first request comes in, we want to ensure that no additional requests are even considered.
+             * To do that, we just say "The last time we changed this window was super far into the future." Now,
+             * every incoming request will be dropped until we have time to restore the window, do any group adjustments, and recalibrate.
+             *
+             * It sounds clunky, and it is somewhat. But I can't think of a better way to do this.
+             */
+            this.lastBoundsAdjustment = Date.now() + 1000000000;
+            /**
+             * This tells the `setMoveRequest` function to offset the incoming request in such a way
+             * that the window is centered on the mouse pointer. If you call setBounds on a window that is maximized, subsequent move
+             * requests will come in as though the window's left edge never moved, until mouseUp happens. This boolean helps us get
+             * around this bug.
+             */
+            this.shouldOffsetByMouse = true;
+        }
+        // This comparison used to check right and bottom...props that don't exist on the request.
+        // If all of the bounds haven't changed, don't waste time processing it.
+        // On monitor resolution change, bounds will not change, but we still need to move
+        // If the changeSource is "system", we might need to move even if the bounds haven't changed.
+        if (request.changeSource !== "system" &&
+            request.left === this.win.windowOptions.left &&
+            request.top === this.win.windowOptions.top &&
+            request.width === this.win.windowOptions.width &&
+            request.height === this.win.windowOptions.height) {
+            console.debug("No change being requested. Dropping.");
+            finishMove();
+            cb === null || cb === void 0 ? void 0 : cb();
+            return;
+        }
+        // An electron bug causes window size to fluctuate on display scaled monitors. Keep the size if we are moving.
+        if (request.changeType === 0) {
+            request.width = this.win.windowOptions.width ? this.win.windowOptions.width : request.width; // For native windows these values do not exist initially
+            request.height = this.win.windowOptions.height ? this.win.windowOptions.height : request.height;
+        }
+        request.right = request.left + request.width;
+        request.bottom = request.top + request.height;
+        request.groupNames = this.groupNames;
+        request.mousePosition = request.mousePosition || position;
+        const bounds = await this.calculator.requestMove(request);
+        if (!bounds) {
+            finishMove();
+            cb === null || cb === void 0 ? void 0 : cb();
+            return;
+        }
+        await this.setBounds(bounds);
+        finishMove();
+        cb === null || cb === void 0 ? void 0 : cb();
+    }
+    setResizeThrottlePeriod(throttlePeriod) {
+        this.resizeThrottlePeriod = throttlePeriod;
+    }
+    async restored(event) {
+        var _a, _b;
+        const group = this.calculator.getMovableGroup(this.name);
+        if (group && group.groupState === group.GROUPSTATES.MINIMIZED) {
+            group.restoreAll();
+        }
+        let previousState = (_a = event === null || event === void 0 ? void 0 : event.data) === null || _a === void 0 ? void 0 : _a.previousState;
+        let updatedBounds = (_b = event === null || event === void 0 ? void 0 : event.data) === null || _b === void 0 ? void 0 : _b.bounds;
+        if (!updatedBounds)
+            return;
+        /* If the window has been restored for maximize we need to update it's new position for Finsemble
+        We mostly rely on electron restore; however, in some cases we've forced the restore to a saved position.
+        If the monitors have changed this old position may be off monitor so we need to handle this case
+
+        Group restore needs more work. Historically we've always assumed the maximized window in the group will end up properly
+        positioned in the group. This doesn't work out after monitor change - the restore position that comes back from electron is not matched with the group
+        For now we make sure the restored window isn't lost, but can't guarantee the group will end up together (which will cause it to break after the next user move). */
+        let adjustedBounds = Object.assign({}, (await adjustBoundsToBeOnMonitorAsync(updatedBounds)));
+        if (previousState === WINDOWSTATE.MAXIMIZED && !checkIfBoundsAreEqual(this.getBounds(), adjustedBounds)) {
+            // If the bounds from the event are not off-monitor, it's safe to only update the bounds for finsemble and not do a full setbounds
+            if (checkIfBoundsAreEqual(adjustedBounds, updatedBounds)) {
+                adjustedBounds.internal = true;
+            }
+            this.setBounds(adjustedBounds);
+        }
+        if (!group && previousState && !this.name.includes("Toolbar")) {
+            this.calculator.buildSnapRelationships(this);
+            this.calculator.formGroup(this.name, { isMovable: false });
+            this.calculator.updateGroupData();
+        }
+    }
+    maximized() {
+        // update the bounds for finsemble except for stacked windows.
+        if (!this.win.parentWindow) {
+            // Monitor bounds are used to update finsemble bounds because of a chromium bug where maximized bounds are off by several pixels.
+            // This varies by scaling but on 100% monitor on a primary bounds were -8,-8 instead of 0,0 and 16 pixels too too and wide.
+            let bounds = Object.assign({}, this.monitor.availableRect);
+            // We need the window service's internal state to reflect the maximized bounds so that other windows don't try to
+            // snap to the old location. But, we must not ask Electron to actually set new bounds because that will then erase
+            // Electron's restoration cache (getNormalBounds). This call will update Finsemble's internal state without making any
+            // actual calls to the window itself.
+            //One side effect of this change is that FEA's bounds no longer get updated by us here.
+            // Electron has a strange issue where maximized bounds have an invisible border or some
+            // sorts that doesn't cause any issues but shows up in the bounds
+            // (On my 100% machine I get x: -8, y: -8 width and height have an extra 16 pixels).
+            // By not updating this value FEAs bounds now match electron bounds here.
+            // This may not matter but we do rely on FEA bounds in several places in mainWindow
+            // It's possible there will be some side effects.
+            this.setInternalBounds(bounds);
+        }
+    }
+    /**
+     * This removes event listeners.
+     * I can't be entirely certain, but from my testing, it _appears_ that Electron isn't actually deleting these objects.
+     * If you close the window, then load the window with the same name, old listeners are still registered with your new window.
+     * So if you reload a workspace, and then try to move a window, you get weird scenarios where onBoundsChanging is called twice with different values (presumably for old eventlisteners).
+     * Removing the eventListeners on close seems to handle this.
+     */
+    removeEventListeners() {
+        // This reason this is necessary is hard to explain.
+        // When the dockableWindow is created we call win.addEventListener(BOUNDS_CHANGING, blah blah).
+        // This forces the window to bubble bounds events up to us. This function also goes out to the router and is pretty heavy for rapid addition/removal. Inside of onBoundsChanging, we add and remove handlers _on the event manager_. So when removeEventListeners is called, the two handlers above are removed. However, there's still that lingering listener that we added to the event manager inside of finishMove. If we don't remove that listener, we could get events thrown from other older incarnations of the same dockable window.
+        this.win.removeEventListener(BOUNDS_CHANGING, this.onBoundsChanging);
+        this.win.removeEventListener(BOUNDS_CHANGED, this.onBoundsChanged);
+        this.win.removeEventListener("hidden", this.hiddenUnclaimSpace);
+        this.win.removeEventListener("shown", this.unhiddenClaimSpace);
+        this.win.removeEventListener("restored", this.restored);
+        this.win.removeEventListener("maximized", this.maximized);
+        this.win.removeEventListener(SYSTEM_BOUNDS_CHANGED, this.onSystemMovedWindow);
+    }
+    /** ******************************************
+     *											*
+     *			Window Moving Methods			*
+     *											*
+     ******************************************* */
+    /**
+     * Hides taskbar icon for windows. This prevents them from being clobbered by aeroshake.
+     */
+    hideTaskbarIcon() {
+        const hideTaskbarPromise = new Promise((resolve) => {
+            // Check to see if the method exists. It wouldn't on an external window wrapper.
+            if (this.win._updateOptions) {
+                this.win._updateOptions({ showTaskbarIcon: false }, resolve);
+            }
+            else {
+                resolve();
+            }
+        });
+        // The timeout should never fire. Showing/hiding the taskbar should take
+        // a couple dozen milliseconds
+        // However, updateOptions also saves data. If we ever lost a connection to the DB,
+        // we could get into a situation where the queue hangs up. We don't want that.
+        this.changeTaskbarVisibilityQueue(() => wrapWithTimeout(hideTaskbarPromise, 2000, "HideTaskbarIcon timed out"));
+    }
+    /**
+     * This shows the taskbar icon for a given window.
+     */
+    showTaskbarIcon(showIcon = this.shouldShowTaskbarIcon) {
+        const showTaskbarPromise = new Promise((resolve) => {
+            if (this.win._updateOptions && (this.shouldShowTaskbarIcon || showIcon)) {
+                this.win._updateOptions({ showTaskbarIcon: true }, resolve);
+            }
+            else {
+                resolve();
+            }
+        });
+        // The timeout should never fire. Showing/hiding the taskbar should take
+        // a couple dozen milliseconds
+        // However, updateOptions also saves data. If we ever lost a connection to the DB,
+        // we could get into a situation where the queue hangs up. We don't want that.
+        this.changeTaskbarVisibilityQueue(() => wrapWithTimeout(showTaskbarPromise, 2000, "ShowTaskbarIcon timed out"));
+    }
+    /**
+     * @function {function name}
+     * @return {type} {description}
+     */
+    disableFrame() {
+        if (this.win.disableFrame) {
+            // This should be renamed disableWindowMovement();
+            this.win.disableFrame();
+        }
+        else if (!warningsSent.disableFrame) {
+            warningsSent.disableFrame = true;
+        }
+    }
+    setOpacity(params = { opacity: 1, persist: false }) {
+        // if (opacity === this.opacity) return;
+        this.opacity = params.opacity;
+        if (this.win._setOpacity) {
+            this.win._setOpacity(params);
+        }
+        else if (!warningsSent.setOpacity) {
+            warningsSent.setOpacity = true;
+        }
+    }
+    /**
+     * Sets bounds for internal calculations.
+     */
+    setInternalBounds(bounds) {
+        // Bunch of if statements was quicker than ternary operators when inside of loops.
+        this.left = typeof bounds.left === "undefined" ? this.left : bounds.left;
+        this.top = typeof bounds.top === "undefined" ? this.top : bounds.top;
+        this.width = typeof bounds.width === "undefined" ? this.width : bounds.width;
+        this.height = typeof bounds.height === "undefined" ? this.height : bounds.height;
+        this.right = typeof bounds.right === "undefined" ? this.left + this.width : bounds.right;
+        this.bottom = typeof bounds.bottom === "undefined" ? this.top + this.height : bounds.bottom;
+        this.setBoundingBoxes();
+    }
+    /**
+     * @function {function name}
+     * @param  {type} bounds    {description}
+     * @param  {type} successCB {description}
+     * @param  {type} errCB     {description}
+     * @return {type} {description}
+     */
+    async setBounds(bounds, successCB) {
+        return new Promise((resolve) => {
+            this.setInternalBounds(bounds);
+            bounds = {
+                left: bounds.left,
+                width: bounds.width,
+                height: bounds.height,
+                top: bounds.top,
+                right: bounds.right,
+                bottom: bounds.bottom,
+                internal: bounds.internal,
+                persistBounds: bounds.persistBounds,
+            };
+            // Old way was to update the monitor on the window when onMouseUp occurred, but now the OS (as well as user) can move a window and the monitor for that window should be updated every time
+            this.monitor = this.calculator.getMonitorForWindow(this);
+            this.win._setBounds({ bounds }, (err, data) => {
+                successCB === null || successCB === void 0 ? void 0 : successCB(err, data);
+                resolve({ err, data });
+            });
+        });
+    }
+    /**
+     * @function {function name}
+     * @param  {type} left {description}
+     * @param  {type} top  {description}
+     * @return {type} {description}
+     */
+    moveTo(left, top) {
+        this.setBounds({
+            left,
+            top,
+            right: left + this.win.windowOptions.width,
+            bottom: top + this.win.windowOptions.height,
+            width: this.win.windowOptions.width,
+            height: this.win.windowOptions.height,
+        });
+    }
+    /**
+     * @function {function name}
+     * @return {type} {description}
+     */
+    getGroupNames() {
+        return this.groupNames;
+    }
+    /**
+     * @function {function name}
+     * @param  {type} request  {description}
+     * @param  {type} callback {description}
+     * @return {type} {description}
+     */
+    requestBoundsChange(request, callback) {
+        // window.methodCalls["requestBoundsChange"]++;
+        // for testing purposes only
+        if (!callback) {
+            callback = this.onBoundsChanged;
+        }
+        System.getMousePosition((err, position) => {
+            this.onBoundsChanging({
+                data: {
+                    corners: this.getCornerObject(request),
+                    left: request.left,
+                    top: request.top,
+                    width: request.width,
+                    height: request.height,
+                    changeType: request.changeType,
+                    name: this.name,
+                    mousePosition: request.mousePosition || position,
+                },
+            }, () => {
+                if (callback) {
+                    callback();
+                }
+            });
+        });
+    }
+    /** ******************************************
+     *											*
+     *			Helper Functions				*
+     *											*
+     ******************************************* */
+    /**
+     * @function {function name}
+     * @return {type} {description}
+     */
+    calculateInnerBoundingBox() {
+        var _a;
+        const adjustment = ((_a = this.bufferSize) !== null && _a !== void 0 ? _a : 0) * 2;
+        return {
+            min: {
+                x: this.left + adjustment,
+                y: this.top + adjustment,
+            },
+            max: {
+                x: this.right - adjustment,
+                y: this.bottom - adjustment,
+            },
+        };
+    }
+    getInnerBoundingBox() {
+        return this.innerBuffer;
+    }
+    /**
+     * @function {function name}
+     * @param  {type} bufferSize {description}
+     * @return {type} {description}
+     */
+    setBufferSize(bufferSize) {
+        this.bufferSize = bufferSize;
+        this.setBoundingBoxes();
+    }
+    /**
+     * @function {function name}
+     * @return {type} {description}
+     */
+    setBoundingBoxes() {
+        const myBounds = this.getBounds();
+        this.setBuffer();
+        this.innerBuffer = this.calculateInnerBoundingBox();
+        this.windowBoundingBox = BoxMath.getWindowBoundingBox(myBounds);
+        this.setSnappingRegions();
+        this.vertices = this.getCornerObject(myBounds);
+    }
+    getSnappingRegions() {
+        return this.snappingRegions;
+    }
+    updateState() {
+        this.win._getBounds({}, (err, bounds) => {
+            this.setBounds(bounds);
+        });
+    }
+    /**
+     * @function setHidden
+     * @param  {function=} callback when done
+     *
+     * Sets the internal state to hidden.  Only needed if window is hidden outside of this class.
+     */
+    setHidden() {
+        Logger.system.debug("MONITOR: DockableWindow hide state");
+        this.isHidden = true;
+    }
+    /**
+     * @function setHidden
+     * @param  {function=} callback when done
+     *
+     * Sets the internal state to shown (i.e. not hidden). Only needed if window is hidden outside of this class.
+     */
+    setShown() {
+        Logger.system.debug("MONITOR: DockableWindow.show state");
+        this.isHidden = false;
+    }
+    hide(cb = NullStandardCallback) {
+        this.win._hide({}, cb);
+    }
+    show(cb = NullStandardCallback) {
+        this.win._show({}, cb);
+    }
+    maximize(cb = NullStandardCallback) {
+        this.win._maximize({}, cb);
+    }
+    minimize(cb = NullStandardCallback) {
+        this.win._minimize({}, cb);
+    }
+    restore(cb = NullStandardCallback) {
+        this.win._restore({}, cb);
+    }
+    alwaysOnTop(isAlwaysOnTop) {
+        try {
+            this.win._alwaysOnTop({ alwaysOnTop: isAlwaysOnTop });
+        }
+        catch (e) {
+            Logger.system.debug("Implement alwaysOnTop");
+        }
+    }
+    /**
+     * Returns the present alwaysOnTop status of the window.
+     *
+     * NOTE: This only reflects Finsemble's internal representation
+     * of the alwaysOnTop status, not the container/OS. When changing the status,
+     * Finsemble's status changes before the underlying container, causing them
+     * to briefly become out of sync.
+     */
+    isAlwaysOnTop() {
+        return this.win._isAlwaysOnTop();
+    }
+    bringToFront() {
+        try {
+            this.win._bringToFront({});
+        }
+        catch (e) {
+            Logger.system.error("Implement bringToFront");
+        }
+    }
+    notifyWindowTitleBarOfGroupMembership() {
+        if (typeof RouterClient !== "undefined") {
+            RouterClient.transmit(`${this.name}.groupMembershipChange`, {
+                type: "joined",
+            });
+        }
+    }
+    notifyWindowTitleBarOfGroupEjection() {
+        if (typeof RouterClient !== "undefined") {
+            RouterClient.transmit(`${this.name}.groupMembershipChange`, {
+                type: "ejected",
+            });
+        }
+    }
+    addSnappedWindow(snapObj) {
+        if (!this.snappedWindows) {
+            this.snappedWindows = [];
+        }
+        let shouldAdd = true;
+        for (let i = 0; i < this.snappedWindows.length; i++) {
+            const snappedWin = this.snappedWindows[i];
+            if (snappedWin.name === snapObj.name) {
+                shouldAdd = false;
+                break;
+            }
+        }
+        if (shouldAdd) {
+            this.snappedWindows.push(snapObj);
+        }
+    }
+    removeSnappedWindow(name) {
+        if (this.snappedWindows) {
+            for (let i = 0; i < this.snappedWindows.length; i++) {
+                const snappedWin = this.snappedWindows[i];
+                if (name === snappedWin.name) {
+                    // Logger.system.log("Removing", name, "from", this.name);
+                    this.snappedWindows.splice(i, 1);
+                    return;
+                }
+            }
+        }
+    }
+    animatePositionAndHeight(params, cb) {
+        this.setInternalBounds(params);
+        if (this.win._setBounds) {
+            params.persistBounds = true;
+            this.win._setBounds({ bounds: params }, cb);
+        }
+    }
+    isGrouped() {
+        return this.groups.length > 0;
+    }
+    /**
+     * Adds eventListeners so that when the finWIndow moves, we can do things with that data.
+     */
+    addListeners() {
+        this.win.addEventListener(BOUNDS_CHANGING, this.onBoundsChanging);
+        this.win.addEventListener(BOUNDS_CHANGED, this.onBoundsChanged);
+        this.win.addEventListener("hidden", this.hiddenUnclaimSpace);
+        this.win.addEventListener("shown", this.unhiddenClaimSpace);
+        this.win.addEventListener("restored", this.restored);
+        this.win.addEventListener("maximized", this.maximized);
+        this.win.addEventListener(SYSTEM_BOUNDS_CHANGED, this.onSystemMovedWindow);
+    }
+}
+export default DockableWindow;
+//# sourceMappingURL=dockableWindow.js.map