@wcardinal/wcardinal-ui 0.371.0 → 0.373.0

package/dist/wcardinal-ui.js

@@ -1,5 +1,5 @@
 /*
- Winter Cardinal UI v0.371.0
+ Winter Cardinal UI v0.373.0
  Copyright (C) 2019 Toshiba Corporation
  SPDX-License-Identifier: Apache-2.0
 
@@ -2560,9 +2560,11 @@
             });
             return this;
         };
-        EShapeConnectorContainerImpl.prototype.detach = function () {
+        EShapeConnectorContainerImpl.prototype.detach = function (exceptions) {
             this._edges.forEach(function (edge) {
-                edge.set(null);
+                if (exceptions == null || !exceptions.has(edge.parent)) {
+                    edge.set(null);
+                }
             });
             return this;
         };
@@ -4472,7 +4474,7 @@
     var GROUP = PRIMITIVE | UNGROUPING;
     var EMBEDDED = ID | COORDINATE | REPLACING | GROUPING | TEXT$2 | DATA | ACTION | LAYER | DATA_MAPPING;
     var EMBEDDED_ACCEPTOR_EDGE = ID | COORDINATE | REPLACING | FILL$1 | STROKE$1 | TEXT$2 | TEXTURE | DATA | ACTION | CURSOR$1 | LAYER;
-    var CONNECTOR = ID | REPLACING | FILL$1 | STROKE$1 | LINE | LINE_TAIL | LINE_HEAD | TEXT$2 | TEXTURE | DATA | ACTION | CURSOR$1 | LAYER | CHILDREN$1;
+    var CONNECTOR = ID | SHAPE | TEXT$2 | TEXTURE | DATA | ACTION | CURSOR$1 | LAYER | CHILDREN$1;
     var ALL = PRIMITIVE | STROKE_SIDE | BORDER_RADIUS | DATA_MAPPING | UNGROUPING;
     var EShapeCapability = {
         NONE: NONE,
@@ -4638,6 +4640,44 @@
         return EShapeCapabilityContainerImpl;
     }());
 
+    var EShapeLock = /** @class */ (function () {
+        function EShapeLock() {
+            this._count = 0;
+            this._flag = 0;
+        }
+        EShapeLock.prototype.lock = function () {
+            this._count += 1;
+            if (this._count === 1) {
+                this._flag = 0;
+                return true;
+            }
+            return false;
+        };
+        EShapeLock.prototype.unlock = function () {
+            this._count -= 1;
+            return this._count <= 0 && this._flag !== 0;
+        };
+        EShapeLock.prototype.isLocked = function (high) {
+            if (0 < this._count) {
+                this._flag |= high ? 3 : 1;
+                return true;
+            }
+            return false;
+        };
+        EShapeLock.prototype.isHigh = function () {
+            return 1 < this._flag;
+        };
+        return EShapeLock;
+    }());
+
+    var EShapeLockPart = {
+        TRANSFORM: 1,
+        TRANSFORM_PARENT: 2,
+        UPLOADED: 4,
+        TRANSFORM_AND_UPLOADED: 7,
+        CONNECTOR: 8
+    };
+
     /*
      * Copyright (C) 2019 Toshiba Corporation
      * SPDX-License-Identifier: Apache-2.0
@@ -4650,13 +4690,11 @@
             _this.uuid = 0;
             _this.type = type;
             _this.transform = _this.newTransform();
-            _this._onTransformChangeLock = 0;
-            _this._isOnTransformChanged = false;
             _this.action = new EShapeAction();
             _this._visible = true;
-            _this._uploadedUpdateLock = 0;
-            _this._isUploadedUpdated = false;
-            _this._isUploadedUpdatedRecursively = false;
+            _this._lockTransform = new EShapeLock();
+            _this._lockTransformParent = new EShapeLock();
+            _this._lockUploaded = new EShapeLock();
             _this._boundsTransformId = NaN;
             _this._boundsInternalTransformId = NaN;
             _this._boundsLocalTransformId = NaN;
@@ -4697,6 +4735,9 @@
             this.onParentTransformChange();
         };
         EShapeBase.prototype.onParentTransformChange = function () {
+            if (this._lockTransformParent.isLocked()) {
+                return;
+            }
             this.updateUploaded();
             var connector = this._connector;
             if (connector != null) {
@@ -4708,79 +4749,62 @@
             }
         };
         EShapeBase.prototype.onTransformChange_ = function () {
-            if (this._onTransformChangeLock === 0) {
-                var parent_1 = this.parent;
-                if (parent_1 != null) {
-                    parent_1.onChildTransformChange();
-                }
+            if (this._lockTransform.isLocked()) {
+                return;
             }
-            else {
-                this._isOnTransformChanged = true;
+            var parent = this.parent;
+            if (parent != null) {
+                parent.onChildTransformChange();
             }
         };
-        EShapeBase.prototype.disallowOnTransformChange = function () {
-            this._onTransformChangeLock += 1;
-            if (this._onTransformChangeLock === 1) {
-                this._isOnTransformChanged = false;
+        EShapeBase.prototype.lock = function (part) {
+            if (part & EShapeLockPart.TRANSFORM) {
+                this._lockTransform.lock();
+            }
+            if (part & EShapeLockPart.TRANSFORM_PARENT) {
+                this._lockTransformParent.lock();
             }
+            if (part & EShapeLockPart.UPLOADED) {
+                this._lockUploaded.lock();
+            }
+            return this;
         };
-        EShapeBase.prototype.allowOnTransformChange = function (invokeOnTransformChange) {
-            this._onTransformChangeLock -= 1;
-            if (this._onTransformChangeLock === 0) {
-                if (this._isOnTransformChanged) {
-                    this._isOnTransformChanged = false;
-                    if (invokeOnTransformChange) {
-                        this.onTransformChange();
-                    }
+        EShapeBase.prototype.unlock = function (part, invoke) {
+            if (part & EShapeLockPart.UPLOADED) {
+                var lockUploaded = this._lockUploaded;
+                if (lockUploaded.unlock() && invoke) {
+                    this.updateUploaded(lockUploaded.isHigh());
                 }
             }
+            if (part & EShapeLockPart.TRANSFORM_PARENT) {
+                if (this._lockTransformParent.unlock() && invoke) {
+                    this.onParentTransformChange();
+                }
+            }
+            if (part & EShapeLockPart.TRANSFORM) {
+                if (this._lockTransform.unlock() && invoke) {
+                    this.onTransformChange();
+                }
+            }
+            return this;
         };
         EShapeBase.prototype.onChildTransformChange = function () {
             //
         };
-        EShapeBase.prototype.disallowUploadedUpdate = function () {
-            this._uploadedUpdateLock += 1;
-            if (this._uploadedUpdateLock === 1) {
-                this._isUploadedUpdated = false;
-                this._isUploadedUpdatedRecursively = false;
+        EShapeBase.prototype.updateUploaded = function (recursively) {
+            if (this._lockUploaded.isLocked()) {
+                return;
             }
-        };
-        EShapeBase.prototype.allowUploadedUpdate = function () {
-            this._uploadedUpdateLock -= 1;
-            if (this._uploadedUpdateLock === 0) {
-                if (this._isUploadedUpdatedRecursively) {
-                    this._isUploadedUpdatedRecursively = false;
-                    this._isUploadedUpdated = false;
-                    this.updateUploadedRecursively();
-                }
-                else if (this._isUploadedUpdated) {
-                    this._isUploadedUpdated = false;
-                    this.updateUploaded();
-                }
+            var uploaded = this.uploaded;
+            if (uploaded != null) {
+                uploaded.update(this);
             }
-        };
-        EShapeBase.prototype.updateUploadedRecursively = function () {
-            if (this._uploadedUpdateLock === 0) {
-                this.updateUploaded();
+            if (recursively === true) {
                 var children = this.children;
                 for (var i = 0, imax = children.length; i < imax; ++i) {
-                    children[i].updateUploadedRecursively();
+                    children[i].updateUploaded(true);
                 }
             }
-            else {
-                this._isUploadedUpdatedRecursively = true;
-            }
-        };
-        EShapeBase.prototype.updateUploaded = function () {
-            if (this._uploadedUpdateLock === 0) {
-                var uploaded = this.uploaded;
-                if (uploaded != null) {
-                    uploaded.update(this);
-                }
-            }
-            else {
-                this._isUploadedUpdated = true;
-            }
         };
         Object.defineProperty(EShapeBase.prototype, "image", {
             get: function () {
@@ -4825,9 +4849,9 @@
         Object.defineProperty(EShapeBase.prototype, "visible", {
             get: function () {
                 if (this._visible) {
-                    var parent_2 = this.parent;
-                    if (parent_2 instanceof EShapeBase) {
-                        return parent_2.visible;
+                    var parent_1 = this.parent;
+                    if (parent_1 instanceof EShapeBase) {
+                        return parent_1.visible;
                     }
                     return true;
                 }
@@ -4836,7 +4860,7 @@
             set: function (visible) {
                 if (this._visible !== visible) {
                     this._visible = visible;
-                    this.updateUploadedRecursively();
+                    this.updateUploaded(true);
                 }
             },
             enumerable: false,
@@ -4845,9 +4869,9 @@
         Object.defineProperty(EShapeBase.prototype, "worldVisible", {
             get: function () {
                 if (this._visible) {
-                    var parent_3 = this.parent;
-                    if (parent_3) {
-                        return parent_3.worldVisible;
+                    var parent_2 = this.parent;
+                    if (parent_2) {
+                        return parent_2.worldVisible;
                     }
                     return true;
                 }
@@ -4891,7 +4915,7 @@
                 children[i].onAttach();
             }
         };
-        EShapeBase.prototype.detach = function () {
+        EShapeBase.prototype.detach = function (exceptions) {
             var parent = this.parent;
             if (parent) {
                 this.parent = null;
@@ -4901,20 +4925,20 @@
                     children.splice(index, 1);
                     parent.onChildTransformChange();
                     parent.toDirty();
-                    this.onDetach();
+                    this.onDetach(exceptions);
                 }
             }
             return this;
         };
-        EShapeBase.prototype.onDetach = function () {
+        EShapeBase.prototype.onDetach = function (exceptions) {
             this.uploaded = undefined;
             var connector = this._connector;
             if (connector) {
-                connector.detach();
+                connector.detach(exceptions);
             }
             var children = this.children;
             for (var i = 0, imax = children.length; i < imax; ++i) {
-                children[i].onDetach();
+                children[i].onDetach(exceptions);
             }
         };
         // Transform
@@ -16929,10 +16953,10 @@
             // Size
             editor.size.copyFrom(shape.size);
             //
-            shape.disallowOnTransformChange();
+            shape.lock(EShapeLockPart.TRANSFORM);
         };
         EShapeTransforms.finalize = function (shape) {
-            shape.allowOnTransformChange(true);
+            shape.unlock(EShapeLockPart.TRANSFORM, true);
         };
         EShapeTransforms.apply = function (shape, transform, capability) {
             var editor = shape.editor;
@@ -16946,7 +16970,7 @@
             }
         };
         EShapeTransforms.applyLocal = function (shape, localTransform, capability, size) {
-            shape.disallowUploadedUpdate();
+            shape.lock(EShapeLockPart.UPLOADED);
             // Reconstruct the position, the rotation and the size
             var a = localTransform.a;
             var b = localTransform.b;
@@ -17006,7 +17030,7 @@
                 }
             }
             //
-            shape.allowUploadedUpdate();
+            shape.unlock(EShapeLockPart.UPLOADED, true);
         };
         return EShapeTransforms;
     }());
@@ -17060,9 +17084,9 @@
                 .translate(-pivotX, -pivotY)
                 .scale(sx, sy)
                 .translate(+pivotX, +pivotY);
-            shape.disallowOnTransformChange();
+            shape.lock(EShapeLockPart.TRANSFORM);
             EShapeTransforms.applyLocal(shape, transform, EShapeCapability.ALL, childBase);
-            shape.allowOnTransformChange(false);
+            shape.unlock(EShapeLockPart.TRANSFORM, false);
         };
         EShapeGroupSizeLayout.WORK_TRANSFORM = new pixi_js.Matrix();
         return EShapeGroupSizeLayout;
@@ -17166,41 +17190,43 @@
         };
         EShapeGroupSizeEditor.prototype.doFit = function () {
             var parent = this._parent;
-            parent.disallowOnTransformChange();
+            parent.lock(EShapeLockPart.TRANSFORM | EShapeLockPart.TRANSFORM_PARENT);
             // Calculate the rect
             var rect = this.calcRect(this._workRectForFit);
             // Set size
             var size = this._size;
             size.set(rect.width, rect.height);
-            // Position & Pivot
-            // rx := rect.x
-            // ry := rect.y
+            // Calculating new position & pivot
+            //
+            // cx := rect.x + rect.width * 0.5
+            // cy := rect.y + rect.height * 0.5
             //
-            // | a c tx | | 1 0 +rx | | 1 0 -rx |   | a c tx + (a * rx + c * ry) | | 1 0 -rx |
-            // | b d ty | | 0 1 +ry | | 0 1 -ry | = | b d ty + (b * rx + d * ry) | | 0 1 -ry |
-            // | 0 0 1  | | 0 0  1  | | 0 0  1  |   | 0 0 1                      | | 0 0  1  |
+            // Since the local transform need to be unchanged:
             //
-            // tx -> tx + (a * rx + c * ry) = poxition.x - (a * pivot.x + c * pivot.y)
-            // ty -> ty + (b * rx + d * ry) = poxition.y - (b * pivot.x + d * pivot.y)
-            // position.x -> position.x + (a * rx + c * ry) - (a * pivot.x + c * pivot.y)
-            // position.y -> position.y + (b * rx + d * ry) - (b * pivot.x + d * pivot.y)
-            // pivot.x -> 0
-            // pivot.y -> 0
+            // | a c tx |   | a c px' - (a * pvx' + c * pvy') |
+            // | b d ty | = | b d py' - (b * pvx' + d * pvy') |
+            // | 0 0 1  |   | 0 0 1                           |
             //
-            // a -> a', b -> b', c -> c', tx -> tx', ty -> ty'
+            // Here, (px', py') and (pvx', pvy') are the new position
+            // and the new pivot, respectively.
             //
-            // | a' c' tx' | | 1 0 -rx |   | a' c' tx' - (a' * rx + c' * ry) |
-            // | b' d' ty' | | 0 1 -ry | = | b' d' ty' - (b' * rx + d' * ry) |
-            // | 0  0  1   | | 0 0  1  |   | 0  0  1                         |
+            // Setting the new pivot (pvx', pvy') to (cx, cy) leads to
             //
-            // tx' -> tx' - (a' * rx + c' * ry) = poxition.x - (a' * pivot.x + c' * pivot.y)
-            // ty' -> ty' - (b' * rx + d' * ry) = poxition.y - (b' * pivot.x + d' * pivot.y)
-            // pivot.x -> pivot.x + rx
-            // pivot.y -> pivot.y + ry
+            // | a c tx |   | a c px' - (a * cx + c * cy) |
+            // | b d ty | = | b d py' - (b * cx + d * cy) |
+            // | 0 0 1  |   | 0 0 1                       |
+            //
+            // tx = px - (a * pvx + c * pvy) = px' - (a * cx + c * cy)
+            // ty = py - (b * pvx + d * pvy) = py' - (b * cx + d * cy)
+            //
+            // Thus, the new position (px', py') is
+            //
+            // px' = px + (a * (cx - pvx) + c * (cy - pvy))
+            // py' = py + (b * (cy - pvx) + d * (cy - pvy))
             parent.updateTransform();
             var transform = parent.transform;
-            var x = rect.x + rect.width * 0.5;
-            var y = rect.y + rect.height * 0.5;
+            var cx = rect.x + rect.width * 0.5;
+            var cy = rect.y + rect.height * 0.5;
             var position = transform.position;
             var localTransform = transform.localTransform;
             var a = localTransform.a;
@@ -17208,12 +17234,16 @@
             var c = localTransform.c;
             var d = localTransform.d;
             var pivot = transform.pivot;
-            position.set(position.x + (a * x + c * y) - (a * pivot.x + c * pivot.y), position.y + (b * x + d * y) - (b * pivot.x + d * pivot.y));
-            pivot.set(x, y);
+            var pvx = pivot.x;
+            var pvy = pivot.y;
+            var dpvx = cx - pvx;
+            var dpvy = cy - pvy;
+            position.set(position.x + (a * dpvx + c * dpvy), position.y + (b * dpvx + d * dpvy));
+            pivot.set(cx, cy);
             // Reset the data
             this.reset(parent.children, this._layouts, size);
             //
-            parent.allowOnTransformChange(true);
+            parent.unlock(EShapeLockPart.TRANSFORM | EShapeLockPart.TRANSFORM_PARENT, true);
         };
         EShapeGroupSizeEditor.prototype.reset = function (children, layouts, size) {
             for (var i = 0, imax = Math.min(layouts.length, children.length); i < imax; ++i) {
@@ -18608,9 +18638,9 @@
             }
             return this;
         };
-        EShapeConnectorEdgeImpl.prototype.detach = function () {
+        EShapeConnectorEdgeImpl.prototype.detach = function (exceptions) {
             var shape = this._acceptor.shape;
-            if (shape) {
+            if (shape != null && (exceptions == null || !exceptions.has(shape))) {
                 if (shape.connector.remove(this)) {
                     this.onAcceptorChange();
                 }
@@ -18722,10 +18752,10 @@
             this.unlock();
             return this;
         };
-        EShapeConnectorEdgeContainerImpl.prototype.detach = function () {
+        EShapeConnectorEdgeContainerImpl.prototype.detach = function (exceptions) {
             this.lock();
-            this._tail.detach();
-            this._head.detach();
+            this._tail.detach(exceptions);
+            this._head.detach(exceptions);
             this.unlock();
             return this;
         };
@@ -20094,8 +20124,7 @@
             _this._headNormalId = 0;
             _this._headMargin = 0;
             _this._bodyId = 0;
-            _this._lockCount = 0;
-            _this._isChanged = false;
+            _this._lockChange = new EShapeLock();
             var sx = EShapeDefaults.SIZE_X;
             var sy = EShapeDefaults.SIZE_Y;
             var hx = sx * 0.5;
@@ -20108,20 +20137,20 @@
             _this._body = new EShapeConnectorBodyImpl(_this, onChangeBound);
             return _this;
         }
-        EShapeConnectorLine.prototype.lock = function () {
-            this._lockCount += 1;
-            if (this._lockCount === 1) {
-                this._isChanged = false;
+        EShapeConnectorLine.prototype.lock = function (part) {
+            _super.prototype.lock.call(this, part);
+            if (part & EShapeLockPart.CONNECTOR) {
+                this._lockChange.lock();
             }
+            return this;
         };
-        EShapeConnectorLine.prototype.unlock = function () {
-            this._lockCount -= 1;
-            if (this._lockCount === 0) {
-                if (this._isChanged) {
+        EShapeConnectorLine.prototype.unlock = function (part, invoke) {
+            if (part & EShapeLockPart.CONNECTOR) {
+                if (this._lockChange.unlock() && invoke) {
                     this.onChange();
                 }
-                this._isChanged = false;
             }
+            return _super.prototype.unlock.call(this, part, invoke);
         };
         Object.defineProperty(EShapeConnectorLine.prototype, "points", {
             get: function () {
@@ -20148,14 +20177,13 @@
             _super.prototype.onAttach.call(this);
             this._edge.attach();
         };
-        EShapeConnectorLine.prototype.onDetach = function () {
-            this._edge.detach();
-            _super.prototype.onDetach.call(this);
+        EShapeConnectorLine.prototype.onDetach = function (exceptions) {
+            this._edge.detach(exceptions);
+            _super.prototype.onDetach.call(this, exceptions);
         };
         EShapeConnectorLine.prototype.onChange = function () {
             var _a;
-            if (0 < this._lockCount) {
-                this._isChanged = true;
+            if (this._lockChange.isLocked()) {
                 return;
             }
             var edge = this._edge;
@@ -20203,7 +20231,7 @@
                     values[i + 0] -= cx;
                     values[i + 1] -= cy;
                 }
-                this.disallowUploadedUpdate();
+                this.lock(EShapeLockPart.TRANSFORM_AND_UPLOADED);
                 transformPosition.set(px + cx, py + cy);
                 transform.scale.set(1, 1);
                 transform.rotation = 0;
@@ -20211,7 +20239,7 @@
                 points.toFitted(sx, sy);
                 this.size.set(sx, sy);
                 points.set(values);
-                this.allowUploadedUpdate();
+                this.unlock(EShapeLockPart.TRANSFORM_AND_UPLOADED, true);
             }
         };
         EShapeConnectorLine.prototype.fillPoints = function (tail, tailMargin, head, headMargin, body, px, py, values) {
@@ -24260,12 +24288,12 @@
             this.interactive = false;
         }
         EShapeRuntimeImpl.prototype.initialize = function (shape) {
-            shape.disallowUploadedUpdate();
+            shape.lock(EShapeLockPart.UPLOADED);
             var actions = this.actions;
             for (var i = 0, imax = actions.length; i < imax; ++i) {
                 actions[i].initialize(shape, this);
             }
-            shape.allowUploadedUpdate();
+            shape.unlock(EShapeLockPart.UPLOADED, true);
         };
         EShapeRuntimeImpl.prototype.isActionable = function () {
             return 0 < this.actions.length;
@@ -24592,9 +24620,9 @@
                 if (isEffectTimeUp) {
                     this.effect = NaN;
                 }
-                shape.disallowUploadedUpdate();
+                shape.lock(EShapeLockPart.UPLOADED);
                 this.onUpdate(shape, time);
-                shape.allowUploadedUpdate();
+                shape.unlock(EShapeLockPart.UPLOADED, true);
                 var wasStateChanged = this.isStateChanged;
                 shape.state.removeAll(EShapeRuntimeImpl.TRANSIENT_STATES);
                 this.isStateChanged = wasStateChanged;
@@ -38650,7 +38678,7 @@
                     manager.setExtension(resourceId, parsed);
                 }
                 // Lock
-                shape.lock();
+                shape.lock(EShapeLockPart.CONNECTOR);
                 // Points
                 var points = shape.points;
                 points.deserialize(parsed[1], manager);
@@ -38668,7 +38696,7 @@
                     body.set(EShapeConnectorBodies.from(points.values, edge.tail.margin, edge.head.margin));
                 }
                 // Unlock
-                shape.unlock();
+                shape.unlock(EShapeLockPart.CONNECTOR, true);
             }
         }
     };
@@ -39608,6 +39636,7 @@
                 clone.parent = result;
                 result.children.push(clone);
             }
+            EShapeConnectors.moveAll(children, result.children, children, result.children);
             result.onChildTransformChange();
             result.toDirty();
             return result;
@@ -45495,7 +45524,7 @@
         var cposition = EShapeCapabilities.contains(shape, EShapeCapability.POSITION);
         var cwidth = EShapeCapabilities.contains(shape, EShapeCapability.WIDTH);
         var cheight = EShapeCapabilities.contains(shape, EShapeCapability.HEIGHT);
-        shape.disallowUploadedUpdate();
+        shape.lock(EShapeLockPart.UPLOADED);
         var position = shape.transform.position;
         if (centerMode) {
             var dx = Math.abs(to.x - from.x);
@@ -45592,7 +45621,7 @@
                 }
             }
         }
-        shape.allowUploadedUpdate();
+        shape.unlock(EShapeLockPart.UPLOADED, true);
     };
 
     /*
@@ -45848,14 +45877,26 @@
     var EShapeDeleter = /** @class */ (function () {
         function EShapeDeleter() {
         }
+        EShapeDeleter.addAll = function (shapes, result) {
+            for (var i = 0, imax = shapes.length; i < imax; ++i) {
+                var shape = shapes[i];
+                result.add(shape);
+                this.addAll(shape.children, result);
+            }
+            return result;
+        };
         EShapeDeleter.delete = function (parent, shapes, generateListOfDetachedShapes) {
+            var _a;
             var children = parent.children;
             var length = children.length;
             // Update indices
+            var exceptions = ((_a = EShapeDeleter.EXCEPTIONS) !== null && _a !== void 0 ? _a : (EShapeDeleter.EXCEPTIONS = new Set()));
             for (var i = 0; i < length; ++i) {
                 var child = children[i];
                 if (child.selected) {
                     child.index = length + i;
+                    exceptions.add(child);
+                    this.addAll(child.children, exceptions);
                 }
                 else {
                     child.index = i;
@@ -45872,9 +45913,10 @@
                         child.parent = null;
                         child.selected = false;
                         child.uploaded = undefined;
-                        child.onDetach();
+                        child.onDetach(exceptions);
                     }
                     else {
+                        exceptions.clear();
                         var size = children.length - (i + 1);
                         if (0 < size) {
                             var result = children.splice(i + 1, size);
@@ -45893,6 +45935,7 @@
                         }
                     }
                 }
+                exceptions.clear();
                 if (0 < children.length) {
                     var result = children.splice(0, children.length);
                     if (shapes != null) {
@@ -45916,9 +45959,10 @@
                         child.parent = null;
                         child.selected = false;
                         child.uploaded = undefined;
-                        child.onDetach();
+                        child.onDetach(exceptions);
                     }
                     else {
+                        exceptions.clear();
                         children.length = i + 1;
                         if (shapes != null) {
                             shapes.length = 0;
@@ -45928,6 +45972,7 @@
                         return null;
                     }
                 }
+                exceptions.clear();
                 if (0 < children.length) {
                     children.length = 0;
                     if (shapes != null) {
@@ -56306,7 +56351,7 @@
                 var plotAreaWidth = plotArea.width;
                 var plotAreaHeight = plotArea.height;
                 var offset = this._parser.padding * index;
-                shape.disallowUploadedUpdate();
+                shape.lock(EShapeLockPart.UPLOADED);
                 var position = shape.transform.position;
                 var size = shape.size;
                 switch (this._parser.position) {
@@ -56327,7 +56372,7 @@
                         size.set(0, plotAreaHeight);
                         break;
                 }
-                shape.allowUploadedUpdate();
+                shape.unlock(EShapeLockPart.UPLOADED, true);
                 return true;
             }
             return false;
@@ -57384,18 +57429,18 @@
             return true;
         };
         DChartAxisBaseTickContainer.prototype.showMajor = function (shape, x, y, text) {
-            shape.disallowUploadedUpdate();
+            shape.lock(EShapeLockPart.UPLOADED);
             shape.visible = true;
             shape.transform.position.set(x, y);
             shape.text.value = text != null ? text : "";
-            shape.allowUploadedUpdate();
+            shape.unlock(EShapeLockPart.UPLOADED, true);
         };
         DChartAxisBaseTickContainer.prototype.showMajorGridline = function (shape, value, x, y, sx, sy) {
-            shape.disallowUploadedUpdate();
+            shape.lock(EShapeLockPart.UPLOADED);
             shape.visible = true;
             shape.transform.position.set(x, y);
             shape.size.set(sx, sy);
-            shape.allowUploadedUpdate();
+            shape.unlock(EShapeLockPart.UPLOADED, true);
         };
         DChartAxisBaseTickContainer.prototype.hideMajor = function (shape) {
             shape.visible = false;
@@ -57404,11 +57449,11 @@
             shape.visible = false;
         };
         DChartAxisBaseTickContainer.prototype.showMinor = function (shape, x, y, text) {
-            shape.disallowUploadedUpdate();
+            shape.lock(EShapeLockPart.UPLOADED);
             shape.visible = true;
             shape.transform.position.set(x, y);
             shape.text.value = text != null ? text : "";
-            shape.allowUploadedUpdate();
+            shape.unlock(EShapeLockPart.UPLOADED, true);
         };
         DChartAxisBaseTickContainer.prototype.hideMinor = function (shape) {
             shape.visible = false;
@@ -57871,7 +57916,7 @@
         DChartAxisGuideSimpleShapeImpl.prototype.update = function (position, x, y, visible, width, height, offset) {
             var bar = this._bar;
             if (bar != null) {
-                bar.disallowUploadedUpdate();
+                bar.lock(EShapeLockPart.UPLOADED);
                 switch (position) {
                     case DChartAxisPosition.TOP:
                         bar.transform.position.set(x, y);
@@ -57894,7 +57939,7 @@
                         bar.visible = visible;
                         break;
                 }
-                bar.allowUploadedUpdate();
+                bar.unlock(EShapeLockPart.UPLOADED, true);
             }
             var label = this._label;
             if (label != null) {
@@ -57902,7 +57947,7 @@
                 var s = label.size;
                 var ox = offset + s.x * 0.5 + m;
                 var oy = offset + s.y * 0.5 + m;
-                label.disallowUploadedUpdate();
+                label.lock(EShapeLockPart.UPLOADED);
                 switch (position) {
                     case DChartAxisPosition.TOP:
                         label.transform.position.set(x, -oy);
@@ -57921,7 +57966,7 @@
                         label.visible = visible;
                         break;
                 }
-                label.allowUploadedUpdate();
+                label.unlock(EShapeLockPart.UPLOADED, true);
             }
             var tick = this._tick;
             if (tick != null) {
@@ -57929,7 +57974,7 @@
                 var s = tick.size;
                 var ox = offset + s.x * 0.5 + m;
                 var oy = offset + s.y * 0.5 + m;
-                tick.disallowUploadedUpdate();
+                tick.lock(EShapeLockPart.UPLOADED);
                 switch (position) {
                     case DChartAxisPosition.TOP:
                         tick.transform.position.set(x, -oy);
@@ -57948,7 +57993,7 @@
                         tick.visible = visible;
                         break;
                 }
-                tick.allowUploadedUpdate();
+                tick.unlock(EShapeLockPart.UPLOADED, true);
             }
             return true;
         };
@@ -60759,9 +60804,9 @@
                 values[i + 0] -= cx;
                 values[i + 1] -= cy;
             }
-            line.disallowUploadedUpdate();
+            line.lock(EShapeLockPart.UPLOADED);
             this.applyLine(line, xcoordinate, ycoordinate, sx, sy, cx, cy, values);
-            line.allowUploadedUpdate();
+            line.unlock(EShapeLockPart.UPLOADED, true);
         };
         DChartSeriesLineOfAny.prototype.adjustLineRegion = function (xmin, xmax, ymin, ymax, result) {
             result.xmin = xmin;
@@ -61251,7 +61296,7 @@
             return false;
         };
         DChartSeriesLine.prototype.doUpdateLine = function (line, xcoordinate, ycoordinate, isPointsDirty) {
-            line.disallowUploadedUpdate();
+            line.lock(EShapeLockPart.UPLOADED);
             if (isPointsDirty) {
                 var values = line.points.values;
                 var segments = line.points.segments;
@@ -61334,7 +61379,7 @@
             }
             line.transform.position.set(xcoordinate.transform.map(this._centerX), ycoordinate.transform.map(this._centerY));
             line.transform.scale.set(xcoordinate.transform.scale, ycoordinate.transform.scale);
-            line.allowUploadedUpdate();
+            line.unlock(EShapeLockPart.UPLOADED, true);
         };
         DChartSeriesLine.prototype.updateRegion = function () {
             var pointId = this._pointId;
@@ -61693,12 +61738,12 @@
             if (0 < segments.length) {
                 segments.length = 0;
             }
-            line.disallowUploadedUpdate();
+            line.lock(EShapeLockPart.UPLOADED);
             line.points.set(values, segments);
             line.points.toFitted(sx, sy);
             line.size.set(sx, sy);
             line.transform.position.set(cx, cy);
-            line.allowUploadedUpdate();
+            line.unlock(EShapeLockPart.UPLOADED, true);
         };
         DChartSeriesLinear.prototype.updateRegion = function () {
             // DO NOTHING
@@ -63289,23 +63334,23 @@
             var shape = null;
             if (index < shapes.length) {
                 shape = shapes[index];
-                shape.disallowUploadedUpdate();
+                shape.lock(EShapeLockPart.UPLOADED);
                 shape.points.position = position;
                 shape.transform.position.set(x, y);
                 shape.stroke.set(true, style.color, style.alpha, style.width, undefined, undefined, style.style);
                 shape.size.set(w, h);
                 shape.visible = true;
-                shape.allowUploadedUpdate();
+                shape.unlock(EShapeLockPart.UPLOADED, true);
             }
             else {
                 shape = new EShapeBar();
-                shape.disallowUploadedUpdate();
+                shape.lock(EShapeLockPart.UPLOADED);
                 shape.points.position = position;
                 shape.transform.position.set(x, y);
                 shape.stroke.set(true, style.color, style.alpha, style.width, undefined, undefined, style.style);
                 shape.size.set(w, h);
                 shape.visible = true;
-                shape.allowUploadedUpdate();
+                shape.unlock(EShapeLockPart.UPLOADED, true);
                 shape.attach(container);
             }
         };
@@ -72151,12 +72196,27 @@
             DApplications.update(this);
             return true;
         };
-        DTableBody.prototype.toRowIndexMapped = function (local) {
-            if (0 <= this.parent.position.y + local.y) {
-                return Math.floor(local.y / this._rowHeight);
+        /**
+         * Returns a mapped row index at the given local Y position or -1.
+         *
+         * @param localY a local Y position
+         * @returns a mapped row index at the given local Y position or -1.
+         */
+        DTableBody.prototype.toRowIndexMapped = function (localY) {
+            if (0 <= this.parent.position.y + localY) {
+                var result = Math.floor(localY / this._rowHeight);
+                if (0 <= result && result < this._data.mapped.size()) {
+                    return result;
+                }
             }
             return -1;
         };
+        /**
+         * Returns a row at the given mapped row index or null if not exits.
+         *
+         * @param rowIndexMapped a mapped row index
+         * @returns a row at the given mapped row index or null if not exists.
+         */
         DTableBody.prototype.toRow = function (rowIndexMapped) {
             var index = rowIndexMapped - this._rowIndexMappedStart;
             var rows = this.children;
@@ -72165,14 +72225,22 @@
             }
             return null;
         };
-        DTableBody.prototype.toCell = function (row, local) {
+        /**
+         * Returns a cell at the given local X position or null if not exits.
+         * This method assumes the given local X position is on the given row.
+         *
+         * @param row a row
+         * @param localX a local X position
+         * @returns a cell at the given local X position or null if not exits
+         */
+        DTableBody.prototype.toCell = function (row, localX) {
             var cells = row.children;
             var cellsLength = cells.length;
             var columns = this._columns;
             var columnsLength = columns.length;
             for (var i = 0, imax = Math.min(cellsLength, columnsLength); i < imax; ++i) {
                 var cell = cells[cellsLength - i - 1];
-                var x = local.x - cell.position.x;
+                var x = localX - cell.position.x;
                 if (0 <= x && x <= cell.width) {
                     return cell;
                 }
@@ -72184,12 +72252,12 @@
                 var local = DTableBody.WORK_ON_CLICK;
                 local.copyFrom(e.data.global);
                 this.toLocal(local, undefined, local, false);
-                var rowIndexMapped = this.toRowIndexMapped(local);
-                if (0 <= rowIndexMapped && rowIndexMapped < this._data.mapped.size()) {
+                var rowIndexMapped = this.toRowIndexMapped(local.y);
+                if (0 <= rowIndexMapped) {
                     // Delegate to the cell at first
                     var row = this.toRow(rowIndexMapped);
                     if (row) {
-                        var cell = this.toCell(row, local);
+                        var cell = this.toCell(row, local.x);
                         if (cell && cell.onRowSelect && cell.onRowSelect(e, local)) {
                             return;
                         }
@@ -76327,6 +76395,8 @@
         EShapeLineOfTriangles: EShapeLineOfTriangles,
         EShapeLinePoints: EShapeLinePoints,
         EShapeLine: EShapeLine,
+        EShapeLockPart: EShapeLockPart,
+        EShapeLock: EShapeLock,
         EShapeNull: EShapeNull,
         EShapePrimitive: EShapePrimitive,
         EShapeRectanglePivoted: EShapeRectanglePivoted,