annuary.lyimo
/
tiseza_oss_live
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
tiseza_oss_live/Scripts/dx-diagram.js

29413 lines
1.3 MiB
Raw Permalink Blame History

/*!
* DevExpress Diagram (dx-diagram)
* Version: 0.1.49
* Build date: Mon Dec 09 2019
*
* Copyright (c) 2012 - 2019 Developer Express Inc. ALL RIGHTS RESERVED
* Read about DevExpress licensing here: https://www.devexpress.com/Support/EULAs
*/
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["diagram"] = factory();
else
root["DevExpress"] = root["DevExpress"] || {}, root["DevExpress"]["diagram"] = factory();
})(window, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 8);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Size = /** @class */ (function () {
function Size(width, height) {
this.width = width;
this.height = height;
}
Size.prototype.clone = function () { return new Size(this.width, this.height); };
Size.prototype.toString = function () { return JSON.stringify(this); };
Size.prototype.offset = function (offsetX, offsetY) {
if (offsetX === void 0) { offsetX = 0; }
if (offsetY === void 0) { offsetY = 0; }
return new Size(Math.max(0, this.width + offsetX), Math.max(0, this.height + offsetY));
};
Size.prototype.multiply = function (multiplierW, multiplierH) {
if (multiplierW === void 0) { multiplierW = 1; }
if (multiplierH === void 0) { multiplierH = multiplierW; }
return new Size(this.width * multiplierW, this.height * multiplierH);
};
Size.prototype.equals = function (size) {
return size.width === this.width && size.height === this.height;
};
Size.prototype.transform = function (func) {
return new Size(func(this.width), func(this.height));
};
return Size;
}());
exports.Size = Size;
var Point = /** @class */ (function () {
function Point(x, y) {
this.x = x;
this.y = y;
}
Point.prototype.clone = function () { return new Point(this.x, this.y); };
Point.prototype.toString = function () { return JSON.stringify(this); };
Point.prototype.offset = function (offsetX, offsetY) {
if (offsetX === void 0) { offsetX = 0; }
if (offsetY === void 0) { offsetY = 0; }
return new Point(this.x + offsetX, this.y + offsetY);
};
Point.prototype.multiply = function (multiplierX, multiplierY) {
if (multiplierX === void 0) { multiplierX = 1; }
if (multiplierY === void 0) { multiplierY = multiplierX; }
return new Point(this.x * multiplierX, this.y * multiplierY);
};
Point.prototype.equals = function (pt) {
return pt.x === this.x && pt.y === this.y;
};
Point.prototype.transform = function (func) {
return new Point(func(this.x), func(this.y));
};
Point.empty = function () {
return new Point(0, 0);
};
Point.plus = function (a, b) {
return new Point(a.x + b.x, a.y + b.y);
};
Point.minus = function (a, b) {
return new Point(a.x - b.x, a.y - b.y);
};
return Point;
}());
exports.Point = Point;
var Offset = /** @class */ (function () {
function Offset(left, top, right, bottom) {
this.left = left;
this.top = top;
this.right = right;
this.bottom = bottom;
}
Object.defineProperty(Offset.prototype, "horizontal", {
get: function () { return this.left + this.right; },
enumerable: true,
configurable: true
});
Object.defineProperty(Offset.prototype, "vertical", {
get: function () { return this.top + this.bottom; },
enumerable: true,
configurable: true
});
Offset.prototype.clone = function () { return new Offset(this.left, this.top, this.right, this.bottom); };
Offset.prototype.transform = function (func) {
return new Offset(func(this.left), func(this.top), func(this.right), func(this.bottom));
};
Offset.prototype.offset = function (offset, increase) {
var clone = this.clone();
if (increase) {
clone.left += offset.left;
clone.right += offset.right;
clone.top += offset.top;
clone.bottom += offset.bottom;
}
else {
clone.left -= offset.left;
clone.right -= offset.right;
clone.top -= offset.top;
clone.bottom -= offset.bottom;
}
return clone;
};
Offset.prototype.multiply = function (multiplierX, multiplierY) {
if (multiplierX === void 0) { multiplierX = 1; }
if (multiplierY === void 0) { multiplierY = multiplierX; }
return new Offset(this.left * multiplierX, this.top * multiplierY, this.right * multiplierX, this.bottom * multiplierY);
};
Offset.prototype.isEmpty = function () {
return this.left === 0 && this.right === 0 && this.top === 0 && this.bottom === 0;
};
Offset.prototype.equals = function (offset) {
return this.left === offset.left && this.top === offset.top && this.right === offset.right && this.bottom === offset.bottom;
};
Offset.prototype.toString = function () {
return "left: " + this.left + " top: " + this.top + " right: " + this.right + " bottom: " + this.bottom;
};
Offset.empty = function () {
return new Offset(0, 0, 0, 0);
};
Offset.fromNumber = function (offset) {
return new Offset(offset, offset, offset, offset);
};
Offset.fromSide = function (horizontal, vertical) {
return new Offset(horizontal, vertical, horizontal, vertical);
};
return Offset;
}());
exports.Offset = Offset;
var Rectangle = /** @class */ (function () {
function Rectangle(position, size) {
this.position = position;
this.size = size;
}
Object.defineProperty(Rectangle.prototype, "left", {
get: function () {
return this.position.x;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Rectangle.prototype, "top", {
get: function () {
return this.position.y;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Rectangle.prototype, "right", {
get: function () {
return this.position.x + this.size.width;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Rectangle.prototype, "bottom", {
get: function () {
return this.position.y + this.size.height;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Rectangle.prototype, "center", {
get: function () {
return new Point(this.position.x + this.size.width / 2, this.position.y + this.size.height / 2);
},
enumerable: true,
configurable: true
});
Object.defineProperty(Rectangle.prototype, "width", {
get: function () {
return this.size.width;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Rectangle.prototype, "height", {
get: function () {
return this.size.height;
},
enumerable: true,
configurable: true
});
Rectangle.prototype.clone = function () { return new Rectangle(this.position.clone(), this.size.clone()); };
Rectangle.prototype.toString = function () { return JSON.stringify(this); };
Rectangle.prototype.contains = function (point) {
return this.left <= point.x && point.x <= this.right &&
this.top <= point.y && point.y <= this.bottom;
};
Rectangle.prototype.intersectX = function (rect) {
if (this.left > rect.right || rect.left > this.right)
return false;
return true;
};
Rectangle.prototype.intersectY = function (rect) {
if (this.top > rect.bottom || rect.top > this.bottom)
return false;
return true;
};
Rectangle.prototype.intersect = function (rect) {
return this.intersectX(rect) && this.intersectY(rect);
};
Rectangle.prototype.inflate = function (deltaX, deltaY) {
deltaY = deltaY === undefined ? deltaX : deltaY;
return new Rectangle(this.position.offset(-deltaX, -deltaY), this.size.offset(2 * deltaX, 2 * deltaY));
};
Rectangle.prototype.resize = function (deltaX, deltaY) {
return new Rectangle(this.position, this.size.offset(deltaX, deltaY));
};
Rectangle.prototype.offset = function (offsetX, offsetY) {
return new Rectangle(this.position.offset(offsetX, offsetY), this.size);
};
Rectangle.prototype.multiply = function (multiplier) {
return new Rectangle(this.position.multiply(multiplier), this.size.multiply(multiplier));
};
Rectangle.prototype.equals = function (rect) {
return this.left === rect.left && this.top === rect.top && this.width === rect.width && this.height === rect.height;
};
Rectangle.prototype.transform = function (func) {
return new Rectangle(this.position.transform(func), this.size.transform(func));
};
Rectangle.create = function (x, y, width, height) {
return new Rectangle(new Point(x, y), new Size(width, height));
};
Rectangle.createByPoints = function (point1, point2) {
return Rectangle.createByPositions(point1.x, point1.y, point2.x, point2.y);
};
Rectangle.createByPositions = function (x1, y1, x2, y2) {
var x = Math.min(x1, x2);
var y = Math.min(y1, y2);
var width = Math.abs(x2 - x1);
var height = Math.abs(y2 - y1);
return Rectangle.create(x, y, width, height);
};
return Rectangle;
}());
exports.Rectangle = Rectangle;
var Segment = /** @class */ (function () {
function Segment(startPoint, endPoint) {
this.startPoint = startPoint;
this.endPoint = endPoint;
}
Object.defineProperty(Segment.prototype, "distance", {
get: function () {
return GeometryUtils.getDistance(this.startPoint, this.endPoint);
},
enumerable: true,
configurable: true
});
Segment.prototype.intersect = function (segment) {
if (this.startPoint.equals(segment.startPoint) || this.endPoint.equals(segment.startPoint) ||
this.startPoint.equals(segment.endPoint) || this.endPoint.equals(segment.endPoint))
return true;
return this.intersectCore(segment) && segment.intersectCore(this);
};
Segment.prototype.intersectRect = function (rectangle) {
var ltPt = rectangle.position, lbPt = new Point(rectangle.left, rectangle.bottom), rtPt = new Point(rectangle.right, rectangle.top), rbPt = new Point(rectangle.right, rectangle.bottom);
return rectangle.contains(this.startPoint) || rectangle.contains(this.endPoint) ||
this.intersect(new Segment(ltPt, lbPt)) || this.intersect(new Segment(lbPt, rbPt)) ||
this.intersect(new Segment(rbPt, rtPt)) || this.intersect(new Segment(rtPt, ltPt));
};
Segment.prototype.intersectCore = function (segment) {
if (this.startPoint.x === this.endPoint.x) {
if (this.startPoint.x - segment.endPoint.x !== 0)
return (this.startPoint.x - segment.startPoint.x) / (this.startPoint.x - segment.endPoint.x) <= 0;
if (segment.endPoint.y - this.endPoint.y !== 0)
return (segment.endPoint.y - this.startPoint.y) / (segment.endPoint.y - this.endPoint.y) <= 0;
}
if (this.startPoint.y === this.endPoint.y) {
if (this.startPoint.y - segment.endPoint.y !== 0)
return (this.startPoint.y - segment.startPoint.y) / (this.startPoint.y - segment.endPoint.y) <= 0;
if (segment.endPoint.x - this.endPoint.x !== 0)
return (segment.endPoint.x - this.startPoint.x) / (segment.endPoint.x - this.endPoint.x) <= 0;
}
var tg = (this.endPoint.y - this.startPoint.y) / (this.endPoint.x - this.startPoint.x);
var y1 = this.startPoint.y + (segment.startPoint.x - this.startPoint.x) * tg;
var y2 = this.startPoint.y + (segment.endPoint.x - this.startPoint.x) * tg;
var dy1 = segment.startPoint.y - y1;
var dy2 = segment.endPoint.y - y2;
if (dy1 === 0 && dy2 === 0) {
return (this.startPoint.y - y1) / (this.endPoint.y - y1) <= 0 ||
(this.startPoint.y - y2) / (this.endPoint.y - y2) <= 0;
}
return dy1 === 0 || dy2 === 0 || dy1 / dy2 < 0;
};
Segment.create = function (x1, y1, x2, y2) {
return new Segment(new Point(x1, y1), new Point(x2, y2));
};
Segment.createByPoints = function (point1, point2) {
return Segment.create(point1.x, point1.y, point2.x, point2.y);
};
return Segment;
}());
exports.Segment = Segment;
var EventDispatcher = /** @class */ (function () {
function EventDispatcher() {
this.listeners = [];
}
EventDispatcher.prototype.add = function (listener) {
if (!listener)
throw new Error("Not Implemented");
if (!this.hasEventListener(listener))
this.listeners.push(listener);
};
EventDispatcher.prototype.remove = function (listener) {
for (var i = 0, currentListener; currentListener = this.listeners[i]; i++) {
if (currentListener === listener) {
this.listeners.splice(i, 1);
break;
}
}
};
EventDispatcher.prototype.raise = function (funcName) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
for (var i = 0, listener; listener = this.listeners[i]; i++) {
listener[funcName].apply(listener, args);
}
};
EventDispatcher.prototype.raise1 = function (action) {
for (var i = 0, listener; listener = this.listeners[i]; i++) {
action(listener);
}
};
EventDispatcher.prototype.hasEventListener = function (listener) {
for (var i = 0, l = this.listeners.length; i < l; i++)
if (this.listeners[i] === listener)
return true;
return false;
};
return EventDispatcher;
}());
exports.EventDispatcher = EventDispatcher;
var Utils = /** @class */ (function () {
function Utils() {
}
//http://workservices01/OpenWiki/ow.asp?ASPxRichEdit_BinarySearch#preview
// BINARY INDEX
// Input array [4, 8, 10]
// find binaryIndexOf normedBinaryIndexOf
// (-inf, 3] -1 -1
// 4 0 0
// [5, 7] -2 0
// 8 1 1
// 9 -3 1
// 10 2 2
// [11, +inf) -4 2
// case array.length == 0, then return -1
// don't touch default value = -2! In some case binaryIndexOf call as ([], ()=>.., 0, [].length - 1)
Utils.binaryIndexOf = function (array, comparer, minIndex, maxIndex) {
if (minIndex === void 0) { minIndex = 0; }
if (maxIndex === void 0) { maxIndex = -2; }
var findFromZeroPosition = minIndex == 0;
if (maxIndex == -2)
maxIndex = array.length - 1;
while (minIndex <= maxIndex) {
var currentIndex = (minIndex + ((maxIndex - minIndex) >> 1));
var compare = comparer(array[currentIndex]);
if (compare < 0)
minIndex = currentIndex + 1;
else if (compare > 0)
maxIndex = currentIndex - 1;
else
return currentIndex;
}
return findFromZeroPosition ? ~minIndex : -1;
};
Utils.normedBinaryIndexOf = function (array, comparer, minIndex, maxIndex) {
if (minIndex === void 0) { minIndex = 0; }
if (maxIndex === void 0) { maxIndex = -2; }
var index = Utils.binaryIndexOf(array, comparer, minIndex, maxIndex);
return Utils.binaryIndexNormalizator(index);
};
Utils.binaryIndexNormalizator = function (index) {
return index < 0 ? ~index - 1 : index;
};
return Utils;
}());
exports.Utils = Utils;
var GeometryUtils = /** @class */ (function () {
function GeometryUtils() {
}
GeometryUtils.getCommonRectangle = function (rects) {
if (!rects.length)
return Rectangle.create(0, 0, 0, 0);
var minX = Number.MAX_VALUE;
var maxX = -Number.MAX_VALUE;
var minY = Number.MAX_VALUE;
var maxY = -Number.MAX_VALUE;
rects.forEach(function (rect) {
minX = Math.min(minX, rect.left);
maxX = Math.max(maxX, rect.right);
minY = Math.min(minY, rect.top);
maxY = Math.max(maxY, rect.bottom);
});
return Rectangle.create(minX, minY, maxX - minX, maxY - minY);
};
GeometryUtils.findFreeSpace = function (rects, size, exact, targetRect) {
var xs = [targetRect ? targetRect.left : 0], xshash;
var ys = [targetRect ? targetRect.top : 0];
rects.forEach(function (r) {
xs.push(r.left);
xs.push(r.right);
ys.push(r.top);
ys.push(r.bottom);
});
xs = xs.sort(function (a, b) { return a - b; }).reduce(function (acc, v, index) { return (xs[index - 1] !== v && acc.push(v) && acc) || acc; }, []); // magic for distinct
ys = ys.sort(function (a, b) { return a - b; }).reduce(function (acc, v, index) { return (ys[index - 1] !== v && acc.push(v) && acc) || acc; }, []);
var matrix = ys.map(function (y) { return xs.map(function (x, i) { return xs[i + 1] - x; }); });
var _loop_1 = function (i, rect) {
var xi0 = Utils.binaryIndexOf(xs, function (a) { return a - rect.left; });
var xi1 = Utils.binaryIndexOf(xs, function (a) { return a - rect.right; });
var yi0 = Utils.binaryIndexOf(ys, function (a) { return a - rect.top; });
var yi1 = Utils.binaryIndexOf(ys, function (a) { return a - rect.bottom; });
for (var y = yi0; y < yi1; y++)
for (var x = xi0; x < xi1; x++)
matrix[y][x] *= -1;
};
for (var i = 0, rect = void 0; rect = rects[i]; i++) {
_loop_1(i, rect);
}
for (var yi = 0; yi < ys.length; yi++) {
for (var xi = 0; xi < xs.length - 1; xi++) {
var checkResult = this.checkRect(matrix, ys, xs, yi, xi, size, exact);
if (checkResult > 0)
xi = checkResult;
else if (checkResult === 0)
return new Point(xs[xi], ys[yi]);
}
}
return null;
};
GeometryUtils.checkRect = function (matrix, ys, xs, yimin, ximin, size, exact) {
var height = 0;
var width = 0;
var ximax = xs.length - 2;
for (var yi = yimin; yi < ys.length; yi++) {
height = ys[yi + 1] - ys[yimin];
for (var xi = ximin; xi <= ximax; xi++) {
if (matrix[yi][xi] < 0)
return xi === 0 ? -1 : xi; // move left?
width = xs[xi + 1] - xs[ximin];
if (size.width <= width || (!exact && xi === xs.length - 2 && size.width / 2 <= width)) {
if (size.height <= height || (!exact && yi === ys.length - 2 && size.height / 2 <= height))
return 0;
ximax = xi;
}
}
}
};
GeometryUtils.getArrowPoints = function (point, directionPoint, arrowHeight, arrowWidth) {
if (point.x === directionPoint.x && point.y === directionPoint.y)
return { point1: point.clone(), point2: point.clone() };
var catX = directionPoint.x - point.x;
var catY = directionPoint.y - point.y;
var hypotenuse = Math.sqrt(Math.pow(catX, 2) + Math.pow(catY, 2));
var cos = catX / hypotenuse;
var sin = catY / hypotenuse;
var x1 = point.x + arrowHeight * cos + arrowWidth * sin;
var y1 = point.y + arrowHeight * sin - arrowWidth * cos;
var x2 = point.x + arrowHeight * cos - arrowWidth * sin;
var y2 = point.y + arrowHeight * sin + arrowWidth * cos;
return { point1: new Point(x1, y1), point2: new Point(x2, y2) };
};
GeometryUtils.removeUnnecessaryLinePoints = function (points, removeCallback, checkCallback) {
if (checkCallback === void 0) { checkCallback = (function (pt) { return pt !== undefined; }); }
this.removeDuplicatedPoints(points, removeCallback, checkCallback);
this.removeOneLinePoints(points, removeCallback, checkCallback);
this.removeBackwardPoints(points, removeCallback, checkCallback);
};
GeometryUtils.removeBackwardPoints = function (points, removeCallback, checkCallback) {
if (checkCallback === void 0) { checkCallback = (function (pt) { return pt !== undefined; }); }
var index = 0;
var point;
while (point = points[index]) {
if (points.length <= 2)
break;
var nextPoint = this.getNextPoint(points, index, true, checkCallback);
var prevPoint = this.getNextPoint(points, index, false, checkCallback);
if (prevPoint && nextPoint) {
if (point.x == prevPoint.x && point.x == nextPoint.x) {
if ((point.y > prevPoint.y && point.y > nextPoint.y) ||
(point.y < prevPoint.y && point.y < nextPoint.y)) {
if (removeCallback(points[index], index))
continue;
}
}
if (point.y == prevPoint.y && point.y == nextPoint.y) {
if ((point.x > prevPoint.x && point.x > nextPoint.x) ||
(point.x < prevPoint.x && point.x < nextPoint.x)) {
if (removeCallback(points[index], index))
continue;
}
}
}
index++;
}
};
GeometryUtils.removeOneLinePoints = function (points, removeCallback, checkCallback) {
if (checkCallback === void 0) { checkCallback = (function (pt) { return pt !== undefined; }); }
var index = 0;
var point;
while (point = points[index]) {
if (points.length <= 2)
break;
var nextPoint = this.getNextPoint(points, index, true, checkCallback);
var prevPoint = this.getNextPoint(points, index, false, checkCallback);
if (prevPoint && nextPoint) {
if ((point.x == prevPoint.x && point.x == nextPoint.x) ||
(point.y == prevPoint.y && point.y == nextPoint.y)) {
if (removeCallback(points[index], index))
continue;
}
var tg = (nextPoint.y - prevPoint.y) / (nextPoint.x - prevPoint.x);
if (nextPoint.y - points[index].y == (nextPoint.x - points[index].x) * tg) {
if (removeCallback(points[index], index))
continue;
}
}
index++;
}
};
GeometryUtils.removeDuplicatedPoints = function (points, removeCallback, checkCallback) {
if (checkCallback === void 0) { checkCallback = (function (pt) { return pt !== undefined; }); }
var index = 0;
var point;
while (point = points[index]) {
if (points.length <= 2)
break;
var nextPoint = this.getNextPoint(points, index, true, checkCallback);
if (nextPoint) {
if (point.x == nextPoint.x && point.y == nextPoint.y) {
var indexToRemove = index + 1;
if (indexToRemove === points.length - 1)
indexToRemove--;
if (removeCallback(points[indexToRemove], indexToRemove))
continue;
}
}
index++;
}
};
GeometryUtils.getNextPoint = function (points, index, direction, checkCallback) {
var result;
var newIndex = index + (direction ? 1 : -1);
while (result = points[newIndex]) {
if (checkCallback(result))
return result;
newIndex = newIndex + (direction ? 1 : -1);
}
};
GeometryUtils.getDistance = function (a, b) {
return Math.sqrt(Math.pow(a.x - b.x, 2) + Math.pow(a.y - b.y, 2));
};
GeometryUtils.getPathLength = function (points) {
var length = 0;
var prevPt;
points.forEach(function (pt) {
if (prevPt !== undefined) {
var lineLength = GeometryUtils.getDistance(pt, prevPt);
length += lineLength;
}
prevPt = pt;
});
return length;
};
GeometryUtils.getPathPointByPosition = function (points, relativePosition) {
if (!points.length)
throw new Error("Invalid points");
if (0 > relativePosition || relativePosition > 1)
throw new Error("Invalid relative position");
var length = this.getPathLength(points);
if (points.length <= 2 && length === 0)
return points[0];
var targetLength = length * relativePosition;
var currentLength = 0;
for (var i = 1; i < points.length; i++) {
var lineLength = GeometryUtils.getDistance(points[i], points[i - 1]);
if (currentLength + lineLength >= targetLength) {
var delta = targetLength - currentLength;
var cos = (points[i].x - points[i - 1].x) / lineLength;
var sin = (points[i].y - points[i - 1].y) / lineLength;
return new Point(points[i - 1].x + cos * delta, points[i - 1].y + sin * delta);
}
currentLength += lineLength;
}
;
return points[points.length - 1];
};
GeometryUtils.getLineAngle = function (beginPoint, endPoint) {
return Math.atan2(endPoint.y - beginPoint.y, endPoint.x - beginPoint.x);
};
GeometryUtils.getTriangleBeginAngle = function (beginPoint, endPoint, point) {
var lineAngle = this.getLineAngle(beginPoint, endPoint);
var beginPointAngle = this.getLineAngle(beginPoint, point);
return Math.abs(beginPointAngle - lineAngle);
};
GeometryUtils.getTriangleEndAngle = function (beginPoint, endPoint, point) {
var lineAngle = this.getLineAngle(beginPoint, endPoint);
var endPointAngle = this.getLineAngle(point, endPoint);
return Math.abs(lineAngle - endPointAngle);
};
GeometryUtils.getPathPointByPoint = function (points, point) {
if (!points.length)
throw new Error("Invalid points");
if (points.length === 1)
return points[0];
var distance = Number.MAX_VALUE;
var result;
for (var i = 1; i < points.length; i++) {
var beginPoint = points[i - 1];
var endPoint = points[i];
if (point.equals(beginPoint)) {
result = beginPoint.clone();
break;
}
if (point.equals(endPoint)) {
result = endPoint.clone();
break;
}
var beginAngle = this.getTriangleBeginAngle(beginPoint, endPoint, point);
var endAngle = this.getTriangleEndAngle(beginPoint, endPoint, point);
var beginDistance = GeometryUtils.getDistance(point, beginPoint);
var endDistance = GeometryUtils.getDistance(point, endPoint);
var orthOffset = beginDistance * Math.sin(beginAngle);
var currentDistance = void 0;
if (Math.PI / 2 <= beginAngle && beginAngle <= Math.PI * 3 / 2)
currentDistance = beginDistance;
else if (Math.PI / 2 <= endAngle && endAngle <= Math.PI * 3 / 2)
currentDistance = endDistance;
else
currentDistance = Math.abs(orthOffset);
if (currentDistance < distance) {
distance = currentDistance;
if (Math.PI / 2 <= beginAngle && beginAngle <= Math.PI * 3 / 2)
result = beginPoint.clone();
else if (Math.PI / 2 <= endAngle && endAngle <= Math.PI * 3 / 2)
result = endPoint.clone();
else {
var round = Math.fround || Math.round;
var lineAngle = this.getLineAngle(beginPoint, endPoint);
var offsetX = round(Math.abs(orthOffset * Math.sin(lineAngle)));
var offsetY = round(Math.abs(orthOffset * Math.cos(lineAngle)));
var isAbove = point.y - beginPoint.y < round((point.x - beginPoint.x) * Math.tan(lineAngle));
if (0 <= lineAngle && lineAngle <= Math.PI / 2) {
offsetX *= isAbove ? -1 : 1;
offsetY *= isAbove ? 1 : -1;
}
else if (Math.PI / 2 <= lineAngle && lineAngle <= Math.PI) {
offsetX *= isAbove ? 1 : -1;
offsetY *= isAbove ? 1 : -1;
}
else if (0 >= lineAngle && lineAngle >= -Math.PI / 2) {
offsetX *= isAbove ? 1 : -1;
offsetY *= isAbove ? 1 : -1;
}
else if (-Math.PI / 2 >= lineAngle && lineAngle >= -Math.PI) {
offsetX *= isAbove ? -1 : 1;
offsetY *= isAbove ? 1 : -1;
}
result = point.offset(offsetX, offsetY);
}
}
}
;
return result;
};
GeometryUtils.getPathPositionByPoint = function (points, point, maxPositionCount) {
if (maxPositionCount === void 0) { maxPositionCount = 100; }
point = this.getPathPointByPoint(points, point);
var length = this.getPathLength(points);
var currentLength = 0;
for (var i = 1; i < points.length; i++) {
var beginPoint = points[i - 1];
var endPoint = points[i];
var lineLength = GeometryUtils.getDistance(endPoint, beginPoint);
var angle = Math.atan((endPoint.y - beginPoint.y) / (endPoint.x - beginPoint.x));
var round = Math.fround || Math.round;
if ((point.x === endPoint.x && point.x === beginPoint.x) || (point.y === endPoint.y && point.y === beginPoint.y) ||
round(point.y - beginPoint.y) === round((point.x - beginPoint.x) * Math.tan(angle))) {
if (Math.sin(angle) !== 0)
currentLength += Math.abs((point.y - beginPoint.y) / Math.sin(angle));
else
currentLength += Math.abs(point.x - beginPoint.x);
return Math.round(currentLength * maxPositionCount / length) / maxPositionCount;
}
currentLength += lineLength;
}
;
return 1;
};
GeometryUtils.arePointsEqual = function (points1, points2) {
var count1 = points1.length;
var count2 = points2.length;
if (count1 != count2)
return false;
for (var i = 0; i < count1; i++)
if (!points1[i].equals(points2[i]))
return false;
return true;
};
return GeometryUtils;
}());
exports.GeometryUtils = GeometryUtils;
/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeCategories = /** @class */ (function () {
function ShapeCategories() {
}
ShapeCategories.General = "general";
ShapeCategories.Flowchart = "flowchart";
ShapeCategories.OrgChart = "orgChart";
ShapeCategories.Containers = "containers";
ShapeCategories.Custom = "custom";
return ShapeCategories;
}());
exports.ShapeCategories = ShapeCategories;
var ShapeTypes = /** @class */ (function () {
function ShapeTypes() {
}
// Standard
ShapeTypes.Text = "text";
ShapeTypes.Rectangle = "rectangle";
ShapeTypes.Ellipse = "ellipse";
ShapeTypes.Cross = "cross";
ShapeTypes.Triangle = "triangle";
ShapeTypes.Diamond = "diamond";
ShapeTypes.Heart = "heart";
ShapeTypes.Pentagon = "pentagon";
ShapeTypes.Hexagon = "hexagon";
ShapeTypes.Octagon = "octagon";
ShapeTypes.Star = "star";
ShapeTypes.ArrowLeft = "arrowLeft";
ShapeTypes.ArrowTop = "arrowTop";
ShapeTypes.ArrowRight = "arrowRight";
ShapeTypes.ArrowBottom = "arrowBottom";
ShapeTypes.ArrowNorthSouth = "arrowNorthSouth";
ShapeTypes.ArrowEastWest = "arrowEastWest";
// Flowchart
ShapeTypes.Process = "process";
ShapeTypes.Decision = "decision";
ShapeTypes.Terminator = "terminator";
ShapeTypes.PredefinedProcess = "predefinedProcess";
ShapeTypes.Document = "document";
ShapeTypes.MultipleDocuments = "multipleDocuments";
ShapeTypes.ManualInput = "manualInput";
ShapeTypes.Preparation = "preparation";
ShapeTypes.Data = "data";
ShapeTypes.Database = "database";
ShapeTypes.HardDisk = "hardDisk";
ShapeTypes.InternalStorage = "internalStorage";
ShapeTypes.PaperTape = "paperTape";
ShapeTypes.ManualOperation = "manualOperation";
ShapeTypes.Delay = "delay";
ShapeTypes.StoredData = "storedData";
ShapeTypes.Display = "display";
ShapeTypes.Merge = "merge";
ShapeTypes.Or = "or";
ShapeTypes.SummingJunction = "summingJunction";
// Containers
ShapeTypes.VerticalContainer = "verticalContainer";
ShapeTypes.HorizontalContainer = "horizontalContainer";
// Shapes with images
ShapeTypes.CardWithImageOnLeft = "cardWithImageOnLeft";
ShapeTypes.CardWithImageOnTop = "cardWithImageOnTop";
ShapeTypes.CardWithImageOnRight = "cardWithImageOnRight";
return ShapeTypes;
}());
exports.ShapeTypes = ShapeTypes;
var ShapeType;
(function (ShapeType) {
ShapeType[ShapeType["text"] = 0] = "text";
ShapeType[ShapeType["rectangle"] = 1] = "rectangle";
ShapeType[ShapeType["ellipse"] = 2] = "ellipse";
ShapeType[ShapeType["cross"] = 3] = "cross";
ShapeType[ShapeType["triangle"] = 4] = "triangle";
ShapeType[ShapeType["diamond"] = 5] = "diamond";
ShapeType[ShapeType["heart"] = 6] = "heart";
ShapeType[ShapeType["pentagon"] = 7] = "pentagon";
ShapeType[ShapeType["hexagon"] = 8] = "hexagon";
ShapeType[ShapeType["octagon"] = 9] = "octagon";
ShapeType[ShapeType["star"] = 10] = "star";
ShapeType[ShapeType["arrowLeft"] = 11] = "arrowLeft";
ShapeType[ShapeType["arrowTop"] = 12] = "arrowTop";
ShapeType[ShapeType["arrowRight"] = 13] = "arrowRight";
ShapeType[ShapeType["arrowBottom"] = 14] = "arrowBottom";
ShapeType[ShapeType["arrowNorthSouth"] = 15] = "arrowNorthSouth";
ShapeType[ShapeType["arrowEastWest"] = 16] = "arrowEastWest";
// Flowchart
ShapeType[ShapeType["process"] = 17] = "process";
ShapeType[ShapeType["decision"] = 18] = "decision";
ShapeType[ShapeType["terminator"] = 19] = "terminator";
ShapeType[ShapeType["predefinedProcess"] = 20] = "predefinedProcess";
ShapeType[ShapeType["document"] = 21] = "document";
ShapeType[ShapeType["multipleDocuments"] = 22] = "multipleDocuments";
ShapeType[ShapeType["manualInput"] = 23] = "manualInput";
ShapeType[ShapeType["preparation"] = 24] = "preparation";
ShapeType[ShapeType["data"] = 25] = "data";
ShapeType[ShapeType["database"] = 26] = "database";
ShapeType[ShapeType["hardDisk"] = 27] = "hardDisk";
ShapeType[ShapeType["internalStorage"] = 28] = "internalStorage";
ShapeType[ShapeType["paperTape"] = 29] = "paperTape";
ShapeType[ShapeType["manualOperation"] = 30] = "manualOperation";
ShapeType[ShapeType["delay"] = 31] = "delay";
ShapeType[ShapeType["storedData"] = 32] = "storedData";
ShapeType[ShapeType["display"] = 33] = "display";
ShapeType[ShapeType["merge"] = 34] = "merge";
ShapeType[ShapeType["or"] = 35] = "or";
ShapeType[ShapeType["summingJunction"] = 36] = "summingJunction";
// Containers
ShapeType[ShapeType["verticalContainer"] = 37] = "verticalContainer";
ShapeType[ShapeType["horizontalContainer"] = 38] = "horizontalContainer";
// Shapes with images
ShapeType[ShapeType["cardWithImageOnLeft"] = 39] = "cardWithImageOnLeft";
ShapeType[ShapeType["cardWithImageOnTop"] = 40] = "cardWithImageOnTop";
ShapeType[ShapeType["cardWithImageOnRight"] = 41] = "cardWithImageOnRight";
})(ShapeType = exports.ShapeType || (exports.ShapeType = {}));
/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var UnitConverter_1 = __webpack_require__(13);
var RenderManager_1 = __webpack_require__(12);
var Primitive_1 = __webpack_require__(18);
var PathPrimitive = /** @class */ (function (_super) {
__extends(PathPrimitive, _super);
function PathPrimitive(commands, style, className, clipPathId, onApplyProperties) {
var _this = _super.call(this, style, className, clipPathId, onApplyProperties) || this;
_this.commands = commands;
return _this;
}
PathPrimitive.prototype.createMainElement = function () {
return document.createElementNS(RenderManager_1.svgNS, "path");
};
PathPrimitive.prototype.applyElementProperties = function (element) {
element.setAttribute("d", this.commands.map(function (c) { return c.toString(); }).join(" "));
_super.prototype.applyElementProperties.call(this, element);
};
return PathPrimitive;
}(Primitive_1.SvgPrimitive));
exports.PathPrimitive = PathPrimitive;
var PathPrimitiveCommand = /** @class */ (function () {
function PathPrimitiveCommand() {
}
PathPrimitiveCommand.prototype.getUnitVaue = function (value) {
return typeof value === "number" ? UnitConverter_1.UnitConverter.twipsToPixels(value).toString() : value;
};
return PathPrimitiveCommand;
}());
exports.PathPrimitiveCommand = PathPrimitiveCommand;
var PathPrimitiveMoveToCommand = /** @class */ (function (_super) {
__extends(PathPrimitiveMoveToCommand, _super);
function PathPrimitiveMoveToCommand(x, y) {
var _this = _super.call(this) || this;
_this.x = x;
_this.y = y;
return _this;
}
PathPrimitiveMoveToCommand.prototype.toString = function () {
return "M " + this.getUnitVaue(this.x) + " " + this.getUnitVaue(this.y);
};
return PathPrimitiveMoveToCommand;
}(PathPrimitiveCommand));
exports.PathPrimitiveMoveToCommand = PathPrimitiveMoveToCommand;
var PathPrimitiveLineToCommand = /** @class */ (function (_super) {
__extends(PathPrimitiveLineToCommand, _super);
function PathPrimitiveLineToCommand(x, y) {
var _this = _super.call(this) || this;
_this.x = x;
_this.y = y;
return _this;
}
PathPrimitiveLineToCommand.prototype.toString = function () {
return "L " + this.getUnitVaue(this.x) + " " + this.getUnitVaue(this.y);
};
return PathPrimitiveLineToCommand;
}(PathPrimitiveCommand));
exports.PathPrimitiveLineToCommand = PathPrimitiveLineToCommand;
var PathPrimitiveCubicCurveToCommand = /** @class */ (function (_super) {
__extends(PathPrimitiveCubicCurveToCommand, _super);
function PathPrimitiveCubicCurveToCommand(x1, y1, x2, y2, x3, y3) {
var _this = _super.call(this) || this;
_this.x1 = x1;
_this.y1 = y1;
_this.x2 = x2;
_this.y2 = y2;
_this.x3 = x3;
_this.y3 = y3;
return _this;
}
PathPrimitiveCubicCurveToCommand.prototype.toString = function () {
return "C " + this.getUnitVaue(this.x1) + " " + this.getUnitVaue(this.y1) + "," +
this.getUnitVaue(this.x2) + " " + this.getUnitVaue(this.y2) + "," +
this.getUnitVaue(this.x3) + " " + this.getUnitVaue(this.y3);
};
return PathPrimitiveCubicCurveToCommand;
}(PathPrimitiveCommand));
exports.PathPrimitiveCubicCurveToCommand = PathPrimitiveCubicCurveToCommand;
var PathPrimitiveQuadraticCurveToCommand = /** @class */ (function (_super) {
__extends(PathPrimitiveQuadraticCurveToCommand, _super);
function PathPrimitiveQuadraticCurveToCommand(x1, y1, x2, y2) {
var _this = _super.call(this) || this;
_this.x1 = x1;
_this.y1 = y1;
_this.x2 = x2;
_this.y2 = y2;
return _this;
}
PathPrimitiveQuadraticCurveToCommand.prototype.toString = function () {
return "Q " + this.getUnitVaue(this.x1) + " " + this.getUnitVaue(this.y1) + "," +
this.getUnitVaue(this.x2) + " " + this.getUnitVaue(this.y2);
};
return PathPrimitiveQuadraticCurveToCommand;
}(PathPrimitiveCommand));
exports.PathPrimitiveQuadraticCurveToCommand = PathPrimitiveQuadraticCurveToCommand;
var PathPrimitiveArcToCommand = /** @class */ (function (_super) {
__extends(PathPrimitiveArcToCommand, _super);
function PathPrimitiveArcToCommand(rx, ry, xAxisRotation, largeArcFlag, sweepFag, x, y) {
var _this = _super.call(this) || this;
_this.rx = rx;
_this.ry = ry;
_this.xAxisRotation = xAxisRotation;
_this.largeArcFlag = largeArcFlag;
_this.sweepFag = sweepFag;
_this.x = x;
_this.y = y;
return _this;
}
PathPrimitiveArcToCommand.prototype.toString = function () {
return "A " + this.getUnitVaue(this.rx) + " " + this.getUnitVaue(this.ry) + " " +
this.getUnitVaue(this.xAxisRotation) + " " +
(this.largeArcFlag ? "1" : "0") + " " + (this.sweepFag ? "1" : "0") +
this.getUnitVaue(this.x) + "," + this.getUnitVaue(this.y);
};
return PathPrimitiveArcToCommand;
}(PathPrimitiveCommand));
exports.PathPrimitiveArcToCommand = PathPrimitiveArcToCommand;
var PathPrimitiveClosePathCommand = /** @class */ (function (_super) {
__extends(PathPrimitiveClosePathCommand, _super);
function PathPrimitiveClosePathCommand() {
return _super.call(this) || this;
}
PathPrimitiveClosePathCommand.prototype.toString = function () {
return "z";
};
return PathPrimitiveClosePathCommand;
}(PathPrimitiveCommand));
exports.PathPrimitiveClosePathCommand = PathPrimitiveClosePathCommand;
/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem = /** @class */ (function () {
function HistoryItem() {
this.uniqueId = -1;
}
HistoryItem.prototype.changeModified = function () {
return true;
};
HistoryItem.prototype.getName = function () {
return this.constructor.name;
};
return HistoryItem;
}());
exports.HistoryItem = HistoryItem;
var CompositionHistoryItem = /** @class */ (function (_super) {
__extends(CompositionHistoryItem, _super);
function CompositionHistoryItem() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this.historyItems = [];
return _this;
}
CompositionHistoryItem.prototype.changeModified = function () {
var item;
for (var i = 0; item = this.historyItems[i]; i++) {
if (item.changeModified())
return true;
}
return false;
};
CompositionHistoryItem.prototype.redo = function (manipulator) {
var item;
for (var i = 0; item = this.historyItems[i]; i++)
item.redo(manipulator);
};
CompositionHistoryItem.prototype.undo = function (manipulator) {
var item;
for (var i = this.historyItems.length - 1; item = this.historyItems[i]; i--)
item.undo(manipulator);
};
CompositionHistoryItem.prototype.add = function (historyItem) {
if (historyItem == null)
throw new Error("cannot be null");
this.historyItems.push(historyItem);
};
return CompositionHistoryItem;
}(HistoryItem));
exports.CompositionHistoryItem = CompositionHistoryItem;
/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Utils_1 = __webpack_require__(0);
var Style_1 = __webpack_require__(27);
var ConnectionPointSide;
(function (ConnectionPointSide) {
ConnectionPointSide[ConnectionPointSide["Undefined"] = -1] = "Undefined";
ConnectionPointSide[ConnectionPointSide["North"] = 0] = "North";
ConnectionPointSide[ConnectionPointSide["East"] = 1] = "East";
ConnectionPointSide[ConnectionPointSide["South"] = 2] = "South";
ConnectionPointSide[ConnectionPointSide["West"] = 3] = "West";
})(ConnectionPointSide = exports.ConnectionPointSide || (exports.ConnectionPointSide = {}));
;
exports.DEFAULT_ZINDEX = 0;
var DiagramItem = /** @class */ (function () {
function DiagramItem() {
this.key = undefined;
this.dataKey = undefined;
this.attachedConnectors = [];
this.zIndex = exports.DEFAULT_ZINDEX;
this.locked = false;
this.container = undefined;
this.containerLocked = false;
this.style = new Style_1.Style();
this.styleText = new Style_1.StyleText();
}
DiagramItem.prototype.assign = function (item) {
item.key = this.key;
item.dataKey = this.dataKey;
item.locked = this.locked;
item.attachedConnectors = this.attachedConnectors.slice();
item.style = this.style.clone();
item.styleText = this.styleText.clone();
item.zIndex = this.zIndex;
item.container = this.container;
item.containerLocked = this.containerLocked;
};
DiagramItem.prototype.invalidatePrimitives = function () {
this.primitives && this.primitives.forEach(function (element) {
element.dispose();
});
delete this.primitives;
delete this.selectorPrimitives;
};
DiagramItem.prototype.getPrimitives = function () {
if (!this.primitives)
this.primitives = this.createPrimitives();
return this.primitives;
};
DiagramItem.prototype.getSelectorPrimitives = function () {
if (!this.selectorPrimitives)
this.selectorPrimitives = this.createSelectorPrimitives();
return this.selectorPrimitives;
};
DiagramItem.prototype.getConnectionPointPosition = function (index, targetPoint) {
return this.getConnectionPoint(index, targetPoint).toPoint();
};
DiagramItem.prototype.getConnectionPoint = function (index, targetPoint) {
if (index < 0 && targetPoint)
index = this.getNearestConnectionPoint(targetPoint);
var connectionPoints = this.getConnectionPoints();
return connectionPoints[index] || connectionPoints[0];
};
DiagramItem.prototype.getNearestConnectionPoint = function (targetPoint) {
var distance = Number.MAX_VALUE;
var result;
this.getConnectionPoints().forEach(function (pt, index) {
var ptDistance = Utils_1.GeometryUtils.getDistance(pt, targetPoint);
if (ptDistance < distance) {
distance = ptDistance;
result = index;
}
});
return result;
};
DiagramItem.prototype.getConnectionPointIndex = function (side) {
var points = this.getConnectionPoints();
return points.reduce(function (prevIndex, pt, index) {
if (side === ConnectionPointSide.North && pt.y < points[prevIndex].y)
return index;
if (side === ConnectionPointSide.South && pt.y > points[prevIndex].y)
return index;
if (side === ConnectionPointSide.West && pt.x < points[prevIndex].x)
return index;
if (side === ConnectionPointSide.East && pt.x > points[prevIndex].x)
return index;
return prevIndex;
}, 0);
};
DiagramItem.prototype.getConnectionPointSideByIndex = function (index, targetPoint) {
var point = this.getConnectionPoint(index, targetPoint);
return this.getConnectionPointSide(point, targetPoint);
};
DiagramItem.prototype.getConnectionPointIndexForSide = function (side) {
return side;
};
Object.defineProperty(DiagramItem.prototype, "enableText", {
get: function () { return true; },
enumerable: true,
configurable: true
});
Object.defineProperty(DiagramItem.prototype, "allowEditText", {
get: function () { return true; },
enumerable: true,
configurable: true
});
Object.defineProperty(DiagramItem.prototype, "enableChildren", {
get: function () { return false; },
enumerable: true,
configurable: true
});
Object.defineProperty(DiagramItem.prototype, "isLocked", {
get: function () { return this.locked || this.containerLocked; },
enumerable: true,
configurable: true
});
DiagramItem.prototype.intersectedByRect = function (rect) {
return this.rectangle.intersect(rect);
};
return DiagramItem;
}());
exports.DiagramItem = DiagramItem;
/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var DiagramItem_1 = __webpack_require__(4);
var Utils_1 = __webpack_require__(0);
var UnitConverter_1 = __webpack_require__(13);
var LinePrimitive_1 = __webpack_require__(80);
var ConnectorPointsCalculator_1 = __webpack_require__(142);
var ConnectorPointsOrthogonalCalculator_1 = __webpack_require__(143);
var ConnectorProperties_1 = __webpack_require__(24);
var ConnectorTexts_1 = __webpack_require__(149);
var TextPrimitive_1 = __webpack_require__(64);
var Event_1 = __webpack_require__(10);
var Utils_2 = __webpack_require__(15);
var CanvasManagerBase_1 = __webpack_require__(33);
var NativeItem_1 = __webpack_require__(63);
var ConnectorPosition;
(function (ConnectorPosition) {
ConnectorPosition[ConnectorPosition["Begin"] = 0] = "Begin";
ConnectorPosition[ConnectorPosition["End"] = 1] = "End";
})(ConnectorPosition = exports.ConnectorPosition || (exports.ConnectorPosition = {}));
exports.CONNECTOR_DEFAULT_TEXT_POSITION = 0.5;
var Connector = /** @class */ (function (_super) {
__extends(Connector, _super);
function Connector(points) {
var _this = _super.call(this) || this;
_this.beginConnectionPointIndex = -1;
_this.endConnectionPointIndex = -1;
_this.properties = new ConnectorProperties_1.ConnectorProperties();
_this.points = points.map(function (pt) { return pt.clone(); });
if (points.length < 2)
throw Error("Points count should be greater than 1");
_this.texts = new ConnectorTexts_1.ConnectorTexts();
return _this;
}
Connector.prototype.assign = function (item) {
_super.prototype.assign.call(this, item);
item.beginItem = this.beginItem;
item.beginConnectionPointIndex = this.beginConnectionPointIndex;
item.endItem = this.endItem;
item.endConnectionPointIndex = this.endConnectionPointIndex;
item.properties = this.properties.clone();
item.texts = this.texts.clone();
};
Connector.prototype.clone = function () {
var clone = new Connector(this.points);
this.assign(clone);
return clone;
};
Connector.prototype.getRenderPoints = function (keepSkipped) {
if (keepSkipped === void 0) { keepSkipped = false; }
if (this.renderPoints === undefined) {
this.renderPoints = this.getCalculator().getPoints();
this.renderPointsWithoutSkipped = this.renderPoints.filter(function (pt) { return !pt.skipped; });
}
return keepSkipped ? this.renderPoints : this.renderPointsWithoutSkipped;
};
Connector.prototype.getText = function (position) {
if (position === void 0) { position = exports.CONNECTOR_DEFAULT_TEXT_POSITION; }
var textObj = this.texts.get(position);
return textObj ? textObj.value : "";
};
Connector.prototype.setText = function (text, position) {
if (position === void 0) { position = exports.CONNECTOR_DEFAULT_TEXT_POSITION; }
if (!text || text === "")
this.texts.remove(position);
else
this.texts.set(position, new ConnectorTexts_1.ConnectorText(position, text));
};
Connector.prototype.getTextPoint = function (position) {
var points = this.getRenderPoints();
return Utils_1.GeometryUtils.getPathPointByPosition(points, position);
};
Connector.prototype.getTextPositionByPoint = function (point) {
var points = this.getRenderPoints();
var length = Utils_1.GeometryUtils.getPathLength(points);
var pos = Utils_1.GeometryUtils.getPathPositionByPoint(points, point);
var minTextHeight = UnitConverter_1.UnitConverter.pointsToTwips(parseInt(this.styleText["font-size"]));
if (minTextHeight > pos * length)
return minTextHeight / length;
if (minTextHeight > length - pos * length)
return (length - minTextHeight) / length;
return pos;
};
Connector.prototype.getTextRectangle = function (position) {
return new Utils_1.Rectangle(this.getTextPoint(position), new Utils_1.Size(0, 0));
};
Connector.prototype.getCalculator = function () {
return (this.properties.lineOption === ConnectorProperties_1.ConnectorLineOption.Straight) ?
new ConnectorPointsCalculator_1.ConnectorPointsCalculator(this) :
new ConnectorPointsOrthogonalCalculator_1.ConnectorPointsOrthogonalCalculator(this);
};
Connector.prototype.invalidateRenderPoints = function () {
delete this.renderPoints;
delete this.renderPointsWithoutSkipped;
this.invalidatePrimitives();
};
Connector.prototype.createPrimitives = function () {
var _this = this;
var result = [];
var points = this.getRenderPoints();
points.forEach(function (pt, index) {
if (index > 0)
result.push(_this.createSegmentPrimitive(points[index - 1], pt, _this.style, null));
});
if (points.length > 1) {
if (this.properties.startLineEnding !== ConnectorProperties_1.ConnectorLineEnding.None)
result = result.concat(this.createLineEndingPrimitives(points[0], points[1]));
if (this.properties.endLineEnding !== ConnectorProperties_1.ConnectorLineEnding.None)
result = result.concat(this.createLineEndingPrimitives(points[points.length - 1], points[points.length - 2]));
}
return result.concat(this.createTextPrimitives());
};
Connector.prototype.createSelectorPrimitives = function () {
var _this = this;
var result = [];
var points = this.getRenderPoints();
points.forEach(function (pt, index) {
if (index > 0)
result.push(_this.createSegmentPrimitive(points[index - 1], pt, null, "selector"));
});
return result;
};
Connector.prototype.createTextPrimitives = function () {
var _this = this;
if (!this.enableText)
return [];
var result = [];
this.texts.forEach(function (textObj) {
var text = _this.getText(textObj.position);
if (text && text !== "") {
var pt = _this.getTextPoint(textObj.position);
result = result.concat([
new TextPrimitive_1.TextPrimitive(pt.x, pt.y, text, undefined, _this.styleText, true, null, CanvasManagerBase_1.PAGE_BG_TEXTFLOOR_FILTER_ID, false, function (el) {
Utils_2.RenderUtils.setElementEventData(el, Event_1.MouseEventElementType.ConnectorText, _this.key, textObj.position);
})
]);
}
});
return result;
};
Connector.prototype.createSegmentPrimitive = function (point1, point2, style, className) {
return new LinePrimitive_1.LinePrimitive(point1.x, point1.y, point2.x, point2.y, style, className);
};
Connector.prototype.createLineEndingPrimitives = function (point, directionPoint) {
var arrowHeight = Connector.arrowHeight;
if (point.x === directionPoint.x) {
var distance = Math.abs(point.y - directionPoint.y);
if (distance < arrowHeight)
arrowHeight = distance;
}
if (point.y === directionPoint.y) {
var distance = Math.abs(point.x - directionPoint.x);
if (distance < arrowHeight)
arrowHeight = distance;
}
var arrowPoints = Utils_1.GeometryUtils.getArrowPoints(point, directionPoint, arrowHeight, Connector.arrowWidth);
return [
new LinePrimitive_1.LinePrimitive(arrowPoints.point1.x, arrowPoints.point1.y, point.x, point.y, this.style),
new LinePrimitive_1.LinePrimitive(arrowPoints.point2.x, arrowPoints.point2.y, point.x, point.y, this.style)
];
};
Connector.prototype.getExtremeItem = function (position) {
if (position === ConnectorPosition.Begin)
return this.beginItem;
if (position === ConnectorPosition.End)
return this.endItem;
return null;
};
Connector.prototype.getExtremeConnectionPointIndex = function (position) {
if (position === ConnectorPosition.Begin)
return this.beginConnectionPointIndex;
if (position === ConnectorPosition.End)
return this.endConnectionPointIndex;
return -1;
};
Object.defineProperty(Connector.prototype, "rectangle", {
get: function () {
var points = this.getRenderPoints();
var xarr = points.map(function (p) { return p.x; });
var yarr = points.map(function (p) { return p.y; });
var minX = xarr.reduce(function (prev, cur) { return Math.min(prev, cur); }, Number.MAX_VALUE);
var maxX = xarr.reduce(function (prev, cur) { return Math.max(prev, cur); }, -Number.MAX_VALUE);
var minY = yarr.reduce(function (prev, cur) { return Math.min(prev, cur); }, Number.MAX_VALUE);
var maxY = yarr.reduce(function (prev, cur) { return Math.max(prev, cur); }, -Number.MAX_VALUE);
return Utils_1.Rectangle.create(minX, minY, maxX - minX, maxY - minY);
},
enumerable: true,
configurable: true
});
Connector.prototype.getMinX = function () {
var points = this.getRenderPoints();
var xarr = points.map(function (p) { return p.x; });
return xarr.reduce(function (prev, cur) { return Math.min(prev, cur); }, Number.MAX_VALUE);
};
Connector.prototype.getMinY = function () {
var points = this.getRenderPoints();
var yarr = points.map(function (p) { return p.y; });
return yarr.reduce(function (prev, cur) { return Math.min(prev, cur); }, Number.MAX_VALUE);
};
Connector.prototype.getConnectionPoints = function () {
return [];
};
Connector.prototype.getConnectionPointsForSelection = function () {
return [];
};
Connector.prototype.getConnectionPointSide = function (point, targetPoint) {
return DiagramItem_1.ConnectionPointSide.Undefined;
};
Connector.prototype.getConnectionPointForSelectionSide = function (point) {
return DiagramItem_1.ConnectionPointSide.Undefined;
};
Connector.prototype.getSegments = function () {
var points = this.getRenderPoints();
var result = [];
points.forEach(function (pt, index) {
if (index > 0)
result.push(Utils_1.Segment.createByPoints(points[index - 1], pt));
});
return result;
};
Connector.prototype.intersectedByRect = function (rect) {
var result = false;
this.getSegments().forEach(function (s) {
if (s.intersectRect(rect)) {
result = true;
return;
}
});
return result;
};
Connector.prototype.toNative = function () {
var item = new NativeItem_1.NativeConnector(this.key, this.dataKey);
item.fromKey = this.beginItem && this.beginItem.dataKey;
item.toKey = this.endItem && this.endItem.dataKey;
item.texts = this.texts.map(function (t) { return t; }).sort(function (a, b) { return a.position - b.position; }).map(function (a) { return a.value; });
return item;
};
Connector.arrowHeight = UnitConverter_1.UnitConverter.pixelsToTwips(8);
Connector.arrowWidth = UnitConverter_1.UnitConverter.pixelsToTwips(2);
Connector.minOffset = UnitConverter_1.UnitConverter.pixelsToTwips(18);
Connector.minTextHeight = UnitConverter_1.UnitConverter.pixelsToTwips(12);
return Connector;
}(DiagramItem_1.DiagramItem));
exports.Connector = Connector;
/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var MoveShapeHistoryItem_1 = __webpack_require__(130);
var AddConnectionHistoryItem_1 = __webpack_require__(37);
var MoveConnectorPointHistoryItem_1 = __webpack_require__(50);
var ModelResizeHistoryItem_1 = __webpack_require__(150);
var UpdatePositionsOnPageResizeHistoryItem_1 = __webpack_require__(151);
var Model_1 = __webpack_require__(19);
var Connector_1 = __webpack_require__(5);
var Utils_1 = __webpack_require__(0);
var DeleteConnectorPointHistoryItem_1 = __webpack_require__(152);
var ResizeShapeHistoryItem_1 = __webpack_require__(153);
var DeleteConnectionHistoryItem_1 = __webpack_require__(90);
var DeleteShapeHistoryItem_1 = __webpack_require__(91);
var DeleteConnectorHistoryItem_1 = __webpack_require__(154);
var SetSelectionHistoryItem_1 = __webpack_require__(44);
var Shape_1 = __webpack_require__(11);
var ConnectorProperties_1 = __webpack_require__(24);
var UnitConverter_1 = __webpack_require__(13);
var AddShapeHistoryItem_1 = __webpack_require__(51);
var AddConnectorHistoryItem_1 = __webpack_require__(52);
var Graph_1 = __webpack_require__(53);
var Base_1 = __webpack_require__(17);
var InsertToContainerHistoryItem_1 = __webpack_require__(191);
var RemoveFromContainerHistoryItem_1 = __webpack_require__(192);
var ChangeShapeParametersHistoryItem_1 = __webpack_require__(102);
var ChangeStyleHistoryItem_1 = __webpack_require__(46);
var ChangeStyleTextHistoryItem_1 = __webpack_require__(36);
var ChangeConnectorTextHistoryItem_1 = __webpack_require__(54);
var ChangeConnectorPropertyHistoryItem_1 = __webpack_require__(55);
var ChangeLockedHistoryItem_1 = __webpack_require__(104);
var ChangeContainerLockedHistoryItem_1 = __webpack_require__(193);
var GraphInfo_1 = __webpack_require__(194);
var Structures_1 = __webpack_require__(31);
var ModelUtils = /** @class */ (function () {
function ModelUtils() {
}
ModelUtils.setShapePosition = function (history, model, shape, newPosition) {
if (!shape.position.equals(newPosition))
history.addAndRedo(new MoveShapeHistoryItem_1.MoveShapeHistoryItem(shape.key, newPosition));
};
ModelUtils.setShapeSize = function (history, model, shape, newPosition, newSize) {
if (!shape.size.equals(newSize) || !shape.position.equals(newPosition))
history.addAndRedo(new ResizeShapeHistoryItem_1.ResizeShapeHistoryItem(shape.key, newPosition, newSize));
};
ModelUtils.setConnectorPoint = function (history, model, connector, pointIndex, newPosition) {
if (!connector.points[pointIndex].equals(newPosition))
history.addAndRedo(new MoveConnectorPointHistoryItem_1.MoveConnectorPointHistoryItem(connector.key, pointIndex, newPosition));
};
ModelUtils.updateConnectorAttachedPoints = function (history, model, connector) {
history.beginTransaction();
var beginContainer = connector.beginItem && model.findItemCollapsedContainer(connector.beginItem);
var beginAttachedToContainer = beginContainer && (!connector.endItem || !model.isContainerItem(beginContainer, connector.endItem));
var endContainer = connector.endItem && model.findItemCollapsedContainer(connector.endItem);
var endAttachedToContainer = endContainer && (!connector.beginItem || !model.isContainerItem(endContainer, connector.beginItem));
if (beginAttachedToContainer)
this.updateConnectorBeginPoint(history, connector, beginContainer, (endAttachedToContainer && endContainer) || connector.endItem, function (index) { return beginContainer.getConnectionPointIndexForItem(connector.beginItem, index); });
else
this.updateConnectorBeginPoint(history, connector, connector.beginItem, (endAttachedToContainer && endContainer) || connector.endItem);
if (endAttachedToContainer)
this.updateConnectorEndPoint(history, connector, endContainer, function (index) { return endContainer.getConnectionPointIndexForItem(connector.beginItem, index); });
else
this.updateConnectorEndPoint(history, connector, connector.endItem);
history.endTransaction();
};
ModelUtils.updateConnectorBeginPoint = function (history, connector, beginItem, endItem, getConnectionPointIndex) {
if (beginItem) {
var connectionPointIndex = getConnectionPointIndex !== undefined ?
getConnectionPointIndex(connector.beginConnectionPointIndex) : connector.beginConnectionPointIndex;
var targetPoint = connector.points[1];
if (endItem && connector.points.length === 2) {
if (connector.endConnectionPointIndex !== -1)
targetPoint = endItem.getConnectionPointPosition(connector.endConnectionPointIndex, Utils_1.Point.empty());
else
targetPoint = endItem.rectangle.center;
}
var pt = beginItem.getConnectionPointPosition(connectionPointIndex, targetPoint);
if (!connector.points[0].equals(pt))
history.addAndRedo(new MoveConnectorPointHistoryItem_1.MoveConnectorPointHistoryItem(connector.key, 0, pt));
}
};
ModelUtils.updateConnectorEndPoint = function (history, connector, endItem, getConnectionPointIndex) {
if (endItem) {
var connectionPointIndex = getConnectionPointIndex !== undefined ?
getConnectionPointIndex(connector.endConnectionPointIndex) : connector.endConnectionPointIndex;
var pt = endItem.getConnectionPointPosition(connectionPointIndex, connector.points[connector.points.length - 2]);
if (!connector.points[connector.points.length - 1].equals(pt))
history.addAndRedo(new MoveConnectorPointHistoryItem_1.MoveConnectorPointHistoryItem(connector.key, connector.points.length - 1, pt));
}
};
ModelUtils.updateContainerConnectorsAttachedPoints = function (history, model, rootContainer, container) {
var _this = this;
if (container === void 0) { container = rootContainer; }
history.beginTransaction();
var children = model.getChildren(container);
children.forEach(function (child) {
if (child instanceof Shape_1.Shape) {
child.attachedConnectors.forEach(function (connector) {
var beginItemInContainer = connector.beginItem && model.isContainerItem(container, connector.beginItem);
var endItemInContainer = connector.endItem && model.isContainerItem(container, connector.endItem);
if (beginItemInContainer && !endItemInContainer) {
var collapsedContainer = model.findItemTopCollapsedContainer(connector.beginItem);
var endCollapsedContainer = connector.endItem && model.findItemTopCollapsedContainer(connector.endItem);
if (!collapsedContainer)
_this.updateConnectorBeginPoint(history, connector, connector.beginItem, endCollapsedContainer || connector.endItem);
else {
_this.updateConnectorBeginPoint(history, connector, collapsedContainer, endCollapsedContainer || connector.endItem, function (index) { return rootContainer.getConnectionPointIndexForItem(connector.beginItem, index); });
}
}
if (endItemInContainer && !beginItemInContainer) {
var collapsedContainer = model.findItemTopCollapsedContainer(connector.endItem);
if (!collapsedContainer)
_this.updateConnectorEndPoint(history, connector, connector.endItem);
else {
_this.updateConnectorEndPoint(history, connector, collapsedContainer, function (index) { return rootContainer.getConnectionPointIndexForItem(connector.endItem, index); });
}
}
});
_this.updateContainerConnectorsAttachedPoints(history, model, rootContainer, child);
}
});
history.endTransaction();
};
ModelUtils.getConnectorsWithoutBeginItemInfo = function (model) {
var connectors = model.findConnectorsWithoutBeginItem();
return connectors.map(function (c) {
return {
connector: c,
point: c.points[0].clone()
};
});
};
ModelUtils.getConnectorsWithoutEndItemInfo = function (model) {
var connectors = model.findConnectorsWithoutEndItem();
return connectors.map(function (c) {
return {
connector: c,
point: c.points[c.points.length - 1].clone()
};
});
};
ModelUtils.updateShapeAttachedConnectors = function (history, model, shape) {
shape.attachedConnectors.forEach(function (connector) {
ModelUtils.removeConnectorIntermediatePoints(history, connector);
ModelUtils.updateConnectorAttachedPoints(history, model, connector);
});
};
ModelUtils.updateMovingShapeConnections = function (history, shape, beginPointsInfo, endPointsInfo, resetTargetCallback, updateTargetCallback) {
var _this = this;
resetTargetCallback();
beginPointsInfo.forEach(function (pi) {
var connectionPointIndex = _this.getMovingShapeConnectionPointIndex(shape, pi.point);
if (shape.rectangle.contains(pi.point) || connectionPointIndex > -1) {
updateTargetCallback(shape, connectionPointIndex);
if (connectionPointIndex !== pi.connector.beginConnectionPointIndex && pi.connector.beginItem)
history.addAndRedo(new DeleteConnectionHistoryItem_1.DeleteConnectionHistoryItem(pi.connector, Connector_1.ConnectorPosition.Begin));
history.addAndRedo(new AddConnectionHistoryItem_1.AddConnectionHistoryItem(pi.connector, shape, connectionPointIndex, Connector_1.ConnectorPosition.Begin));
}
else if (pi.connector.beginItem) {
history.addAndRedo(new DeleteConnectionHistoryItem_1.DeleteConnectionHistoryItem(pi.connector, Connector_1.ConnectorPosition.Begin));
history.addAndRedo(new MoveConnectorPointHistoryItem_1.MoveConnectorPointHistoryItem(pi.connector.key, 0, pi.point));
}
});
endPointsInfo.forEach(function (pi) {
var connectionPointIndex = _this.getMovingShapeConnectionPointIndex(shape, pi.point);
if (shape.rectangle.contains(pi.point) || connectionPointIndex > -1) {
updateTargetCallback(shape, connectionPointIndex);
if (connectionPointIndex !== pi.connector.endConnectionPointIndex && pi.connector.endItem)
history.addAndRedo(new DeleteConnectionHistoryItem_1.DeleteConnectionHistoryItem(pi.connector, Connector_1.ConnectorPosition.End));
history.addAndRedo(new AddConnectionHistoryItem_1.AddConnectionHistoryItem(pi.connector, shape, connectionPointIndex, Connector_1.ConnectorPosition.End));
}
else if (pi.connector.endItem) {
history.addAndRedo(new DeleteConnectionHistoryItem_1.DeleteConnectionHistoryItem(pi.connector, Connector_1.ConnectorPosition.End));
history.addAndRedo(new MoveConnectorPointHistoryItem_1.MoveConnectorPointHistoryItem(pi.connector.key, pi.connector.points.length - 1, pi.point));
}
});
};
ModelUtils.getMovingShapeConnectionPointIndex = function (shape, point) {
var _this = this;
var connectionPointIndex = -1;
shape.getConnectionPoints().forEach(function (pt, index) {
if (Utils_1.GeometryUtils.getDistance(point, pt) < _this.connectionPointActionSize)
connectionPointIndex = index;
});
return connectionPointIndex;
};
ModelUtils.removeUnnecessaryConnectorPoints = function (history, connector, exceptPoints, removeCallback) {
history.beginTransaction();
Utils_1.GeometryUtils.removeUnnecessaryLinePoints(connector.points, function (pt, index) {
var needRemove = true;
if (exceptPoints) {
exceptPoints.forEach(function (ept) {
if (ept && ept.equals(pt)) {
needRemove = false;
return;
}
});
}
if (needRemove) {
history.addAndRedo(new DeleteConnectorPointHistoryItem_1.DeleteConnectorPointHistoryItem(connector.key, index));
if (removeCallback !== undefined)
removeCallback(index);
return true;
}
});
history.endTransaction();
};
ModelUtils.removeConnectorIntermediatePoints = function (history, connector) {
if (connector.properties.lineOption !== ConnectorProperties_1.ConnectorLineOption.Orthogonal || connector.points.length <= 2)
return;
history.beginTransaction();
var removePoints = false;
if (this.isShapeIntersectConnectorPointsLine(connector.beginItem, connector))
removePoints = true;
if (this.isShapeIntersectConnectorPointsLine(connector.endItem, connector))
removePoints = true;
if (removePoints) {
while (connector.points.length > 2) {
history.addAndRedo(new DeleteConnectorPointHistoryItem_1.DeleteConnectorPointHistoryItem(connector.key, 1));
}
}
history.endTransaction();
};
ModelUtils.isShapeIntersectConnectorPointsLine = function (shape, connector) {
if (!shape)
return false;
var offset = Connector_1.Connector.minOffset - UnitConverter_1.UnitConverter.pixelsToTwips(1);
var rect = shape.rectangle.inflate(offset, offset);
var prevPt;
for (var i = 1; i < connector.points.length - 1; i++) {
if (prevPt !== undefined) {
if (prevPt.x === connector.points[i].x) {
if (rect.left <= prevPt.x && prevPt.x <= rect.right)
return true;
}
if (prevPt.y === connector.points[i].y) {
if (rect.top <= prevPt.y && prevPt.y <= rect.bottom)
return true;
}
}
prevPt = connector.points[i];
}
return false;
};
ModelUtils.getSnappedPos = function (model, gridSize, pos, isHorizontal) {
var snapOffset = isHorizontal ? model.snapStartPoint.x : model.snapStartPoint.y;
return Math.round((pos - snapOffset) / gridSize) * gridSize + snapOffset;
};
ModelUtils.tryUpdateModelSize = function (history, model, processPoints) {
var offset = history.modelManipulator.getModelSizeUpdateOffset();
if (!offset.isEmpty()) {
history.addAndRedo(new ModelResizeHistoryItem_1.ModelResizeHistoryItem(offset));
if (offset.left || offset.top) {
history.addAndRedo(new UpdatePositionsOnPageResizeHistoryItem_1.UpdatePositionsOnPageResizeHistoryItem(offset.left, offset.top));
if (processPoints !== undefined)
processPoints(offset.left, offset.top);
}
history.modelManipulator.raiseModelRectangleChanged(model.getRectangle(true));
}
};
ModelUtils.deleteItems = function (history, model, selection, items, deleteLocked) {
history.beginTransaction();
this.deleteItemsCore(history, model, items, deleteLocked);
this.tryUpdateModelSize(history, model);
history.addAndRedo(new SetSelectionHistoryItem_1.SetSelectionHistoryItem(selection, []));
history.endTransaction();
};
ModelUtils.deleteItemsCore = function (history, model, items, deleteLocked) {
var _this = this;
items.forEach(function (item) {
if (item instanceof Shape_1.Shape) {
var children = model.getChildren(item);
if (children.length) {
children.forEach(function (child) {
history.addAndRedo(new RemoveFromContainerHistoryItem_1.RemoveFromContainerHistoryItem(child));
_this.updateAttachedConnectorsContainer(history, model, child);
});
_this.deleteItemsCore(history, model, children.filter(function (child) { return !child.locked || deleteLocked; }), deleteLocked);
}
if (model.findItem(item.key))
_this.deleteShape(history, item);
}
if (item instanceof Connector_1.Connector) {
if (model.findItem(item.key))
_this.deleteConnector(history, item);
}
});
};
ModelUtils.deleteShape = function (history, shape) {
while (shape.attachedConnectors.length > 0) {
var connector = shape.attachedConnectors[0];
history.addAndRedo(new DeleteConnectionHistoryItem_1.DeleteConnectionHistoryItem(connector, connector.beginItem === shape ? Connector_1.ConnectorPosition.Begin : Connector_1.ConnectorPosition.End));
}
history.addAndRedo(new DeleteShapeHistoryItem_1.DeleteShapeHistoryItem(shape.key));
};
ModelUtils.deleteConnector = function (history, connector) {
if (connector.beginItem)
history.addAndRedo(new DeleteConnectionHistoryItem_1.DeleteConnectionHistoryItem(connector, Connector_1.ConnectorPosition.Begin));
if (connector.endItem)
history.addAndRedo(new DeleteConnectionHistoryItem_1.DeleteConnectionHistoryItem(connector, Connector_1.ConnectorPosition.End));
history.addAndRedo(new DeleteConnectorHistoryItem_1.DeleteConnectorHistoryItem(connector.key));
};
ModelUtils.deleteAllItems = function (history, model, selection) {
this.deleteItems(history, model, selection, model.items.slice(), true);
};
ModelUtils.deleteSelection = function (history, model, selection) {
this.deleteItems(history, model, selection, selection.getSelectedItems());
};
ModelUtils.changeChildrenContainerLocked = function (history, model, item, locked) {
var _this = this;
if (item instanceof Shape_1.Shape) {
var items = model.getChildren(item);
items.forEach(function (item) {
history.addAndRedo(new ChangeContainerLockedHistoryItem_1.ChangeContainerLockedHistoryItem(item, locked));
_this.changeChildrenContainerLocked(history, model, item, locked);
});
}
};
ModelUtils.changeSelectionLocked = function (history, model, selection, locked) {
var _this = this;
history.beginTransaction();
var items = selection.getSelectedItems(true);
items.forEach(function (item) {
history.addAndRedo(new ChangeLockedHistoryItem_1.ChangeLockedHistoryItem(item, locked));
_this.changeChildrenContainerLocked(history, model, item, locked);
});
history.addAndRedo(new SetSelectionHistoryItem_1.SetSelectionHistoryItem(selection, selection.getKeys())); // Update canvas
history.endTransaction();
};
ModelUtils.copyStylesToItem = function (history, model, fromItem, newItemKey) {
var toItem = model.findItem(newItemKey);
fromItem.styleText.forEach(function (propertyName) {
if (fromItem.styleText[propertyName] !== toItem.styleText[propertyName])
history.addAndRedo(new ChangeStyleTextHistoryItem_1.ChangeStyleTextHistoryItem(newItemKey, propertyName, fromItem.styleText[propertyName]));
});
fromItem.style.forEach(function (propertyName) {
if (fromItem.style[propertyName] !== toItem.style[propertyName])
history.addAndRedo(new ChangeStyleHistoryItem_1.ChangeStyleHistoryItem(newItemKey, propertyName, fromItem.style[propertyName]));
});
};
// Cloning
ModelUtils.cloneShapeToOffset = function (history, model, shape, dx, dy) {
history.beginTransaction();
var newPosition = shape.position.offset(dx, dy);
var addHistoryItem = new AddShapeHistoryItem_1.AddShapeHistoryItem(shape.description.key, newPosition, shape.text);
history.addAndRedo(addHistoryItem);
var newKey = addHistoryItem.shapeKey;
history.addAndRedo(new ResizeShapeHistoryItem_1.ResizeShapeHistoryItem(newKey, newPosition, shape.size.clone()));
history.addAndRedo(new ChangeShapeParametersHistoryItem_1.ChangeShapeParametersHistoryItem(newKey, shape.parameters.clone()));
this.copyStylesToItem(history, model, shape, newKey);
history.endTransaction();
return newKey;
};
ModelUtils.cloneConnectorToOffset = function (history, model, connector, beginItemKey, endItemKey, dx, dy) {
history.beginTransaction();
var newPoints = connector.points.map(function (p) { return p.offset(dx, dy); });
var addHistoryItem = new AddConnectorHistoryItem_1.AddConnectorHistoryItem(newPoints);
history.addAndRedo(addHistoryItem);
var newKey = addHistoryItem.connectorKey;
var newConnector = model.findConnector(newKey);
connector.properties.forEach(function (propertyName) {
if (connector.properties[propertyName] !== newConnector.properties[propertyName])
history.addAndRedo(new ChangeConnectorPropertyHistoryItem_1.ChangeConnectorPropertyHistoryItem(newKey, propertyName, connector.properties[propertyName]));
});
if (beginItemKey) {
var from = model.findShape(beginItemKey);
history.addAndRedo(new AddConnectionHistoryItem_1.AddConnectionHistoryItem(newConnector, from, connector.beginConnectionPointIndex, Connector_1.ConnectorPosition.Begin));
}
if (endItemKey) {
var to = model.findShape(endItemKey);
history.addAndRedo(new AddConnectionHistoryItem_1.AddConnectionHistoryItem(newConnector, to, connector.endConnectionPointIndex, Connector_1.ConnectorPosition.End));
}
var newTexts = connector.texts.clone();
newTexts.forEach(function (connectorText) {
history.addAndRedo(new ChangeConnectorTextHistoryItem_1.ChangeConnectorTextHistoryItem(newConnector, connectorText.position, connectorText.value));
});
this.copyStylesToItem(history, model, connector, newKey);
history.endTransaction();
return newKey;
};
ModelUtils.cloneSelectionToOffset = function (history, model, selection, dx, dy) {
var _this = this;
history.beginTransaction();
var newShapes = {};
var ids = [];
selection.getSelectedShapes().forEach(function (shape) {
var newKey = _this.cloneShapeToOffset(history, model, shape, dx, dy);
newShapes[shape.key] = newKey;
ids.push(newKey);
});
selection.getSelectedConnectors().forEach(function (connector) {
var beginItemKey = connector.beginItem ? newShapes[connector.beginItem.key] : null;
var endItemKey = connector.endItem ? newShapes[connector.endItem.key] : null;
var newKey = _this.cloneConnectorToOffset(history, model, connector, beginItemKey, endItemKey, dx, dy);
ids.push(newKey);
});
history.addAndRedo(new SetSelectionHistoryItem_1.SetSelectionHistoryItem(selection, ids));
ModelUtils.tryUpdateModelSize(history, model);
history.endTransaction();
};
// Containers
ModelUtils.findContainerByEventKey = function (model, selection, key) {
var container = model.findContainer(key);
if (container)
return container;
else {
var shape = model.findShape(key);
if (shape && shape.container && !selection.hasKey(shape.key))
return shape.container;
}
};
ModelUtils.canInsertToContainer = function (model, item, container) {
if (item === container)
return false;
if (item instanceof Shape_1.Shape) {
if (model.findChild(item, container.key))
return false;
}
return true;
};
ModelUtils.canInsertSelectionToContainer = function (model, selection, container) {
var result = true;
selection.getSelectedItems().forEach(function (item) {
if (item === container) {
result = false;
return;
}
if (item instanceof Shape_1.Shape) {
if (model.findChild(item, container.key)) {
result = false;
return;
}
}
});
return result;
};
ModelUtils.insertToContainer = function (history, model, item, container) {
if (!container.enableChildren)
throw Error("Inpossible to add children to non-container shape.");
if (!this.canInsertToContainer(model, item, container))
return;
var oldContainer = item.container;
if (oldContainer !== container) {
history.beginTransaction();
if (oldContainer)
history.addAndRedo(new RemoveFromContainerHistoryItem_1.RemoveFromContainerHistoryItem(item));
history.addAndRedo(new InsertToContainerHistoryItem_1.InsertToContainerHistoryItem(item, container));
this.updateAttachedConnectorsContainer(history, model, item);
history.endTransaction();
}
};
ModelUtils.removeFromContainer = function (history, model, item) {
if (item.container) {
history.beginTransaction();
history.addAndRedo(new RemoveFromContainerHistoryItem_1.RemoveFromContainerHistoryItem(item));
this.updateAttachedConnectorsContainer(history, model, item);
history.endTransaction();
}
};
ModelUtils.insertSelectionToContainer = function (history, model, selection, container) {
var _this = this;
history.beginTransaction();
var selectedItems = selection.getSelectedItems();
var items = selectedItems.filter(function (item) { return !item.container || selectedItems.indexOf(item.container) === -1; });
items.forEach(function (item) {
_this.insertToContainer(history, model, item, container);
});
history.endTransaction();
};
ModelUtils.removeSelectionFromContainer = function (history, model, selection) {
var _this = this;
history.beginTransaction();
selection.getSelectedItems().forEach(function (item) {
if (item.container && !selection.hasKey(item.container.key)) {
history.addAndRedo(new RemoveFromContainerHistoryItem_1.RemoveFromContainerHistoryItem(item));
_this.updateAttachedConnectorsContainer(history, model, item);
}
});
history.endTransaction();
};
ModelUtils.getConnectorContainer = function (connector) {
if (connector.beginItem && connector.endItem && connector.beginItem.container === connector.endItem.container)
return connector.beginItem.container;
};
ModelUtils.updateAttachedConnectorsContainer = function (history, model, item) {
var _this = this;
history.beginTransaction();
item.attachedConnectors.forEach(function (connector) {
_this.updateConnectorContainer(history, model, connector);
});
history.endTransaction();
};
ModelUtils.updateConnectorContainer = function (history, model, connector) {
var container = this.getConnectorContainer(connector);
if (container) {
history.addAndRedo(new InsertToContainerHistoryItem_1.InsertToContainerHistoryItem(connector, container));
}
else if (connector.container) {
history.addAndRedo(new RemoveFromContainerHistoryItem_1.RemoveFromContainerHistoryItem(connector));
}
};
// Layout
ModelUtils.applyLayout = function (history, model, container, graph, layout, nonGraphItems, settings, snapToGrid, gridSize) {
history.beginTransaction();
var occupiedRectangles = this.getOccupiedRectangles(nonGraphItems, container);
layout = this.offsetLayoutToFreeSpace(layout, container && container.clientRectangle, occupiedRectangles, settings.columnSpacing);
if (snapToGrid)
this.adjustLayoutToSnapGrid(model, layout, gridSize);
if (container)
this.resizeContainerOnLayout(history, model, layout, container, settings.columnSpacing);
this.applyLayoutToNodes(history, model, layout, graph.edges.map(function (e) { return model.findConnector(e.key); }));
this.applyLayoutToConnectors(history, model, layout, graph.edges.map(function (e) { return model.findConnector(e.key); }));
history.endTransaction();
};
ModelUtils.getNonGraphItems = function (model, container, nodeKeyMap, shapes, connectors) {
var allItems = container ? model.getChildren(container) : model.items.filter(function (item) { return !item.container; });
return allItems.filter(function (item) {
if (item instanceof Connector_1.Connector) {
return (!item.beginItem || !nodeKeyMap[item.beginItem.key]) && (!item.endItem || !nodeKeyMap[item.endItem.key]) &&
connectors.indexOf(item) === -1;
}
if (item instanceof Shape_1.Shape) {
return !nodeKeyMap[item.key] &&
shapes.indexOf(item) === -1;
}
});
};
ModelUtils.getOccupiedRectangles = function (nonGraphItems, container) {
var occupiedRectangles = nonGraphItems.map(function (i) { return i.rectangle; });
if (container && occupiedRectangles.length) {
var rect = container.clientRectangle;
occupiedRectangles.push(Utils_1.Rectangle.create(rect.right, rect.top, 1, 1));
occupiedRectangles.push(Utils_1.Rectangle.create(rect.right, rect.bottom, 1, 1));
}
return occupiedRectangles;
};
ModelUtils.offsetLayoutToFreeSpace = function (layout, containerRect, occupiedRectangles, spacing) {
var graphItemRect = layout.getRectangle(true);
var freePoint = Utils_1.GeometryUtils.findFreeSpace(occupiedRectangles, graphItemRect.size.offset(spacing, spacing), false, containerRect);
if (freePoint) {
var x = freePoint.x + spacing;
var y = freePoint.y + spacing;
return layout.offsetNodes(x, y);
}
var maxX = occupiedRectangles && occupiedRectangles.length ?
occupiedRectangles.reduce(function (max, rect) { return rect.right > max ? rect.right : max; }, 0) :
(containerRect ? containerRect.left : 0);
var minY = containerRect ? containerRect.top : Math.max(0, graphItemRect.top);
return layout.offsetNodes(maxX + spacing, minY + spacing);
};
ModelUtils.resizeContainerOnLayout = function (history, model, layout, container, spacing) {
var rect = layout.getRectangle(true);
var width = container.rectangle.width;
if (container.rectangle.right < rect.right + spacing)
width += rect.right + spacing - container.rectangle.right;
var height = container.rectangle.height;
if (container.rectangle.bottom < rect.bottom + spacing)
height += rect.bottom + spacing - container.rectangle.bottom;
ModelUtils.setShapeSize(history, model, container, container.position, new Utils_1.Size(width, height));
};
ModelUtils.applyLayoutToNodes = function (history, model, layout, connectors) {
var _this = this;
var connectorsSet = connectors.reduce(function (acc, c) { return acc[c.key] = true && acc; }, {});
layout.forEachNode(function (nl, nk) {
var shape = model.findShape(nk);
_this.applyLayoutToNode(history, model, shape, nl.position, connectorsSet);
});
};
ModelUtils.applyLayoutToNode = function (history, model, shape, position, connectorsSet) {
var _this = this;
var delta = position.offset(-shape.position.x, -shape.position.y);
ModelUtils.setShapePosition(history, model, shape, position);
if (delta.x !== 0 || delta.y !== 0) {
shape.attachedConnectors
.filter(function (c) { return !connectorsSet[c.key]; })
.forEach(function (connector) {
ModelUtils.updateConnectorAttachedPoints(history, model, connector);
var beginPointIndex = connector.beginItem ? 1 : 0;
var endPointIndex = connector.endItem ? (connector.points.length - 2) : (connector.points.length - 1);
for (var i = beginPointIndex; i <= endPointIndex; i++)
history.addAndRedo(new MoveConnectorPointHistoryItem_1.MoveConnectorPointHistoryItem(connector.key, i, connector.points[i].offset(delta.x, delta.y)));
});
model.getChildren(shape).forEach(function (child) {
if (child instanceof Shape_1.Shape) {
var childPosition = child.position.offset(delta.x, delta.y);
_this.applyLayoutToNode(history, model, child, childPosition, connectorsSet);
}
});
}
};
ModelUtils.applyLayoutToConnectors = function (history, model, layout, connectors) {
var _this = this;
connectors.filter(function (c) { return c.beginItem && c.endItem; }).forEach(function (connector) {
var edgeLayout = layout.edgeToPosition[connector.key];
if (edgeLayout) {
var beginIndex = connector.beginItem.getConnectionPointIndexForSide(edgeLayout.beginIndex);
if (beginIndex !== connector.beginConnectionPointIndex)
history.addAndRedo(new AddConnectionHistoryItem_1.SetConnectionPointIndexHistoryItem(connector, beginIndex, Connector_1.ConnectorPosition.Begin));
var endIndex = connector.endItem.getConnectionPointIndexForSide(edgeLayout.endIndex);
if (endIndex !== connector.endConnectionPointIndex)
history.addAndRedo(new AddConnectionHistoryItem_1.SetConnectionPointIndexHistoryItem(connector, endIndex, Connector_1.ConnectorPosition.End));
}
_this.updateConnectorAttachedPoints(history, model, connector);
if (edgeLayout) {
while (connector.points.length > 2)
history.addAndRedo(new DeleteConnectorPointHistoryItem_1.DeleteConnectorPointHistoryItem(connector.key, 1));
}
});
};
ModelUtils.adjustLayoutToSnapGrid = function (model, layout, gridSize) {
var _this = this;
layout.nodeKeys.forEach(function (key) {
layout.nodeToLayout[key].position.x = _this.getSnappedPos(model, gridSize, layout.nodeToLayout[key].position.x, true);
layout.nodeToLayout[key].position.y = _this.getSnappedPos(model, gridSize, layout.nodeToLayout[key].position.y, false);
});
};
ModelUtils.getGraphInfoByItems = function (model, shapes, connectors) {
var itemsByContainerKey = {};
var items = [].concat(shapes).concat(connectors);
items.forEach(function (item) {
var containerKey = item.container && item.container.key;
if (!itemsByContainerKey[containerKey])
itemsByContainerKey[containerKey] = [];
itemsByContainerKey[containerKey].push(item);
});
var result = [];
for (var key in itemsByContainerKey) {
if (!itemsByContainerKey.hasOwnProperty(key))
continue;
var container = key && model.findContainer(key);
if (!container || container.expanded) {
var containerKey = container && container.key;
var graph = this.getGraphByItems(model, itemsByContainerKey[key], containerKey);
if (graph.nodes.length > 1)
result.push(new GraphInfo_1.GraphInfo(container, graph));
}
}
return result;
};
ModelUtils.getGraphByItems = function (model, items, containerKey) {
var _this = this;
var graph = new Graph_1.Graph([], []);
var knownIds = {};
items.forEach(function (item) {
_this.extendByConnectedComponents(item, graph, containerKey, knownIds);
});
graph.nodes = graph.nodes.sort(function (a, b) { return model.getItemIndex(model.findShape(a)) - model.getItemIndex(model.findShape(b)); });
return graph;
};
ModelUtils.extendByConnectedComponents = function (item, graph, containerKey, knownIds) {
var _this = this;
if (!item || item.locked || knownIds[item.key])
return;
knownIds[item.key] = true;
if (item instanceof Connector_1.Connector && (item.container && item.container.key) === containerKey &&
item.beginItem && !item.beginItem.locked && item.endItem && !item.endItem.locked &&
item.beginItem !== item.endItem) {
graph.addEdge(new Structures_1.Edge(item.key, item.beginItem && item.beginItem.key, item.endItem && item.endItem.key));
this.extendByConnectedComponents(item.beginItem, graph, containerKey, knownIds);
this.extendByConnectedComponents(item.endItem, graph, containerKey, knownIds);
}
else if (item instanceof Shape_1.Shape && (item.container && item.container.key) === containerKey) {
graph.addNode(item);
item.attachedConnectors.forEach(function (c) { return _this.extendByConnectedComponents(c, graph, containerKey, knownIds); });
}
};
// Units
ModelUtils.getlUnitValue = function (units, twipsValue) {
switch (units) {
case Model_1.DiagramUnit.Cm:
return UnitConverter_1.UnitConverter.twipsToCentimeters(twipsValue);
case Model_1.DiagramUnit.In:
return UnitConverter_1.UnitConverter.twipsToInches(twipsValue);
case Model_1.DiagramUnit.Px:
return UnitConverter_1.UnitConverter.twipsToPixels(twipsValue);
}
};
ModelUtils.getUnitText = function (units, unitItems, formatUnit, twipsValue, fractionDigits) {
if (fractionDigits === void 0) { fractionDigits = 2; }
var unitItemText = unitItems[units] ? " " + unitItems[units] : "";
var unitValue = this.getlUnitValue(units, twipsValue);
switch (units) {
case Model_1.DiagramUnit.Cm:
return formatUnit(+unitValue.toFixed(fractionDigits)) + unitItemText;
case Model_1.DiagramUnit.In:
return formatUnit(+unitValue.toFixed(fractionDigits)) + unitItemText;
case Model_1.DiagramUnit.Px:
return formatUnit(+unitValue.toFixed(0)) + unitItemText;
}
};
ModelUtils.getTwipsValue = function (units, value) {
switch (units) {
case Model_1.DiagramUnit.Cm:
return UnitConverter_1.UnitConverter.centimetersToTwips(value);
case Model_1.DiagramUnit.In:
return UnitConverter_1.UnitConverter.inchesToTwips(value);
case Model_1.DiagramUnit.Px:
return UnitConverter_1.UnitConverter.pixelsToTwips(value);
}
};
// Key generation
ModelUtils.getNextItemKey = function (keys, checkKey, baseKey) {
if (!keys.length && baseKey === undefined)
return "0";
for (var i = keys.length - 1; i >= 0; i--) {
baseKey = baseKey || keys[i];
if (baseKey !== undefined && baseKey !== null)
break;
}
var key = this.generateNextItemKey(baseKey || "0");
while (!checkKey(key)) {
key = this.generateNextItemKey(key);
}
return key;
};
ModelUtils.generateNextItemKey = function (key) {
for (var i = key.length - 1; i >= 0; i--) {
if (!this.isDigit(key[i])) {
if (i === key.length - 1)
key = key + "0";
break;
}
var code = key.charCodeAt(i);
var char = String.fromCharCode(code + 1);
if (char > "9") {
char = "0";
if (i === 0 || !this.isDigit(key[i - 1]))
char = "1" + char;
}
key = key.substr(0, i) + char + key.substr(i + 1);
if (char !== "0" && char !== "10")
break;
else if (char === "10")
i--;
}
return key;
};
ModelUtils.isDigit = function (char) {
return "0" <= char && char <= "9";
};
ModelUtils.getGuidItemKey = function () {
return Base_1.CreateGuid();
};
ModelUtils.connectionPointActionSize = UnitConverter_1.UnitConverter.pixelsToTwips(8);
return ModelUtils;
}());
exports.ModelUtils = ModelUtils;
/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var CommandBase_1 = __webpack_require__(196);
var CommandStates_1 = __webpack_require__(197);
var ModelUtils_1 = __webpack_require__(6);
var SimpleCommandBase = /** @class */ (function (_super) {
__extends(SimpleCommandBase, _super);
function SimpleCommandBase() {
return _super !== null && _super.apply(this, arguments) || this;
}
SimpleCommandBase.prototype.getState = function () {
return new CommandStates_1.SimpleCommandState(this.isEnabled(), this.getValue(), this.getDefaultValue(), this.getItems(), this.isVisible());
};
SimpleCommandBase.prototype.isVisible = function () {
return true;
};
SimpleCommandBase.prototype.isEnabled = function () {
return !this.control.settings.readOnly || this.isEnabledInReadOnlyMode();
};
SimpleCommandBase.prototype.isEnabledInReadOnlyMode = function () {
return false;
};
SimpleCommandBase.prototype.getValue = function () {
return undefined;
};
SimpleCommandBase.prototype.getDefaultValue = function () {
return undefined;
};
SimpleCommandBase.prototype.getItems = function () {
return undefined;
};
SimpleCommandBase.prototype.getModelUnit = function (value) {
return ModelUtils_1.ModelUtils.getlUnitValue(this.control.model.units, value);
};
SimpleCommandBase.prototype.getModelUnitText = function (value) {
return ModelUtils_1.ModelUtils.getUnitText(this.control.model.units, this.control.settings.unitItems, this.control.settings.formatUnit, value);
};
SimpleCommandBase.prototype.getModelUnitTwipsValue = function (value) {
return ModelUtils_1.ModelUtils.getTwipsValue(this.control.model.units, value);
};
SimpleCommandBase.prototype.getViewUnit = function (value) {
return ModelUtils_1.ModelUtils.getlUnitValue(this.control.settings.viewUnits, value);
};
SimpleCommandBase.prototype.getViewUnitText = function (value) {
return ModelUtils_1.ModelUtils.getUnitText(this.control.settings.viewUnits, this.control.settings.unitItems, this.control.settings.formatUnit, value);
};
SimpleCommandBase.prototype.getViewUnitTwipsValue = function (value) {
return ModelUtils_1.ModelUtils.getTwipsValue(this.control.settings.viewUnits, value);
};
return SimpleCommandBase;
}(CommandBase_1.CommandBase));
exports.SimpleCommandBase = SimpleCommandBase;
/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var CommandManager_1 = __webpack_require__(48);
exports.DiagramCommand = CommandManager_1.DiagramCommand;
var Diagram_1 = __webpack_require__(262);
exports.DiagramControl = Diagram_1.DiagramControl;
var Utils_1 = __webpack_require__(0);
exports.EventDispatcher = Utils_1.EventDispatcher;
var ShapeTypes_1 = __webpack_require__(1);
exports.ShapeTypes = ShapeTypes_1.ShapeTypes;
exports.ShapeCategories = ShapeTypes_1.ShapeCategories;
exports.ShapeType = ShapeTypes_1.ShapeType;
var UnitConverter_1 = __webpack_require__(13);
exports.UnitConverter = UnitConverter_1.UnitConverter;
var Browser_1 = __webpack_require__(23);
exports.Browser = Browser_1.Browser;
var DiagramSettings_1 = __webpack_require__(35);
exports.AutoZoomMode = DiagramSettings_1.AutoZoomMode;
var DataLayoutParameters_1 = __webpack_require__(114);
exports.DataLayoutType = DataLayoutParameters_1.DataLayoutType;
var LayoutSettings_1 = __webpack_require__(22);
exports.DataLayoutOrientation = LayoutSettings_1.DataLayoutOrientation;
__webpack_require__(306);
var Model_1 = __webpack_require__(19);
exports.DiagramUnit = Model_1.DiagramUnit;
exports.PageOrientation = Model_1.PageOrientation;
var ConnectorProperties_1 = __webpack_require__(24);
exports.ConnectorLineEnding = ConnectorProperties_1.ConnectorLineEnding;
exports.ConnectorLineOption = ConnectorProperties_1.ConnectorLineOption;
var Color_1 = __webpack_require__(38);
exports.ColorHelper = Color_1.ColorHelper;
var NativeItem_1 = __webpack_require__(63);
exports.NativeShape = NativeItem_1.NativeShape;
exports.NativeConnector = NativeItem_1.NativeConnector;
/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Utils_1 = __webpack_require__(0);
var TextPrimitive_1 = __webpack_require__(64);
var ClipPathPrimitive_1 = __webpack_require__(41);
var RectaglePrimitive_1 = __webpack_require__(20);
var DiagramItem_1 = __webpack_require__(4);
var UnitConverter_1 = __webpack_require__(13);
var Utils_2 = __webpack_require__(15);
var ConnectionPoint_1 = __webpack_require__(34);
exports.ShapeDefaultDimension = 1440;
exports.ShapeDefaultSize = new Utils_1.Size(exports.ShapeDefaultDimension, exports.ShapeDefaultDimension);
var ShapeDescription = /** @class */ (function () {
function ShapeDescription(title, defaultText, defaultSize, defaultImageUrl) {
if (defaultSize === void 0) { defaultSize = exports.ShapeDefaultSize.clone(); }
this.title = title;
this.defaultText = defaultText;
this.defaultSize = defaultSize;
this.defaultImageUrl = defaultImageUrl;
this.connectionPoints = this.createConnectionPoints();
this.connectionPointsWhileSelected = this.createConnectionPointsForSelection();
}
Object.defineProperty(ShapeDescription.prototype, "enableText", {
get: function () { return true; },
enumerable: true,
configurable: true
});
Object.defineProperty(ShapeDescription.prototype, "allowEditText", {
get: function () { return true; },
enumerable: true,
configurable: true
});
Object.defineProperty(ShapeDescription.prototype, "enableImage", {
get: function () { return false; },
enumerable: true,
configurable: true
});
Object.defineProperty(ShapeDescription.prototype, "allowEditImage", {
get: function () { return true; },
enumerable: true,
configurable: true
});
Object.defineProperty(ShapeDescription.prototype, "enableChildren", {
get: function () { return false; },
enumerable: true,
configurable: true
});
ShapeDescription.prototype.getConnectionPoints = function () {
return this.connectionPoints;
};
ShapeDescription.prototype.createConnectionPoints = function () {
return [
new ConnectionPoint_1.ConnectionPoint(0.5, 0, DiagramItem_1.ConnectionPointSide.North),
new ConnectionPoint_1.ConnectionPoint(1, 0.5, DiagramItem_1.ConnectionPointSide.East),
new ConnectionPoint_1.ConnectionPoint(0.5, 1, DiagramItem_1.ConnectionPointSide.South),
new ConnectionPoint_1.ConnectionPoint(0, 0.5, DiagramItem_1.ConnectionPointSide.West)
];
};
ShapeDescription.prototype.getConnectionPointsForSelection = function () {
return this.connectionPointsWhileSelected;
};
ShapeDescription.prototype.createConnectionPointsForSelection = function () {
return [
new ConnectionPoint_1.ConnectionPoint(0.5, 0, DiagramItem_1.ConnectionPointSide.North),
new ConnectionPoint_1.ConnectionPoint(1, 0.5, DiagramItem_1.ConnectionPointSide.East),
new ConnectionPoint_1.ConnectionPoint(0.5, 1, DiagramItem_1.ConnectionPointSide.South),
new ConnectionPoint_1.ConnectionPoint(0, 0.5, DiagramItem_1.ConnectionPointSide.West)
];
};
ShapeDescription.prototype.processConnectionPoint = function (shape, point) {
};
ShapeDescription.prototype.getConnectionPointIndexForItem = function (item, connectionPointIndex) {
return connectionPointIndex;
};
ShapeDescription.prototype.getConnectionPointIndexForSide = function (side) {
return side;
};
ShapeDescription.prototype.createParameters = function (parameters) {
};
ShapeDescription.prototype.normalizeParameters = function (shape, parameters) {
};
ShapeDescription.prototype.modifyParameters = function (shape, parameters, deltaX, deltaY) {
throw Error("Not implemented");
};
ShapeDescription.prototype.changeParameterValue = function (parameters, key, change) {
var p = parameters.get(key);
p.value = change(p);
};
ShapeDescription.prototype.getParameterPoints = function (shape) {
return [];
};
ShapeDescription.prototype.getExpandedSize = function (size, expandedSize) {
return size;
};
ShapeDescription.prototype.getCollapsedSize = function (size) {
return size;
};
ShapeDescription.prototype.getToolboxHeightToWidthRatio = function (width, height) {
return height / width;
};
ShapeDescription.prototype.allowResizeHorizontally = function (shape) {
return true;
};
ShapeDescription.prototype.allowResizeVertically = function (shape) {
return true;
};
ShapeDescription.prototype.createPrimitives = function (shape, forToolbox) {
var primitives = [];
primitives = primitives.concat(this.createShapePrimitives(shape, forToolbox));
if (this.enableImage)
primitives = primitives.concat(this.createImagePrimitives(shape, forToolbox));
if (this.enableText)
primitives = primitives.concat(this.createTextPrimitives(shape, forToolbox));
return primitives;
};
ShapeDescription.prototype.createImagePrimitives = function (shape, forToolbox) {
return [];
};
ShapeDescription.prototype.createTextPrimitives = function (shape, forToolbox) {
if (shape.text === undefined || shape.text === "")
return [];
var rect = this.getTextRectangle(shape.rectangle, shape.parameters);
var clipPathId = !forToolbox && Utils_2.RenderUtils.generateSvgElementId("clipText");
var textPoint = this.getTextPosition(rect, shape.styleText["text-anchor"]);
return [
new TextPrimitive_1.TextPrimitive(textPoint.x, textPoint.y, shape.text, rect.width, shape.styleText, false, clipPathId, undefined, this.getTextRotated()),
new ClipPathPrimitive_1.ClipPathPrimitive(clipPathId, [new RectaglePrimitive_1.RectanglePrimitive(rect.left, rect.top, rect.width, rect.height)]),
];
};
ShapeDescription.prototype.getTextRotated = function () {
return false;
};
ShapeDescription.prototype.getTextRectangle = function (rect, parameters) {
return rect;
};
ShapeDescription.prototype.getClientRectangle = function (rect) {
return rect;
};
ShapeDescription.prototype.getTextEditRectangle = function (rect, parameters) {
return this.getTextRectangle(rect, parameters);
};
ShapeDescription.prototype.createSelectorPrimitives = function (shape) {
return [
new RectaglePrimitive_1.RectanglePrimitive(shape.position.x, shape.position.y, shape.size.width, shape.size.height, null, "selector")
];
};
ShapeDescription.prototype.getTextPosition = function (rect, textAnchor) {
var result = new Utils_1.Point(rect.left, rect.top + rect.height / 2);
if (!textAnchor || textAnchor === "middle")
result.x = rect.left + rect.width / 2;
else if (textAnchor === "end")
result.x = rect.left + rect.width - ShapeDescription.textSpacing;
else if (textAnchor === "start")
result.x = rect.left + ShapeDescription.textSpacing;
return result;
};
ShapeDescription.textSpacing = UnitConverter_1.UnitConverter.pixelsToTwips(2);
return ShapeDescription;
}());
exports.ShapeDescription = ShapeDescription;
/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var KeyCode_1 = __webpack_require__(16);
var MouseButton;
(function (MouseButton) {
MouseButton[MouseButton["None"] = 0] = "None";
MouseButton[MouseButton["Left"] = 1] = "Left";
MouseButton[MouseButton["Right"] = 2] = "Right";
MouseButton[MouseButton["Middle"] = 4] = "Middle";
})(MouseButton = exports.MouseButton || (exports.MouseButton = {}));
var MouseEventElementType;
(function (MouseEventElementType) {
MouseEventElementType[MouseEventElementType["Background"] = 0] = "Background";
MouseEventElementType[MouseEventElementType["Document"] = 1] = "Document";
MouseEventElementType[MouseEventElementType["Undefined"] = 2] = "Undefined";
MouseEventElementType[MouseEventElementType["Connector"] = 3] = "Connector";
MouseEventElementType[MouseEventElementType["ConnectorPoint"] = 4] = "ConnectorPoint";
MouseEventElementType[MouseEventElementType["ConnectorSide"] = 5] = "ConnectorSide";
MouseEventElementType[MouseEventElementType["ConnectorOrthogonalSide"] = 6] = "ConnectorOrthogonalSide";
MouseEventElementType[MouseEventElementType["ConnectorText"] = 7] = "ConnectorText";
MouseEventElementType[MouseEventElementType["Shape"] = 8] = "Shape";
MouseEventElementType[MouseEventElementType["ShapeResizeBox"] = 9] = "ShapeResizeBox";
MouseEventElementType[MouseEventElementType["ShapeParameterBox"] = 10] = "ShapeParameterBox";
MouseEventElementType[MouseEventElementType["SelectionRect"] = 11] = "SelectionRect";
MouseEventElementType[MouseEventElementType["ShapeConnectionPoint"] = 12] = "ShapeConnectionPoint";
MouseEventElementType[MouseEventElementType["ShapeExpandButton"] = 13] = "ShapeExpandButton";
})(MouseEventElementType = exports.MouseEventElementType || (exports.MouseEventElementType = {}));
var MouseEventSource = /** @class */ (function () {
function MouseEventSource(type, key, value) {
this.type = type;
this.key = key;
this.value = value;
}
return MouseEventSource;
}());
exports.MouseEventSource = MouseEventSource;
var ResizeEventSource;
(function (ResizeEventSource) {
ResizeEventSource[ResizeEventSource["Undefined"] = 0] = "Undefined";
ResizeEventSource[ResizeEventSource["ResizeBox_NW"] = 1] = "ResizeBox_NW";
ResizeEventSource[ResizeEventSource["ResizeBox_NE"] = 2] = "ResizeBox_NE";
ResizeEventSource[ResizeEventSource["ResizeBox_SE"] = 3] = "ResizeBox_SE";
ResizeEventSource[ResizeEventSource["ResizeBox_SW"] = 4] = "ResizeBox_SW";
ResizeEventSource[ResizeEventSource["ResizeBox_N"] = 5] = "ResizeBox_N";
ResizeEventSource[ResizeEventSource["ResizeBox_E"] = 6] = "ResizeBox_E";
ResizeEventSource[ResizeEventSource["ResizeBox_S"] = 7] = "ResizeBox_S";
ResizeEventSource[ResizeEventSource["ResizeBox_W"] = 8] = "ResizeBox_W";
})(ResizeEventSource = exports.ResizeEventSource || (exports.ResizeEventSource = {}));
var DiagramEvent = /** @class */ (function () {
function DiagramEvent(modifiers) {
this.modifiers = modifiers;
}
return DiagramEvent;
}());
exports.DiagramEvent = DiagramEvent;
var DiagramFocusEvent = /** @class */ (function (_super) {
__extends(DiagramFocusEvent, _super);
function DiagramFocusEvent(inputText) {
var _this = _super.call(this, KeyCode_1.ModifierKey.None) || this;
_this.inputText = inputText;
return _this;
}
return DiagramFocusEvent;
}(DiagramEvent));
exports.DiagramFocusEvent = DiagramFocusEvent;
var DiagramMouseEventTouch = /** @class */ (function () {
function DiagramMouseEventTouch(offsetPoint, modelPoint) {
this.offsetPoint = offsetPoint;
this.modelPoint = modelPoint;
}
return DiagramMouseEventTouch;
}());
exports.DiagramMouseEventTouch = DiagramMouseEventTouch;
var DiagramMouseEventBase = /** @class */ (function (_super) {
__extends(DiagramMouseEventBase, _super);
function DiagramMouseEventBase(modifiers, offsetPoint, modelPoint, source) {
var _this = _super.call(this, modifiers) || this;
_this.offsetPoint = offsetPoint;
_this.modelPoint = modelPoint;
_this.source = source;
return _this;
}
return DiagramMouseEventBase;
}(DiagramEvent));
exports.DiagramMouseEventBase = DiagramMouseEventBase;
var DiagramMouseEvent = /** @class */ (function (_super) {
__extends(DiagramMouseEvent, _super);
function DiagramMouseEvent(modifiers, button, offsetPoint, modelPoint, source, touches) {
if (touches === void 0) { touches = []; }
var _this = _super.call(this, modifiers, offsetPoint, modelPoint, source) || this;
_this.button = button;
_this.touches = touches;
_this.scrollX = 0;
_this.scrollY = 0;
return _this;
}
return DiagramMouseEvent;
}(DiagramMouseEventBase));
exports.DiagramMouseEvent = DiagramMouseEvent;
var DiagramWheelEvent = /** @class */ (function (_super) {
__extends(DiagramWheelEvent, _super);
function DiagramWheelEvent(modifiers, deltaX, deltaY, offsetPoint, modelPoint, source) {
var _this = _super.call(this, modifiers, offsetPoint, modelPoint, source) || this;
_this.deltaX = deltaX;
_this.deltaY = deltaY;
return _this;
}
return DiagramWheelEvent;
}(DiagramMouseEventBase));
exports.DiagramWheelEvent = DiagramWheelEvent;
var DiagramContextMenuEvent = /** @class */ (function (_super) {
__extends(DiagramContextMenuEvent, _super);
function DiagramContextMenuEvent(modifiers, eventPoint, modelPoint) {
var _this = _super.call(this, modifiers) || this;
_this.eventPoint = eventPoint;
_this.modelPoint = modelPoint;
return _this;
}
return DiagramContextMenuEvent;
}(DiagramEvent));
exports.DiagramContextMenuEvent = DiagramContextMenuEvent;
var DiagramKeyboardEvent = /** @class */ (function (_super) {
__extends(DiagramKeyboardEvent, _super);
function DiagramKeyboardEvent(modifiers, keyCode, inputText) {
var _this = _super.call(this, modifiers) || this;
_this.keyCode = keyCode;
_this.inputText = inputText;
return _this;
}
DiagramKeyboardEvent.prototype.getShortcutCode = function () {
return this.modifiers | this.keyCode;
};
return DiagramKeyboardEvent;
}(DiagramEvent));
exports.DiagramKeyboardEvent = DiagramKeyboardEvent;
var DiagramClipboardEvent = /** @class */ (function (_super) {
__extends(DiagramClipboardEvent, _super);
function DiagramClipboardEvent(clipboardData) {
var _this = _super.call(this, KeyCode_1.ModifierKey.None) || this;
_this.clipboardData = clipboardData;
return _this;
}
return DiagramClipboardEvent;
}(DiagramEvent));
exports.DiagramClipboardEvent = DiagramClipboardEvent;
/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Utils_1 = __webpack_require__(0);
var ShapeParameters_1 = __webpack_require__(29);
var UnitConverter_1 = __webpack_require__(13);
var DiagramItem_1 = __webpack_require__(4);
var ConnectionPoint_1 = __webpack_require__(34);
var ImageInfo_1 = __webpack_require__(40);
var NativeItem_1 = __webpack_require__(63);
var Shape = /** @class */ (function (_super) {
__extends(Shape, _super);
function Shape(description, position) {
var _this = _super.call(this) || this;
_this.description = description;
// Containers
_this.childKeys = [];
_this.expanded = true;
_this.expandedSize = undefined;
if (!description)
throw Error("Shape type is incorrect");
_this.position = position.clone();
_this.size = description.defaultSize.clone();
_this.text = description.defaultText;
_this.image = new ImageInfo_1.ImageInfo(description.defaultImageUrl);
_this.parameters = new ShapeParameters_1.ShapeParameters();
description.createParameters(_this.parameters);
return _this;
}
Shape.prototype.assign = function (item) {
_super.prototype.assign.call(this, item);
item.size = this.size.clone();
item.text = this.text;
item.image = this.image.clone();
item.parameters = this.parameters.clone();
item.childKeys = this.childKeys.slice();
item.expanded = this.expanded;
if (this.expandedSize)
item.expandedSize = this.expandedSize.clone();
};
Shape.prototype.clone = function () {
var clone = new Shape(this.description, this.position.clone());
this.assign(clone);
return clone;
};
Object.defineProperty(Shape.prototype, "enableText", {
get: function () { return this.description.enableText; },
enumerable: true,
configurable: true
});
Object.defineProperty(Shape.prototype, "allowEditText", {
get: function () { return this.description.allowEditText; },
enumerable: true,
configurable: true
});
Object.defineProperty(Shape.prototype, "enableChildren", {
get: function () { return this.description.enableChildren; },
enumerable: true,
configurable: true
});
Object.defineProperty(Shape.prototype, "enableImage", {
get: function () { return this.description.enableImage; },
enumerable: true,
configurable: true
});
Object.defineProperty(Shape.prototype, "allowEditImage", {
get: function () { return this.description.allowEditImage; },
enumerable: true,
configurable: true
});
Shape.prototype.createPrimitives = function () {
return this.description.createPrimitives(this);
};
Shape.prototype.createSelectorPrimitives = function () {
return this.description.createSelectorPrimitives(this);
};
Shape.prototype.normalizeX = function (x) {
return Math.max(this.position.x, Math.min(x, this.position.x + this.size.width));
};
Shape.prototype.normalizeY = function (y) {
return Math.max(this.position.y, Math.min(y, this.position.y + this.size.height));
};
Shape.prototype.getConnectionPoints = function () {
var _this = this;
var result = this.description.getConnectionPoints().map(function (pt) {
var point = new ConnectionPoint_1.ConnectionPoint(_this.position.x + pt.x * _this.size.width, _this.position.y + pt.y * _this.size.height, pt.side);
_this.description.processConnectionPoint(_this, point);
return point;
});
return result;
};
Shape.prototype.getConnectionPointsForSelection = function () {
var _this = this;
var result = this.description.getConnectionPointsForSelection().map(function (pt) {
var point = new ConnectionPoint_1.ConnectionPoint(_this.position.x + pt.x * _this.size.width, _this.position.y + pt.y * _this.size.height, pt.side);
return point;
});
return result;
};
Shape.prototype.getConnectionPointSide = function (point, targetPoint) {
if (point.side !== DiagramItem_1.ConnectionPointSide.Undefined)
return point.side;
return this.getConnectionPointSideByGeometry(point);
};
Shape.prototype.getConnectionPointForSelectionSide = function (point) {
if (point.side !== DiagramItem_1.ConnectionPointSide.Undefined)
return point.side;
return this.getConnectionPointSideByGeometry(point);
};
Shape.prototype.getConnectionPointSideByGeometry = function (point) {
var pt = point.offset(-this.position.x, -this.position.y).multiply(1 / this.size.width, 1 / this.size.height);
if (pt.x >= pt.y && (pt.x > 0 || pt.y > 0)) {
if (pt.x < 0.5 || (1 - pt.x) >= pt.y)
return DiagramItem_1.ConnectionPointSide.North;
return DiagramItem_1.ConnectionPointSide.East;
}
else {
if (pt.x > 0.5 || (1 - pt.x) <= pt.y)
return DiagramItem_1.ConnectionPointSide.South;
return DiagramItem_1.ConnectionPointSide.West;
}
};
Shape.prototype.getConnectionPointIndexForItem = function (item, connectionPointIndex) {
return this.description.getConnectionPointIndexForItem(item, connectionPointIndex);
};
Shape.prototype.getConnectionPointIndexForSide = function (side) {
return this.description.getConnectionPointIndexForSide(side);
};
Shape.prototype.toggleExpandedSize = function () {
if (!this.expanded) {
this.expandedSize = this.size.clone();
this.size = this.getCollapsedSize();
}
else {
this.size = this.getExpandedSize();
this.expandedSize = undefined;
}
};
Shape.prototype.getExpandedSize = function () {
return this.description.getExpandedSize(this.size, this.expandedSize);
};
Shape.prototype.getCollapsedSize = function () {
return this.description.getCollapsedSize(this.size);
};
Shape.prototype.getToolboxHeightToWidthRatio = function () {
return this.description.getToolboxHeightToWidthRatio(this.size.width, this.size.height);
};
Object.defineProperty(Shape.prototype, "allowResizeHorizontally", {
get: function () {
return this.description.allowResizeHorizontally(this);
},
enumerable: true,
configurable: true
});
Object.defineProperty(Shape.prototype, "allowResizeVertically", {
get: function () {
return this.description.allowResizeVertically(this);
},
enumerable: true,
configurable: true
});
Object.defineProperty(Shape.prototype, "rectangle", {
get: function () {
return new Utils_1.Rectangle(this.position, this.size);
},
enumerable: true,
configurable: true
});
Object.defineProperty(Shape.prototype, "clientRectangle", {
get: function () {
return this.description.getClientRectangle(this.rectangle);
},
enumerable: true,
configurable: true
});
Object.defineProperty(Shape.prototype, "textRectangle", {
get: function () {
return this.description.getTextRectangle(this.rectangle, this.parameters);
},
enumerable: true,
configurable: true
});
Object.defineProperty(Shape.prototype, "textEditRectangle", {
get: function () {
return this.description.getTextEditRectangle(this.rectangle, this.parameters);
},
enumerable: true,
configurable: true
});
Shape.prototype.toNative = function () {
var item = new NativeItem_1.NativeShape(this.key, this.dataKey);
item.type = this.description.key;
item.text = this.text;
return item;
};
Shape.lineWidth = UnitConverter_1.UnitConverter.pixelsToTwips(2);
return Shape;
}(DiagramItem_1.DiagramItem));
exports.Shape = Shape;
/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Event_1 = __webpack_require__(10);
var Evt_1 = __webpack_require__(39);
var Utils_1 = __webpack_require__(0);
var Base_1 = __webpack_require__(17);
var KeyCode_1 = __webpack_require__(16);
var Browser_1 = __webpack_require__(23);
var Utils_2 = __webpack_require__(15);
var TouchUIHelper_1 = __webpack_require__(62);
var CanvasItemsManager_1 = __webpack_require__(82);
var ScrollView_1 = __webpack_require__(134);
var DiagramSettings_1 = __webpack_require__(35);
var InputManager_1 = __webpack_require__(135);
var CanvasPageManager_1 = __webpack_require__(136);
var CanvasViewManager_1 = __webpack_require__(138);
var CanvasSelectionManager_1 = __webpack_require__(87);
var ScrollController_1 = __webpack_require__(141);
exports.svgNS = "http://www.w3.org/2000/svg";
var PADDING_NORMALIZATION_TIMEOUT = 500, READONLY_CSSCLASS = "dxdi-read-only";
exports.LONG_TOUCH_TIMEOUT = 500, exports.DBL_CLICK_TIMEOUT = 500;
var RenderManager = /** @class */ (function () {
function RenderManager(parent, events, settings) {
this.moveLocked = false;
this.normalizationRequired = false;
this.lastClickElement = undefined;
this.longTouchTimer = undefined;
this.dblTouchTimer = undefined;
var mainElement = RenderManager.createMainElement(parent);
var svgElement = RenderManager.createSvgElement(mainElement);
this.scroll = settings.scrollView || new ScrollView_1.NativeScrollView(mainElement);
this.scroll.onScroll.add(this);
this.autoScroll = new ScrollController_1.AutoScrollController(this.scroll, mainElement);
this.view = new CanvasViewManager_1.CanvasViewManager(this.scroll, svgElement, settings.modelSize, settings.zoomLevel, settings.autoZoom, settings.simpleView, settings.rectangle);
this.input = new InputManager_1.InputManager(parent, mainElement, this.view, events, settings.zoomLevel);
this.items = new CanvasItemsManager_1.CanvasItemsManager(this.view.canvasElement, settings.zoomLevel);
this.page = new CanvasPageManager_1.CanvasPageManager(this.view.pageElement, settings);
this.selection = new CanvasSelectionManager_1.CanvasSelectionManager(this.view.canvasElement, settings.zoomLevel, settings.readOnly);
this.view.onViewChanged.add(this.page);
this.view.onViewChanged.add(this.items);
this.view.onViewChanged.add(this.selection);
this.view.onViewChanged.add(this.input);
this.attachEvents(svgElement);
this.mainElement = mainElement;
this.svgElement = svgElement;
this.events = events;
}
RenderManager.prototype.dispose = function () {
this.detachEvents(this.svgElement);
this.scroll.dispose();
this.input.dispose();
};
RenderManager.prototype.replaceParent = function (parent) {
if (this.mainElement && this.mainElement.parentNode !== parent)
parent.appendChild(this.mainElement);
this.input.replaceParent(parent);
};
RenderManager.prototype.update = function (saveScrollPosition) {
this.view.update({ horizontal: !saveScrollPosition, vertical: !saveScrollPosition });
this.page.redraw();
};
RenderManager.prototype.clear = function () {
this.items.clear();
this.selection.clear();
};
RenderManager.prototype.attachEvents = function (svgElement) {
this.onMouseDownHandler = this.onMouseDown.bind(this);
this.onMouseEnterHandler = this.onMouseEnter.bind(this);
this.onMouseLeaveHandler = this.onMouseLeave.bind(this);
this.onMouseWheelHandler = this.onMouseWheel.bind(this);
this.onMouseDblClickHandler = this.onMouseDblClick.bind(this);
this.onContextMenuHandler = this.onContextMenu.bind(this);
this.onMouseMoveHandler = this.onMouseMove.bind(this);
this.onMouseUpHandler = this.onMouseUp.bind(this);
this.onWindowResizelHandler = this.onWindowResize.bind(this);
this.onMouseClickHandler = this.onMouseClick.bind(this);
svgElement.addEventListener(TouchUIHelper_1.TouchUIHelper.touchMouseDownEventName, this.onMouseDownHandler);
svgElement.addEventListener("mouseenter", this.onMouseEnterHandler);
svgElement.addEventListener("mouseleave", this.onMouseLeaveHandler);
svgElement.addEventListener("wheel", this.onMouseWheelHandler);
svgElement.addEventListener("dblclick", this.onMouseDblClickHandler);
svgElement.addEventListener("click", this.onMouseClickHandler);
svgElement.addEventListener("contextmenu", this.onContextMenuHandler);
document.addEventListener(TouchUIHelper_1.TouchUIHelper.touchMouseMoveEventName, this.onMouseMoveHandler);
document.addEventListener(TouchUIHelper_1.TouchUIHelper.touchMouseUpEventName, this.onMouseUpHandler);
window.addEventListener("resize", this.onWindowResizelHandler);
};
RenderManager.prototype.detachEvents = function (svgElement) {
svgElement.removeEventListener(TouchUIHelper_1.TouchUIHelper.touchMouseDownEventName, this.onMouseDownHandler);
svgElement.removeEventListener("mouseenter", this.onMouseEnterHandler);
svgElement.removeEventListener("mouseleave", this.onMouseLeaveHandler);
svgElement.removeEventListener("wheel", this.onMouseWheelHandler);
svgElement.removeEventListener("dblclick", this.onMouseDblClickHandler);
svgElement.removeEventListener("contextmenu", this.onContextMenuHandler);
svgElement.removeEventListener("click", this.onMouseClickHandler);
document.removeEventListener(TouchUIHelper_1.TouchUIHelper.touchMouseMoveEventName, this.onMouseMoveHandler);
document.removeEventListener(TouchUIHelper_1.TouchUIHelper.touchMouseUpEventName, this.onMouseUpHandler);
window.removeEventListener("resize", this.onWindowResizelHandler);
};
RenderManager.prototype.onMouseDown = function (evt) {
var _this = this;
this.lockMouseMove();
this.input.lockFocus();
this.autoScroll.onMouseDown(evt);
Utils_2.raiseEvent(evt, this.createDiagramMouseEvent(evt), function (e) { return _this.events.onMouseDown(e); });
this.input.captureFocus();
if (Browser_1.Browser.TouchUI)
this.processTouchDown(evt);
var srcElement = Evt_1.Evt.GetEventSource(evt);
var tagName = srcElement && srcElement.tagName;
if (Browser_1.Browser.TouchUI || tagName.toLowerCase() === "img" || tagName.toLowerCase() === "image") // prevent dragging
return Evt_1.Evt.PreventEventAndBubble(evt);
};
RenderManager.prototype.onMouseMove = function (evt) {
var _this = this;
if (this.moveLocked)
return;
this.tryFinishNormalization(evt);
this.autoScroll.onMouseMove(evt, function () { return _this.onMouseMoveCore(evt); });
this.onMouseMoveCore(evt);
Browser_1.Browser.IE && this.lockMouseMove();
if (Browser_1.Browser.TouchUI) {
this.processTouchMove(evt);
return Evt_1.Evt.PreventEventAndBubble(evt);
}
};
RenderManager.prototype.onMouseMoveCore = function (evt) {
var _this = this;
Utils_2.raiseEvent(evt, this.createDiagramMouseEvent(evt, Browser_1.Browser.TouchUI), function (e) { return _this.events.onMouseMove(e); });
};
RenderManager.prototype.onMouseUp = function (evt) {
var _this = this;
this.lockMouseMove();
this.tryFinishNormalization(evt);
var needCaptureFocus = Base_1.GetIsParent(this.mainElement, Evt_1.Evt.GetEventSource(evt));
Utils_2.raiseEvent(evt, this.createDiagramMouseEvent(evt), function (e) { return _this.events.onMouseUp(e); });
this.autoScroll.onMouseUp(evt);
if (needCaptureFocus)
this.input.captureFocus();
if (Browser_1.Browser.TouchUI)
this.processTouchUp(evt);
};
RenderManager.prototype.onMouseEnter = function (evt) {
var _this = this;
this.autoScroll.onMouseEnter(evt);
this.tryFinishNormalization(evt);
Utils_2.raiseEvent(evt, this.createDiagramMouseEvent(evt), function (e) { return _this.events.onMouseEnter(e); });
};
RenderManager.prototype.onMouseLeave = function (evt) {
var _this = this;
Utils_2.raiseEvent(evt, this.createDiagramMouseEvent(evt), function (e) { return _this.events.onMouseLeave(e); });
};
RenderManager.prototype.onMouseDblClick = function (evt) {
var _this = this;
Utils_2.raiseEvent(evt, this.createDiagramMouseEvent(evt), function (e) { return _this.events.onDblClick(e); });
};
RenderManager.prototype.onMouseClick = function (evt) {
var _this = this;
Utils_2.raiseEvent(evt, this.createDiagramMouseEvent(evt), function (e) { return _this.events.onClick(e); });
};
RenderManager.prototype.onContextMenu = function (evt) {
var _this = this;
Utils_2.raiseEvent(evt, this.createDiagramContextMenuEvent(evt), function (e) { return _this.events.onContextMenu(e); });
this.input.captureFocus();
return Evt_1.Evt.PreventEventAndBubble(evt);
};
RenderManager.prototype.processTouchDown = function (evt) {
var _this = this;
this.resetLongTouch();
this.longTouchTimer = setTimeout(function () {
Utils_2.raiseEvent(evt, _this.createDiagramMouseEvent(evt), function (e) { return _this.events.onLongTouch(e); });
_this.resetLongTouch();
_this.resetDblClick();
}, exports.LONG_TOUCH_TIMEOUT);
};
RenderManager.prototype.processTouchMove = function (evt) {
this.resetLongTouch();
this.resetDblClick();
};
RenderManager.prototype.processTouchUp = function (evt) {
var _this = this;
if (this.longTouchTimer !== undefined) {
Utils_2.raiseEvent(evt, this.createDiagramMouseEvent(evt), function (e) { return _this.events.onClick(e); });
var element = Evt_1.Evt.GetEventSource(evt);
if (this.dblTouchTimer !== undefined && this.lastClickElement === element) {
Utils_2.raiseEvent(evt, this.createDiagramMouseEvent(evt), function (e) { return _this.events.onDblClick(e); });
this.resetDblClick();
}
else {
this.resetDblClick();
this.dblTouchTimer = setTimeout(function () { return _this.dblTouchTimer = undefined; }, exports.DBL_CLICK_TIMEOUT);
}
this.lastClickElement = element;
}
this.resetLongTouch();
};
RenderManager.prototype.resetLongTouch = function () {
if (this.longTouchTimer !== undefined)
clearTimeout(this.longTouchTimer);
this.longTouchTimer = undefined;
};
RenderManager.prototype.resetDblClick = function () {
if (this.dblTouchTimer !== undefined)
clearTimeout(this.dblTouchTimer);
this.dblTouchTimer = undefined;
};
RenderManager.prototype.onWindowResize = function () {
var resetTo = { horizontal: false, vertical: false };
if (this.view.autoZoom !== DiagramSettings_1.AutoZoomMode.Disabled) {
resetTo.horizontal = true;
resetTo.vertical = true;
}
else
resetTo = this.view.checkFitToCanvas();
this.view.update(resetTo);
};
RenderManager.prototype.onMouseWheel = function (evt) {
var _this = this;
Utils_2.raiseEvent(evt, this.createDiagramWheelEvent(evt), function (e) { return _this.events.onMouseWheel(e); });
};
RenderManager.prototype.notifyModelSizeChanged = function (size, offset) {
this.view.notifyModelSizeChanged(size, offset);
};
RenderManager.prototype.notifyModelRectangleChanged = function (rectangle) {
this.view.notifyModelRectangleChanged(rectangle);
};
RenderManager.prototype.notifyReadOnlyChanged = function (readOnly) {
Base_1.ToggleElementClassName(this.mainElement, READONLY_CSSCLASS, readOnly);
};
RenderManager.prototype.notifyDragStart = function (itemKeys) { };
RenderManager.prototype.notifyDragEnd = function (itemKeys) { };
RenderManager.prototype.notifyDragScrollStart = function () {
this.autoScroll.onDragScrollStart();
};
RenderManager.prototype.notifyDragScrollEnd = function () {
this.autoScroll.onDragScrollEnd();
};
RenderManager.prototype.createDiagramMouseEvent = function (evt, findEventSourceByPosition) {
var modifiers = KeyCode_1.getKeyModifiers(evt);
var button = isLeftButtonPressed(evt) ? Event_1.MouseButton.Left : Event_1.MouseButton.Right;
var offsetPoint = this.getOffsetPointByEvent(evt);
var modelPoint = this.getModelPoint(offsetPoint);
var eventSource = this.getEventSource(evt, findEventSourceByPosition);
var touches = this.createDiagramMouseEventTouches(evt);
return new Event_1.DiagramMouseEvent(modifiers, button, offsetPoint, modelPoint, eventSource, touches);
};
RenderManager.prototype.createDiagramMouseEventTouches = function (evt) {
var touches = [];
if (evt["touches"]) {
for (var i = 0; i < evt["touches"].length; i++) {
var x = evt["touches"][i].clientX;
var y = evt["touches"][i].clientY;
var offsetPoint = this.getOffsetPointByEventPoint(x, y);
var modelPoint = this.getModelPoint(offsetPoint);
touches.push(new Event_1.DiagramMouseEventTouch(offsetPoint, modelPoint));
}
}
return touches;
};
RenderManager.prototype.createDiagramContextMenuEvent = function (evt, findEventSourceByPosition) {
var modifiers = KeyCode_1.getKeyModifiers(evt);
var eventPoint = new Utils_1.Point(evt.pageX, evt.pageY);
var offsetPoint = this.getOffsetPointByEvent(evt);
var modelPoint = this.getModelPoint(offsetPoint);
return new Event_1.DiagramContextMenuEvent(modifiers, eventPoint, modelPoint);
};
RenderManager.prototype.createDiagramWheelEvent = function (evt) {
var modifiers = KeyCode_1.getKeyModifiers(evt);
var offsetPoint = this.getOffsetPointByEvent(evt);
var modelPoint = this.view.getModelPoint(offsetPoint);
var eventSource = this.getEventSource(evt);
return new Event_1.DiagramWheelEvent(modifiers, evt.deltaX, evt.deltaY, offsetPoint, modelPoint, eventSource);
};
RenderManager.prototype.getEventSource = function (evt, findByPosition) {
var element = Evt_1.Evt.GetEventSource(evt, findByPosition);
while (element && !this.isDocumentContainer(element)) {
var src_1 = Utils_2.RenderUtils.getElementEventData(element);
if (src_1 !== undefined)
return src_1;
element = element.parentNode;
}
var src = new Event_1.MouseEventSource();
if (element && this.isDocumentContainer(element))
src.type = Event_1.MouseEventElementType.Background;
return src;
};
RenderManager.prototype.isDocumentContainer = function (element) {
return Base_1.ElementHasCssClass(element, "dxdi-control");
};
RenderManager.prototype.lockMouseMove = function () {
var _this = this;
this.moveLocked = true;
setTimeout(function () { return _this.moveLocked = false; }, 10); // because chrome raises 2 events on click: buttonDown and move.
};
RenderManager.prototype.getModelPoint = function (offsetPoint) {
return this.view.getModelPoint(offsetPoint);
};
RenderManager.prototype.getOffsetPointByEvent = function (evt) {
var clientX = Evt_1.Evt.GetEventX(evt);
var clientY = Evt_1.Evt.GetEventY(evt);
return this.getOffsetPointByEventPoint(clientX, clientY);
};
RenderManager.prototype.getOffsetPointByEventPoint = function (clientX, clientY) {
var mainElementX = Base_1.GetAbsolutePositionX(this.mainElement);
var mainElementY = Base_1.GetAbsolutePositionY(this.mainElement);
return new Utils_1.Point(clientX - mainElementX, clientY - mainElementY);
};
RenderManager.prototype.getModelPointByEventPoint = function (clientX, clientY) {
var offsetPoint = this.getOffsetPointByEventPoint(clientX, clientY);
return this.view.getModelPoint(offsetPoint);
};
RenderManager.prototype.getEventPointByModelPoint = function (point) {
var pos = this.view.getAbsolutePoint(point);
return new Utils_1.Point(Base_1.GetAbsolutePositionX(this.mainElement) + pos.x, Base_1.GetAbsolutePositionY(this.mainElement) + pos.y);
};
RenderManager.prototype.notifyScrollChanged = function () {
var _this = this;
if (!this.normalizationRequired) {
setTimeout(function () {
_this.normalizationRequired = true;
}, PADDING_NORMALIZATION_TIMEOUT);
}
};
RenderManager.prototype.tryFinishNormalization = function (evt) {
if (!this.normalizationRequired)
return;
if (!Evt_1.Evt.IsLeftButtonPressed(evt)) {
this.normalizationRequired = false;
//this.view.tryNormalizePaddings();
}
};
RenderManager.createSvgElement = function (parent, forExport) {
if (forExport === void 0) { forExport = false; }
var svgElement = document.createElementNS(exports.svgNS, "svg");
svgElement.className.baseVal = "dxdi-canvas" + (forExport ? " export" : "");
parent && parent.appendChild(svgElement);
return svgElement;
};
RenderManager.createMainElement = function (parent) {
var element = document.createElement("div");
element.setAttribute("class", "dxdi-control");
parent.appendChild(element);
return element;
};
return RenderManager;
}());
exports.RenderManager = RenderManager;
function isLeftButtonPressed(evt) {
return !Browser_1.Browser.MSTouchUI ? Evt_1.Evt.IsLeftButtonPressed(evt) : evt.button != 2;
}
/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RichEditUnit;
(function (RichEditUnit) {
RichEditUnit[RichEditUnit["Centimeter"] = 0] = "Centimeter";
RichEditUnit[RichEditUnit["Inch"] = 1] = "Inch";
})(RichEditUnit = exports.RichEditUnit || (exports.RichEditUnit = {}));
var UnitConverter = /** @class */ (function () {
function UnitConverter() {
}
UnitConverter.getConverter = function (unit) {
switch (unit) {
case RichEditUnit.Centimeter: return new UIUnitConverterCentimeter();
case RichEditUnit.Inch: return new UIUnitConverterInch();
default: throw new Error();
}
};
// LAYOUT - PIXELS
// MODEL - TWIPS
// FORMS - CENTIMETERS / INCHES
// FONT - POINTS
// BORDER WIDTH ON UI - POINTS
// TO TWIPS (round and no round version)
UnitConverter.pixelsToTwips = function (value) {
return Math.round(UnitConverter.pixelsToTwipsF(value));
};
UnitConverter.inchesToTwips = function (value) {
return Math.round(UnitConverter.inchesToTwipsF(value));
};
UnitConverter.pointsToTwips = function (value) {
return Math.round(UnitConverter.pointsToTwipsF(value));
};
UnitConverter.picasToTwips = function (value) {
return Math.round(value * 1440 / UnitConverter.PICAS_PER_INCH);
};
UnitConverter.centimetersToTwips = function (value) {
return Math.round(UnitConverter.centimetersToTwipsF(value));
};
UnitConverter.pixelsToTwipsF = function (value) {
return value * 1440 / UnitConverter.DPI;
};
UnitConverter.inchesToTwipsF = function (value) {
return value * 1440;
};
UnitConverter.pointsToTwipsF = function (value) {
return value * 20;
};
UnitConverter.centimetersToTwipsF = function (value) {
return value * 1440 / UnitConverter.CENTIMETERS_PER_INCH;
};
UnitConverter.modelUnitsToDegrees = function (value) {
return value / 60000;
};
UnitConverter.modelUnitsToRadians = function (value) {
return value / 60000 * Math.PI / 180;
};
UnitConverter.degreesToModelUnits = function (value) {
return value * 60000;
};
UnitConverter.radiansToModelUnits = function (value) {
return value * 60000 / Math.PI * 180;
};
UnitConverter.radiansToDegrees = function (value) {
return value / Math.PI * 180;
};
UnitConverter.fdToModelUnits = function (value) {
return Math.round(value * 1875 / 2048);
};
UnitConverter.emuToTwips = function (val) {
return val / 635;
};
// TO PIXELS (round)
UnitConverter.twipsToPixels = function (value) {
return Math.round(UnitConverter.twipsToPixelsF(value));
};
UnitConverter.inchesToPixels = function (value) {
return Math.round(UnitConverter.DPI * value);
};
UnitConverter.centimeterToPixel = function (value) {
return Math.round(value / (UnitConverter.CENTIMETERS_PER_INCH / UnitConverter.DPI));
};
UnitConverter.pointsToPixels = function (value) {
return Math.round(value * UnitConverter.DPI / 72);
};
// TO PIXELS (no round)
UnitConverter.pointsToPixelsF = function (value) {
return value * UnitConverter.DPI / 72;
};
UnitConverter.twipsToPixelsF = function (value) {
return value * UnitConverter.DPI / 1440;
};
// TO POINTS (round)
UnitConverter.pixelsToPoints = function (value) {
return Math.round(value * 72 / UnitConverter.DPI);
};
UnitConverter.twipsToPoints = function (value) {
return Math.round(this.twipsToPointsF(value));
};
// TO POINTS (no round)
UnitConverter.twipsToPointsF = function (value) {
return value / 20;
};
// TO INCHES (no round)
UnitConverter.twipsToInches = function (value) {
return value / 1440;
};
UnitConverter.pixelsToInches = function (value) {
return value / UnitConverter.DPI;
};
// TO CENTIMETERS (no round)
UnitConverter.twipsToCentimeters = function (value) {
return value * UnitConverter.CENTIMETERS_PER_INCH / 1440;
};
UnitConverter.pixelToCentimeters = function (value) {
return value * UnitConverter.CENTIMETERS_PER_INCH / UnitConverter.DPI;
};
// ANOTHER
UnitConverter.hundredthsOfMillimeterToModelUnits = function (value) {
return 15 * value / 127;
};
UnitConverter.twipsToEmu = function (val) {
return val * 635;
};
UnitConverter.twipsToDegree = function (value) {
return value / 60000;
};
UnitConverter.DPI = 96;
UnitConverter.CENTIMETERS_PER_INCH = 2.54;
UnitConverter.PICAS_PER_INCH = 6;
return UnitConverter;
}());
exports.UnitConverter = UnitConverter;
var UIUnitConverterCentimeter = /** @class */ (function (_super) {
__extends(UIUnitConverterCentimeter, _super);
function UIUnitConverterCentimeter() {
return _super !== null && _super.apply(this, arguments) || this;
}
UIUnitConverterCentimeter.prototype.getUnits = function () {
return RichEditUnit.Centimeter;
};
UIUnitConverterCentimeter.prototype.twipsToUI = function (value) {
return UnitConverter.twipsToCentimeters(value);
};
UIUnitConverterCentimeter.prototype.UIToTwips = function (value) {
return UnitConverter.centimetersToTwips(value);
};
return UIUnitConverterCentimeter;
}(UnitConverter));
exports.UIUnitConverterCentimeter = UIUnitConverterCentimeter;
var UIUnitConverterInch = /** @class */ (function (_super) {
__extends(UIUnitConverterInch, _super);
function UIUnitConverterInch() {
return _super !== null && _super.apply(this, arguments) || this;
}
UIUnitConverterInch.prototype.getUnits = function () {
return RichEditUnit.Inch;
};
UIUnitConverterInch.prototype.twipsToUI = function (value) {
return UnitConverter.twipsToInches(value);
};
UIUnitConverterInch.prototype.UIToTwips = function (value) {
return UnitConverter.inchesToTwips(value);
};
return UIUnitConverterInch;
}(UnitConverter));
exports.UIUnitConverterInch = UIUnitConverterInch;
/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeDescription_1 = __webpack_require__(9);
var Utils_1 = __webpack_require__(0);
var RectaglePrimitive_1 = __webpack_require__(20);
var ShapeTypes_1 = __webpack_require__(1);
var RectangleShapeDescription = /** @class */ (function (_super) {
__extends(RectangleShapeDescription, _super);
function RectangleShapeDescription(title, defaultText, defaultSize) {
if (title === void 0) { title = "Rectangle"; }
if (defaultText === void 0) { defaultText = ""; }
if (defaultSize === void 0) { defaultSize = new Utils_1.Size(ShapeDescription_1.ShapeDefaultDimension, ShapeDescription_1.ShapeDefaultDimension * 0.75); }
return _super.call(this, title, defaultText, defaultSize) || this;
}
Object.defineProperty(RectangleShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Rectangle; },
enumerable: true,
configurable: true
});
RectangleShapeDescription.prototype.createShapePrimitives = function (shape) {
var _a = shape.rectangle, left = _a.left, top = _a.top, width = _a.width, height = _a.height;
return [
new RectaglePrimitive_1.RectanglePrimitive(left, top, width, height, shape.style),
];
};
return RectangleShapeDescription;
}(ShapeDescription_1.ShapeDescription));
exports.RectangleShapeDescription = RectangleShapeDescription;
/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Event_1 = __webpack_require__(10);
var __1 = __webpack_require__(8);
var Utils_1 = __webpack_require__(0);
var Base_1 = __webpack_require__(17);
var Browser_1 = __webpack_require__(23);
var RenderUtils = /** @class */ (function () {
function RenderUtils() {
}
RenderUtils.updateSvgElementSize = function (svgElement, width, height, forExport) {
svgElement.style.width = width + "px";
svgElement.style.height = height + "px";
svgElement.setAttribute("viewBox", "0 0 " + width + " " + height);
if (forExport) {
svgElement.setAttribute("width", width.toString());
svgElement.setAttribute("height", height.toString());
}
};
RenderUtils.removeContent = function (element) {
while (element.firstChild)
element.removeChild(element.firstChild);
};
RenderUtils.setElementEventData = function (element, type, key, value) {
if (type === Event_1.MouseEventElementType.Undefined)
return;
element.setAttribute("data-type", type.toString());
if (key !== undefined)
element.setAttribute("data-key", key.toString());
if (value !== undefined)
element.setAttribute("data-value", value.toString());
};
RenderUtils.getElementEventData = function (element) {
if (element.getAttribute && element.getAttribute("data-type")) {
return new Event_1.MouseEventSource(parseInt(element.getAttribute("data-type")), element.getAttribute("data-key"), element.getAttribute("data-value"));
}
var className = element.getAttribute && element.getAttribute("class");
if (className === "dxdi-page" || className === "dxdi-main")
return new Event_1.MouseEventSource(Event_1.MouseEventElementType.Document);
};
RenderUtils.getHtmlElementStylePropertyName = function (propertyName) {
switch (propertyName) {
case "fill":
return "color";
case "text-anchor":
return "text-align";
}
return propertyName;
};
RenderUtils.getStylePropertyValue = function (propertyName, propertyValue, reverseTextAnchor) {
if (reverseTextAnchor === void 0) { reverseTextAnchor = false; }
if (propertyName === "text-anchor" && reverseTextAnchor) {
if (propertyValue === "start")
return "end";
if (propertyValue === "end")
return "start";
}
return propertyValue;
};
RenderUtils.applyStyleToElement = function (style, element, reverseTextAnchor) {
var _this = this;
if (reverseTextAnchor === void 0) { reverseTextAnchor = false; }
var defaultStyle = style.getDefaultInstance();
style.forEach(function (propertyName) {
var propertyValue = style[propertyName];
var elPropertyName = (element instanceof HTMLElement) ? _this.getHtmlElementStylePropertyName(propertyName) : propertyName;
if (propertyValue !== undefined && propertyValue !== "" && propertyValue !== defaultStyle[propertyName])
element.style.setProperty(elPropertyName, _this.getStylePropertyValue(propertyName, propertyValue, reverseTextAnchor));
else
element.style.setProperty(elPropertyName, "");
});
};
RenderUtils.generateSvgElementId = function (prefix) {
return prefix + "_" + Base_1.CreateGuid();
};
RenderUtils.getSvgTextRectangle = function (textEl, lineWidth) {
if (lineWidth === void 0) { lineWidth = 0; }
var bBox;
try {
bBox = textEl.getBBox();
}
catch (_a) { } // TODO make measure in another way because of FF error
if (bBox) {
var x = __1.UnitConverter.pixelsToTwips(Math.round(bBox.x)) - lineWidth;
var y = __1.UnitConverter.pixelsToTwips(Math.round(bBox.y)) - lineWidth;
var width = __1.UnitConverter.pixelsToTwips(Math.round(bBox.width)) + 2 * lineWidth;
var height = __1.UnitConverter.pixelsToTwips(Math.round(bBox.height)) + 2 * lineWidth;
return Utils_1.Rectangle.create(x, y, width, height);
}
return Utils_1.Rectangle.create(0, 0, 0, 0);
};
RenderUtils.getUrlPathById = function (id) {
if (Browser_1.Browser.Safari)
return "url(" + location.protocol + "//" + location.host + location.pathname + "#" + id + ")";
return "url(#" + id + ")";
};
return RenderUtils;
}());
exports.RenderUtils = RenderUtils;
function raiseEvent(evt, _evt, raiseFunc) {
raiseFunc(_evt);
if (_evt.preventDefault)
evt.preventDefault();
}
exports.raiseEvent = raiseEvent;
/***/ }),
/* 16 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ModifierKey;
(function (ModifierKey) {
ModifierKey[ModifierKey["None"] = 0] = "None";
ModifierKey[ModifierKey["Ctrl"] = 65536] = "Ctrl";
ModifierKey[ModifierKey["Shift"] = 262144] = "Shift";
ModifierKey[ModifierKey["Alt"] = 1048576] = "Alt";
ModifierKey[ModifierKey["Meta"] = 16777216] = "Meta";
})(ModifierKey = exports.ModifierKey || (exports.ModifierKey = {}));
var KeyCode;
(function (KeyCode) {
KeyCode[KeyCode["Backspace"] = 8] = "Backspace";
KeyCode[KeyCode["Tab"] = 9] = "Tab";
KeyCode[KeyCode["Enter"] = 13] = "Enter";
KeyCode[KeyCode["Pause"] = 19] = "Pause";
KeyCode[KeyCode["CapsLock"] = 20] = "CapsLock";
KeyCode[KeyCode["Esc"] = 27] = "Esc";
KeyCode[KeyCode["Space"] = 32] = "Space";
KeyCode[KeyCode["PageUp"] = 33] = "PageUp";
KeyCode[KeyCode["PageDown"] = 34] = "PageDown";
KeyCode[KeyCode["End"] = 35] = "End";
KeyCode[KeyCode["Home"] = 36] = "Home";
KeyCode[KeyCode["Left"] = 37] = "Left";
KeyCode[KeyCode["Up"] = 38] = "Up";
KeyCode[KeyCode["Right"] = 39] = "Right";
KeyCode[KeyCode["Down"] = 40] = "Down";
KeyCode[KeyCode["Insert"] = 45] = "Insert";
KeyCode[KeyCode["Delete"] = 46] = "Delete";
KeyCode[KeyCode["Key_0"] = 48] = "Key_0";
KeyCode[KeyCode["Key_1"] = 49] = "Key_1";
KeyCode[KeyCode["Key_2"] = 50] = "Key_2";
KeyCode[KeyCode["Key_3"] = 51] = "Key_3";
KeyCode[KeyCode["Key_4"] = 52] = "Key_4";
KeyCode[KeyCode["Key_5"] = 53] = "Key_5";
KeyCode[KeyCode["Key_6"] = 54] = "Key_6";
KeyCode[KeyCode["Key_7"] = 55] = "Key_7";
KeyCode[KeyCode["Key_8"] = 56] = "Key_8";
KeyCode[KeyCode["Key_9"] = 57] = "Key_9";
KeyCode[KeyCode["Key_a"] = 65] = "Key_a";
KeyCode[KeyCode["Key_b"] = 66] = "Key_b";
KeyCode[KeyCode["Key_c"] = 67] = "Key_c";
KeyCode[KeyCode["Key_d"] = 68] = "Key_d";
KeyCode[KeyCode["Key_e"] = 69] = "Key_e";
KeyCode[KeyCode["Key_f"] = 70] = "Key_f";
KeyCode[KeyCode["Key_g"] = 71] = "Key_g";
KeyCode[KeyCode["Key_h"] = 72] = "Key_h";
KeyCode[KeyCode["Key_i"] = 73] = "Key_i";
KeyCode[KeyCode["Key_j"] = 74] = "Key_j";
KeyCode[KeyCode["Key_k"] = 75] = "Key_k";
KeyCode[KeyCode["Key_l"] = 76] = "Key_l";
KeyCode[KeyCode["Key_m"] = 77] = "Key_m";
KeyCode[KeyCode["Key_n"] = 78] = "Key_n";
KeyCode[KeyCode["Key_o"] = 79] = "Key_o";
KeyCode[KeyCode["Key_p"] = 80] = "Key_p";
KeyCode[KeyCode["Key_q"] = 81] = "Key_q";
KeyCode[KeyCode["Key_r"] = 82] = "Key_r";
KeyCode[KeyCode["Key_s"] = 83] = "Key_s";
KeyCode[KeyCode["Key_t"] = 84] = "Key_t";
KeyCode[KeyCode["Key_u"] = 85] = "Key_u";
KeyCode[KeyCode["Key_v"] = 86] = "Key_v";
KeyCode[KeyCode["Key_w"] = 87] = "Key_w";
KeyCode[KeyCode["Key_x"] = 88] = "Key_x";
KeyCode[KeyCode["Key_y"] = 89] = "Key_y";
KeyCode[KeyCode["Key_z"] = 90] = "Key_z";
KeyCode[KeyCode["Windows"] = 91] = "Windows";
KeyCode[KeyCode["ContextMenu"] = 93] = "ContextMenu";
KeyCode[KeyCode["Numpad_0"] = 96] = "Numpad_0";
KeyCode[KeyCode["Numpad_1"] = 97] = "Numpad_1";
KeyCode[KeyCode["Numpad_2"] = 98] = "Numpad_2";
KeyCode[KeyCode["Numpad_3"] = 99] = "Numpad_3";
KeyCode[KeyCode["Numpad_4"] = 100] = "Numpad_4";
KeyCode[KeyCode["Numpad_5"] = 101] = "Numpad_5";
KeyCode[KeyCode["Numpad_6"] = 102] = "Numpad_6";
KeyCode[KeyCode["Numpad_7"] = 103] = "Numpad_7";
KeyCode[KeyCode["Numpad_8"] = 104] = "Numpad_8";
KeyCode[KeyCode["Numpad_9"] = 105] = "Numpad_9";
KeyCode[KeyCode["Multiply"] = 106] = "Multiply";
KeyCode[KeyCode["Add"] = 107] = "Add";
KeyCode[KeyCode["Subtract"] = 109] = "Subtract";
KeyCode[KeyCode["Decimal"] = 110] = "Decimal";
KeyCode[KeyCode["Divide"] = 111] = "Divide";
KeyCode[KeyCode["F1"] = 112] = "F1";
KeyCode[KeyCode["F2"] = 113] = "F2";
KeyCode[KeyCode["F3"] = 114] = "F3";
KeyCode[KeyCode["F4"] = 115] = "F4";
KeyCode[KeyCode["F5"] = 116] = "F5";
KeyCode[KeyCode["F6"] = 117] = "F6";
KeyCode[KeyCode["F7"] = 118] = "F7";
KeyCode[KeyCode["F8"] = 119] = "F8";
KeyCode[KeyCode["F9"] = 120] = "F9";
KeyCode[KeyCode["F10"] = 121] = "F10";
KeyCode[KeyCode["F11"] = 122] = "F11";
KeyCode[KeyCode["F12"] = 123] = "F12";
KeyCode[KeyCode["NumLock"] = 144] = "NumLock";
KeyCode[KeyCode["ScrollLock"] = 145] = "ScrollLock";
KeyCode[KeyCode["Semicolon"] = 186] = "Semicolon";
KeyCode[KeyCode["Equals"] = 187] = "Equals";
KeyCode[KeyCode["Comma"] = 188] = "Comma";
KeyCode[KeyCode["Dash"] = 189] = "Dash";
KeyCode[KeyCode["Period"] = 190] = "Period";
KeyCode[KeyCode["ForwardSlash"] = 191] = "ForwardSlash";
KeyCode[KeyCode["GraveAccent"] = 192] = "GraveAccent";
KeyCode[KeyCode["OpenBracket"] = 219] = "OpenBracket";
KeyCode[KeyCode["BackSlash"] = 220] = "BackSlash";
KeyCode[KeyCode["CloseBracket"] = 221] = "CloseBracket";
KeyCode[KeyCode["SingleQuote"] = 222] = "SingleQuote";
})(KeyCode = exports.KeyCode || (exports.KeyCode = {}));
function getKeyModifiers(evt) {
var result = 0;
if (evt.altKey)
result |= ModifierKey.Alt;
if (evt.ctrlKey)
result |= ModifierKey.Ctrl;
if (evt.shiftKey)
result |= ModifierKey.Shift;
if (evt.metaKey)
result |= ModifierKey.Meta;
return result;
}
exports.getKeyModifiers = getKeyModifiers;
/***/ }),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Browser_1 = __webpack_require__(23);
var Data_1 = __webpack_require__(81);
var Str_1 = __webpack_require__(132);
var Attr_1 = __webpack_require__(133);
var KeyCode_1 = __webpack_require__(16);
var Evt_1 = __webpack_require__(39);
function IsExists(obj) {
return (typeof (obj) != "undefined") && (obj != null);
}
exports.IsExists = IsExists;
function IsNumber(str) {
return !isNaN(parseFloat(str)) && isFinite(str);
}
exports.IsNumber = IsNumber;
;
function SetStyles(element, styles, makeImportant) {
if (IsExists(styles.cssText))
element.style.cssText = styles.cssText;
if (IsExists(styles.className))
element.className = styles.className;
for (var property in styles) {
if (!styles.hasOwnProperty(property))
continue;
var value = styles[property];
switch (property) {
case "cssText":
case "className":
break;
case "float":
SetElementFloat(element, value);
break;
case "opacity":
SetElementOpacity(element, value);
break;
case "zIndex":
SetStylesCore(element, property, value, makeImportant);
break;
/*jshint -W086 */
case "fontWeight":
if (Browser_1.Browser.IE && Browser_1.Browser.Version < 9 && typeof (styles[property]) == "number")
value = styles[property].toString();
default:
SetStylesCore(element, property, value + (typeof (value) == "number" ? "px" : ""), makeImportant);
/*jshint +W086 */
}
}
}
exports.SetStyles = SetStyles;
;
function SetStylesCore(element, property, value, makeImportant) {
if (makeImportant) {
var index = property.search("[A-Z]");
if (index != -1)
property = property.replace(property.charAt(index), "-" + property.charAt(index).toLowerCase());
if (element.style.setProperty)
element.style.setProperty(property, value, "important");
else
element.style.cssText += ";" + property + ":" + value + "!important";
}
else
element.style[property] = value;
}
exports.SetStylesCore = SetStylesCore;
function GetDocumentScrollTop() {
var isScrollBodyIE = Browser_1.Browser.IE && GetCurrentStyle(document.body).overflow == "hidden" && document.body.scrollTop > 0;
if (Browser_1.Browser.WebKitFamily || Browser_1.Browser.Edge || isScrollBodyIE) {
if (Browser_1.Browser.MacOSMobilePlatform) //B157267
return window.pageYOffset;
if (Browser_1.Browser.WebKitFamily)
return document.documentElement.scrollTop || document.body.scrollTop;
return document.body.scrollTop;
}
else
return document.documentElement.scrollTop;
}
exports.GetDocumentScrollTop = GetDocumentScrollTop;
function CloneObject(srcObject) {
if (typeof (srcObject) != 'object' || srcObject == null)
return srcObject;
var newObject = {};
/* jshint ignore:start */
for (var i in srcObject)
newObject[i] = srcObject[i];
/* jshint ignore:end */
return newObject;
}
exports.CloneObject = CloneObject;
function GetCurrentStyle(element) {
if (element.currentStyle)
return element.currentStyle;
else if (document.defaultView && document.defaultView.getComputedStyle) {
var result = document.defaultView.getComputedStyle(element, null);
if (!result && Browser_1.Browser.Firefox && window.frameElement) {
var changes = [];
var curElement = window.frameElement;
while (!(result = document.defaultView.getComputedStyle(element, null))) {
changes.push([curElement, curElement.style.display]);
SetStylesCore(curElement, "display", "block", true);
curElement = curElement.tagName == "BODY" ? curElement.ownerDocument.defaultView.frameElement : curElement.parentNode;
}
result = CloneObject(result);
for (var ch, i = 0; ch = changes[i]; i++)
SetStylesCore(ch[0], "display", ch[1], false);
document.body.offsetWidth; //T334387
}
return result;
}
return window.getComputedStyle(element, null);
}
exports.GetCurrentStyle = GetCurrentStyle;
function GetDocumentScrollLeft() {
var isScrollBodyIE = Browser_1.Browser.IE && GetCurrentStyle(document.body).overflow == "hidden" && document.body.scrollLeft > 0;
if (Browser_1.Browser.Edge || isScrollBodyIE)
return document.body ? document.body.scrollLeft : document.documentElement.scrollLeft;
if (Browser_1.Browser.WebKitFamily)
return document.documentElement.scrollLeft || document.body.scrollLeft;
return document.documentElement.scrollLeft;
}
exports.GetDocumentScrollLeft = GetDocumentScrollLeft;
exports.focusedElement = null;
function GetFocusedElement() {
var activeElement = GetActiveElement();
return activeElement ? activeElement : exports.focusedElement;
}
exports.GetFocusedElement = GetFocusedElement;
function GetActiveElement() {
try {
return document.activeElement;
}
catch (e) {
return null;
}
}
exports.GetActiveElement = GetActiveElement;
;
function focusCore(element, selectAction) {
try {
element.focus();
if (Browser_1.Browser.IE && document.activeElement != element)
element.focus();
// Q339238
if (selectAction) {
var currentSelection = Selection.GetInfo(element);
// apply selection only if there is no selection present already
if (currentSelection.startPos == currentSelection.endPos) {
switch (selectAction) {
case "start":
Selection.SetCaretPosition(element, 0);
break;
case "all":
Selection.Set(element);
break;
}
}
}
}
catch (e) {
}
}
function SetFocus(element, selectAction) {
if (Browser_1.Browser.MacOSMobilePlatform) // Q471191
focusCore(element, selectAction);
else {
window.setTimeout(function () {
focusCore(element, selectAction);
}, 100);
}
}
exports.SetFocus = SetFocus;
function GetIsParent(parentElement, element) {
if (!parentElement || !element)
return false;
while (element) {
if (element === parentElement)
return true;
if (element.tagName === "BODY")
return false;
element = element.parentNode;
}
return false;
}
exports.GetIsParent = GetIsParent;
function ElementContainsCssClass(element, className) {
//B187659
try {
if (!element.className)
return false;
return element.className.indexOf(className) != -1;
}
catch (e) {
return false;
}
}
exports.ElementContainsCssClass = ElementContainsCssClass;
function AddClassNameToElement(element, className) {
if (!element || typeof (className) !== "string")
return;
className = className.trim();
if (!ElementHasCssClass(element, className) && className !== "")
element.className = (element.className === "") ? className : element.className + " " + className;
}
exports.AddClassNameToElement = AddClassNameToElement;
function ElementHasCssClass(element, className) {
//B220674
try {
var elementClasses;
var classList = element.classList;
if (!classList) {
if (!element.className)
return false;
elementClasses = element.className.split(" ");
}
var classNames = className.split(" ");
for (var i = classNames.length - 1; i >= 0; i--) {
if (classList) {
if (!classList.contains(classNames[i]))
return false;
continue;
}
if (Data_1.Data.ArrayIndexOf(elementClasses, classNames[i]) < 0)
return false;
}
return true;
}
catch (e) {
return false;
}
}
exports.ElementHasCssClass = ElementHasCssClass;
function RemoveClassNameFromElement(element, className) {
if (!element)
return;
var updClassName = " " + element.className + " ";
var newClassName = updClassName.replace(" " + className + " ", " ");
if (updClassName.length != newClassName.length)
element.className = Str_1.Str.Trim(newClassName);
}
exports.RemoveClassNameFromElement = RemoveClassNameFromElement;
function ToggleElementClassName(element, className, toggle) {
if (!element)
return;
if (toggle === false || (toggle === undefined && ElementHasCssClass(element, className)))
RemoveClassNameFromElement(element, className);
else if (toggle === true || (toggle === undefined && !ElementHasCssClass(element, className)))
AddClassNameToElement(element, className);
}
exports.ToggleElementClassName = ToggleElementClassName;
function GetAbsolutePositionY(element) {
if (Browser_1.Browser.IE)
return getAbsolutePositionY_IE(element);
else if (Browser_1.Browser.Firefox && Browser_1.Browser.Version >= 3)
return getAbsolutePositionY_FF3(element);
else if (Browser_1.Browser.Opera)
return getAbsolutePositionY_Opera(element);
else if (Browser_1.Browser.NetscapeFamily && (!Browser_1.Browser.Firefox || Browser_1.Browser.Version < 3))
return getAbsolutePositionY_NS(element);
else if (Browser_1.Browser.WebKitFamily || Browser_1.Browser.Edge)
return getAbsolutePositionY_FF3(element);
else
return getAbsolutePositionY_Other(element);
}
exports.GetAbsolutePositionY = GetAbsolutePositionY;
function getAbsolutePositionY_Opera(curEl) {
var isFirstCycle = true;
if (curEl && curEl.tagName == "TR" && curEl.cells.length > 0)
curEl = curEl.cells[0];
var pos = getAbsoluteScrollOffset_OperaFF(curEl, false);
while (curEl != null) {
pos += curEl.offsetTop;
if (!isFirstCycle)
pos -= curEl.scrollTop;
curEl = curEl.offsetParent;
isFirstCycle = false;
}
pos += document.body.scrollTop;
return pos;
}
function getAbsolutePositionY_IE(element) {
if (element == null || Browser_1.Browser.IE && element.parentNode == null)
return 0; // B96664
return element.getBoundingClientRect().top + GetDocumentScrollTop();
}
function getAbsolutePositionY_FF3(element) {
if (element == null)
return 0;
var y = element.getBoundingClientRect().top + GetDocumentScrollTop();
return Math.round(y);
}
function getAbsolutePositionY_NS(curEl) {
var pos = getAbsoluteScrollOffset_OperaFF(curEl, false);
var isFirstCycle = true;
while (curEl != null) {
pos += curEl.offsetTop;
if (!isFirstCycle && curEl.offsetParent != null)
pos -= curEl.scrollTop;
if (!isFirstCycle && Browser_1.Browser.Firefox) {
var style = GetCurrentStyle(curEl);
if (curEl.tagName == "DIV" && style.overflow != "visible")
pos += PxToInt(style.borderTopWidth);
}
isFirstCycle = false;
curEl = curEl.offsetParent;
}
return pos;
}
function getAbsolutePositionY_Other(curEl) {
var pos = 0;
var isFirstCycle = true;
while (curEl != null) {
pos += curEl.offsetTop;
if (!isFirstCycle && curEl.offsetParent != null)
pos -= curEl.scrollTop;
isFirstCycle = false;
curEl = curEl.offsetParent;
}
return pos;
}
function getAbsoluteScrollOffset_OperaFF(curEl, isX) {
var pos = 0;
var isFirstCycle = true;
while (curEl != null) {
if (curEl.tagName == "BODY")
break;
var style = GetCurrentStyle(curEl);
if (style.position == "absolute")
break;
if (!isFirstCycle && curEl.tagName == "DIV" && (style.position == "" || style.position == "static"))
pos -= isX ? curEl.scrollLeft : curEl.scrollTop;
curEl = curEl.parentNode;
isFirstCycle = false;
}
return pos;
}
function PxToInt(px) {
return pxToNumber(px, parseInt);
}
exports.PxToInt = PxToInt;
;
function PxToFloat(px) {
return pxToNumber(px, parseFloat);
}
exports.PxToFloat = PxToFloat;
;
function pxToNumber(px, parseFunction) {
var result = 0;
if (px != null && px != "") {
try {
var indexOfPx = px.indexOf("px");
if (indexOfPx > -1)
result = parseFunction(px.substr(0, indexOfPx));
}
catch (e) { }
}
return result;
}
//function GetAbsolutePositionX(element: HTMLElement): number;
function GetAbsolutePositionX(element) {
if (Browser_1.Browser.IE)
return getAbsolutePositionX_IE(element);
else if (Browser_1.Browser.Firefox && Browser_1.Browser.Version >= 3)
return getAbsolutePositionX_FF3(element);
else if (Browser_1.Browser.Opera)
return getAbsolutePositionX_Opera(element);
else if (Browser_1.Browser.NetscapeFamily && (!Browser_1.Browser.Firefox || Browser_1.Browser.Version < 3))
return getAbsolutePositionX_NS(element);
else if (Browser_1.Browser.WebKitFamily || Browser_1.Browser.Edge)
return getAbsolutePositionX_FF3(element);
else
return getAbsolutePositionX_Other(element);
}
exports.GetAbsolutePositionX = GetAbsolutePositionX;
function getAbsolutePositionX_Opera(curEl) {
var isFirstCycle = true;
var pos = getAbsoluteScrollOffset_OperaFF(curEl, true);
while (curEl != null) {
pos += curEl.offsetLeft;
if (!isFirstCycle)
pos -= curEl.scrollLeft;
curEl = curEl.offsetParent;
isFirstCycle = false;
}
pos += document.body.scrollLeft;
return pos;
}
function getAbsolutePositionX_IE(element) {
if (element == null || Browser_1.Browser.IE && element.parentNode == null)
return 0; // B96664
return element.getBoundingClientRect().left + GetDocumentScrollLeft();
}
function getAbsolutePositionX_FF3(element) {
if (element == null)
return 0;
var x = element.getBoundingClientRect().left + GetDocumentScrollLeft();
return Math.round(x);
}
function getAbsolutePositionX_NS(curEl) {
var pos = getAbsoluteScrollOffset_OperaFF(curEl, true);
var isFirstCycle = true;
while (curEl != null) {
pos += curEl.offsetLeft;
if (!isFirstCycle && curEl.offsetParent != null)
pos -= curEl.scrollLeft;
if (!isFirstCycle && Browser_1.Browser.Firefox) {
var style = GetCurrentStyle(curEl);
if (curEl.tagName == "DIV" && style.overflow != "visible")
pos += PxToInt(style.borderLeftWidth);
}
isFirstCycle = false;
curEl = curEl.offsetParent;
}
return pos;
}
function getAbsolutePositionX_Other(curEl) {
var pos = 0;
var isFirstCycle = true;
while (curEl != null) {
pos += curEl.offsetLeft;
if (!isFirstCycle && curEl.offsetParent != null)
pos -= curEl.scrollLeft;
isFirstCycle = false;
curEl = curEl.offsetParent;
}
return pos;
}
function SetAbsoluteX(element, x) {
element.style.left = prepareClientPosForElement(x, element, true) + "px";
}
exports.SetAbsoluteX = SetAbsoluteX;
;
function SetAbsoluteY(element, y) {
element.style.top = prepareClientPosForElement(y, element, false) + "px";
}
exports.SetAbsoluteY = SetAbsoluteY;
;
function prepareClientPosForElement(pos, element, isX) {
pos -= getPositionElementOffset(element, isX);
return pos;
}
;
function getPositionElementOffset(element, isX) {
var div = createElementMock(element);
if (div.style.position == "static")
div.style.position = "absolute";
element.parentNode.appendChild(div);
var realPos = isX ? GetAbsolutePositionX(div) : GetAbsolutePositionY(div);
element.parentNode.removeChild(div);
return Math.round(realPos);
}
;
function createElementMock(element) {
var div = document.createElement('DIV');
div.style.top = "0px";
div.style.left = "0px";
div.style.visibility = "hidden";
div.style.position = GetCurrentStyle(element).position;
return div;
}
function IsPercentageSize(size) {
return size && size.indexOf('%') != -1;
}
exports.IsPercentageSize = IsPercentageSize;
;
function GetChildNodes(parent, predicate) {
return RetrieveByPredicate(parent.childNodes, predicate);
}
exports.GetChildNodes = GetChildNodes;
;
function GetNodes(parent, predicate) {
var c = parent.all || parent.getElementsByTagName('*');
return RetrieveByPredicate(c, predicate);
}
exports.GetNodes = GetNodes;
;
function RetrieveByPredicate(scourceCollection, predicate) {
var result = [];
for (var i = 0; i < scourceCollection.length; i++) {
var element = scourceCollection[i];
if (!predicate || predicate(element))
result.push(element);
}
return result;
}
exports.RetrieveByPredicate = RetrieveByPredicate;
;
function GetChildNodesByClassName(parent, className) {
if (!parent)
return [];
if (parent.querySelectorAll) {
var children = parent.querySelectorAll('.' + className);
return nodeListToArray(children, function (element) {
return element.parentNode === parent;
});
}
return GetChildNodes(parent, function (elem) { return elem.className && ElementHasCssClass(elem, className); });
}
exports.GetChildNodesByClassName = GetChildNodesByClassName;
function nodeListToArray(nodeList, filter) {
var result = [];
for (var i = 0, element; element = nodeList[i]; i++) {
if (filter && !filter(element))
continue;
result.push(element);
}
return result;
}
function GetNodesByClassName(parent, className) {
if (parent.querySelectorAll) {
var children = parent.querySelectorAll('.' + className);
return nodeListToArray(children, null);
}
return GetNodes(parent, function (elem) { return elem.className && ElementHasCssClass(elem, className); });
}
exports.GetNodesByClassName = GetNodesByClassName;
function GetParentByClassName(element, className) {
while (element != null) {
if (element.tagName == "BODY" || element.nodeName == "#document")
return null;
if (ElementContainsCssClass(element, className))
return element;
element = element.parentNode;
}
return null;
}
exports.GetParentByClassName = GetParentByClassName;
function GetParentByTagName(element, tagName) {
tagName = tagName.toUpperCase();
while (element) {
if (element.tagName === "BODY")
return null;
if (element.tagName === tagName)
return element;
element = element.parentNode;
}
return null;
}
exports.GetParentByTagName = GetParentByTagName;
var html2PlainTextFilter = null;
function setInnerHtmlInternal(el, trustedHtmlString) {
el.innerHTML = trustedHtmlString;
}
exports.setInnerHtmlInternal = setInnerHtmlInternal;
function SetElementDisplay(element, value, checkCurrentStyle, makeInline) {
if (!element)
return;
if (typeof (value) === "string")
element.style.display = value;
else if (!value)
element.style.display = "none";
else {
element.style.display = "";
if (checkCurrentStyle && GetCurrentStyle(element).display === "none") {
var displayAddon = makeInline ? "inline-" : "";
switch (element.tagName) {
case "TABLE": {
element.style.display = displayAddon + "table";
break;
}
default: {
element.style.display = displayAddon + "block";
break;
}
}
}
}
}
exports.SetElementDisplay = SetElementDisplay;
function GetInnerText(container) {
if (Browser_1.Browser.Safari && Browser_1.Browser.MajorVersion <= 5) {
var filter = getHtml2PlainTextFilter();
setInnerHtmlInternal(filter, container.innerHTML);
SetElementDisplay(filter, true, false, false);
var innerText = filter.innerText;
SetElementDisplay(filter, false, false, false);
return innerText;
}
else if (Browser_1.Browser.NetscapeFamily || Browser_1.Browser.WebKitFamily || (Browser_1.Browser.IE && Browser_1.Browser.Version >= 9) || Browser_1.Browser.Edge) {
return container.textContent;
}
else
return container.innerText;
}
exports.GetInnerText = GetInnerText;
function getHtml2PlainTextFilter() {
if (html2PlainTextFilter == null) {
html2PlainTextFilter = document.createElement("DIV");
html2PlainTextFilter.style.width = "0";
html2PlainTextFilter.style.height = "0";
html2PlainTextFilter.style.overflow = "visible";
SetElementDisplay(html2PlainTextFilter, false, false, false);
document.body.appendChild(html2PlainTextFilter);
}
return html2PlainTextFilter;
}
var verticalScrollBarWidth;
function GetVerticalScrollBarWidth() {
if (typeof (verticalScrollBarWidth) == "undefined") {
var container = document.createElement("DIV");
container.style.cssText = "position: absolute; top: 0px; left: 0px; visibility: hidden; width: 200px; height: 150px; overflow: hidden; box-sizing: content-box";
document.body.appendChild(container);
var child = document.createElement("P");
container.appendChild(child);
child.style.cssText = "width: 100%; height: 200px;";
var widthWithoutScrollBar = child.offsetWidth;
container.style.overflow = "scroll";
var widthWithScrollBar = child.offsetWidth;
if (widthWithoutScrollBar == widthWithScrollBar)
widthWithScrollBar = container.clientWidth;
verticalScrollBarWidth = widthWithoutScrollBar - widthWithScrollBar;
document.body.removeChild(container);
}
return verticalScrollBarWidth;
}
exports.GetVerticalScrollBarWidth = GetVerticalScrollBarWidth;
function GetHorizontalBordersWidth(element, style) {
if (!IsExists(style))
style = (Browser_1.Browser.IE && window.getComputedStyle) ? window.getComputedStyle(element) : GetCurrentStyle(element);
var res = 0;
if (style.borderLeftStyle != "none")
res += PxToFloat(style.borderLeftWidth);
if (style.borderRightStyle != "none")
res += PxToFloat(style.borderRightWidth);
return res;
}
exports.GetHorizontalBordersWidth = GetHorizontalBordersWidth;
function GetVerticalBordersWidth(element, style) {
if (!IsExists(style))
style = (Browser_1.Browser.IE && Browser_1.Browser.MajorVersion != 9 && window.getComputedStyle) ? window.getComputedStyle(element) : GetCurrentStyle(element);
var res = 0;
if (style.borderTopStyle != "none")
res += PxToFloat(style.borderTopWidth);
if (style.borderBottomStyle != "none")
res += PxToFloat(style.borderBottomWidth);
return res;
}
exports.GetVerticalBordersWidth = GetVerticalBordersWidth;
function SetElementVisibility(element, value) {
if (!element)
return;
if (typeof (value) === "string")
element.style.visibility = value;
else
element.style.visibility = value ? "visible" : "hidden";
}
exports.SetElementVisibility = SetElementVisibility;
;
function SetElementFloat(element, value) {
if (IsExists(element.style.cssFloat))
element.style.cssFloat = value;
else if (IsExists(element.style.styleFloat))
element.style.styleFloat = value;
else
Attr_1.Attr.SetAttribute(element.style, "float", value);
}
exports.SetElementFloat = SetElementFloat;
;
function SetElementOpacity(element, value) {
var useOpacityStyle = !Browser_1.Browser.IE || Browser_1.Browser.Version > 8;
if (useOpacityStyle) {
element.style.opacity = value;
}
else {
if (typeof (element.filters) === "object" && element.filters["DXImageTransform.Microsoft.Alpha"])
element.filters.item("DXImageTransform.Microsoft.Alpha").Opacity = value * 100;
else
element.style.filter = "alpha(opacity=" + (value * 100) + ")";
}
}
exports.SetElementOpacity = SetElementOpacity;
function CreateGuid() {
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
var r = Math.random() * 16 | 0; // trunc fractional part
var v = c == 'x' ? r : r & 0x3 | 0x8;
return v.toString(16);
});
}
exports.CreateGuid = CreateGuid;
function IsUrlContainsClientScript(url) {
return url.toLowerCase().indexOf("javascript:") !== -1;
}
exports.IsUrlContainsClientScript = IsUrlContainsClientScript;
function IsExistsElement(element) {
return element && IsValidElement(element);
}
exports.IsExistsElement = IsExistsElement;
function IsValidElement(element) {
if (!element)
return false;
if (!(Browser_1.Browser.Firefox && Browser_1.Browser.Version < 4)) {
if (element.ownerDocument && element.ownerDocument.body && element.ownerDocument.body.compareDocumentPosition)
return element.ownerDocument.body.compareDocumentPosition(element) % 2 === 0;
}
if (!Browser_1.Browser.Opera && !(Browser_1.Browser.IE && Browser_1.Browser.Version < 9) && element.offsetParent && element.parentNode.tagName)
return true;
while (element != null) {
if (element.tagName == "BODY")
return true;
element = element.parentNode;
}
return false;
}
exports.IsValidElement = IsValidElement;
function IsInteractiveControl(element) {
return Data_1.Data.ArrayIndexOf(["A", "INPUT", "SELECT", "OPTION", "TEXTAREA", "BUTTON", "IFRAME"], element.tagName) > -1;
}
exports.IsInteractiveControl = IsInteractiveControl;
function IsActionElement(element) {
if (!IsExistsElement(element))
return false;
var tabIndex = parseInt(Attr_1.Attr.GetAttribute(element, Attr_1.Attr.GetTabIndexAttributeName()));
var hasTabIndex = !isNaN(tabIndex);
var hasNonNegativeTabIndex = hasTabIndex && tabIndex > -1;
var hasNegativeTabIndex = hasTabIndex && tabIndex < 0;
var tagName = element.tagName;
var focusableElementTags = ["BUTTON", "SELECT", "TEXTAREA", "OPTION", "IFRAME"];
var isFocusableCore = IsFocusable(element);
var isFocusableTag = focusableElementTags.indexOf(tagName) !== -1;
var isFocusableLink = tagName === "A" && (!!element.href || hasNonNegativeTabIndex);
var isFocusableInput = tagName === "INPUT" && element.type.toLowerCase() !== "hidden";
var isFocusableByTabIndex = tagName !== "INPUT" && hasNonNegativeTabIndex;
var isEditableDiv = tagName == "DIV" && element.contentEditable === "true";
return isFocusableCore && !hasNegativeTabIndex && (isFocusableTag || isFocusableLink || isFocusableInput || isFocusableByTabIndex || isEditableDiv);
}
exports.IsActionElement = IsActionElement;
function IsFocusable(element, skipContainerVisibilityCheck) {
if (skipContainerVisibilityCheck === void 0) { skipContainerVisibilityCheck = function () { return false; }; }
var current = element;
while (current && current.nodeType == 1) {
if (current == element || !skipContainerVisibilityCheck(current)) {
var tagName = current.tagName.toUpperCase();
if (tagName == "BODY")
return true;
var disabledElementTags = ["INPUT", "BUTTON", "TEXTAREA", "SELECT", "OPTION"];
if (disabledElementTags.indexOf(tagName) !== -1 && current.disabled || !GetElementDisplay(current, false) || !GetElementVisibility(current, false))
return false;
}
current = current.parentNode;
}
return true;
}
exports.IsFocusable = IsFocusable;
function GetElementDisplay(element, isCurrentStyle) {
if (isCurrentStyle)
return GetCurrentStyle(element).display != "none";
return element.style.display != "none";
}
exports.GetElementDisplay = GetElementDisplay;
function GetElementVisibility(element, isCurrentStyle) {
if (isCurrentStyle)
return GetCurrentStyle(element).visibility != "hidden";
return element.style.visibility != "hidden";
}
exports.GetElementVisibility = GetElementVisibility;
function GetClearClientHeight(element) {
return element.offsetHeight - GetTopBottomBordersAndPaddingsSummaryValue(element);
}
exports.GetClearClientHeight = GetClearClientHeight;
function GetTopBottomBordersAndPaddingsSummaryValue(element, currentStyle) {
return GetTopBottomPaddings(element, currentStyle) + GetVerticalBordersWidth(element, currentStyle);
}
exports.GetTopBottomBordersAndPaddingsSummaryValue = GetTopBottomBordersAndPaddingsSummaryValue;
;
function GetTopBottomPaddings(element, style) {
var currentStyle = style ? style : GetCurrentStyle(element);
return PxToInt(currentStyle.paddingTop) + PxToInt(currentStyle.paddingBottom);
}
exports.GetTopBottomPaddings = GetTopBottomPaddings;
;
function ParseShortcutString(shortcutString) {
if (!shortcutString)
return 0;
var isCtrlKey = false;
var isShiftKey = false;
var isAltKey = false;
var isMetaKey = false;
var keyCode = null;
var shcKeys = shortcutString.toString().split("+");
if (shcKeys.length > 0) {
for (var i = 0; i < shcKeys.length; i++) {
var key = Str_1.Str.Trim(shcKeys[i].toUpperCase());
switch (key) {
case "CONTROL":
case "CONTROLKEY":
case "CTRL":
isCtrlKey = true;
break;
case "SHIFT":
case "SHIFTKEY":
isShiftKey = true;
break;
case "ALT":
isAltKey = true;
break;
case "CMD":
isMetaKey = true;
break;
case "F1":
keyCode = KeyCode_1.KeyCode.F1;
break;
case "F2":
keyCode = KeyCode_1.KeyCode.F2;
break;
case "F3":
keyCode = KeyCode_1.KeyCode.F3;
break;
case "F4":
keyCode = KeyCode_1.KeyCode.F4;
break;
case "F5":
keyCode = KeyCode_1.KeyCode.F5;
break;
case "F6":
keyCode = KeyCode_1.KeyCode.F6;
break;
case "F7":
keyCode = KeyCode_1.KeyCode.F7;
break;
case "F8":
keyCode = KeyCode_1.KeyCode.F8;
break;
case "F9":
keyCode = KeyCode_1.KeyCode.F9;
break;
case "F10":
keyCode = KeyCode_1.KeyCode.F10;
break;
case "F11":
keyCode = KeyCode_1.KeyCode.F11;
break;
case "F12":
keyCode = KeyCode_1.KeyCode.F12;
break;
case "RETURN":
case "ENTER":
keyCode = KeyCode_1.KeyCode.Enter;
break;
case "HOME":
keyCode = KeyCode_1.KeyCode.Home;
break;
case "END":
keyCode = KeyCode_1.KeyCode.End;
break;
case "LEFT":
keyCode = KeyCode_1.KeyCode.Left;
break;
case "RIGHT":
keyCode = KeyCode_1.KeyCode.Right;
break;
case "UP":
keyCode = KeyCode_1.KeyCode.Up;
break;
case "DOWN":
keyCode = KeyCode_1.KeyCode.Down;
break;
case "PAGEUP":
keyCode = KeyCode_1.KeyCode.PageUp;
break;
case "PAGEDOWN":
keyCode = KeyCode_1.KeyCode.PageDown;
break;
case "SPACE":
keyCode = KeyCode_1.KeyCode.Space;
break;
case "TAB":
keyCode = KeyCode_1.KeyCode.Tab;
break;
case "BACKSPACE":
case "BACK":
keyCode = KeyCode_1.KeyCode.Backspace;
break;
case "CONTEXT":
keyCode = KeyCode_1.KeyCode.ContextMenu;
break;
case "ESCAPE":
case "ESC":
keyCode = KeyCode_1.KeyCode.Esc;
break;
case "DELETE":
case "DEL":
keyCode = KeyCode_1.KeyCode.Delete;
break;
case "INSERT":
case "INS":
keyCode = KeyCode_1.KeyCode.Insert;
break;
case "PLUS":
keyCode = "+".charCodeAt(0);
break;
default:
keyCode = key.charCodeAt(0);
break;
}
}
}
else
ShowErrorAlert("Invalid shortcut");
return GetShortcutCode(keyCode, isCtrlKey, isShiftKey, isAltKey, isMetaKey);
}
exports.ParseShortcutString = ParseShortcutString;
function ShowErrorAlert(message) {
message = Str_1.Str.DecodeHtmlViaTextArea(message);
if (IsExists(message) && message !== "")
alert(message);
}
exports.ShowErrorAlert = ShowErrorAlert;
;
function GetShortcutCode(keyCode, isCtrlKey, isShiftKey, isAltKey, isMetaKey) {
var value = keyCode;
value |= isCtrlKey ? KeyCode_1.ModifierKey.Ctrl : 0;
value |= isShiftKey ? KeyCode_1.ModifierKey.Shift : 0;
value |= isAltKey ? KeyCode_1.ModifierKey.Alt : 0;
value |= isMetaKey ? KeyCode_1.ModifierKey.Meta : 0;
return value;
}
exports.GetShortcutCode = GetShortcutCode;
;
function GetShortcutCodeByEvent(evt) {
return GetShortcutCode(Evt_1.Evt.GetKeyCode(evt), evt.ctrlKey, evt.shiftKey, evt.altKey, Browser_1.Browser.MacOSPlatform ? evt.metaKey : false);
}
exports.GetShortcutCodeByEvent = GetShortcutCodeByEvent;
;
/***/ }),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var UnitConverter_1 = __webpack_require__(13);
var Utils_1 = __webpack_require__(15);
var SvgPrimitive = /** @class */ (function () {
function SvgPrimitive(style, className, clipPathId, onApplyProperties) {
this.style = style;
this.className = className;
this.clipPathId = clipPathId;
this.onApplyProperties = onApplyProperties;
this.children = [];
}
SvgPrimitive.prototype.createElement = function () {
var el = this.createMainElement();
this.createChildElements(el);
return el;
};
SvgPrimitive.prototype.createChildElements = function (parent) {
for (var i = 0; i < this.children.length; i++)
parent.appendChild(this.children[i].createElement());
};
SvgPrimitive.prototype.applyElementProperties = function (element) {
this.applyElementStyleProperties(element);
if (this.className)
element.setAttribute("class", this.className);
if (typeof this.clipPathId === "string") {
if (this.clipPathId)
element.setAttribute("clip-path", Utils_1.RenderUtils.getUrlPathById(this.clipPathId));
else
element.removeAttribute("clip-path");
}
if (this.onApplyProperties)
this.onApplyProperties(element);
this.applyChildrenProperties(element);
};
SvgPrimitive.prototype.applyChildrenProperties = function (element) {
for (var i = 0; i < this.children.length; i++)
this.children[i].applyElementProperties(element.childNodes[i]);
};
SvgPrimitive.prototype.applyElementStyleProperties = function (element) {
this.applyElementStylePropertiesCore(element);
};
SvgPrimitive.prototype.applyElementStylePropertiesCore = function (element, reverseTextAnchor) {
if (reverseTextAnchor === void 0) { reverseTextAnchor = false; }
if (this.style)
Utils_1.RenderUtils.applyStyleToElement(this.style, element, reverseTextAnchor);
};
SvgPrimitive.prototype.setUnitAttribute = function (element, key, value) {
if (value === undefined || value === null)
return;
var valueStr = typeof value === "number" ? UnitConverter_1.UnitConverter.twipsToPixels(value).toString() : value;
element.setAttribute(key, valueStr);
};
SvgPrimitive.prototype.dispose = function () {
if (this.children)
this.children.forEach(function (primitive) { return primitive.dispose(); });
};
return SvgPrimitive;
}());
exports.SvgPrimitive = SvgPrimitive;
/***/ }),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Shape_1 = __webpack_require__(11);
var Connector_1 = __webpack_require__(5);
var Utils_1 = __webpack_require__(0);
var ModelUtils_1 = __webpack_require__(6);
var ImageCache_1 = __webpack_require__(49);
var Color_1 = __webpack_require__(38);
var DiagramUnit;
(function (DiagramUnit) {
DiagramUnit[DiagramUnit["In"] = 0] = "In";
DiagramUnit[DiagramUnit["Cm"] = 1] = "Cm";
DiagramUnit[DiagramUnit["Px"] = 2] = "Px";
})(DiagramUnit = exports.DiagramUnit || (exports.DiagramUnit = {}));
var PageOrientation;
(function (PageOrientation) {
PageOrientation[PageOrientation["Portrait"] = 0] = "Portrait";
PageOrientation[PageOrientation["Landscape"] = 1] = "Landscape";
})(PageOrientation = exports.PageOrientation || (exports.PageOrientation = {}));
var DiagramModel = /** @class */ (function () {
function DiagramModel(pageSize) {
if (pageSize === void 0) { pageSize = new Utils_1.Size(8391, 11906); }
this.items = [];
this.itemIndexByKey = {};
this.pageSize = new Utils_1.Size(8391, 11906);
this.pageLandscape = false;
this.pageColor = DiagramModel.defaultPageColor;
this.units = DiagramUnit.In;
this.snapStartPoint = new Utils_1.Point(0, 0);
this.pageSize = pageSize;
this.size = this.pageSize.clone();
this.rectangle = new Utils_1.Rectangle(new Utils_1.Point(0, 0), new Utils_1.Size(0, 0));
}
Object.defineProperty(DiagramModel.prototype, "pageWidth", {
get: function () {
return this.pageLandscape ? this.pageSize.height : this.pageSize.width;
},
enumerable: true,
configurable: true
});
Object.defineProperty(DiagramModel.prototype, "pageHeight", {
get: function () {
return this.pageLandscape ? this.pageSize.width : this.pageSize.height;
},
enumerable: true,
configurable: true
});
DiagramModel.prototype.getRectangle = function (forceUpdate) {
if (forceUpdate)
this.rectangle = Utils_1.GeometryUtils.getCommonRectangle(this.items.map(function (i) { return i.rectangle; }));
return this.rectangle;
};
DiagramModel.getRectangle = function (items) {
return Utils_1.GeometryUtils.getCommonRectangle(items.map(function (i) { return i.rectangle; }));
};
DiagramModel.prototype.pushItem = function (item) {
var index = this.items.push(item);
this.itemIndexByKey[item.key] = index - 1;
if (item instanceof Shape_1.Shape && !item.image.isEmpty)
this.cacheShapeImage(item);
};
DiagramModel.prototype.removeItem = function (item) {
var index = this.getItemIndex(item);
delete this.itemIndexByKey[item.key];
this.items.splice(index, 1);
this.updateIndicesHash(index);
};
DiagramModel.prototype.updateIndicesHash = function (startIndex) {
for (var i = startIndex; i < this.items.length; i++)
this.itemIndexByKey[this.items[i].key] = i;
};
DiagramModel.prototype.getItemIndex = function (item) {
return this.itemIndexByKey[item.key];
};
DiagramModel.prototype.findShape = function (key) {
var shape = this.findItem(key);
return shape instanceof Shape_1.Shape ? shape : undefined;
};
DiagramModel.prototype.findShapesCore = function (callback) {
var shapes;
shapes = [];
this.items.forEach(function (item) {
if (item instanceof Shape_1.Shape) {
if (callback(item)) {
shapes.push(item);
return;
}
}
});
return shapes;
};
DiagramModel.prototype.findShapeCore = function (callback) {
var shape;
this.items.forEach(function (item) {
if (item instanceof Shape_1.Shape) {
if (callback(item)) {
shape = item;
return;
}
}
});
return shape;
};
DiagramModel.prototype.findShapeAtPosition = function (position) {
return this.findShapeCore(function (shape) { return shape.position.equals(position); });
};
DiagramModel.prototype.findShapeByDataKey = function (key) {
return this.findShapeCore(function (shape) { return shape.dataKey === key; });
};
DiagramModel.prototype.findShapesByImageUrl = function (imageUrl) {
return this.findShapesCore(function (shape) { return shape.image.url === imageUrl; });
};
DiagramModel.prototype.cacheShapeImage = function (shape) {
var cacheImageInfo = ImageCache_1.ImageCache.instance.createUnloadedInfoByShapeImageInfo(shape.image);
if (cacheImageInfo.isLoaded)
shape.image.loadBase64Content(cacheImageInfo.base64);
};
DiagramModel.prototype.loadAllImages = function (imageLoader) {
ImageCache_1.ImageCache.instance.loadAllImages(imageLoader);
};
DiagramModel.prototype.findContainer = function (key) {
var shape = this.findShape(key);
return shape && shape.enableChildren ? shape : undefined;
};
DiagramModel.prototype.getChildren = function (container) {
var _this = this;
return container.childKeys.map(function (key) { return _this.findItem(key); }).filter(function (item) { return item; });
};
DiagramModel.prototype.findChild = function (container, key, recursive) {
var _this = this;
if (recursive === void 0) { recursive = true; }
var result;
container.childKeys.forEach(function (childKey) {
if (result)
return;
var child = _this.findItem(childKey);
if (childKey === key) {
result = child;
return;
}
if (recursive && child instanceof Shape_1.Shape) {
result = _this.findChild(child, key, recursive);
if (result)
return;
}
});
return result;
};
DiagramModel.prototype.findItemContainerCore = function (item, callback) {
var container = item.container;
while (container) {
if (!callback || callback(container))
break;
container = container.container;
}
return container;
};
DiagramModel.prototype.findItemContainer = function (item) {
return this.findItemContainerCore(item);
};
DiagramModel.prototype.findItemCollapsedContainer = function (item) {
return this.findItemContainerCore(item, function (c) { return !c.expanded; });
};
DiagramModel.prototype.findItemTopCollapsedContainer = function (item) {
var container = item.container;
var collapsedContainer;
while (container) {
if (!container.expanded)
collapsedContainer = container;
container = container.container;
}
return collapsedContainer;
};
DiagramModel.prototype.isContainerItem = function (container, item) {
return this.findItemContainerCore(item, function (c) { return c.key === container.key; }) !== undefined;
};
DiagramModel.prototype.findConnector = function (key) {
var connector = this.findItem(key);
return connector instanceof Connector_1.Connector ? connector : undefined;
};
DiagramModel.prototype.findConnectorCore = function (callback) {
var connector;
this.items.forEach(function (item) {
if (item instanceof Connector_1.Connector) {
if (callback(item)) {
connector = item;
return;
}
}
});
return connector;
};
DiagramModel.prototype.findConnectorAtPoints = function (points) {
return this.findConnectorCore(function (connector) { return Utils_1.GeometryUtils.arePointsEqual(connector.points, points); });
};
DiagramModel.prototype.findConnectorByDataKey = function (key) {
return this.findConnectorCore(function (connector) { return connector.dataKey === key; });
};
DiagramModel.prototype.findConnectorsCore = function (callback) {
var result = [];
this.items.forEach(function (item) {
if (item instanceof Connector_1.Connector) {
if (callback(item)) {
result.push(item);
return;
}
}
});
return result;
};
DiagramModel.prototype.findConnectorsWithoutBeginItem = function () {
return this.findConnectorsCore(function (connector) { return !connector.beginItem; });
};
DiagramModel.prototype.findConnectorsWithoutEndItem = function () {
return this.findConnectorsCore(function (connector) { return !connector.endItem; });
};
DiagramModel.prototype.findItem = function (key) {
return this.items[this.itemIndexByKey[key]];
};
DiagramModel.isIntersectedItems = function (item1, item2) {
var result = false;
if (item1 instanceof Shape_1.Shape)
result = item2.intersectedByRect(item1.rectangle);
else if (item1 instanceof Connector_1.Connector) {
item1.getSegments().forEach(function (s1) {
if (item2 instanceof Shape_1.Shape)
result = result || s1.intersectRect(item2.rectangle);
else if (item2 instanceof Connector_1.Connector) {
item2.getSegments().forEach(function (s2) {
result = result || s1.intersect(s2);
});
}
});
}
return result;
};
DiagramModel.prototype.getIntersectItems = function (item) {
var result = [];
this.items.forEach(function (i) {
if (i.container !== item.container)
return;
if (item !== i && (!(i instanceof Connector_1.Connector) || item.attachedConnectors.indexOf(i) === -1) &&
DiagramModel.isIntersectedItems(i, item))
result.push(i);
});
return result;
};
DiagramModel.prototype.getIntersectItemsMinZIndex = function (item) {
var items = this.getIntersectItems(item);
return items.map(function (i) { return i.zIndex; }).reduce(function (prev, cur) { return Math.min(prev, cur); }, Number.MAX_VALUE);
};
DiagramModel.prototype.getIntersectItemsMaxZIndex = function (item) {
var items = this.getIntersectItems(item);
return items.map(function (i) { return i.zIndex; }).reduce(function (prev, cur) { return Math.max(prev, cur); }, -Number.MAX_VALUE);
};
DiagramModel.prototype.iterateItems = function (callback) {
this.items.forEach(callback);
};
DiagramModel.prototype.invalidateItems = function () {
this.iterateItems(function (item) {
item.invalidatePrimitives();
if (item instanceof Connector_1.Connector)
item.invalidateRenderPoints();
});
};
DiagramModel.prototype.getNextKey = function (baseKey) {
var _this = this;
return ModelUtils_1.ModelUtils.getNextItemKey(this.items.map(function (item) { return item.key; }), function (key) { return _this.itemIndexByKey[key] === undefined; }, baseKey);
};
DiagramModel.defaultPageColor = Color_1.ColorHelper.LIGHT_COLOR;
return DiagramModel;
}());
exports.DiagramModel = DiagramModel;
/***/ }),
/* 20 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RenderManager_1 = __webpack_require__(12);
var Primitive_1 = __webpack_require__(18);
var RectanglePrimitive = /** @class */ (function (_super) {
__extends(RectanglePrimitive, _super);
function RectanglePrimitive(x, y, width, height, style, className, clipPathId, onApplyProperties) {
var _this = _super.call(this, style, className, clipPathId, onApplyProperties) || this;
_this.x = x;
_this.y = y;
_this.width = width;
_this.height = height;
return _this;
}
RectanglePrimitive.prototype.createMainElement = function () {
return document.createElementNS(RenderManager_1.svgNS, "rect");
};
RectanglePrimitive.prototype.applyElementProperties = function (element) {
this.setUnitAttribute(element, "x", this.x);
this.setUnitAttribute(element, "y", this.y);
this.setUnitAttribute(element, "width", this.width);
this.setUnitAttribute(element, "height", this.height);
_super.prototype.applyElementProperties.call(this, element);
};
return RectanglePrimitive;
}(Primitive_1.SvgPrimitive));
exports.RectanglePrimitive = RectanglePrimitive;
/***/ }),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeParameterPoint = /** @class */ (function () {
function ShapeParameterPoint(key, point) {
this.key = key;
this.point = point;
}
return ShapeParameterPoint;
}());
exports.ShapeParameterPoint = ShapeParameterPoint;
/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Connector_1 = __webpack_require__(5);
var LayoutSettings = /** @class */ (function () {
function LayoutSettings(gridSize) {
this.orientation = DataLayoutOrientation.Vertical;
this.direction = LogicalDirectionKind.Forward;
this.componentSpacing = (gridSize && gridSize * 2 > 720) ? gridSize * 2 : 720;
this.columnSpacing = (gridSize && gridSize * 2 > Connector_1.Connector.minOffset) ? gridSize * 2 : Connector_1.Connector.minOffset;
this.layerSpacing = this.columnSpacing * 2;
}
return LayoutSettings;
}());
exports.LayoutSettings = LayoutSettings;
var TreeLayoutSettings = /** @class */ (function (_super) {
__extends(TreeLayoutSettings, _super);
function TreeLayoutSettings(gridSize) {
var _this = _super.call(this, gridSize) || this;
_this.alignment = Alignment.Center;
_this.subTreeColumnSpacing = _this.componentSpacing / 2;
return _this;
}
return TreeLayoutSettings;
}(LayoutSettings));
exports.TreeLayoutSettings = TreeLayoutSettings;
var LogicalDirectionKind;
(function (LogicalDirectionKind) {
LogicalDirectionKind[LogicalDirectionKind["Backward"] = 0] = "Backward";
LogicalDirectionKind[LogicalDirectionKind["Forward"] = 1] = "Forward";
})(LogicalDirectionKind = exports.LogicalDirectionKind || (exports.LogicalDirectionKind = {}));
var DataLayoutOrientation;
(function (DataLayoutOrientation) {
DataLayoutOrientation[DataLayoutOrientation["Horizontal"] = 0] = "Horizontal";
DataLayoutOrientation[DataLayoutOrientation["Vertical"] = 1] = "Vertical";
})(DataLayoutOrientation = exports.DataLayoutOrientation || (exports.DataLayoutOrientation = {}));
var Alignment;
(function (Alignment) {
Alignment[Alignment["Left"] = 0] = "Left";
Alignment[Alignment["Center"] = 1] = "Center";
})(Alignment = exports.Alignment || (exports.Alignment = {}));
/***/ }),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Browser = /** @class */ (function () {
function Browser() {
}
Browser.IdentUserAgent = function (userAgent, ignoreDocumentMode) {
if (ignoreDocumentMode === void 0) { ignoreDocumentMode = false; }
var browserTypesOrderedList = ["Mozilla", "IE", "Firefox", "Netscape", "Safari", "Chrome", "Opera", "Opera10", "Edge"];
var defaultBrowserType = "IE";
var defaultPlatform = "Win";
var defaultVersions = { Safari: 2, Chrome: 0.1, Mozilla: 1.9, Netscape: 8, Firefox: 2, Opera: 9, IE: 6, Edge: 12 };
if (!userAgent || userAgent.length == 0) {
Browser.fillUserAgentInfo(browserTypesOrderedList, defaultBrowserType, defaultVersions[defaultBrowserType], defaultPlatform);
return;
}
userAgent = userAgent.toLowerCase();
Browser.indentPlatformMajorVersion(userAgent);
try {
var platformIdentStrings = {
"Windows": "Win",
"Macintosh": "Mac",
"Mac OS": "Mac",
"Mac_PowerPC": "Mac",
"cpu os": "MacMobile",
"cpu iphone os": "MacMobile",
"Android": "Android",
"!Windows Phone": "WinPhone",
"!WPDesktop": "WinPhone",
"!ZuneWP": "WinPhone"
};
var optSlashOrSpace = "(?:/|\\s*)?";
var versionString = "(\\d+)(?:\\.((?:\\d+?[1-9])|\\d)0*?)?";
var optVersion = "(?:" + versionString + ")?";
var patterns = {
Safari: "applewebkit(?:.*?(?:version/" + versionString + "[\\.\\w\\d]*?(?:\\s+mobile\/\\S*)?\\s+safari))?",
Chrome: "(?:chrome|crios)(?!frame)" + optSlashOrSpace + optVersion,
Mozilla: "mozilla(?:.*rv:" + optVersion + ".*Gecko)?",
Netscape: "(?:netscape|navigator)\\d*/?\\s*" + optVersion,
Firefox: "firefox" + optSlashOrSpace + optVersion,
Opera: "(?:opera|\sopr)" + optSlashOrSpace + optVersion,
Opera10: "opera.*\\s*version" + optSlashOrSpace + optVersion,
IE: "msie\\s*" + optVersion,
Edge: "edge" + optSlashOrSpace + optVersion
};
var browserType;
var version = -1;
for (var i = 0; i < browserTypesOrderedList.length; i++) {
var browserTypeCandidate = browserTypesOrderedList[i];
var regExp = new RegExp(patterns[browserTypeCandidate], "i");
if (regExp.compile)
regExp.compile(patterns[browserTypeCandidate], "i");
var matches = regExp.exec(userAgent);
if (matches && matches.index >= 0) {
if (browserType == "IE" && version >= 11 && browserTypeCandidate == "Safari") // WinPhone8.1 update
continue;
browserType = browserTypeCandidate;
if (browserType == "Opera10")
browserType = "Opera";
var tridentPattern = "trident" + optSlashOrSpace + optVersion;
version = Browser.GetBrowserVersion(userAgent, matches, tridentPattern, Browser.getIECompatibleVersionString());
if (browserType == "Mozilla" && version >= 11)
browserType = "IE";
}
}
if (!browserType)
browserType = defaultBrowserType;
var browserVersionDetected = version != -1;
if (!browserVersionDetected)
version = defaultVersions[browserType];
var platform;
var minOccurenceIndex = Number.MAX_VALUE;
for (var identStr in platformIdentStrings) {
if (!platformIdentStrings.hasOwnProperty(identStr))
continue;
var importantIdent = identStr.substr(0, 1) == "!";
var occurenceIndex = userAgent.indexOf((importantIdent ? identStr.substr(1) : identStr).toLowerCase());
if (occurenceIndex >= 0 && (occurenceIndex < minOccurenceIndex || importantIdent)) {
minOccurenceIndex = importantIdent ? 0 : occurenceIndex;
platform = platformIdentStrings[identStr];
}
}
var samsungPattern = "SM-[A-Z]";
var m = userAgent.toUpperCase().match(samsungPattern);
var isSamsungAndroidDevice = m && m.length > 0;
if (platform == "WinPhone" && version < 9)
version = Math.floor(Browser.getVersionFromTrident(userAgent, "trident" + optSlashOrSpace + optVersion));
if (!ignoreDocumentMode && browserType == "IE" && version > 7 && document.documentMode < version)
version = document.documentMode;
if (platform == "WinPhone")
version = Math.max(9, version);
if (!platform)
platform = defaultPlatform;
if (platform == platformIdentStrings["cpu os"] && !browserVersionDetected) // Terra browser
version = 4;
Browser.fillUserAgentInfo(browserTypesOrderedList, browserType, version, platform, isSamsungAndroidDevice);
}
catch (e) {
Browser.fillUserAgentInfo(browserTypesOrderedList, defaultBrowserType, defaultVersions[defaultBrowserType], defaultPlatform);
}
};
Browser.GetBrowserVersion = function (userAgent, matches, tridentPattern, ieCompatibleVersionString) {
var version = Browser.getVersionFromMatches(matches);
if (ieCompatibleVersionString) {
var versionFromTrident = Browser.getVersionFromTrident(userAgent, tridentPattern);
if (ieCompatibleVersionString === "edge" || parseInt(ieCompatibleVersionString) === versionFromTrident)
return versionFromTrident;
}
return version;
};
Browser.getIECompatibleVersionString = function () {
if (document.compatible) {
for (var i = 0; i < document.compatible.length; i++)
if (document.compatible[i].userAgent === "IE" && document.compatible[i].version)
return document.compatible[i].version.toLowerCase();
}
return "";
};
Browser.isTouchEnabled = function () {
return ("ontouchstart" in window) ||
(navigator["maxTouchPoints"] > 0) ||
(navigator["msMaxTouchPoints"] > 0);
};
Browser.fillUserAgentInfo = function (browserTypesOrderedList, browserType, version, platform, isSamsungAndroidDevice) {
if (isSamsungAndroidDevice === void 0) { isSamsungAndroidDevice = false; }
for (var i = 0; i < browserTypesOrderedList.length; i++) {
var type = browserTypesOrderedList[i];
Browser[type] = type == browserType;
}
Browser.Version = Math.floor(10.0 * version) / 10.0;
Browser.MajorVersion = Math.floor(Browser.Version);
Browser.WindowsPlatform = platform == "Win" || platform == "WinPhone";
Browser.MacOSPlatform = platform == "Mac";
Browser.MacOSMobilePlatform = platform == "MacMobile" || (platform == "Mac" && Browser.isTouchEnabled());
Browser.AndroidMobilePlatform = platform == "Android";
Browser.WindowsPhonePlatform = platform == "WinPhone";
Browser.WebKitFamily = Browser.Safari || Browser.Chrome || Browser.Opera && Browser.MajorVersion >= 15;
Browser.NetscapeFamily = Browser.Netscape || Browser.Mozilla || Browser.Firefox;
Browser.HardwareAcceleration = (Browser.IE && Browser.MajorVersion >= 9) || (Browser.Firefox && Browser.MajorVersion >= 4) ||
(Browser.AndroidMobilePlatform && Browser.Chrome) || (Browser.Chrome && Browser.MajorVersion >= 37) ||
(Browser.Safari && !Browser.WindowsPlatform) || Browser.Edge || (Browser.Opera && Browser.MajorVersion >= 46);
Browser.WebKitTouchUI = Browser.MacOSMobilePlatform || Browser.AndroidMobilePlatform;
var isIETouchUI = Browser.IE && Browser.MajorVersion > 9 && Browser.WindowsPlatform && Browser.UserAgent.toLowerCase().indexOf("touch") >= 0;
Browser.MSTouchUI = isIETouchUI || (Browser.Edge && !!window.navigator.maxTouchPoints);
Browser.TouchUI = Browser.WebKitTouchUI || Browser.MSTouchUI;
Browser.MobileUI = Browser.WebKitTouchUI || Browser.WindowsPhonePlatform;
Browser.AndroidDefaultBrowser = Browser.AndroidMobilePlatform && !Browser.Chrome;
Browser.AndroidChromeBrowser = Browser.AndroidMobilePlatform && Browser.Chrome;
if (isSamsungAndroidDevice)
Browser.SamsungAndroidDevice = isSamsungAndroidDevice;
if (Browser.MSTouchUI) {
var isARMArchitecture = Browser.UserAgent.toLowerCase().indexOf("arm;") > -1;
Browser.VirtualKeyboardSupported = isARMArchitecture || Browser.WindowsPhonePlatform;
}
else {
Browser.VirtualKeyboardSupported = Browser.WebKitTouchUI;
}
Browser.fillDocumentElementBrowserTypeClassNames(browserTypesOrderedList);
};
Browser.indentPlatformMajorVersion = function (userAgent) {
var regex = /(?:(?:windows nt|macintosh|mac os|cpu os|cpu iphone os|android|windows phone|linux) )(\d+)(?:[-0-9_.])*/;
var matches = regex.exec(userAgent);
if (matches)
Browser.PlaformMajorVersion = matches[1];
};
Browser.prototype.GetBrowserVersion = function (userAgent, matches, tridentPattern, ieCompatibleVersionString) {
var version = Browser.getVersionFromMatches(matches);
if (ieCompatibleVersionString) {
var versionFromTrident = Browser.getVersionFromTrident(userAgent, tridentPattern);
if (ieCompatibleVersionString === "edge" || parseInt(ieCompatibleVersionString) === versionFromTrident)
return versionFromTrident;
}
return version;
};
Browser.getVersionFromMatches = function (matches) {
var result = -1;
var versionStr = "";
if (matches[1]) {
versionStr += matches[1];
if (matches[2])
versionStr += "." + matches[2];
}
if (versionStr != "") {
result = parseFloat(versionStr);
if (isNaN(result))
result = -1;
}
return result;
};
Browser.getVersionFromTrident = function (userAgent, tridentPattern) {
var tridentDiffFromVersion = 4;
var matches = new RegExp(tridentPattern, "i").exec(userAgent);
return Browser.getVersionFromMatches(matches) + tridentDiffFromVersion;
};
Browser.fillDocumentElementBrowserTypeClassNames = function (browserTypesOrderedList) {
var documentElementClassName = "";
var browserTypeslist = browserTypesOrderedList.concat(["WindowsPlatform", "MacOSPlatform", "MacOSMobilePlatform", "AndroidMobilePlatform",
"WindowsPhonePlatform", "WebKitFamily", "WebKitTouchUI", "MSTouchUI", "TouchUI", "AndroidDefaultBrowser"]);
for (var i = 0; i < browserTypeslist.length; i++) {
var type = browserTypeslist[i];
if (Browser[type])
documentElementClassName += "dx" + type + " ";
}
documentElementClassName += "dxBrowserVersion-" + Browser.MajorVersion;
if (document && document.documentElement) {
if (document.documentElement.className != "")
documentElementClassName = " " + documentElementClassName;
document.documentElement.className += documentElementClassName;
Browser.Info = documentElementClassName;
}
};
Browser.UserAgent = window.navigator.userAgent.toLowerCase();
Browser._foo = Browser.IdentUserAgent(Browser.UserAgent); // to init
return Browser;
}());
exports.Browser = Browser;
/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ConnectorLineOption;
(function (ConnectorLineOption) {
ConnectorLineOption[ConnectorLineOption["Straight"] = 0] = "Straight";
ConnectorLineOption[ConnectorLineOption["Orthogonal"] = 1] = "Orthogonal";
})(ConnectorLineOption = exports.ConnectorLineOption || (exports.ConnectorLineOption = {}));
var ConnectorLineEnding;
(function (ConnectorLineEnding) {
ConnectorLineEnding[ConnectorLineEnding["None"] = 0] = "None";
ConnectorLineEnding[ConnectorLineEnding["Arrow"] = 1] = "Arrow";
})(ConnectorLineEnding = exports.ConnectorLineEnding || (exports.ConnectorLineEnding = {}));
exports.DEFAULT_CONNECTOR_LINEOPTION = ConnectorLineOption.Orthogonal;
exports.DEFAULT_CONNECTOR_STARTLINEENDING = ConnectorLineEnding.None;
exports.DEFAULT_CONNECTOR_ENDLINEENDING = ConnectorLineEnding.Arrow;
var ConnectorProperties = /** @class */ (function () {
function ConnectorProperties() {
this.lineOption = exports.DEFAULT_CONNECTOR_LINEOPTION;
this.startLineEnding = exports.DEFAULT_CONNECTOR_STARTLINEENDING;
this.endLineEnding = exports.DEFAULT_CONNECTOR_ENDLINEENDING;
}
ConnectorProperties.prototype.clone = function () {
var clone = new ConnectorProperties();
clone.lineOption = this.lineOption;
clone.startLineEnding = this.startLineEnding;
clone.endLineEnding = this.endLineEnding;
return clone;
};
ConnectorProperties.prototype.forEach = function (callback) {
for (var propertyName in this) {
if (this.hasOwnProperty(propertyName))
callback(propertyName);
}
};
ConnectorProperties.prototype.toObject = function () {
var result = {};
var modified = false;
if (this.lineOption !== exports.DEFAULT_CONNECTOR_LINEOPTION) {
result["lineOption"] = this.lineOption;
modified = true;
}
if (this.startLineEnding !== exports.DEFAULT_CONNECTOR_STARTLINEENDING) {
result["startLineEnding"] = this.startLineEnding;
modified = true;
}
if (this.endLineEnding !== exports.DEFAULT_CONNECTOR_ENDLINEENDING) {
result["endLineEnding"] = this.endLineEnding;
modified = true;
}
return modified ? result : null;
};
ConnectorProperties.prototype.fromObject = function (obj) {
if (typeof obj["lineOption"] === "number")
this.lineOption = obj["lineOption"];
if (typeof obj["startLineEnding"] === "number")
this.startLineEnding = obj["startLineEnding"];
if (typeof obj["endLineEnding"] === "number")
this.endLineEnding = obj["endLineEnding"];
};
return ConnectorProperties;
}());
exports.ConnectorProperties = ConnectorProperties;
/***/ }),
/* 25 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ProcessShapeDescription_1 = __webpack_require__(155);
var DecisionShapeDescription_1 = __webpack_require__(156);
var ManualInputShapeDescription_1 = __webpack_require__(157);
var DataShapeDescription_1 = __webpack_require__(158);
var TerminatorShapeDescription_1 = __webpack_require__(159);
var PredefinedProcessShapeDescription_1 = __webpack_require__(160);
var ArrowNorthSouthShapeDescription_1 = __webpack_require__(161);
var ArrowRightShapeDescription_1 = __webpack_require__(162);
var ArrowTopShapeDescription_1 = __webpack_require__(163);
var CrossShapeDescription_1 = __webpack_require__(164);
var DiamondShapeDescription_1 = __webpack_require__(92);
var EllipseShapeDescription_1 = __webpack_require__(67);
var HeartShapeDescription_1 = __webpack_require__(165);
var RectangleShapeDescription_1 = __webpack_require__(14);
var TextShapeDescription_1 = __webpack_require__(93);
var PentagonShapeDescription_1 = __webpack_require__(94);
var HexagonShapeDescription_1 = __webpack_require__(95);
var OctagonShapeDescription_1 = __webpack_require__(166);
var StarShapeDescription_1 = __webpack_require__(167);
var ArrowBottomShapeDescription_1 = __webpack_require__(168);
var ArrowEastWestShapeDescription_1 = __webpack_require__(169);
var ArrowLeftShapeDescription_1 = __webpack_require__(170);
var TriangleShapeDescription_1 = __webpack_require__(96);
var DocumentShapeDescription_1 = __webpack_require__(97);
var MultipleDocumentsShapeDescription_1 = __webpack_require__(171);
var PreparationShapeDescription_1 = __webpack_require__(172);
var HardDiskShapeDescription_1 = __webpack_require__(173);
var DatabaseShapeDescription_1 = __webpack_require__(174);
var InternalStorageShapeDescription_1 = __webpack_require__(175);
var PaperTapeShapeDescription_1 = __webpack_require__(176);
var ManualOperationShapeDescription_1 = __webpack_require__(177);
var DelayShapeDescription_1 = __webpack_require__(178);
var StoredDataShapeDescription_1 = __webpack_require__(179);
var MergeShapeDescription_1 = __webpack_require__(180);
var DisplayShapeDescription_1 = __webpack_require__(181);
var OrShapeDescription_1 = __webpack_require__(182);
var SummingJunctionShapeDescription_1 = __webpack_require__(183);
var CustomShapeDescription_1 = __webpack_require__(184);
var VerticalContainerDescription_1 = __webpack_require__(185);
var HorizontalContainerDescription_1 = __webpack_require__(186);
var CardWithImageOnLeftDescription_1 = __webpack_require__(187);
var CardWithImageOnRightDescription_1 = __webpack_require__(189);
var CardWithImageOnTopDescription_1 = __webpack_require__(190);
var ShapeTypes_1 = __webpack_require__(1);
var ShapeDescriptionManager = /** @class */ (function () {
function ShapeDescriptionManager() {
}
ShapeDescriptionManager.get = function (type) {
return this.descriptions[type];
};
ShapeDescriptionManager.rectangle = function () {
return this.descriptions[ShapeTypes_1.ShapeTypes.Rectangle];
};
ShapeDescriptionManager.getTypesByCategory = function (category) {
return this.descriptionTypes[category];
};
ShapeDescriptionManager.getCategoryByType = function (type) {
return this.descriptionCategories[type];
};
ShapeDescriptionManager.getCategoryByDescription = function (description) {
return ShapeDescriptionManager.getCategoryByType(description.key);
};
ShapeDescriptionManager.register = function (description, category, type) {
if (type === void 0) { type = description.key; }
if (this.descriptions[type] !== undefined)
throw Error("Description key is duplicated");
this.descriptions[type] = description;
if (!this.descriptionTypes[category])
this.descriptionTypes[category] = [];
this.descriptionTypes[category].push(type);
this.descriptionCategories[type] = category;
};
ShapeDescriptionManager.registerCustomShape = function (shape) {
if (shape.type === undefined)
throw Error("Custom shape type is not defined");
if (this.descriptions[shape.type] !== undefined)
throw Error("Custom shape type is duplicated");
var baseDescription = shape.baseType && this.descriptions[shape.baseType];
this.register(new CustomShapeDescription_1.CustomShapeDescription(shape, baseDescription), shape.category || ShapeTypes_1.ShapeCategories.Custom);
};
ShapeDescriptionManager.unregisterCustomShape = function (shapeType) {
var description = this.descriptions[shapeType];
if (description instanceof CustomShapeDescription_1.CustomShapeDescription) {
var category = this.descriptionCategories[shapeType];
delete this.descriptions[shapeType];
delete this.descriptionCategories[shapeType];
var index = this.descriptionTypes[category].indexOf(shapeType);
this.descriptionTypes[category].splice(index, 1);
if (this.descriptionTypes[category].length === 0)
delete this.descriptionTypes[category];
}
};
ShapeDescriptionManager.descriptions = {};
ShapeDescriptionManager.descriptionTypes = {};
ShapeDescriptionManager.descriptionCategories = {};
return ShapeDescriptionManager;
}());
exports.ShapeDescriptionManager = ShapeDescriptionManager;
ShapeDescriptionManager.register(new TextShapeDescription_1.TextShapeDescription(), ShapeTypes_1.ShapeCategories.General);
ShapeDescriptionManager.register(new RectangleShapeDescription_1.RectangleShapeDescription(), ShapeTypes_1.ShapeCategories.General);
ShapeDescriptionManager.register(new EllipseShapeDescription_1.EllipseShapeDescription(), ShapeTypes_1.ShapeCategories.General);
ShapeDescriptionManager.register(new CrossShapeDescription_1.CrossShapeDescription(), ShapeTypes_1.ShapeCategories.General);
ShapeDescriptionManager.register(new TriangleShapeDescription_1.TriangleShapeDescription(), ShapeTypes_1.ShapeCategories.General);
ShapeDescriptionManager.register(new DiamondShapeDescription_1.DiamondShapeDescription(), ShapeTypes_1.ShapeCategories.General);
ShapeDescriptionManager.register(new HeartShapeDescription_1.HeartShapeDescription(), ShapeTypes_1.ShapeCategories.General);
ShapeDescriptionManager.register(new PentagonShapeDescription_1.PentagonShapeDescription(), ShapeTypes_1.ShapeCategories.General);
ShapeDescriptionManager.register(new HexagonShapeDescription_1.HexagonShapeDescription(), ShapeTypes_1.ShapeCategories.General);
ShapeDescriptionManager.register(new OctagonShapeDescription_1.OctagonShapeDescription(), ShapeTypes_1.ShapeCategories.General);
ShapeDescriptionManager.register(new StarShapeDescription_1.StarShapeDescription(), ShapeTypes_1.ShapeCategories.General);
ShapeDescriptionManager.register(new ArrowTopShapeDescription_1.ArrowTopShapeDescription(), ShapeTypes_1.ShapeCategories.General);
ShapeDescriptionManager.register(new ArrowBottomShapeDescription_1.ArrowBottomShapeDescription(), ShapeTypes_1.ShapeCategories.General);
ShapeDescriptionManager.register(new ArrowLeftShapeDescription_1.ArrowLeftShapeDescription(), ShapeTypes_1.ShapeCategories.General);
ShapeDescriptionManager.register(new ArrowRightShapeDescription_1.ArrowRightShapeDescription(), ShapeTypes_1.ShapeCategories.General);
ShapeDescriptionManager.register(new ArrowNorthSouthShapeDescription_1.ArrowNorthSouthShapeDescription(), ShapeTypes_1.ShapeCategories.General);
ShapeDescriptionManager.register(new ArrowEastWestShapeDescription_1.ArrowEastWestShapeDescription(), ShapeTypes_1.ShapeCategories.General);
ShapeDescriptionManager.register(new ProcessShapeDescription_1.ProcessShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new DecisionShapeDescription_1.DecisionShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new TerminatorShapeDescription_1.TerminatorShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new PredefinedProcessShapeDescription_1.PredefinedProcessShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new DocumentShapeDescription_1.DocumentShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new MultipleDocumentsShapeDescription_1.MultipleDocumentsShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new ManualInputShapeDescription_1.ManualInputShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new PreparationShapeDescription_1.PreparationShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new DataShapeDescription_1.DataShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new DatabaseShapeDescription_1.DatabaseShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new HardDiskShapeDescription_1.HardDiskShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new InternalStorageShapeDescription_1.InternalStorageShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new PaperTapeShapeDescription_1.PaperTapeShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new ManualOperationShapeDescription_1.ManualOperationShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new DelayShapeDescription_1.DelayShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new StoredDataShapeDescription_1.StoredDataShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new DisplayShapeDescription_1.DisplayShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new MergeShapeDescription_1.MergeShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new OrShapeDescription_1.OrShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new SummingJunctionShapeDescription_1.SummingJunctionShapeDescription(), ShapeTypes_1.ShapeCategories.Flowchart);
ShapeDescriptionManager.register(new CardWithImageOnLeftDescription_1.CardWithImageOnLeftDescription(), ShapeTypes_1.ShapeCategories.OrgChart);
ShapeDescriptionManager.register(new CardWithImageOnRightDescription_1.CardWithImageOnRightDescription(), ShapeTypes_1.ShapeCategories.OrgChart);
ShapeDescriptionManager.register(new CardWithImageOnTopDescription_1.CardWithImageOnTopDescription(), ShapeTypes_1.ShapeCategories.OrgChart);
ShapeDescriptionManager.register(new VerticalContainerDescription_1.VerticalContainerDescription(), ShapeTypes_1.ShapeCategories.Containers);
ShapeDescriptionManager.register(new HorizontalContainerDescription_1.HorizontalContainerDescription(), ShapeTypes_1.ShapeCategories.Containers);
/***/ }),
/* 26 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var MouseHandlerStateBase_1 = __webpack_require__(32);
var Event_1 = __webpack_require__(10);
var UnitConverter_1 = __webpack_require__(13);
var MouseHandlerDraggingState = /** @class */ (function (_super) {
__extends(MouseHandlerDraggingState, _super);
function MouseHandlerDraggingState(handler, history) {
var _this = _super.call(this, handler) || this;
_this.history = history;
return _this;
}
MouseHandlerDraggingState.prototype.onMouseDown = function (evt) {
this.mouseDownPoint = evt.modelPoint.clone();
};
MouseHandlerDraggingState.prototype.onMouseMove = function (evt) {
if (evt.button !== Event_1.MouseButton.Left) {
this.cancelChanges();
this.handler.switchToDefaultState();
}
else if (!this.mouseDownPoint ||
Math.abs(this.mouseDownPoint.x - evt.modelPoint.x) > MouseHandlerDraggingState.dragStartLimit ||
Math.abs(this.mouseDownPoint.y - evt.modelPoint.y) > MouseHandlerDraggingState.dragStartLimit) {
this.onApplyChanges(evt);
if (!this.modified)
this.handler.raiseDragStart(this.getDraggingElementKeys());
this.modified = true;
this.mouseDownPoint = undefined;
}
};
MouseHandlerDraggingState.prototype.cancelChanges = function () {
this.history.undoTransaction();
if (this.modified)
this.handler.raiseDragEnd(this.getDraggingElementKeys());
this.modified = false;
};
MouseHandlerDraggingState.prototype.onMouseUp = function (evt) {
this.mouseDownPoint = undefined;
this.handler.switchToDefaultState();
};
MouseHandlerDraggingState.prototype.start = function () {
this.history.beginTransaction();
};
MouseHandlerDraggingState.prototype.finish = function () {
if (this.modified) {
this.onFinishWithChanges();
this.modified = false;
this.history.endTransaction();
this.handler.raiseDragEnd(this.getDraggingElementKeys());
}
else
this.history.endTransaction();
};
MouseHandlerDraggingState.prototype.onFinishWithChanges = function () { };
MouseHandlerDraggingState.prototype.getSnappedPoint = function (evt, point) {
return this.handler.getSnappedPoint(evt, point);
};
MouseHandlerDraggingState.dragStartLimit = UnitConverter_1.UnitConverter.pixelsToTwips(4);
return MouseHandlerDraggingState;
}(MouseHandlerStateBase_1.MouseHandlerCancellableState));
exports.MouseHandlerDraggingState = MouseHandlerDraggingState;
/***/ }),
/* 27 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Color_1 = __webpack_require__(38);
var Svg_1 = __webpack_require__(79);
var StyleBase = /** @class */ (function () {
function StyleBase() {
}
StyleBase.prototype.clone = function () {
var _this = this;
var style = this.createInstance();
this.forEach(function (propertyName) { style[propertyName] = _this[propertyName]; });
return style;
};
StyleBase.prototype.forEach = function (callback) {
for (var propertyName in this) {
if (this.hasOwnProperty(propertyName))
callback(propertyName);
}
};
StyleBase.prototype.toObject = function () {
var _this = this;
var result = {};
var modified = false;
var defaultStyle = this.getDefaultInstance();
this.forEach(function (key) {
if (_this[key] !== defaultStyle[key]) {
result[key] = _this[key];
modified = true;
}
});
return modified ? result : null;
};
StyleBase.prototype.fromObject = function (obj) {
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
if (this[key] !== undefined) {
var value = Svg_1.isColorProperty(key) ? Color_1.ColorHelper.stringToHash(obj[key]) : obj[key];
this[key] = value;
}
}
}
};
return StyleBase;
}());
exports.StyleBase = StyleBase;
var EmptyStyle = /** @class */ (function (_super) {
__extends(EmptyStyle, _super);
function EmptyStyle(styles) {
var _this = _super.call(this) || this;
if (styles)
Object.keys(styles).forEach(function (k) { return _this[k] = styles[k]; });
return _this;
}
EmptyStyle.prototype.createInstance = function () {
return new EmptyStyle();
};
EmptyStyle.prototype.getDefaultInstance = function () {
return Style.defaultInstace;
};
return EmptyStyle;
}(StyleBase));
exports.EmptyStyle = EmptyStyle;
var Style = /** @class */ (function (_super) {
__extends(Style, _super);
function Style() {
var _this = _super.call(this) || this;
// Default values must be the same with css
_this["fill"] = "#ffffff";
_this["stroke"] = "#000000";
return _this;
}
Style.prototype.createInstance = function () {
return new Style();
};
Style.prototype.getDefaultInstance = function () {
return Style.defaultInstace;
};
Style.defaultInstace = new Style();
return Style;
}(StyleBase));
exports.Style = Style;
var StyleText = /** @class */ (function (_super) {
__extends(StyleText, _super);
function StyleText() {
var _this = _super.call(this) || this;
// Default values must be the same with css
_this["fill"] = "#000000";
_this["font-family"] = "Arial";
_this["font-size"] = "10pt";
_this["font-weight"] = "";
_this["font-style"] = "";
_this["text-decoration"] = "";
_this["text-anchor"] = "middle";
return _this;
}
StyleText.prototype.createInstance = function () {
return new StyleText();
};
StyleText.prototype.getDefaultInstance = function () {
return StyleText.defaultInstace;
};
StyleText.defaultInstace = new StyleText();
return StyleText;
}(StyleBase));
exports.StyleText = StyleText;
/***/ }),
/* 28 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RenderManager_1 = __webpack_require__(12);
var Primitive_1 = __webpack_require__(18);
var GroupPrimitive = /** @class */ (function (_super) {
__extends(GroupPrimitive, _super);
function GroupPrimitive(children, className, zIndex, clipPathId, onApplyProperties, onBeforeDispose) {
var _this = _super.call(this, null, className, clipPathId, onApplyProperties) || this;
_this.zIndex = zIndex;
_this.onBeforeDispose = onBeforeDispose;
_this.children = children;
return _this;
}
GroupPrimitive.prototype.createMainElement = function () {
return document.createElementNS(RenderManager_1.svgNS, "g");
};
GroupPrimitive.prototype.applyElementProperties = function (element) {
if (this.zIndex || this.zIndex === 0)
element.style.setProperty("z-index", this.zIndex.toString());
_super.prototype.applyElementProperties.call(this, element);
};
GroupPrimitive.prototype.dispose = function () {
if (this.onBeforeDispose)
this.onBeforeDispose();
_super.prototype.dispose.call(this);
};
return GroupPrimitive;
}(Primitive_1.SvgPrimitive));
exports.GroupPrimitive = GroupPrimitive;
/***/ }),
/* 29 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeParameter = /** @class */ (function () {
function ShapeParameter(key, value) {
this.key = key;
this.value = value;
}
return ShapeParameter;
}());
exports.ShapeParameter = ShapeParameter;
var ShapeParameters = /** @class */ (function () {
function ShapeParameters() {
this.items = {};
}
ShapeParameters.prototype.add = function (parameter) {
this.items[parameter.key] = parameter;
};
ShapeParameters.prototype.addRange = function (parameters) {
for (var i = 0; i < parameters.length; i++)
this.add(parameters[i]);
};
ShapeParameters.prototype.get = function (key) {
return this.items[key];
};
ShapeParameters.prototype.forEach = function (callback) {
for (var key in this.items)
if (this.items.hasOwnProperty(key))
callback(this.items[key]);
};
ShapeParameters.prototype.clone = function () {
var result = new ShapeParameters();
this.forEach(function (p) { result.add(new ShapeParameter(p.key, p.value)); });
return result;
};
ShapeParameters.prototype.toObject = function () {
var result = {};
var modified = false;
this.forEach(function (p) {
result[p.key] = { 'value': p.value };
modified = true;
});
return modified ? result : null;
};
ShapeParameters.prototype.fromObject = function (obj) {
this.forEach(function (p) {
var paramObj = obj[p.key];
if (paramObj) {
if (typeof paramObj["value"] === "number")
p.value = paramObj["value"];
}
});
};
return ShapeParameters;
}());
exports.ShapeParameters = ShapeParameters;
/***/ }),
/* 30 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Utils_1 = __webpack_require__(0);
var ConnectorRenderPoint = /** @class */ (function (_super) {
__extends(ConnectorRenderPoint, _super);
function ConnectorRenderPoint(x, y, pointIndex, skipped) {
if (pointIndex === void 0) { pointIndex = -1; }
if (skipped === void 0) { skipped = false; }
var _this = _super.call(this, x, y) || this;
_this.pointIndex = pointIndex;
_this.skipped = skipped;
return _this;
}
ConnectorRenderPoint.prototype.offset = function (offsetX, offsetY) {
if (offsetX === void 0) { offsetX = 0; }
if (offsetY === void 0) { offsetY = 0; }
return new ConnectorRenderPoint(this.x + offsetX, this.y + offsetY);
};
ConnectorRenderPoint.prototype.multiply = function (multiplierX, multiplierY) {
if (multiplierX === void 0) { multiplierX = 1; }
if (multiplierY === void 0) { multiplierY = multiplierX; }
return new ConnectorRenderPoint(this.x * multiplierX, this.y * multiplierY);
};
ConnectorRenderPoint.prototype.clone = function () { return new ConnectorRenderPoint(this.x, this.y, this.pointIndex); };
return ConnectorRenderPoint;
}(Utils_1.Point));
exports.ConnectorRenderPoint = ConnectorRenderPoint;
/***/ }),
/* 31 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Edge = /** @class */ (function () {
function Edge(key, from, to, weight) {
if (weight === void 0) { weight = 1; }
this.weight = weight;
this.key = key;
this.from = from;
this.to = to;
}
Edge.prototype.getHashKey = function () {
return this.from + "_" + this.to;
};
Edge.prototype.reverse = function () {
return new Edge(this.key, this.to, this.from, this.weight);
};
return Edge;
}());
exports.Edge = Edge;
var PositionInfo = /** @class */ (function () {
function PositionInfo(item, position) {
this.item = item;
this.position = position;
}
return PositionInfo;
}());
exports.PositionInfo = PositionInfo;
var ConnectionMode;
(function (ConnectionMode) {
ConnectionMode[ConnectionMode["Outgoing"] = 1] = "Outgoing";
ConnectionMode[ConnectionMode["Incoming"] = 2] = "Incoming";
ConnectionMode[ConnectionMode["OutgoingAndIncoming"] = 3] = "OutgoingAndIncoming";
})(ConnectionMode = exports.ConnectionMode || (exports.ConnectionMode = {}));
/***/ }),
/* 32 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var KeyCode_1 = __webpack_require__(16);
var MouseHandlerStateBase = /** @class */ (function () {
function MouseHandlerStateBase(handler) {
this.handler = handler;
}
MouseHandlerStateBase.prototype.start = function () { };
MouseHandlerStateBase.prototype.finish = function () { };
MouseHandlerStateBase.prototype.onMouseClick = function (_evt) { };
MouseHandlerStateBase.prototype.onMouseDblClick = function (_evt) {
this.handler.switchToDefaultState();
};
MouseHandlerStateBase.prototype.onMouseDown = function (_evt) { };
MouseHandlerStateBase.prototype.onMouseUp = function (_evt) { };
MouseHandlerStateBase.prototype.onMouseMove = function (_evt) { };
MouseHandlerStateBase.prototype.onMouseWheel = function (_evt) { return false; };
MouseHandlerStateBase.prototype.onDragStart = function (_evt) { };
MouseHandlerStateBase.prototype.onDragEnd = function (_evt) { };
MouseHandlerStateBase.prototype.onShortcut = function (_shortcutCode) { return false; };
return MouseHandlerStateBase;
}());
exports.MouseHandlerStateBase = MouseHandlerStateBase;
var MouseHandlerCancellableState = /** @class */ (function (_super) {
__extends(MouseHandlerCancellableState, _super);
function MouseHandlerCancellableState() {
return _super !== null && _super.apply(this, arguments) || this;
}
MouseHandlerCancellableState.prototype.onShortcut = function (code) {
if (code === KeyCode_1.KeyCode.Esc) {
this.cancelChanges();
this.handler.switchToDefaultState();
return true;
}
return false;
};
return MouseHandlerCancellableState;
}(MouseHandlerStateBase));
exports.MouseHandlerCancellableState = MouseHandlerCancellableState;
/***/ }),
/* 33 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var TextFilterPrimitive_1 = __webpack_require__(84);
var UnitConverter_1 = __webpack_require__(13);
exports.PAGE_BG_TEXTFLOOR_FILTER_ID = "page-text-flood";
var CanvasManagerBase = /** @class */ (function () {
function CanvasManagerBase(actualZoom) {
this.elements = {};
this.actualZoom = actualZoom;
}
CanvasManagerBase.prototype.createAndChangePrimitivesElements = function (primitives, parent) {
var _this = this;
primitives.forEach(function (primitive) {
_this.createAndChangePrimitiveElement(primitive, parent);
});
};
CanvasManagerBase.prototype.changePrimitivesElements = function (primitives, parent) {
var _this = this;
primitives.forEach(function (primitive, index) {
var element = parent.childNodes[index];
_this.changePrimitiveElement(primitive, element);
});
};
CanvasManagerBase.prototype.createPrimitiveElement = function (primitive, parent, sibling) {
var element = primitive.createElement();
if (parent != null) {
if (sibling !== undefined)
parent.insertBefore(element, sibling);
else
parent.appendChild(element);
}
return element;
};
CanvasManagerBase.prototype.createAndChangePrimitiveElement = function (primitive, parent, sibling) {
var element = this.createPrimitiveElement(primitive, parent, sibling);
this.changePrimitiveElement(primitive, element);
return element;
};
CanvasManagerBase.prototype.changePrimitiveElement = function (primitive, element) {
primitive.applyElementProperties(element);
};
CanvasManagerBase.prototype.getOrCreateElement = function (key, primitive, parent, sibling) {
var element = (key && this.elements[key]) || (this.elements[key] = this.createPrimitiveElement(primitive, parent, sibling));
this.changePrimitiveElement(primitive, element);
return element;
};
CanvasManagerBase.prototype.createTextFloodFilter = function (key, parent, pageColor) {
this.getOrCreateElement(key, new TextFilterPrimitive_1.TextFloodFilterPrimitive(exports.PAGE_BG_TEXTFLOOR_FILTER_ID, pageColor), parent);
};
CanvasManagerBase.prototype.getAbsoluteSize = function (modelSize) {
return modelSize
.transform(UnitConverter_1.UnitConverter.twipsToPixelsF)
.multiply(this.actualZoom);
};
return CanvasManagerBase;
}());
exports.CanvasManagerBase = CanvasManagerBase;
/***/ }),
/* 34 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Utils_1 = __webpack_require__(0);
var DiagramItem_1 = __webpack_require__(4);
var ConnectionPoint = /** @class */ (function (_super) {
__extends(ConnectionPoint, _super);
function ConnectionPoint(x, y, side) {
if (side === void 0) { side = DiagramItem_1.ConnectionPointSide.Undefined; }
var _this = _super.call(this, x, y) || this;
_this.side = side;
return _this;
}
ConnectionPoint.prototype.offset = function (offsetX, offsetY) {
if (offsetX === void 0) { offsetX = 0; }
if (offsetY === void 0) { offsetY = 0; }
return new ConnectionPoint(this.x + offsetX, this.y + offsetY);
};
ConnectionPoint.prototype.multiply = function (multiplierX, multiplierY) {
if (multiplierX === void 0) { multiplierX = 1; }
if (multiplierY === void 0) { multiplierY = multiplierX; }
return new ConnectionPoint(this.x * multiplierX, this.y * multiplierY);
};
ConnectionPoint.prototype.clone = function () { return new ConnectionPoint(this.x, this.y, this.side); };
ConnectionPoint.prototype.toPoint = function () { return new Utils_1.Point(this.x, this.y); };
return ConnectionPoint;
}(Utils_1.Point));
exports.ConnectionPoint = ConnectionPoint;
/***/ }),
/* 35 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var _1 = __webpack_require__(8);
var Model_1 = __webpack_require__(19);
var Utils_1 = __webpack_require__(0);
var DiagramSettings = /** @class */ (function () {
function DiagramSettings() {
this.onZoomChanged = new _1.EventDispatcher();
this.onViewChanged = new _1.EventDispatcher();
this.onReadOnlyChanged = new _1.EventDispatcher();
this._zoomLevel = 1;
this._zoomLevelItems = [0.5, 0.75, 1, 1.25, 1.5, 2, 3];
this._simpleView = false;
this._fullscreen = false;
this._readOnly = false;
this._autoZoom = AutoZoomMode.Disabled;
this._snapToGrid = true;
this._showGrid = true;
this._gridSize = 180;
this._gridSizeItems = [90, 180, 360, 720];
this._pageSizeItems = [
{ size: new Utils_1.Size(12240, 15840), text: "US-Letter ({width} x {height})" },
{ size: new Utils_1.Size(12240, 20160), text: "US-Legal ({width} x {height})" },
{ size: new Utils_1.Size(15817, 24491), text: "US-Tabloid ({width} x {height})" },
{ size: new Utils_1.Size(47679, 67408), text: "A0 ({width} x {height})" },
{ size: new Utils_1.Size(33676, 47679), text: "A1 ({width} x {height})" },
{ size: new Utils_1.Size(23811, 33676), text: "A2 ({width} x {height})" },
{ size: new Utils_1.Size(16838, 23811), text: "A3 ({width} x {height})" },
{ size: new Utils_1.Size(11906, 16838), text: "A4 ({width} x {height})" },
{ size: new Utils_1.Size(8391, 11906), text: "A5 ({width} x {height})" },
{ size: new Utils_1.Size(5953, 8391), text: "A6 ({width} x {height})" },
{ size: new Utils_1.Size(4195, 5953), text: "A7 ({width} x {height})" }
];
this._viewUnits = Model_1.DiagramUnit.In;
this.unitItems = {};
this.formatUnit = function (value) { return value.toString(); };
this.unitItems[Model_1.DiagramUnit.In] = "in";
this.unitItems[Model_1.DiagramUnit.Cm] = "cm";
this.unitItems[Model_1.DiagramUnit.Px] = "px";
}
Object.defineProperty(DiagramSettings.prototype, "zoomLevel", {
get: function () { return this._zoomLevel; },
set: function (value) {
var _this = this;
value = DiagramSettings.correctZoomLevel(value);
if (value !== this._zoomLevel) {
this._zoomLevel = value;
this.onZoomChanged.raise1(function (listener) { return listener.notifyZoomChanged(value, _this._autoZoom); });
}
},
enumerable: true,
configurable: true
});
Object.defineProperty(DiagramSettings.prototype, "zoomLevelItems", {
get: function () { return this._zoomLevelItems; },
set: function (value) {
value = value.map(function (l) { return DiagramSettings.correctZoomLevel(l); });
if (value !== this._zoomLevelItems) {
this._zoomLevelItems = value;
}
},
enumerable: true,
configurable: true
});
Object.defineProperty(DiagramSettings.prototype, "autoZoom", {
get: function () { return this._autoZoom; },
set: function (value) {
var _this = this;
if (value !== this._autoZoom) {
this._autoZoom = value;
this.onZoomChanged.raise1(function (l) { return l.notifyZoomChanged(_this._zoomLevel, value); });
}
},
enumerable: true,
configurable: true
});
Object.defineProperty(DiagramSettings.prototype, "simpleView", {
get: function () { return this._simpleView; },
set: function (value) {
if (value !== this._simpleView) {
this._simpleView = value;
this.onViewChanged.raise1(function (listener) { return listener.notifyViewChanged(value); });
}
},
enumerable: true,
configurable: true
});
Object.defineProperty(DiagramSettings.prototype, "readOnly", {
get: function () { return this._readOnly; },
set: function (value) {
if (value !== this._readOnly) {
this._readOnly = value;
this.onReadOnlyChanged.raise1(function (listener) { return listener.notifyReadOnlyChanged(value); });
}
},
enumerable: true,
configurable: true
});
Object.defineProperty(DiagramSettings.prototype, "fullscreen", {
get: function () { return this._fullscreen; },
set: function (value) { this._fullscreen = value; },
enumerable: true,
configurable: true
});
Object.defineProperty(DiagramSettings.prototype, "snapToGrid", {
get: function () { return this._snapToGrid; },
set: function (value) { this._snapToGrid = value; },
enumerable: true,
configurable: true
});
Object.defineProperty(DiagramSettings.prototype, "showGrid", {
get: function () { return this._showGrid; },
set: function (value) {
var _this = this;
if (value !== this._showGrid) {
this._showGrid = value;
this.onViewChanged.raise1(function (l) { return l.notifyGridChanged(_this.showGrid, _this.gridSize); });
}
},
enumerable: true,
configurable: true
});
Object.defineProperty(DiagramSettings.prototype, "gridSize", {
get: function () { return this._gridSize; },
set: function (value) {
var _this = this;
if (value !== this._gridSize) {
this._gridSize = value;
this.onViewChanged.raise1(function (l) { return l.notifyGridChanged(_this.showGrid, _this.gridSize); });
}
},
enumerable: true,
configurable: true
});
Object.defineProperty(DiagramSettings.prototype, "gridSizeItems", {
get: function () { return this._gridSizeItems; },
set: function (value) {
if (value !== this._gridSizeItems) {
this._gridSizeItems = value;
}
},
enumerable: true,
configurable: true
});
Object.defineProperty(DiagramSettings.prototype, "pageSizeItems", {
get: function () { return this._pageSizeItems; },
set: function (value) {
if (value !== this._pageSizeItems) {
this._pageSizeItems = value;
}
},
enumerable: true,
configurable: true
});
Object.defineProperty(DiagramSettings.prototype, "viewUnits", {
get: function () { return this._viewUnits; },
set: function (value) { this._viewUnits = value; },
enumerable: true,
configurable: true
});
DiagramSettings.correctZoomLevel = function (level) {
return Math.min(10, Math.max(level, 0.01));
};
return DiagramSettings;
}());
exports.DiagramSettings = DiagramSettings;
var AutoZoomMode;
(function (AutoZoomMode) {
AutoZoomMode[AutoZoomMode["Disabled"] = 0] = "Disabled";
AutoZoomMode[AutoZoomMode["FitContent"] = 1] = "FitContent";
AutoZoomMode[AutoZoomMode["FitToWidth"] = 2] = "FitToWidth";
})(AutoZoomMode = exports.AutoZoomMode || (exports.AutoZoomMode = {}));
/***/ }),
/* 36 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangeStyleHistoryItemBase_1 = __webpack_require__(103);
var ChangeStyleTextHistoryItem = /** @class */ (function (_super) {
__extends(ChangeStyleTextHistoryItem, _super);
function ChangeStyleTextHistoryItem(itemKey, styleProperty, styleValue) {
return _super.call(this, itemKey, styleProperty, styleValue) || this;
}
ChangeStyleTextHistoryItem.prototype.redo = function (manipulator) {
var item = manipulator.model.findItem(this.itemKey);
this.oldStyleValue = item.styleText[this.styleProperty];
manipulator.changeStyleText(item, this.styleProperty, this.styleValue);
};
ChangeStyleTextHistoryItem.prototype.undo = function (manipulator) {
var item = manipulator.model.findItem(this.itemKey);
manipulator.changeStyleText(item, this.styleProperty, this.oldStyleValue);
};
return ChangeStyleTextHistoryItem;
}(ChangeStyleHistoryItemBase_1.ChangeStyleHistoryItemBase));
exports.ChangeStyleTextHistoryItem = ChangeStyleTextHistoryItem;
/***/ }),
/* 37 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var Connector_1 = __webpack_require__(5);
var AddConnectionHistoryItem = /** @class */ (function (_super) {
__extends(AddConnectionHistoryItem, _super);
function AddConnectionHistoryItem(connector, item, connectionPointIndex, position) {
var _this = _super.call(this) || this;
_this.connectorKey = connector.key;
_this.itemKey = item.key;
_this.connectionPointIndex = connectionPointIndex;
_this.position = position;
return _this;
}
AddConnectionHistoryItem.prototype.redo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
var item = manipulator.model.findItem(this.itemKey);
manipulator.addConnection(connector, item, this.connectionPointIndex, this.position);
};
AddConnectionHistoryItem.prototype.undo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
manipulator.deleteConnection(connector, this.position);
};
return AddConnectionHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.AddConnectionHistoryItem = AddConnectionHistoryItem;
var SetConnectionPointIndexHistoryItem = /** @class */ (function (_super) {
__extends(SetConnectionPointIndexHistoryItem, _super);
function SetConnectionPointIndexHistoryItem(connector, connectionPointIndex, position) {
var _this = _super.call(this) || this;
_this.connectorKey = connector.key;
_this.connectionPointIndex = connectionPointIndex;
_this.position = position;
return _this;
}
SetConnectionPointIndexHistoryItem.prototype.redo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
this.oldConnectionPointIndex = this.position === Connector_1.ConnectorPosition.Begin ? connector.beginConnectionPointIndex : connector.endConnectionPointIndex;
manipulator.setConnectionPointIndex(connector, this.connectionPointIndex, this.position);
};
SetConnectionPointIndexHistoryItem.prototype.undo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
manipulator.setConnectionPointIndex(connector, this.oldConnectionPointIndex, this.position);
};
return SetConnectionPointIndexHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.SetConnectionPointIndexHistoryItem = SetConnectionPointIndexHistoryItem;
/***/ }),
/* 38 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var StringUtils_1 = __webpack_require__(131);
var ColorHelper = /** @class */ (function () {
function ColorHelper() {
}
ColorHelper.constructFromArgbNumber = function (alpha, red, green, blue) {
return (alpha << 24) | (red << 16) | (green << 8) | blue;
};
ColorHelper.getPredefinedColor = function (color) {
return ColorHelper.hashToColor(color, 0);
};
ColorHelper.isGray = function (color) {
var red = ColorHelper.getRed(color);
return red == ColorHelper.getGreen(color) && red == ColorHelper.getBlue(color);
};
ColorHelper.getAlpha = function (color) {
return (color >> 24) & 255;
};
ColorHelper.getRed = function (color) {
return (color >> 16) & 255;
};
ColorHelper.getGreen = function (color) {
return (color >> 8) & 255;
};
ColorHelper.getBlue = function (color) {
return color & 255;
};
ColorHelper.redPartToString = function (color) {
var redStr = ColorHelper.getRed(color).toString(16);
return redStr.length > 1 ? redStr : "0" + redStr;
};
ColorHelper.greenPartToString = function (color) {
var greenStr = ColorHelper.getGreen(color).toString(16);
return greenStr.length > 1 ? greenStr : "0" + greenStr;
};
ColorHelper.bluePartToString = function (color) {
var blueStr = ColorHelper.getBlue(color).toString(16);
return blueStr.length > 1 ? blueStr : "0" + blueStr;
};
ColorHelper.colorToHash = function (color) {
return "#" + ColorHelper.redPartToString(color) + ColorHelper.greenPartToString(color) + ColorHelper.bluePartToString(color);
};
// static anyToColor(value: any, defaultValue: number): number {
// if (typeof value === "number" && !isNaN(value))
// return value;
// if (typeof value === "string") {
// var intValue = parseInt(value);
// return !isNaN(intValue) && value == <any>intValue ? intValue : ColorHelper.hashToColor(value);
// }
// return defaultValue;
// }
ColorHelper.hashToColor = function (hash, alpha) {
if (alpha === void 0) { alpha = 255; }
hash = hash.charAt(0) == "#" ? hash.substr(1) : hash;
if (hash.length === 3)
hash = StringUtils_1.StringUtils.repeat(hash.charAt(0), 2) + StringUtils_1.StringUtils.repeat(hash.charAt(1), 2) + StringUtils_1.StringUtils.repeat(hash.charAt(2), 2);
return parseInt(hash, 16) | (alpha << 24);
};
ColorHelper.getActualForeColor = function (foreColor, backColor) {
if (foreColor == ColorHelper.AUTOMATIC_COLOR) {
var backColorIsLight = backColor == ColorHelper.AUTOMATIC_COLOR ||
backColor == ColorHelper.NO_COLOR ||
ColorHelper.calculateLumaY(backColor) >= ColorHelper.DEFAULT_BOUNDARY_LUMA;
foreColor = backColorIsLight ? ColorHelper.DARK_COLOR : ColorHelper.LIGHT_COLOR;
}
return ColorHelper.getCssString(foreColor, true);
};
ColorHelper.getCssString = function (color, isAutoColorTranslateToDark) {
if (color == ColorHelper.AUTOMATIC_COLOR)
return ColorHelper.colorToHash(isAutoColorTranslateToDark ? ColorHelper.DARK_COLOR : ColorHelper.LIGHT_COLOR);
return ColorHelper.getCssStringInternal(color);
};
ColorHelper.stringToHash = function (color) {
return this.colorToHash(this.stringToColor(color));
};
ColorHelper.stringToColor = function (color) {
var foreColorMatchesRGB = this.getRGBAByString(color);
var hashColor = "";
if (foreColorMatchesRGB) {
return ((foreColorMatchesRGB[0] & 255) << 16) | ((foreColorMatchesRGB[1] & 255) << 8) | (foreColorMatchesRGB[2] & 255) |
(((foreColorMatchesRGB.length > 3 ? foreColorMatchesRGB[3] : 255) & 255) << 24);
}
else {
if (/^#([0-9a-f]{6})$/i.test(color) || /^#([0-9a-f]{3})$/i.test(color))
hashColor = color;
else if (/^[a-z]+$/i.test(color))
hashColor = ColorHelper.colorNames[color.toLowerCase()];
}
if (hashColor)
return ColorHelper.hashToColor(hashColor);
return null;
};
ColorHelper.getRGBAByString = function (color) {
var matchesRGBA = color.replace(/ +/g, '').match(/(rgba?)|(\d+(\.\d+)?%?)|(\.\d+)/g);
if (matchesRGBA && matchesRGBA.length > 3) {
var i = 0, itm;
var result = [];
while (i < matchesRGBA.length - 1) {
itm = matchesRGBA[++i];
if (itm.indexOf('%') != -1)
itm = Math.round(parseFloat(itm) * 2.55);
else
itm = parseInt(itm);
if (itm < 0 || itm > 255)
return null;
result.push(itm);
}
if (color.indexOf('rgba') === 0) {
if (isNaN(result[3]) || result[3] < 0 || result[3] > 1)
return null;
else if (result[3] <= 1)
result[3] = Math.round(result[3] * 255);
}
else if (result[3])
return null;
return result;
}
return null;
};
ColorHelper.IsDarkColor = function (color) {
return ColorHelper.calculateLumaY(color) < ColorHelper.DEFAULT_BOUNDARY_LUMA;
};
ColorHelper.getCssStringInternal = function (color) {
var alpfa = ColorHelper.getAlpha(color);
switch (alpfa) {
case 0: return "transparent";
case 255: return ColorHelper.colorToHash(color);
default: return "rgba(" + ColorHelper.getRed(color) + "," + ColorHelper.getGreen(color) + "," + ColorHelper.getBlue(color) + "," + (alpfa / 255) + ")";
}
};
ColorHelper.isEmptyBgColor = function (color) {
return color === this.AUTOMATIC_COLOR || color === this.NO_COLOR;
};
ColorHelper.calculateLumaY = function (color) {
//ITU 601:
//Y' = 0.299 * R + 0.587 * G + 0.114 * B
//Word boundary: 60.762 (possible not very accurate). All tests based on MSWord results
//y = Y' * 65536
return ColorHelper.DEFAULT_BOUNDARY_LUMA_RED * ColorHelper.getRed(color) +
ColorHelper.DEFAULT_BOUNDARY_LUMA_GREEN * ColorHelper.getGreen(color) +
ColorHelper.DEFAULT_BOUNDARY_LUMA_BLUE * ColorHelper.getBlue(color);
};
ColorHelper.colorNames = {
aliceblue: '#f0f8ff', antiquewhite: '#faebd7', aqua: '#00ffff',
aquamarine: '#7fffd4', azure: '#f0ffff', beige: '#f5f5dc',
bisque: '#ffe4c4', black: '#000000', blanchedalmond: '#ffebcd',
blue: '#0000ff', blueviolet: '#8a2be2', brown: '#a52a2a',
burlywood: '#deb887', cadetblue: '#5f9ea0', chartreuse: '#7fff00',
chocolate: '#d2691e', coral: '#ff7f50', cornflowerblue: '#6495ed',
cornsilk: '#fff8dc', crimson: '#dc143c', cyan: '#00ffff',
darkblue: '#00008b', darkcyan: '#008b8b', darkgoldenrod: '#b8860b',
darkgray: '#a9a9a9', darkgreen: '#006400', darkkhaki: '#bdb76b',
darkmagenta: '#8b008b', darkolivegreen: '#556b2f', darkorange: '#ff8c00',
darkorchid: '#9932cc', darkred: '#8b0000', darksalmon: '#e9967a',
darkseagreen: '#8fbc8f', darkslateblue: '#483d8b', darkslategray: '#2f4f4f',
darkturquoise: '#00ced1', darkviolet: '#9400d3', deeppink: '#ff1493',
deepskyblue: '#00bfff', dimgray: '#696969', dodgerblue: '#1e90ff',
feldspar: '#d19275', firebrick: '#b22222', floralwhite: '#fffaf0',
forestgreen: '#228b22', fuchsia: '#ff00ff', gainsboro: '#dcdcdc',
ghostwhite: '#f8f8ff', gold: '#ffd700', goldenrod: '#daa520', gray: '#808080',
green: '#00ff00', /* in winFroms green = 008000 */ greenyellow: '#adff2f', honeydew: '#f0fff0', hotpink: '#ff69b4',
indianred: '#cd5c5c', indigo: '#4b0082', ivory: '#fffff0', khaki: '#f0e68c',
lavender: '#e6e6fa', lavenderblush: '#fff0f5', lawngreen: '#7cfc00',
lemonchiffon: '#fffacd', lightblue: '#add8e6', lightcoral: '#f08080',
lightcyan: '#e0ffff', lightgoldenrodyellow: '#fafad2', lightgray: '#d3d3d3',
lightgreen: '#90ee90', lightpink: '#ffb6c1', lightsalmon: '#ffa07a',
lightseagreen: '#20b2aa', lightskyblue: '#87cefa', lightslateblue: '#8470ff',
lightslategray: '#778899', lightsteelblue: '#b0c4de', lightyellow: '#ffffe0',
lime: '#00ff00', limegreen: '#32cd32', linen: '#faf0e6', magenta: '#ff00ff',
maroon: '#800000', mediumaquamarine: '#66cdaa', mediumblue: '#0000cd',
mediumorchid: '#ba55d3', mediumpurple: '#9370d8', mediumseagreen: '#3cb371',
mediumslateblue: '#7b68ee', mediumspringgreen: '#00fa9a', mediumturquoise: '#48d1cc',
mediumvioletred: '#c71585', midnightblue: '#191970', mintcream: '#f5fffa',
mistyrose: '#ffe4e1', moccasin: '#ffe4b5', navajowhite: '#ffdead', navy: '#000080',
oldlace: '#fdf5e6', olive: '#808000', olivedrab: '#6b8e23', orange: '#ffa500',
orangered: '#ff4500', orchid: '#da70d6', palegoldenrod: '#eee8aa', palegreen: '#98fb98',
paleturquoise: '#afeeee', palevioletred: '#d87093', papayawhip: '#ffefd5',
peachpuff: '#ffdab9', peru: '#cd853f', pink: '#ffc0cb', plum: '#dda0dd',
powderblue: '#b0e0e6', purple: '#800080', red: '#ff0000', rosybrown: '#bc8f8f',
royalblue: '#4169e1', saddlebrown: '#8b4513', salmon: '#fa8072', sandybrown: '#f4a460',
seagreen: '#2e8b57', seashell: '#fff5ee', sienna: '#a0522d', silver: '#c0c0c0',
skyblue: '#87ceeb', slateblue: '#6a5acd', slategray: '#708090', snow: '#fffafa',
springgreen: '#00ff7f', steelblue: '#4682b4', tan: '#d2b48c', teal: '#008080',
thistle: '#d8bfd8', tomato: '#ff6347', turquoise: '#40e0d0', violet: '#ee82ee',
violetred: '#d02090', wheat: '#f5deb3', white: '#ffffff', whitesmoke: '#f5f5f5',
yellow: '#ffff00', yellowgreen: '#9acd32', windowtext: '#000000'
};
//ITU 601:
//Y' = 0.299 * R + 0.587 * G + 0.114 * B
ColorHelper.DEFAULT_BOUNDARY_LUMA = 60.762 * 65536; // exeprimental value;
ColorHelper.DEFAULT_BOUNDARY_LUMA_RED = 0.299 * 65536;
ColorHelper.DEFAULT_BOUNDARY_LUMA_BLUE = 0.114 * 65536;
ColorHelper.DEFAULT_BOUNDARY_LUMA_GREEN = 0.587 * 65536;
ColorHelper.DARK_COLOR = -16777216; // FFFFFFFFFF000000
ColorHelper.LIGHT_COLOR = -1; // FFFFFFFFFFFFFFFF
ColorHelper.BLACK_COLOR = -16777216; // FFFFFFFFFF000000 // todo delete
// here need get color, that different from back color. (back color that table, paragraph, box back colors)
ColorHelper.AUTOMATIC_COLOR = 0; // for text color, text strikeout, text underline. Character back color don't affect fore color, bot paragraph - affect
ColorHelper.NO_COLOR = 16777215; // 00000000FFFFFF for back color
return ColorHelper;
}());
exports.ColorHelper = ColorHelper;
/***/ }),
/* 39 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Browser_1 = __webpack_require__(23);
var TouchUIHelper_1 = __webpack_require__(62);
var Base_1 = __webpack_require__(17);
var Evt = /** @class */ (function () {
function Evt() {
}
Evt.GetEvent = function (evt) {
return (typeof (event) != "undefined" && event != null && Browser_1.Browser.IE) ? event : evt;
};
Evt.AttachEventToElement = function (element, eventName, handler, onlyBubbling) {
if (onlyBubbling === void 0) { onlyBubbling = false; }
if (element.addEventListener)
element.addEventListener(eventName, handler, !onlyBubbling);
else
element.attachEvent("on" + eventName, handler);
};
Evt.AttachEventToDocument = function (eventName, handler) {
var attachingAllowed = TouchUIHelper_1.TouchUIHelper.onEventAttachingToDocument(eventName, handler);
if (attachingAllowed)
Evt.AttachEventToElement(document, eventName, handler);
};
Evt.PreventEvent = function (evt) {
if (evt.preventDefault)
evt.preventDefault();
else
evt.returnValue = false;
return false;
};
Evt.GetKeyCode = function (evt) {
return Browser_1.Browser.NetscapeFamily || Browser_1.Browser.Opera ? evt.which : evt.keyCode;
};
Evt.GetEventSource = function (evt, findByPosition) {
if (!Base_1.IsExists(evt))
return null;
if (findByPosition && document.elementFromPoint && Evt.GetEventX(evt) !== undefined && Evt.GetEventY(evt) !== undefined)
return document.elementFromPoint(Evt.GetEventX(evt), Evt.GetEventY(evt));
return evt.srcElement ? evt.srcElement : evt.target;
};
Evt.GetMouseWheelEventName = function () {
if (Browser_1.Browser.Safari)
return "mousewheel";
if (Browser_1.Browser.NetscapeFamily && Browser_1.Browser.MajorVersion < 17)
return "DOMMouseScroll";
return "wheel";
};
Evt.IsLeftButtonPressed = function (evt) {
if (TouchUIHelper_1.TouchUIHelper.isTouchEvent(evt))
return true;
evt = Evt.GetEvent(evt);
if (!evt)
return false;
if (Browser_1.Browser.IE && Browser_1.Browser.Version < 11) {
if (Browser_1.Browser.MSTouchUI)
return true;
return evt.button % 2 == 1; // B213431
}
else if (Browser_1.Browser.WebKitFamily) {
if (evt.type === "pointermove")
return evt.buttons === 1;
return evt.which == 1;
}
else if (Browser_1.Browser.NetscapeFamily || Browser_1.Browser.Edge || (Browser_1.Browser.IE && Browser_1.Browser.Version >= 11)) {
if (evt.type === TouchUIHelper_1.TouchUIHelper.touchMouseMoveEventName)
return evt.buttons === 1;
return evt.which == 1;
}
else if (Browser_1.Browser.Opera)
return evt.button == 0;
return true;
};
Evt.PreventEventAndBubble = function (evt) {
Evt.PreventEvent(evt);
if (evt.stopPropagation)
evt.stopPropagation();
evt.cancelBubble = true;
return false;
};
Evt.clientEventRequiresDocScrollCorrection = function () {
var isSafariVerLess3 = Browser_1.Browser.Safari && Browser_1.Browser.Version < 3, isMacOSMobileVerLess51 = Browser_1.Browser.MacOSMobilePlatform && Browser_1.Browser.Version < 5.1;
return Browser_1.Browser.AndroidDefaultBrowser || Browser_1.Browser.AndroidChromeBrowser || !(isSafariVerLess3 || isMacOSMobileVerLess51);
};
Evt.GetEventX = function (evt) {
if (TouchUIHelper_1.TouchUIHelper.isTouchEvent(evt))
return TouchUIHelper_1.TouchUIHelper.getEventX(evt);
return evt.clientX + (Evt.clientEventRequiresDocScrollCorrection() ? Base_1.GetDocumentScrollLeft() : 0);
};
Evt.GetEventY = function (evt) {
if (TouchUIHelper_1.TouchUIHelper.isTouchEvent(evt))
return TouchUIHelper_1.TouchUIHelper.getEventY(evt);
return evt.clientY + (Evt.clientEventRequiresDocScrollCorrection() ? Base_1.GetDocumentScrollTop() : 0);
};
Evt.CancelBubble = function (evt) {
evt.cancelBubble = true;
return false;
};
return Evt;
}());
exports.Evt = Evt;
/***/ }),
/* 40 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Base64_1 = __webpack_require__(86);
var ImageInfo = /** @class */ (function () {
function ImageInfo(imageUrlOrBase64) {
this.url = undefined;
this.base64 = undefined;
if (imageUrlOrBase64) {
if (Base64_1.Base64Utils.checkPrependDataUrl(imageUrlOrBase64))
this.base64 = imageUrlOrBase64;
else
this.url = imageUrlOrBase64;
}
this.loadFailed = false;
}
ImageInfo.prototype.clone = function () {
var result = new ImageInfo();
result.url = this.url;
result.base64 = this.base64;
return result;
};
Object.defineProperty(ImageInfo.prototype, "isEmpty", {
get: function () { return this.url === undefined && this.base64 === undefined; },
enumerable: true,
configurable: true
});
Object.defineProperty(ImageInfo.prototype, "unableToLoad", {
get: function () { return this.loadFailed; },
enumerable: true,
configurable: true
});
Object.defineProperty(ImageInfo.prototype, "renderUrl", {
get: function () { return this.base64 || ""; },
enumerable: true,
configurable: true
});
Object.defineProperty(ImageInfo.prototype, "exportUrl", {
get: function () { return this.base64 ? this.base64 : this.url; },
enumerable: true,
configurable: true
});
Object.defineProperty(ImageInfo, "transparentOnePixelImage", {
get: function () { return this.transparentWhiteImage1_1; },
enumerable: true,
configurable: true
});
ImageInfo.prototype.loadBase64Content = function (base64Content) {
this.base64 = Base64_1.Base64Utils.normalize(base64Content);
};
ImageInfo.prototype.setUnableToLoadFlag = function () {
this.loadFailed = true;
};
ImageInfo.transparentWhiteImage1_1 = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAANSURBVBhXY/j///9/AAn7A/0FQ0XKAAAAAElFTkSuQmCC';
return ImageInfo;
}());
exports.ImageInfo = ImageInfo;
/***/ }),
/* 41 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RenderManager_1 = __webpack_require__(12);
var Primitive_1 = __webpack_require__(18);
var ClipPathPrimitive = /** @class */ (function (_super) {
__extends(ClipPathPrimitive, _super);
function ClipPathPrimitive(id, children) {
var _this = _super.call(this) || this;
_this.id = id;
_this.children = children;
return _this;
}
ClipPathPrimitive.prototype.createMainElement = function () {
return document.createElementNS(RenderManager_1.svgNS, "clipPath");
};
ClipPathPrimitive.prototype.applyElementProperties = function (element) {
if (this.id)
element.setAttribute("id", this.id);
_super.prototype.applyElementProperties.call(this, element);
};
return ClipPathPrimitive;
}(Primitive_1.SvgPrimitive));
exports.ClipPathPrimitive = ClipPathPrimitive;
/***/ }),
/* 42 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RenderManager_1 = __webpack_require__(12);
var Primitive_1 = __webpack_require__(18);
var EllipsePrimitive = /** @class */ (function (_super) {
__extends(EllipsePrimitive, _super);
function EllipsePrimitive(cx, cy, rx, ry, style, className) {
var _this = _super.call(this, style, className) || this;
_this.cx = cx;
_this.cy = cy;
_this.rx = rx;
_this.ry = ry;
return _this;
}
EllipsePrimitive.prototype.createMainElement = function () {
return document.createElementNS(RenderManager_1.svgNS, "ellipse");
};
EllipsePrimitive.prototype.applyElementProperties = function (element) {
this.setUnitAttribute(element, "cx", this.cx);
this.setUnitAttribute(element, "cy", this.cy);
this.setUnitAttribute(element, "rx", this.rx);
this.setUnitAttribute(element, "ry", this.ry);
_super.prototype.applyElementProperties.call(this, element);
};
return EllipsePrimitive;
}(Primitive_1.SvgPrimitive));
exports.EllipsePrimitive = EllipsePrimitive;
/***/ }),
/* 43 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var DiagramItem_1 = __webpack_require__(4);
var Connector_1 = __webpack_require__(5);
var ConnectorPointsOrthogonalSideCalculatorBase = /** @class */ (function () {
function ConnectorPointsOrthogonalSideCalculatorBase(parent) {
this.parent = parent;
}
Object.defineProperty(ConnectorPointsOrthogonalSideCalculatorBase.prototype, "connector", {
get: function () { return this.parent.connector; },
enumerable: true,
configurable: true
});
Object.defineProperty(ConnectorPointsOrthogonalSideCalculatorBase.prototype, "beginRect", {
get: function () { return this.parent.beginRect; },
enumerable: true,
configurable: true
});
Object.defineProperty(ConnectorPointsOrthogonalSideCalculatorBase.prototype, "endRect", {
get: function () { return this.parent.endRect; },
enumerable: true,
configurable: true
});
ConnectorPointsOrthogonalSideCalculatorBase.prototype.getBeginOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
originPoint = this.getCorrectOriginPoint(originPoint, originRect);
if (targetSide !== DiagramItem_1.ConnectionPointSide.Undefined) {
if (this.isBeginEndSame())
return this.getSameShapeOffsetPoints(targetSide, originPoint, targetPoint, originRect);
else if (this.isBeginEndOverlappedPoints(originPoint, targetPoint))
return this.getOverlappedPointsOffsetPoints(targetSide, originPoint, targetPoint, originRect);
else if (this.isBeginEndOverlapped())
return this.getBeginOverlappedShapeOffsetPoints(targetSide, originPoint, targetPoint, originRect);
}
else if (this.isOriginRectContainsTargetPoint(originRect, targetPoint))
return this.getOverlappedPointsOffsetPoints(targetSide, originPoint, targetPoint, originRect);
if (this.isOnSidePoint(originPoint, targetPoint))
return this.getBeginOnSideOffsetPoints(targetSide, originPoint, targetPoint, originRect);
return this.getBeginOffSideOffsetPoints(targetSide, originPoint, targetPoint, originRect);
};
ConnectorPointsOrthogonalSideCalculatorBase.prototype.getEndOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
originPoint = this.getCorrectOriginPoint(originPoint, originRect);
if (targetSide !== DiagramItem_1.ConnectionPointSide.Undefined) {
if (this.isBeginEndSame())
return this.getSameShapeOffsetPoints(targetSide, originPoint, targetPoint, originRect);
else if (this.isBeginEndOverlappedPoints(targetPoint, originPoint))
return this.getOverlappedPointsOffsetPoints(targetSide, originPoint, targetPoint, originRect);
else if (this.isBeginEndOverlapped())
return this.getEndOverlappedShapeOffsetPoints(targetSide, originPoint, targetPoint, originRect);
}
else if (this.isOriginRectContainsTargetPoint(originRect, targetPoint))
return this.getOverlappedPointsOffsetPoints(targetSide, originPoint, targetPoint, originRect);
if (this.isOnSidePoint(originPoint, targetPoint))
return this.getEndOnSideOffsetPoints(targetSide, originPoint, targetPoint, originRect);
return this.getEndOffSideOffsetPoints(targetSide, originPoint, targetPoint, originRect);
};
ConnectorPointsOrthogonalSideCalculatorBase.prototype.getSide = function (originPoint, targetPoint) {
var diffX = Math.abs(targetPoint.x - originPoint.x);
var diffY = Math.abs(targetPoint.y - originPoint.y);
if (diffX > diffY) {
if (targetPoint.x > originPoint.x)
return DiagramItem_1.ConnectionPointSide.East;
else
return DiagramItem_1.ConnectionPointSide.West;
}
else {
if (targetPoint.y > originPoint.y)
return DiagramItem_1.ConnectionPointSide.South;
else
return DiagramItem_1.ConnectionPointSide.North;
}
};
ConnectorPointsOrthogonalSideCalculatorBase.prototype.getSideCalculator = function (originPoint, targetPoint) {
return this.parent.getSideCalculator(this.getSide(originPoint, targetPoint));
};
ConnectorPointsOrthogonalSideCalculatorBase.prototype.getMinOffset = function () {
return Connector_1.Connector.minOffset;
};
ConnectorPointsOrthogonalSideCalculatorBase.prototype.isBeginEndSame = function () {
return this.connector.beginItem === this.connector.endItem;
};
ConnectorPointsOrthogonalSideCalculatorBase.prototype.isBeginEndOverlapped = function () {
return this.beginRect && this.endRect && this.beginRect.intersect(this.endRect);
};
ConnectorPointsOrthogonalSideCalculatorBase.prototype.isBeginEndOverlappedX = function () {
return this.beginRect && this.endRect && this.beginRect.intersectX(this.endRect);
};
ConnectorPointsOrthogonalSideCalculatorBase.prototype.isBeginEndOverlappedY = function () {
return this.beginRect && this.endRect && this.beginRect.intersectY(this.endRect);
};
ConnectorPointsOrthogonalSideCalculatorBase.prototype.isBeginEndOverlappedPoints = function (beginPoint, endPoint) {
return this.beginRect && this.endRect && (this.beginRect.contains(endPoint) || this.endRect.contains(beginPoint));
};
ConnectorPointsOrthogonalSideCalculatorBase.prototype.isOriginRectContainsTargetPoint = function (originRect, targetPoint) {
return originRect && originRect.contains(targetPoint);
};
return ConnectorPointsOrthogonalSideCalculatorBase;
}());
exports.ConnectorPointsOrthogonalSideCalculatorBase = ConnectorPointsOrthogonalSideCalculatorBase;
/***/ }),
/* 44 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var SetSelectionHistoryItem = /** @class */ (function (_super) {
__extends(SetSelectionHistoryItem, _super);
function SetSelectionHistoryItem(selection, selectedKeys) {
var _this = _super.call(this) || this;
_this.selectedKeys = selectedKeys;
_this.selection = selection;
return _this;
}
SetSelectionHistoryItem.prototype.redo = function () {
this.oldSelection = this.selection.getKeys().slice(0);
this.selection.set(this.selectedKeys);
};
SetSelectionHistoryItem.prototype.undo = function () {
this.selection.set(this.oldSelection);
};
return SetSelectionHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.SetSelectionHistoryItem = SetSelectionHistoryItem;
/***/ }),
/* 45 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeDescription_1 = __webpack_require__(9);
var Utils_1 = __webpack_require__(0);
var UnitConverter_1 = __webpack_require__(13);
var ImagePrimitive_1 = __webpack_require__(98);
var RectaglePrimitive_1 = __webpack_require__(20);
var GroupPrimitive_1 = __webpack_require__(28);
var Utils_2 = __webpack_require__(15);
var ClipPathPrimitive_1 = __webpack_require__(41);
var ShapeImageIndicator_1 = __webpack_require__(99);
exports.ShapeDefaultDimension = 1440;
exports.ShapeDefaultSize = new Utils_1.Size(exports.ShapeDefaultDimension, exports.ShapeDefaultDimension);
exports.SHAPE_IMAGE_CLASSNAMES = {
IMAGE: "dxdi-image",
IMAGE_PLACEHOLDER: "dxdi-image-placeholder",
LOADING_INDICATOR: "dxdi-spinner",
USER_PIC: "dxdi-user",
WARNING_MARK: "dxdi-warning"
};
var ShapeWithImageDescription = /** @class */ (function (_super) {
__extends(ShapeWithImageDescription, _super);
function ShapeWithImageDescription(title, defaultText, defaultSize, defaultImageUrl) {
if (defaultSize === void 0) { defaultSize = exports.ShapeDefaultSize.clone(); }
var _this = _super.call(this, title, defaultText, defaultSize, defaultImageUrl) || this;
_this.title = title;
_this.defaultText = defaultText;
_this.defaultSize = defaultSize;
_this.defaultImageUrl = defaultImageUrl;
_this.defaultIconSize = 480;
return _this;
}
Object.defineProperty(ShapeWithImageDescription.prototype, "enableImage", {
get: function () { return true; },
enumerable: true,
configurable: true
});
ShapeWithImageDescription.getImageMargins = function (forToolbox) {
return UnitConverter_1.UnitConverter.pixelsToTwips(3);
};
ShapeWithImageDescription.prototype.createImagePrimitives = function (shape, forToolbox) {
if (!this.enableImage)
return [];
var rect = this.getImagePlacementRectangle(shape.rectangle, forToolbox);
if (forToolbox)
return this.createImagePlaceholder(rect);
var imagePrimitives = [];
if (shape.image.isEmpty || shape.image.unableToLoad)
imagePrimitives = imagePrimitives.concat(this.createEmptyImagePrimitives(rect, shape.image.unableToLoad));
else if (shape.image.renderUrl === "")
imagePrimitives = imagePrimitives.concat(this.createLoadingImagePrimitives(rect));
else
imagePrimitives = imagePrimitives.concat(this.createLoadedImagePrimitives(rect, shape.image.renderUrl));
if (shape.image.renderUrl === "") {
var clipPathId = Utils_2.RenderUtils.generateSvgElementId("clipImage");
return [
new GroupPrimitive_1.GroupPrimitive(imagePrimitives, exports.SHAPE_IMAGE_CLASSNAMES.IMAGE, undefined, clipPathId),
new ClipPathPrimitive_1.ClipPathPrimitive(clipPathId, [new RectaglePrimitive_1.RectanglePrimitive(rect.left, rect.top, rect.width, rect.height)])
];
}
else
return imagePrimitives;
};
ShapeWithImageDescription.prototype.createImagePlaceholder = function (rect) {
return [];
};
ShapeWithImageDescription.prototype.createLoadedImagePrimitives = function (rect, imageUrl) {
return [
new ImagePrimitive_1.ImagePrimitive(rect.left, rect.top, rect.width, rect.height, imageUrl, ShapeWithImageDescription.imageScalingRule, undefined, exports.SHAPE_IMAGE_CLASSNAMES.IMAGE)
];
};
ShapeWithImageDescription.prototype.createLoadingImagePrimitives = function (rect) {
var loadingRect = this.getIconPlacementRectangle(rect);
return [
ShapeImageIndicator_1.ShapeImageIndicator.createLoadingIndicatorPrimitives(loadingRect.left, loadingRect.top, this.defaultIconSize, UnitConverter_1.UnitConverter.pixelsToTwips(5), exports.SHAPE_IMAGE_CLASSNAMES.LOADING_INDICATOR)
];
};
ShapeWithImageDescription.prototype.createEmptyImagePrimitives = function (rect, showWarning) {
var loadingRect = this.getIconPlacementRectangle(rect);
var primitives = [];
primitives = primitives.concat(this.createEmptyImagePrimitive(loadingRect));
if (showWarning)
primitives = primitives.concat(this.createWarningPrimitive(loadingRect));
return primitives;
};
ShapeWithImageDescription.prototype.createEmptyImagePrimitive = function (rect) {
return new GroupPrimitive_1.GroupPrimitive([]);
};
ShapeWithImageDescription.prototype.createWarningPrimitive = function (rect) {
return new GroupPrimitive_1.GroupPrimitive([]);
};
ShapeWithImageDescription.prototype.getIconPlacementRectangle = function (rect) {
var iconRect = new Utils_1.Rectangle(new Utils_1.Point(rect.left, rect.top), new Utils_1.Size(this.defaultIconSize, this.defaultIconSize));
if (iconRect.width < rect.width)
iconRect.position.x = rect.left + (rect.width - iconRect.width) / 2;
if (iconRect.height < rect.height)
iconRect.position.y = rect.top + (rect.height - iconRect.height) / 2;
return iconRect;
};
ShapeWithImageDescription.prototype.getImagePlacementRectangle = function (rect, forToolbox) {
var imageSize = this.getImageSize(rect, forToolbox);
var imageRectangle = Utils_1.Rectangle.create(rect.left, rect.top, imageSize.width, imageSize.height);
var textBlockOffset = this.getTextBlockOffset(rect, forToolbox);
if (textBlockOffset.right > 0)
imageRectangle.position.x = rect.right - textBlockOffset.right - ShapeWithImageDescription.getImageMargins(forToolbox);
else if (textBlockOffset.left > 0)
imageRectangle.position.x += ShapeWithImageDescription.getImageMargins(forToolbox);
if (textBlockOffset.bottom > 0)
imageRectangle.position.y = rect.bottom - textBlockOffset.bottom - ShapeWithImageDescription.getImageMargins(forToolbox);
else
imageRectangle.position.y += ShapeWithImageDescription.getImageMargins(forToolbox);
if (textBlockOffset.top > 0 || textBlockOffset.bottom > 0)
imageRectangle.position.x = imageRectangle.left + (rect.width - imageRectangle.width) / 2;
return imageRectangle;
};
ShapeWithImageDescription.prototype.getImageSize = function (rect, forToolbox) {
var imageSize = this.getRawImageSize(rect, forToolbox);
return this.correctImageSize(imageSize);
};
ShapeWithImageDescription.prototype.getRawImageSize = function (rect, forToolbox) {
return new Utils_1.Size(0, 0);
};
ShapeWithImageDescription.prototype.correctImageSize = function (imageSize) {
imageSize.width = Math.max(imageSize.width, 0);
imageSize.height = Math.max(imageSize.height, 0);
return imageSize;
};
ShapeWithImageDescription.prototype.getTextBlockOffset = function (rect, forToolbox) {
return Utils_1.Offset.empty();
};
ShapeWithImageDescription.imageScalingRule = "xMidYMid meet";
return ShapeWithImageDescription;
}(ShapeDescription_1.ShapeDescription));
exports.ShapeWithImageDescription = ShapeWithImageDescription;
/***/ }),
/* 46 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangeStyleHistoryItemBase_1 = __webpack_require__(103);
var ChangeStyleHistoryItem = /** @class */ (function (_super) {
__extends(ChangeStyleHistoryItem, _super);
function ChangeStyleHistoryItem(itemKey, styleProperty, styleValue) {
return _super.call(this, itemKey, styleProperty, styleValue) || this;
}
ChangeStyleHistoryItem.prototype.redo = function (manipulator) {
var item = manipulator.model.findItem(this.itemKey);
this.oldStyleValue = item.style[this.styleProperty];
manipulator.changeStyle(item, this.styleProperty, this.styleValue);
};
ChangeStyleHistoryItem.prototype.undo = function (manipulator) {
var item = manipulator.model.findItem(this.itemKey);
manipulator.changeStyle(item, this.styleProperty, this.oldStyleValue);
};
return ChangeStyleHistoryItem;
}(ChangeStyleHistoryItemBase_1.ChangeStyleHistoryItemBase));
exports.ChangeStyleHistoryItem = ChangeStyleHistoryItem;
/***/ }),
/* 47 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var SimpleCommandBase_1 = __webpack_require__(7);
var ExportImportCommandBase = /** @class */ (function (_super) {
__extends(ExportImportCommandBase, _super);
function ExportImportCommandBase() {
return _super !== null && _super.apply(this, arguments) || this;
}
ExportImportCommandBase.prototype.isEnabledInReadOnlyMode = function () {
return true;
};
return ExportImportCommandBase;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.ExportImportCommandBase = ExportImportCommandBase;
/***/ }),
/* 48 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var DeleteCommand_1 = __webpack_require__(129);
var UndoCommand_1 = __webpack_require__(198);
var RedoCommand_1 = __webpack_require__(199);
var ImportCommand_1 = __webpack_require__(200);
var ExportCommand_1 = __webpack_require__(201);
var ToggleFontBoldCommand_1 = __webpack_require__(202);
var ToggleFontItalicCommand_1 = __webpack_require__(203);
var ToggleFontUnderlineCommand_1 = __webpack_require__(204);
var ChangeFontNameCommand_1 = __webpack_require__(205);
var ChangeFontSizeCommand_1 = __webpack_require__(206);
var ChangeFontColorCommand_1 = __webpack_require__(207);
var ChangeFillColorCommand_1 = __webpack_require__(208);
var ChangeStrokeColorCommand_1 = __webpack_require__(209);
var ChangeTextAlignCommand_1 = __webpack_require__(210);
var ChangeConnectorLineEndingCommand_1 = __webpack_require__(211);
var ChangeConnectorLineOptionCommand_1 = __webpack_require__(212);
var SelectAllCommand_1 = __webpack_require__(213);
var KeyCode_1 = __webpack_require__(16);
var AutoLayoutTreeVerticalCommand_1 = __webpack_require__(214);
var ChangeSnapToGridCommand_1 = __webpack_require__(217);
var ChangeGridSizeCommand_1 = __webpack_require__(218);
var ChangePageLandscapeCommand_1 = __webpack_require__(219);
var ChangePageSizeCommand_1 = __webpack_require__(221);
var ExportPngCommand_1 = __webpack_require__(223);
var ExportSvgCommand_1 = __webpack_require__(225);
var ExportJpgCommand_1 = __webpack_require__(226);
var CopySelectionCommand_1 = __webpack_require__(227);
var CutSelectionCommand_1 = __webpack_require__(228);
var PasteSelectionCommand_1 = __webpack_require__(229);
var ImportBPMNCommand_1 = __webpack_require__(232);
var SendToBackCommand_1 = __webpack_require__(235);
var BringToFrontCommand_1 = __webpack_require__(236);
var AutoLayoutLayeredHorizontalCommand_1 = __webpack_require__(237);
var MoveCommands_1 = __webpack_require__(238);
var ChangeZoomLevelCommand_1 = __webpack_require__(239);
var BindDocumentCommand_1 = __webpack_require__(240);
var UnbindDocumentCommand_1 = __webpack_require__(242);
var AutoLayoutTreeHorizontalCommand_1 = __webpack_require__(243);
var AutoLayoutLayeredVerticalCommand_1 = __webpack_require__(244);
var LockCommand_1 = __webpack_require__(245);
var UnlockCommand_1 = __webpack_require__(246);
var CloneCommand_1 = __webpack_require__(247);
var ChangeUnitsCommand_1 = __webpack_require__(248);
var ChangePageColorCommand_1 = __webpack_require__(250);
var ChangeShowGridCommand_1 = __webpack_require__(252);
var ToggleFullscreenCommand_1 = __webpack_require__(253);
var ToggleSimpleViewCommand_1 = __webpack_require__(254);
var ToggleReadOnlyCommand_1 = __webpack_require__(255);
var EditShapeImageCommand_1 = __webpack_require__(256);
var PasteSelectionInPosition_1 = __webpack_require__(257);
var ImportXMLCommand_1 = __webpack_require__(258);
var InsertShapeImageCommand_1 = __webpack_require__(260);
var DeleteShapeImageCommand_1 = __webpack_require__(261);
var DiagramCommand;
(function (DiagramCommand) {
DiagramCommand[DiagramCommand["Undo"] = 0] = "Undo";
DiagramCommand[DiagramCommand["Redo"] = 1] = "Redo";
DiagramCommand[DiagramCommand["Cut"] = 2] = "Cut";
DiagramCommand[DiagramCommand["Copy"] = 3] = "Copy";
DiagramCommand[DiagramCommand["Paste"] = 4] = "Paste";
DiagramCommand[DiagramCommand["PasteInPosition"] = 5] = "PasteInPosition";
DiagramCommand[DiagramCommand["SelectAll"] = 6] = "SelectAll";
DiagramCommand[DiagramCommand["Delete"] = 7] = "Delete";
DiagramCommand[DiagramCommand["Import"] = 8] = "Import";
DiagramCommand[DiagramCommand["ImportBPMN"] = 9] = "ImportBPMN";
DiagramCommand[DiagramCommand["Export"] = 10] = "Export";
DiagramCommand[DiagramCommand["ExportSvg"] = 11] = "ExportSvg";
DiagramCommand[DiagramCommand["ExportPng"] = 12] = "ExportPng";
DiagramCommand[DiagramCommand["ExportJpg"] = 13] = "ExportJpg";
DiagramCommand[DiagramCommand["BindDocument"] = 14] = "BindDocument";
DiagramCommand[DiagramCommand["UnbindDocument"] = 15] = "UnbindDocument";
DiagramCommand[DiagramCommand["Bold"] = 16] = "Bold";
DiagramCommand[DiagramCommand["Italic"] = 17] = "Italic";
DiagramCommand[DiagramCommand["Underline"] = 18] = "Underline";
DiagramCommand[DiagramCommand["FontName"] = 19] = "FontName";
DiagramCommand[DiagramCommand["FontSize"] = 20] = "FontSize";
DiagramCommand[DiagramCommand["FontColor"] = 21] = "FontColor";
DiagramCommand[DiagramCommand["FillColor"] = 22] = "FillColor";
DiagramCommand[DiagramCommand["StrokeColor"] = 23] = "StrokeColor";
DiagramCommand[DiagramCommand["TextLeftAlign"] = 24] = "TextLeftAlign";
DiagramCommand[DiagramCommand["TextCenterAlign"] = 25] = "TextCenterAlign";
DiagramCommand[DiagramCommand["TextRightAlign"] = 26] = "TextRightAlign";
DiagramCommand[DiagramCommand["ConnectorLineOption"] = 27] = "ConnectorLineOption";
DiagramCommand[DiagramCommand["ConnectorStartLineEnding"] = 28] = "ConnectorStartLineEnding";
DiagramCommand[DiagramCommand["ConnectorEndLineEnding"] = 29] = "ConnectorEndLineEnding";
DiagramCommand[DiagramCommand["BringToFront"] = 30] = "BringToFront";
DiagramCommand[DiagramCommand["SendToBack"] = 31] = "SendToBack";
DiagramCommand[DiagramCommand["MoveLeft"] = 32] = "MoveLeft";
DiagramCommand[DiagramCommand["MoveStepLeft"] = 33] = "MoveStepLeft";
DiagramCommand[DiagramCommand["MoveRight"] = 34] = "MoveRight";
DiagramCommand[DiagramCommand["MoveStepRight"] = 35] = "MoveStepRight";
DiagramCommand[DiagramCommand["MoveUp"] = 36] = "MoveUp";
DiagramCommand[DiagramCommand["MoveStepUp"] = 37] = "MoveStepUp";
DiagramCommand[DiagramCommand["MoveDown"] = 38] = "MoveDown";
DiagramCommand[DiagramCommand["MoveStepDown"] = 39] = "MoveStepDown";
DiagramCommand[DiagramCommand["CloneLeft"] = 40] = "CloneLeft";
DiagramCommand[DiagramCommand["CloneRight"] = 41] = "CloneRight";
DiagramCommand[DiagramCommand["CloneUp"] = 42] = "CloneUp";
DiagramCommand[DiagramCommand["CloneDown"] = 43] = "CloneDown";
DiagramCommand[DiagramCommand["AutoLayoutTree"] = 44] = "AutoLayoutTree";
DiagramCommand[DiagramCommand["AutoLayoutFlow"] = 45] = "AutoLayoutFlow";
DiagramCommand[DiagramCommand["AutoLayoutTreeVertical"] = 46] = "AutoLayoutTreeVertical";
DiagramCommand[DiagramCommand["AutoLayoutTreeHorizontal"] = 47] = "AutoLayoutTreeHorizontal";
DiagramCommand[DiagramCommand["AutoLayoutLayeredVertical"] = 48] = "AutoLayoutLayeredVertical";
DiagramCommand[DiagramCommand["AutoLayoutLayeredHorizontal"] = 49] = "AutoLayoutLayeredHorizontal";
DiagramCommand[DiagramCommand["Lock"] = 50] = "Lock";
DiagramCommand[DiagramCommand["Unlock"] = 51] = "Unlock";
DiagramCommand[DiagramCommand["Units"] = 52] = "Units";
DiagramCommand[DiagramCommand["ViewUnits"] = 53] = "ViewUnits";
DiagramCommand[DiagramCommand["PageSize"] = 54] = "PageSize";
DiagramCommand[DiagramCommand["PageLandscape"] = 55] = "PageLandscape";
DiagramCommand[DiagramCommand["PageColor"] = 56] = "PageColor";
DiagramCommand[DiagramCommand["GridSize"] = 57] = "GridSize";
DiagramCommand[DiagramCommand["ShowGrid"] = 58] = "ShowGrid";
DiagramCommand[DiagramCommand["SnapToGrid"] = 59] = "SnapToGrid";
DiagramCommand[DiagramCommand["ZoomLevel"] = 60] = "ZoomLevel";
DiagramCommand[DiagramCommand["Fullscreen"] = 61] = "Fullscreen";
DiagramCommand[DiagramCommand["ToggleSimpleView"] = 62] = "ToggleSimpleView";
DiagramCommand[DiagramCommand["ToggleReadOnly"] = 63] = "ToggleReadOnly";
DiagramCommand[DiagramCommand["EditShapeImage"] = 64] = "EditShapeImage";
DiagramCommand[DiagramCommand["FitToScreen"] = 65] = "FitToScreen";
DiagramCommand[DiagramCommand["SwitchAutoZoom"] = 66] = "SwitchAutoZoom";
DiagramCommand[DiagramCommand["ToggleAutoZoom"] = 67] = "ToggleAutoZoom";
DiagramCommand[DiagramCommand["FitToWidth"] = 68] = "FitToWidth";
DiagramCommand[DiagramCommand["ZoomLevelItems"] = 69] = "ZoomLevelItems";
DiagramCommand[DiagramCommand["GridSizeItems"] = 70] = "GridSizeItems";
DiagramCommand[DiagramCommand["PageSizeItems"] = 71] = "PageSizeItems";
DiagramCommand[DiagramCommand["ImportXML"] = 72] = "ImportXML";
DiagramCommand[DiagramCommand["InsertShapeImage"] = 73] = "InsertShapeImage";
DiagramCommand[DiagramCommand["DeleteShapeImage"] = 74] = "DeleteShapeImage";
})(DiagramCommand = exports.DiagramCommand || (exports.DiagramCommand = {}));
var CommandManager = /** @class */ (function () {
function CommandManager(control) {
this.commands = {};
this.shortcutsToCommand = {};
this.lastCommandsChain = [];
this.executingCommandsChain = [];
this.executingCommandCounter = 0;
this.isPublicApiCall = false;
this.createCommand(control, DiagramCommand.Undo, UndoCommand_1.UndoCommand, KeyCode_1.ModifierKey.Ctrl | KeyCode_1.KeyCode.Key_z, KeyCode_1.ModifierKey.Meta | KeyCode_1.KeyCode.Key_z);
this.createCommand(control, DiagramCommand.Redo, RedoCommand_1.RedoCommand, KeyCode_1.ModifierKey.Ctrl | KeyCode_1.KeyCode.Key_y, KeyCode_1.ModifierKey.Ctrl | KeyCode_1.ModifierKey.Shift | KeyCode_1.KeyCode.Key_z, KeyCode_1.ModifierKey.Meta | KeyCode_1.ModifierKey.Shift | KeyCode_1.KeyCode.Key_z);
this.createCommand(control, DiagramCommand.Cut, CutSelectionCommand_1.CutSelectionCommand, KeyCode_1.KeyCode.Key_x | KeyCode_1.ModifierKey.Ctrl, KeyCode_1.KeyCode.Key_x | KeyCode_1.ModifierKey.Meta);
this.createCommand(control, DiagramCommand.Copy, CopySelectionCommand_1.CopySelectionCommand, KeyCode_1.KeyCode.Key_c | KeyCode_1.ModifierKey.Ctrl, KeyCode_1.KeyCode.Key_c | KeyCode_1.ModifierKey.Meta);
this.createCommand(control, DiagramCommand.Paste, PasteSelectionCommand_1.PasteSelectionCommand);
this.createCommand(control, DiagramCommand.PasteInPosition, PasteSelectionInPosition_1.PasteSelectionInPositionCommand);
this.createCommand(control, DiagramCommand.SelectAll, SelectAllCommand_1.SelectAllCommand, KeyCode_1.KeyCode.Key_a | KeyCode_1.ModifierKey.Ctrl, KeyCode_1.KeyCode.Key_a | KeyCode_1.ModifierKey.Meta);
this.createCommand(control, DiagramCommand.Delete, DeleteCommand_1.DeleteCommand, KeyCode_1.KeyCode.Delete, KeyCode_1.KeyCode.Backspace);
this.createCommand(control, DiagramCommand.Import, ImportCommand_1.ImportCommand);
this.createCommand(control, DiagramCommand.ImportBPMN, ImportBPMNCommand_1.ImportBPMNCommand);
this.createCommand(control, DiagramCommand.ImportXML, ImportXMLCommand_1.ImportXMLCommand);
this.createCommand(control, DiagramCommand.Export, ExportCommand_1.ExportCommand);
this.createCommand(control, DiagramCommand.ExportSvg, ExportSvgCommand_1.ExportSvgCommand);
this.createCommand(control, DiagramCommand.ExportPng, ExportPngCommand_1.ExportPngCommand);
this.createCommand(control, DiagramCommand.ExportJpg, ExportJpgCommand_1.ExportJpgCommand);
this.createCommand(control, DiagramCommand.BindDocument, BindDocumentCommand_1.BindDocumentCommand);
this.createCommand(control, DiagramCommand.UnbindDocument, UnbindDocumentCommand_1.UnbindDocumentCommand);
this.createCommand(control, DiagramCommand.Bold, ToggleFontBoldCommand_1.ToggleFontBoldCommand, KeyCode_1.ModifierKey.Ctrl | KeyCode_1.KeyCode.Key_b, KeyCode_1.ModifierKey.Meta | KeyCode_1.KeyCode.Key_b);
this.createCommand(control, DiagramCommand.Italic, ToggleFontItalicCommand_1.ToggleFontItalicCommand, KeyCode_1.ModifierKey.Ctrl | KeyCode_1.KeyCode.Key_i, KeyCode_1.ModifierKey.Meta | KeyCode_1.KeyCode.Key_i);
this.createCommand(control, DiagramCommand.Underline, ToggleFontUnderlineCommand_1.ToggleFontUnderlineCommand, KeyCode_1.ModifierKey.Ctrl | KeyCode_1.KeyCode.Key_u, KeyCode_1.ModifierKey.Meta | KeyCode_1.KeyCode.Key_u);
this.createCommand(control, DiagramCommand.FontName, ChangeFontNameCommand_1.ChangeFontNameCommand);
this.createCommand(control, DiagramCommand.FontSize, ChangeFontSizeCommand_1.ChangeFontSizeCommand);
this.createCommand(control, DiagramCommand.FontColor, ChangeFontColorCommand_1.ChangeFontColorCommand);
this.createCommand(control, DiagramCommand.FillColor, ChangeFillColorCommand_1.ChangeFillColorCommand);
this.createCommand(control, DiagramCommand.StrokeColor, ChangeStrokeColorCommand_1.ChangeStrokeColorCommand);
this.createCommand(control, DiagramCommand.TextLeftAlign, ChangeTextAlignCommand_1.TextLeftAlignCommand);
this.createCommand(control, DiagramCommand.TextCenterAlign, ChangeTextAlignCommand_1.TextCenterAlignCommand);
this.createCommand(control, DiagramCommand.TextRightAlign, ChangeTextAlignCommand_1.TextRightAlignCommand);
this.createCommand(control, DiagramCommand.ConnectorLineOption, ChangeConnectorLineOptionCommand_1.ChangeConnectorLineOptionCommand);
this.createCommand(control, DiagramCommand.ConnectorStartLineEnding, ChangeConnectorLineEndingCommand_1.ChangeConnectorStartLineEndingCommand);
this.createCommand(control, DiagramCommand.ConnectorEndLineEnding, ChangeConnectorLineEndingCommand_1.ChangeConnectorEndLineEndingCommand);
this.createCommand(control, DiagramCommand.BringToFront, BringToFrontCommand_1.BringToFrontCommand);
this.createCommand(control, DiagramCommand.SendToBack, SendToBackCommand_1.SendToBackCommand);
this.createCommand(control, DiagramCommand.MoveLeft, MoveCommands_1.MoveLeftCommand, KeyCode_1.ModifierKey.Shift | KeyCode_1.KeyCode.Left);
this.createCommand(control, DiagramCommand.MoveStepLeft, MoveCommands_1.MoveStepLeftCommand, KeyCode_1.KeyCode.Left);
this.createCommand(control, DiagramCommand.MoveRight, MoveCommands_1.MoveRightCommand, KeyCode_1.ModifierKey.Shift | KeyCode_1.KeyCode.Right);
this.createCommand(control, DiagramCommand.MoveStepRight, MoveCommands_1.MoveStepRightCommand, KeyCode_1.KeyCode.Right);
this.createCommand(control, DiagramCommand.MoveUp, MoveCommands_1.MoveUpCommand, KeyCode_1.ModifierKey.Shift | KeyCode_1.KeyCode.Up);
this.createCommand(control, DiagramCommand.MoveStepUp, MoveCommands_1.MoveStepUpCommand, KeyCode_1.KeyCode.Up);
this.createCommand(control, DiagramCommand.MoveDown, MoveCommands_1.MoveDownCommand, KeyCode_1.ModifierKey.Shift | KeyCode_1.KeyCode.Down);
this.createCommand(control, DiagramCommand.MoveStepDown, MoveCommands_1.MoveStepDownCommand, KeyCode_1.KeyCode.Down);
this.createCommand(control, DiagramCommand.CloneLeft, CloneCommand_1.CloneLeftCommand, KeyCode_1.ModifierKey.Ctrl | KeyCode_1.ModifierKey.Shift | KeyCode_1.KeyCode.Left);
this.createCommand(control, DiagramCommand.CloneRight, CloneCommand_1.CloneRightCommand, KeyCode_1.ModifierKey.Ctrl | KeyCode_1.ModifierKey.Shift | KeyCode_1.KeyCode.Right);
this.createCommand(control, DiagramCommand.CloneUp, CloneCommand_1.CloneUpCommand, KeyCode_1.ModifierKey.Ctrl | KeyCode_1.ModifierKey.Shift | KeyCode_1.KeyCode.Up);
this.createCommand(control, DiagramCommand.CloneDown, CloneCommand_1.CloneDownCommand, KeyCode_1.ModifierKey.Ctrl | KeyCode_1.ModifierKey.Shift | KeyCode_1.KeyCode.Down);
this.createCommand(control, DiagramCommand.Lock, LockCommand_1.LockCommand);
this.createCommand(control, DiagramCommand.Unlock, UnlockCommand_1.UnLockCommand);
this.createCommand(control, DiagramCommand.AutoLayoutTree, AutoLayoutTreeVerticalCommand_1.AutoLayoutTreeVerticalCommand); // TODO: remove after, need for BC
this.createCommand(control, DiagramCommand.AutoLayoutFlow, AutoLayoutLayeredHorizontalCommand_1.AutoLayoutLayeredHorizontalCommand); // TODO: remove after, need for BC
this.createCommand(control, DiagramCommand.Units, ChangeUnitsCommand_1.ChangeUnitsCommand);
this.createCommand(control, DiagramCommand.ViewUnits, ChangeUnitsCommand_1.ChangeViewUnitsCommand);
this.createCommand(control, DiagramCommand.PageSize, ChangePageSizeCommand_1.ChangePageSizeCommand);
this.createCommand(control, DiagramCommand.PageLandscape, ChangePageLandscapeCommand_1.ChangePageLandscapeCommand);
this.createCommand(control, DiagramCommand.PageColor, ChangePageColorCommand_1.ChangePageColorCommand);
this.createCommand(control, DiagramCommand.GridSize, ChangeGridSizeCommand_1.ChangeGridSizeCommand);
this.createCommand(control, DiagramCommand.ShowGrid, ChangeShowGridCommand_1.ChangeShowGridCommand);
this.createCommand(control, DiagramCommand.SnapToGrid, ChangeSnapToGridCommand_1.ChangeSnapToGridCommand);
this.createCommand(control, DiagramCommand.ZoomLevel, ChangeZoomLevelCommand_1.ChangeZoomLevelCommand);
this.createCommand(control, DiagramCommand.AutoLayoutTreeVertical, AutoLayoutTreeVerticalCommand_1.AutoLayoutTreeVerticalCommand);
this.createCommand(control, DiagramCommand.AutoLayoutTreeHorizontal, AutoLayoutTreeHorizontalCommand_1.AutoLayoutTreeHorizontalCommand); // Not Implemented
this.createCommand(control, DiagramCommand.AutoLayoutLayeredVertical, AutoLayoutLayeredVerticalCommand_1.AutoLayoutLayeredVerticalCommand);
this.createCommand(control, DiagramCommand.AutoLayoutLayeredHorizontal, AutoLayoutLayeredHorizontalCommand_1.AutoLayoutLayeredHorizontalCommand);
this.createCommand(control, DiagramCommand.Fullscreen, ToggleFullscreenCommand_1.ToggleFullscreenCommand, KeyCode_1.KeyCode.F11);
this.createCommand(control, DiagramCommand.ToggleSimpleView, ToggleSimpleViewCommand_1.ToggleSimpleViewCommand);
this.createCommand(control, DiagramCommand.ToggleReadOnly, ToggleReadOnlyCommand_1.ToggleReadOnlyCommand);
this.createCommand(control, DiagramCommand.InsertShapeImage, InsertShapeImageCommand_1.InsertShapeImageCommand);
this.createCommand(control, DiagramCommand.EditShapeImage, EditShapeImageCommand_1.EditShapeImageCommand);
this.createCommand(control, DiagramCommand.DeleteShapeImage, DeleteShapeImageCommand_1.DeleteShapeImageCommand);
this.createCommand(control, DiagramCommand.FitToScreen, ChangeZoomLevelCommand_1.FitToScreenCommand);
this.createCommand(control, DiagramCommand.FitToWidth, ChangeZoomLevelCommand_1.FitToWidthCommand);
this.createCommand(control, DiagramCommand.SwitchAutoZoom, ChangeZoomLevelCommand_1.SwitchAutoZoomCommand);
this.createCommand(control, DiagramCommand.ToggleAutoZoom, ChangeZoomLevelCommand_1.ToggleAutoZoomCommand);
this.createCommand(control, DiagramCommand.ZoomLevelItems, ChangeZoomLevelCommand_1.ChangeZoomLevelItemsCommand);
this.createCommand(control, DiagramCommand.GridSizeItems, ChangeGridSizeCommand_1.ChangeGridSizeItemsCommand);
this.createCommand(control, DiagramCommand.PageSizeItems, ChangePageSizeCommand_1.ChangePageSizeItemsCommand);
}
CommandManager.prototype.getCommand = function (key) {
return this.commands[key];
};
CommandManager.prototype.beforeExecuting = function (command) {
this.executingCommandsChain.push(command);
this.executingCommandCounter++;
};
CommandManager.prototype.afterExecuting = function () {
this.executingCommandCounter--;
if (this.executingCommandCounter === 0) {
this.lastCommandsChain = this.executingCommandsChain;
this.executingCommandsChain = [];
}
};
CommandManager.prototype.assertLastExecutedCommandsChain = function (checkLength) {
var types = [];
for (var _i = 1; _i < arguments.length; _i++) {
types[_i - 1] = arguments[_i];
}
if (checkLength && this.lastCommandsChain.length !== types.length)
return false;
for (var i = 0, type; type = types[i]; i++) {
if (!this.lastCommandsChain[i] || !(this.lastCommandsChain[i] instanceof type))
return false;
}
return true;
};
CommandManager.prototype.processShortcut = function (code) {
var command = this.shortcutsToCommand[code];
if (command)
return command.execute();
return false;
};
CommandManager.prototype.processPaste = function (clipboardData) {
var command = this.getCommand(DiagramCommand.Paste);
if (command && command.isEnabled())
command.performPaste(clipboardData);
return true;
};
// ISelectionChangesListener
CommandManager.prototype.notifySelectionChanged = function (_selection) {
this.lastCommandsChain = [];
};
CommandManager.prototype.notifyScrollPositionChanged = function () { };
CommandManager.prototype.createCommand = function (control, commandId, commandType) {
var shortcuts = [];
for (var _i = 3; _i < arguments.length; _i++) {
shortcuts[_i - 3] = arguments[_i];
}
this.commands[commandId] = new commandType(control);
for (var i = 0; i < shortcuts.length; i++) {
var shortcut = shortcuts[i];
if (typeof shortcut === "number")
this.shortcutsToCommand[shortcut] = this.commands[commandId];
}
};
return CommandManager;
}());
exports.CommandManager = CommandManager;
/***/ }),
/* 49 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Base64_1 = __webpack_require__(86);
var ImageInfo_1 = __webpack_require__(40);
var CacheImageInfo = /** @class */ (function () {
function CacheImageInfo(base64, actualId, imageUrl, referenceInfo, isLoaded) {
this._base64 = base64 !== undefined ? Base64_1.Base64Utils.normalize(base64) : undefined;
this.actualId = actualId;
this._referenceInfo = referenceInfo;
this._isLoaded = isLoaded !== undefined ? isLoaded : false;
this.imageUrl = imageUrl;
}
Object.defineProperty(CacheImageInfo.prototype, "isLoaded", {
get: function () { return this._referenceInfo ? this._referenceInfo._isLoaded : this._isLoaded; },
set: function (val) { this._isLoaded = val; },
enumerable: true,
configurable: true
});
Object.defineProperty(CacheImageInfo.prototype, "base64", {
get: function () { return this._base64; },
set: function (val) { this._base64 = Base64_1.Base64Utils.normalize(val); },
enumerable: true,
configurable: true
});
Object.defineProperty(CacheImageInfo.prototype, "referenceInfo", {
get: function () { return this._referenceInfo; },
set: function (val) {
this._referenceInfo = val;
this._base64 = undefined;
this._isLoaded = undefined;
},
enumerable: true,
configurable: true
});
return CacheImageInfo;
}());
exports.CacheImageInfo = CacheImageInfo;
var ImageCache = /** @class */ (function () {
function ImageCache() {
this.emptyImageId = 0;
this.lastActualId = 0;
this.cache = [];
var emptyImage = this.createUnloadedInfoByBase64(ImageInfo_1.ImageInfo.transparentOnePixelImage);
emptyImage.isLoaded = true;
}
ImageCache.prototype.reset = function () {
this.cache.splice(1);
this.lastActualId = 1;
};
Object.defineProperty(ImageCache.prototype, "emptyImage", {
get: function () { return this.cache[this.emptyImageId]; },
enumerable: true,
configurable: true
});
ImageCache.prototype.getImageData = function (id) {
return this.cache[id];
};
ImageCache.prototype.createUnloadedInfoByUrl = function (imageUrl) {
var info = this.findInfoByUrl(imageUrl);
if (info)
return info;
return this.registerImageData(new CacheImageInfo(undefined, this.getNextActualId(), imageUrl));
};
ImageCache.prototype.createUnloadedInfoByBase64 = function (base64) {
var info = this.findInfoByBase64(base64);
if (info)
return info;
return this.registerImageData(new CacheImageInfo(base64, this.getNextActualId()));
};
ImageCache.prototype.createUnloadedInfoByShapeImageInfo = function (imageInfo) {
var data = imageInfo.exportUrl;
return Base64_1.Base64Utils.checkPrependDataUrl(data) ?
this.createUnloadedInfoByBase64(data) :
this.createUnloadedInfoByUrl(data);
};
ImageCache.prototype.registerImageData = function (data) {
var existingData = this.cache[data.actualId];
if (!existingData)
existingData = data;
if (data.actualId !== undefined)
this.cache[data.actualId] = existingData;
return existingData;
};
ImageCache.prototype.loadAllImages = function (loader) {
var _this = this;
this.cache.forEach(function (cacheInfo) {
if (_this.emptyImageId != cacheInfo.actualId && !cacheInfo.isLoaded)
loader.load(cacheInfo);
});
};
ImageCache.prototype.finalizeLoading = function (existingInfo, loadedInfo) {
existingInfo.isLoaded = true;
if (existingInfo.referenceInfo)
return;
if (loadedInfo.base64) {
var base64_1 = Base64_1.Base64Utils.normalize(loadedInfo.base64);
this.cache.forEach(function (cacheElem) {
var isReference = cacheElem.base64 == base64_1 && cacheElem !== existingInfo && cacheElem.isLoaded;
if (isReference)
existingInfo.referenceInfo = cacheElem.referenceInfo ? cacheElem.referenceInfo : cacheElem;
return isReference;
});
existingInfo.base64 = base64_1;
}
};
ImageCache.prototype.getNextActualId = function () {
return this.lastActualId++;
};
ImageCache.prototype.findInfoByBase64 = function (base64) {
base64 = Base64_1.Base64Utils.normalize(base64);
return this.findInfoCore(function (cacheImageInfo) { return cacheImageInfo.base64 === base64; });
};
ImageCache.prototype.findInfoByUrl = function (imageUrl) {
return this.findInfoCore(function (cacheImageInfo) { return cacheImageInfo.imageUrl === imageUrl; });
};
ImageCache.prototype.findInfoCore = function (callback) {
var cacheInfo;
this.cache.forEach(function (item) {
if (callback(item))
cacheInfo = item;
});
return cacheInfo;
};
ImageCache.instance = new ImageCache();
return ImageCache;
}());
exports.ImageCache = ImageCache;
/***/ }),
/* 50 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var MoveConnectorPointHistoryItem = /** @class */ (function (_super) {
__extends(MoveConnectorPointHistoryItem, _super);
function MoveConnectorPointHistoryItem(connectorKey, pointIndex, point) {
var _this = _super.call(this) || this;
_this.connectorKey = connectorKey;
_this.pointIndex = pointIndex;
_this.point = point;
return _this;
}
MoveConnectorPointHistoryItem.prototype.redo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
this.oldPoint = connector.points[this.pointIndex].clone();
manipulator.moveConnectorPoint(connector, this.pointIndex, this.point);
};
MoveConnectorPointHistoryItem.prototype.undo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
manipulator.moveConnectorPoint(connector, this.pointIndex, this.oldPoint);
};
return MoveConnectorPointHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.MoveConnectorPointHistoryItem = MoveConnectorPointHistoryItem;
/***/ }),
/* 51 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var ShapeDescriptionManager_1 = __webpack_require__(25);
var Shape_1 = __webpack_require__(11);
var AddShapeHistoryItem = /** @class */ (function (_super) {
__extends(AddShapeHistoryItem, _super);
function AddShapeHistoryItem(shapeType, position, text, dataKey) {
var _this = _super.call(this) || this;
_this.shapeType = shapeType;
_this.position = position;
_this.text = text;
_this.dataKey = dataKey;
return _this;
}
AddShapeHistoryItem.prototype.redo = function (manipulator) {
var shape = new Shape_1.Shape(ShapeDescriptionManager_1.ShapeDescriptionManager.get(this.shapeType), this.position);
if (typeof this.text === "string")
shape.text = this.text;
if (this.dataKey !== undefined)
shape.dataKey = this.dataKey;
manipulator.addShape(shape, this.shapeKey);
this.shapeKey = shape.key;
};
AddShapeHistoryItem.prototype.undo = function (manipulator) {
manipulator.deleteShape(manipulator.model.findShape(this.shapeKey));
};
return AddShapeHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.AddShapeHistoryItem = AddShapeHistoryItem;
/***/ }),
/* 52 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var Connector_1 = __webpack_require__(5);
var AddConnectorHistoryItem = /** @class */ (function (_super) {
__extends(AddConnectorHistoryItem, _super);
function AddConnectorHistoryItem(points, dataKey) {
var _this = _super.call(this) || this;
_this.points = points;
_this.dataKey = dataKey;
return _this;
}
AddConnectorHistoryItem.prototype.redo = function (manipulator) {
var connector = new Connector_1.Connector(this.points);
if (this.dataKey !== undefined)
connector.dataKey = this.dataKey;
manipulator.addConnector(connector, this.connectorKey);
this.connectorKey = connector.key;
};
AddConnectorHistoryItem.prototype.undo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
manipulator.deleteConnector(connector);
};
return AddConnectorHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.AddConnectorHistoryItem = AddConnectorHistoryItem;
/***/ }),
/* 53 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Structures_1 = __webpack_require__(31);
var Shape_1 = __webpack_require__(11);
var Utils_1 = __webpack_require__(0);
var ListUtils_1 = __webpack_require__(70);
var GraphBase = /** @class */ (function () {
function GraphBase(nodes, edges) {
this.nodeMap = {};
this.edgeMap = {};
this.nodes = [];
this.edges = [];
this.onInit();
nodes.forEach(this.addNode.bind(this));
edges.forEach(this.addEdge.bind(this));
}
Object.defineProperty(GraphBase.prototype, "items", {
get: function () {
return this.nodes.map(this.getNode.bind(this));
},
enumerable: true,
configurable: true
});
GraphBase.prototype.onInit = function () { };
GraphBase.prototype.addEdge = function (edge) {
this.edgeMap[edge.key] = edge;
this.edges.push(edge);
};
GraphBase.prototype.addNode = function (node) {
this.nodeMap[node.key] = node;
this.nodes.push(node.key);
};
GraphBase.prototype.getNode = function (key) {
return this.nodeMap[key];
};
GraphBase.prototype.getEdge = function (key) {
return this.edgeMap[key];
};
GraphBase.prototype.isEmpty = function () {
return !this.nodes.length && !this.edges.length;
};
GraphBase.prototype.getAdjacentEdges = function (nodeKey, connectionMode) {
if (connectionMode === void 0) { connectionMode = Structures_1.ConnectionMode.OutgoingAndIncoming; }
return this.edges.filter(function (e) {
return connectionMode & Structures_1.ConnectionMode.Incoming && e.to === nodeKey ||
connectionMode & Structures_1.ConnectionMode.Outgoing && e.from === nodeKey;
});
};
return GraphBase;
}());
var Graph = /** @class */ (function (_super) {
__extends(Graph, _super);
function Graph() {
return _super !== null && _super.apply(this, arguments) || this;
}
Graph.prototype.cast = function (castNode, castEdge) {
var _this = this;
var newNodes = this.nodes.map(function (nk) { return castNode(_this.getNode(nk)); });
var newEdges = this.edges.map(function (e) { return castEdge ? castEdge(e) : e; });
return new Graph(newNodes, newEdges);
};
Graph.prototype.getConnectedComponents = function () {
var iterator = this.createIterator(Structures_1.ConnectionMode.OutgoingAndIncoming);
iterator.visitEachEdgeOnce = true;
var components = [];
var _loop_1 = function (i) {
var nodes = [];
var edges = [];
iterator.onNode = function (n) { return nodes.push(n); };
iterator.onEdge = function (e) { return edges.push(e); };
iterator.iterate(this_1.nodes[i]);
if (nodes.length)
components.push(new Graph(nodes, edges));
};
var this_1 = this;
for (var i = 0; i < this.nodes.length; i++) {
_loop_1(i);
}
return components;
};
Graph.prototype.createIterator = function (connectionMode) {
var iterator = new GraphIterator(this, connectionMode);
iterator.comparer = function (a, b) { return a.weight - b.weight; };
return iterator;
};
Graph.prototype.getSpanningGraph = function (rootKey, connectionMode, edgeWeightFunc) {
var _this = this;
if (edgeWeightFunc === void 0) { edgeWeightFunc = undefined; }
if (!this.nodes.length)
return new Graph([], []);
if (!edgeWeightFunc)
edgeWeightFunc = function (e) { return e.weight; };
var sortedAdjacentEdges = [];
var spanningTreeNodesSet = new ListUtils_1.HashSet();
var spanningTreeEdgesSet = new ListUtils_1.HashSet([], function (e) { return e.getHashKey(); });
this.addNodeToSpanningGraph(rootKey, connectionMode, sortedAdjacentEdges, spanningTreeNodesSet, spanningTreeEdgesSet, edgeWeightFunc);
while (sortedAdjacentEdges.length && spanningTreeNodesSet.length !== this.nodes.length) {
var minWeighedEdge = sortedAdjacentEdges.shift();
spanningTreeEdgesSet.tryPush(minWeighedEdge);
var node = spanningTreeNodesSet.contains(minWeighedEdge.from) ? minWeighedEdge.to : minWeighedEdge.from;
this.addNodeToSpanningGraph(node, connectionMode, sortedAdjacentEdges, spanningTreeNodesSet, spanningTreeEdgesSet, edgeWeightFunc);
sortedAdjacentEdges = sortedAdjacentEdges.filter(function (e) { return !spanningTreeNodesSet.contains(e.from) || !spanningTreeNodesSet.contains(e.to); });
}
return new Graph(spanningTreeNodesSet.list().map(function (nk) { return _this.getNode(nk); }), spanningTreeEdgesSet.list());
};
Graph.prototype.addNodeToSpanningGraph = function (nodeKey, connectionMode, adjacentEdges, spanningTreeNodesSet, spanningTreeEdgesSet, edgeWeightFunc) {
spanningTreeNodesSet.tryPush(nodeKey);
this.getAdjacentEdges(nodeKey, connectionMode)
.filter(function (e) { return !spanningTreeEdgesSet.contains(e); })
.forEach(function (e) {
var weight = edgeWeightFunc(e);
var pos = Utils_1.Utils.binaryIndexOf(adjacentEdges, function (a) { return a.weight - weight; });
pos = pos < 0 ? ~pos : pos;
while (pos < adjacentEdges.length && edgeWeightFunc(adjacentEdges[pos]) === weight)
pos++;
adjacentEdges.splice(pos, 0, new Structures_1.Edge(e.key, e.from, e.to, weight));
});
};
Graph.create = function (shapes, connectors) {
var nodes = shapes;
var edges = connectors
.filter(function (i) { return i.beginItem && i.endItem instanceof Shape_1.Shape && i.endItem && i.endItem instanceof Shape_1.Shape && i.beginItem !== i.endItem; }) // TBD: ShapeItem?
.map(function (i) { return new Structures_1.Edge(i.key, i.beginItem && i.beginItem.key, i.endItem && i.endItem.key); });
return new Graph(nodes, edges);
};
return Graph;
}(GraphBase));
exports.Graph = Graph;
var FastGraph = /** @class */ (function (_super) {
__extends(FastGraph, _super);
function FastGraph() {
return _super !== null && _super.apply(this, arguments) || this;
}
FastGraph.prototype.onInit = function () {
this.parentToChildren = {};
this.childToParents = {};
};
FastGraph.prototype.addEdge = function (edge) {
_super.prototype.addEdge.call(this, edge);
(this.parentToChildren[edge.from] || (this.parentToChildren[edge.from] = [])).push(edge.to);
(this.childToParents[edge.to] || (this.childToParents[edge.to] = [])).push(edge.from);
};
FastGraph.prototype.getChildren = function (parent) {
return this.parentToChildren[parent] || [];
};
FastGraph.prototype.getParents = function (child) {
return this.childToParents[child] || [];
};
FastGraph.prototype.createIterator = function (connectionMode) {
return new GraphIterator(this, connectionMode);
};
return FastGraph;
}(GraphBase));
exports.FastGraph = FastGraph;
var GraphIterator = /** @class */ (function () {
function GraphIterator(graph, connectionMode) {
if (connectionMode === void 0) { connectionMode = Structures_1.ConnectionMode.OutgoingAndIncoming; }
this.graph = graph;
this.connectionMode = connectionMode;
this.visitEachEdgeOnce = true;
this.visitEachNodeOnce = true;
this.visitedNodes = {};
this.visitedEdges = {};
}
GraphIterator.prototype.iterate = function (nodeKey) {
if (!this.visitEachNodeOnce && !this.visitEachEdgeOnce && !this.skipNode)
throw "skipNode or visitEachNodeOnce or visitEachEdgeOnce must be set to avoid SOF";
this.iterateCore(nodeKey);
};
GraphIterator.prototype.iterateCore = function (nodeKey) {
var _this = this;
var node = this.graph.getNode(nodeKey);
if (!node || (this.skipNode && this.skipNode(node)) || (this.visitEachNodeOnce && this.isNodeVisited(nodeKey)))
return;
this.visitedNodes[nodeKey] = true;
this.onNode && this.onNode(node);
var edges = this.graph.getAdjacentEdges(nodeKey, this.connectionMode);
if (this.skipEdge)
edges = edges.filter(function (e) { return !_this.skipEdge(e); });
if (this.connectionMode & Structures_1.ConnectionMode.Outgoing) {
var outgoing = edges.filter(function (e) { return e.from === nodeKey; });
if (this.comparer)
outgoing.sort(this.comparer);
outgoing.forEach(function (e) {
if (_this.visitEachEdgeOnce && _this.visitedEdges[e.key])
return;
_this.visitedEdges[e.key] = true;
_this.onEdge && _this.onEdge(e, true);
_this.iterateCore(e.to);
_this.onAfterEdge && _this.onAfterEdge(e, true);
});
}
this.onAllEdges && this.onAllEdges(node, true);
if (this.connectionMode & Structures_1.ConnectionMode.Incoming) {
var incoming = edges.filter(function (e) { return e.to === nodeKey; });
if (this.comparer)
incoming.sort(this.comparer);
incoming.forEach(function (e) {
if (_this.visitEachEdgeOnce && _this.visitedEdges[e.key])
return;
_this.visitedEdges[e.key] = true;
_this.onEdge && _this.onEdge(e, false);
_this.iterateCore(e.from);
_this.onAfterEdge && _this.onAfterEdge(e, false);
});
}
this.onAllEdges && this.onAllEdges(node, false);
};
GraphIterator.prototype.isNodeVisited = function (nodeKey) {
return !!this.visitedNodes[nodeKey];
};
GraphIterator.prototype.isEdgeVisited = function (edgeKey) {
return !!this.visitedEdges[edgeKey];
};
return GraphIterator;
}());
exports.GraphIterator = GraphIterator;
/***/ }),
/* 54 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var ChangeConnectorTextHistoryItem = /** @class */ (function (_super) {
__extends(ChangeConnectorTextHistoryItem, _super);
function ChangeConnectorTextHistoryItem(connector, position, text) {
var _this = _super.call(this) || this;
_this.connectorKey = connector.key;
_this.text = text;
_this.position = position;
return _this;
}
ChangeConnectorTextHistoryItem.prototype.redo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
this.oldText = connector.getText(this.position);
manipulator.changeConnectorText(connector, this.text, this.position);
};
ChangeConnectorTextHistoryItem.prototype.undo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
manipulator.changeConnectorText(connector, this.oldText, this.position);
};
return ChangeConnectorTextHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.ChangeConnectorTextHistoryItem = ChangeConnectorTextHistoryItem;
/***/ }),
/* 55 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var ChangeConnectorPropertyHistoryItem = /** @class */ (function (_super) {
__extends(ChangeConnectorPropertyHistoryItem, _super);
function ChangeConnectorPropertyHistoryItem(connectorKey, propertyName, value) {
var _this = _super.call(this) || this;
_this.connectorKey = connectorKey;
_this.propertyName = propertyName;
_this.value = value;
return _this;
}
ChangeConnectorPropertyHistoryItem.prototype.redo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
this.oldValue = connector.properties[this.propertyName];
manipulator.changeConnectorProperty(connector, this.propertyName, this.value);
};
ChangeConnectorPropertyHistoryItem.prototype.undo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
manipulator.changeConnectorProperty(connector, this.propertyName, this.oldValue);
};
return ChangeConnectorPropertyHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.ChangeConnectorPropertyHistoryItem = ChangeConnectorPropertyHistoryItem;
/***/ }),
/* 56 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Utils_1 = __webpack_require__(0);
var NodeInfo = /** @class */ (function () {
function NodeInfo(key, margin, size, connectionPoints) {
if (connectionPoints === void 0) { connectionPoints = []; }
this.key = key;
this.margin = margin;
this.size = size;
this.connectionPoints = connectionPoints;
}
return NodeInfo;
}());
exports.NodeInfo = NodeInfo;
var NodeLayout = /** @class */ (function () {
function NodeLayout(info, position) {
this.info = info;
this.position = position;
}
Object.defineProperty(NodeLayout.prototype, "key", {
get: function () { return this.info.key; },
enumerable: true,
configurable: true
});
Object.defineProperty(NodeLayout.prototype, "rectangle", {
get: function () {
return new Utils_1.Rectangle(this.position, this.info.size);
},
enumerable: true,
configurable: true
});
return NodeLayout;
}());
exports.NodeLayout = NodeLayout;
var EdgeLayout = /** @class */ (function () {
function EdgeLayout(key, beginIndex, endIndex) {
this.key = key;
this.beginIndex = beginIndex;
this.endIndex = endIndex;
}
return EdgeLayout;
}());
exports.EdgeLayout = EdgeLayout;
var Margin = /** @class */ (function () {
function Margin(top, right, bottom, left) {
if (right === void 0) { right = top; }
if (bottom === void 0) { bottom = top; }
if (left === void 0) { left = top; }
this.top = top;
this.right = right;
this.bottom = bottom;
this.left = left;
}
Margin.empty = function () {
return new Margin(0);
};
return Margin;
}());
exports.Margin = Margin;
/***/ }),
/* 57 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Shape_1 = __webpack_require__(11);
var Connector_1 = __webpack_require__(5);
var Exporter = /** @class */ (function () {
function Exporter() {
}
Exporter.prototype.export = function (model) {
var obj = {
page: {},
connectors: [],
shapes: []
};
obj.page = {
"width": model.size.width,
"height": model.size.height,
"pageColor": model.pageColor,
"pageWidth": model.pageSize.width,
"pageHeight": model.pageSize.height,
"pageLandscape": model.pageLandscape,
"units": model.units
};
this.exportItemsCore(model.items, obj);
return JSON.stringify(obj);
};
Exporter.prototype.exportItems = function (items) {
var obj = {
connectors: [],
shapes: []
};
this.exportItemsCore(items, obj);
return JSON.stringify(obj);
};
Exporter.prototype.exportItemsCore = function (items, obj) {
var _this = this;
items.forEach(function (item) {
if (item instanceof Shape_1.Shape) {
obj.shapes.push(_this.exportShape(item));
}
else if (item instanceof Connector_1.Connector) {
var connectorObj = _this.exportConnector(item);
if (item.beginItem) {
connectorObj["beginItemKey"] = item.beginItem.key;
connectorObj["beginConnectionPointIndex"] = item.beginConnectionPointIndex;
}
if (item.endItem) {
connectorObj["endItemKey"] = item.endItem.key;
connectorObj["endConnectionPointIndex"] = item.endConnectionPointIndex;
}
obj.connectors.push(connectorObj);
}
});
};
Exporter.prototype.exportItem = function (item) {
return {
"key": item.key,
"dataKey": item.dataKey,
"locked": item.locked,
"zIndex": item.zIndex
};
};
Exporter.prototype.exportShape = function (shape) {
var result = this.exportItem(shape);
result["type"] = shape.description.key;
result["text"] = shape.text;
if (!shape.image.isEmpty)
result["imageUrl"] = shape.image.exportUrl;
result["x"] = shape.position.x;
result["y"] = shape.position.y;
result["width"] = shape.size.width;
result["height"] = shape.size.height;
var paramsObj = shape.parameters.toObject();
if (paramsObj)
result["parameters"] = paramsObj;
var styleObj = shape.style.toObject();
if (styleObj)
result["style"] = styleObj;
var styleTextObj = shape.styleText.toObject();
if (styleTextObj)
result["styleText"] = styleTextObj;
if (shape.childKeys.length)
result["childKeys"] = shape.childKeys.slice();
if (!shape.expanded)
result["expanded"] = false;
if (shape.expandedSize) {
result["expandedWidth"] = shape.expandedSize.width;
result["expandedHeight"] = shape.expandedSize.height;
}
return result;
};
Exporter.prototype.exportConnector = function (connector) {
var result = this.exportItem(connector);
result["points"] = connector.points.map(function (p) { return { "x": p.x, "y": p.y }; });
var textObj = connector.texts.toObject();
if (textObj)
result["texts"] = textObj;
var propsObj = connector.properties.toObject();
if (propsObj)
result["properties"] = propsObj;
var styleObj = connector.style.toObject();
if (styleObj)
result["style"] = styleObj;
var styleTextObj = connector.styleText.toObject();
if (styleTextObj)
result["styleText"] = styleTextObj;
return result;
};
// Images
Exporter.prototype.exportSvg = function (modelSize, pageColor, exportManager, callback) {
exportManager.exportSvgImage(modelSize, pageColor, callback);
};
Exporter.prototype.exportPng = function (modelSize, pageColor, exportManager, callback) {
exportManager.exportPngImage(modelSize, pageColor, callback);
};
Exporter.prototype.exportJpg = function (modelSize, pageColor, exportManager, callback) {
exportManager.exportJpgImage(modelSize, pageColor, callback);
};
return Exporter;
}());
exports.Exporter = Exporter;
/***/ }),
/* 58 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var StylePropertyCommandBase_1 = __webpack_require__(107);
var ChangeStyleTextHistoryItem_1 = __webpack_require__(36);
var Style_1 = __webpack_require__(27);
var ToggleStyleTextPropertyCommand = /** @class */ (function (_super) {
__extends(ToggleStyleTextPropertyCommand, _super);
function ToggleStyleTextPropertyCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ToggleStyleTextPropertyCommand.prototype.getValue = function () {
var value = this.control.selection.inputPosition.getStyleTextPropertyValue(this.getStyleProperty());
return value === this.getStylePropertyValue();
};
ToggleStyleTextPropertyCommand.prototype.executeCore = function (state) {
var _this = this;
this.control.history.beginTransaction();
var styleProperty = this.getStyleProperty();
var styleValue = state.value ? Style_1.StyleText.defaultInstace[styleProperty] : this.getStylePropertyValue();
var items = this.control.selection.getSelectedItems();
items.forEach(function (item) {
_this.control.history.addAndRedo(new ChangeStyleTextHistoryItem_1.ChangeStyleTextHistoryItem(item.key, styleProperty, styleValue));
});
this.control.selection.inputPosition.setStyleTextPropertyValue(this.getStyleProperty(), styleValue);
this.control.history.endTransaction();
return true;
};
ToggleStyleTextPropertyCommand.prototype.getStyleObj = function (item) {
return item.styleText;
};
ToggleStyleTextPropertyCommand.prototype.getDefaultStyleObj = function () {
return new Style_1.StyleText();
};
return ToggleStyleTextPropertyCommand;
}(StylePropertyCommandBase_1.StylePropertyCommandBase));
exports.ToggleStyleTextPropertyCommand = ToggleStyleTextPropertyCommand;
/***/ }),
/* 59 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ModelUtils_1 = __webpack_require__(6);
var SimpleCommandBase_1 = __webpack_require__(7);
var AutoLayoutCommandBase = /** @class */ (function (_super) {
__extends(AutoLayoutCommandBase, _super);
function AutoLayoutCommandBase() {
return _super !== null && _super.apply(this, arguments) || this;
}
AutoLayoutCommandBase.prototype.isEnabled = function () {
return _super.prototype.isEnabled.call(this) && !this.control.selection.isEmpty();
};
AutoLayoutCommandBase.prototype.executeCore = function (state, parameter) {
var _this = this;
this.control.history.beginTransaction();
var shapes = this.control.selection.getSelectedShapes(false, true);
var connectors = this.control.selection.getSelectedConnectors(false, true);
var graphInfo = ModelUtils_1.ModelUtils.getGraphInfoByItems(this.control.model, shapes, connectors);
var settings = this.createLayoutSettings();
graphInfo.forEach(function (info) {
var layout = _this.createLayout(settings, info.graph);
var nonGraphItems = ModelUtils_1.ModelUtils.getNonGraphItems(_this.control.model, info.container, layout.nodeToLayout, shapes, connectors);
ModelUtils_1.ModelUtils.applyLayout(_this.control.history, _this.control.model, info.container, info.graph, layout, nonGraphItems, settings, _this.control.settings.snapToGrid, _this.control.settings.gridSize);
});
ModelUtils_1.ModelUtils.tryUpdateModelSize(this.control.history, this.control.model);
this.control.history.endTransaction();
return true;
};
return AutoLayoutCommandBase;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.AutoLayoutCommandBase = AutoLayoutCommandBase;
/***/ }),
/* 60 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ModelUtils_1 = __webpack_require__(6);
var SimpleCommandBase_1 = __webpack_require__(7);
var ChangePagePropertyCommand = /** @class */ (function (_super) {
__extends(ChangePagePropertyCommand, _super);
function ChangePagePropertyCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangePagePropertyCommand.prototype.executeCore = function (state, parameter) {
var _this = this;
this.control.history.beginTransaction();
var items = this.createHistoryItems(parameter);
items.forEach(function (item) { _this.control.history.addAndRedo(item); });
ModelUtils_1.ModelUtils.tryUpdateModelSize(this.control.history, this.control.model);
this.control.history.endTransaction();
return true;
};
ChangePagePropertyCommand.prototype.getItems = function () {
return null;
};
return ChangePagePropertyCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.ChangePagePropertyCommand = ChangePagePropertyCommand;
/***/ }),
/* 61 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var BaseBuilder_1 = __webpack_require__(112);
var Graph_1 = __webpack_require__(53);
var NodeLayout_1 = __webpack_require__(56);
var Structures_1 = __webpack_require__(31);
var ListUtils_1 = __webpack_require__(70);
var Utils_1 = __webpack_require__(0);
var LayoutSettings_1 = __webpack_require__(22);
var GraphLayout_1 = __webpack_require__(111);
var Connector_1 = __webpack_require__(5);
var CycleRemover_1 = __webpack_require__(234);
var SugiyamaLayoutBuilder = /** @class */ (function (_super) {
__extends(SugiyamaLayoutBuilder, _super);
function SugiyamaLayoutBuilder() {
return _super !== null && _super.apply(this, arguments) || this;
}
SugiyamaLayoutBuilder.prototype.build = function () {
var _this = this;
var offset = 0;
var layout = new GraphLayout_1.GraphLayout();
var nodeOrderer = new SugiyamaNodesOrderer();
this.graph.getConnectedComponents()
.forEach(function (component) {
var acyclicGraphInfo = CycleRemover_1.CycleRemover.removeCycles(component);
var layers = SugiyamaLayerDistributor.getLayers(acyclicGraphInfo.graph);
var orderedGraph = nodeOrderer.orderNodes(acyclicGraphInfo.graph, layers);
var removedEdges = Object.keys(acyclicGraphInfo.removedEdges).map(function (ek) { return component.getEdge(ek); });
var coordinatedGraph = nodeOrderer.assignAbsCoordinates(orderedGraph);
var componentLayout = _this.createInfoGraphLayout(coordinatedGraph, acyclicGraphInfo.reversedEdges, removedEdges);
layout.extend(_this.setComponentOffset(componentLayout, offset));
offset += _this.getComponentOffset(componentLayout);
});
return layout;
};
// Order Nodes
SugiyamaLayoutBuilder.prototype.createInfoGraphLayout = function (coordinatedGraph, reversedEdges, removedEdges) {
var _this = this;
var currentPosition = new Utils_1.Point(0, 0);
var items = coordinatedGraph.items;
var sortedLayers = new ListUtils_1.HashSet(items.map(function (n) { return n.layer; }).sort());
var absOffsetInfo = this.getAbsOffsetInfo(coordinatedGraph.items);
var positions = {};
var totalDepth = 0;
var leftEdge = Number.MAX_SAFE_INTEGER || Number.MAX_VALUE;
var rightEdge = Number.MIN_SAFE_INTEGER || Number.MAX_VALUE;
var _loop_1 = function (i) {
var layer = sortedLayers.item(i);
var maxDepthLayer = 0;
items
.filter(function (n) { return n.layer === layer; })
.sort(function (a, b) { return a.position - b.position; })
.forEach(function (n) {
var depthNodeSize = _this.getDepthNodeSize(n);
var directionOffset = _this.chooseDirectionValue(0, depthNodeSize);
var absPosition = _this.getAbsPosition(n.position, _this.getBreadthNodeSize(n), absOffsetInfo);
currentPosition = _this.setBreadth(currentPosition, absPosition);
var nodePosition = _this.setDepthOffset(currentPosition, -directionOffset);
positions[n.key] = nodePosition;
if (n.isDummy)
return;
var breadth = _this.settings.orientation === LayoutSettings_1.DataLayoutOrientation.Horizontal ? nodePosition.y : nodePosition.x;
leftEdge = Math.min(leftEdge, breadth);
rightEdge = Math.max(rightEdge, breadth + _this.getBreadthNodeSize(n));
maxDepthLayer = Math.max(maxDepthLayer, _this.getDepthNodeSize(n));
});
totalDepth += maxDepthLayer;
currentPosition = this_1.setBreadth(currentPosition, 0);
currentPosition = this_1.setDepthOffset(currentPosition, this_1.getDirectionValue(maxDepthLayer + this_1.settings.layerSpacing));
};
var this_1 = this;
for (var i = 0; i < sortedLayers.length; i++) {
_loop_1(i);
}
totalDepth += (sortedLayers.length - 1) * this.settings.layerSpacing;
var layout = new GraphLayout_1.GraphLayout();
this.createNodesLayout(coordinatedGraph, layout, leftEdge, totalDepth, positions);
this.createEdgesLayout(coordinatedGraph, layout, reversedEdges, removedEdges);
return layout;
//this.getDummyEdgesRoutes(infoGraph);
};
SugiyamaLayoutBuilder.prototype.createNodesLayout = function (infoGraph, layout, leftEdge, totalDepth, positions) {
var _this = this;
var offset = this.settings.orientation === LayoutSettings_1.DataLayoutOrientation.Vertical ?
new Utils_1.Point(-leftEdge, this.chooseDirectionValue(0, totalDepth)) :
new Utils_1.Point(this.chooseDirectionValue(0, totalDepth), -leftEdge);
infoGraph.items.forEach(function (n) {
if (!n.isDummy) {
var node = _this.graph.getNode(n.key);
layout.addNode(new NodeLayout_1.NodeLayout(node, positions[n.key].offset(offset.x, offset.y)));
}
});
};
SugiyamaLayoutBuilder.prototype.createEdgesLayout = function (infoGraph, layout, reversedEdges, removedEdges) {
var DIRECT = this.getDirectEdgeLayout();
var TOP_TO_BOTTOM = this.getDiffLevelEdgeLayout(true);
var BOTTOM_TO_TOP = this.getDiffLevelEdgeLayout(false);
var TOP_TO_TOP = this.getSameLevelEdgeLayout(true);
var BOTTOM_TO_BOTTOM = this.getSameLevelEdgeLayout(false);
var occupied = {};
infoGraph.edges
.filter(function (e) { return !e.isDummy; })
.concat(removedEdges.map(function (e) { return new EdgeOnLayer(e.key, false, e.from, e.to); }))
.sort(function (a, b) {
return (infoGraph.getNode(a.originFrom).layer - infoGraph.getNode(b.originFrom).layer) ||
(infoGraph.getNode(a.to).layer - infoGraph.getNode(b.to).layer);
})
.forEach(function (e) {
var isReversed = reversedEdges[e.key];
var from = infoGraph.getNode(isReversed ? e.to : e.originFrom);
var to = infoGraph.getNode(isReversed ? e.originFrom : e.to);
if (to.layer - from.layer === 1)
layout.addEdge(new NodeLayout_1.EdgeLayout(e.key, DIRECT.from, DIRECT.to));
else {
var candidates_1 = [];
if (to.position - from.position >= 1) {
candidates_1.push(TOP_TO_BOTTOM);
candidates_1.push({ from: DIRECT.from, to: TOP_TO_BOTTOM.to });
candidates_1.push({ from: TOP_TO_BOTTOM.from, to: DIRECT.to });
}
else if (to.position - from.position <= -1) {
candidates_1.push(BOTTOM_TO_TOP);
candidates_1.push({ from: DIRECT.from, to: BOTTOM_TO_TOP.to });
candidates_1.push({ from: BOTTOM_TO_TOP.from, to: DIRECT.to });
}
else {
var oneliner = from.position === to.position && to.position === 0 ? [TOP_TO_TOP, BOTTOM_TO_BOTTOM] : [BOTTOM_TO_BOTTOM, TOP_TO_TOP];
oneliner.forEach(function (c) { return candidates_1.push(c); });
oneliner.forEach(function (c) {
candidates_1.push({ from: c.from, to: DIRECT.to });
candidates_1.push({ from: DIRECT.from, to: c.to });
});
}
candidates_1.push(DIRECT);
for (var i = 0, candidate = void 0; candidate = candidates_1[i]; i++) {
var fromKey = from.key + "_" + candidate.from;
var toKey = to.key + "_" + candidate.to;
if (occupied[fromKey] !== Connector_1.ConnectorPosition.End && occupied[toKey] !== Connector_1.ConnectorPosition.Begin) {
layout.addEdge(new NodeLayout_1.EdgeLayout(e.key, candidate.from, candidate.to));
occupied[fromKey] = Connector_1.ConnectorPosition.Begin;
occupied[toKey] = Connector_1.ConnectorPosition.End;
break;
}
}
}
});
};
SugiyamaLayoutBuilder.prototype.getDirectEdgeLayout = function () {
if (this.settings.orientation === LayoutSettings_1.DataLayoutOrientation.Horizontal)
return this.settings.direction === LayoutSettings_1.LogicalDirectionKind.Forward ? { from: 1, to: 3 } : { from: 3, to: 1 };
return this.settings.direction === LayoutSettings_1.LogicalDirectionKind.Forward ? { from: 2, to: 0 } : { from: 0, to: 2 };
};
SugiyamaLayoutBuilder.prototype.getDiffLevelEdgeLayout = function (topToBottom) {
if (this.settings.orientation === LayoutSettings_1.DataLayoutOrientation.Horizontal)
return topToBottom ? { from: 2, to: 0 } : { from: 0, to: 2 };
return topToBottom ? { from: 3, to: 1 } : { from: 1, to: 3 };
};
SugiyamaLayoutBuilder.prototype.getSameLevelEdgeLayout = function (topToBottom) {
if (this.settings.orientation === LayoutSettings_1.DataLayoutOrientation.Horizontal)
return topToBottom ? { from: 0, to: 0 } : { from: 2, to: 2 };
return topToBottom ? { from: 3, to: 3 } : { from: 1, to: 1 };
};
// private getDummyEdgesRoutes(infoGraph: FastGraph<NodeOnLayer, EdgeOnLayer>): {[nodeKey: string]: NodeOnLayer[]} {
// let resultRoutes: {[nodeKey: string]: NodeOnLayer[]} = {};
// let dummyEdgeRoutes: {[edgeHash: string]: NodeOnLayer[]} = {};
// infoGraph.edges
// .filter(e => !infoGraph.getNode(e.from).isDummy && infoGraph.getNode(e.to).isDummy)
// .forEach(rootEdge => {
// let edgeHash = rootEdge.getHashCode();
// dummyEdgeRoutes[edgeHash] = [];
// let iterator = infoGraph.createIterator(ConnectionMode.Outgoing);
// iterator.visitEachEdgeOnce = false;
// iterator.onNode = (n) => dummyEdgeRoutes[edgeHash].push(n);
// iterator.skipNode = (n) => !n.isDummy;
// iterator.skipEdge = (e) => false;
// iterator.onEdge = (e, out) => {
// if(!infoGraph.getNode(e.to).isDummy)
// resultRoutes[new EdgeOnLayer(e.key, e.isDummy, rootEdge.from, e.to).getHashCode()] = dummyEdgeRoutes[edgeHash];
// };
// iterator.iterate(rootEdge.to);
// });
// return resultRoutes;
// }
SugiyamaLayoutBuilder.prototype.getAbsOffsetInfo = function (nodesInfos) {
var _this = this;
var absOffsetMatrix = {};
var addCell = function (n, intAbsCoord) {
if (absOffsetMatrix[intAbsCoord] === undefined)
absOffsetMatrix[intAbsCoord] = _this.getBreadthNodeSize(n);
absOffsetMatrix[intAbsCoord] = Math.max(absOffsetMatrix[intAbsCoord], _this.getBreadthNodeSize(n));
};
nodesInfos.forEach(function (n) {
var intAbsCoord = trunc(n.position);
addCell(n, intAbsCoord);
if (absOffsetMatrix[intAbsCoord] % 1 !== 0)
addCell(n, intAbsCoord + 1);
});
var absOffsetInfo = {};
var leftOffset = 0;
Object.keys(absOffsetMatrix).sort().forEach(function (coord) {
absOffsetInfo[coord] = { leftOffset: leftOffset, width: absOffsetMatrix[coord] };
leftOffset += absOffsetMatrix[coord] + _this.settings.columnSpacing;
});
return absOffsetInfo;
};
SugiyamaLayoutBuilder.prototype.setBreadth = function (position, breadthPosition) {
if (this.settings.orientation === LayoutSettings_1.DataLayoutOrientation.Vertical)
return new Utils_1.Point(breadthPosition, position.y);
return new Utils_1.Point(position.x, breadthPosition);
};
SugiyamaLayoutBuilder.prototype.setDepthOffset = function (position, offset) {
if (this.settings.orientation === LayoutSettings_1.DataLayoutOrientation.Horizontal)
return new Utils_1.Point(position.x + offset, position.y);
return new Utils_1.Point(position.x, position.y + offset);
};
SugiyamaLayoutBuilder.prototype.getAbsPosition = function (absCoordinate, itemSize, absoluteOffsetInfo) {
var intAbsCoord = trunc(absCoordinate);
var absLeftOffset = absoluteOffsetInfo[intAbsCoord].leftOffset;
var cellWidth = absoluteOffsetInfo[intAbsCoord].width;
if (absCoordinate % 1 === 0)
return absLeftOffset + (cellWidth - itemSize) / 2;
return absLeftOffset + cellWidth - (itemSize - this.settings.columnSpacing) / 2;
};
SugiyamaLayoutBuilder.prototype.getBreadthNodeSize = function (node) {
return node.isDummy ? 0 : this.getBreadthNodeSizeCore(this.graph.getNode(node.key));
};
SugiyamaLayoutBuilder.prototype.getDepthNodeSize = function (node) {
return node.isDummy ? 0 : this.getDepthNodeSizeCore(this.graph.getNode(node.key));
};
return SugiyamaLayoutBuilder;
}(BaseBuilder_1.LayoutBuilder));
exports.SugiyamaLayoutBuilder = SugiyamaLayoutBuilder;
var SugiyamaLayerDistributor = /** @class */ (function () {
function SugiyamaLayerDistributor() {
}
SugiyamaLayerDistributor.getLayers = function (acyclicGraph) {
var feasibleTree = this.getFeasibleTree(acyclicGraph);
return this.calcNodesLayers(feasibleTree);
};
SugiyamaLayerDistributor.getFeasibleTree = function (graph) {
var layers = this.initLayerAssignment(graph);
return graph.getSpanningGraph(graph.nodes[0], Structures_1.ConnectionMode.OutgoingAndIncoming, function (e) { return layers[e.to] - layers[e.from]; });
};
SugiyamaLayerDistributor.initLayerAssignment = function (graph) {
var layers = {};
var currentLayer = 0;
var actualAssignedNodes = {};
var assigningNodes = graph.nodes.filter(function (n) { return !graph.getAdjacentEdges(n, Structures_1.ConnectionMode.Incoming).length; });
var _loop_2 = function () {
assigningNodes.forEach(function (n) {
layers[n] = currentLayer;
actualAssignedNodes[n] = true;
});
Object.keys(actualAssignedNodes).forEach(function (n) {
if (graph.getAdjacentEdges(n, Structures_1.ConnectionMode.Outgoing).filter(function (e) { return layers[e.to] === undefined; }).length === 0)
delete actualAssignedNodes[n];
});
var assigningNodesSet = {};
Object.keys(actualAssignedNodes).forEach(function (n) {
graph.getAdjacentEdges(n, Structures_1.ConnectionMode.Outgoing)
.map(function (e) { return e.to; })
.filter(function (n) { return layers[n] === undefined && graph.getAdjacentEdges(n, Structures_1.ConnectionMode.Incoming).reduce(function (acc, e) { return acc && layers[e.from] !== undefined; }, true); })
.forEach(function (n) { return assigningNodesSet[n] = true; });
});
assigningNodes = Object.keys(assigningNodesSet);
currentLayer++;
};
while (assigningNodes.length) {
_loop_2();
}
return layers;
};
SugiyamaLayerDistributor.calcNodesLayers = function (graph) {
var layers = {};
var minLayer = Number.MAX_SAFE_INTEGER || Number.MAX_VALUE;
var currentLevel = 0;
var iterator = graph.createIterator(Structures_1.ConnectionMode.OutgoingAndIncoming);
iterator.visitEachEdgeOnce = false;
iterator.onNode = function (n) {
layers[n.key] = currentLevel;
minLayer = Math.min(minLayer, currentLevel);
};
iterator.skipNode = function (n) { return layers[n.key] !== undefined; };
iterator.skipEdge = function (e) { return layers[e.from] !== undefined && layers[e.to] !== undefined; };
iterator.onEdge = function (e, out) {
if (out)
currentLevel = layers[e.from] + 1;
else
currentLevel = layers[e.to] - 1;
};
iterator.iterate(graph.nodes[0]);
for (var key in layers) {
if (!layers.hasOwnProperty(key))
continue;
layers[key] -= minLayer;
}
return layers;
};
return SugiyamaLayerDistributor;
}());
exports.SugiyamaLayerDistributor = SugiyamaLayerDistributor;
var SugiyamaNodesOrderer = /** @class */ (function () {
function SugiyamaNodesOrderer() {
this.idCounter = -10000;
}
SugiyamaNodesOrderer.prototype.orderNodes = function (graph, layers) {
var maxIteration = 14; //magic number - http://www.graphviz.org/Documentation/TSE93.pdf PAGE (14)
var currentIteration = 1;
var graphInfo = this.initGraphInfo(graph, layers);
var nodeInfos = graphInfo.items;
var orderInfo = this.initOrder(nodeInfos);
var bestNodesPositions = this.getNodeToPositionMap(nodeInfos);
var bestCrossCount = this.getCrossCount(orderInfo, graphInfo);
var isParentToChildren = true;
while (currentIteration < maxIteration && bestCrossCount != 0) {
orderInfo = this.getNodesOrder(orderInfo, graphInfo, isParentToChildren);
var crossCount = this.getCrossCount(orderInfo, graphInfo);
if (crossCount < bestCrossCount) {
bestNodesPositions = this.getNodeToPositionMap(graphInfo.items);
bestCrossCount = crossCount;
}
isParentToChildren = !isParentToChildren;
currentIteration++;
}
//transpose() procedure doesn`t implement.
//http://www.graphviz.org/Documentation/TSE93.pdf PAGE(16)
graphInfo.items.forEach(function (n) { return n.position = bestNodesPositions[n.key]; });
return graphInfo;
};
SugiyamaNodesOrderer.prototype.getNodesOrder = function (current, graph, isParentToChildren) {
var _this = this;
var order = {};
var _loop_3 = function (layer) {
if (!current.hasOwnProperty(layer))
return "continue";
var nodePositions = {};
current[layer].forEach(function (ni) {
var adjacentNodesPositions = (isParentToChildren ? graph.getChildren(ni.key) : graph.getParents(ni.key))
.map(function (nk) { return graph.getNode(nk).position; });
nodePositions[ni.key] = _this.getNodePosition(adjacentNodesPositions);
});
order[layer] = this_2.sortNodes(nodePositions, graph);
};
var this_2 = this;
for (var layer in current) {
_loop_3(layer);
}
return order;
};
SugiyamaNodesOrderer.prototype.sortNodes = function (nodePositions, graph) {
return Object.keys(nodePositions)
.sort(function (a, b) { return nodePositions[a] - nodePositions[b]; })
.map(function (nk, index) {
var node = graph.getNode(nk);
node.position = index;
return node;
});
};
SugiyamaNodesOrderer.prototype.getNodePosition = function (adjacentNodesPositions) {
adjacentNodesPositions = adjacentNodesPositions.sort();
if (!adjacentNodesPositions.length)
return 0;
var medianIndex = Math.floor(adjacentNodesPositions.length / 2);
if (adjacentNodesPositions.length === 2 || adjacentNodesPositions.length % 2 === 1)
return adjacentNodesPositions[medianIndex];
var leftMedianPosition = adjacentNodesPositions[medianIndex - 1] - adjacentNodesPositions[0];
var rightMedianPosition = adjacentNodesPositions[adjacentNodesPositions.length - 1] - adjacentNodesPositions[medianIndex];
return Math.floor((adjacentNodesPositions[medianIndex - 1] * rightMedianPosition + adjacentNodesPositions[medianIndex] * leftMedianPosition) /
(leftMedianPosition + rightMedianPosition));
};
SugiyamaNodesOrderer.prototype.initOrder = function (nodeInfos) {
var result = {};
nodeInfos.forEach(function (ni) { return (result[ni.layer] || (result[ni.layer] = [])).push(ni); });
return result;
};
SugiyamaNodesOrderer.prototype.getCrossCount = function (orderInfo, graph) {
var count = 0;
var _loop_4 = function (layer) {
if (!orderInfo.hasOwnProperty(layer))
return "continue";
var viewedAdjacentNodesPositions = [];
orderInfo[layer].forEach(function (n) {
var positions = graph.getChildren(n.key).map(function (c) { return graph.getNode(c).position; });
positions.forEach(function (p) {
count += viewedAdjacentNodesPositions.filter(function (vp) { return p < vp; }).length;
});
viewedAdjacentNodesPositions.push.apply(viewedAdjacentNodesPositions, positions);
});
};
for (var layer in orderInfo) {
_loop_4(layer);
}
return count;
};
SugiyamaNodesOrderer.prototype.initGraphInfo = function (graph, layers) {
var _this = this;
var countNodesOnLayer = {};
var nodesInfoMap = {};
var nodeInfos = [];
var edgeInfos = [];
graph.nodes.forEach(function (n) {
var layer = layers[n];
if (countNodesOnLayer[layer] === undefined)
countNodesOnLayer[layer] = 0;
var info = new NodeOnLayer(n, false, layer, countNodesOnLayer[layer]++);
nodesInfoMap[n] = info;
nodeInfos.push(info);
});
graph.edges.forEach(function (e) {
var span = layers[e.to] - layers[e.from];
if (span > 1) {
var prevNodeInfo = nodesInfoMap[e.from];
for (var delta = 1; delta < span; delta++) {
var dNodeInfo = new NodeOnLayer(_this.createDummyID(), true, layers[e.from] + delta, countNodesOnLayer[layers[e.from] + delta]++);
edgeInfos.push(new EdgeOnLayer(_this.createDummyID(), true, prevNodeInfo.key, dNodeInfo.key));
nodeInfos.push(dNodeInfo);
prevNodeInfo = dNodeInfo;
}
edgeInfos.push(new EdgeOnLayer(e.key, false, prevNodeInfo.key, nodesInfoMap[e.to].key, nodesInfoMap[e.from].key));
}
else
edgeInfos.push(new EdgeOnLayer(e.key, false, nodesInfoMap[e.from].key, nodesInfoMap[e.to].key));
});
return new Graph_1.FastGraph(nodeInfos, edgeInfos);
};
SugiyamaNodesOrderer.prototype.createDummyID = function () {
return "dummy_" + --this.idCounter;
};
SugiyamaNodesOrderer.prototype.getNodeToPositionMap = function (nodeInfos) {
return nodeInfos.reduce(function (acc, ni) {
acc[ni.key] = ni.position;
return acc;
}, {});
};
// absolute positioning
SugiyamaNodesOrderer.prototype.assignAbsCoordinates = function (graph) {
var absCoordinates = this.getAbsCoodinate(graph);
return new Graph_1.FastGraph(graph.items.map(function (n) { return new NodeOnLayer(n.key, n.isDummy, n.layer, absCoordinates[n.key]); }), graph.edges.slice(0));
};
SugiyamaNodesOrderer.prototype.getAbsCoodinate = function (graph) {
var _this = this;
var orderInfo = graph.items.reduce(function (acc, n) {
acc[n.layer] = acc[n.layer] || [];
var pos = Utils_1.Utils.binaryIndexOf(acc[n.layer], function (ni) { return ni.position - n.position; });
acc[n.layer].splice(pos < 0 ? ~pos : pos, 0, n);
return acc;
}, {});
var medianPositions = [MedianAlignmentMode.TopLeft, MedianAlignmentMode.TopRight, MedianAlignmentMode.BottomLeft, MedianAlignmentMode.BottomRight]
.map(function (alignment) { return _this.getPositionByMedian(graph, alignment, orderInfo); });
var nodeToPosition = {};
graph.items.forEach(function (n) {
var posList = medianPositions.map(function (positions) { return positions[n.key]; }).sort();
nodeToPosition[n.key] = (posList[1] + posList[2]) / 2;
});
return nodeToPosition;
};
SugiyamaNodesOrderer.prototype.getPositionByMedian = function (graph, alignment, orderInfo) {
var nodeInfos = graph.items;
var positions = this.getNodeToPositionMap(nodeInfos);
var medians = this.getMedians(graph, nodeInfos, alignment);
medians = this.resolveMedianConflicts(graph, orderInfo, medians, alignment);
this.getSortedBlocks(graph, nodeInfos, medians, alignment)
.forEach(function (block) {
var maxPos = block.reduce(function (acc, n) { return positions[n.key] > acc ? positions[n.key] : acc; }, -2);
block.forEach(function (n) {
var delta = maxPos - positions[n.key];
if (delta > 0) {
orderInfo[n.layer]
.filter(function (ln) { return ln.position > n.position; })
.forEach(function (ln) { return positions[ln.key] += delta; });
}
positions[n.key] = maxPos;
});
});
return positions;
};
SugiyamaNodesOrderer.prototype.getSortedBlocks = function (graph, nodeInfos, medians, alignment) {
var blocks = [];
var isBottom = alignment === MedianAlignmentMode.BottomLeft || alignment === MedianAlignmentMode.BottomRight;
var allNodesInfo = new ListUtils_1.HashSet(nodeInfos.slice(0).sort(function (a, b) { return isBottom ? (a.layer - b.layer) : (b.layer - a.layer); }), function (n) { return n.key; });
while (allNodesInfo.length) {
var firstNode = allNodesInfo.item(0);
var block = this.getBlock(graph, firstNode, medians, alignment);
blocks.push(block);
block.forEach(function (n) { return allNodesInfo.remove(n); });
}
blocks.sort(function (x, y) {
var xMinNodeInfo = x.reduce(function (min, n) { return n.position < min.position ? n : min; }, x[0]);
var yOnMinXLayer = y.filter(function (n) { return n.layer == xMinNodeInfo.layer; })[0];
if (yOnMinXLayer)
return xMinNodeInfo.position - yOnMinXLayer.position;
var yMinNodeInfo = y.reduce(function (min, n) { return n.position < min.position ? n : min; }, y[0]);
var xOnMinXLayer = x.filter(function (n) { return n.layer == yMinNodeInfo.layer; })[0];
if (xOnMinXLayer)
return xOnMinXLayer.position - yMinNodeInfo.position;
return xMinNodeInfo.layer - yMinNodeInfo.layer;
});
return blocks;
};
SugiyamaNodesOrderer.prototype.getBlock = function (graph, root, medians, alignment) {
var block = [];
var median = null;
do {
if (median)
root = alignment === MedianAlignmentMode.TopLeft || alignment === MedianAlignmentMode.TopRight ? graph.getNode(median.from) : graph.getNode(median.to);
block.push(root);
median = medians[root.key];
} while (median);
return block;
};
SugiyamaNodesOrderer.prototype.resolveMedianConflicts = function (graph, layers, medians, alignment) {
var _this = this;
var filteredMedians = {};
var _loop_5 = function (layer) {
var minPos = undefined, maxPos = undefined;
if (!layers.hasOwnProperty(layer))
return "continue";
var nodeInfos = layers[layer];
if (alignment === MedianAlignmentMode.TopRight || alignment === MedianAlignmentMode.BottomRight)
nodeInfos = nodeInfos.slice(0).sort(function (a, b) { return b.position - a.position; }); // sorted descending
nodeInfos.forEach(function (n) {
var median = medians[n.key];
if (!median)
filteredMedians[n.key] = null;
else {
var medianItemKey = alignment === MedianAlignmentMode.TopLeft || alignment === MedianAlignmentMode.TopRight ? median.from : median.to;
var medianPosition = graph.getNode(medianItemKey).position;
if (_this.checkMedianConfict(minPos, maxPos, medianPosition, alignment))
filteredMedians[n.key] = null;
else {
minPos = minPos === undefined ? medianPosition : Math.min(minPos, medianPosition);
maxPos = maxPos === undefined ? medianPosition : Math.max(maxPos, medianPosition);
filteredMedians[n.key] = median;
}
}
});
};
for (var layer in layers) {
_loop_5(layer);
}
return filteredMedians;
};
SugiyamaNodesOrderer.prototype.checkMedianConfict = function (min, max, medianPosition, alignment) {
if (min === undefined || max === undefined)
return false;
if (alignment === MedianAlignmentMode.TopLeft || alignment === MedianAlignmentMode.BottomLeft)
return max >= medianPosition;
return min <= medianPosition;
};
SugiyamaNodesOrderer.prototype.getMedians = function (graph, nodeInfos, alignment) {
var _this = this;
var medians = {};
nodeInfos.forEach(function (n) {
var actualAdjacentEdges = _this.getActualAdjacentEdges(graph, n, alignment);
var medianPosition = _this.getMedianPosition(actualAdjacentEdges.length, alignment);
medians[n.key] = actualAdjacentEdges[medianPosition];
});
return medians;
};
SugiyamaNodesOrderer.prototype.getMedianPosition = function (length, alignment) {
if (length === 0)
return -1;
if (length % 2 !== 0)
return Math.floor(length / 2);
if (alignment === MedianAlignmentMode.TopLeft || alignment === MedianAlignmentMode.BottomLeft)
return Math.floor(length / 2) - 1;
if (alignment === MedianAlignmentMode.TopRight || alignment === MedianAlignmentMode.BottomRight)
return Math.floor(length / 2);
throw new Error("Invalid Operation");
};
SugiyamaNodesOrderer.prototype.getActualAdjacentEdges = function (graph, node, alignment) {
if (alignment === MedianAlignmentMode.TopLeft || alignment === MedianAlignmentMode.TopRight)
return graph.getAdjacentEdges(node.key, Structures_1.ConnectionMode.Incoming).sort(function (a, b) { return graph.getNode(a.from).position - graph.getNode(b.from).position; });
return graph.getAdjacentEdges(node.key, Structures_1.ConnectionMode.Outgoing).sort(function (a, b) { return graph.getNode(a.to).position - graph.getNode(b.to).position; });
};
return SugiyamaNodesOrderer;
}());
exports.SugiyamaNodesOrderer = SugiyamaNodesOrderer;
var NodeOnLayer = /** @class */ (function () {
function NodeOnLayer(key, isDummy, layer, position) {
this.key = key;
this.isDummy = isDummy;
this.layer = layer;
this.position = position;
}
NodeOnLayer.prototype.getHashCode = function () {
return this.key.toString();
};
return NodeOnLayer;
}());
exports.NodeOnLayer = NodeOnLayer;
var EdgeOnLayer = /** @class */ (function () {
function EdgeOnLayer(key, isDummy, from, to, originFrom) {
this.key = key;
this.isDummy = isDummy;
this.from = from;
this.to = to;
this._originFrom = originFrom;
}
EdgeOnLayer.prototype.getHashCode = function () {
return this.from + "-" + this.to;
};
Object.defineProperty(EdgeOnLayer.prototype, "originFrom", {
get: function () {
return this._originFrom !== undefined ? this._originFrom : this.from;
},
enumerable: true,
configurable: true
});
return EdgeOnLayer;
}());
exports.EdgeOnLayer = EdgeOnLayer;
var MedianAlignmentMode;
(function (MedianAlignmentMode) {
MedianAlignmentMode[MedianAlignmentMode["TopLeft"] = 0] = "TopLeft";
MedianAlignmentMode[MedianAlignmentMode["TopRight"] = 1] = "TopRight";
MedianAlignmentMode[MedianAlignmentMode["BottomLeft"] = 2] = "BottomLeft";
MedianAlignmentMode[MedianAlignmentMode["BottomRight"] = 3] = "BottomRight";
})(MedianAlignmentMode || (MedianAlignmentMode = {}));
function trunc(val) {
if (Math.trunc)
return Math.trunc(val);
if (!isFinite(val))
return val;
return (val - val % 1) || (val < 0 ? -0 : val === 0 ? val : 0);
}
/***/ }),
/* 62 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Browser_1 = __webpack_require__(23);
var Base_1 = __webpack_require__(17);
var TouchUIHelper = /** @class */ (function () {
function TouchUIHelper() {
}
TouchUIHelper.onEventAttachingToDocument = function (eventName, func) {
if (Browser_1.Browser.MacOSMobilePlatform && TouchUIHelper.isTouchEventName(eventName)) {
if (!TouchUIHelper.documentTouchHandlers[eventName])
TouchUIHelper.documentTouchHandlers[eventName] = [];
TouchUIHelper.documentTouchHandlers[eventName].push(func);
return TouchUIHelper.documentEventAttachingAllowed;
}
return true;
};
TouchUIHelper.isTouchEventName = function (eventName) {
return Browser_1.Browser.WebKitTouchUI && (eventName.indexOf("touch") > -1 || eventName.indexOf("gesture") > -1);
};
TouchUIHelper.isTouchEvent = function (evt) {
if (!evt)
return false;
return Browser_1.Browser.WebKitTouchUI && Base_1.IsExists(evt.changedTouches);
};
TouchUIHelper.getEventX = function (evt) {
return Browser_1.Browser.IE ? evt.pageX : evt.changedTouches[0].pageX;
};
TouchUIHelper.getEventY = function (evt) {
return Browser_1.Browser.IE ? evt.pageY : evt.changedTouches[0].pageY;
};
TouchUIHelper.touchMouseDownEventName = Browser_1.Browser.WebKitTouchUI ? "touchstart" : (Browser_1.Browser.Edge && Browser_1.Browser.MSTouchUI && window.PointerEvent ? "pointerdown" : "mousedown");
TouchUIHelper.touchMouseUpEventName = Browser_1.Browser.WebKitTouchUI ? "touchend" : (Browser_1.Browser.Edge && Browser_1.Browser.MSTouchUI && window.PointerEvent ? "pointerup" : "mouseup");
TouchUIHelper.touchMouseMoveEventName = Browser_1.Browser.WebKitTouchUI ? "touchmove" : (Browser_1.Browser.Edge && Browser_1.Browser.MSTouchUI && window.PointerEvent ? "pointermove" : "mousemove");
TouchUIHelper.msTouchDraggableClassName = "dxMSTouchDraggable";
TouchUIHelper.documentTouchHandlers = {};
TouchUIHelper.documentEventAttachingAllowed = true;
return TouchUIHelper;
}());
exports.TouchUIHelper = TouchUIHelper;
//export class TouchUIHelper {
// isGesture: false;
// isMouseEventFromScrolling: false;
// isNativeScrollingAllowed: true;
// clickSensetivity: 10;
// documentTouchHandlers: {};
// documentEventAttachingAllowed: true;
// isTouchEvent(evt) {
// if (!evt)
// return false;
// return ASPx.Browser.WebKitTouchUI && ASPx.IsExists(evt.changedTouches);
// }
// getEventX(evt) {
// return ASPx.Browser.IE ? evt.pageX : evt.changedTouches[0].pageX;
// }
// getEventY (evt) {
// return ASPx.Browser.IE ? evt.pageY : evt.changedTouches[0].pageY;
// }
// getWebkitMajorVersion() {
// if (!this.webkitMajorVersion) {
// var regExp = new RegExp("applewebkit/(\\d+)", "i");
// var matches = regExp.exec(ASPx.Browser.UserAgent);
// if (matches && matches.index >= 1)
// this.webkitMajorVersion = matches[1];
// }
// return this.webkitMajorVersion;
// }
// getIsLandscapeOrientation() {
// if (ASPx.Browser.MacOSMobilePlatform || ASPx.Browser.AndroidMobilePlatform)
// return Math.abs(window.orientation) == 90;
// return ASPx.GetDocumentClientWidth() > ASPx.GetDocumentClientHeight();
// }
// nativeScrollingSupported() {
// var allowedSafariVersion = ASPx.Browser.Version >= 5.1 && ASPx.Browser.Version < 8; //T250059
// var allowedWebKitVersion = this.getWebkitMajorVersion() > 533 && (ASPx.Browser.Chrome || this.getWebkitMajorVersion() < 600);
// return (ASPx.Browser.MacOSMobilePlatform && (allowedSafariVersion || allowedWebKitVersion))
// || (ASPx.Browser.AndroidMobilePlatform && ASPx.Browser.PlaformMajorVersion >= 3) || (ASPx.Browser.MSTouchUI && (!ASPx.Browser.WindowsPhonePlatform || !ASPx.Browser.IE));
// }
// makeScrollableIfRequired(element, options) {
// if (ASPx.Browser.WebKitTouchUI && element) {
// var overflow = ASPx.GetCurrentStyle(element).overflow;
// if (element.tagName == "DIV" && overflow != "hidden" && overflow != "visible") {
// return this.MakeScrollable(element);
// }
// }
// }
// preventScrollOnEvent(evt) {
// }
// handleFastTapIfRequired(evt, action, preventCommonClickEvents) {
// if (ASPx.Browser.WebKitTouchUI && evt.type == 'touchstart' && action) {
// this.FastTapHelper.HandleFastTap(evt, action, preventCommonClickEvents);
// return true;
// }
// return false;
// }
// ensureDocumentSizesCorrect () {
// return (document.documentElement.clientWidth - document.documentElement.clientHeight) / (screen.width - screen.height) > 0;
// }
// ensureOrientationChanged(onOrientationChangedFunction) {
// if (ASPxClientUtils.iOSPlatform || this.ensureDocumentSizesCorrect())
// onOrientationChangedFunction();
// else {
// window.setTimeout(function () {
// this.ensureOrientationChanged(onOrientationChangedFunction);
// }.aspxBind(this), 100);
// }
// }
// onEventAttachingToDocument(eventName, func) {
// if (ASPx.Browser.MacOSMobilePlatform && this.isTouchEventName(eventName)) {
// if (!this.documentTouchHandlers[eventName])
// this.documentTouchHandlers[eventName] = [];
// this.documentTouchHandlers[eventName].push(func);
// return this.documentEventAttachingAllowed;
// }
// return true;
// }
// onEventDettachedFromDocument(eventName, func) {
// if (ASPx.Browser.MacOSMobilePlatform && this.isTouchEventName(eventName)) {
// var handlers = this.documentTouchHandlers[eventName];
// if (handlers)
// ASPx.Data.ArrayRemove(handlers, func);
// }
// }
// processDocumentTouchEventHandlers(proc) {
// var touchEventNames = ["touchstart", "touchend", "touchmove", "gesturestart", "gestureend"];
// for (var i = 0; i < touchEventNames.length; i++) {
// var eventName = touchEventNames[i];
// var handlers = this.documentTouchHandlers[eventName];
// if (handlers) {
// for (var j = 0; j < handlers.length; j++) {
// proc(eventName, handlers[j]);
// }
// }
// }
// }
// removeDocumentTouchEventHandlers() {
// if (ASPx.Browser.MacOSMobilePlatform) {
// this.documentEventAttachingAllowed = false;
// this.processDocumentTouchEventHandlers(ASPx.Evt.DetachEventFromDocumentCore);
// }
// }
// restoreDocumentTouchEventHandlers () {
// if (ASPx.Browser.MacOSMobilePlatform) {
// this.documentEventAttachingAllowed = true;
// this.processDocumentTouchEventHandlers(ASPx.Evt.AttachEventToDocumentCore);
// }
// }
// IsNativeScrolling() {
// return TouchUIHelper.nativeScrollingSupported() && TouchUIHelper.isNativeScrollingAllowed;
// }
// pointerEnabled: !!(window.PointerEvent || window.MSPointerEvent);
// pointerDownEventName: window.PointerEvent ? "pointerdown" : "MSPointerDown",
// pointerUpEventName: window.PointerEvent ? "pointerup" : "MSPointerUp",
// pointerCancelEventName: window.PointerEvent ? "pointercancel" : "MSPointerCancel",
// pointerMoveEventName: window.PointerEvent ? "pointermove" : "MSPointerMove",
// pointerOverEventName: window.PointerEvent ? "pointerover" : "MSPointerOver",
// pointerOutEventName: window.PointerEvent ? "pointerout" : "MSPointerOut",
// pointerType: {
// Touch: (ASPx.Browser.IE && ASPx.Browser.Version == 10) ? 2 : "touch",
// Pen: (ASPx.Browser.IE && ASPx.Browser.Version == 10) ? 3 : "pen",
// Mouse: (ASPx.Browser.IE && ASPx.Browser.Version == 10) ? 4 : "mouse"
// }
// msGestureEnabled: !!(window.PointerEvent || window.MSPointerEvent) && typeof (MSGesture) != "undefined";
// msTouchCreateGesturesWrapper(element, onTap) {
// if (!TouchUIHelper.msGestureEnabled)
// return;
// var gesture = new MSGesture();
// gesture.target = element;
// ASPx.Evt.AttachEventToElement(element, TouchUIHelper.pointerDownEventName, function (evt) {
// gesture.addPointer(evt.pointerId);
// });
// ASPx.Evt.AttachEventToElement(element, TouchUIHelper.pointerUpEventName, function (evt) {
// gesture.stop();
// });
// if (onTap)
// ASPx.Evt.AttachEventToElement(element, "MSGestureTap", onTap);
// return gesture;
// }
//}
/***/ }),
/* 63 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var NativeItem = /** @class */ (function () {
function NativeItem(id, key) {
this.id = id;
this.key = key;
}
return NativeItem;
}());
exports.NativeItem = NativeItem;
var NativeShape = /** @class */ (function (_super) {
__extends(NativeShape, _super);
function NativeShape() {
return _super !== null && _super.apply(this, arguments) || this;
}
return NativeShape;
}(NativeItem));
exports.NativeShape = NativeShape;
var NativeConnector = /** @class */ (function (_super) {
__extends(NativeConnector, _super);
function NativeConnector() {
return _super !== null && _super.apply(this, arguments) || this;
}
return NativeConnector;
}(NativeItem));
exports.NativeConnector = NativeConnector;
/***/ }),
/* 64 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var UnitConverter_1 = __webpack_require__(13);
var RenderManager_1 = __webpack_require__(12);
var Primitive_1 = __webpack_require__(18);
var Utils_1 = __webpack_require__(15);
var TextPrimitive = /** @class */ (function (_super) {
__extends(TextPrimitive, _super);
function TextPrimitive(x, y, text, width, style, reverseTextAhchor, clipPathId, filterId, rotated, onApplyProperties) {
var _this = _super.call(this, style, "", clipPathId, onApplyProperties) || this;
_this.x = x;
_this.y = y;
_this.text = text;
_this.width = width;
_this.reverseTextAhchor = reverseTextAhchor;
_this.rotated = rotated;
_this.filterId = filterId;
_this.textSegmens = _this.text.split("\n").filter(function (s) { return s; });
return _this;
}
TextPrimitive.prototype.createMainElement = function () {
return document.createElementNS(RenderManager_1.svgNS, "text");
};
TextPrimitive.prototype.applyElementProperties = function (element) {
this.setUnitAttribute(element, "x", this.x);
this.setUnitAttribute(element, "y", this.y);
if (this.filterId)
element.setAttribute("filter", Utils_1.RenderUtils.getUrlPathById(this.filterId));
_super.prototype.applyElementProperties.call(this, element);
if (element.getAttribute("appliedText") !== this.text || element.getAttribute("appliedWidth") !== (this.width && this.width.toString())) {
this.createTSpanElements(element);
element.setAttribute("appliedText", this.text);
element.setAttribute("appliedWidth", (this.width && this.width.toString()));
}
else
this.prepareTSpanElements(element);
if (this.rotated) {
element.setAttribute("class", "rotated");
element.style.setProperty("transform-origin", (typeof this.x === "number" ? UnitConverter_1.UnitConverter.twipsToPixels(this.x) + "px" : this.x) + " " +
(typeof this.y === "number" ? UnitConverter_1.UnitConverter.twipsToPixels(this.y) + "px" : this.y));
}
};
TextPrimitive.prototype.createTSpanElements = function (element) {
var _this = this;
Utils_1.RenderUtils.removeContent(element);
this.textSegmens.forEach(function (txt, index) {
var tSpan = _this.createTSpanElement(element);
if (_this.width) {
var words = txt.split(" ");
var line = "", prevLine = "";
for (var i = 0; i < words.length; i++) {
line += (line.length ? " " : "") + words[i];
tSpan.textContent = line;
var lineWidth = Utils_1.RenderUtils.getSvgTextRectangle(element).width;
if (lineWidth >= _this.width && prevLine !== "") {
tSpan.textContent = prevLine;
prevLine = line = words[i];
tSpan = _this.createTSpanElement(element);
tSpan.textContent = line;
}
else {
prevLine = line;
}
}
}
else {
tSpan.textContent = txt;
}
});
var firstTSpan = element.firstChild;
if (firstTSpan)
this.prepareFirstTSpanElement(firstTSpan, element.childNodes.length);
};
TextPrimitive.prototype.createTSpanElement = function (parent) {
var tSpan = document.createElementNS(RenderManager_1.svgNS, "tspan");
parent.appendChild(tSpan);
this.prepareTSpanElement(tSpan);
return tSpan;
};
TextPrimitive.prototype.prepareTSpanElements = function (element) {
for (var i = 0; i < element.childNodes.length; i++) {
var tSpan = element.childNodes[i];
this.prepareTSpanElement(tSpan);
}
var firstTSpan = element.firstChild;
if (firstTSpan)
this.prepareFirstTSpanElement(firstTSpan, element.childNodes.length);
};
TextPrimitive.prototype.prepareTSpanElement = function (tSpan) {
this.setUnitAttribute(tSpan, "x", this.x);
tSpan.setAttribute("dy", "1.05em");
};
TextPrimitive.prototype.prepareFirstTSpanElement = function (tSpan, lineCount) {
var dy = -((lineCount - 1) / 2) + TextPrimitive.baselineCorrection;
tSpan.setAttribute("dy", dy.toFixed(2) + "em");
};
TextPrimitive.prototype.applyElementStyleProperties = function (element) {
this.applyElementStylePropertiesCore(element, this.reverseTextAhchor);
};
TextPrimitive.baselineCorrection = 0.35;
return TextPrimitive;
}(Primitive_1.SvgPrimitive));
exports.TextPrimitive = TextPrimitive;
/***/ }),
/* 65 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeDescription_1 = __webpack_require__(9);
var Utils_1 = __webpack_require__(0);
var ShapeParameters_1 = __webpack_require__(29);
var DiagramItem_1 = __webpack_require__(4);
exports.ArrowVerticalTriangleHeightParameterName = "th";
exports.ArrowVerticalLineWidthParameterName = "lw";
var ArrowVerticalShapeDescription = /** @class */ (function (_super) {
__extends(ArrowVerticalShapeDescription, _super);
function ArrowVerticalShapeDescription(title) {
return _super.call(this, title, "", new Utils_1.Size(ShapeDescription_1.ShapeDefaultDimension * 0.375, ShapeDescription_1.ShapeDefaultDimension)) || this;
}
ArrowVerticalShapeDescription.prototype.createParameters = function (parameters) {
parameters.addRange([
new ShapeParameters_1.ShapeParameter(exports.ArrowVerticalTriangleHeightParameterName, Math.sqrt(Math.pow(this.defaultSize.width, 2) - Math.pow(this.defaultSize.width / 2, 2))),
new ShapeParameters_1.ShapeParameter(exports.ArrowVerticalLineWidthParameterName, this.defaultSize.width / 3)
]);
};
ArrowVerticalShapeDescription.prototype.normalizeParameters = function (shape, parameters) {
this.changeParameterValue(parameters, exports.ArrowVerticalTriangleHeightParameterName, function (p) { return Math.max(0, Math.min(shape.size.height, p.value)); });
this.changeParameterValue(parameters, exports.ArrowVerticalLineWidthParameterName, function (p) { return Math.max(0, Math.min(shape.size.width, p.value)); });
};
ArrowVerticalShapeDescription.prototype.processConnectionPoint = function (shape, point) {
var delta = (shape.size.width - shape.parameters.get(exports.ArrowVerticalLineWidthParameterName).value) / 2;
var side = shape.getConnectionPointSide(point);
if (side === DiagramItem_1.ConnectionPointSide.East)
point.x -= delta;
else if (side === DiagramItem_1.ConnectionPointSide.West)
point.x += delta;
};
return ArrowVerticalShapeDescription;
}(ShapeDescription_1.ShapeDescription));
exports.ArrowVerticalShapeDescription = ArrowVerticalShapeDescription;
/***/ }),
/* 66 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeDescription_1 = __webpack_require__(9);
var Utils_1 = __webpack_require__(0);
var ShapeParameters_1 = __webpack_require__(29);
var DiagramItem_1 = __webpack_require__(4);
exports.ArrowVerticalTriangleWidthParameterName = "tw";
exports.ArrowVerticalLineHeightParameterName = "lh";
var ArrowHorizontalShapeDescription = /** @class */ (function (_super) {
__extends(ArrowHorizontalShapeDescription, _super);
function ArrowHorizontalShapeDescription(title) {
return _super.call(this, title, "", new Utils_1.Size(ShapeDescription_1.ShapeDefaultDimension, ShapeDescription_1.ShapeDefaultDimension * 0.375)) || this;
}
ArrowHorizontalShapeDescription.prototype.createParameters = function (parameters) {
parameters.addRange([
new ShapeParameters_1.ShapeParameter(exports.ArrowVerticalTriangleWidthParameterName, Math.sqrt(Math.pow(this.defaultSize.height, 2) - Math.pow(this.defaultSize.height / 2, 2))),
new ShapeParameters_1.ShapeParameter(exports.ArrowVerticalLineHeightParameterName, this.defaultSize.height / 3)
]);
};
ArrowHorizontalShapeDescription.prototype.normalizeParameters = function (shape, parameters) {
this.changeParameterValue(parameters, exports.ArrowVerticalTriangleWidthParameterName, function (p) { return Math.max(0, Math.min(shape.size.width, p.value)); });
this.changeParameterValue(parameters, exports.ArrowVerticalLineHeightParameterName, function (p) { return Math.max(0, Math.min(shape.size.height, p.value)); });
};
ArrowHorizontalShapeDescription.prototype.processConnectionPoint = function (shape, point) {
var delta = (shape.size.height - shape.parameters.get(exports.ArrowVerticalLineHeightParameterName).value) / 2;
var side = shape.getConnectionPointSide(point);
if (side === DiagramItem_1.ConnectionPointSide.North)
point.y += delta;
else if (side === DiagramItem_1.ConnectionPointSide.South)
point.y -= delta;
};
return ArrowHorizontalShapeDescription;
}(ShapeDescription_1.ShapeDescription));
exports.ArrowHorizontalShapeDescription = ArrowHorizontalShapeDescription;
/***/ }),
/* 67 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeDescription_1 = __webpack_require__(9);
var Utils_1 = __webpack_require__(0);
var EllipsePrimitive_1 = __webpack_require__(42);
var ShapeTypes_1 = __webpack_require__(1);
var EllipseShapeDescription = /** @class */ (function (_super) {
__extends(EllipseShapeDescription, _super);
function EllipseShapeDescription(title, defaultText) {
if (title === void 0) { title = "Ellipse"; }
if (defaultText === void 0) { defaultText = ""; }
return _super.call(this, title, defaultText, new Utils_1.Size(ShapeDescription_1.ShapeDefaultDimension, ShapeDescription_1.ShapeDefaultDimension * 0.75)) || this;
}
Object.defineProperty(EllipseShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Ellipse; },
enumerable: true,
configurable: true
});
EllipseShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var width = rect.width, height = rect.height;
var _a = rect.center, cx = _a.x, cy = _a.y;
return [
new EllipsePrimitive_1.EllipsePrimitive(cx, cy, width / 2, height / 2, shape.style),
];
};
return EllipseShapeDescription;
}(ShapeDescription_1.ShapeDescription));
exports.EllipseShapeDescription = EllipseShapeDescription;
/***/ }),
/* 68 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeDescription_1 = __webpack_require__(9);
var PolygonShapeDescription = /** @class */ (function (_super) {
__extends(PolygonShapeDescription, _super);
function PolygonShapeDescription(title, defaultText) {
var _this = _super.call(this, title, defaultText) || this;
_this.defaultSize.height = _this.calculateHeight(ShapeDescription_1.ShapeDefaultDimension);
return _this;
}
Object.defineProperty(PolygonShapeDescription.prototype, "angle", {
get: function () {
return Math.PI * (this.angleCount - 2) / this.angleCount;
},
enumerable: true,
configurable: true
});
return PolygonShapeDescription;
}(ShapeDescription_1.ShapeDescription));
exports.PolygonShapeDescription = PolygonShapeDescription;
/***/ }),
/* 69 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeDescription_1 = __webpack_require__(9);
var Utils_1 = __webpack_require__(0);
var ShapeWithImageDescription_1 = __webpack_require__(45);
var RoundedRectanglePrimitive_1 = __webpack_require__(188);
var __1 = __webpack_require__(8);
var PathPrimitive_1 = __webpack_require__(2);
var GroupPrimitive_1 = __webpack_require__(28);
var ShapeImageIndicator_1 = __webpack_require__(99);
var CardBaseDescription = /** @class */ (function (_super) {
__extends(CardBaseDescription, _super);
function CardBaseDescription(title, defaultText, defaultSize) {
if (title === void 0) { title = "Card Base"; }
if (defaultText === void 0) { defaultText = ""; }
if (defaultSize === void 0) { defaultSize = new Utils_1.Size(ShapeDescription_1.ShapeDefaultDimension, 26 / 46 * ShapeDescription_1.ShapeDefaultDimension); }
return _super.call(this, title, defaultText, defaultSize) || this;
}
CardBaseDescription.getTextMargins = function () {
return ShapeWithImageDescription_1.ShapeWithImageDescription.getImageMargins();
};
CardBaseDescription.prototype.createShapePrimitives = function (shape, forToolbox) {
var _a = shape.rectangle, left = _a.left, top = _a.top, width = _a.width, height = _a.height;
return [
new RoundedRectanglePrimitive_1.RoundedRectanglePrimitive(left, top, width, height, (forToolbox) ? 30 : 60, (forToolbox) ? 30 : 60, shape.style)
];
};
CardBaseDescription.prototype.createImagePlaceholder = function (rect) {
return [
new RoundedRectanglePrimitive_1.RoundedRectanglePrimitive(rect.left, rect.top, rect.width, rect.height, __1.UnitConverter.pixelsToTwips(2), __1.UnitConverter.pixelsToTwips(2), undefined, ShapeWithImageDescription_1.SHAPE_IMAGE_CLASSNAMES.IMAGE_PLACEHOLDER)
];
};
CardBaseDescription.prototype.createEmptyImagePrimitive = function (rect) {
return ShapeImageIndicator_1.ShapeImageIndicator.createUserIconPrimitives(rect.left, rect.top, this.defaultIconSize, __1.UnitConverter.pixelsToTwips(1), ShapeWithImageDescription_1.SHAPE_IMAGE_CLASSNAMES.USER_PIC);
};
CardBaseDescription.prototype.createWarningPrimitive = function (rect) {
return ShapeImageIndicator_1.ShapeImageIndicator.createWarningIconPrimitives(rect.left + this.defaultIconSize / 2, rect.top + this.defaultIconSize / 2, this.defaultIconSize / 2, ShapeWithImageDescription_1.SHAPE_IMAGE_CLASSNAMES.WARNING_MARK);
};
CardBaseDescription.prototype.getTextRectangle = function (rect, parameters) {
var textRectangle = rect.clone();
var textBlockOffset = this.getTextBlockOffset(rect);
if (textBlockOffset.left > 0)
textRectangle.position.x = textRectangle.left + textBlockOffset.left + CardBaseDescription.getTextMargins();
if (textBlockOffset.top > 0)
textRectangle.position.y = textRectangle.top + textBlockOffset.top + CardBaseDescription.getTextMargins();
textRectangle.size.width = textRectangle.width - textBlockOffset.right - textBlockOffset.left - CardBaseDescription.getTextMargins() * 2;
textRectangle.size.height = textRectangle.height - textBlockOffset.bottom - textBlockOffset.top - CardBaseDescription.getTextMargins() * 2;
textRectangle.position.x += CardBaseDescription.getTextMargins();
textRectangle.position.y += CardBaseDescription.getTextMargins();
if (textBlockOffset.left > 0 || textBlockOffset.right > 0)
textRectangle.size.width = Math.max(textRectangle.width - CardBaseDescription.getTextMargins(), 0);
if (textBlockOffset.top > 0 || textBlockOffset.bottom > 0)
textRectangle.size.height = Math.max(textRectangle.height - CardBaseDescription.getTextMargins(), 0);
return textRectangle;
};
CardBaseDescription.prototype.createTextPrimitives = function (shape, forToolbox) {
if (forToolbox)
return this.createGraphicalTextRepresentation(shape.rectangle);
else
return _super.prototype.createTextPrimitives.call(this, shape, forToolbox);
};
CardBaseDescription.prototype.createGraphicalTextRepresentation = function (rect) {
var textRect = Utils_1.Rectangle.create(0, 0, 0, 0);
var textBlockOffset = this.getTextBlockOffset(rect, true);
if (textBlockOffset.left > 0 || textBlockOffset.right > 0) {
var horizontalShift = (textBlockOffset.left > 0) ? rect.width / 2 : 0;
textRect.position.x = rect.left + horizontalShift + 1.5 * ShapeWithImageDescription_1.ShapeWithImageDescription.getImageMargins(true);
textRect.position.y = rect.top + 2.5 * ShapeWithImageDescription_1.ShapeWithImageDescription.getImageMargins(true);
textRect.size.width = (textBlockOffset.left || textBlockOffset.right) - 2 * ShapeWithImageDescription_1.ShapeWithImageDescription.getImageMargins(true);
textRect.size.height = rect.height - 4 * ShapeWithImageDescription_1.ShapeWithImageDescription.getImageMargins(true);
}
else {
var verticalShift = (textBlockOffset.top > 0) ? rect.height / 2 : 0;
textRect.position.x = rect.left + rect.width / 2 - (rect.width / 2 + 1) / 2;
textRect.position.y = rect.top + verticalShift + 1.5 * ShapeWithImageDescription_1.ShapeWithImageDescription.getImageMargins(true);
textRect.size.width = rect.width / 2 + 1;
textRect.size.height = (textBlockOffset.top || textBlockOffset.bottom) - 2 * ShapeWithImageDescription_1.ShapeWithImageDescription.getImageMargins(true);
}
return this.createTextRepresentationPrimitives(textRect);
};
CardBaseDescription.prototype.createTextRepresentationPrimitives = function (rect) {
var lineHeight = __1.UnitConverter.pixelsToTwips(__1.UnitConverter.twipsToPixels(rect.height / 3));
return [
new GroupPrimitive_1.GroupPrimitive([
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(rect.left, rect.top),
new PathPrimitive_1.PathPrimitiveLineToCommand(rect.left + rect.width, rect.top)
]),
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(rect.left, rect.top + lineHeight),
new PathPrimitive_1.PathPrimitiveLineToCommand(rect.left + rect.width, rect.top + lineHeight)
]),
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(rect.left, rect.top + lineHeight * 2),
new PathPrimitive_1.PathPrimitiveLineToCommand(rect.left + rect.width * 0.66, rect.top + lineHeight * 2)
])
], "dxdi-shape-text")
];
};
return CardBaseDescription;
}(ShapeWithImageDescription_1.ShapeWithImageDescription));
exports.CardBaseDescription = CardBaseDescription;
/***/ }),
/* 70 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var HashSet = /** @class */ (function () {
function HashSet(list, getHashCode) {
if (list === void 0) { list = []; }
if (getHashCode === void 0) { getHashCode = function (item) { return item.toString(); }; }
var _this = this;
this.items = [];
this.map = {};
this.getHashCode = getHashCode;
list.forEach(function (i) { return _this.tryPush(i); });
}
HashSet.prototype.tryPush = function (item) {
var code = this.getHashCode(item);
if (this.map[code] === undefined) {
this.map[code] = this.items.push(item) - 1;
return true;
}
return false;
};
HashSet.prototype.contains = function (item) {
return this.map[this.getHashCode(item)] !== undefined;
};
HashSet.prototype.forEach = function (callback) {
this.items.forEach(callback);
};
HashSet.prototype.filter = function (predicate) {
return this.items.filter(predicate);
};
HashSet.prototype.list = function () {
return this.items.slice(0);
};
HashSet.prototype.item = function (index) {
return this.items[index];
};
HashSet.prototype.first = function () {
return this.items[0];
};
HashSet.prototype.remove = function (item) {
var code = this.getHashCode(item);
var index = this.map[code];
if (typeof index === "number") {
delete this.map[code];
this.items.splice(index, 1);
for (var i = index; i < this.items.length; i++)
this.map[this.getHashCode(this.items[i])]--;
}
else
throw "Item not found";
};
Object.defineProperty(HashSet.prototype, "length", {
get: function () { return this.items.length; },
enumerable: true,
configurable: true
});
return HashSet;
}());
exports.HashSet = HashSet;
/***/ }),
/* 71 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ImportUtils = /** @class */ (function () {
function ImportUtils() {
}
ImportUtils.parseJSON = function (json) {
if (!json || json === "")
return {};
try {
return JSON.parse(json);
}
catch (_a) {
return {};
}
};
ImportUtils.createDocument = function (xml) {
var parser = new DOMParser();
return parser.parseFromString(xml, "application/xml");
};
return ImportUtils;
}());
exports.ImportUtils = ImportUtils;
/***/ }),
/* 72 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangeStylePropertyCommandBase_1 = __webpack_require__(108);
var ChangeStyleTextHistoryItem_1 = __webpack_require__(36);
var Style_1 = __webpack_require__(27);
var ChangeStyleTextPropertyCommand = /** @class */ (function (_super) {
__extends(ChangeStyleTextPropertyCommand, _super);
function ChangeStyleTextPropertyCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeStyleTextPropertyCommand.prototype.getValue = function () {
return this.control.selection.inputPosition.getStyleTextPropertyValue(this.getStyleProperty());
};
ChangeStyleTextPropertyCommand.prototype.getStyleObj = function (item) {
return item.styleText;
};
ChangeStyleTextPropertyCommand.prototype.getDefaultStyleObj = function () {
return new Style_1.StyleText();
};
ChangeStyleTextPropertyCommand.prototype.createHistoryItem = function (item, styleProperty, styleValue) {
return new ChangeStyleTextHistoryItem_1.ChangeStyleTextHistoryItem(item.key, styleProperty, styleValue);
};
ChangeStyleTextPropertyCommand.prototype.updateInputPosition = function (value) {
this.control.selection.inputPosition.setStyleTextPropertyValue(this.getStyleProperty(), value);
};
return ChangeStyleTextPropertyCommand;
}(ChangeStylePropertyCommandBase_1.ChangeStylePropertyCommandBase));
exports.ChangeStyleTextPropertyCommand = ChangeStyleTextPropertyCommand;
/***/ }),
/* 73 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Forest_1 = __webpack_require__(215);
var GraphLayout_1 = __webpack_require__(111);
var NodeLayout_1 = __webpack_require__(56);
var Utils_1 = __webpack_require__(0);
var BaseBuilder_1 = __webpack_require__(112);
var Structures_1 = __webpack_require__(31);
var DiagramItem_1 = __webpack_require__(4);
var LayoutSettings_1 = __webpack_require__(22);
var TreeLayoutBuilder = /** @class */ (function (_super) {
__extends(TreeLayoutBuilder, _super);
function TreeLayoutBuilder() {
return _super !== null && _super.apply(this, arguments) || this;
}
TreeLayoutBuilder.prototype.build = function () {
var forest = Forest_1.Forest.create(this.graph);
var layouts = [];
for (var tree = void 0, i = 0; tree = forest.trees[i]; i++) {
var layout_1 = this.processTree(tree);
layouts.push(layout_1);
}
var offset = 0, layout = new GraphLayout_1.GraphLayout();
for (var layoutComponent = void 0, i = 0; layoutComponent = layouts[i]; i++) {
layout.extend(this.setComponentOffset(layoutComponent, offset));
offset += this.getComponentOffset(layoutComponent);
}
return layout;
};
TreeLayoutBuilder.prototype.processTree = function (tree) {
var layout = new GraphLayout_1.GraphLayout();
var rootLayout = new NodeLayout_1.NodeLayout(tree.root, new Utils_1.Point(tree.root.margin.left, tree.root.margin.top));
layout.addNode(rootLayout);
this.processChildren(rootLayout, tree, layout, 0);
if (this.settings.alignment === LayoutSettings_1.Alignment.Center)
this.processParents(layout, rootLayout, tree);
return layout;
};
TreeLayoutBuilder.prototype.processChildren = function (parent, tree, layout, nearbyPoint) {
var _this = this;
var children = tree.getChildren(parent.info);
var edges = this.graph.getAdjacentEdges(parent.key, Structures_1.ConnectionMode.Outgoing);
var distantPoint = nearbyPoint;
var prevSiblingLayout;
var _loop_1 = function (child, i) {
var nearbyMargin = this_1.isVertical() ? child.margin.left : child.margin.top;
if (prevSiblingLayout) {
var prevSiblingDistantPoint = this_1.getChangingCoordinateForLayer(prevSiblingLayout.position) + this_1.getSizeMeasurement(prevSiblingLayout.info.size);
var actualNearbyMargin = distantPoint - prevSiblingDistantPoint;
nearbyMargin = Math.max(0, nearbyMargin - actualNearbyMargin);
nearbyMargin += this_1.settings.columnSpacing;
}
var layerStartingPoint = this_1.isVertical() ? Math.max(parent.info.margin.bottom, child.margin.top) : Math.max(parent.info.margin.right, child.margin.left);
var nodePosition = this_1.isVertical() ?
new Utils_1.Point(distantPoint + nearbyMargin, parent.position.y + parent.info.size.height + layerStartingPoint + this_1.settings.layerSpacing) :
new Utils_1.Point(parent.position.x + parent.info.size.width + layerStartingPoint + this_1.settings.layerSpacing, distantPoint + nearbyMargin);
var childLayout = new NodeLayout_1.NodeLayout(child, nodePosition);
distantPoint = Math.max(this_1.getChangingCoordinateForLayer(childLayout.position) + this_1.getSizeMeasurement(childLayout.info.size), this_1.processChildren(childLayout, tree, layout, distantPoint));
layout.addNode(childLayout);
edges.filter(function (e) { return e.to === child.key; }).forEach(function (e) {
var beginIndex = _this.isVertical() ? DiagramItem_1.ConnectionPointSide.South : DiagramItem_1.ConnectionPointSide.East;
var endIndex = _this.isVertical() ? DiagramItem_1.ConnectionPointSide.North : DiagramItem_1.ConnectionPointSide.West;
layout.addEdge(new NodeLayout_1.EdgeLayout(e.key, beginIndex, endIndex));
});
prevSiblingLayout = childLayout;
};
var this_1 = this;
for (var child = void 0, i = 0; child = children[i]; i++) {
_loop_1(child, i);
}
return distantPoint + this.settings.subTreeColumnSpacing;
};
TreeLayoutBuilder.prototype.processParents = function (layout, parent, tree, parentNextSibling) {
var children = tree.getChildren(parent.info);
for (var child = void 0, i = children.length - 1; child = children[i]; i--)
this.processParents(layout, layout.nodeToLayout[child.key], tree, children[i + 1]);
if (children.length) {
var nearbyPoint = this.getChangingCoordinateForLayer(layout.nodeToLayout[children[0].key].position);
var distantPoint = this.getRectangleDistantEdge(layout.nodeToLayout[children[children.length - 1].key].rectangle);
var position = nearbyPoint + (distantPoint - nearbyPoint) / 2 - this.getSizeMeasurement(parent.info.size) / 2;
position = Math.max(this.getChangingCoordinateForLayer(parent.position), this.correctByMargin(position, parent, parentNextSibling && layout.nodeToLayout[parentNextSibling.key]));
if (this.isVertical())
parent.position.x = position;
else
parent.position.y = position;
}
};
TreeLayoutBuilder.prototype.getChangingCoordinateForLayer = function (point) {
return this.isVertical() ? point.x : point.y;
};
TreeLayoutBuilder.prototype.getRectangleDistantEdge = function (rectangle) {
return this.isVertical() ? rectangle.right : rectangle.bottom;
};
TreeLayoutBuilder.prototype.getSizeMeasurement = function (size) {
return this.isVertical() ? size.width : size.height;
};
TreeLayoutBuilder.prototype.correctByMargin = function (position, element, distant) {
if (distant) {
var distantPoint = this.isVertical() ? Math.max(distant.info.margin.left, element.info.margin.right) : Math.max(distant.info.margin.top, element.info.margin.bottom);
position = Math.min(position, this.getChangingCoordinateForLayer(distant.position) - distantPoint - this.getSizeMeasurement(element.info.size));
}
return position;
};
TreeLayoutBuilder.prototype.isVertical = function () {
return this.settings.orientation === LayoutSettings_1.DataLayoutOrientation.Vertical;
};
return TreeLayoutBuilder;
}(BaseBuilder_1.LayoutBuilder));
exports.TreeLayoutBuilder = TreeLayoutBuilder;
/***/ }),
/* 74 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var CanvasItemsManager_1 = __webpack_require__(82);
var RenderManager_1 = __webpack_require__(12);
var CanvasExportManager_1 = __webpack_require__(224);
var ExportImportCommandBase_1 = __webpack_require__(47);
var Exporter_1 = __webpack_require__(57);
var ExportImageCommand = /** @class */ (function (_super) {
__extends(ExportImageCommand, _super);
function ExportImageCommand(control) {
var _this = _super.call(this, control) || this;
_this.exporter = new Exporter_1.Exporter();
return _this;
}
ExportImageCommand.prototype.executeCore = function (state, parameter) {
var _this = this;
try {
var exportManager = this.getExportManager();
var exportFunc = this.getExportFunc();
exportFunc(this.control.model.size.clone(), this.control.model.pageColor, exportManager, function (url) {
parameter(url, _this.getExtension());
_this.tryDispose();
});
}
catch (e) {
this.tryDispose();
throw e;
}
return true;
};
ExportImageCommand.prototype.getExportManager = function () {
var itemsManager = (this.control.render && this.control.render.items) || this.createItemsManager();
return this.exportManager || (this.exportManager = new CanvasExportManager_1.CanvasExportManager(itemsManager.itemsContainer));
};
ExportImageCommand.prototype.createItemsManager = function () {
this.svgElement = RenderManager_1.RenderManager.createSvgElement(document.body, true);
var canvasManager = new CanvasItemsManager_1.CanvasItemsManager(this.svgElement, 1);
this.control.modelManipulator.onModelChanged.add(canvasManager);
this.control.modelManipulator.onLoad();
return canvasManager;
};
ExportImageCommand.prototype.tryDispose = function () {
if (this.svgElement) {
document.body.removeChild(this.svgElement);
delete this.svgElement;
this.exportManager = undefined;
}
};
return ExportImageCommand;
}(ExportImportCommandBase_1.ExportImportCommandBase));
exports.ExportImageCommand = ExportImageCommand;
/***/ }),
/* 75 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var SimpleCommandBase_1 = __webpack_require__(7);
var ClipboardCommand = /** @class */ (function (_super) {
__extends(ClipboardCommand, _super);
function ClipboardCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ClipboardCommand.prototype.setClipboardData = function (data) {
if (this.control.render)
this.control.render.input.setClipboardData(data);
ClipboardCommand.clipboardData = data;
};
ClipboardCommand.prototype.getClipboardData = function (callback) {
if (this.control.render && this.isPasteSupportedByBrowser())
this.control.render.input.getClipboardData(callback);
else
callback(ClipboardCommand.clipboardData);
};
ClipboardCommand.prototype.isPasteSupportedByBrowser = function () {
return this.control.render && this.control.render.input.isPasteSupportedByBrowser();
};
return ClipboardCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.ClipboardCommand = ClipboardCommand;
/***/ }),
/* 76 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var ChangeZindexHistoryItem = /** @class */ (function (_super) {
__extends(ChangeZindexHistoryItem, _super);
function ChangeZindexHistoryItem(item, zIndex) {
var _this = _super.call(this) || this;
_this.itemKey = item.key;
_this.zIndex = zIndex;
return _this;
}
ChangeZindexHistoryItem.prototype.redo = function (manipulator) {
var item = manipulator.model.findItem(this.itemKey);
this.oldZIndex = item.zIndex;
manipulator.changeZIndex(item, this.zIndex);
};
ChangeZindexHistoryItem.prototype.undo = function (manipulator) {
var item = manipulator.model.findItem(this.itemKey);
manipulator.changeZIndex(item, this.oldZIndex);
};
return ChangeZindexHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.ChangeZindexHistoryItem = ChangeZindexHistoryItem;
/***/ }),
/* 77 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangeShapeImageHistoryItem_1 = __webpack_require__(116);
var SimpleCommandBase_1 = __webpack_require__(7);
var EditShapeImageCommandBase = /** @class */ (function (_super) {
__extends(EditShapeImageCommandBase, _super);
function EditShapeImageCommandBase() {
return _super !== null && _super.apply(this, arguments) || this;
}
EditShapeImageCommandBase.prototype.isEnabled = function () {
var selectedShape = this.getSelectedShape();
return _super.prototype.isEnabled.call(this) && selectedShape && !selectedShape.locked && selectedShape.enableImage && selectedShape.allowEditImage;
};
EditShapeImageCommandBase.prototype.getValue = function () {
var selectedShape = this.getSelectedShape();
var imageUrl = (selectedShape) ? selectedShape.image.exportUrl : undefined;
return imageUrl;
};
EditShapeImageCommandBase.prototype.getSelectedShape = function () {
var selectedShapes = this.control.selection.getSelectedShapes(true);
return (selectedShapes.length === 1) ? selectedShapes[0] : undefined;
};
EditShapeImageCommandBase.prototype.executeCore = function (state, parameter) {
this.control.history.beginTransaction();
var selectedUnlockedShapes = this.control.selection.getSelectedShapes(false);
this.control.history.addAndRedo(new ChangeShapeImageHistoryItem_1.ChangeShapeImageHistoryItem(selectedUnlockedShapes[0], parameter));
this.control.history.endTransaction();
return true;
};
return EditShapeImageCommandBase;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.EditShapeImageCommandBase = EditShapeImageCommandBase;
/***/ }),
/* 78 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ModelUtils_1 = __webpack_require__(6);
var MouseHandlerMoveShapeStateBase_1 = __webpack_require__(120);
var KeyCode_1 = __webpack_require__(16);
var MouseHandlerMoveClonedShapeState = /** @class */ (function (_super) {
__extends(MouseHandlerMoveClonedShapeState, _super);
function MouseHandlerMoveClonedShapeState(handler, history, model, selection, visualizerManager, moveStartPoint) {
var _this = _super.call(this, handler, history, model, selection, visualizerManager) || this;
_this.moveStartPoint = moveStartPoint;
return _this;
}
MouseHandlerMoveClonedShapeState.prototype.onMouseDown = function (evt) {
var dx = this.moveStartPoint ? evt.modelPoint.x - this.moveStartPoint.x : 0;
var dy = this.moveStartPoint ? evt.modelPoint.y - this.moveStartPoint.y : 0;
ModelUtils_1.ModelUtils.cloneSelectionToOffset(this.history, this.model, this.selection, dx, dy);
_super.prototype.onMouseDown.call(this, evt);
};
MouseHandlerMoveClonedShapeState.isMoveClonedShapeEvent = function (evt) {
return evt.modifiers & KeyCode_1.ModifierKey.Ctrl && evt.modifiers & KeyCode_1.ModifierKey.Shift;
};
return MouseHandlerMoveClonedShapeState;
}(MouseHandlerMoveShapeStateBase_1.MouseHandlerMoveShapeStateBase));
exports.MouseHandlerMoveClonedShapeState = MouseHandlerMoveClonedShapeState;
/***/ }),
/* 79 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var COLOR_PROPERTIES = { "stroke": true, "fill": true };
function isColorProperty(propName) {
return COLOR_PROPERTIES[propName];
}
exports.isColorProperty = isColorProperty;
/***/ }),
/* 80 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RenderManager_1 = __webpack_require__(12);
var Primitive_1 = __webpack_require__(18);
var LinePrimitive = /** @class */ (function (_super) {
__extends(LinePrimitive, _super);
function LinePrimitive(x1, y1, x2, y2, style, className, clipPathId, onApplyProperties) {
var _this = _super.call(this, style, className, clipPathId, onApplyProperties) || this;
_this.x1 = x1;
_this.y1 = y1;
_this.x2 = x2;
_this.y2 = y2;
return _this;
}
LinePrimitive.prototype.createMainElement = function () {
return document.createElementNS(RenderManager_1.svgNS, "line");
};
LinePrimitive.prototype.applyElementProperties = function (element) {
this.setUnitAttribute(element, "x1", this.x1);
this.setUnitAttribute(element, "y1", this.y1);
this.setUnitAttribute(element, "x2", this.x2);
this.setUnitAttribute(element, "y2", this.y2);
_super.prototype.applyElementProperties.call(this, element);
};
return LinePrimitive;
}(Primitive_1.SvgPrimitive));
exports.LinePrimitive = LinePrimitive;
/***/ }),
/* 81 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Base_1 = __webpack_require__(17);
var Data = /** @class */ (function () {
function Data() {
}
Data.ArrayInsert = function (array, element, position) {
if (0 <= position && position < array.length) {
for (var i = array.length; i > position; i--)
array[i] = array[i - 1];
array[position] = element;
}
else
array.push(element);
};
Data.ArrayRemove = function (array, element) {
var index = Data.ArrayIndexOf(array, element);
if (index > -1)
Data.ArrayRemoveAt(array, index);
};
Data.ArrayRemoveAt = function (array, index) {
if (index >= 0 && index < array.length) {
for (var i = index; i < array.length - 1; i++)
array[i] = array[i + 1];
array.pop();
}
};
Data.ArrayClear = function (array) {
while (array.length > 0)
array.pop();
};
Data.ArrayIndexOf = function (array, element, comparer) {
if (!comparer) {
for (var i = 0; i < array.length; i++) {
if (array[i] == element)
return i;
}
}
else {
for (var i = 0; i < array.length; i++) {
if (comparer(array[i], element))
return i;
}
}
return -1;
};
Data.ArrayContains = function (array, element) {
return Data.ArrayIndexOf(array, element) >= 0;
};
Data.ArrayEqual = function (array1, array2) {
var count1 = array1.length;
var count2 = array2.length;
if (count1 != count2)
return false;
for (var i = 0; i < count1; i++)
if (array1[i] != array2[i])
return false;
return true;
};
Data.ArraySame = function (array1, array2) {
if (array1.length !== array2.length)
return false;
return array1.every(function (elem) { return Data.ArrayContains(array2, elem); });
};
Data.ArrayGetIntegerEdgeValues = function (array) {
var arrayToSort = Data.CollectionToArray(array);
Data.ArrayIntegerAscendingSort(arrayToSort);
return {
start: arrayToSort[0],
end: arrayToSort[arrayToSort.length - 1]
};
};
Data.ArrayIntegerAscendingSort = function (array) {
Data.ArrayIntegerSort(array, false);
};
Data.ArrayIntegerSort = function (array, desc) {
array.sort(function (i1, i2) {
var res = 0;
if (i1 > i2)
res = 1;
else if (i1 < i2)
res = -1;
if (desc)
res *= -1;
return res;
});
};
Data.CollectionsUnionToArray = function (firstCollection, secondCollection) {
var result = [];
var firstCollectionLength = firstCollection.length;
var secondCollectionLength = secondCollection.length;
for (var i = 0; i < firstCollectionLength + secondCollectionLength; i++) {
if (i < firstCollectionLength)
result.push(firstCollection[i]);
else
result.push(secondCollection[i - firstCollectionLength]);
}
return result;
};
Data.CollectionToArray = function (collection) {
var array = [];
for (var i = 0; i < collection.length; i++)
array.push(collection[i]);
return array;
};
Data.CreateHashTableFromArray = function (array) {
var hash = [];
for (var i = 0; i < array.length; i++)
hash[array[i]] = 1;
return hash;
};
Data.CreateIndexHashTableFromArray = function (array) {
var hash = [];
for (var i = 0; i < array.length; i++)
hash[array[i]] = i;
return hash;
};
Data.ArrayToHash = function (array, getKeyFunc, getValueFunc) {
if (!(array instanceof Array))
return {};
return array.reduce(function (map, element, index) {
var key = getKeyFunc(element, index);
var value = getValueFunc(element, index);
map[key] = value;
return map;
}, {});
};
Data.Sum = function (array, getValueFunc) {
if (!(array instanceof Array))
return 0;
return array.reduce(function (prevValue, item) {
var value = getValueFunc ? getValueFunc(item) : item;
if (!Base_1.IsNumber(value))
value = 0;
return prevValue + value;
}, 0);
};
Data.Min = function (array, getValueFunc) { return Data.CalculateArrayMinMax(array, getValueFunc, false); };
;
Data.Max = function (array, getValueFunc) { return Data.CalculateArrayMinMax(array, getValueFunc, true); };
;
Data.NearestLeftBinarySearchComparer = function (array, index, value) {
var arrayElement = array[index];
var leftPoint = arrayElement < value;
var lastLeftPoint = leftPoint && index == array.length - 1;
var nearestLeftPoint = lastLeftPoint || (leftPoint && array[index + 1] >= value);
if (nearestLeftPoint)
return 0;
else
return arrayElement < value ? -1 : 1;
};
Data.ArrayBinarySearch = function (array, value, binarySearchComparer, startIndex, length) {
if (!binarySearchComparer)
binarySearchComparer = Data.defaultBinarySearchComparer;
if (!Base_1.IsExists(startIndex))
startIndex = 0;
if (!Base_1.IsExists(length))
length = array.length - startIndex;
var endIndex = (startIndex + length) - 1;
while (startIndex <= endIndex) {
var middle = (startIndex + ((endIndex - startIndex) >> 1));
var compareResult = binarySearchComparer(array, middle, value);
if (compareResult == 0)
return middle;
if (compareResult < 0)
startIndex = middle + 1;
else
endIndex = middle - 1;
}
return -(startIndex + 1);
};
Data.ArrayFlatten = function (arrayOfArrays) {
return [].concat.apply([], arrayOfArrays);
};
Data.GetDistinctArray = function (array) {
var resultArray = [];
for (var i = 0; i < array.length; i++) {
var currentEntry = array[i];
if (Data.ArrayIndexOf(resultArray, currentEntry) == -1) {
resultArray.push(currentEntry);
}
}
return resultArray;
};
Data.ForEach = function (arr, callback) {
if (Array.prototype.forEach) {
Array.prototype.forEach.call(arr, callback);
}
else {
for (var i = 0, len = arr.length; i < len; i++) {
callback(arr[i], i, arr);
}
}
};
Data.MergeHashTables = function (target, object) {
if (!object || typeof (object) == "string")
return target;
if (!target)
target = {};
for (var key in object)
if (key && !(key in target))
target[key] = object[key];
return target;
};
Data.Range = function (count, start) {
count = parseInt(count) || 0;
start = parseInt(start) || 0;
if (count < 0)
count = 0;
if (start < 0)
start = 0;
return Array.apply(null, Array(count)).map(function (_val, i) { return start + i; });
};
Data.CalculateArrayMinMax = function (array, getValueFunc, isMax) {
if (!(array instanceof Array))
return 0;
var startValue = isMax ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY;
return array.reduce(function (prevValue, item) {
var value = getValueFunc ? getValueFunc(item) : item;
if (!Base_1.IsNumber(value))
value = startValue;
var func = isMax ? Math.max : Math.min;
return func(value, prevValue);
}, startValue);
};
Data.defaultBinarySearchComparer = function (array, index, value) {
var arrayElement = array[index];
if (arrayElement == value)
return 0;
else
return arrayElement < value ? -1 : 1;
};
return Data;
}());
exports.Data = Data;
/***/ }),
/* 82 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ModelChange_1 = __webpack_require__(83);
var Event_1 = __webpack_require__(10);
var GroupPrimitive_1 = __webpack_require__(28);
var Utils_1 = __webpack_require__(15);
var CanvasManagerBase_1 = __webpack_require__(33);
var Shape_1 = __webpack_require__(11);
var Connector_1 = __webpack_require__(5);
var CanvasItemsManager = /** @class */ (function (_super) {
__extends(CanvasItemsManager, _super);
function CanvasItemsManager(viewElement, zoomLevel) {
var _this = _super.call(this, zoomLevel) || this;
_this.itemSelectorGroupContainers = {};
_this.itemSelectorElements = {};
_this.itemGroupContainers = {};
_this.itemElements = {};
_this.itemChildElements = {};
_this.pendingChanges = {};
_this.updatesLock = 0;
_this.initializeContainerElements(viewElement);
return _this;
}
CanvasItemsManager.prototype.initializeContainerElements = function (view) {
this.itemSelectorsContainer = this.createAndChangePrimitiveElement(new GroupPrimitive_1.GroupPrimitive([], null), view);
this.itemsContainer = this.createAndChangePrimitiveElement(new GroupPrimitive_1.GroupPrimitive([], null), view);
};
CanvasItemsManager.prototype.clear = function () {
Utils_1.RenderUtils.removeContent(this.itemSelectorsContainer);
Utils_1.RenderUtils.removeContent(this.itemsContainer);
this.itemSelectorGroupContainers = {};
this.itemSelectorElements = {};
this.itemGroupContainers = {};
this.itemElements = {};
this.itemChildElements = {};
};
CanvasItemsManager.prototype.beginUpdate = function () {
this.updatesLock++;
};
CanvasItemsManager.prototype.endUpdate = function () {
this.updatesLock--;
if (this.updatesLock === 0)
this.applyPendingChanges();
};
CanvasItemsManager.prototype.getPendingChanges = function () {
var _this = this;
return Object.keys(this.pendingChanges).map(function (key) { return _this.pendingChanges[key]; });
};
CanvasItemsManager.prototype.applyPendingChanges = function () {
var changes = this.getPendingChanges();
while (changes.length) {
var changesCount = changes.length;
this.applyPendingChangesCore(changes);
changes = this.getPendingChanges();
if (changesCount === changes.length)
break;
}
this.pendingChanges = {};
};
CanvasItemsManager.prototype.applyPendingChangesCore = function (changes) {
var _this = this;
changes.forEach(function (change) {
if (_this.applyChange(change))
delete _this.pendingChanges[change.item.key];
});
};
CanvasItemsManager.prototype.applyChange = function (change) {
var item = change.item;
var itemParent = this.getItemParent(item.zIndex, item.container && item.container.key);
if (!itemParent)
return false;
if (item instanceof Shape_1.Shape)
this.applyShapeChange(item, change.type);
else if (item instanceof Connector_1.Connector)
this.applyConnectorChange(item, change.type);
return true;
};
CanvasItemsManager.prototype.postponeChanges = function (changes) {
var _this = this;
changes.forEach(function (change) {
if (!_this.pendingChanges[change.key])
_this.pendingChanges[change.key] = change;
else {
if (change.type === ModelChange_1.ItemChangeType.Create || change.type === ModelChange_1.ItemChangeType.Remove)
_this.pendingChanges[change.key] = change;
else if (change.type === ModelChange_1.ItemChangeType.UpdateStructure) {
if (_this.pendingChanges[change.key].type === ModelChange_1.ItemChangeType.Update)
_this.pendingChanges[change.key] = change;
}
}
});
};
// Notifications
CanvasItemsManager.prototype.notifyModelChanged = function (changes) {
var _this = this;
if (this.updatesLock === 0) {
changes.forEach(function (change) {
_this.applyChange(change);
});
}
else
this.postponeChanges(changes);
};
CanvasItemsManager.prototype.notifyPageColorChanged = function (color) { };
CanvasItemsManager.prototype.notifyPageSizeChanged = function (pageSize, pageLandscape) { };
CanvasItemsManager.prototype.notifyDragStart = function (itemKeys) {
var _this = this;
itemKeys.forEach(function (itemKey) {
if (_this.itemElements[itemKey])
_this.itemElements[itemKey].style.pointerEvents = "none";
if (_this.itemChildElements[itemKey])
_this.itemChildElements[itemKey].style.pointerEvents = "none";
if (_this.itemSelectorElements[itemKey])
_this.itemSelectorElements[itemKey].style.display = "none";
});
};
CanvasItemsManager.prototype.notifyDragEnd = function (itemKeys) {
var _this = this;
itemKeys.forEach(function (itemKey) {
if (_this.itemElements[itemKey])
_this.itemElements[itemKey].style.pointerEvents = "";
if (_this.itemChildElements[itemKey])
_this.itemChildElements[itemKey].style.pointerEvents = "";
if (_this.itemSelectorElements[itemKey])
_this.itemSelectorElements[itemKey].style.display = "";
});
};
CanvasItemsManager.prototype.notifyDragScrollStart = function () { };
CanvasItemsManager.prototype.notifyDragScrollEnd = function () { };
CanvasItemsManager.prototype.notifyTextInputStart = function (item, text, position, size) {
var element = this.itemElements[item.key];
var className = element.getAttribute("class");
element.setAttribute("class", className + " text-input");
};
CanvasItemsManager.prototype.notifyTextInputEnd = function (item) {
var element = this.itemElements[item.key];
var className = element.getAttribute("class");
element.setAttribute("class", className.replace(" text-input", ""));
};
CanvasItemsManager.prototype.notifyActualZoomChanged = function (actualZoom) {
var scale = "scale(" + actualZoom + ")";
this.itemsContainer.setAttribute('transform', scale);
this.itemSelectorsContainer.setAttribute('transform', scale);
this.actualZoom = actualZoom;
};
CanvasItemsManager.prototype.notifyViewAdjusted = function (canvasOffset) { };
// Drawing
CanvasItemsManager.prototype.applyShapeChange = function (shape, type) {
var key = shape.key;
var containerKey = shape.container && shape.container.key;
var itemSelectorParent = this.getItemSelectorGroupContainer(shape.zIndex, containerKey);
var itemParent = this.getItemGroupContainer(shape.zIndex, containerKey);
var className = "shape";
if (shape.enableChildren)
className += " container";
switch (type) {
case ModelChange_1.ItemChangeType.Create:
this.itemSelectorElements[key] = this.createItemElements(key, shape.getSelectorPrimitives(), itemSelectorParent, className, Event_1.MouseEventElementType.Shape);
this.itemElements[key] = this.createItemElements(key, shape.getPrimitives(), itemParent, className, Event_1.MouseEventElementType.Shape);
if (shape.enableChildren) {
this.itemChildElements[key] = this.createItemElements(key, [], itemParent, "container-children", Event_1.MouseEventElementType.Undefined);
this.changeItemChildrenVisibility(this.itemChildElements[key], shape.expanded);
}
break;
case ModelChange_1.ItemChangeType.Remove:
this.removeItemElements(this.itemSelectorElements[key]);
delete this.itemSelectorElements[key];
this.removeItemElements(this.itemElements[key]);
delete this.itemElements[key];
if (this.itemChildElements[key]) {
this.removeItemElements(this.itemChildElements[key]);
delete this.itemChildElements[key];
delete this.itemGroupContainers[key];
delete this.itemSelectorGroupContainers[key];
}
break;
case ModelChange_1.ItemChangeType.UpdateStructure:
case ModelChange_1.ItemChangeType.Update:
this.changeItemElements(shape.getSelectorPrimitives(), this.itemSelectorElements[key], type === ModelChange_1.ItemChangeType.UpdateStructure);
this.changeItemElements(shape.getPrimitives(), this.itemElements[key], type === ModelChange_1.ItemChangeType.UpdateStructure);
if (this.itemChildElements[key]) {
this.changeItemChildrenVisibility(this.itemChildElements[key], shape.expanded);
}
if (itemSelectorParent !== (this.itemSelectorElements[key] && this.itemSelectorElements[key].parentNode))
this.moveItemElements(itemSelectorParent, this.itemSelectorElements[key]);
if (itemParent !== (this.itemElements[key] && this.itemElements[key].parentNode))
this.moveItemElements(itemParent, this.itemElements[key]);
if (this.itemChildElements[key] && (itemParent !== this.itemChildElements[key].parentNode))
this.moveItemElements(itemParent, this.itemChildElements[key]);
break;
}
};
CanvasItemsManager.prototype.applyConnectorChange = function (connector, type) {
var key = connector.key;
var containerKey = connector.container && connector.container.key;
var itemSelectorParent = this.getItemSelectorGroupContainer(connector.zIndex, containerKey);
var itemParent = this.getItemGroupContainer(connector.zIndex, containerKey);
var className = "connector";
switch (type) {
case ModelChange_1.ItemChangeType.Create:
this.itemSelectorElements[key] = this.createItemElements(key, connector.getSelectorPrimitives(), itemSelectorParent, className, Event_1.MouseEventElementType.Connector);
this.itemElements[key] = this.createItemElements(key, connector.getPrimitives(), itemParent, className, Event_1.MouseEventElementType.Connector);
break;
case ModelChange_1.ItemChangeType.Remove:
this.removeItemElements(this.itemSelectorElements[key]);
delete this.itemSelectorElements[key];
this.removeItemElements(this.itemElements[key]);
delete this.itemElements[key];
break;
case ModelChange_1.ItemChangeType.UpdateStructure:
case ModelChange_1.ItemChangeType.Update:
this.changeItemElements(connector.getSelectorPrimitives(), this.itemSelectorElements[key], type === ModelChange_1.ItemChangeType.UpdateStructure);
this.changeItemElements(connector.getPrimitives(), this.itemElements[key], type === ModelChange_1.ItemChangeType.UpdateStructure);
if (itemSelectorParent !== (this.itemSelectorElements[key] && this.itemSelectorElements[key].parentNode))
this.moveItemElements(itemSelectorParent, this.itemSelectorElements[key]);
if (itemParent !== (this.itemElements[key] && this.itemElements[key].parentNode))
this.moveItemElements(itemParent, this.itemElements[key]);
break;
}
};
CanvasItemsManager.prototype.createItemElements = function (key, primitives, parent, className, type) {
var gEl = this.createAndChangePrimitiveElement(new GroupPrimitive_1.GroupPrimitive([], className), parent);
Utils_1.RenderUtils.setElementEventData(gEl, type, key);
this.createAndChangePrimitivesElements(primitives, gEl);
return gEl;
};
CanvasItemsManager.prototype.changeItemElements = function (primitives, element, updateStructure) {
if (updateStructure === void 0) { updateStructure = false; }
if (updateStructure) {
Utils_1.RenderUtils.removeContent(element);
this.createAndChangePrimitivesElements(primitives, element);
}
else
this.changePrimitivesElements(primitives, element);
};
CanvasItemsManager.prototype.removeItemElements = function (element) {
if (element && element.parentNode)
element.parentNode.removeChild(element);
};
CanvasItemsManager.prototype.moveItemElements = function (parent, element, sibling) {
if (element && parent) {
if (sibling)
parent.insertBefore(element, sibling);
else
parent.appendChild(element);
}
};
CanvasItemsManager.prototype.changeItemChildrenVisibility = function (element, expanded) {
element.style.display = expanded ? "" : "none";
};
CanvasItemsManager.prototype.getItemGroupContainerKey = function (zIndex, parentContainerKey) {
return parentContainerKey !== undefined ? zIndex + "_" + parentContainerKey : zIndex.toString();
};
CanvasItemsManager.prototype.getItemGroupContainer = function (zIndex, parentContainerKey) {
var parent = parentContainerKey !== undefined ? this.getItemParent(zIndex, parentContainerKey) : this.itemsContainer;
var key = parentContainerKey || "Main";
if (this.itemGroupContainers[key] === undefined || this.itemGroupContainers[key][zIndex] === undefined) {
if (this.itemGroupContainers[key] === undefined)
this.itemGroupContainers[key] = [];
this.itemGroupContainers[key][zIndex] = this.createAndChangePrimitiveElement(new GroupPrimitive_1.GroupPrimitive([], null, zIndex), parent, this.itemGroupContainers[key][zIndex + 1]);
}
return this.itemGroupContainers[key][zIndex];
};
CanvasItemsManager.prototype.getItemSelectorGroupContainer = function (zIndex, parentContainerKey) {
var parent = parentContainerKey !== undefined ? this.getItemSelectorParent(zIndex, parentContainerKey) : this.itemSelectorsContainer;
var key = parentContainerKey || "Main";
if (this.itemSelectorGroupContainers[key] === undefined || this.itemSelectorGroupContainers[key][zIndex] === undefined) {
if (this.itemSelectorGroupContainers[key] === undefined)
this.itemSelectorGroupContainers[key] = [];
this.itemSelectorGroupContainers[key][zIndex] = this.createAndChangePrimitiveElement(new GroupPrimitive_1.GroupPrimitive([], null, zIndex), parent, this.itemSelectorGroupContainers[key][zIndex + 1]);
}
return this.itemSelectorGroupContainers[key][zIndex];
};
CanvasItemsManager.prototype.getItemParent = function (zIndex, parentContainerKey) {
return parentContainerKey !== undefined ?
this.itemChildElements[parentContainerKey] :
this.getItemGroupContainer(zIndex);
};
CanvasItemsManager.prototype.getItemSelectorParent = function (zIndex, parentContainerKey) {
return parentContainerKey !== undefined ?
this.itemChildElements[parentContainerKey] :
this.getItemSelectorGroupContainer(zIndex);
};
return CanvasItemsManager;
}(CanvasManagerBase_1.CanvasManagerBase));
exports.CanvasItemsManager = CanvasItemsManager;
/***/ }),
/* 83 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ItemChangeType;
(function (ItemChangeType) {
ItemChangeType[ItemChangeType["Create"] = 0] = "Create";
ItemChangeType[ItemChangeType["Update"] = 1] = "Update";
ItemChangeType[ItemChangeType["UpdateStructure"] = 2] = "UpdateStructure";
ItemChangeType[ItemChangeType["Remove"] = 3] = "Remove";
})(ItemChangeType = exports.ItemChangeType || (exports.ItemChangeType = {}));
var ItemChange = /** @class */ (function () {
function ItemChange(item, type) {
this.item = item;
this.type = type;
}
Object.defineProperty(ItemChange.prototype, "key", {
get: function () { return this.item.key; },
enumerable: true,
configurable: true
});
return ItemChange;
}());
exports.ItemChange = ItemChange;
/***/ }),
/* 84 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RenderManager_1 = __webpack_require__(12);
var FilterPrimitive_1 = __webpack_require__(85);
var Model_1 = __webpack_require__(19);
var __1 = __webpack_require__(8);
var TextFilterPrimitive = /** @class */ (function (_super) {
__extends(TextFilterPrimitive, _super);
function TextFilterPrimitive(id, x, y, width, height) {
if (x === void 0) { x = "-0.05"; }
if (y === void 0) { y = "-0.05"; }
if (width === void 0) { width = "1.1"; }
if (height === void 0) { height = "1.1"; }
var _this = _super.call(this, id, x, y, width, height) || this;
_this.id = id;
_this.x = x;
_this.y = y;
_this.width = width;
_this.height = height;
return _this;
}
TextFilterPrimitive.prototype.createChildElements = function (parent) {
var feFlood = document.createElementNS(RenderManager_1.svgNS, "feFlood");
parent.appendChild(feFlood);
var feComposite = document.createElementNS(RenderManager_1.svgNS, "feComposite");
feComposite.setAttribute("in", "SourceGraphic");
feComposite.setAttribute("operator", "atop");
parent.appendChild(feComposite);
};
return TextFilterPrimitive;
}(FilterPrimitive_1.FilterPrimitive));
exports.TextFilterPrimitive = TextFilterPrimitive;
var TextFloodFilterPrimitive = /** @class */ (function (_super) {
__extends(TextFloodFilterPrimitive, _super);
function TextFloodFilterPrimitive(id, floodColor, x, y, width, height) {
if (x === void 0) { x = "-0.05"; }
if (y === void 0) { y = "-0.05"; }
if (width === void 0) { width = "1.1"; }
if (height === void 0) { height = "1.1"; }
var _this = _super.call(this, id, x, y, width, height) || this;
_this.id = id;
_this.floodColor = floodColor;
_this.x = x;
_this.y = y;
_this.width = width;
_this.height = height;
return _this;
}
TextFloodFilterPrimitive.prototype.applyChildrenProperties = function (element) {
for (var child = void 0, i = 0; child = element.childNodes[i]; i++) {
if (child.nodeName && child.nodeName.toUpperCase() === "FEFLOOD") {
this.prepareFEFloodNode(child);
break;
}
}
};
TextFloodFilterPrimitive.prototype.prepareFEFloodNode = function (node) {
var colorHash = __1.ColorHelper.colorToHash(this.floodColor);
node.setAttribute("flood-color", colorHash);
node.setAttribute("class", "text-filter-flood");
if (this.floodColor !== Model_1.DiagramModel.defaultPageColor)
node.style.setProperty("flood-color", colorHash);
};
return TextFloodFilterPrimitive;
}(TextFilterPrimitive));
exports.TextFloodFilterPrimitive = TextFloodFilterPrimitive;
/***/ }),
/* 85 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RenderManager_1 = __webpack_require__(12);
var Primitive_1 = __webpack_require__(18);
var FilterPrimitive = /** @class */ (function (_super) {
__extends(FilterPrimitive, _super);
function FilterPrimitive(id, x, y, width, height) {
var _this = _super.call(this) || this;
_this.id = id;
_this.x = x;
_this.y = y;
_this.width = width;
_this.height = height;
return _this;
}
FilterPrimitive.prototype.createMainElement = function () {
return document.createElementNS(RenderManager_1.svgNS, "filter");
};
FilterPrimitive.prototype.applyElementProperties = function (element) {
if (this.id)
element.setAttribute("id", this.id);
this.setUnitAttribute(element, "x", this.x);
this.setUnitAttribute(element, "y", this.y);
this.setUnitAttribute(element, "width", this.width);
this.setUnitAttribute(element, "height", this.height);
_super.prototype.applyElementProperties.call(this, element);
};
return FilterPrimitive;
}(Primitive_1.SvgPrimitive));
exports.FilterPrimitive = FilterPrimitive;
/***/ }),
/* 86 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Base64Utils = /** @class */ (function () {
function Base64Utils() {
}
Base64Utils.normalize = function (base64, mimeType) {
if (mimeType === void 0) { mimeType = "image/png"; }
if (!Base64Utils.checkPrependDataUrl(base64))
base64 = Base64Utils.prepend(base64, mimeType);
return base64;
};
Base64Utils.prepend = function (base64, mimeType) {
if (mimeType === void 0) { mimeType = "image/png"; }
return "data:" + mimeType + ";base64," + base64;
};
Base64Utils.checkPrependDataUrl = function (base64) {
return Base64Utils.dataUrl.test(base64);
};
Base64Utils.dataUrl = /data:(.*)(;(.*))?(;base64)?,/;
return Base64Utils;
}());
exports.Base64Utils = Base64Utils;
/***/ }),
/* 87 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var CanvasManagerBase_1 = __webpack_require__(33);
var GroupPrimitive_1 = __webpack_require__(28);
var Utils_1 = __webpack_require__(15);
var Event_1 = __webpack_require__(10);
var DiagramItem_1 = __webpack_require__(4);
var Utils_2 = __webpack_require__(0);
var ExtensionLinesVisualizer_1 = __webpack_require__(88);
var Shape_1 = __webpack_require__(11);
var Connector_1 = __webpack_require__(5);
var ConnectorProperties_1 = __webpack_require__(24);
var RectaglePrimitive_1 = __webpack_require__(20);
var PathPrimitive_1 = __webpack_require__(2);
var TextPrimitive_1 = __webpack_require__(64);
var MaskPrimitive_1 = __webpack_require__(140);
var TextFilterPrimitive_1 = __webpack_require__(84);
var EllipsePrimitive_1 = __webpack_require__(42);
var LinePrimitive_1 = __webpack_require__(80);
var __1 = __webpack_require__(8);
var UnitConverter_1 = __webpack_require__(13);
var MULTIPLE_SELECTION_KEY = "-1";
exports.SELECTION_ELEMENT_CLASSNAMES = {
SELECTION_RECTANGLE: "selection-rect",
CONNECTION_POINT: "connection-point",
ACTIVE: "active",
CONTAINER_TARGET: "container-target",
CONNECTION_TARGET: "connection-target",
EXTENSION_LINE: "extension-line",
CONNECTION_MARK: "connection-mark",
SELECTION_MARK: "selection-mark",
LOCKED_SELECTION_MARK: "locked-selection-mark",
ITEMS_SELECTION_RECT: "items-selection-rect",
CONNECTOR_MULTI_SELECTION: "connector-multi-selection",
CONNECTOR_SELECTION: "connector-selection",
CONNECTOR_POINT_MARK: "connector-point-mark",
CONNECTOR_SELECTION_MASK: "connector-selection-mask",
CONNECTOR_SIDE_MARK: "connector-side-mark",
ITEM_SELECTION_RECT: "item-selection-rect",
ITEM_MULTI_SELECTION: "item-multi-selection-rect"
};
var CanvasSelectionManager = /** @class */ (function (_super) {
__extends(CanvasSelectionManager, _super);
function CanvasSelectionManager(parent, zoomLevel, readOnly) {
var _this = _super.call(this, zoomLevel) || this;
_this.readOnly = readOnly;
_this.connectionPointElements = [];
_this.extensionLineElements = [];
_this.selectionMap = {};
_this.initializeContainerElements(parent);
return _this;
}
CanvasSelectionManager.prototype.initializeContainerElements = function (parent) {
this.itemSelectionContainer = this.createAndChangePrimitiveElement(new GroupPrimitive_1.GroupPrimitive([], null), parent);
this.visualizersContainer = this.createAndChangePrimitiveElement(new GroupPrimitive_1.GroupPrimitive([], null), parent);
this.selectionMarksContainer = this.createAndChangePrimitiveElement(new GroupPrimitive_1.GroupPrimitive([], null), parent);
};
CanvasSelectionManager.prototype.clear = function () {
Utils_1.RenderUtils.removeContent(this.itemSelectionContainer);
Utils_1.RenderUtils.removeContent(this.selectionMarksContainer);
Utils_1.RenderUtils.removeContent(this.visualizersContainer);
this.selectionRectElement = undefined;
this.resizeInfoElement = undefined;
this.connectionPointElements = [];
this.connectionTargetElement = undefined;
this.containerTargetElement = undefined;
this.extensionLineElements = [];
this.selectionMap = {};
};
CanvasSelectionManager.prototype.showSelectionRect = function (rect) {
var primitive = new RectaglePrimitive_1.RectanglePrimitive(rect.left, rect.top, rect.size.width, rect.size.height, null, exports.SELECTION_ELEMENT_CLASSNAMES.SELECTION_RECTANGLE);
var rectEl = this.getSelectionRectElement(primitive);
this.changePrimitiveElement(primitive, rectEl);
};
CanvasSelectionManager.prototype.hideSelectionRect = function () {
if (this.selectionRectElement !== undefined)
this.selectionRectElement.style.display = "none";
};
CanvasSelectionManager.prototype.getSelectionRectElement = function (primitive) {
if (this.selectionRectElement !== undefined)
this.selectionRectElement.style.display = "";
else
this.selectionRectElement = this.createPrimitiveElement(primitive, this.visualizersContainer);
return this.selectionRectElement;
};
CanvasSelectionManager.prototype.showResizeInfo = function (point, text) {
var rectPrimitive = new RectaglePrimitive_1.RectanglePrimitive(point.x, point.y, 0, 0);
var primitive = new GroupPrimitive_1.GroupPrimitive([
rectPrimitive,
new TextPrimitive_1.TextPrimitive(point.x, point.y, text)
], "resize-info");
var groupEl = this.getResizeInfoElement(primitive);
this.changePrimitiveElement(primitive, groupEl);
var textRect = Utils_1.RenderUtils.getSvgTextRectangle(groupEl.childNodes[1], CanvasSelectionManager.resizeInfoLineWidth)
.inflate(CanvasSelectionManager.resizeInfoTextOffset, CanvasSelectionManager.resizeInfoTextOffset);
rectPrimitive.x = textRect.left;
rectPrimitive.y = textRect.top;
rectPrimitive.width = textRect.width;
rectPrimitive.height = textRect.height;
this.changePrimitiveElement(primitive, groupEl);
};
CanvasSelectionManager.prototype.hideResizeInfo = function () {
if (this.resizeInfoElement !== undefined)
this.resizeInfoElement.style.display = "none";
};
CanvasSelectionManager.prototype.getResizeInfoElement = function (primitive) {
if (this.resizeInfoElement !== undefined)
this.resizeInfoElement.style.display = "";
else
this.resizeInfoElement = this.createPrimitiveElement(primitive, this.visualizersContainer);
return this.resizeInfoElement;
};
CanvasSelectionManager.prototype.showConnectionPoint = function (index, point, side, key, value, active) {
this.showConnectionPointCore(index * 2, point.x, point.y, CanvasSelectionManager.connectionPointLargeSize, CanvasSelectionManager.connectionPointLargeSize, Event_1.MouseEventElementType.ShapeConnectionPoint, key, value, exports.SELECTION_ELEMENT_CLASSNAMES.CONNECTION_POINT + " selector");
this.showConnectionPointCore(index * 2 + 1, point.x, point.y, CanvasSelectionManager.connectionPointSmallSize, CanvasSelectionManager.connectionPointSmallSize, Event_1.MouseEventElementType.ShapeConnectionPoint, key, value, exports.SELECTION_ELEMENT_CLASSNAMES.CONNECTION_POINT + (active ? (" " + exports.SELECTION_ELEMENT_CLASSNAMES.ACTIVE) : ""));
};
CanvasSelectionManager.prototype.showConnectionPointCore = function (index, cx, cy, rx, ry, type, key, value, className) {
var primitive = new EllipsePrimitive_1.EllipsePrimitive(cx, cy, rx, ry, null, className);
var ellEl = this.getConnectionPointElement(primitive, index);
this.changePrimitiveElement(primitive, ellEl);
Utils_1.RenderUtils.setElementEventData(ellEl, type, key, value);
};
CanvasSelectionManager.prototype.hideConnectionPoints = function () {
for (var i = 0; i < this.connectionPointElements.length; i++)
this.connectionPointElements[i].style.display = "none";
};
CanvasSelectionManager.prototype.getConnectionPointElement = function (primitive, index) {
var ellEl = this.connectionPointElements[index];
if (ellEl !== undefined)
ellEl.style.display = "";
else {
ellEl = this.createPrimitiveElement(primitive, this.visualizersContainer);
this.connectionPointElements[index] = ellEl;
}
return ellEl;
};
CanvasSelectionManager.prototype.showContainerTarget = function (index, targetRect) {
var primitive = new RectaglePrimitive_1.RectanglePrimitive(targetRect.left, targetRect.top, targetRect.width, targetRect.height, null, exports.SELECTION_ELEMENT_CLASSNAMES.CONTAINER_TARGET);
var rectEl = this.getContainerTargetElement(primitive, index);
this.changePrimitiveElement(primitive, rectEl);
};
CanvasSelectionManager.prototype.hideContainerTarget = function () {
if (this.containerTargetElement)
this.containerTargetElement.style.display = "none";
};
CanvasSelectionManager.prototype.getContainerTargetElement = function (primitive, index) {
if (this.containerTargetElement !== undefined)
this.containerTargetElement.style.display = "";
else {
this.containerTargetElement = this.createPrimitiveElement(primitive, this.itemSelectionContainer);
}
return this.containerTargetElement;
};
CanvasSelectionManager.prototype.showConnectionTarget = function (index, targetRect) {
var primitive = new RectaglePrimitive_1.RectanglePrimitive(targetRect.left, targetRect.top, targetRect.width, targetRect.height, null, exports.SELECTION_ELEMENT_CLASSNAMES.CONNECTION_TARGET);
var rectEl = this.getConnectionTargetElement(primitive, index);
this.changePrimitiveElement(primitive, rectEl);
};
CanvasSelectionManager.prototype.hideConnectionTarget = function () {
if (this.connectionTargetElement)
this.connectionTargetElement.style.display = "none";
};
CanvasSelectionManager.prototype.getConnectionTargetElement = function (primitive, index) {
if (this.connectionTargetElement !== undefined)
this.connectionTargetElement.style.display = "";
else {
this.connectionTargetElement = this.createPrimitiveElement(primitive, this.itemSelectionContainer);
}
return this.connectionTargetElement;
};
CanvasSelectionManager.prototype.showExtensionLine = function (index, type, startPoint, endPoint, text) {
var className = exports.SELECTION_ELEMENT_CLASSNAMES.EXTENSION_LINE;
if (type === ExtensionLinesVisualizer_1.ExtensionLineType.VerticalCenterAfter || type === ExtensionLinesVisualizer_1.ExtensionLineType.VerticalCenterBefore ||
type === ExtensionLinesVisualizer_1.ExtensionLineType.HorizontalCenterAbove || type === ExtensionLinesVisualizer_1.ExtensionLineType.HorizontalCenterBelow)
className += " center";
if (type === ExtensionLinesVisualizer_1.ExtensionLineType.VerticalCenterToPageCenter || type === ExtensionLinesVisualizer_1.ExtensionLineType.HorizontalCenterToPageCenter ||
type === ExtensionLinesVisualizer_1.ExtensionLineType.LeftToPageCenter || type === ExtensionLinesVisualizer_1.ExtensionLineType.RightToPageCenter ||
type === ExtensionLinesVisualizer_1.ExtensionLineType.TopToPageCenter || type === ExtensionLinesVisualizer_1.ExtensionLineType.BottomToPageCenter)
className += " page";
var x1_1 = 0, y1_1 = 0, x1_2 = 0, y1_2 = 0, x2_1 = 0, y2_1 = 0, x2_2 = 0, y2_2 = 0;
if (startPoint.y === endPoint.y) {
x1_1 = startPoint.x;
y1_1 = startPoint.y - CanvasSelectionManager.extensionLineEndingSize;
x1_2 = startPoint.x;
y1_2 = startPoint.y + CanvasSelectionManager.extensionLineEndingSize;
x2_1 = endPoint.x;
y2_1 = startPoint.y - CanvasSelectionManager.extensionLineEndingSize;
x2_2 = endPoint.x;
y2_2 = startPoint.y + CanvasSelectionManager.extensionLineEndingSize;
}
else if (startPoint.x === endPoint.x) {
x1_1 = startPoint.x - CanvasSelectionManager.extensionLineEndingSize;
y1_1 = startPoint.y;
x1_2 = startPoint.x + CanvasSelectionManager.extensionLineEndingSize;
y1_2 = startPoint.y;
x2_1 = startPoint.x - CanvasSelectionManager.extensionLineEndingSize;
y2_1 = endPoint.y;
x2_2 = startPoint.x + CanvasSelectionManager.extensionLineEndingSize;
y2_2 = endPoint.y;
}
var linePrimitives = [
new LinePrimitive_1.LinePrimitive(startPoint.x, startPoint.y, endPoint.x, endPoint.y),
new LinePrimitive_1.LinePrimitive(x1_1, y1_1, x1_2, y1_2),
new LinePrimitive_1.LinePrimitive(x2_1, y2_1, x2_2, y2_2),
new TextPrimitive_1.TextPrimitive((endPoint.x + startPoint.x) / 2, (endPoint.y + startPoint.y) / 2, text, undefined, null, false, null, CanvasManagerBase_1.PAGE_BG_TEXTFLOOR_FILTER_ID, false, function (el) {
el.style.display = text && text !== "" ? "inherit" : "none";
})
];
var primitive = new GroupPrimitive_1.GroupPrimitive(linePrimitives, className);
var ellEl = this.getExtensionLineElement(primitive, index);
this.changePrimitiveElement(primitive, ellEl);
};
CanvasSelectionManager.prototype.hideExtensionLines = function () {
for (var i = 0; i < this.extensionLineElements.length; i++) {
if (this.extensionLineElements[i])
this.extensionLineElements[i].style.display = "none";
}
};
CanvasSelectionManager.prototype.getExtensionLineElement = function (primitive, index) {
var ellEl = this.extensionLineElements[index];
if (ellEl !== undefined)
ellEl.style.display = "";
else {
ellEl = this.createPrimitiveElement(primitive, this.visualizersContainer);
this.extensionLineElements[index] = (ellEl);
}
return ellEl;
};
CanvasSelectionManager.prototype.getOrCreateShapeSelection = function (shape, usedItems) {
var element = this.selectionMap[shape.key];
if (!element) {
element = new ShapeSelectionElement(this.itemSelectionContainer, this.selectionMarksContainer, this.actualZoom, this.readOnly, shape.key, shape.isLocked, shape.rectangle, shape.allowResizeHorizontally, shape.allowResizeVertically, shape.description.getParameterPoints(shape));
this.selectionMap[shape.key] = element;
}
usedItems && (usedItems[shape.key] = true);
return element;
};
CanvasSelectionManager.prototype.getOrCreateConnectorSelection = function (connector, usedItems) {
var element = this.selectionMap[connector.key];
if (!element) {
element = new ConnectorSelectionElement(this.itemSelectionContainer, this.selectionMarksContainer, this.actualZoom, this.readOnly, connector.key, connector.isLocked, connector.rectangle, connector.getRenderPoints(), connector.styleText, connector.enableText, connector.texts.map(function (t) {
return {
text: connector.getText(t.position),
point: connector.getTextPoint(t.position)
};
}), connector.points, connector.properties.lineOption);
this.selectionMap[connector.key] = element;
}
usedItems && (usedItems[connector.key] = true);
return element;
};
CanvasSelectionManager.prototype.getOrCreateMultipleSelection = function (usedItems) {
var element = this.selectionMap[MULTIPLE_SELECTION_KEY];
if (!element) {
element = new MultipleSelectionElement(this.itemSelectionContainer, this.selectionMarksContainer, this.actualZoom, this.readOnly);
this.selectionMap[MULTIPLE_SELECTION_KEY] = element;
}
usedItems[MULTIPLE_SELECTION_KEY] = true;
return element;
};
CanvasSelectionManager.prototype.getMultipleSelection = function () {
return this.selectionMap[MULTIPLE_SELECTION_KEY];
};
CanvasSelectionManager.prototype.updateShapeSelection = function (shape, multipleSelection) {
if (shape.key in this.selectionMap) {
var rect = shape.rectangle;
this.getOrCreateShapeSelection(shape)
.onModelChanged(shape.isLocked, rect, shape.allowResizeHorizontally, shape.allowResizeVertically, shape.description.getParameterPoints(shape));
multipleSelection && multipleSelection.onModelItemChanged(shape.key, rect);
}
};
CanvasSelectionManager.prototype.updateConnectorSelection = function (connector, multipleSelection) {
if (connector.key in this.selectionMap) {
var rect = connector.rectangle;
this.getOrCreateConnectorSelection(connector)
.onModelChanged(connector.isLocked, rect, connector.getRenderPoints(), connector.styleText, connector.enableText, connector.texts.map(function (t) {
return {
text: connector.getText(t.position),
point: connector.getTextPoint(t.position)
};
}), connector.points, connector.properties.lineOption);
multipleSelection && multipleSelection.onModelItemChanged(connector.key, rect);
}
};
CanvasSelectionManager.prototype.hideOutdatedSelection = function (updated) {
var _this = this;
Object.keys(this.selectionMap)
.filter(function (k) { return !updated[k]; })
.forEach(function (k) {
_this.selectionMap[k].destroy();
delete _this.selectionMap[k];
});
};
CanvasSelectionManager.prototype.notifySelectionChanged = function (selection) {
var _this = this;
var items = selection.getSelectedItems(true);
var changedItems = {};
var isMultipleSelection = items.length > 1;
var shapes = selection.getSelectedShapes(true);
var connectors = selection.getSelectedConnectors(true);
shapes.forEach(function (shape) { return _this.getOrCreateShapeSelection(shape, changedItems).onSelectionChanged(isMultipleSelection); });
connectors.forEach(function (connector) { return _this.getOrCreateConnectorSelection(connector, changedItems).onSelectionChanged(isMultipleSelection); });
if (isMultipleSelection)
this.getOrCreateMultipleSelection(changedItems).onSelectionChanged(!!shapes.length, items);
this.hideOutdatedSelection(changedItems);
};
CanvasSelectionManager.prototype.notifyModelChanged = function (changes) {
var _this = this;
var multipleSelection = this.getMultipleSelection();
changes.forEach(function (change) {
if (change.item instanceof Shape_1.Shape)
_this.updateShapeSelection(change.item, multipleSelection);
else if (change.item instanceof Connector_1.Connector)
_this.updateConnectorSelection(change.item, multipleSelection);
});
multipleSelection && multipleSelection.onModelChanged();
};
CanvasSelectionManager.prototype.notifyPageColorChanged = function (color) { };
CanvasSelectionManager.prototype.notifyPageSizeChanged = function (pageSize, pageLandscape) { };
CanvasSelectionManager.prototype.notifyActualZoomChanged = function (actualZoom) {
var _this = this;
Object.keys(this.selectionMap).forEach(function (k) { return _this.selectionMap[k].notifyZoomChanged(actualZoom); });
this.actualZoom = actualZoom;
};
CanvasSelectionManager.prototype.notifyViewAdjusted = function (canvasOffset) { };
CanvasSelectionManager.prototype.notifyReadOnlyChanged = function (readOnly) {
var _this = this;
this.readOnly = readOnly;
Object.keys(this.selectionMap).forEach(function (k) { return _this.selectionMap[k].notifyReadOnlyChanged(readOnly); });
};
CanvasSelectionManager.prototype.notifySelectionRectShow = function (rect) {
this.showSelectionRect(rect.multiply(this.actualZoom));
};
CanvasSelectionManager.prototype.notifySelectionRectHide = function () {
this.hideSelectionRect();
};
CanvasSelectionManager.prototype.notifyResizeInfoShow = function (point, text) {
this.showResizeInfo(point.multiply(this.actualZoom), text);
};
CanvasSelectionManager.prototype.notifyResizeInfoHide = function () {
this.hideResizeInfo();
};
CanvasSelectionManager.prototype.notifyConnectionPointsShow = function (key, points, activePointIndex, showOutside) {
var _this = this;
this.hideConnectionPoints();
points.forEach(function (p, index) {
var point = p.point.multiply(_this.actualZoom);
if (showOutside) {
switch (p.side) {
case DiagramItem_1.ConnectionPointSide.North:
point.y -= CanvasSelectionManager.connectionPointShift;
break;
case DiagramItem_1.ConnectionPointSide.South:
point.y += CanvasSelectionManager.connectionPointShift;
break;
case DiagramItem_1.ConnectionPointSide.East:
point.x += CanvasSelectionManager.connectionPointShift;
break;
case DiagramItem_1.ConnectionPointSide.West:
point.x -= CanvasSelectionManager.connectionPointShift;
break;
}
}
_this.showConnectionPoint(index, point, p.side, key, index, index === activePointIndex);
});
};
CanvasSelectionManager.prototype.notifyConnectionPointsHide = function () {
this.hideConnectionPoints();
};
CanvasSelectionManager.prototype.notifyConnectionTargetShow = function (key, targetRect) {
var rect = CanvasSelectionManager.correctShapeSelectionRect(targetRect.multiply(this.actualZoom), CanvasSelectionManager.connectionTargetBorderWidth, this.actualZoom);
this.showConnectionTarget(0, rect);
};
CanvasSelectionManager.prototype.notifyConnectionTargetHide = function () {
this.hideConnectionTarget();
};
CanvasSelectionManager.prototype.notifyContainerTargetShow = function (key, targetRect) {
var rect = CanvasSelectionManager.correctShapeSelectionRect(targetRect.multiply(this.actualZoom), CanvasSelectionManager.connectionTargetBorderWidth, this.actualZoom);
this.showContainerTarget(0, rect);
};
CanvasSelectionManager.prototype.notifyContainerTargetHide = function () {
this.hideContainerTarget();
};
CanvasSelectionManager.prototype.notifyExtensionLinesShow = function (lines) {
var _this = this;
this.hideExtensionLines();
lines.forEach(function (line, index) {
_this.showExtensionLine(index, line.type, line.segment.startPoint.multiply(_this.actualZoom), line.segment.endPoint.multiply(_this.actualZoom), line.text);
});
};
CanvasSelectionManager.prototype.notifyExtensionLinesHide = function () {
this.hideExtensionLines();
};
CanvasSelectionManager.prototype.notifyDragStart = function (itemKeys) {
this.selectionMarksContainer.style.display = "none";
};
CanvasSelectionManager.prototype.notifyDragEnd = function (itemKeys) {
this.selectionMarksContainer.style.display = "";
};
CanvasSelectionManager.prototype.notifyDragScrollStart = function () { };
CanvasSelectionManager.prototype.notifyDragScrollEnd = function () { };
CanvasSelectionManager.prototype.notifyTextInputStart = function (item, text, position, size) {
this.visualizersContainer.style.display = "none";
};
CanvasSelectionManager.prototype.notifyTextInputEnd = function (item) {
this.visualizersContainer.style.display = "";
};
CanvasSelectionManager.correctShapeSelectionRect = function (rect, lineWidth, zoomLevel) {
var corr = Math.ceil(Shape_1.Shape.lineWidth / 2 * zoomLevel);
rect = rect.inflate(corr, corr);
var lwCorr = Math.floor(lineWidth / 2);
rect.position.x -= lwCorr;
rect.position.y -= lwCorr;
rect.size.width += lineWidth;
rect.size.height += lineWidth;
return rect;
};
CanvasSelectionManager.selectionMarkSize = UnitConverter_1.UnitConverter.pixelsToTwips(10);
CanvasSelectionManager.lockedSelectionMarkSize = UnitConverter_1.UnitConverter.pixelsToTwips(8);
CanvasSelectionManager.selectionRectLineWidth = UnitConverter_1.UnitConverter.pixelsToTwips(1);
CanvasSelectionManager.multiSelectionRectLineWidth = UnitConverter_1.UnitConverter.pixelsToTwips(1);
CanvasSelectionManager.connectionPointSmallSize = UnitConverter_1.UnitConverter.pixelsToTwips(5);
CanvasSelectionManager.connectionPointLargeSize = UnitConverter_1.UnitConverter.pixelsToTwips(12);
CanvasSelectionManager.connectionPointShift = UnitConverter_1.UnitConverter.pixelsToTwips(16);
CanvasSelectionManager.connectionTargetBorderWidth = UnitConverter_1.UnitConverter.pixelsToTwips(2);
CanvasSelectionManager.connectorSelectionLineWidth = UnitConverter_1.UnitConverter.pixelsToTwips(1);
CanvasSelectionManager.connectorSelectionWidth = UnitConverter_1.UnitConverter.pixelsToTwips(6);
CanvasSelectionManager.geomertyMarkSize = UnitConverter_1.UnitConverter.pixelsToTwips(8);
CanvasSelectionManager.connectorPointMarkSize = UnitConverter_1.UnitConverter.pixelsToTwips(6);
CanvasSelectionManager.connectorSideMarkSize = UnitConverter_1.UnitConverter.pixelsToTwips(6);
CanvasSelectionManager.extensionLineWidth = UnitConverter_1.UnitConverter.pixelsToTwips(1);
CanvasSelectionManager.extensionLineOffset = UnitConverter_1.UnitConverter.pixelsToTwips(1);
CanvasSelectionManager.extensionLineEndingSize = UnitConverter_1.UnitConverter.pixelsToTwips(6);
CanvasSelectionManager.resizeInfoOffset = UnitConverter_1.UnitConverter.pixelsToTwips(16);
CanvasSelectionManager.resizeInfoTextOffset = UnitConverter_1.UnitConverter.pixelsToTwips(2);
CanvasSelectionManager.resizeInfoLineWidth = UnitConverter_1.UnitConverter.pixelsToTwips(1);
return CanvasSelectionManager;
}(CanvasManagerBase_1.CanvasManagerBase));
exports.CanvasSelectionManager = CanvasSelectionManager;
var CanvasElement = /** @class */ (function () {
function CanvasElement(rectsContainer, marksContainer, key, zoomLevel, readOnly) {
this.rectsContainer = rectsContainer;
this.marksContainer = marksContainer;
this.key = key;
this.zoomLevel = zoomLevel;
this.readOnly = readOnly;
this.elements = {};
this.updatedElements = {};
}
CanvasElement.prototype.notifyZoomChanged = function (zoom) {
if (this.zoomLevel !== zoom) {
this.zoomLevel = zoom;
this.redraw();
}
};
CanvasElement.prototype.notifyReadOnlyChanged = function (readOnly) {
this.readOnly = readOnly;
this.redraw();
};
CanvasElement.prototype.destroy = function () {
var _this = this;
Object.keys(this.elements)
.forEach(function (key) {
_this.elements[key].parentNode.removeChild(_this.elements[key]);
delete _this.elements[key];
});
};
CanvasElement.prototype.redraw = function () {
var _this = this;
this.updatedElements = {};
this.redrawCore();
Object.keys(this.elements)
.filter(function (key) { return !_this.updatedElements[key]; })
.forEach(function (key) {
_this.elements[key].parentNode.removeChild(_this.elements[key]);
delete _this.elements[key];
});
this.updatedElements = {};
};
CanvasElement.prototype.drawSelectionMarks = function (rect, allowResizeHorizontally, allowResizeVertically) {
if (this.readOnly)
return;
var hasEWMarks = allowResizeHorizontally && rect.height > CanvasSelectionManager.selectionMarkSize * 3;
var hasNSMarks = allowResizeVertically && rect.width > CanvasSelectionManager.selectionMarkSize * 3;
var hasCornerMarks = allowResizeHorizontally || allowResizeVertically;
if (hasCornerMarks)
this.drawSelectionMark(0, new Utils_2.Point(rect.left, rect.top), CanvasSelectionManager.selectionMarkSize, Event_1.MouseEventElementType.ShapeResizeBox, Event_1.ResizeEventSource.ResizeBox_NW, exports.SELECTION_ELEMENT_CLASSNAMES.SELECTION_MARK);
if (hasNSMarks && !__1.Browser.TouchUI)
this.drawSelectionMark(1, new Utils_2.Point(rect.left + rect.size.width / 2, rect.top), CanvasSelectionManager.selectionMarkSize, Event_1.MouseEventElementType.ShapeResizeBox, Event_1.ResizeEventSource.ResizeBox_N, exports.SELECTION_ELEMENT_CLASSNAMES.SELECTION_MARK);
if (hasCornerMarks)
this.drawSelectionMark(2, new Utils_2.Point(rect.right, rect.top), CanvasSelectionManager.selectionMarkSize, Event_1.MouseEventElementType.ShapeResizeBox, Event_1.ResizeEventSource.ResizeBox_NE, exports.SELECTION_ELEMENT_CLASSNAMES.SELECTION_MARK);
if (hasEWMarks && !__1.Browser.TouchUI)
this.drawSelectionMark(3, new Utils_2.Point(rect.right, rect.top + rect.size.height / 2), CanvasSelectionManager.selectionMarkSize, Event_1.MouseEventElementType.ShapeResizeBox, Event_1.ResizeEventSource.ResizeBox_E, exports.SELECTION_ELEMENT_CLASSNAMES.SELECTION_MARK);
if (hasCornerMarks)
this.drawSelectionMark(4, new Utils_2.Point(rect.right, rect.bottom), CanvasSelectionManager.selectionMarkSize, Event_1.MouseEventElementType.ShapeResizeBox, Event_1.ResizeEventSource.ResizeBox_SE, exports.SELECTION_ELEMENT_CLASSNAMES.SELECTION_MARK);
if (hasNSMarks && !__1.Browser.TouchUI)
this.drawSelectionMark(5, new Utils_2.Point(rect.left + rect.size.width / 2, rect.bottom), CanvasSelectionManager.selectionMarkSize, Event_1.MouseEventElementType.ShapeResizeBox, Event_1.ResizeEventSource.ResizeBox_S, exports.SELECTION_ELEMENT_CLASSNAMES.SELECTION_MARK);
if (hasCornerMarks)
this.drawSelectionMark(6, new Utils_2.Point(rect.left, rect.bottom), CanvasSelectionManager.selectionMarkSize, Event_1.MouseEventElementType.ShapeResizeBox, Event_1.ResizeEventSource.ResizeBox_SW, exports.SELECTION_ELEMENT_CLASSNAMES.SELECTION_MARK);
if (hasEWMarks && !__1.Browser.TouchUI)
this.drawSelectionMark(7, new Utils_2.Point(rect.left, rect.top + rect.size.height / 2), CanvasSelectionManager.selectionMarkSize, Event_1.MouseEventElementType.ShapeResizeBox, Event_1.ResizeEventSource.ResizeBox_W, exports.SELECTION_ELEMENT_CLASSNAMES.SELECTION_MARK);
};
CanvasElement.prototype.drawSelectionMark = function (index, point, size, type, value, className) {
var _this = this;
this.getOrCreateElement("SM" + index, new RectaglePrimitive_1.RectanglePrimitive(point.x - size / 2, point.y - size / 2, size, size, null, className, undefined, function (el) {
Utils_1.RenderUtils.setElementEventData(el, type, _this.key, value);
}), this.marksContainer);
};
CanvasElement.prototype.drawSelectionRect = function (rectangle, type, className) {
var primitive = new RectaglePrimitive_1.RectanglePrimitive(rectangle.left, rectangle.top, rectangle.width, rectangle.height, null, className, undefined, function (el) {
Utils_1.RenderUtils.setElementEventData(el, type, "-1", -1);
});
this.getOrCreateElement("shapeSelection", primitive, this.rectsContainer);
};
CanvasElement.prototype.getOrCreateElement = function (cacheKey, primitive, container) {
var element = this.elements[cacheKey];
if (!element) {
element = primitive.createElement();
this.elements[cacheKey] = element;
container.appendChild(element);
}
this.updatedElements[cacheKey] = true;
primitive.applyElementProperties(element);
return element;
};
return CanvasElement;
}());
var ItemSelectionElement = /** @class */ (function (_super) {
__extends(ItemSelectionElement, _super);
function ItemSelectionElement(rectsContainer, marksContainer, key, zoomLevel, readOnly, isLocked, rectangle) {
var _this = _super.call(this, rectsContainer, marksContainer, key, zoomLevel, readOnly) || this;
_this.isLocked = isLocked;
_this.rectangle = rectangle;
return _this;
}
ItemSelectionElement.prototype.onSelectionChanged = function (isMultipleSelection) {
if (this.isMultipleSelection !== isMultipleSelection) {
this.isMultipleSelection = isMultipleSelection;
this.redraw();
}
};
ItemSelectionElement.prototype.redrawCore = function () {
var rect = this.rectangle.multiply(this.zoomLevel);
if (this.isLockedRender())
this.drawLockedSelection(rect);
else
this.drawUnlockedSelection(rect);
};
ItemSelectionElement.prototype.isLockedRender = function () {
return this.isLocked && !this.readOnly;
};
ItemSelectionElement.prototype.drawLockedSelection = function (rect) {
this.drawLockedSelectionMark(0, new Utils_2.Point(rect.left, rect.top), CanvasSelectionManager.lockedSelectionMarkSize, exports.SELECTION_ELEMENT_CLASSNAMES.LOCKED_SELECTION_MARK);
this.drawLockedSelectionMark(1, new Utils_2.Point(rect.right, rect.top), CanvasSelectionManager.lockedSelectionMarkSize, exports.SELECTION_ELEMENT_CLASSNAMES.LOCKED_SELECTION_MARK);
this.drawLockedSelectionMark(2, new Utils_2.Point(rect.right, rect.bottom), CanvasSelectionManager.lockedSelectionMarkSize, exports.SELECTION_ELEMENT_CLASSNAMES.LOCKED_SELECTION_MARK);
this.drawLockedSelectionMark(3, new Utils_2.Point(rect.left, rect.bottom), CanvasSelectionManager.lockedSelectionMarkSize, exports.SELECTION_ELEMENT_CLASSNAMES.LOCKED_SELECTION_MARK);
};
ItemSelectionElement.prototype.drawLockedSelectionMark = function (index, point, size, className) {
var primitive = new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(point.x - size / 2, point.y - size / 2),
new PathPrimitive_1.PathPrimitiveLineToCommand(point.x + size / 2, point.y + size / 2),
new PathPrimitive_1.PathPrimitiveMoveToCommand(point.x + size / 2, point.y - size / 2),
new PathPrimitive_1.PathPrimitiveLineToCommand(point.x - size / 2, point.y + size / 2)
], null, className);
this.getOrCreateElement("LSM" + index, primitive, this.marksContainer);
};
return ItemSelectionElement;
}(CanvasElement));
var MultipleSelectionElement = /** @class */ (function (_super) {
__extends(MultipleSelectionElement, _super);
function MultipleSelectionElement(rectsContainer, marksContainer, zoomLevel, readOnly) {
var _this = _super.call(this, rectsContainer, marksContainer, "-1", zoomLevel, readOnly) || this;
_this.items = {};
return _this;
}
MultipleSelectionElement.prototype.onModelItemChanged = function (itemKey, rectangle) {
if (itemKey in this.items)
this.items[itemKey] = rectangle;
};
MultipleSelectionElement.prototype.onModelChanged = function () {
this.redraw();
};
MultipleSelectionElement.prototype.onSelectionChanged = function (containsShapes, items) {
var _this = this;
this.containsShapes = containsShapes;
this.items = {};
items.forEach(function (i) { return _this.items[i.key] = i.rectangle; });
this.redraw();
};
MultipleSelectionElement.prototype.redrawCore = function () {
var _this = this;
var rectangle = Utils_2.GeometryUtils.getCommonRectangle(Object.keys(this.items).map(function (key) { return _this.items[key]; }));
var rect = CanvasSelectionManager.correctShapeSelectionRect(rectangle.multiply(this.zoomLevel), CanvasSelectionManager.selectionRectLineWidth, this.zoomLevel);
this.drawSelectionRect(rect, Event_1.MouseEventElementType.SelectionRect, exports.SELECTION_ELEMENT_CLASSNAMES.ITEMS_SELECTION_RECT);
if (this.containsShapes)
this.drawSelectionMarks(rect, true, true);
};
return MultipleSelectionElement;
}(CanvasElement));
var ShapeSelectionElement = /** @class */ (function (_super) {
__extends(ShapeSelectionElement, _super);
function ShapeSelectionElement(rectsContainer, marksContainer, zoomLevel, readOnly, key, isLocked, rectangle, allowResizeHorizontally, allowResizeVertically, shapeParameterPoints) {
var _this = _super.call(this, rectsContainer, marksContainer, key, zoomLevel, readOnly, isLocked, rectangle) || this;
_this.allowResizeHorizontally = allowResizeHorizontally;
_this.allowResizeVertically = allowResizeVertically;
_this.shapeParameterPoints = shapeParameterPoints;
return _this;
}
ShapeSelectionElement.prototype.onModelChanged = function (isLocked, rectangle, allowResizeHorizontally, allowResizeVertically, shapeParameterPoints) {
this.isLocked = isLocked;
this.rectangle = rectangle;
this.allowResizeHorizontally = allowResizeHorizontally;
this.allowResizeVertically = allowResizeVertically;
this.shapeParameterPoints = shapeParameterPoints;
this.redraw();
};
ShapeSelectionElement.prototype.drawUnlockedSelection = function (rect) {
var shapeRect = CanvasSelectionManager.correctShapeSelectionRect(rect, CanvasSelectionManager.selectionRectLineWidth, this.zoomLevel);
this.drawSelectionRect(shapeRect, Event_1.MouseEventElementType.SelectionRect, this.isMultipleSelection ? exports.SELECTION_ELEMENT_CLASSNAMES.ITEM_MULTI_SELECTION : exports.SELECTION_ELEMENT_CLASSNAMES.ITEM_SELECTION_RECT);
if (!this.isMultipleSelection)
this.drawSelectionMarks(rect, this.allowResizeHorizontally, this.allowResizeVertically);
this.drawShapeParameterPoints();
};
ShapeSelectionElement.prototype.drawShapeParameterPoints = function () {
var _this = this;
if (this.readOnly)
return;
this.shapeParameterPoints.forEach(function (pp, index) {
var point = pp.point.multiply(_this.zoomLevel);
_this.drawShapeParameterPoint(point, index, pp.key);
});
};
ShapeSelectionElement.prototype.drawShapeParameterPoint = function (point, index, pointKey) {
var _this = this;
var size = CanvasSelectionManager.geomertyMarkSize;
var primitive = new RectaglePrimitive_1.RectanglePrimitive(point.x - size / 2, point.y - size / 2, size, size, null, "geometry-mark", undefined, function (el) {
Utils_1.RenderUtils.setElementEventData(el, Event_1.MouseEventElementType.ShapeParameterBox, _this.key, pointKey);
});
this.getOrCreateElement("pp" + index.toString(), primitive, this.marksContainer);
};
return ShapeSelectionElement;
}(ItemSelectionElement));
var ConnectorSelectionElement = /** @class */ (function (_super) {
__extends(ConnectorSelectionElement, _super);
function ConnectorSelectionElement(rectsContainer, marksContainer, zoomLevel, readOnly, key, isLocked, rectangle, renderPoints, styleText, enableText, texts, points, lineType) {
var _this = _super.call(this, rectsContainer, marksContainer, key, zoomLevel, readOnly, isLocked, rectangle) || this;
_this.renderPoints = renderPoints;
_this.styleText = styleText;
_this.enableText = enableText;
_this.texts = texts;
_this.points = points;
_this.lineType = lineType;
return _this;
}
ConnectorSelectionElement.prototype.onModelChanged = function (isLocked, rectangle, renderPoints, styleText, enableText, texts, points, lineType) {
this.isLocked = isLocked;
this.rectangle = rectangle;
this.renderPoints = renderPoints;
this.styleText = styleText;
this.enableText = enableText;
this.texts = texts;
this.points = points;
this.lineType = lineType;
this.redraw();
};
ConnectorSelectionElement.prototype.drawUnlockedSelection = function (rect) {
this.drawConnectorSelection(this.isMultipleSelection ? exports.SELECTION_ELEMENT_CLASSNAMES.CONNECTOR_MULTI_SELECTION : exports.SELECTION_ELEMENT_CLASSNAMES.CONNECTOR_SELECTION);
if (!this.isMultipleSelection && !this.readOnly)
this.drawConnectorSelectionMarks();
};
ConnectorSelectionElement.prototype.drawConnectorSelection = function (className) {
var _this = this;
var points = this.renderPoints;
var pathCommands = [];
var prevPt, firstPt, lastPt;
var difX = 0, difY = 0;
points.forEach(function (pt) {
pt = pt.multiply(_this.zoomLevel);
if (prevPt === undefined) {
firstPt = pt;
pathCommands.push(new PathPrimitive_1.PathPrimitiveMoveToCommand(pt.x, pt.y));
}
else {
pathCommands.push(new PathPrimitive_1.PathPrimitiveLineToCommand(pt.x, pt.y));
difX = Math.max(difX, Math.abs(prevPt.x - pt.x));
difY = Math.max(difY, Math.abs(prevPt.y - pt.y));
}
prevPt = pt;
});
lastPt = prevPt;
if (difX < CanvasSelectionManager.connectorSelectionLineWidth || difY < CanvasSelectionManager.connectorSelectionLineWidth) {
// Increase mask size
var offsetX = difX < CanvasSelectionManager.connectorSelectionLineWidth ? CanvasSelectionManager.connectorSelectionLineWidth : 0;
var offsetY = (difY < CanvasSelectionManager.connectorSelectionLineWidth ? CanvasSelectionManager.connectorSelectionLineWidth : 0);
pathCommands.push(new PathPrimitive_1.PathPrimitiveLineToCommand(lastPt.x - offsetX, lastPt.y - offsetY));
}
var maskId = Utils_1.RenderUtils.generateSvgElementId("maskSel");
var cliPathId = Utils_1.RenderUtils.generateSvgElementId("clipSel");
var primitive = new GroupPrimitive_1.GroupPrimitive([
new PathPrimitive_1.PathPrimitive(pathCommands, null, className, cliPathId, function (el) {
el.setAttribute("mask", Utils_1.RenderUtils.getUrlPathById(maskId));
}),
new MaskPrimitive_1.MaskPrimitive(maskId, [
new RectaglePrimitive_1.RectanglePrimitive("0", "0", "100%", "100%", null, "background"),
new PathPrimitive_1.PathPrimitive(pathCommands),
new RectaglePrimitive_1.RectanglePrimitive(firstPt.x - CanvasSelectionManager.connectorSelectionWidth / 2, firstPt.y - CanvasSelectionManager.connectorSelectionWidth / 2, CanvasSelectionManager.connectorSelectionWidth, CanvasSelectionManager.connectorSelectionWidth),
new RectaglePrimitive_1.RectanglePrimitive(lastPt.x - CanvasSelectionManager.connectorSelectionWidth / 2, lastPt.y - CanvasSelectionManager.connectorSelectionWidth / 2, CanvasSelectionManager.connectorSelectionWidth, CanvasSelectionManager.connectorSelectionWidth),
new GroupPrimitive_1.GroupPrimitive([])
], exports.SELECTION_ELEMENT_CLASSNAMES.CONNECTOR_SELECTION_MASK, "-1000%", "-1000%", "2100%", "2100%")
]);
var csElement = this.getOrCreateElement("CS", primitive, this.rectsContainer);
this.drawConnectorTextsSelection(csElement, csElement.querySelector("g"), className, maskId);
};
ConnectorSelectionElement.prototype.drawConnectorTextsSelection = function (parent, maskParent, className, maskId) {
var _this = this;
var textRects = [];
if (maskParent && this.enableText) {
this.texts.forEach(function (textObj, index) {
if (textObj.text) {
var filterId = Utils_1.RenderUtils.generateSvgElementId("filterSel");
var textPrimitive = new GroupPrimitive_1.GroupPrimitive([
new TextPrimitive_1.TextPrimitive(textObj.point.x, textObj.point.y, textObj.text, undefined, _this.styleText, true, null, filterId),
new TextFilterPrimitive_1.TextFilterPrimitive(filterId)
]);
var gTextEl = _this.getOrCreateElement("FSE" + index, textPrimitive, maskParent);
var textEl = gTextEl.querySelector("text");
var textRect = Utils_1.RenderUtils.getSvgTextRectangle(textEl, CanvasSelectionManager.connectorSelectionLineWidth);
if (textRect)
textRects.push(textRect.multiply(_this.zoomLevel));
}
});
}
for (var i = 0; i < textRects.length; i++) {
var textRectPrimitive = new RectaglePrimitive_1.RectanglePrimitive(textRects[i].left, textRects[i].top, textRects[i].width, textRects[i].height, null, className + " text", null);
this.getOrCreateElement("TR" + i, textRectPrimitive, parent);
}
};
ConnectorSelectionElement.prototype.drawConnectorSelectionMarks = function () {
var _this = this;
var pointsCount = this.points.length - 1;
this.points.forEach(function (pt, index) {
var isEdgePoint = index === 0 || index === pointsCount;
var className = isEdgePoint ? exports.SELECTION_ELEMENT_CLASSNAMES.SELECTION_MARK : exports.SELECTION_ELEMENT_CLASSNAMES.CONNECTOR_POINT_MARK;
var markSize = isEdgePoint ? CanvasSelectionManager.selectionMarkSize : CanvasSelectionManager.connectorPointMarkSize;
if (isEdgePoint || _this.lineType === ConnectorProperties_1.ConnectorLineOption.Straight) {
_this.drawSelectionMark(index, pt.multiply(_this.zoomLevel), markSize, Event_1.MouseEventElementType.ConnectorPoint, index, className);
}
else {
_this.drawSelectionMark(index, pt.multiply(_this.zoomLevel), markSize, Event_1.MouseEventElementType.Undefined, -1, className + " disabled");
}
});
this.drawConnectorSideMarks();
};
ConnectorSelectionElement.prototype.drawConnectorSideMarks = function () {
var _this = this;
var type = (this.lineType === ConnectorProperties_1.ConnectorLineOption.Straight) ?
Event_1.MouseEventElementType.ConnectorSide : Event_1.MouseEventElementType.ConnectorOrthogonalSide;
var prevPt, prevPtIndex;
this.renderPoints.filter(function (rp) { return !rp.skipped; }).forEach(function (pt, index) {
if (pt.skipped)
return;
if (prevPt !== undefined) {
if (_this.canDrawConnectorSideMark(pt, prevPt)) {
var classNameSuffix = _this.lineType === ConnectorProperties_1.ConnectorLineOption.Orthogonal ?
(pt.x - prevPt.x === 0 ? "vertical" : "horizontal") : "";
_this.drawSelectionMark(_this.points.length + index - 1, new Utils_2.Point(prevPt.x + (pt.x - prevPt.x) / 2, prevPt.y + (pt.y - prevPt.y) / 2).multiply(_this.zoomLevel), CanvasSelectionManager.connectorSideMarkSize, type, prevPtIndex + "_" + index, exports.SELECTION_ELEMENT_CLASSNAMES.CONNECTOR_SIDE_MARK + " " + classNameSuffix);
}
}
prevPt = pt;
prevPtIndex = index;
});
};
ConnectorSelectionElement.prototype.canDrawConnectorSideMark = function (point1, point2) {
if (this.lineType === ConnectorProperties_1.ConnectorLineOption.Straight) {
var minSize = CanvasSelectionManager.selectionMarkSize + CanvasSelectionManager.connectorSideMarkSize;
return Utils_2.GeometryUtils.getDistance(point1, point2) > minSize;
}
if (this.lineType === ConnectorProperties_1.ConnectorLineOption.Orthogonal) {
return ((point1.x - point2.x === 0 || Math.abs(point1.x - point2.x) > Connector_1.Connector.minOffset) &&
(point1.y - point2.y === 0 || Math.abs(point1.y - point2.y) > Connector_1.Connector.minOffset));
}
return false;
};
return ConnectorSelectionElement;
}(ItemSelectionElement));
/***/ }),
/* 88 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ExtensionLineType;
(function (ExtensionLineType) {
ExtensionLineType[ExtensionLineType["LeftToLeftAbove"] = 0] = "LeftToLeftAbove";
ExtensionLineType[ExtensionLineType["LeftToLeftBelow"] = 1] = "LeftToLeftBelow";
ExtensionLineType[ExtensionLineType["RightToRightAbove"] = 2] = "RightToRightAbove";
ExtensionLineType[ExtensionLineType["RightToRightBelow"] = 3] = "RightToRightBelow";
ExtensionLineType[ExtensionLineType["LeftToRightAbove"] = 4] = "LeftToRightAbove";
ExtensionLineType[ExtensionLineType["LeftToRightBelow"] = 5] = "LeftToRightBelow";
ExtensionLineType[ExtensionLineType["RightToLeftAbove"] = 6] = "RightToLeftAbove";
ExtensionLineType[ExtensionLineType["RightToLeftBelow"] = 7] = "RightToLeftBelow";
ExtensionLineType[ExtensionLineType["TopToTopBefore"] = 8] = "TopToTopBefore";
ExtensionLineType[ExtensionLineType["TopToTopAfter"] = 9] = "TopToTopAfter";
ExtensionLineType[ExtensionLineType["BottomToBottomBefore"] = 10] = "BottomToBottomBefore";
ExtensionLineType[ExtensionLineType["BottomToBottomAfter"] = 11] = "BottomToBottomAfter";
ExtensionLineType[ExtensionLineType["TopToBottomBefore"] = 12] = "TopToBottomBefore";
ExtensionLineType[ExtensionLineType["TopToBottomAfter"] = 13] = "TopToBottomAfter";
ExtensionLineType[ExtensionLineType["BottomToTopBefore"] = 14] = "BottomToTopBefore";
ExtensionLineType[ExtensionLineType["BottomToTopAfter"] = 15] = "BottomToTopAfter";
ExtensionLineType[ExtensionLineType["HorizontalCenterAbove"] = 16] = "HorizontalCenterAbove";
ExtensionLineType[ExtensionLineType["HorizontalCenterBelow"] = 17] = "HorizontalCenterBelow";
ExtensionLineType[ExtensionLineType["VerticalCenterBefore"] = 18] = "VerticalCenterBefore";
ExtensionLineType[ExtensionLineType["VerticalCenterAfter"] = 19] = "VerticalCenterAfter";
ExtensionLineType[ExtensionLineType["VerticalCenterToPageCenter"] = 20] = "VerticalCenterToPageCenter";
ExtensionLineType[ExtensionLineType["HorizontalCenterToPageCenter"] = 21] = "HorizontalCenterToPageCenter";
ExtensionLineType[ExtensionLineType["LeftToPageCenter"] = 22] = "LeftToPageCenter";
ExtensionLineType[ExtensionLineType["RightToPageCenter"] = 23] = "RightToPageCenter";
ExtensionLineType[ExtensionLineType["TopToPageCenter"] = 24] = "TopToPageCenter";
ExtensionLineType[ExtensionLineType["BottomToPageCenter"] = 25] = "BottomToPageCenter";
})(ExtensionLineType = exports.ExtensionLineType || (exports.ExtensionLineType = {}));
var ExtensionLine = /** @class */ (function () {
function ExtensionLine(type, segment, text) {
this.type = type;
this.segment = segment;
this.text = text;
}
return ExtensionLine;
}());
exports.ExtensionLine = ExtensionLine;
var ExtensionLinesVisualizer = /** @class */ (function () {
function ExtensionLinesVisualizer(dispatcher) {
this.dispatcher = dispatcher;
this.lines = [];
this.lineIndexByType = {};
}
ExtensionLinesVisualizer.prototype.addSegment = function (type, segment, text) {
var curIndex = this.lineIndexByType[type];
if (curIndex === undefined) {
var line = new ExtensionLine(type, segment, text);
var index = this.lines.push(line);
this.lineIndexByType[line.type] = index - 1;
this.raiseShow();
}
else if (segment.distance < this.lines[curIndex].segment.distance) {
var line = new ExtensionLine(type, segment, text);
this.lines.splice(curIndex, 1, line);
this.raiseShow();
}
};
ExtensionLinesVisualizer.prototype.update = function () {
this.raiseShow();
};
ExtensionLinesVisualizer.prototype.reset = function () {
if (this.lines.length) {
this.lines = [];
this.lineIndexByType = {};
this.raiseHide();
}
};
ExtensionLinesVisualizer.prototype.raiseShow = function () {
var _this = this;
this.dispatcher.raise1(function (l) { return l.notifyExtensionLinesShow(_this.lines); });
};
ExtensionLinesVisualizer.prototype.raiseHide = function () {
this.dispatcher.raise1(function (l) { return l.notifyExtensionLinesHide(); });
};
return ExtensionLinesVisualizer;
}());
exports.ExtensionLinesVisualizer = ExtensionLinesVisualizer;
/***/ }),
/* 89 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ConnectorPointsCalculatorBase = /** @class */ (function () {
function ConnectorPointsCalculatorBase(connector) {
this.connector = connector;
}
return ConnectorPointsCalculatorBase;
}());
exports.ConnectorPointsCalculatorBase = ConnectorPointsCalculatorBase;
/***/ }),
/* 90 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var Connector_1 = __webpack_require__(5);
var DeleteConnectionHistoryItem = /** @class */ (function (_super) {
__extends(DeleteConnectionHistoryItem, _super);
function DeleteConnectionHistoryItem(connector, position) {
var _this = _super.call(this) || this;
_this.connectorKey = connector.key;
_this.position = position;
_this.itemKey = connector.getExtremeItem(_this.position).key;
return _this;
}
DeleteConnectionHistoryItem.prototype.redo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
this.oldConnectionPointIndex = this.position === Connector_1.ConnectorPosition.Begin ? connector.beginConnectionPointIndex : connector.endConnectionPointIndex;
manipulator.deleteConnection(connector, this.position);
};
DeleteConnectionHistoryItem.prototype.undo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
var item = manipulator.model.findItem(this.itemKey);
manipulator.addConnection(connector, item, this.oldConnectionPointIndex, this.position);
};
return DeleteConnectionHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.DeleteConnectionHistoryItem = DeleteConnectionHistoryItem;
/***/ }),
/* 91 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var DeleteShapeHistoryItem = /** @class */ (function (_super) {
__extends(DeleteShapeHistoryItem, _super);
function DeleteShapeHistoryItem(shapeKey) {
var _this = _super.call(this) || this;
_this.shapeKey = shapeKey;
return _this;
}
DeleteShapeHistoryItem.prototype.redo = function (manipulator) {
var shape = manipulator.model.findShape(this.shapeKey);
this.shape = shape.clone();
manipulator.deleteShape(shape);
};
DeleteShapeHistoryItem.prototype.undo = function (manipulator) {
manipulator.addShape(this.shape, this.shape.key);
};
return DeleteShapeHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.DeleteShapeHistoryItem = DeleteShapeHistoryItem;
/***/ }),
/* 92 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeDescription_1 = __webpack_require__(9);
var PathPrimitive_1 = __webpack_require__(2);
var ShapeTypes_1 = __webpack_require__(1);
var DiamondShapeDescription = /** @class */ (function (_super) {
__extends(DiamondShapeDescription, _super);
function DiamondShapeDescription(title, defaultText, defaultSize) {
if (title === void 0) { title = "Diamond"; }
if (defaultText === void 0) { defaultText = ""; }
if (defaultSize === void 0) { defaultSize = ShapeDescription_1.ShapeDefaultSize.clone(); }
return _super.call(this, title, defaultText, defaultSize) || this;
}
Object.defineProperty(DiamondShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Diamond; },
enumerable: true,
configurable: true
});
DiamondShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom;
var _a = rect.center, cx = _a.x, cy = _a.y;
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(cx, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, cy),
new PathPrimitive_1.PathPrimitiveLineToCommand(cx, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(left, cy),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
return DiamondShapeDescription;
}(ShapeDescription_1.ShapeDescription));
exports.DiamondShapeDescription = DiamondShapeDescription;
/***/ }),
/* 93 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeDescription_1 = __webpack_require__(9);
var Utils_1 = __webpack_require__(0);
var ShapeTypes_1 = __webpack_require__(1);
var TextShapeDescription = /** @class */ (function (_super) {
__extends(TextShapeDescription, _super);
function TextShapeDescription() {
return _super.call(this, "Text", "Text", new Utils_1.Size(ShapeDescription_1.ShapeDefaultDimension, ShapeDescription_1.ShapeDefaultDimension * 0.5)) || this;
}
Object.defineProperty(TextShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Text; },
enumerable: true,
configurable: true
});
TextShapeDescription.prototype.createShapePrimitives = function (shape, forToolbox) {
return [];
};
return TextShapeDescription;
}(ShapeDescription_1.ShapeDescription));
exports.TextShapeDescription = TextShapeDescription;
/***/ }),
/* 94 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var PathPrimitive_1 = __webpack_require__(2);
var ShapeTypes_1 = __webpack_require__(1);
var PolygonShapeDescription_1 = __webpack_require__(68);
var DiagramItem_1 = __webpack_require__(4);
var PentagonShapeDescription = /** @class */ (function (_super) {
__extends(PentagonShapeDescription, _super);
function PentagonShapeDescription(title, defaultText) {
if (title === void 0) { title = "Pentagon"; }
if (defaultText === void 0) { defaultText = ""; }
var _this = _super.call(this, title, defaultText) || this;
_this.defaultRatio = _this.defaultSize.height / _this.defaultSize.width;
return _this;
}
Object.defineProperty(PentagonShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Pentagon; },
enumerable: true,
configurable: true
});
Object.defineProperty(PentagonShapeDescription.prototype, "angleCount", {
get: function () { return 5; },
enumerable: true,
configurable: true
});
PentagonShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var cx = rect.center.x;
var ratio = height / width / this.defaultRatio;
var angle = Math.PI - this.angle;
var py = width / 2 * Math.tan(angle / 2) * ratio;
var y = top + py;
var px = (height - py) / Math.tan(angle) / ratio;
var x1 = left + px;
var x2 = right - px;
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(cx, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, y),
new PathPrimitive_1.PathPrimitiveLineToCommand(x2, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(x1, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(left, y),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
PentagonShapeDescription.prototype.processConnectionPoint = function (shape, point) {
var side = shape.getConnectionPointSide(point);
if (side === DiagramItem_1.ConnectionPointSide.East || side === DiagramItem_1.ConnectionPointSide.West) {
var rect = shape.rectangle;
var top_1 = rect.top, width = rect.width, height = rect.height;
var ratio = height / width / this.defaultRatio;
var angle = Math.PI - this.angle;
var py = width / 2 * Math.tan(angle / 2) * ratio;
var y = top_1 + py;
if (side === DiagramItem_1.ConnectionPointSide.East)
point.y = y;
else if (side === DiagramItem_1.ConnectionPointSide.West)
point.y = y;
}
};
PentagonShapeDescription.prototype.calculateHeight = function (width) {
var angle = Math.PI - this.angle;
var h1 = width / 2 * Math.tan(angle / 2);
var side = width / 2 / Math.cos(angle / 2);
var h2 = side * Math.sin(angle);
return h1 + h2;
};
return PentagonShapeDescription;
}(PolygonShapeDescription_1.PolygonShapeDescription));
exports.PentagonShapeDescription = PentagonShapeDescription;
/***/ }),
/* 95 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var PathPrimitive_1 = __webpack_require__(2);
var ShapeTypes_1 = __webpack_require__(1);
var PolygonShapeDescription_1 = __webpack_require__(68);
var HexagonShapeDescription = /** @class */ (function (_super) {
__extends(HexagonShapeDescription, _super);
function HexagonShapeDescription(title, defaultText) {
if (title === void 0) { title = "Hexagon"; }
if (defaultText === void 0) { defaultText = ""; }
return _super.call(this, title, defaultText) || this;
}
Object.defineProperty(HexagonShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Hexagon; },
enumerable: true,
configurable: true
});
Object.defineProperty(HexagonShapeDescription.prototype, "angleCount", {
get: function () { return 6; },
enumerable: true,
configurable: true
});
HexagonShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var cy = rect.center.y;
var angle = Math.PI - this.angle;
var sideX = width / (1 + 2 * Math.cos(angle));
var x1 = left + (width - sideX) / 2;
var x2 = x1 + sideX;
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(x1, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(x2, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, cy),
new PathPrimitive_1.PathPrimitiveLineToCommand(x2, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(x1, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(left, cy),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
HexagonShapeDescription.prototype.calculateHeight = function (width) {
var angle = Math.PI - this.angle;
var sideX = width / (1 + 2 * Math.cos(angle));
return 2 * sideX * Math.sin(angle);
};
return HexagonShapeDescription;
}(PolygonShapeDescription_1.PolygonShapeDescription));
exports.HexagonShapeDescription = HexagonShapeDescription;
/***/ }),
/* 96 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeDescription_1 = __webpack_require__(9);
var PathPrimitive_1 = __webpack_require__(2);
var ShapeTypes_1 = __webpack_require__(1);
var ConnectionPoint_1 = __webpack_require__(34);
var DiagramItem_1 = __webpack_require__(4);
var TriangleShapeDescription = /** @class */ (function (_super) {
__extends(TriangleShapeDescription, _super);
function TriangleShapeDescription(title, defaultText) {
if (title === void 0) { title = "Triangle"; }
if (defaultText === void 0) { defaultText = ""; }
var _this = _super.call(this, title, defaultText) || this;
_this.defaultSize.height = _this.calculateHeight(ShapeDescription_1.ShapeDefaultDimension);
return _this;
}
Object.defineProperty(TriangleShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Triangle; },
enumerable: true,
configurable: true
});
TriangleShapeDescription.prototype.createConnectionPoints = function () {
return [
new ConnectionPoint_1.ConnectionPoint(0.5, 0, DiagramItem_1.ConnectionPointSide.North),
new ConnectionPoint_1.ConnectionPoint(0.75, 0.5, DiagramItem_1.ConnectionPointSide.East),
new ConnectionPoint_1.ConnectionPoint(0.5, 1, DiagramItem_1.ConnectionPointSide.South),
new ConnectionPoint_1.ConnectionPoint(0.25, 0.5, DiagramItem_1.ConnectionPointSide.West)
];
};
TriangleShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom;
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(rect.center.x, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(left, bottom),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
TriangleShapeDescription.prototype.calculateHeight = function (width) {
return Math.sqrt(Math.pow(width, 2) - Math.pow(width / 2, 2));
};
TriangleShapeDescription.prototype.getTextRectangle = function (rect, parameters) {
return rect.resize(0, -rect.width * 0.25).offset(0, rect.width * 0.25);
};
return TriangleShapeDescription;
}(ShapeDescription_1.ShapeDescription));
exports.TriangleShapeDescription = TriangleShapeDescription;
/***/ }),
/* 97 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RectangleShapeDescription_1 = __webpack_require__(14);
var ShapeTypes_1 = __webpack_require__(1);
var PathPrimitive_1 = __webpack_require__(2);
var DiagramItem_1 = __webpack_require__(4);
var DocumentShapeDescription = /** @class */ (function (_super) {
__extends(DocumentShapeDescription, _super);
function DocumentShapeDescription(title, defaultText) {
if (title === void 0) { title = "Document"; }
if (defaultText === void 0) { defaultText = "Document"; }
return _super.call(this, title, defaultText) || this;
}
Object.defineProperty(DocumentShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Document; },
enumerable: true,
configurable: true
});
DocumentShapeDescription.prototype.createShapePrimitives = function (shape) {
return this.createDocumentPrimitives(shape.rectangle, shape.style);
};
DocumentShapeDescription.prototype.createDocumentPrimitives = function (rect, style) {
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var cx = rect.center.x;
var dy = height * DocumentShapeDescription.curveOffsetRatio;
var primitives = [];
return primitives.concat([
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(left, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, bottom),
new PathPrimitive_1.PathPrimitiveQuadraticCurveToCommand(right - width * 0.25, bottom - 2 * dy, cx, bottom - dy),
new PathPrimitive_1.PathPrimitiveQuadraticCurveToCommand(left + width * 0.25, bottom + dy, left, bottom - dy),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], style)
]);
};
DocumentShapeDescription.prototype.processConnectionPoint = function (shape, point) {
var side = shape.getConnectionPointSide(point);
if (side === DiagramItem_1.ConnectionPointSide.South)
point.y -= shape.size.height * DocumentShapeDescription.curveOffsetRatio;
};
DocumentShapeDescription.prototype.getTextRectangle = function (rect, parameters) {
return rect.resize(0, -rect.height * DocumentShapeDescription.curveOffsetRatio);
};
DocumentShapeDescription.curveOffsetRatio = 0.1;
return DocumentShapeDescription;
}(RectangleShapeDescription_1.RectangleShapeDescription));
exports.DocumentShapeDescription = DocumentShapeDescription;
/***/ }),
/* 98 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RenderManager_1 = __webpack_require__(12);
var Primitive_1 = __webpack_require__(18);
var ImagePrimitive = /** @class */ (function (_super) {
__extends(ImagePrimitive, _super);
function ImagePrimitive(x, y, width, height, url, preserveAspectRatio, style, className) {
if (preserveAspectRatio === void 0) { preserveAspectRatio = "none"; }
var _this = _super.call(this, style, className) || this;
_this.x = x;
_this.y = y;
_this.width = width;
_this.height = height;
_this.url = url;
_this.preserveAspectRatio = preserveAspectRatio;
return _this;
}
ImagePrimitive.prototype.createMainElement = function () {
return document.createElementNS(RenderManager_1.svgNS, "image");
};
ImagePrimitive.prototype.applyElementProperties = function (element) {
this.setUnitAttribute(element, "x", this.x);
this.setUnitAttribute(element, "y", this.y);
this.setUnitAttribute(element, "width", this.width);
this.setUnitAttribute(element, "height", this.height);
this.setUnitAttribute(element, "href", this.url);
this.setUnitAttribute(element, "preserveAspectRatio", this.preserveAspectRatio);
_super.prototype.applyElementProperties.call(this, element);
};
return ImagePrimitive;
}(Primitive_1.SvgPrimitive));
exports.ImagePrimitive = ImagePrimitive;
/***/ }),
/* 99 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var EllipsePrimitive_1 = __webpack_require__(42);
var PathPrimitive_1 = __webpack_require__(2);
var __1 = __webpack_require__(8);
var GroupPrimitive_1 = __webpack_require__(28);
var Browser_1 = __webpack_require__(23);
var RectaglePrimitive_1 = __webpack_require__(20);
var ShapeImageIndicator = /** @class */ (function () {
function ShapeImageIndicator(x, y, size, borderThickness, className) {
this.x = x;
this.y = y;
this.size = size;
this.borderThickness = borderThickness;
this.className = className;
this.animationStarted = false;
}
ShapeImageIndicator.createLoadingIndicatorPrimitives = function (x, y, r, borderThickness, className) {
var indicator = new ShapeImageIndicator(x, y, r, borderThickness, className);
return indicator.createLoadingIndicatorPrimitive();
};
ShapeImageIndicator.createUserIconPrimitives = function (x, y, r, borderThickness, className) {
var indicator = new ShapeImageIndicator(x, y, r, borderThickness, className);
return indicator.createUserIconPrimitive();
};
ShapeImageIndicator.createWarningIconPrimitives = function (x, y, size, className) {
var indicator = new ShapeImageIndicator(x, y, size, undefined, className);
return indicator.createWarningIconPrimitive();
};
ShapeImageIndicator.prototype.rotate = function (element, centerX, centerY, timestamp) {
if (!this.animationStarted)
return;
var angle = (Math.round(timestamp) % 1080) / 3;
var transformAttributeValue = "rotate(" + angle + " " + centerX + " " + centerY + ")";
element.setAttribute("transform", transformAttributeValue);
this.animationRequestId = requestAnimationFrame(function (timestamp) {
this.rotate(element, centerX, centerY, timestamp);
}.bind(this));
};
ShapeImageIndicator.prototype.onApplyLoadingIndicatorElementProperties = function (element) {
var _a = [__1.UnitConverter.twipsToPixelsF(this.x + this.size / 2), __1.UnitConverter.twipsToPixelsF(this.y + this.size / 2)], centerX = _a[0], centerY = _a[1];
if (Browser_1.Browser.IE) {
this.animationRequestId = requestAnimationFrame(function (timestamp) {
this.rotate(element, centerX, centerY, timestamp);
}.bind(this));
this.animationStarted = true;
}
else {
element.style.setProperty("transform-origin", centerX + "px " + centerY + "px");
}
};
ShapeImageIndicator.prototype.center = function () {
return [__1.UnitConverter.twipsToPixelsF(this.x + this.size / 2), __1.UnitConverter.twipsToPixelsF(this.y + this.size / 2)];
};
ShapeImageIndicator.prototype.createLoadingIndicatorPrimitive = function () {
var _a = this.center(), centerX = _a[0], centerY = _a[1], radius = __1.UnitConverter.twipsToPixelsF(this.size / 2 - this.borderThickness / 2);
return new GroupPrimitive_1.GroupPrimitive([
new EllipsePrimitive_1.EllipsePrimitive(centerX + "", centerY + "", radius + "", radius + ""),
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand((centerX + radius) + "", centerY + ""),
new PathPrimitive_1.PathPrimitiveArcToCommand(radius + "", radius + "", 0, false, false, centerX + "", (centerY - radius) + "")
])
], this.className, undefined, undefined, this.onApplyLoadingIndicatorElementProperties.bind(this), this.onBeforeDispose.bind(this));
};
ShapeImageIndicator.prototype.createUserIconPrimitive = function () {
var _a = this.center(), centerX = _a[0], centerY = _a[1], radius = __1.UnitConverter.twipsToPixelsF(this.size / 2 - this.borderThickness / 2), sizeInPixels = __1.UnitConverter.twipsToPixelsF(this.size);
return new GroupPrimitive_1.GroupPrimitive([
new EllipsePrimitive_1.EllipsePrimitive(centerX + "", centerY + "", radius + "", radius + "", undefined, "dxdi-background"),
new EllipsePrimitive_1.EllipsePrimitive(centerX + "", centerY - sizeInPixels / 8 + "", sizeInPixels / 8 + "", sizeInPixels / 8 + ""),
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(centerX + "", centerY + sizeInPixels / 16 + ""),
new PathPrimitive_1.PathPrimitiveCubicCurveToCommand(centerX + 0.1375 * sizeInPixels + "", centerY + sizeInPixels / 16 + "", centerX + sizeInPixels / 4 + "", centerY
+ 0.11875 * sizeInPixels + "", centerX + sizeInPixels / 4 + "", centerY + 0.1875 * sizeInPixels + ""),
new PathPrimitive_1.PathPrimitiveLineToCommand(centerX + sizeInPixels / 4 + "", centerY + sizeInPixels / 4 + ""),
new PathPrimitive_1.PathPrimitiveLineToCommand(centerX - sizeInPixels / 4 + "", centerY + sizeInPixels / 4 + ""),
new PathPrimitive_1.PathPrimitiveLineToCommand(centerX - sizeInPixels / 4 + "", centerY + 0.1875 * sizeInPixels + ""),
new PathPrimitive_1.PathPrimitiveCubicCurveToCommand(centerX - sizeInPixels / 4 + "", centerY + 0.11875 * sizeInPixels + "", centerX - 0.1375 * sizeInPixels + "", centerY
+ sizeInPixels / 16 + "", centerX + "", centerY + sizeInPixels / 16 + ""),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
])
], this.className);
};
ShapeImageIndicator.prototype.createWarningIconPrimitive = function () {
var _a = this.center(), centerX = _a[0], centerY = _a[1], radius = __1.UnitConverter.twipsToPixelsF(this.size / 2) - 1, exclamationLineWidth = __1.UnitConverter.twipsToPixelsF(this.size / 8);
return new GroupPrimitive_1.GroupPrimitive([
new EllipsePrimitive_1.EllipsePrimitive(centerX + "", centerY + "", radius + "", radius + ""),
new RectaglePrimitive_1.RectanglePrimitive(centerX - exclamationLineWidth / 2 + 0.5 + "", centerY + radius - __1.UnitConverter.twipsToPixelsF(this.size / 4) + "", exclamationLineWidth + "", exclamationLineWidth + ""),
new RectaglePrimitive_1.RectanglePrimitive(centerX - exclamationLineWidth / 2 + 0.5 + "", centerY - radius + __1.UnitConverter.twipsToPixelsF(this.size / 4) - exclamationLineWidth + "", exclamationLineWidth + "", radius + "")
], this.className);
};
ShapeImageIndicator.prototype.onBeforeDispose = function () {
if (this.animationRequestId)
cancelAnimationFrame(this.animationRequestId);
this.animationStarted = false;
};
return ShapeImageIndicator;
}());
exports.ShapeImageIndicator = ShapeImageIndicator;
/***/ }),
/* 100 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ImageCache_1 = __webpack_require__(49);
var ImageLoader = /** @class */ (function () {
function ImageLoader(loadedCallback) {
this.loadedCallback = loadedCallback;
}
ImageLoader.prototype.load = function (data) {
if (data.isLoaded) {
this.loadedCallback(data);
return;
}
this.loadInner(data);
};
ImageLoader.prototype.loadInner = function (data) {
var _this = this;
if (data.imageUrl)
this.loadPictureByUrl(data, function () { return _this.finalizeLoading(data, data); });
else if (data.base64)
this.loadPictureByBase64(data, function () { return _this.finalizeLoading(data, data); });
return data;
};
ImageLoader.prototype.finalizeLoading = function (loadedData, existingInfo) {
if (!existingInfo)
existingInfo = ImageCache_1.ImageCache.instance.getImageData(loadedData.actualId);
if (!existingInfo.isLoaded)
ImageCache_1.ImageCache.instance.finalizeLoading(existingInfo, loadedData);
this.loadedCallback(existingInfo);
};
ImageLoader.prototype.loadPictureByBase64 = function (data, imageLoaded) {
var img = new Image();
img.onload = function () {
imageLoaded(data);
};
img.src = data.base64;
};
ImageLoader.prototype.loadPictureByUrl = function (data, imageLoaded) {
var _this = this;
var xhr = new XMLHttpRequest();
try {
xhr.onload = function () {
var reader = new FileReader();
reader.onloadend = function () {
data.base64 = reader.result;
_this.loadPictureByBase64(data, function (data) { return imageLoaded(data); });
};
reader.readAsDataURL(xhr.response);
};
// Access to XMLHttpRequest at 'https://url.jpg' from origin 'http://myurl' has been blocked by CORS policy:
// No 'Access-Control-Allow-Origin' header is present on the requested resource.
xhr.onerror = function ( /*this: XMLHttpRequest*/) { return imageLoaded(data); };
xhr.onloadend = function () {
if (xhr.status === 404)
imageLoaded(data);
};
xhr.open('GET', data.imageUrl, true);
xhr.responseType = 'blob';
xhr.send();
}
catch (_a) { }
};
return ImageLoader;
}());
exports.ImageLoader = ImageLoader;
/***/ }),
/* 101 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeDescription_1 = __webpack_require__(9);
var Utils_1 = __webpack_require__(0);
var RectaglePrimitive_1 = __webpack_require__(20);
var PathPrimitive_1 = __webpack_require__(2);
var Utils_2 = __webpack_require__(15);
var Event_1 = __webpack_require__(10);
var GroupPrimitive_1 = __webpack_require__(28);
var ConnectionPoint_1 = __webpack_require__(34);
var DiagramItem_1 = __webpack_require__(4);
var ContainerDescription = /** @class */ (function (_super) {
__extends(ContainerDescription, _super);
function ContainerDescription(title, defaultText, defaultSize) {
if (title === void 0) { title = "Container"; }
if (defaultText === void 0) { defaultText = ""; }
if (defaultSize === void 0) { defaultSize = new Utils_1.Size(ShapeDescription_1.ShapeDefaultDimension * 2, ShapeDescription_1.ShapeDefaultDimension * 1.5); }
return _super.call(this, title, defaultText, defaultSize) || this;
}
Object.defineProperty(ContainerDescription.prototype, "enableChildren", {
get: function () { return true; },
enumerable: true,
configurable: true
});
ContainerDescription.prototype.createConnectionPoints = function () {
return [
new ConnectionPoint_1.ConnectionPoint(0.25, 0, DiagramItem_1.ConnectionPointSide.North),
new ConnectionPoint_1.ConnectionPoint(0.5, 0, DiagramItem_1.ConnectionPointSide.North),
new ConnectionPoint_1.ConnectionPoint(0.75, 0, DiagramItem_1.ConnectionPointSide.North),
new ConnectionPoint_1.ConnectionPoint(1, 0.25, DiagramItem_1.ConnectionPointSide.East),
new ConnectionPoint_1.ConnectionPoint(1, 0.5, DiagramItem_1.ConnectionPointSide.East),
new ConnectionPoint_1.ConnectionPoint(1, 0.75, DiagramItem_1.ConnectionPointSide.East),
new ConnectionPoint_1.ConnectionPoint(0.75, 1, DiagramItem_1.ConnectionPointSide.South),
new ConnectionPoint_1.ConnectionPoint(0.5, 1, DiagramItem_1.ConnectionPointSide.South),
new ConnectionPoint_1.ConnectionPoint(0.25, 1, DiagramItem_1.ConnectionPointSide.South),
new ConnectionPoint_1.ConnectionPoint(0, 0.75, DiagramItem_1.ConnectionPointSide.West),
new ConnectionPoint_1.ConnectionPoint(0, 0.5, DiagramItem_1.ConnectionPointSide.West),
new ConnectionPoint_1.ConnectionPoint(0, 0.25, DiagramItem_1.ConnectionPointSide.West)
];
};
ContainerDescription.prototype.getConnectionPointIndexForItem = function (item, connectionPointIndex) {
var shapeConnectionPoints = item.getConnectionPoints();
if (shapeConnectionPoints.length === 4)
return connectionPointIndex * 3 + 1;
return connectionPointIndex;
};
ContainerDescription.prototype.getConnectionPointIndexForSide = function (side) {
return side * 3 + 1;
};
ContainerDescription.prototype.createShapePrimitives = function (shape, forToolbox) {
var _a = shape.rectangle, left = _a.left, top = _a.top, width = _a.width, height = _a.height;
var primitives = [];
if (shape.expanded) {
primitives = primitives.concat([
new RectaglePrimitive_1.RectanglePrimitive(left, top, width, height, shape.style)
]);
}
return primitives.concat(this.createHeaderPrimitives(shape, forToolbox));
};
ContainerDescription.prototype.createExpandButtonPrimitives = function (shape, rect) {
var commands = [
new PathPrimitive_1.PathPrimitiveMoveToCommand(rect.left + rect.width * ((1 - ContainerDescription.expandButtonSignRatio) / 2), rect.center.y),
new PathPrimitive_1.PathPrimitiveLineToCommand(rect.left + rect.width * ((1 - ContainerDescription.expandButtonSignRatio) / 2 + ContainerDescription.expandButtonSignRatio), rect.center.y)
];
if (!shape.expanded) {
commands = commands.concat([
new PathPrimitive_1.PathPrimitiveMoveToCommand(rect.center.x, rect.top + rect.height * ((1 - ContainerDescription.expandButtonSignRatio) / 2)),
new PathPrimitive_1.PathPrimitiveLineToCommand(rect.center.x, rect.top + rect.height * ((1 - ContainerDescription.expandButtonSignRatio) / 2 + ContainerDescription.expandButtonSignRatio)),
]);
}
var buttonRect = rect.inflate(-rect.width * (1 - ContainerDescription.expandButtonRectRatio) / 2, -rect.height * (1 - ContainerDescription.expandButtonRectRatio) / 2);
return [
new GroupPrimitive_1.GroupPrimitive([
new RectaglePrimitive_1.RectanglePrimitive(buttonRect.left, buttonRect.top, buttonRect.width, buttonRect.height, shape.style),
new PathPrimitive_1.PathPrimitive(commands, shape.style)
], "shape-expand-btn", null, null, function (el) {
Utils_2.RenderUtils.setElementEventData(el, Event_1.MouseEventElementType.ShapeExpandButton, shape.key);
})
];
};
ContainerDescription.headerSize = 360;
ContainerDescription.headerToolboxSizeRatio = 0.2;
ContainerDescription.expandButtonRectRatio = 0.5;
ContainerDescription.expandButtonSignRatio = 0.3;
return ContainerDescription;
}(ShapeDescription_1.ShapeDescription));
exports.ContainerDescription = ContainerDescription;
/***/ }),
/* 102 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var ChangeShapeParametersHistoryItem = /** @class */ (function (_super) {
__extends(ChangeShapeParametersHistoryItem, _super);
function ChangeShapeParametersHistoryItem(shapeKey, parameters) {
var _this = _super.call(this) || this;
_this.shapeKey = shapeKey;
_this.parameters = parameters;
return _this;
}
ChangeShapeParametersHistoryItem.prototype.redo = function (manipulator) {
var shape = manipulator.model.findShape(this.shapeKey);
this.oldParameters = shape.parameters.clone();
manipulator.changeShapeParameters(shape, this.parameters);
};
ChangeShapeParametersHistoryItem.prototype.undo = function (manipulator) {
var shape = manipulator.model.findShape(this.shapeKey);
manipulator.changeShapeParameters(shape, this.oldParameters);
};
return ChangeShapeParametersHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.ChangeShapeParametersHistoryItem = ChangeShapeParametersHistoryItem;
/***/ }),
/* 103 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var ChangeStyleHistoryItemBase = /** @class */ (function (_super) {
__extends(ChangeStyleHistoryItemBase, _super);
function ChangeStyleHistoryItemBase(itemKey, styleProperty, styleValue) {
var _this = _super.call(this) || this;
_this.itemKey = itemKey;
_this.styleProperty = styleProperty;
_this.styleValue = styleValue;
return _this;
}
ChangeStyleHistoryItemBase.prototype.redo = function (manipulator) {
var item = manipulator.model.findItem(this.itemKey);
this.oldStyleValue = item.style[this.styleProperty];
manipulator.changeStyle(item, this.styleProperty, this.styleValue);
};
ChangeStyleHistoryItemBase.prototype.undo = function (manipulator) {
var item = manipulator.model.findItem(this.itemKey);
manipulator.changeStyle(item, this.styleProperty, this.oldStyleValue);
};
return ChangeStyleHistoryItemBase;
}(HistoryItem_1.HistoryItem));
exports.ChangeStyleHistoryItemBase = ChangeStyleHistoryItemBase;
/***/ }),
/* 104 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var ChangeLockedHistoryItem = /** @class */ (function (_super) {
__extends(ChangeLockedHistoryItem, _super);
function ChangeLockedHistoryItem(item, locked) {
var _this = _super.call(this) || this;
_this.itemKey = item.key;
_this.locked = locked;
return _this;
}
ChangeLockedHistoryItem.prototype.redo = function (manipulator) {
var item = manipulator.model.findItem(this.itemKey);
this.oldLocked = item.locked;
manipulator.changeLocked(item, this.locked);
};
ChangeLockedHistoryItem.prototype.undo = function (manipulator) {
var item = manipulator.model.findItem(this.itemKey);
manipulator.changeLocked(item, this.oldLocked);
};
return ChangeLockedHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.ChangeLockedHistoryItem = ChangeLockedHistoryItem;
/***/ }),
/* 105 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Shape_1 = __webpack_require__(11);
var Utils_1 = __webpack_require__(0);
var ShapeDescriptionManager_1 = __webpack_require__(25);
var Connector_1 = __webpack_require__(5);
var ShapeTypes_1 = __webpack_require__(1);
var ImageInfo_1 = __webpack_require__(40);
var ImporterBase_1 = __webpack_require__(106);
var ImportUtils_1 = __webpack_require__(71);
var __1 = __webpack_require__(8);
var Importer = /** @class */ (function (_super) {
__extends(Importer, _super);
function Importer(json) {
var _this = _super.call(this) || this;
_this.obj = ImportUtils_1.ImportUtils.parseJSON(json);
return _this;
}
Importer.prototype.getObject = function () {
return this.obj;
};
Importer.prototype.getPageObject = function (obj) {
return obj["page"];
};
Importer.prototype.getShapeObjects = function (obj) {
return obj["shapes"];
};
Importer.prototype.getConnectorObjects = function (obj) {
return obj["connectors"];
};
Importer.prototype.importPageSettings = function (model, pageObj) {
if (!pageObj)
return;
this.assert(pageObj["width"], "number");
this.assert(pageObj["height"], "number");
if (typeof pageObj["width"] === "number")
model.size.width = pageObj["width"];
if (typeof pageObj["height"] === "number")
model.size.height = pageObj["height"];
if (typeof pageObj["pageColor"] === "number")
model.pageColor = pageObj["pageColor"];
else if (typeof pageObj["pageColor"] === "string")
model.pageColor = __1.ColorHelper.stringToColor(pageObj["pageColor"]);
if (typeof pageObj["pageWidth"] === "number")
model.pageSize.width = pageObj["pageWidth"];
if (typeof pageObj["pageHeight"] === "number")
model.pageSize.height = pageObj["pageHeight"];
if (typeof pageObj["pageLandscape"] === "boolean")
model.pageLandscape = pageObj["pageLandscape"];
if (typeof pageObj["units"] === "number")
model.units = pageObj["units"];
};
Importer.prototype.importShape = function (shapeObj) {
this.assert(shapeObj["key"], "string");
this.assert(shapeObj["x"], "number");
this.assert(shapeObj["y"], "number");
this.assert(shapeObj["type"], "string");
var shapeType = shapeObj["type"];
var description = ShapeDescriptionManager_1.ShapeDescriptionManager.get(shapeType);
var position = new Utils_1.Point(shapeObj["x"], shapeObj["y"]);
var shape = new Shape_1.Shape(description || ShapeDescriptionManager_1.ShapeDescriptionManager.get(ShapeTypes_1.ShapeTypes.Rectangle), position);
shape.key = shapeObj["key"];
if (typeof shapeObj["dataKey"] === "string")
shape.dataKey = shapeObj["dataKey"];
if (typeof shapeObj["locked"] === "boolean")
shape.locked = shapeObj["locked"];
if (typeof shapeObj["width"] === "number")
shape.size.width = shapeObj["width"];
if (typeof shapeObj["height"] === "number")
shape.size.height = shapeObj["height"];
if (typeof shapeObj["text"] === "string")
shape.text = shapeObj["text"];
if (typeof shapeObj["imageUrl"] === "string")
shape.image = new ImageInfo_1.ImageInfo(shapeObj["imageUrl"]);
if (shapeObj["parameters"]) {
shape.parameters.fromObject(shapeObj["parameters"]);
shape.description.normalizeParameters(shape, shape.parameters);
}
if (shapeObj["style"])
shape.style.fromObject(shapeObj["style"]);
if (shapeObj["styleText"])
shape.styleText.fromObject(shapeObj["styleText"]);
if (typeof shapeObj["zIndex"] === "number")
shape.zIndex = shapeObj["zIndex"];
if (Array.isArray(shapeObj["childKeys"]))
shape.childKeys = shapeObj["childKeys"].slice();
if (typeof shapeObj["expanded"] === "boolean")
shape.expanded = shapeObj["expanded"];
if (typeof shapeObj["expandedWidth"] === "number" && typeof shapeObj["expandedHeight"] === "number")
shape.expandedSize = new Utils_1.Size(shapeObj["expandedWidth"], shapeObj["expandedHeight"]);
return shape;
};
Importer.prototype.importShapeChildren = function (shapeObj, shape) {
return [];
};
Importer.prototype.importConnector = function (connectorObj) {
var _this = this;
this.assert(connectorObj["key"], "string");
if (!Array.isArray(connectorObj["points"]))
throw Error("Invalid Format");
var points = connectorObj["points"].map(function (pt) {
_this.assert(pt["x"], "number");
_this.assert(pt["y"], "number");
return new Utils_1.Point(pt["x"], pt["y"]);
});
var connector = new Connector_1.Connector(points);
connector.key = connectorObj["key"];
if (typeof connectorObj["dataKey"] === "string")
connector.dataKey = connectorObj["dataKey"];
if (typeof connectorObj["locked"] === "boolean")
connector.locked = connectorObj["locked"];
connector.endConnectionPointIndex = typeof connectorObj["endConnectionPointIndex"] === "number" ? connectorObj["endConnectionPointIndex"] : -1;
connector.beginConnectionPointIndex = typeof connectorObj["beginConnectionPointIndex"] === "number" ? connectorObj["beginConnectionPointIndex"] : -1;
if (connectorObj["endItemKey"] !== undefined)
this.assert(connectorObj["endItemKey"], "string");
if (connectorObj["beginItemKey"] !== undefined)
this.assert(connectorObj["beginItemKey"], "string");
connector["endItemKey"] = connectorObj["endItemKey"];
connector["beginItemKey"] = connectorObj["beginItemKey"];
if (connectorObj["texts"])
connector.texts.fromObject(connectorObj["texts"]);
if (connectorObj["properties"])
connector.properties.fromObject(connectorObj["properties"]);
if (connectorObj["style"])
connector.style.fromObject(connectorObj["style"]);
if (connectorObj["styleText"])
connector.styleText.fromObject(connectorObj["styleText"]);
if (typeof connectorObj["zIndex"] === "number")
connector.zIndex = connectorObj["zIndex"];
return connector;
};
return Importer;
}(ImporterBase_1.ImporterBase));
exports.Importer = Importer;
/***/ }),
/* 106 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Model_1 = __webpack_require__(19);
var Shape_1 = __webpack_require__(11);
var ImporterBase = /** @class */ (function () {
function ImporterBase() {
}
ImporterBase.prototype.import = function () {
var model = new Model_1.DiagramModel();
var obj = this.getObject();
this.importPageSettings(model, this.getPageObject(obj));
var shapes = this.importShapes(this.getShapeObjects(obj));
for (var i = 0; i < shapes.length; i++) {
var shape = shapes[i];
if (model.findItem(shape.key))
throw Error("Item key is duplicated");
model.pushItem(shape);
}
var connectors = this.importConnectors(this.getConnectorObjects(obj));
for (var i = 0; i < connectors.length; i++) {
var connector = connectors[i];
connector.endItem = model.findItem(connector["endItemKey"]) || undefined;
delete connector["endItemKey"];
connector.beginItem = model.findItem(connector["beginItemKey"]) || undefined;
delete connector["beginItemKey"];
if (model.findItem(connector.key))
throw Error("Item key is duplicated");
model.pushItem(connector);
this.updateConnections(connector);
}
model.items.forEach(function (item) {
if (item instanceof Shape_1.Shape) {
item.childKeys.forEach(function (childKey) {
var child = model.findItem(childKey);
if (child) {
child.container = item;
child.containerLocked = item.locked;
}
});
}
});
return model;
};
ImporterBase.prototype.importItems = function (model) {
var result = [];
var obj = this.getObject();
var itemHash = {};
var shapes = this.importShapes(this.getShapeObjects(obj));
var key;
for (var i = 0; i < shapes.length; i++) {
var shape = shapes[i];
var oldKey = shape.key;
key = model.getNextKey(key);
shape.key = key;
itemHash[oldKey] = shape;
result.push(shape);
}
var connectors = this.importConnectors(this.getConnectorObjects(obj));
for (var i = 0; i < connectors.length; i++) {
var connector = connectors[i];
var oldKey = connector.key;
key = model.getNextKey(key);
connector.key = key;
itemHash[oldKey] = connector;
var endItemKey = connector["endItemKey"];
connector.endItem = itemHash[endItemKey];
delete connector["endItemKey"];
var beginItemKey = connector["beginItemKey"];
connector.beginItem = itemHash[beginItemKey];
delete connector["beginItemKey"];
result.push(connector);
this.updateConnections(connector);
}
result.forEach(function (item) {
if (item instanceof Shape_1.Shape) {
item.childKeys.forEach(function (childKey) {
var child = itemHash[childKey];
if (child) {
child.container = item;
child.containerLocked = item.locked;
}
});
item.childKeys = item.childKeys
.map(function (childKey) { return itemHash[childKey] && itemHash[childKey].key; })
.filter(function (childKey) { return childKey; });
}
});
return result;
};
ImporterBase.prototype.importItemsData = function (model) {
var obj = this.getObject();
var shapes = this.importShapes(this.getShapeObjects(obj));
for (var i = 0; i < shapes.length; i++) {
var srcShape = shapes[i];
var destShape = void 0;
if (srcShape.dataKey !== undefined)
destShape = model.findShapeByDataKey(srcShape.dataKey);
if (!destShape)
destShape = model.findShape(srcShape.key);
if (destShape) {
destShape.dataKey = srcShape.dataKey;
destShape.locked = srcShape.locked;
destShape.position = srcShape.position.clone();
destShape.size = srcShape.size.clone();
destShape.parameters = srcShape.parameters.clone();
destShape.style = srcShape.style.clone();
destShape.styleText = srcShape.styleText.clone();
destShape.zIndex = srcShape.zIndex;
}
}
var connectors = this.importConnectors(this.getConnectorObjects(obj));
for (var i = 0; i < connectors.length; i++) {
var srcConnector = connectors[i];
var destConnector = void 0;
if (srcConnector.dataKey !== undefined)
destConnector = model.findConnectorByDataKey(srcConnector.dataKey);
if (!destConnector)
destConnector = model.findConnector(srcConnector.key);
if (destConnector) {
destConnector.dataKey = srcConnector.dataKey;
destConnector.locked = srcConnector.locked;
destConnector.points = srcConnector.points.slice();
destConnector.properties = srcConnector.properties.clone();
destConnector.style = srcConnector.style.clone();
destConnector.styleText = srcConnector.styleText.clone();
destConnector.zIndex = srcConnector.zIndex;
}
}
};
ImporterBase.prototype.importShapes = function (shapeObjs) {
var result = [];
if (!shapeObjs)
return result;
if (!Array.isArray(shapeObjs))
throw Error("Invalid Format");
for (var i = 0; i < shapeObjs.length; i++) {
var shapeObj = shapeObjs[i];
var shape = this.importShape(shapeObj);
result.push(shape);
result = result.concat(this.importShapeChildren(shapeObj, shape));
}
return result;
};
ImporterBase.prototype.importConnectors = function (connectorObjs) {
var result = [];
if (!connectorObjs)
return result;
if (!Array.isArray(connectorObjs))
throw Error("Invalid Format");
for (var i = 0; i < connectorObjs.length; i++) {
var shapeObj = connectorObjs[i];
result.push(this.importConnector(shapeObj));
}
return result;
};
ImporterBase.prototype.updateConnections = function (connector) {
if (connector.endItem) {
if (connector.endItem instanceof Shape_1.Shape) {
connector.endItem.attachedConnectors.push(connector);
connector.points[connector.points.length - 1] = connector.endItem.getConnectionPointPosition(connector.endConnectionPointIndex, connector.points[connector.points.length - 2]);
}
else {
connector.endItem = undefined;
connector.endConnectionPointIndex = -1;
}
}
if (connector.beginItem) {
if (connector.beginItem instanceof Shape_1.Shape) {
connector.beginItem.attachedConnectors.push(connector);
connector.points[0] = connector.beginItem.getConnectionPointPosition(connector.beginConnectionPointIndex, connector.points[1]);
}
else {
connector.beginItem = undefined;
connector.beginConnectionPointIndex = -1;
}
}
};
ImporterBase.prototype.assert = function (value, type) {
if (value === undefined)
throw Error("Invalid Format");
if (type !== undefined && typeof value !== type)
throw Error("Invalid Format");
};
return ImporterBase;
}());
exports.ImporterBase = ImporterBase;
/***/ }),
/* 107 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var SimpleCommandBase_1 = __webpack_require__(7);
var StylePropertyCommandBase = /** @class */ (function (_super) {
__extends(StylePropertyCommandBase, _super);
function StylePropertyCommandBase() {
return _super !== null && _super.apply(this, arguments) || this;
}
return StylePropertyCommandBase;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.StylePropertyCommandBase = StylePropertyCommandBase;
/***/ }),
/* 108 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var StylePropertyCommandBase_1 = __webpack_require__(107);
var ChangeStylePropertyCommandBase = /** @class */ (function (_super) {
__extends(ChangeStylePropertyCommandBase, _super);
function ChangeStylePropertyCommandBase() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeStylePropertyCommandBase.prototype.executeCore = function (state, parameter) {
var _this = this;
this.control.history.beginTransaction();
var items = this.control.selection.getSelectedItems();
parameter = this.processParameter(parameter);
items.forEach(function (item) {
var styleProperty = _this.getStyleProperty();
_this.control.history.addAndRedo(_this.createHistoryItem(item, styleProperty, parameter));
});
this.updateInputPosition(parameter);
this.control.history.endTransaction();
return true;
};
ChangeStylePropertyCommandBase.prototype.getDefaultValue = function () {
return this.getDefaultStyleObj()[this.getStyleProperty()];
};
ChangeStylePropertyCommandBase.prototype.processParameter = function (parameter) {
return parameter;
};
return ChangeStylePropertyCommandBase;
}(StylePropertyCommandBase_1.StylePropertyCommandBase));
exports.ChangeStylePropertyCommandBase = ChangeStylePropertyCommandBase;
/***/ }),
/* 109 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangeStylePropertyCommandBase_1 = __webpack_require__(108);
var ChangeStyleHistoryItem_1 = __webpack_require__(46);
var Style_1 = __webpack_require__(27);
var ChangeStylePropertyCommand = /** @class */ (function (_super) {
__extends(ChangeStylePropertyCommand, _super);
function ChangeStylePropertyCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeStylePropertyCommand.prototype.getValue = function () {
return this.control.selection.inputPosition.getStylePropertyValue(this.getStyleProperty());
};
ChangeStylePropertyCommand.prototype.getStyleObj = function (item) {
return item.style;
};
ChangeStylePropertyCommand.prototype.getDefaultStyleObj = function () {
return new Style_1.Style();
};
ChangeStylePropertyCommand.prototype.createHistoryItem = function (item, styleProperty, styleValue) {
return new ChangeStyleHistoryItem_1.ChangeStyleHistoryItem(item.key, styleProperty, styleValue);
};
ChangeStylePropertyCommand.prototype.updateInputPosition = function (value) {
this.control.selection.inputPosition.setStylePropertyValue(this.getStyleProperty(), value);
};
return ChangeStylePropertyCommand;
}(ChangeStylePropertyCommandBase_1.ChangeStylePropertyCommandBase));
exports.ChangeStylePropertyCommand = ChangeStylePropertyCommand;
/***/ }),
/* 110 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangeConnectorPropertyHistoryItem_1 = __webpack_require__(55);
var SimpleCommandBase_1 = __webpack_require__(7);
var ChangeConnectorPropertyCommand = /** @class */ (function (_super) {
__extends(ChangeConnectorPropertyCommand, _super);
function ChangeConnectorPropertyCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeConnectorPropertyCommand.prototype.getValue = function () {
return this.control.selection.inputPosition.getConnectorPropertyValue(this.getPropertyName());
};
ChangeConnectorPropertyCommand.prototype.getDefaultValue = function () {
return this.getPropertyDefaultValue();
};
ChangeConnectorPropertyCommand.prototype.executeCore = function (state, parameter) {
var _this = this;
this.control.history.beginTransaction();
var connectors = this.control.selection.getSelectedConnectors();
connectors.forEach(function (connector) {
var propertyName = _this.getPropertyName();
_this.control.history.addAndRedo(new ChangeConnectorPropertyHistoryItem_1.ChangeConnectorPropertyHistoryItem(connector.key, propertyName, parameter));
});
this.control.selection.inputPosition.setConnectorPropertyValue(this.getPropertyName(), parameter);
this.control.history.endTransaction();
return true;
};
return ChangeConnectorPropertyCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.ChangeConnectorPropertyCommand = ChangeConnectorPropertyCommand;
/***/ }),
/* 111 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Utils_1 = __webpack_require__(0);
var NodeLayout_1 = __webpack_require__(56);
var GraphLayout = /** @class */ (function () {
function GraphLayout() {
this.nodeKeys = [];
this.nodeToLayout = {};
this.edgeToPosition = {};
}
GraphLayout.prototype.forEachNode = function (callback) {
var _this = this;
this.nodeKeys.forEach(function (nk) { return callback(_this.nodeToLayout[nk], nk); });
};
GraphLayout.prototype.addNode = function (nodeLayout) {
if (this.nodeToLayout[nodeLayout.key])
throw Error("Node layout is already registered");
this.nodeKeys.push(nodeLayout.key);
this.nodeToLayout[nodeLayout.key] = nodeLayout;
};
GraphLayout.prototype.addEdge = function (edgeLayout) {
if (this.edgeToPosition[edgeLayout.key])
throw Error("Edge layout is already registered");
this.edgeToPosition[edgeLayout.key] = edgeLayout;
};
GraphLayout.prototype.getRectangle = function (includeMargins) {
var _this = this;
return Utils_1.GeometryUtils.getCommonRectangle(this.nodeKeys.map(function (nk) { return _this.nodeToLayout[nk].rectangle; }));
};
GraphLayout.prototype.offsetNodes = function (deltaX, deltaY) {
var _this = this;
if (deltaX === void 0) { deltaX = 0; }
if (deltaY === void 0) { deltaY = 0; }
var layout = new GraphLayout();
this.nodeKeys.forEach(function (nk) {
var nl = _this.nodeToLayout[nk];
layout.addNode(new NodeLayout_1.NodeLayout(nl.info, nl.position.offset(deltaX, deltaY)));
});
layout.copyEdges(this);
return layout;
};
GraphLayout.prototype.extend = function (layout) {
var _this = this;
layout.forEachNode(function (nl) { return _this.addNode(nl); });
this.copyEdges(layout);
};
GraphLayout.prototype.copyEdges = function (source) {
var _this = this;
Object.keys(source.edgeToPosition).forEach(function (e) {
var edge = source.edgeToPosition[e];
_this.addEdge(new NodeLayout_1.EdgeLayout(edge.key, edge.beginIndex, edge.endIndex));
});
};
return GraphLayout;
}());
exports.GraphLayout = GraphLayout;
/***/ }),
/* 112 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var LayoutSettings_1 = __webpack_require__(22);
var LayoutBuilder = /** @class */ (function () {
function LayoutBuilder(settings, graph) {
this.settings = settings;
this.graph = graph;
}
LayoutBuilder.prototype.getBreadthNodeSizeCore = function (node) {
return this.settings.orientation === LayoutSettings_1.DataLayoutOrientation.Vertical ?
(node.size.width + node.margin.left + node.margin.right) :
(node.size.height + node.margin.top + node.margin.bottom);
};
LayoutBuilder.prototype.getDepthNodeSizeCore = function (node) {
return this.settings.orientation === LayoutSettings_1.DataLayoutOrientation.Horizontal ?
(node.size.width + node.margin.left + node.margin.right) :
(node.size.height + node.margin.top + node.margin.bottom);
};
LayoutBuilder.prototype.chooseDirectionValue = function (near, far) {
return this.settings.direction === LayoutSettings_1.LogicalDirectionKind.Forward ? near : far;
};
LayoutBuilder.prototype.getDirectionValue = function (value) {
return this.settings.direction === LayoutSettings_1.LogicalDirectionKind.Forward ? value : -value;
};
LayoutBuilder.prototype.getComponentOffset = function (graphLayout) {
var rect = graphLayout.getRectangle(true);
var offset = this.settings.orientation === LayoutSettings_1.DataLayoutOrientation.Vertical ? rect.width : rect.height;
return offset + this.settings.componentSpacing;
};
LayoutBuilder.prototype.setComponentOffset = function (graphLayout, offset) {
return this.settings.orientation === LayoutSettings_1.DataLayoutOrientation.Vertical ?
graphLayout.offsetNodes(offset) :
graphLayout.offsetNodes(0, offset);
};
return LayoutBuilder;
}());
exports.LayoutBuilder = LayoutBuilder;
/***/ }),
/* 113 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ClipboardCommand_1 = __webpack_require__(75);
var Importer_1 = __webpack_require__(105);
var Shape_1 = __webpack_require__(11);
var ImportShapeHistoryItem_1 = __webpack_require__(230);
var Connector_1 = __webpack_require__(5);
var ImportConnectorHistoryItem_1 = __webpack_require__(231);
var ModelUtils_1 = __webpack_require__(6);
var SetSelectionHistoryItem_1 = __webpack_require__(44);
var UnitConverter_1 = __webpack_require__(13);
var PasteSelectionCommandBase = /** @class */ (function (_super) {
__extends(PasteSelectionCommandBase, _super);
function PasteSelectionCommandBase() {
return _super !== null && _super.apply(this, arguments) || this;
}
PasteSelectionCommandBase.prototype.isEnabled = function () {
return _super.prototype.isEnabled.call(this) && (this.isPasteSupportedByBrowser() || ClipboardCommand_1.ClipboardCommand.clipboardData !== undefined);
};
PasteSelectionCommandBase.prototype.isVisible = function () {
return this.isPasteSupportedByBrowser() || ClipboardCommand_1.ClipboardCommand.clipboardData !== undefined;
};
PasteSelectionCommandBase.prototype.executeCore = function (state, parameter) {
var _this = this;
this.getClipboardData(function (data) {
_this.performPaste(data, parameter);
});
return true;
};
PasteSelectionCommandBase.prototype.performPaste = function (data, parameter) {
this.control.beginUpdate(true);
this.control.history.beginTransaction();
var ids = [];
var importer = new Importer_1.Importer(data);
var items = importer.importItems(this.control.model);
this.calculateSelectionOffset(items, parameter);
for (var i = 0; i < items.length; i++) {
var item = items[i];
if (item instanceof Shape_1.Shape) {
item.position = this.getShapeNewPosition(item.position);
this.control.history.addAndRedo(new ImportShapeHistoryItem_1.ImportShapeHistoryItem(item));
}
else if (item instanceof Connector_1.Connector) {
this.changeConnectorPoints(item);
this.control.history.addAndRedo(new ImportConnectorHistoryItem_1.ImportConnectorHistoryItem(item));
}
var containerKey = item.container && item.container.key;
if (!containerKey || ids.indexOf(containerKey) === -1)
ids.push(item.key);
}
ModelUtils_1.ModelUtils.tryUpdateModelSize(this.control.history, this.control.model);
this.control.history.addAndRedo(new SetSelectionHistoryItem_1.SetSelectionHistoryItem(this.control.selection, ids));
this.control.history.endTransaction();
this.control.endUpdate(true);
};
PasteSelectionCommandBase.prototype.calculateSelectionOffset = function (items, position) { };
PasteSelectionCommandBase.getShapeNewPosition = function (model, position) {
while (model.findShapeAtPosition(position))
position = position.offset(PasteSelectionCommandBase.positionOffset, PasteSelectionCommandBase.positionOffset);
return position;
};
PasteSelectionCommandBase.changeConnectorPoints = function (model, connector) {
while (model.findConnectorAtPoints(connector.points)) {
connector.points.forEach(function (pt) {
pt.x += PasteSelectionCommandBase.positionOffset;
pt.y += PasteSelectionCommandBase.positionOffset;
});
}
};
PasteSelectionCommandBase.positionOffset = UnitConverter_1.UnitConverter.pixelsToTwips(10);
return PasteSelectionCommandBase;
}(ClipboardCommand_1.ClipboardCommand));
exports.PasteSelectionCommandBase = PasteSelectionCommandBase;
/***/ }),
/* 114 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var LayoutSettings_1 = __webpack_require__(22);
var WideTree_1 = __webpack_require__(73);
var Sugiyama_1 = __webpack_require__(61);
var DataLayoutType;
(function (DataLayoutType) {
DataLayoutType[DataLayoutType["Tree"] = 0] = "Tree";
DataLayoutType[DataLayoutType["Sugiyama"] = 1] = "Sugiyama";
})(DataLayoutType = exports.DataLayoutType || (exports.DataLayoutType = {}));
var DataLayoutParameters = /** @class */ (function () {
function DataLayoutParameters(parameter) {
this.layoutType = parameter !== undefined && parameter.type || DataLayoutType.Tree;
this.layoutSettings = (this.layoutType === DataLayoutType.Sugiyama) ? new LayoutSettings_1.LayoutSettings() : new LayoutSettings_1.TreeLayoutSettings();
if (parameter !== undefined && parameter.orientation !== undefined)
this.layoutSettings.orientation = parameter.orientation;
}
DataLayoutParameters.prototype.getLayoutBuilder = function (graph) {
return (this.layoutType === DataLayoutType.Tree) ?
new WideTree_1.TreeLayoutBuilder(this.layoutSettings, graph) :
new Sugiyama_1.SugiyamaLayoutBuilder(this.layoutSettings, graph);
};
return DataLayoutParameters;
}());
exports.DataLayoutParameters = DataLayoutParameters;
/***/ }),
/* 115 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ModelUtils_1 = __webpack_require__(6);
var SimpleCommandBase_1 = __webpack_require__(7);
var ChangeLockedCommand = /** @class */ (function (_super) {
__extends(ChangeLockedCommand, _super);
function ChangeLockedCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeLockedCommand.prototype.isEnabled = function () {
var _this = this;
var items = this.control.selection.getSelectedItems(true);
var enabled = false;
items.forEach(function (item) { if (item.locked !== _this.getLockState())
enabled = true; });
return _super.prototype.isEnabled.call(this) && enabled;
};
ChangeLockedCommand.prototype.executeCore = function (state, parameter) {
ModelUtils_1.ModelUtils.changeSelectionLocked(this.control.history, this.control.model, this.control.selection, this.getLockState());
return true;
};
return ChangeLockedCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.ChangeLockedCommand = ChangeLockedCommand;
/***/ }),
/* 116 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var ImageInfo_1 = __webpack_require__(40);
var ChangeShapeImageHistoryItem = /** @class */ (function (_super) {
__extends(ChangeShapeImageHistoryItem, _super);
function ChangeShapeImageHistoryItem(item, imageUrl) {
var _this = _super.call(this) || this;
_this.shapeKey = item.key;
_this.imageUrl = imageUrl;
return _this;
}
ChangeShapeImageHistoryItem.prototype.redo = function (manipulator) {
var item = manipulator.model.findShape(this.shapeKey);
this.oldImage = item.image;
manipulator.changeShapeImage(item, new ImageInfo_1.ImageInfo(this.imageUrl));
};
ChangeShapeImageHistoryItem.prototype.undo = function (manipulator) {
var item = manipulator.model.findShape(this.shapeKey);
manipulator.changeShapeImage(item, this.oldImage);
};
return ChangeShapeImageHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.ChangeShapeImageHistoryItem = ChangeShapeImageHistoryItem;
/***/ }),
/* 117 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Event_1 = __webpack_require__(10);
var MouseHandlerMoveConnectorPointState_1 = __webpack_require__(266);
var MouseHandlerResizeShapeState_1 = __webpack_require__(267);
var MouseHandlerMoveConnectorSideState_1 = __webpack_require__(268);
var MouseHandlerDragParameterPointState_1 = __webpack_require__(269);
var MouseHandlerCreateConnectorState_1 = __webpack_require__(270);
var MouseHandlerMoveConnectorOrthogonalSideState_1 = __webpack_require__(271);
var MouseHandlerToolboxDraggingState_1 = __webpack_require__(272);
var MouseHandlerMoveConnectorTextState_1 = __webpack_require__(273);
var MouseHandlerMoveClonedShapeState_1 = __webpack_require__(78);
var MouseHandlerDefaultStateBase_1 = __webpack_require__(121);
var MouseHandlerMoveShapeState_1 = __webpack_require__(279);
var MouseHandlerDefaultState = /** @class */ (function (_super) {
__extends(MouseHandlerDefaultState, _super);
function MouseHandlerDefaultState() {
return _super !== null && _super.apply(this, arguments) || this;
}
MouseHandlerDefaultState.prototype.finish = function () {
this.visualizerManager.resetConnectionPoints();
_super.prototype.finish.call(this);
};
MouseHandlerDefaultState.prototype.onMouseDownCore = function (evt) {
if (evt.source.type === Event_1.MouseEventElementType.ConnectorText) {
var connectorKey = evt.source.key;
this.modifySelection(evt, connectorKey);
this.handler.switchState(new MouseHandlerMoveConnectorTextState_1.MouseHandlerMoveConnectorTextState(this.handler, this.history, this.model));
}
else if (evt.source.type === Event_1.MouseEventElementType.ShapeResizeBox)
this.handler.switchState(new MouseHandlerResizeShapeState_1.MouseHandlerResizeShapeState(this.handler, this.history, this.model, this.selection, this.visualizerManager));
else if (evt.source.type === Event_1.MouseEventElementType.ShapeParameterBox)
this.handler.switchState(new MouseHandlerDragParameterPointState_1.MouseHandlerDragParameterPointState(this.handler, this.history, this.model));
else if (evt.source.type === Event_1.MouseEventElementType.ConnectorPoint)
this.handler.switchState(new MouseHandlerMoveConnectorPointState_1.MouseHandlerMoveConnectorPointState(this.handler, this.history, this.model, this.visualizerManager));
else if (evt.source.type === Event_1.MouseEventElementType.ConnectorSide)
this.handler.switchState(new MouseHandlerMoveConnectorSideState_1.MouseHandlerMoveConnectorSideState(this.handler, this.history, this.model));
else if (evt.source.type === Event_1.MouseEventElementType.ConnectorOrthogonalSide)
this.handler.switchState(new MouseHandlerMoveConnectorOrthogonalSideState_1.MouseHandlerMoveConnectorOrthogonalSideState(this.handler, this.history, this.model));
else if (evt.source.type === Event_1.MouseEventElementType.ShapeConnectionPoint)
this.handler.switchState(new MouseHandlerCreateConnectorState_1.MouseHandlerCreateConnectorState(this.handler, this.history, this.model, this.visualizerManager, this.selection));
else
_super.prototype.onMouseDownCore.call(this, evt);
};
MouseHandlerDefaultState.prototype.onShapeMouseDown = function (evt) {
var shapeKey = evt.source.key;
if (MouseHandlerMoveClonedShapeState_1.MouseHandlerMoveClonedShapeState.isMoveClonedShapeEvent(evt)) {
this.selection.add(shapeKey);
this.handler.switchToMoveClonedShapeState();
}
else {
this.modifySelection(evt, shapeKey);
this.handler.switchState(new MouseHandlerMoveShapeState_1.MouseHandlerMoveShapeState(this.handler, this.history, this.model, this.selection, this.visualizerManager));
}
this.handler.state.onMouseDown(evt);
};
MouseHandlerDefaultState.prototype.onDragStart = function (evt) {
this.handler.switchState(new MouseHandlerToolboxDraggingState_1.MouseHandlerBeforeToolboxDraggingState(this.handler, this.history, this.model, this.selection, this.visualizerManager));
this.handler.state.onDragStart(evt);
};
MouseHandlerDefaultState.prototype.onMouseMoveCore = function (evt) {
this.updateConnectionsOnMouseMove(evt);
_super.prototype.onMouseMoveCore.call(this, evt);
};
MouseHandlerDefaultState.prototype.updateConnectionsOnMouseMove = function (evt) {
var item = this.model.findItem(evt.source.key);
this.visualizerManager.updateConnections(item, evt.source.type, evt.source.value);
};
MouseHandlerDefaultState.prototype.canDragObjectOnMouseDown = function (key) {
return true;
};
MouseHandlerDefaultState.prototype.canClearSelectionOnMouseDown = function () {
return false;
};
MouseHandlerDefaultState.prototype.processOnMouseMoveAfterLimit = function (evt) {
this.startSelection(evt);
};
MouseHandlerDefaultState.prototype.canSelectOnMouseUp = function (key) {
return true;
};
MouseHandlerDefaultState.prototype.canClearSelectionOnMouseUp = function () {
return true;
};
return MouseHandlerDefaultState;
}(MouseHandlerDefaultStateBase_1.MouseHandlerDefaultStateBase));
exports.MouseHandlerDefaultState = MouseHandlerDefaultState;
/***/ }),
/* 118 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Connector_1 = __webpack_require__(5);
var Event_1 = __webpack_require__(10);
var MouseHandlerDraggingState_1 = __webpack_require__(26);
var DeleteConnectionHistoryItem_1 = __webpack_require__(90);
var AddConnectionHistoryItem_1 = __webpack_require__(37);
var MoveConnectorPointHistoryItem_1 = __webpack_require__(50);
var ModelUtils_1 = __webpack_require__(6);
var MouseHandlerMoveConnectorPointStateBase = /** @class */ (function (_super) {
__extends(MouseHandlerMoveConnectorPointStateBase, _super);
function MouseHandlerMoveConnectorPointStateBase(handler, history, model, visualizerManager) {
var _this = _super.call(this, handler, history) || this;
_this.model = model;
_this.visualizerManager = visualizerManager;
return _this;
}
MouseHandlerMoveConnectorPointStateBase.prototype.finish = function () {
this.visualizerManager.resetConnectionTarget();
this.visualizerManager.resetConnectionPoints();
_super.prototype.finish.call(this);
};
MouseHandlerMoveConnectorPointStateBase.prototype.onMouseMove = function (evt) {
_super.prototype.onMouseMove.call(this, evt);
if (this.connector) {
var item = this.connector.getExtremeItem(this.pointPosition);
this.visualizerManager.setConnectionTarget(item, evt.source.type);
var pointIndex = this.connector.getExtremeConnectionPointIndex(this.pointPosition);
if (!item && this.oppositeConnectionPointIndex !== -1)
item = this.model.findItem(evt.source.key);
this.visualizerManager.setConnectionPoints(item, evt.source.type, pointIndex, true);
}
};
MouseHandlerMoveConnectorPointStateBase.prototype.onApplyChanges = function (evt) {
var point = this.getSnappedPoint(evt, evt.modelPoint);
if (this.pointPosition !== undefined) {
if (this.oppositePointPosition === undefined) {
this.oppositePointPosition = this.getOppositePointPosition();
this.oppositeItem = this.connector.getExtremeItem(this.oppositePointPosition);
this.oppositeConnectionPointIndex = this.connector.getExtremeConnectionPointIndex(this.oppositePointPosition);
}
var item = this.model.findItem(evt.source.key);
var connectionPointIndex = -1;
if (evt.source.type === Event_1.MouseEventElementType.ShapeConnectionPoint)
connectionPointIndex = parseInt(evt.source.value);
if (item && !item.isLocked && (evt.source.type === Event_1.MouseEventElementType.Shape || evt.source.type === Event_1.MouseEventElementType.ShapeConnectionPoint) &&
(this.connector.getExtremeItem(this.oppositePointPosition) !== item ||
(connectionPointIndex !== -1 && this.oppositeConnectionPointIndex !== -1 &&
connectionPointIndex !== this.oppositeConnectionPointIndex))) {
if (this.connector.getExtremeItem(this.pointPosition) !== item ||
this.connector.getExtremeConnectionPointIndex(this.pointPosition) !== connectionPointIndex) {
if (this.connector.getExtremeItem(this.pointPosition))
this.history.addAndRedo(new DeleteConnectionHistoryItem_1.DeleteConnectionHistoryItem(this.connector, this.pointPosition));
this.history.addAndRedo(new AddConnectionHistoryItem_1.AddConnectionHistoryItem(this.connector, item, connectionPointIndex, this.pointPosition));
if (this.oppositeItem)
this.updateOppositeItemConnectionPointIndex(connectionPointIndex);
}
point = item.getConnectionPointPosition(connectionPointIndex, this.connector.points[this.pointIndex + (this.pointPosition === Connector_1.ConnectorPosition.End ? -1 : 1)]);
this.visualizerManager.setConnectionPointIndex(connectionPointIndex);
}
else if (this.connector.getExtremeItem(this.pointPosition)) {
this.history.addAndRedo(new DeleteConnectionHistoryItem_1.DeleteConnectionHistoryItem(this.connector, this.pointPosition));
if (this.oppositeItem)
this.updateOppositeItemConnectionPointIndex(this.oppositeConnectionPointIndex);
}
}
this.history.addAndRedo(new MoveConnectorPointHistoryItem_1.MoveConnectorPointHistoryItem(this.connector.key, this.pointIndex, point));
ModelUtils_1.ModelUtils.updateConnectorAttachedPoints(this.history, this.model, this.connector);
this.handler.tryUpdateModelSize();
};
MouseHandlerMoveConnectorPointStateBase.prototype.updateOppositeItemConnectionPointIndex = function (connectionPointIndex) {
this.history.addAndRedo(new DeleteConnectionHistoryItem_1.DeleteConnectionHistoryItem(this.connector, this.oppositePointPosition));
this.history.addAndRedo(new AddConnectionHistoryItem_1.AddConnectionHistoryItem(this.connector, this.oppositeItem, connectionPointIndex === -1 ? -1 : this.oppositeConnectionPointIndex, this.oppositePointPosition));
};
MouseHandlerMoveConnectorPointStateBase.prototype.onFinishWithChanges = function () {
ModelUtils_1.ModelUtils.updateConnectorContainer(this.history, this.model, this.connector);
ModelUtils_1.ModelUtils.removeUnnecessaryConnectorPoints(this.history, this.connector);
};
MouseHandlerMoveConnectorPointStateBase.prototype.getDraggingElementKeys = function () {
return this.connector ? [this.connector.key] : [];
};
MouseHandlerMoveConnectorPointStateBase.prototype.getOppositePointPosition = function () {
return this.pointPosition === Connector_1.ConnectorPosition.Begin ? Connector_1.ConnectorPosition.End : Connector_1.ConnectorPosition.Begin;
};
return MouseHandlerMoveConnectorPointStateBase;
}(MouseHandlerDraggingState_1.MouseHandlerDraggingState));
exports.MouseHandlerMoveConnectorPointStateBase = MouseHandlerMoveConnectorPointStateBase;
/***/ }),
/* 119 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var AddConnectorPointHistoryItem = /** @class */ (function (_super) {
__extends(AddConnectorPointHistoryItem, _super);
function AddConnectorPointHistoryItem(connectorKey, pointIndex, point) {
var _this = _super.call(this) || this;
_this.connectorKey = connectorKey;
_this.pointIndex = pointIndex;
_this.point = point;
return _this;
}
AddConnectorPointHistoryItem.prototype.redo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
manipulator.addConnectorPoint(connector, this.pointIndex, this.point.clone());
};
AddConnectorPointHistoryItem.prototype.undo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
manipulator.deleteConnectorPoint(connector, this.pointIndex);
};
return AddConnectorPointHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.AddConnectorPointHistoryItem = AddConnectorPointHistoryItem;
/***/ }),
/* 120 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Utils_1 = __webpack_require__(0);
var Event_1 = __webpack_require__(10);
var MouseHandlerDraggingState_1 = __webpack_require__(26);
var ModelUtils_1 = __webpack_require__(6);
var MouseHandlerMoveShapeStateBase = /** @class */ (function (_super) {
__extends(MouseHandlerMoveShapeStateBase, _super);
function MouseHandlerMoveShapeStateBase(handler, history, model, selection, visualizerManager) {
var _this = _super.call(this, handler, history) || this;
_this.model = model;
_this.selection = selection;
_this.visualizerManager = visualizerManager;
_this.startScrollLeft = 0;
_this.startScrollTop = 0;
return _this;
}
MouseHandlerMoveShapeStateBase.prototype.finish = function () {
this.visualizerManager.resetExtensionLines();
this.visualizerManager.resetContainerTarget();
this.visualizerManager.resetConnectionTarget();
this.visualizerManager.resetConnectionPoints();
_super.prototype.finish.call(this);
};
MouseHandlerMoveShapeStateBase.prototype.onMouseDown = function (evt) {
this.startPoint = evt.modelPoint;
this.shapes = this.selection.getSelectedShapes(false, true);
this.connectors = this.selection.getSelectedConnectors(false, true);
if (this.shapes.length === 0) {
this.handler.switchToDefaultState();
return;
}
this.startShapePositions = this.shapes.map(function (shape) { return shape.position.clone(); });
this.startConnectorPoints = this.connectors.map(function (c) { return c.points.map(function (p) { return p.clone(); }); });
this.connectorsWithoutBeginItemInfo = ModelUtils_1.ModelUtils.getConnectorsWithoutBeginItemInfo(this.model);
this.connectorsWithoutEndItemInfo = ModelUtils_1.ModelUtils.getConnectorsWithoutEndItemInfo(this.model);
_super.prototype.onMouseDown.call(this, evt);
};
MouseHandlerMoveShapeStateBase.prototype.onMouseMove = function (evt) {
_super.prototype.onMouseMove.call(this, evt);
this.visualizerManager.setExtensionLines(this.selection.getSelectedShapes(false, true));
var container = ModelUtils_1.ModelUtils.findContainerByEventKey(this.model, this.selection, evt.source.key);
if (container && ModelUtils_1.ModelUtils.canInsertSelectionToContainer(this.model, this.selection, container))
this.visualizerManager.setContainerTarget(container, evt.source.type);
else
this.visualizerManager.resetContainerTarget();
};
MouseHandlerMoveShapeStateBase.prototype.onApplyChanges = function (evt) {
var _this = this;
this.shapes.forEach(function (shape, index) {
var pos = _this.getPosition(evt, _this.startShapePositions[index]);
ModelUtils_1.ModelUtils.setShapePosition(_this.history, _this.model, shape, pos);
ModelUtils_1.ModelUtils.updateMovingShapeConnections(_this.history, shape, _this.connectorsWithoutBeginItemInfo, _this.connectorsWithoutEndItemInfo, function () {
_this.visualizerManager.resetConnectionTarget();
_this.visualizerManager.resetConnectionPoints();
}, function (shape, connectionPointIndex) {
_this.visualizerManager.setConnectionTarget(shape, Event_1.MouseEventElementType.Shape);
_this.visualizerManager.setConnectionPoints(shape, Event_1.MouseEventElementType.Shape, connectionPointIndex, true);
});
ModelUtils_1.ModelUtils.updateShapeAttachedConnectors(_this.history, _this.model, shape);
});
this.connectors.forEach(function (connector, index) {
var delta = _this.startShapePositions[0].offset(-_this.shapes[0].position.x, -_this.shapes[0].position.y);
if (delta.x !== 0 || delta.y !== 0) {
var startPtIndex = connector.beginItem ? 1 : 0;
var endPtIndex = connector.endItem ? (connector.points.length - 2) : (connector.points.length - 1);
for (var i = startPtIndex; i <= endPtIndex; i++)
ModelUtils_1.ModelUtils.setConnectorPoint(_this.history, _this.model, connector, i, _this.startConnectorPoints[index][i].offset(-delta.x, -delta.y));
}
});
var container = ModelUtils_1.ModelUtils.findContainerByEventKey(this.model, this.selection, evt.source.key);
if (container && ModelUtils_1.ModelUtils.canInsertSelectionToContainer(this.model, this.selection, container))
ModelUtils_1.ModelUtils.insertSelectionToContainer(this.history, this.model, this.selection, container);
else
ModelUtils_1.ModelUtils.removeSelectionFromContainer(this.history, this.model, this.selection);
this.handler.tryUpdateModelSize(function (offsetLeft, offsetTop) {
_this.connectorsWithoutBeginItemInfo.forEach(function (pi) {
pi.point.x += offsetLeft;
pi.point.y += offsetTop;
});
_this.connectorsWithoutEndItemInfo.forEach(function (pi) {
pi.point.x += offsetLeft;
pi.point.y += offsetTop;
});
});
};
MouseHandlerMoveShapeStateBase.prototype.getDraggingElementKeys = function () {
return this.shapes.map(function (shape) { return shape.key; });
};
MouseHandlerMoveShapeStateBase.prototype.getXPosition = function (evt, baseX) {
return baseX + evt.modelPoint.x - this.startPoint.x;
};
MouseHandlerMoveShapeStateBase.prototype.getYPosition = function (evt, baseY) {
return baseY + evt.modelPoint.y - this.startPoint.y;
};
MouseHandlerMoveShapeStateBase.prototype.getPosition = function (evt, basePoint) {
return new Utils_1.Point(this.handler.getSnappedPos(evt, this.getXPosition(evt, basePoint.x), true), this.handler.getSnappedPos(evt, this.getYPosition(evt, basePoint.y), false));
};
return MouseHandlerMoveShapeStateBase;
}(MouseHandlerDraggingState_1.MouseHandlerDraggingState));
exports.MouseHandlerMoveShapeStateBase = MouseHandlerMoveShapeStateBase;
/***/ }),
/* 121 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var MouseHandlerStateBase_1 = __webpack_require__(32);
var Event_1 = __webpack_require__(10);
var KeyCode_1 = __webpack_require__(16);
var MouseHandlerToggleShapeExpandedState_1 = __webpack_require__(275);
var MouseHandlerSelectionState_1 = __webpack_require__(277);
var MouseHandlerZoomOnWheelState_1 = __webpack_require__(278);
var MouseHandlerScrollingState_1 = __webpack_require__(122);
var UnitConverter_1 = __webpack_require__(13);
var MouseHandlerDefaultStateBase = /** @class */ (function (_super) {
__extends(MouseHandlerDefaultStateBase, _super);
function MouseHandlerDefaultStateBase(handler, history, selection, model, view, visualizerManager, settings, bars) {
var _this = _super.call(this, handler) || this;
_this.history = history;
_this.selection = selection;
_this.model = model;
_this.view = view;
_this.visualizerManager = visualizerManager;
_this.settings = settings;
_this.bars = bars;
return _this;
}
MouseHandlerDefaultStateBase.prototype.onMouseDown = function (evt) {
this.onMouseDownCore(evt);
if (this.handler.state !== this)
this.handler.state.onMouseDown(evt);
};
MouseHandlerDefaultStateBase.prototype.onMouseDownCore = function (evt) {
if (evt.modifiers === KeyCode_1.ModifierKey.Ctrl)
this.startScrolling(evt);
else if (evt.source.type === Event_1.MouseEventElementType.Shape && this.canDragObjectOnMouseDown(evt.source.key))
this.onShapeMouseDown(evt);
else if (evt.source.type === Event_1.MouseEventElementType.Connector && this.canDragObjectOnMouseDown(evt.source.key))
this.onConnectorMouseDown(evt);
else if (evt.source.type === Event_1.MouseEventElementType.ShapeExpandButton)
this.onShapeExpandBtnMouseDown(evt);
else {
if (evt.source.type !== Event_1.MouseEventElementType.Shape &&
evt.source.type !== Event_1.MouseEventElementType.Connector &&
this.canClearSelectionOnMouseDown())
this.clearSelection();
this.startPoint = evt.modelPoint;
}
};
MouseHandlerDefaultStateBase.prototype.onMouseMove = function (evt) {
this.onMouseMoveCore(evt);
if (this.handler.state !== this) {
this.handler.state.onMouseDown(this.handler.mouseDownEvent);
this.handler.state.onMouseMove(evt);
}
};
MouseHandlerDefaultStateBase.prototype.onMouseMoveCore = function (evt) {
if (this.startPoint &&
(Math.abs(this.startPoint.x - evt.modelPoint.x) > MouseHandlerDefaultStateBase.startLimit ||
Math.abs(this.startPoint.y - evt.modelPoint.y) > MouseHandlerDefaultStateBase.startLimit)) {
this.processOnMouseMoveAfterLimit(evt);
this.startPoint = undefined;
}
};
MouseHandlerDefaultStateBase.prototype.onMouseUp = function (evt) {
this.onMouseUpCore(evt);
if (this.handler.state !== this)
this.handler.state.onMouseUp(evt);
};
MouseHandlerDefaultStateBase.prototype.onMouseUpCore = function (evt) {
if (evt.source.type === Event_1.MouseEventElementType.Shape && this.canSelectOnMouseUp(evt.source.key))
this.modifySelection(evt, evt.source.key);
else if (evt.source.type === Event_1.MouseEventElementType.Connector && this.canSelectOnMouseUp(evt.source.key))
this.modifySelection(evt, evt.source.key);
else if (evt.source.type === Event_1.MouseEventElementType.ShapeExpandButton && this.canSelectOnMouseUp(evt.source.key))
this.modifySelection(evt, evt.source.key);
else if (this.startPoint && this.canClearSelectionOnMouseUp())
this.clearSelection();
this.startPoint = undefined;
};
MouseHandlerDefaultStateBase.prototype.onMouseWheel = function (evt) {
if (evt.modifiers & KeyCode_1.ModifierKey.Ctrl) {
this.handler.switchState(new MouseHandlerZoomOnWheelState_1.MouseHandlerZoomOnWheelState(this.handler, this.settings, this.view, this.bars));
this.handler.state.onMouseWheel(evt);
return true;
}
return false;
};
MouseHandlerDefaultStateBase.prototype.onLongTouch = function (evt) {
this.modifySelection(evt, evt.source.key, true);
};
MouseHandlerDefaultStateBase.prototype.onConnectorMouseDown = function (evt) {
this.modifySelection(evt, evt.source.key);
};
MouseHandlerDefaultStateBase.prototype.onShapeMouseDown = function (evt) {
this.modifySelection(evt, evt.source.key);
};
MouseHandlerDefaultStateBase.prototype.onShapeExpandBtnMouseDown = function (evt) {
this.modifySelection(evt, evt.source.key);
this.handler.switchState(new MouseHandlerToggleShapeExpandedState_1.MouseHandlerToggleShapeExpandedState(this.handler, this.history, this.model));
};
MouseHandlerDefaultStateBase.prototype.finish = function () {
this.startPoint = undefined;
};
MouseHandlerDefaultStateBase.prototype.startSelection = function (evt) {
this.handler.switchState(new MouseHandlerSelectionState_1.MouseHandlerSelectionState(this.handler, this.selection, this.visualizerManager));
};
MouseHandlerDefaultStateBase.prototype.startScrolling = function (evt) {
this.handler.switchState(new MouseHandlerScrollingState_1.MouseHandlerScrollingState(this.handler, this.view, this.selection));
};
MouseHandlerDefaultStateBase.prototype.modifySelection = function (evt, key, forceMultipleSelection) {
if (this.isMultipleSelectionModifier(evt) || forceMultipleSelection) {
if (this.selection.hasKey(key))
this.selection.remove(key);
else
this.selection.add(key);
}
else if (!this.selection.hasKey(key))
this.selection.set([key]);
};
MouseHandlerDefaultStateBase.prototype.clearSelection = function () {
this.selection.set([]);
};
MouseHandlerDefaultStateBase.prototype.inSelection = function (key) {
return this.selection.hasKey(key);
};
MouseHandlerDefaultStateBase.prototype.isMultipleSelectionModifier = function (evt) {
return evt.modifiers & KeyCode_1.ModifierKey.Ctrl || evt.modifiers & KeyCode_1.ModifierKey.Shift;
};
MouseHandlerDefaultStateBase.startLimit = UnitConverter_1.UnitConverter.pixelsToTwips(1);
return MouseHandlerDefaultStateBase;
}(MouseHandlerStateBase_1.MouseHandlerStateBase));
exports.MouseHandlerDefaultStateBase = MouseHandlerDefaultStateBase;
/***/ }),
/* 122 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var MouseHandlerStateBase_1 = __webpack_require__(32);
var Event_1 = __webpack_require__(10);
var Utils_1 = __webpack_require__(0);
var MouseHandlerScrollingState = /** @class */ (function (_super) {
__extends(MouseHandlerScrollingState, _super);
function MouseHandlerScrollingState(handler, view, selection) {
var _this = _super.call(this, handler) || this;
_this.view = view;
_this.selection = selection;
_this.lastOffset = new Utils_1.Point(0, 0);
return _this;
}
MouseHandlerScrollingState.prototype.onMouseDown = function (evt) {
evt.preventDefault = true;
this.startPoint = this.getPointByEvent(evt);
};
MouseHandlerScrollingState.prototype.onMouseMove = function (evt) {
if (evt.button !== Event_1.MouseButton.Left) {
this.handler.switchToDefaultState();
return;
}
var prevPoint = this.currentPoint || this.startPoint;
evt.preventDefault = true;
var point = this.getPointByEvent(evt);
var actualOffset = this.view.scrollBy(new Utils_1.Point(point.x - prevPoint.x, point.y - prevPoint.y));
this.lastOffset = this.lastOffset.offset(actualOffset.x, actualOffset.y);
this.currentPoint = point;
};
MouseHandlerScrollingState.prototype.onMouseUp = function (evt) {
this.handler.switchToDefaultState();
};
MouseHandlerScrollingState.prototype.cancelChanges = function () {
if (this.currentPoint)
this.view.scrollBy(this.lastOffset.multiply(-1));
};
MouseHandlerScrollingState.prototype.start = function () {
this.handler.raiseDragScrollStart();
_super.prototype.start.call(this);
};
MouseHandlerScrollingState.prototype.finish = function () {
this.handler.raiseDragScrollEnd();
if (!this.currentPoint || !this.startPoint || this.currentPoint.equals(this.startPoint))
this.selection.set([]);
_super.prototype.finish.call(this);
};
MouseHandlerScrollingState.prototype.getPointByEvent = function (evt) {
return evt.offsetPoint;
};
return MouseHandlerScrollingState;
}(MouseHandlerStateBase_1.MouseHandlerCancellableState));
exports.MouseHandlerScrollingState = MouseHandlerScrollingState;
/***/ }),
/* 123 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var MouseHandlerDefaultStateBase_1 = __webpack_require__(121);
var MouseHandlerDefaultReadOnlyState = /** @class */ (function (_super) {
__extends(MouseHandlerDefaultReadOnlyState, _super);
function MouseHandlerDefaultReadOnlyState() {
return _super !== null && _super.apply(this, arguments) || this;
}
MouseHandlerDefaultReadOnlyState.prototype.canDragObjectOnMouseDown = function (key) {
return false;
};
MouseHandlerDefaultReadOnlyState.prototype.canClearSelectionOnMouseDown = function () {
return false;
};
MouseHandlerDefaultReadOnlyState.prototype.processOnMouseMoveAfterLimit = function (evt) {
this.startSelection(evt);
};
MouseHandlerDefaultReadOnlyState.prototype.canSelectOnMouseUp = function (key) {
return true;
};
MouseHandlerDefaultReadOnlyState.prototype.canClearSelectionOnMouseUp = function () {
return true;
};
return MouseHandlerDefaultReadOnlyState;
}(MouseHandlerDefaultStateBase_1.MouseHandlerDefaultStateBase));
exports.MouseHandlerDefaultReadOnlyState = MouseHandlerDefaultReadOnlyState;
/***/ }),
/* 124 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var __1 = __webpack_require__(8);
var ContextMenuHandler = /** @class */ (function () {
function ContextMenuHandler() {
this.contextMenuVisible = false;
this.onVisibilityChanged = new __1.EventDispatcher();
}
ContextMenuHandler.prototype.onMouseDown = function (evt) { };
ContextMenuHandler.prototype.onMouseUp = function (evt) {
this.hideContextMenu();
};
ContextMenuHandler.prototype.onContextMenu = function (evt) {
this.showContextMenu(evt.eventPoint, evt.modelPoint);
};
ContextMenuHandler.prototype.onFocus = function (evt) { };
ContextMenuHandler.prototype.onBlur = function (evt) { };
ContextMenuHandler.prototype.onTextInputFocus = function (evt) { };
ContextMenuHandler.prototype.onTextInputBlur = function (evt) { };
ContextMenuHandler.prototype.onLongTouch = function (evt) { };
ContextMenuHandler.prototype.showContextMenu = function (eventPoint, modelPoint) {
this.onVisibilityChanged.raise1(function (l) { return l.notifyShowContextMenu(eventPoint, modelPoint); });
this.contextMenuVisible = true;
};
ContextMenuHandler.prototype.hideContextMenu = function () {
if (this.contextMenuVisible) {
this.onVisibilityChanged.raise1(function (l) { return l.notifyHideContextMenu(); });
this.contextMenuVisible = false;
}
};
ContextMenuHandler.prototype.notifyDragStart = function (itemKeys) { };
ContextMenuHandler.prototype.notifyDragEnd = function (itemKeys) { };
ContextMenuHandler.prototype.notifyDragScrollStart = function () { };
ContextMenuHandler.prototype.notifyDragScrollEnd = function () { };
return ContextMenuHandler;
}());
exports.ContextMenuHandler = ContextMenuHandler;
/***/ }),
/* 125 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ConnectionTargetVisualizer_1 = __webpack_require__(287);
var ContainerTargetVisualizer_1 = __webpack_require__(288);
var ExtensionLinesVisualizer_1 = __webpack_require__(88);
var __1 = __webpack_require__(8);
var Model_1 = __webpack_require__(19);
var Event_1 = __webpack_require__(10);
var ConnectionPointsVisualizer_1 = __webpack_require__(289);
var Shape_1 = __webpack_require__(11);
var Utils_1 = __webpack_require__(0);
var CanvasSelectionManager_1 = __webpack_require__(87);
var ModelUtils_1 = __webpack_require__(6);
var ResizeInfoVisualizer_1 = __webpack_require__(290);
var SelectionRectVisualizer_1 = __webpack_require__(291);
var VisualizerManager = /** @class */ (function () {
function VisualizerManager(selection, model, eventManager, settings, readOnly) {
if (readOnly === void 0) { readOnly = settings.readOnly; }
this.selection = selection;
this.model = model;
this.eventManager = eventManager;
this.settings = settings;
this.readOnly = readOnly;
this.onVisualizersUpdate = new __1.EventDispatcher();
this.connectionPointsVisualizer = new ConnectionPointsVisualizer_1.ConnectionPointsVisualizer(this.onVisualizersUpdate);
this.connectionPointsVisualizer = new ConnectionPointsVisualizer_1.ConnectionPointsVisualizer(this.onVisualizersUpdate);
this.connectionTargetVisualizer = new ConnectionTargetVisualizer_1.ConnectionTargetVisualizer(this.onVisualizersUpdate);
this.containerTargetVisualizer = new ContainerTargetVisualizer_1.ContainerTargetVisualizer(this.onVisualizersUpdate);
this.extensionLinesVisualizer = new ExtensionLinesVisualizer_1.ExtensionLinesVisualizer(this.onVisualizersUpdate);
this.resizeInfoVisualizer = new ResizeInfoVisualizer_1.ResizeInfoVisualizer(this.onVisualizersUpdate);
this.selectionRectangleVisualizer = new SelectionRectVisualizer_1.SelectionRectVisualizer(this.onVisualizersUpdate);
}
VisualizerManager.prototype.initialize = function (model) {
this.model = model;
};
VisualizerManager.prototype.onMouseDown = function (evt) {
};
VisualizerManager.prototype.onMouseUp = function (evt) {
};
VisualizerManager.prototype.onMouseEnter = function (evt) {
};
VisualizerManager.prototype.onMouseLeave = function (evt) {
this.resetConnectionPoints();
this.resetConnectionTarget();
this.resetExtensionLines();
this.resetContainerTarget();
this.resetResizeInfo();
this.resetSelectionRectangle();
};
VisualizerManager.prototype.onBlur = function (evt) {
};
VisualizerManager.prototype.onFocus = function (evt) {
};
VisualizerManager.prototype.updateConnections = function (item, type, value) {
var pointIndex = -1;
if (value && type === Event_1.MouseEventElementType.ShapeConnectionPoint)
pointIndex = parseInt(value);
this.setConnectionPoints(item, type, pointIndex);
};
VisualizerManager.prototype.setConnectionPoints = function (item, type, pointIndex, preventShowOutside) {
if (!this.eventManager.isFocused())
return;
if (item && !item.isLocked && (type === Event_1.MouseEventElementType.Shape || type === Event_1.MouseEventElementType.ShapeResizeBox ||
type === Event_1.MouseEventElementType.ShapeConnectionPoint) && item !== undefined) {
var key = item.key;
var isSelected_1 = this.selection.hasKey(key);
var points = isSelected_1 ? item.getConnectionPointsForSelection() : item.getConnectionPoints();
this.connectionPointsVisualizer.setPoints(key, points.map(function (pt) { return new ConnectionPointsVisualizer_1.ConnectionPointInfo(pt, isSelected_1 ? item.getConnectionPointForSelectionSide(pt) : item.getConnectionPointSide(pt)); }), pointIndex, isSelected_1 && !preventShowOutside);
}
else
this.connectionPointsVisualizer.reset();
};
VisualizerManager.prototype.setConnectionPointIndex = function (index) {
this.connectionPointsVisualizer.setPointIndex(index);
};
VisualizerManager.prototype.updateConnectionPoints = function () {
var item = this.model.findItem(this.connectionPointsVisualizer.getKey());
if (item !== undefined)
this.connectionPointsVisualizer.update();
else
this.connectionPointsVisualizer.reset();
};
VisualizerManager.prototype.resetConnectionPoints = function () {
this.connectionPointsVisualizer.reset();
};
VisualizerManager.prototype.setConnectionTarget = function (item, type) {
if (item && !item.isLocked && (type === Event_1.MouseEventElementType.Shape ||
type === Event_1.MouseEventElementType.ShapeConnectionPoint)) {
this.connectionTargetVisualizer.setTargetRect(item.key, item.rectangle);
}
else
this.connectionTargetVisualizer.reset();
};
VisualizerManager.prototype.resetConnectionTarget = function () {
this.connectionTargetVisualizer.reset();
};
VisualizerManager.prototype.setContainerTarget = function (item, type) {
if (item && !item.isLocked && (type === Event_1.MouseEventElementType.Shape) && item.enableChildren)
this.containerTargetVisualizer.setTargetRect(item.key, item.rectangle);
else
this.containerTargetVisualizer.reset();
};
VisualizerManager.prototype.resetContainerTarget = function () {
this.containerTargetVisualizer.reset();
};
VisualizerManager.prototype.setExtensionLines = function (items) {
var _this = this;
if (!this.eventManager.isFocused())
return;
this.extensionLinesVisualizer.reset();
var rect = Model_1.DiagramModel.getRectangle(items.filter(function (item) { return item; }));
this.addPageExtensionLines(rect);
this.model.items.forEach(function (item) {
if (items.indexOf(item) > -1)
return;
if (item instanceof Shape_1.Shape)
_this.addShapeExtensionLines(item, rect);
});
};
VisualizerManager.prototype.addPageExtensionLines = function (rect) {
var horPages = Math.round(this.model.size.width / this.model.pageWidth);
var verPages = Math.round(this.model.size.height / this.model.pageHeight);
for (var i = 0; i < horPages; i++) {
for (var j = 0; j < verPages; j++) {
var center = new Utils_1.Point(i * this.model.pageWidth + this.model.pageWidth / 2, j * this.model.pageHeight + this.model.pageHeight / 2);
if (Math.abs(rect.center.x - center.x) < this.settings.gridSize / 2) {
var segment = new Utils_1.Segment(new Utils_1.Point(rect.center.x, 0), new Utils_1.Point(rect.center.x, this.model.size.height));
this.extensionLinesVisualizer.addSegment(ExtensionLinesVisualizer_1.ExtensionLineType.HorizontalCenterToPageCenter, segment, "");
}
if (Math.abs(rect.center.y - center.y) < this.settings.gridSize / 2) {
var segment = new Utils_1.Segment(new Utils_1.Point(0, rect.center.y), new Utils_1.Point(this.model.size.width, rect.center.y));
this.extensionLinesVisualizer.addSegment(ExtensionLinesVisualizer_1.ExtensionLineType.VerticalCenterToPageCenter, segment, "");
}
if (Math.abs(rect.left - center.x) < this.settings.gridSize / 2) {
var segment = new Utils_1.Segment(new Utils_1.Point(rect.left, 0), new Utils_1.Point(rect.left, this.model.size.height));
this.extensionLinesVisualizer.addSegment(ExtensionLinesVisualizer_1.ExtensionLineType.LeftToPageCenter, segment, "");
}
if (Math.abs(rect.top - center.y) < this.settings.gridSize / 2) {
var segment = new Utils_1.Segment(new Utils_1.Point(0, rect.top), new Utils_1.Point(this.model.size.width, rect.top));
this.extensionLinesVisualizer.addSegment(ExtensionLinesVisualizer_1.ExtensionLineType.TopToPageCenter, segment, "");
}
if (Math.abs(rect.right - center.x) < this.settings.gridSize / 2) {
var segment = new Utils_1.Segment(new Utils_1.Point(rect.right, 0), new Utils_1.Point(rect.right, this.model.size.height));
this.extensionLinesVisualizer.addSegment(ExtensionLinesVisualizer_1.ExtensionLineType.RightToPageCenter, segment, "");
}
if (Math.abs(rect.bottom - center.y) < this.settings.gridSize / 2) {
var segment = new Utils_1.Segment(new Utils_1.Point(0, rect.bottom), new Utils_1.Point(this.model.size.width, rect.bottom));
this.extensionLinesVisualizer.addSegment(ExtensionLinesVisualizer_1.ExtensionLineType.BottomToPageCenter, segment, "");
}
}
}
};
VisualizerManager.prototype.addShapeExtensionLines = function (shape, rect) {
var sRect = shape.rectangle;
var lwCor = Shape_1.Shape.lineWidth - CanvasSelectionManager_1.CanvasSelectionManager.extensionLineWidth;
var showDistance = true;
var x1, y1, x2, y2;
if (rect.right < sRect.left) {
x1 = rect.right + lwCor + CanvasSelectionManager_1.CanvasSelectionManager.extensionLineOffset;
x2 = sRect.left - CanvasSelectionManager_1.CanvasSelectionManager.extensionLineOffset;
}
else if (rect.left > sRect.right) {
x1 = rect.left - CanvasSelectionManager_1.CanvasSelectionManager.extensionLineOffset;
x2 = sRect.right + lwCor + CanvasSelectionManager_1.CanvasSelectionManager.extensionLineOffset;
}
if (rect.bottom < sRect.top) {
y1 = rect.bottom + lwCor + CanvasSelectionManager_1.CanvasSelectionManager.extensionLineOffset;
y2 = sRect.top - CanvasSelectionManager_1.CanvasSelectionManager.extensionLineOffset;
}
else if (rect.top > sRect.bottom) {
y1 = rect.top - CanvasSelectionManager_1.CanvasSelectionManager.extensionLineOffset;
y2 = sRect.bottom + lwCor + CanvasSelectionManager_1.CanvasSelectionManager.extensionLineOffset;
}
if (x1 != undefined && x2 !== undefined) {
if (rect.center.y === sRect.center.y) {
var segment = new Utils_1.Segment(new Utils_1.Point(x1, rect.center.y), new Utils_1.Point(x2, sRect.center.y));
this.extensionLinesVisualizer.addSegment(x1 > x2 ? ExtensionLinesVisualizer_1.ExtensionLineType.VerticalCenterAfter : ExtensionLinesVisualizer_1.ExtensionLineType.VerticalCenterBefore, segment, showDistance ? this.getViewUnitText(segment.distance) : "");
showDistance = false;
}
if (rect.top === sRect.top) {
var segment = new Utils_1.Segment(new Utils_1.Point(x1, rect.top), new Utils_1.Point(x2, sRect.top));
this.extensionLinesVisualizer.addSegment(x1 > x2 ? ExtensionLinesVisualizer_1.ExtensionLineType.TopToTopAfter : ExtensionLinesVisualizer_1.ExtensionLineType.TopToTopBefore, segment, showDistance ? this.getViewUnitText(segment.distance) : "");
}
if (rect.bottom === sRect.bottom) {
var segment = new Utils_1.Segment(new Utils_1.Point(x1, rect.bottom + lwCor), new Utils_1.Point(x2, sRect.bottom + lwCor));
this.extensionLinesVisualizer.addSegment(x1 > x2 ? ExtensionLinesVisualizer_1.ExtensionLineType.BottomToBottomAfter : ExtensionLinesVisualizer_1.ExtensionLineType.BottomToBottomBefore, segment, showDistance ? this.getViewUnitText(segment.distance) : "");
}
if (rect.top === sRect.bottom) {
var segment = new Utils_1.Segment(new Utils_1.Point(x1, rect.top), new Utils_1.Point(x2, sRect.bottom + lwCor));
this.extensionLinesVisualizer.addSegment(x1 > x2 ? ExtensionLinesVisualizer_1.ExtensionLineType.TopToBottomAfter : ExtensionLinesVisualizer_1.ExtensionLineType.TopToBottomBefore, segment, showDistance ? this.getViewUnitText(segment.distance) : "");
}
if (rect.bottom === sRect.top) {
var segment = new Utils_1.Segment(new Utils_1.Point(x1, rect.bottom + lwCor), new Utils_1.Point(x2, sRect.top));
this.extensionLinesVisualizer.addSegment(x1 > x2 ? ExtensionLinesVisualizer_1.ExtensionLineType.BottomToTopAfter : ExtensionLinesVisualizer_1.ExtensionLineType.BottomToTopBefore, segment, showDistance ? this.getViewUnitText(segment.distance) : "");
}
}
if (y1 != undefined && y2 !== undefined) {
if (rect.center.x === sRect.center.x) {
var segment = new Utils_1.Segment(new Utils_1.Point(rect.center.x, y1), new Utils_1.Point(sRect.center.x, y2));
this.extensionLinesVisualizer.addSegment(y1 > y2 ? ExtensionLinesVisualizer_1.ExtensionLineType.HorizontalCenterBelow : ExtensionLinesVisualizer_1.ExtensionLineType.HorizontalCenterAbove, segment, showDistance ? this.getViewUnitText(segment.distance) : "");
showDistance = false;
}
if (rect.left === sRect.left) {
var segment = new Utils_1.Segment(new Utils_1.Point(rect.left, y1), new Utils_1.Point(sRect.left, y2));
this.extensionLinesVisualizer.addSegment(y1 > y2 ? ExtensionLinesVisualizer_1.ExtensionLineType.LeftToLeftBelow : ExtensionLinesVisualizer_1.ExtensionLineType.LeftToLeftAbove, segment, showDistance ? this.getViewUnitText(segment.distance) : "");
}
if (rect.right === sRect.right) {
var segment = new Utils_1.Segment(new Utils_1.Point(rect.right + lwCor, y1), new Utils_1.Point(sRect.right + lwCor, y2));
this.extensionLinesVisualizer.addSegment(y1 > y2 ? ExtensionLinesVisualizer_1.ExtensionLineType.RightToRightBelow : ExtensionLinesVisualizer_1.ExtensionLineType.RightToRightAbove, segment, showDistance ? this.getViewUnitText(segment.distance) : "");
}
if (rect.left === sRect.right) {
var segment = new Utils_1.Segment(new Utils_1.Point(rect.left, y1), new Utils_1.Point(sRect.right + lwCor, y2));
this.extensionLinesVisualizer.addSegment(y1 > y2 ? ExtensionLinesVisualizer_1.ExtensionLineType.LeftToRightBelow : ExtensionLinesVisualizer_1.ExtensionLineType.LeftToRightAbove, segment, showDistance ? this.getViewUnitText(segment.distance) : "");
}
if (rect.right === sRect.left) {
var segment = new Utils_1.Segment(new Utils_1.Point(rect.right + lwCor, y1), new Utils_1.Point(sRect.left, y2));
this.extensionLinesVisualizer.addSegment(y1 > y2 ? ExtensionLinesVisualizer_1.ExtensionLineType.RightToLeftBelow : ExtensionLinesVisualizer_1.ExtensionLineType.RightToLeftAbove, segment, showDistance ? this.getViewUnitText(segment.distance) : "");
}
}
};
VisualizerManager.prototype.resetExtensionLines = function () {
this.extensionLinesVisualizer.reset();
};
VisualizerManager.prototype.setResizeInfo = function (items) {
var rect = Model_1.DiagramModel.getRectangle(items);
var point = new Utils_1.Point(rect.center.x, rect.bottom + CanvasSelectionManager_1.CanvasSelectionManager.resizeInfoOffset);
var text = this.getViewUnitText(rect.width) + " x " + this.getViewUnitText(rect.height);
this.resizeInfoVisualizer.set(point, text);
};
VisualizerManager.prototype.resetResizeInfo = function () {
this.resizeInfoVisualizer.reset();
};
VisualizerManager.prototype.setSelectionRectangle = function (rect) {
this.selectionRectangleVisualizer.setRectangle(rect);
};
VisualizerManager.prototype.resetSelectionRectangle = function () {
this.selectionRectangleVisualizer.reset();
};
// utils
VisualizerManager.prototype.getViewUnitText = function (value) {
return ModelUtils_1.ModelUtils.getUnitText(this.settings.viewUnits, this.settings.unitItems, this.settings.formatUnit, value);
};
VisualizerManager.prototype.notifyReadOnlyChanged = function (readOnly) {
this.readOnly = readOnly;
};
VisualizerManager.prototype.notifyDragStart = function (itemKeys) { };
VisualizerManager.prototype.notifyDragEnd = function (itemKeys) { };
VisualizerManager.prototype.notifyDragScrollStart = function () { };
VisualizerManager.prototype.notifyDragScrollEnd = function () { };
return VisualizerManager;
}());
exports.VisualizerManager = VisualizerManager;
/***/ }),
/* 126 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var TargetVisualizerBase = /** @class */ (function () {
function TargetVisualizerBase(dispatcher) {
this.dispatcher = dispatcher;
}
TargetVisualizerBase.prototype.getKey = function () {
return this.key;
};
TargetVisualizerBase.prototype.setTargetRect = function (key, targetRect) {
if (this.key !== key) {
this.key = key;
this.targetRect = targetRect;
this.raiseShow();
}
};
TargetVisualizerBase.prototype.reset = function () {
if (this.key !== "-1") {
this.key = "-1";
this.targetRect = undefined;
this.raiseHide();
}
};
return TargetVisualizerBase;
}());
exports.TargetVisualizerBase = TargetVisualizerBase;
/***/ }),
/* 127 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var BatchUpdatableObject = /** @class */ (function () {
function BatchUpdatableObject() {
this.suspendUpdateCount = 0;
this.occurredEvents = 0;
}
BatchUpdatableObject.prototype.beginUpdate = function () {
if (this.suspendUpdateCount === 0)
this.onUpdateLocked();
if (this.suspendUpdateCount < 0)
this.suspendUpdateCount--;
else
this.suspendUpdateCount++;
};
BatchUpdatableObject.prototype.endUpdate = function () {
if (this.suspendUpdateCount < 0)
this.suspendUpdateCount++;
else if (this.suspendUpdateCount > 0)
this.suspendUpdateCount--;
if (!this.isUpdateLocked()) {
var occurredEvents = this.occurredEvents;
this.occurredEvents = 0;
this.onUpdateUnlocked(occurredEvents);
}
};
BatchUpdatableObject.prototype.suspendUpdate = function () {
if (this.suspendUpdateCount > 0) {
this.suspendUpdateCount *= -1;
var occurredEvents = this.occurredEvents;
this.occurredEvents = 0;
this.onUpdateUnlocked(occurredEvents);
}
};
BatchUpdatableObject.prototype.continueUpdate = function () {
if (this.suspendUpdateCount < 0)
this.suspendUpdateCount *= -1;
};
BatchUpdatableObject.prototype.isUpdateLocked = function () {
return this.suspendUpdateCount > 0;
};
BatchUpdatableObject.prototype.onUpdateLocked = function () { };
BatchUpdatableObject.prototype.registerOccurredEvent = function (eventMask) {
this.occurredEvents |= eventMask;
};
return BatchUpdatableObject;
}());
exports.BatchUpdatableObject = BatchUpdatableObject;
/***/ }),
/* 128 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Utils_1 = __webpack_require__(0);
var Evt_1 = __webpack_require__(39);
var Base_1 = __webpack_require__(17);
var TouchUIHelper_1 = __webpack_require__(62);
var __1 = __webpack_require__(8);
var DRAGGING_OFFSET = 4, TOOLBOX_CSSCLASS = "dxdi-toolbox", DRAG_CAPTURED_CSSCLASS = "dxdi-tb-drag-captured";
var Toolbox = /** @class */ (function () {
function Toolbox(parent, readonly, options) {
this.readonly = readonly;
this.options = options;
this.onDragOperation = new Utils_1.EventDispatcher();
if (!parent)
return;
this.mainElement = this.createMainElement(parent);
this.attachHandlers(this.mainElement);
}
Toolbox.prototype.dispose = function () {
this.detachHandlers(this.mainElement);
};
Toolbox.prototype.createMainElement = function (parent) {
var element = document.createElement("div");
element.setAttribute("class", TOOLBOX_CSSCLASS);
parent.appendChild(element);
return element;
};
Toolbox.prototype.attachHandlers = function (element) {
this.onMouseDownHandler = this.onMouseDown.bind(this);
this.onMouseMoveHandler = this.onMouseMove.bind(this);
this.onMouseUpHandler = this.onMouseUp.bind(this);
element.addEventListener(TouchUIHelper_1.TouchUIHelper.touchMouseDownEventName, this.onMouseDownHandler);
document.addEventListener(TouchUIHelper_1.TouchUIHelper.touchMouseMoveEventName, this.onMouseMoveHandler);
document.addEventListener(TouchUIHelper_1.TouchUIHelper.touchMouseUpEventName, this.onMouseUpHandler);
};
Toolbox.prototype.detachHandlers = function (element) {
element.removeEventListener(TouchUIHelper_1.TouchUIHelper.touchMouseDownEventName, this.onMouseDownHandler);
document.removeEventListener(TouchUIHelper_1.TouchUIHelper.touchMouseMoveEventName, this.onMouseMoveHandler);
document.removeEventListener(TouchUIHelper_1.TouchUIHelper.touchMouseUpEventName, this.onMouseUpHandler);
};
Toolbox.prototype.render = function (filter) {
if (this.mainElement.childNodes)
this.mainElement.innerHTML = "";
var shapeTypes = filter ? this.options.shapeTypes.filter(filter) : this.options.shapeTypes;
if (shapeTypes.length)
this.createElements(this.mainElement, shapeTypes);
return !!shapeTypes.length;
};
Toolbox.prototype.createDraggingObject = function (srcElement) {
var shapeType = this.getDragShapeType(srcElement);
if (shapeType !== undefined) {
var evt = new DiagramDraggingEvent();
evt.data = shapeType;
return new ToolboxDraggingObject(evt);
}
return undefined;
};
Toolbox.prototype.getDragShapeType = function (element) {
while (element && !Base_1.ElementHasCssClass(element, TOOLBOX_CSSCLASS)) {
if (element.getAttribute("data-tb-type"))
return element.getAttribute("data-tb-type");
element = element.parentNode;
}
return undefined;
};
Toolbox.prototype.onMouseDown = function (evt) {
if (this.readonly)
return;
this.mouseDownPoint = new Utils_1.Point(Evt_1.Evt.GetEventX(evt), Evt_1.Evt.GetEventY(evt));
this.draggingObject = this.createDraggingObject(evt.target);
if (this.draggingObject) {
this.draggingObject.evt.onFinishDragging = this.finishDragging.bind(this);
this.draggingObject.evt.onCaptured = this.capture.bind(this);
this.onDragStart();
}
var srcElement = Evt_1.Evt.GetEventSource(evt);
var tagName = srcElement && srcElement.tagName;
if (__1.Browser.TouchUI || tagName.toLowerCase() === "img" || tagName.toLowerCase() === "image") // prevent dragging
return Evt_1.Evt.PreventEventAndBubble(evt);
};
Toolbox.prototype.onMouseMove = function (evt) {
if (!Evt_1.Evt.IsLeftButtonPressed(evt))
this.finishDragging();
else if (this.draggingObject) {
if (!this.draggingObject.element &&
(Math.abs(Evt_1.Evt.GetEventX(evt) - this.mouseDownPoint.x) > DRAGGING_OFFSET ||
Math.abs(Evt_1.Evt.GetEventY(evt) - this.mouseDownPoint.y) > DRAGGING_OFFSET)) {
this.draggingObject.element = this.createDraggingElement(this.draggingObject);
if (this.draggingObject.captured !== undefined)
this.capture(this.draggingObject.captured, true);
}
if (this.draggingObject.element)
this.updateDraggingElementPosition(evt);
}
if (__1.Browser.TouchUI)
return Evt_1.Evt.PreventEventAndBubble(evt);
};
Toolbox.prototype.onMouseUp = function (evt) {
this.finishDragging();
};
Toolbox.prototype.updateDraggingElementPosition = function (evt) {
var element = this.draggingObject.element;
var xPos = (Evt_1.Evt.GetEventX(evt) - element.offsetWidth / 2);
var yPos = (Evt_1.Evt.GetEventY(evt) - element.offsetHeight / 2);
Base_1.SetAbsoluteX(element, xPos);
Base_1.SetAbsoluteY(element, yPos);
};
Toolbox.prototype.finishDragging = function () {
if (this.draggingObject) {
this.onDragEnd();
var element = this.draggingObject.element;
if (element)
element.parentNode.removeChild(element);
delete this.draggingObject;
}
};
Toolbox.prototype.capture = function (captured, forced) {
if (this.draggingObject && (this.draggingObject.captured !== captured || forced)) {
this.draggingObject.captured = captured;
if (this.draggingObject.element)
Base_1.ToggleElementClassName(this.draggingObject.element, DRAG_CAPTURED_CSSCLASS, captured);
}
};
Toolbox.prototype.onDragEnd = function () {
this.onDragOperation.raise("notifyToolboxDragEnd");
};
Toolbox.prototype.onDragStart = function () {
this.onDragOperation.raise("notifyToolboxDragStart");
};
Toolbox.prototype.notifyReadOnlyChanged = function (readOnly) {
this.readonly = readOnly;
};
return Toolbox;
}());
exports.Toolbox = Toolbox;
var ToolboxDraggingObject = /** @class */ (function () {
function ToolboxDraggingObject(evt) {
this.evt = evt;
}
return ToolboxDraggingObject;
}());
exports.ToolboxDraggingObject = ToolboxDraggingObject;
var DiagramDraggingEvent = /** @class */ (function () {
function DiagramDraggingEvent() {
}
return DiagramDraggingEvent;
}());
exports.DiagramDraggingEvent = DiagramDraggingEvent;
/***/ }),
/* 129 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ModelUtils_1 = __webpack_require__(6);
var SimpleCommandBase_1 = __webpack_require__(7);
var DeleteCommand = /** @class */ (function (_super) {
__extends(DeleteCommand, _super);
function DeleteCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
DeleteCommand.prototype.isEnabled = function () {
return _super.prototype.isEnabled.call(this) && !this.control.selection.isEmpty();
};
DeleteCommand.prototype.executeCore = function (state) {
ModelUtils_1.ModelUtils.deleteSelection(this.control.history, this.control.model, this.control.selection);
return true;
};
return DeleteCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.DeleteCommand = DeleteCommand;
/***/ }),
/* 130 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var MoveShapeHistoryItem = /** @class */ (function (_super) {
__extends(MoveShapeHistoryItem, _super);
function MoveShapeHistoryItem(shapeKey, position) {
var _this = _super.call(this) || this;
_this.shapeKey = shapeKey;
_this.position = position;
return _this;
}
MoveShapeHistoryItem.prototype.redo = function (manipulator) {
var shape = manipulator.model.findShape(this.shapeKey);
this.oldPosition = shape.position.clone();
manipulator.moveShape(shape, this.position);
};
MoveShapeHistoryItem.prototype.undo = function (manipulator) {
var shape = manipulator.model.findShape(this.shapeKey);
manipulator.moveShape(shape, this.oldPosition);
};
return MoveShapeHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.MoveShapeHistoryItem = MoveShapeHistoryItem;
/***/ }),
/* 131 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var StringUtils = /** @class */ (function () {
function StringUtils() {
}
// to compare with ignore case use ~StrUtils.strCompare
StringUtils.stringCompare = function (a, b) {
return ((a == b) ? 0 : ((a > b) ? 1 : -1));
};
StringUtils.stringHashCode = function (str) {
var hash = 0;
if (str.length === 0)
return hash;
var strLen = str.length;
for (var i = 0; i < strLen; i++) {
hash = ((hash << 5) - hash) + str.charCodeAt(i);
hash |= 0; // Convert to 32bit integer
}
return hash;
};
;
StringUtils.endsAt = function (str, template) {
var strInd = str.length - 1;
var tmplInd = template.length - 1;
var strStartInd = strInd - tmplInd;
if (strStartInd < 0)
return false;
for (; strInd >= strStartInd; strInd--, tmplInd--)
if (str[strInd] != template[tmplInd])
return false;
return true;
};
StringUtils.startsAt = function (str, template) {
return str.substr(0, template.length) == template;
};
StringUtils.stringInLowerCase = function (str) {
return str.toLowerCase() == str;
};
StringUtils.stringInUpperCase = function (str) {
return str.toUpperCase() == str;
};
StringUtils.inStringAtLeastOneSymbolInUpperCase = function (str) {
for (var i = 0, char; char = str[i]; i++)
if (StringUtils.stringInUpperCase(char) && !StringUtils.stringInLowerCase(char))
return true;
return false;
};
StringUtils.getSymbolFromEnd = function (text, posFromEnd) {
return text[text.length - posFromEnd];
};
StringUtils.stringTrim = function (str, trimChars) {
if (trimChars === void 0) { trimChars = ["\\s"]; }
var joinedChars = trimChars.join("");
return str.replace(new RegExp("(^[" + joinedChars + "]*)|([" + joinedChars + "]*$)", 'g'), '');
};
StringUtils.stringTrimStart = function (str) {
return str.replace(/(^\s*)/g, '');
};
StringUtils.stringTrimEnd = function (str, trimChar) {
if (trimChar === void 0) { trimChar = "\\s"; }
return str.replace(new RegExp(trimChar + "*$"), '');
};
//todo and test it
StringUtils.stringCustomTrim = function (str, trimChars) {
for (var _i = 0, trimChars_1 = trimChars; _i < trimChars_1.length; _i++) {
var template = trimChars_1[_i];
str = str.replace(new RegExp("(^" + template + "*)|(" + template + "*)$", "g"), '');
}
return str;
};
// mergeStringNTimes("&nbsp;", 1) = "&nbsp;"
// mergeStringNTimes("&nbsp;", 3) = "&nbsp;&nbsp;&nbsp;"
StringUtils.mergeStringNTimes = function (str, times) {
return new Array(times <= 0 ? 0 : times + 1).join(str);
};
StringUtils.getDecimalSeparator = function () {
return (1.1).toLocaleString().substr(1, 1);
};
StringUtils.strCompare = function (a, b, ignoreCase) {
if (ignoreCase === void 0) { ignoreCase = false; }
if (ignoreCase) {
a = a.toLowerCase();
b = b.toLowerCase();
}
return ((a == b) ? 0 : ((a > b) ? 1 : -1));
};
StringUtils.repeat = function (str, count) {
var result = "";
for (var i = 1; i <= count; i++)
result += str;
return result;
};
StringUtils.isNullOrEmpty = function (str) {
return !str || !str.length;
};
StringUtils.padLeft = function (str, totalWidth, paddingChar) {
return StringUtils.mergeStringNTimes(paddingChar, Math.max(0, totalWidth - str.length)) + str;
};
return StringUtils;
}());
exports.StringUtils = StringUtils;
/***/ }),
/* 132 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Base_1 = __webpack_require__(17);
var Str = /** @class */ (function () {
function Str() {
}
Str.TrimStart = function (str) {
return Str.trimInternal(str, true, false);
};
Str.TrimEnd = function (str) {
return Str.trimInternal(str, false, true);
};
Str.Trim = function (str) {
return Str.trimInternal(str, true, true);
};
Str.EncodeHtml = function (html) {
return Str.ApplyReplacement(html, [
[/&amp;/g, '&ampx;'], [/&/g, '&amp;'],
[/&quot;/g, '&quotx;'], [/"/g, '&quot;'],
[/&lt;/g, '&ltx;'], [/</g, '&lt;'],
[/&gt;/g, '&gtx;'], [/>/g, '&gt;']
]);
};
Str.trimInternal = function (source, trimStart, trimEnd) {
var len = source.length;
if (!len)
return source;
if (len < 0xBABA1) { // B181394
var result = source;
if (trimStart) {
result = result.replace(/^\s+/, "");
}
if (trimEnd) {
result = result.replace(/\s+$/, "");
}
return result;
}
else {
var start = 0;
if (trimEnd) {
while (len > 0 && Str.whiteSpaces[source.charCodeAt(len - 1)]) {
len--;
}
}
if (trimStart && len > 0) {
while (start < len && Str.whiteSpaces[source.charCodeAt(start)]) {
start++;
}
}
return source.substring(start, len);
}
};
Str.ApplyReplacement = function (text, replecementTable) {
//if (typeof (text) != "string")
// text = text.toString();
for (var i = 0; i < replecementTable.length; i++) {
var replacement = replecementTable[i];
text = text.replace(replacement[0], replacement[1]);
}
return text;
};
Str.DecodeHtmlViaTextArea = function (html) {
var textArea = document.createElement("TEXTAREA");
Base_1.setInnerHtmlInternal(textArea, html);
return textArea.value;
};
Str.whiteSpaces = {
0x0009: 1, 0x000a: 1, 0x000b: 1, 0x000c: 1, 0x000d: 1, 0x0020: 1, 0x0085: 1,
0x00a0: 1, 0x1680: 1, 0x180e: 1, 0x2000: 1, 0x2001: 1, 0x2002: 1, 0x2003: 1,
0x2004: 1, 0x2005: 1, 0x2006: 1, 0x2007: 1, 0x2008: 1, 0x2009: 1, 0x200a: 1,
0x200b: 1, 0x2028: 1, 0x2029: 1, 0x202f: 1, 0x205f: 1, 0x3000: 1
};
return Str;
}());
exports.Str = Str;
/***/ }),
/* 133 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Browser_1 = __webpack_require__(23);
var Attr = /** @class */ (function () {
function Attr() {
}
Attr.SetAttribute = function (obj, attrName, value) {
if (obj.setAttribute) {
if (Attr.isSourceResetRequired() && attrName.toLowerCase() === "src") // T481593
obj.setAttribute(attrName, "");
obj.setAttribute(attrName, value);
}
else if (obj.setProperty)
obj.setProperty(attrName, value, "");
};
Attr.GetAttribute = function (obj, attrName) {
if (obj.getAttribute)
return obj.getAttribute(attrName);
else if (obj.getPropertyValue) {
if (Browser_1.Browser.Firefox) { //T644613
try {
return obj.getPropertyValue(attrName);
}
catch (e) {
return obj[attrName];
}
}
return obj.getPropertyValue(attrName);
}
return null;
};
Attr.GetTabIndexAttributeName = function () {
return Browser_1.Browser.IE ? "tabIndex" : "tabindex";
};
Attr.ChangeStyleAttribute = function (obj, attrName, newValue) {
Attr.ChangeAttributeExtended(obj.style, attrName, obj, "saved" + attrName, newValue);
};
Attr.ChangeAttributeExtended = function (obj, attrName, savedObj, savedAttrName, newValue) {
Attr.SaveAttribute(obj, attrName, savedObj, savedAttrName);
Attr.SetAttribute(obj, attrName, newValue);
};
Attr.SaveAttribute = function (obj, attrName, savedObj, savedAttrName) {
if (!Attr.IsExistsAttribute(savedObj, savedAttrName)) {
var oldValue = Attr.IsExistsAttribute(obj, attrName) ? Attr.GetAttribute(obj, attrName) : Attr.EmptyObject;
Attr.SetAttribute(savedObj, savedAttrName, oldValue);
}
};
Attr.RestoreAttributeExtended = function (obj, attrName, savedObj, savedAttrName) {
if (Attr.IsExistsAttribute(savedObj, savedAttrName)) {
var oldValue = Attr.GetAttribute(savedObj, savedAttrName);
if (oldValue != Attr.EmptyObject)
Attr.SetAttribute(obj, attrName, oldValue);
else
Attr.RemoveAttribute(obj, attrName);
Attr.RemoveAttribute(savedObj, savedAttrName);
return true;
}
return false;
};
Attr.RemoveAttribute = function (obj, attrName) {
if (obj.removeAttribute)
obj.removeAttribute(attrName);
else if (obj.removeProperty)
obj.removeProperty(attrName);
};
Attr.IsExistsAttribute = function (obj, attrName) {
var value = Attr.GetAttribute(obj, attrName);
return (value != null) && (value !== "");
};
Attr.isSourceResetRequired = function () {
return Browser_1.Browser.IE && Browser_1.Browser.MajorVersion >= 11;
};
Attr.EmptyObject = {};
Attr.RestoreStyleAttribute = function (obj, attrName) {
return Attr.RestoreAttributeExtended(obj.style, attrName, obj, "saved" + attrName);
};
return Attr;
}());
exports.Attr = Attr;
/***/ }),
/* 134 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Utils_1 = __webpack_require__(0);
var Base_1 = __webpack_require__(17);
var NativeScrollView = /** @class */ (function () {
function NativeScrollView(mainElement) {
this.onScroll = new Utils_1.EventDispatcher();
this.scrollBarWidth = Base_1.GetVerticalScrollBarWidth();
this.mainElement = mainElement;
this.attachEvents();
}
NativeScrollView.prototype.dispose = function () {
this.detachEvents();
};
NativeScrollView.prototype.attachEvents = function () {
var _this = this;
this.onScrollHandler = function () { return _this.onScroll.raise1(function (l) { return l.notifyScrollChanged(); }); };
this.mainElement.addEventListener("scroll", this.onScrollHandler);
};
NativeScrollView.prototype.detachEvents = function () {
this.mainElement.removeEventListener("scroll", this.onScrollHandler);
};
NativeScrollView.prototype.setScroll = function (left, top) {
this.mainElement.style.overflow = "scroll";
this.mainElement.scrollLeft = left;
this.mainElement.scrollTop = top;
this.mainElement.style.overflow = "";
};
NativeScrollView.prototype.offsetScroll = function (left, top) {
if (left)
this.mainElement.scrollLeft += left;
if (top)
this.mainElement.scrollTop += top;
};
NativeScrollView.prototype.getScroll = function () {
return new Utils_1.Point(this.mainElement.scrollLeft, this.mainElement.scrollTop);
};
NativeScrollView.prototype.getSize = function () {
var boundingRect = this.mainElement.getBoundingClientRect();
return new Utils_1.Size(Math.floor(boundingRect.width), Math.floor(boundingRect.height));
};
NativeScrollView.prototype.getScrollBarWidth = function () {
return this.scrollBarWidth;
};
NativeScrollView.prototype.getScrollSize = function () {
return new Utils_1.Size(this.mainElement.scrollWidth, this.mainElement.scrollHeight);
};
return NativeScrollView;
}());
exports.NativeScrollView = NativeScrollView;
/***/ }),
/* 135 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Base_1 = __webpack_require__(17);
var __1 = __webpack_require__(8);
var Utils_1 = __webpack_require__(15);
var Event_1 = __webpack_require__(10);
var Shape_1 = __webpack_require__(11);
var Connector_1 = __webpack_require__(5);
var Evt_1 = __webpack_require__(39);
var KeyCode_1 = __webpack_require__(16);
var InputManager = /** @class */ (function () {
function InputManager(parent, mainElement, layoutPointResolver, eventManager, actualZoom) {
this.mainElement = mainElement;
this.layoutPointResolver = layoutPointResolver;
this.eventManager = eventManager;
this.actualZoom = actualZoom;
this.focused = false;
this.focusLocked = false;
this.createInputElements(parent);
}
InputManager.prototype.dispose = function () {
this.detachInputElementEvents();
this.detachTextInputElementEvents();
};
InputManager.prototype.isFocused = function () {
return this.focused;
};
InputManager.prototype.captureFocus = function (inputElement, selectAll) {
var element = inputElement || this.inputElement;
element.focus({
preventScroll: true
});
if (selectAll) {
window.setTimeout(function () {
if (window.getSelection) { // doesn't work in unit tests, see https://github.com/jsdom/jsdom/issues/317
var selection = window.getSelection();
var range = document.createRange();
range.selectNodeContents(element);
selection.removeAllRanges();
selection.addRange(range);
}
}, 100);
}
};
InputManager.prototype.setClipboardData = function (data) {
this.clipboardInputElement.value = data;
this.clipboardInputElement.focus({
preventScroll: true
});
this.clipboardInputElement.select();
document.execCommand('copy');
this.captureFocus();
};
InputManager.prototype.getClipboardData = function (callback) {
var _this = this;
if (navigator && navigator["clipboard"]) {
navigator["clipboard"].readText().then(function (clipText) {
callback(clipText);
_this.captureFocus();
}).catch(function () {
callback("");
_this.captureFocus();
});
}
else if (__1.Browser.IE) {
this.clipboardInputElement.value = "";
this.clipboardInputElement.focus({
preventScroll: true
});
this.clipboardInputElement.select();
document.execCommand('Paste');
callback(this.clipboardInputElement.value);
this.captureFocus();
}
};
InputManager.prototype.isPasteSupportedByBrowser = function () {
return __1.Browser.IE || (__1.Browser.WebKitFamily && navigator && navigator["clipboard"] !== undefined);
};
InputManager.prototype.createInputElements = function (parent) {
this.createInputElement(parent);
this.createTextInputElement(parent);
this.createClipboardInputElement(parent);
};
InputManager.prototype.setInputElementFocusHandlerMode = function () {
this.textInputElementContainer.setAttribute("class", "dxdi-text-input-container");
this.captureFocus();
};
InputManager.prototype.setInputElementTextInputMode = function (text, position, size, style, className) {
this.textInputElementContainer.setAttribute("class", "dxdi-text-input-container " + className);
this.textInputElement.innerText = text;
if (__1.Browser.Firefox && (!text || text === ""))
this.textInputElement.innerHTML = "&nbsp;";
this.setTextInputElementBounds(position, size);
this.setTextInputElementStyle(style);
this.captureFocus(this.textInputElement, true);
};
InputManager.prototype.setTextInputElementBounds = function (position, size) {
var abs = this.layoutPointResolver.getAbsolutePoint(position);
size = size && size.transform(__1.UnitConverter.twipsToPixels);
Base_1.SetAbsoluteX(this.textInputElementContainer, Base_1.GetAbsolutePositionX(this.mainElement) + abs.x);
Base_1.SetAbsoluteY(this.textInputElementContainer, Base_1.GetAbsolutePositionY(this.mainElement) + abs.y);
this.textInputElementContainer.style.width = (size !== undefined) ? size.width + "px" : "0px";
this.textInputElementContainer.style.height = (size !== undefined) ? size.height + "px" : "0px";
this.textInputElementContainer.style.transform = "scale(" + this.actualZoom + ")";
this.textInputElement.style.width = (size !== undefined) ? size.width + "px" : "";
this.textInputElement.style.height = (size !== undefined) ? size.height + "px" : "auto";
};
InputManager.prototype.setTextInputElementStyle = function (style) {
Utils_1.RenderUtils.applyStyleToElement(style, this.textInputElement);
};
InputManager.prototype.createInputElement = function (parent) {
this.inputElement = document.createElement("textarea");
this.inputElement.readOnly = true;
this.inputElement.setAttribute("class", "dxdi-focus-input");
this.attachInputElementEvents();
parent.appendChild(this.inputElement);
};
InputManager.prototype.attachInputElementEvents = function () {
this.onInputBlurHandler = this.onInputBlur.bind(this);
this.onInputFocusHandler = this.onInputFocus.bind(this);
this.onInputKeyDownHandler = this.onInputKeyDown.bind(this);
this.onPasteHandler = this.onPaste.bind(this);
this.inputElement.addEventListener("blur", this.onInputBlurHandler);
this.inputElement.addEventListener("focus", this.onInputFocusHandler);
this.inputElement.addEventListener("keydown", this.onInputKeyDownHandler);
this.inputElement.addEventListener("paste", this.onPasteHandler);
};
InputManager.prototype.detachInputElementEvents = function () {
this.inputElement.removeEventListener("blur", this.onInputBlurHandler);
this.inputElement.removeEventListener("focus", this.onInputFocusHandler);
this.inputElement.removeEventListener("keydown", this.onInputKeyDownHandler);
this.inputElement.removeEventListener("paste", this.onPasteHandler);
};
InputManager.prototype.createTextInputElement = function (parent) {
this.textInputElementContainer = document.createElement("div");
this.textInputElementContainer.setAttribute("class", "dxdi-text-input-container");
parent.appendChild(this.textInputElementContainer);
this.textInputElement = document.createElement("div");
this.textInputElement.setAttribute("class", "dxdi-text-input");
this.textInputElement.setAttribute("contenteditable", "true");
this.attachTextInputElementEvents();
this.textInputElementContainer.appendChild(this.textInputElement);
};
InputManager.prototype.attachTextInputElementEvents = function () {
this.onTextInputBlurHandler = this.onTextInputBlur.bind(this);
this.onTextInputFocusHandler = this.onTextInputFocus.bind(this);
this.onTextInputKeyDownHandler = this.onTextInputKeyDown.bind(this);
this.textInputElement.addEventListener("blur", this.onTextInputBlurHandler);
this.textInputElement.addEventListener("focus", this.onTextInputFocusHandler);
this.textInputElement.addEventListener("keydown", this.onTextInputKeyDownHandler);
};
InputManager.prototype.detachTextInputElementEvents = function () {
this.textInputElement.removeEventListener("blur", this.onTextInputBlurHandler);
this.textInputElement.removeEventListener("focus", this.onTextInputFocusHandler);
this.textInputElement.removeEventListener("keydown", this.onTextInputKeyDownHandler);
};
InputManager.prototype.createClipboardInputElement = function (parent) {
this.clipboardInputElement = document.createElement("textarea");
this.clipboardInputElement.setAttribute("class", "dxdi-clipboard-input");
parent.appendChild(this.clipboardInputElement);
};
InputManager.prototype.blurControl = function () {
if (!this.focusLocked) {
this.focused = false;
Base_1.RemoveClassNameFromElement(this.mainElement, "focused");
}
};
InputManager.prototype.focusControl = function () {
this.focused = true;
this.focusLocked = false;
Base_1.AddClassNameToElement(this.mainElement, "focused");
};
InputManager.prototype.onInputBlur = function (evt) {
var _this = this;
this.blurControl();
Utils_1.raiseEvent(evt, this.getDiagramFocusEvent(evt), function (e) { return _this.eventManager.onBlur(e); });
};
InputManager.prototype.onInputFocus = function (evt) {
var _this = this;
this.focusControl();
Utils_1.raiseEvent(evt, this.getDiagramFocusEvent(evt), function (e) { return _this.eventManager.onFocus(e); });
};
InputManager.prototype.onInputKeyDown = function (evt) {
var _this = this;
Utils_1.raiseEvent(evt, this.getDiagramKeyboardEvent(evt), function (e) { return _this.eventManager.onKeyDown(e); });
};
InputManager.prototype.onTextInputBlur = function (evt) {
var _this = this;
this.blurControl();
Utils_1.raiseEvent(evt, this.getDiagramFocusEvent(evt), function (e) { return _this.eventManager.onTextInputBlur(e); });
};
InputManager.prototype.onTextInputFocus = function (evt) {
var _this = this;
this.focusControl();
Utils_1.raiseEvent(evt, this.getDiagramFocusEvent(evt), function (e) { return _this.eventManager.onTextInputFocus(e); });
};
InputManager.prototype.onTextInputKeyDown = function (evt) {
var _this = this;
Utils_1.raiseEvent(evt, this.getDiagramKeyboardEvent(evt), function (e) { return _this.eventManager.onTextInputKeyDown(e); });
};
InputManager.prototype.getDiagramKeyboardEvent = function (evt) {
return new Event_1.DiagramKeyboardEvent(KeyCode_1.getKeyModifiers(evt), Evt_1.Evt.GetKeyCode(evt), Evt_1.Evt.GetEventSource(evt).innerText); // TODO: check it
};
InputManager.prototype.lockFocus = function () {
var _this = this;
this.focusLocked = true;
setTimeout(function () { return _this.focusLocked = false; }, 10);
};
InputManager.prototype.replaceParent = function (parent) {
if (this.inputElement && this.inputElement.parentNode !== parent)
parent.appendChild(this.inputElement);
if (this.textInputElementContainer && this.textInputElementContainer.parentNode !== parent)
parent.appendChild(this.textInputElementContainer);
if (this.clipboardInputElement && this.clipboardInputElement.parentNode !== parent)
parent.appendChild(this.clipboardInputElement);
};
InputManager.prototype.getDiagramFocusEvent = function (evt) {
return new Event_1.DiagramFocusEvent(evt.target.innerText);
};
InputManager.prototype.onPaste = function (evt) {
var _this = this;
Utils_1.raiseEvent(evt, this.getDiagramClipboardEvent(evt), function (e) { return _this.eventManager.onPaste(e); });
};
InputManager.prototype.getDiagramClipboardEvent = function (evt) {
var clipboardData;
if (evt.clipboardData !== undefined)
clipboardData = evt.clipboardData.getData('text/plain');
else
clipboardData = window["clipboardData"].getData('Text');
return new Event_1.DiagramClipboardEvent(clipboardData);
};
InputManager.prototype.notifyViewAdjusted = function (canvasOffset) { };
InputManager.prototype.notifyActualZoomChanged = function (actualZoom) {
this.actualZoom = actualZoom;
};
InputManager.prototype.notifyTextInputStart = function (item, text, position, size) {
var className = "";
if (item instanceof Shape_1.Shape)
className = "shape-text";
else if (item instanceof Connector_1.Connector)
className = "connector-text";
this.setInputElementTextInputMode(text, position, size, item.styleText, className);
};
InputManager.prototype.notifyTextInputEnd = function (item) {
this.setInputElementFocusHandlerMode();
};
return InputManager;
}());
exports.InputManager = InputManager;
/***/ }),
/* 136 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var __1 = __webpack_require__(8);
var Style_1 = __webpack_require__(27);
var RectaglePrimitive_1 = __webpack_require__(20);
var PathPrimitive_1 = __webpack_require__(2);
var PatternPrimitive_1 = __webpack_require__(137);
var ClipPathPrimitive_1 = __webpack_require__(41);
var CanvasManagerBase_1 = __webpack_require__(33);
var Utils_1 = __webpack_require__(0);
var Utils_2 = __webpack_require__(15);
var GRID_PAGES_LINEWIDTH = 2;
var CanvasPageManager = /** @class */ (function (_super) {
__extends(CanvasPageManager, _super);
function CanvasPageManager(parent, settings) {
var _this = _super.call(this, settings.zoomLevel) || this;
_this.snapPoint = new Utils_1.Point(0, 0);
_this.gridPatternId = Utils_2.RenderUtils.generateSvgElementId("gridPattern");
_this.pagesGridPatternId = Utils_2.RenderUtils.generateSvgElementId("pagesGridPattern");
_this.pagesGridClipId = Utils_2.RenderUtils.generateSvgElementId("pagesGridClip");
_this.pageColor = settings.pageColor;
_this.modelSize = settings.modelSize;
_this.simpleView = settings.simpleView;
_this.gridSize = settings.gridSize;
_this.gridVisible = settings.gridVisible;
_this.pageSize = settings.pageLandscape ? new Utils_1.Size(settings.pageSize.height, settings.pageSize.width) : settings.pageSize;
_this.canvasViewOffset = new Utils_1.Point(0, 0);
_this.initContainers(parent);
return _this;
}
CanvasPageManager.prototype.initContainers = function (parent) {
this.backgroundContainer = parent;
};
CanvasPageManager.prototype.redraw = function () {
this.redrawPage(this.pageColor);
this.redrawGrid();
};
CanvasPageManager.prototype.redrawPage = function (color) {
var style = new Style_1.Style();
style["fill"] = __1.ColorHelper.colorToHash(color);
this.getOrCreateElement("page-bg", new RectaglePrimitive_1.RectanglePrimitive(0, 0, "100%", "100%", style, "page"), this.backgroundContainer);
this.createTextFloodFilter("page-bg-textflood-filter", this.backgroundContainer, color);
};
CanvasPageManager.prototype.redrawGrid = function () {
this.updateGridElements(this.gridVisible, __1.UnitConverter.twipsToPixelsF(this.gridSize) * this.actualZoom);
this.updatePagesGridElements(this.simpleView, this.getAbsoluteSize(this.pageSize));
};
CanvasPageManager.prototype.getGridRectElement = function (primitive) {
if (this.gridRectElement === undefined)
this.gridRectElement = this.createPrimitiveElement(primitive, this.backgroundContainer);
return this.gridRectElement;
};
CanvasPageManager.prototype.getGridPatternElement = function (primitive) {
if (this.gridPatternElement === undefined)
this.gridPatternElement = this.createPrimitiveElement(primitive, this.backgroundContainer);
return this.gridPatternElement;
};
CanvasPageManager.prototype.updateGridElements = function (visible, absGridSize) {
var _this = this;
var gridRectPrimitive = new RectaglePrimitive_1.RectanglePrimitive("0", "0", "100%", "100%", null, "grid", null, function (element) {
element.style.setProperty("fill", Utils_2.RenderUtils.getUrlPathById(_this.gridPatternId));
});
var rectEl = this.getGridRectElement(gridRectPrimitive);
if (!visible)
rectEl.style.display = "none";
else {
rectEl.style.display = "";
this.changePrimitiveElement(gridRectPrimitive, rectEl);
var sizes = [0, 1, 2, 3, 4].map(function (i) { return Math.round(absGridSize * i); });
var outerPathCommands = [
new PathPrimitive_1.PathPrimitiveMoveToCommand(sizes[4].toString(), "0"),
new PathPrimitive_1.PathPrimitiveLineToCommand(sizes[4].toString(), sizes[4].toString()),
new PathPrimitive_1.PathPrimitiveLineToCommand("0", sizes[4].toString())
];
var innerPathCommands = [];
for (var i = 1; i <= 3; i++) {
innerPathCommands.push(new PathPrimitive_1.PathPrimitiveMoveToCommand(sizes[i].toString(), "0"));
innerPathCommands.push(new PathPrimitive_1.PathPrimitiveLineToCommand(sizes[i].toString(), sizes[4].toString()));
}
for (var i = 1; i <= 3; i++) {
innerPathCommands.push(new PathPrimitive_1.PathPrimitiveMoveToCommand("0", sizes[i].toString()));
innerPathCommands.push(new PathPrimitive_1.PathPrimitiveLineToCommand(sizes[4].toString(), sizes[i].toString()));
}
var commonSize = absGridSize * 4;
var canvasViewOffset = this.simpleView ? this.canvasViewOffset : Utils_1.Point.empty();
var gridPatternPrimitive = new PatternPrimitive_1.PatternPrimitive(this.gridPatternId, [
new PathPrimitive_1.PathPrimitive(outerPathCommands, null, "grid-outer-line"),
new PathPrimitive_1.PathPrimitive(innerPathCommands, null, "grid-inner-line")
], (((canvasViewOffset.x + this.snapPoint.x) % commonSize - commonSize) % commonSize).toString(), (((canvasViewOffset.y + this.snapPoint.y) % commonSize - commonSize) % commonSize).toString(), commonSize.toString(), commonSize.toString());
this.changePrimitiveElement(gridPatternPrimitive, this.getGridPatternElement(gridPatternPrimitive));
}
};
CanvasPageManager.prototype.getPagesGridRectElement = function (primitive) {
return this.getOrCreateElement("grid-pages-rect", primitive, this.backgroundContainer);
};
CanvasPageManager.prototype.getPagesGridClipPathElement = function (primitive) {
if (this.pagesGridClipPathElement === undefined)
this.pagesGridClipPathElement = this.createPrimitiveElement(primitive, this.backgroundContainer);
return this.pagesGridClipPathElement;
};
CanvasPageManager.prototype.getPagesGridPatternElement = function (primitive) {
if (this.pagesGridPatternElement === undefined)
this.pagesGridPatternElement = this.createPrimitiveElement(primitive, this.backgroundContainer);
return this.pagesGridPatternElement;
};
CanvasPageManager.prototype.updatePagesGridElements = function (simpleView, pageAbsSize) {
var _this = this;
var rectPrimitive = new RectaglePrimitive_1.RectanglePrimitive("0", "0", "100%", "100%", null, "grid-page", this.pagesGridClipId, function (element) {
element.style.setProperty("fill", Utils_2.RenderUtils.getUrlPathById(_this.pagesGridPatternId));
element.style.setProperty("display", simpleView ? "none" : "");
});
this.getPagesGridRectElement(rectPrimitive);
if (!simpleView) {
var modelSize = this.modelSize.multiply(this.actualZoom);
var pageGridPathCommands = [
new PathPrimitive_1.PathPrimitiveMoveToCommand((pageAbsSize.width - GRID_PAGES_LINEWIDTH / 2).toString(), "0"),
new PathPrimitive_1.PathPrimitiveLineToCommand((pageAbsSize.width - GRID_PAGES_LINEWIDTH / 2).toString(), (pageAbsSize.height - GRID_PAGES_LINEWIDTH / 2).toString()),
new PathPrimitive_1.PathPrimitiveLineToCommand("0", (pageAbsSize.height - GRID_PAGES_LINEWIDTH / 2).toString())
];
var pagesGridPatternPrimitive = new PatternPrimitive_1.PatternPrimitive(this.pagesGridPatternId, [
new PathPrimitive_1.PathPrimitive(pageGridPathCommands, null, "pages-grid-line")
], 0, 0, pageAbsSize.width.toString(), pageAbsSize.height.toString());
this.changePrimitiveElement(pagesGridPatternPrimitive, this.getPagesGridPatternElement(pagesGridPatternPrimitive));
var pagesGridClipPathPrimitive = new ClipPathPrimitive_1.ClipPathPrimitive(this.pagesGridClipId, [
new RectaglePrimitive_1.RectanglePrimitive(0, 0, (__1.UnitConverter.twipsToPixelsF(modelSize.width) - GRID_PAGES_LINEWIDTH * 2).toString(), (__1.UnitConverter.twipsToPixelsF(modelSize.height) - GRID_PAGES_LINEWIDTH * 2).toString())
]);
this.changePrimitiveElement(pagesGridClipPathPrimitive, this.getPagesGridClipPathElement(pagesGridClipPathPrimitive));
}
};
CanvasPageManager.prototype.notifyModelSizeChanged = function (size, offset) {
this.modelSize = size.clone();
this.redraw();
};
CanvasPageManager.prototype.notifyModelRectangleChanged = function (rectangle) { };
CanvasPageManager.prototype.notifySnapPointPositionChanged = function (point) {
this.snapPoint = point.transform(__1.UnitConverter.twipsToPixelsF);
this.redrawGrid();
};
CanvasPageManager.prototype.notifyPageColorChanged = function (color) {
this.pageColor = color;
this.redrawPage(this.pageColor);
};
CanvasPageManager.prototype.notifyModelChanged = function (changes) { };
CanvasPageManager.prototype.notifyPageSizeChanged = function (pageSize, pageLandscape) {
this.pageSize = pageLandscape ? new Utils_1.Size(pageSize.height, pageSize.width) : pageSize.clone();
this.redraw();
};
CanvasPageManager.prototype.notifyActualZoomChanged = function (actualZoom) {
this.actualZoom = actualZoom;
this.redraw();
};
CanvasPageManager.prototype.notifyViewAdjusted = function (canvasViewOffset) {
if (!this.canvasViewOffset.equals(canvasViewOffset)) {
this.canvasViewOffset = canvasViewOffset;
if (this.simpleView)
this.redraw();
}
};
CanvasPageManager.prototype.notifyViewChanged = function (simpleView) {
this.simpleView = simpleView;
this.redraw();
};
CanvasPageManager.prototype.notifyGridChanged = function (showGrid, gridSize) {
this.gridVisible = showGrid;
this.gridSize = gridSize;
this.redraw();
};
return CanvasPageManager;
}(CanvasManagerBase_1.CanvasManagerBase));
exports.CanvasPageManager = CanvasPageManager;
/***/ }),
/* 137 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RenderManager_1 = __webpack_require__(12);
var Primitive_1 = __webpack_require__(18);
var PatternPrimitive = /** @class */ (function (_super) {
__extends(PatternPrimitive, _super);
function PatternPrimitive(id, children, x, y, width, height) {
var _this = _super.call(this) || this;
_this.id = id;
_this.x = x;
_this.y = y;
_this.width = width;
_this.height = height;
_this.children = children;
return _this;
}
PatternPrimitive.prototype.createMainElement = function () {
return document.createElementNS(RenderManager_1.svgNS, "pattern");
};
PatternPrimitive.prototype.applyElementProperties = function (element) {
if (this.id)
element.setAttribute("id", this.id);
element.setAttribute("patternUnits", "userSpaceOnUse");
this.setUnitAttribute(element, "x", this.x);
this.setUnitAttribute(element, "y", this.y);
this.setUnitAttribute(element, "width", this.width);
this.setUnitAttribute(element, "height", this.height);
_super.prototype.applyElementProperties.call(this, element);
};
return PatternPrimitive;
}(Primitive_1.SvgPrimitive));
exports.PatternPrimitive = PatternPrimitive;
/***/ }),
/* 138 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var CanvasManagerBase_1 = __webpack_require__(33);
var DiagramSettings_1 = __webpack_require__(35);
var Utils_1 = __webpack_require__(0);
var __1 = __webpack_require__(8);
var GroupPrimitive_1 = __webpack_require__(28);
var ClipPathPrimitive_1 = __webpack_require__(41);
var RectaglePrimitive_1 = __webpack_require__(20);
var Utils_2 = __webpack_require__(15);
var ShadowFilterPrimitive_1 = __webpack_require__(139);
var Style_1 = __webpack_require__(27);
exports.CANVAS_MIN_PADDING = 12;
exports.CROP_OFFSET = 40;
var DRAG_SCROLL_CSSCLASS = "dxdi-drag-scroll", DRAG_ITEM_CSSCLASS = "dxdi-drag-item";
var CanvasViewManager = /** @class */ (function (_super) {
__extends(CanvasViewManager, _super);
function CanvasViewManager(scroll, svgElement, modelSize, fixedZoomLevel, autoZoom, simpleView, rectangle) {
var _this = _super.call(this, fixedZoomLevel) || this;
_this.scroll = scroll;
_this.svgElement = svgElement;
_this.paddings = new Utils_1.Offset(0, 0, 0, 0);
_this.crop = Utils_1.Offset.empty();
_this.lockAutoZoom = false;
_this.pageClipPathId = Utils_2.RenderUtils.generateSvgElementId("page-clip");
_this.pageShadowId = Utils_2.RenderUtils.generateSvgElementId("page-shadow");
_this.onViewChanged = new __1.EventDispatcher();
modelSize = modelSize.transform(__1.UnitConverter.twipsToPixelsF);
_this.modelSize = modelSize;
_this.simpleView = simpleView;
_this.fixedZoomLevel = fixedZoomLevel;
_this.autoZoom = autoZoom;
_this.crop = _this.rectangleToCrop(rectangle, modelSize);
_this.updateElements(modelSize.multiply(fixedZoomLevel), Utils_1.Point.empty(), simpleView); // TODO: remove?
_this.getOrCreateElement("shadow", new ShadowFilterPrimitive_1.ShadowFilterPrimitive(_this.pageShadowId), _this.svgElement);
return _this;
}
CanvasViewManager.prototype.update = function (toReset) {
if (toReset)
this.reset(toReset.horizontal, toReset.vertical);
else
this.adjust(this.modelSize, this.fixedZoomLevel, this.autoZoom, this.simpleView, this.crop, Utils_1.Offset.empty());
};
CanvasViewManager.prototype.reset = function (horizontal, vertical) {
if (horizontal === void 0) { horizontal = true; }
if (vertical === void 0) { vertical = true; }
this.adjust(this.modelSize, this.fixedZoomLevel, this.autoZoom, this.simpleView, this.crop, undefined, { horizontal: horizontal, vertical: vertical });
};
CanvasViewManager.prototype.notifyModelSizeChanged = function (size, offset) {
size = size.transform(__1.UnitConverter.twipsToPixelsF);
this.adjust(size, this.fixedZoomLevel, this.autoZoom, this.simpleView, this.crop, offset && offset.transform(__1.UnitConverter.twipsToPixelsF));
this.modelSize = size;
};
CanvasViewManager.prototype.notifyModelRectangleChanged = function (rectangle) {
var crop = this.rectangleToCrop(rectangle, this.modelSize, this.crop);
if (!this.crop || !this.crop.equals(crop)) {
if (this.simpleView)
this.adjust(this.modelSize, this.fixedZoomLevel, this.autoZoom, this.simpleView, crop, Utils_1.Offset.empty());
this.crop = crop;
}
};
CanvasViewManager.prototype.notifySnapPointPositionChanged = function (point) { };
CanvasViewManager.prototype.notifyZoomChanged = function (fixedZoomLevel, autoZoom) {
this.adjust(this.modelSize, fixedZoomLevel, autoZoom, this.simpleView, this.crop, undefined, {
horizontal: false,
vertical: false
});
this.fixedZoomLevel = fixedZoomLevel;
this.autoZoom = autoZoom;
};
CanvasViewManager.prototype.notifyViewChanged = function (simpleView) {
this.adjust(this.modelSize, this.fixedZoomLevel, this.autoZoom, simpleView, this.crop);
this.simpleView = simpleView;
};
CanvasViewManager.prototype.notifyGridChanged = function (showGrid, gridSize) { };
CanvasViewManager.prototype.notifyDragStart = function (itemKeys) {
this.lockAutoZoom = true;
var className = this.svgElement.getAttribute("class") + " " + DRAG_ITEM_CSSCLASS;
this.svgElement.setAttribute("class", className);
};
CanvasViewManager.prototype.notifyDragEnd = function (itemKeys) {
this.lockAutoZoom = false;
var className = this.svgElement.getAttribute("class").replace(" " + DRAG_ITEM_CSSCLASS, "");
this.svgElement.setAttribute("class", className);
if (this.autoZoom)
this.update({ horizontal: true, vertical: true });
};
CanvasViewManager.prototype.notifyDragScrollStart = function () {
var className = this.svgElement.getAttribute("class") + " " + DRAG_SCROLL_CSSCLASS;
this.svgElement.setAttribute("class", className);
};
CanvasViewManager.prototype.notifyDragScrollEnd = function () {
var className = this.svgElement.getAttribute("class").replace(" " + DRAG_SCROLL_CSSCLASS, "");
this.svgElement.setAttribute("class", className);
};
CanvasViewManager.prototype.checkFitToCanvas = function () {
var scrollSize = this.scroll.getScrollBarWidth();
var containerSize = this.scroll.getSize().offset(-exports.CANVAS_MIN_PADDING * 2, -exports.CANVAS_MIN_PADDING * 2);
var modelAbsSize = this.getActualModelSizeWithoutZoom(this.modelSize, this.simpleView, this.crop).multiply(this.actualZoom);
var scrollbars = this.checkScrollBars(containerSize, scrollSize, modelAbsSize, Utils_1.Offset.empty());
containerSize = containerSize.offset(scrollbars.vertical ? -scrollSize : 0, scrollbars.horizontal ? -scrollSize : 0);
return {
vertical: containerSize.height >= modelAbsSize.height,
horizontal: containerSize.width >= modelAbsSize.width
};
};
CanvasViewManager.prototype.rectangleToCrop = function (rectangle, modelSize, oldCrop) {
var absRectangle = rectangle.transform(__1.UnitConverter.twipsToPixelsF);
return new Utils_1.Offset(this.correctCrop(absRectangle.left), this.correctCrop(absRectangle.top), this.correctCrop(modelSize.width - absRectangle.right), this.correctCrop(modelSize.height - absRectangle.bottom));
};
CanvasViewManager.prototype.correctCrop = function (newVal) {
return exports.CROP_OFFSET * Math.floor(newVal / exports.CROP_OFFSET);
};
CanvasViewManager.prototype.setActualZoom = function (actualZoom) {
if (this.actualZoom !== actualZoom) {
this.actualZoom = actualZoom;
this.onViewChanged.raise1(function (l) { return l.notifyActualZoomChanged(actualZoom); });
}
};
CanvasViewManager.prototype.getActualAutoZoomLevel = function (autoZoom) {
if (autoZoom === DiagramSettings_1.AutoZoomMode.Disabled)
return this.actualZoom;
var containerSize = this.scroll.getSize();
var scrollbarWidth = this.scroll.getScrollBarWidth();
var actualModelSizeWithoutZoom = this.getActualModelSizeWithoutZoom(this.modelSize, this.simpleView, this.crop);
return this.getActualAutoZoom(containerSize, scrollbarWidth, actualModelSizeWithoutZoom, autoZoom);
};
CanvasViewManager.prototype.getActualZoom = function (containerSize, scrollbarWidth, actualModelSizeWithoutZoom, fixedZoom, autoZoom) {
return this.lockAutoZoom ? this.actualZoom :
autoZoom === DiagramSettings_1.AutoZoomMode.Disabled ? fixedZoom : this.getActualAutoZoom(containerSize, scrollbarWidth, actualModelSizeWithoutZoom, autoZoom);
};
CanvasViewManager.prototype.getActualAutoZoom = function (containerSize, scrollbarWidth, actualModelSizeWithoutZoom, autoZoom) {
if (autoZoom === DiagramSettings_1.AutoZoomMode.FitContent) {
return Math.min((containerSize.width - exports.CANVAS_MIN_PADDING * 2) / actualModelSizeWithoutZoom.width, (containerSize.height - exports.CANVAS_MIN_PADDING * 2) / actualModelSizeWithoutZoom.height, 1);
}
return Math.min((containerSize.width - exports.CANVAS_MIN_PADDING * 2 - scrollbarWidth) / actualModelSizeWithoutZoom.width, 1);
};
CanvasViewManager.prototype.tryNormalizePaddings = function () {
var scroll = this.scroll.getScroll();
var containerSize = this.scroll.getSize();
var scrollbarWidth = this.scroll.getScrollBarWidth();
var actualModelSize = this.getActualModelSizeWithoutZoom(this.modelSize, this.simpleView, this.crop).multiply(this.actualZoom);
var translate = new Utils_1.Point(this.paddings.left, this.paddings.top);
var currentTail = new Utils_1.Size(this.paddings.right, this.paddings.bottom);
var tail = this.getTailSpace(translate, scroll, actualModelSize, containerSize, scrollbarWidth);
if (!tail.equals(currentTail))
this.applyChanges(new Utils_1.Offset(translate.x, translate.y, tail.width, tail.height), actualModelSize, this.simpleView, this.crop);
};
CanvasViewManager.prototype.scrollBy = function (offset) {
var _a, _b, _c;
var scroll = this.scroll.getScroll();
var containerSize = this.scroll.getSize();
var scrollbarWidth = this.scroll.getScrollBarWidth();
var actualModelSize = this.getActualModelSizeWithoutZoom(this.modelSize, this.simpleView, this.crop).multiply(this.actualZoom);
var scrollbars = this.checkScrollBars(containerSize, scrollbarWidth, actualModelSize, this.paddings);
var translate = new Utils_1.Point(this.paddings.left, this.paddings.top);
var tail = new Utils_1.Size(this.paddings.right, this.paddings.bottom);
(_a = this.changeScrollByOffset(translate, scroll, tail, actualModelSize, offset, containerSize, scrollbars), scroll = _a.scroll, offset = _a.offset);
(_b = this.changeTranslateByOffset(translate, tail, offset, scrollbars), translate = _b.translate, offset = _b.offset);
(_c = this.cropHiddenHead(translate, scroll), translate = _c.translate, scroll = _c.scroll);
tail = this.getTailSpace(translate, scroll, actualModelSize, containerSize, scrollbarWidth);
this.applyChanges(new Utils_1.Offset(translate.x, translate.y, tail.width, tail.height), actualModelSize, this.simpleView, this.crop, scroll);
return offset;
};
CanvasViewManager.prototype.changeScrollByOffset = function (curTranslate, curScroll, curTail, modelSize, curOffset, containerSize, scrollbars) {
var scroll = curScroll.clone();
var offset = curOffset.clone();
if (curOffset.x && scrollbars.horizontal)
scroll.x -= (offset.x = -this.getScrollDeltaByOffset(curOffset.x, curScroll.x, curTranslate.x + modelSize.width + curTail.width, containerSize.width, scrollbars.vertical));
if (curOffset.y && scrollbars.vertical)
scroll.y -= (offset.y = -this.getScrollDeltaByOffset(curOffset.y, curScroll.y, curTranslate.y + modelSize.height + curTail.height, containerSize.height, scrollbars.horizontal));
return { scroll: scroll, offset: offset };
};
CanvasViewManager.prototype.changeTranslateByOffset = function (curTranslate, curTail, curOffset, scrollbars) {
var translate = curTranslate.clone();
var offset = curOffset.clone();
if (curOffset.x && !scrollbars.horizontal)
translate.x += (offset.x = this.getTranslateDeltaByOffset(curOffset.x, translate.x, curTail.width));
if (curOffset.y && !scrollbars.vertical)
translate.y += (offset.y = this.getTranslateDeltaByOffset(curOffset.y, translate.y, curTail.height));
return { translate: translate, offset: offset };
};
CanvasViewManager.prototype.getScrollDeltaByOffset = function (offset, scroll, commonWidth, containerWidth, hasScrollbar) {
if (offset > 0)
return -Math.min(scroll, offset);
var maxScroll = commonWidth - (containerWidth - (hasScrollbar ? this.scroll.getScrollBarWidth() : 0));
return Math.min(maxScroll - scroll, -offset);
};
CanvasViewManager.prototype.getTranslateDeltaByOffset = function (offset, headPadding, tailPadding) {
if (!offset)
return 0;
return offset < 0 ?
-Math.min(headPadding - exports.CANVAS_MIN_PADDING, -offset) :
Math.min(tailPadding - exports.CANVAS_MIN_PADDING, offset);
};
CanvasViewManager.prototype.getActualModelSizeWithoutZoom = function (originModelSize, simpleView, crop) {
return simpleView && crop ? originModelSize.offset(-crop.horizontal, -crop.vertical) : originModelSize;
};
CanvasViewManager.prototype.setScrollTo = function (modelPoint, offsetPoint) {
var containerSize = this.scroll.getSize();
var shift = this.getVisibileAreaAbsShift();
var absPoint = modelPoint
.transform(__1.UnitConverter.twipsToPixelsF)
.multiply(this.actualZoom)
.offset(shift.x, shift.y);
var scroll = this.scroll.getScroll();
if (!offsetPoint) {
if (absPoint.x < 0)
scroll.x += absPoint.x - exports.CANVAS_MIN_PADDING;
if (absPoint.y < 0)
scroll.y += absPoint.y - exports.CANVAS_MIN_PADDING;
if (absPoint.x > containerSize.width)
scroll.x += (absPoint.x - containerSize.width + exports.CANVAS_MIN_PADDING);
if (absPoint.y > containerSize.height)
scroll.y += (absPoint.y - containerSize.height + exports.CANVAS_MIN_PADDING);
}
else {
scroll.x += absPoint.x - offsetPoint.x;
scroll.y += absPoint.y - offsetPoint.y;
}
var modelAbsSize = this.modelSize.multiply(this.actualZoom);
scroll.x = Math.max(0, Math.min(scroll.x, modelAbsSize.width + this.paddings.horizontal - containerSize.width));
scroll.y = Math.max(0, Math.min(scroll.y, modelAbsSize.height + this.paddings.vertical - containerSize.height));
this.scroll.setScroll(scroll.x, scroll.y);
};
CanvasViewManager.prototype.updateElements = function (modelAbsSize, translate, simpleView) {
this.updatePageElement(modelAbsSize, translate, simpleView);
this.updateCanvasElement(translate);
};
CanvasViewManager.prototype.updateCanvasElement = function (translate) {
this.canvasElement = this.getOrCreateElement("dxdi-main", new GroupPrimitive_1.GroupPrimitive([], "dxdi-main", null, null, function (el) {
el.setAttribute("transform", "translate(" + Math.round(translate.x) + ", " + Math.round(translate.y) + ")");
}), this.svgElement);
};
CanvasViewManager.prototype.updatePageElement = function (modelAbsSize, translate, simpleView) {
if (!simpleView) {
this.getOrCreateElement("pageShadowRect", new RectaglePrimitive_1.RectanglePrimitive(translate.x.toString(), translate.y.toString(), modelAbsSize.width.toString(), modelAbsSize.height.toString(), new Style_1.EmptyStyle({
"filter": Utils_2.RenderUtils.getUrlPathById(this.pageShadowId)
}), "dxdi-page-shadow"), this.svgElement);
}
this.pageElement = this.getOrCreateElement("page", new GroupPrimitive_1.GroupPrimitive([], "dxdi-page", null, !simpleView ? this.pageClipPathId : "", function (el) {
el.setAttribute("transform", "translate(" + (simpleView ? 0 : Math.round(translate.x)) + ", " + (simpleView ? 0 : Math.round(translate.y)) + ")");
}), this.svgElement);
this.getOrCreateElement("pageClip", this.createPageClipPathPrimitive(modelAbsSize), this.svgElement);
};
CanvasViewManager.prototype.createPageClipPathPrimitive = function (modelAbsSize) {
var children = [];
children.push(new RectaglePrimitive_1.RectanglePrimitive(0, 0, modelAbsSize.width.toString(), modelAbsSize.height.toString()));
return new ClipPathPrimitive_1.ClipPathPrimitive(this.pageClipPathId, children);
};
CanvasViewManager.prototype.adjust = function (newModelSize, fixedZoomLevel, autoZoom, simpleView, crop, offset, toReset) {
var containerSize = this.scroll.getSize();
var actualModelSizeWithoutZoom = this.getActualModelSizeWithoutZoom(newModelSize, simpleView, crop);
if (!this.lockAutoZoom && (autoZoom || !offset || !this.modelSize)) {
var scrollbarWidth = this.scroll.getScrollBarWidth();
var actualZoom = this.getActualZoom(containerSize, scrollbarWidth, actualModelSizeWithoutZoom, fixedZoomLevel, autoZoom);
if (autoZoom && actualZoom === this.actualZoom)
this.resizeView(actualModelSizeWithoutZoom, actualZoom, containerSize, simpleView, crop, offset || Utils_1.Offset.empty());
else {
this.resetView(actualModelSizeWithoutZoom, actualZoom, containerSize, simpleView, crop, toReset);
this.setActualZoom(actualZoom);
}
}
else
this.resizeView(actualModelSizeWithoutZoom, this.actualZoom, containerSize, simpleView, crop, offset);
};
CanvasViewManager.prototype.resetView = function (actualModelSizeWithoutZoom, actualZoom, containerSize, simpleView, cropWithoutZoom, toReset) {
var actualModelSize = actualModelSizeWithoutZoom.multiply(actualZoom);
var paddings = Utils_1.Offset.fromNumber(exports.CANVAS_MIN_PADDING);
toReset = toReset || { horizontal: true, vertical: true };
if (!toReset.horizontal && this.paddings) {
paddings.left = this.paddings.left;
paddings.right = this.paddings.right;
}
if (!toReset.vertical && this.paddings) {
paddings.top = this.paddings.top;
paddings.bottom = this.paddings.bottom;
}
var scrollbars = this.checkScrollBars(containerSize, this.scroll.getScrollBarWidth(), actualModelSize, paddings);
var scrollBarWidth = this.scroll.getScrollBarWidth();
var scroll = (toReset.horizontal || toReset.vertical) ? this.scroll.getScroll() : undefined;
if (toReset.horizontal) {
var paddingsH = Math.max((containerSize.width - (scrollbars.vertical ? scrollBarWidth : 0) - actualModelSize.width) / 2, exports.CANVAS_MIN_PADDING);
paddings.left = paddingsH;
paddings.right = paddingsH;
scroll.x = 0;
}
if (toReset.vertical) {
var paddingsV = Math.max((containerSize.height - (scrollbars.horizontal ? scrollBarWidth : 0) - actualModelSize.height) / 2, exports.CANVAS_MIN_PADDING);
paddings.top = paddingsV;
paddings.bottom = paddingsV;
scroll.y = 0;
}
this.applyChanges(paddings, actualModelSize, simpleView, cropWithoutZoom.multiply(actualZoom), scroll);
};
CanvasViewManager.prototype.resizeView = function (actualModelSizeWithoutZoom, actualZoom, containerSize, simpleView, cropWithoutZoom, offset) {
var _a, _b;
var oldZoom = this.actualZoom;
var oldCrop = this.simpleView && this.crop ? this.crop.multiply(oldZoom) : Utils_1.Offset.empty();
var actualModelSize = actualModelSizeWithoutZoom.multiply(actualZoom);
offset = offset.multiply(actualZoom);
var newCrop = simpleView && cropWithoutZoom ? cropWithoutZoom.multiply(actualZoom) : Utils_1.Offset.empty();
var translate = new Utils_1.Point(this.paddings.left, this.paddings.top), scroll = this.scroll.getScroll();
(_a = this.applyOffset(translate, scroll, oldCrop, newCrop, offset), translate = _a.translate, scroll = _a.scroll);
(_b = this.cropHiddenHead(translate, scroll), translate = _b.translate, scroll = _b.scroll);
var tailSpace = this.getTailSpace(translate, scroll, actualModelSize, containerSize, this.scroll.getScrollBarWidth());
var newPaddings = new Utils_1.Offset(translate.x, translate.y, tailSpace.width, tailSpace.height);
this.applyChanges(newPaddings, actualModelSize, simpleView, newCrop, scroll);
};
CanvasViewManager.prototype.applyChanges = function (paddings, actualModelSize, simpleView, crop, scroll) {
var translate = new Utils_1.Point(paddings.left, paddings.top);
if (simpleView && crop)
translate = translate.offset(-crop.left, -crop.top);
this.updateElements(actualModelSize, translate, simpleView);
this.setSvgSize(actualModelSize.width + paddings.horizontal, actualModelSize.height + paddings.vertical);
this.onViewChanged.raise1(function (l) { return l.notifyViewAdjusted(new Utils_1.Point(translate.x, translate.y)); });
scroll && this.scroll.setScroll(scroll.x, scroll.y);
this.paddings = paddings;
};
CanvasViewManager.prototype.applyOffset = function (curTranslate, curScroll, oldCrop, newCrop, modelOffset) {
var translate = curTranslate.clone();
var scroll = curScroll.clone();
var offset = this.getActualOffset(oldCrop, newCrop, modelOffset);
if (offset.left) {
translate.x = Math.max(exports.CANVAS_MIN_PADDING, translate.x - offset.left);
scroll.x += offset.left - (curTranslate.x - translate.x);
}
if (offset.top) {
translate.y = Math.max(exports.CANVAS_MIN_PADDING, translate.y - offset.top);
scroll.y += offset.top - (curTranslate.y - translate.y);
}
return { translate: translate, scroll: scroll };
};
CanvasViewManager.prototype.cropHiddenHead = function (curTranslate, curScroll) {
var scroll = curScroll.clone();
var translate = curTranslate.clone();
if (scroll.x && translate.x > exports.CANVAS_MIN_PADDING) {
var delta = translate.x - Math.max(exports.CANVAS_MIN_PADDING, translate.x - scroll.x);
translate.x -= delta;
scroll.x -= delta;
}
if (scroll.y && translate.y > exports.CANVAS_MIN_PADDING) {
var delta = translate.y - Math.max(exports.CANVAS_MIN_PADDING, translate.y - scroll.y);
translate.y -= delta;
scroll.y -= delta;
}
return { translate: translate, scroll: scroll };
};
CanvasViewManager.prototype.getTailSpace = function (curTranslate, curScroll, newModelAbsSize, containerSize, scrollbarWidth) {
var translate = curTranslate.clone();
var scroll = curScroll.clone();
var right = Math.max(containerSize.width + scroll.x - (translate.x + newModelAbsSize.width), exports.CANVAS_MIN_PADDING);
var bottom = Math.max(containerSize.height + scroll.y - (translate.y + newModelAbsSize.height), exports.CANVAS_MIN_PADDING);
var scrollbars = this.checkScrollBars(containerSize, scrollbarWidth, newModelAbsSize, new Utils_1.Offset(translate.x, translate.y, right, bottom));
if (scrollbars.vertical)
right = Math.max(exports.CANVAS_MIN_PADDING, right - scrollbarWidth);
if (scrollbars.horizontal)
bottom = Math.max(exports.CANVAS_MIN_PADDING, bottom - scrollbarWidth);
return new Utils_1.Size(right, bottom);
};
CanvasViewManager.prototype.getActualOffset = function (oldCrop, newCrop, docOffset) {
return new Utils_1.Offset(-(newCrop.left - oldCrop.left) + docOffset.left, -(newCrop.top - oldCrop.top) + docOffset.top, -(newCrop.right - oldCrop.right) + docOffset.right, -(newCrop.bottom - oldCrop.bottom) + docOffset.bottom);
};
CanvasViewManager.prototype.checkScrollBars = function (containerSize, scrollBarWidth, modelAbsSize, paddings) {
var hasHorizontalScroll = containerSize.width < modelAbsSize.width + paddings.horizontal;
var hasVerticalScroll = containerSize.height < modelAbsSize.height + paddings.vertical;
if (hasHorizontalScroll && !hasVerticalScroll)
hasVerticalScroll = containerSize.height - scrollBarWidth < modelAbsSize.height + paddings.vertical;
if (hasVerticalScroll && !hasHorizontalScroll)
hasHorizontalScroll = containerSize.width - scrollBarWidth < modelAbsSize.width + paddings.horizontal;
return { horizontal: hasHorizontalScroll, vertical: hasVerticalScroll };
};
CanvasViewManager.prototype.setSvgSize = function (width, height) {
Utils_2.RenderUtils.updateSvgElementSize(this.svgElement, width, height);
};
CanvasViewManager.prototype.getVisibileAreaAbsShift = function () {
var scroll = this.scroll.getScroll();
var paddings = this.paddings.clone();
var simpleView = this.simpleView;
var cropLeft = simpleView && this.crop ? this.crop.left * this.actualZoom : 0;
var cropTop = simpleView && this.crop ? this.crop.top * this.actualZoom : 0;
return new Utils_1.Point(paddings.left - cropLeft - scroll.x, paddings.top - cropTop - scroll.y);
};
/* ILayoutPointResolver */
CanvasViewManager.prototype.getModelPoint = function (absolutePoint, checkScrollArea) {
var shift = this.getVisibileAreaAbsShift();
var modelPoint = absolutePoint
.offset(-shift.x, -shift.y)
.multiply(1 / this.actualZoom);
if (checkScrollArea) {
var scrollSize = this.scroll.getSize();
if (absolutePoint.x < 0 || absolutePoint.y < 0 || absolutePoint.x > scrollSize.width || absolutePoint.y > scrollSize.height)
return null;
if (modelPoint.x < 0 || modelPoint.y < 0)
return null;
if (modelPoint.x > this.modelSize.width || modelPoint.y > this.modelSize.height)
return null;
}
return modelPoint.transform(__1.UnitConverter.pixelsToTwips);
};
CanvasViewManager.prototype.getAbsolutePoint = function (modelPoint, checkScrollArea) {
var shift = this.getVisibileAreaAbsShift();
var absPoint = modelPoint
.transform(__1.UnitConverter.twipsToPixelsF)
.multiply(this.actualZoom)
.offset(shift.x, shift.y);
if (checkScrollArea) {
if (absPoint.x < 0 || absPoint.y < 0)
return null;
var scrollSize = this.scroll.getSize();
if (absPoint.x > scrollSize.width || absPoint.y > scrollSize.height)
return null;
}
return absPoint;
};
return CanvasViewManager;
}(CanvasManagerBase_1.CanvasManagerBase));
exports.CanvasViewManager = CanvasViewManager;
/***/ }),
/* 139 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var FilterPrimitive_1 = __webpack_require__(85);
var RenderManager_1 = __webpack_require__(12);
var ShadowFilterPrimitive = /** @class */ (function (_super) {
__extends(ShadowFilterPrimitive, _super);
function ShadowFilterPrimitive() {
return _super !== null && _super.apply(this, arguments) || this;
}
ShadowFilterPrimitive.prototype.createChildElements = function (parent) {
var feGaussianBlur = document.createElementNS(RenderManager_1.svgNS, "feGaussianBlur");
feGaussianBlur.setAttribute("in", "SourceGraphic");
feGaussianBlur.setAttribute("stdDeviation", "4.6");
parent.appendChild(feGaussianBlur);
var feOffset = document.createElementNS(RenderManager_1.svgNS, "feOffset");
feOffset.setAttribute("dx", "0");
feOffset.setAttribute("dy", "0");
parent.appendChild(feOffset);
var feMerge = document.createElementNS(RenderManager_1.svgNS, "feMerge");
parent.appendChild(feMerge);
var feMergeNode1 = document.createElementNS(RenderManager_1.svgNS, "feMergeNode");
feMerge.appendChild(feMergeNode1);
var feMergeNode2 = document.createElementNS(RenderManager_1.svgNS, "feMergeNode");
feMergeNode2.setAttribute("in", "SourceGraphic");
feMerge.appendChild(feMergeNode2);
};
return ShadowFilterPrimitive;
}(FilterPrimitive_1.FilterPrimitive));
exports.ShadowFilterPrimitive = ShadowFilterPrimitive;
/***/ }),
/* 140 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RenderManager_1 = __webpack_require__(12);
var Primitive_1 = __webpack_require__(18);
var MaskPrimitive = /** @class */ (function (_super) {
__extends(MaskPrimitive, _super);
function MaskPrimitive(id, children, className, x, y, width, height) {
var _this = _super.call(this, null, className) || this;
_this.id = id;
_this.x = x;
_this.y = y;
_this.width = width;
_this.height = height;
_this.children = children;
return _this;
}
MaskPrimitive.prototype.createMainElement = function () {
return document.createElementNS(RenderManager_1.svgNS, "mask");
};
MaskPrimitive.prototype.applyElementProperties = function (element) {
if (this.id)
element.setAttribute("id", this.id);
this.setUnitAttribute(element, "x", this.x);
this.setUnitAttribute(element, "y", this.y);
this.setUnitAttribute(element, "width", this.width);
this.setUnitAttribute(element, "height", this.height);
_super.prototype.applyElementProperties.call(this, element);
};
return MaskPrimitive;
}(Primitive_1.SvgPrimitive));
exports.MaskPrimitive = MaskPrimitive;
/***/ }),
/* 141 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Evt_1 = __webpack_require__(39);
var Base_1 = __webpack_require__(17);
var RenderManager_1 = __webpack_require__(12);
var SCROLL_EDGE = 40, SCROLL_RATIO = 5, SCROLL_MAXOFFSET = 5, SCROLL_DELAY = 50;
var AutoScrollController = /** @class */ (function () {
function AutoScrollController(scroll, mainElement) {
this.scroll = scroll;
this.mainElement = mainElement;
this.leftButtonPressed = false;
this.scrollDragging = false;
this.scrollTimer = -1;
this.scrollBarWidth = Base_1.GetVerticalScrollBarWidth();
}
AutoScrollController.prototype.onMouseMove = function (evt, raiseMouseMoveFunc) {
this.clearScrollTimer();
if (!Evt_1.Evt.IsLeftButtonPressed(evt))
this.leftButtonPressed = false;
if (this.canAutoScroll())
this.changeScrollPosition(evt, raiseMouseMoveFunc, false);
};
AutoScrollController.prototype.onMouseDown = function (evt) {
this.leftButtonPressed = !!Evt_1.Evt.IsLeftButtonPressed(evt);
};
AutoScrollController.prototype.onMouseUp = function (evt) {
this.clearScrollTimer();
this.leftButtonPressed = false;
};
AutoScrollController.prototype.onMouseEnter = function (evt) {
var _this = this;
if (Evt_1.Evt.IsLeftButtonPressed(evt)) {
setTimeout(function () {
_this.leftButtonPressed = true;
}, 500);
}
};
AutoScrollController.prototype.onDragScrollStart = function () {
this.scrollDragging = true;
};
AutoScrollController.prototype.onDragScrollEnd = function () {
this.scrollDragging = false;
};
AutoScrollController.prototype.canAutoScroll = function () {
return this.leftButtonPressed && !this.scrollDragging;
};
AutoScrollController.prototype.changeScrollPosition = function (evt, raiseMouseMoveFunc, raiseMouseMove) {
var _this = this;
var x = evt.pageX - Base_1.GetAbsolutePositionX(this.mainElement);
var y = evt.pageY - Base_1.GetAbsolutePositionY(this.mainElement);
var size = this.scroll.getSize();
var scrollSize = this.scroll.getScrollSize();
var width = size.width;
if (size.width < scrollSize.width)
width -= this.scrollBarWidth;
var height = size.height;
if (size.height < scrollSize.height)
height -= this.scrollBarWidth;
var changed = false;
if (x <= SCROLL_EDGE) {
this.scroll.offsetScroll(-this.getScrollingOffset(x), 0);
changed = true;
}
else if (width - SCROLL_EDGE <= x) {
this.scroll.offsetScroll(this.getScrollingOffset(width - x), 0);
changed = true;
}
if (y <= SCROLL_EDGE) {
this.scroll.offsetScroll(0, -this.getScrollingOffset(y));
changed = true;
}
else if (height - SCROLL_EDGE <= y) {
this.scroll.offsetScroll(0, this.getScrollingOffset(height - y));
changed = true;
}
if (changed)
this.scrollTimer = window.setTimeout(function () { return _this.changeScrollPosition(evt, raiseMouseMoveFunc, true); }, SCROLL_DELAY);
if (raiseMouseMove)
raiseMouseMoveFunc();
};
AutoScrollController.prototype.clearScrollTimer = function () {
if (this.scrollTimer > -1) {
window.clearTimeout(this.scrollTimer);
this.scrollTimer = -1;
}
};
AutoScrollController.prototype.getScrollingOffset = function (edgeOffset) {
var offset = Math.pow((SCROLL_EDGE - edgeOffset) / SCROLL_RATIO, 2);
return Math.min(offset, SCROLL_MAXOFFSET);
};
AutoScrollController.createMainElement = function (parent) {
var element = document.createElement("div");
element.setAttribute("class", "dxdi-control");
parent.appendChild(element);
return element;
};
AutoScrollController.createSvgElement = function (parent, forExport) {
if (forExport === void 0) { forExport = false; }
var svgElement = document.createElementNS(RenderManager_1.svgNS, "svg");
svgElement.className.baseVal = "dxdi-canvas" + (forExport ? " export" : "");
parent.appendChild(svgElement);
return svgElement;
};
return AutoScrollController;
}());
exports.AutoScrollController = AutoScrollController;
/***/ }),
/* 142 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ConnectorPointsCalculatorBase_1 = __webpack_require__(89);
var ConnectorRenderPoint_1 = __webpack_require__(30);
var ConnectorPointsCalculator = /** @class */ (function (_super) {
__extends(ConnectorPointsCalculator, _super);
function ConnectorPointsCalculator() {
return _super !== null && _super.apply(this, arguments) || this;
}
ConnectorPointsCalculator.prototype.getPoints = function () {
return this.connector.points.map(function (pt, index) { return new ConnectorRenderPoint_1.ConnectorRenderPoint(pt.x, pt.y, index); });
};
return ConnectorPointsCalculator;
}(ConnectorPointsCalculatorBase_1.ConnectorPointsCalculatorBase));
exports.ConnectorPointsCalculator = ConnectorPointsCalculator;
/***/ }),
/* 143 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Utils_1 = __webpack_require__(0);
var DiagramItem_1 = __webpack_require__(4);
var ConnectorPointsCalculatorBase_1 = __webpack_require__(89);
var ConnectorPointsOrthogonalUndefinedSideCalculator_1 = __webpack_require__(144);
var ConnectorPointsOrthogonalSouthSideCalculator_1 = __webpack_require__(145);
var ConnectorPointsOrthogonalNorthSideCalculator_1 = __webpack_require__(146);
var ConnectorPointsOrthogonalEastSideCalculator_1 = __webpack_require__(147);
var ConnectorPointsOrthogonalWestSideCalculator_1 = __webpack_require__(148);
var ConnectorRenderPoint_1 = __webpack_require__(30);
var ConnectorPointsOrthogonalCalculator = /** @class */ (function (_super) {
__extends(ConnectorPointsOrthogonalCalculator, _super);
function ConnectorPointsOrthogonalCalculator(connector) {
var _this = _super.call(this, connector) || this;
_this.sideCalculators = {};
_this.sideCalculators[DiagramItem_1.ConnectionPointSide.Undefined] = new ConnectorPointsOrthogonalUndefinedSideCalculator_1.ConnectorPointsOrthogonalUndefinedSideCalculator(_this);
_this.sideCalculators[DiagramItem_1.ConnectionPointSide.South] = new ConnectorPointsOrthogonalSouthSideCalculator_1.ConnectorPointsOrthogonalSouthSideCalculator(_this);
_this.sideCalculators[DiagramItem_1.ConnectionPointSide.North] = new ConnectorPointsOrthogonalNorthSideCalculator_1.ConnectorPointsOrthogonalNorthSideCalculator(_this);
_this.sideCalculators[DiagramItem_1.ConnectionPointSide.East] = new ConnectorPointsOrthogonalEastSideCalculator_1.ConnectorPointsOrthogonalEastSideCalculator(_this);
_this.sideCalculators[DiagramItem_1.ConnectionPointSide.West] = new ConnectorPointsOrthogonalWestSideCalculator_1.ConnectorPointsOrthogonalWestSideCalculator(_this);
return _this;
}
Object.defineProperty(ConnectorPointsOrthogonalCalculator.prototype, "beginRect", {
get: function () { return this.connector.beginItem ? this.connector.beginItem.rectangle : undefined; },
enumerable: true,
configurable: true
});
Object.defineProperty(ConnectorPointsOrthogonalCalculator.prototype, "endRect", {
get: function () { return this.connector.endItem ? this.connector.endItem.rectangle : undefined; },
enumerable: true,
configurable: true
});
ConnectorPointsOrthogonalCalculator.prototype.getPoints = function () {
var points = this.connector.points.map(function (pt, index) { return new ConnectorRenderPoint_1.ConnectorRenderPoint(pt.x, pt.y, index); });
this.removeUnnecessaryLinePoints(points);
var beginIndex = 0, endIndex = points.length - 1;
var beginSide = this.getPointSide(points, 0);
var beginNextSide = this.getPointSide(points, 1);
var endSide = this.getPointSide(points, points.length - 1);
var endPrevSide = this.getPointSide(points, points.length - 1 - 1);
var beginSideCalculator = this.getSideCalculator(beginSide);
var endSideCalculator = this.getSideCalculator(endSide);
var originRect = this.beginRect;
var originPoint = beginSideCalculator.getCorrectOriginPoint(points[beginIndex], originRect);
var targetPoint = points[beginIndex + 1];
if (points.length === 2 && beginSideCalculator.isOnSidePoint(originPoint, targetPoint) &&
beginSideCalculator.isDirectConnectionAllowed(beginNextSide, originPoint, targetPoint)) {
var directConnectionPoints = beginSideCalculator.getDirectConnectionPoints(originPoint, targetPoint);
directConnectionPoints.forEach(function (pt) {
points.splice(beginIndex + 1, 0, pt);
beginIndex++;
endIndex++;
});
}
else {
var bOffsetPoints = beginSideCalculator.getBeginOffsetPoints(beginNextSide, points[beginIndex], points[beginIndex + 1], this.beginRect);
bOffsetPoints.forEach(function (pt) {
points.splice(beginIndex + 1, 0, pt);
});
beginIndex += bOffsetPoints.length;
endIndex += bOffsetPoints.length;
var eOffsetPoints = endSideCalculator.getEndOffsetPoints(endPrevSide, points[endIndex], points[endIndex - 1], this.endRect);
eOffsetPoints.forEach(function (pt, index) {
points.splice(endIndex + index, 0, pt);
});
for (var index = beginIndex; index < endIndex; index++) {
var nextIndex = index + 1;
var middlePoint = this.getMiddlePoint(points[index], points[index - 1], index - 1 === 0, points[nextIndex], points[nextIndex + 1], nextIndex + 1 === points.length - 1);
if (middlePoint !== undefined) {
points.splice(index + 1, 0, middlePoint);
index++;
endIndex++;
}
}
}
this.removeUnnecessaryLinePoints(points);
return points;
};
ConnectorPointsOrthogonalCalculator.prototype.getSideCalculator = function (side) {
return this.sideCalculators[side];
};
ConnectorPointsOrthogonalCalculator.prototype.getPointSide = function (points, index) {
if (index === 0 && this.connector.beginItem) {
var connectionPointIndex = this.connector.beginConnectionPointIndex;
return this.connector.beginItem.getConnectionPointSideByIndex(connectionPointIndex, points[1]);
}
if (index === points.length - 1 && this.connector.endItem) {
var connectionPointIndex = this.connector.endConnectionPointIndex;
return this.connector.endItem.getConnectionPointSideByIndex(connectionPointIndex, points[points.length - 2]);
}
return DiagramItem_1.ConnectionPointSide.Undefined;
};
ConnectorPointsOrthogonalCalculator.prototype.getMiddlePoints = function (point1, point2) {
if (point1.x === point2.x || point1.y === point2.y)
return [];
return [
new ConnectorRenderPoint_1.ConnectorRenderPoint(point1.x, point2.y),
new ConnectorRenderPoint_1.ConnectorRenderPoint(point2.x, point1.y)
];
};
ConnectorPointsOrthogonalCalculator.prototype.getMiddlePoint = function (point1, directionPoint1, nextToBegin, point2, directionPoint2, nextToEnd) {
var _this = this;
var point;
var points = this.getMiddlePoints(point1, point2);
points.forEach(function (pt) {
var rect1 = _this.createPointsRect(point1, pt);
var rect2 = _this.createPointsRect(pt, point2);
var itemRect1 = _this.connector.beginItem ? _this.connector.beginItem.rectangle : undefined;
var itemRect2 = _this.connector.endItem ? _this.connector.endItem.rectangle : undefined;
if (itemRect1) {
if (itemRect1.intersect(rect1) || itemRect1.intersect(rect2))
return;
}
if (itemRect2) {
if (itemRect2.intersect(rect1) || itemRect2.intersect(rect2))
return;
}
if ((!_this.isReturnPoint(pt, point1, directionPoint1) || _this.isIntermediatePoints(point1, directionPoint1)) &&
(!_this.isReturnPoint(pt, point2, directionPoint2) || _this.isIntermediatePoints(point2, directionPoint2))) {
if (point === undefined)
point = pt;
else if (_this.isPriorMiddlePoint(pt, point1, directionPoint1, point2, directionPoint2))
point = pt;
}
});
if (point === undefined && points.length > 0)
point = points[0];
return point;
};
ConnectorPointsOrthogonalCalculator.prototype.createPointsRect = function (point1, point2) {
var result = Utils_1.Rectangle.createByPoints(point1, point2);
if (result.width > 0)
result = result.inflate(-1, 0);
if (result.height > 0)
result = result.inflate(0, -1);
return result;
};
ConnectorPointsOrthogonalCalculator.prototype.isPriorMiddlePoint = function (point, point1, directionPoint1, point2, directionPoint2) {
if (directionPoint1) {
if (point.x === directionPoint1.x || point.y === directionPoint1.y)
return true;
}
if (directionPoint2) {
if (point.x === directionPoint2.x || point.y === directionPoint2.y)
return true;
}
return false;
};
ConnectorPointsOrthogonalCalculator.prototype.isReturnPoint = function (point, point1, point2) {
if (point1 !== undefined && point2 !== undefined) {
if (point.x === point2.x)
if (point1.y < point.y && point.y < point2.y || point1.y > point.y && point.y > point2.y)
return true;
if (point.y === point2.y)
if (point1.x < point.x && point.x < point2.x || point1.x > point.x && point.x > point2.x)
return true;
}
return false;
};
ConnectorPointsOrthogonalCalculator.prototype.isIntermediatePoints = function (point1, point2) {
return 0 < point1.pointIndex && point1.pointIndex < this.connector.points.length - 1 &&
0 < point2.pointIndex && point2.pointIndex < this.connector.points.length - 1;
};
ConnectorPointsOrthogonalCalculator.prototype.removeUnnecessaryLinePoints = function (points) {
Utils_1.GeometryUtils.removeUnnecessaryLinePoints(points, function (pt, index) {
if (pt.pointIndex === -1) {
points.splice(index, 1);
return true;
}
else {
pt.skipped = true;
return false;
}
}, function (pt) {
return pt !== undefined && !pt.skipped;
});
};
return ConnectorPointsOrthogonalCalculator;
}(ConnectorPointsCalculatorBase_1.ConnectorPointsCalculatorBase));
exports.ConnectorPointsOrthogonalCalculator = ConnectorPointsOrthogonalCalculator;
/***/ }),
/* 144 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ConnectorPointsOrthogonalSideCalculatorBase_1 = __webpack_require__(43);
var ConnectorRenderPoint_1 = __webpack_require__(30);
var ConnectorPointsOrthogonalUndefinedSideCalculator = /** @class */ (function (_super) {
__extends(ConnectorPointsOrthogonalUndefinedSideCalculator, _super);
function ConnectorPointsOrthogonalUndefinedSideCalculator(parent) {
return _super.call(this, parent) || this;
}
ConnectorPointsOrthogonalUndefinedSideCalculator.prototype.getCorrectOriginPoint = function (originPoint, originRect) {
return originPoint;
};
ConnectorPointsOrthogonalUndefinedSideCalculator.prototype.getSameShapeOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
return [];
};
ConnectorPointsOrthogonalUndefinedSideCalculator.prototype.getOverlappedPointsOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
return [];
};
ConnectorPointsOrthogonalUndefinedSideCalculator.prototype.getBeginOverlappedShapeOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
return [];
};
ConnectorPointsOrthogonalUndefinedSideCalculator.prototype.getEndOverlappedShapeOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
return [];
};
ConnectorPointsOrthogonalUndefinedSideCalculator.prototype.getBeginOnSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
return [];
};
ConnectorPointsOrthogonalUndefinedSideCalculator.prototype.getEndOnSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
return [];
};
ConnectorPointsOrthogonalUndefinedSideCalculator.prototype.getBeginOffSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
return [];
};
ConnectorPointsOrthogonalUndefinedSideCalculator.prototype.getEndOffSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
return [];
};
ConnectorPointsOrthogonalUndefinedSideCalculator.prototype.isOnSidePoint = function (originPoint, targetPoint) {
return true;
};
ConnectorPointsOrthogonalUndefinedSideCalculator.prototype.isDirectConnectionAllowed = function (targetSide, originPoint, targetPoint) {
var calculator = this.getSideCalculator(originPoint, targetPoint);
if (calculator !== undefined)
return calculator.isDirectConnectionAllowed(targetSide, originPoint, targetPoint);
return true;
};
ConnectorPointsOrthogonalUndefinedSideCalculator.prototype.getDirectConnectionPoints = function (originPoint, targetPoint) {
var diffX = Math.abs(targetPoint.x - originPoint.x);
var diffY = Math.abs(targetPoint.y - originPoint.y);
if (diffX > diffY) {
var minX = Math.min(originPoint.x, targetPoint.x);
var cx = minX + diffX / 2;
return [
new ConnectorRenderPoint_1.ConnectorRenderPoint(cx, originPoint.y),
new ConnectorRenderPoint_1.ConnectorRenderPoint(cx, targetPoint.y)
];
}
else {
var minY = Math.min(originPoint.y, targetPoint.y);
var cy = minY + diffY / 2;
return [
new ConnectorRenderPoint_1.ConnectorRenderPoint(originPoint.x, cy),
new ConnectorRenderPoint_1.ConnectorRenderPoint(targetPoint.x, cy)
];
}
};
return ConnectorPointsOrthogonalUndefinedSideCalculator;
}(ConnectorPointsOrthogonalSideCalculatorBase_1.ConnectorPointsOrthogonalSideCalculatorBase));
exports.ConnectorPointsOrthogonalUndefinedSideCalculator = ConnectorPointsOrthogonalUndefinedSideCalculator;
/***/ }),
/* 145 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var DiagramItem_1 = __webpack_require__(4);
var ConnectorPointsOrthogonalSideCalculatorBase_1 = __webpack_require__(43);
var ConnectorRenderPoint_1 = __webpack_require__(30);
var ConnectorPointsOrthogonalSouthSideCalculator = /** @class */ (function (_super) {
__extends(ConnectorPointsOrthogonalSouthSideCalculator, _super);
function ConnectorPointsOrthogonalSouthSideCalculator(parent) {
return _super.call(this, parent) || this;
}
ConnectorPointsOrthogonalSouthSideCalculator.prototype.getCorrectOriginPoint = function (originPoint, originRect) {
if (originPoint.y < originRect.bottom)
originPoint = originPoint.offset(0, originRect.bottom - originPoint.y);
return originPoint;
};
ConnectorPointsOrthogonalSouthSideCalculator.prototype.getSameShapeOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.East:
case DiagramItem_1.ConnectionPointSide.West:
case DiagramItem_1.ConnectionPointSide.South:
return [originPoint.offset(0, this.getMinOffset())];
case DiagramItem_1.ConnectionPointSide.North:
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset());
}
};
ConnectorPointsOrthogonalSouthSideCalculator.prototype.getOverlappedPointsOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.South:
return [originPoint.offset(0, this.getMinOffset())];
case DiagramItem_1.ConnectionPointSide.North:
return [originPoint.offset(0, -this.getMinOffset())];
}
return [];
};
ConnectorPointsOrthogonalSouthSideCalculator.prototype.getBeginOverlappedShapeOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.East:
if (originPoint.y < targetPoint.y) {
if (originPoint.x > targetPoint.x)
return [];
else
return [originPoint.offset(0, this.getMinOffset())];
}
if (originPoint.y > this.endRect.bottom)
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), false);
return [originPoint.offset(0, this.getMinOffset())];
case DiagramItem_1.ConnectionPointSide.West:
if (originPoint.y < targetPoint.y) {
if (originPoint.x < targetPoint.x)
return [];
else
return [originPoint.offset(0, this.getMinOffset())];
}
if (originPoint.y > this.endRect.bottom)
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), true);
return [originPoint.offset(0, this.getMinOffset())];
case DiagramItem_1.ConnectionPointSide.South:
return [originPoint.offset(0, this.getMinOffset())];
case DiagramItem_1.ConnectionPointSide.North:
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), originPoint.x < targetPoint.x);
}
};
ConnectorPointsOrthogonalSouthSideCalculator.prototype.getEndOverlappedShapeOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.East:
if (targetPoint.y < originPoint.y)
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), false);
if (originPoint.x < targetPoint.x)
return [originPoint.offset(0, this.getMinOffset())];
return [];
case DiagramItem_1.ConnectionPointSide.West:
if (targetPoint.y < originPoint.y)
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), true);
if (originPoint.x > targetPoint.x)
return [originPoint.offset(0, this.getMinOffset())];
return [];
case DiagramItem_1.ConnectionPointSide.South:
return [originPoint.offset(0, this.getMinOffset())];
case DiagramItem_1.ConnectionPointSide.North:
var offset = this.getMinOffset();
if (this.beginRect.bottom > originPoint.y)
offset += this.beginRect.bottom - originPoint.y;
return [originPoint.offset(0, offset)];
}
};
ConnectorPointsOrthogonalSouthSideCalculator.prototype.getBeginOnSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
return [originPoint.offset(0, this.getScaleableOffsetY(originPoint, targetPoint, false))];
};
ConnectorPointsOrthogonalSouthSideCalculator.prototype.getEndOnSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
return [originPoint.offset(0, this.getScaleableOffsetY(originPoint, targetPoint, true))];
};
ConnectorPointsOrthogonalSouthSideCalculator.prototype.getBeginOffSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.East:
if (this.isBeginEndOverlappedX())
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, false, false);
break;
case DiagramItem_1.ConnectionPointSide.West:
if (this.isBeginEndOverlappedX())
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, false, true);
break;
case DiagramItem_1.ConnectionPointSide.South:
if (this.isBeginEndOverlappedX())
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, false);
break;
case DiagramItem_1.ConnectionPointSide.Undefined:
case DiagramItem_1.ConnectionPointSide.North:
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, false);
}
return [originPoint.offset(0, this.getScaleableOffsetY(originPoint, targetPoint, false))];
};
ConnectorPointsOrthogonalSouthSideCalculator.prototype.getEndOffSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
if (targetSide === DiagramItem_1.ConnectionPointSide.Undefined)
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, true);
else if (this.isBeginEndOverlappedX()) {
var direction = this.beginRect.center.x > this.endRect.center.x;
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, true, direction);
}
return [originPoint.offset(0, this.getScaleableOffsetY(originPoint, targetPoint, true))];
};
ConnectorPointsOrthogonalSouthSideCalculator.prototype.getAsideOffsetPoints = function (originPoint, targetPoint, originRect, offset, asideOffset, direction) {
var points = [];
if (originRect !== undefined) {
if (direction === undefined)
direction = targetPoint.x < originPoint.x;
if (direction)
points.push(originPoint.offset(-(originPoint.x - originRect.left + asideOffset), offset));
else
points.push(originPoint.offset((originRect.right - originPoint.x + asideOffset), offset));
}
points.push(originPoint.offset(0, offset));
return points;
};
ConnectorPointsOrthogonalSouthSideCalculator.prototype.getScaleableAsideOffsetPoints = function (originPoint, targetPoint, originRect, isEnd, direction) {
var offset = this.getScaleableOffsetY(originPoint, targetPoint, isEnd);
var asideOffset = this.getScaleableOffsetX(originPoint, targetPoint, isEnd);
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, offset, asideOffset, direction);
};
ConnectorPointsOrthogonalSouthSideCalculator.prototype.getScaleableOffsetX = function (originPoint, targetPoint, isEnd) {
if (this.beginRect && this.endRect) {
if (!isEnd && !this.isBeginEndOverlappedX()) {
var distance = void 0;
if (targetPoint.x < originPoint.x)
distance = this.beginRect.left - this.endRect.right;
else
distance = this.endRect.left - this.beginRect.right;
if (distance < this.getMinOffset() * 2)
return distance / 2;
}
}
return this.getMinOffset();
};
ConnectorPointsOrthogonalSouthSideCalculator.prototype.getScaleableOffsetY = function (originPoint, targetPoint, isEnd) {
if (this.beginRect && this.endRect) {
var distance = isEnd ? this.beginRect.top - originPoint.y : this.endRect.top - originPoint.y;
if (distance > 0 && distance < this.getMinOffset() * 2)
return distance / 2;
}
return this.getMinOffset();
};
ConnectorPointsOrthogonalSouthSideCalculator.prototype.isOnSidePoint = function (originPoint, targetPoint) {
return targetPoint.y > originPoint.y;
};
ConnectorPointsOrthogonalSouthSideCalculator.prototype.isDirectConnectionAllowed = function (targetSide, originPoint, targetPoint) {
return targetSide === DiagramItem_1.ConnectionPointSide.North || targetSide === DiagramItem_1.ConnectionPointSide.Undefined;
};
ConnectorPointsOrthogonalSouthSideCalculator.prototype.getDirectConnectionPoints = function (originPoint, targetPoint) {
var cy = originPoint.y + (targetPoint.y - originPoint.y) / 2;
return [
new ConnectorRenderPoint_1.ConnectorRenderPoint(originPoint.x, cy),
new ConnectorRenderPoint_1.ConnectorRenderPoint(targetPoint.x, cy)
];
};
return ConnectorPointsOrthogonalSouthSideCalculator;
}(ConnectorPointsOrthogonalSideCalculatorBase_1.ConnectorPointsOrthogonalSideCalculatorBase));
exports.ConnectorPointsOrthogonalSouthSideCalculator = ConnectorPointsOrthogonalSouthSideCalculator;
/***/ }),
/* 146 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var DiagramItem_1 = __webpack_require__(4);
var ConnectorPointsOrthogonalSideCalculatorBase_1 = __webpack_require__(43);
var ConnectorRenderPoint_1 = __webpack_require__(30);
var ConnectorPointsOrthogonalNorthSideCalculator = /** @class */ (function (_super) {
__extends(ConnectorPointsOrthogonalNorthSideCalculator, _super);
function ConnectorPointsOrthogonalNorthSideCalculator(parent) {
return _super.call(this, parent) || this;
}
ConnectorPointsOrthogonalNorthSideCalculator.prototype.getCorrectOriginPoint = function (originPoint, originRect) {
if (originPoint.y > originRect.top)
originPoint = originPoint.offset(0, originRect.top - originPoint.y);
return originPoint;
};
ConnectorPointsOrthogonalNorthSideCalculator.prototype.getSameShapeOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.East:
case DiagramItem_1.ConnectionPointSide.West:
case DiagramItem_1.ConnectionPointSide.North:
return [originPoint.offset(0, -this.getMinOffset())];
case DiagramItem_1.ConnectionPointSide.South:
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset());
}
};
ConnectorPointsOrthogonalNorthSideCalculator.prototype.getOverlappedPointsOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.South:
return [originPoint.offset(0, this.getMinOffset())];
case DiagramItem_1.ConnectionPointSide.North:
return [originPoint.offset(0, -this.getMinOffset())];
}
return [];
};
ConnectorPointsOrthogonalNorthSideCalculator.prototype.getBeginOverlappedShapeOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.East:
if (originPoint.y > targetPoint.y) {
if (originPoint.x > targetPoint.x)
return [];
else
return [originPoint.offset(0, -this.getMinOffset())];
}
if (originPoint.y < this.endRect.top)
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), false);
return [originPoint.offset(0, -this.getMinOffset())];
case DiagramItem_1.ConnectionPointSide.West:
if (originPoint.y > targetPoint.y) {
if (originPoint.x < targetPoint.x)
return [];
else
return [originPoint.offset(0, -this.getMinOffset())];
}
if (originPoint.y < this.endRect.top)
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), true);
return [originPoint.offset(0, -this.getMinOffset())];
case DiagramItem_1.ConnectionPointSide.North:
return [originPoint.offset(0, -this.getMinOffset())];
case DiagramItem_1.ConnectionPointSide.South:
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), originPoint.x < targetPoint.x);
}
};
ConnectorPointsOrthogonalNorthSideCalculator.prototype.getEndOverlappedShapeOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.East:
if (targetPoint.y > originPoint.y)
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), false);
if (originPoint.x < targetPoint.x)
return [originPoint.offset(0, -this.getMinOffset())];
return [];
case DiagramItem_1.ConnectionPointSide.West:
if (targetPoint.y > originPoint.y)
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), true);
if (originPoint.x > targetPoint.x)
return [originPoint.offset(0, -this.getMinOffset())];
return [];
case DiagramItem_1.ConnectionPointSide.North:
return [originPoint.offset(0, -this.getMinOffset())];
case DiagramItem_1.ConnectionPointSide.South:
var offset = -this.getMinOffset();
if (this.beginRect.top < originPoint.y)
offset -= originPoint.y - this.beginRect.top;
return [originPoint.offset(0, offset)];
}
};
ConnectorPointsOrthogonalNorthSideCalculator.prototype.getBeginOnSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
return [originPoint.offset(0, -this.getScaleableOffsetY(originPoint, targetPoint, false))];
};
ConnectorPointsOrthogonalNorthSideCalculator.prototype.getEndOnSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
return [originPoint.offset(0, -this.getScaleableOffsetY(originPoint, targetPoint, true))];
};
ConnectorPointsOrthogonalNorthSideCalculator.prototype.getBeginOffSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.East:
if (this.isBeginEndOverlappedX())
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, false, false);
break;
case DiagramItem_1.ConnectionPointSide.West:
if (this.isBeginEndOverlappedX())
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, false, true);
break;
case DiagramItem_1.ConnectionPointSide.North:
if (this.isBeginEndOverlappedX())
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, false);
break;
case DiagramItem_1.ConnectionPointSide.Undefined:
case DiagramItem_1.ConnectionPointSide.South:
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, false);
}
return [originPoint.offset(0, -this.getScaleableOffsetY(originPoint, targetPoint, false))];
};
ConnectorPointsOrthogonalNorthSideCalculator.prototype.getEndOffSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
if (targetSide === DiagramItem_1.ConnectionPointSide.Undefined)
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, true);
else if (this.isBeginEndOverlappedX()) {
var direction = this.beginRect.center.x > this.endRect.center.x;
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, true, direction);
}
return [originPoint.offset(0, -this.getScaleableOffsetY(originPoint, targetPoint, true))];
};
ConnectorPointsOrthogonalNorthSideCalculator.prototype.getAsideOffsetPoints = function (originPoint, targetPoint, originRect, offset, asideOffset, direction) {
var points = [];
if (originRect !== undefined) {
if (direction === undefined)
direction = targetPoint.x < originPoint.x;
if (direction)
points.push(originPoint.offset(-(originPoint.x - originRect.left + asideOffset), -offset));
else
points.push(originPoint.offset((originRect.right - originPoint.x + asideOffset), -offset));
}
points.push(originPoint.offset(0, -offset));
return points;
};
ConnectorPointsOrthogonalNorthSideCalculator.prototype.getScaleableAsideOffsetPoints = function (originPoint, targetPoint, originRect, isEnd, direction) {
var offset = this.getScaleableOffsetY(originPoint, targetPoint, isEnd);
var asideOffset = this.getScaleableOffsetX(originPoint, targetPoint, isEnd);
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, offset, asideOffset, direction);
};
ConnectorPointsOrthogonalNorthSideCalculator.prototype.getScaleableOffsetX = function (originPoint, targetPoint, isEnd) {
if (this.beginRect && this.endRect) {
if (!isEnd && !this.isBeginEndOverlappedX()) {
var distance = void 0;
if (targetPoint.x < originPoint.x)
distance = this.beginRect.left - this.endRect.right;
else
distance = this.endRect.left - this.beginRect.right;
if (distance < this.getMinOffset() * 2)
return distance / 2;
}
}
return this.getMinOffset();
};
ConnectorPointsOrthogonalNorthSideCalculator.prototype.getScaleableOffsetY = function (originPoint, targetPoint, isEnd) {
if (this.beginRect && this.endRect) {
var distance = isEnd ? originPoint.y - this.beginRect.bottom : originPoint.y - this.endRect.bottom;
if (distance > 0 && distance < this.getMinOffset() * 2)
return distance / 2;
}
return this.getMinOffset();
};
ConnectorPointsOrthogonalNorthSideCalculator.prototype.isOnSidePoint = function (originPoint, targetPoint) {
return targetPoint.y < originPoint.y;
};
ConnectorPointsOrthogonalNorthSideCalculator.prototype.isDirectConnectionAllowed = function (targetSide, originPoint, targetPoint) {
return targetSide === DiagramItem_1.ConnectionPointSide.South || targetSide === DiagramItem_1.ConnectionPointSide.Undefined;
};
ConnectorPointsOrthogonalNorthSideCalculator.prototype.getDirectConnectionPoints = function (originPoint, targetPoint) {
var cy = targetPoint.y + (originPoint.y - targetPoint.y) / 2;
return [
new ConnectorRenderPoint_1.ConnectorRenderPoint(originPoint.x, cy),
new ConnectorRenderPoint_1.ConnectorRenderPoint(targetPoint.x, cy)
];
};
return ConnectorPointsOrthogonalNorthSideCalculator;
}(ConnectorPointsOrthogonalSideCalculatorBase_1.ConnectorPointsOrthogonalSideCalculatorBase));
exports.ConnectorPointsOrthogonalNorthSideCalculator = ConnectorPointsOrthogonalNorthSideCalculator;
/***/ }),
/* 147 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var DiagramItem_1 = __webpack_require__(4);
var ConnectorPointsOrthogonalSideCalculatorBase_1 = __webpack_require__(43);
var ConnectorRenderPoint_1 = __webpack_require__(30);
var ConnectorPointsOrthogonalEastSideCalculator = /** @class */ (function (_super) {
__extends(ConnectorPointsOrthogonalEastSideCalculator, _super);
function ConnectorPointsOrthogonalEastSideCalculator(parent) {
return _super.call(this, parent) || this;
}
ConnectorPointsOrthogonalEastSideCalculator.prototype.getCorrectOriginPoint = function (originPoint, originRect) {
if (originPoint.x < originRect.right)
originPoint = originPoint.offset(originRect.right - originPoint.x, 0);
return originPoint;
};
ConnectorPointsOrthogonalEastSideCalculator.prototype.getSameShapeOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.North:
case DiagramItem_1.ConnectionPointSide.South:
case DiagramItem_1.ConnectionPointSide.East:
return [originPoint.offset(this.getMinOffset(), 0)];
case DiagramItem_1.ConnectionPointSide.West:
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset());
}
};
ConnectorPointsOrthogonalEastSideCalculator.prototype.getOverlappedPointsOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.East:
return [originPoint.offset(this.getMinOffset(), 0)];
case DiagramItem_1.ConnectionPointSide.West:
return [originPoint.offset(-this.getMinOffset(), 0)];
}
return [];
};
ConnectorPointsOrthogonalEastSideCalculator.prototype.getBeginOverlappedShapeOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.North:
if (originPoint.x < targetPoint.x) {
if (originPoint.y < targetPoint.y)
return [];
else
return [originPoint.offset(this.getMinOffset(), 0)];
}
if (originPoint.x > this.endRect.right)
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), true);
return [originPoint.offset(this.getMinOffset(), 0)];
case DiagramItem_1.ConnectionPointSide.South:
if (originPoint.x < targetPoint.x) {
if (originPoint.y > targetPoint.y)
return [];
else
return [originPoint.offset(this.getMinOffset(), 0)];
}
if (originPoint.x > this.endRect.right)
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), false);
return [originPoint.offset(this.getMinOffset(), 0)];
case DiagramItem_1.ConnectionPointSide.East:
return [originPoint.offset(this.getMinOffset(), 0)];
case DiagramItem_1.ConnectionPointSide.West:
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), originPoint.y < targetPoint.y);
}
};
ConnectorPointsOrthogonalEastSideCalculator.prototype.getEndOverlappedShapeOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.East:
return [originPoint.offset(this.getMinOffset(), 0)];
case DiagramItem_1.ConnectionPointSide.West:
var offset = this.getMinOffset();
if (this.beginRect.right > originPoint.x)
offset += this.beginRect.right - originPoint.x;
return [originPoint.offset(offset, 0)];
case DiagramItem_1.ConnectionPointSide.North:
if (targetPoint.x < originPoint.x)
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), true);
if (originPoint.y > targetPoint.y)
return [originPoint.offset(this.getMinOffset(), 0)];
return [];
case DiagramItem_1.ConnectionPointSide.South:
if (targetPoint.x < originPoint.x)
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), false);
if (originPoint.y < targetPoint.y)
return [originPoint.offset(this.getMinOffset(), 0)];
return [];
}
};
ConnectorPointsOrthogonalEastSideCalculator.prototype.getBeginOnSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
return [originPoint.offset(this.getScaleableOffsetX(originPoint, targetPoint, false), 0)];
};
ConnectorPointsOrthogonalEastSideCalculator.prototype.getEndOnSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
return [originPoint.offset(this.getScaleableOffsetX(originPoint, targetPoint, true), 0)];
};
ConnectorPointsOrthogonalEastSideCalculator.prototype.getBeginOffSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.South:
if (this.isBeginEndOverlappedY())
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, false, false);
break;
case DiagramItem_1.ConnectionPointSide.North:
if (this.isBeginEndOverlappedY())
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, false, true);
break;
case DiagramItem_1.ConnectionPointSide.East:
if (this.isBeginEndOverlappedY())
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, false);
break;
case DiagramItem_1.ConnectionPointSide.Undefined:
case DiagramItem_1.ConnectionPointSide.West:
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, false);
}
return [originPoint.offset(this.getScaleableOffsetX(originPoint, targetPoint, false), 0)];
};
ConnectorPointsOrthogonalEastSideCalculator.prototype.getEndOffSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
if (targetSide === DiagramItem_1.ConnectionPointSide.Undefined)
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, true);
else if (this.isBeginEndOverlappedY()) {
var direction = this.beginRect.center.y > this.endRect.center.y;
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, true, direction);
}
return [originPoint.offset(this.getScaleableOffsetX(originPoint, targetPoint, true), 0)];
};
ConnectorPointsOrthogonalEastSideCalculator.prototype.getAsideOffsetPoints = function (originPoint, targetPoint, originRect, offset, asideOffset, direction) {
var points = [];
if (originRect !== undefined) {
if (direction === undefined)
direction = targetPoint.y < originPoint.y;
if (direction)
points.push(originPoint.offset(offset, -(originPoint.y - originRect.top + asideOffset)));
else
points.push(originPoint.offset(offset, (originRect.bottom - originPoint.y + asideOffset)));
}
points.push(originPoint.offset(offset, 0));
return points;
};
ConnectorPointsOrthogonalEastSideCalculator.prototype.getScaleableAsideOffsetPoints = function (originPoint, targetPoint, originRect, isEnd, direction) {
var offset = this.getScaleableOffsetX(originPoint, targetPoint, isEnd);
var asideOffset = this.getScaleableOffsetY(originPoint, targetPoint, isEnd);
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, offset, asideOffset, direction);
};
ConnectorPointsOrthogonalEastSideCalculator.prototype.getScaleableOffsetX = function (originPoint, targetPoint, isEnd) {
if (this.beginRect && this.endRect) {
var distance = isEnd ? this.beginRect.left - originPoint.x : this.endRect.left - originPoint.x;
if (distance > 0 && distance < this.getMinOffset() * 2)
return distance / 2;
}
return this.getMinOffset();
};
ConnectorPointsOrthogonalEastSideCalculator.prototype.getScaleableOffsetY = function (originPoint, targetPoint, isEnd) {
if (this.beginRect && this.endRect) {
if (!isEnd && !this.isBeginEndOverlappedY()) {
var distance = void 0;
if (targetPoint.y < originPoint.y)
distance = this.beginRect.top - this.endRect.bottom;
else
distance = this.endRect.top - this.beginRect.bottom;
if (distance < this.getMinOffset() * 2)
return distance / 2;
}
}
return this.getMinOffset();
};
ConnectorPointsOrthogonalEastSideCalculator.prototype.isOnSidePoint = function (originPoint, targetPoint) {
return targetPoint.x > originPoint.x;
};
ConnectorPointsOrthogonalEastSideCalculator.prototype.isDirectConnectionAllowed = function (targetSide, originPoint, targetPoint) {
return targetSide === DiagramItem_1.ConnectionPointSide.West || targetSide === DiagramItem_1.ConnectionPointSide.Undefined;
};
ConnectorPointsOrthogonalEastSideCalculator.prototype.getDirectConnectionPoints = function (originPoint, targetPoint) {
var cx = originPoint.x + (targetPoint.x - originPoint.x) / 2;
return [
new ConnectorRenderPoint_1.ConnectorRenderPoint(cx, originPoint.y),
new ConnectorRenderPoint_1.ConnectorRenderPoint(cx, targetPoint.y)
];
};
return ConnectorPointsOrthogonalEastSideCalculator;
}(ConnectorPointsOrthogonalSideCalculatorBase_1.ConnectorPointsOrthogonalSideCalculatorBase));
exports.ConnectorPointsOrthogonalEastSideCalculator = ConnectorPointsOrthogonalEastSideCalculator;
/***/ }),
/* 148 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var DiagramItem_1 = __webpack_require__(4);
var ConnectorPointsOrthogonalSideCalculatorBase_1 = __webpack_require__(43);
var ConnectorRenderPoint_1 = __webpack_require__(30);
var ConnectorPointsOrthogonalWestSideCalculator = /** @class */ (function (_super) {
__extends(ConnectorPointsOrthogonalWestSideCalculator, _super);
function ConnectorPointsOrthogonalWestSideCalculator(parent) {
return _super.call(this, parent) || this;
}
ConnectorPointsOrthogonalWestSideCalculator.prototype.getCorrectOriginPoint = function (originPoint, originRect) {
if (originPoint.x > originRect.left)
originPoint = originPoint.offset(originRect.left - originPoint.x, 0);
return originPoint;
};
ConnectorPointsOrthogonalWestSideCalculator.prototype.getSameShapeOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.North:
case DiagramItem_1.ConnectionPointSide.South:
case DiagramItem_1.ConnectionPointSide.West:
return [originPoint.offset(-this.getMinOffset(), 0)];
case DiagramItem_1.ConnectionPointSide.East:
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset());
}
};
ConnectorPointsOrthogonalWestSideCalculator.prototype.getOverlappedPointsOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.East:
return [originPoint.offset(this.getMinOffset(), 0)];
case DiagramItem_1.ConnectionPointSide.West:
return [originPoint.offset(-this.getMinOffset(), 0)];
}
return [];
};
ConnectorPointsOrthogonalWestSideCalculator.prototype.getBeginOverlappedShapeOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.North:
if (originPoint.x > targetPoint.x) {
if (originPoint.y < targetPoint.y)
return [];
else
return [originPoint.offset(-this.getMinOffset(), 0)];
}
if (originPoint.x < this.endRect.left)
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), true);
return [originPoint.offset(-this.getMinOffset(), 0)];
case DiagramItem_1.ConnectionPointSide.South:
if (originPoint.x > targetPoint.x) {
if (originPoint.y > targetPoint.y)
return [];
else
return [originPoint.offset(-this.getMinOffset(), 0)];
}
if (originPoint.x < this.endRect.left)
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), false);
return [originPoint.offset(-this.getMinOffset(), 0)];
case DiagramItem_1.ConnectionPointSide.West:
return [originPoint.offset(-this.getMinOffset(), 0)];
case DiagramItem_1.ConnectionPointSide.East:
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), originPoint.y < targetPoint.y);
}
};
ConnectorPointsOrthogonalWestSideCalculator.prototype.getEndOverlappedShapeOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.East:
var offset = -this.getMinOffset();
if (this.beginRect.left < originPoint.x)
offset -= originPoint.x - this.beginRect.left;
return [originPoint.offset(offset, 0)];
case DiagramItem_1.ConnectionPointSide.West:
return [originPoint.offset(-this.getMinOffset(), 0)];
case DiagramItem_1.ConnectionPointSide.North:
if (targetPoint.x > originPoint.x)
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), true);
if (originPoint.y > targetPoint.y)
return [originPoint.offset(-this.getMinOffset(), 0)];
return [];
case DiagramItem_1.ConnectionPointSide.South:
if (targetPoint.x > originPoint.x)
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, this.getMinOffset(), this.getMinOffset(), false);
if (originPoint.y < targetPoint.y)
return [originPoint.offset(-this.getMinOffset(), 0)];
return [];
}
};
ConnectorPointsOrthogonalWestSideCalculator.prototype.getBeginOnSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
return [originPoint.offset(-this.getScaleableOffsetX(originPoint, targetPoint, false), 0)];
};
ConnectorPointsOrthogonalWestSideCalculator.prototype.getEndOnSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
return [originPoint.offset(-this.getScaleableOffsetX(originPoint, targetPoint, true), 0)];
};
ConnectorPointsOrthogonalWestSideCalculator.prototype.getBeginOffSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
switch (targetSide) {
case DiagramItem_1.ConnectionPointSide.South:
if (this.isBeginEndOverlappedY())
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, false, false);
break;
case DiagramItem_1.ConnectionPointSide.North:
if (this.isBeginEndOverlappedY())
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, false, true);
break;
case DiagramItem_1.ConnectionPointSide.West:
if (this.isBeginEndOverlappedY())
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, false);
break;
case DiagramItem_1.ConnectionPointSide.Undefined:
case DiagramItem_1.ConnectionPointSide.East:
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, false);
}
return [originPoint.offset(-this.getScaleableOffsetX(originPoint, targetPoint, false), 0)];
};
ConnectorPointsOrthogonalWestSideCalculator.prototype.getEndOffSideOffsetPoints = function (targetSide, originPoint, targetPoint, originRect) {
if (targetSide === DiagramItem_1.ConnectionPointSide.Undefined)
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, true);
else if (this.isBeginEndOverlappedY()) {
var direction = this.beginRect.center.y > this.endRect.center.y;
return this.getScaleableAsideOffsetPoints(originPoint, targetPoint, originRect, true, direction);
}
return [originPoint.offset(-this.getScaleableOffsetX(originPoint, targetPoint, true), 0)];
};
ConnectorPointsOrthogonalWestSideCalculator.prototype.getAsideOffsetPoints = function (originPoint, targetPoint, originRect, offset, asideOffset, direction) {
var points = [];
if (originRect !== undefined) {
if (direction === undefined)
direction = targetPoint.y < originPoint.y;
if (direction)
points.push(originPoint.offset(-offset, -(originPoint.y - originRect.top + asideOffset)));
else
points.push(originPoint.offset(-offset, (originRect.bottom - originPoint.y + asideOffset)));
}
points.push(originPoint.offset(-offset, 0));
return points;
};
ConnectorPointsOrthogonalWestSideCalculator.prototype.getScaleableAsideOffsetPoints = function (originPoint, targetPoint, originRect, isEnd, direction) {
var offset = this.getScaleableOffsetX(originPoint, targetPoint, isEnd);
var asideOffset = this.getScaleableOffsetY(originPoint, targetPoint, isEnd);
return this.getAsideOffsetPoints(originPoint, targetPoint, originRect, offset, asideOffset, direction);
};
ConnectorPointsOrthogonalWestSideCalculator.prototype.getScaleableOffsetX = function (originPoint, targetPoint, isEnd) {
if (this.beginRect && this.endRect) {
var distance = isEnd ? originPoint.x - this.beginRect.right : originPoint.x - this.endRect.right;
if (distance > 0 && distance < this.getMinOffset() * 2)
return distance / 2;
}
return this.getMinOffset();
};
ConnectorPointsOrthogonalWestSideCalculator.prototype.getScaleableOffsetY = function (originPoint, targetPoint, isEnd) {
if (this.beginRect && this.endRect) {
if (!isEnd && !this.isBeginEndOverlappedY()) {
var distance = void 0;
if (targetPoint.y < originPoint.y)
distance = this.beginRect.top - this.endRect.bottom;
else
distance = this.endRect.top - this.beginRect.bottom;
if (distance < this.getMinOffset() * 2)
return distance / 2;
}
}
return this.getMinOffset();
};
ConnectorPointsOrthogonalWestSideCalculator.prototype.isOnSidePoint = function (originPoint, targetPoint) {
return targetPoint.x < originPoint.x;
};
ConnectorPointsOrthogonalWestSideCalculator.prototype.isDirectConnectionAllowed = function (targetSide, originPoint, targetPoint) {
return targetSide === DiagramItem_1.ConnectionPointSide.East || targetSide === DiagramItem_1.ConnectionPointSide.Undefined;
};
ConnectorPointsOrthogonalWestSideCalculator.prototype.getDirectConnectionPoints = function (originPoint, targetPoint) {
var cx = targetPoint.x + (originPoint.x - targetPoint.x) / 2;
return [
new ConnectorRenderPoint_1.ConnectorRenderPoint(cx, originPoint.y),
new ConnectorRenderPoint_1.ConnectorRenderPoint(cx, targetPoint.y)
];
};
return ConnectorPointsOrthogonalWestSideCalculator;
}(ConnectorPointsOrthogonalSideCalculatorBase_1.ConnectorPointsOrthogonalSideCalculatorBase));
exports.ConnectorPointsOrthogonalWestSideCalculator = ConnectorPointsOrthogonalWestSideCalculator;
/***/ }),
/* 149 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ConnectorText = /** @class */ (function () {
function ConnectorText(position, value) {
this.position = position;
this.value = value;
}
return ConnectorText;
}());
exports.ConnectorText = ConnectorText;
var ConnectorTexts = /** @class */ (function () {
function ConnectorTexts() {
this.items = {};
}
ConnectorTexts.prototype.get = function (position) {
return this.items[position];
};
ConnectorTexts.prototype.set = function (position, text) {
this.items[position] = text;
};
ConnectorTexts.prototype.remove = function (position) {
delete this.items[position];
};
ConnectorTexts.prototype.map = function (callback) {
var list = [];
this.forEach(function (t) { return list.push(callback(t)); });
return list;
};
ConnectorTexts.prototype.forEach = function (callback) {
for (var key in this.items)
if (this.items.hasOwnProperty(key))
callback(this.items[key]);
};
ConnectorTexts.prototype.clone = function () {
var result = new ConnectorTexts();
this.forEach(function (t) { result.set(t.position, new ConnectorText(t.position, t.value)); });
return result;
};
ConnectorTexts.prototype.toObject = function () {
var result = {};
var modified = false;
this.forEach(function (t) {
result[t.position] = t.value;
modified = true;
});
return modified ? result : null;
};
ConnectorTexts.prototype.fromObject = function (obj) {
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
var position = parseFloat(key);
if (!isNaN(position) && typeof obj[key] === "string") {
this.set(position, new ConnectorText(position, obj[key]));
}
}
}
};
return ConnectorTexts;
}());
exports.ConnectorTexts = ConnectorTexts;
/***/ }),
/* 150 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var Utils_1 = __webpack_require__(0);
var ModelResizeHistoryItem = /** @class */ (function (_super) {
__extends(ModelResizeHistoryItem, _super);
function ModelResizeHistoryItem(offset) {
var _this = _super.call(this) || this;
_this.offset = offset;
return _this;
}
ModelResizeHistoryItem.prototype.redo = function (manipulator) {
this.oldSize = manipulator.model.size.clone();
this.backOffset = new Utils_1.Offset(-this.offset.left, -this.offset.top, -this.offset.right, -this.offset.bottom);
var newWidth = Math.max(this.oldSize.width + this.offset.left + this.offset.right, manipulator.model.pageWidth);
var newHeight = Math.max(this.oldSize.height + this.offset.top + this.offset.bottom, manipulator.model.pageHeight);
manipulator.changeModelSize(new Utils_1.Size(newWidth, newHeight), this.offset);
};
ModelResizeHistoryItem.prototype.undo = function (manipulator) {
manipulator.changeModelSize(this.oldSize, this.backOffset);
};
return ModelResizeHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.ModelResizeHistoryItem = ModelResizeHistoryItem;
/***/ }),
/* 151 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var Shape_1 = __webpack_require__(11);
var Connector_1 = __webpack_require__(5);
var UpdatePositionsOnPageResizeHistoryItem = /** @class */ (function (_super) {
__extends(UpdatePositionsOnPageResizeHistoryItem, _super);
function UpdatePositionsOnPageResizeHistoryItem(offsetX, offsetY) {
var _this = _super.call(this) || this;
_this.offsetX = offsetX;
_this.offsetY = offsetY;
return _this;
}
UpdatePositionsOnPageResizeHistoryItem.prototype.redo = function (manipulator) {
var _this = this;
manipulator.model.iterateItems(function (item) {
if (item instanceof Shape_1.Shape)
manipulator.moveShape(item, item.position.offset(_this.offsetX, _this.offsetY));
if (item instanceof Connector_1.Connector)
item.points.forEach(function (p, index) { return manipulator.moveConnectorPoint(item, index, p.offset(_this.offsetX, _this.offsetY)); });
});
};
UpdatePositionsOnPageResizeHistoryItem.prototype.undo = function (manipulator) {
var _this = this;
manipulator.model.iterateItems(function (item) {
if (item instanceof Shape_1.Shape)
manipulator.moveShape(item, item.position.offset(-_this.offsetX, -_this.offsetY));
if (item instanceof Connector_1.Connector)
item.points.forEach(function (p, index) { return manipulator.moveConnectorPoint(item, index, p.offset(-_this.offsetX, -_this.offsetY)); });
});
};
return UpdatePositionsOnPageResizeHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.UpdatePositionsOnPageResizeHistoryItem = UpdatePositionsOnPageResizeHistoryItem;
/***/ }),
/* 152 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var DeleteConnectorPointHistoryItem = /** @class */ (function (_super) {
__extends(DeleteConnectorPointHistoryItem, _super);
function DeleteConnectorPointHistoryItem(connectorKey, pointIndex) {
var _this = _super.call(this) || this;
_this.connectorKey = connectorKey;
_this.pointIndex = pointIndex;
return _this;
}
DeleteConnectorPointHistoryItem.prototype.redo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
this.point = connector.points[this.pointIndex].clone();
manipulator.deleteConnectorPoint(connector, this.pointIndex);
};
DeleteConnectorPointHistoryItem.prototype.undo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
manipulator.addConnectorPoint(connector, this.pointIndex, this.point);
};
return DeleteConnectorPointHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.DeleteConnectorPointHistoryItem = DeleteConnectorPointHistoryItem;
/***/ }),
/* 153 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var ResizeShapeHistoryItem = /** @class */ (function (_super) {
__extends(ResizeShapeHistoryItem, _super);
function ResizeShapeHistoryItem(shapeKey, position, size) {
var _this = _super.call(this) || this;
_this.shapeKey = shapeKey;
_this.position = position;
_this.size = size;
return _this;
}
ResizeShapeHistoryItem.prototype.redo = function (manipulator) {
var shape = manipulator.model.findShape(this.shapeKey);
this.oldPosition = shape.position.clone();
this.oldSize = shape.size.clone();
manipulator.resizeShape(shape, this.position, this.size);
};
ResizeShapeHistoryItem.prototype.undo = function (manipulator) {
var shape = manipulator.model.findShape(this.shapeKey);
manipulator.resizeShape(shape, this.oldPosition, this.oldSize);
};
return ResizeShapeHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.ResizeShapeHistoryItem = ResizeShapeHistoryItem;
/***/ }),
/* 154 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var DeleteConnectorHistoryItem = /** @class */ (function (_super) {
__extends(DeleteConnectorHistoryItem, _super);
function DeleteConnectorHistoryItem(connectorKey) {
var _this = _super.call(this) || this;
_this.connectorKey = connectorKey;
return _this;
}
DeleteConnectorHistoryItem.prototype.redo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
this.connector = connector.clone();
manipulator.deleteConnector(connector);
};
DeleteConnectorHistoryItem.prototype.undo = function (manipulator) {
manipulator.addConnector(this.connector, this.connector.key);
};
return DeleteConnectorHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.DeleteConnectorHistoryItem = DeleteConnectorHistoryItem;
/***/ }),
/* 155 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RectangleShapeDescription_1 = __webpack_require__(14);
var ShapeTypes_1 = __webpack_require__(1);
var ProcessShapeDescription = /** @class */ (function (_super) {
__extends(ProcessShapeDescription, _super);
function ProcessShapeDescription() {
return _super.call(this, "Process", "Process") || this;
}
Object.defineProperty(ProcessShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Process; },
enumerable: true,
configurable: true
});
return ProcessShapeDescription;
}(RectangleShapeDescription_1.RectangleShapeDescription));
exports.ProcessShapeDescription = ProcessShapeDescription;
/***/ }),
/* 156 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var DiamondShapeDescription_1 = __webpack_require__(92);
var ShapeTypes_1 = __webpack_require__(1);
var Utils_1 = __webpack_require__(0);
var ShapeDescription_1 = __webpack_require__(9);
var DecisionShapeDescription = /** @class */ (function (_super) {
__extends(DecisionShapeDescription, _super);
function DecisionShapeDescription() {
return _super.call(this, "Decision", "Decision", new Utils_1.Size(ShapeDescription_1.ShapeDefaultDimension, ShapeDescription_1.ShapeDefaultDimension * 0.75)) || this;
}
Object.defineProperty(DecisionShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Decision; },
enumerable: true,
configurable: true
});
return DecisionShapeDescription;
}(DiamondShapeDescription_1.DiamondShapeDescription));
exports.DecisionShapeDescription = DecisionShapeDescription;
/***/ }),
/* 157 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RectangleShapeDescription_1 = __webpack_require__(14);
var ShapeTypes_1 = __webpack_require__(1);
var PathPrimitive_1 = __webpack_require__(2);
var DiagramItem_1 = __webpack_require__(4);
var ManualInputShapeDescription = /** @class */ (function (_super) {
__extends(ManualInputShapeDescription, _super);
function ManualInputShapeDescription() {
return _super.call(this, "Manual Input", "Manual Input") || this;
}
Object.defineProperty(ManualInputShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.ManualInput; },
enumerable: true,
configurable: true
});
ManualInputShapeDescription.prototype.createShapePrimitives = function (shape) {
var _a = shape.rectangle, left = _a.left, top = _a.top, right = _a.right, bottom = _a.bottom, width = _a.width, height = _a.height;
var y1 = top + height * ManualInputShapeDescription.slopeHeightRatio;
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(left, y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(left, bottom),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
ManualInputShapeDescription.prototype.processConnectionPoint = function (shape, point) {
var side = shape.getConnectionPointSide(point);
if (side === DiagramItem_1.ConnectionPointSide.North)
point.y += ManualInputShapeDescription.slopeHeightRatio / 2 * shape.size.height;
};
ManualInputShapeDescription.slopeHeightRatio = 0.1;
return ManualInputShapeDescription;
}(RectangleShapeDescription_1.RectangleShapeDescription));
exports.ManualInputShapeDescription = ManualInputShapeDescription;
/***/ }),
/* 158 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RectangleShapeDescription_1 = __webpack_require__(14);
var ShapeTypes_1 = __webpack_require__(1);
var PathPrimitive_1 = __webpack_require__(2);
var DiagramItem_1 = __webpack_require__(4);
var DataShapeDescription = /** @class */ (function (_super) {
__extends(DataShapeDescription, _super);
function DataShapeDescription() {
return _super.call(this, "Data", "Data") || this;
}
Object.defineProperty(DataShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Data; },
enumerable: true,
configurable: true
});
DataShapeDescription.prototype.createShapePrimitives = function (shape) {
var _a = shape.rectangle, left = _a.left, top = _a.top, right = _a.right, bottom = _a.bottom, width = _a.width, height = _a.height;
var px = Math.min(Math.max(0, height / Math.tan(DataShapeDescription.slopeAngle)), width);
var x1 = left + px;
var x2 = right - px;
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(x1, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(x2, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(left, bottom),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
DataShapeDescription.prototype.processConnectionPoint = function (shape, point) {
var offset = shape.size.height / Math.tan(DataShapeDescription.slopeAngle);
var side = shape.getConnectionPointSide(point);
if (side === DiagramItem_1.ConnectionPointSide.East)
point.x -= offset / 2;
else if (side === DiagramItem_1.ConnectionPointSide.West)
point.x += offset / 2;
};
DataShapeDescription.slopeAngle = 81 * Math.PI / 180;
return DataShapeDescription;
}(RectangleShapeDescription_1.RectangleShapeDescription));
exports.DataShapeDescription = DataShapeDescription;
/***/ }),
/* 159 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RectangleShapeDescription_1 = __webpack_require__(14);
var ShapeTypes_1 = __webpack_require__(1);
var PathPrimitive_1 = __webpack_require__(2);
var Utils_1 = __webpack_require__(0);
var ShapeDescription_1 = __webpack_require__(9);
var TerminatorShapeDescription = /** @class */ (function (_super) {
__extends(TerminatorShapeDescription, _super);
function TerminatorShapeDescription() {
return _super.call(this, "Terminator", "Terminator", new Utils_1.Size(ShapeDescription_1.ShapeDefaultDimension, ShapeDescription_1.ShapeDefaultDimension * 0.5)) || this;
}
Object.defineProperty(TerminatorShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Terminator; },
enumerable: true,
configurable: true
});
TerminatorShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var cy = rect.center.y;
var x1 = left + width * TerminatorShapeDescription.curveWidthRatio;
var x2 = left + width * (1 - TerminatorShapeDescription.curveWidthRatio);
var ratio = height / width;
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(x1, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(x2, top),
new PathPrimitive_1.PathPrimitiveQuadraticCurveToCommand(right, top, right, cy),
new PathPrimitive_1.PathPrimitiveQuadraticCurveToCommand(right, bottom, x2, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(x1, bottom),
new PathPrimitive_1.PathPrimitiveQuadraticCurveToCommand(left, bottom, left, cy),
new PathPrimitive_1.PathPrimitiveQuadraticCurveToCommand(left, top, x1, top),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
TerminatorShapeDescription.curveWidthRatio = 0.3;
return TerminatorShapeDescription;
}(RectangleShapeDescription_1.RectangleShapeDescription));
exports.TerminatorShapeDescription = TerminatorShapeDescription;
/***/ }),
/* 160 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RectangleShapeDescription_1 = __webpack_require__(14);
var ShapeTypes_1 = __webpack_require__(1);
var ShapeParameters_1 = __webpack_require__(29);
var ShapeParameterPoint_1 = __webpack_require__(21);
var Utils_1 = __webpack_require__(0);
var PathPrimitive_1 = __webpack_require__(2);
exports.PredefinedProcessEdgeParameterName = "e";
var PredefinedProcessShapeDescription = /** @class */ (function (_super) {
__extends(PredefinedProcessShapeDescription, _super);
function PredefinedProcessShapeDescription() {
return _super.call(this, "Predefined Process", "Predefined\nProcess") || this;
}
Object.defineProperty(PredefinedProcessShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.PredefinedProcess; },
enumerable: true,
configurable: true
});
PredefinedProcessShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var x1 = left + shape.parameters.get(exports.PredefinedProcessEdgeParameterName).value;
var x2 = right - shape.parameters.get(exports.PredefinedProcessEdgeParameterName).value;
var primitives = _super.prototype.createShapePrimitives.call(this, shape);
return primitives.concat([
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(x1, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(x1, bottom),
new PathPrimitive_1.PathPrimitiveMoveToCommand(x2, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(x2, bottom)
], shape.style)
]);
};
PredefinedProcessShapeDescription.prototype.createParameters = function (parameters) {
parameters.add(new ShapeParameters_1.ShapeParameter(exports.PredefinedProcessEdgeParameterName, this.defaultSize.width * 0.1));
};
PredefinedProcessShapeDescription.prototype.normalizeParameters = function (shape, parameters) {
this.changeParameterValue(parameters, exports.PredefinedProcessEdgeParameterName, function (p) { return Math.max(PredefinedProcessShapeDescription.minEdge, Math.min(shape.size.width * 0.3, p.value)); });
};
PredefinedProcessShapeDescription.prototype.modifyParameters = function (shape, parameters, deltaX, deltaY) {
this.changeParameterValue(parameters, exports.PredefinedProcessEdgeParameterName, function (p) { return p.value + deltaX; });
this.normalizeParameters(shape, parameters);
};
PredefinedProcessShapeDescription.prototype.getParameterPoints = function (shape) {
return [
new ShapeParameterPoint_1.ShapeParameterPoint("c", new Utils_1.Point(shape.normalizeX(shape.position.x + shape.parameters.get(exports.PredefinedProcessEdgeParameterName).value), shape.position.y))
];
};
PredefinedProcessShapeDescription.prototype.getTextRectangle = function (rect, parameters) {
var dx = parameters.get(exports.PredefinedProcessEdgeParameterName).value;
return rect.resize(-2 * dx, 0).offset(dx, 0);
};
PredefinedProcessShapeDescription.minEdge = 72;
return PredefinedProcessShapeDescription;
}(RectangleShapeDescription_1.RectangleShapeDescription));
exports.PredefinedProcessShapeDescription = PredefinedProcessShapeDescription;
/***/ }),
/* 161 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Shape_1 = __webpack_require__(11);
var PathPrimitive_1 = __webpack_require__(2);
var ShapeParameterPoint_1 = __webpack_require__(21);
var Utils_1 = __webpack_require__(0);
var ArrowVerticalShapeDescription_1 = __webpack_require__(65);
var ShapeTypes_1 = __webpack_require__(1);
var ArrowNorthSouthShapeDescription = /** @class */ (function (_super) {
__extends(ArrowNorthSouthShapeDescription, _super);
function ArrowNorthSouthShapeDescription() {
return _super.call(this, "North-South Arrow") || this;
}
Object.defineProperty(ArrowNorthSouthShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.ArrowNorthSouth; },
enumerable: true,
configurable: true
});
ArrowNorthSouthShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var cx = rect.center.x;
var p1dx = (width - shape.parameters.get(ArrowVerticalShapeDescription_1.ArrowVerticalLineWidthParameterName).value) / 2;
var p0dy = shape.parameters.get(ArrowVerticalShapeDescription_1.ArrowVerticalTriangleHeightParameterName).value;
var p1x1 = shape.normalizeX(left + p1dx);
var p0y1 = shape.normalizeY(top + p0dy);
var p1x2 = shape.normalizeX(right - p1dx);
var p0y2 = shape.normalizeY(bottom - p0dy);
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(cx, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, p0y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(p1x2, p0y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(p1x2, p0y2),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, p0y2),
new PathPrimitive_1.PathPrimitiveLineToCommand(cx, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(left, p0y2),
new PathPrimitive_1.PathPrimitiveLineToCommand(p1x1, p0y2),
new PathPrimitive_1.PathPrimitiveLineToCommand(p1x1, p0y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(left, p0y1),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
ArrowNorthSouthShapeDescription.prototype.normalizeParameters = function (shape, parameters) {
this.changeParameterValue(parameters, ArrowVerticalShapeDescription_1.ArrowVerticalTriangleHeightParameterName, function (p) { return Math.max(0, Math.min(shape.size.height / 2 - 2 * Shape_1.Shape.lineWidth, p.value)); });
this.changeParameterValue(parameters, ArrowVerticalShapeDescription_1.ArrowVerticalLineWidthParameterName, function (p) { return Math.max(0, Math.min(shape.size.width, p.value)); });
};
ArrowNorthSouthShapeDescription.prototype.modifyParameters = function (shape, parameters, deltaX, deltaY) {
this.changeParameterValue(parameters, ArrowVerticalShapeDescription_1.ArrowVerticalTriangleHeightParameterName, function (p) { return p.value + deltaY; });
this.changeParameterValue(parameters, ArrowVerticalShapeDescription_1.ArrowVerticalLineWidthParameterName, function (p) { return p.value - deltaX * 2; });
this.normalizeParameters(shape, parameters);
};
ArrowNorthSouthShapeDescription.prototype.getParameterPoints = function (shape) {
return [
new ShapeParameterPoint_1.ShapeParameterPoint("c", new Utils_1.Point(shape.normalizeX(shape.position.x + (shape.size.width - shape.parameters.get(ArrowVerticalShapeDescription_1.ArrowVerticalLineWidthParameterName).value) / 2), shape.normalizeY(shape.position.y + shape.parameters.get(ArrowVerticalShapeDescription_1.ArrowVerticalTriangleHeightParameterName).value)))
];
};
return ArrowNorthSouthShapeDescription;
}(ArrowVerticalShapeDescription_1.ArrowVerticalShapeDescription));
exports.ArrowNorthSouthShapeDescription = ArrowNorthSouthShapeDescription;
/***/ }),
/* 162 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var PathPrimitive_1 = __webpack_require__(2);
var ArrowHorizontalShapeDescription_1 = __webpack_require__(66);
var ShapeParameterPoint_1 = __webpack_require__(21);
var Utils_1 = __webpack_require__(0);
var ShapeTypes_1 = __webpack_require__(1);
var DiagramItem_1 = __webpack_require__(4);
var ArrowRightShapeDescription = /** @class */ (function (_super) {
__extends(ArrowRightShapeDescription, _super);
function ArrowRightShapeDescription() {
return _super.call(this, "Right Arrow") || this;
}
Object.defineProperty(ArrowRightShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.ArrowRight; },
enumerable: true,
configurable: true
});
ArrowRightShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var cy = rect.center.y;
var p0dx = width - shape.parameters.get(ArrowHorizontalShapeDescription_1.ArrowVerticalTriangleWidthParameterName).value;
var p1dy = (height - shape.parameters.get(ArrowHorizontalShapeDescription_1.ArrowVerticalLineHeightParameterName).value) / 2;
var p0x1 = shape.normalizeX(left + p0dx);
var p1y1 = shape.normalizeY(top + p1dy);
var p1y2 = shape.normalizeY(bottom - p1dy);
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(left, p1y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x1, p1y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x1, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, cy),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x1, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x1, p1y2),
new PathPrimitive_1.PathPrimitiveLineToCommand(left, p1y2),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
ArrowRightShapeDescription.prototype.modifyParameters = function (shape, parameters, deltaX, deltaY) {
this.changeParameterValue(parameters, ArrowHorizontalShapeDescription_1.ArrowVerticalTriangleWidthParameterName, function (p) { return p.value - deltaX; });
this.changeParameterValue(parameters, ArrowHorizontalShapeDescription_1.ArrowVerticalLineHeightParameterName, function (p) { return p.value - deltaY * 2; });
this.normalizeParameters(shape, parameters);
};
ArrowRightShapeDescription.prototype.getParameterPoints = function (shape) {
return [
new ShapeParameterPoint_1.ShapeParameterPoint("c", new Utils_1.Point(shape.normalizeX(shape.position.x + shape.size.width - shape.parameters.get(ArrowHorizontalShapeDescription_1.ArrowVerticalTriangleWidthParameterName).value), shape.normalizeY(shape.position.y + (shape.size.height - shape.parameters.get(ArrowHorizontalShapeDescription_1.ArrowVerticalLineHeightParameterName).value) / 2)))
];
};
ArrowRightShapeDescription.prototype.processConnectionPoint = function (shape, point) {
var triangleWidth = shape.parameters.get(ArrowHorizontalShapeDescription_1.ArrowVerticalTriangleWidthParameterName).value;
if (point.x > shape.position.x + shape.size.width - triangleWidth) {
var tg = shape.size.height / 2 / triangleWidth;
var delta = (point.x - (shape.position.x + shape.size.width - triangleWidth)) * tg;
var side = shape.getConnectionPointSide(point);
if (side === DiagramItem_1.ConnectionPointSide.North)
point.y += delta;
else if (side === DiagramItem_1.ConnectionPointSide.South)
point.y -= delta;
}
else
_super.prototype.processConnectionPoint.call(this, shape, point);
};
return ArrowRightShapeDescription;
}(ArrowHorizontalShapeDescription_1.ArrowHorizontalShapeDescription));
exports.ArrowRightShapeDescription = ArrowRightShapeDescription;
/***/ }),
/* 163 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var PathPrimitive_1 = __webpack_require__(2);
var ShapeParameterPoint_1 = __webpack_require__(21);
var Utils_1 = __webpack_require__(0);
var ArrowVerticalShapeDescription_1 = __webpack_require__(65);
var ShapeTypes_1 = __webpack_require__(1);
var DiagramItem_1 = __webpack_require__(4);
var ArrowTopShapeDescription = /** @class */ (function (_super) {
__extends(ArrowTopShapeDescription, _super);
function ArrowTopShapeDescription() {
return _super.call(this, "Top Arrow") || this;
}
Object.defineProperty(ArrowTopShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.ArrowTop; },
enumerable: true,
configurable: true
});
ArrowTopShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var cx = rect.center.x;
var p1dx = (width - shape.parameters.get(ArrowVerticalShapeDescription_1.ArrowVerticalLineWidthParameterName).value) / 2;
var p0dy = shape.parameters.get(ArrowVerticalShapeDescription_1.ArrowVerticalTriangleHeightParameterName).value;
var p1x1 = shape.normalizeX(left + p1dx);
var p0y1 = shape.normalizeY(top + p0dy);
var p1x2 = shape.normalizeX(right - p1dx);
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(cx, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, p0y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(p1x2, p0y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(p1x2, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(p1x1, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(p1x1, p0y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(left, p0y1),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
ArrowTopShapeDescription.prototype.modifyParameters = function (shape, parameters, deltaX, deltaY) {
this.changeParameterValue(parameters, ArrowVerticalShapeDescription_1.ArrowVerticalTriangleHeightParameterName, function (p) { return p.value + deltaY; });
this.changeParameterValue(parameters, ArrowVerticalShapeDescription_1.ArrowVerticalLineWidthParameterName, function (p) { return p.value - deltaX * 2; });
this.normalizeParameters(shape, parameters);
};
ArrowTopShapeDescription.prototype.getParameterPoints = function (shape) {
return [
new ShapeParameterPoint_1.ShapeParameterPoint("c", new Utils_1.Point(shape.normalizeX(shape.position.x + (shape.size.width - shape.parameters.get(ArrowVerticalShapeDescription_1.ArrowVerticalLineWidthParameterName).value) / 2), shape.normalizeY(shape.position.y + shape.parameters.get(ArrowVerticalShapeDescription_1.ArrowVerticalTriangleHeightParameterName).value)))
];
};
ArrowTopShapeDescription.prototype.processConnectionPoint = function (shape, point) {
var triangleHeight = shape.parameters.get(ArrowVerticalShapeDescription_1.ArrowVerticalTriangleHeightParameterName).value;
if (point.y < shape.position.y + triangleHeight) {
var tg = shape.size.width / 2 / triangleHeight;
var delta = (shape.position.y + triangleHeight - point.y) * tg;
var side = shape.getConnectionPointSide(point);
if (side === DiagramItem_1.ConnectionPointSide.East)
point.x -= delta;
else if (side === DiagramItem_1.ConnectionPointSide.West)
point.x += delta;
}
else
_super.prototype.processConnectionPoint.call(this, shape, point);
};
return ArrowTopShapeDescription;
}(ArrowVerticalShapeDescription_1.ArrowVerticalShapeDescription));
exports.ArrowTopShapeDescription = ArrowTopShapeDescription;
/***/ }),
/* 164 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeDescription_1 = __webpack_require__(9);
var Utils_1 = __webpack_require__(0);
var ShapeParameters_1 = __webpack_require__(29);
var ShapeParameterPoint_1 = __webpack_require__(21);
var PathPrimitive_1 = __webpack_require__(2);
var ShapeTypes_1 = __webpack_require__(1);
exports.CrossHorizontalWidthParameterName = "chw";
exports.CrossVerticalWidthParameterName = "cvw";
var CrossShapeDescription = /** @class */ (function (_super) {
__extends(CrossShapeDescription, _super);
function CrossShapeDescription() {
return _super.call(this, "Cross", "") || this;
}
Object.defineProperty(CrossShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Cross; },
enumerable: true,
configurable: true
});
CrossShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var p0dx = (width - shape.parameters.get(exports.CrossHorizontalWidthParameterName).value) / 2;
var p1dy = (height - shape.parameters.get(exports.CrossVerticalWidthParameterName).value) / 2;
var p0x1 = shape.normalizeX(left + p0dx);
var p1y1 = shape.normalizeY(top + p1dy);
var p0x2 = shape.normalizeX(right - p0dx);
var p1y2 = shape.normalizeY(bottom - p1dy);
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(left, p1y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x1, p1y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x1, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x2, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x2, p1y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, p1y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, p1y2),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x2, p1y2),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x2, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x1, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x1, p1y2),
new PathPrimitive_1.PathPrimitiveLineToCommand(left, p1y2),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
CrossShapeDescription.prototype.createParameters = function (parameters) {
parameters.addRange([
new ShapeParameters_1.ShapeParameter(exports.CrossHorizontalWidthParameterName, this.defaultSize.width * 0.2),
new ShapeParameters_1.ShapeParameter(exports.CrossVerticalWidthParameterName, this.defaultSize.height * 0.2)
]);
};
CrossShapeDescription.prototype.normalizeParameters = function (shape, parameters) {
this.changeParameterValue(parameters, exports.CrossHorizontalWidthParameterName, function (p) { return Math.max(0, Math.min(shape.size.width, p.value)); });
this.changeParameterValue(parameters, exports.CrossVerticalWidthParameterName, function (p) { return Math.max(0, Math.min(shape.size.height, p.value)); });
};
CrossShapeDescription.prototype.modifyParameters = function (shape, parameters, deltaX, deltaY) {
this.changeParameterValue(parameters, exports.CrossHorizontalWidthParameterName, function (p) { return p.value - deltaX * 2; });
this.changeParameterValue(parameters, exports.CrossVerticalWidthParameterName, function (p) { return p.value - deltaY * 2; });
this.normalizeParameters(shape, parameters);
};
CrossShapeDescription.prototype.getParameterPoints = function (shape) {
return [
new ShapeParameterPoint_1.ShapeParameterPoint("c", new Utils_1.Point(shape.normalizeX(shape.position.x + (shape.size.width - shape.parameters.get(exports.CrossHorizontalWidthParameterName).value) / 2), shape.normalizeY(shape.position.y + (shape.size.height - shape.parameters.get(exports.CrossVerticalWidthParameterName).value) / 2)))
];
};
return CrossShapeDescription;
}(ShapeDescription_1.ShapeDescription));
exports.CrossShapeDescription = CrossShapeDescription;
/***/ }),
/* 165 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeDescription_1 = __webpack_require__(9);
var PathPrimitive_1 = __webpack_require__(2);
var ShapeTypes_1 = __webpack_require__(1);
var ConnectionPoint_1 = __webpack_require__(34);
var DiagramItem_1 = __webpack_require__(4);
var HeartShapeDescription = /** @class */ (function (_super) {
__extends(HeartShapeDescription, _super);
function HeartShapeDescription() {
return _super.call(this, "Heart", "") || this;
}
Object.defineProperty(HeartShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Heart; },
enumerable: true,
configurable: true
});
HeartShapeDescription.prototype.createConnectionPoints = function () {
return [
new ConnectionPoint_1.ConnectionPoint(0.5, 0.15, DiagramItem_1.ConnectionPointSide.North),
new ConnectionPoint_1.ConnectionPoint(1, 0.25, DiagramItem_1.ConnectionPointSide.East),
new ConnectionPoint_1.ConnectionPoint(0.5, 1, DiagramItem_1.ConnectionPointSide.South),
new ConnectionPoint_1.ConnectionPoint(0, 0.25, DiagramItem_1.ConnectionPointSide.West)
];
};
HeartShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(right - width * 0.25, top),
new PathPrimitive_1.PathPrimitiveCubicCurveToCommand(right - width * 0.15, top, right, top + height * 0.1, right, top + height * 0.25),
new PathPrimitive_1.PathPrimitiveCubicCurveToCommand(right, top + height * 0.3, right - width * 0.02, top + height * 0.35, right - width * 0.05, top + height * 0.4),
new PathPrimitive_1.PathPrimitiveLineToCommand(rect.center.x, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(left + width * 0.05, top + height * 0.4),
new PathPrimitive_1.PathPrimitiveCubicCurveToCommand(left + width * 0.02, top + height * 0.35, left, top + height * 0.3, left, top + height * 0.25),
new PathPrimitive_1.PathPrimitiveCubicCurveToCommand(left, top + height * 0.1, left + width * 0.15, top, left + width * 0.25, top),
new PathPrimitive_1.PathPrimitiveCubicCurveToCommand(left + width * 0.3, top, left + width * 0.45, top + height * 0.03, left + width * 0.5, top + height * 0.15),
new PathPrimitive_1.PathPrimitiveCubicCurveToCommand(right - width * 0.45, top + height * 0.03, right - width * 0.3, top, right - width * 0.25, top),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
return HeartShapeDescription;
}(ShapeDescription_1.ShapeDescription));
exports.HeartShapeDescription = HeartShapeDescription;
/***/ }),
/* 166 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var PathPrimitive_1 = __webpack_require__(2);
var ShapeTypes_1 = __webpack_require__(1);
var PolygonShapeDescription_1 = __webpack_require__(68);
var OctagonShapeDescription = /** @class */ (function (_super) {
__extends(OctagonShapeDescription, _super);
function OctagonShapeDescription() {
return _super.call(this, "Octagon", "") || this;
}
Object.defineProperty(OctagonShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Octagon; },
enumerable: true,
configurable: true
});
Object.defineProperty(OctagonShapeDescription.prototype, "angleCount", {
get: function () { return 8; },
enumerable: true,
configurable: true
});
OctagonShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var angle = Math.PI - this.angle;
var sideX = width / (1 + 2 * Math.cos(angle));
var sideY = height / (1 + 2 * Math.cos(angle));
var x1 = left + (width - sideX) / 2;
var x2 = x1 + sideX;
var y1 = top + (height - sideY) / 2;
var y2 = y1 + sideY;
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(x1, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(x2, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, y2),
new PathPrimitive_1.PathPrimitiveLineToCommand(x2, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(x1, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(left, y2),
new PathPrimitive_1.PathPrimitiveLineToCommand(left, y1),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
OctagonShapeDescription.prototype.calculateHeight = function (width) {
return width;
};
return OctagonShapeDescription;
}(PolygonShapeDescription_1.PolygonShapeDescription));
exports.OctagonShapeDescription = OctagonShapeDescription;
/***/ }),
/* 167 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var PathPrimitive_1 = __webpack_require__(2);
var ShapeTypes_1 = __webpack_require__(1);
var PentagonShapeDescription_1 = __webpack_require__(94);
var ShapeParameters_1 = __webpack_require__(29);
var ShapeParameterPoint_1 = __webpack_require__(21);
var Utils_1 = __webpack_require__(0);
var DiagramItem_1 = __webpack_require__(4);
exports.StarConvexParameterName = "sc";
var StarShapeDescription = /** @class */ (function (_super) {
__extends(StarShapeDescription, _super);
function StarShapeDescription() {
return _super.call(this, "Star", "") || this;
}
Object.defineProperty(StarShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Star; },
enumerable: true,
configurable: true
});
StarShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
bottom = this.getActualBottom(top, bottom, width, height);
var cx = rect.center.x;
var cy = top + (bottom - top) / 2;
var ratio = height / width;
var angle = Math.PI - this.angle;
var py = width / 2 * Math.tan(angle / 2) * ratio;
var y = top + py;
var px = (height - py) / Math.tan(angle) / ratio;
var x1 = left + px;
var x2 = right - px;
var pDistance = shape.parameters.get(exports.StarConvexParameterName).value;
var distance = this.getInnerPointDistance(cx, cx, right, cy, top, y);
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(cx, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(this.getInnerPointPos(cx, cx, right, pDistance, distance), this.getInnerPointPos(cy, top, y, pDistance, distance)),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, y),
new PathPrimitive_1.PathPrimitiveLineToCommand(this.getInnerPointPos(cx, right, x2, pDistance, distance), this.getInnerPointPos(cy, y, bottom, pDistance, distance)),
new PathPrimitive_1.PathPrimitiveLineToCommand(x2, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(this.getInnerPointPos(cx, x2, x1, pDistance, distance), this.getInnerPointPos(cy, bottom, bottom, pDistance, distance)),
new PathPrimitive_1.PathPrimitiveLineToCommand(x1, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(this.getInnerPointPos(cx, x1, left, pDistance, distance), this.getInnerPointPos(cy, bottom, y, pDistance, distance)),
new PathPrimitive_1.PathPrimitiveLineToCommand(left, y),
new PathPrimitive_1.PathPrimitiveLineToCommand(this.getInnerPointPos(cx, left, cx, pDistance, distance), this.getInnerPointPos(cy, y, top, pDistance, distance)),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
StarShapeDescription.prototype.createParameters = function (parameters) {
parameters.addRange([
new ShapeParameters_1.ShapeParameter(exports.StarConvexParameterName, 300)
]);
};
StarShapeDescription.prototype.normalizeParameters = function (shape, parameters) {
var rect = shape.rectangle;
var top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
bottom = this.getActualBottom(top, bottom, width, height);
var cx = rect.center.x;
var cy = top + (bottom - top) / 2;
var ratio = height / width;
var angle = Math.PI - this.angle;
var py = width / 2 * Math.tan(angle / 2) * ratio;
var y = top + py;
var distance = this.getInnerPointDistance(cx, cx, right, cy, top, y);
this.changeParameterValue(parameters, exports.StarConvexParameterName, function (p) { return Math.max(0, Math.min(distance, p.value)); });
};
StarShapeDescription.prototype.modifyParameters = function (shape, parameters, deltaX, deltaY) {
var distance = Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2));
if (deltaX < 0 || deltaY > 0)
distance = -distance;
this.changeParameterValue(parameters, exports.StarConvexParameterName, function (p) { return p.value + distance; });
this.normalizeParameters(shape, parameters);
};
StarShapeDescription.prototype.getParameterPoints = function (shape) {
var rect = shape.rectangle;
var top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
bottom = this.getActualBottom(top, bottom, width, height);
var cx = rect.center.x;
var cy = top + (bottom - top) / 2;
var ratio = height / width;
var angle = Math.PI - this.angle;
var py = width / 2 * Math.tan(angle / 2) * ratio;
var y = top + py;
var pDistance = shape.parameters.get(exports.StarConvexParameterName).value;
var distance = this.getInnerPointDistance(cx, cx, right, cy, top, y);
var innerPointX = this.getInnerPointPos(cx, cx, right, pDistance, distance);
var innerPointY = this.getInnerPointPos(cy, top, y, pDistance, distance);
return [
new ShapeParameterPoint_1.ShapeParameterPoint("c", new Utils_1.Point(innerPointX, innerPointY))
];
};
StarShapeDescription.prototype.processConnectionPoint = function (shape, point) {
_super.prototype.processConnectionPoint.call(this, shape, point);
var side = shape.getConnectionPointSide(point);
if (side === DiagramItem_1.ConnectionPointSide.South) {
var rect = shape.rectangle;
var top_1 = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
bottom = this.getActualBottom(top_1, bottom, width, height);
var cx = rect.center.x;
var cy = top_1 + (bottom - top_1) / 2;
var ratio = height / width;
var angle = Math.PI - this.angle;
var py = width / 2 * Math.tan(angle / 2) * ratio;
var y = top_1 + py;
var pDistance = shape.parameters.get(exports.StarConvexParameterName).value;
var distance = this.getInnerPointDistance(cx, cx, right, cy, top_1, y);
point.y = this.getInnerPointPos(cy, bottom, bottom, pDistance, distance);
}
};
StarShapeDescription.prototype.getInnerPointDistanceByAxis = function (center, edge1, edge2) {
var edgeX = Math.min(edge1, edge2) + Math.abs(edge1 - edge2) / 2;
return edgeX - center;
};
StarShapeDescription.prototype.getInnerPointPos = function (center, edge1, edge2, pDistance, distance) {
var ratio = Math.min(1, pDistance / distance);
return center + this.getInnerPointDistanceByAxis(center, edge1, edge2) * ratio;
};
StarShapeDescription.prototype.getInnerPointDistance = function (centerX, edgeX1, edgeX2, centerY, edgeY1, edgeY2) {
var disX = this.getInnerPointDistanceByAxis(centerX, edgeX1, edgeX2);
var disY = this.getInnerPointDistanceByAxis(centerY, edgeY1, edgeY2);
return Math.sqrt(Math.pow(disX, 2) + Math.pow(disY, 2));
};
StarShapeDescription.prototype.getActualBottom = function (top, bottom, width, height) {
var result = top + _super.prototype.calculateHeight.call(this, width) * height / width;
return result < bottom ? result : bottom;
};
StarShapeDescription.prototype.calculateHeight = function (width) {
return width;
};
return StarShapeDescription;
}(PentagonShapeDescription_1.PentagonShapeDescription));
exports.StarShapeDescription = StarShapeDescription;
/***/ }),
/* 168 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var PathPrimitive_1 = __webpack_require__(2);
var ShapeParameterPoint_1 = __webpack_require__(21);
var Utils_1 = __webpack_require__(0);
var ArrowVerticalShapeDescription_1 = __webpack_require__(65);
var ShapeTypes_1 = __webpack_require__(1);
var DiagramItem_1 = __webpack_require__(4);
var ArrowBottomShapeDescription = /** @class */ (function (_super) {
__extends(ArrowBottomShapeDescription, _super);
function ArrowBottomShapeDescription() {
return _super.call(this, "Bottom Arrow") || this;
}
Object.defineProperty(ArrowBottomShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.ArrowBottom; },
enumerable: true,
configurable: true
});
ArrowBottomShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var cx = rect.center.x;
var p1dx = (width - shape.parameters.get(ArrowVerticalShapeDescription_1.ArrowVerticalLineWidthParameterName).value) / 2;
var p0dy = height - shape.parameters.get(ArrowVerticalShapeDescription_1.ArrowVerticalTriangleHeightParameterName).value;
var p1x1 = shape.normalizeX(left + p1dx);
var p0y1 = shape.normalizeY(top + p0dy);
var p1x2 = shape.normalizeX(right - p1dx);
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(p1x1, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(p1x2, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(p1x2, p0y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, p0y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(cx, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(left, p0y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(p1x1, p0y1),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
ArrowBottomShapeDescription.prototype.modifyParameters = function (shape, parameters, deltaX, deltaY) {
this.changeParameterValue(parameters, ArrowVerticalShapeDescription_1.ArrowVerticalTriangleHeightParameterName, function (p) { return p.value - deltaY; });
this.changeParameterValue(parameters, ArrowVerticalShapeDescription_1.ArrowVerticalLineWidthParameterName, function (p) { return p.value - deltaX * 2; });
this.normalizeParameters(shape, parameters);
};
ArrowBottomShapeDescription.prototype.getParameterPoints = function (shape) {
return [
new ShapeParameterPoint_1.ShapeParameterPoint("c", new Utils_1.Point(shape.normalizeX(shape.position.x + (shape.size.width - shape.parameters.get(ArrowVerticalShapeDescription_1.ArrowVerticalLineWidthParameterName).value) / 2), shape.normalizeY(shape.position.y + shape.size.height - shape.parameters.get(ArrowVerticalShapeDescription_1.ArrowVerticalTriangleHeightParameterName).value)))
];
};
ArrowBottomShapeDescription.prototype.processConnectionPoint = function (shape, point) {
var triangleHeight = shape.parameters.get(ArrowVerticalShapeDescription_1.ArrowVerticalTriangleHeightParameterName).value;
if (point.y > shape.position.y + shape.size.height - triangleHeight) {
var tg = shape.size.width / 2 / triangleHeight;
var delta = (point.y - (shape.position.y + shape.size.height - triangleHeight)) * tg;
var side = shape.getConnectionPointSide(point);
if (side === DiagramItem_1.ConnectionPointSide.East)
point.x -= delta;
else if (side === DiagramItem_1.ConnectionPointSide.West)
point.x += delta;
}
else
_super.prototype.processConnectionPoint.call(this, shape, point);
};
return ArrowBottomShapeDescription;
}(ArrowVerticalShapeDescription_1.ArrowVerticalShapeDescription));
exports.ArrowBottomShapeDescription = ArrowBottomShapeDescription;
/***/ }),
/* 169 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Shape_1 = __webpack_require__(11);
var PathPrimitive_1 = __webpack_require__(2);
var ArrowHorizontalShapeDescription_1 = __webpack_require__(66);
var ShapeParameterPoint_1 = __webpack_require__(21);
var Utils_1 = __webpack_require__(0);
var ShapeTypes_1 = __webpack_require__(1);
var ArrowEastWestShapeDescription = /** @class */ (function (_super) {
__extends(ArrowEastWestShapeDescription, _super);
function ArrowEastWestShapeDescription() {
return _super.call(this, "East-West Arrow") || this;
}
Object.defineProperty(ArrowEastWestShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.ArrowEastWest; },
enumerable: true,
configurable: true
});
ArrowEastWestShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var cy = rect.center.y;
var p0dx = shape.parameters.get(ArrowHorizontalShapeDescription_1.ArrowVerticalTriangleWidthParameterName).value;
var p1dy = (height - shape.parameters.get(ArrowHorizontalShapeDescription_1.ArrowVerticalLineHeightParameterName).value) / 2;
var p0x1 = shape.normalizeX(left + p0dx);
var p1y1 = shape.normalizeY(top + p1dy);
var p0x2 = shape.normalizeX(right - p0dx);
var p1y2 = shape.normalizeY(bottom - p1dy);
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(left, cy),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x1, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x1, p1y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x2, p1y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x2, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, cy),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x2, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x2, p1y2),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x1, p1y2),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x1, bottom),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
ArrowEastWestShapeDescription.prototype.normalizeParameters = function (shape, parameters) {
this.changeParameterValue(parameters, ArrowHorizontalShapeDescription_1.ArrowVerticalTriangleWidthParameterName, function (p) { return Math.max(0, Math.min(shape.size.width / 2 - 2 * Shape_1.Shape.lineWidth, p.value)); });
this.changeParameterValue(parameters, ArrowHorizontalShapeDescription_1.ArrowVerticalLineHeightParameterName, function (p) { return Math.max(0, Math.min(shape.size.height, p.value)); });
};
ArrowEastWestShapeDescription.prototype.modifyParameters = function (shape, parameters, deltaX, deltaY) {
this.changeParameterValue(parameters, ArrowHorizontalShapeDescription_1.ArrowVerticalTriangleWidthParameterName, function (p) { return p.value + deltaX; });
this.changeParameterValue(parameters, ArrowHorizontalShapeDescription_1.ArrowVerticalLineHeightParameterName, function (p) { return p.value - deltaY * 2; });
this.normalizeParameters(shape, parameters);
};
ArrowEastWestShapeDescription.prototype.getParameterPoints = function (shape) {
return [
new ShapeParameterPoint_1.ShapeParameterPoint("c", new Utils_1.Point(shape.normalizeX(shape.position.x + shape.parameters.get(ArrowHorizontalShapeDescription_1.ArrowVerticalTriangleWidthParameterName).value), shape.normalizeY(shape.position.y + (shape.size.height - shape.parameters.get(ArrowHorizontalShapeDescription_1.ArrowVerticalLineHeightParameterName).value) / 2)))
];
};
return ArrowEastWestShapeDescription;
}(ArrowHorizontalShapeDescription_1.ArrowHorizontalShapeDescription));
exports.ArrowEastWestShapeDescription = ArrowEastWestShapeDescription;
/***/ }),
/* 170 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var PathPrimitive_1 = __webpack_require__(2);
var ArrowHorizontalShapeDescription_1 = __webpack_require__(66);
var ShapeParameterPoint_1 = __webpack_require__(21);
var Utils_1 = __webpack_require__(0);
var ShapeTypes_1 = __webpack_require__(1);
var DiagramItem_1 = __webpack_require__(4);
var ArrowLeftShapeDescription = /** @class */ (function (_super) {
__extends(ArrowLeftShapeDescription, _super);
function ArrowLeftShapeDescription() {
return _super.call(this, "Left Arrow") || this;
}
Object.defineProperty(ArrowLeftShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.ArrowLeft; },
enumerable: true,
configurable: true
});
ArrowLeftShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var cy = rect.center.y;
var p0dx = shape.parameters.get(ArrowHorizontalShapeDescription_1.ArrowVerticalTriangleWidthParameterName).value;
var p1dy = (height - shape.parameters.get(ArrowHorizontalShapeDescription_1.ArrowVerticalLineHeightParameterName).value) / 2;
var p0x1 = shape.normalizeX(left + p0dx);
var p1y1 = shape.normalizeY(top + p1dy);
var p1y2 = shape.normalizeY(bottom - p1dy);
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(left, cy),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x1, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x1, p1y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, p1y1),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, p1y2),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x1, p1y2),
new PathPrimitive_1.PathPrimitiveLineToCommand(p0x1, bottom),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
ArrowLeftShapeDescription.prototype.modifyParameters = function (shape, parameters, deltaX, deltaY) {
this.changeParameterValue(parameters, ArrowHorizontalShapeDescription_1.ArrowVerticalTriangleWidthParameterName, function (p) { return p.value + deltaX; });
this.changeParameterValue(parameters, ArrowHorizontalShapeDescription_1.ArrowVerticalLineHeightParameterName, function (p) { return p.value - deltaY * 2; });
this.normalizeParameters(shape, parameters);
};
ArrowLeftShapeDescription.prototype.getParameterPoints = function (shape) {
return [
new ShapeParameterPoint_1.ShapeParameterPoint("c", new Utils_1.Point(shape.normalizeX(shape.position.x + shape.parameters.get(ArrowHorizontalShapeDescription_1.ArrowVerticalTriangleWidthParameterName).value), shape.normalizeY(shape.position.y + (shape.size.height - shape.parameters.get(ArrowHorizontalShapeDescription_1.ArrowVerticalLineHeightParameterName).value) / 2)))
];
};
ArrowLeftShapeDescription.prototype.processConnectionPoint = function (shape, point) {
var triangleWidth = shape.parameters.get(ArrowHorizontalShapeDescription_1.ArrowVerticalTriangleWidthParameterName).value;
if (point.x < shape.position.x + triangleWidth) {
var tg = shape.size.height / 2 / triangleWidth;
var delta = (shape.position.x + triangleWidth - point.x) * tg;
var side = shape.getConnectionPointSide(point);
if (side === DiagramItem_1.ConnectionPointSide.North)
point.y += delta;
else if (side === DiagramItem_1.ConnectionPointSide.South)
point.y -= delta;
}
else
_super.prototype.processConnectionPoint.call(this, shape, point);
};
return ArrowLeftShapeDescription;
}(ArrowHorizontalShapeDescription_1.ArrowHorizontalShapeDescription));
exports.ArrowLeftShapeDescription = ArrowLeftShapeDescription;
/***/ }),
/* 171 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeTypes_1 = __webpack_require__(1);
var Shape_1 = __webpack_require__(11);
var PathPrimitive_1 = __webpack_require__(2);
var DocumentShapeDescription_1 = __webpack_require__(97);
var ClipPathPrimitive_1 = __webpack_require__(41);
var Utils_1 = __webpack_require__(15);
var MultipleDocumentsShapeDescription = /** @class */ (function (_super) {
__extends(MultipleDocumentsShapeDescription, _super);
function MultipleDocumentsShapeDescription() {
return _super.call(this, "Multiple Documents", "Multiple\nDocuments") || this;
}
Object.defineProperty(MultipleDocumentsShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.MultipleDocuments; },
enumerable: true,
configurable: true
});
MultipleDocumentsShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var _a = shape.rectangle, left = _a.left, top = _a.top, right = _a.right, bottom = _a.bottom, width = _a.width, height = _a.height;
var documentOffsetX = width * MultipleDocumentsShapeDescription.documentsOffsetRatio;
var documentOffsetY = height * MultipleDocumentsShapeDescription.documentsOffsetRatio;
rect = rect.inflate(-documentOffsetX, -documentOffsetY).offset(-documentOffsetX, -documentOffsetY);
var rect1 = rect.offset(documentOffsetX, documentOffsetY);
var rect2 = rect.offset(2 * documentOffsetX, 2 * documentOffsetY);
var clipPathId = Utils_1.RenderUtils.generateSvgElementId("clipRect");
var primitives = [];
return primitives
.concat(this.createDocumentPrimitives(rect, shape.style, clipPathId + "1", rect1))
.concat(this.createDocumentPrimitives(rect1, shape.style, clipPathId + "2", rect2))
.concat(this.createDocumentPrimitives(rect2, shape.style));
};
MultipleDocumentsShapeDescription.prototype.createDocumentPrimitives = function (rect, style, clipPathId, clipRect) {
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var cx = rect.center.x;
var dy = height * DocumentShapeDescription_1.DocumentShapeDescription.curveOffsetRatio;
var primitives = [];
primitives = primitives.concat([
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(left, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, bottom),
new PathPrimitive_1.PathPrimitiveQuadraticCurveToCommand(right - width * 0.25, bottom - 2 * dy, cx, bottom - dy),
new PathPrimitive_1.PathPrimitiveQuadraticCurveToCommand(left + width * 0.25, bottom + dy, left, bottom - dy),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], style, undefined, clipRect && clipPathId)
]);
if (clipRect && clipPathId) {
primitives = primitives.concat([
new ClipPathPrimitive_1.ClipPathPrimitive(clipPathId, [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(left - Shape_1.Shape.lineWidth, top - Shape_1.Shape.lineWidth),
new PathPrimitive_1.PathPrimitiveLineToCommand(right + Shape_1.Shape.lineWidth, top - Shape_1.Shape.lineWidth),
new PathPrimitive_1.PathPrimitiveLineToCommand(right + Shape_1.Shape.lineWidth, clipRect.top),
new PathPrimitive_1.PathPrimitiveLineToCommand(clipRect.left, clipRect.top),
new PathPrimitive_1.PathPrimitiveLineToCommand(clipRect.left, bottom + Shape_1.Shape.lineWidth),
new PathPrimitive_1.PathPrimitiveLineToCommand(left - Shape_1.Shape.lineWidth, bottom + Shape_1.Shape.lineWidth),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
])
])
]);
}
return primitives;
};
MultipleDocumentsShapeDescription.prototype.getTextRectangle = function (rect, parameters) {
var documentOffsetX = rect.width * MultipleDocumentsShapeDescription.documentsOffsetRatio;
var documentOffsetY = rect.height * MultipleDocumentsShapeDescription.documentsOffsetRatio;
rect = rect.inflate(-documentOffsetX, -documentOffsetY).offset(-documentOffsetX, -documentOffsetY);
var innerRect = rect.offset(2 * documentOffsetX, 2 * documentOffsetY);
return innerRect.resize(0, -rect.height * DocumentShapeDescription_1.DocumentShapeDescription.curveOffsetRatio);
};
MultipleDocumentsShapeDescription.documentsOffsetRatio = 0.1;
return MultipleDocumentsShapeDescription;
}(DocumentShapeDescription_1.DocumentShapeDescription));
exports.MultipleDocumentsShapeDescription = MultipleDocumentsShapeDescription;
/***/ }),
/* 172 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeTypes_1 = __webpack_require__(1);
var Utils_1 = __webpack_require__(0);
var ShapeDescription_1 = __webpack_require__(9);
var HexagonShapeDescription_1 = __webpack_require__(95);
var PreparationShapeDescription = /** @class */ (function (_super) {
__extends(PreparationShapeDescription, _super);
function PreparationShapeDescription() {
var _this = _super.call(this, "Preparation", "Preparation") || this;
_this.defaultSize = new Utils_1.Size(ShapeDescription_1.ShapeDefaultDimension, ShapeDescription_1.ShapeDefaultDimension * 0.75);
return _this;
}
Object.defineProperty(PreparationShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Preparation; },
enumerable: true,
configurable: true
});
return PreparationShapeDescription;
}(HexagonShapeDescription_1.HexagonShapeDescription));
exports.PreparationShapeDescription = PreparationShapeDescription;
/***/ }),
/* 173 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RectangleShapeDescription_1 = __webpack_require__(14);
var ShapeTypes_1 = __webpack_require__(1);
var PathPrimitive_1 = __webpack_require__(2);
var EllipsePrimitive_1 = __webpack_require__(42);
var HardDiskShapeDescription = /** @class */ (function (_super) {
__extends(HardDiskShapeDescription, _super);
function HardDiskShapeDescription() {
return _super.call(this, "Hard Disk", "Hard Disk") || this;
}
Object.defineProperty(HardDiskShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.HardDisk; },
enumerable: true,
configurable: true
});
HardDiskShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var cy = rect.center.y;
var dx = width * HardDiskShapeDescription.arcWidthRatio;
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(right - dx / 2, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(left + dx / 2, top),
new PathPrimitive_1.PathPrimitiveArcToCommand(dx / 2, (bottom - top) / 2, 0, false, false, left + dx / 2, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(right - dx / 2, bottom),
], shape.style),
new EllipsePrimitive_1.EllipsePrimitive(right - dx / 2, cy, dx / 2, (bottom - top) / 2, shape.style)
];
};
HardDiskShapeDescription.prototype.getTextRectangle = function (rect, parameters) {
var dx = rect.width * HardDiskShapeDescription.arcWidthRatio;
return rect.resize(-dx, 0);
};
HardDiskShapeDescription.arcWidthRatio = 0.2;
return HardDiskShapeDescription;
}(RectangleShapeDescription_1.RectangleShapeDescription));
exports.HardDiskShapeDescription = HardDiskShapeDescription;
/***/ }),
/* 174 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RectangleShapeDescription_1 = __webpack_require__(14);
var ShapeTypes_1 = __webpack_require__(1);
var PathPrimitive_1 = __webpack_require__(2);
var EllipsePrimitive_1 = __webpack_require__(42);
var DatabaseShapeDescription = /** @class */ (function (_super) {
__extends(DatabaseShapeDescription, _super);
function DatabaseShapeDescription() {
var _this = _super.call(this, "Database", "Database") || this;
_this.defaultSize.width = _this.defaultSize.height;
return _this;
}
Object.defineProperty(DatabaseShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Database; },
enumerable: true,
configurable: true
});
DatabaseShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var cx = rect.center.x;
var dy = height * DatabaseShapeDescription.arcWidthRatio;
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(right, top + dy / 2),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, bottom - dy / 2),
new PathPrimitive_1.PathPrimitiveArcToCommand((right - left) / 2, dy / 2, 0, false, true, left, bottom - dy / 2),
new PathPrimitive_1.PathPrimitiveLineToCommand(left, top + dy / 2),
], shape.style),
new EllipsePrimitive_1.EllipsePrimitive(cx, top + dy / 2, (right - left) / 2, dy / 2, shape.style)
];
};
DatabaseShapeDescription.prototype.getTextRectangle = function (rect, parameters) {
var dy = rect.height * DatabaseShapeDescription.arcWidthRatio;
return rect.resize(0, -dy).offset(0, dy);
};
DatabaseShapeDescription.arcWidthRatio = 0.2;
return DatabaseShapeDescription;
}(RectangleShapeDescription_1.RectangleShapeDescription));
exports.DatabaseShapeDescription = DatabaseShapeDescription;
/***/ }),
/* 175 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RectangleShapeDescription_1 = __webpack_require__(14);
var ShapeTypes_1 = __webpack_require__(1);
var ShapeParameters_1 = __webpack_require__(29);
var ShapeParameterPoint_1 = __webpack_require__(21);
var Utils_1 = __webpack_require__(0);
var PathPrimitive_1 = __webpack_require__(2);
exports.InternalStorageHorizontalEdgeParameterName = "he";
exports.InternalStorageVerticalEdgeParameterName = "ve";
var InternalStorageShapeDescription = /** @class */ (function (_super) {
__extends(InternalStorageShapeDescription, _super);
function InternalStorageShapeDescription() {
return _super.call(this, "Internal Storage", "Internal\nStorage") || this;
}
Object.defineProperty(InternalStorageShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.InternalStorage; },
enumerable: true,
configurable: true
});
InternalStorageShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var x = left + shape.parameters.get(exports.InternalStorageHorizontalEdgeParameterName).value;
var y = top + shape.parameters.get(exports.InternalStorageVerticalEdgeParameterName).value;
var primitives = _super.prototype.createShapePrimitives.call(this, shape);
return primitives.concat([
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(x, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(x, bottom),
new PathPrimitive_1.PathPrimitiveMoveToCommand(left, y),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, y)
], shape.style)
]);
};
InternalStorageShapeDescription.prototype.createParameters = function (parameters) {
parameters.addRange([
new ShapeParameters_1.ShapeParameter(exports.InternalStorageHorizontalEdgeParameterName, this.defaultSize.width * 0.1),
new ShapeParameters_1.ShapeParameter(exports.InternalStorageVerticalEdgeParameterName, this.defaultSize.width * 0.1)
]);
};
InternalStorageShapeDescription.prototype.normalizeParameters = function (shape, parameters) {
this.changeParameterValue(parameters, exports.InternalStorageHorizontalEdgeParameterName, function (p) { return Math.max(InternalStorageShapeDescription.minEdge, Math.min(shape.size.width * 0.3, p.value)); });
this.changeParameterValue(parameters, exports.InternalStorageVerticalEdgeParameterName, function (p) { return Math.max(InternalStorageShapeDescription.minEdge, Math.min(shape.size.height * 0.3, p.value)); });
};
InternalStorageShapeDescription.prototype.modifyParameters = function (shape, parameters, deltaX, deltaY) {
this.changeParameterValue(parameters, exports.InternalStorageHorizontalEdgeParameterName, function (p) { return p.value + deltaX; });
this.changeParameterValue(parameters, exports.InternalStorageVerticalEdgeParameterName, function (p) { return p.value + deltaY; });
this.normalizeParameters(shape, parameters);
};
InternalStorageShapeDescription.prototype.getParameterPoints = function (shape) {
return [
new ShapeParameterPoint_1.ShapeParameterPoint("c", new Utils_1.Point(shape.normalizeX(shape.position.x + shape.parameters.get(exports.InternalStorageHorizontalEdgeParameterName).value), shape.normalizeY(shape.position.y + shape.parameters.get(exports.InternalStorageVerticalEdgeParameterName).value)))
];
};
InternalStorageShapeDescription.minEdge = 72;
return InternalStorageShapeDescription;
}(RectangleShapeDescription_1.RectangleShapeDescription));
exports.InternalStorageShapeDescription = InternalStorageShapeDescription;
/***/ }),
/* 176 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RectangleShapeDescription_1 = __webpack_require__(14);
var ShapeTypes_1 = __webpack_require__(1);
var PathPrimitive_1 = __webpack_require__(2);
var DiagramItem_1 = __webpack_require__(4);
var PaperTapeShapeDescription = /** @class */ (function (_super) {
__extends(PaperTapeShapeDescription, _super);
function PaperTapeShapeDescription(title, defaultText) {
if (title === void 0) { title = "Paper Tape"; }
if (defaultText === void 0) { defaultText = "Paper Tape"; }
return _super.call(this, title, defaultText) || this;
}
Object.defineProperty(PaperTapeShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.PaperTape; },
enumerable: true,
configurable: true
});
PaperTapeShapeDescription.prototype.createShapePrimitives = function (shape) {
return this.createDocumentPrimitives(shape.rectangle, shape.style);
};
PaperTapeShapeDescription.prototype.createDocumentPrimitives = function (rect, style) {
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var cx = rect.center.x;
var dy = height * PaperTapeShapeDescription.curveOffsetRatio;
var primitives = [];
return primitives.concat([
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(left, top),
new PathPrimitive_1.PathPrimitiveQuadraticCurveToCommand(left + width * 0.25, top + 2 * dy, cx, top + dy),
new PathPrimitive_1.PathPrimitiveQuadraticCurveToCommand(right - width * 0.25, top - dy, right, top + dy),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, bottom),
new PathPrimitive_1.PathPrimitiveQuadraticCurveToCommand(right - width * 0.25, bottom - 2 * dy, cx, bottom - dy),
new PathPrimitive_1.PathPrimitiveQuadraticCurveToCommand(left + width * 0.25, bottom + dy, left, bottom - dy),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], style)
]);
};
PaperTapeShapeDescription.prototype.processConnectionPoint = function (shape, point) {
var side = shape.getConnectionPointSide(point);
if (side === DiagramItem_1.ConnectionPointSide.North)
point.y += shape.size.height * PaperTapeShapeDescription.curveOffsetRatio;
if (side === DiagramItem_1.ConnectionPointSide.South)
point.y -= shape.size.height * PaperTapeShapeDescription.curveOffsetRatio;
};
PaperTapeShapeDescription.prototype.getTextRectangle = function (rect, parameters) {
return rect.inflate(0, -rect.height * PaperTapeShapeDescription.curveOffsetRatio);
};
PaperTapeShapeDescription.curveOffsetRatio = 0.1;
return PaperTapeShapeDescription;
}(RectangleShapeDescription_1.RectangleShapeDescription));
exports.PaperTapeShapeDescription = PaperTapeShapeDescription;
/***/ }),
/* 177 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RectangleShapeDescription_1 = __webpack_require__(14);
var ShapeTypes_1 = __webpack_require__(1);
var PathPrimitive_1 = __webpack_require__(2);
var DiagramItem_1 = __webpack_require__(4);
var ManualOperationShapeDescription = /** @class */ (function (_super) {
__extends(ManualOperationShapeDescription, _super);
function ManualOperationShapeDescription() {
return _super.call(this, "Manual Operation", "Manual\nOperation") || this;
}
Object.defineProperty(ManualOperationShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.ManualOperation; },
enumerable: true,
configurable: true
});
ManualOperationShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var _a = shape.rectangle, left = _a.left, top = _a.top, right = _a.right, bottom = _a.bottom, width = _a.width, height = _a.height;
var px = Math.min(Math.max(0, height / Math.tan(ManualOperationShapeDescription.slopeAngle)), width);
var cx = rect.center.x;
var x1 = Math.min(left + px, cx);
var x2 = Math.max(right - px, cx);
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(left, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(x2, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(x1, bottom),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
ManualOperationShapeDescription.prototype.processConnectionPoint = function (shape, point) {
var offset = shape.size.height / Math.tan(ManualOperationShapeDescription.slopeAngle);
var side = shape.getConnectionPointSide(point);
if (side === DiagramItem_1.ConnectionPointSide.East)
point.x -= offset / 2;
else if (side === DiagramItem_1.ConnectionPointSide.West)
point.x += offset / 2;
};
ManualOperationShapeDescription.slopeAngle = 81 * Math.PI / 180;
return ManualOperationShapeDescription;
}(RectangleShapeDescription_1.RectangleShapeDescription));
exports.ManualOperationShapeDescription = ManualOperationShapeDescription;
/***/ }),
/* 178 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RectangleShapeDescription_1 = __webpack_require__(14);
var ShapeTypes_1 = __webpack_require__(1);
var PathPrimitive_1 = __webpack_require__(2);
var DelayShapeDescription = /** @class */ (function (_super) {
__extends(DelayShapeDescription, _super);
function DelayShapeDescription() {
var _this = _super.call(this, "Delay", "Delay") || this;
_this.defaultSize.width = _this.defaultSize.height;
return _this;
}
Object.defineProperty(DelayShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Delay; },
enumerable: true,
configurable: true
});
DelayShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom;
var cx = rect.center.x;
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(left, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(cx, top),
new PathPrimitive_1.PathPrimitiveArcToCommand((right - left) / 2, (bottom - top) / 2, 0, false, true, cx, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(left, bottom),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
DelayShapeDescription.arcWidthRatio = 0.2;
return DelayShapeDescription;
}(RectangleShapeDescription_1.RectangleShapeDescription));
exports.DelayShapeDescription = DelayShapeDescription;
/***/ }),
/* 179 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RectangleShapeDescription_1 = __webpack_require__(14);
var ShapeTypes_1 = __webpack_require__(1);
var PathPrimitive_1 = __webpack_require__(2);
var StoredDataShapeDescription = /** @class */ (function (_super) {
__extends(StoredDataShapeDescription, _super);
function StoredDataShapeDescription() {
return _super.call(this, "Stored Data", "Stored Data") || this;
}
Object.defineProperty(StoredDataShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.StoredData; },
enumerable: true,
configurable: true
});
StoredDataShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var cy = rect.center.y;
var dx = width * StoredDataShapeDescription.arcWidthRatio;
var primitives = [];
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(right, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(left + dx / 2, top),
new PathPrimitive_1.PathPrimitiveArcToCommand(dx / 2, (bottom - top) / 2, 0, false, false, left + dx / 2, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, bottom),
new PathPrimitive_1.PathPrimitiveArcToCommand(dx / 2, (bottom - top) / 2, 0, false, true, right, top)
], shape.style)
];
};
StoredDataShapeDescription.prototype.getTextRectangle = function (rect, parameters) {
var dx = rect.width * StoredDataShapeDescription.arcWidthRatio;
return rect.resize(-dx, 0);
};
StoredDataShapeDescription.arcWidthRatio = 0.2;
return StoredDataShapeDescription;
}(RectangleShapeDescription_1.RectangleShapeDescription));
exports.StoredDataShapeDescription = StoredDataShapeDescription;
/***/ }),
/* 180 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeTypes_1 = __webpack_require__(1);
var TriangleShapeDescription_1 = __webpack_require__(96);
var PathPrimitive_1 = __webpack_require__(2);
var MergeShapeDescription = /** @class */ (function (_super) {
__extends(MergeShapeDescription, _super);
function MergeShapeDescription() {
return _super.call(this, "Merge", "Merge") || this;
}
Object.defineProperty(MergeShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Merge; },
enumerable: true,
configurable: true
});
MergeShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width;
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(left, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(rect.center.x, bottom),
new PathPrimitive_1.PathPrimitiveClosePathCommand()
], shape.style)
];
};
MergeShapeDescription.prototype.calculateHeight = function (width) {
return width * 0.75;
};
MergeShapeDescription.prototype.getTextRectangle = function (rect, parameters) {
return rect.resize(0, -rect.width * 0.25);
};
return MergeShapeDescription;
}(TriangleShapeDescription_1.TriangleShapeDescription));
exports.MergeShapeDescription = MergeShapeDescription;
/***/ }),
/* 181 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RectangleShapeDescription_1 = __webpack_require__(14);
var ShapeTypes_1 = __webpack_require__(1);
var PathPrimitive_1 = __webpack_require__(2);
var DisplayShapeDescription = /** @class */ (function (_super) {
__extends(DisplayShapeDescription, _super);
function DisplayShapeDescription() {
return _super.call(this, "Display", "Display") || this;
}
Object.defineProperty(DisplayShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Display; },
enumerable: true,
configurable: true
});
DisplayShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var cy = rect.center.y;
var dx = width * DisplayShapeDescription.arcWidthRatio;
return [
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(right - dx / 2, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(left + dx / 2, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(left, cy),
new PathPrimitive_1.PathPrimitiveLineToCommand(left + dx / 2, bottom),
new PathPrimitive_1.PathPrimitiveLineToCommand(right - dx / 2, bottom),
new PathPrimitive_1.PathPrimitiveArcToCommand(dx / 2, (bottom - top) / 2, 0, false, false, right - dx / 2, top)
], shape.style),
];
};
DisplayShapeDescription.arcWidthRatio = 0.2;
return DisplayShapeDescription;
}(RectangleShapeDescription_1.RectangleShapeDescription));
exports.DisplayShapeDescription = DisplayShapeDescription;
/***/ }),
/* 182 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeTypes_1 = __webpack_require__(1);
var Utils_1 = __webpack_require__(0);
var ShapeDescription_1 = __webpack_require__(9);
var EllipseShapeDescription_1 = __webpack_require__(67);
var PathPrimitive_1 = __webpack_require__(2);
var OrShapeDescription = /** @class */ (function (_super) {
__extends(OrShapeDescription, _super);
function OrShapeDescription() {
var _this = _super.call(this, "Or", "") || this;
_this.defaultSize = new Utils_1.Size(ShapeDescription_1.ShapeDefaultDimension * 0.5, ShapeDescription_1.ShapeDefaultDimension * 0.5);
return _this;
}
Object.defineProperty(OrShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.Or; },
enumerable: true,
configurable: true
});
Object.defineProperty(OrShapeDescription.prototype, "enableText", {
get: function () { return false; },
enumerable: true,
configurable: true
});
OrShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom;
var _a = rect.center, cx = _a.x, cy = _a.y;
var primitives = [];
return primitives
.concat(_super.prototype.createShapePrimitives.call(this, shape))
.concat([
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(cx, top),
new PathPrimitive_1.PathPrimitiveLineToCommand(cx, bottom),
new PathPrimitive_1.PathPrimitiveMoveToCommand(left, cy),
new PathPrimitive_1.PathPrimitiveLineToCommand(right, cy)
], shape.style)
]);
};
return OrShapeDescription;
}(EllipseShapeDescription_1.EllipseShapeDescription));
exports.OrShapeDescription = OrShapeDescription;
/***/ }),
/* 183 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeTypes_1 = __webpack_require__(1);
var Utils_1 = __webpack_require__(0);
var ShapeDescription_1 = __webpack_require__(9);
var EllipseShapeDescription_1 = __webpack_require__(67);
var PathPrimitive_1 = __webpack_require__(2);
var SummingJunctionShapeDescription = /** @class */ (function (_super) {
__extends(SummingJunctionShapeDescription, _super);
function SummingJunctionShapeDescription() {
var _this = _super.call(this, "Summing Junction", "") || this;
_this.defaultSize = new Utils_1.Size(ShapeDescription_1.ShapeDefaultDimension * 0.5, ShapeDescription_1.ShapeDefaultDimension * 0.5);
return _this;
}
Object.defineProperty(SummingJunctionShapeDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.SummingJunction; },
enumerable: true,
configurable: true
});
Object.defineProperty(SummingJunctionShapeDescription.prototype, "enableText", {
get: function () { return false; },
enumerable: true,
configurable: true
});
SummingJunctionShapeDescription.prototype.createShapePrimitives = function (shape) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, right = rect.right, bottom = rect.bottom, width = rect.width, height = rect.height;
var _a = rect.center, cx = _a.x, cy = _a.y;
var rx = width / 2;
var ry = height / 2;
var angle = Math.atan(ry / rx);
var ex = 1 / Math.sqrt(1 / Math.pow(rx, 2) + Math.pow(Math.tan(angle), 2) / Math.pow(ry, 2));
var ey = ex * Math.tan(angle);
var primitives = [];
return primitives
.concat(_super.prototype.createShapePrimitives.call(this, shape))
.concat([
new PathPrimitive_1.PathPrimitive([
new PathPrimitive_1.PathPrimitiveMoveToCommand(cx - ex, cy - ey),
new PathPrimitive_1.PathPrimitiveLineToCommand(cx + ex, cy + ey),
new PathPrimitive_1.PathPrimitiveMoveToCommand(cx - ex, cy + ey),
new PathPrimitive_1.PathPrimitiveLineToCommand(cx + ex, cy - ey)
], shape.style)
]);
};
return SummingJunctionShapeDescription;
}(EllipseShapeDescription_1.EllipseShapeDescription));
exports.SummingJunctionShapeDescription = SummingJunctionShapeDescription;
/***/ }),
/* 184 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ImagePrimitive_1 = __webpack_require__(98);
var Utils_1 = __webpack_require__(0);
var ConnectionPoint_1 = __webpack_require__(34);
var DiagramItem_1 = __webpack_require__(4);
var ShapeWithImageDescription_1 = __webpack_require__(45);
var ImageInfo_1 = __webpack_require__(40);
var ImageCache_1 = __webpack_require__(49);
var ImageLoader_1 = __webpack_require__(100);
var CustomShapeDescription = /** @class */ (function (_super) {
__extends(CustomShapeDescription, _super);
function CustomShapeDescription(properties, baseDescription) {
var _this = _super.call(this, properties.title || baseDescription && baseDescription.title, properties.defaultText || baseDescription && baseDescription.defaultText, new Utils_1.Size(properties.defaultWidth || baseDescription && baseDescription.defaultSize.width || 1440, properties.defaultHeight || baseDescription && baseDescription.defaultSize.height || 1440), properties.defaultImageUrl || baseDescription && baseDescription.defaultImageUrl) || this;
_this.properties = properties;
_this.baseDescription = baseDescription;
_this.imageLoader = new ImageLoader_1.ImageLoader(_this.updateSvgImage.bind(_this));
_this.connectionPoints = _this.createConnectionPoints();
_this.svgImage = new ImageInfo_1.ImageInfo(properties.svgUrl);
var cachedImage = ImageCache_1.ImageCache.instance.createUnloadedInfoByShapeImageInfo(_this.svgImage);
_this.imageLoader.load(cachedImage);
return _this;
}
Object.defineProperty(CustomShapeDescription.prototype, "key", {
get: function () { return this.properties.type; },
enumerable: true,
configurable: true
});
Object.defineProperty(CustomShapeDescription.prototype, "allowEditText", {
get: function () { return !!this.properties.allowEditText; },
enumerable: true,
configurable: true
});
Object.defineProperty(CustomShapeDescription.prototype, "allowEditImage", {
get: function () { return !!this.properties.allowEditImage; },
enumerable: true,
configurable: true
});
CustomShapeDescription.prototype.createConnectionPoints = function () {
if (this.properties && this.properties.connectionPoints && this.properties.connectionPoints.length)
return this.properties.connectionPoints.map(function (ptObj) {
if (ptObj && typeof ptObj["x"] === "number" && typeof ptObj["y"] === "number") {
var side = typeof ptObj["side"] === "number" ? ptObj["side"] : DiagramItem_1.ConnectionPointSide.Undefined;
return new ConnectionPoint_1.ConnectionPoint(ptObj["x"], ptObj["y"], side);
}
}).filter(function (pt) { return pt; });
return _super.prototype.createConnectionPoints.call(this);
};
CustomShapeDescription.prototype.createImagePrimitives = function (shape, forToolbox) {
if (this.baseDescription)
return this.baseDescription.createImagePrimitives(shape, forToolbox);
return _super.prototype.createImagePrimitives.call(this, shape, forToolbox);
};
CustomShapeDescription.prototype.createShapePrimitives = function (shape, forToolbox) {
if (this.baseDescription)
return this.baseDescription.createShapePrimitives(shape, forToolbox);
else {
var _a = shape.rectangle, left = _a.left, top_1 = _a.top, width = _a.width, height = _a.height;
return [
new ImagePrimitive_1.ImagePrimitive(left + (this.properties.svgLeft && !forToolbox ? this.properties.svgLeft * width : 0), top_1 + (this.properties.svgTop && !forToolbox ? this.properties.svgTop * height : 0), this.properties.svgWidth && !forToolbox ? this.properties.svgWidth * width : width, this.properties.svgHeight && !forToolbox ? this.properties.svgHeight * height : height, this.svgImage.exportUrl)
];
}
};
CustomShapeDescription.prototype.createParameters = function (parameters) {
if (this.baseDescription)
return this.baseDescription.createParameters(parameters);
else
return _super.prototype.createParameters.call(this, parameters);
};
CustomShapeDescription.prototype.normalizeParameters = function (shape, parameters) {
if (this.baseDescription)
this.baseDescription.normalizeParameters(shape, parameters);
else
_super.prototype.normalizeParameters.call(this, shape, parameters);
};
CustomShapeDescription.prototype.modifyParameters = function (shape, parameters, deltaX, deltaY) {
if (this.baseDescription)
this.baseDescription.modifyParameters(shape, parameters, deltaX, deltaY);
else
_super.prototype.modifyParameters.call(this, shape, parameters, deltaX, deltaY);
};
CustomShapeDescription.prototype.getParameterPoints = function (shape) {
if (this.baseDescription)
return this.baseDescription.getParameterPoints(shape);
else
return _super.prototype.getParameterPoints.call(this, shape);
};
CustomShapeDescription.prototype.getTextRectangle = function (rect, parameters) {
var left = rect.left, top = rect.top, width = rect.width, height = rect.height;
return Utils_1.Rectangle.create(left + (this.properties.textLeft ? this.properties.textLeft * width : 0), top + (this.properties.textTop ? this.properties.textTop * height : 0), this.properties.textWidth ? this.properties.textWidth * width : width, this.properties.textHeight ? this.properties.textHeight * height : height);
};
CustomShapeDescription.prototype.getRawImageSize = function (rect) {
var left = rect.left, top = rect.top, width = rect.width, height = rect.height;
return new Utils_1.Size(this.properties.imageWidth ? this.properties.imageWidth * width : width, this.properties.imageHeight ? this.properties.imageHeight * height : height);
};
CustomShapeDescription.prototype.getImagePlacementRectangle = function (rect, forToolbox) {
var left = rect.left, top = rect.top, width = rect.width, height = rect.height;
return Utils_1.Rectangle.create(left + (this.properties.imageLeft && !forToolbox ? this.properties.imageLeft * width : 0), top + (this.properties.imageTop && !forToolbox ? this.properties.imageTop * height : 0), this.properties.imageWidth && !forToolbox ? this.properties.imageWidth * width : 0, this.properties.imageHeight && !forToolbox ? this.properties.imageHeight * height : 0);
};
CustomShapeDescription.prototype.updateSvgImage = function (cacheImageInfo) {
if (cacheImageInfo.base64)
this.svgImage.loadBase64Content(cacheImageInfo.base64);
else
this.svgImage.setUnableToLoadFlag();
};
return CustomShapeDescription;
}(ShapeWithImageDescription_1.ShapeWithImageDescription));
exports.CustomShapeDescription = CustomShapeDescription;
/***/ }),
/* 185 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeDescription_1 = __webpack_require__(9);
var Utils_1 = __webpack_require__(0);
var ShapeTypes_1 = __webpack_require__(1);
var ContainerDescription_1 = __webpack_require__(101);
var RectaglePrimitive_1 = __webpack_require__(20);
var VerticalContainerDescription = /** @class */ (function (_super) {
__extends(VerticalContainerDescription, _super);
function VerticalContainerDescription(title, defaultText, defaultSize) {
if (title === void 0) { title = "Vertical Container"; }
if (defaultText === void 0) { defaultText = "Container"; }
if (defaultSize === void 0) { defaultSize = new Utils_1.Size(ShapeDescription_1.ShapeDefaultDimension * 2, ShapeDescription_1.ShapeDefaultDimension * 1.5); }
return _super.call(this, title, defaultText, defaultSize) || this;
}
Object.defineProperty(VerticalContainerDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.VerticalContainer; },
enumerable: true,
configurable: true
});
VerticalContainerDescription.prototype.getExpandedSize = function (size, expandedSize) {
return new Utils_1.Size(size.width, expandedSize.height);
};
VerticalContainerDescription.prototype.getCollapsedSize = function (size) {
return new Utils_1.Size(size.width, ContainerDescription_1.ContainerDescription.headerSize);
};
VerticalContainerDescription.prototype.allowResizeVertically = function (shape) {
return shape.expanded;
};
VerticalContainerDescription.prototype.createHeaderPrimitives = function (shape, forToolbox) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, width = rect.width;
var headerSize = this.getHeaderSize(rect, forToolbox);
var primitives = [];
primitives = primitives.concat([
new RectaglePrimitive_1.RectanglePrimitive(left, top, width, headerSize, shape.style)
]);
if (!forToolbox) {
primitives = primitives.concat(this.createExpandButtonPrimitives(shape, Utils_1.Rectangle.create(left, top, headerSize, headerSize)));
}
return primitives;
};
VerticalContainerDescription.prototype.getClientRectangle = function (rect) {
var headerSize = this.getHeaderSize(rect);
return new Utils_1.Rectangle(new Utils_1.Point(rect.left, rect.top + headerSize), new Utils_1.Size(rect.width, rect.height - headerSize));
};
VerticalContainerDescription.prototype.getTextRectangle = function (rect, parameters) {
var headerSize = this.getHeaderSize(rect);
return new Utils_1.Rectangle(new Utils_1.Point(rect.left + headerSize, rect.top), new Utils_1.Size(rect.width - headerSize, headerSize));
};
VerticalContainerDescription.prototype.getHeaderSize = function (rect, forToolbox) {
return forToolbox ? rect.height * ContainerDescription_1.ContainerDescription.headerToolboxSizeRatio : ContainerDescription_1.ContainerDescription.headerSize;
};
return VerticalContainerDescription;
}(ContainerDescription_1.ContainerDescription));
exports.VerticalContainerDescription = VerticalContainerDescription;
/***/ }),
/* 186 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeDescription_1 = __webpack_require__(9);
var Utils_1 = __webpack_require__(0);
var ShapeTypes_1 = __webpack_require__(1);
var ContainerDescription_1 = __webpack_require__(101);
var RectaglePrimitive_1 = __webpack_require__(20);
var HorizontalContainerDescription = /** @class */ (function (_super) {
__extends(HorizontalContainerDescription, _super);
function HorizontalContainerDescription(title, defaultText, defaultSize) {
if (title === void 0) { title = "Horizontal Container"; }
if (defaultText === void 0) { defaultText = "Container"; }
if (defaultSize === void 0) { defaultSize = new Utils_1.Size(ShapeDescription_1.ShapeDefaultDimension * 2, ShapeDescription_1.ShapeDefaultDimension * 1.5); }
return _super.call(this, title, defaultText, defaultSize) || this;
}
Object.defineProperty(HorizontalContainerDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.HorizontalContainer; },
enumerable: true,
configurable: true
});
HorizontalContainerDescription.prototype.getExpandedSize = function (size, expandedSize) {
return new Utils_1.Size(expandedSize.width, size.height);
};
HorizontalContainerDescription.prototype.getCollapsedSize = function (size) {
return new Utils_1.Size(ContainerDescription_1.ContainerDescription.headerSize, size.height);
};
HorizontalContainerDescription.prototype.allowResizeHorizontally = function (shape) {
return shape.expanded;
};
HorizontalContainerDescription.prototype.createHeaderPrimitives = function (shape, forToolbox) {
var rect = shape.rectangle;
var left = rect.left, top = rect.top, height = rect.height;
var headerSize = this.getHeaderSize(rect, forToolbox);
var primitives = [];
primitives = primitives.concat([
new RectaglePrimitive_1.RectanglePrimitive(left, top, headerSize, height, shape.style)
]);
if (!forToolbox) {
primitives = primitives.concat(this.createExpandButtonPrimitives(shape, Utils_1.Rectangle.create(left, top, headerSize, headerSize)));
}
return primitives;
};
HorizontalContainerDescription.prototype.getClientRectangle = function (rect) {
var headerSize = this.getHeaderSize(rect);
return new Utils_1.Rectangle(new Utils_1.Point(rect.left + headerSize, rect.top), new Utils_1.Size(rect.width - headerSize, rect.height));
};
HorizontalContainerDescription.prototype.getTextRectangle = function (rect, parameters) {
var headerSize = this.getHeaderSize(rect);
return new Utils_1.Rectangle(new Utils_1.Point(rect.left, rect.top + headerSize), new Utils_1.Size(headerSize, rect.height - headerSize));
};
HorizontalContainerDescription.prototype.getTextEditRectangle = function (rect) {
return new Utils_1.Rectangle(rect.position, new Utils_1.Size(rect.width, this.getHeaderSize(rect)));
};
HorizontalContainerDescription.prototype.getTextRotated = function () {
return true;
};
HorizontalContainerDescription.prototype.getHeaderSize = function (rect, forToolbox) {
return forToolbox ? rect.height * ContainerDescription_1.ContainerDescription.headerToolboxSizeRatio : ContainerDescription_1.ContainerDescription.headerSize;
};
return HorizontalContainerDescription;
}(ContainerDescription_1.ContainerDescription));
exports.HorizontalContainerDescription = HorizontalContainerDescription;
/***/ }),
/* 187 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeDescription_1 = __webpack_require__(9);
var Utils_1 = __webpack_require__(0);
var ShapeTypes_1 = __webpack_require__(1);
var CardBaseDescription_1 = __webpack_require__(69);
var ShapeWithImageDescription_1 = __webpack_require__(45);
var CardWithImageOnLeftDescription = /** @class */ (function (_super) {
__extends(CardWithImageOnLeftDescription, _super);
function CardWithImageOnLeftDescription(title, defaultText, defaultSize) {
if (title === void 0) { title = "Card with Image on the Left"; }
if (defaultText === void 0) { defaultText = ""; }
if (defaultSize === void 0) { defaultSize = new Utils_1.Size(1.5 * ShapeDescription_1.ShapeDefaultDimension, 0.5 * ShapeDescription_1.ShapeDefaultDimension); }
return _super.call(this, title, defaultText, defaultSize) || this;
}
Object.defineProperty(CardWithImageOnLeftDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.CardWithImageOnLeft; },
enumerable: true,
configurable: true
});
CardWithImageOnLeftDescription.prototype.getToolboxHeightToWidthRatio = function (width, height) {
return 26 / 46;
};
CardWithImageOnLeftDescription.prototype.getRawImageSize = function (rect, forToolbox) {
var imageSize = Math.min(rect.height, rect.width) - 2 * ShapeWithImageDescription_1.ShapeWithImageDescription.getImageMargins(forToolbox);
return new Utils_1.Size(imageSize, imageSize);
};
CardWithImageOnLeftDescription.prototype.getTextBlockOffset = function (rect, forToolbox) {
return new Utils_1.Offset(this.getImageSize(rect, forToolbox).width, 0, 0, 0);
};
return CardWithImageOnLeftDescription;
}(CardBaseDescription_1.CardBaseDescription));
exports.CardWithImageOnLeftDescription = CardWithImageOnLeftDescription;
/***/ }),
/* 188 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var RenderManager_1 = __webpack_require__(12);
var RectaglePrimitive_1 = __webpack_require__(20);
var RoundedRectanglePrimitive = /** @class */ (function (_super) {
__extends(RoundedRectanglePrimitive, _super);
function RoundedRectanglePrimitive(x, y, width, height, rx, ry, style, className, clipPathId, onApplyProperties) {
if (rx === void 0) { rx = 0; }
if (ry === void 0) { ry = 0; }
var _this = _super.call(this, x, y, width, height, style, className, clipPathId, onApplyProperties) || this;
_this.x = x;
_this.y = y;
_this.width = width;
_this.height = height;
_this.rx = rx;
_this.ry = ry;
return _this;
}
RoundedRectanglePrimitive.prototype.createMainElement = function () {
return document.createElementNS(RenderManager_1.svgNS, "rect");
};
RoundedRectanglePrimitive.prototype.applyElementProperties = function (element) {
this.setUnitAttribute(element, "rx", this.rx);
this.setUnitAttribute(element, "ry", this.ry);
_super.prototype.applyElementProperties.call(this, element);
};
return RoundedRectanglePrimitive;
}(RectaglePrimitive_1.RectanglePrimitive));
exports.RoundedRectanglePrimitive = RoundedRectanglePrimitive;
/***/ }),
/* 189 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeDescription_1 = __webpack_require__(9);
var Utils_1 = __webpack_require__(0);
var ShapeTypes_1 = __webpack_require__(1);
var CardBaseDescription_1 = __webpack_require__(69);
var ShapeWithImageDescription_1 = __webpack_require__(45);
var CardWithImageOnRightDescription = /** @class */ (function (_super) {
__extends(CardWithImageOnRightDescription, _super);
function CardWithImageOnRightDescription(title, defaultText, defaultSize) {
if (title === void 0) { title = "Card with Image on the Right"; }
if (defaultText === void 0) { defaultText = ""; }
if (defaultSize === void 0) { defaultSize = new Utils_1.Size(1.5 * ShapeDescription_1.ShapeDefaultDimension, 0.5 * ShapeDescription_1.ShapeDefaultDimension); }
return _super.call(this, title, defaultText, defaultSize) || this;
}
Object.defineProperty(CardWithImageOnRightDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.CardWithImageOnRight; },
enumerable: true,
configurable: true
});
CardWithImageOnRightDescription.prototype.getToolboxHeightToWidthRatio = function (width, height) {
return 26 / 46;
};
CardWithImageOnRightDescription.prototype.getRawImageSize = function (rect, forToolbox) {
var imageSize = Math.min(rect.height, rect.width) - 2 * ShapeWithImageDescription_1.ShapeWithImageDescription.getImageMargins(forToolbox);
return new Utils_1.Size(imageSize, imageSize);
};
CardWithImageOnRightDescription.prototype.getTextBlockOffset = function (rect, forToolbox) {
return new Utils_1.Offset(0, 0, this.getImageSize(rect, forToolbox).width, 0);
};
return CardWithImageOnRightDescription;
}(CardBaseDescription_1.CardBaseDescription));
exports.CardWithImageOnRightDescription = CardWithImageOnRightDescription;
/***/ }),
/* 190 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeDescription_1 = __webpack_require__(9);
var Utils_1 = __webpack_require__(0);
var ShapeTypes_1 = __webpack_require__(1);
var CardBaseDescription_1 = __webpack_require__(69);
var ShapeWithImageDescription_1 = __webpack_require__(45);
var CardWithImageOnTopDescription = /** @class */ (function (_super) {
__extends(CardWithImageOnTopDescription, _super);
function CardWithImageOnTopDescription(title, defaultText, defaultSize) {
if (title === void 0) { title = "Card with Image on the Top"; }
if (defaultText === void 0) { defaultText = ""; }
if (defaultSize === void 0) { defaultSize = new Utils_1.Size(32 / 40 * ShapeDescription_1.ShapeDefaultDimension, ShapeDescription_1.ShapeDefaultDimension); }
return _super.call(this, title, defaultText, defaultSize) || this;
}
Object.defineProperty(CardWithImageOnTopDescription.prototype, "key", {
get: function () { return ShapeTypes_1.ShapeTypes.CardWithImageOnTop; },
enumerable: true,
configurable: true
});
CardWithImageOnTopDescription.prototype.getRawImageSize = function (rect, forToolbox) {
var imageSize = Math.min(rect.width / 2 + 1, rect.height - ShapeWithImageDescription_1.ShapeWithImageDescription.getImageMargins(forToolbox) * 2);
return new Utils_1.Size(imageSize, imageSize);
};
CardWithImageOnTopDescription.prototype.getTextBlockOffset = function (rect, forToolbox) {
return new Utils_1.Offset(0, this.getImageSize(rect).height + ShapeWithImageDescription_1.ShapeWithImageDescription.getImageMargins(forToolbox), 0, 0);
};
return CardWithImageOnTopDescription;
}(CardBaseDescription_1.CardBaseDescription));
exports.CardWithImageOnTopDescription = CardWithImageOnTopDescription;
/***/ }),
/* 191 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var InsertToContainerHistoryItem = /** @class */ (function (_super) {
__extends(InsertToContainerHistoryItem, _super);
function InsertToContainerHistoryItem(item, container) {
var _this = _super.call(this) || this;
_this.containerKey = container.key;
_this.itemKey = item.key;
return _this;
}
InsertToContainerHistoryItem.prototype.redo = function (manipulator) {
var item = manipulator.model.findItem(this.itemKey);
var container = manipulator.model.findShape(this.containerKey);
manipulator.insertToContainer(item, container);
};
InsertToContainerHistoryItem.prototype.undo = function (manipulator) {
var item = manipulator.model.findItem(this.itemKey);
manipulator.removeFromContainer(item);
};
return InsertToContainerHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.InsertToContainerHistoryItem = InsertToContainerHistoryItem;
/***/ }),
/* 192 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var RemoveFromContainerHistoryItem = /** @class */ (function (_super) {
__extends(RemoveFromContainerHistoryItem, _super);
function RemoveFromContainerHistoryItem(item) {
var _this = _super.call(this) || this;
_this.itemKey = item.key;
return _this;
}
RemoveFromContainerHistoryItem.prototype.redo = function (manipulator) {
var item = manipulator.model.findItem(this.itemKey);
this.containerKey = item.container && item.container.key;
manipulator.removeFromContainer(item);
};
RemoveFromContainerHistoryItem.prototype.undo = function (manipulator) {
var container = manipulator.model.findContainer(this.containerKey);
var item = manipulator.model.findItem(this.itemKey);
manipulator.insertToContainer(item, container);
};
return RemoveFromContainerHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.RemoveFromContainerHistoryItem = RemoveFromContainerHistoryItem;
/***/ }),
/* 193 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var ChangeContainerLockedHistoryItem = /** @class */ (function (_super) {
__extends(ChangeContainerLockedHistoryItem, _super);
function ChangeContainerLockedHistoryItem(item, locked) {
var _this = _super.call(this) || this;
_this.itemKey = item.key;
_this.containerLocked = locked;
return _this;
}
ChangeContainerLockedHistoryItem.prototype.redo = function (manipulator) {
var item = manipulator.model.findItem(this.itemKey);
this.oldContainerLocked = item.containerLocked;
manipulator.changeContainerLocked(item, this.containerLocked);
};
ChangeContainerLockedHistoryItem.prototype.undo = function (manipulator) {
var item = manipulator.model.findItem(this.itemKey);
manipulator.changeContainerLocked(item, this.oldContainerLocked);
};
return ChangeContainerLockedHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.ChangeContainerLockedHistoryItem = ChangeContainerLockedHistoryItem;
/***/ }),
/* 194 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var LayoutUtils_1 = __webpack_require__(195);
var GraphInfo = /** @class */ (function () {
function GraphInfo(container, sourceGraph) {
this.container = container;
this.sourceGraph = sourceGraph;
}
Object.defineProperty(GraphInfo.prototype, "graph", {
get: function () {
return this._graph || (this._graph = this.getNodeInfoGraph());
},
enumerable: true,
configurable: true
});
GraphInfo.prototype.getNodeInfoGraph = function () {
return this.sourceGraph.cast(LayoutUtils_1.LayoutUtils.shapeToLayout);
};
return GraphInfo;
}());
exports.GraphInfo = GraphInfo;
/***/ }),
/* 195 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Connector_1 = __webpack_require__(5);
var NodeLayout_1 = __webpack_require__(56);
var LayoutUtils = /** @class */ (function () {
function LayoutUtils() {
}
LayoutUtils.shapeToLayout = function (shape) {
var margin = new NodeLayout_1.Margin(0);
var shapeRect = shape.rectangle;
shape.attachedConnectors.filter(function (c) { return !c.beginItem || !c.endItem; }).forEach(function (c) {
var connRect = c.rectangle;
margin.left = Math.max(margin.left, shapeRect.left - connRect.left + Connector_1.Connector.minOffset);
margin.right = Math.max(margin.right, connRect.right - shapeRect.right + Connector_1.Connector.minOffset);
margin.top = Math.max(margin.top, shapeRect.top - connRect.top + Connector_1.Connector.minOffset);
margin.bottom = Math.max(margin.bottom, connRect.bottom - shapeRect.bottom + Connector_1.Connector.minOffset);
});
var layout = new NodeLayout_1.NodeInfo(shape.key, margin, shape.size.clone());
layout.connectionPoints = shape.description.getConnectionPoints();
return layout;
};
return LayoutUtils;
}());
exports.LayoutUtils = LayoutUtils;
/***/ }),
/* 196 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var CommandBase = /** @class */ (function () {
function CommandBase(control) {
this.control = control;
}
CommandBase.prototype.execute = function (parameter) {
var state = this.getState();
if (!state.enabled)
return false;
this.control.beginUpdate();
var executed = this.executeCore(state, parameter);
this.control.endUpdate();
return executed;
};
CommandBase.prototype.updateControlState = function () {
if (!this.lockUIUpdating()) {
this.control.barManager.updateItemsState();
}
};
CommandBase.prototype.lockUIUpdating = function () {
return false;
};
return CommandBase;
}());
exports.CommandBase = CommandBase;
/***/ }),
/* 197 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var SimpleCommandState = /** @class */ (function () {
function SimpleCommandState(enabled, value, defaultValue, items, visible) {
this.visible = true;
this.denyUpdateValue = false;
this.enabled = enabled;
this.value = value;
this.items = items;
this.visible = visible;
this.defaultValue = defaultValue;
}
return SimpleCommandState;
}());
exports.SimpleCommandState = SimpleCommandState;
/***/ }),
/* 198 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var SimpleCommandBase_1 = __webpack_require__(7);
var UndoCommand = /** @class */ (function (_super) {
__extends(UndoCommand, _super);
function UndoCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
UndoCommand.prototype.executeCore = function (state) {
this.control.beginUpdate(true);
this.control.history.undo();
this.control.endUpdate(true);
return true;
};
UndoCommand.prototype.isEnabled = function () {
return _super.prototype.isEnabled.call(this) && this.control.history.canUndo();
};
return UndoCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.UndoCommand = UndoCommand;
/***/ }),
/* 199 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var SimpleCommandBase_1 = __webpack_require__(7);
var RedoCommand = /** @class */ (function (_super) {
__extends(RedoCommand, _super);
function RedoCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
RedoCommand.prototype.executeCore = function (state) {
this.control.beginUpdate(true);
this.control.history.redo();
this.control.endUpdate(true);
return true;
};
RedoCommand.prototype.isEnabled = function () {
return _super.prototype.isEnabled.call(this) && this.control.history.canRedo();
};
return RedoCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.RedoCommand = RedoCommand;
/***/ }),
/* 200 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Importer_1 = __webpack_require__(105);
var ExportImportCommandBase_1 = __webpack_require__(47);
var ImportCommand = /** @class */ (function (_super) {
__extends(ImportCommand, _super);
function ImportCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ImportCommand.prototype.executeCore = function (state, parameter) {
var data = parameter["data"] ? parameter["data"] : parameter;
var importer = new Importer_1.Importer(data);
if (parameter["keepExistingItems"] === true) {
importer.importItemsData(this.control.model);
this.control.importItemsData();
}
else {
var model = importer.import();
this.control.importModel(model);
}
return true;
};
return ImportCommand;
}(ExportImportCommandBase_1.ExportImportCommandBase));
exports.ImportCommand = ImportCommand;
/***/ }),
/* 201 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Exporter_1 = __webpack_require__(57);
var ExportImportCommandBase_1 = __webpack_require__(47);
var ExportCommand = /** @class */ (function (_super) {
__extends(ExportCommand, _super);
function ExportCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ExportCommand.prototype.executeCore = function (state, parameter) {
var exporter = new Exporter_1.Exporter();
var data = exporter.export(this.control.model);
parameter(data);
return true;
};
return ExportCommand;
}(ExportImportCommandBase_1.ExportImportCommandBase));
exports.ExportCommand = ExportCommand;
/***/ }),
/* 202 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ToggleStyleTextPropertyCommand_1 = __webpack_require__(58);
var ToggleFontBoldCommand = /** @class */ (function (_super) {
__extends(ToggleFontBoldCommand, _super);
function ToggleFontBoldCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ToggleFontBoldCommand.prototype.getStyleProperty = function () {
return "font-weight";
};
ToggleFontBoldCommand.prototype.getStylePropertyValue = function () {
return "bold";
};
return ToggleFontBoldCommand;
}(ToggleStyleTextPropertyCommand_1.ToggleStyleTextPropertyCommand));
exports.ToggleFontBoldCommand = ToggleFontBoldCommand;
/***/ }),
/* 203 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ToggleStyleTextPropertyCommand_1 = __webpack_require__(58);
var ToggleFontItalicCommand = /** @class */ (function (_super) {
__extends(ToggleFontItalicCommand, _super);
function ToggleFontItalicCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ToggleFontItalicCommand.prototype.getStyleProperty = function () {
return "font-style";
};
ToggleFontItalicCommand.prototype.getStylePropertyValue = function () {
return "italic";
};
return ToggleFontItalicCommand;
}(ToggleStyleTextPropertyCommand_1.ToggleStyleTextPropertyCommand));
exports.ToggleFontItalicCommand = ToggleFontItalicCommand;
/***/ }),
/* 204 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ToggleStyleTextPropertyCommand_1 = __webpack_require__(58);
var ToggleFontUnderlineCommand = /** @class */ (function (_super) {
__extends(ToggleFontUnderlineCommand, _super);
function ToggleFontUnderlineCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ToggleFontUnderlineCommand.prototype.getStyleProperty = function () {
return "text-decoration";
};
ToggleFontUnderlineCommand.prototype.getStylePropertyValue = function () {
return "underline";
};
return ToggleFontUnderlineCommand;
}(ToggleStyleTextPropertyCommand_1.ToggleStyleTextPropertyCommand));
exports.ToggleFontUnderlineCommand = ToggleFontUnderlineCommand;
/***/ }),
/* 205 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangeStyleTextPropertyCommand_1 = __webpack_require__(72);
var ChangeFontNameCommand = /** @class */ (function (_super) {
__extends(ChangeFontNameCommand, _super);
function ChangeFontNameCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeFontNameCommand.prototype.getStyleProperty = function () {
return "font-family";
};
return ChangeFontNameCommand;
}(ChangeStyleTextPropertyCommand_1.ChangeStyleTextPropertyCommand));
exports.ChangeFontNameCommand = ChangeFontNameCommand;
/***/ }),
/* 206 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangeStyleTextPropertyCommand_1 = __webpack_require__(72);
var ChangeFontSizeCommand = /** @class */ (function (_super) {
__extends(ChangeFontSizeCommand, _super);
function ChangeFontSizeCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeFontSizeCommand.prototype.getStyleProperty = function () {
return "font-size";
};
return ChangeFontSizeCommand;
}(ChangeStyleTextPropertyCommand_1.ChangeStyleTextPropertyCommand));
exports.ChangeFontSizeCommand = ChangeFontSizeCommand;
/***/ }),
/* 207 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangeStyleTextPropertyCommand_1 = __webpack_require__(72);
var __1 = __webpack_require__(8);
var ChangeFontColorCommand = /** @class */ (function (_super) {
__extends(ChangeFontColorCommand, _super);
function ChangeFontColorCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeFontColorCommand.prototype.processParameter = function (parameter) {
return __1.ColorHelper.stringToHash(parameter);
};
ChangeFontColorCommand.prototype.getStyleProperty = function () {
return "fill";
};
return ChangeFontColorCommand;
}(ChangeStyleTextPropertyCommand_1.ChangeStyleTextPropertyCommand));
exports.ChangeFontColorCommand = ChangeFontColorCommand;
/***/ }),
/* 208 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangeStylePropertyCommand_1 = __webpack_require__(109);
var __1 = __webpack_require__(8);
var ChangeFillColorCommand = /** @class */ (function (_super) {
__extends(ChangeFillColorCommand, _super);
function ChangeFillColorCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeFillColorCommand.prototype.processParameter = function (parameter) {
return __1.ColorHelper.stringToHash(parameter);
};
ChangeFillColorCommand.prototype.getStyleProperty = function () {
return "fill";
};
return ChangeFillColorCommand;
}(ChangeStylePropertyCommand_1.ChangeStylePropertyCommand));
exports.ChangeFillColorCommand = ChangeFillColorCommand;
/***/ }),
/* 209 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangeStylePropertyCommand_1 = __webpack_require__(109);
var __1 = __webpack_require__(8);
var ChangeStrokeColorCommand = /** @class */ (function (_super) {
__extends(ChangeStrokeColorCommand, _super);
function ChangeStrokeColorCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeStrokeColorCommand.prototype.processParameter = function (parameter) {
return __1.ColorHelper.stringToHash(parameter);
};
ChangeStrokeColorCommand.prototype.getStyleProperty = function () {
return "stroke";
};
return ChangeStrokeColorCommand;
}(ChangeStylePropertyCommand_1.ChangeStylePropertyCommand));
exports.ChangeStrokeColorCommand = ChangeStrokeColorCommand;
/***/ }),
/* 210 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ToggleStyleTextPropertyCommand_1 = __webpack_require__(58);
var ChangeTextAlignCommand = /** @class */ (function (_super) {
__extends(ChangeTextAlignCommand, _super);
function ChangeTextAlignCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeTextAlignCommand.prototype.getStyleProperty = function () {
return "text-anchor";
};
return ChangeTextAlignCommand;
}(ToggleStyleTextPropertyCommand_1.ToggleStyleTextPropertyCommand));
exports.ChangeTextAlignCommand = ChangeTextAlignCommand;
var TextLeftAlignCommand = /** @class */ (function (_super) {
__extends(TextLeftAlignCommand, _super);
function TextLeftAlignCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
TextLeftAlignCommand.prototype.getStylePropertyValue = function () {
return "start";
};
return TextLeftAlignCommand;
}(ChangeTextAlignCommand));
exports.TextLeftAlignCommand = TextLeftAlignCommand;
var TextCenterAlignCommand = /** @class */ (function (_super) {
__extends(TextCenterAlignCommand, _super);
function TextCenterAlignCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
TextCenterAlignCommand.prototype.getStylePropertyValue = function () {
return "middle";
};
return TextCenterAlignCommand;
}(ChangeTextAlignCommand));
exports.TextCenterAlignCommand = TextCenterAlignCommand;
var TextRightAlignCommand = /** @class */ (function (_super) {
__extends(TextRightAlignCommand, _super);
function TextRightAlignCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
TextRightAlignCommand.prototype.getStylePropertyValue = function () {
return "end";
};
return TextRightAlignCommand;
}(ChangeTextAlignCommand));
exports.TextRightAlignCommand = TextRightAlignCommand;
/***/ }),
/* 211 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangeConnectorPropertyCommand_1 = __webpack_require__(110);
var ConnectorProperties_1 = __webpack_require__(24);
var ChangeConnectorStartLineEndingCommand = /** @class */ (function (_super) {
__extends(ChangeConnectorStartLineEndingCommand, _super);
function ChangeConnectorStartLineEndingCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeConnectorStartLineEndingCommand.prototype.getPropertyName = function () {
return "startLineEnding";
};
ChangeConnectorStartLineEndingCommand.prototype.getPropertyDefaultValue = function () {
return ConnectorProperties_1.ConnectorLineEnding.None;
};
return ChangeConnectorStartLineEndingCommand;
}(ChangeConnectorPropertyCommand_1.ChangeConnectorPropertyCommand));
exports.ChangeConnectorStartLineEndingCommand = ChangeConnectorStartLineEndingCommand;
var ChangeConnectorEndLineEndingCommand = /** @class */ (function (_super) {
__extends(ChangeConnectorEndLineEndingCommand, _super);
function ChangeConnectorEndLineEndingCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeConnectorEndLineEndingCommand.prototype.getPropertyName = function () {
return "endLineEnding";
};
ChangeConnectorEndLineEndingCommand.prototype.getPropertyDefaultValue = function () {
return ConnectorProperties_1.ConnectorLineEnding.Arrow;
};
return ChangeConnectorEndLineEndingCommand;
}(ChangeConnectorPropertyCommand_1.ChangeConnectorPropertyCommand));
exports.ChangeConnectorEndLineEndingCommand = ChangeConnectorEndLineEndingCommand;
/***/ }),
/* 212 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangeConnectorPropertyCommand_1 = __webpack_require__(110);
var ConnectorProperties_1 = __webpack_require__(24);
var ChangeConnectorLineOptionCommand = /** @class */ (function (_super) {
__extends(ChangeConnectorLineOptionCommand, _super);
function ChangeConnectorLineOptionCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeConnectorLineOptionCommand.prototype.getPropertyName = function () {
return "lineOption";
};
ChangeConnectorLineOptionCommand.prototype.getPropertyDefaultValue = function () {
return ConnectorProperties_1.ConnectorLineOption.Straight;
};
return ChangeConnectorLineOptionCommand;
}(ChangeConnectorPropertyCommand_1.ChangeConnectorPropertyCommand));
exports.ChangeConnectorLineOptionCommand = ChangeConnectorLineOptionCommand;
/***/ }),
/* 213 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var SimpleCommandBase_1 = __webpack_require__(7);
var SelectAllCommand = /** @class */ (function (_super) {
__extends(SelectAllCommand, _super);
function SelectAllCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
SelectAllCommand.prototype.isEnabledInReadOnlyMode = function () {
return true;
};
SelectAllCommand.prototype.executeCore = function (state, parameter) {
var itemKeys = [];
this.control.model.iterateItems(function (i) { return itemKeys.push(i.key); });
this.control.selection.set(itemKeys);
return true;
};
return SelectAllCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.SelectAllCommand = SelectAllCommand;
/***/ }),
/* 214 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var AutoLayoutCommandBase_1 = __webpack_require__(59);
var WideTree_1 = __webpack_require__(73);
var LayoutSettings_1 = __webpack_require__(22);
var AutoLayoutTreeVerticalCommand = /** @class */ (function (_super) {
__extends(AutoLayoutTreeVerticalCommand, _super);
function AutoLayoutTreeVerticalCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
AutoLayoutTreeVerticalCommand.prototype.createLayoutSettings = function () {
var gridSize = this.control.settings.snapToGrid ? this.control.settings.gridSize : undefined;
var settings = new LayoutSettings_1.TreeLayoutSettings(gridSize);
settings.orientation = LayoutSettings_1.DataLayoutOrientation.Vertical;
return settings;
};
AutoLayoutTreeVerticalCommand.prototype.createLayout = function (settings, graph) {
return new WideTree_1.TreeLayoutBuilder(settings, graph).build();
};
return AutoLayoutTreeVerticalCommand;
}(AutoLayoutCommandBase_1.AutoLayoutCommandBase));
exports.AutoLayoutTreeVerticalCommand = AutoLayoutTreeVerticalCommand;
/***/ }),
/* 215 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Tree_1 = __webpack_require__(216);
var Forest = /** @class */ (function () {
function Forest(trees) {
this.trees = trees;
}
Forest.create = function (graph) {
var components = graph.getConnectedComponents();
return new Forest(components.map(Tree_1.Tree.createSpanningTree));
};
return Forest;
}());
exports.Forest = Forest;
/***/ }),
/* 216 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Structures_1 = __webpack_require__(31);
var Tree = /** @class */ (function () {
function Tree(root, parentToChildren) {
var _this = this;
this.childToParent = {};
this.root = root;
this.parentToChildren = parentToChildren;
var _loop_1 = function (key) {
if (!parentToChildren.hasOwnProperty(key))
return "continue";
parentToChildren[key].forEach(function (c) { return _this.childToParent[c.key] = key; });
};
for (var key in parentToChildren) {
_loop_1(key);
}
}
Tree.prototype.getChildren = function (node) {
return node && this.parentToChildren[node.key] ? this.parentToChildren[node.key] : [];
};
Tree.prototype.hasChildren = function (node) {
return this.parentToChildren[node.key] && this.parentToChildren[node.key].length > 0;
};
Tree.prototype.iterate = function (callback) {
this.iterateCore(this.root, 0, callback);
};
Tree.createSpanningTree = function (component) {
var rootKey = Tree.findRoot(component);
var iterator = component.createIterator(Structures_1.ConnectionMode.Outgoing);
var parentToChildren = {};
iterator.skipEdge = (function (e) { return e.to === undefined || iterator.isNodeVisited(e.to); });
iterator.onNode = function (n) { return parentToChildren[n.key] = []; };
iterator.onEdge = function (e) {
var node = component.getNode(e.to);
node && parentToChildren[e.from].push(node);
};
iterator.iterate(rootKey);
return new Tree(component.getNode(rootKey), parentToChildren);
};
Tree.prototype.iterateCore = function (node, level, callback) {
var _this = this;
callback(node, level);
this.getChildren(node).forEach(function (n) { return _this.iterateCore(n, level + 1, callback); });
};
Tree.findRoot = function (component) {
return component.nodes.reduce(function (aggregator, cur) {
var edges = component.getAdjacentEdges(cur);
var inc = edges.filter(function (l) { return l.to === cur; }).length;
var out = edges.filter(function (l) { return l.from === cur; }).length;
if (aggregator.candidate === undefined || (inc === 0 && aggregator.inc > 0) || (aggregator.inc !== 0 && aggregator.out - aggregator.inc < out - inc)) {
aggregator.candidate = cur;
aggregator.inc = inc;
aggregator.out = out;
}
return aggregator;
}, { inc: -1, out: -1, candidate: undefined }).candidate;
};
return Tree;
}());
exports.Tree = Tree;
/***/ }),
/* 217 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var SimpleCommandBase_1 = __webpack_require__(7);
var ChangeSnapToGridCommand = /** @class */ (function (_super) {
__extends(ChangeSnapToGridCommand, _super);
function ChangeSnapToGridCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeSnapToGridCommand.prototype.executeCore = function (state, parameter) {
var newValue = parameter === undefined ? !this.control.settings.snapToGrid : !!parameter;
if (this.control.settings.snapToGrid !== newValue) {
this.control.settings.snapToGrid = newValue;
return true;
}
return false;
};
ChangeSnapToGridCommand.prototype.getValue = function () {
return this.control.settings.snapToGrid;
};
return ChangeSnapToGridCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.ChangeSnapToGridCommand = ChangeSnapToGridCommand;
/***/ }),
/* 218 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var SimpleCommandBase_1 = __webpack_require__(7);
var ChangeGridSizeCommand = /** @class */ (function (_super) {
__extends(ChangeGridSizeCommand, _super);
function ChangeGridSizeCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeGridSizeCommand.prototype.isEnabledInReadOnlyMode = function () {
return true;
};
ChangeGridSizeCommand.prototype.getValue = function () {
return this.getModelUnit(this.control.settings.gridSize);
};
ChangeGridSizeCommand.prototype.executeCore = function (state, parameter) {
this.control.settings.gridSize = this.getModelUnitTwipsValue(parameter);
return true;
};
ChangeGridSizeCommand.prototype.getItems = function () {
var _this = this;
return this.control.settings.gridSizeItems.map(function (s) {
return { value: _this.getModelUnit(s), text: _this.getViewUnitText(s) };
});
};
return ChangeGridSizeCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.ChangeGridSizeCommand = ChangeGridSizeCommand;
var ChangeGridSizeItemsCommand = /** @class */ (function (_super) {
__extends(ChangeGridSizeItemsCommand, _super);
function ChangeGridSizeItemsCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeGridSizeItemsCommand.prototype.isEnabledInReadOnlyMode = function () {
return true;
};
ChangeGridSizeItemsCommand.prototype.getValue = function () {
var _this = this;
return this.control.settings.gridSizeItems.map(function (s) { return _this.getModelUnit(s); });
};
ChangeGridSizeItemsCommand.prototype.executeCore = function (state, parameter) {
var _this = this;
this.control.settings.gridSizeItems = parameter.map(function (s) { return _this.getModelUnitTwipsValue(s); });
return true;
};
return ChangeGridSizeItemsCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.ChangeGridSizeItemsCommand = ChangeGridSizeItemsCommand;
/***/ }),
/* 219 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangePagePropertyCommand_1 = __webpack_require__(60);
var ChangePageLandscapeHistoryItem_1 = __webpack_require__(220);
var ChangePageLandscapeCommand = /** @class */ (function (_super) {
__extends(ChangePageLandscapeCommand, _super);
function ChangePageLandscapeCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangePageLandscapeCommand.prototype.getValue = function () {
return this.control.model.pageLandscape;
};
ChangePageLandscapeCommand.prototype.createHistoryItems = function (parameter) {
return [new ChangePageLandscapeHistoryItem_1.ChangePageLandscapeHistoryItem(parameter)];
};
return ChangePageLandscapeCommand;
}(ChangePagePropertyCommand_1.ChangePagePropertyCommand));
exports.ChangePageLandscapeCommand = ChangePageLandscapeCommand;
/***/ }),
/* 220 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var ChangePageLandscapeHistoryItem = /** @class */ (function (_super) {
__extends(ChangePageLandscapeHistoryItem, _super);
function ChangePageLandscapeHistoryItem(value) {
var _this = _super.call(this) || this;
_this.value = value;
return _this;
}
ChangePageLandscapeHistoryItem.prototype.redo = function (manipulator) {
this.oldValue = manipulator.model.pageLandscape;
manipulator.changePageLandscape(this.value);
};
ChangePageLandscapeHistoryItem.prototype.undo = function (manipulator) {
manipulator.changePageLandscape(this.oldValue);
};
return ChangePageLandscapeHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.ChangePageLandscapeHistoryItem = ChangePageLandscapeHistoryItem;
/***/ }),
/* 221 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangePagePropertyCommand_1 = __webpack_require__(60);
var Utils_1 = __webpack_require__(0);
var ChangePageSizeHistoryItem_1 = __webpack_require__(222);
var SimpleCommandBase_1 = __webpack_require__(7);
var ChangePageSizeCommand = /** @class */ (function (_super) {
__extends(ChangePageSizeCommand, _super);
function ChangePageSizeCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangePageSizeCommand.prototype.getValue = function () {
return this.getModelUnitSize(this.control.model.pageSize);
};
ChangePageSizeCommand.prototype.createHistoryItems = function (parameter) {
return [new ChangePageSizeHistoryItem_1.ChangePageSizeHistoryItem(new Utils_1.Size(this.getModelUnitTwipsValue(parameter.width), this.getModelUnitTwipsValue(parameter.height)))];
};
ChangePageSizeCommand.prototype.getItems = function () {
var _this = this;
return this.control.settings.pageSizeItems.map(function (i) {
return {
value: _this.getModelUnitSize(i.size),
text: i.text.replace("{width}", _this.getViewUnitText(i.size.width)).replace("{height}", _this.getViewUnitText(i.size.height))
};
});
};
ChangePageSizeCommand.prototype.getModelUnitSize = function (size) {
return new Utils_1.Size(this.getModelUnit(size.width), this.getModelUnit(size.height));
};
return ChangePageSizeCommand;
}(ChangePagePropertyCommand_1.ChangePagePropertyCommand));
exports.ChangePageSizeCommand = ChangePageSizeCommand;
var ChangePageSizeItemsCommand = /** @class */ (function (_super) {
__extends(ChangePageSizeItemsCommand, _super);
function ChangePageSizeItemsCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangePageSizeItemsCommand.prototype.isEnabled = function () {
return true;
};
ChangePageSizeItemsCommand.prototype.getValue = function () {
var _this = this;
return this.control.settings.pageSizeItems.map(function (i) {
return {
size: new Utils_1.Size(_this.getModelUnit(i.width), _this.getModelUnit(i.height)),
text: i.text
};
});
};
ChangePageSizeItemsCommand.prototype.executeCore = function (state, parameter) {
var _this = this;
this.control.settings.pageSizeItems = parameter.map(function (i) {
return {
size: new Utils_1.Size(_this.getModelUnitTwipsValue(i.width), _this.getModelUnitTwipsValue(i.height)),
text: i.text
};
});
return true;
};
return ChangePageSizeItemsCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.ChangePageSizeItemsCommand = ChangePageSizeItemsCommand;
/***/ }),
/* 222 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var ChangePageSizeHistoryItem = /** @class */ (function (_super) {
__extends(ChangePageSizeHistoryItem, _super);
function ChangePageSizeHistoryItem(size) {
var _this = _super.call(this) || this;
_this.size = size;
return _this;
}
ChangePageSizeHistoryItem.prototype.redo = function (manipulator) {
this.oldSize = manipulator.model.pageSize;
manipulator.changePageSize(this.size);
};
ChangePageSizeHistoryItem.prototype.undo = function (manipulator) {
manipulator.changePageSize(this.oldSize);
};
return ChangePageSizeHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.ChangePageSizeHistoryItem = ChangePageSizeHistoryItem;
/***/ }),
/* 223 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ExportImageCommand_1 = __webpack_require__(74);
var ExportPngCommand = /** @class */ (function (_super) {
__extends(ExportPngCommand, _super);
function ExportPngCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ExportPngCommand.prototype.getExtension = function () { return "png"; };
ExportPngCommand.prototype.getExportFunc = function () {
return this.exporter.exportPng;
};
return ExportPngCommand;
}(ExportImageCommand_1.ExportImageCommand));
exports.ExportPngCommand = ExportPngCommand;
/***/ }),
/* 224 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var UnitConverter_1 = __webpack_require__(13);
var RenderManager_1 = __webpack_require__(12);
var Browser_1 = __webpack_require__(23);
var Utils_1 = __webpack_require__(15);
var CanvasManagerBase_1 = __webpack_require__(33);
var __1 = __webpack_require__(8);
var EXPORT_IMAGE_QUALITY = 1;
var CanvasExportManager = /** @class */ (function (_super) {
__extends(CanvasExportManager, _super);
function CanvasExportManager(itemsContainer) {
var _this = _super.call(this, 1) || this;
_this.itemsContainer = itemsContainer;
return _this;
}
CanvasExportManager.prototype.getSvgImage = function (modelSize, pageColor) {
var svgEl = RenderManager_1.RenderManager.createSvgElement(null, true);
var modelAbsSize = modelSize.transform(UnitConverter_1.UnitConverter.twipsToPixelsF);
Utils_1.RenderUtils.updateSvgElementSize(svgEl, modelAbsSize.width, modelAbsSize.height, true);
svgEl.style.backgroundColor = __1.ColorHelper.colorToHash(pageColor);
this.createTextFloodFilter(undefined, svgEl, pageColor);
var exportCssRules = this.getExportCssRules();
var useCssRules = exportCssRules && !Browser_1.Browser.IE;
if (useCssRules) {
var style = document.createElementNS(RenderManager_1.svgNS, "style");
style.innerHTML = exportCssRules;
svgEl.appendChild(style);
}
for (var i = 0; i < this.itemsContainer.childNodes.length; i++) {
var node = this.itemsContainer.childNodes[i].cloneNode(true);
if (!useCssRules) {
this.inlineStyle(node, this.itemsContainer.childNodes[i]);
}
svgEl.appendChild(node);
}
return svgEl;
};
CanvasExportManager.prototype.getSvgImageUrl = function (modelSize, pageColor) {
var svgEl = this.getSvgImage(modelSize, pageColor);
return this.getSvgBase64String(svgEl);
};
CanvasExportManager.prototype.getSvgString = function (svgElement) {
return new XMLSerializer().serializeToString(svgElement);
};
CanvasExportManager.prototype.getSvgBase64String = function (svgElement) {
var xml = this.getSvgString(svgElement);
return CanvasExportManager.base64Start + this.getBase64EncodeUnicode(xml);
};
CanvasExportManager.prototype.getBase64EncodeUnicode = function (s) {
return btoa(encodeURIComponent(s).replace(/%([0-9A-F]{2})/g, function (match, p1) { return String.fromCharCode(parseInt("0x" + p1, 16)); }));
};
CanvasExportManager.prototype.getExportCssRules = function () {
for (var i = 0; i < document.styleSheets.length; i++) {
var rules = this.getRules(document.styleSheets[i]);
if (rules) {
var cssText = "";
for (var j = 0; j < rules.length; j++) {
var rule = rules[j];
var selectorText = this.isCSSStyleRule(rule) ? rule.selectorText : null;
if (selectorText && this.checkSelector(selectorText))
cssText += rule.cssText + "\n";
}
if (cssText.length > 0)
return "\n" + cssText;
}
}
};
CanvasExportManager.prototype.checkSelector = function (selectorText) {
for (var i = 0; i < CanvasExportManager.exportStyleRules.length; i++) {
if (selectorText.indexOf(CanvasExportManager.exportStyleRules[i]) === 0)
return true;
}
return false;
};
CanvasExportManager.prototype.getRules = function (styleSheet) {
try {
return this.isCSSStyleSheet(styleSheet) ? styleSheet.rules || styleSheet.cssRules : null;
}
catch (_a) { } // Catch access dinied exception
};
CanvasExportManager.prototype.isCSSStyleSheet = function (stylesheet) {
return stylesheet.rules !== undefined;
};
CanvasExportManager.prototype.isCSSStyleRule = function (rule) {
return rule.selectorText !== undefined;
};
CanvasExportManager.prototype.inlineStyle = function (destNode, srcNode) {
for (var i = 0; i < destNode.childNodes.length; i++) {
var child = destNode.childNodes[i];
if (!child.tagName)
continue;
if (child.tagName === "g")
this.inlineStyle(child, srcNode.childNodes[i]);
else if (child.style) {
var style = window.getComputedStyle(srcNode.childNodes[i]);
if (style !== undefined) {
for (var index = 0; index < CanvasExportManager.exportStyleAttributes.length; index++) {
var styleProperty = CanvasExportManager.exportStyleAttributes[index];
child.style.setProperty(styleProperty, style.getPropertyValue(styleProperty));
}
}
}
}
};
CanvasExportManager.prototype.exportSvgImage = function (modelSize, pageColor, callback) {
callback(this.getSvgImageUrl(modelSize, pageColor));
};
CanvasExportManager.prototype.exportBinaryImage = function (modelSize, pageColor, mimeType, callback) {
var modelAbsSize = this.getAbsoluteSize(modelSize);
var canvasEl = document.createElement('canvas');
canvasEl.width = modelAbsSize.width;
canvasEl.height = modelAbsSize.height;
var ctx = canvasEl.getContext("2d");
ctx.fillStyle = __1.ColorHelper.colorToHash(pageColor);
ctx.fillRect(0, 0, modelAbsSize.width, modelAbsSize.height);
if (Browser_1.Browser.IE && typeof window["canvg"] === "function") {
var svgEl = this.getSvgImage(modelSize, pageColor);
var svgStr = this.getSvgString(svgEl);
ctx["drawSvg"](svgStr, 0, 0, null, null, {
renderCallback: function () {
callback(canvasEl.toDataURL(mimeType, EXPORT_IMAGE_QUALITY));
}
});
}
else {
var imgEl = new Image();
imgEl.width = modelAbsSize.width;
imgEl.height = modelAbsSize.height;
imgEl.setAttribute('crossOrigin', 'anonymous');
imgEl.onload = function () {
ctx.drawImage(imgEl, 0, 0);
callback(canvasEl.toDataURL(mimeType, EXPORT_IMAGE_QUALITY));
};
imgEl.src = this.getSvgImageUrl(modelSize, pageColor);
}
};
CanvasExportManager.prototype.exportPngImage = function (modelSize, pageColor, callback) {
this.exportBinaryImage(modelSize, pageColor, "image/png", callback);
};
CanvasExportManager.prototype.exportJpgImage = function (modelSize, pageColor, callback) {
this.exportBinaryImage(modelSize, pageColor, "image/jpeg", callback);
};
CanvasExportManager.prototype.notifyModelChanged = function (changes) { };
CanvasExportManager.prototype.notifyPageColorChanged = function (color) { };
CanvasExportManager.prototype.notifyPageSizeChanged = function (pageSize, pageLandscape) { };
CanvasExportManager.base64Start = 'data:image/svg+xml;base64,';
CanvasExportManager.exportStyleRules = [
".dxdi-canvas .shape ", ".dxdi-canvas .connector ", ".dxdi-canvas text", ".dxdi-canvas.export"
];
CanvasExportManager.exportStyleAttributes = [
"fill", "stroke", "stroke-width", "shape-rendering",
"font-family", "font-size", "font-weight", "font-style", "text-decoration", "text-anchor"
];
return CanvasExportManager;
}(CanvasManagerBase_1.CanvasManagerBase));
exports.CanvasExportManager = CanvasExportManager;
/***/ }),
/* 225 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ExportImageCommand_1 = __webpack_require__(74);
var ExportSvgCommand = /** @class */ (function (_super) {
__extends(ExportSvgCommand, _super);
function ExportSvgCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ExportSvgCommand.prototype.getExtension = function () { return "svg"; };
ExportSvgCommand.prototype.getExportFunc = function () {
return this.exporter.exportSvg;
};
return ExportSvgCommand;
}(ExportImageCommand_1.ExportImageCommand));
exports.ExportSvgCommand = ExportSvgCommand;
/***/ }),
/* 226 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ExportImageCommand_1 = __webpack_require__(74);
var ExportJpgCommand = /** @class */ (function (_super) {
__extends(ExportJpgCommand, _super);
function ExportJpgCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ExportJpgCommand.prototype.getExtension = function () { return "jpg"; };
ExportJpgCommand.prototype.getExportFunc = function () {
return this.exporter.exportJpg;
};
return ExportJpgCommand;
}(ExportImageCommand_1.ExportImageCommand));
exports.ExportJpgCommand = ExportJpgCommand;
/***/ }),
/* 227 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Exporter_1 = __webpack_require__(57);
var ClipboardCommand_1 = __webpack_require__(75);
var CopySelectionCommand = /** @class */ (function (_super) {
__extends(CopySelectionCommand, _super);
function CopySelectionCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
CopySelectionCommand.prototype.isEnabled = function () {
return _super.prototype.isEnabled.call(this) && !this.control.selection.isEmpty(true);
};
CopySelectionCommand.prototype.isEnabledInReadOnlyMode = function () {
return true;
};
CopySelectionCommand.prototype.executeCore = function (state) {
var exporter = new Exporter_1.Exporter();
var data = exporter.exportItems(this.control.selection.getSelectedItems(true, true));
this.setClipboardData(data);
return true;
};
return CopySelectionCommand;
}(ClipboardCommand_1.ClipboardCommand));
exports.CopySelectionCommand = CopySelectionCommand;
/***/ }),
/* 228 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Exporter_1 = __webpack_require__(57);
var ModelUtils_1 = __webpack_require__(6);
var ClipboardCommand_1 = __webpack_require__(75);
var CutSelectionCommand = /** @class */ (function (_super) {
__extends(CutSelectionCommand, _super);
function CutSelectionCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
CutSelectionCommand.prototype.isEnabled = function () {
return _super.prototype.isEnabled.call(this) && !this.control.selection.isEmpty();
};
CutSelectionCommand.prototype.executeCore = function (state) {
var exporter = new Exporter_1.Exporter();
var data = exporter.exportItems(this.control.selection.getSelectedItems(true, true));
this.setClipboardData(data);
ModelUtils_1.ModelUtils.deleteSelection(this.control.history, this.control.model, this.control.selection);
return true;
};
return CutSelectionCommand;
}(ClipboardCommand_1.ClipboardCommand));
exports.CutSelectionCommand = CutSelectionCommand;
/***/ }),
/* 229 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var PasteSelectoinCommandBase_1 = __webpack_require__(113);
var PasteSelectionCommand = /** @class */ (function (_super) {
__extends(PasteSelectionCommand, _super);
function PasteSelectionCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
PasteSelectionCommand.prototype.getShapeNewPosition = function (position) {
return PasteSelectoinCommandBase_1.PasteSelectionCommandBase.getShapeNewPosition(this.control.model, position);
};
PasteSelectionCommand.prototype.changeConnectorPoints = function (connector) {
PasteSelectoinCommandBase_1.PasteSelectionCommandBase.changeConnectorPoints(this.control.model, connector);
};
return PasteSelectionCommand;
}(PasteSelectoinCommandBase_1.PasteSelectionCommandBase));
exports.PasteSelectionCommand = PasteSelectionCommand;
/***/ }),
/* 230 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var ImportShapeHistoryItem = /** @class */ (function (_super) {
__extends(ImportShapeHistoryItem, _super);
function ImportShapeHistoryItem(shape) {
var _this = _super.call(this) || this;
_this.shape = shape;
return _this;
}
ImportShapeHistoryItem.prototype.redo = function (manipulator) {
this.shapeKey = this.shape.key;
manipulator.insertShape(this.shape);
};
ImportShapeHistoryItem.prototype.undo = function (manipulator) {
manipulator.removeShape(manipulator.model.findShape(this.shapeKey));
};
return ImportShapeHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.ImportShapeHistoryItem = ImportShapeHistoryItem;
/***/ }),
/* 231 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var ImportConnectorHistoryItem = /** @class */ (function (_super) {
__extends(ImportConnectorHistoryItem, _super);
function ImportConnectorHistoryItem(connector) {
var _this = _super.call(this) || this;
_this.connector = connector;
return _this;
}
ImportConnectorHistoryItem.prototype.redo = function (manipulator) {
this.connectorKey = this.connector.key;
manipulator.insertConnector(this.connector);
};
ImportConnectorHistoryItem.prototype.undo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
manipulator.removeConnector(connector);
};
return ImportConnectorHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.ImportConnectorHistoryItem = ImportConnectorHistoryItem;
/***/ }),
/* 232 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var BPMNImporter_1 = __webpack_require__(233);
var ModelUtils_1 = __webpack_require__(6);
var AddShapeHistoryItem_1 = __webpack_require__(51);
var Utils_1 = __webpack_require__(0);
var Connector_1 = __webpack_require__(5);
var AddConnectorHistoryItem_1 = __webpack_require__(52);
var AddConnectionHistoryItem_1 = __webpack_require__(37);
var Sugiyama_1 = __webpack_require__(61);
var LayoutSettings_1 = __webpack_require__(22);
var ExportImportCommandBase_1 = __webpack_require__(47);
var ImportBPMNCommand = /** @class */ (function (_super) {
__extends(ImportBPMNCommand, _super);
function ImportBPMNCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ImportBPMNCommand.prototype.executeCore = function (state, parameter) {
var importer = new BPMNImporter_1.BPMNImporter(parameter);
var graph = importer.import();
this.updateModel(graph);
return true;
};
ImportBPMNCommand.prototype.updateModel = function (graph) {
var _this = this;
var externalKeyToModelKey = {};
var shapes = [];
var connectors = [];
this.control.history.beginTransaction();
graph.items.forEach(function (node) {
var insert = new AddShapeHistoryItem_1.AddShapeHistoryItem(node.type, new Utils_1.Point(0, 0), node.text, node.key);
_this.control.history.addAndRedo(insert);
externalKeyToModelKey[node.key] = insert.shapeKey;
var shape = _this.control.model.findShape(insert.shapeKey);
shapes.push(shape);
});
graph.edges.forEach(function (edge) {
var from = _this.control.model.findShape(externalKeyToModelKey[edge.from]);
var to = _this.control.model.findShape(externalKeyToModelKey[edge.to]);
var insert = new AddConnectorHistoryItem_1.AddConnectorHistoryItem([from.getConnectionPointPosition(0), to.getConnectionPointPosition(0)]);
_this.control.history.addAndRedo(insert);
var connector = _this.control.model.findConnector(insert.connectorKey);
_this.control.history.addAndRedo(new AddConnectionHistoryItem_1.AddConnectionHistoryItem(connector, from, 0, Connector_1.ConnectorPosition.Begin));
_this.control.history.addAndRedo(new AddConnectionHistoryItem_1.AddConnectionHistoryItem(connector, to, 0, Connector_1.ConnectorPosition.End));
connectors.push(connector);
});
var settings = new LayoutSettings_1.LayoutSettings();
var graphInfo = ModelUtils_1.ModelUtils.getGraphInfoByItems(this.control.model, shapes, connectors);
graphInfo.forEach(function (info) {
var layout = new Sugiyama_1.SugiyamaLayoutBuilder(settings, info.graph).build();
var nonGraphItems = ModelUtils_1.ModelUtils.getNonGraphItems(_this.control.model, info.container, layout.nodeToLayout, shapes, connectors);
ModelUtils_1.ModelUtils.applyLayout(_this.control.history, _this.control.model, undefined, info.graph, layout, nonGraphItems, settings, _this.control.settings.snapToGrid, _this.control.settings.gridSize);
});
ModelUtils_1.ModelUtils.tryUpdateModelSize(this.control.history, this.control.model);
this.control.history.endTransaction();
};
return ImportBPMNCommand;
}(ExportImportCommandBase_1.ExportImportCommandBase));
exports.ImportBPMNCommand = ImportBPMNCommand;
/***/ }),
/* 233 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Graph_1 = __webpack_require__(53);
var ShapeTypes_1 = __webpack_require__(1);
var Structures_1 = __webpack_require__(31);
var ImportUtils_1 = __webpack_require__(71);
var BPMNImporter = /** @class */ (function () {
function BPMNImporter(xml) {
this.doc = ImportUtils_1.ImportUtils.createDocument(xml);
this.graph = new Graph_1.Graph([], []);
}
BPMNImporter.prototype.import = function () {
for (var child = void 0, i = 0; child = this.doc.children[i]; i++) {
if (child.nodeName.toUpperCase() === "DEFINITIONS")
this.onDefinitionsElement(child);
}
this.validate();
return this.graph;
};
BPMNImporter.prototype.validate = function () {
var nodesMap = {};
this.graph.nodes.forEach(function (n) { return nodesMap[n] = true; });
for (var i = 0, edge = void 0; edge = this.graph.edges[i]; i++) {
if (!nodesMap[edge.from] || !nodesMap[edge.to]) {
this.graph.edges.splice(i, 1);
i--;
}
}
};
BPMNImporter.prototype.onDefinitionsElement = function (element) {
this.dataSourceKey = element.getAttribute("id");
for (var child = void 0, i = 0; child = element.children[i]; i++) {
if (child.nodeName.toUpperCase() === "PROCESS")
this.onProcessElement(child);
}
};
BPMNImporter.prototype.onProcessElement = function (element) {
for (var child = void 0, i = 0; child = element.children[i]; i++) {
switch (child.nodeName.toUpperCase()) {
case "STARTEVENT":
this.onStartEventElement(child);
break;
case "SEQUENCEFLOW":
this.onSequenceFlowElement(child);
break;
case "SCRIPTTASK":
this.onScriptTaskElement(child);
break;
case "USERTASK":
this.onUserTaskElement(child);
break;
case "SERVICETASK":
this.onServiceTaskElement(child);
break;
case "SENDTASK":
this.onSendTaskElement(child);
break;
case "EXCLUSIVEGATEWAY":
this.onExclusiveGateway(child);
break;
case "ENDEVENT":
this.onEndEventGateway(child);
break;
}
}
};
BPMNImporter.prototype.onStartEventElement = function (element) {
var node = this.createNode(element);
node.type = ShapeTypes_1.ShapeTypes.Ellipse;
node.text = element.getAttribute("name");
this.graph.addNode(node);
};
BPMNImporter.prototype.onSequenceFlowElement = function (element) {
var fromKey = element.getAttribute("sourceRef");
var toKey = element.getAttribute("targetRef");
var edge = this.createEdge(element, fromKey, toKey);
if (element.hasAttribute("name"))
edge.text = element.getAttribute("name");
this.graph.addEdge(edge);
};
BPMNImporter.prototype.onScriptTaskElement = function (element) {
var node = this.createNode(element);
node.text = element.getAttribute("name");
this.graph.addNode(node);
};
BPMNImporter.prototype.onUserTaskElement = function (element) {
var node = this.createNode(element);
node.text = element.getAttribute("name");
this.graph.addNode(node);
};
BPMNImporter.prototype.onServiceTaskElement = function (element) {
var node = this.createNode(element);
node.text = element.getAttribute("name");
this.graph.addNode(node);
};
BPMNImporter.prototype.onSendTaskElement = function (element) {
var node = this.createNode(element);
node.text = element.getAttribute("name");
this.graph.addNode(node);
};
BPMNImporter.prototype.onExclusiveGateway = function (element) {
var node = this.createNode(element);
node.text = element.getAttribute("name");
node.type = ShapeTypes_1.ShapeTypes.Decision;
this.graph.addNode(node);
};
BPMNImporter.prototype.onEndEventGateway = function (element) {
var node = this.createNode(element);
node.text = element.getAttribute("name");
node.type = ShapeTypes_1.ShapeTypes.Ellipse;
this.graph.addNode(node);
};
BPMNImporter.prototype.createNode = function (element) {
return new BPMNNode(this.dataSourceKey, element.getAttribute("id"));
};
BPMNImporter.prototype.createEdge = function (element, fromKey, toKey) {
return new BPMNEdge(this.dataSourceKey, element.getAttribute("id"), fromKey, toKey);
};
return BPMNImporter;
}());
exports.BPMNImporter = BPMNImporter;
var BPMNNode = /** @class */ (function () {
function BPMNNode(sourceKey, key) {
this.sourceKey = sourceKey;
this.key = key;
this.type = ShapeTypes_1.ShapeTypes.Rectangle;
}
return BPMNNode;
}());
exports.BPMNNode = BPMNNode;
var BPMNEdge = /** @class */ (function (_super) {
__extends(BPMNEdge, _super);
function BPMNEdge(sourceKey, key, fromKey, toKey) {
var _this = _super.call(this, key, fromKey, toKey) || this;
_this.sourceKey = sourceKey;
return _this;
}
return BPMNEdge;
}(Structures_1.Edge));
/***/ }),
/* 234 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Graph_1 = __webpack_require__(53);
var Structures_1 = __webpack_require__(31);
var ListUtils_1 = __webpack_require__(70);
var CycleRemover = /** @class */ (function () {
function CycleRemover() {
}
CycleRemover.removeCycles = function (graph) {
var feedbackSet = this.getFeedbackSet(graph);
return this.reverseEdges(graph, feedbackSet);
};
CycleRemover.getFeedbackSet = function (graph) {
var _this = this;
var feedbackSet = {};
var nonTrivialStronglyConnectedComponents = this.getNonTrivialStronglyConnectedComponents(graph);
while (nonTrivialStronglyConnectedComponents.length) {
nonTrivialStronglyConnectedComponents.forEach(function (g) {
var maxCyclicEdges = _this.getMaxCyclicEdges(g);
maxCyclicEdges.forEach(function (e) { return delete feedbackSet[e.reverse().getHashKey()]; });
maxCyclicEdges.forEach(function (e) { return feedbackSet[e.getHashKey()] = true; });
});
nonTrivialStronglyConnectedComponents = this.getNonTrivialStronglyConnectedComponents(this.reverseEdges(graph, feedbackSet).graph);
}
return feedbackSet;
};
CycleRemover.getMaxCyclicEdges = function (graph) {
var black = {};
var gray = {};
var edgeCycleCount = {};
var visitedEdges = [];
var cycles = [];
var iterator = graph.createIterator(Structures_1.ConnectionMode.Outgoing);
iterator.visitEachEdgeOnce = false;
iterator.onNode = function (n) {
gray[n.key] = true;
};
iterator.skipNode = function (n) {
if (gray[n.key]) {
var cycle = [];
for (var i = 0; i < visitedEdges.length; i++) {
var e = visitedEdges[i];
if (edgeCycleCount[e.key] === undefined)
edgeCycleCount[e.key] = 0;
edgeCycleCount[e.key]++;
cycle.push(e);
if (e.from === n.key)
break;
}
cycles.push(cycle);
}
return gray[n.key] || black[n.key];
};
iterator.skipEdge = function (e) { return false; };
iterator.onEdge = function (e) {
visitedEdges.splice(0, 0, e);
};
iterator.onAfterEdge = function (e) {
visitedEdges.splice(0, 1);
};
iterator.onAllEdges = function (e) {
black[e.key] = true;
gray[e.key] = false;
};
iterator.iterate(graph.nodes[0]);
var edgeSet = new ListUtils_1.HashSet([], function (e) { return e.key; });
cycles.forEach(function (c) {
edgeSet.tryPush(c.reduce(function (max, curr) { return edgeCycleCount[curr.key] > edgeCycleCount[max.key] ? curr : max; }, c[0]));
});
return edgeSet.list();
};
CycleRemover.reverseEdges = function (graph, feedbackSet) {
var edges = new ListUtils_1.HashSet([], function (e) { return e.getHashKey(); });
var reversedEdges = {};
var removedEdges = {};
graph.edges.forEach(function (e) {
if (feedbackSet[e.getHashKey()]) {
e = e.reverse();
reversedEdges[e.key] = true;
}
if (!edges.tryPush(e)) {
removedEdges[e.key] = true;
delete reversedEdges[e.key];
}
});
return {
graph: new Graph_1.Graph(graph.nodes.map(function (n) { return graph.getNode(n); }), edges.list()),
reversedEdges: reversedEdges,
removedEdges: removedEdges
};
};
CycleRemover.getNonTrivialStronglyConnectedComponents = function (graph) {
return this.getStronglyConnectedComponents(graph).filter(function (g) { return g.edges.length; });
};
CycleRemover.getStronglyConnectedComponents = function (graph) {
var _this = this;
// Tarjan algorithm
// https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
var nodesStack = [];
var index = 0;
var lowIndex = {};
var lowLink = {};
var onStack = {};
var components = [];
var visitedNodes = {};
for (var i = 0; i < graph.nodes.length; i++) {
var nodeKey = graph.nodes[i];
var iterator = graph.createIterator(Structures_1.ConnectionMode.Outgoing);
iterator.visitEachEdgeOnce = false;
iterator.visitEachNodeOnce = false;
iterator.onNode = function (n) {
visitedNodes[n.key] = true;
nodesStack.push(n);
onStack[n.key] = true;
lowLink[n.key] = index;
lowIndex[n.key] = index;
index++;
};
iterator.skipNode = function (n) { return visitedNodes[n.key]; };
iterator.skipEdge = function (e) {
var isVisited = visitedNodes[e.to];
if (isVisited && onStack[e.to])
lowLink[e.from] = Math.min(lowLink[e.from], lowIndex[e.to]);
return isVisited;
};
iterator.onAfterEdge = function (e) {
lowLink[e.from] = Math.min(lowLink[e.from], lowLink[e.to]);
};
iterator.onAllEdges = function (n, outgoing) {
if (outgoing && lowLink[n.key] === lowIndex[n.key])
components.push(_this.getStronglyConnectedComponent(graph, n, nodesStack, onStack));
};
iterator.iterate(nodeKey);
}
return components;
};
CycleRemover.getStronglyConnectedComponent = function (graph, root, nodesStack, onStack) {
var itemsMap = {};
var nodes = [];
var edges = [];
var topStackNode;
do {
topStackNode = nodesStack.pop();
if (!itemsMap[topStackNode.key])
nodes.push(topStackNode);
itemsMap[topStackNode.key] = true;
onStack[topStackNode.key] = false;
} while (topStackNode !== root);
nodes.forEach(function (n) {
var aEdges = graph.getAdjacentEdges(n.key, Structures_1.ConnectionMode.Outgoing);
edges.push.apply(edges, aEdges.filter(function (e) { return !itemsMap[e.key] && itemsMap[e.to]; }));
aEdges.forEach(function (e) { return itemsMap[e.key] = true; });
});
return new Graph_1.Graph(nodes, edges);
};
return CycleRemover;
}());
exports.CycleRemover = CycleRemover;
/***/ }),
/* 235 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangeZindexHistoryItem_1 = __webpack_require__(76);
var SimpleCommandBase_1 = __webpack_require__(7);
var SendToBackCommand = /** @class */ (function (_super) {
__extends(SendToBackCommand, _super);
function SendToBackCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
SendToBackCommand.prototype.isEnabled = function () {
var items = this.control.selection.getSelectedItems();
return _super.prototype.isEnabled.call(this) && items.length > 0 && this.needSendToBack(items);
};
SendToBackCommand.prototype.executeCore = function (state, parameter) {
var _this = this;
this.control.history.beginTransaction();
var items = this.control.selection.getSelectedItems();
items.forEach(function (item) {
var newZIndex = _this.control.model.getIntersectItemsMinZIndex(item) - 1;
_this.control.history.addAndRedo(new ChangeZindexHistoryItem_1.ChangeZindexHistoryItem(item, newZIndex));
});
this.control.history.endTransaction();
return true;
};
SendToBackCommand.prototype.needSendToBack = function (items) {
var _this = this;
var _loop_1 = function (i) {
var zIndex = this_1.control.model.getIntersectItemsMinZIndex(items[i]);
if (zIndex < items[i].zIndex)
return { value: true };
if (zIndex === items[i].zIndex) {
var result_1 = false;
var sameZIndexItems = this_1.control.model.getIntersectItems(items[i]).filter(function (item) { return item.zIndex === items[i].zIndex; });
sameZIndexItems.forEach(function (item) {
if (_this.control.model.getItemIndex(item) < _this.control.model.getItemIndex(items[i])) {
result_1 = true;
return;
}
});
return { value: result_1 };
}
};
var this_1 = this;
for (var i = 0; i < items.length; i++) {
var state_1 = _loop_1(i);
if (typeof state_1 === "object")
return state_1.value;
}
return false;
};
return SendToBackCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.SendToBackCommand = SendToBackCommand;
/***/ }),
/* 236 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangeZindexHistoryItem_1 = __webpack_require__(76);
var SimpleCommandBase_1 = __webpack_require__(7);
var BringToFrontCommand = /** @class */ (function (_super) {
__extends(BringToFrontCommand, _super);
function BringToFrontCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
BringToFrontCommand.prototype.isEnabled = function () {
var items = this.control.selection.getSelectedItems();
return _super.prototype.isEnabled.call(this) && items.length > 0 && this.needBringToFront(items);
};
BringToFrontCommand.prototype.executeCore = function (state, parameter) {
var _this = this;
this.control.history.beginTransaction();
var items = this.control.selection.getSelectedItems();
items.forEach(function (item) {
var newZIndex = _this.control.model.getIntersectItemsMaxZIndex(item) + 1;
_this.control.history.addAndRedo(new ChangeZindexHistoryItem_1.ChangeZindexHistoryItem(item, newZIndex));
});
this.control.history.endTransaction();
return true;
};
BringToFrontCommand.prototype.needBringToFront = function (items) {
var _this = this;
var _loop_1 = function (i) {
var zIndex = this_1.control.model.getIntersectItemsMaxZIndex(items[i]);
if (zIndex > items[i].zIndex)
return { value: true };
if (zIndex === items[i].zIndex) {
var result_1 = false;
var sameZIndexItems = this_1.control.model.getIntersectItems(items[i]).filter(function (item) { return item.zIndex === items[i].zIndex; });
sameZIndexItems.forEach(function (item) {
if (_this.control.model.getItemIndex(item) > _this.control.model.getItemIndex(items[i])) {
result_1 = true;
return;
}
});
return { value: result_1 };
}
};
var this_1 = this;
for (var i = 0; i < items.length; i++) {
var state_1 = _loop_1(i);
if (typeof state_1 === "object")
return state_1.value;
}
return false;
};
return BringToFrontCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.BringToFrontCommand = BringToFrontCommand;
/***/ }),
/* 237 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var AutoLayoutCommandBase_1 = __webpack_require__(59);
var Sugiyama_1 = __webpack_require__(61);
var LayoutSettings_1 = __webpack_require__(22);
var AutoLayoutLayeredHorizontalCommand = /** @class */ (function (_super) {
__extends(AutoLayoutLayeredHorizontalCommand, _super);
function AutoLayoutLayeredHorizontalCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
AutoLayoutLayeredHorizontalCommand.prototype.createLayoutSettings = function () {
var settings = new LayoutSettings_1.LayoutSettings();
settings.orientation = LayoutSettings_1.DataLayoutOrientation.Horizontal;
return settings;
};
AutoLayoutLayeredHorizontalCommand.prototype.createLayout = function (settings, graph) {
return new Sugiyama_1.SugiyamaLayoutBuilder(settings, graph).build();
};
return AutoLayoutLayeredHorizontalCommand;
}(AutoLayoutCommandBase_1.AutoLayoutCommandBase));
exports.AutoLayoutLayeredHorizontalCommand = AutoLayoutLayeredHorizontalCommand;
/***/ }),
/* 238 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Utils_1 = __webpack_require__(0);
var ModelUtils_1 = __webpack_require__(6);
var UnitConverter_1 = __webpack_require__(13);
var SimpleCommandBase_1 = __webpack_require__(7);
var MoveCommand = /** @class */ (function (_super) {
__extends(MoveCommand, _super);
function MoveCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
MoveCommand.prototype.isEnabled = function () {
return _super.prototype.isEnabled.call(this) && !this.control.selection.isEmpty();
};
MoveCommand.prototype.executeCore = function (state, parameter) {
var _this = this;
this.control.history.beginTransaction();
var shapes = this.control.selection.getSelectedShapes();
shapes.forEach(function (shape, index) {
var pos = _this.getPosition(shape.position);
ModelUtils_1.ModelUtils.setShapePosition(_this.control.history, _this.control.model, shape, pos);
ModelUtils_1.ModelUtils.updateShapeAttachedConnectors(_this.control.history, _this.control.model, shape);
});
var connectors = this.control.selection.getSelectedConnectors();
connectors.forEach(function (connector, index) {
var startPtIndex = connector.beginItem ? 1 : 0;
var endPtIndex = connector.endItem ? (connector.points.length - 2) : (connector.points.length - 1);
for (var i = startPtIndex; i <= endPtIndex; i++) {
var pos = _this.getPosition(connector.points[i]);
ModelUtils_1.ModelUtils.setConnectorPoint(_this.control.history, _this.control.model, connector, i, pos);
}
});
ModelUtils_1.ModelUtils.tryUpdateModelSize(this.control.history, this.control.model);
this.control.history.endTransaction();
return true;
};
return MoveCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.MoveCommand = MoveCommand;
var MoveLeftCommand = /** @class */ (function (_super) {
__extends(MoveLeftCommand, _super);
function MoveLeftCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
MoveLeftCommand.prototype.getPosition = function (position) {
return position.offset(-UnitConverter_1.UnitConverter.pixelsToTwips(1), 0);
};
return MoveLeftCommand;
}(MoveCommand));
exports.MoveLeftCommand = MoveLeftCommand;
var MoveStepLeftCommand = /** @class */ (function (_super) {
__extends(MoveStepLeftCommand, _super);
function MoveStepLeftCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
MoveStepLeftCommand.prototype.getPosition = function (position) {
if (this.control.settings.snapToGrid)
return new Utils_1.Point(ModelUtils_1.ModelUtils.getSnappedPos(this.control.model, this.control.settings.gridSize, position.x - (this.control.settings.gridSize / 2 + 2), true), position.y);
else
return position.offset(-this.control.settings.gridSize, 0);
};
return MoveStepLeftCommand;
}(MoveCommand));
exports.MoveStepLeftCommand = MoveStepLeftCommand;
var MoveRightCommand = /** @class */ (function (_super) {
__extends(MoveRightCommand, _super);
function MoveRightCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
MoveRightCommand.prototype.getPosition = function (position) {
return position.offset(UnitConverter_1.UnitConverter.pixelsToTwips(1), 0);
};
return MoveRightCommand;
}(MoveCommand));
exports.MoveRightCommand = MoveRightCommand;
var MoveStepRightCommand = /** @class */ (function (_super) {
__extends(MoveStepRightCommand, _super);
function MoveStepRightCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
MoveStepRightCommand.prototype.getPosition = function (position) {
if (this.control.settings.snapToGrid)
return new Utils_1.Point(ModelUtils_1.ModelUtils.getSnappedPos(this.control.model, this.control.settings.gridSize, position.x + (this.control.settings.gridSize / 2 + 2), true), position.y);
else
return position.offset(this.control.settings.gridSize, 0);
};
return MoveStepRightCommand;
}(MoveCommand));
exports.MoveStepRightCommand = MoveStepRightCommand;
var MoveUpCommand = /** @class */ (function (_super) {
__extends(MoveUpCommand, _super);
function MoveUpCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
MoveUpCommand.prototype.getPosition = function (position) {
return position.offset(0, -UnitConverter_1.UnitConverter.pixelsToTwips(1));
};
return MoveUpCommand;
}(MoveCommand));
exports.MoveUpCommand = MoveUpCommand;
var MoveStepUpCommand = /** @class */ (function (_super) {
__extends(MoveStepUpCommand, _super);
function MoveStepUpCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
MoveStepUpCommand.prototype.getPosition = function (position) {
if (this.control.settings.snapToGrid)
return new Utils_1.Point(position.x, ModelUtils_1.ModelUtils.getSnappedPos(this.control.model, this.control.settings.gridSize, position.y - (this.control.settings.gridSize / 2 + 2), false));
else
return position.offset(0, -this.control.settings.gridSize);
};
return MoveStepUpCommand;
}(MoveCommand));
exports.MoveStepUpCommand = MoveStepUpCommand;
var MoveDownCommand = /** @class */ (function (_super) {
__extends(MoveDownCommand, _super);
function MoveDownCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
MoveDownCommand.prototype.getPosition = function (position) {
return position.offset(0, UnitConverter_1.UnitConverter.pixelsToTwips(1));
};
return MoveDownCommand;
}(MoveCommand));
exports.MoveDownCommand = MoveDownCommand;
var MoveStepDownCommand = /** @class */ (function (_super) {
__extends(MoveStepDownCommand, _super);
function MoveStepDownCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
MoveStepDownCommand.prototype.getPosition = function (position) {
if (this.control.settings.snapToGrid)
return new Utils_1.Point(position.x, ModelUtils_1.ModelUtils.getSnappedPos(this.control.model, this.control.settings.gridSize, position.y + (this.control.settings.gridSize / 2 + 2), false));
else
return position.offset(0, this.control.settings.gridSize);
};
return MoveStepDownCommand;
}(MoveCommand));
exports.MoveStepDownCommand = MoveStepDownCommand;
/***/ }),
/* 239 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var SimpleCommandBase_1 = __webpack_require__(7);
var DiagramSettings_1 = __webpack_require__(35);
var ChangeZoomLevelCommand = /** @class */ (function (_super) {
__extends(ChangeZoomLevelCommand, _super);
function ChangeZoomLevelCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeZoomLevelCommand.prototype.isEnabledInReadOnlyMode = function () {
return true;
};
ChangeZoomLevelCommand.prototype.getValue = function () {
return this.control.view.getZoom();
};
ChangeZoomLevelCommand.prototype.executeCore = function (state, parameter) {
this.control.settings.zoomLevel = parameter;
this.control.settings.autoZoom = DiagramSettings_1.AutoZoomMode.Disabled;
this.control.updateLayout(true);
return true;
};
ChangeZoomLevelCommand.prototype.getItems = function () {
return this.control.settings.zoomLevelItems.map(function (l) {
return { value: l, text: l * 100 + "%" };
});
};
return ChangeZoomLevelCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.ChangeZoomLevelCommand = ChangeZoomLevelCommand;
var ChangeZoomLevelItemsCommand = /** @class */ (function (_super) {
__extends(ChangeZoomLevelItemsCommand, _super);
function ChangeZoomLevelItemsCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeZoomLevelItemsCommand.prototype.isEnabledInReadOnlyMode = function () {
return true;
};
ChangeZoomLevelItemsCommand.prototype.getValue = function () {
return this.control.settings.zoomLevelItems;
};
ChangeZoomLevelItemsCommand.prototype.executeCore = function (state, parameter) {
this.control.settings.zoomLevelItems = parameter;
return true;
};
return ChangeZoomLevelItemsCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.ChangeZoomLevelItemsCommand = ChangeZoomLevelItemsCommand;
var FitZoomCommandBase = /** @class */ (function (_super) {
__extends(FitZoomCommandBase, _super);
function FitZoomCommandBase() {
return _super !== null && _super.apply(this, arguments) || this;
}
FitZoomCommandBase.prototype.isEnabled = function () {
return _super.prototype.isEnabled.call(this) && !!this.control.render;
};
FitZoomCommandBase.prototype.isEnabledInReadOnlyMode = function () {
return true;
};
FitZoomCommandBase.prototype.executeCore = function (state) {
var zoomLevel = this.getZoomLevel();
this.control.settings.zoomLevel = zoomLevel;
this.control.settings.autoZoom = DiagramSettings_1.AutoZoomMode.Disabled;
return true;
};
return FitZoomCommandBase;
}(SimpleCommandBase_1.SimpleCommandBase));
var FitToScreenCommand = /** @class */ (function (_super) {
__extends(FitToScreenCommand, _super);
function FitToScreenCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
FitToScreenCommand.prototype.getZoomLevel = function () {
return this.control.render.view.getActualAutoZoomLevel(DiagramSettings_1.AutoZoomMode.FitContent);
};
return FitToScreenCommand;
}(FitZoomCommandBase));
exports.FitToScreenCommand = FitToScreenCommand;
var FitToWidthCommand = /** @class */ (function (_super) {
__extends(FitToWidthCommand, _super);
function FitToWidthCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
FitToWidthCommand.prototype.getZoomLevel = function () {
return this.control.render.view.getActualAutoZoomLevel(DiagramSettings_1.AutoZoomMode.FitToWidth);
};
return FitToWidthCommand;
}(FitZoomCommandBase));
exports.FitToWidthCommand = FitToWidthCommand;
var SwitchAutoZoomCommand = /** @class */ (function (_super) {
__extends(SwitchAutoZoomCommand, _super);
function SwitchAutoZoomCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
SwitchAutoZoomCommand.prototype.isEnabled = function () {
return _super.prototype.isEnabled.call(this) && !!this.control.render;
};
SwitchAutoZoomCommand.prototype.isEnabledInReadOnlyMode = function () {
return true;
};
SwitchAutoZoomCommand.prototype.getValue = function () {
return this.control.settings.autoZoom;
};
SwitchAutoZoomCommand.prototype.executeCore = function (state, value) {
value = parseInt(value);
if (this.control.settings.autoZoom === value)
return false;
if (value === DiagramSettings_1.AutoZoomMode.Disabled)
this.control.settings.zoomLevel = this.control.view.getZoom();
this.control.settings.autoZoom = value;
return true;
};
return SwitchAutoZoomCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.SwitchAutoZoomCommand = SwitchAutoZoomCommand;
var ToggleAutoZoomCommand = /** @class */ (function (_super) {
__extends(ToggleAutoZoomCommand, _super);
function ToggleAutoZoomCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ToggleAutoZoomCommand.prototype.isEnabled = function () {
return _super.prototype.isEnabled.call(this) && !!this.control.render;
};
ToggleAutoZoomCommand.prototype.isEnabledInReadOnlyMode = function () {
return true;
};
ToggleAutoZoomCommand.prototype.getValue = function () {
return this.control.settings.autoZoom;
};
ToggleAutoZoomCommand.prototype.executeCore = function (state, value) {
var newValue;
if (value === undefined)
newValue = this.control.settings.autoZoom === DiagramSettings_1.AutoZoomMode.Disabled ? DiagramSettings_1.AutoZoomMode.FitContent : DiagramSettings_1.AutoZoomMode.Disabled;
else
newValue = value ? DiagramSettings_1.AutoZoomMode.FitContent : DiagramSettings_1.AutoZoomMode.Disabled;
if (this.control.settings.autoZoom === newValue)
return false;
if (!newValue)
this.control.settings.zoomLevel = this.control.view.getZoom();
this.control.settings.autoZoom = newValue;
return true;
};
return ToggleAutoZoomCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.ToggleAutoZoomCommand = ToggleAutoZoomCommand;
/***/ }),
/* 240 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ModelUtils_1 = __webpack_require__(6);
var ImportDataCommandBase_1 = __webpack_require__(241);
var DataLayoutParameters_1 = __webpack_require__(114);
var BindDocumentCommand = /** @class */ (function (_super) {
__extends(BindDocumentCommand, _super);
function BindDocumentCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
BindDocumentCommand.prototype.isEnabledInReadOnlyMode = function () {
return true;
};
BindDocumentCommand.prototype.performImportData = function (parameter) {
var dataSource = this.control.createDocumentDataSource(parameter.nodeDataSource, parameter.edgeDataSource, parameter.nodeDataImporter, parameter.edgeDataImporter);
var layoutParameters = (parameter.layoutParameters) ? new DataLayoutParameters_1.DataLayoutParameters(parameter.layoutParameters) : undefined;
this.control.history.beginTransaction();
ModelUtils_1.ModelUtils.deleteAllItems(this.control.history, this.control.model, this.control.selection);
this.createItems(dataSource, layoutParameters);
this.control.history.endTransaction();
this.control.history.clear();
};
return BindDocumentCommand;
}(ImportDataCommandBase_1.ImportDataCommandBase));
exports.BindDocumentCommand = BindDocumentCommand;
/***/ }),
/* 241 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var SimpleCommandBase_1 = __webpack_require__(7);
var ImportDataCommandBase = /** @class */ (function (_super) {
__extends(ImportDataCommandBase, _super);
function ImportDataCommandBase() {
return _super !== null && _super.apply(this, arguments) || this;
}
ImportDataCommandBase.prototype.executeCore = function (state, parameter) {
if (!parameter || !Array.isArray(parameter.nodeDataSource))
throw Error("Format exception");
this.performImportData(parameter);
this.control.updateLayout(true);
return true;
};
ImportDataCommandBase.prototype.createItems = function (dataSource, layoutParameters) {
dataSource.createModelItems(this.control.history, this.control.model, this.control.selection, layoutParameters, this.control.settings.snapToGrid, this.control.settings.gridSize);
};
return ImportDataCommandBase;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.ImportDataCommandBase = ImportDataCommandBase;
/***/ }),
/* 242 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ModelUtils_1 = __webpack_require__(6);
var SimpleCommandBase_1 = __webpack_require__(7);
var UnbindDocumentCommand = /** @class */ (function (_super) {
__extends(UnbindDocumentCommand, _super);
function UnbindDocumentCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
UnbindDocumentCommand.prototype.isEnabledInReadOnlyMode = function () {
return true;
};
UnbindDocumentCommand.prototype.executeCore = function (state) {
this.control.deleteDocumentDataSource();
ModelUtils_1.ModelUtils.deleteAllItems(this.control.history, this.control.model, this.control.selection);
this.control.history.clear();
return true;
};
return UnbindDocumentCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.UnbindDocumentCommand = UnbindDocumentCommand;
/***/ }),
/* 243 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var AutoLayoutCommandBase_1 = __webpack_require__(59);
var WideTree_1 = __webpack_require__(73);
var LayoutSettings_1 = __webpack_require__(22);
var AutoLayoutTreeHorizontalCommand = /** @class */ (function (_super) {
__extends(AutoLayoutTreeHorizontalCommand, _super);
function AutoLayoutTreeHorizontalCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
AutoLayoutTreeHorizontalCommand.prototype.createLayoutSettings = function () {
var gridSize = this.control.settings.snapToGrid ? this.control.settings.gridSize : undefined;
var settings = new LayoutSettings_1.TreeLayoutSettings(gridSize);
settings.orientation = LayoutSettings_1.DataLayoutOrientation.Horizontal;
return settings;
};
AutoLayoutTreeHorizontalCommand.prototype.createLayout = function (settings, graph) {
return new WideTree_1.TreeLayoutBuilder(settings, graph).build();
};
return AutoLayoutTreeHorizontalCommand;
}(AutoLayoutCommandBase_1.AutoLayoutCommandBase));
exports.AutoLayoutTreeHorizontalCommand = AutoLayoutTreeHorizontalCommand;
/***/ }),
/* 244 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var AutoLayoutCommandBase_1 = __webpack_require__(59);
var Sugiyama_1 = __webpack_require__(61);
var LayoutSettings_1 = __webpack_require__(22);
var AutoLayoutLayeredVerticalCommand = /** @class */ (function (_super) {
__extends(AutoLayoutLayeredVerticalCommand, _super);
function AutoLayoutLayeredVerticalCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
AutoLayoutLayeredVerticalCommand.prototype.createLayoutSettings = function () {
var settings = new LayoutSettings_1.LayoutSettings();
settings.orientation = LayoutSettings_1.DataLayoutOrientation.Vertical;
return settings;
};
AutoLayoutLayeredVerticalCommand.prototype.createLayout = function (settings, graph) {
return new Sugiyama_1.SugiyamaLayoutBuilder(settings, graph).build();
};
return AutoLayoutLayeredVerticalCommand;
}(AutoLayoutCommandBase_1.AutoLayoutCommandBase));
exports.AutoLayoutLayeredVerticalCommand = AutoLayoutLayeredVerticalCommand;
/***/ }),
/* 245 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangeLockedCommand_1 = __webpack_require__(115);
var LockCommand = /** @class */ (function (_super) {
__extends(LockCommand, _super);
function LockCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
LockCommand.prototype.getLockState = function () {
return true;
};
return LockCommand;
}(ChangeLockedCommand_1.ChangeLockedCommand));
exports.LockCommand = LockCommand;
/***/ }),
/* 246 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangeLockedCommand_1 = __webpack_require__(115);
var UnLockCommand = /** @class */ (function (_super) {
__extends(UnLockCommand, _super);
function UnLockCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
UnLockCommand.prototype.getLockState = function () {
return false;
};
return UnLockCommand;
}(ChangeLockedCommand_1.ChangeLockedCommand));
exports.UnLockCommand = UnLockCommand;
/***/ }),
/* 247 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Model_1 = __webpack_require__(19);
var ModelUtils_1 = __webpack_require__(6);
var SimpleCommandBase_1 = __webpack_require__(7);
var CloneCommand = /** @class */ (function (_super) {
__extends(CloneCommand, _super);
function CloneCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
CloneCommand.prototype.isEnabled = function () {
return _super.prototype.isEnabled.call(this) && !this.control.selection.isEmpty();
};
CloneCommand.prototype.executeCore = function (state, parameter) {
var selectionRect = Model_1.DiagramModel.getRectangle(this.control.selection.getSelectedItems());
ModelUtils_1.ModelUtils.cloneSelectionToOffset(this.control.history, this.control.model, this.control.selection, this.getOffsetX(selectionRect), this.getOffsetY(selectionRect));
return true;
};
CloneCommand.prototype.getOffsetX = function (selectionRect) {
return 0;
};
;
CloneCommand.prototype.getOffsetY = function (selectionRect) {
return 0;
};
;
return CloneCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.CloneCommand = CloneCommand;
var CloneLeftCommand = /** @class */ (function (_super) {
__extends(CloneLeftCommand, _super);
function CloneLeftCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
CloneLeftCommand.prototype.getOffsetX = function (selectionRect) {
return -selectionRect.width;
};
;
return CloneLeftCommand;
}(CloneCommand));
exports.CloneLeftCommand = CloneLeftCommand;
var CloneRightCommand = /** @class */ (function (_super) {
__extends(CloneRightCommand, _super);
function CloneRightCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
CloneRightCommand.prototype.getOffsetX = function (selectionRect) {
return selectionRect.width;
};
;
return CloneRightCommand;
}(CloneCommand));
exports.CloneRightCommand = CloneRightCommand;
var CloneUpCommand = /** @class */ (function (_super) {
__extends(CloneUpCommand, _super);
function CloneUpCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
CloneUpCommand.prototype.getOffsetY = function (selectionRect) {
return -selectionRect.height;
};
;
return CloneUpCommand;
}(CloneCommand));
exports.CloneUpCommand = CloneUpCommand;
var CloneDownCommand = /** @class */ (function (_super) {
__extends(CloneDownCommand, _super);
function CloneDownCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
CloneDownCommand.prototype.getOffsetY = function (selectionRect) {
return selectionRect.height;
};
;
return CloneDownCommand;
}(CloneCommand));
exports.CloneDownCommand = CloneDownCommand;
/***/ }),
/* 248 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangePagePropertyCommand_1 = __webpack_require__(60);
var ChangePagePropertyHistoryItem_1 = __webpack_require__(249);
var SimpleCommandBase_1 = __webpack_require__(7);
var ChangeUnitsCommand = /** @class */ (function (_super) {
__extends(ChangeUnitsCommand, _super);
function ChangeUnitsCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeUnitsCommand.prototype.isEnabledInReadOnlyMode = function () {
return true;
};
ChangeUnitsCommand.prototype.getValue = function () {
return this.control.model.units;
};
ChangeUnitsCommand.prototype.createHistoryItems = function (parameter) {
return [new ChangePagePropertyHistoryItem_1.ChangeUnitsHistoryItem(parameter)];
};
ChangeUnitsCommand.prototype.getItems = function () {
var _this = this;
return Object.keys(this.control.settings.unitItems).map(function (key) {
return { value: parseInt(key), text: _this.control.settings.unitItems[key] };
});
};
return ChangeUnitsCommand;
}(ChangePagePropertyCommand_1.ChangePagePropertyCommand));
exports.ChangeUnitsCommand = ChangeUnitsCommand;
var ChangeViewUnitsCommand = /** @class */ (function (_super) {
__extends(ChangeViewUnitsCommand, _super);
function ChangeViewUnitsCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeViewUnitsCommand.prototype.isEnabledInReadOnlyMode = function () {
return true;
};
ChangeViewUnitsCommand.prototype.getValue = function () {
return this.control.settings.viewUnits;
};
ChangeViewUnitsCommand.prototype.executeCore = function (state, parameter) {
this.control.settings.viewUnits = parameter;
return true;
};
ChangeViewUnitsCommand.prototype.getItems = function () {
var _this = this;
return Object.keys(this.control.settings.unitItems).map(function (key) {
return { value: parseInt(key), text: _this.control.settings.unitItems[key] };
});
};
return ChangeViewUnitsCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.ChangeViewUnitsCommand = ChangeViewUnitsCommand;
/***/ }),
/* 249 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var ChangePagePropertyHistoryItem = /** @class */ (function (_super) {
__extends(ChangePagePropertyHistoryItem, _super);
function ChangePagePropertyHistoryItem(value) {
var _this = _super.call(this) || this;
_this.value = value;
return _this;
}
ChangePagePropertyHistoryItem.prototype.redo = function (manipulator) {
var _this = this;
this.oldValue = this.getValue(manipulator.model);
manipulator.changePageProperty(function (m) { return _this.setValue(m, _this.value); });
};
ChangePagePropertyHistoryItem.prototype.undo = function (manipulator) {
var _this = this;
manipulator.changePageProperty(function (m) { return _this.setValue(m, _this.oldValue); });
};
return ChangePagePropertyHistoryItem;
}(HistoryItem_1.HistoryItem));
var ChangeUnitsHistoryItem = /** @class */ (function (_super) {
__extends(ChangeUnitsHistoryItem, _super);
function ChangeUnitsHistoryItem() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this.setValue = function (model, value) { return model.units = value; };
_this.getValue = function (model) { return model.units; };
return _this;
}
return ChangeUnitsHistoryItem;
}(ChangePagePropertyHistoryItem));
exports.ChangeUnitsHistoryItem = ChangeUnitsHistoryItem;
/***/ }),
/* 250 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ChangePagePropertyCommand_1 = __webpack_require__(60);
var ChangePageColorHistoryItem_1 = __webpack_require__(251);
var __1 = __webpack_require__(8);
var Model_1 = __webpack_require__(19);
var ChangePageColorCommand = /** @class */ (function (_super) {
__extends(ChangePageColorCommand, _super);
function ChangePageColorCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangePageColorCommand.prototype.getValue = function () {
return __1.ColorHelper.colorToHash(this.control.model.pageColor);
};
ChangePageColorCommand.prototype.getDefaultValue = function () {
return __1.ColorHelper.colorToHash(Model_1.DiagramModel.defaultPageColor);
};
ChangePageColorCommand.prototype.createHistoryItems = function (parameter) {
return [new ChangePageColorHistoryItem_1.ChangePageColorHistoryItem(__1.ColorHelper.stringToColor(parameter))];
};
return ChangePageColorCommand;
}(ChangePagePropertyCommand_1.ChangePagePropertyCommand));
exports.ChangePageColorCommand = ChangePageColorCommand;
/***/ }),
/* 251 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var ChangePageColorHistoryItem = /** @class */ (function (_super) {
__extends(ChangePageColorHistoryItem, _super);
function ChangePageColorHistoryItem(value) {
var _this = _super.call(this) || this;
_this.value = value;
return _this;
}
ChangePageColorHistoryItem.prototype.redo = function (manipulator) {
this.oldValue = manipulator.model.pageColor;
manipulator.changePageColor(this.value);
};
ChangePageColorHistoryItem.prototype.undo = function (manipulator) {
manipulator.changePageColor(this.oldValue);
};
return ChangePageColorHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.ChangePageColorHistoryItem = ChangePageColorHistoryItem;
/***/ }),
/* 252 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var SimpleCommandBase_1 = __webpack_require__(7);
var ChangeShowGridCommand = /** @class */ (function (_super) {
__extends(ChangeShowGridCommand, _super);
function ChangeShowGridCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ChangeShowGridCommand.prototype.isEnabledInReadOnlyMode = function () {
return true;
};
ChangeShowGridCommand.prototype.executeCore = function (state, parameter) {
var newValue = parameter === undefined ? !this.control.settings.showGrid : !!parameter;
if (this.control.settings.showGrid !== newValue) {
this.control.settings.showGrid = newValue;
return true;
}
return false;
};
ChangeShowGridCommand.prototype.getValue = function () {
return this.control.settings.showGrid;
};
return ChangeShowGridCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.ChangeShowGridCommand = ChangeShowGridCommand;
/***/ }),
/* 253 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var SimpleCommandBase_1 = __webpack_require__(7);
var ToggleFullscreenCommand = /** @class */ (function (_super) {
__extends(ToggleFullscreenCommand, _super);
function ToggleFullscreenCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ToggleFullscreenCommand.prototype.isEnabledInReadOnlyMode = function () {
return true;
};
ToggleFullscreenCommand.prototype.getValue = function () {
return this.control.settings.fullscreen;
};
ToggleFullscreenCommand.prototype.executeCore = function (state, parameter) {
var newValue = typeof parameter === "boolean" ? parameter : !state.value;
if (this.control.settings.fullscreen !== newValue) {
this.control.settings.fullscreen = !state.value;
this.control.notifyToggleFullscreen(this.control.settings.fullscreen);
}
return true;
};
return ToggleFullscreenCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.ToggleFullscreenCommand = ToggleFullscreenCommand;
/***/ }),
/* 254 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var SimpleCommandBase_1 = __webpack_require__(7);
var ToggleSimpleViewCommand = /** @class */ (function (_super) {
__extends(ToggleSimpleViewCommand, _super);
function ToggleSimpleViewCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ToggleSimpleViewCommand.prototype.isEnabledInReadOnlyMode = function () {
return true;
};
ToggleSimpleViewCommand.prototype.getValue = function () {
return this.control.settings.simpleView;
};
ToggleSimpleViewCommand.prototype.executeCore = function (state, parameter) {
if (typeof parameter === "boolean")
this.control.settings.simpleView = parameter;
else if (parameter === undefined)
this.control.settings.simpleView = !state.value;
this.control.updateLayout(true);
return true;
};
return ToggleSimpleViewCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.ToggleSimpleViewCommand = ToggleSimpleViewCommand;
/***/ }),
/* 255 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var SimpleCommandBase_1 = __webpack_require__(7);
var ToggleReadOnlyCommand = /** @class */ (function (_super) {
__extends(ToggleReadOnlyCommand, _super);
function ToggleReadOnlyCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ToggleReadOnlyCommand.prototype.isEnabledInReadOnlyMode = function () {
return true;
};
ToggleReadOnlyCommand.prototype.getValue = function () {
return this.control.settings.readOnly;
};
ToggleReadOnlyCommand.prototype.executeCore = function (state, parameter) {
if (typeof parameter === "boolean")
this.control.settings.readOnly = parameter;
else if (parameter === undefined)
this.control.settings.readOnly = !state.value;
return true;
};
return ToggleReadOnlyCommand;
}(SimpleCommandBase_1.SimpleCommandBase));
exports.ToggleReadOnlyCommand = ToggleReadOnlyCommand;
/***/ }),
/* 256 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var EditShapeImageCommandBase_1 = __webpack_require__(77);
var EditShapeImageCommand = /** @class */ (function (_super) {
__extends(EditShapeImageCommand, _super);
function EditShapeImageCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
EditShapeImageCommand.prototype.isEnabled = function () {
var selectedShape = this.getSelectedShape();
return _super.prototype.isEnabled.call(this) && !selectedShape.image.isEmpty;
};
return EditShapeImageCommand;
}(EditShapeImageCommandBase_1.EditShapeImageCommandBase));
exports.EditShapeImageCommand = EditShapeImageCommand;
/***/ }),
/* 257 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var PasteSelectoinCommandBase_1 = __webpack_require__(113);
var Shape_1 = __webpack_require__(11);
var Connector_1 = __webpack_require__(5);
var PasteSelectionInPositionCommand = /** @class */ (function (_super) {
__extends(PasteSelectionInPositionCommand, _super);
function PasteSelectionInPositionCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
PasteSelectionInPositionCommand.prototype.calculateSelectionOffset = function (items, position) {
var selectionPos = items.reduce(function (min, i) {
return {
x: Math.min(min.x, i instanceof Shape_1.Shape ? i.position.x : i instanceof Connector_1.Connector ? i.getMinX() : Number.MAX_VALUE),
y: Math.min(min.y, i instanceof Shape_1.Shape ? i.position.y : i instanceof Connector_1.Connector ? i.getMinY() : Number.MAX_VALUE)
};
}, {
x: Number.MAX_VALUE,
y: Number.MAX_VALUE
});
var newSelectionPos = this.control.render.getModelPointByEventPoint(position.x, position.y);
this.offsetX = newSelectionPos.x - selectionPos.x;
this.offsetY = newSelectionPos.y - selectionPos.y;
};
PasteSelectionInPositionCommand.prototype.getShapeNewPosition = function (position) {
var newPosition = position.offset(this.offsetX, this.offsetY);
return PasteSelectoinCommandBase_1.PasteSelectionCommandBase.getShapeNewPosition(this.control.model, newPosition);
};
PasteSelectionInPositionCommand.prototype.changeConnectorPoints = function (connector) {
var _this = this;
connector.points.forEach(function (pt) {
pt.x += _this.offsetX;
pt.y += _this.offsetY;
});
PasteSelectoinCommandBase_1.PasteSelectionCommandBase.changeConnectorPoints(this.control.model, connector);
};
return PasteSelectionInPositionCommand;
}(PasteSelectoinCommandBase_1.PasteSelectionCommandBase));
exports.PasteSelectionInPositionCommand = PasteSelectionInPositionCommand;
/***/ }),
/* 258 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var XMLImporter_1 = __webpack_require__(259);
var ExportImportCommandBase_1 = __webpack_require__(47);
var ImportXMLCommand = /** @class */ (function (_super) {
__extends(ImportXMLCommand, _super);
function ImportXMLCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
ImportXMLCommand.prototype.executeCore = function (state, parameter) {
var importer = new XMLImporter_1.XmlImporter(parameter);
var model = importer.import();
this.control.importModel(model);
return true;
};
return ImportXMLCommand;
}(ExportImportCommandBase_1.ExportImportCommandBase));
exports.ImportXMLCommand = ImportXMLCommand;
/***/ }),
/* 259 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Connector_1 = __webpack_require__(5);
var Shape_1 = __webpack_require__(11);
var ImporterBase_1 = __webpack_require__(106);
var __1 = __webpack_require__(8);
var ShapeTypes_1 = __webpack_require__(1);
var ShapeDescriptionManager_1 = __webpack_require__(25);
var Utils_1 = __webpack_require__(0);
var ImportUtils_1 = __webpack_require__(71);
var Color_1 = __webpack_require__(38);
var XmlImporter = /** @class */ (function (_super) {
__extends(XmlImporter, _super);
function XmlImporter(xml) {
var _this = _super.call(this) || this;
_this.doc = ImportUtils_1.ImportUtils.createDocument(xml);
return _this;
}
XmlImporter.prototype.getObject = function () {
return this.doc;
};
XmlImporter.prototype.getPageObject = function (obj) {
var pageElements = this.doc.querySelectorAll("[ItemKind='DiagramRoot']");
return pageElements && pageElements[0];
};
XmlImporter.prototype.getShapeObjects = function (obj) {
var shapeObjs = [];
this.doc.querySelectorAll("[ItemKind='DiagramRoot'] > Children > [ItemKind='DiagramShape']").forEach(function (obj) { shapeObjs.push(obj); });
this.doc.querySelectorAll("[ItemKind='DiagramRoot'] > Children > [ItemKind='DiagramContainer']").forEach(function (obj) { shapeObjs.push(obj); });
return shapeObjs;
};
XmlImporter.prototype.getConnectorObjects = function (obj) {
var connectorObjs = [];
this.doc.querySelectorAll("[ItemKind='DiagramRoot'] > Children > [ItemKind='DiagramConnector']").forEach(function (obj) { connectorObjs.push(obj); });
return connectorObjs;
};
XmlImporter.prototype.importPageSettings = function (model, pageObj) {
if (!pageObj)
return;
var pageSizeAttr = pageObj.getAttribute("PageSize");
var pageSize = this.getSize(pageSizeAttr);
if (pageSize) {
model.size = pageSize.clone();
model.pageSize = pageSize.clone();
}
};
XmlImporter.prototype.importShape = function (shapeObj) {
var positionAttr = shapeObj.getAttribute("Position");
var position = this.getPoint(positionAttr);
var shapeAttr = shapeObj.getAttribute("Shape");
var shapeType = this.getShapeType(shapeAttr);
var description = ShapeDescriptionManager_1.ShapeDescriptionManager.get(shapeType);
var shape = new Shape_1.Shape(description || ShapeDescriptionManager_1.ShapeDescriptionManager.get(ShapeTypes_1.ShapeTypes.Rectangle), position);
shape.key = this.getItemKey(shapeObj);
var sizeAttr = shapeObj.getAttribute("Size");
var size = this.getSize(sizeAttr);
if (size)
shape.size = size;
var contentAttr = shapeObj.getAttribute("Content");
if (typeof contentAttr === "string")
shape.text = contentAttr;
else {
var headerAttr = shapeObj.getAttribute("Header");
if (typeof headerAttr === "string")
shape.text = headerAttr;
}
this.importStyle(shapeObj, shape);
return shape;
};
XmlImporter.prototype.importShapeChildren = function (shapeObj, shape) {
var childShapeObjs = [];
shapeObj.setAttribute("dxDiagram", "");
this.doc.querySelectorAll("[dxDiagram] > Children > [ItemKind='DiagramShape']").forEach(function (obj) { childShapeObjs.push(obj); });
this.doc.querySelectorAll("[dxDiagram] > Children > [ItemKind='DiagramContainer']").forEach(function (obj) { childShapeObjs.push(obj); });
shapeObj.removeAttribute("dxDiagram");
var result = [];
if (!childShapeObjs)
return result;
for (var i = 0; i < childShapeObjs.length; i++) {
var childShapeObj = childShapeObjs[i];
var childShape = this.importShape(childShapeObj);
childShape.key = shape.key + "," + childShape.key;
var rect = shape.clientRectangle;
childShape.position = childShape.position.offset(rect.left, rect.top);
shape.childKeys.push(childShape.key);
result.push(childShape);
result = result.concat(this.importShapeChildren(childShapeObj, childShape));
}
return result;
};
XmlImporter.prototype.importConnector = function (connectorObj) {
var _this = this;
var points = [];
var beginPointAttr = connectorObj.getAttribute("BeginPoint");
var beginPoint = this.getPoint(beginPointAttr);
if (beginPoint)
points.push(beginPoint);
var pointsAttr = connectorObj.getAttribute("Points");
pointsAttr.split(" ").forEach(function (pointAttr) {
var point = _this.getPoint(pointAttr);
if (point)
points.push(point);
});
var endPointAttr = connectorObj.getAttribute("EndPoint");
var endPoint = this.getPoint(endPointAttr);
if (endPoint)
points.push(endPoint);
var connector = new Connector_1.Connector(points);
connector.key = this.getItemKey(connectorObj);
var endItemPointIndexAttr = connectorObj.getAttribute("EndItemPointIndex");
var endItemPointIndex = parseInt(endItemPointIndexAttr);
connector.endConnectionPointIndex = !isNaN(endItemPointIndex) ? endItemPointIndex : -1;
var beginItemPointIndexAttr = connectorObj.getAttribute("BeginItemPointIndex");
var beginItemPointIndex = parseInt(beginItemPointIndexAttr);
connector.beginConnectionPointIndex = !isNaN(beginItemPointIndex) ? beginItemPointIndex : -1;
var endItemAttr = connectorObj.getAttribute("EndItem");
if (endItemAttr !== undefined)
this.assert(endItemAttr, "string");
var beginItemAttr = connectorObj.getAttribute("BeginItem");
if (beginItemAttr !== undefined)
this.assert(beginItemAttr, "string");
connector["endItemKey"] = endItemAttr;
connector["beginItemKey"] = beginItemAttr;
var contentAttr = connectorObj.getAttribute("Content");
if (typeof contentAttr === "string")
connector.setText(contentAttr);
this.importStyle(connectorObj, connector);
return connector;
};
XmlImporter.prototype.importStyle = function (obj, item) {
var backgroundAttr = obj.getAttribute("Background");
if (typeof backgroundAttr === "string")
item.style["fill"] = this.getColor(backgroundAttr);
var strokeAttr = obj.getAttribute("Stroke");
if (typeof strokeAttr === "string")
item.style["stroke"] = this.getColor(strokeAttr);
var foregroundAttr = obj.getAttribute("Foreground");
if (typeof foregroundAttr === "string")
item.styleText["fill"] = this.getColor(foregroundAttr);
var fontFamilyAttr = obj.getAttribute("FontFamily");
if (typeof fontFamilyAttr === "string")
item.styleText["font-family"] = fontFamilyAttr;
var fontSizeAttr = obj.getAttribute("FontSize");
if (typeof fontSizeAttr === "string")
item.styleText["font-size"] = fontSizeAttr;
var fontWeightAttr = obj.getAttribute("FontWeight");
if (fontWeightAttr === "Bold")
item.styleText["font-weight"] = "bold";
var fontStyleAttr = obj.getAttribute("FontStyle");
if (fontStyleAttr === "Italic")
item.styleText["font-style"] = "italic";
var textDecorationsAttr = obj.getAttribute("TextDecorations");
if (textDecorationsAttr === "Underline")
item.styleText["text-decoration"] = "underline";
var textAlignmentAttr = obj.getAttribute("TextAlignment");
if (textAlignmentAttr === "Left")
item.styleText["text-anchor"] = "start";
else if (textAlignmentAttr === "Right")
item.styleText["text-anchor"] = "end";
else if (textAlignmentAttr === "Right")
item.styleText["text-anchor"] = "middle";
};
XmlImporter.prototype.getShapeType = function (shapeAttr) {
if (XmlImporter.shapeTypes[shapeAttr])
return XmlImporter.shapeTypes[shapeAttr];
if (shapeAttr && shapeAttr.toLowerCase().indexOf("container") > -1)
return ShapeTypes_1.ShapeTypes.VerticalContainer;
return ShapeTypes_1.ShapeTypes.Rectangle;
};
XmlImporter.prototype.getItemKey = function (obj) {
return (parseInt(obj.tagName.replace("Item", "")) - 1).toString();
};
XmlImporter.prototype.getNumbers = function (s) {
var parts = s.split(",");
return parts && parts.length ? parts.map(function (part) { return +part; }) : [];
};
XmlImporter.prototype.getSize = function (attrValue) {
if (attrValue) {
var numbers = this.getNumbers(attrValue);
if (numbers.length >= 2) {
this.assert(numbers[0], "number");
this.assert(numbers[1], "number");
return new Utils_1.Size(__1.UnitConverter.pixelsToTwips(numbers[0]), __1.UnitConverter.pixelsToTwips(numbers[1]));
}
}
};
XmlImporter.prototype.getPoint = function (attrValue) {
if (attrValue) {
var numbers = this.getNumbers(attrValue);
if (numbers.length >= 2) {
this.assert(numbers[0], "number");
this.assert(numbers[1], "number");
return new Utils_1.Point(__1.UnitConverter.pixelsToTwips(numbers[0]), __1.UnitConverter.pixelsToTwips(numbers[1]));
}
}
};
XmlImporter.prototype.getColor = function (attrValue) {
attrValue = attrValue.charAt(0) == "#" ? attrValue.substr(1) : attrValue;
var color = parseInt(attrValue, 16);
return !isNaN(color) ? Color_1.ColorHelper.colorToHash(color) : undefined;
};
XmlImporter.shapeTypes = {
"BasicShapes.Rectangle": ShapeTypes_1.ShapeTypes.Rectangle,
"BasicShapes.Ellipse": ShapeTypes_1.ShapeTypes.Ellipse,
"BasicShapes.Triangle": ShapeTypes_1.ShapeTypes.Triangle,
"BasicShapes.Pentagon": ShapeTypes_1.ShapeTypes.Pentagon,
"BasicShapes.Hexagon": ShapeTypes_1.ShapeTypes.Hexagon,
"BasicShapes.Octagon": ShapeTypes_1.ShapeTypes.Octagon,
"BasicShapes.Diamond": ShapeTypes_1.ShapeTypes.Diamond,
"BasicShapes.Cross": ShapeTypes_1.ShapeTypes.Cross,
"BasicShapes.Star5": ShapeTypes_1.ShapeTypes.Star,
"BasicFlowchartShapes.StartEnd": ShapeTypes_1.ShapeTypes.Terminator,
"BasicFlowchartShapes.Data": ShapeTypes_1.ShapeTypes.Data,
"BasicFlowchartShapes.Database": ShapeTypes_1.ShapeTypes.Database,
"BasicFlowchartShapes.ExternalData": ShapeTypes_1.ShapeTypes.StoredData,
"BasicFlowchartShapes.Process": ShapeTypes_1.ShapeTypes.Process,
"BasicFlowchartShapes.Decision": ShapeTypes_1.ShapeTypes.Decision,
"BasicFlowchartShapes.Subprocess": ShapeTypes_1.ShapeTypes.PredefinedProcess,
"BasicFlowchartShapes.Document": ShapeTypes_1.ShapeTypes.Document,
"BasicFlowchartShapes.Custom1": ShapeTypes_1.ShapeTypes.ManualInput,
"BasicFlowchartShapes.Custom2": ShapeTypes_1.ShapeTypes.ManualOperation,
"ArrowShapes.SimpleArrow": ShapeTypes_1.ShapeTypes.ArrowLeft,
"ArrowShapes.SimpleDoubleArrow": ShapeTypes_1.ShapeTypes.ArrowEastWest
};
return XmlImporter;
}(ImporterBase_1.ImporterBase));
exports.XmlImporter = XmlImporter;
/***/ }),
/* 260 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var EditShapeImageCommandBase_1 = __webpack_require__(77);
var InsertShapeImageCommand = /** @class */ (function (_super) {
__extends(InsertShapeImageCommand, _super);
function InsertShapeImageCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
InsertShapeImageCommand.prototype.isEnabled = function () {
var selectedShape = this.getSelectedShape();
return _super.prototype.isEnabled.call(this) && selectedShape.image.isEmpty;
};
return InsertShapeImageCommand;
}(EditShapeImageCommandBase_1.EditShapeImageCommandBase));
exports.InsertShapeImageCommand = InsertShapeImageCommand;
/***/ }),
/* 261 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var EditShapeImageCommandBase_1 = __webpack_require__(77);
var DeleteShapeImageCommand = /** @class */ (function (_super) {
__extends(DeleteShapeImageCommand, _super);
function DeleteShapeImageCommand() {
return _super !== null && _super.apply(this, arguments) || this;
}
DeleteShapeImageCommand.prototype.isEnabled = function () {
var selectedShape = this.getSelectedShape();
return _super.prototype.isEnabled.call(this) && !selectedShape.image.isEmpty;
};
DeleteShapeImageCommand.prototype.executeCore = function (state, parameter) {
return _super.prototype.executeCore.call(this, state, undefined);
};
return DeleteShapeImageCommand;
}(EditShapeImageCommandBase_1.EditShapeImageCommandBase));
exports.DeleteShapeImageCommand = DeleteShapeImageCommand;
/***/ }),
/* 262 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ModelManipulator_1 = __webpack_require__(263);
var CommandManager_1 = __webpack_require__(48);
var EventManager_1 = __webpack_require__(264);
var Model_1 = __webpack_require__(19);
var Selection_1 = __webpack_require__(293);
var History_1 = __webpack_require__(295);
var BarManager_1 = __webpack_require__(296);
var RenderManager_1 = __webpack_require__(12);
var ShapeDescriptionManager_1 = __webpack_require__(25);
var DocumentDataSource_1 = __webpack_require__(297);
var DiagramSettings_1 = __webpack_require__(35);
var ViewController_1 = __webpack_require__(301);
var ModelUtils_1 = __webpack_require__(6);
var ToolboxManager_1 = __webpack_require__(302);
var _1 = __webpack_require__(8);
var ApiController_1 = __webpack_require__(305);
var DiagramControl = /** @class */ (function () {
function DiagramControl() {
this.processDataChangesNeeded = false;
this.settings = new DiagramSettings_1.DiagramSettings();
this.model = new Model_1.DiagramModel();
this.selection = new Selection_1.Selection(this.model);
this.modelManipulator = new ModelManipulator_1.ModelManipulator(this.model);
this.history = new History_1.History(this.modelManipulator);
this.onNativeAction = new _1.EventDispatcher();
this.view = new ViewController_1.ViewController(this.settings);
this.commandManager = new CommandManager_1.CommandManager(this);
this.barManager = new BarManager_1.BarManager(this);
this.eventManager = new EventManager_1.EventManager(this);
this.selection.onChanged.add(this.barManager);
this.selection.onChanged.add(this);
this.modelManipulator.onLoad();
this.history.onChanged.add(this);
this.toolboxManager = new ToolboxManager_1.ToolboxManager(this.settings.readOnly);
this.settings.onReadOnlyChanged.add(this.toolboxManager);
this.apiController = new ApiController_1.ApiController(this.onNativeAction, this.selection, this.model);
}
DiagramControl.prototype.dispose = function () {
this.toolboxManager.dispose();
if (this.render)
this.render.dispose();
};
DiagramControl.prototype.createDocument = function (parent) {
if (this.render)
this.render.replaceParent(parent);
else {
this.render = new RenderManager_1.RenderManager(parent, this.eventManager, {
pageColor: this.model.pageColor,
modelSize: this.model.size,
pageLandscape: this.model.pageLandscape,
pageSize: this.model.pageSize,
simpleView: this.settings.simpleView,
readOnly: this.settings.readOnly,
gridSize: this.settings.gridSize,
gridVisible: this.settings.showGrid,
zoomLevel: this.settings.zoomLevel,
autoZoom: this.settings.autoZoom,
rectangle: this.model.getRectangle(true)
});
this.settings.onZoomChanged.add(this.render.view);
this.settings.onViewChanged.add(this.render.page);
this.settings.onViewChanged.add(this.render.view);
this.settings.onReadOnlyChanged.add(this.eventManager.mouseHandler);
this.settings.onReadOnlyChanged.add(this.eventManager.visualizersManager);
this.settings.onReadOnlyChanged.add(this.render);
this.settings.onReadOnlyChanged.add(this.render.selection);
this.eventManager.onTextInputOperation.add(this.render.input);
this.eventManager.onTextInputOperation.add(this.render.items);
this.eventManager.onTextInputOperation.add(this.render.selection);
this.eventManager.onMouseOperation.add(this.render.items);
this.eventManager.onMouseOperation.add(this.render.selection);
this.eventManager.onMouseOperation.add(this.render.view);
this.eventManager.onMouseOperation.add(this.render);
this.eventManager.onVisualizersUpdate.add(this.render.selection);
this.modelManipulator.onModelSizeChanged.add(this.render.view);
this.modelManipulator.onModelSizeChanged.add(this.render.page);
this.modelManipulator.onModelChanged.add(this.render.items);
this.modelManipulator.onModelChanged.add(this.render.page);
this.modelManipulator.onModelChanged.add(this.render.selection);
this.selection.onChanged.add(this.render.selection);
this.render.update(false);
this.modelManipulator.onLoad();
this.view.initialize(this.render.view);
this.selection.onLoad();
}
};
DiagramControl.prototype.createToolbox = function (parent, shapeIconSize, shapeIconSpacing, shapeIconAttributes, shapes, renderAsText) {
var toolbox = this.toolboxManager.create(parent, shapeIconSize, shapeIconSpacing, shapeIconAttributes, shapes, renderAsText);
this.settings.onReadOnlyChanged.add(toolbox);
toolbox.onDragOperation.add(this);
this.eventManager.registerToolbox(toolbox);
};
DiagramControl.prototype.applyToolboxFilter = function (shapeSubstring, filteringToolboxes) {
return this.toolboxManager.applyFilter(shapeSubstring, filteringToolboxes);
};
DiagramControl.prototype.updateLayout = function (resetScroll) {
if (resetScroll === void 0) { resetScroll = false; }
this.render && this.render.update(!resetScroll);
};
DiagramControl.prototype.captureFocus = function () {
this.render && this.render.input.captureFocus();
};
DiagramControl.prototype.isFocused = function () {
return !this.render || this.render.input.isFocused();
};
DiagramControl.prototype.addCustomShapes = function (shapes) {
var _this = this;
shapes.forEach(function (shape) {
if (shape.defaultWidth)
shape.defaultWidth = ModelUtils_1.ModelUtils.getTwipsValue(_this.model.units, shape.defaultWidth);
if (shape.defaultHeight)
shape.defaultHeight = ModelUtils_1.ModelUtils.getTwipsValue(_this.model.units, shape.defaultHeight);
ShapeDescriptionManager_1.ShapeDescriptionManager.registerCustomShape(shape);
});
};
DiagramControl.prototype.removeCustomShapes = function (shapeTypes) {
shapeTypes.forEach(function (shapeType) {
ShapeDescriptionManager_1.ShapeDescriptionManager.unregisterCustomShape(shapeType);
});
};
DiagramControl.prototype.importModel = function (model) {
this.model = model;
this.apiController.model = model;
this.importData();
};
DiagramControl.prototype.importItemsData = function () {
this.model.invalidateItems();
this.importData();
};
DiagramControl.prototype.importData = function () {
this.render && this.render.clear();
this.selection.initialize(this.model);
this.modelManipulator.load(this.model);
this.history.clear();
this.eventManager.initialize();
this.modelManipulator.onLoad();
};
DiagramControl.prototype.createDocumentDataSource = function (nodeDataSource, edgeDataSource, nodeDataImporter, edgeDataImporter) {
this.documentDataSource = new DocumentDataSource_1.DocumentDataSource(this, nodeDataSource, edgeDataSource, nodeDataImporter, edgeDataImporter);
return this.documentDataSource;
};
DiagramControl.prototype.deleteDocumentDataSource = function () {
delete this.documentDataSource;
};
DiagramControl.prototype.beginUpdate = function (lockUpdateCanvas) {
this.barManager.beginUpdate();
if (lockUpdateCanvas && this.render)
this.render.items.beginUpdate();
this.apiController.beginUpdate();
};
DiagramControl.prototype.endUpdate = function (lockUpdateCanvas) {
if (lockUpdateCanvas && this.render)
this.render.items.endUpdate();
this.barManager.endUpdate();
this.apiController.endUpdate();
};
DiagramControl.prototype.notifyEdgeInserted = function (data, callback, errorCallback) {
if (this.onEdgeInserted)
this.onEdgeInserted(data, callback, errorCallback);
};
DiagramControl.prototype.notifyEdgeUpdated = function (key, data, callback, errorCallback) {
if (this.onEdgeUpdated)
this.onEdgeUpdated(key, data, callback, errorCallback);
};
DiagramControl.prototype.notifyEdgeRemoved = function (key, data, callback, errorCallback) {
if (this.onEdgeUpdated)
this.onEdgeRemoved(key, data, callback, errorCallback);
};
DiagramControl.prototype.notifyNodeInserted = function (data, callback, errorCallback) {
if (this.onNodeInserted)
this.onNodeInserted(data, callback, errorCallback);
};
DiagramControl.prototype.notifyNodeUpdated = function (key, data, callback, errorCallback) {
if (this.onNodeUpdated)
this.onNodeUpdated(key, data, callback, errorCallback);
};
DiagramControl.prototype.notifyNodeRemoved = function (key, data, callback, errorCallback) {
if (this.onNodeRemoved)
this.onNodeRemoved(key, data, callback, errorCallback);
};
DiagramControl.prototype.notifySelectionChanged = function (selection) {
this.apiController.onSelectionChanged();
};
DiagramControl.prototype.checkProcessDataChanges = function () {
if (this.documentDataSource.isUpdateLocked()) {
this.processDataChangesNeeded = true;
return;
}
this.processDataChanges();
};
DiagramControl.prototype.processDataChanges = function (force) {
if (force === void 0) { force = true; }
if (force || this.processDataChangesNeeded) {
this.documentDataSource.updateItemsByModel(this.model);
this.processDataChangesNeeded = false;
}
if (!this.documentDataSource.isUpdateLocked())
this.raiseOnChanged();
};
DiagramControl.prototype.notifyHistoryChanged = function () {
if (this.settings.readOnly)
return;
if (this.documentDataSource)
this.checkProcessDataChanges();
else
this.raiseOnChanged();
};
DiagramControl.prototype.raiseOnChanged = function () {
if (this.onChanged)
this.onChanged();
};
DiagramControl.prototype.notifyToolboxDragStart = function () {
if (this.onToolboxDragStart)
this.onToolboxDragStart();
};
DiagramControl.prototype.notifyToolboxDragEnd = function () {
if (this.onToolboxDragEnd)
this.onToolboxDragEnd();
};
DiagramControl.prototype.notifyToggleFullscreen = function (value) {
if (this.onToggleFullscreen)
this.onToggleFullscreen(value);
};
DiagramControl.prototype.notifyShowContextMenu = function (eventPoint, modelPoint) {
if (this.onShowContextMenu && this.render) {
var selection = void 0;
var selectedItems = this.selection.getSelectedItems(true);
if (selectedItems.length > 0) {
var rect = Model_1.DiagramModel.getRectangle(this.selection.getSelectedItems(true));
var pos = this.render.getEventPointByModelPoint(rect.position);
var size = this.render.view.getAbsoluteSize(rect.size);
selection = { x: pos.x, y: pos.y, width: size.width, height: size.height };
}
if (eventPoint)
this.onShowContextMenu(eventPoint.x, eventPoint.y, selection);
else if (modelPoint) {
var point = this.render.getEventPointByModelPoint(modelPoint);
this.onShowContextMenu(point.x, point.y, selection);
}
}
};
DiagramControl.prototype.notifyHideContextMenu = function () {
if (this.onHideContextMenu && this.render)
this.onHideContextMenu();
};
return DiagramControl;
}());
exports.DiagramControl = DiagramControl;
/***/ }),
/* 263 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ModelChange_1 = __webpack_require__(83);
var Utils_1 = __webpack_require__(0);
var Connector_1 = __webpack_require__(5);
var ImageCache_1 = __webpack_require__(49);
var ImageLoader_1 = __webpack_require__(100);
var ModelManipulator = /** @class */ (function () {
function ModelManipulator(model) {
this.onModelChanged = new Utils_1.EventDispatcher();
this.onModelSizeChanged = new Utils_1.EventDispatcher();
this.model = model;
this.imageLoader = new ImageLoader_1.ImageLoader(this.updateShapeImage.bind(this));
}
ModelManipulator.prototype.load = function (model) {
this.model = model;
this.model.loadAllImages(this.imageLoader);
this.updateModelSize();
this.raisePageSizeChanged(model.pageSize.clone(), model.pageLandscape);
this.raiseModelSizeChanged(model.size.clone());
this.raisePageColorChanged(model.pageColor);
this.raiseModelRectangleChanged(Utils_1.GeometryUtils.getCommonRectangle(model.items.map(function (i) { return i.rectangle; })));
};
ModelManipulator.prototype.onLoad = function () {
var changes = [];
this.model.iterateItems(function (item) {
changes.push(new ModelChange_1.ItemChange(item, ModelChange_1.ItemChangeType.Create));
});
this.raiseModelChanged(changes);
};
// Items
ModelManipulator.prototype.insertToContainer = function (item, container) {
if (item.container && container && item.container.key !== container.key)
throw Error("To insert an item to a container it's necessary to remove it from the current container.");
if (container) {
container.childKeys.push(item.key);
item.container = container;
this.raiseModelChanged([new ModelChange_1.ItemChange(item, ModelChange_1.ItemChangeType.Update)]);
}
};
ModelManipulator.prototype.removeFromContainer = function (item) {
if (item.container) {
var index = item.container.childKeys.indexOf(item.key);
item.container.childKeys.splice(index, 1);
item.container = undefined;
this.raiseModelChanged([new ModelChange_1.ItemChange(item, ModelChange_1.ItemChangeType.Update)]);
}
};
ModelManipulator.prototype.changeStyle = function (item, styleProperty, styleValue) {
this.changeStyleCore(item, item.style, styleProperty, styleValue);
};
ModelManipulator.prototype.changeStyleText = function (item, styleProperty, styleValue) {
this.changeStyleCore(item, item.styleText, styleProperty, styleValue);
};
ModelManipulator.prototype.changeStyleCore = function (item, styleObj, styleProperty, styleValue) {
if (styleValue !== undefined)
styleObj[styleProperty] = styleValue;
else
delete styleObj[styleProperty];
item.invalidatePrimitives();
this.raiseModelChanged([new ModelChange_1.ItemChange(item, ModelChange_1.ItemChangeType.Update)]);
};
ModelManipulator.prototype.changeZIndex = function (item, zIndex) {
item.zIndex = zIndex;
this.raiseModelChanged([new ModelChange_1.ItemChange(item, ModelChange_1.ItemChangeType.Update)]);
};
ModelManipulator.prototype.changeLocked = function (item, locked) {
item.locked = locked;
this.raiseModelChanged([new ModelChange_1.ItemChange(item, ModelChange_1.ItemChangeType.Update)]);
};
ModelManipulator.prototype.changeContainerLocked = function (item, locked) {
item.containerLocked = locked;
this.raiseModelChanged([new ModelChange_1.ItemChange(item, ModelChange_1.ItemChangeType.Update)]);
};
// Shapes
ModelManipulator.prototype.addShape = function (shape, key) {
if (shape.attachedConnectors.length)
throw Error("A creating shape should not contain existing connectors.");
shape.key = key !== undefined ? key : this.model.getNextKey();
return this.insertShape(shape);
};
ModelManipulator.prototype.insertShape = function (shape) {
this.model.pushItem(shape);
this.raiseModelChanged([new ModelChange_1.ItemChange(shape, ModelChange_1.ItemChangeType.Create)]);
this.model.loadAllImages(this.imageLoader);
return shape;
};
ModelManipulator.prototype.resizeShape = function (shape, position, size) {
shape.position = position;
shape.size = size;
shape.invalidatePrimitives();
this.raiseModelChanged([new ModelChange_1.ItemChange(shape, ModelChange_1.ItemChangeType.Update)]);
};
ModelManipulator.prototype.moveShape = function (shape, position) {
shape.position = position;
shape.invalidatePrimitives();
this.raiseModelChanged([new ModelChange_1.ItemChange(shape, ModelChange_1.ItemChangeType.Update)]);
};
ModelManipulator.prototype.changeShapeParameters = function (shape, parameters) {
shape.parameters.forEach(function (p) {
var parameter = parameters.get(p.key);
if (parameter)
p.value = parameter.value;
});
shape.invalidatePrimitives();
this.raiseModelChanged([new ModelChange_1.ItemChange(shape, ModelChange_1.ItemChangeType.Update)]);
};
ModelManipulator.prototype.changeShapeText = function (shape, text) {
shape.text = text;
shape.invalidatePrimitives();
this.raiseModelChanged([new ModelChange_1.ItemChange(shape, ModelChange_1.ItemChangeType.UpdateStructure)]);
};
ModelManipulator.prototype.changeShapeImage = function (shape, image) {
shape.image = image;
var cachedImage = ImageCache_1.ImageCache.instance.createUnloadedInfoByShapeImageInfo(image);
this.imageLoader.load(cachedImage);
shape.invalidatePrimitives();
this.raiseModelChanged([new ModelChange_1.ItemChange(shape, ModelChange_1.ItemChangeType.UpdateStructure)]);
};
ModelManipulator.prototype.changeShapeExpanded = function (shape, expanded) {
shape.expanded = expanded;
shape.toggleExpandedSize();
shape.invalidatePrimitives();
this.raiseModelChanged([new ModelChange_1.ItemChange(shape, ModelChange_1.ItemChangeType.UpdateStructure)]);
};
ModelManipulator.prototype.deleteShape = function (shape) {
if (shape.attachedConnectors.length)
throw Error("A removing shape should not contain existing connectors.");
this.removeShape(shape);
};
ModelManipulator.prototype.removeShape = function (shape) {
this.model.removeItem(shape);
this.raiseModelChanged([new ModelChange_1.ItemChange(shape, ModelChange_1.ItemChangeType.Remove)]);
};
ModelManipulator.prototype.updateShapeImage = function (cacheImageInfo) {
if (!cacheImageInfo.imageUrl)
return;
var shapes = this.model.findShapesByImageUrl(cacheImageInfo.imageUrl);
var changes = [];
shapes.forEach(function (shape) {
if (cacheImageInfo.base64)
shape.image.loadBase64Content(cacheImageInfo.base64);
else
shape.image.setUnableToLoadFlag();
shape.invalidatePrimitives();
changes.push(new ModelChange_1.ItemChange(shape, ModelChange_1.ItemChangeType.UpdateStructure));
});
if (changes.length > 0)
this.raiseModelChanged(changes);
};
// Connectors
ModelManipulator.prototype.addConnector = function (connector, key) {
if (connector.beginItem || connector.endItem)
throw Error("Creating connector should not contain begin/end items");
connector.key = key !== undefined ? key : this.model.getNextKey();
;
return this.insertConnector(connector);
};
ModelManipulator.prototype.insertConnector = function (connector) {
this.model.pushItem(connector);
connector.invalidateRenderPoints();
this.raiseModelChanged([new ModelChange_1.ItemChange(connector, ModelChange_1.ItemChangeType.Create)]);
return connector;
};
ModelManipulator.prototype.deleteConnector = function (connector) {
if (connector.beginItem || connector.endItem)
throw Error("Creating connector should not contain begin/end items");
this.removeConnector(connector);
};
ModelManipulator.prototype.removeConnector = function (connector) {
this.model.removeItem(connector);
this.raiseModelChanged([new ModelChange_1.ItemChange(connector, ModelChange_1.ItemChangeType.Remove)]);
};
ModelManipulator.prototype.moveConnectorPoint = function (connector, pointIndex, point) {
connector.points[pointIndex] = point;
connector.invalidateRenderPoints();
this.raiseModelChanged([new ModelChange_1.ItemChange(connector, ModelChange_1.ItemChangeType.UpdateStructure)]);
};
ModelManipulator.prototype.addConnectorPoint = function (connector, pointIndex, point) {
connector.points.splice(pointIndex, 0, point);
connector.invalidateRenderPoints();
this.raiseModelChanged([new ModelChange_1.ItemChange(connector, ModelChange_1.ItemChangeType.UpdateStructure)]);
};
ModelManipulator.prototype.deleteConnectorPoint = function (connector, pointIndex) {
connector.points.splice(pointIndex, 1);
connector.invalidateRenderPoints();
this.raiseModelChanged([new ModelChange_1.ItemChange(connector, ModelChange_1.ItemChangeType.UpdateStructure)]);
};
ModelManipulator.prototype.addConnection = function (connector, item, connectionPointIndex, position) {
var existingItem = connector.getExtremeItem(position);
var existingConnectionPointIndex = connector.getExtremeConnectionPointIndex(position);
if (existingItem === item && existingConnectionPointIndex === connectionPointIndex)
return;
else if (existingItem)
throw Error("Connector is already connected");
item.attachedConnectors.push(connector);
if (position === Connector_1.ConnectorPosition.Begin) {
connector.beginItem = item;
connector.beginConnectionPointIndex = connectionPointIndex;
}
else {
connector.endItem = item;
connector.endConnectionPointIndex = connectionPointIndex;
}
connector.invalidateRenderPoints();
this.raiseModelChanged([new ModelChange_1.ItemChange(connector, ModelChange_1.ItemChangeType.UpdateStructure)]);
};
ModelManipulator.prototype.setConnectionPointIndex = function (connector, connectionPointIndex, position) {
if (!connector.getExtremeItem(position))
throw Error("Connection should be connected");
if (position === Connector_1.ConnectorPosition.Begin)
connector.beginConnectionPointIndex = connectionPointIndex;
else
connector.endConnectionPointIndex = connectionPointIndex;
connector.invalidateRenderPoints();
this.raiseModelChanged([new ModelChange_1.ItemChange(connector, ModelChange_1.ItemChangeType.UpdateStructure)]);
};
ModelManipulator.prototype.deleteConnection = function (connector, position) {
var item = connector.getExtremeItem(position);
if (!item)
return;
item.attachedConnectors.splice(item.attachedConnectors.indexOf(connector), 1);
if (position === Connector_1.ConnectorPosition.Begin) {
connector.beginItem = null;
connector.beginConnectionPointIndex = -1;
}
else {
connector.endItem = null;
connector.endConnectionPointIndex = -1;
}
connector.invalidateRenderPoints();
this.raiseModelChanged([new ModelChange_1.ItemChange(connector, ModelChange_1.ItemChangeType.UpdateStructure)]);
};
ModelManipulator.prototype.changeConnectorProperty = function (connector, propertyName, value) {
connector.properties[propertyName] = value;
connector.invalidateRenderPoints();
this.raiseModelChanged([new ModelChange_1.ItemChange(connector, ModelChange_1.ItemChangeType.UpdateStructure)]);
};
ModelManipulator.prototype.changeConnectorText = function (connector, text, position) {
connector.setText(text, position);
connector.invalidatePrimitives();
this.raiseModelChanged([new ModelChange_1.ItemChange(connector, ModelChange_1.ItemChangeType.UpdateStructure)]);
};
ModelManipulator.prototype.changeConnectorTextPosition = function (connector, position, newPosition) {
var text = connector.getText(position);
connector.setText(null, position);
connector.setText(text, newPosition);
connector.invalidatePrimitives();
this.raiseModelChanged([new ModelChange_1.ItemChange(connector, ModelChange_1.ItemChangeType.Update)]);
};
// Model
ModelManipulator.prototype.changeModelSize = function (size, offset) {
this.model.size.width = size.width;
this.model.size.height = size.height;
this.raiseModelSizeChanged(this.model.size.clone(), offset);
if (offset.left || offset.top) {
this.model.snapStartPoint = this.model.snapStartPoint.offset(offset.left, offset.top);
this.raiseSnapPointChange(this.model.snapStartPoint);
}
};
ModelManipulator.prototype.changePageSize = function (value) {
if (!this.model.pageSize.equals(value)) {
this.model.pageSize = value;
this.model.size = new Utils_1.Size(this.model.pageWidth, this.model.pageHeight);
this.raiseModelSizeChanged(this.model.size.clone());
this.raisePageSizeChanged(this.model.pageSize, this.model.pageLandscape);
}
};
ModelManipulator.prototype.changePageLandscape = function (value) {
if (this.model.pageLandscape !== value) {
this.model.pageLandscape = value;
if (this.model.pageSize.width !== this.model.pageSize.height) {
this.model.size = new Utils_1.Size(this.model.pageWidth, this.model.pageHeight);
this.raiseModelSizeChanged(this.model.size.clone());
this.raisePageSizeChanged(this.model.pageSize, this.model.pageLandscape);
}
}
};
ModelManipulator.prototype.changePageColor = function (value) {
if (this.model.pageColor !== value) {
this.model.pageColor = value;
this.raisePageColorChanged(value);
}
};
ModelManipulator.prototype.changePageProperty = function (apply) {
apply(this.model);
};
ModelManipulator.prototype.getModelSizeUpdateOffset = function () {
var oldRectangle = this.model.getRectangle(false);
var newRectangle = this.model.getRectangle(true);
if (!newRectangle.equals(oldRectangle))
this.raiseModelRectangleChanged(newRectangle);
var leftPageOffset = -Math.floor(newRectangle.left / this.model.pageWidth);
var topPageOffset = -Math.floor(newRectangle.top / this.model.pageHeight);
var rightPageOffset = -Math.floor((this.model.size.width - newRectangle.right) / this.model.pageWidth);
var bottomPageOffset = -Math.floor((this.model.size.height - newRectangle.bottom) / this.model.pageHeight);
return new Utils_1.Offset(leftPageOffset * this.model.pageWidth, topPageOffset * this.model.pageHeight, rightPageOffset * this.model.pageWidth, bottomPageOffset * this.model.pageHeight);
};
ModelManipulator.prototype.updateModelSize = function () {
var offset = this.getModelSizeUpdateOffset();
if (!offset.isEmpty()) {
var newWidth = Math.max(this.model.size.width + offset.left + offset.right, this.model.pageWidth);
var newHeight = Math.max(this.model.size.height + offset.top + offset.bottom, this.model.pageHeight);
this.model.size = new Utils_1.Size(newWidth, newHeight);
}
};
ModelManipulator.prototype.raiseModelChanged = function (changes) {
this.onModelChanged.raise1(function (l) { return l.notifyModelChanged(changes); });
};
ModelManipulator.prototype.raisePageColorChanged = function (color) {
this.onModelChanged.raise1(function (l) { return l.notifyPageColorChanged(color); });
};
ModelManipulator.prototype.raisePageSizeChanged = function (pageSize, pageLandscape) {
this.onModelChanged.raise1(function (l) { return l.notifyPageSizeChanged(pageSize, pageLandscape); });
};
ModelManipulator.prototype.raiseModelSizeChanged = function (size, offset) {
this.onModelSizeChanged.raise1(function (l) { return l.notifyModelSizeChanged(size, offset); });
};
ModelManipulator.prototype.raiseModelRectangleChanged = function (rectangle) {
this.onModelSizeChanged.raise1(function (l) { return l.notifyModelRectangleChanged(rectangle); });
};
ModelManipulator.prototype.raiseSnapPointChange = function (point) {
this.onModelSizeChanged.raise1(function (l) { return l.notifySnapPointPositionChanged(point); });
};
return ModelManipulator;
}());
exports.ModelManipulator = ModelManipulator;
/***/ }),
/* 264 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var MouseHandler_1 = __webpack_require__(265);
var Utils_1 = __webpack_require__(0);
var TextInputHandler_1 = __webpack_require__(284);
var ContextMenuHandler_1 = __webpack_require__(124);
var __1 = __webpack_require__(8);
var ContextMenuTouchHandler_1 = __webpack_require__(286);
var VisualizersManager_1 = __webpack_require__(125);
var VisualizersTouchManager_1 = __webpack_require__(292);
var EventManager = /** @class */ (function () {
function EventManager(control) {
this.onMouseOperation = new Utils_1.EventDispatcher();
this.onTextInputOperation = new Utils_1.EventDispatcher();
this.toolboxes = [];
this.control = control;
this.visualizersManager = __1.Browser.TouchUI ?
new VisualizersTouchManager_1.VisualizerTouchManager(control.selection, control.model, this, control.settings) :
new VisualizersManager_1.VisualizerManager(control.selection, control.model, this, control.settings);
this.onMouseOperation.add(this.visualizersManager);
this.mouseHandler = new MouseHandler_1.MouseHandler(control.history, control.selection, control.model, this, control.settings.readOnly, control.view, this.visualizersManager, control.settings, control.barManager, control.onNativeAction);
this.textInputHandler = new TextInputHandler_1.TextInputHandler(control);
this.contextMenuHandler = __1.Browser.TouchUI ?
new ContextMenuTouchHandler_1.ContextMenuTouchHandler(control.selection) :
new ContextMenuHandler_1.ContextMenuHandler();
this.contextMenuHandler.onVisibilityChanged.add(control);
this.onMouseOperation.add(this.contextMenuHandler);
}
Object.defineProperty(EventManager.prototype, "onVisualizersUpdate", {
get: function () {
return this.visualizersManager.onVisualizersUpdate;
},
enumerable: true,
configurable: true
});
EventManager.prototype.registerToolbox = function (toolbox) {
this.toolboxes.push(toolbox);
};
EventManager.prototype.initialize = function () {
this.visualizersManager.initialize(this.control.model);
this.mouseHandler.initialize(this.control.model);
};
EventManager.prototype.onMouseDown = function (evt) {
this.mouseHandler.onMouseDown(evt);
this.contextMenuHandler.onMouseDown(evt);
this.visualizersManager.onMouseDown(evt);
};
EventManager.prototype.onMouseMove = function (evt) {
this.processDragging(evt);
this.mouseHandler.onMouseMove(evt);
};
EventManager.prototype.onMouseUp = function (evt) {
this.mouseHandler.onMouseUp(evt);
this.contextMenuHandler.onMouseUp(evt);
this.visualizersManager.onMouseUp(evt);
this.processDragging(evt);
};
EventManager.prototype.onMouseEnter = function (evt) {
this.visualizersManager.onMouseEnter(evt);
};
EventManager.prototype.onMouseLeave = function (evt) {
this.visualizersManager.onMouseLeave(evt);
};
EventManager.prototype.onDblClick = function (evt) {
this.mouseHandler.onMouseDblClick(evt);
this.textInputHandler.onDblClick(evt);
};
EventManager.prototype.onClick = function (evt) {
this.mouseHandler.onMouseClick(evt);
};
EventManager.prototype.onContextMenu = function (evt) {
this.contextMenuHandler.onContextMenu(evt);
};
EventManager.prototype.onLongTouch = function (evt) {
this.mouseHandler.onLongTouch(evt);
this.contextMenuHandler.onLongTouch(evt);
};
EventManager.prototype.onBlur = function (evt) {
this.contextMenuHandler.onBlur(evt);
this.visualizersManager.onBlur(evt);
};
EventManager.prototype.onFocus = function (evt) {
this.contextMenuHandler.onFocus(evt);
this.visualizersManager.onFocus(evt);
};
EventManager.prototype.onKeyDown = function (evt) {
var scCode = evt.getShortcutCode();
if (this.onShortcut(scCode)) {
this.visualizersManager.updateConnectionPoints();
evt.preventDefault = true;
}
};
EventManager.prototype.onTextInputBlur = function (evt) {
this.textInputHandler.onBlur(evt);
this.contextMenuHandler.onTextInputBlur(evt);
};
EventManager.prototype.onTextInputFocus = function (evt) {
this.textInputHandler.onFocus(evt);
this.contextMenuHandler.onTextInputFocus(evt);
};
EventManager.prototype.onTextInputKeyDown = function (evt) {
this.textInputHandler.onKeyDown(evt);
};
EventManager.prototype.onShortcut = function (code) {
if (this.control.commandManager.processShortcut(code))
return true;
if (this.mouseHandler.onShortcut(code))
return true;
};
EventManager.prototype.onPaste = function (evt) {
if (!this.textInputHandler.isTextInputActive() && this.control.commandManager.processPaste(evt.clipboardData)) {
this.visualizersManager.updateConnectionPoints();
evt.preventDefault = true;
}
};
EventManager.prototype.onMouseWheel = function (evt) {
if (this.mouseHandler.onWheel(evt))
evt.preventDefault = true;
};
EventManager.prototype.isFocused = function () {
return this.control.isFocused();
};
EventManager.prototype.processDragging = function (evt) {
var draggingEvt = this.getDraggingEvent();
if (draggingEvt && !this.draggingEvent) {
this.draggingEvent = draggingEvt;
this.mouseHandler.onDragStart(this.draggingEvent);
this.control.captureFocus();
}
else if (!draggingEvt && this.draggingEvent) {
delete this.draggingEvent;
this.mouseHandler.onDragEnd(evt);
}
};
EventManager.prototype.getDraggingEvent = function () {
return this.toolboxes
.filter(function (t) { return t.draggingObject; })
.map(function (t) { return t.draggingObject.evt; })[0];
};
EventManager.prototype.onDocumentDragStart = function (itemKeys) {
this.control.beginUpdate();
this.control.captureFocus();
this.onMouseOperation.raise("notifyDragStart", itemKeys);
};
EventManager.prototype.onDocumentDragEnd = function (itemKeys) {
this.onMouseOperation.raise("notifyDragEnd", itemKeys);
this.control.endUpdate();
};
EventManager.prototype.onDocumentDragScrollStart = function () {
this.onMouseOperation.raise1(function (l) { return l.notifyDragScrollStart(); });
};
EventManager.prototype.onDocumentDragScrollEnd = function () {
this.onMouseOperation.raise1(function (l) { return l.notifyDragScrollEnd(); });
};
EventManager.prototype.onDocumentClick = function (itemKeys) {
this.control.beginUpdate();
this.control.endUpdate();
};
EventManager.prototype.raiseTextInputStart = function (item, text, position, size) {
this.onTextInputOperation.raise("notifyTextInputStart", item, text, position, size);
};
EventManager.prototype.raiseTextInputEnd = function (item) {
this.onTextInputOperation.raise("notifyTextInputEnd", item);
};
return EventManager;
}());
exports.EventManager = EventManager;
/***/ }),
/* 265 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var MouseHandlerDefaultState_1 = __webpack_require__(117);
var Event_1 = __webpack_require__(10);
var Utils_1 = __webpack_require__(0);
var KeyCode_1 = __webpack_require__(16);
var ModelUtils_1 = __webpack_require__(6);
var MouseHandlerMoveClonedShapeState_1 = __webpack_require__(78);
var __1 = __webpack_require__(8);
var MouseHandlerDefaultReadOnlyTouchState_1 = __webpack_require__(281);
var MouseHandlerDefaultReadOnlyState_1 = __webpack_require__(123);
var MouseHandlerDefaultTouchState_1 = __webpack_require__(282);
var MouseHandler = /** @class */ (function () {
function MouseHandler(history, selection, model, eventManager, readOnly, view, visualizerManager, settings, bars, nativeActions) {
this.history = history;
this.selection = selection;
this.model = model;
this.eventManager = eventManager;
this.readOnly = readOnly;
this.view = view;
this.visualizerManager = visualizerManager;
this.settings = settings;
this.bars = bars;
this.nativeActions = nativeActions;
this.initialize(model);
}
MouseHandler.prototype.initialize = function (model) {
this.model = model;
this.initializeDefaultState();
};
MouseHandler.prototype.initializeDefaultState = function () {
this.defaultState = this.readOnly ?
(__1.Browser.TouchUI ?
new MouseHandlerDefaultReadOnlyTouchState_1.MouseHandlerDefaultReadOnlyTouchState(this, this.history, this.selection, this.model, this.view, this.visualizerManager, this.settings, this.bars) :
new MouseHandlerDefaultReadOnlyState_1.MouseHandlerDefaultReadOnlyState(this, this.history, this.selection, this.model, this.view, this.visualizerManager, this.settings, this.bars)) :
(__1.Browser.TouchUI ?
new MouseHandlerDefaultTouchState_1.MouseHandlerDefaultTouchState(this, this.history, this.selection, this.model, this.view, this.visualizerManager, this.settings, this.bars) :
new MouseHandlerDefaultState_1.MouseHandlerDefaultState(this, this.history, this.selection, this.model, this.view, this.visualizerManager, this.settings, this.bars));
this.switchToDefaultState();
};
MouseHandler.prototype.onMouseDown = function (evt) {
this.mouseDownEvent = evt;
this.state.onMouseDown(evt);
};
MouseHandler.prototype.onMouseMove = function (evt) {
this.state.onMouseMove(evt);
};
MouseHandler.prototype.onMouseUp = function (evt) {
this.state.onMouseUp(evt);
};
MouseHandler.prototype.onMouseDblClick = function (evt) {
this.state.onMouseDblClick(evt);
this.tryRaiseUserAction(evt, function (l, item) { return l.notifyItemDblClick(item); });
};
MouseHandler.prototype.onMouseClick = function (evt) {
this.state.onMouseClick(evt);
this.tryRaiseUserAction(evt, function (l, item) { return l.notifyItemClick(item); });
};
MouseHandler.prototype.onLongTouch = function (evt) {
if (!evt.touches || evt.touches.length > 1)
return;
var key = evt.source.key;
if (key === undefined)
this.selection.clear();
else if (this.selection.hasKey(key))
this.selection.remove(key);
else
this.selection.add(key);
};
MouseHandler.prototype.onShortcut = function (code) {
return this.state.onShortcut(code);
};
MouseHandler.prototype.onWheel = function (evt) {
return this.state.onMouseWheel(evt);
};
MouseHandler.prototype.onDragStart = function (evt) {
this.state.onDragStart(evt);
};
MouseHandler.prototype.onDragEnd = function (evt) {
this.state.onDragEnd(evt);
};
// utils
MouseHandler.prototype.getSnappedPos = function (evt, pos, isHorizontal) {
if (!this.settings.snapToGrid || (evt.modifiers & KeyCode_1.ModifierKey.Ctrl))
return pos;
return ModelUtils_1.ModelUtils.getSnappedPos(this.model, this.settings.gridSize, pos, isHorizontal);
};
MouseHandler.prototype.getSnappedPoint = function (evt, point, additionalSnappedPoint) {
var x = this.getSnappedPos(evt, point.x, true);
var y = this.getSnappedPos(evt, point.y, false);
if (additionalSnappedPoint === undefined)
return new Utils_1.Point(x, y);
else {
if (Math.pow(point.x - x, 2) + Math.pow(point.y - y, 2) < Math.pow(point.x - additionalSnappedPoint.x, 2) + Math.pow(point.y - additionalSnappedPoint.y, 2))
return new Utils_1.Point(x, y);
else
return additionalSnappedPoint;
}
};
MouseHandler.prototype.tryUpdateModelSize = function (processPoints) {
ModelUtils_1.ModelUtils.tryUpdateModelSize(this.history, this.model, processPoints);
};
MouseHandler.prototype.raiseDragStart = function (keys) {
this.eventManager.onDocumentDragStart(keys);
};
MouseHandler.prototype.raiseDragEnd = function (keys) {
this.eventManager.onDocumentDragEnd(keys);
};
MouseHandler.prototype.raiseDragScrollStart = function () {
this.eventManager.onDocumentDragScrollStart();
};
MouseHandler.prototype.raiseDragScrollEnd = function () {
this.eventManager.onDocumentDragScrollEnd();
};
MouseHandler.prototype.raiseClick = function (keys) {
this.eventManager.onDocumentClick(keys);
};
MouseHandler.prototype.tryRaiseUserAction = function (evt, callEvent) {
if (this.isUserAction(evt)) {
var item = this.model.findItem(evt.source.key);
item && this.nativeActions.raise1(function (l) { return callEvent(l, item.toNative()); });
}
};
MouseHandler.prototype.isUserAction = function (evt) {
return evt.source &&
(evt.source.type === Event_1.MouseEventElementType.Shape || evt.source.type === Event_1.MouseEventElementType.Connector);
};
// switch state
MouseHandler.prototype.switchToDefaultState = function () {
this.switchState(this.defaultState);
};
MouseHandler.prototype.switchToMoveClonedShapeState = function (startPoint) {
this.switchState(new MouseHandlerMoveClonedShapeState_1.MouseHandlerMoveClonedShapeState(this, this.history, this.model, this.selection, this.visualizerManager, startPoint));
};
MouseHandler.prototype.switchState = function (state) {
if (this.state)
this.state.finish();
this.state = state;
this.state.start();
};
MouseHandler.prototype.notifyReadOnlyChanged = function (readOnly) {
this.readOnly = readOnly;
this.initializeDefaultState();
};
return MouseHandler;
}());
exports.MouseHandler = MouseHandler;
/***/ }),
/* 266 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var MouseHandlerMoveConnectorPointStateBase_1 = __webpack_require__(118);
var Connector_1 = __webpack_require__(5);
var ModelUtils_1 = __webpack_require__(6);
var Utils_1 = __webpack_require__(0);
var ConnectorProperties_1 = __webpack_require__(24);
var MouseHandlerMoveConnectorPointState = /** @class */ (function (_super) {
__extends(MouseHandlerMoveConnectorPointState, _super);
function MouseHandlerMoveConnectorPointState() {
return _super !== null && _super.apply(this, arguments) || this;
}
MouseHandlerMoveConnectorPointState.prototype.onMouseDown = function (evt) {
this.connector = this.model.findConnector(evt.source.key);
this.pointIndex = parseInt(evt.source.value);
if (this.pointIndex === 0) {
this.pointPosition = Connector_1.ConnectorPosition.Begin;
}
else if (this.pointIndex === this.connector.points.length - 1) {
this.pointPosition = Connector_1.ConnectorPosition.End;
}
_super.prototype.onMouseDown.call(this, evt);
};
MouseHandlerMoveConnectorPointState.prototype.onApplyChanges = function (evt) {
if (this.connector.properties.lineOption !== ConnectorProperties_1.ConnectorLineOption.Orthogonal ||
this.pointIndex === 0 || this.pointIndex === this.connector.points.length - 1)
_super.prototype.onApplyChanges.call(this, evt);
};
MouseHandlerMoveConnectorPointState.prototype.onFinishWithChanges = function () {
_super.prototype.onFinishWithChanges.call(this);
ModelUtils_1.ModelUtils.removeUnnecessaryConnectorPoints(this.history, this.connector);
};
MouseHandlerMoveConnectorPointState.prototype.getSnappedPoint = function (evt, point) {
var points = this.connector.points;
var index = this.pointIndex;
if (0 < index && index < points.length - 1) {
var tg = (points[index + 1].y - points[index - 1].y) / (points[index + 1].x - points[index - 1].x);
var x = point.x;
var y = points[index + 1].y - (points[index + 1].x - x) * tg;
return this.handler.getSnappedPoint(evt, point, new Utils_1.Point(x, y));
}
return this.handler.getSnappedPoint(evt, point);
};
return MouseHandlerMoveConnectorPointState;
}(MouseHandlerMoveConnectorPointStateBase_1.MouseHandlerMoveConnectorPointStateBase));
exports.MouseHandlerMoveConnectorPointState = MouseHandlerMoveConnectorPointState;
/***/ }),
/* 267 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Utils_1 = __webpack_require__(0);
var Event_1 = __webpack_require__(10);
var KeyCode_1 = __webpack_require__(16);
var MouseHandlerDraggingState_1 = __webpack_require__(26);
var Model_1 = __webpack_require__(19);
var ModelUtils_1 = __webpack_require__(6);
var MouseHandlerResizeShapeState = /** @class */ (function (_super) {
__extends(MouseHandlerResizeShapeState, _super);
function MouseHandlerResizeShapeState(handler, history, model, selection, visualizerManager) {
var _this = _super.call(this, handler, history) || this;
_this.model = model;
_this.selection = selection;
_this.visualizerManager = visualizerManager;
_this.startScrollLeft = 0;
_this.startScrollTop = 0;
_this.rotation = 0;
return _this;
}
MouseHandlerResizeShapeState.prototype.start = function () {
_super.prototype.start.call(this);
};
MouseHandlerResizeShapeState.prototype.finish = function () {
this.visualizerManager.resetResizeInfo();
this.visualizerManager.resetExtensionLines();
_super.prototype.finish.call(this);
};
MouseHandlerResizeShapeState.prototype.onMouseDown = function (evt) {
var source = parseInt(evt.source.value);
this.resizeEventSource = source;
this.startPoint = evt.modelPoint;
this.lockH = source == Event_1.ResizeEventSource.ResizeBox_S || source == Event_1.ResizeEventSource.ResizeBox_N;
this.lockV = source == Event_1.ResizeEventSource.ResizeBox_E || source == Event_1.ResizeEventSource.ResizeBox_W;
this.sideH = source == Event_1.ResizeEventSource.ResizeBox_E || source == Event_1.ResizeEventSource.ResizeBox_NE || source == Event_1.ResizeEventSource.ResizeBox_SE;
this.sideV = source == Event_1.ResizeEventSource.ResizeBox_SE || source == Event_1.ResizeEventSource.ResizeBox_S || source == Event_1.ResizeEventSource.ResizeBox_SW;
this.shapes = this.selection.getSelectedShapes();
if (this.shapes.length === 0) {
this.handler.switchToDefaultState();
return;
}
this.connectors = this.selection.getSelectedConnectors();
this.startRectangle = Model_1.DiagramModel.getRectangle(this.shapes);
this.startShapeSizes = this.shapes.map(function (shape) { return shape.size.clone(); });
this.startShapePositions = this.shapes.map(function (shape) { return shape.position.clone(); });
this.startConnectorPoints = this.connectors.map(function (c) { return c.points.map(function (p) { return p.clone(); }); });
this.lockAspectRatio = !!(evt.modifiers & KeyCode_1.ModifierKey.Shift);
_super.prototype.onMouseDown.call(this, evt);
};
MouseHandlerResizeShapeState.prototype.onMouseMove = function (evt) {
_super.prototype.onMouseMove.call(this, evt);
var shapes = this.selection.getSelectedShapes();
this.visualizerManager.setExtensionLines(shapes);
};
MouseHandlerResizeShapeState.prototype.onApplyChanges = function (evt) {
var _this = this;
var rectangle = Model_1.DiagramModel.getRectangle(this.shapes);
var size = this.getSize(evt, rectangle.position, this.startRectangle.size);
var pos = this.getPosition(evt, size, this.startRectangle.size, this.startRectangle.position);
var ratioX = size.width / this.startRectangle.width;
var ratioY = size.height / this.startRectangle.height;
this.shapes.forEach(function (shape, index) {
var shapeSize = new Utils_1.Size(_this.startShapeSizes[index].width * (shape.allowResizeHorizontally ? ratioX : 1), _this.startShapeSizes[index].height * (shape.allowResizeVertically ? ratioY : 1));
var shapePos = new Utils_1.Point(shape.allowResizeHorizontally ? (pos.x + (_this.startShapePositions[index].x - _this.startRectangle.left) * ratioX) : _this.startShapePositions[index].x, shape.allowResizeVertically ? (pos.y + (_this.startShapePositions[index].y - _this.startRectangle.top) * ratioY) : _this.startShapePositions[index].y);
ModelUtils_1.ModelUtils.setShapeSize(_this.history, _this.model, shape, shapePos, shapeSize);
});
this.connectors.forEach(function (connector, index) {
var startPtIndex = connector.beginItem ? 1 : 0;
var endPtIndex = connector.endItem ? (connector.points.length - 2) : (connector.points.length - 1);
for (var i = startPtIndex; i <= endPtIndex; i++) {
var connectorPtPos = new Utils_1.Point(pos.x + (_this.startConnectorPoints[index][i].x - _this.startRectangle.left) * ratioX, pos.y + (_this.startConnectorPoints[index][i].y - _this.startRectangle.top) * ratioY);
ModelUtils_1.ModelUtils.setConnectorPoint(_this.history, _this.model, connector, i, connectorPtPos);
}
});
var shapes = this.selection.getSelectedShapes(false, true);
shapes.forEach(function (shape) {
ModelUtils_1.ModelUtils.updateShapeAttachedConnectors(_this.history, _this.model, shape);
});
this.tryUpdateModelSize();
this.visualizerManager.setResizeInfo(this.shapes);
};
MouseHandlerResizeShapeState.prototype.tryUpdateModelSize = function () {
var _this = this;
this.handler.tryUpdateModelSize(function (offsetLeft, offsetTop) {
_this.startShapePositions.forEach(function (pt) {
pt.x += offsetLeft;
pt.y += offsetTop;
});
_this.startConnectorPoints.forEach(function (connector) {
connector.forEach(function (pt) {
pt.x += offsetLeft;
pt.y += offsetTop;
});
});
_this.startRectangle.position.x += offsetLeft;
_this.startRectangle.position.y += offsetTop;
_this.startPoint.x += offsetLeft;
_this.startPoint.y += offsetTop;
});
};
MouseHandlerResizeShapeState.prototype.getDraggingElementKeys = function () {
return this.shapes.map(function (shape) { return shape.key; });
};
MouseHandlerResizeShapeState.prototype.getSize = function (evt, position, startSize) {
var absDeltaX = evt.modelPoint.x - (this.startScrollLeft - evt.scrollX) - this.startPoint.x;
var absDeltaY = evt.modelPoint.y - (this.startScrollTop - evt.scrollY) - this.startPoint.y;
var deltaX = absDeltaX * Math.cos(this.rotation) - (-absDeltaY) * Math.sin(this.rotation);
var deltaY = -(absDeltaX * Math.sin(this.rotation) + (-absDeltaY) * Math.cos(this.rotation));
var newWidth, newHeight;
deltaY = !this.sideV && deltaY > 0 ? Math.min(startSize.height + 1, deltaY) : deltaY;
deltaX = !this.sideH && deltaX > 0 ? Math.min(startSize.width + 1, deltaX) : deltaX;
if (!this.lockH && !this.lockV && this.lockAspectRatio) {
if (Math.abs(deltaX) > Math.abs(deltaY)) {
newWidth = this.sideH ? Math.max(MouseHandlerResizeShapeState.minSize, startSize.width + deltaX) : (startSize.width - deltaX);
newHeight = startSize.height * (newWidth / startSize.width);
}
else {
newHeight = this.sideV ? Math.max(MouseHandlerResizeShapeState.minSize, startSize.height + deltaY) : (startSize.height - deltaY);
newWidth = startSize.width * (newHeight / startSize.height);
}
}
else {
deltaX = this.lockH ? 0 : deltaX;
deltaY = this.lockV ? 0 : deltaY;
newWidth = Math.max(MouseHandlerResizeShapeState.minSize, this.sideH ? (startSize.width + deltaX) : (startSize.width - deltaX));
newHeight = Math.max(MouseHandlerResizeShapeState.minSize, this.sideV ? (startSize.height + deltaY) : (startSize.height - deltaY));
}
if (!this.lockH)
newWidth = this.handler.getSnappedPos(evt, position.x + newWidth, true) - position.x;
if (!this.lockV)
newHeight = this.handler.getSnappedPos(evt, position.y + newHeight, false) - position.y;
return new Utils_1.Size(newWidth, newHeight);
};
MouseHandlerResizeShapeState.prototype.getPosition = function (evt, size, startSize, startPosition) {
var x = startPosition.x;
var y = startPosition.y;
if (this.resizeEventSource === Event_1.ResizeEventSource.ResizeBox_N ||
this.resizeEventSource === Event_1.ResizeEventSource.ResizeBox_NE ||
this.resizeEventSource === Event_1.ResizeEventSource.ResizeBox_NW) {
y += startSize.height - size.height;
var snappedY = this.handler.getSnappedPos(evt, y, false);
size.height += y - snappedY;
y = snappedY;
}
if (this.resizeEventSource === Event_1.ResizeEventSource.ResizeBox_W ||
this.resizeEventSource === Event_1.ResizeEventSource.ResizeBox_NW ||
this.resizeEventSource === Event_1.ResizeEventSource.ResizeBox_SW) {
x += startSize.width - size.width;
var snappedX = this.handler.getSnappedPos(evt, x, true);
size.width += x - snappedX;
x = snappedX;
}
return new Utils_1.Point(x, y);
};
MouseHandlerResizeShapeState.minSize = 360;
return MouseHandlerResizeShapeState;
}(MouseHandlerDraggingState_1.MouseHandlerDraggingState));
exports.MouseHandlerResizeShapeState = MouseHandlerResizeShapeState;
/***/ }),
/* 268 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var MouseHandlerDraggingState_1 = __webpack_require__(26);
var AddConnectorPointHistoryItem_1 = __webpack_require__(119);
var MoveConnectorPointHistoryItem_1 = __webpack_require__(50);
var ModelUtils_1 = __webpack_require__(6);
var MouseHandlerMoveConnectorSideState = /** @class */ (function (_super) {
__extends(MouseHandlerMoveConnectorSideState, _super);
function MouseHandlerMoveConnectorSideState(handler, history, model) {
var _this = _super.call(this, handler, history) || this;
_this.model = model;
return _this;
}
MouseHandlerMoveConnectorSideState.prototype.onMouseDown = function (evt) {
this.startPoint = evt.modelPoint;
this.connectorKey = evt.source.key;
this.pointIndex = parseInt(evt.source.value) + 1;
_super.prototype.onMouseDown.call(this, evt);
};
MouseHandlerMoveConnectorSideState.prototype.onApplyChanges = function (evt) {
var point = this.getSnappedPoint(evt, evt.modelPoint);
if (!this.pointCreated) {
this.history.addAndRedo(new AddConnectorPointHistoryItem_1.AddConnectorPointHistoryItem(this.connectorKey, this.pointIndex, point));
this.pointCreated = true;
}
else {
this.history.addAndRedo(new MoveConnectorPointHistoryItem_1.MoveConnectorPointHistoryItem(this.connectorKey, this.pointIndex, point));
}
this.handler.tryUpdateModelSize();
};
MouseHandlerMoveConnectorSideState.prototype.onFinishWithChanges = function () {
ModelUtils_1.ModelUtils.removeUnnecessaryConnectorPoints(this.history, this.model.findConnector(this.connectorKey));
};
MouseHandlerMoveConnectorSideState.prototype.getDraggingElementKeys = function () {
return [this.connectorKey];
};
return MouseHandlerMoveConnectorSideState;
}(MouseHandlerDraggingState_1.MouseHandlerDraggingState));
exports.MouseHandlerMoveConnectorSideState = MouseHandlerMoveConnectorSideState;
/***/ }),
/* 269 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var MouseHandlerDraggingState_1 = __webpack_require__(26);
var ChangeShapeParametersHistoryItem_1 = __webpack_require__(102);
var MouseHandlerDragParameterPointState = /** @class */ (function (_super) {
__extends(MouseHandlerDragParameterPointState, _super);
function MouseHandlerDragParameterPointState(handler, history, model) {
var _this = _super.call(this, handler, history) || this;
_this.model = model;
_this.startScrollLeft = 0;
_this.startScrollTop = 0;
return _this;
}
MouseHandlerDragParameterPointState.prototype.onMouseDown = function (evt) {
this.startPoint = evt.modelPoint;
this.shape = this.model.findShape(evt.source.key);
this.parameterPointKey = evt.source.value;
this.startParameters = this.shape.parameters.clone();
_super.prototype.onMouseDown.call(this, evt);
};
MouseHandlerDragParameterPointState.prototype.onApplyChanges = function (evt) {
var offsetX = this.handler.getSnappedPos(evt, evt.modelPoint.x - this.startPoint.x, true);
var offsetY = this.handler.getSnappedPos(evt, evt.modelPoint.y - this.startPoint.y, false);
var parameters = this.startParameters.clone();
this.shape.description.modifyParameters(this.shape, parameters, offsetX, offsetY);
this.history.addAndRedo(new ChangeShapeParametersHistoryItem_1.ChangeShapeParametersHistoryItem(this.shape.key, parameters));
};
MouseHandlerDragParameterPointState.prototype.getDraggingElementKeys = function () {
return [this.shape.key];
};
return MouseHandlerDragParameterPointState;
}(MouseHandlerDraggingState_1.MouseHandlerDraggingState));
exports.MouseHandlerDragParameterPointState = MouseHandlerDragParameterPointState;
/***/ }),
/* 270 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Connector_1 = __webpack_require__(5);
var AddConnectionHistoryItem_1 = __webpack_require__(37);
var AddConnectorHistoryItem_1 = __webpack_require__(52);
var MouseHandlerMoveConnectorPointStateBase_1 = __webpack_require__(118);
var SetSelectionHistoryItem_1 = __webpack_require__(44);
var ChangeConnectorPropertyHistoryItem_1 = __webpack_require__(55);
var ChangeStyleHistoryItem_1 = __webpack_require__(46);
var ChangeStyleTextHistoryItem_1 = __webpack_require__(36);
var MouseHandlerCreateConnectorState = /** @class */ (function (_super) {
__extends(MouseHandlerCreateConnectorState, _super);
function MouseHandlerCreateConnectorState(handler, history, model, visualizerManager, selection, connectionPointIndex) {
var _this = _super.call(this, handler, history, model, visualizerManager) || this;
_this.selection = selection;
_this.connectionPointIndex = connectionPointIndex;
return _this;
}
MouseHandlerCreateConnectorState.prototype.onMouseDown = function (evt) {
if (this.connectionPointIndex === undefined)
this.connectionPointIndex = parseInt(evt.source.value);
this.connectedItem = this.model.findItem(evt.source.key);
this.pointIndex = 1;
this.pointPosition = Connector_1.ConnectorPosition.End;
_super.prototype.onMouseDown.call(this, evt);
};
MouseHandlerCreateConnectorState.prototype.onApplyChanges = function (evt) {
var _this = this;
var point = this.getSnappedPoint(evt, evt.modelPoint);
if (!this.connector) {
var historyItem = new AddConnectorHistoryItem_1.AddConnectorHistoryItem([this.connectedItem.getConnectionPointPosition(this.connectionPointIndex, point), point]);
this.history.addAndRedo(historyItem);
this.connector = this.model.findConnector(historyItem.connectorKey);
this.connector.properties.forEach(function (propertyName) {
_this.history.addAndRedo(new ChangeConnectorPropertyHistoryItem_1.ChangeConnectorPropertyHistoryItem(_this.connector.key, propertyName, _this.selection.inputPosition.getConnectorPropertyDefaultValue(propertyName)));
});
this.connector.style.forEach(function (propertyName) {
_this.history.addAndRedo(new ChangeStyleHistoryItem_1.ChangeStyleHistoryItem(_this.connector.key, propertyName, _this.selection.inputPosition.getStylePropertyDefaultValue(propertyName)));
});
this.connector.styleText.forEach(function (propertyName) {
_this.history.addAndRedo(new ChangeStyleTextHistoryItem_1.ChangeStyleTextHistoryItem(_this.connector.key, propertyName, _this.selection.inputPosition.getStyleTextPropertyDefaultValue(propertyName)));
});
this.history.addAndRedo(new AddConnectionHistoryItem_1.AddConnectionHistoryItem(this.connector, this.connectedItem, this.connectionPointIndex, Connector_1.ConnectorPosition.Begin));
}
else
_super.prototype.onApplyChanges.call(this, evt);
};
MouseHandlerCreateConnectorState.prototype.onFinishWithChanges = function () {
_super.prototype.onFinishWithChanges.call(this);
this.history.addAndRedo(new SetSelectionHistoryItem_1.SetSelectionHistoryItem(this.selection, [this.connector.key]));
};
return MouseHandlerCreateConnectorState;
}(MouseHandlerMoveConnectorPointStateBase_1.MouseHandlerMoveConnectorPointStateBase));
exports.MouseHandlerCreateConnectorState = MouseHandlerCreateConnectorState;
/***/ }),
/* 271 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Utils_1 = __webpack_require__(0);
var Connector_1 = __webpack_require__(5);
var MouseHandlerDraggingState_1 = __webpack_require__(26);
var AddConnectorPointHistoryItem_1 = __webpack_require__(119);
var MoveConnectorPointHistoryItem_1 = __webpack_require__(50);
var ModelUtils_1 = __webpack_require__(6);
var DiagramItem_1 = __webpack_require__(4);
var MouseHandlerMoveConnectorOrthogonalSideState = /** @class */ (function (_super) {
__extends(MouseHandlerMoveConnectorOrthogonalSideState, _super);
function MouseHandlerMoveConnectorOrthogonalSideState(handler, history, model) {
var _this = _super.call(this, handler, history) || this;
_this.model = model;
return _this;
}
MouseHandlerMoveConnectorOrthogonalSideState.prototype.onMouseDown = function (evt) {
this.startPoint = evt.modelPoint;
this.connector = this.model.findConnector(evt.source.key);
var renderPointIndexes = evt.source.value.split("_");
var renderPointIndex1 = parseInt(renderPointIndexes[0]);
var renderPointIndex2 = parseInt(renderPointIndexes[1]);
var points = this.connector.getRenderPoints(true);
this.renderPoint1 = points[renderPointIndex1].clone();
this.renderPoint2 = points[renderPointIndex2].clone();
this.isVerticalOrientation = this.renderPoint1.x === this.renderPoint2.x;
if (this.renderPoint1.pointIndex !== -1) {
this.pointIndex1 = this.renderPoint1.pointIndex;
if (this.pointIndex1 === 0) {
this.pointIndex1++;
this.correctEdgePoint(this.renderPoint1, this.renderPoint2, this.connector.beginItem, this.connector.beginConnectionPointIndex);
}
else
this.point1 = this.connector.points[this.pointIndex1];
}
else
this.pointIndex1 = this.findPointIndex(points, renderPointIndex1, false) + 1;
if (this.renderPoint2.pointIndex !== -1) {
this.pointIndex2 = this.renderPoint2.pointIndex;
if (this.pointIndex2 === this.connector.points.length - 1) {
this.correctEdgePoint(this.renderPoint2, this.renderPoint1, this.connector.endItem, this.connector.endConnectionPointIndex);
}
else
this.point2 = this.connector.points[this.pointIndex2];
}
else
this.pointIndex2 = this.findPointIndex(points, renderPointIndex2, true);
_super.prototype.onMouseDown.call(this, evt);
};
MouseHandlerMoveConnectorOrthogonalSideState.prototype.onApplyChanges = function (evt) {
var _this = this;
if (!this.pointCreated) {
var createdPoint1 = void 0, createdPoint2 = void 0;
if (this.point1 === undefined) {
this.point1 = new Utils_1.Point(this.renderPoint1.x, this.renderPoint1.y);
this.history.addAndRedo(new AddConnectorPointHistoryItem_1.AddConnectorPointHistoryItem(this.connector.key, this.pointIndex1, this.point1));
createdPoint1 = this.point1;
this.pointIndex2++;
}
if (this.point2 === undefined) {
this.point2 = new Utils_1.Point(this.renderPoint2.x, this.renderPoint2.y);
this.history.addAndRedo(new AddConnectorPointHistoryItem_1.AddConnectorPointHistoryItem(this.connector.key, this.pointIndex2, this.point2));
createdPoint2 = this.point2;
}
ModelUtils_1.ModelUtils.removeUnnecessaryConnectorPoints(this.history, this.connector, [createdPoint1, createdPoint2], function (index) {
if (index < _this.pointIndex1)
_this.pointIndex1--;
if (index < _this.pointIndex2)
_this.pointIndex2--;
});
this.pointCreated = true;
}
var point = this.getSnappedPoint(evt, evt.modelPoint);
if (this.isVerticalOrientation) {
this.point1.x = point.x;
this.point2.x = point.x;
}
else {
this.point1.y = point.y;
this.point2.y = point.y;
}
this.history.addAndRedo(new MoveConnectorPointHistoryItem_1.MoveConnectorPointHistoryItem(this.connector.key, this.pointIndex1, this.point1));
this.history.addAndRedo(new MoveConnectorPointHistoryItem_1.MoveConnectorPointHistoryItem(this.connector.key, this.pointIndex2, this.point2));
this.handler.tryUpdateModelSize();
};
MouseHandlerMoveConnectorOrthogonalSideState.prototype.onFinishWithChanges = function () {
ModelUtils_1.ModelUtils.removeUnnecessaryConnectorPoints(this.history, this.connector);
};
MouseHandlerMoveConnectorOrthogonalSideState.prototype.findPointIndex = function (points, index, direction) {
var point;
while (point = points[index]) {
if (point.pointIndex !== -1)
return point.pointIndex;
index += direction ? 1 : -1;
}
};
MouseHandlerMoveConnectorOrthogonalSideState.prototype.correctEdgePoint = function (point, directionPoint, item, connectionPointIndex) {
var offset = 0;
if (item !== undefined) {
var side = item.getConnectionPointSideByIndex(connectionPointIndex);
var rect = item.rectangle;
offset = Connector_1.Connector.minOffset;
switch (side) {
case DiagramItem_1.ConnectionPointSide.South:
offset += rect.bottom - point.y;
break;
case DiagramItem_1.ConnectionPointSide.North:
offset += point.y - rect.top;
break;
case DiagramItem_1.ConnectionPointSide.East:
offset += rect.right - point.x;
break;
case DiagramItem_1.ConnectionPointSide.West:
offset += point.x - rect.left;
break;
}
}
if (this.isVerticalOrientation) {
if (point.y > directionPoint.y)
point.y -= Math.min(offset, point.y - directionPoint.y);
else
point.y += Math.min(offset, directionPoint.y - point.y);
}
else {
if (point.x > directionPoint.x)
point.x -= Math.min(offset, point.x - directionPoint.x);
else
point.x += Math.min(offset, directionPoint.x - point.x);
}
};
MouseHandlerMoveConnectorOrthogonalSideState.prototype.getDraggingElementKeys = function () {
return [this.connector.key];
};
return MouseHandlerMoveConnectorOrthogonalSideState;
}(MouseHandlerDraggingState_1.MouseHandlerDraggingState));
exports.MouseHandlerMoveConnectorOrthogonalSideState = MouseHandlerMoveConnectorOrthogonalSideState;
/***/ }),
/* 272 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Event_1 = __webpack_require__(10);
var ShapeDescriptionManager_1 = __webpack_require__(25);
var Utils_1 = __webpack_require__(0);
var AddShapeHistoryItem_1 = __webpack_require__(51);
var SetSelectionHistoryItem_1 = __webpack_require__(44);
var ChangeStyleHistoryItem_1 = __webpack_require__(46);
var ChangeStyleTextHistoryItem_1 = __webpack_require__(36);
var MouseHandlerDraggingState_1 = __webpack_require__(26);
var DeleteShapeHistoryItem_1 = __webpack_require__(91);
var ModelUtils_1 = __webpack_require__(6);
var MouseHandlerStateBase_1 = __webpack_require__(32);
var NON_DOCUMENT_TIMER = 500;
var LOCK_UPDATEPAGESIZE_TIMER = 300;
var MouseHandlerBeforeToolboxDraggingState = /** @class */ (function (_super) {
__extends(MouseHandlerBeforeToolboxDraggingState, _super);
function MouseHandlerBeforeToolboxDraggingState(handler, history, model, selection, visualizerManager) {
var _this = _super.call(this, handler) || this;
_this.history = history;
_this.model = model;
_this.selection = selection;
_this.visualizerManager = visualizerManager;
_this.isModelEmpty = model.items.length === 0;
return _this;
}
MouseHandlerBeforeToolboxDraggingState.prototype.cancelChanges = function () {
this.tryRemoveTimer();
};
MouseHandlerBeforeToolboxDraggingState.prototype.onDragStart = function (evt) {
this.dragging = evt;
};
MouseHandlerBeforeToolboxDraggingState.prototype.onDragEnd = function (evt) {
this.cancelChanges();
this.handler.switchToDefaultState();
};
MouseHandlerBeforeToolboxDraggingState.prototype.onMouseMove = function (evt) {
var _this = this;
if (evt.source.type > Event_1.MouseEventElementType.Background) {
this.tryRemoveTimer();
this.switchToDraggingState(evt, false);
}
else if (evt.source.type === Event_1.MouseEventElementType.Background && !this.isModelEmpty) {
this.savedEvt = evt;
if (this.nonPageAreaTimer === undefined)
this.nonPageAreaTimer = setTimeout(function () { return _this.switchToDraggingState(_this.savedEvt, true); }, NON_DOCUMENT_TIMER);
}
else if (this.nonPageAreaTimer !== undefined)
this.tryRemoveTimer();
};
MouseHandlerBeforeToolboxDraggingState.prototype.switchToDraggingState = function (evt, skipLockUpdatePageSize) {
this.handler.switchState(new MouseHandlerToolboxDraggingState(this.handler, this.history, this.model, this.selection, this.visualizerManager, skipLockUpdatePageSize));
this.handler.state.onDragStart(this.dragging);
this.handler.state.onMouseMove(evt);
};
MouseHandlerBeforeToolboxDraggingState.prototype.tryRemoveTimer = function () {
if (this.nonPageAreaTimer !== undefined) {
clearTimeout(this.nonPageAreaTimer);
delete this.nonPageAreaTimer;
}
};
MouseHandlerBeforeToolboxDraggingState.prototype.finish = function () {
this.tryRemoveTimer();
};
return MouseHandlerBeforeToolboxDraggingState;
}(MouseHandlerStateBase_1.MouseHandlerCancellableState));
exports.MouseHandlerBeforeToolboxDraggingState = MouseHandlerBeforeToolboxDraggingState;
var MouseHandlerToolboxDraggingState = /** @class */ (function (_super) {
__extends(MouseHandlerToolboxDraggingState, _super);
function MouseHandlerToolboxDraggingState(handler, history, model, selection, visualizerManager, skipLockUpdatePageSize) {
var _this = _super.call(this, handler, history) || this;
_this.model = model;
_this.selection = selection;
_this.visualizerManager = visualizerManager;
if (!skipLockUpdatePageSize) {
_this.updatePageSizeTimer = setTimeout(function () {
_this.handler.tryUpdateModelSize();
delete _this.updatePageSizeTimer;
}, LOCK_UPDATEPAGESIZE_TIMER);
}
return _this;
}
MouseHandlerToolboxDraggingState.prototype.onMouseMove = function (evt) {
_super.prototype.onMouseMove.call(this, evt);
var shape = this.model.findShape(this.shapeKey);
if (shape) {
this.visualizerManager.setExtensionLines([shape]);
var container = ModelUtils_1.ModelUtils.findContainerByEventKey(this.model, this.selection, evt.source.key);
if (container && ModelUtils_1.ModelUtils.canInsertToContainer(this.model, shape, container))
this.visualizerManager.setContainerTarget(container, evt.source.type);
else
this.visualizerManager.resetContainerTarget();
}
};
MouseHandlerToolboxDraggingState.prototype.getDraggingElementKeys = function () {
return this.shapeKey === undefined ? [] : [this.shapeKey];
};
MouseHandlerToolboxDraggingState.prototype.onApplyChanges = function (evt) {
var _this = this;
if (evt.source.type === undefined) {
this.dragging.onCaptured(false);
if (this.shapeKey !== undefined && !this.deleteHistoryItem) {
this.deleteHistoryItem = new DeleteShapeHistoryItem_1.DeleteShapeHistoryItem(this.shapeKey);
this.history.addAndRedo(this.deleteHistoryItem);
}
return;
}
this.dragging.onCaptured(true);
if (this.shapeKey === undefined) {
this.startPoint = evt.modelPoint;
this.shapeKey = this.insertToolboxItem(evt);
}
if (this.deleteHistoryItem) {
this.history.undoTransactionTo(this.deleteHistoryItem);
delete this.deleteHistoryItem;
}
var pos = this.getPosition(evt, this.startShapePosition);
var shape = this.model.findShape(this.shapeKey);
ModelUtils_1.ModelUtils.setShapePosition(this.history, this.model, shape, pos);
ModelUtils_1.ModelUtils.updateMovingShapeConnections(this.history, shape, this.connectorsWithoutBeginItemInfo, this.connectorsWithoutEndItemInfo, function () {
_this.visualizerManager.resetConnectionTarget();
_this.visualizerManager.resetConnectionPoints();
}, function (shape, connectionPointIndex) {
_this.visualizerManager.setConnectionTarget(shape, Event_1.MouseEventElementType.Shape);
_this.visualizerManager.setConnectionPoints(shape, Event_1.MouseEventElementType.Shape, connectionPointIndex, true);
});
ModelUtils_1.ModelUtils.updateShapeAttachedConnectors(this.history, this.model, shape);
var container = ModelUtils_1.ModelUtils.findContainerByEventKey(this.model, this.selection, evt.source.key);
if (shape && container && ModelUtils_1.ModelUtils.canInsertToContainer(this.model, shape, container))
ModelUtils_1.ModelUtils.insertToContainer(this.history, this.model, shape, container);
else
ModelUtils_1.ModelUtils.removeFromContainer(this.history, this.model, shape);
if (this.updatePageSizeTimer === undefined) {
this.handler.tryUpdateModelSize(function (offsetLeft, offsetTop) {
_this.connectorsWithoutBeginItemInfo.forEach(function (pi) {
pi.point.x += offsetLeft;
pi.point.y += offsetTop;
});
_this.connectorsWithoutEndItemInfo.forEach(function (pi) {
pi.point.x += offsetLeft;
pi.point.y += offsetTop;
});
});
}
};
MouseHandlerToolboxDraggingState.prototype.onFinishWithChanges = function () {
this.history.addAndRedo(new SetSelectionHistoryItem_1.SetSelectionHistoryItem(this.selection, [this.shapeKey]));
};
MouseHandlerToolboxDraggingState.prototype.onDragStart = function (evt) {
this.dragging = evt;
this.connectorsWithoutBeginItemInfo = ModelUtils_1.ModelUtils.getConnectorsWithoutBeginItemInfo(this.model);
this.connectorsWithoutEndItemInfo = ModelUtils_1.ModelUtils.getConnectorsWithoutEndItemInfo(this.model);
};
MouseHandlerToolboxDraggingState.prototype.onDragEnd = function (evt) {
if (this.shapeKey !== undefined && evt.source.type === undefined)
this.cancelChanges();
this.handler.switchToDefaultState();
};
MouseHandlerToolboxDraggingState.prototype.finish = function () {
this.visualizerManager.resetExtensionLines();
this.visualizerManager.resetContainerTarget();
this.visualizerManager.resetConnectionTarget();
this.visualizerManager.resetConnectionPoints();
this.dragging.onFinishDragging();
_super.prototype.finish.call(this);
};
MouseHandlerToolboxDraggingState.prototype.updateShapeProperties = function (itemKey) {
var _this = this;
this.selection.inputPosition.stylePropertiesDefault.forEach(function (propertyName) {
_this.history.addAndRedo(new ChangeStyleHistoryItem_1.ChangeStyleHistoryItem(itemKey, propertyName, _this.selection.inputPosition.getStylePropertyDefaultValue(propertyName)));
});
this.selection.inputPosition.styleTextPropertiesDefault.forEach(function (propertyName) {
_this.history.addAndRedo(new ChangeStyleTextHistoryItem_1.ChangeStyleTextHistoryItem(itemKey, propertyName, _this.selection.inputPosition.getStyleTextPropertyValue(propertyName)));
});
};
MouseHandlerToolboxDraggingState.prototype.insertToolboxItem = function (evt) {
var description = ShapeDescriptionManager_1.ShapeDescriptionManager.get(this.dragging.data);
this.startShapePosition = this.getSnappedPoint(evt, new Utils_1.Point(evt.modelPoint.x - description.defaultSize.width / 2, evt.modelPoint.y - description.defaultSize.height / 2));
var historyItem = new AddShapeHistoryItem_1.AddShapeHistoryItem(this.dragging.data, this.startShapePosition);
this.history.addAndRedo(historyItem);
this.updateShapeProperties(historyItem.shapeKey);
return historyItem.shapeKey;
};
MouseHandlerToolboxDraggingState.prototype.getPosition = function (evt, basePoint) {
return this.getSnappedPoint(evt, new Utils_1.Point(basePoint.x + evt.modelPoint.x - this.startPoint.x, basePoint.y + evt.modelPoint.y - this.startPoint.y));
};
return MouseHandlerToolboxDraggingState;
}(MouseHandlerDraggingState_1.MouseHandlerDraggingState));
exports.MouseHandlerToolboxDraggingState = MouseHandlerToolboxDraggingState;
/***/ }),
/* 273 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var MouseHandlerDraggingState_1 = __webpack_require__(26);
var ChangeConnectorTextPositionHistoryItem_1 = __webpack_require__(274);
var ChangeConnectorTextHistoryItem_1 = __webpack_require__(54);
var MouseHandlerMoveConnectorTextState = /** @class */ (function (_super) {
__extends(MouseHandlerMoveConnectorTextState, _super);
function MouseHandlerMoveConnectorTextState(handler, history, model) {
var _this = _super.call(this, handler, history) || this;
_this.model = model;
return _this;
}
MouseHandlerMoveConnectorTextState.prototype.onMouseDown = function (evt) {
this.connector = this.model.findConnector(evt.source.key);
this.position = parseFloat(evt.source.value);
this.text = this.connector.getText(this.position);
this.savedText = "";
_super.prototype.onMouseDown.call(this, evt);
};
MouseHandlerMoveConnectorTextState.prototype.onApplyChanges = function (evt) {
var newPosition = this.connector.getTextPositionByPoint(evt.modelPoint);
if (newPosition != this.position) {
var text = this.connector.getText(newPosition);
if (text !== "" && text !== this.text) {
this.history.addAndRedo(new ChangeConnectorTextHistoryItem_1.ChangeConnectorTextHistoryItem(this.connector, newPosition, ""));
this.savedText = text;
}
this.history.addAndRedo(new ChangeConnectorTextPositionHistoryItem_1.ChangeConnectorTextPositionHistoryItem(this.connector, this.position, newPosition));
if (this.savedText !== "" && this.savedText !== text) {
this.history.addAndRedo(new ChangeConnectorTextHistoryItem_1.ChangeConnectorTextHistoryItem(this.connector, this.position, this.savedText));
this.savedText = "";
}
this.position = newPosition;
}
};
MouseHandlerMoveConnectorTextState.prototype.getDraggingElementKeys = function () {
return [this.connector.key];
};
return MouseHandlerMoveConnectorTextState;
}(MouseHandlerDraggingState_1.MouseHandlerDraggingState));
exports.MouseHandlerMoveConnectorTextState = MouseHandlerMoveConnectorTextState;
/***/ }),
/* 274 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var ChangeConnectorTextPositionHistoryItem = /** @class */ (function (_super) {
__extends(ChangeConnectorTextPositionHistoryItem, _super);
function ChangeConnectorTextPositionHistoryItem(connector, position, newPosition) {
var _this = _super.call(this) || this;
_this.connectorKey = connector.key;
_this.position = position;
_this.newPosition = newPosition;
return _this;
}
ChangeConnectorTextPositionHistoryItem.prototype.redo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
manipulator.changeConnectorTextPosition(connector, this.position, this.newPosition);
};
ChangeConnectorTextPositionHistoryItem.prototype.undo = function (manipulator) {
var connector = manipulator.model.findConnector(this.connectorKey);
manipulator.changeConnectorTextPosition(connector, this.newPosition, this.position);
};
return ChangeConnectorTextPositionHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.ChangeConnectorTextPositionHistoryItem = ChangeConnectorTextPositionHistoryItem;
/***/ }),
/* 275 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var MouseHandlerStateBase_1 = __webpack_require__(32);
var ToggleShapeExpandedHistoryItem_1 = __webpack_require__(276);
var ModelUtils_1 = __webpack_require__(6);
var MouseHandlerToggleShapeExpandedState = /** @class */ (function (_super) {
__extends(MouseHandlerToggleShapeExpandedState, _super);
function MouseHandlerToggleShapeExpandedState(handler, history, model) {
var _this = _super.call(this, handler) || this;
_this.history = history;
_this.model = model;
return _this;
}
MouseHandlerToggleShapeExpandedState.prototype.onMouseUp = function (evt) {
var shape = this.model.findShape(evt.source.key);
if (shape) {
this.history.beginTransaction();
this.history.addAndRedo(new ToggleShapeExpandedHistoryItem_1.ToggleShapeExpandedHistoryItem(shape));
ModelUtils_1.ModelUtils.updateShapeAttachedConnectors(this.history, this.model, shape);
ModelUtils_1.ModelUtils.updateContainerConnectorsAttachedPoints(this.history, this.model, shape);
this.handler.tryUpdateModelSize();
this.history.endTransaction();
this.handler.raiseClick([shape.key]);
}
this.handler.switchToDefaultState();
};
return MouseHandlerToggleShapeExpandedState;
}(MouseHandlerStateBase_1.MouseHandlerStateBase));
exports.MouseHandlerToggleShapeExpandedState = MouseHandlerToggleShapeExpandedState;
/***/ }),
/* 276 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var ToggleShapeExpandedHistoryItem = /** @class */ (function (_super) {
__extends(ToggleShapeExpandedHistoryItem, _super);
function ToggleShapeExpandedHistoryItem(shape) {
var _this = _super.call(this) || this;
_this.shapeKey = shape.key;
_this.expanded = shape.expanded;
return _this;
}
ToggleShapeExpandedHistoryItem.prototype.redo = function (manipulator) {
var shape = manipulator.model.findShape(this.shapeKey);
manipulator.changeShapeExpanded(shape, !this.expanded);
};
ToggleShapeExpandedHistoryItem.prototype.undo = function (manipulator) {
var shape = manipulator.model.findShape(this.shapeKey);
manipulator.changeShapeExpanded(shape, this.expanded);
};
return ToggleShapeExpandedHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.ToggleShapeExpandedHistoryItem = ToggleShapeExpandedHistoryItem;
/***/ }),
/* 277 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Event_1 = __webpack_require__(10);
var Utils_1 = __webpack_require__(0);
var MouseHandlerStateBase_1 = __webpack_require__(32);
var MouseHandlerSelectionState = /** @class */ (function (_super) {
__extends(MouseHandlerSelectionState, _super);
function MouseHandlerSelectionState(handler, selection, visualizerManager) {
var _this = _super.call(this, handler) || this;
_this.selection = selection;
_this.visualizerManager = visualizerManager;
return _this;
}
MouseHandlerSelectionState.prototype.finish = function () {
this.handler.raiseDragEnd([]);
this.visualizerManager.resetSelectionRectangle();
_super.prototype.finish.call(this);
};
MouseHandlerSelectionState.prototype.cancelChanges = function () {
};
MouseHandlerSelectionState.prototype.onMouseDown = function (evt) {
this.startPoint = evt.modelPoint;
this.handler.raiseDragStart([]);
};
MouseHandlerSelectionState.prototype.onMouseMove = function (evt) {
if (evt.button !== Event_1.MouseButton.Left) {
this.handler.switchToDefaultState();
}
else {
this.rectangle = Utils_1.Rectangle.createByPoints(this.startPoint, evt.modelPoint);
this.visualizerManager.setSelectionRectangle(this.rectangle);
}
};
MouseHandlerSelectionState.prototype.onMouseUp = function (evt) {
if (this.rectangle !== undefined)
this.selection.selectRect(this.rectangle);
else
this.selection.set([]);
this.rectangle = undefined;
this.handler.switchToDefaultState();
};
return MouseHandlerSelectionState;
}(MouseHandlerStateBase_1.MouseHandlerCancellableState));
exports.MouseHandlerSelectionState = MouseHandlerSelectionState;
/***/ }),
/* 278 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var MouseHandlerStateBase_1 = __webpack_require__(32);
var Event_1 = __webpack_require__(10);
var KeyCode_1 = __webpack_require__(16);
var __1 = __webpack_require__(8);
var CommandManager_1 = __webpack_require__(48);
var MouseHandlerZoomOnWheelState = /** @class */ (function (_super) {
__extends(MouseHandlerZoomOnWheelState, _super);
function MouseHandlerZoomOnWheelState(handler, settings, view, bars) {
var _this = _super.call(this, handler) || this;
_this.settings = settings;
_this.view = view;
_this.bars = bars;
return _this;
}
MouseHandlerZoomOnWheelState.prototype.onMouseWheel = function (evt) {
if (!this.trySwitchToDefault(evt)) {
this.settings.zoomLevel = this.view.getNextStepZoom(evt.deltaY < 0);
this.bars.updateItemsState([CommandManager_1.DiagramCommand.ZoomLevel]);
if (evt.source.type === Event_1.MouseEventElementType.Background)
this.view.resetScroll();
else {
this.view.scrollTo(evt.modelPoint, evt.offsetPoint);
this.view.normalize();
}
evt.preventDefault = true;
return true;
}
else
return this.handler.state.onMouseWheel(evt);
};
MouseHandlerZoomOnWheelState.prototype.onMouseUp = function (evt) {
this.handler.switchToDefaultState();
this.handler.state.onMouseUp(evt);
};
MouseHandlerZoomOnWheelState.prototype.onMouseDown = function (evt) {
this.handler.switchToDefaultState();
this.handler.state.onMouseDown(evt);
};
MouseHandlerZoomOnWheelState.prototype.onMouseMove = function (evt) {
this.trySwitchToDefault(evt) && this.handler.state.onMouseMove(evt);
};
MouseHandlerZoomOnWheelState.prototype.trySwitchToDefault = function (evt) {
if (!(evt.modifiers & KeyCode_1.ModifierKey.Ctrl)) {
this.handler.switchToDefaultState();
return true;
}
};
MouseHandlerZoomOnWheelState.prototype.start = function () {
_super.prototype.start.call(this);
this.settings.zoomLevel = this.view.getZoom();
if (this.settings.autoZoom !== __1.AutoZoomMode.Disabled) {
this.settings.autoZoom = __1.AutoZoomMode.Disabled;
this.bars.updateItemsState([CommandManager_1.DiagramCommand.SwitchAutoZoom, CommandManager_1.DiagramCommand.ToggleAutoZoom]);
}
};
return MouseHandlerZoomOnWheelState;
}(MouseHandlerStateBase_1.MouseHandlerStateBase));
exports.MouseHandlerZoomOnWheelState = MouseHandlerZoomOnWheelState;
/***/ }),
/* 279 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var MouseHandlerMoveClonedShapeState_1 = __webpack_require__(78);
var MouseHandlerMoveShapeOrthogonallyState_1 = __webpack_require__(280);
var MouseHandlerMoveShapeState = /** @class */ (function (_super) {
__extends(MouseHandlerMoveShapeState, _super);
function MouseHandlerMoveShapeState() {
return _super !== null && _super.apply(this, arguments) || this;
}
MouseHandlerMoveShapeState.prototype.onMouseMove = function (evt) {
_super.prototype.onMouseMove.call(this, evt);
this.switchToMoveClonedShapeState(evt);
};
MouseHandlerMoveShapeState.prototype.switchToMoveClonedShapeState = function (evt) {
if (MouseHandlerMoveClonedShapeState_1.MouseHandlerMoveClonedShapeState.isMoveClonedShapeEvent(evt)) {
this.cancelChanges();
this.handler.switchToMoveClonedShapeState(this.startPoint);
this.handler.onMouseDown(evt);
}
};
return MouseHandlerMoveShapeState;
}(MouseHandlerMoveShapeOrthogonallyState_1.MouseHandlerMoveShapeOrthogonallyState));
exports.MouseHandlerMoveShapeState = MouseHandlerMoveShapeState;
/***/ }),
/* 280 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var KeyCode_1 = __webpack_require__(16);
var MouseHandlerMoveShapeStateBase_1 = __webpack_require__(120);
var MouseHandlerMoveShapeOrthogonallyState = /** @class */ (function (_super) {
__extends(MouseHandlerMoveShapeOrthogonallyState, _super);
function MouseHandlerMoveShapeOrthogonallyState() {
return _super !== null && _super.apply(this, arguments) || this;
}
MouseHandlerMoveShapeOrthogonallyState.prototype.onApplyChanges = function (evt) {
this.calculateFixedPosition(evt);
_super.prototype.onApplyChanges.call(this, evt);
};
MouseHandlerMoveShapeOrthogonallyState.prototype.getXPosition = function (evt, baseX) {
return this.fixedX ? baseX : _super.prototype.getXPosition.call(this, evt, baseX);
};
MouseHandlerMoveShapeOrthogonallyState.prototype.getYPosition = function (evt, baseY) {
return this.fixedY ? baseY : _super.prototype.getYPosition.call(this, evt, baseY);
};
MouseHandlerMoveShapeOrthogonallyState.prototype.calculateFixedPosition = function (evt) {
this.fixedX = false;
this.fixedY = false;
if (evt.modifiers & KeyCode_1.ModifierKey.Shift) {
var dx = Math.abs(this.startPoint.x - evt.modelPoint.x);
var dy = Math.abs(this.startPoint.y - evt.modelPoint.y);
if (dx < dy)
this.fixedX = true;
else
this.fixedY = true;
}
};
return MouseHandlerMoveShapeOrthogonallyState;
}(MouseHandlerMoveShapeStateBase_1.MouseHandlerMoveShapeStateBase));
exports.MouseHandlerMoveShapeOrthogonallyState = MouseHandlerMoveShapeOrthogonallyState;
/***/ }),
/* 281 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var MouseHandlerDefaultReadOnlyState_1 = __webpack_require__(123);
var MouseHandlerDefaultReadOnlyTouchState = /** @class */ (function (_super) {
__extends(MouseHandlerDefaultReadOnlyTouchState, _super);
function MouseHandlerDefaultReadOnlyTouchState() {
return _super !== null && _super.apply(this, arguments) || this;
}
MouseHandlerDefaultReadOnlyTouchState.prototype.canDragObjectOnMouseDown = function (key) {
return false;
};
MouseHandlerDefaultReadOnlyTouchState.prototype.canClearSelectionOnMouseDown = function () {
return true;
};
MouseHandlerDefaultReadOnlyTouchState.prototype.processOnMouseMoveAfterLimit = function (evt) {
this.startScrolling(evt);
};
MouseHandlerDefaultReadOnlyTouchState.prototype.canSelectOnMouseUp = function (key) {
return !this.inSelection(key);
};
MouseHandlerDefaultReadOnlyTouchState.prototype.canClearSelectionOnMouseUp = function () {
return false;
};
return MouseHandlerDefaultReadOnlyTouchState;
}(MouseHandlerDefaultReadOnlyState_1.MouseHandlerDefaultReadOnlyState));
exports.MouseHandlerDefaultReadOnlyTouchState = MouseHandlerDefaultReadOnlyTouchState;
/***/ }),
/* 282 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var MouseHandlerDefaultState_1 = __webpack_require__(117);
var MouseHandlerZoomOnPinchState_1 = __webpack_require__(283);
var MouseHandlerDefaultTouchState = /** @class */ (function (_super) {
__extends(MouseHandlerDefaultTouchState, _super);
function MouseHandlerDefaultTouchState() {
return _super !== null && _super.apply(this, arguments) || this;
}
MouseHandlerDefaultTouchState.prototype.updateConnectionsOnMouseMove = function (evt) {
};
MouseHandlerDefaultTouchState.prototype.canDragObjectOnMouseDown = function (key) {
return this.inSelection(key);
};
MouseHandlerDefaultTouchState.prototype.canClearSelectionOnMouseDown = function () {
return true;
};
MouseHandlerDefaultTouchState.prototype.processOnMouseMoveAfterLimit = function (evt) {
if (evt.touches.length > 1)
this.startZooming(evt);
else
this.startScrolling(evt);
};
MouseHandlerDefaultTouchState.prototype.startZooming = function (evt) {
this.handler.switchState(new MouseHandlerZoomOnPinchState_1.MouseHandlerZoomOnPinchState(this.handler, this.selection, this.settings, this.view, this.bars));
};
MouseHandlerDefaultTouchState.prototype.canSelectOnMouseUp = function (key) {
return !this.inSelection(key);
};
MouseHandlerDefaultTouchState.prototype.canClearSelectionOnMouseUp = function () {
return false;
};
return MouseHandlerDefaultTouchState;
}(MouseHandlerDefaultState_1.MouseHandlerDefaultState));
exports.MouseHandlerDefaultTouchState = MouseHandlerDefaultTouchState;
/***/ }),
/* 283 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var DiagramSettings_1 = __webpack_require__(35);
var CommandManager_1 = __webpack_require__(48);
var Utils_1 = __webpack_require__(0);
var MouseHandlerScrollingState_1 = __webpack_require__(122);
var PINCH_CHANGE_DISTANCE = 1;
var MouseHandlerZoomOnPinchState = /** @class */ (function (_super) {
__extends(MouseHandlerZoomOnPinchState, _super);
function MouseHandlerZoomOnPinchState(handler, selection, settings, view, bars) {
var _this = _super.call(this, handler, view, selection) || this;
_this.selection = selection;
_this.settings = settings;
_this.view = view;
_this.bars = bars;
return _this;
}
MouseHandlerZoomOnPinchState.prototype.onMouseDown = function (evt) {
_super.prototype.onMouseDown.call(this, evt);
if (evt.touches.length > 1) {
this.startDistance = this.getTouchDistance(evt);
this.startZoomLevel = this.settings.zoomLevel;
this.prevDistance = this.startDistance;
}
};
MouseHandlerZoomOnPinchState.prototype.onMouseMove = function (evt) {
if (evt.touches.length > 1) {
var distance = this.getTouchDistance(evt);
if (Math.abs(this.prevDistance - distance) > PINCH_CHANGE_DISTANCE) {
this.settings.zoomLevel = this.startZoomLevel * (distance / this.startDistance);
this.bars.updateItemsState([CommandManager_1.DiagramCommand.ZoomLevel]);
this.view.scrollTo(this.getMiddleLayoutPoint(evt), this.getMiddleAbsPoint(evt));
this.view.normalize();
this.prevDistance = distance;
}
}
_super.prototype.onMouseMove.call(this, evt);
};
MouseHandlerZoomOnPinchState.prototype.onMouseUp = function (evt) {
if (evt.touches.length === 0) {
setTimeout(function () {
this.handler.switchToDefaultState();
}.bind(this), 1);
}
};
MouseHandlerZoomOnPinchState.prototype.start = function () {
_super.prototype.start.call(this);
this.settings.zoomLevel = this.view.getZoom();
if (this.settings.autoZoom !== DiagramSettings_1.AutoZoomMode.Disabled) {
this.settings.autoZoom = DiagramSettings_1.AutoZoomMode.Disabled;
this.bars.updateItemsState([CommandManager_1.DiagramCommand.SwitchAutoZoom, CommandManager_1.DiagramCommand.ToggleAutoZoom]);
}
};
MouseHandlerZoomOnPinchState.prototype.getTouchDistance = function (evt) {
var pt0 = new Utils_1.Point(evt.touches[0].offsetPoint.x, evt.touches[0].offsetPoint.y);
var pt1 = new Utils_1.Point(evt.touches[1].offsetPoint.x, evt.touches[1].offsetPoint.y);
return Utils_1.GeometryUtils.getDistance(pt0, pt1);
};
MouseHandlerZoomOnPinchState.prototype.getPointByEvent = function (evt) {
return this.getMiddleAbsPoint(evt);
};
MouseHandlerZoomOnPinchState.prototype.getMiddleAbsPoint = function (evt) {
if (evt.touches.length > 1)
return MouseHandlerZoomOnPinchState.getMiddlePointByEvent(evt, function (touch) { return touch.offsetPoint; });
return evt.offsetPoint;
};
MouseHandlerZoomOnPinchState.prototype.getMiddleLayoutPoint = function (evt) {
if (evt.touches.length > 1)
return MouseHandlerZoomOnPinchState.getMiddlePointByEvent(evt, function (touch) { return touch.modelPoint; });
return evt.modelPoint;
};
MouseHandlerZoomOnPinchState.getMiddlePointByEvent = function (evt, getPoint) {
if (evt.touches.length > 1) {
return new Utils_1.Point((getPoint(evt.touches[0]).x + getPoint(evt.touches[1]).x) / 2, (getPoint(evt.touches[0]).y + getPoint(evt.touches[1]).y) / 2);
}
};
return MouseHandlerZoomOnPinchState;
}(MouseHandlerScrollingState_1.MouseHandlerScrollingState));
exports.MouseHandlerZoomOnPinchState = MouseHandlerZoomOnPinchState;
/***/ }),
/* 284 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ChangeShapeTextHistoryItem_1 = __webpack_require__(285);
var Event_1 = __webpack_require__(10);
var KeyCode_1 = __webpack_require__(16);
var Shape_1 = __webpack_require__(11);
var Connector_1 = __webpack_require__(5);
var ChangeConnectorTextHistoryItem_1 = __webpack_require__(54);
var TextInputHandler = /** @class */ (function () {
function TextInputHandler(control) {
this.control = control;
}
TextInputHandler.prototype.startTextInput = function (item, position) {
if (item.isLocked || !item.enableText || !item.allowEditText || this.control.settings.readOnly)
return;
this.control.beginUpdate();
this.textInputItem = item;
if (this.textInputItem instanceof Shape_1.Shape) {
var textRect = this.textInputItem.textEditRectangle;
this.control.eventManager.raiseTextInputStart(this.textInputItem, this.textInputItem.text, textRect.position, textRect.size);
}
if (this.textInputItem instanceof Connector_1.Connector) {
this.textInputPosition = position;
this.control.eventManager.raiseTextInputStart(this.textInputItem, this.textInputItem.getText(this.textInputPosition), this.textInputItem.getTextPoint(this.textInputPosition));
}
};
TextInputHandler.prototype.endTextInput = function () {
var textInputItem = this.textInputItem;
delete this.textInputItem;
this.control.eventManager.raiseTextInputEnd(textInputItem);
this.control.endUpdate();
};
TextInputHandler.prototype.applyTextInput = function (text) {
var textInputItem = this.textInputItem;
var textInputPosition = this.textInputPosition;
// call this first to be able measure text on changes
this.endTextInput();
if (textInputItem instanceof Shape_1.Shape) {
if (textInputItem.text !== text)
this.control.history.addAndRedo(new ChangeShapeTextHistoryItem_1.ChangeShapeTextHistoryItem(textInputItem, text));
}
else if (textInputItem instanceof Connector_1.Connector) {
if (textInputItem.getText(textInputPosition) !== text)
this.control.history.addAndRedo(new ChangeConnectorTextHistoryItem_1.ChangeConnectorTextHistoryItem(textInputItem, textInputPosition, text));
}
};
TextInputHandler.prototype.cancelTextInput = function () {
this.endTextInput();
};
TextInputHandler.prototype.isTextInputActive = function () {
return this.textInputItem !== undefined;
};
TextInputHandler.prototype.processDblClick = function (evt) {
if (evt.source.type === Event_1.MouseEventElementType.Shape) {
var shape = this.control.model.findShape(evt.source.key);
this.startTextInput(shape);
}
else if (evt.source.type === Event_1.MouseEventElementType.Connector) {
var connector = this.control.model.findConnector(evt.source.key);
var position = connector.getTextPositionByPoint(evt.modelPoint);
this.startTextInput(connector, position);
}
else if (evt.source.type === Event_1.MouseEventElementType.ConnectorText) {
var connector = this.control.model.findConnector(evt.source.key);
var position = parseFloat(evt.source.value);
this.startTextInput(connector, position);
}
};
TextInputHandler.prototype.onDblClick = function (evt) {
this.processDblClick(evt);
};
TextInputHandler.prototype.onKeyDown = function (evt) {
if (!this.isTextInputActive())
return;
if (evt.keyCode === 13 && (evt.modifiers & KeyCode_1.ModifierKey.Ctrl)) {
evt.preventDefault = true;
this.applyTextInput(evt.inputText);
}
if (evt.keyCode === 27)
this.cancelTextInput();
};
TextInputHandler.prototype.onBlur = function (evt) {
if (this.isTextInputActive())
this.applyTextInput(evt.inputText);
};
TextInputHandler.prototype.onFocus = function (evt) {
};
return TextInputHandler;
}());
exports.TextInputHandler = TextInputHandler;
/***/ }),
/* 285 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var ChangeShapeTextHistoryItem = /** @class */ (function (_super) {
__extends(ChangeShapeTextHistoryItem, _super);
function ChangeShapeTextHistoryItem(item, text) {
var _this = _super.call(this) || this;
_this.shapeKey = item.key;
_this.text = text;
return _this;
}
ChangeShapeTextHistoryItem.prototype.redo = function (manipulator) {
var item = manipulator.model.findShape(this.shapeKey);
this.oldText = item.text;
manipulator.changeShapeText(item, this.text);
};
ChangeShapeTextHistoryItem.prototype.undo = function (manipulator) {
var item = manipulator.model.findShape(this.shapeKey);
manipulator.changeShapeText(item, this.oldText);
};
return ChangeShapeTextHistoryItem;
}(HistoryItem_1.HistoryItem));
exports.ChangeShapeTextHistoryItem = ChangeShapeTextHistoryItem;
/***/ }),
/* 286 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Event_1 = __webpack_require__(10);
var Model_1 = __webpack_require__(19);
var ContextMenuHandler_1 = __webpack_require__(124);
var ContextMenuTouchHandler = /** @class */ (function (_super) {
__extends(ContextMenuTouchHandler, _super);
function ContextMenuTouchHandler(selection) {
var _this = _super.call(this) || this;
_this.selection = selection;
_this.selection.onChanged.add(_this);
return _this;
}
ContextMenuTouchHandler.prototype.onMouseDown = function (evt) {
};
ContextMenuTouchHandler.prototype.onMouseUp = function (evt) {
};
ContextMenuTouchHandler.prototype.onFocus = function (evt) {
setTimeout(function () {
this.showContextMenuAtSelection();
}.bind(this), 1);
};
ContextMenuTouchHandler.prototype.onBlur = function (evt) {
setTimeout(function () {
if (!this.isLongTouch)
this.hideContextMenu();
}.bind(this), 1);
};
ContextMenuTouchHandler.prototype.onTextInputFocus = function (evt) {
setTimeout(function () {
this.hideContextMenu();
}.bind(this), 1);
};
ContextMenuTouchHandler.prototype.onTextInputBlur = function (evt) {
setTimeout(function () {
this.showContextMenuAtSelection();
}.bind(this), 1);
};
ContextMenuTouchHandler.prototype.onLongTouch = function (evt) {
if (evt.source.type === Event_1.MouseEventElementType.Document)
this.showContextMenuAtEmptySelection(evt.modelPoint);
};
ContextMenuTouchHandler.prototype.getSelectedItems = function () {
return this.selection.getSelectedItems(true);
};
ContextMenuTouchHandler.prototype.showContextMenuAtSelection = function () {
var items = this.getSelectedItems();
if (items.length !== 0)
this.showContextMenu(undefined, Model_1.DiagramModel.getRectangle(items).position);
};
ContextMenuTouchHandler.prototype.showContextMenuAtEmptySelection = function (point) {
var items = this.getSelectedItems();
if (items.length === 0)
this.showContextMenu(undefined, point);
};
ContextMenuTouchHandler.prototype.notifySelectionChanged = function (selection) {
var items = this.getSelectedItems();
if (items.length !== 0)
this.showContextMenuAtSelection();
else
this.hideContextMenu();
};
ContextMenuTouchHandler.prototype.notifyDragStart = function (itemKeys) {
this.hideContextMenu();
};
ContextMenuTouchHandler.prototype.notifyDragEnd = function (itemKeys) {
this.showContextMenuAtSelection();
};
return ContextMenuTouchHandler;
}(ContextMenuHandler_1.ContextMenuHandler));
exports.ContextMenuTouchHandler = ContextMenuTouchHandler;
/***/ }),
/* 287 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var TargetVisualizerBase_1 = __webpack_require__(126);
var ConnectionTargetVisualizer = /** @class */ (function (_super) {
__extends(ConnectionTargetVisualizer, _super);
function ConnectionTargetVisualizer(dispatcher) {
return _super.call(this, dispatcher) || this;
}
ConnectionTargetVisualizer.prototype.raiseShow = function () {
var _this = this;
this.dispatcher.raise1(function (l) { return l.notifyConnectionTargetShow(_this.key, _this.targetRect); });
};
ConnectionTargetVisualizer.prototype.raiseHide = function () {
this.dispatcher.raise1(function (l) { return l.notifyConnectionTargetHide(); });
};
return ConnectionTargetVisualizer;
}(TargetVisualizerBase_1.TargetVisualizerBase));
exports.ConnectionTargetVisualizer = ConnectionTargetVisualizer;
/***/ }),
/* 288 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var TargetVisualizerBase_1 = __webpack_require__(126);
var ContainerTargetVisualizer = /** @class */ (function (_super) {
__extends(ContainerTargetVisualizer, _super);
function ContainerTargetVisualizer(dispatcher) {
return _super.call(this, dispatcher) || this;
}
ContainerTargetVisualizer.prototype.raiseShow = function () {
var _this = this;
this.dispatcher.raise1(function (l) { return l.notifyContainerTargetShow(_this.key, _this.targetRect); });
};
ContainerTargetVisualizer.prototype.raiseHide = function () {
this.dispatcher.raise1(function (l) { return l.notifyContainerTargetHide(); });
};
return ContainerTargetVisualizer;
}(TargetVisualizerBase_1.TargetVisualizerBase));
exports.ContainerTargetVisualizer = ContainerTargetVisualizer;
/***/ }),
/* 289 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ConnectionPointInfo = /** @class */ (function () {
function ConnectionPointInfo(point, side) {
this.point = point;
this.side = side;
}
return ConnectionPointInfo;
}());
exports.ConnectionPointInfo = ConnectionPointInfo;
var ConnectionPointsVisualizer = /** @class */ (function () {
function ConnectionPointsVisualizer(dispatcher) {
this.dispatcher = dispatcher;
}
ConnectionPointsVisualizer.prototype.getKey = function () {
return this.key;
};
ConnectionPointsVisualizer.prototype.setPoints = function (key, points, pointIndex, isSelected) {
if (this.key !== key || this.pointIndex !== pointIndex) {
this.key = key;
this.isSelected = isSelected;
this.points = points;
this.pointIndex = pointIndex;
this.raiseShow();
}
};
ConnectionPointsVisualizer.prototype.setPointIndex = function (pointIndex) {
if (0 <= pointIndex && pointIndex < this.points.length && this.pointIndex !== pointIndex) {
this.pointIndex = pointIndex;
this.raiseShow();
}
};
ConnectionPointsVisualizer.prototype.update = function () {
this.raiseShow();
};
ConnectionPointsVisualizer.prototype.reset = function () {
if (this.key !== "-1") {
this.key = "-1";
this.isSelected = false;
this.points = [];
this.pointIndex = -1;
this.raiseHide();
}
};
ConnectionPointsVisualizer.prototype.raiseShow = function () {
var _this = this;
this.dispatcher.raise1(function (l) { return l.notifyConnectionPointsShow(_this.key, _this.points, _this.pointIndex, _this.isSelected); });
};
ConnectionPointsVisualizer.prototype.raiseHide = function () {
this.dispatcher.raise1(function (l) { return l.notifyConnectionPointsHide(); });
};
return ConnectionPointsVisualizer;
}());
exports.ConnectionPointsVisualizer = ConnectionPointsVisualizer;
/***/ }),
/* 290 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ResizeInfoVisualizer = /** @class */ (function () {
function ResizeInfoVisualizer(dispatcher) {
this.dispatcher = dispatcher;
}
ResizeInfoVisualizer.prototype.set = function (point, text) {
this.point = point;
this.text = text;
this.raiseShow();
};
ResizeInfoVisualizer.prototype.reset = function () {
if (this.point !== undefined) {
this.point = undefined;
this.text = undefined;
this.raiseHide();
}
};
ResizeInfoVisualizer.prototype.raiseShow = function () {
var _this = this;
this.dispatcher.raise1(function (l) { return l.notifyResizeInfoShow(_this.point, _this.text); });
};
ResizeInfoVisualizer.prototype.raiseHide = function () {
this.dispatcher.raise1(function (l) { return l.notifyResizeInfoHide(); });
};
return ResizeInfoVisualizer;
}());
exports.ResizeInfoVisualizer = ResizeInfoVisualizer;
/***/ }),
/* 291 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var SelectionRectVisualizer = /** @class */ (function () {
function SelectionRectVisualizer(dispatcher) {
this.dispatcher = dispatcher;
}
SelectionRectVisualizer.prototype.setRectangle = function (rect) {
this.rect = rect;
this.raiseShow();
};
SelectionRectVisualizer.prototype.reset = function () {
this.rect = undefined;
this.raiseHide();
};
SelectionRectVisualizer.prototype.raiseShow = function () {
var _this = this;
this.dispatcher.raise1(function (l) { return l.notifySelectionRectShow(_this.rect); });
};
SelectionRectVisualizer.prototype.raiseHide = function () {
this.dispatcher.raise1(function (l) { return l.notifySelectionRectHide(); });
};
return SelectionRectVisualizer;
}());
exports.SelectionRectVisualizer = SelectionRectVisualizer;
/***/ }),
/* 292 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var VisualizersManager_1 = __webpack_require__(125);
var Event_1 = __webpack_require__(10);
var VisualizerTouchManager = /** @class */ (function (_super) {
__extends(VisualizerTouchManager, _super);
function VisualizerTouchManager(selection, model, eventManager, settings, readOnly) {
if (readOnly === void 0) { readOnly = settings.readOnly; }
var _this = _super.call(this, selection, model, eventManager, settings, readOnly) || this;
selection.onChanged.add(_this);
return _this;
}
VisualizerTouchManager.prototype.onBlur = function (evt) {
setTimeout(function () {
this.hideConnections();
}.bind(this), 1);
};
VisualizerTouchManager.prototype.onFocus = function (evt) {
setTimeout(function () {
this.showConnections();
}.bind(this), 1);
};
VisualizerTouchManager.prototype.hideConnections = function () {
if (this.readOnly)
return;
this.resetConnectionPoints();
};
VisualizerTouchManager.prototype.showConnections = function () {
if (this.readOnly)
return;
if (this.needShowConnections()) {
var shapes = this.selection.getSelectedShapes();
this.setConnectionPoints(shapes[0], Event_1.MouseEventElementType.ShapeConnectionPoint, -1);
}
};
VisualizerTouchManager.prototype.needShowConnections = function () {
var items = this.selection.getSelectedItems();
var shapes = this.selection.getSelectedShapes();
return (items.length === 1 && shapes.length === 1);
};
VisualizerTouchManager.prototype.notifySelectionChanged = function (selection) {
if (this.needShowConnections())
this.showConnections();
else
this.hideConnections();
};
VisualizerTouchManager.prototype.notifyDragStart = function (itemKeys) {
this.hideConnections();
};
VisualizerTouchManager.prototype.notifyDragEnd = function (itemKeys) {
this.showConnections();
};
return VisualizerTouchManager;
}(VisualizersManager_1.VisualizerManager));
exports.VisualizerTouchManager = VisualizerTouchManager;
/***/ }),
/* 293 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Utils_1 = __webpack_require__(0);
var InputPosition_1 = __webpack_require__(294);
var Shape_1 = __webpack_require__(11);
var Connector_1 = __webpack_require__(5);
var Selection = /** @class */ (function () {
function Selection(model) {
this.onChanged = new Utils_1.EventDispatcher();
this.inputPosition = new InputPosition_1.InputPosition(this);
this.onChanged.add(this.inputPosition);
this.initialize(model);
}
Selection.prototype.initialize = function (model) {
this.model = model;
this.keys = [];
this.inputPosition.initialize();
};
Selection.prototype.add = function (key) {
if (this.keys.indexOf(key) < 0) { // binarySearch
this.keys.push(key);
this.raiseSelectionChanged();
}
};
Selection.prototype.remove = function (key) {
if (this.keys.indexOf(key) >= 0) { // binarySearch
this.keys.splice(this.keys.indexOf(key), 1);
this.raiseSelectionChanged();
}
};
Selection.prototype.clear = function () {
this.keys = [];
this.raiseSelectionChanged();
};
Selection.prototype.set = function (keys) {
this.keys = keys;
this.raiseSelectionChanged();
};
Selection.prototype.getKeys = function () {
return this.keys;
};
Selection.prototype.getKey = function (index) {
return this.keys[index];
};
Selection.prototype.getSelectedItemsInsideContainers = function (items) {
var _this = this;
var result = items.slice();
items.forEach(function (item) {
if (item instanceof Shape_1.Shape) {
var children = _this.getSelectedItemsInsideContainers(_this.model.getChildren(item));
children.forEach(function (child) {
if (result.indexOf(child) === -1 && !_this.hasKey(child.key))
result.push(child);
});
}
});
return result;
};
Selection.prototype.getSelectedItemsCore = function (includeLocked) {
var _this = this;
return this.keys.map(function (key) { return _this.model.findItem(key); })
.filter(function (conn) { return conn && (includeLocked || !conn.isLocked); });
};
Selection.prototype.getSelectedItems = function (includeLocked, includeInsideContainers) {
if (includeInsideContainers)
return this.getSelectedItemsInsideContainers(this.getSelectedItemsCore(includeLocked));
return this.getSelectedItemsCore(includeLocked);
};
Selection.prototype.getSelectedShapes = function (includeLocked, includeInsideContainers) {
var _this = this;
if (includeInsideContainers) {
var items = this.getSelectedItemsCore(includeLocked);
return this.getSelectedItemsInsideContainers(items)
.map(function (item) { return item instanceof Shape_1.Shape ? item : undefined; })
.filter(function (shape) { return shape; });
}
else
return this.keys.map(function (key) { return _this.model.findShape(key); })
.filter(function (conn) { return conn && (includeLocked || !conn.isLocked); });
};
Selection.prototype.getSelectedConnectors = function (includeLocked, includeInsideContainers) {
var _this = this;
if (includeInsideContainers) {
var items = this.keys.map(function (key) { return _this.model.findItem(key); });
return this.getSelectedItemsInsideContainers(items)
.map(function (item) { return item instanceof Connector_1.Connector ? item : undefined; })
.filter(function (connector) { return connector; });
}
else
return this.keys.map(function (key) { return _this.model.findConnector(key); })
.filter(function (conn) { return conn && (includeLocked || !conn.isLocked); });
};
Selection.prototype.hasKey = function (key) {
return this.keys.indexOf(key) >= 0;
};
Selection.prototype.isEmpty = function (includeLocked) {
return !this.getSelectedItems(includeLocked).length;
};
Selection.prototype.selectRect = function (rect) {
var keys = [];
this.model.iterateItems(function (item) {
if (item.intersectedByRect(rect))
keys.push(item.key);
});
this.set(keys);
this.raiseSelectionChanged();
};
Selection.prototype.onLoad = function () {
this.raiseSelectionChanged();
};
Selection.prototype.raiseSelectionChanged = function () {
this.onChanged.raise("notifySelectionChanged", this);
};
return Selection;
}());
exports.Selection = Selection;
/***/ }),
/* 294 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ConnectorProperties_1 = __webpack_require__(24);
var Style_1 = __webpack_require__(27);
var InputPosition = /** @class */ (function () {
function InputPosition(selection) {
this.selection = selection;
this.initialize();
}
InputPosition.prototype.initialize = function () {
this.reset();
this.connectorPropertiesDefault = new ConnectorProperties_1.ConnectorProperties();
this.stylePropertiesDefault = new Style_1.Style();
this.styleTextPropertiesDefault = new Style_1.StyleText();
};
InputPosition.prototype.reset = function () {
this.connectorPropertiesCurrent = null;
this.stylePropertiesCurrent = null;
this.styleTextPropertiesCurrent = null;
};
// Connectors
InputPosition.prototype.getConnectorProperties = function () {
if (!this.connectorPropertiesCurrent) {
this.connectorPropertiesCurrent = this.connectorPropertiesDefault.clone();
this.updateConnectorProperties(this.connectorPropertiesCurrent);
}
return this.connectorPropertiesCurrent;
};
InputPosition.prototype.getConnectorPropertyValue = function (propertyName) {
return this.getConnectorProperties()[propertyName];
};
InputPosition.prototype.getConnectorPropertyDefaultValue = function (propertyName) {
return this.connectorPropertiesDefault[propertyName];
};
InputPosition.prototype.setConnectorPropertyValue = function (propertyName, value) {
this.getConnectorProperties()[propertyName] = value;
this.connectorPropertiesDefault[propertyName] = value;
};
InputPosition.prototype.updateConnectorProperties = function (properties) {
var _this = this;
var connectors = this.selection.getSelectedConnectors();
properties.forEach(function (propertyName) {
_this.updatePropertyValue(properties, connectors, function (item) { return item["properties"]; }, propertyName);
});
};
// Style
InputPosition.prototype.getStyleProperties = function () {
if (!this.stylePropertiesCurrent) {
this.stylePropertiesCurrent = this.stylePropertiesDefault.clone();
this.updateStyleProperties(this.stylePropertiesCurrent, "style");
}
return this.stylePropertiesCurrent;
};
InputPosition.prototype.getStyleTextProperties = function () {
if (!this.styleTextPropertiesCurrent) {
this.styleTextPropertiesCurrent = this.styleTextPropertiesDefault.clone();
this.updateStyleProperties(this.styleTextPropertiesCurrent, "styleText");
}
return this.styleTextPropertiesCurrent;
};
InputPosition.prototype.getStylePropertyValue = function (propertyName) {
return this.getStyleProperties()[propertyName];
};
InputPosition.prototype.getStylePropertyDefaultValue = function (propertyName) {
return this.stylePropertiesDefault[propertyName];
};
InputPosition.prototype.getStyleTextPropertyValue = function (propertyName) {
return this.getStyleTextProperties()[propertyName];
};
InputPosition.prototype.getStyleTextPropertyDefaultValue = function (propertyName) {
return this.styleTextPropertiesDefault[propertyName];
};
InputPosition.prototype.setStylePropertyValue = function (propertyName, value) {
this.getStyleProperties()[propertyName] = value;
this.stylePropertiesDefault[propertyName] = value;
};
InputPosition.prototype.setStyleTextPropertyValue = function (propertyName, value) {
this.getStyleTextProperties()[propertyName] = value;
this.styleTextPropertiesDefault[propertyName] = value;
};
InputPosition.prototype.updateStyleProperties = function (style, stylePropertyName) {
var _this = this;
var items = this.selection.getSelectedItems();
style.forEach(function (propertyName) {
_this.updatePropertyValue(style, items, function (item) { return item[stylePropertyName]; }, propertyName);
});
};
InputPosition.prototype.updatePropertyValue = function (destObj, items, getSrcObj, propertyName) {
var value = undefined;
var valueAssigned = false;
items.forEach(function (item) {
var obj = getSrcObj(item);
var propertyValue = obj[propertyName];
if (value === undefined && propertyValue != undefined) {
value = propertyValue;
valueAssigned = true;
}
else if (valueAssigned && value !== propertyValue) {
value = undefined;
return;
}
});
if (valueAssigned)
destObj[propertyName] = value;
};
InputPosition.prototype.notifySelectionChanged = function (selection) {
this.reset();
};
return InputPosition;
}());
exports.InputPosition = InputPosition;
/***/ }),
/* 295 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var HistoryItem_1 = __webpack_require__(3);
var __1 = __webpack_require__(8);
var History = /** @class */ (function () {
function History(modelManipulator) {
this.historyItems = [];
this.currentIndex = -1;
this.incrementalId = -1;
this.transactionLevel = -1;
this.unmodifiedIndex = -1;
// need for async actions
this.currTransactionId = 0;
this.onChanged = new __1.EventDispatcher();
this.modelManipulator = modelManipulator;
}
History.prototype.isModified = function () {
if (this.unmodifiedIndex == this.currentIndex)
return false;
var startIndex = Math.min(this.unmodifiedIndex, this.currentIndex);
var endIndex = Math.max(this.unmodifiedIndex, this.currentIndex);
for (var i = startIndex + 1; i <= endIndex; i++) {
if (this.historyItems[i].changeModified())
return true;
}
return false;
};
History.prototype.undo = function () {
if (!this.canUndo())
return;
this.historyItems[this.currentIndex].undo(this.modelManipulator);
this.currentIndex--;
this.raiseChanged();
};
History.prototype.redo = function () {
if (!this.canRedo())
return;
this.currentIndex++;
this.historyItems[this.currentIndex].redo(this.modelManipulator);
this.raiseChanged();
};
History.prototype.canUndo = function () {
return this.currentIndex >= 0;
};
History.prototype.canRedo = function () {
return this.currentIndex < this.historyItems.length - 1;
};
History.prototype.beginTransaction = function () {
this.transactionLevel++;
if (this.transactionLevel == 0)
this.transaction = new HistoryItem_1.CompositionHistoryItem();
var id = this.currTransactionId++;
return id;
};
History.prototype.endTransaction = function () {
if (--this.transactionLevel >= 0)
return;
var transactionLength = this.transaction.historyItems.length;
if (transactionLength > 1)
this.addInternal(this.transaction);
else if (transactionLength == 1)
this.addInternal(this.transaction.historyItems.pop());
if (transactionLength > 0)
this.raiseChanged();
delete this.transaction;
};
History.prototype.addAndRedo = function (historyItem) {
this.add(historyItem);
historyItem.redo(this.modelManipulator);
this.raiseChanged();
};
History.prototype.add = function (historyItem) {
if (this.transactionLevel >= 0)
this.transaction.add(historyItem);
else
this.addInternal(historyItem);
};
History.prototype.addInternal = function (historyItem) {
if (this.currentIndex < this.historyItems.length - 1) {
this.historyItems.splice(this.currentIndex + 1);
this.unmodifiedIndex = Math.min(this.unmodifiedIndex, this.currentIndex);
}
this.historyItems.push(historyItem);
this.currentIndex++;
this.deleteOldItems();
};
History.prototype.deleteOldItems = function () {
var exceedItemsCount = this.historyItems.length - History.MAX_HISTORY_ITEM_COUNT;
if (exceedItemsCount > 0 && this.currentIndex > exceedItemsCount) {
this.historyItems.splice(0, exceedItemsCount);
this.currentIndex -= exceedItemsCount;
}
};
History.prototype.getNextId = function () {
this.incrementalId++;
return this.incrementalId;
};
History.prototype.clear = function () {
this.currentIndex = -1;
this.unmodifiedIndex = -1;
this.incrementalId = -1;
this.historyItems = [];
delete this.transaction;
this.transactionLevel = -1;
};
History.prototype.resetModified = function () {
this.unmodifiedIndex = this.currentIndex;
};
History.prototype.getCurrentItemId = function () {
if (this.currentIndex == -1)
return -1;
var currentItem = this.historyItems[this.currentIndex];
if (currentItem.uniqueId == -1)
currentItem.uniqueId = this.getNextId();
return currentItem.uniqueId;
};
History.prototype.undoTransaction = function () {
var items = this.transaction.historyItems;
while (items.length)
items.pop().undo(this.modelManipulator);
this.raiseChanged();
};
History.prototype.undoTransactionTo = function (item) {
var items = this.transaction.historyItems;
while (items.length) {
var ti = items.pop();
ti.undo(this.modelManipulator);
if (ti === item)
return;
}
this.raiseChanged();
};
History.prototype.raiseChanged = function () {
if (this.transactionLevel === -1)
this.onChanged.raise("notifyHistoryChanged");
};
History.MAX_HISTORY_ITEM_COUNT = 100;
return History;
}());
exports.History = History;
/***/ }),
/* 296 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var BatchUpdatableObject_1 = __webpack_require__(127);
var BarManager = /** @class */ (function (_super) {
__extends(BarManager, _super);
function BarManager(control) {
var _this = _super.call(this) || this;
_this.bars = [];
_this.control = control;
return _this;
}
BarManager.prototype.registerBar = function (bar) {
this.bars.push(bar);
bar.onChanged.add(this);
this.updateBarItemsState(bar);
};
BarManager.prototype.updateItemsState = function (queryCommands) {
if (this.isUpdateLocked())
return;
for (var i = 0, bar; bar = this.bars[i]; i++)
this.updateBarItemsState(bar, queryCommands);
};
BarManager.prototype.updateBarItemsState = function (bar, queryCommands) {
if (this.isUpdateLocked())
return;
if (bar.isVisible()) {
var commandKeys = void 0;
if (queryCommands) {
var knownCommandKeys_1 = bar.getCommandKeys().reduce(function (hash, cmd) {
hash[cmd] = true;
return hash;
}, {});
commandKeys = queryCommands.filter(function (cmd) { return knownCommandKeys_1[cmd]; });
}
else
commandKeys = bar.getCommandKeys();
var length_1 = commandKeys.length;
for (var j = 0; j < length_1; j++)
this.updateBarItem(bar, commandKeys[j]);
}
};
BarManager.prototype.updateBarItem = function (bar, commandKey) {
var command = this.control.commandManager.getCommand(commandKey);
if (command) {
var commandState = command.getState();
bar.setItemVisible(commandKey, commandState.visible);
if (commandState.visible) {
bar.setItemEnabled(commandKey, commandState.enabled);
if (!commandState.denyUpdateValue) {
var itemValue = this.getItemValue(commandState.value);
if (commandState.items)
bar.setItemSubItems(commandKey, commandState.items);
bar.setItemValue(commandKey, itemValue, this.getDefaultItemValue(commandState.defaultValue));
}
}
}
};
BarManager.prototype.setEnabled = function (enabled) {
for (var i = 0, bar; bar = this.bars[i]; i++)
bar.setEnabled(enabled);
};
BarManager.prototype.notifyBarCommandExecuted = function (commandID, parameter) {
var executeResult = this.control.commandManager.getCommand(commandID).execute(parameter);
if (!executeResult)
this.updateItemsState([commandID]);
};
BarManager.prototype.notifyBarUpdateRequested = function () {
this.updateItemsState();
};
// ISelectionChangesListener
BarManager.prototype.notifySelectionChanged = function (_selection) {
this.updateItemsState();
};
BarManager.prototype.onUpdateUnlocked = function (occurredEvents) {
this.updateItemsState(); // TODO
};
BarManager.prototype.getItemValue = function (value) {
return value;
};
BarManager.prototype.getDefaultItemValue = function (value) {
return value;
};
return BarManager;
}(BatchUpdatableObject_1.BatchUpdatableObject));
exports.BarManager = BarManager;
/***/ }),
/* 297 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeTypes_1 = __webpack_require__(1);
var Shape_1 = __webpack_require__(11);
var Connector_1 = __webpack_require__(5);
var DataSource_1 = __webpack_require__(298);
var ModelUtils_1 = __webpack_require__(6);
var Data_1 = __webpack_require__(81);
var DocumentDataSource = /** @class */ (function (_super) {
__extends(DocumentDataSource, _super);
function DocumentDataSource(changesListener, nodeDataSource, edgeDataSource, nodeDataImporter, edgeDataImporter) {
var _this = _super.call(this, "Document", nodeDataSource, edgeDataSource, nodeDataImporter, edgeDataImporter) || this;
_this.changesListener = changesListener;
_this.updateLockCount = 0;
return _this;
}
DocumentDataSource.prototype.createModelItems = function (history, model, selection, layoutParameters, snapToGrid, gridSize) {
DataSource_1.DataSource.createModelItems(history, model, selection, this, layoutParameters, true, false, snapToGrid, gridSize);
};
DocumentDataSource.prototype.updateItemsByModel = function (model) {
var _this = this;
this.deleteNodes(model);
this.deleteEdges(model);
model.items.forEach(function (item) {
if (item instanceof Shape_1.Shape)
_this.updateNode(model, item);
if (item instanceof Connector_1.Connector)
_this.updateEdge(model, item);
});
};
DocumentDataSource.prototype.isItemObjectModified = function (item, itemObj, importer) {
var modified = (importer.setLocked && itemObj.locked !== item.locked) ||
(importer.setZIndex && itemObj.zIndex !== item.zIndex);
if (!modified && importer.setStyle) {
var defaultStyle_1 = item.style.getDefaultInstance();
item.style.forEach(function (key) {
if (item.style[key] !== defaultStyle_1[key] && item.style[key] !== itemObj.style[key])
modified = true;
});
}
if (!modified && importer.setStyleText) {
var defaultTextStyle_1 = item.styleText.getDefaultInstance();
item.styleText.forEach(function (key) {
if (item.styleText[key] !== defaultTextStyle_1[key] && item.styleText[key] !== itemObj.styleText[key])
modified = true;
});
}
return modified;
};
DocumentDataSource.prototype.updateItemObjectProperties = function (itemObj, item, importer) {
if (importer.setLocked) {
itemObj.locked = item.locked;
if (itemObj.dataObj && itemObj.locked !== undefined)
importer.setLocked(itemObj.dataObj, item.locked);
}
if (importer.setStyle) {
var styleObj = item.style.toObject();
itemObj.style = styleObj;
if (itemObj.dataObj && itemObj.style !== undefined)
importer.setStyle(itemObj.dataObj, styleObj);
}
if (importer.setStyleText) {
var styleTextObj = item.styleText.toObject();
itemObj.styleText = styleTextObj;
if (itemObj.dataObj && itemObj.styleText !== undefined)
importer.setStyleText(itemObj.dataObj, styleTextObj);
}
if (importer.setZIndex) {
itemObj.zIndex = item.zIndex;
if (itemObj.dataObj && itemObj.zIndex !== undefined)
importer.setZIndex(itemObj.dataObj, item.zIndex);
}
};
DocumentDataSource.prototype.deleteItems = function (dataSourceItems, findItem, getParentArray, callback) {
var items = dataSourceItems.slice();
items.forEach(function (item) {
if (item.key && !findItem(item.key)) {
var parentArray = getParentArray(item);
var index = parentArray.indexOf(item.dataObj);
parentArray.splice(index, 1);
callback(item, index > -1);
}
});
};
// Nodes
DocumentDataSource.prototype.updateNode = function (model, shape) {
var _this = this;
var nodeObj = this.findNode(shape.dataKey);
if (!nodeObj) {
var dataObj = {};
nodeObj = this.addNodeInternal(dataObj, shape.description.key, shape.text);
this.nodeDataSource.push(nodeObj.dataObj);
this.nodeDataImporter.setKey(dataObj, nodeObj.key);
this.updateNodeObjectProperties(shape, nodeObj, model.units);
this.updateNodeObjectConnectedProperties(shape, nodeObj);
this.updateNodeObjectKey(shape, nodeObj, nodeObj.dataObj);
this.beginChangesNotification();
this.changesListener.notifyNodeInserted.call(this.changesListener, nodeObj.dataObj, function (data) {
_this.updateNodeObjectKey(shape, nodeObj, data);
_this.endChangesNotification();
}, function (error) {
_this.endChangesNotification();
});
}
else {
if (this.isNodeObjectModified(shape, nodeObj, model.units)) {
this.updateNodeObjectProperties(shape, nodeObj, model.units);
this.updateNodeObjectConnectedProperties(shape, nodeObj);
this.beginChangesNotification();
this.changesListener.notifyNodeUpdated.call(this.changesListener, this.nodeDataImporter.getKey(nodeObj.dataObj || nodeObj.key), nodeObj.dataObj, function (key, data) {
_this.endChangesNotification();
}, function (error) {
_this.endChangesNotification();
});
}
else
this.updateNodeObjectConnectedProperties(shape, nodeObj, this.changesListener);
}
};
DocumentDataSource.prototype.isNodeObjectModified = function (shape, nodeObj, units) {
return this.isItemObjectModified(shape, nodeObj, this.nodeDataImporter) ||
(nodeObj.type !== shape.description.key && !(nodeObj.type === undefined && shape.description.key === ShapeTypes_1.ShapeTypes.Rectangle)) ||
!this.compareStrings(nodeObj.text, shape.text) ||
(nodeObj.containerKey !== (shape.container && shape.container.dataKey)) ||
(this.nodeDataImporter.setImage && nodeObj.image !== shape.image.url) ||
(this.nodeDataImporter.setLeft && nodeObj.left !== ModelUtils_1.ModelUtils.getlUnitValue(units, shape.position.x)) ||
(this.nodeDataImporter.setTop && nodeObj.top !== ModelUtils_1.ModelUtils.getlUnitValue(units, shape.position.y)) ||
(this.nodeDataImporter.setWidth && nodeObj.width !== ModelUtils_1.ModelUtils.getlUnitValue(units, shape.size.width)) ||
(this.nodeDataImporter.setHeight && nodeObj.height !== ModelUtils_1.ModelUtils.getlUnitValue(units, shape.size.height));
};
DocumentDataSource.prototype.updateNodeObjectProperties = function (shape, nodeObj, units) {
this.updateItemObjectProperties(nodeObj, shape, this.nodeDataImporter);
if (this.nodeDataImporter.setType) {
nodeObj.type = shape.description.key;
this.nodeDataImporter.setType(nodeObj.dataObj, shape.description.key);
}
if (this.nodeDataImporter.setText) {
nodeObj.text = shape.text;
this.nodeDataImporter.setText(nodeObj.dataObj, shape.text);
}
if (this.nodeDataImporter.setImage) {
nodeObj.image = shape.image.url;
this.nodeDataImporter.setImage(nodeObj.dataObj, shape.image.url);
}
if (this.nodeDataImporter.setLeft) {
var left = ModelUtils_1.ModelUtils.getlUnitValue(units, shape.position.x);
nodeObj.left = left;
this.nodeDataImporter.setLeft(nodeObj.dataObj, left);
}
if (this.nodeDataImporter.setTop) {
var top_1 = ModelUtils_1.ModelUtils.getlUnitValue(units, shape.position.y);
nodeObj.top = top_1;
this.nodeDataImporter.setTop(nodeObj.dataObj, top_1);
}
if (this.nodeDataImporter.setWidth) {
var width = ModelUtils_1.ModelUtils.getlUnitValue(units, shape.size.width);
nodeObj.width = width;
this.nodeDataImporter.setWidth(nodeObj.dataObj, width);
}
if (this.nodeDataImporter.setHeight) {
var height = ModelUtils_1.ModelUtils.getlUnitValue(units, shape.size.height);
nodeObj.height = height;
this.nodeDataImporter.setHeight(nodeObj.dataObj, height);
}
};
DocumentDataSource.prototype.updateNodeObjectConnectedProperties = function (shape, nodeObj, changesListener) {
if (this.useNodeParentId && this.nodeDataImporter.setParentKey !== undefined) {
var parentKey = this.getParentShapeKey(shape);
var parentItem = this.findNode(parentKey);
this.updateNodeObjectParentKey(nodeObj, parentItem, changesListener);
}
if (this.useNodeContainerId && this.nodeDataImporter.setContainerKey !== undefined) {
var containerKey = this.getContainerShapeKey(shape);
var containerItem = this.findNode(containerKey);
this.updateNodeObjectContainerKey(nodeObj, containerItem, changesListener);
}
if (this.useNodeItems && this.nodeDataImporter.setItems !== undefined) {
var parentKey = this.getParentShapeKey(shape);
var parentItem = this.findNode(parentKey);
this.updateNodeObjectItems(nodeObj, parentItem, changesListener);
}
if (this.useNodeChildren && this.nodeDataImporter.setChildren !== undefined) {
var containerKey = this.getContainerShapeKey(shape);
var containerItem = this.findNode(containerKey);
this.updateNodeObjectChildren(nodeObj, containerItem, changesListener);
}
};
DocumentDataSource.prototype.updateNodeObjectParentKey = function (nodeObj, parentNodeObj, changesListener) {
var _this = this;
var parentKey = this.nodeDataImporter.getParentKey(nodeObj.dataObj);
var newParentKey = parentNodeObj ? this.nodeDataImporter.getKey(parentNodeObj.dataObj) : undefined;
if (parentKey !== newParentKey && !(this.isRootParentKey(parentKey) && this.isRootParentKey(newParentKey))) {
this.nodeDataImporter.setParentKey(nodeObj.dataObj, newParentKey);
if (changesListener) {
this.beginChangesNotification();
changesListener.notifyNodeUpdated.call(changesListener, this.nodeDataImporter.getKey(nodeObj.dataObj) || nodeObj.key, nodeObj.dataObj, function (key, data) {
_this.endChangesNotification();
}, function (error) {
_this.endChangesNotification();
});
}
}
};
DocumentDataSource.prototype.updateNodeObjectContainerKey = function (nodeObj, containerNodeObj, changesListener) {
var _this = this;
var containerKey = this.nodeDataImporter.getContainerKey(nodeObj.dataObj);
var newContainerKey = containerNodeObj ? this.nodeDataImporter.getKey(containerNodeObj.dataObj) : undefined;
if (containerKey !== newContainerKey && !(this.isRootParentKey(containerKey) && this.isRootParentKey(newContainerKey))) {
this.nodeDataImporter.setContainerKey(nodeObj.dataObj, newContainerKey);
if (changesListener) {
this.beginChangesNotification();
changesListener.notifyNodeUpdated.call(changesListener, this.nodeDataImporter.getKey(nodeObj.dataObj) || nodeObj.key, nodeObj.dataObj, function (key, data) {
_this.endChangesNotification();
}, function (error) {
_this.endChangesNotification();
});
}
}
};
DocumentDataSource.prototype.isRootParentKey = function (key) {
return key === undefined || key === null || !this.findNode(key);
};
DocumentDataSource.prototype.updateNodeObjectItems = function (nodeObj, parentNodeObj, changesListener) {
var _this = this;
if (parentNodeObj && nodeObj.parentDataObj !== parentNodeObj.dataObj ||
!parentNodeObj && nodeObj.parentDataObj) {
if (!parentNodeObj || !this.checkNodeCyrcleItems(nodeObj.dataObj, parentNodeObj.dataObj)) {
var oldItemsArray = nodeObj.parentDataObj ? this.nodeDataImporter.getItems(nodeObj.parentDataObj) : this.nodeDataSource;
var index = oldItemsArray.indexOf(nodeObj.dataObj);
oldItemsArray.splice(index, 1);
var itemsArray = parentNodeObj ? this.nodeDataImporter.getItems(parentNodeObj.dataObj) : this.nodeDataSource;
if (!itemsArray)
this.nodeDataImporter.setItems(parentNodeObj.dataObj, [nodeObj.dataObj]);
else
itemsArray.push(nodeObj.dataObj);
nodeObj.parentDataObj = parentNodeObj && parentNodeObj.dataObj;
if (changesListener) {
this.beginChangesNotification();
changesListener.notifyNodeUpdated.call(changesListener, this.nodeDataImporter.getKey(nodeObj.dataObj) || nodeObj.key, nodeObj.dataObj, function (key, data) {
_this.endChangesNotification();
}, function (error) {
_this.endChangesNotification();
});
}
}
}
};
DocumentDataSource.prototype.updateNodeObjectChildren = function (nodeObj, containerNodeObj, changesListener) {
var _this = this;
if (containerNodeObj && nodeObj.containerDataObj !== containerNodeObj.dataObj ||
!containerNodeObj && nodeObj.containerDataObj) {
var oldChildrenArray = nodeObj.containerDataObj ? this.nodeDataImporter.getChildren(nodeObj.containerDataObj) : this.nodeDataSource;
var index = oldChildrenArray.indexOf(nodeObj.dataObj);
oldChildrenArray.splice(index, 1);
var childrenArray = containerNodeObj ? this.nodeDataImporter.getChildren(containerNodeObj.dataObj) : this.nodeDataSource;
if (!childrenArray)
this.nodeDataImporter.setChildren(containerNodeObj.dataObj, [nodeObj.dataObj]);
else
childrenArray.push(nodeObj.dataObj);
nodeObj.containerDataObj = containerNodeObj && containerNodeObj.dataObj;
if (changesListener) {
this.beginChangesNotification();
changesListener.notifyNodeUpdated.call(changesListener, this.nodeDataImporter.getKey(nodeObj.dataObj) || nodeObj.key, nodeObj.dataObj, function (key, data) {
_this.endChangesNotification();
}, function (error) {
_this.endChangesNotification();
});
}
}
};
DocumentDataSource.prototype.checkNodeCyrcleItems = function (nodeDataObj, parentDataObjCandidate) {
var _this = this;
var result = false;
var items = this.nodeDataImporter.getItems(nodeDataObj);
if (items) {
items.forEach(function (childDataObj) {
result = result || childDataObj === parentDataObjCandidate ||
_this.checkNodeCyrcleItems(childDataObj, parentDataObjCandidate);
});
}
return result;
};
DocumentDataSource.prototype.updateNodeObjectKey = function (shape, nodeObj, dataObj) {
var key = this.nodeDataImporter.getKey(dataObj);
if (key !== undefined && key !== null && key !== nodeObj.key) {
nodeObj.key = key;
delete this.nodeKeyMap[nodeObj.key];
this.nodeKeyMap[key] = nodeObj.key;
}
shape.dataKey = nodeObj.key;
if (nodeObj.dataObj !== dataObj) {
var parentArray = this.getNodeArray(nodeObj);
var index = parentArray.indexOf(nodeObj.dataObj);
parentArray.splice(index, 1, dataObj);
nodeObj.dataObj = dataObj;
}
};
DocumentDataSource.prototype.deleteNodes = function (model) {
var _this = this;
this.deleteItems(this.nodes, function (key) { return model.findShapeByDataKey(key); }, function (item) { return _this.getNodeArray(item); }, function (item, dataModified) {
var key = (item.dataObj && _this.nodeDataImporter.getKey(item.dataObj)) || item.key;
var dataKey = _this.nodeKeyMap[key];
if (dataKey)
delete _this.nodeKeyMap[key];
var nodeObj = _this.findNode(dataKey);
if (nodeObj)
_this.nodes.splice(_this.nodes.indexOf(nodeObj), 1);
if (dataModified) {
_this.beginChangesNotification();
_this.changesListener.notifyNodeRemoved.call(_this.changesListener, key, item.dataObj, function (key, data) {
_this.endChangesNotification();
}, function (error) {
_this.endChangesNotification();
});
}
});
};
DocumentDataSource.prototype.getParentShapeKey = function (shape) {
var parentKey;
for (var i = 0; i < shape.attachedConnectors.length; i++) {
if (shape.attachedConnectors[i].endItem === shape) {
var parentShape = shape.attachedConnectors[i].beginItem;
parentKey = parentShape && parentShape.dataKey;
break;
}
}
return parentKey;
};
DocumentDataSource.prototype.getNodeArray = function (item) {
var items;
if (this.useNodeItems && item.parentDataObj)
items = this.nodeDataImporter.getItems(item.parentDataObj);
else if (item.containerDataObj)
items = this.nodeDataImporter.getChildren(item.containerDataObj);
return items || this.nodeDataSource;
};
DocumentDataSource.prototype.getContainerShapeKey = function (shape) {
return shape.container && shape.container.dataKey;
};
// Edges
DocumentDataSource.prototype.updateEdge = function (model, connector) {
var _this = this;
var beginDataKey = connector.beginItem ? connector.beginItem.dataKey : undefined;
var endDataKey = connector.endItem ? connector.endItem.dataKey : undefined;
var edgeObj = this.findEdge(connector.dataKey);
if (!edgeObj) {
var dataObj = this.useEdgesArray() ? {} : undefined;
edgeObj = this.addEdgeInternal(dataObj, beginDataKey, endDataKey);
if (dataObj) {
this.edgeDataImporter.setKey(dataObj, edgeObj.key);
this.edgeDataSource.push(edgeObj.dataObj);
}
this.updateEdgeObjectProperties(connector, edgeObj, model.units);
this.updateEdgeObjectKey(connector, edgeObj, edgeObj.dataObj);
if (dataObj) {
this.beginChangesNotification();
this.changesListener.notifyEdgeInserted.call(this.changesListener, edgeObj.dataObj, function (data) {
_this.updateEdgeObjectKey(connector, edgeObj, data);
_this.endChangesNotification();
}, function (error) {
_this.endChangesNotification();
});
}
}
else {
if (this.isEdgeObjectModified(connector, edgeObj, model.units)) {
this.updateEdgeObjectProperties(connector, edgeObj, model.units);
if (edgeObj.dataObj) {
this.beginChangesNotification();
this.changesListener.notifyEdgeUpdated.call(this.changesListener, this.edgeDataImporter.getKey(edgeObj.dataObj) || edgeObj.key, edgeObj.dataObj, function (key, data) {
_this.endChangesNotification();
}, function (error) {
_this.endChangesNotification();
});
}
}
}
};
DocumentDataSource.prototype.isEdgeObjectModified = function (connector, edgeObj, units) {
return this.isItemObjectModified(connector, edgeObj, this.edgeDataImporter) ||
edgeObj.from !== (connector.beginItem ? connector.beginItem.dataKey : undefined) ||
edgeObj.to !== (connector.endItem ? connector.endItem.dataKey : undefined) ||
(this.edgeDataImporter.setFromPointIndex && edgeObj.fromPointIndex !== connector.beginConnectionPointIndex) ||
(this.edgeDataImporter.setToPointIndex && edgeObj.toPointIndex !== connector.endConnectionPointIndex) ||
(this.edgeDataImporter.setPoints && (!edgeObj.points ||
!Data_1.Data.ArrayEqual(edgeObj.points.map(function (ptObj) { return ptObj.x; }), connector.points.map(function (pt) { return ModelUtils_1.ModelUtils.getlUnitValue(units, pt.x); })) ||
!Data_1.Data.ArrayEqual(edgeObj.points.map(function (ptObj) { return ptObj.y; }), connector.points.map(function (pt) { return ModelUtils_1.ModelUtils.getlUnitValue(units, pt.y); })))) ||
(this.edgeDataImporter.setText && !this.compareStrings(edgeObj.text, connector.getText())) ||
(this.edgeDataImporter.setLineOption && edgeObj.lineOption !== connector.properties.lineOption) ||
(this.edgeDataImporter.setStartLineEnding && edgeObj.startLineEnding !== connector.properties.startLineEnding) ||
(this.edgeDataImporter.setEndLineEnding && edgeObj.endLineEnding !== connector.properties.endLineEnding);
};
DocumentDataSource.prototype.updateEdgeObjectProperties = function (connector, edgeObj, units) {
this.updateItemObjectProperties(edgeObj, connector, this.edgeDataImporter);
if (this.edgeDataImporter.setFrom) {
var fromObj = this.findNode(connector.beginItem && connector.beginItem.dataKey);
edgeObj.from = fromObj && fromObj.key;
if (edgeObj.dataObj)
this.edgeDataImporter.setFrom(edgeObj.dataObj, fromObj && fromObj.dataObj && this.nodeDataImporter.getKey(fromObj.dataObj));
}
if (this.edgeDataImporter.setTo) {
var toObj = this.findNode(connector.endItem && connector.endItem.dataKey);
edgeObj.to = toObj && toObj.key;
if (edgeObj.dataObj)
this.edgeDataImporter.setTo(edgeObj.dataObj, toObj && toObj.dataObj && this.nodeDataImporter.getKey(toObj.dataObj));
}
if (this.edgeDataImporter.setFromPointIndex) {
edgeObj.fromPointIndex = connector.beginConnectionPointIndex;
if (edgeObj.dataObj)
this.edgeDataImporter.setFromPointIndex(edgeObj.dataObj, connector.beginConnectionPointIndex);
}
if (this.edgeDataImporter.setToPointIndex) {
edgeObj.toPointIndex = connector.endConnectionPointIndex;
if (edgeObj.dataObj)
this.edgeDataImporter.setToPointIndex(edgeObj.dataObj, connector.endConnectionPointIndex);
}
if (this.edgeDataImporter.setPoints) {
var points = connector.points.map(function (pt) {
return {
x: ModelUtils_1.ModelUtils.getlUnitValue(units, pt.x),
y: ModelUtils_1.ModelUtils.getlUnitValue(units, pt.y)
};
});
edgeObj.points = points;
if (edgeObj.dataObj)
this.edgeDataImporter.setPoints(edgeObj.dataObj, points);
}
if (this.edgeDataImporter.setText) {
var text = connector.getText();
edgeObj.text = text;
if (edgeObj.dataObj)
this.edgeDataImporter.setText(edgeObj.dataObj, text);
}
if (this.edgeDataImporter.setLineOption) {
edgeObj.lineOption = connector.properties.lineOption;
if (edgeObj.dataObj)
this.edgeDataImporter.setLineOption(edgeObj.dataObj, connector.properties.lineOption);
}
if (this.edgeDataImporter.setStartLineEnding) {
edgeObj.startLineEnding = connector.properties.startLineEnding;
if (edgeObj.dataObj)
this.edgeDataImporter.setStartLineEnding(edgeObj.dataObj, connector.properties.startLineEnding);
}
if (this.edgeDataImporter.setEndLineEnding) {
edgeObj.endLineEnding = connector.properties.endLineEnding;
if (edgeObj.dataObj)
this.edgeDataImporter.setEndLineEnding(edgeObj.dataObj, connector.properties.endLineEnding);
}
};
DocumentDataSource.prototype.updateEdgeObjectKey = function (connector, edgeObj, dataObj) {
var key = dataObj && this.edgeDataImporter.getKey(dataObj);
if (key !== undefined && key !== null && key !== edgeObj.key) {
edgeObj.key = key;
delete this.edgeKeyMap[edgeObj.key];
this.edgeKeyMap[key] = edgeObj.key;
}
connector.dataKey = edgeObj.key;
if (edgeObj.dataObj !== dataObj) {
var parentArray = this.edgeDataSource;
var index = parentArray.indexOf(edgeObj.dataObj);
parentArray.splice(index, 1, dataObj);
edgeObj.dataObj = dataObj;
}
};
DocumentDataSource.prototype.deleteEdges = function (model) {
var _this = this;
this.deleteItems(this.edges, function (key) { return model.findConnectorByDataKey(key); }, function (item) { return _this.edgeDataSource; }, function (item, dataModified) {
var key = (item.dataObj && _this.edgeDataImporter.getKey(item.dataObj)) || item.key;
var dataKey = _this.edgeKeyMap[key];
if (dataKey)
delete _this.edgeKeyMap[key];
var edgeObj = _this.findEdge(dataKey);
if (edgeObj)
_this.edges.splice(_this.edges.indexOf(edgeObj), 1);
if (dataModified) {
_this.beginChangesNotification();
_this.changesListener.notifyEdgeRemoved.call(_this.changesListener, key, item.dataObj, function (key, data) {
_this.endChangesNotification();
}, function (error) {
_this.endChangesNotification();
});
}
});
};
DocumentDataSource.prototype.compareStrings = function (str1, str2) {
if (typeof str1 === "string" && typeof str2 === "string")
return str1 === str2;
return this.isEmptyString(str1) && this.isEmptyString(str2);
};
DocumentDataSource.prototype.isEmptyString = function (str) {
return str === "" || str === null || str === undefined;
};
DocumentDataSource.prototype.beginChangesNotification = function () {
this.updateLockCount++;
};
DocumentDataSource.prototype.endChangesNotification = function () {
this.updateLockCount--;
if (!this.isUpdateLocked()) {
setTimeout(function () {
this.changesListener.processDataChanges.call(this.changesListener, false);
}.bind(this), 0);
}
};
DocumentDataSource.prototype.isUpdateLocked = function () {
return this.updateLockCount > 0;
};
return DocumentDataSource;
}(DataSource_1.DataSource));
exports.DocumentDataSource = DocumentDataSource;
/***/ }),
/* 298 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ShapeTypes_1 = __webpack_require__(1);
var ModelUtils_1 = __webpack_require__(6);
var DataImporter_1 = __webpack_require__(299);
var DataSourceItems_1 = __webpack_require__(300);
var Connector_1 = __webpack_require__(5);
var Utils_1 = __webpack_require__(0);
var AddShapeHistoryItem_1 = __webpack_require__(51);
var AddConnectorHistoryItem_1 = __webpack_require__(52);
var AddConnectionHistoryItem_1 = __webpack_require__(37);
var SetSelectionHistoryItem_1 = __webpack_require__(44);
var ChangeShapeImageHistoryItem_1 = __webpack_require__(116);
var ChangeZindexHistoryItem_1 = __webpack_require__(76);
var ChangeStyleHistoryItem_1 = __webpack_require__(46);
var ChangeStyleTextHistoryItem_1 = __webpack_require__(36);
var ChangeConnectorPropertyHistoryItem_1 = __webpack_require__(55);
var ChangeConnectorTextHistoryItem_1 = __webpack_require__(54);
var ChangeLockedHistoryItem_1 = __webpack_require__(104);
var Color_1 = __webpack_require__(38);
var Svg_1 = __webpack_require__(79);
var DataSource = /** @class */ (function () {
function DataSource(key, nodeDataSource, edgeDataSource, nodeDataImporter, edgeDataImporter) {
this.key = key;
this.nodes = [];
this.edges = [];
this.nodeKeyMap = {};
this.edgeKeyMap = {};
this.useNodeParentId = false;
this.useNodeContainerId = false;
this.useNodeChildren = false;
this.useNodeItems = false;
this.containers = null;
if (key === undefined || key === null)
throw new Error("DataSource key must be specified");
this.key = key.toString();
this.nodeDataImporter = this.createNodeDataImporter(nodeDataImporter);
this.edgeDataImporter = this.createEdgeDataImporter(edgeDataImporter);
this.nodeDataSource = nodeDataSource || [];
this.edgeDataSource = edgeDataSource || [];
this.fetchData();
}
DataSource.prototype.createNodeDataImporter = function (source) {
var result = new DataImporter_1.DataSourceNodeDataImporter();
if (source)
this.assignNodeDataImporterProperties(source, result);
return result;
};
DataSource.prototype.createEdgeDataImporter = function (source) {
var result = new DataImporter_1.DataSourceEdgeDataImporter();
if (source)
this.assignEdgeDataImporterProperties(source, result);
return result;
};
DataSource.prototype.assignItemDataImporterProperties = function (source, importer) {
if (source.getKey)
importer.getKey = source.getKey;
if (source.setKey)
importer.setKey = source.setKey;
if (source.getLocked)
importer.getLocked = source.getLocked;
if (source.setLocked)
importer.setLocked = source.setLocked;
if (source.getStyle)
importer.getStyle = source.getStyle;
if (source.setStyle)
importer.setStyle = source.setStyle;
if (source.getStyleText)
importer.getStyleText = source.getStyleText;
if (source.setStyleText)
importer.setStyleText = source.setStyleText;
if (source.getZIndex)
importer.getZIndex = source.getZIndex;
if (source.setZIndex)
importer.setZIndex = source.setZIndex;
};
DataSource.prototype.assignNodeDataImporterProperties = function (source, importer) {
this.assignItemDataImporterProperties(source, importer);
if (source.getType)
importer.getType = source.getType;
if (source.setType)
importer.setType = source.setType;
if (source.getImage)
importer.getImage = source.getImage;
if (source.setImage)
importer.setImage = source.setImage;
if (source.getText)
importer.getText = source.getText;
if (source.setText)
importer.setText = source.setText;
if (source.getLeft)
importer.getLeft = source.getLeft;
if (source.setLeft)
importer.setLeft = source.setLeft;
if (source.getTop)
importer.getTop = source.getTop;
if (source.setTop)
importer.setTop = source.setTop;
if (source.getWidth)
importer.getWidth = source.getWidth;
if (source.setWidth)
importer.setWidth = source.setWidth;
if (source.getHeight)
importer.getHeight = source.getHeight;
if (source.setHeight)
importer.setHeight = source.setHeight;
if (source.getChildren)
importer.getChildren = source.getChildren;
if (source.setChildren)
importer.setChildren = source.setChildren;
if (source.getParentKey)
importer.getParentKey = source.getParentKey;
if (source.setParentKey)
importer.setParentKey = source.setParentKey;
if (source.getItems)
importer.getItems = source.getItems;
if (source.setItems)
importer.setItems = source.setItems;
if (source.getContainerKey)
importer.getContainerKey = source.getContainerKey;
if (source.setContainerKey)
importer.setContainerKey = source.setContainerKey;
};
DataSource.prototype.assignEdgeDataImporterProperties = function (source, importer) {
this.assignItemDataImporterProperties(source, importer);
if (source.getFrom)
importer.getFrom = source.getFrom;
if (source.setFrom)
importer.setFrom = source.setFrom;
if (source.getFromPointIndex)
importer.getFromPointIndex = source.getFromPointIndex;
if (source.setFromPointIndex)
importer.setFromPointIndex = source.setFromPointIndex;
if (source.getTo)
importer.getTo = source.getTo;
if (source.setTo)
importer.setTo = source.setTo;
if (source.getToPointIndex)
importer.getToPointIndex = source.getToPointIndex;
if (source.setToPointIndex)
importer.setToPointIndex = source.setToPointIndex;
if (source.getPoints)
importer.getPoints = source.getPoints;
if (source.setPoints)
importer.setPoints = source.setPoints;
if (source.getText)
importer.getText = source.getText;
if (source.setText)
importer.setText = source.setText;
if (source.getLineOption)
importer.getLineOption = source.getLineOption;
if (source.setLineOption)
importer.setLineOption = source.setLineOption;
if (source.getStartLineEnding)
importer.getStartLineEnding = source.getStartLineEnding;
if (source.setStartLineEnding)
importer.setStartLineEnding = source.setStartLineEnding;
if (source.getEndLineEnding)
importer.getEndLineEnding = source.getEndLineEnding;
if (source.setEndLineEnding)
importer.setEndLineEnding = source.setEndLineEnding;
};
DataSource.prototype.fetchData = function () {
var _this = this;
this.useNodeParentId = this.nodeDataImporter.getParentKey !== undefined;
this.useNodeContainerId = this.nodeDataImporter.getContainerKey !== undefined;
this.useNodeItems = this.nodeDataImporter.getItems !== undefined;
this.useNodeChildren = this.nodeDataImporter.getChildren !== undefined;
if (this.useEdgesArray() && this.useNodeParentId)
throw new Error("You cannot use edges array and parentKey simultaneously.");
if (this.useEdgesArray() && this.useNodeItems)
throw new Error("You cannot use edges array and items array simultaneously.");
if (this.useNodeParentId && this.useNodeItems)
throw new Error("You cannot use parentKey and items array simultaneously.");
if (this.useNodeContainerId && this.useNodeChildren)
throw new Error("You cannot use containerKey and children array simultaneously.");
this.nodeDataSource.forEach(function (nodeDataObj) {
_this.addNode(nodeDataObj);
});
if (this.useEdgesArray()) {
this.edgeDataSource.forEach(function (edgeDataObj) {
_this.addEdge(edgeDataObj);
});
}
else {
this.nodes.forEach(function (node) {
_this.addNodeEdgesByParentId(node);
});
}
};
DataSource.prototype.isContainer = function (itemKey) {
var _this = this;
if (!this.containers && this.useNodeContainerId) {
this.containers = this.nodeDataSource
.map(function (i) { return _this.nodeDataImporter.getContainerKey(i); })
.filter(function (i) { return i !== undefined && i !== null; })
.reduce(function (map, i) {
map[i] = true;
return map;
}, {});
}
return this.containers && this.containers[itemKey];
};
DataSource.prototype.useEdgesArray = function () {
return Array.isArray(this.edgeDataSource) && (this.edgeDataSource.length || !(this.useNodeParentId || this.useNodeItems));
};
DataSource.prototype.addNode = function (nodeDataObj, parentNodeDataObj, containerKey, containerNodeDataObj) {
var _this = this;
var childNodeDataObjs = this.nodeDataImporter.getChildren && this.nodeDataImporter.getChildren(nodeDataObj);
var hasChildren = childNodeDataObjs && Array.isArray(childNodeDataObjs) && childNodeDataObjs.length;
var isContainer = hasChildren || this.isContainer(this.nodeDataImporter.getKey(nodeDataObj));
var type = this.nodeDataImporter.getType && this.nodeDataImporter.getType(nodeDataObj) || (isContainer && ShapeTypes_1.ShapeTypes.VerticalContainer) || ShapeTypes_1.ShapeTypes.Rectangle;
var text = this.nodeDataImporter.getText && (this.nodeDataImporter.getText(nodeDataObj) || "");
var node = this.addNodeInternal(nodeDataObj, type, text, parentNodeDataObj, containerKey, containerNodeDataObj);
this.assignNodeProperties(node, nodeDataObj);
if (hasChildren) {
childNodeDataObjs.forEach(function (childNodeDataObj) {
_this.addNode(childNodeDataObj, undefined, node.key, nodeDataObj);
});
}
if (this.useNodeItems) {
var itemDataObjs = this.nodeDataImporter.getItems(nodeDataObj);
if (Array.isArray(itemDataObjs) && itemDataObjs.length) {
itemDataObjs.forEach(function (itemDataObj) {
var itemNode = _this.addNode(itemDataObj, nodeDataObj, containerKey, containerNodeDataObj);
_this.addEdgeInternal(undefined, node.key, itemNode.key);
});
}
}
return node;
};
DataSource.prototype.addNodeEdgesByParentId = function (node) {
if (this.useNodeParentId) {
var parentKey = this.nodeDataImporter.getParentKey(node.dataObj);
if (parentKey !== undefined && parentKey !== null) {
this.addEdgeInternal(undefined, this.getNodeKey(node.dataObj, this.nodeDataImporter.getParentKey), this.getNodeKey(node.dataObj, this.nodeDataImporter.getKey));
}
}
};
DataSource.prototype.addNodeInternal = function (nodeDataObj, type, text, parentNodeDataObj, containerKey, containerNodeDataObj) {
var externalKey = this.nodeDataImporter.getKey(nodeDataObj);
var key = (externalKey !== undefined && externalKey !== null) ? externalKey : ModelUtils_1.ModelUtils.getGuidItemKey();
var node = new DataSourceItems_1.DataSourceNodeItem(this.key, key, nodeDataObj, type, text, parentNodeDataObj, containerKey, containerNodeDataObj);
this.nodes.push(node);
if (externalKey === undefined || externalKey === null) {
externalKey = key;
this.nodeDataImporter.setKey(nodeDataObj, key);
}
if (externalKey !== undefined && externalKey !== null)
this.nodeKeyMap[externalKey] = key;
return node;
};
DataSource.prototype.addEdge = function (edgeDataObj) {
var edge = this.addEdgeInternal(edgeDataObj, this.getNodeKey(edgeDataObj, this.edgeDataImporter.getFrom), this.getNodeKey(edgeDataObj, this.edgeDataImporter.getTo));
this.assignEdgeProperties(edge, edgeDataObj);
return edge;
};
DataSource.prototype.addEdgeInternal = function (edgeDataObj, from, to) {
var externalKey = edgeDataObj && this.edgeDataImporter.getKey(edgeDataObj);
var key = (externalKey !== undefined && externalKey !== null) ? externalKey : ModelUtils_1.ModelUtils.getGuidItemKey();
var edge = new DataSourceItems_1.DataSourceEdgeItem(this.key, key, edgeDataObj, from, to);
this.edges.push(edge);
if (externalKey === undefined || externalKey === null) {
externalKey = key;
if (edgeDataObj)
this.edgeDataImporter.setKey(edgeDataObj, key);
}
if (externalKey !== undefined && externalKey !== null)
this.edgeKeyMap[externalKey] = key;
return edge;
};
DataSource.prototype.assignItemProperties = function (item, dataObj, importer) {
if (importer.getLocked)
item.locked = importer.getLocked(dataObj);
if (importer.getStyle)
item.style = importer.getStyle(dataObj);
if (importer.getStyleText)
item.styleText = importer.getStyleText(dataObj);
if (importer.getZIndex)
item.zIndex = importer.getZIndex(dataObj);
};
DataSource.prototype.assignNodeProperties = function (item, dataObj) {
this.assignItemProperties(item, dataObj, this.nodeDataImporter);
if (this.nodeDataImporter.getImage)
item.image = this.nodeDataImporter.getImage(dataObj);
if (this.nodeDataImporter.getLeft)
item.left = this.nodeDataImporter.getLeft(dataObj);
if (this.nodeDataImporter.getTop)
item.top = this.nodeDataImporter.getTop(dataObj);
if (this.nodeDataImporter.getWidth)
item.width = this.nodeDataImporter.getWidth(dataObj);
if (this.nodeDataImporter.getHeight)
item.height = this.nodeDataImporter.getHeight(dataObj);
if (this.nodeDataImporter.getContainerKey)
item.containerKey = this.nodeDataImporter.getContainerKey(dataObj);
};
DataSource.prototype.assignEdgeProperties = function (item, dataObj) {
this.assignItemProperties(item, dataObj, this.edgeDataImporter);
if (this.edgeDataImporter.getFromPointIndex)
item.fromPointIndex = this.edgeDataImporter.getFromPointIndex(dataObj);
if (this.edgeDataImporter.getToPointIndex)
item.toPointIndex = this.edgeDataImporter.getToPointIndex(dataObj);
if (this.edgeDataImporter.getPoints)
item.points = this.edgeDataImporter.getPoints(dataObj);
if (this.edgeDataImporter.getText)
item.text = this.edgeDataImporter.getText(dataObj);
if (this.edgeDataImporter.getLineOption)
item.lineOption = this.edgeDataImporter.getLineOption(dataObj);
if (this.edgeDataImporter.getStartLineEnding)
item.startLineEnding = this.edgeDataImporter.getStartLineEnding(dataObj);
if (this.edgeDataImporter.getEndLineEnding)
item.endLineEnding = this.edgeDataImporter.getEndLineEnding(dataObj);
};
DataSource.prototype.findNode = function (key) {
return this.nodes.filter(function (i) { return key !== undefined && i.key === key; })[0];
};
DataSource.prototype.findEdge = function (key) {
return this.edges.filter(function (i) { return key !== undefined && i.key === key; })[0];
};
DataSource.prototype.getNodeKey = function (nodeDataObj, getKey) {
return this.nodeKeyMap[getKey(nodeDataObj)];
};
DataSource.prototype.createModelItems = function (history, model, selection, layoutParameters, snapToGrid, gridSize) {
DataSource.createModelItems(history, model, selection, this, layoutParameters, false, true, snapToGrid, gridSize);
};
DataSource.createModelItems = function (history, model, selection, dataSource, layoutParameters, setDataKeys, selectItems, snapToGrid, gridSize) {
var DEFAULT_STEP = 2000;
var rowIndex = 0;
var colIndex = 0;
var externalToInnerMap = {};
var shapes = [];
var connectors = [];
history.beginTransaction();
dataSource.nodes.forEach(function (node) {
var point = new Utils_1.Point(colIndex++ * DEFAULT_STEP, rowIndex * DEFAULT_STEP);
var shape = DataSource.createShapeByNode(history, model, node, point, setDataKeys);
if (node.key !== undefined)
externalToInnerMap[node.key] = shape.key;
if (colIndex > 4) {
colIndex = 0;
rowIndex++;
}
shapes.push(shape);
if (node.containerKey !== undefined && node.containerKey !== null) {
var containerShape = model.findShape(externalToInnerMap[node.containerKey]);
if (containerShape)
ModelUtils_1.ModelUtils.insertToContainer(history, model, shape, containerShape);
}
});
dataSource.edges.forEach(function (edge) {
var toShape = model.findShape(externalToInnerMap[edge.to]);
var fromShape = model.findShape(externalToInnerMap[edge.from]);
if (toShape && fromShape !== undefined) {
var connector = DataSource.createConnectorByEdge(history, model, edge, toShape, fromShape, setDataKeys);
connectors.push(connector);
ModelUtils_1.ModelUtils.updateConnectorContainer(history, model, connector);
}
});
if (layoutParameters !== undefined) {
var graphInfo = ModelUtils_1.ModelUtils.getGraphInfoByItems(model, shapes, connectors);
graphInfo.forEach(function (info) {
var layout = layoutParameters.getLayoutBuilder(info.graph).build();
var nonGraphItems = ModelUtils_1.ModelUtils.getNonGraphItems(model, info.container, layout.nodeToLayout, shapes, connectors);
ModelUtils_1.ModelUtils.applyLayout(history, model, info.container, info.graph, layout, nonGraphItems, layoutParameters.layoutSettings, snapToGrid, gridSize);
});
}
if (selectItems) {
var items = connectors.map(function (c) { return c.key; }).concat(shapes.map(function (s) { return s.key; }));
history.addAndRedo(new SetSelectionHistoryItem_1.SetSelectionHistoryItem(selection, items));
}
ModelUtils_1.ModelUtils.tryUpdateModelSize(history, model);
history.endTransaction();
};
DataSource.createShapeByNode = function (history, model, node, point, setDataKeys) {
var dataKey = setDataKeys ? node.key : undefined;
if (node.left !== undefined)
point.x = ModelUtils_1.ModelUtils.getTwipsValue(model.units, node.left);
if (node.top !== undefined)
point.y = ModelUtils_1.ModelUtils.getTwipsValue(model.units, node.top);
var insert = new AddShapeHistoryItem_1.AddShapeHistoryItem(node.type, point, node.text, dataKey);
history.addAndRedo(insert);
var shape = model.findShape(insert.shapeKey);
var size = shape.size.clone();
if (node.width !== undefined)
size.width = ModelUtils_1.ModelUtils.getTwipsValue(model.units, node.width);
if (node.height !== undefined)
size.height = ModelUtils_1.ModelUtils.getTwipsValue(model.units, node.height);
ModelUtils_1.ModelUtils.setShapeSize(history, model, shape, point, size);
if (node.image !== undefined)
history.addAndRedo(new ChangeShapeImageHistoryItem_1.ChangeShapeImageHistoryItem(shape, node.image));
this.changeItemByDataItem(history, shape, node);
return shape;
};
DataSource.createConnectorByEdge = function (history, model, edge, toShape, fromShape, setDataKeys) {
var dataKey = setDataKeys ? edge.key : undefined;
var points = Array.isArray(edge.points) && edge.points.length > 1 ?
edge.points.map(function (ptObj) {
if (ptObj.x !== undefined && ptObj.y !== undefined)
return new Utils_1.Point(ModelUtils_1.ModelUtils.getTwipsValue(model.units, ptObj.x), ModelUtils_1.ModelUtils.getTwipsValue(model.units, ptObj.y));
}).filter(function (pt) { return pt; }) :
[fromShape.position.clone(), toShape.position.clone()];
var insert = new AddConnectorHistoryItem_1.AddConnectorHistoryItem(points, dataKey);
history.addAndRedo(insert);
var connector = model.findConnector(insert.connectorKey);
var fromPointIndex = edge.fromPointIndex !== undefined ? edge.fromPointIndex : -1;
history.addAndRedo(new AddConnectionHistoryItem_1.AddConnectionHistoryItem(connector, fromShape, fromPointIndex, Connector_1.ConnectorPosition.Begin));
var toPointIndex = edge.toPointIndex !== undefined ? edge.toPointIndex : -1;
history.addAndRedo(new AddConnectionHistoryItem_1.AddConnectionHistoryItem(connector, toShape, toPointIndex, Connector_1.ConnectorPosition.End));
ModelUtils_1.ModelUtils.updateConnectorAttachedPoints(history, model, connector);
if (edge.text !== undefined)
history.addAndRedo(new ChangeConnectorTextHistoryItem_1.ChangeConnectorTextHistoryItem(connector, Connector_1.CONNECTOR_DEFAULT_TEXT_POSITION, edge.text));
if (edge.lineOption !== undefined)
history.addAndRedo(new ChangeConnectorPropertyHistoryItem_1.ChangeConnectorPropertyHistoryItem(connector.key, "lineOption", edge.lineOption));
if (edge.startLineEnding !== undefined)
history.addAndRedo(new ChangeConnectorPropertyHistoryItem_1.ChangeConnectorPropertyHistoryItem(connector.key, "startLineEnding", edge.startLineEnding));
if (edge.endLineEnding !== undefined)
history.addAndRedo(new ChangeConnectorPropertyHistoryItem_1.ChangeConnectorPropertyHistoryItem(connector.key, "endLineEnding", edge.endLineEnding));
this.changeItemByDataItem(history, connector, edge);
return connector;
};
DataSource.changeItemByDataItem = function (history, item, dataItem) {
if (dataItem.locked !== undefined) {
history.addAndRedo(new ChangeLockedHistoryItem_1.ChangeLockedHistoryItem(item, dataItem.locked));
}
if (dataItem.zIndex !== undefined) {
history.addAndRedo(new ChangeZindexHistoryItem_1.ChangeZindexHistoryItem(item, dataItem.zIndex));
}
if (dataItem.style !== undefined) {
for (var key in dataItem.style) {
if (!dataItem.style.hasOwnProperty(key))
continue;
var value = Svg_1.isColorProperty(key) ? Color_1.ColorHelper.stringToHash(dataItem.style[key]) : dataItem.style[key];
history.addAndRedo(new ChangeStyleHistoryItem_1.ChangeStyleHistoryItem(item.key, key, value));
}
}
if (dataItem.styleText !== undefined) {
for (var key in dataItem.styleText) {
if (!dataItem.styleText.hasOwnProperty(key))
continue;
var value = Svg_1.isColorProperty(key) ? Color_1.ColorHelper.stringToHash(dataItem.styleText[key]) : dataItem.styleText[key];
history.addAndRedo(new ChangeStyleTextHistoryItem_1.ChangeStyleTextHistoryItem(item.key, key, value));
}
}
};
return DataSource;
}());
exports.DataSource = DataSource;
/***/ }),
/* 299 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var DataSourceItemDataImporter = /** @class */ (function () {
function DataSourceItemDataImporter() {
this.getKey = function (obj) { return obj["id"]; };
this.setKey = function (obj, value) { obj["id"] = value; };
this.getLocked = undefined;
this.setLocked = undefined;
this.getStyle = undefined;
this.setStyle = undefined;
this.getStyleText = undefined;
this.setStyleText = undefined;
this.getZIndex = undefined;
this.setZIndex = undefined;
}
return DataSourceItemDataImporter;
}());
exports.DataSourceItemDataImporter = DataSourceItemDataImporter;
var DataSourceNodeDataImporter = /** @class */ (function (_super) {
__extends(DataSourceNodeDataImporter, _super);
function DataSourceNodeDataImporter() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this.getType = undefined;
_this.setType = undefined;
_this.getText = undefined;
_this.setText = undefined;
_this.getImage = undefined;
_this.setImage = undefined;
_this.getLeft = undefined;
_this.setLeft = undefined;
_this.getTop = undefined;
_this.setTop = undefined;
_this.getWidth = undefined;
_this.setWidth = undefined;
_this.getHeight = undefined;
_this.setHeight = undefined;
_this.getChildren = undefined;
_this.setChildren = undefined;
_this.getParentKey = undefined;
_this.setParentKey = undefined;
_this.getItems = undefined;
_this.setItems = undefined;
_this.getContainerKey = undefined;
_this.setContainerKey = undefined;
return _this;
}
return DataSourceNodeDataImporter;
}(DataSourceItemDataImporter));
exports.DataSourceNodeDataImporter = DataSourceNodeDataImporter;
var DataSourceEdgeDataImporter = /** @class */ (function (_super) {
__extends(DataSourceEdgeDataImporter, _super);
function DataSourceEdgeDataImporter() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this.getFrom = function (obj) { return obj["from"]; };
_this.setFrom = function (obj, value) { obj["from"] = value; };
_this.getFromPointIndex = undefined;
_this.setFromPointIndex = undefined;
_this.getTo = function (obj) { return obj["to"]; };
_this.setTo = function (obj, value) { obj["to"] = value; };
_this.getToPointIndex = undefined;
_this.setToPointIndex = undefined;
_this.getPoints = undefined;
_this.setPoints = undefined;
_this.getText = undefined;
_this.setText = undefined;
_this.getLineOption = undefined;
_this.setLineOption = undefined;
_this.getStartLineEnding = undefined;
_this.setStartLineEnding = undefined;
_this.getEndLineEnding = undefined;
_this.setEndLineEnding = undefined;
return _this;
}
return DataSourceEdgeDataImporter;
}(DataSourceItemDataImporter));
exports.DataSourceEdgeDataImporter = DataSourceEdgeDataImporter;
/***/ }),
/* 300 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var DataSourceItem = /** @class */ (function () {
function DataSourceItem(sourceKey, key, dataObj) {
this.sourceKey = sourceKey;
this.key = key;
this.dataObj = dataObj;
}
return DataSourceItem;
}());
exports.DataSourceItem = DataSourceItem;
var DataSourceNodeItem = /** @class */ (function (_super) {
__extends(DataSourceNodeItem, _super);
function DataSourceNodeItem(sourceKey, key, dataObj, type, text, parentDataObj, containerKey, containerDataObj) {
var _this = _super.call(this, sourceKey, key, dataObj) || this;
_this.type = type;
_this.text = text;
_this.parentDataObj = parentDataObj;
_this.containerKey = containerKey;
_this.containerDataObj = containerDataObj;
return _this;
}
return DataSourceNodeItem;
}(DataSourceItem));
exports.DataSourceNodeItem = DataSourceNodeItem;
var DataSourceEdgeItem = /** @class */ (function (_super) {
__extends(DataSourceEdgeItem, _super);
function DataSourceEdgeItem(sourceKey, key, dataObj, from, to) {
var _this = _super.call(this, sourceKey, key, dataObj) || this;
_this.sourceKey = sourceKey;
_this.from = from;
_this.to = to;
return _this;
}
return DataSourceEdgeItem;
}(DataSourceItem));
exports.DataSourceEdgeItem = DataSourceEdgeItem;
/***/ }),
/* 301 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var LOG_MIN_ZOOM = Math.log(0.05);
var LOG_MAX_ZOOM = Math.log(3);
var ZOOM_STEPS = 40;
var ZERO_STEP = getStepByZoom(1);
var ViewController = /** @class */ (function () {
function ViewController(settings) {
this.settings = settings;
}
ViewController.prototype.initialize = function (view) {
this.view = view;
};
ViewController.prototype.scrollTo = function (modelPoint, offsetPoint) {
if (this.view)
this.view.setScrollTo(modelPoint, offsetPoint);
};
ViewController.prototype.scrollBy = function (offset) {
if (this.view && (offset.x !== 0 || offset.y !== 0))
return this.view.scrollBy(offset);
return offset;
};
ViewController.prototype.normalize = function () {
this.view.tryNormalizePaddings();
};
ViewController.prototype.getNextStepZoom = function (increase) {
var currentZoomStep = this.getNearestCurrentZoomStep();
var delta = increase ? 1 : -1;
var step = Math.min(ZOOM_STEPS - 1, Math.max(0, currentZoomStep + delta));
if (step !== ZERO_STEP) {
var logZoom = LOG_MIN_ZOOM + (LOG_MAX_ZOOM - LOG_MIN_ZOOM) * step / (ZOOM_STEPS - 1);
return Math.exp(logZoom);
}
return 1;
};
ViewController.prototype.getNearestCurrentZoomStep = function () {
var zoom = this.getZoom();
return getStepByZoom(zoom);
};
ViewController.prototype.getZoom = function () {
return this.view ? this.view.actualZoom : this.settings.zoomLevel;
};
ViewController.prototype.resetScroll = function () {
this.view.update({ horizontal: true, vertical: true });
};
return ViewController;
}());
exports.ViewController = ViewController;
function getStepByZoom(zoom) {
var logZoom = Math.log(zoom);
return Math.round((logZoom - LOG_MIN_ZOOM) * (ZOOM_STEPS - 1) / (LOG_MAX_ZOOM - LOG_MIN_ZOOM));
}
/***/ }),
/* 302 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var TextToolbox_1 = __webpack_require__(303);
var IconToolbox_1 = __webpack_require__(304);
var ShapeDescriptionManager_1 = __webpack_require__(25);
var ToolboxManager = /** @class */ (function () {
function ToolboxManager(readonly) {
this.toolboxes = [];
this.readonly = readonly;
}
ToolboxManager.prototype.create = function (parent, shapeIconSize, shapeIconSpacing, shapeIconAttributes, shapes, renderAsText) {
var shapeTypes = Array.isArray(shapes) ? shapes : ShapeDescriptionManager_1.ShapeDescriptionManager.getTypesByCategory(shapes);
var toolbox = renderAsText ?
new TextToolbox_1.TextToolbox(parent, this.readonly, {
shapeTypes: shapeTypes,
}) :
new IconToolbox_1.IconToolbox(parent, this.readonly, {
shapeIconSize: shapeIconSize,
shapeIconSpacing: shapeIconSpacing,
shapeIconAttributes: shapeIconAttributes,
shapeTypes: shapeTypes
});
toolbox.render();
this.toolboxes.push(toolbox);
return toolbox;
};
ToolboxManager.prototype.dispose = function () {
for (var i = 0; i < this.toolboxes.length; i++)
this.toolboxes[i].dispose();
};
ToolboxManager.prototype.applyFilter = function (str, filteringToolboxes) {
var _this = this;
return this.toolboxes
.reduce(function (aggr, toolbox, index) {
(typeof (filteringToolboxes) !== "number" || index === filteringToolboxes) &&
toolbox.render(function (shapeType) { return _this.searchFilter(shapeType, str, index); }) && aggr.push(index);
return aggr;
}, []);
};
ToolboxManager.prototype.searchFilter = function (shapeType, str, toolboxIndex, filteringToolboxes) {
if (!str || (filteringToolboxes && filteringToolboxes.indexOf(toolboxIndex) === -1))
return true;
return shapeType.indexOf(str) > -1;
};
ToolboxManager.prototype.notifyReadOnlyChanged = function (readOnly) {
this.readonly = readOnly;
};
return ToolboxManager;
}());
exports.ToolboxManager = ToolboxManager;
/***/ }),
/* 303 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Toolbox_1 = __webpack_require__(128);
var ShapeDescriptionManager_1 = __webpack_require__(25);
var TextToolbox = /** @class */ (function (_super) {
__extends(TextToolbox, _super);
function TextToolbox() {
return _super !== null && _super.apply(this, arguments) || this;
}
TextToolbox.prototype.createElements = function (element, shapeTypes) {
shapeTypes.forEach(function (shapeType) {
var description = ShapeDescriptionManager_1.ShapeDescriptionManager.get(shapeType);
var itemEl = document.createElement("div");
itemEl.setAttribute("class", "toolbox-text-item");
itemEl.setAttribute("data-tb-type", shapeType);
itemEl.innerHTML = description.defaultText;
element.appendChild(itemEl);
});
};
TextToolbox.prototype.createDraggingElement = function (draggingObject) {
var element = document.createElement("DIV");
element.setAttribute("class", "dxdi-toolbox-drag-text-item");
var shapeDescription = ShapeDescriptionManager_1.ShapeDescriptionManager.get(draggingObject.evt.data);
element.innerHTML = shapeDescription.defaultText;
document.body.appendChild(element);
return element;
};
return TextToolbox;
}(Toolbox_1.Toolbox));
exports.TextToolbox = TextToolbox;
/***/ }),
/* 304 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Toolbox_1 = __webpack_require__(128);
var ShapeDescriptionManager_1 = __webpack_require__(25);
var RenderManager_1 = __webpack_require__(12);
var Shape_1 = __webpack_require__(11);
var UnitConverter_1 = __webpack_require__(13);
var Utils_1 = __webpack_require__(0);
var TextShapeDescription_1 = __webpack_require__(93);
var IconToolbox = /** @class */ (function (_super) {
__extends(IconToolbox, _super);
function IconToolbox() {
return _super !== null && _super.apply(this, arguments) || this;
}
IconToolbox.prototype.createElements = function (element, shapeTypes) {
var svgElement = document.createElementNS(RenderManager_1.svgNS, "svg");
svgElement.className.baseVal = "dxdi-canvas";
element.appendChild(svgElement);
this.drawShapeIcons(svgElement, shapeTypes, svgElement.getBoundingClientRect().width);
};
IconToolbox.prototype.drawShapeIcons = function (parent, shapeTypes, svgWidth) {
var _this = this;
var lineWidth = UnitConverter_1.UnitConverter.twipsToPixels(Shape_1.Shape.lineWidth);
svgWidth -= 2 * lineWidth;
var iconCount = 1;
var width = this.options.shapeIconSize;
while (width < svgWidth) {
width += this.options.shapeIconSpacing + this.options.shapeIconSize;
if (width < svgWidth)
iconCount++;
}
var shapeIconSpacing = (iconCount > 1) ? (svgWidth - this.options.shapeIconSize * iconCount) / (iconCount - 1) : 0;
var xPos = lineWidth, yPos = lineWidth;
shapeTypes.forEach(function (shapeType, index) {
if (index > 0 && index % iconCount === 0) {
xPos = lineWidth;
yPos += _this.options.shapeIconSize + shapeIconSpacing;
}
var shapeDescription = ShapeDescriptionManager_1.ShapeDescriptionManager.get(shapeType);
var shape = _this.createShape(shapeDescription, xPos, yPos);
_this.updateShapeIconBounds(shape);
_this.drawShape(parent, shape);
xPos += _this.options.shapeIconSize + shapeIconSpacing;
});
parent.style.height = yPos + this.options.shapeIconSize + lineWidth + "px";
};
IconToolbox.prototype.drawShape = function (parent, shape) {
var primitives = shape.description.createPrimitives(shape, true);
var gEl = document.createElementNS(RenderManager_1.svgNS, "g");
gEl.setAttribute("data-tb-type", shape.description.key.toString());
gEl.setAttribute("class", "toolbox-item");
gEl.setAttribute("title", shape.description.title);
for (var key in this.options.shapeIconAttributes) {
if (this.options.shapeIconAttributes.hasOwnProperty(key))
gEl.setAttribute(key, this.options.shapeIconAttributes[key]);
}
parent.appendChild(gEl);
primitives.forEach(function (pr) {
var el = pr.createElement();
gEl.appendChild(el);
pr.applyElementProperties(el);
});
};
IconToolbox.prototype.createShape = function (shapeDescription, xPos, yPos) {
var xPosT = UnitConverter_1.UnitConverter.pixelsToTwips(xPos);
var yPosT = UnitConverter_1.UnitConverter.pixelsToTwips(yPos);
var shape = new Shape_1.Shape(shapeDescription, new Utils_1.Point(xPosT, yPosT));
if (!(shapeDescription instanceof TextShapeDescription_1.TextShapeDescription))
shape.text = "";
return shape;
};
IconToolbox.prototype.updateShapeIconBounds = function (shape) {
var shapeSizeT = UnitConverter_1.UnitConverter.pixelsToTwips(this.options.shapeIconSize);
shape.size.height = shape.size.width * shape.getToolboxHeightToWidthRatio();
if (shape.size.width > shape.size.height) {
var ratio = shape.size.height / shape.size.width;
shape.size.width = shapeSizeT;
shape.size.height = shapeSizeT * ratio;
shape.position.y = shape.position.y + (shapeSizeT - shape.size.height) / 2;
shape.parameters.forEach(function (p) { p.value = p.value * shapeSizeT / shape.description.defaultSize.width; });
}
else if (shape.size.width < shape.size.height) {
var ratio = shape.size.width / shape.size.height;
shape.size.height = shapeSizeT;
shape.size.width = shapeSizeT * ratio;
shape.position.x = shape.position.x + (shapeSizeT - shape.size.width) / 2;
shape.parameters.forEach(function (p) { p.value = p.value * shapeSizeT / shape.description.defaultSize.height; });
}
else {
shape.size.width = shapeSizeT;
shape.size.height = shapeSizeT;
shape.parameters.forEach(function (p) { p.value = p.value * shapeSizeT / shape.description.defaultSize.width; });
}
};
IconToolbox.prototype.createDraggingElement = function (draggingObject) {
var element = document.createElement("DIV");
element.setAttribute("class", "dxdi-toolbox-drag-item");
document.body.appendChild(element);
var svgElement = document.createElementNS(RenderManager_1.svgNS, "svg");
svgElement.className.baseVal = "dxdi-canvas";
element.appendChild(svgElement);
var shapeDescription = ShapeDescriptionManager_1.ShapeDescriptionManager.get(draggingObject.evt.data);
var shape = this.createShape(shapeDescription, UnitConverter_1.UnitConverter.twipsToPixels(Shape_1.Shape.lineWidth), UnitConverter_1.UnitConverter.twipsToPixels(Shape_1.Shape.lineWidth));
this.drawShape(svgElement, shape);
element.style.width = UnitConverter_1.UnitConverter.twipsToPixels(shape.size.width + 2 * Shape_1.Shape.lineWidth) + "px";
element.style.height = UnitConverter_1.UnitConverter.twipsToPixels(shape.size.height + 2 * Shape_1.Shape.lineWidth) + "px";
return element;
};
return IconToolbox;
}(Toolbox_1.Toolbox));
exports.IconToolbox = IconToolbox;
/***/ }),
/* 305 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var BatchUpdatableObject_1 = __webpack_require__(127);
var ApiController = /** @class */ (function (_super) {
__extends(ApiController, _super);
function ApiController(events, selection, model) {
var _this = _super.call(this) || this;
_this.events = events;
_this.model = model;
_this.selection = selection;
return _this;
}
ApiController.prototype.onSelectionChanged = function () {
if (this.isUpdateLocked())
this.registerOccurredEvent(ApiControllerAction.SelectionChanged);
else
this.raiseSelectionChanged();
};
ApiController.prototype.onUpdateUnlocked = function (occurredEvents) {
if (occurredEvents & ApiControllerAction.SelectionChanged)
this.raiseSelectionChanged();
};
ApiController.prototype.raiseSelectionChanged = function () {
var _this = this;
var items = this.selection.getKeys().map(function (key) { return _this.model.findItem(key).toNative(); });
this.events.raise1(function (l) { return l.notifySelectionChanged(items); });
};
return ApiController;
}(BatchUpdatableObject_1.BatchUpdatableObject));
exports.ApiController = ApiController;
var ApiControllerAction;
(function (ApiControllerAction) {
ApiControllerAction[ApiControllerAction["SelectionChanged"] = 1] = "SelectionChanged";
})(ApiControllerAction || (ApiControllerAction = {}));
/***/ }),
/* 306 */
/***/ (function(module, exports, __webpack_require__) {
// extracted by mini-css-extract-plugin
/***/ })
/******/ ]);
});
Reference in New Issue View Git Blame Copy Permalink