qms-angular 1.0.86 → 1.0.87

package/esm2015/lib/qms-ckeditor-components/common/flowchart/service/kitchensink-service.js

@@ -0,0 +1,412 @@
+/*! Rappid v3.3.0 - HTML5 Diagramming Framework
+
+Copyright (c) 2021 client IO
+
+ 2021-02-12
+
+
+This Source Code Form is subject to the terms of the Rappid License
+, v. 2.0. If a copy of the Rappid License was not distributed with this
+file, You can obtain one at http://jointjs.com/license/rappid_v2.txt
+ or from the Rappid archive as was distributed by client IO. See the LICENSE file.*/
+import { __awaiter } from "tslib";
+// import * as joint from '@clientio/rappid'
+import * as dagre from 'dagre';
+import * as _ from 'lodash';
+import * as appShapes from '../models/app-shapes';
+import HaloFunction from '../config/halo.function';
+import StencilFunction from '../config/stencil.function';
+import ToolbartFunction from '../config/toolbar.function';
+import InspectorFunction from '../config/inspector.function';
+import { FlowChartConst } from '../../constants/ckeditorFlowchart.const';
+class KitchenSinkService {
+    constructor(el, keyboardService, LANG) {
+        // backwards compatibility for older shapes
+        this.exportStylesheet = '.scalable * { vector-effect: non-scaling-stroke }';
+        this.el = el;
+        // apply current joint js theme
+        const view = new joint.mvc.View({ el });
+        view.delegateEvents({
+            'mouseup input[type="range"]': (evt) => evt.target.blur()
+        });
+        this.keyboardService = keyboardService;
+        this.LANG = LANG;
+    }
+    startRappid() {
+        joint.setTheme('modern');
+        this.initializePaper();
+        this.initializeStencil();
+        this.initializeSelection();
+        this.initializeToolsAndInspector();
+        this.initializeNavigator();
+        this.initializeToolbar();
+        this.initializeKeyboardShortcuts();
+        this.initializeTooltips();
+    }
+    initializePaper() {
+        const graph = this.graph = new joint.dia.Graph({}, {
+            cellNamespace: appShapes
+        });
+        graph.on('add', (cell, collection, opt) => {
+            if (opt.stencil) {
+                return joint.ui.Inspector.create('.inspector-container', _.extend({
+                    cell: cell
+                }, InspectorFunction.getInspectorConfiguration(this.LANG)[cell.get('type')]));
+            }
+        });
+        this.commandManager = new joint.dia.CommandManager({ graph: graph });
+        const paper = this.paper = new joint.dia.Paper({
+            width: 1000,
+            height: 1000,
+            gridSize: 10,
+            drawGrid: true,
+            model: graph,
+            cellViewNamespace: appShapes,
+            defaultLink: new appShapes.app.Link(),
+            defaultConnectionPoint: appShapes.app.Link.connectionPoint,
+            interactive: { linkMove: false },
+            async: true,
+            sorting: joint.dia.Paper.sorting.APPROX
+        });
+        paper.on('blank:mousewheel', _.partial(this.onMousewheel, null), this);
+        paper.on('cell:mousewheel', this.onMousewheel.bind(this));
+        this.snaplines = new joint.ui.Snaplines({ paper: paper });
+        const paperScroller = this.paperScroller = new joint.ui.PaperScroller({
+            paper,
+            autoResizePaper: true,
+            scrollWhileDragging: true,
+            cursor: 'grab'
+        });
+        this.renderPlugin('.paper-container', paperScroller);
+        paperScroller.render().center();
+    }
+    initializeStencil() {
+        this.stencil = new joint.ui.Stencil({
+            paper: this.paperScroller,
+            snaplines: this.snaplines,
+            width: 240,
+            groups: StencilFunction.getStencilGroups(),
+            dropAnimation: true,
+            groupsToggleButtons: true,
+            paperOptions: function () {
+                return {
+                    model: new joint.dia.Graph({}, {
+                        cellNamespace: appShapes
+                    }),
+                    cellViewNamespace: appShapes
+                };
+            },
+            search: {
+                '*': ['type', 'attrs/text/text', 'attrs/root/dataTooltip', 'attrs/label/text'],
+                'org.Member': ['attrs/.rank/text', 'attrs/root/dataTooltip', 'attrs/.name/text']
+            },
+            // Use default Grid Layout
+            layout: true,
+            // Remove tooltip definition from clone
+            dragStartClone: (cell) => cell.clone().removeAttr('root/dataTooltip')
+        });
+        this.renderPlugin('.stencil-container', this.stencil);
+        this.stencil.load(StencilFunction.getStencilShapes(this.LANG));
+    }
+    initializeSelection() {
+        this.clipboard = new joint.ui.Clipboard();
+        this.selection = new joint.ui.Selection({ paper: this.paper, useModelGeometry: true });
+        this.selection.collection.on('reset add remove', this.onSelectionChange.bind(this));
+        const keyboard = this.keyboardService.keyboard;
+        // Initiate selecting when the user grabs the blank area of the paper while the Shift key is pressed.
+        // Otherwise, initiate paper pan.
+        this.paper.on('blank:pointerdown', (evt, x, y) => {
+            if (keyboard.isActive('shift', evt)) {
+                this.selection.startSelecting(evt);
+            }
+            else {
+                this.selection.collection.reset([]);
+                this.paperScroller.startPanning(evt);
+                this.paper.removeTools();
+            }
+        });
+        this.paper.on('element:pointerdown', (elementView, evt) => {
+            // Select an element if CTRL/Meta key is pressed while the element is clicked.
+            if (keyboard.isActive('ctrl meta', evt)) {
+                if (this.selection.collection.find(function (cell) { return cell.isLink(); })) {
+                    // Do not allow mixing links and elements in the selection
+                    this.selection.collection.reset([elementView.model]);
+                }
+                else {
+                    this.selection.collection.add(elementView.model);
+                }
+            }
+        });
+        this.selection.on('selection-box:pointerdown', (elementView, evt) => {
+            // Unselect an element if the CTRL/Meta key is pressed while a selected element is clicked.
+            if (keyboard.isActive('ctrl meta', evt)) {
+                evt.preventDefault();
+                this.selection.collection.remove(elementView.model);
+            }
+        });
+    }
+    getImageContent() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                this.paper.toPNG((imageData) => {
+                    resolve(imageData);
+                });
+            });
+        });
+    }
+    getJsonContent() {
+        return JSON.stringify(this.graph.toJSON());
+    }
+    onSelectionChange() {
+        const { paper, selection } = this;
+        const { collection } = selection;
+        paper.removeTools();
+        joint.ui.Halo.clear(paper);
+        joint.ui.FreeTransform.clear(paper);
+        joint.ui.Inspector.close();
+        if (collection.length === 1) {
+            const primaryCell = collection.first();
+            const primaryCellView = paper.requireView(primaryCell);
+            selection.destroySelectionBox(primaryCell);
+            this.selectPrimaryCell(primaryCellView);
+        }
+        else if (collection.length === 2) {
+            collection.each(function (cell) {
+                selection.createSelectionBox(cell);
+            });
+        }
+    }
+    selectPrimaryCell(cellView) {
+        const cell = cellView.model;
+        if (cell.isElement()) {
+            this.selectPrimaryElement(cellView);
+        }
+        else {
+            this.selectPrimaryLink(cellView);
+        }
+        joint.ui.Inspector.create('.inspector-container', _.extend({
+            cell: cell
+        }, InspectorFunction.getInspectorConfiguration(this.LANG)[cell.get('type')]));
+    }
+    selectPrimaryElement(elementView) {
+        const element = elementView.model;
+        new joint.ui.FreeTransform({
+            cellView: elementView,
+            allowRotation: false,
+            preserveAspectRatio: !!element.get('preserveAspectRatio'),
+            allowOrthogonalResize: element.get('allowOrthogonalResize') !== false
+        }).render();
+        new joint.ui.Halo({
+            cellView: elementView,
+            handles: HaloFunction.getHaloConfiguration(this.LANG),
+            useModelGeometry: true
+        }).render();
+    }
+    selectPrimaryLink(linkView) {
+        const ns = joint.linkTools;
+        const toolsView = new joint.dia.ToolsView({
+            name: 'link-pointerdown',
+            tools: [
+                new ns.Vertices(),
+                new ns.SourceAnchor(),
+                new ns.TargetAnchor(),
+                new ns.SourceArrowhead(),
+                new ns.TargetArrowhead(),
+                new ns.Segments,
+                new ns.Boundary({ padding: 15 }),
+                new ns.Remove({ offset: -20, distance: 40 })
+            ]
+        });
+        linkView.addTools(toolsView);
+    }
+    initializeToolsAndInspector() {
+        this.paper.on('cell:pointerup', (cellView) => {
+            const cell = cellView.model;
+            const { collection } = this.selection;
+            if (collection.includes(cell)) {
+                return;
+            }
+            collection.reset([cell]);
+        });
+        this.paper.on('link:mouseenter', (linkView) => {
+            // Open tool only if there is none yet
+            if (linkView.hasTools()) {
+                return;
+            }
+            const ns = joint.linkTools;
+            const toolsView = new joint.dia.ToolsView({
+                name: 'link-hover',
+                tools: [
+                    new ns.Vertices({ vertexAdding: false }),
+                    new ns.SourceArrowhead(),
+                    new ns.TargetArrowhead()
+                ]
+            });
+            linkView.addTools(toolsView);
+        });
+        this.paper.on('link:mouseleave', (linkView) => {
+            // Remove only the hover tool, not the pointerdown tool
+            if (linkView.hasTools('link-hover')) {
+                linkView.removeTools();
+            }
+        });
+        this.graph.on('change', (cell, opt) => {
+            if (!cell.isLink() || !opt.inspector) {
+                return;
+            }
+            const ns = joint.linkTools;
+            const toolsView = new joint.dia.ToolsView({
+                name: 'link-inspected',
+                tools: [
+                    new ns.Boundary({ padding: 15 }),
+                ]
+            });
+            cell.findView(this.paper).addTools(toolsView);
+        });
+    }
+    initializeNavigator() {
+        const navigator = this.navigator = new joint.ui.Navigator({
+            width: 240,
+            height: 115,
+            paperScroller: this.paperScroller,
+            zoom: false,
+            paperOptions: {
+                async: true,
+                sorting: joint.dia.Paper.sorting.NONE,
+                elementView: appShapes.NavigatorElementView,
+                linkView: appShapes.NavigatorLinkView,
+                cellViewNamespace: { /* no other views are accessible in the navigator */}
+            }
+        });
+        this.renderPlugin('.navigator-container', navigator);
+    }
+    initializeToolbar() {
+        const { groups, tools } = ToolbartFunction.getToolbarConfiguration(this.LANG);
+        this.toolbar = new joint.ui.Toolbar({
+            groups,
+            tools,
+            autoToggle: true,
+            references: {
+                paperScroller: this.paperScroller,
+                commandManager: this.commandManager
+            }
+        });
+        this.toolbar.on({
+            'svg:pointerclick': this.openAsSVG.bind(this),
+            'png:pointerclick': this.openAsPNG.bind(this),
+            'to-front:pointerclick': this.applyOnSelection.bind(this, 'toFront'),
+            'to-back:pointerclick': this.applyOnSelection.bind(this, 'toBack'),
+            'layout:pointerclick': this.layoutDirectedGraph.bind(this),
+            'snapline:change': this.changeSnapLines.bind(this),
+            'clear:pointerclick': this.graph.clear.bind(this.graph),
+            'print:pointerclick': this.paper.print.bind(this.paper),
+            'grid-size:change': this.paper.setGridSize.bind(this.paper),
+            'selectTemplate:option:select': this.onChangeTemplate,
+            'deleteTemplate:pointerclick': this.onDeleteTemplate,
+            'saveAsTemplate:pointerclick': this.onSaveAsTemplate,
+            'resetTemplate:pointerclick': this.onResetTemplate
+        });
+        this.renderPlugin('.toolbar-container', this.toolbar);
+    }
+    applyOnSelection(method) {
+        this.graph.startBatch('selection');
+        this.selection.collection.models.forEach(function (model) { model[method](); });
+        this.graph.stopBatch('selection');
+    }
+    changeSnapLines(checked) {
+        if (checked) {
+            this.snaplines.startListening();
+            this.stencil.options.snaplines = this.snaplines;
+        }
+        else {
+            this.snaplines.stopListening();
+            this.stencil.options.snaplines = null;
+        }
+    }
+    initializeKeyboardShortcuts() {
+        this.keyboardService.create(this.graph, this.clipboard, this.selection, this.paperScroller, this.commandManager);
+    }
+    initializeTooltips() {
+        return new joint.ui.Tooltip({
+            rootTarget: document.body,
+            target: '[data-tooltip]',
+            direction: joint.ui.Tooltip.TooltipArrowPosition.Auto,
+            padding: 10
+        });
+    }
+    openAsSVG() {
+        this.paper.hideTools().toSVG((svg) => {
+            new joint.ui.Lightbox({
+                image: 'data:image/svg+xml,' + encodeURIComponent(svg),
+                downloadable: true,
+                fileName: 'Rappid'
+            }).open();
+            this.paper.showTools();
+        }, {
+            preserveDimensions: true,
+            convertImagesToDataUris: true,
+            useComputedStyles: false,
+            stylesheet: this.exportStylesheet
+        });
+    }
+    openAsPNG() {
+        this.paper.hideTools().toPNG((dataURL) => {
+            new joint.ui.Lightbox({
+                image: dataURL,
+                downloadable: true,
+                fileName: 'Rappid'
+            }).open();
+            this.paper.showTools();
+        }, {
+            padding: 10,
+            useComputedStyles: false,
+            stylesheet: this.exportStylesheet
+        });
+    }
+    onMousewheel(cellView, evt, ox, oy, delta) {
+        if (this.keyboardService.keyboard.isActive('alt', evt)) {
+            evt.preventDefault();
+            this.paperScroller.zoom(delta * 0.2, { min: 0.2, max: 5, grid: 0.2, ox, oy });
+        }
+    }
+    layoutDirectedGraph() {
+        joint.layout.DirectedGraph.layout(this.graph, {
+            graphlib: dagre.graphlib,
+            dagre: dagre,
+            setVertices: true,
+            rankDir: 'TB',
+            marginX: 100,
+            marginY: 100
+        });
+        this.paperScroller.centerContent();
+    }
+    renderPlugin(selector, plugin) {
+        this.el.querySelector(selector).appendChild(plugin.el);
+        plugin.render();
+    }
+    onChangeTemplate(event) {
+        if (event.jsonContent) {
+            window[FlowChartConst.KS_SELECTED_FLOWCHART_ID] = event.flowChartId;
+            window[FlowChartConst.KS_SELECTED_JSONCONTENT] = event.jsonContent;
+            window.postMessage(FlowChartConst.KS_CHANGE_TEMPLATE, '*');
+        }
+    }
+    onDeleteTemplate(event) {
+        if (window[FlowChartConst.KS_IS_SELECTED_TEMPLATE]) {
+            window.postMessage(FlowChartConst.KS_DELETE_TEMPLATE, '*');
+        }
+        else {
+            window.postMessage(FlowChartConst.MUST_SELECT_TEMPLATE, '*');
+        }
+    }
+    onSaveAsTemplate() {
+        window.postMessage(FlowChartConst.KS_SAVE_AS_TEMPLATE, '*');
+    }
+    onResetTemplate() {
+        if (window[FlowChartConst.KS_IS_SELECTED_TEMPLATE]) {
+            window.postMessage(FlowChartConst.KS_RESET_TEMPLATE, '*');
+        }
+    }
+}
+export default KitchenSinkService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kitchensink-service.js","sourceRoot":"","sources":["../../../../../../../../projects/qms-angular/src/lib/qms-ckeditor-components/common/flowchart/service/kitchensink-service.ts"],"names":[],"mappings":"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","sourcesContent":["/*! Rappid v3.3.0 - HTML5 Diagramming Framework\r\n\r\nCopyright (c) 2021 client IO\r\n\r\n 2021-02-12 \r\n\r\n\r\nThis Source Code Form is subject to the terms of the Rappid License\r\n, v. 2.0. If a copy of the Rappid License was not distributed with this\r\nfile, You can obtain one at http://jointjs.com/license/rappid_v2.txt\r\n or from the Rappid archive as was distributed by client IO. See the LICENSE file.*/\r\n\r\n// import * as joint from '@clientio/rappid'\r\nimport * as dagre from 'dagre';\r\nimport * as _ from 'lodash';\r\nimport { KeyboardService } from './keyboard-service';\r\nimport * as appShapes from '../models/app-shapes';\r\nimport HaloFunction from '../config/halo.function';\r\nimport StencilFunction from '../config/stencil.function';\r\nimport ToolbartFunction from '../config/toolbar.function';\r\nimport InspectorFunction from '../config/inspector.function';\r\nimport { FlowChartConst } from '../../constants/ckeditorFlowchart.const';\r\ndeclare var joint: any;\r\nclass KitchenSinkService {\r\n    LANG: any\r\n    el: Element;\r\n\r\n    // graph: joint.dia.Graph;\r\n    // paper: joint.dia.Paper;\r\n    // paperScroller: joint.ui.PaperScroller;\r\n\r\n    // commandManager: joint.dia.CommandManager;\r\n    // snaplines: joint.ui.Snaplines;\r\n    // clipboard: joint.ui.Clipboard;\r\n    // selection: joint.ui.Selection;\r\n    // navigator: joint.ui.Navigator;\r\n    // stencil: joint.ui.Stencil\r\n    // toolbar: joint.ui.Toolbar\r\n    graph: any;\r\n    paper: any;\r\n    paperScroller: any;\r\n\r\n    commandManager: any;\r\n    snaplines: any;\r\n    clipboard: any;\r\n    selection: any;\r\n    navigator: any;\r\n    stencil: any;\r\n    toolbar: any;\r\n\r\n    keyboardService: KeyboardService;\r\n\r\n    constructor(\r\n        el: Element,\r\n        keyboardService: KeyboardService,\r\n        LANG: any\r\n    ) {\r\n        this.el = el;\r\n\r\n        // apply current joint js theme\r\n        const view = new joint.mvc.View({ el });\r\n        view.delegateEvents({\r\n            'mouseup input[type=\"range\"]': (evt) => evt.target.blur()\r\n        });\r\n\r\n        this.keyboardService = keyboardService;\r\n        this.LANG = LANG\r\n    }\r\n\r\n    startRappid() {\r\n\r\n        joint.setTheme('modern');\r\n\r\n        this.initializePaper();\r\n        this.initializeStencil();\r\n        this.initializeSelection();\r\n        this.initializeToolsAndInspector();\r\n        this.initializeNavigator();\r\n        this.initializeToolbar();\r\n        this.initializeKeyboardShortcuts();\r\n        this.initializeTooltips();\r\n    }\r\n\r\n    initializePaper() {\r\n\r\n        const graph = this.graph = new joint.dia.Graph({}, {\r\n            cellNamespace: appShapes\r\n        });\r\n\r\n        graph.on('add', (cell: any, collection: any, opt: any) => {\r\n            if (opt.stencil) {\r\n                return joint.ui.Inspector.create('.inspector-container', _.extend({\r\n                    cell: cell\r\n                }, InspectorFunction.getInspectorConfiguration(this.LANG)[cell.get('type')]));\r\n            }\r\n        });\r\n\r\n        this.commandManager = new joint.dia.CommandManager({ graph: graph });\r\n\r\n        const paper = this.paper = new joint.dia.Paper({\r\n            width: 1000,\r\n            height: 1000,\r\n            gridSize: 10,\r\n            drawGrid: true,\r\n            model: graph,\r\n            cellViewNamespace: appShapes,\r\n            defaultLink: <unknown>new appShapes.app.Link(),\r\n            defaultConnectionPoint: appShapes.app.Link.connectionPoint,\r\n            interactive: { linkMove: false },\r\n            async: true,\r\n            sorting: joint.dia.Paper.sorting.APPROX\r\n        });\r\n\r\n        paper.on('blank:mousewheel', _.partial(this.onMousewheel, null), this);\r\n        paper.on('cell:mousewheel', this.onMousewheel.bind(this));\r\n\r\n        this.snaplines = new joint.ui.Snaplines({ paper: paper });\r\n\r\n        const paperScroller = this.paperScroller = new joint.ui.PaperScroller({\r\n            paper,\r\n            autoResizePaper: true,\r\n            scrollWhileDragging: true,\r\n            cursor: 'grab'\r\n        });\r\n\r\n        this.renderPlugin('.paper-container', paperScroller);\r\n        paperScroller.render().center();\r\n    }\r\n\r\n    initializeStencil() {\r\n\r\n        this.stencil = new joint.ui.Stencil({\r\n            paper: this.paperScroller,\r\n            snaplines: this.snaplines,\r\n            width: 240,\r\n            groups: StencilFunction.getStencilGroups(),\r\n            dropAnimation: true,\r\n            groupsToggleButtons: true,\r\n            paperOptions: function () {\r\n                return {\r\n                    model: new joint.dia.Graph({}, {\r\n                        cellNamespace: appShapes\r\n                    }),\r\n                    cellViewNamespace: appShapes\r\n                };\r\n            },\r\n            search: {\r\n                '*': ['type', 'attrs/text/text', 'attrs/root/dataTooltip', 'attrs/label/text'],\r\n                'org.Member': ['attrs/.rank/text', 'attrs/root/dataTooltip', 'attrs/.name/text']\r\n            },\r\n            // Use default Grid Layout\r\n            layout: true,\r\n            // Remove tooltip definition from clone\r\n            dragStartClone: (cell: any) => cell.clone().removeAttr('root/dataTooltip')\r\n        });\r\n        this.renderPlugin('.stencil-container', this.stencil);\r\n        this.stencil.load(StencilFunction.getStencilShapes(this.LANG));\r\n    }\r\n\r\n    initializeSelection() {\r\n\r\n        this.clipboard = new joint.ui.Clipboard();\r\n        this.selection = new joint.ui.Selection({ paper: this.paper, useModelGeometry: true });\r\n        this.selection.collection.on('reset add remove', this.onSelectionChange.bind(this));\r\n\r\n        const keyboard = this.keyboardService.keyboard;\r\n\r\n        // Initiate selecting when the user grabs the blank area of the paper while the Shift key is pressed.\r\n        // Otherwise, initiate paper pan.\r\n        this.paper.on('blank:pointerdown', (evt: any, x: number, y: number) => {\r\n\r\n            if (keyboard.isActive('shift', evt)) {\r\n                this.selection.startSelecting(evt);\r\n            } else {\r\n                this.selection.collection.reset([]);\r\n                this.paperScroller.startPanning(evt);\r\n                this.paper.removeTools();\r\n            }\r\n        });\r\n\r\n        this.paper.on('element:pointerdown', (elementView: any, evt: any) => {\r\n\r\n            // Select an element if CTRL/Meta key is pressed while the element is clicked.\r\n            if (keyboard.isActive('ctrl meta', evt)) {\r\n                if (this.selection.collection.find(function (cell) { return cell.isLink() })) {\r\n                    // Do not allow mixing links and elements in the selection\r\n                    this.selection.collection.reset([elementView.model]);\r\n                } else {\r\n                    this.selection.collection.add(elementView.model);\r\n                }\r\n            }\r\n\r\n        });\r\n\r\n        this.selection.on('selection-box:pointerdown', (elementView: any, evt: any) => {\r\n\r\n            // Unselect an element if the CTRL/Meta key is pressed while a selected element is clicked.\r\n            if (keyboard.isActive('ctrl meta', evt)) {\r\n                evt.preventDefault();\r\n                this.selection.collection.remove(elementView.model);\r\n            }\r\n\r\n        });\r\n    }\r\n\r\n    async getImageContent() {\r\n        return new Promise((resolve) => {\r\n            this.paper.toPNG((imageData) => {\r\n                resolve(imageData);\r\n            });\r\n        });\r\n    }\r\n\r\n    getJsonContent() {\r\n        return JSON.stringify(this.graph.toJSON());\r\n    }\r\n\r\n    onSelectionChange() {\r\n        const { paper, selection } = this;\r\n        const { collection } = selection;\r\n        paper.removeTools();\r\n        joint.ui.Halo.clear(paper);\r\n        joint.ui.FreeTransform.clear(paper);\r\n        joint.ui.Inspector.close();\r\n        if (collection.length === 1) {\r\n            const primaryCell: any = collection.first();\r\n            const primaryCellView = paper.requireView(primaryCell);\r\n            selection.destroySelectionBox(primaryCell);\r\n            this.selectPrimaryCell(primaryCellView);\r\n        } else if (collection.length === 2) {\r\n            collection.each(function (cell: any) {\r\n                selection.createSelectionBox(cell);\r\n            });\r\n        }\r\n    }\r\n\r\n    selectPrimaryCell(cellView: any) {\r\n        const cell = cellView.model;\r\n        if (cell.isElement()) {\r\n            this.selectPrimaryElement(cellView);\r\n        } else {\r\n            this.selectPrimaryLink(cellView);\r\n        }\r\n        joint.ui.Inspector.create('.inspector-container', _.extend({\r\n            cell: cell\r\n        }, InspectorFunction.getInspectorConfiguration(this.LANG)[cell.get('type')]));\r\n    }\r\n\r\n    selectPrimaryElement(elementView: any) {\r\n\r\n        const element = elementView.model;\r\n\r\n        new joint.ui.FreeTransform({\r\n            cellView: elementView,\r\n            allowRotation: false,\r\n            preserveAspectRatio: !!element.get('preserveAspectRatio'),\r\n            allowOrthogonalResize: element.get('allowOrthogonalResize') !== false\r\n        }).render();\r\n\r\n        new joint.ui.Halo({\r\n            cellView: elementView,\r\n            handles: HaloFunction.getHaloConfiguration(this.LANG),\r\n            useModelGeometry: true\r\n        }).render();\r\n    }\r\n\r\n    selectPrimaryLink(linkView: any) {\r\n\r\n        const ns = joint.linkTools;\r\n        const toolsView = new joint.dia.ToolsView({\r\n            name: 'link-pointerdown',\r\n            tools: [\r\n                new ns.Vertices(),\r\n                new ns.SourceAnchor(),\r\n                new ns.TargetAnchor(),\r\n                new ns.SourceArrowhead(),\r\n                new ns.TargetArrowhead(),\r\n                new ns.Segments,\r\n                new ns.Boundary({ padding: 15 }),\r\n                new ns.Remove({ offset: -20, distance: 40 })\r\n            ]\r\n        });\r\n\r\n        linkView.addTools(toolsView);\r\n    }\r\n\r\n    initializeToolsAndInspector() {\r\n\r\n        this.paper.on('cell:pointerup', (cellView: any) => {\r\n            const cell = cellView.model;\r\n            const { collection } = this.selection;\r\n            if (collection.includes(cell)) { return; }\r\n            collection.reset([cell]);\r\n        });\r\n\r\n        this.paper.on('link:mouseenter', (linkView: any) => {\r\n\r\n            // Open tool only if there is none yet\r\n            if (linkView.hasTools()) { return; }\r\n\r\n            const ns = joint.linkTools;\r\n            const toolsView = new joint.dia.ToolsView({\r\n                name: 'link-hover',\r\n                tools: [\r\n                    new ns.Vertices({ vertexAdding: false }),\r\n                    new ns.SourceArrowhead(),\r\n                    new ns.TargetArrowhead()\r\n                ]\r\n            });\r\n\r\n            linkView.addTools(toolsView);\r\n        });\r\n\r\n        this.paper.on('link:mouseleave', (linkView: any) => {\r\n\r\n            // Remove only the hover tool, not the pointerdown tool\r\n            if (linkView.hasTools('link-hover')) {\r\n                linkView.removeTools();\r\n            }\r\n        });\r\n\r\n        this.graph.on('change', (cell: any, opt: any) => {\r\n\r\n            if (!cell.isLink() || !opt.inspector) { return; }\r\n\r\n            const ns = joint.linkTools;\r\n            const toolsView = new joint.dia.ToolsView({\r\n                name: 'link-inspected',\r\n                tools: [\r\n                    new ns.Boundary({ padding: 15 }),\r\n                ]\r\n            });\r\n\r\n            cell.findView(this.paper).addTools(toolsView);\r\n        });\r\n    }\r\n\r\n    initializeNavigator() {\r\n\r\n        const navigator = this.navigator = new joint.ui.Navigator({\r\n            width: 240,\r\n            height: 115,\r\n            paperScroller: this.paperScroller,\r\n            zoom: false,\r\n            paperOptions: {\r\n                async: true,\r\n                sorting: joint.dia.Paper.sorting.NONE,\r\n                elementView: appShapes.NavigatorElementView,\r\n                linkView: appShapes.NavigatorLinkView,\r\n                cellViewNamespace: { /* no other views are accessible in the navigator */ }\r\n            }\r\n        });\r\n\r\n        this.renderPlugin('.navigator-container', navigator);\r\n    }\r\n\r\n    initializeToolbar() {\r\n        const { groups, tools } = ToolbartFunction.getToolbarConfiguration(this.LANG);\r\n        this.toolbar = new joint.ui.Toolbar({\r\n            groups,\r\n            tools,\r\n            autoToggle: true,\r\n            references: {\r\n                paperScroller: this.paperScroller,\r\n                commandManager: this.commandManager\r\n            }\r\n        });\r\n        this.toolbar.on({\r\n            'svg:pointerclick': this.openAsSVG.bind(this),\r\n            'png:pointerclick': this.openAsPNG.bind(this),\r\n            'to-front:pointerclick': this.applyOnSelection.bind(this, 'toFront'),\r\n            'to-back:pointerclick': this.applyOnSelection.bind(this, 'toBack'),\r\n            'layout:pointerclick': this.layoutDirectedGraph.bind(this),\r\n            'snapline:change': this.changeSnapLines.bind(this),\r\n            'clear:pointerclick': this.graph.clear.bind(this.graph),\r\n            'print:pointerclick': this.paper.print.bind(this.paper),\r\n            'grid-size:change': this.paper.setGridSize.bind(this.paper),\r\n            'selectTemplate:option:select': this.onChangeTemplate,\r\n            'deleteTemplate:pointerclick': this.onDeleteTemplate,\r\n            'saveAsTemplate:pointerclick': this.onSaveAsTemplate,\r\n            'resetTemplate:pointerclick': this.onResetTemplate\r\n        });\r\n\r\n        this.renderPlugin('.toolbar-container', this.toolbar);\r\n    }\r\n\r\n    applyOnSelection(method: string) {\r\n        this.graph.startBatch('selection');\r\n        this.selection.collection.models.forEach(function (model: any) { model[method](); });\r\n        this.graph.stopBatch('selection');\r\n    }\r\n\r\n    changeSnapLines(checked: boolean) {\r\n\r\n        if (checked) {\r\n            this.snaplines.startListening();\r\n            this.stencil.options.snaplines = this.snaplines;\r\n        } else {\r\n            this.snaplines.stopListening();\r\n            this.stencil.options.snaplines = null;\r\n        }\r\n    }\r\n\r\n    initializeKeyboardShortcuts() {\r\n\r\n        this.keyboardService.create(\r\n            this.graph, this.clipboard, this.selection, this.paperScroller, this.commandManager);\r\n    }\r\n\r\n    initializeTooltips(): any {\r\n\r\n        return new joint.ui.Tooltip({\r\n            rootTarget: document.body,\r\n            target: '[data-tooltip]',\r\n            direction: joint.ui.Tooltip.TooltipArrowPosition.Auto,\r\n            padding: 10\r\n        });\r\n    }\r\n\r\n    // backwards compatibility for older shapes\r\n    exportStylesheet = '.scalable * { vector-effect: non-scaling-stroke }';\r\n\r\n    openAsSVG() {\r\n\r\n        this.paper.hideTools().toSVG((svg: string) => {\r\n            new joint.ui.Lightbox({\r\n                image: 'data:image/svg+xml,' + encodeURIComponent(svg),\r\n                downloadable: true,\r\n                fileName: 'Rappid'\r\n            }).open();\r\n            this.paper.showTools();\r\n        }, {\r\n            preserveDimensions: true,\r\n            convertImagesToDataUris: true,\r\n            useComputedStyles: false,\r\n            stylesheet: this.exportStylesheet\r\n        });\r\n    }\r\n\r\n    openAsPNG() {\r\n\r\n        this.paper.hideTools().toPNG((dataURL: string) => {\r\n            new joint.ui.Lightbox({\r\n                image: dataURL,\r\n                downloadable: true,\r\n                fileName: 'Rappid'\r\n            }).open();\r\n            this.paper.showTools();\r\n        }, {\r\n            padding: 10,\r\n            useComputedStyles: false,\r\n            stylesheet: this.exportStylesheet\r\n        });\r\n    }\r\n\r\n    onMousewheel(cellView: any, evt: any, ox: number, oy: number, delta: number) {\r\n\r\n        if (this.keyboardService.keyboard.isActive('alt', evt)) {\r\n            evt.preventDefault();\r\n            this.paperScroller.zoom(delta * 0.2, { min: 0.2, max: 5, grid: 0.2, ox, oy });\r\n        }\r\n    }\r\n\r\n    layoutDirectedGraph() {\r\n\r\n        joint.layout.DirectedGraph.layout(this.graph, {\r\n            graphlib: dagre.graphlib,\r\n            dagre: dagre,\r\n            setVertices: true,\r\n            rankDir: 'TB',\r\n            marginX: 100,\r\n            marginY: 100\r\n        });\r\n\r\n        this.paperScroller.centerContent();\r\n    }\r\n\r\n    renderPlugin(selector: string, plugin: any): void {\r\n\r\n        this.el.querySelector(selector).appendChild(plugin.el);\r\n        plugin.render();\r\n    }\r\n    onChangeTemplate(event) {\r\n        if (event.jsonContent) {\r\n            window[FlowChartConst.KS_SELECTED_FLOWCHART_ID] = event.flowChartId;\r\n            window[FlowChartConst.KS_SELECTED_JSONCONTENT] = event.jsonContent;\r\n            window.postMessage(FlowChartConst.KS_CHANGE_TEMPLATE, '*');\r\n        }\r\n    }\r\n\r\n    onDeleteTemplate(event) {\r\n        if (window[FlowChartConst.KS_IS_SELECTED_TEMPLATE]) {\r\n            window.postMessage(FlowChartConst.KS_DELETE_TEMPLATE, '*');\r\n        }\r\n        else {\r\n            window.postMessage(FlowChartConst.MUST_SELECT_TEMPLATE, '*');\r\n        }\r\n    }\r\n\r\n    onSaveAsTemplate() {\r\n        window.postMessage(FlowChartConst.KS_SAVE_AS_TEMPLATE, '*');\r\n    }\r\n\r\n    onResetTemplate() {\r\n        if (window[FlowChartConst.KS_IS_SELECTED_TEMPLATE]) {\r\n            window.postMessage(FlowChartConst.KS_RESET_TEMPLATE, '*');\r\n        }\r\n    }\r\n}\r\n\r\nexport default KitchenSinkService;\r\n"]}

package/esm2015/lib/qms-ckeditor-components/common/flowchart/themes/theme-picker.js

@@ -0,0 +1,80 @@
+/*! Rappid v3.2.0 - HTML5 Diagramming Framework
+
+Copyright (c) 2015 client IO
+
+ 2020-06-12
+
+
+This Source Code Form is subject to the terms of the Rappid License
+, v. 2.0. If a copy of the Rappid License was not distributed with this
+file, You can obtain one at http://jointjs.com/license/rappid_v2.txt
+ or from the Rappid archive as was distributed by client IO. See the LICENSE file.*/
+// import * as joint from '@clientio/rappid';
+import * as _ from 'lodash';
+export class ThemePicker extends joint.ui.Toolbar {
+    constructor(options) {
+        super({
+            className: _.result(joint.ui.Toolbar.prototype, 'className') + ' theme-picker'
+        });
+        this.mainView = options.mainView;
+    }
+    init() {
+        const options = [
+            { value: 'modern', content: 'Modern' },
+            { value: 'dark', content: 'Dark' },
+            { value: 'material', content: 'Material' }
+        ];
+        const themes = {
+            type: 'select-button-group',
+            name: 'theme-picker',
+            multi: false,
+            selected: _.findIndex(options, { value: this.defaultTheme }),
+            options,
+            attrs: {
+                '.joint-select-button-group': {
+                    'data-tooltip': 'Change Theme',
+                    'data-tooltip-position': 'bottom'
+                }
+            }
+        };
+        this.options.tools = [themes];
+        this.on('theme-picker:option:select', this.onThemeSelected, this);
+        super.init();
+    }
+    onThemeSelected(option) {
+        joint.setTheme(option.value);
+        if (this.mainView) {
+            this.adjustAppToTheme(this.mainView, option.value);
+        }
+    }
+    adjustAppToTheme(app, theme) {
+        // Make the following changes silently without the command manager notice.
+        app.commandManager.stopListening();
+        // Links in the dark theme would not be visible on the dark background.
+        // Note that this overrides custom color
+        const linkColor = (theme === 'dark' ? '#f6f6f6' : '#222138');
+        const themedLinks = app.graph.getLinks();
+        const defaultLink = app.paper.options.defaultLink;
+        if (defaultLink instanceof joint.dia.Link) {
+            themedLinks.push(defaultLink);
+        }
+        themedLinks.forEach(function (link) {
+            link.attr({
+                '.connection': { 'stroke': linkColor },
+                '.marker-target': { 'fill': linkColor },
+                '.marker-source': { 'fill': linkColor }
+            });
+        });
+        // Material design has no grid shown.
+        if (theme === 'material') {
+            app.paper.options.drawGrid = false;
+            app.paper.clearGrid();
+        }
+        else {
+            app.paper.options.drawGrid = true;
+            app.paper.drawGrid();
+        }
+        app.commandManager.listen();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/qms-ckeditor-components/common/models/qms-ckeditor-save-as-template.model.js

@@ -1,3 +1,3 @@
 export class QMSCKEditorSaveAsTemplate {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicW1zLWNrZWRpdG9yLXNhdmUtYXMtdGVtcGxhdGUubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9xbXMtYW5ndWxhci9zcmMvbGliL3Ftcy1ja2VkaXRvci1jb21wb25lbnRzL2NvbW1vbi9tb2RlbHMvcW1zLWNrZWRpdG9yLXNhdmUtYXMtdGVtcGxhdGUubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLHlCQUF5QjtDQUdyQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFFNU0NLRWRpdG9yQnBtbiB9IGZyb20gXCIuL3Ftcy1ja2VkaXRvci1icG1uLm1vZGVsXCI7XHJcblxyXG5leHBvcnQgY2xhc3MgUU1TQ0tFZGl0b3JTYXZlQXNUZW1wbGF0ZSB7XHJcbiAgdGVtcGxhdGVUeXBlPzogc3RyaW5nO1xyXG4gIGJwbW4/OiBRTVNDS0VkaXRvckJwbW47XHJcbn1cclxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicW1zLWNrZWRpdG9yLXNhdmUtYXMtdGVtcGxhdGUubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9xbXMtYW5ndWxhci9zcmMvbGliL3Ftcy1ja2VkaXRvci1jb21wb25lbnRzL2NvbW1vbi9tb2RlbHMvcW1zLWNrZWRpdG9yLXNhdmUtYXMtdGVtcGxhdGUubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsTUFBTSxPQUFPLHlCQUF5QjtDQUlyQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFFNU0NLRWRpdG9yQnBtbiB9IGZyb20gXCIuL3Ftcy1ja2VkaXRvci1icG1uLm1vZGVsXCI7XHJcbmltcG9ydCB7IFFNU0NLRWRpdG9yRmxvd2NoYXJ0IH0gZnJvbSBcIi4vcW1zLWNrZWRpdG9yLWZsb3djaGFydC5tb2RlbFwiO1xyXG5cclxuZXhwb3J0IGNsYXNzIFFNU0NLRWRpdG9yU2F2ZUFzVGVtcGxhdGUge1xyXG4gIHRlbXBsYXRlVHlwZT86IHN0cmluZztcclxuICBicG1uPzogUU1TQ0tFZGl0b3JCcG1uO1xyXG4gIGZsb3djaGFydD86IFFNU0NLRWRpdG9yRmxvd2NoYXJ0O1xyXG59XHJcbiJdfQ==

package/esm2015/lib/qms-ckeditor-components/common/module/confirm/qms-ckeditor-confirm.component.js

@@ -33,7 +33,7 @@ export class QMSCKEditorConfirmComponent extends QMSCKEditorBaseComponent {
 QMSCKEditorConfirmComponent.decorators = [
     { type: Component, args: [{
                 selector: 'app-confirm-popup',
-                template: "<div\r\n  id=\"qmsckeditor-confirm\"\r\n  class=\"qmsckeditor qmsckeditor__confirm__container\"\r\n>\r\n  <h2>{{ data.title }}</h2>\r\n  <div class=\"row ml2 mr-0\" [innerHTML]=\"data.content\"></div>\r\n  <div *ngIf=\"!data.isMessage\" class=\"row ml-0 mr-0 mt20\">\r\n    <div *ngIf=\"data.isAdvance\" class=\"mt-4\">\r\n      <mat-checkbox [(ngModel)]=\"isNotShowAgain\">{{\r\n        data.checkText\r\n      }}</mat-checkbox>\r\n    </div>\r\n    <div class=\"qmsckeditor confirm__button__groups ml-auto mt-auto\">\r\n      <button mat-button class=\"cancel\" (click)=\"onCancelClick()\">\r\n        {{ LANG.QMSCKEDITOR.CANCEL }}\r\n      </button>\r\n      <button\r\n        *ngIf=\"!data.isAdvance\"\r\n        mat-button\r\n        class=\"confirm ml3\"\r\n        (click)=\"onConfirmClick()\"\r\n      >\r\n        {{ LANG.QMSCKEDITOR.CONFIRM }}\r\n      </button>\r\n      <button\r\n        *ngIf=\"data.isAdvance\"\r\n        mat-button\r\n        class=\"confirm ml3\"\r\n        (click)=\"onAdvanceConfirmClick()\"\r\n      >\r\n        {{ LANG.QMSCKEDITOR.CONFIRM }}\r\n      </button>\r\n    </div>\r\n  </div>\r\n  <div *ngIf=\"data.isMessage\" class=\"row ml-0 mr-0 mt20\">\r\n    <div class=\"ml-auto mt-auto\">\r\n      <button mat-button class=\"save ml-3\" (click)=\"onConfirmClick()\">\r\n        {{ LANG.QMSCKEDITOR.OK }}\r\n      </button>\r\n    </div>\r\n  </div>\r\n</div>\r\n",
+                template: "<div\r\n  id=\"qmsckeditor-confirm\"\r\n  class=\"qmsckeditor qmsckeditor__confirm__container\"\r\n>\r\n  <h2>{{ data.title }}</h2>\r\n  <div class=\"row ml2 mr-0 me-0\" [innerHTML]=\"data.content\"></div>\r\n  <div *ngIf=\"!data.isMessage\" class=\"row ml-0 mr-0 mt20 ms-0 me-0\">\r\n    <div *ngIf=\"data.isAdvance\" class=\"mt-4\">\r\n      <mat-checkbox [(ngModel)]=\"isNotShowAgain\">{{\r\n        data.checkText\r\n      }}</mat-checkbox>\r\n    </div>\r\n    <div class=\"qmsckeditor confirm__button__groups ml-auto mt-auto\">\r\n      <button mat-button class=\"cancel\" (click)=\"onCancelClick()\">\r\n        {{ LANG.QMSCKEDITOR.CANCEL }}\r\n      </button>\r\n      <button\r\n        *ngIf=\"!data.isAdvance\"\r\n        mat-button\r\n        class=\"confirm ml3\"\r\n        (click)=\"onConfirmClick()\"\r\n      >\r\n        {{ LANG.QMSCKEDITOR.CONFIRM }}\r\n      </button>\r\n      <button\r\n        *ngIf=\"data.isAdvance\"\r\n        mat-button\r\n        class=\"confirm ml3\"\r\n        (click)=\"onAdvanceConfirmClick()\"\r\n      >\r\n        {{ LANG.QMSCKEDITOR.CONFIRM }}\r\n      </button>\r\n    </div>\r\n  </div>\r\n  <div *ngIf=\"data.isMessage\" class=\"row ml-0 mr-0 mt20 ms-0 me-0\">\r\n    <div class=\"ml-auto mt-auto\">\r\n      <button mat-button class=\"save ml-3 ms-3\" (click)=\"onConfirmClick()\">\r\n        {{ LANG.QMSCKEDITOR.OK }}\r\n      </button>\r\n    </div>\r\n  </div>\r\n</div>\r\n",
                 styles: [".mt5{margin-top:5px!important}.mt10{margin-top:10px!important}.mt7{margin-top:7px!important}.mt15{margin-top:15px!important}.mt20{margin-top:20px!important}.mt30{margin-top:30px!important}.mt40{margin-top:40px!important}.ml2{margin-left:2px!important}.ml3{margin-left:3px!important}.ml5{margin-left:5px!important}.ml15{margin-left:15px!important}.ml10{margin-left:10px!important}.ml12{margin-left:12px!important}.ml16{margin-left:16px!important}.ml-auto{margin-left:auto!important}.ml-25{margin-left:-25px!important}.mr5{margin-right:5px!important}.mr12{margin-right:12px!important}.mr15{margin-right:15px!important}.mb5{margin-bottom:5px!important}.mb10{margin-bottom:10px!important}.mb15{margin-bottom:15px!important}.pt8{padding-top:8px!important}.pt10{padding-top:10px!important}.pt15{padding-top:15px!important}.pt16{padding-top:16px!important}.pl15{padding-left:15px!important}.pl0{padding-left:0!important}.pr0{padding-right:0!important}.pr15{padding-right:15px!important}.fs12{font-size:12px}.fs14{font-size:14px!important}.fs16{font-size:16px!important}.fs22{font-size:22px!important}.fw500{font-weight:500!important}.italic-text{font-style:italic}.display-flex{display:flex}.qmsckeditor{font-family:Roboto,Helvetica Neue,sans-serif;font-size:14px;font-weight:400}.qmsckeditor h2{font-size:20px;font-weight:400}.qmsckeditor .mat-dialog-content{padding:0}.qmsckeditor .mat-icon{color:#909497}.qmsckeditor__fullscreen{position:fixed;top:0;left:0;right:0;bottom:0;background:#fff;overflow-y:auto;max-height:100vh;overflow-x:hidden}.qmsckeditor__cursor{cursor:pointer}.qmsckeditor__notallowed{cursor:not-allowed}.qmsckeditor.button__close,.qmsckeditor.button__done{float:right;top:-24px;right:-24px;cursor:pointer}.qmsckeditor.button__done{margin-right:20px}.qmsckeditor.button__done .mat-icon{color:#28a745;font-weight:700}.qmsckeditor.button__groups button{min-height:40px;width:100%;border-radius:4px;border:1px solid #c5c5c5;font-family:Open Sans;font-weight:600;font-size:14px;letter-spacing:1px;line-height:16px}.qmsckeditor.button__groups .save{background:#f8f9f9}.qmsckeditor.button__groups .save:hover{background:#e5e7e9}.qmsckeditor.button__groups .save:disabled{cursor:not-allowed}.qmsckeditor.button__groups .cancel{background:#f8f9f9}.qmsckeditor.button__groups .cancel:hover{background:#e5e7e9}.qmsckeditor.button__groups .cancel:disabled{cursor:not-allowed}.qmsckeditor.button__groups .delete{background:#f8f9f9}.qmsckeditor.button__groups .delete:hover{background:#e5e7e9}.qmsckeditor.button__groups .delete:disabled{cursor:not-allowed}.qmsckeditor.confirm__button__groups button{min-height:36px;border-radius:4px;width:auto;border:1px solid #c5c5c5;font-family:Open Sans;font-weight:600;font-size:14px;letter-spacing:1px;line-height:16px;padding-left:15px;padding-right:15px}.qmsckeditor.confirm__button__groups .confirm{background:#f8f9f9}.qmsckeditor.confirm__button__groups .confirm:hover{background:#e5e7e9}.qmsckeditor.confirm__button__groups .cancel{background:#f8f9f9}.qmsckeditor.confirm__button__groups .cancel:hover{background:#e5e7e9}.qmsckeditor.template-content.height{min-height:420px;max-height:520px;overflow:auto}.qmsckeditor.template-content.title{margin-left:-9px}.qmsckeditor.link__content.height{min-height:400px;max-height:520px}.qmsckeditor.card{margin-bottom:10px;min-height:60px;box-shadow:none;border:1px solid #e5e5e5}.qmsckeditor.card .title{font-weight:700}.qmsckeditor.card .content{text-overflow:ellipsis;overflow:hidden;white-space:nowrap}.qmsckeditor.card .material-icons{font-size:20px}.qmsckeditor.tooltip-content.height{min-height:400px;max-height:472px;overflow:auto}.qmsckeditor.save__as__template.height{height:125px}.ck-content .ck-horizontal-line,.ck-content .page-break{width:100%}.ck-content hr{background:#ccc}"]
             },] }
 ];
@@ -42,4 +42,4 @@ QMSCKEditorConfirmComponent.ctorParameters = () => [
     { type: MatDialogRef },
     { type: QMSCKEditorDialogData, decorators: [{ type: Inject, args: [MAT_DIALOG_DATA,] }] }
 ];
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicW1zLWNrZWRpdG9yLWNvbmZpcm0uY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvcW1zLWFuZ3VsYXIvc3JjL2xpYi9xbXMtY2tlZGl0b3ItY29tcG9uZW50cy9jb21tb24vbW9kdWxlL2NvbmZpcm0vcW1zLWNrZWRpdG9yLWNvbmZpcm0uY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFVLE1BQU0sZUFBZSxDQUFDO0FBQzFELE9BQU8sRUFBRSxZQUFZLEVBQUUsZUFBZSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDekUsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sbURBQW1ELENBQUM7QUFDNUYsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzNDLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBQ2hGLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBTy9FLE1BQU0sT0FBTywyQkFBNEIsU0FBUSx3QkFBd0I7SUFJdkUsWUFDVSxTQUFrQyxFQUNuQyxTQUFvRCxFQUMzQixJQUEyQjtRQUUzRCxLQUFLLEVBQUUsQ0FBQztRQUpBLGNBQVMsR0FBVCxTQUFTLENBQXlCO1FBQ25DLGNBQVMsR0FBVCxTQUFTLENBQTJDO1FBQzNCLFNBQUksR0FBSixJQUFJLENBQXVCO1FBTDdELG1CQUFjLEdBQUcsS0FBSyxDQUFDO0lBUXZCLENBQUM7SUFFRCxRQUFRO1FBQ04sSUFBSSxDQUFDLFNBQVMsQ0FBQyxtQkFBbUIsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEdBQUcsRUFBRSxFQUFFO1lBQ3RGLElBQUksR0FBRyxFQUFFO2dCQUNQLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUFDLENBQUM7YUFDL0M7UUFDSCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFRCxhQUFhO1FBQ1gsSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUN6QixDQUFDO0lBRUQsY0FBYztRQUNaLElBQUksQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzdCLENBQUM7SUFFRCxxQkFBcUI7UUFDbkIsTUFBTSxHQUFHLEdBQUcsRUFBRSxXQUFXLEVBQUUsSUFBSSxFQUFFLGNBQWMsRUFBRSxJQUFJLENBQUMsY0FBYyxFQUFFLENBQUM7UUFDdkUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDNUIsQ0FBQzs7O1lBcENGLFNBQVMsU0FBQztnQkFDVCxRQUFRLEVBQUUsbUJBQW1CO2dCQUM3QixzNkNBQW9EOzthQUVyRDs7O1lBVFEsdUJBQXVCO1lBRHZCLFlBQVk7WUFJWixxQkFBcUIsdUJBY3pCLE1BQU0sU0FBQyxlQUFlIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBJbmplY3QsIE9uSW5pdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBNYXREaWFsb2dSZWYsIE1BVF9ESUFMT0dfREFUQSB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2RpYWxvZyc7XHJcbmltcG9ydCB7IFRyYW5zbGF0ZUxpYnJhcnlTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vLi4vLi4vc2VydmljZXMvdHJhbnNsYXRpb24tcmVnaXN0cnkuc2VydmljZSc7XHJcbmltcG9ydCB7IHRha2VVbnRpbCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcclxuaW1wb3J0IHsgUU1TQ0tFZGl0b3JCYXNlQ29tcG9uZW50IH0gZnJvbSAnLi4vLi4vLi4vcW1zLWNrZWRpdG9yLWJhc2UuY29tcG9uZW50JztcclxuaW1wb3J0IHsgUU1TQ0tFZGl0b3JEaWFsb2dEYXRhIH0gZnJvbSAnLi4vLi4vbW9kZWxzL3Ftcy1ja2VkaXRvci1kaWFsb2cubW9kZWwnO1xyXG5cclxuQENvbXBvbmVudCh7XHJcbiAgc2VsZWN0b3I6ICdhcHAtY29uZmlybS1wb3B1cCcsXHJcbiAgdGVtcGxhdGVVcmw6ICcuL3Ftcy1ja2VkaXRvci1jb25maXJtLmNvbXBvbmVudC5odG1sJyxcclxuICBzdHlsZVVybHM6IFsnLi9xbXMtY2tlZGl0b3ItY29uZmlybS5jb21wb25lbnQuc2NzcyddXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBRTVNDS0VkaXRvckNvbmZpcm1Db21wb25lbnQgZXh0ZW5kcyBRTVNDS0VkaXRvckJhc2VDb21wb25lbnQgaW1wbGVtZW50cyBPbkluaXQge1xyXG4gIExBTkc6IGFueTtcclxuICBpc05vdFNob3dBZ2FpbiA9IGZhbHNlO1xyXG5cclxuICBjb25zdHJ1Y3RvcihcclxuICAgIHByaXZhdGUgdHJhbnNsYXRlOiBUcmFuc2xhdGVMaWJyYXJ5U2VydmljZSxcclxuICAgIHB1YmxpYyBkaWFsb2dSZWY6IE1hdERpYWxvZ1JlZjxRTVNDS0VkaXRvckNvbmZpcm1Db21wb25lbnQ+LFxyXG4gICAgQEluamVjdChNQVRfRElBTE9HX0RBVEEpIHB1YmxpYyBkYXRhOiBRTVNDS0VkaXRvckRpYWxvZ0RhdGFcclxuICApIHtcclxuICAgIHN1cGVyKCk7XHJcbiAgfVxyXG5cclxuICBuZ09uSW5pdCgpOiB2b2lkIHtcclxuICAgIHRoaXMudHJhbnNsYXRlLmdldExhbmd1YWdlU3ViamVjdCQucGlwZSh0YWtlVW50aWwodGhpcy5uZ1Vuc3ViY3JpYmUpKS5zdWJzY3JpYmUoKHJlcykgPT4ge1xyXG4gICAgICBpZiAocmVzKSB7XHJcbiAgICAgICAgdGhpcy5MQU5HID0gdGhpcy50cmFuc2xhdGUuZ2V0T2JqZWN0TGFuZyhyZXMpO1xyXG4gICAgICB9XHJcbiAgICB9KTtcclxuICB9XHJcblxyXG4gIG9uQ2FuY2VsQ2xpY2soKTogdm9pZCB7XHJcbiAgICB0aGlzLmRpYWxvZ1JlZi5jbG9zZSgpO1xyXG4gIH1cclxuXHJcbiAgb25Db25maXJtQ2xpY2soKSB7XHJcbiAgICB0aGlzLmRpYWxvZ1JlZi5jbG9zZSh0cnVlKTtcclxuICB9XHJcblxyXG4gIG9uQWR2YW5jZUNvbmZpcm1DbGljaygpIHtcclxuICAgIGNvbnN0IG9iaiA9IHsgaXNDb25maXJtZWQ6IHRydWUsIGlzTm90U2hvd0FnYWluOiB0aGlzLmlzTm90U2hvd0FnYWluIH07XHJcbiAgICB0aGlzLmRpYWxvZ1JlZi5jbG9zZShvYmopO1xyXG4gIH1cclxufVxyXG4iXX0=