@trudb/tru-common-lib 0.0.177 → 0.0.179

package/esm2020/lib/components/desktop/tru-desktop.mjs

@@ -0,0 +1,703 @@
+import { Component, Input } from '@angular/core';
+import { TruDesktopService } from './services/tru-desktop-service';
+import * as i0 from "@angular/core";
+import * as i1 from "./services/tru-desktop-service";
+import * as i2 from "../../services/tru-window-event-handler";
+import * as i3 from "@angular/common";
+import * as i4 from "./menubar/tru-desktop-menubar";
+import * as i5 from "./taskbar/tru-desktop-taskbar";
+import * as i6 from "./viewport/tru-desktop-viewport";
+export class TruDesktop {
+    constructor(desktopService, truWindowEventHandler) {
+        this.desktopService = desktopService;
+        this.truWindowEventHandler = truWindowEventHandler;
+        this.minimizeAll = false;
+        this.desktop = this.desktopService.createDesktop();
+        this.minWindowCascadePosition = 40;
+        this.maxWindowCascadePosition = 100;
+        this.lastWindowCascadePosition = { top: this.minWindowCascadePosition, left: this.minWindowCascadePosition };
+        this.shiftPressed = false;
+        this.altPressed = false;
+        this.xPressed = false;
+        this.keyboardMap = ["", "", "", "CANCEL", "", "", "HELP", "", "BACK_SPACE", "TAB", "", "", "CLEAR", "ENTER", "RETURN", "", "SHIFT", "CONTROL", "ALT", "PAUSE", "CAPS_LOCK", "KANA", "EISU", "JUNJA", "FINAL", "HANJA", "", "ESCAPE", "CONVERT", "NONCONVERT", "ACCEPT", "MODECHANGE", "SPACE", "PAGE_UP", "PAGE_DOWN", "END", "HOME", "LEFT", "UP", "RIGHT", "DOWN", "SELECT", "PRINT", "EXECUTE", "PRINTSCREEN", "INSERT", "DELETE", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "COLON", "SEMICOLON", "LESS_THAN", "EQUALS", "GREATER_THAN", "QUESTION_MARK", "AT", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "WIN", "", "CONTEXT_MENU", "", "SLEEP", "NUMPAD0", "NUMPAD1", "NUMPAD2", "NUMPAD3", "NUMPAD4", "NUMPAD5", "NUMPAD6", "NUMPAD7", "NUMPAD8", "NUMPAD9", "MULTIPLY", "ADD", "SEPARATOR", "SUBTRACT", "DECIMAL", "DIVIDE", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12", "F13", "F14", "F15", "F16", "F17", "F18", "F19", "F20", "F21", "F22", "F23", "F24", "", "", "", "", "", "", "", "", "NUM_LOCK", "SCROLL_LOCK", "WIN_OEM_FJ_JISHO", "WIN_OEM_FJ_MASSHOU", "WIN_OEM_FJ_TOUROKU", "WIN_OEM_FJ_LOYA", "WIN_OEM_FJ_ROYA", "", "", "", "", "", "", "", "", "", "CIRCUMFLEX", "EXCLAMATION", "DOUBLE_QUOTE", "HASH", "DOLLAR", "PERCENT", "AMPERSAND", "UNDERSCORE", "OPEN_PAREN", "CLOSE_PAREN", "ASTERISK", "PLUS", "PIPE", "HYPHEN_MINUS", "OPEN_CURLY_BRACKET", "CLOSE_CURLY_BRACKET", "TILDE", "", "", "", "", "VOLUME_MUTE", "VOLUME_DOWN", "VOLUME_UP", "", "", "", "", "COMMA", "", "PERIOD", "SLASH", "BACK_QUOTE", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "OPEN_BRACKET", "BACK_SLASH", "CLOSE_BRACKET", "QUOTE", "", "META", "ALTGR", "", "WIN_ICO_HELP", "WIN_ICO_00", "", "WIN_ICO_CLEAR", "", "", "WIN_OEM_RESET", "WIN_OEM_JUMP", "WIN_OEM_PA1", "WIN_OEM_PA2", "WIN_OEM_PA3", "WIN_OEM_WSCTRL", "WIN_OEM_CUSEL", "WIN_OEM_ATTN", "WIN_OEM_FINISH", "WIN_OEM_COPY", "WIN_OEM_AUTO", "WIN_OEM_ENLW", "WIN_OEM_BACKTAB", "ATTN", "CRSEL", "EXSEL", "EREOF", "PLAY", "ZOOM", "", "PA1", "WIN_OEM_CLEAR", ""];
+        this.logoUrl = null;
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.getDesktop
+         * @module tru.desktop
+         *
+         * @description
+         * Return an object of desktop.
+         *
+         * @returns {object} desktop.
+         */
+        this.getDesktop = () => {
+            return this.desktop;
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.getOptions
+         * @module tru.desktop
+         *
+         * @description
+         * Return an object of desktop options.
+         *
+         * @returns {object} options.
+         */
+        this.getOptions = () => {
+            return this.options;
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.getWindows
+         * @module tru.desktop
+         *
+         * @description
+         * Return an array of windows.
+         *
+         * @returns {array} windows.
+         */
+        this.getWindows = () => {
+            return this.windows;
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.getNextMaxZIndex
+         * @module tru.desktop
+         *
+         * @description
+         * Iterates through all window objects in the windows array to find the max z-index
+         * and increases the value found by 1.
+         *
+         * @returns {int}
+         */
+        this.getNextMaxZIndex = () => {
+            var max = 0;
+            var tmp;
+            for (var i = this.windows.length - 1; i >= 0; i--) {
+                tmp = this.windows[i].zIndex;
+                if (tmp > max)
+                    max = tmp;
+            }
+            return ++max;
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.clearActive
+         * @module tru.desktop
+         *
+         * @description
+         * Iterates through all window objects in the windows
+         * and sets the active property to false.
+         *
+         */
+        this.clearActive = () => {
+            this.windows.forEach((window) => {
+                window.active = false;
+            });
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.getActiveWindow
+         * @module tru.desktop
+         *
+         * @description
+         * Gets the active window.
+         *
+         * @returns {object} view object.
+         */
+        this.getActiveWindow = () => {
+            var activeWindow = null;
+            this.windows.forEach((wdw) => {
+                if (wdw.active === true) {
+                    activeWindow = wdw;
+                }
+            });
+            return activeWindow;
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.getActiveView
+         * @module tru.desktop
+         *
+         * @description
+         * Gets the active view.
+         *
+         * @returns {object} view object.
+         */
+        this.getActiveView = (wdw) => {
+            var activeView = null;
+            wdw.views.forEach((view) => {
+                if (view.active === true) {
+                    activeView = view;
+                }
+            });
+            return activeView;
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.allWindowsAreMinimized
+         * @module tru.desktop
+         *
+         * @description
+         * Iterates through windows to determine if all are minimized.
+         *
+         */
+        this.allWindowsAreMinimized = () => {
+            var allMinimized = true;
+            this.windows.forEach((window) => {
+                if (!window.minimized) {
+                    allMinimized = false;
+                }
+            });
+            return allMinimized;
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.hideShowAll
+         * @module tru.desktop
+         *
+         * @description
+         * Hides/shows all windows
+         *
+         */
+        this.hideShowAll = () => {
+            this.minimizeAll = this.allWindowsAreMinimized() ? false : !this.minimizeAll;
+            this.windows.forEach((wdw) => {
+                if (wdw.outOfBounds)
+                    this.recover(wdw);
+                wdw.active = false;
+                wdw.minimized = this.minimizeAll;
+            });
+            this.activateForemostWindow();
+            return this.minimizeAll;
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.findWindowViewDirective
+         * @module tru.desktop
+         *
+         * @description
+         * Looks for previously open window with a view directive
+         *
+         */
+        this.findWindowViewDirective = (windowViewDirective) => {
+            for (let i = 0; i < this.windows.length; i++) {
+                for (let j = 0; j < this.windows[i].views.length; j++) {
+                    if (this.windows[i].views[0].viewDirective === windowViewDirective)
+                        return this.windows[i];
+                }
+            }
+            return null;
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.openWindow
+         * @module tru.desktop
+         *
+         * @description
+         * Displays a new window. All window properties defined by the application developer will be
+         * overlaid here before displaying the window
+         *
+         */
+        this.openWindow = (windowConfigOverlays, singleInstance) => {
+            let activeWindow = this.getActiveWindow();
+            if (activeWindow && activeWindow.isModal) {
+                activeWindow.invalidOperation = true;
+                return;
+            }
+            if (singleInstance) {
+                let window = this.findWindowViewDirective(windowConfigOverlays.views[0].viewDirective);
+                if (window) {
+                    this.updateWindowState(window);
+                    return;
+                }
+            }
+            if (windowConfigOverlays.isModal) {
+                let heightOffset = (parseInt(windowConfigOverlays.height, 10) / 2) + 30;
+                let widthOffset = (parseInt(windowConfigOverlays.width, 10) / 2);
+                windowConfigOverlays.top = 'calc(50% - ' + heightOffset + 'px )';
+                windowConfigOverlays.left = 'calc(50% - ' + widthOffset + 'px )';
+            }
+            this.clearActive();
+            let configuredWindow = this.configureWindow(windowConfigOverlays);
+            configuredWindow.views = this.configureViews(windowConfigOverlays, configuredWindow);
+            if (!configuredWindow.isModal) {
+                configuredWindow.cascadeWindow = false;
+                this.savePosition(configuredWindow);
+                this.maximize(configuredWindow);
+                this.windows.push(configuredWindow);
+            }
+            else {
+                this.windows.push(configuredWindow);
+            }
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.configureWindow
+         * @module tru.desktop
+         *
+         * @description
+         * Creates a new window instance.
+         *
+         */
+        this.configureWindow = (windowConfigOverlays) => {
+            var windowConfigInstance = Object.assign({}, this.desktop.windowConfig);
+            windowConfigInstance.savedPosition = Object.create({ top: 0, left: 0, right: 0, bottom: 0, height: 0, width: 0 });
+            windowConfigInstance.zIndex = this.getNextMaxZIndex();
+            //windowConfigInstance.globals = Object.assign({}, $rootScope.$eval(this.options.globals));
+            return Object.assign(windowConfigInstance, windowConfigOverlays);
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.configureViews
+         * @module tru.desktop
+         *
+         * @description
+         * Creates one or more view instances
+         *
+         */
+        this.configureViews = (windowConfigOverlays, configuredWindow) => {
+            let configuredViews = [];
+            windowConfigOverlays.views.forEach((view) => {
+                let viewConfigInstance = Object.assign({}, this.desktop.viewConfig);
+                //viewConfigInstance.globals = this.options.globals;
+                let configuredView = Object.assign(viewConfigInstance, view);
+                configuredView.window = configuredWindow;
+                configuredViews.push(configuredView);
+            });
+            return configuredViews;
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.closeWindow
+         * @module tru.desktop
+         *
+         * @description
+         * Remove a window {object} from the windows array.
+         *
+         * @returns {boolean} returns true if window was closed, false if not closed.
+         */
+        this.closeWindow = (wdw) => {
+            if (!this.options.allowDirtyClose && wdw.isDirty) {
+                alert("Unsaved Changes. Save changes before closing window.");
+                return false;
+            }
+            if (!this.options.allowInvalidClose && wdw.isInvalid) {
+                alert("Data is invalid. Correct Invalid data before closing window.");
+                return false;
+            }
+            if (this.options.canCloseFn !== undefined) {
+                if (this.options.canCloseFn(wdw)) {
+                    this.windows.splice(this.windows.indexOf(wdw), 1);
+                    this.activateForemostWindow();
+                    return true;
+                }
+                ;
+            }
+            else {
+                this.windows.splice(this.windows.indexOf(wdw), 1);
+                this.activateForemostWindow();
+                return true;
+            }
+            return false;
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.activateForemostWindow
+         * @module tru.desktop
+         *
+         * @description
+         * Set the foremost window to an active state
+         *
+         */
+        this.activateForemostWindow = () => {
+            var foremost = undefined;
+            for (var i = 0; i < this.windows.length; i++) {
+                if ((foremost === undefined || this.windows[i].zIndex > foremost.zIndex) && !this.windows[i].minimized && !this.windows[i].outOfBounds)
+                    foremost = this.windows[i];
+            }
+            if (foremost)
+                foremost.active = true;
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.activateNextWindow
+         * @module tru.desktop
+         *
+         * @description
+         * Set the next window to an active state
+         *
+         */
+        this.activateNextWindow = (activeWindowLocation) => {
+            if (this.windows.length <= 1)
+                return;
+            var backend = this.windows.slice(activeWindowLocation);
+            var frontend = this.windows.slice(0, activeWindowLocation - 1);
+            var sorted = backend.concat(frontend);
+            var nextWindow = undefined;
+            for (var i = 0; i < sorted.length; i++) {
+                if (!sorted[i].minimized && !sorted[i].outOfBounds && !nextWindow)
+                    nextWindow = sorted[i];
+            }
+            if (nextWindow) {
+                this.clearActive();
+                nextWindow.zIndex = this.getNextMaxZIndex();
+                nextWindow.active = true;
+            }
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.activatePreviousWindow
+         * @module tru.desktop
+         *
+         * @description
+         * Set the previous window to an active state
+         *
+         */
+        this.activatePreviousWindow = (activeWindowLocation) => {
+            if (this.windows.length <= 1)
+                return;
+            var backend = this.windows.slice(activeWindowLocation);
+            var frontend = this.windows.slice(0, activeWindowLocation - 1);
+            var sorted = backend.concat(frontend);
+            var nextWindow = undefined;
+            for (var i = sorted.length - 1; i >= 0; i--) {
+                if (!sorted[i].minimized && !sorted[i].outOfBounds && !nextWindow)
+                    nextWindow = sorted[i];
+            }
+            if (nextWindow) {
+                this.clearActive();
+                nextWindow.zIndex = this.getNextMaxZIndex();
+                nextWindow.active = true;
+            }
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.minimize
+         * @module tru.desktop
+         *
+         * @description
+         * Visually removes window from the viewport.
+         *
+         */
+        this.minimize = (window) => {
+            this.savePosition(window);
+            window.active = false;
+            window.minimized = true;
+            this.activateForemostWindow();
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.maximize
+         * @module tru.desktop
+         *
+         * @description
+         * Positions window such that it fills the whole viewport.
+         *
+         */
+        this.maximize = (window) => {
+            window.top = 0;
+            window.left = 0;
+            window.right = 0;
+            window.bottom = 0;
+            window.height = 'auto';
+            window.width = '100%';
+            window.maximized = 'fill';
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.maximizeLeft
+         * @module tru.desktop
+         *
+         * @description
+         * Positions window such that it fills the left portion viewport.
+         *
+         */
+        this.maximizeLeft = (window) => {
+            window.split = true;
+            window.top = 0;
+            window.left = 0;
+            window.bottom = 0;
+            window.width = '50%';
+            window.height = 'auto';
+            window.maximized = 'left';
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.maximizeRight
+         * @module tru.desktop
+         *
+         * @description
+         * Positions window such that it fills the right portion viewport.
+         *
+         */
+        this.maximizeRight = (window) => {
+            window.top = 0;
+            window.left = '50%';
+            window.right = 0;
+            window.bottom = 0;
+            window.width = '50%';
+            window.height = 'auto';
+            window.maximized = 'right';
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.recover
+         * @module tru.desktop
+         *
+         * @description
+         * Brings window back into view when it has escaped the viewport.
+         *
+         */
+        this.recover = (window) => {
+            window.active = true;
+            window.outOfBounds = false;
+            window.minimized = false;
+            window.zIndex = this.getNextMaxZIndex();
+            this.cascadeWindow(window);
+            this.clearActive();
+            this.activateForemostWindow();
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.restore
+         * @module tru.desktop
+         *
+         * @description
+         *
+         */
+        this.restore = (wdw) => {
+            if (wdw.maximized === 'fill') {
+                this.maximize(wdw);
+            }
+            else if (wdw.maximized === 'left') {
+                this.maximizeLeft(wdw);
+            }
+            else if (wdw.maximized === 'right') {
+                this.maximizeRight(wdw);
+            }
+            this.updateWindowState(wdw);
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.bringToFront
+         * @module tru.desktop
+         *
+         * @description
+         *
+         */
+        this.updateWindowState = (wdw) => {
+            if (wdw.outOfBounds) {
+                this.recover(wdw);
+                return;
+            }
+            if (wdw.maximized === 'fill') {
+                this.maximize(wdw);
+            }
+            else if (wdw.maximized === 'left') {
+                this.maximizeLeft(wdw);
+            }
+            else if (wdw.maximized === 'right') {
+                this.maximizeRight(wdw);
+            }
+            this.clearActive();
+            wdw.active = true;
+            wdw.minimized = false;
+            wdw.zIndex = this.getNextMaxZIndex();
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.restoreSavedPosition
+         * @module tru.desktop
+         *
+         * @description
+         * Set the windows last know position to the current position.
+         *
+         */
+        this.restoreSavedPosition = (wdw) => {
+            this.clearActive();
+            wdw.top = wdw.savedPosition.top;
+            wdw.left = wdw.savedPosition.left;
+            wdw.right = wdw.savedPosition.right;
+            wdw.bottom = wdw.savedPosition.bottom;
+            wdw.height = wdw.savedPosition.height;
+            wdw.width = wdw.savedPosition.width;
+            wdw.maximized = undefined;
+            wdw.minimized = undefined;
+            wdw.active = true;
+            wdw.minimized = false;
+            wdw.zIndex = this.getNextMaxZIndex();
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.savePosition
+         * @module tru.desktop
+         *
+         * @description
+         * Save the windows last know position.
+         *
+         */
+        this.savePosition = (wdw) => {
+            wdw.savedPosition.top = wdw.top;
+            wdw.savedPosition.left = wdw.left;
+            wdw.savedPosition.right = wdw.right;
+            wdw.savedPosition.bottom = wdw.bottom;
+            wdw.savedPosition.height = wdw.height;
+            wdw.savedPosition.width = wdw.width;
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.closeWindow
+         * @module tru.desktop
+         *
+         * @description
+         * Moves a window to the next cascade position.
+         *
+         */
+        this.cascadeWindow = (window) => {
+            if (!this.options.enableWindowCascading || window.isModal)
+                return;
+            this.lastWindowCascadePosition.top += 10;
+            this.lastWindowCascadePosition.left += 10;
+            if (this.lastWindowCascadePosition.top > this.maxWindowCascadePosition)
+                this.lastWindowCascadePosition.top = this.minWindowCascadePosition;
+            if (this.lastWindowCascadePosition.left > this.maxWindowCascadePosition)
+                this.lastWindowCascadePosition.left = this.minWindowCascadePosition;
+            window.top = this.lastWindowCascadePosition.top + 'px';
+            window.left = this.lastWindowCascadePosition.left + 'px';
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.getKeyCode
+         * @module tru.desktop
+         *
+         * @description
+         *
+         */
+        this.getKeySequence = (event) => {
+            var keys = [];
+            if (event.shiftKey)
+                keys.push('shift');
+            if (event.ctrlKey)
+                keys.push('ctrl');
+            if (event.altKey)
+                keys.push('alt');
+            if (event.metaKey)
+                keys.push('meta');
+            var keyCode = event.keyCode || event.which;
+            if (keyCode)
+                keys.push(this.keyboardMap[keyCode].toLowerCase());
+            return keys.join('+');
+        };
+        /**
+         * @tru.doc event
+         * @module tru.desktop
+         *
+         * @description
+         *
+         */
+        this.onKeyDown = (event) => {
+            var keySequence = this.getKeySequence(event);
+            if (keySequence === 'alt+m') { //Maximize
+                var activeWindow = this.getActiveWindow();
+                if (activeWindow === null)
+                    return;
+                if (!activeWindow.maximized) {
+                    this.savePosition(activeWindow);
+                    this.maximize(activeWindow);
+                }
+                else if (activeWindow.maximized === 'right' || activeWindow.maximized === 'left')
+                    this.maximize(activeWindow);
+                else
+                    this.restoreSavedPosition(activeWindow);
+                event.preventDefault();
+            }
+            if (keySequence === 'alt+n') { //Minimize
+                var activeWindow = this.getActiveWindow();
+                if (activeWindow === null || activeWindow.minimized)
+                    return;
+                this.minimize(activeWindow);
+                event.preventDefault();
+            }
+            if (keySequence === 'alt+w') { //Cycles Forward
+                var index = this.windows.indexOf(this.getActiveWindow());
+                this.activateNextWindow(index + 1);
+                event.preventDefault();
+            }
+            if (keySequence === 'shift+alt+w') { //Cycles Backward
+                var index = this.windows.indexOf(this.getActiveWindow());
+                this.activatePreviousWindow(index + 1);
+                event.preventDefault();
+            }
+            if (keySequence === 'shift+alt+x' && !(this.shiftPressed && this.altPressed && this.xPressed)) { //Close
+                var activeWindow = this.getActiveWindow();
+                if (!activeWindow)
+                    return;
+                this.closeWindow(activeWindow);
+                event.preventDefault();
+            }
+            if (keySequence === 'alt+d') { //Toggle Desktop
+                //this.desktopShown = this.hideShowAll();
+                event.preventDefault();
+            }
+            if (event.shiftKey)
+                this.shiftPressed = true;
+            if (event.altKey)
+                this.altPressed = true;
+            if (event.keyCode === 88)
+                this.xPressed = true;
+        };
+        this.onKeyUp = (event) => {
+            if (event.shiftKey)
+                this.shiftPressed = false;
+            if (event.altKey)
+                this.altPressed = false;
+            if (event.keyCode === 88)
+                this.xPressed = false;
+        };
+        /**
+         * @tru.doc function
+         * @name truDesktopComponent.handleSelectAttempt
+         * @module tru.desktop
+         *
+         * @description
+         * Prevents the user from highlight desktop elements.
+         *
+         */
+        this.handleSelectAttempt = (e) => {
+            var nodeName = e.target.nodeName.toLowerCase();
+            if (nodeName === 'input' || nodeName === 'textarea' || nodeName === 'select')
+                return true;
+            if (window.event) {
+                e.preventDefault();
+            }
+            return true;
+        };
+        this.windows = [];
+    }
+    ngOnInit() {
+        this.logoUrl = this.options.logoUrl;
+        this.options = Object.assign(this.desktop.options, this.options);
+        this.options.viewportTop = this.options.menubarConfig !== undefined ? this.options.menubarHeight + 1 : 0;
+        this.truWindowEventHandler.onOpen().subscribe((windiowEvent) => {
+            this.openWindow(windiowEvent, false);
+        });
+        document.onselectstart = this.handleSelectAttempt;
+        window.addEventListener('keydown', this.onKeyDown);
+        window.addEventListener('keyup', this.onKeyUp);
+    }
+    ngOnDestroy() {
+        window.removeEventListener('keydown', this.onKeyDown);
+        window.removeEventListener('keyup', this.onKeyUp);
+    }
+}
+TruDesktop.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.2", ngImport: i0, type: TruDesktop, deps: [{ token: i1.TruDesktopService }, { token: i2.TruWindowEventHandler }], target: i0.ɵɵFactoryTarget.Component });
+TruDesktop.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.2", type: TruDesktop, selector: "tru-desktop", inputs: { options: "options" }, providers: [TruDesktopService], ngImport: i0, template: "<div class=\"desktop-wrapper\">\r\n\r\n  <div class=\"desktop-menubar-container\" [ngStyle]=\"{'height': options.menubarHeight + 'px'}\">\r\n    <tru-desktop-menubar [desktopCtrl]=\"this\"></tru-desktop-menubar>\r\n  </div>\r\n\r\n  <tru-desktop-viewport [windows]=\"windows\" [desktopCtrl]=\"this\"></tru-desktop-viewport>\r\n\r\n  <tru-desktop-taskbar [windows]=\"windows\" [desktopCtrl]=\"this\"></tru-desktop-taskbar>\r\n\r\n  <img class=\"desktop-viewport-logo\" data-ng-show=\"logoUrl\" alt=\"\">\r\n</div>\r\n", styles: ["body{-webkit-user-select:none;user-select:none}input,textarea{-moz-user-select:text}.desktop-text{-webkit-text-size-adjust:100%;-ms-text-size-adjust:100%;-webkit-tap-highlight-color:rgba(0,0,0,0);font-size:14px;line-height:1;color:#333}.desktop-wrapper{position:absolute!important;inset:0;background:#ffffff;overflow:hidden}.desktop-relative{position:relative}.desktop-display-none{display:none}.desktop-click-through{pointer-events:none}.desktop-menubar-container{position:absolute!important;top:0;left:0;right:0;height:26px;background:#f8f8f8;border-bottom:1px solid #e7e7e7;padding-left:5px}\n"], dependencies: [{ kind: "directive", type: i3.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "component", type: i4.TruDesktopMenubar, selector: "tru-desktop-menubar", inputs: ["desktopCtrl"] }, { kind: "component", type: i5.TruDesktopTaskbar, selector: "tru-desktop-taskbar", inputs: ["windows", "desktopCtrl"] }, { kind: "component", type: i6.TruDesktopViewport, selector: "tru-desktop-viewport", inputs: ["windows", "desktopCtrl"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.2", ngImport: i0, type: TruDesktop, decorators: [{
+            type: Component,
+            args: [{ selector: 'tru-desktop', providers: [TruDesktopService], template: "<div class=\"desktop-wrapper\">\r\n\r\n  <div class=\"desktop-menubar-container\" [ngStyle]=\"{'height': options.menubarHeight + 'px'}\">\r\n    <tru-desktop-menubar [desktopCtrl]=\"this\"></tru-desktop-menubar>\r\n  </div>\r\n\r\n  <tru-desktop-viewport [windows]=\"windows\" [desktopCtrl]=\"this\"></tru-desktop-viewport>\r\n\r\n  <tru-desktop-taskbar [windows]=\"windows\" [desktopCtrl]=\"this\"></tru-desktop-taskbar>\r\n\r\n  <img class=\"desktop-viewport-logo\" data-ng-show=\"logoUrl\" alt=\"\">\r\n</div>\r\n", styles: ["body{-webkit-user-select:none;user-select:none}input,textarea{-moz-user-select:text}.desktop-text{-webkit-text-size-adjust:100%;-ms-text-size-adjust:100%;-webkit-tap-highlight-color:rgba(0,0,0,0);font-size:14px;line-height:1;color:#333}.desktop-wrapper{position:absolute!important;inset:0;background:#ffffff;overflow:hidden}.desktop-relative{position:relative}.desktop-display-none{display:none}.desktop-click-through{pointer-events:none}.desktop-menubar-container{position:absolute!important;top:0;left:0;right:0;height:26px;background:#f8f8f8;border-bottom:1px solid #e7e7e7;padding-left:5px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.TruDesktopService }, { type: i2.TruWindowEventHandler }]; }, propDecorators: { options: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tru-desktop.js","sourceRoot":"","sources":["../../../../../../projects/tru-common-lib/src/lib/components/desktop/tru-desktop.ts","../../../../../../projects/tru-common-lib/src/lib/components/desktop/tru-desktop.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, Input } from '@angular/core';\r\nimport { TruWindowEvent } from '../../classes/tru-window-event';\r\nimport { TruWindowEventHandler } from '../../services/tru-window-event-handler';\nimport { TruDesktopService } from './services/tru-desktop-service';\n\n@Component({\n  selector: 'tru-desktop',\n  templateUrl: './tru-desktop.html',\n  styleUrls: ['./tru-desktop.css'],\n  providers: [TruDesktopService]\n})\nexport class TruDesktop implements OnInit {\n  @Input() options: any;\n\n  constructor(\n    private desktopService: TruDesktopService,\n    private truWindowEventHandler: TruWindowEventHandler) {\n  }\r\n\n  minimizeAll = false;\n  desktop = this.desktopService.createDesktop();\n  minWindowCascadePosition = 40;\n  maxWindowCascadePosition = 100;\n  lastWindowCascadePosition = { top: this.minWindowCascadePosition, left: this.minWindowCascadePosition };\n  shiftPressed = false;\n  altPressed = false;\n  xPressed = false;\n  keyboardMap = [\"\", \"\", \"\", \"CANCEL\", \"\", \"\", \"HELP\", \"\", \"BACK_SPACE\", \"TAB\", \"\", \"\", \"CLEAR\", \"ENTER\", \"RETURN\", \"\", \"SHIFT\", \"CONTROL\", \"ALT\", \"PAUSE\", \"CAPS_LOCK\", \"KANA\", \"EISU\", \"JUNJA\", \"FINAL\", \"HANJA\", \"\", \"ESCAPE\", \"CONVERT\", \"NONCONVERT\", \"ACCEPT\", \"MODECHANGE\", \"SPACE\", \"PAGE_UP\", \"PAGE_DOWN\", \"END\", \"HOME\", \"LEFT\", \"UP\", \"RIGHT\", \"DOWN\", \"SELECT\", \"PRINT\", \"EXECUTE\", \"PRINTSCREEN\", \"INSERT\", \"DELETE\", \"\", \"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"COLON\", \"SEMICOLON\", \"LESS_THAN\", \"EQUALS\", \"GREATER_THAN\", \"QUESTION_MARK\", \"AT\", \"A\", \"B\", \"C\", \"D\", \"E\", \"F\", \"G\", \"H\", \"I\", \"J\", \"K\", \"L\", \"M\", \"N\", \"O\", \"P\", \"Q\", \"R\", \"S\", \"T\", \"U\", \"V\", \"W\", \"X\", \"Y\", \"Z\", \"WIN\", \"\", \"CONTEXT_MENU\", \"\", \"SLEEP\", \"NUMPAD0\", \"NUMPAD1\", \"NUMPAD2\", \"NUMPAD3\", \"NUMPAD4\", \"NUMPAD5\", \"NUMPAD6\", \"NUMPAD7\", \"NUMPAD8\", \"NUMPAD9\", \"MULTIPLY\", \"ADD\", \"SEPARATOR\", \"SUBTRACT\", \"DECIMAL\", \"DIVIDE\", \"F1\", \"F2\", \"F3\", \"F4\", \"F5\", \"F6\", \"F7\", \"F8\", \"F9\", \"F10\", \"F11\", \"F12\", \"F13\", \"F14\", \"F15\", \"F16\", \"F17\", \"F18\", \"F19\", \"F20\", \"F21\", \"F22\", \"F23\", \"F24\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"NUM_LOCK\", \"SCROLL_LOCK\", \"WIN_OEM_FJ_JISHO\", \"WIN_OEM_FJ_MASSHOU\", \"WIN_OEM_FJ_TOUROKU\", \"WIN_OEM_FJ_LOYA\", \"WIN_OEM_FJ_ROYA\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"CIRCUMFLEX\", \"EXCLAMATION\", \"DOUBLE_QUOTE\", \"HASH\", \"DOLLAR\", \"PERCENT\", \"AMPERSAND\", \"UNDERSCORE\", \"OPEN_PAREN\", \"CLOSE_PAREN\", \"ASTERISK\", \"PLUS\", \"PIPE\", \"HYPHEN_MINUS\", \"OPEN_CURLY_BRACKET\", \"CLOSE_CURLY_BRACKET\", \"TILDE\", \"\", \"\", \"\", \"\", \"VOLUME_MUTE\", \"VOLUME_DOWN\", \"VOLUME_UP\", \"\", \"\", \"\", \"\", \"COMMA\", \"\", \"PERIOD\", \"SLASH\", \"BACK_QUOTE\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"OPEN_BRACKET\", \"BACK_SLASH\", \"CLOSE_BRACKET\", \"QUOTE\", \"\", \"META\", \"ALTGR\", \"\", \"WIN_ICO_HELP\", \"WIN_ICO_00\", \"\", \"WIN_ICO_CLEAR\", \"\", \"\", \"WIN_OEM_RESET\", \"WIN_OEM_JUMP\", \"WIN_OEM_PA1\", \"WIN_OEM_PA2\", \"WIN_OEM_PA3\", \"WIN_OEM_WSCTRL\", \"WIN_OEM_CUSEL\", \"WIN_OEM_ATTN\", \"WIN_OEM_FINISH\", \"WIN_OEM_COPY\", \"WIN_OEM_AUTO\", \"WIN_OEM_ENLW\", \"WIN_OEM_BACKTAB\", \"ATTN\", \"CRSEL\", \"EXSEL\", \"EREOF\", \"PLAY\", \"ZOOM\", \"\", \"PA1\", \"WIN_OEM_CLEAR\", \"\"];\n  logoUrl = null;\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.getDesktop\n   * @module tru.desktop\n   *\n   * @description\n   * Return an object of desktop.\n   *\n   * @returns {object} desktop.\n   */\n  getDesktop = () => {\n    return this.desktop;\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.getOptions\n   * @module tru.desktop\n   *\n   * @description\n   * Return an object of desktop options.\n   *\n   * @returns {object} options.\n   */\n  getOptions = () => {\n    return this.options;\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.getWindows\n   * @module tru.desktop\n   *\n   * @description\n   * Return an array of windows.\n   *\n   * @returns {array} windows.\n   */\n  getWindows = () => {\n    return this.windows;\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.getNextMaxZIndex\n   * @module tru.desktop\n   *\n   * @description\n   * Iterates through all window objects in the windows array to find the max z-index\n   * and increases the value found by 1.\n   *\n   * @returns {int}\n   */\n  getNextMaxZIndex = () => {\n    var max = 0;\n    var tmp;\n    for (var i = this.windows.length - 1; i >= 0; i--) {\n      tmp = this.windows[i].zIndex;\n      if (tmp > max) max = tmp;\n    }\n    return ++max;\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.clearActive\n   * @module tru.desktop\n   *\n   * @description\n   * Iterates through all window objects in the windows\n   * and sets the active property to false.\n   *\n   */\n  clearActive = () => {\n    this.windows.forEach((window: any) => {\n      window.active = false;\n    });\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.getActiveWindow\n   * @module tru.desktop\n   *\n   * @description\n   * Gets the active window.\n   *\n   * @returns {object} view object.\n   */\n  getActiveWindow = (): any => {\n    var activeWindow = null;\n    this.windows.forEach((wdw: any) => {\n      if (wdw.active === true) {\n        activeWindow = wdw;\n      }\n    });\n    return activeWindow;\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.getActiveView\n   * @module tru.desktop\n   *\n   * @description\n   * Gets the active view.\n   *\n   * @returns {object} view object.\n   */\n  getActiveView = (wdw: any) => {\n    var activeView = null;\n    wdw.views.forEach((view: any) => {\n      if (view.active === true) {\n        activeView = view;\n      }\n    });\n    return activeView;\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.allWindowsAreMinimized\n   * @module tru.desktop\n   *\n   * @description\n   * Iterates through windows to determine if all are minimized.\n   *\n   */\n  allWindowsAreMinimized = () => {\n    var allMinimized = true;\n    this.windows.forEach((window: any) => {\n      if (!window.minimized) {\n        allMinimized = false;\n      }\n    });\n    return allMinimized;\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.hideShowAll\n   * @module tru.desktop\n   *\n   * @description\n   * Hides/shows all windows\n   *\n   */\n  hideShowAll = () => {\n    this.minimizeAll = this.allWindowsAreMinimized() ? false : !this.minimizeAll;\n    this.windows.forEach((wdw: any) => {\n      if (wdw.outOfBounds) this.recover(wdw);\n      wdw.active = false;\n      wdw.minimized = this.minimizeAll;\n    });\n    this.activateForemostWindow();\n    return this.minimizeAll;\n  };\n\n  /**\r\n   * @tru.doc function\r\n   * @name truDesktopComponent.findWindowViewDirective\r\n   * @module tru.desktop\r\n   *\r\n   * @description\r\n   * Looks for previously open window with a view directive\r\n   *\r\n   */\r\n  findWindowViewDirective = (windowViewDirective: any) => {\r\n    for (let i = 0; i < this.windows.length; i++) {\r\n      for (let j = 0; j < this.windows[i].views.length; j++) {\r\n        if (this.windows[i].views[0].viewDirective === windowViewDirective)\r\n          return this.windows[i];\r\n      }\r\n    }\r\n    return null;\r\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.openWindow\n   * @module tru.desktop\n   *\n   * @description\n   * Displays a new window. All window properties defined by the application developer will be\n   * overlaid here before displaying the window\n   *\n   */\n  openWindow = (windowConfigOverlays: any, singleInstance: any) => {\n    let activeWindow = this.getActiveWindow();\r\n    if (activeWindow && activeWindow.isModal) {\r\n      activeWindow.invalidOperation = true;\r\n      return;\r\n    }\r\n\r\n    if (singleInstance) {\r\n      let window = this.findWindowViewDirective(windowConfigOverlays.views[0].viewDirective);\r\n      if (window) {\r\n        this.updateWindowState(window);\r\n        return;\r\n      }\r\n    }\r\n\r\n    if (windowConfigOverlays.isModal) {\r\n      let heightOffset = (parseInt(windowConfigOverlays.height, 10) / 2) + 30;\r\n      let widthOffset = (parseInt(windowConfigOverlays.width, 10) / 2);\r\n      windowConfigOverlays.top = 'calc(50% - ' + heightOffset + 'px )';\r\n      windowConfigOverlays.left = 'calc(50% - ' + widthOffset + 'px )';\r\n    }\r\n\r\n    this.clearActive();\r\n    let configuredWindow = this.configureWindow(windowConfigOverlays);\r\n    configuredWindow.views = this.configureViews(windowConfigOverlays, configuredWindow);\r\n    if (!configuredWindow.isModal) {\r\n      configuredWindow.cascadeWindow = false;\r\n      this.savePosition(configuredWindow);\r\n      this.maximize(configuredWindow);\r\n      this.windows.push(configuredWindow);\r\n    } else {\r\n      this.windows.push(configuredWindow);\r\n    }\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.configureWindow\n   * @module tru.desktop\n   *\n   * @description\n   * Creates a new window instance.\n   *\n   */\n  configureWindow = (windowConfigOverlays: any) => {\n    var windowConfigInstance = Object.assign({}, this.desktop.windowConfig);\n    windowConfigInstance.savedPosition = Object.create({ top: 0, left: 0, right: 0, bottom: 0, height: 0, width: 0 });\n    windowConfigInstance.zIndex = this.getNextMaxZIndex();\n    //windowConfigInstance.globals = Object.assign({}, $rootScope.$eval(this.options.globals));\n    return Object.assign(windowConfigInstance, windowConfigOverlays);\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.configureViews\n   * @module tru.desktop\n   *\n   * @description\n   * Creates one or more view instances\n   *\n   */\n  configureViews = (windowConfigOverlays: any, configuredWindow: any): Array<any> => {\n    let configuredViews: Array<any> = [];\n    windowConfigOverlays.views.forEach((view: any) => {\n      let viewConfigInstance = Object.assign({}, this.desktop.viewConfig);\n      //viewConfigInstance.globals = this.options.globals;\n      let configuredView = Object.assign(viewConfigInstance, view);\n      configuredView.window = configuredWindow;\n      configuredViews.push(configuredView);\n    });\n    return configuredViews;\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.closeWindow\n   * @module tru.desktop\n   *\n   * @description\n   * Remove a window {object} from the windows array.\n   *\n   * @returns {boolean} returns true if window was closed, false if not closed.\n   */\n  closeWindow = (wdw: any) => {\n    if (!this.options.allowDirtyClose && wdw.isDirty) {\n      alert(\"Unsaved Changes. Save changes before closing window.\");\n      return false;\n    }\n\n    if (!this.options.allowInvalidClose && wdw.isInvalid) {\n      alert(\"Data is invalid. Correct Invalid data before closing window.\");\n      return false;\n    }\n\n    if (this.options.canCloseFn !== undefined) {\n      if (this.options.canCloseFn(wdw)) {\n        this.windows.splice(this.windows.indexOf(wdw), 1);\n        this.activateForemostWindow();\n        return true;\n      };\n    } else {\n      this.windows.splice(this.windows.indexOf(wdw), 1);\n      this.activateForemostWindow();\n      return true;\n    }\n    return false;\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.activateForemostWindow\n   * @module tru.desktop\n   *\n   * @description\n   * Set the foremost window to an active state\n   *\n   */\n  activateForemostWindow = () => {\n    var foremost = undefined;\n    for (var i = 0; i < this.windows.length; i++) {\n      if ((foremost === undefined || this.windows[i].zIndex > foremost.zIndex) && !this.windows[i].minimized && !this.windows[i].outOfBounds)\n        foremost = this.windows[i];\n    }\n    if (foremost)\n      foremost.active = true;\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.activateNextWindow\n   * @module tru.desktop\n   *\n   * @description\n   * Set the next window to an active state\n   *\n   */\n  activateNextWindow = (activeWindowLocation: any) => {\n    if (this.windows.length <= 1) return;\n    var backend = this.windows.slice(activeWindowLocation);\n    var frontend = this.windows.slice(0, activeWindowLocation - 1);\n    var sorted = backend.concat(frontend);\n    var nextWindow = undefined;\n    for (var i = 0; i < sorted.length; i++) {\n      if (!sorted[i].minimized && !sorted[i].outOfBounds && !nextWindow)\n        nextWindow = sorted[i];\n    }\n\n    if (nextWindow) {\n      this.clearActive();\n      nextWindow.zIndex = this.getNextMaxZIndex();\n      nextWindow.active = true;\n    }\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.activatePreviousWindow\n   * @module tru.desktop\n   *\n   * @description\n   * Set the previous window to an active state\n   *\n   */\n  activatePreviousWindow = (activeWindowLocation: any) => {\n    if (this.windows.length <= 1) return;\n    var backend = this.windows.slice(activeWindowLocation);\n    var frontend = this.windows.slice(0, activeWindowLocation - 1);\n    var sorted = backend.concat(frontend);\n    var nextWindow = undefined;\n    for (var i = sorted.length - 1; i >= 0; i--) {\n      if (!sorted[i].minimized && !sorted[i].outOfBounds && !nextWindow)\n        nextWindow = sorted[i];\n    }\n\n    if (nextWindow) {\n      this.clearActive();\n      nextWindow.zIndex = this.getNextMaxZIndex();\n      nextWindow.active = true;\n    }\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.minimize\n   * @module tru.desktop\n   *\n   * @description\n   * Visually removes window from the viewport.\n   *\n   */\n  minimize = (window: any) => {\n    this.savePosition(window);\n\n    window.active = false;\n    window.minimized = true;\n    this.activateForemostWindow();\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.maximize\n   * @module tru.desktop\n   *\n   * @description\n   * Positions window such that it fills the whole viewport.\n   *\n   */\n  maximize = (window: any) => {\n    window.top = 0;\n    window.left = 0;\n    window.right = 0;\n    window.bottom = 0;\n    window.height = 'auto';\n    window.width = '100%';\n    window.maximized = 'fill';\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.maximizeLeft\n   * @module tru.desktop\n   *\n   * @description\n   * Positions window such that it fills the left portion viewport.\n   *\n   */\n  maximizeLeft = (window: any) => {\n    window.split = true;\n    window.top = 0;\n    window.left = 0;\n    window.bottom = 0;\n    window.width = '50%';\n    window.height = 'auto';\n    window.maximized = 'left';\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.maximizeRight\n   * @module tru.desktop\n   *\n   * @description\n   * Positions window such that it fills the right portion viewport.\n   *\n   */\n  maximizeRight = (window: any) => {\n    window.top = 0;\n    window.left = '50%';\n    window.right = 0;\n    window.bottom = 0;\n    window.width = '50%';\n    window.height = 'auto';\n    window.maximized = 'right';\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.recover\n   * @module tru.desktop\n   *\n   * @description\n   * Brings window back into view when it has escaped the viewport.\n   *\n   */\n  recover = (window: any) => {\n    window.active = true;\n    window.outOfBounds = false;\n    window.minimized = false;\n    window.zIndex = this.getNextMaxZIndex();\n    this.cascadeWindow(window);\n    this.clearActive();\n    this.activateForemostWindow();\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.restore\n   * @module tru.desktop\n   *\n   * @description\n   *\n   */\n  restore = (wdw: any) => {\n    if (wdw.maximized === 'fill') {\n      this.maximize(wdw);\n    } else if (wdw.maximized === 'left') {\n      this.maximizeLeft(wdw);\n    } else if (wdw.maximized === 'right') {\n      this.maximizeRight(wdw);\n    }\n    this.updateWindowState(wdw);\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.bringToFront\n   * @module tru.desktop\n   *\n   * @description\n   *\n   */\n  updateWindowState = (wdw: any) => {\r\n    if (wdw.outOfBounds) {\r\n      this.recover(wdw);\r\n      return;\r\n    }\r\n\r\n    if (wdw.maximized === 'fill') {\r\n      this.maximize(wdw);\r\n    } else if (wdw.maximized === 'left') {\r\n      this.maximizeLeft(wdw);\r\n    } else if (wdw.maximized === 'right') {\r\n      this.maximizeRight(wdw);\r\n    }\r\n    this.clearActive();\r\n    wdw.active = true;\r\n    wdw.minimized = false;\r\n    wdw.zIndex = this.getNextMaxZIndex();\r\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.restoreSavedPosition\n   * @module tru.desktop\n   *\n   * @description\n   * Set the windows last know position to the current position.\n   *\n   */\n  restoreSavedPosition = (wdw: any) => {\n    this.clearActive();\n    wdw.top = wdw.savedPosition.top;\n    wdw.left = wdw.savedPosition.left;\n    wdw.right = wdw.savedPosition.right;\n    wdw.bottom = wdw.savedPosition.bottom;\n    wdw.height = wdw.savedPosition.height;\n    wdw.width = wdw.savedPosition.width;\n    wdw.maximized = undefined;\n    wdw.minimized = undefined;\n    wdw.active = true;\n    wdw.minimized = false;\n    wdw.zIndex = this.getNextMaxZIndex();\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.savePosition\n   * @module tru.desktop\n   *\n   * @description\n   * Save the windows last know position.\n   *\n   */\n  savePosition = (wdw: any) => {\n    wdw.savedPosition.top = wdw.top;\n    wdw.savedPosition.left = wdw.left;\n    wdw.savedPosition.right = wdw.right;\n    wdw.savedPosition.bottom = wdw.bottom;\n    wdw.savedPosition.height = wdw.height;\n    wdw.savedPosition.width = wdw.width;\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.closeWindow\n   * @module tru.desktop\n   *\n   * @description\n   * Moves a window to the next cascade position.\n   *\n   */\n  cascadeWindow = (window: any) => {\n    if (!this.options.enableWindowCascading || window.isModal) return;\n    this.lastWindowCascadePosition.top += 10;\n    this.lastWindowCascadePosition.left += 10;\n    if (this.lastWindowCascadePosition.top > this.maxWindowCascadePosition)\n      this.lastWindowCascadePosition.top = this.minWindowCascadePosition;\n    if (this.lastWindowCascadePosition.left > this.maxWindowCascadePosition)\n      this.lastWindowCascadePosition.left = this.minWindowCascadePosition;\n\n    window.top = this.lastWindowCascadePosition.top + 'px';\n    window.left = this.lastWindowCascadePosition.left + 'px';\n  };\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.getKeyCode\n   * @module tru.desktop\n   *\n   * @description\n   *\n   */\n  getKeySequence = (event: any) => {\n    var keys = [];\n    if (event.shiftKey) keys.push('shift');\n    if (event.ctrlKey) keys.push('ctrl');\n    if (event.altKey) keys.push('alt');\n    if (event.metaKey) keys.push('meta');\n\n    var keyCode = event.keyCode || event.which;\n    if (keyCode) keys.push(this.keyboardMap[keyCode].toLowerCase());\n\n    return keys.join('+');\n  };\n\n  /**\n   * @tru.doc event\n   * @module tru.desktop\n   *\n   * @description\n   *\n   */\n  onKeyDown = (event: any) => {\n    var keySequence = this.getKeySequence(event);\n    if (keySequence === 'alt+m') { //Maximize\n      var activeWindow = this.getActiveWindow();\n      if (activeWindow === null) return;\n      if (!activeWindow.maximized) {\n        this.savePosition(activeWindow);\n        this.maximize(activeWindow);\n      } else if (activeWindow.maximized === 'right' || activeWindow.maximized === 'left')\n        this.maximize(activeWindow);\n      else\n        this.restoreSavedPosition(activeWindow);\n      event.preventDefault();\n    }\n    if (keySequence === 'alt+n') { //Minimize\n      var activeWindow = this.getActiveWindow();\n      if (activeWindow === null || activeWindow.minimized) return;\n      this.minimize(activeWindow);\n      event.preventDefault();\n    }\n    if (keySequence === 'alt+w') { //Cycles Forward\n      var index = this.windows.indexOf(this.getActiveWindow());\n      this.activateNextWindow(index + 1);\n      event.preventDefault();\n    }\n    if (keySequence === 'shift+alt+w') { //Cycles Backward\n      var index = this.windows.indexOf(this.getActiveWindow());\n      this.activatePreviousWindow(index + 1);\n      event.preventDefault();\n    }\n    if (keySequence === 'shift+alt+x' && !(this.shiftPressed && this.altPressed && this.xPressed)) { //Close\n      var activeWindow = this.getActiveWindow();\n      if (!activeWindow) return;\n      this.closeWindow(activeWindow);\n      event.preventDefault();\n    }\n    if (keySequence === 'alt+d') { //Toggle Desktop\n      //this.desktopShown = this.hideShowAll();\n      event.preventDefault();\n    }\n\n    if (event.shiftKey)\n      this.shiftPressed = true;\n    if (event.altKey)\n      this.altPressed = true;\n    if (event.keyCode === 88)\n      this.xPressed = true;\n  }\n\n  onKeyUp = (event: any) => {\n    if (event.shiftKey)\n      this.shiftPressed = false;\n    if (event.altKey)\n      this.altPressed = false;\n    if (event.keyCode === 88)\n      this.xPressed = false;\n  }\n\n  /**\n   * @tru.doc function\n   * @name truDesktopComponent.handleSelectAttempt\n   * @module tru.desktop\n   *\n   * @description\n   * Prevents the user from highlight desktop elements.\n   *\n   */\n  handleSelectAttempt = (e: any) => {\n    var nodeName = e.target.nodeName.toLowerCase();\n    if (nodeName === 'input' || nodeName === 'textarea' || nodeName === 'select') return true;\n    if (window.event) { e.preventDefault(); }\n    return true;\n  }\n\n  windows: Array<any> = [];\n\n  ngOnInit(): void {\r\n    this.logoUrl = this.options.logoUrl;\r\n    this.options = Object.assign(this.desktop.options, this.options);\r\n    this.options.viewportTop = this.options.menubarConfig !== undefined ? this.options.menubarHeight + 1 : 0;\r\n    this.truWindowEventHandler.onOpen().subscribe((windiowEvent: TruWindowEvent) => {\r\n      this.openWindow(windiowEvent, false);\r\n    });\r\n    document.onselectstart = this.handleSelectAttempt;\r\n    window.addEventListener('keydown', this.onKeyDown);\r\n    window.addEventListener('keyup', this.onKeyUp);\r\n  }\n\n  ngOnDestroy() {\n    window.removeEventListener('keydown', this.onKeyDown);\n    window.removeEventListener('keyup', this.onKeyUp);\n  }\n}\n","<div class=\"desktop-wrapper\">\r\n\r\n  <div class=\"desktop-menubar-container\" [ngStyle]=\"{'height': options.menubarHeight + 'px'}\">\r\n    <tru-desktop-menubar [desktopCtrl]=\"this\"></tru-desktop-menubar>\r\n  </div>\r\n\r\n  <tru-desktop-viewport [windows]=\"windows\" [desktopCtrl]=\"this\"></tru-desktop-viewport>\r\n\r\n  <tru-desktop-taskbar [windows]=\"windows\" [desktopCtrl]=\"this\"></tru-desktop-taskbar>\r\n\r\n  <img class=\"desktop-viewport-logo\" data-ng-show=\"logoUrl\" alt=\"\">\r\n</div>\r\n"]}