qms-angular 1.0.50 → 1.0.54

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

@@ -0,0 +1,68 @@
+/*! 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 _ from 'lodash';
+export class KeyboardService {
+    constructor() {
+        this.keyboard = new window["joint"].ui.Keyboard();
+    }
+    create(graph, clipboard, selection, paperScroller, commandManager) {
+        this.keyboard.on({
+            'ctrl+c': () => {
+                // Copy all selected elements and their associated links.
+                clipboard.copyElements(selection.collection, graph);
+            },
+            'ctrl+v': () => {
+                const pastedCells = clipboard.pasteCells(graph, {
+                    translate: { dx: 20, dy: 20 },
+                    useLocalStorage: true
+                });
+                const elements = _.filter(pastedCells, cell => cell.isElement());
+                // Make sure pasted elements get selected immediately. This makes the UX better as
+                // the user can immediately manipulate the pasted elements.
+                selection.collection.reset(elements);
+            },
+            'ctrl+x shift+delete': () => {
+                clipboard.cutElements(selection.collection, graph);
+            },
+            'delete backspace': (evt) => {
+                evt.preventDefault();
+                graph.removeCells(selection.collection.toArray());
+            },
+            'ctrl+z': () => {
+                commandManager.undo();
+                selection.cancelSelection();
+            },
+            'ctrl+y': () => {
+                commandManager.redo();
+                selection.cancelSelection();
+            },
+            'ctrl+a': () => {
+                selection.collection.reset(graph.getElements());
+            },
+            'ctrl+plus': (evt) => {
+                evt.preventDefault();
+                paperScroller.zoom(0.2, { max: 5, grid: 0.2 });
+            },
+            'ctrl+minus': (evt) => {
+                evt.preventDefault();
+                paperScroller.zoom(-0.2, { min: 0.2, grid: 0.2 });
+            },
+            'keydown:shift': (evt) => {
+                paperScroller.setCursor('crosshair');
+            },
+            'keyup:shift': () => {
+                paperScroller.setCursor('grab');
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,372 @@
+/*! 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 { __awaiter } from "tslib";
+import * as dagre from 'dagre';
+import * as _ from 'lodash';
+import { FlowChartConst } from '../../constants/ckeditorFlowchart.const';
+import * as appShapes from '../shapes/app-shapes';
+var joint = window['joint'];
+class KitchenSinkService {
+    constructor(el, stencilService, toolbarService, inspectorService, haloService, keyboardService) {
+        // backwards compatibility for older shapes
+        this.exportStylesheet = '.scalable * { vector-effect: non-scaling-stroke }';
+        this.el = el;
+        // apply current joint js theme
+        const view = new window["joint"].mvc.View({ el });
+        view.delegateEvents({
+            'mouseup input[type="range"]': (evt) => evt.target.blur()
+        });
+        this.stencilService = stencilService;
+        this.toolbarService = toolbarService;
+        this.inspectorService = inspectorService;
+        this.haloService = haloService;
+        this.keyboardService = keyboardService;
+    }
+    startRappid() {
+        window["joint"].setTheme('modern');
+        this.initializePaper();
+        this.initializeStencil();
+        this.initializeSelection();
+        this.initializeToolsAndInspector();
+        this.initializeNavigator();
+        this.initializeToolbar();
+        this.initializeKeyboardShortcuts();
+        this.initializeTooltips();
+        this.initializeStencilTooltips();
+    }
+    initializePaper() {
+        const graph = this.graph = new window["joint"].dia.Graph({}, {
+            cellNamespace: appShapes
+        });
+        graph.on('add', (cell, collection, opt) => {
+            if (opt.stencil) {
+                this.inspectorService.create(cell);
+            }
+        });
+        this.commandManager = new window["joint"].dia.CommandManager({ graph: graph });
+        const paper = this.paper = new window["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 window["joint"].ui.Snaplines({ paper: paper });
+        const paperScroller = this.paperScroller = new window["joint"].ui.PaperScroller({
+            paper,
+            autoResizePaper: true,
+            scrollWhileDragging: true,
+            cursor: 'grab'
+        });
+        this.renderPlugin('.paper-container', paperScroller);
+        paperScroller.render().center();
+    }
+    initializeStencil() {
+        this.stencilService.create(this.paperScroller, this.snaplines);
+        this.renderPlugin('.stencil-container', this.stencilService.stencil);
+        this.stencilService.setShapes();
+    }
+    initializeSelection() {
+        this.clipboard = new window["joint"].ui.Clipboard();
+        this.selection = new window["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)) {
+                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)) {
+                this.selection.collection.remove(elementView.model);
+            }
+        }, this);
+    }
+    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);
+        }
+        this.inspectorService.create(cell);
+    }
+    selectPrimaryElement(elementView) {
+        const element = elementView.model;
+        new window["joint"].ui.FreeTransform({
+            cellView: elementView,
+            allowRotation: false,
+            preserveAspectRatio: !!element.get('preserveAspectRatio'),
+            allowOrthogonalResize: element.get('allowOrthogonalResize') !== false
+        }).render();
+        this.haloService.create(elementView);
+    }
+    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,
+                elementView: appShapes.NavigatorElementView,
+                linkView: appShapes.NavigatorLinkView,
+                cellViewNamespace: { /* no other views are accessible in the navigator */}
+            }
+        });
+        this.renderPlugin('.joint-navigator-container', navigator);
+    }
+    initializeToolbar() {
+        this.toolbarService.create(this.commandManager, this.paperScroller);
+        this.toolbarService.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.toolbarService.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.stencilService.stencil.options.snaplines = this.snaplines;
+        }
+        else {
+            this.snaplines.stopListening();
+            this.stencilService.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.getElementById('tooltipcontainer'),
+            target: '[data-tooltip]',
+            direction: joint.ui.Tooltip.TooltipArrowPosition.Auto,
+            padding: 10
+        });
+    }
+    initializeStencilTooltips() {
+        return new joint.ui.Tooltip({
+            rootTarget: document.getElementById('flowchartstencil'),
+            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();
+    }
+    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());
+    }
+    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.2.0 - HTML5 Diagramming Framework\r\n\r\nCopyright (c) 2015 client IO\r\n\r\n 2020-06-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\r\nimport * as dagre from 'dagre';\r\nimport * as _ from 'lodash';\r\nimport { FlowChartConst } from '../../constants/ckeditorFlowchart.const';\r\nimport * as appShapes from '../shapes/app-shapes';\r\nimport { HaloService } from './halo-service';\r\nimport { InspectorService } from './inspector-service';\r\nimport { KeyboardService } from './keyboard-service';\r\nimport { StencilService } from './stencil-service';\r\nimport { ToolbarService } from './toolbar-service';\r\nvar joint = window['joint'];\r\n\r\nclass KitchenSinkService {\r\n\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\r\n  stencilService: StencilService;\r\n  toolbarService: ToolbarService;\r\n  inspectorService: InspectorService;\r\n  haloService: HaloService;\r\n  keyboardService: KeyboardService;\r\n\r\n  constructor(\r\n    el: Element,\r\n    stencilService: StencilService,\r\n    toolbarService: ToolbarService,\r\n    inspectorService: InspectorService,\r\n    haloService: HaloService,\r\n    keyboardService: KeyboardService\r\n  ) {\r\n    this.el = el;\r\n    // apply current joint js theme\r\n    const view = new window[\"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.stencilService = stencilService;\r\n    this.toolbarService = toolbarService;\r\n    this.inspectorService = inspectorService;\r\n    this.haloService = haloService;\r\n    this.keyboardService = keyboardService;\r\n  }\r\n\r\n  startRappid() {\r\n\r\n    window[\"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    this.initializeStencilTooltips();\r\n  }\r\n\r\n  initializePaper() {\r\n\r\n    const graph = this.graph = new window[\"joint\"].dia.Graph({}, {\r\n      cellNamespace: appShapes\r\n    });\r\n\r\n    graph.on('add', (cell: joint.dia.Cell, collection: any, opt: any) => {\r\n      if (opt.stencil) { this.inspectorService.create(cell); }\r\n    });\r\n\r\n    this.commandManager = new window[\"joint\"].dia.CommandManager({ graph: graph });\r\n\r\n    const paper = this.paper = new window[\"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: <joint.dia.Link>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 window[\"joint\"].ui.Snaplines({ paper: paper });\r\n\r\n    const paperScroller = this.paperScroller = new window[\"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.stencilService.create(this.paperScroller, this.snaplines);\r\n    this.renderPlugin('.stencil-container', this.stencilService.stencil);\r\n    this.stencilService.setShapes();\r\n  }\r\n\r\n  initializeSelection() {\r\n\r\n    this.clipboard = new window[\"joint\"].ui.Clipboard();\r\n    this.selection = new window[\"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: joint.dia.Event, 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: joint.dia.ElementView, evt: joint.dia.Event) => {\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        this.selection.collection.add(elementView.model);\r\n      }\r\n\r\n    });\r\n\r\n    this.selection.on('selection-box:pointerdown', (elementView: joint.dia.ElementView, evt: joint.dia.Event) => {\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        this.selection.collection.remove(elementView.model);\r\n      }\r\n\r\n    }, this);\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: joint.dia.Cell = 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: joint.dia.Cell) {\r\n        selection.createSelectionBox(cell);\r\n      });\r\n    }\r\n  }\r\n\r\n  selectPrimaryCell(cellView: joint.dia.CellView) {\r\n    const cell = cellView.model;\r\n    if (cell.isElement()) {\r\n      this.selectPrimaryElement(<joint.dia.ElementView>cellView);\r\n    } else {\r\n      this.selectPrimaryLink(<joint.dia.LinkView>cellView);\r\n    }\r\n    this.inspectorService.create(cell);\r\n  }\r\n\r\n  selectPrimaryElement(elementView: joint.dia.ElementView) {\r\n\r\n    const element = elementView.model;\r\n\r\n    new window[\"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    this.haloService.create(elementView);\r\n  }\r\n\r\n  selectPrimaryLink(linkView: joint.dia.LinkView) {\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: joint.dia.CellView) => {\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: joint.dia.LinkView) => {\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: joint.dia.LinkView) => {\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: joint.dia.Cell, 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        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('.joint-navigator-container', navigator);\r\n  }\r\n\r\n  initializeToolbar() {\r\n\r\n    this.toolbarService.create(this.commandManager, this.paperScroller);\r\n\r\n    this.toolbarService.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.toolbarService.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: joint.dia.Cell) { 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.stencilService.stencil.options.snaplines = this.snaplines;\r\n    } else {\r\n      this.snaplines.stopListening();\r\n      this.stencilService.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(): joint.ui.Tooltip {\r\n\r\n    return new joint.ui.Tooltip({\r\n      rootTarget: document.getElementById('tooltipcontainer'),\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  initializeStencilTooltips(): joint.ui.Tooltip {\r\n\r\n    return new joint.ui.Tooltip({\r\n      rootTarget: document.getElementById('flowchartstencil'),\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: joint.dia.CellView, evt: joint.dia.Event, 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\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  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"]}