@wcardinal/wcardinal-ui 0.412.0 → 0.413.0

package/dist/wcardinal-ui.js

@@ -1,5 +1,5 @@
 /*
- Winter Cardinal UI v0.412.0
+ Winter Cardinal UI v0.413.0
  Copyright (C) 2019 Toshiba Corporation
  SPDX-License-Identifier: Apache-2.0
 
@@ -66990,15 +66990,17 @@
         return DExpandable;
     }(DLayoutVertical));
 
-    var STATE_INITIAL = 0;
-    var STATE_STARTED = 1;
-    var STATE_RESOLVED = 2;
-    var STATE_REJECTED = 3;
+    var DIndicatorProcessingState = {
+        INITIAL: 0,
+        STARTED: 1,
+        RESOLVED: 2,
+        REJECTED: 3
+    };
     var DIndicatorProcessing = /** @class */ (function () {
         function DIndicatorProcessing(parent, options) {
             var _a, _b, _c, _d, _e, _f, _g;
             this._parent = parent;
-            this._state = STATE_INITIAL;
+            this._state = DIndicatorProcessingState.INITIAL;
             this._startTime = 0;
             // Delay
             var theme = this.theme;
@@ -67021,12 +67023,13 @@
         }
         DIndicatorProcessing.prototype.start = function () {
             var state = this._state;
-            if (state === STATE_INITIAL) {
-                this._state = STATE_STARTED;
+            if (state === DIndicatorProcessingState.INITIAL) {
+                this._state = DIndicatorProcessingState.STARTED;
                 this.onBegin();
             }
-            else if (state === STATE_RESOLVED || state === STATE_REJECTED) {
-                this._state = STATE_STARTED;
+            else if (state === DIndicatorProcessingState.RESOLVED ||
+                state === DIndicatorProcessingState.REJECTED) {
+                this._state = DIndicatorProcessingState.STARTED;
                 this.onEnd();
                 this.onBegin();
             }
@@ -67077,8 +67080,10 @@
         };
         DIndicatorProcessing.prototype.end = function () {
             var state = this._state;
-            if (state === STATE_STARTED || state === STATE_RESOLVED || state === STATE_REJECTED) {
-                this._state = STATE_INITIAL;
+            if (state === DIndicatorProcessingState.STARTED ||
+                state === DIndicatorProcessingState.RESOLVED ||
+                state === DIndicatorProcessingState.REJECTED) {
+                this._state = DIndicatorProcessingState.INITIAL;
                 this.onEnd();
             }
             return this;
@@ -67114,8 +67119,8 @@
         };
         DIndicatorProcessing.prototype.resolve = function (message) {
             var _this = this;
-            if (this._state === STATE_STARTED) {
-                this._state = STATE_RESOLVED;
+            if (this._state === DIndicatorProcessingState.STARTED) {
+                this._state = DIndicatorProcessingState.RESOLVED;
                 var elapsedTime = Date.now() - this._startTime;
                 var delay = this._delayDone - elapsedTime;
                 if (0 < delay) {
@@ -67147,8 +67152,8 @@
         };
         DIndicatorProcessing.prototype.reject = function (message) {
             var _this = this;
-            if (this._state === STATE_STARTED) {
-                this._state = STATE_REJECTED;
+            if (this._state === DIndicatorProcessingState.STARTED) {
+                this._state = DIndicatorProcessingState.REJECTED;
                 var elapsedTime = Date.now() - this._startTime;
                 var delay = this._delayDone - elapsedTime;
                 if (0 < delay) {
@@ -68766,7 +68771,7 @@
         };
         /**
          * Goes to the last page.
-         * Unlike {@link #value}, this method emits the change event if silently is not true.
+         * Unlike {@link value}, this method emits the change event if silently is not true.
          *
          * @param silently true to suppress the change event
          * @returns true if succeeded.
@@ -68776,7 +68781,7 @@
         };
         /**
          * Goes to the given page.
-         * Unlike {@link #value}, this method emits the change event if silently is not true.
+         * Unlike {@link value}, this method emits the change event if silently is not true.
          *
          * @param index a page index
          * @param silently true to suppress the change event
@@ -68825,7 +68830,7 @@
         };
         /**
          * Goes to the next page.
-         * Unlike {@link #value}, this method emits the change event if silently is not true.
+         * Unlike {@link value}, this method emits the change event if silently is not true.
          *
          * @param silently true to suppress the change event
          * @returns true if succeeded.
@@ -68863,7 +68868,7 @@
         };
         /**
          * Goes to the previous page.
-         * Unlike {@link #value}, this method emits the change event if silently is not true.
+         * Unlike {@link value}, this method emits the change event if silently is not true.
          *
          * @param silently true to suppress the change event
          * @returns true if succeeded.
@@ -68901,7 +68906,7 @@
         };
         /**
          * Goes to the top page.
-         * Unlike {@link #value}, this method emits the change event if silently is not true.
+         * Unlike {@link value}, this method emits the change event if silently is not true.
          *
          * @param silently true to suppress the change event
          * @returns true if succeeded.
@@ -74216,6 +74221,224 @@
         return DTableCategoryCell;
     }(DImage));
 
+    /*
+     * Copyright (C) 2019 Toshiba Corporation
+     * SPDX-License-Identifier: Apache-2.0
+     */
+    var DTableCategoryColumnImpl = /** @class */ (function (_super) {
+        __extends(DTableCategoryColumnImpl, _super);
+        function DTableCategoryColumnImpl(index, column) {
+            var _this = _super.call(this) || this;
+            // Label
+            var category = column.category;
+            if (category) {
+                if (isString(category)) {
+                    if (index === 0) {
+                        _this.label = category;
+                    }
+                }
+                else {
+                    if (index < category.length) {
+                        _this.label = category[index];
+                    }
+                }
+            }
+            _this._weight = column.weight;
+            _this._width = column.width;
+            _this._isLocked = false;
+            _this.offset = 0.0;
+            _this._columns = [column];
+            _this._nresizable = column.resizable ? 1 : 0;
+            var onResizeBound = function () {
+                _this.onResize();
+            };
+            _this._onResizeBound = onResizeBound;
+            column.on("resize", onResizeBound);
+            return _this;
+        }
+        DTableCategoryColumnImpl.prototype.onResize = function () {
+            if (this._isLocked) {
+                return;
+            }
+            var columns = this._columns;
+            if (this._weight != null) {
+                var newWeight = 0;
+                for (var i = 0, imax = columns.length; i < imax; ++i) {
+                    var weight = columns[i].weight;
+                    if (weight != null) {
+                        newWeight += weight;
+                    }
+                }
+                if (this._weight !== newWeight) {
+                    this._weight = newWeight;
+                    this.emit("resize", this);
+                }
+            }
+            else {
+                var newWidth = 0;
+                for (var i = 0, imax = columns.length; i < imax; ++i) {
+                    var width = columns[i].width;
+                    if (width != null) {
+                        newWidth += width;
+                    }
+                }
+                if (this._width !== newWidth) {
+                    this._width = newWidth;
+                    this.emit("resize", this);
+                }
+            }
+        };
+        Object.defineProperty(DTableCategoryColumnImpl.prototype, "resizable", {
+            get: function () {
+                return 0 < this._nresizable;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(DTableCategoryColumnImpl.prototype, "weight", {
+            get: function () {
+                return this._weight;
+            },
+            set: function (weight) {
+                var oldWeight = this._weight;
+                var nresizable = this._nresizable;
+                if (0 < nresizable && oldWeight != null && oldWeight !== weight) {
+                    var columns = this._columns;
+                    var columnsLength = columns.length;
+                    var minWeight = this.minWeight;
+                    var newWeight = Math.max(minWeight, weight);
+                    if (this._weight !== newWeight) {
+                        this._isLocked = true;
+                        if (minWeight < oldWeight) {
+                            var columnWeightRatio = (newWeight - minWeight) / (oldWeight - minWeight);
+                            for (var i = 0; i < columnsLength; ++i) {
+                                var column = columns[i];
+                                var columnWeight = column.weight;
+                                if (column.resizable && columnWeight != null) {
+                                    column.weight = columnWeight * columnWeightRatio;
+                                }
+                            }
+                        }
+                        else {
+                            var newColumnWeight = (newWeight - minWeight) / this._nresizable;
+                            for (var i = 0; i < columnsLength; ++i) {
+                                var column = columns[i];
+                                var columnWeight = column.weight;
+                                if (column.resizable && columnWeight != null) {
+                                    column.weight = newColumnWeight;
+                                }
+                            }
+                        }
+                        this._isLocked = false;
+                        this.onResize();
+                    }
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(DTableCategoryColumnImpl.prototype, "minWeight", {
+            get: function () {
+                var result = 0;
+                var columns = this._columns;
+                var columnsLength = columns.length;
+                for (var i = 0; i < columnsLength; ++i) {
+                    var column = columns[i];
+                    var columnWeight = column.weight;
+                    if (!column.resizable && columnWeight != null) {
+                        result += columnWeight;
+                    }
+                }
+                return result;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(DTableCategoryColumnImpl.prototype, "width", {
+            get: function () {
+                return this._width;
+            },
+            set: function (width) {
+                var oldWidth = this._width;
+                var nresizable = this._nresizable;
+                if (0 < nresizable && oldWidth != null && oldWidth !== width) {
+                    var columns = this._columns;
+                    var columnsLength = columns.length;
+                    var minWidth = this.minWidth;
+                    var newWidth = Math.max(minWidth, width);
+                    if (oldWidth !== newWidth) {
+                        this._isLocked = true;
+                        if (minWidth < oldWidth) {
+                            var columnWidthRatio = (newWidth - minWidth) / (oldWidth - minWidth);
+                            for (var i = 0; i < columnsLength; ++i) {
+                                var column = columns[i];
+                                var columnWidth = column.width;
+                                if (column.resizable && columnWidth != null) {
+                                    column.width = columnWidth * columnWidthRatio;
+                                }
+                            }
+                        }
+                        else {
+                            var newColumnWidth = (newWidth - minWidth) / this._nresizable;
+                            for (var i = 0; i < columnsLength; ++i) {
+                                var column = columns[i];
+                                var columnWidth = column.width;
+                                if (column.resizable && columnWidth != null) {
+                                    column.width = newColumnWidth;
+                                }
+                            }
+                        }
+                        this._isLocked = false;
+                        this.onResize();
+                    }
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(DTableCategoryColumnImpl.prototype, "minWidth", {
+            get: function () {
+                var result = 0;
+                var columns = this._columns;
+                var columnsLength = columns.length;
+                for (var i = 0; i < columnsLength; ++i) {
+                    var column = columns[i];
+                    var columnWidth = column.width;
+                    if (!column.resizable && columnWidth != null) {
+                        result += columnWidth;
+                    }
+                }
+                return result;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DTableCategoryColumnImpl.prototype.add = function (column) {
+            this._columns.push(column);
+            if (this._weight != null) {
+                var weight = column.weight;
+                if (weight != null) {
+                    this._weight += weight;
+                    if (column.resizable) {
+                        this._nresizable += 1;
+                    }
+                    column.on("resize", this._onResizeBound);
+                }
+            }
+            else if (this._width != null) {
+                var width = column.width;
+                if (width != null) {
+                    this._width += width;
+                    if (column.resizable) {
+                        this._nresizable += 1;
+                    }
+                    column.on("resize", this._onResizeBound);
+                }
+            }
+        };
+        return DTableCategoryColumnImpl;
+    }(pixi_js.utils.EventEmitter));
+
     /*
      * Copyright (C) 2019 Toshiba Corporation
      * SPDX-License-Identifier: Apache-2.0
@@ -74314,403 +74537,1034 @@
         return DTableCategory;
     }(DTableRow));
 
-    /*
-     * Copyright (C) 2019 Toshiba Corporation
-     * SPDX-License-Identifier: Apache-2.0
-     */
-    var DTableDataTreeFilter = /** @class */ (function (_super) {
-        __extends(DTableDataTreeFilter, _super);
-        function DTableDataTreeFilter(parent) {
-            var _this = _super.call(this) || this;
-            _this._id = 0;
-            _this._idUpdated = -1;
-            _this._isApplied = false;
-            _this._parent = parent;
-            _this._filter = null;
-            _this._filtered = null;
-            return _this;
-        }
-        Object.defineProperty(DTableDataTreeFilter.prototype, "id", {
-            get: function () {
-                return this._id;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        DTableDataTreeFilter.prototype.apply = function () {
-            this._isApplied = true;
-            this._id += 1;
-            this._parent.update();
-        };
-        DTableDataTreeFilter.prototype.unapply = function () {
-            if (this._isApplied) {
-                this._isApplied = false;
-                this._id += 1;
-                this._parent.update();
-            }
-        };
-        DTableDataTreeFilter.prototype.isApplied = function () {
-            return this._isApplied;
-        };
-        DTableDataTreeFilter.prototype.isFiltered = function (node, index, filter) {
-            if (isFunction(filter)) {
-                return filter(node, index);
-            }
-            else {
-                return filter.test(node, index);
-            }
-        };
-        DTableDataTreeFilter.prototype.hasFiltered = function (parent, nodes, filter) {
-            var accessor = this._parent.accessor;
-            var toChildren = accessor.toChildren;
-            var hasChildren = accessor.hasChildren;
-            for (var i = 0, imax = nodes.length; i < imax; ++i) {
-                var node = nodes[i];
-                if (this.isFiltered(node, -1, filter)) {
-                    return true;
-                }
-                var children = toChildren(node);
-                if (hasChildren(node, children) && this.hasFiltered(parent, children, filter)) {
-                    return true;
-                }
+    var DTableCategoryContainerImpl = /** @class */ (function () {
+        function DTableCategoryContainerImpl(columns, frozen, options) {
+            var count = this.toCount(columns);
+            var items = [];
+            var offset = 0;
+            for (var i = count - 1; 0 <= i; --i) {
+                var item = new DTableCategory(this.toColumns(i, columns, frozen), frozen, offset, options);
+                items.push(item);
+                offset += item.height;
             }
-            return false;
-        };
-        DTableDataTreeFilter.prototype.addAllToFiltered = function (parent, nodes, filtered, cursor) {
-            var accessor = this._parent.accessor;
-            var toChildren = accessor.toChildren;
-            var hasChildren = accessor.hasChildren;
-            for (var i = 0, imax = nodes.length; i < imax; ++i) {
-                var node = nodes[i];
-                filtered.push(cursor[0]);
-                cursor[0] += 1;
-                var children = toChildren(node);
-                if (hasChildren(node, children) && parent.isOpened(node)) {
-                    this.addAllToFiltered(parent, children, filtered, cursor);
+            this.items = items;
+        }
+        DTableCategoryContainerImpl.prototype.toCount = function (columns) {
+            var result = 0;
+            for (var i = 0, imax = columns.length; i < imax; ++i) {
+                var category = columns[i].category;
+                if (category != null) {
+                    var count = isString(category) ? 1 : category.length;
+                    result = Math.max(result, count);
                 }
             }
+            return result;
         };
-        DTableDataTreeFilter.prototype.newFilteredSub = function (parent, nodes, filter, filtered, cursor) {
-            var result = false;
-            var accessor = this._parent.accessor;
-            var toChildren = accessor.toChildren;
-            var hasChildren = accessor.hasChildren;
-            for (var i = 0, imax = nodes.length; i < imax; ++i) {
-                var node = nodes[i];
-                var index = cursor[0];
-                cursor[0] += 1;
-                var isFiltered = this.isFiltered(node, index, filter);
-                var children = toChildren(node);
-                if (hasChildren(node, children)) {
-                    if (parent.isOpened(node)) {
-                        if (isFiltered) {
-                            filtered.push(index);
-                            result = true;
-                            this.addAllToFiltered(parent, children, filtered, cursor);
+        DTableCategoryContainerImpl.prototype.isCategory = function (index, a, b) {
+            if (a != null) {
+                if (b != null) {
+                    if (isString(a)) {
+                        if (isString(b)) {
+                            if (0 < index) {
+                                return true;
+                            }
+                            else {
+                                return a === b;
+                            }
                         }
                         else {
-                            var position = filtered.length;
-                            if (this.newFilteredSub(parent, children, filter, filtered, cursor)) {
-                                filtered.splice(position, 0, index);
-                                result = true;
+                            if (0 < index) {
+                                return b.length <= index;
+                            }
+                            else {
+                                return b.length === 1 && a === b[0];
                             }
                         }
                     }
-                    else if (isFiltered || this.hasFiltered(parent, children, filter)) {
-                        filtered.push(index);
-                        result = true;
+                    else {
+                        if (isString(b)) {
+                            if (0 < index) {
+                                return a.length <= index;
+                            }
+                            else {
+                                return a.length === 1 && a[0] === b;
+                            }
+                        }
+                        else {
+                            if (a.length <= index && b.length <= index) {
+                                return true;
+                            }
+                            else if (b.length === a.length) {
+                                for (var i = index, imax = a.length; i < imax; ++i) {
+                                    if (a[i] !== b[i]) {
+                                        return false;
+                                    }
+                                }
+                                return true;
+                            }
+                            return false;
+                        }
                     }
                 }
-                else if (isFiltered) {
-                    filtered.push(index);
-                    result = true;
-                }
-            }
-            return result;
-        };
-        DTableDataTreeFilter.prototype.newFiltered = function () {
-            var filter = this._filter;
-            if (filter != null) {
-                var filtered = [];
-                var parent_1 = this._parent;
-                var nodes = parent_1.nodes;
-                if (nodes) {
-                    var cursor = [0];
-                    this.newFilteredSub(parent_1, nodes, filter, filtered, cursor);
+                else {
+                    if (isString(a)) {
+                        if (0 < index) {
+                            return true;
+                        }
+                        else {
+                            return false;
+                        }
+                    }
+                    else {
+                        if (a.length <= index) {
+                            return true;
+                        }
+                        else {
+                            return false;
+                        }
+                    }
                 }
-                return filtered;
-            }
-            return null;
-        };
-        DTableDataTreeFilter.prototype.get = function () {
-            return this._filter;
-        };
-        DTableDataTreeFilter.prototype.set = function (filter) {
-            if (this._filter !== filter) {
-                this._filter = filter;
             }
-        };
-        DTableDataTreeFilter.prototype.toDirty = function () {
-            this._id += 1;
-        };
-        DTableDataTreeFilter.prototype.update = function () {
-            if (this._id !== this._idUpdated) {
-                this._idUpdated = this._id;
-                if (this._isApplied) {
-                    this._filtered = this.newFiltered();
-                    this.emit("change", this);
+            else {
+                if (b != null) {
+                    if (isString(b)) {
+                        if (0 < index) {
+                            return true;
+                        }
+                        else {
+                            return false;
+                        }
+                    }
+                    else {
+                        if (b.length <= index) {
+                            return true;
+                        }
+                        else {
+                            return false;
+                        }
+                    }
                 }
-                else if (this._filtered != null) {
-                    this._filtered = null;
-                    this.emit("change", this);
+                else {
+                    return true;
                 }
             }
         };
-        Object.defineProperty(DTableDataTreeFilter.prototype, "indices", {
-            get: function () {
-                this.update();
-                return this._filtered;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        DTableDataTreeFilter.prototype.map = function (sortedIndex) {
-            var result = sortedIndex;
-            var indices = this.indices;
-            if (indices) {
-                var index = indices.indexOf(result);
-                if (0 <= index) {
-                    result = index;
+        DTableCategoryContainerImpl.prototype.toColumns = function (index, columns, frozen) {
+            var result = [];
+            var tcolumn = null;
+            var ccolumn = null;
+            for (var i = 0, imax = columns.length; i < imax; ++i) {
+                var column = columns[i];
+                if (i !== frozen &&
+                    ccolumn &&
+                    tcolumn &&
+                    this.isCategory(index, tcolumn.category, column.category)) {
+                    if (ccolumn.weight != null && column.weight != null) {
+                        ccolumn.add(column);
+                    }
+                    else if (ccolumn.width != null && column.width != null) {
+                        ccolumn.add(column);
+                    }
+                    else {
+                        tcolumn = column;
+                        ccolumn = new DTableCategoryColumnImpl(index, column);
+                        result.push(ccolumn);
+                    }
                 }
                 else {
-                    return null;
+                    tcolumn = column;
+                    ccolumn = new DTableCategoryColumnImpl(index, column);
+                    result.push(ccolumn);
                 }
             }
             return result;
         };
-        DTableDataTreeFilter.prototype.unmap = function (index) {
-            var result = index;
-            var indices = this.indices;
-            if (indices) {
-                result = indices[result];
-            }
-            return result;
-        };
-        return DTableDataTreeFilter;
-    }(pixi_js.utils.EventEmitter));
+        return DTableCategoryContainerImpl;
+    }());
 
-    /*
-     * Copyright (C) 2021 Toshiba Corporation
-     * SPDX-License-Identifier: Apache-2.0
-     */
-    var toParent = function (node) {
-        return node.parent;
-    };
-    var toChildren$1 = function (node) {
-        return node.children;
+    var defaultGetter = function (row, columnIndex) {
+        return row[columnIndex];
     };
-    var hasChildren = function (node, children) {
-        return children != null && 0 < children.length;
+    var defaultSetter = function (row, columnIndex, cell) {
+        row[columnIndex] = cell;
     };
-    var DTableDataTreeItemAccessor = /** @class */ (function () {
-        function DTableDataTreeItemAccessor(options) {
-            if (options != null) {
-                this.toParent = options.toParent || toParent;
-                this.toChildren = options.toChildren || toChildren$1;
-                this.hasChildren = options.hasChildren || hasChildren;
+    var defaultGetterEmpty = function () { return ""; };
+    var defaultSetterEmpty = function () {
+        // DO NOTHING
+    };
+    var toPathGetter = function (path, def) {
+        if (path.length <= 1) {
+            var key_1 = path[0];
+            if (def === undefined) {
+                return function (row) {
+                    return row[key_1];
+                };
             }
             else {
-                this.toParent = toParent;
-                this.toChildren = toChildren$1;
-                this.hasChildren = hasChildren;
+                return function (row) {
+                    return Object.prototype.hasOwnProperty.call(row, key_1) ? row[key_1] : def;
+                };
             }
         }
-        return DTableDataTreeItemAccessor;
-    }());
-
-    /*
-     * Copyright (C) 2021 Toshiba Corporation
-     * SPDX-License-Identifier: Apache-2.0
-     */
-    var COMPARATOR = function (a, b) {
-        return a[0] - b[0];
-    };
-    var DTableDataTreeSelectionImpl = /** @class */ (function (_super) {
-        __extends(DTableDataTreeSelectionImpl, _super);
-        function DTableDataTreeSelectionImpl(parent, options) {
-            var _a;
-            var _this = _super.call(this) || this;
-            _this._parent = parent;
-            _this._type = toEnum((_a = options === null || options === void 0 ? void 0 : options.type) !== null && _a !== void 0 ? _a : DTableDataSelectionType.NONE, DTableDataSelectionType);
-            _this._rows = new Set();
-            // Events
-            var on = options === null || options === void 0 ? void 0 : options.on;
-            if (on) {
-                for (var name_1 in on) {
-                    var handler = on[name_1];
-                    if (handler) {
-                        _this.on(name_1, handler);
+        else {
+            if (def === undefined) {
+                return function (row) {
+                    for (var i = 0, imax = path.length - 1; i < imax; ++i) {
+                        row = row[path[i]];
                     }
-                }
+                    return row[path[path.length - 1]];
+                };
+            }
+            else {
+                return function (row) {
+                    for (var i = 0, imax = path.length - 1; i < imax; ++i) {
+                        row = row[path[i]];
+                    }
+                    var key = path[path.length - 1];
+                    return Object.prototype.hasOwnProperty.call(row, key) ? row[key] : def;
+                };
             }
-            return _this;
         }
-        Object.defineProperty(DTableDataTreeSelectionImpl.prototype, "parent", {
-            get: function () {
-                return this._parent;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        DTableDataTreeSelectionImpl.prototype.onNodeChange = function (nodes) {
-            if (nodes != null) {
-                var accessor = this._parent.accessor;
-                var toChildren = accessor.toChildren;
-                var hasChildren = accessor.hasChildren;
-                var oldRows = this._rows;
-                var newRows = this.newRows(nodes, toChildren, hasChildren, oldRows, new Set());
-                if (oldRows.size !== newRows.size) {
-                    this._rows = newRows;
-                    this.onChange();
+    };
+    var toPathSetter = function (path) {
+        if (path.length <= 1) {
+            var key_2 = path[0];
+            return function (row, columnIndex, cell) {
+                row[key_2] = cell;
+            };
+        }
+        else {
+            return function (row, columnIndex, cell) {
+                for (var i = 0, imax = path.length - 1; i < imax; ++i) {
+                    row = row[path[i]] || {};
                 }
+                row[path[path.length - 1]] = cell;
+            };
+        }
+    };
+    var toAlign = function (options, type) {
+        var align = options.align;
+        if (align != null) {
+            if (isString(align)) {
+                return DAlignHorizontal[align];
             }
             else {
-                var rows = this._rows;
-                if (0 < rows.size) {
-                    rows.clear();
-                    this.onChange();
-                }
+                return align;
             }
-        };
-        DTableDataTreeSelectionImpl.prototype.newRows = function (nodes, toChildren, hasChildren, rows, result) {
-            for (var i = 0, imax = nodes.length; i < imax; ++i) {
-                var node = nodes[i];
-                if (rows.has(node)) {
-                    result.add(node);
-                }
-                var children = toChildren(node);
-                if (hasChildren(node, children)) {
-                    this.newRows(children, toChildren, hasChildren, rows, result);
-                }
+        }
+        switch (type) {
+            case DTableColumnType.TEXT:
+            case DTableColumnType.TEXT_AREA:
+                return DAlignHorizontal.LEFT;
+            case DTableColumnType.REAL:
+            case DTableColumnType.INTEGER:
+                return DAlignHorizontal.RIGHT;
+            case DTableColumnType.BUTTON:
+            case DTableColumnType.INDEX:
+            case DTableColumnType.SELECT:
+            case DTableColumnType.ACTION:
+            case DTableColumnType.LINK:
+            case DTableColumnType.CHECK:
+            case DTableColumnType.CHECK_SINGLE:
+            case DTableColumnType.COLOR:
+                return DAlignHorizontal.CENTER;
+            default:
+                return DAlignHorizontal.LEFT;
+        }
+    };
+    var toDataChecker = function (path) {
+        if (path != null) {
+            var pathLength_1 = path.length;
+            if (pathLength_1 <= 1) {
+                var key_3 = path[0];
+                return function (row) {
+                    return Object.prototype.hasOwnProperty.call(row, key_3);
+                };
             }
-            return result;
-        };
-        Object.defineProperty(DTableDataTreeSelectionImpl.prototype, "indices", {
-            get: function () {
-                var rows = this._rows;
-                var result = [];
-                this._parent.each(function (row, index) {
-                    if (rows.has(row)) {
-                        result.push(index);
-                    }
-                });
-                return result;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(DTableDataTreeSelectionImpl.prototype, "rows", {
-            get: function () {
-                var result = [];
-                this._rows.forEach(function (row) {
-                    result.push(row);
-                });
-                return result;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(DTableDataTreeSelectionImpl.prototype, "type", {
-            get: function () {
-                return this._type;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        DTableDataTreeSelectionImpl.prototype.getFirst = function () {
-            var rows = this._rows;
-            if (0 < rows.size) {
-                var result_1 = null;
-                rows.forEach(function (row) {
-                    if (result_1 == null) {
-                        result_1 = row;
+            else {
+                return function (row) {
+                    for (var i = 0; i < pathLength_1; ++i) {
+                        var part = path[i];
+                        if (part in row) {
+                            row = row[part];
+                        }
+                        else {
+                            return false;
+                        }
                     }
-                });
-                return result_1;
+                    return true;
+                };
             }
-            return null;
+        }
+        return function (row, columnIndex) {
+            return columnIndex < row.length;
         };
-        DTableDataTreeSelectionImpl.prototype.getLast = function () {
-            var rows = this._rows;
-            if (0 < rows.size) {
-                var result_2 = null;
-                rows.forEach(function (row) {
-                    result_2 = row;
-                });
-                return result_2;
+    };
+    var toEditingEnable = function (enable, path) {
+        if (isString(enable)) {
+            return toDataChecker(path);
+        }
+        else if (enable != null) {
+            return enable;
+        }
+        else {
+            return false;
+        }
+    };
+    var toEditing = function (options, path) {
+        var _a;
+        var editing = options.editing;
+        var editable = options.editable;
+        if (editing) {
+            return {
+                enable: toEditingEnable((_a = editing.enable) !== null && _a !== void 0 ? _a : editable, path),
+                formatter: editing.formatter,
+                unformatter: editing.unformatter,
+                validator: editing.validator
+            };
+        }
+        return {
+            enable: toEditingEnable(editable, path)
+        };
+    };
+    var toComparator = function (getter, index) {
+        return function (rowA, rowB) {
+            var valueA = getter(rowA, index);
+            var valueB = getter(rowB, index);
+            return valueA < valueB ? -1 : valueB < valueA ? +1 : 0;
+        };
+    };
+    var toSorting = function (getter, index, options) {
+        var sorting = options.sorting;
+        var sortable = options.sortable;
+        if (sorting) {
+            if (sorting.enable || sortable) {
+                return {
+                    enable: true,
+                    comparator: sorting.comparator || toComparator(getter, index)
+                };
             }
-            return null;
+            return {
+                enable: false
+            };
+        }
+        if (sortable) {
+            return {
+                enable: true,
+                comparator: toComparator(getter, index)
+            };
+        }
+        return {
+            enable: false
         };
-        DTableDataTreeSelectionImpl.prototype.toIndex = function (target) {
-            var result = null;
-            this._parent.each(function (row, index) {
-                if (target === row) {
-                    result = index;
-                    return false;
+    };
+    var toMenu = function (options) {
+        if (options == null) {
+            return undefined;
+        }
+        else if (options instanceof DMenu) {
+            return options;
+        }
+        else {
+            return new DMenu(options);
+        }
+    };
+    var toDialog = function (options) {
+        if (options == null) {
+            return undefined;
+        }
+        else if ("open" in options) {
+            return options;
+        }
+        else {
+            return new DDialogSelect(options);
+        }
+    };
+    var defaultSelectingGetter = function (dialog) {
+        return dialog.value;
+    };
+    var defaultSelectingSetter = function () {
+        // DO NOTHING
+    };
+    var toSelecting = function (options) {
+        if (options) {
+            return {
+                getter: options.getter || defaultSelectingGetter,
+                setter: options.setter || defaultSelectingSetter,
+                menu: toMenu(options.menu),
+                multiple: toMenu(options.multiple),
+                dialog: toDialog(options.dialog),
+                promise: options.promise
+            };
+        }
+        return {
+            getter: defaultSelectingGetter,
+            setter: defaultSelectingSetter
+        };
+    };
+    var toGetter = function (options, type, parts) {
+        var getter = options.getter;
+        if (getter) {
+            return getter;
+        }
+        switch (type) {
+            case DTableColumnType.ACTION:
+            case DTableColumnType.LINK:
+                return defaultGetterEmpty;
+            default:
+                if (parts == null) {
+                    return defaultGetter;
                 }
-                return true;
-            });
-            return result;
+                else {
+                    return toPathGetter(parts, options.default);
+                }
+        }
+    };
+    var toSetter = function (options, type, path) {
+        var setter = options.setter;
+        if (setter) {
+            return setter;
+        }
+        switch (type) {
+            case DTableColumnType.BUTTON:
+            case DTableColumnType.ACTION:
+            case DTableColumnType.LINK:
+                return defaultSetterEmpty;
+            default:
+                if (path == null) {
+                    return defaultSetter;
+                }
+                else {
+                    return toPathSetter(path);
+                }
+        }
+    };
+    var toState = function (options) {
+        var state = options.state;
+        if (state != null) {
+            if (isString(state) || isArray(state)) {
+                return {
+                    initial: state,
+                    modifier: undefined
+                };
+            }
+            else {
+                return {
+                    initial: undefined,
+                    modifier: state
+                };
+            }
+        }
+        return {
+            initial: undefined,
+            modifier: undefined
         };
-        Object.defineProperty(DTableDataTreeSelectionImpl.prototype, "first", {
+    };
+    var toPath = function (options) {
+        return options.path != null ? options.path.split(".") : null;
+    };
+    var toRenderable = function (options, path) {
+        var renderable = options.renderable;
+        if (isString(renderable)) {
+            return toDataChecker(path);
+        }
+        else if (renderable != null) {
+            return renderable;
+        }
+        return true;
+    };
+    var DTableColumnImpl = /** @class */ (function (_super) {
+        __extends(DTableColumnImpl, _super);
+        function DTableColumnImpl(index, options) {
+            var _a, _b, _c;
+            var _this = _super.call(this) || this;
+            var weight = options.weight;
+            var width = options.width;
+            if (weight != null) {
+                if (width != null) {
+                    width = undefined;
+                }
+            }
+            else if (width == null) {
+                weight = 1;
+            }
+            var type = toEnum((_a = options.type) !== null && _a !== void 0 ? _a : DTableColumnType.TEXT, DTableColumnType);
+            var align = toAlign(options, type);
+            var label = options.label || "";
+            var path = toPath(options);
+            var getter = toGetter(options, type, path);
+            var setter = toSetter(options, type, path);
+            _this._weight = weight;
+            _this._width = width;
+            _this.resizable = (_b = options.resizable) !== null && _b !== void 0 ? _b : false;
+            _this.type = type;
+            _this.label = label;
+            _this.getter = getter;
+            _this.setter = setter;
+            _this.formatter = options.formatter;
+            _this.renderable = toRenderable(options, path);
+            _this.align = align;
+            _this.state = toState(options);
+            _this.editing = toEditing(options, path);
+            _this.sorting = toSorting(getter, index, options);
+            _this.header = options.header;
+            _this.body = options.body;
+            _this.selecting = toSelecting(options.selecting);
+            _this.category = options.category;
+            _this.frozen = options.frozen;
+            _this.offset = 0.0;
+            _this.link = options.link;
+            _this.update = toEnum((_c = options.update) !== null && _c !== void 0 ? _c : DTableColumnUpdate.CELL, DTableColumnUpdate);
+            return _this;
+        }
+        Object.defineProperty(DTableColumnImpl.prototype, "weight", {
             get: function () {
-                var row = this.getFirst();
-                if (row) {
-                    return this.toIndex(row);
+                return this._weight;
+            },
+            set: function (weight) {
+                if (this._weight != null && this._weight !== weight) {
+                    this._weight = weight;
+                    this.emit("resize", this);
                 }
-                return null;
             },
             enumerable: false,
             configurable: true
         });
-        Object.defineProperty(DTableDataTreeSelectionImpl.prototype, "last", {
+        Object.defineProperty(DTableColumnImpl.prototype, "width", {
             get: function () {
-                var row = this.getLast();
-                if (row) {
-                    return this.toIndex(row);
+                return this._width;
+            },
+            set: function (width) {
+                if (this._width != null && this._width !== width) {
+                    this._width = width;
+                    this.emit("resize", this);
                 }
-                return null;
             },
             enumerable: false,
             configurable: true
         });
-        DTableDataTreeSelectionImpl.prototype.onChange = function () {
-            this._parent.update();
-            this.emit("change", this);
-        };
-        DTableDataTreeSelectionImpl.prototype.toggle = function (rowIndex) {
-            var row = this._parent.get(rowIndex);
-            if (row) {
-                var rows = this._rows;
-                if (rows.has(row)) {
-                    rows.delete(row);
-                }
-                else {
-                    rows.add(row);
+        return DTableColumnImpl;
+    }(pixi_js.utils.EventEmitter));
+
+    var DTableColumnContainerImpl = /** @class */ (function (_super) {
+        __extends(DTableColumnContainerImpl, _super);
+        function DTableColumnContainerImpl(parent, options) {
+            var _this = _super.call(this) || this;
+            _this.parent = parent;
+            var columns = [];
+            if (options != null) {
+                for (var i = 0, imax = options.length; i < imax; ++i) {
+                    var column = new DTableColumnImpl(i, options[i]);
+                    columns.push(column);
+                    column.on("resize", _this.newOnColumnResize(i, column));
                 }
-                this.onChange();
             }
-        };
-        DTableDataTreeSelectionImpl.prototype.add = function (rowIndex) {
-            var row = this._parent.get(rowIndex);
-            if (row) {
-                var rows = this._rows;
-                if (!rows.has(row)) {
-                    rows.add(row);
-                    this.onChange();
+            _this.items = columns;
+            var frozen = 0;
+            for (var i = columns.length - 1; 0 <= i; --i) {
+                if (columns[i].frozen === true) {
+                    frozen = i + 1;
+                    break;
                 }
             }
-        };
+            _this.frozen = frozen;
+            return _this;
+        }
+        DTableColumnContainerImpl.prototype.newOnColumnResize = function (index, column) {
+            var _this = this;
+            return function () {
+                _this.onColumnResize(index, column);
+            };
+        };
+        DTableColumnContainerImpl.prototype.onColumnResize = function (index, column) {
+            this.onColumnResizeHeader(index, column);
+            this.onColumnResizeBody(index, column);
+            this.emit("resize", index, column, this);
+        };
+        DTableColumnContainerImpl.prototype.onColumnResizeHeader = function (index, column) {
+            var header = this.parent.header;
+            if (header != null) {
+                var columnWeight = column.weight;
+                if (columnWeight != null) {
+                    this.onColumnResizeWeight(header, index, columnWeight);
+                }
+                else {
+                    var columnWidth = column.width;
+                    if (columnWidth != null) {
+                        this.onColumnResizeWidth(header, index, columnWidth);
+                    }
+                }
+            }
+        };
+        DTableColumnContainerImpl.prototype.onColumnResizeBody = function (index, column) {
+            var rows = this.parent.body.children;
+            var columnWeight = column.weight;
+            if (columnWeight != null) {
+                for (var i = 0, imax = rows.length; i < imax; ++i) {
+                    this.onColumnResizeWeight(rows[i], index, columnWeight);
+                }
+            }
+            else {
+                var columnWidth = column.width;
+                if (columnWidth != null) {
+                    for (var i = 0, imax = rows.length; i < imax; ++i) {
+                        this.onColumnResizeWidth(rows[i], index, columnWidth);
+                    }
+                }
+            }
+        };
+        DTableColumnContainerImpl.prototype.onColumnResizeWeight = function (row, index, columnWeight) {
+            var cells = row.children;
+            var cellsLength = cells.length;
+            var cellsIndex = cellsLength - index - 1;
+            if (0 <= cellsIndex && cellsIndex < cellsLength) {
+                cells[cellsIndex].weight = columnWeight;
+            }
+        };
+        DTableColumnContainerImpl.prototype.onColumnResizeWidth = function (row, index, columnWidth) {
+            var cells = row.children;
+            var cellsLength = cells.length;
+            var cellsIndex = cellsLength - index - 1;
+            if (0 <= cellsIndex && cellsIndex < cellsLength) {
+                cells[cellsIndex].width = columnWidth;
+            }
+        };
+        Object.defineProperty(DTableColumnContainerImpl.prototype, "width", {
+            get: function () {
+                var result = 0;
+                var items = this.items;
+                var length = items.length;
+                for (var i = 0; i < length; ++i) {
+                    var item = items[i];
+                    var itemWidth = item.width;
+                    if (itemWidth != null) {
+                        result += itemWidth;
+                    }
+                }
+                return result;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DTableColumnContainerImpl.prototype.get = function (index) {
+            var columns = this.items;
+            if (0 <= index && index < columns.length) {
+                return columns[index];
+            }
+            return null;
+        };
+        DTableColumnContainerImpl.prototype.each = function (iteratee) {
+            var columns = this.items;
+            for (var i = 0, imax = columns.length; i < imax; ++i) {
+                if (iteratee(columns[i], i) === false) {
+                    break;
+                }
+            }
+            return this;
+        };
+        DTableColumnContainerImpl.prototype.size = function () {
+            return this.items.length;
+        };
+        return DTableColumnContainerImpl;
+    }(pixi_js.utils.EventEmitter));
+
+    /*
+     * Copyright (C) 2019 Toshiba Corporation
+     * SPDX-License-Identifier: Apache-2.0
+     */
+    var DTableDataTreeFilter = /** @class */ (function (_super) {
+        __extends(DTableDataTreeFilter, _super);
+        function DTableDataTreeFilter(parent) {
+            var _this = _super.call(this) || this;
+            _this._id = 0;
+            _this._idUpdated = -1;
+            _this._isApplied = false;
+            _this._parent = parent;
+            _this._filter = null;
+            _this._filtered = null;
+            return _this;
+        }
+        Object.defineProperty(DTableDataTreeFilter.prototype, "id", {
+            get: function () {
+                return this._id;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DTableDataTreeFilter.prototype.apply = function () {
+            this._isApplied = true;
+            this._id += 1;
+            this._parent.update();
+        };
+        DTableDataTreeFilter.prototype.unapply = function () {
+            if (this._isApplied) {
+                this._isApplied = false;
+                this._id += 1;
+                this._parent.update();
+            }
+        };
+        DTableDataTreeFilter.prototype.isApplied = function () {
+            return this._isApplied;
+        };
+        DTableDataTreeFilter.prototype.isFiltered = function (node, index, filter) {
+            if (isFunction(filter)) {
+                return filter(node, index);
+            }
+            else {
+                return filter.test(node, index);
+            }
+        };
+        DTableDataTreeFilter.prototype.hasFiltered = function (parent, nodes, filter) {
+            var accessor = this._parent.accessor;
+            var toChildren = accessor.toChildren;
+            var hasChildren = accessor.hasChildren;
+            for (var i = 0, imax = nodes.length; i < imax; ++i) {
+                var node = nodes[i];
+                if (this.isFiltered(node, -1, filter)) {
+                    return true;
+                }
+                var children = toChildren(node);
+                if (hasChildren(node, children) && this.hasFiltered(parent, children, filter)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        DTableDataTreeFilter.prototype.addAllToFiltered = function (parent, nodes, filtered, cursor) {
+            var accessor = this._parent.accessor;
+            var toChildren = accessor.toChildren;
+            var hasChildren = accessor.hasChildren;
+            for (var i = 0, imax = nodes.length; i < imax; ++i) {
+                var node = nodes[i];
+                filtered.push(cursor[0]);
+                cursor[0] += 1;
+                var children = toChildren(node);
+                if (hasChildren(node, children) && parent.isOpened(node)) {
+                    this.addAllToFiltered(parent, children, filtered, cursor);
+                }
+            }
+        };
+        DTableDataTreeFilter.prototype.newFilteredSub = function (parent, nodes, filter, filtered, cursor) {
+            var result = false;
+            var accessor = this._parent.accessor;
+            var toChildren = accessor.toChildren;
+            var hasChildren = accessor.hasChildren;
+            for (var i = 0, imax = nodes.length; i < imax; ++i) {
+                var node = nodes[i];
+                var index = cursor[0];
+                cursor[0] += 1;
+                var isFiltered = this.isFiltered(node, index, filter);
+                var children = toChildren(node);
+                if (hasChildren(node, children)) {
+                    if (parent.isOpened(node)) {
+                        if (isFiltered) {
+                            filtered.push(index);
+                            result = true;
+                            this.addAllToFiltered(parent, children, filtered, cursor);
+                        }
+                        else {
+                            var position = filtered.length;
+                            if (this.newFilteredSub(parent, children, filter, filtered, cursor)) {
+                                filtered.splice(position, 0, index);
+                                result = true;
+                            }
+                        }
+                    }
+                    else if (isFiltered || this.hasFiltered(parent, children, filter)) {
+                        filtered.push(index);
+                        result = true;
+                    }
+                }
+                else if (isFiltered) {
+                    filtered.push(index);
+                    result = true;
+                }
+            }
+            return result;
+        };
+        DTableDataTreeFilter.prototype.newFiltered = function () {
+            var filter = this._filter;
+            if (filter != null) {
+                var filtered = [];
+                var parent_1 = this._parent;
+                var nodes = parent_1.nodes;
+                if (nodes) {
+                    var cursor = [0];
+                    this.newFilteredSub(parent_1, nodes, filter, filtered, cursor);
+                }
+                return filtered;
+            }
+            return null;
+        };
+        DTableDataTreeFilter.prototype.get = function () {
+            return this._filter;
+        };
+        DTableDataTreeFilter.prototype.set = function (filter) {
+            if (this._filter !== filter) {
+                this._filter = filter;
+            }
+        };
+        DTableDataTreeFilter.prototype.toDirty = function () {
+            this._id += 1;
+        };
+        DTableDataTreeFilter.prototype.update = function () {
+            if (this._id !== this._idUpdated) {
+                this._idUpdated = this._id;
+                if (this._isApplied) {
+                    this._filtered = this.newFiltered();
+                    this.emit("change", this);
+                }
+                else if (this._filtered != null) {
+                    this._filtered = null;
+                    this.emit("change", this);
+                }
+            }
+        };
+        Object.defineProperty(DTableDataTreeFilter.prototype, "indices", {
+            get: function () {
+                this.update();
+                return this._filtered;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DTableDataTreeFilter.prototype.map = function (sortedIndex) {
+            var result = sortedIndex;
+            var indices = this.indices;
+            if (indices) {
+                var index = indices.indexOf(result);
+                if (0 <= index) {
+                    result = index;
+                }
+                else {
+                    return null;
+                }
+            }
+            return result;
+        };
+        DTableDataTreeFilter.prototype.unmap = function (index) {
+            var result = index;
+            var indices = this.indices;
+            if (indices) {
+                result = indices[result];
+            }
+            return result;
+        };
+        return DTableDataTreeFilter;
+    }(pixi_js.utils.EventEmitter));
+
+    /*
+     * Copyright (C) 2021 Toshiba Corporation
+     * SPDX-License-Identifier: Apache-2.0
+     */
+    var toParent = function (node) {
+        return node.parent;
+    };
+    var toChildren$1 = function (node) {
+        return node.children;
+    };
+    var hasChildren = function (node, children) {
+        return children != null && 0 < children.length;
+    };
+    var DTableDataTreeItemAccessor = /** @class */ (function () {
+        function DTableDataTreeItemAccessor(options) {
+            if (options != null) {
+                this.toParent = options.toParent || toParent;
+                this.toChildren = options.toChildren || toChildren$1;
+                this.hasChildren = options.hasChildren || hasChildren;
+            }
+            else {
+                this.toParent = toParent;
+                this.toChildren = toChildren$1;
+                this.hasChildren = hasChildren;
+            }
+        }
+        return DTableDataTreeItemAccessor;
+    }());
+
+    /*
+     * Copyright (C) 2021 Toshiba Corporation
+     * SPDX-License-Identifier: Apache-2.0
+     */
+    var COMPARATOR = function (a, b) {
+        return a[0] - b[0];
+    };
+    var DTableDataTreeSelectionImpl = /** @class */ (function (_super) {
+        __extends(DTableDataTreeSelectionImpl, _super);
+        function DTableDataTreeSelectionImpl(parent, options) {
+            var _a;
+            var _this = _super.call(this) || this;
+            _this._parent = parent;
+            _this._type = toEnum((_a = options === null || options === void 0 ? void 0 : options.type) !== null && _a !== void 0 ? _a : DTableDataSelectionType.NONE, DTableDataSelectionType);
+            _this._rows = new Set();
+            // Events
+            var on = options === null || options === void 0 ? void 0 : options.on;
+            if (on) {
+                for (var name_1 in on) {
+                    var handler = on[name_1];
+                    if (handler) {
+                        _this.on(name_1, handler);
+                    }
+                }
+            }
+            return _this;
+        }
+        Object.defineProperty(DTableDataTreeSelectionImpl.prototype, "parent", {
+            get: function () {
+                return this._parent;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DTableDataTreeSelectionImpl.prototype.onNodeChange = function (nodes) {
+            if (nodes != null) {
+                var accessor = this._parent.accessor;
+                var toChildren = accessor.toChildren;
+                var hasChildren = accessor.hasChildren;
+                var oldRows = this._rows;
+                var newRows = this.newRows(nodes, toChildren, hasChildren, oldRows, new Set());
+                if (oldRows.size !== newRows.size) {
+                    this._rows = newRows;
+                    this.onChange();
+                }
+            }
+            else {
+                var rows = this._rows;
+                if (0 < rows.size) {
+                    rows.clear();
+                    this.onChange();
+                }
+            }
+        };
+        DTableDataTreeSelectionImpl.prototype.newRows = function (nodes, toChildren, hasChildren, rows, result) {
+            for (var i = 0, imax = nodes.length; i < imax; ++i) {
+                var node = nodes[i];
+                if (rows.has(node)) {
+                    result.add(node);
+                }
+                var children = toChildren(node);
+                if (hasChildren(node, children)) {
+                    this.newRows(children, toChildren, hasChildren, rows, result);
+                }
+            }
+            return result;
+        };
+        Object.defineProperty(DTableDataTreeSelectionImpl.prototype, "indices", {
+            get: function () {
+                var rows = this._rows;
+                var result = [];
+                this._parent.each(function (row, index) {
+                    if (rows.has(row)) {
+                        result.push(index);
+                    }
+                });
+                return result;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(DTableDataTreeSelectionImpl.prototype, "rows", {
+            get: function () {
+                var result = [];
+                this._rows.forEach(function (row) {
+                    result.push(row);
+                });
+                return result;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(DTableDataTreeSelectionImpl.prototype, "type", {
+            get: function () {
+                return this._type;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DTableDataTreeSelectionImpl.prototype.getFirst = function () {
+            var rows = this._rows;
+            if (0 < rows.size) {
+                var result_1 = null;
+                rows.forEach(function (row) {
+                    if (result_1 == null) {
+                        result_1 = row;
+                    }
+                });
+                return result_1;
+            }
+            return null;
+        };
+        DTableDataTreeSelectionImpl.prototype.getLast = function () {
+            var rows = this._rows;
+            if (0 < rows.size) {
+                var result_2 = null;
+                rows.forEach(function (row) {
+                    result_2 = row;
+                });
+                return result_2;
+            }
+            return null;
+        };
+        DTableDataTreeSelectionImpl.prototype.toIndex = function (target) {
+            var result = null;
+            this._parent.each(function (row, index) {
+                if (target === row) {
+                    result = index;
+                    return false;
+                }
+                return true;
+            });
+            return result;
+        };
+        Object.defineProperty(DTableDataTreeSelectionImpl.prototype, "first", {
+            get: function () {
+                var row = this.getFirst();
+                if (row) {
+                    return this.toIndex(row);
+                }
+                return null;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(DTableDataTreeSelectionImpl.prototype, "last", {
+            get: function () {
+                var row = this.getLast();
+                if (row) {
+                    return this.toIndex(row);
+                }
+                return null;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DTableDataTreeSelectionImpl.prototype.onChange = function () {
+            this._parent.update();
+            this.emit("change", this);
+        };
+        DTableDataTreeSelectionImpl.prototype.toggle = function (rowIndex) {
+            var row = this._parent.get(rowIndex);
+            if (row) {
+                var rows = this._rows;
+                if (rows.has(row)) {
+                    rows.delete(row);
+                }
+                else {
+                    rows.add(row);
+                }
+                this.onChange();
+            }
+        };
+        DTableDataTreeSelectionImpl.prototype.add = function (rowIndex) {
+            var row = this._parent.get(rowIndex);
+            if (row) {
+                var rows = this._rows;
+                if (!rows.has(row)) {
+                    rows.add(row);
+                    this.onChange();
+                }
+            }
+        };
         DTableDataTreeSelectionImpl.prototype.addTo = function (rowIndex) {
             var lastRowIndex = this.last;
             if (lastRowIndex != null) {
@@ -75206,1498 +76060,649 @@
                 return this._isFilterable;
             },
             set: function (isFilterable) {
-                this._isFilterable = isFilterable;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(DTableHeaderCellCheck.prototype, "isEmittable", {
-            get: function () {
-                return this._isEmittable;
-            },
-            set: function (isEmittable) {
-                this._isEmittable = isEmittable;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        DTableHeaderCellCheck.prototype.newIteratee = function (table, isChecked) {
-            var parent = this._parent;
-            var column = parent.column;
-            var columnIndex = parent.columnIndex;
-            if (column != null && columnIndex != null) {
-                var getter_1 = column.getter;
-                var setter_1 = column.setter;
-                if (this._isEmittable) {
-                    var data_1 = table.data;
-                    return function (row, rowIndex) {
-                        if (getter_1(row, columnIndex) !== isChecked) {
-                            setter_1(row, columnIndex, isChecked);
-                            data_1.emit("change", isChecked, !isChecked, row, rowIndex, columnIndex, data_1);
-                            return true;
-                        }
-                        return false;
-                    };
-                }
-                else {
-                    return function (row) {
-                        if (getter_1(row, columnIndex) !== isChecked) {
-                            setter_1(row, columnIndex, isChecked);
-                            return true;
-                        }
-                        return false;
-                    };
-                }
-            }
-            return null;
-        };
-        DTableHeaderCellCheck.prototype.execute = function (isChecked) {
-            var _a;
-            var table = (_a = this._parent.header) === null || _a === void 0 ? void 0 : _a.table;
-            if (table) {
-                var iteratee_1 = this.newIteratee(table, isChecked);
-                if (iteratee_1) {
-                    var isChanged_1 = false;
-                    if (this._isFilterable) {
-                        table.data.mapped.each(function (row, supplimental, index, unmappedIndex) {
-                            if (iteratee_1(row, unmappedIndex)) {
-                                isChanged_1 = true;
-                            }
-                        });
-                    }
-                    else {
-                        table.data.each(function (row, index) {
-                            if (iteratee_1(row, index)) {
-                                isChanged_1 = true;
-                            }
-                        });
-                    }
-                    if (isChanged_1) {
-                        table.body.update(true);
-                    }
-                }
-            }
-        };
-        return DTableHeaderCellCheck;
-    }());
-
-    /*
-     * Copyright (C) 2019 Toshiba Corporation
-     * SPDX-License-Identifier: Apache-2.0
-     */
-    var DTableHeaderCellEdge = {
-        NONE: 0,
-        LEFT: 1,
-        RIGHT: 2,
-        BOTH: 3
-    };
-    var DTableHeaderCell = /** @class */ (function (_super) {
-        __extends(DTableHeaderCell, _super);
-        function DTableHeaderCell(header, columnIndex, column, options) {
-            var _this = _super.call(this, options) || this;
-            _this._header = header;
-            _this._column = column;
-            _this._columnIndex = columnIndex;
-            var check = new DTableHeaderCellCheck(_this, options === null || options === void 0 ? void 0 : options.check);
-            _this._check = check;
-            _this._edgeSize = _this.theme.getEdgeWidth();
-            _this._wasResizing = false;
-            var sortable = column.sorting.enable;
-            var checkable = check.isEnabled;
-            if (checkable || sortable) {
-                _this.on(UtilPointerEvent.tap, function (e) {
-                    _this.onClick(e);
-                });
-                var state = _this.state;
-                state.lock();
-                state.set(DTableState.SORTABLE, sortable);
-                state.set(DTableState.CHECKABLE, checkable);
-                state.unlock();
-            }
-            return _this;
-        }
-        Object.defineProperty(DTableHeaderCell.prototype, "column", {
-            get: function () {
-                return this._column;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(DTableHeaderCell.prototype, "columnIndex", {
-            get: function () {
-                return this._columnIndex;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(DTableHeaderCell.prototype, "header", {
-            get: function () {
-                return this._header;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(DTableHeaderCell.prototype, "check", {
-            get: function () {
-                return this._check;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        DTableHeaderCell.prototype.onDown = function (e) {
-            var edges = this.state.valueOf(DTableState.HOVERED_ON_EDGE);
-            if (edges != null) {
-                this._wasResizing = true;
-                var layer = DApplications.getLayer(this);
-                if (layer != null) {
-                    var interactionManager = layer.renderer.plugins.interaction;
-                    var columnIndex = this._columnIndex;
-                    if (edges === DTableHeaderCellEdge.LEFT) {
-                        this.onDownEdge(e.data.global.x, columnIndex - 1, interactionManager);
-                    }
-                    else {
-                        this.onDownEdge(e.data.global.x, columnIndex, interactionManager);
-                    }
-                }
-            }
-            else {
-                this._wasResizing = false;
-                _super.prototype.onDown.call(this, e);
-            }
-        };
-        DTableHeaderCell.prototype.findLeftResizableCell = function (columnIndex) {
-            var children = this._header.children;
-            var childrenLength = children.length;
-            for (var i = columnIndex; 0 <= i; --i) {
-                var child = children[childrenLength - i - 1];
-                if (child.column.resizable) {
-                    return child;
-                }
-            }
-            return null;
-        };
-        DTableHeaderCell.prototype.findRightResizableCellOfWeight = function (columnIndex) {
-            var children = this._header.children;
-            var childrenLength = children.length;
-            for (var i = columnIndex + 1; i < childrenLength; ++i) {
-                var child = children[childrenLength - i - 1];
-                var childColumn = child.column;
-                if (childColumn.resizable) {
-                    var childColumnWeight = childColumn.weight;
-                    if (childColumnWeight != null) {
-                        return child;
-                    }
-                }
-            }
-            return null;
-        };
-        DTableHeaderCell.prototype.checkIfEdgeResizable = function (columnIndex) {
-            var target = this.findLeftResizableCell(columnIndex);
-            if (target != null) {
-                if (target.column.weight != null) {
-                    return this.findRightResizableCellOfWeight(target.columnIndex) != null;
-                }
-                else {
-                    return true;
-                }
-            }
-            return false;
-        };
-        DTableHeaderCell.prototype.getResizableEdges = function () {
-            var result = this._resizableEdges;
-            if (result == null) {
-                var columnIndex = this._columnIndex;
-                if (this.checkIfEdgeResizable(columnIndex - 1)) {
-                    if (this.checkIfEdgeResizable(columnIndex)) {
-                        result = DTableHeaderCellEdge.BOTH;
-                    }
-                    else {
-                        result = DTableHeaderCellEdge.LEFT;
-                    }
-                }
-                else {
-                    if (this.checkIfEdgeResizable(columnIndex)) {
-                        result = DTableHeaderCellEdge.RIGHT;
-                    }
-                    else {
-                        result = DTableHeaderCellEdge.NONE;
-                    }
-                }
-                this._resizableEdges = result;
-            }
-            return result;
-        };
-        DTableHeaderCell.prototype.onOver = function (e) {
-            var _this = this;
-            var _a;
-            _super.prototype.onOver.call(this, e);
-            if (this.getResizableEdges() !== DTableHeaderCellEdge.NONE) {
-                var onHoveredBound = ((_a = this._onHoveredBound) !== null && _a !== void 0 ? _a : (this._onHoveredBound = function (event) {
-                    _this.onHovered(event);
-                }));
-                this.on(UtilPointerEvent.move, onHoveredBound);
-                // Since the cursor is set by InteractionManager before this method is called,
-                // the cursor need to be overriden.
-                this.onHovered(e);
-                var layer = DApplications.getLayer(this);
-                if (layer != null) {
-                    layer.renderer.plugins.interaction.cursor = this.cursor;
-                }
-            }
-        };
-        DTableHeaderCell.prototype.onOut = function (e) {
-            _super.prototype.onOut.call(this, e);
-            var onHoveredBound = this._onHoveredBound;
-            if (onHoveredBound != null) {
-                this.state.remove(DTableState.HOVERED_ON_EDGE);
-                this.off(UtilPointerEvent.move, onHoveredBound);
-            }
-        };
-        DTableHeaderCell.prototype.onHovered = function (e) {
-            var width = this.width;
-            var x = this.toClickPosition(e);
-            var edgeSize = this._edgeSize;
-            if (0 <= x && x <= edgeSize) {
-                if (this.getResizableEdges() & DTableHeaderCellEdge.LEFT) {
-                    this.state.add(DTableState.HOVERED_ON_EDGE, DTableHeaderCellEdge.LEFT);
-                }
-                else {
-                    this.state.remove(DTableState.HOVERED_ON_EDGE);
-                }
-            }
-            else if (width - edgeSize <= x && x <= width) {
-                if (this.getResizableEdges() & DTableHeaderCellEdge.RIGHT) {
-                    this.state.add(DTableState.HOVERED_ON_EDGE, DTableHeaderCellEdge.RIGHT);
-                }
-                else {
-                    this.state.remove(DTableState.HOVERED_ON_EDGE);
-                }
-            }
-            else {
-                this.state.remove(DTableState.HOVERED_ON_EDGE);
-            }
-        };
-        DTableHeaderCell.prototype.onDownEdge = function (onDownPoint, columnIndex, interactionManager) {
-            // Find the resizable cell
-            var left = this.findLeftResizableCell(columnIndex);
-            if (left == null) {
-                // No resizable cell
-                return;
-            }
-            var header = this._header;
-            var leftColumn = left.column;
-            var leftOldWidth = left.width;
-            var leftOldWeight = left.weight;
-            if (leftColumn.weight == null) {
-                header.state.add(DTableState.RESIZING);
-                var onMove_1 = function (e) {
-                    leftColumn.width = Math.max(1, leftOldWidth + e.data.global.x - onDownPoint);
-                };
-                var onUp_1 = function (e) {
-                    header.state.remove(DTableState.RESIZING);
-                    interactionManager.off(UtilPointerEvent.move, onMove_1);
-                    interactionManager.off(UtilPointerEvent.up, onUp_1);
-                    interactionManager.off(UtilPointerEvent.upoutside, onUp_1);
-                    interactionManager.off(UtilPointerEvent.cancel, onUp_1);
-                };
-                interactionManager.on(UtilPointerEvent.move, onMove_1);
-                interactionManager.on(UtilPointerEvent.up, onUp_1);
-                interactionManager.on(UtilPointerEvent.upoutside, onUp_1);
-                interactionManager.on(UtilPointerEvent.cancel, onUp_1);
-            }
-            else {
-                var right = this.findRightResizableCellOfWeight(left.columnIndex);
-                if (right == null) {
-                    // No right resizable cell found
-                    return;
-                }
-                var rightColumn_1 = right.column;
-                var rightOldWeight = right.weight;
-                var rightOldWidth = right.width;
-                var totalWidth_1 = leftOldWidth + rightOldWidth;
-                var totalWeight_1 = leftOldWeight + rightOldWeight;
-                if (totalWidth_1 <= 0) {
-                    // The left and right resizable cells doesn't have non-zero width
-                    return;
-                }
-                header.state.add(DTableState.RESIZING);
-                var onMove_2 = function (e) {
-                    var leftNewWidth = Math.max(0, Math.min(totalWidth_1, leftOldWidth + e.data.global.x - onDownPoint));
-                    var leftNewWeight = totalWeight_1 * (leftNewWidth / totalWidth_1);
-                    leftColumn.weight = leftNewWeight;
-                    rightColumn_1.weight = totalWeight_1 - leftNewWeight;
-                };
-                var onUp_2 = function (e) {
-                    header.state.remove(DTableState.RESIZING);
-                    interactionManager.off(UtilPointerEvent.move, onMove_2);
-                    interactionManager.off(UtilPointerEvent.up, onUp_2);
-                    interactionManager.off(UtilPointerEvent.upoutside, onUp_2);
-                    interactionManager.off(UtilPointerEvent.cancel, onUp_2);
-                };
-                interactionManager.on(UtilPointerEvent.move, onMove_2);
-                interactionManager.on(UtilPointerEvent.up, onUp_2);
-                interactionManager.on(UtilPointerEvent.upoutside, onUp_2);
-                interactionManager.on(UtilPointerEvent.cancel, onUp_2);
-            }
-        };
-        Object.defineProperty(DTableHeaderCell.prototype, "sorter", {
-            get: function () {
-                var _this = this;
-                var sorter = this._sorter;
-                if (sorter == null) {
-                    var header = this._header;
-                    if (header) {
-                        var table = header.table;
-                        if (table) {
-                            sorter = table.data.sorter;
-                            this._sorter = sorter;
-                            this._onSorterChangeBound =
-                                this._onSorterChangeBound ||
-                                    (function () {
-                                        _this.onSorterChange();
-                                    });
-                            sorter.on("change", this._onSorterChangeBound);
-                        }
-                        else {
-                            return null;
-                        }
-                    }
-                    else {
-                        return null;
-                    }
-                }
-                return sorter;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(DTableHeaderCell.prototype, "comparator", {
-            get: function () {
-                return this._column.sorting.comparator || null;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        DTableHeaderCell.prototype.onSorterChange = function () {
-            var comparator = this.comparator;
-            if (comparator) {
-                var sorter = this._sorter;
-                if (sorter) {
-                    var SORTED_ASCENDING = DTableState.SORTED_ASCENDING;
-                    var SORTED_DESCENDING = DTableState.SORTED_DESCENDING;
-                    if (sorter.isApplied() && sorter.get() === comparator) {
-                        if (sorter.order === DTableDataOrder.ASCENDING) {
-                            this.state.set(SORTED_ASCENDING, SORTED_DESCENDING);
-                        }
-                        else {
-                            this.state.set(SORTED_DESCENDING, SORTED_ASCENDING);
-                        }
-                    }
-                    else {
-                        this.state.removeAll(SORTED_ASCENDING, SORTED_DESCENDING);
-                    }
-                }
-            }
-        };
-        DTableHeaderCell.prototype.toClickPosition = function (e) {
-            var _a;
-            var checkWork = ((_a = this._checkWork) !== null && _a !== void 0 ? _a : (this._checkWork = new pixi_js.Point()));
-            return e.data.getLocalPosition(this, checkWork).x;
-        };
-        DTableHeaderCell.prototype.isCheckClicked = function (e) {
-            if (e instanceof pixi_js.InteractionEvent && this._check.isEnabled) {
-                if (this.isSortable) {
-                    var image = this.image.get(1);
-                    if (image) {
-                        var position = this.toClickPosition(e);
-                        var object = image.object;
-                        if (object != null) {
-                            var bound = object.getLocalBounds();
-                            var margin = image.margin.horizontal;
-                            var x = object.x;
-                            return (x + bound.left - margin <= position &&
-                                position <= x + bound.right + margin);
-                        }
-                    }
-                }
-                else {
-                    return true;
-                }
-            }
-            return false;
-        };
-        DTableHeaderCell.prototype.isEdgeClicked = function (e) {
-            return (e instanceof pixi_js.InteractionEvent &&
-                (this.state.is(DTableState.HOVERED_ON_EDGE) || this._wasResizing));
-        };
-        DTableHeaderCell.prototype.onClick = function (e) {
-            if (this.state.isActionable) {
-                this.activate(e);
-            }
-        };
-        DTableHeaderCell.prototype.activate = function (e) {
-            this.onActivate(e);
-        };
-        DTableHeaderCell.prototype.onActivate = function (e) {
-            if (!this.isEdgeClicked(e)) {
-                if (this.isCheckClicked(e)) {
-                    this.onToggleStart();
-                    this.onToggleEnd();
-                }
-                else {
-                    this.doSort(e);
-                    this.emit("active", this);
-                }
-            }
-        };
-        DTableHeaderCell.prototype.doSort = function (e) {
-            if (this.isSortable) {
-                var comparator = this.comparator;
-                if (comparator) {
-                    var sorter = this.sorter;
-                    if (sorter) {
-                        if (sorter.get() === comparator) {
-                            if (sorter.order === DTableDataOrder.ASCENDING) {
-                                sorter.order = DTableDataOrder.DESCENDING;
-                                sorter.apply();
-                            }
-                            else {
-                                sorter.set(null);
-                                sorter.apply();
-                            }
-                        }
-                        else {
-                            sorter.set(comparator);
-                            sorter.order = DTableDataOrder.ASCENDING;
-                            sorter.apply();
-                        }
-                    }
-                }
-            }
-        };
-        Object.defineProperty(DTableHeaderCell.prototype, "isSortable", {
-            get: function () {
-                return this._column.sorting.enable;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(DTableHeaderCell.prototype, "isResizable", {
-            get: function () {
-                return this._column.resizable;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(DTableHeaderCell.prototype, "isToggle", {
-            get: function () {
-                return this._check.isEnabled;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        DTableHeaderCell.prototype.toggle = function () {
-            if (this.state.isActionable) {
-                if (this.isToggle) {
-                    this.onToggleStart();
-                    this.onToggleEnd();
-                }
-            }
-        };
-        DTableHeaderCell.prototype.onToggleStart = function () {
-            this.state.isActive = !this.state.isActive;
-        };
-        DTableHeaderCell.prototype.onToggleEnd = function () {
-            if (this.state.isActive) {
-                this._check.execute(true);
-                this.emit("active", this);
-            }
-            else {
-                this._check.execute(false);
-                this.emit("inactive", this);
-            }
-        };
-        DTableHeaderCell.prototype.onActivateKeyDown = function (e) {
-            if (this.state.isActionable) {
-                if (this.isToggle) {
-                    this.onToggleStart();
-                }
-                else {
-                    this.state.isPressed = true;
-                }
-            }
-        };
-        DTableHeaderCell.prototype.onActivateKeyUp = function (e) {
-            if (this.state.isActionable) {
-                if (this.isToggle) {
-                    this.onToggleEnd();
-                }
-                else {
-                    if (this.state.isPressed) {
-                        this.activate(e);
-                    }
-                    this.state.isPressed = false;
-                }
-            }
-        };
-        DTableHeaderCell.prototype.onKeyDown = function (e) {
-            if (UtilKeyboardEvent.isActivateKey(e)) {
-                this.onActivateKeyDown(e);
-            }
-            return _super.prototype.onKeyDown.call(this, e);
-        };
-        DTableHeaderCell.prototype.onKeyUp = function (e) {
-            if (UtilKeyboardEvent.isActivateKey(e)) {
-                this.onActivateKeyUp(e);
-            }
-            return _super.prototype.onKeyUp.call(this, e);
-        };
-        DTableHeaderCell.prototype.getType = function () {
-            return "DTableHeaderCell";
-        };
-        DTableHeaderCell.prototype.destroy = function () {
-            var sorter = this._sorter;
-            var onSorterChangeBound = this._onSorterChangeBound;
-            if (sorter && onSorterChangeBound) {
-                sorter.off("change", onSorterChangeBound);
-            }
-            this._sorter = undefined;
-            this._onSorterChangeBound = undefined;
-            _super.prototype.destroy.call(this);
-        };
-        return DTableHeaderCell;
-    }(DImage));
-
-    /*
-     * Copyright (C) 2019 Toshiba Corporation
-     * SPDX-License-Identifier: Apache-2.0
-     */
-    var DTableHeader = /** @class */ (function (_super) {
-        __extends(DTableHeader, _super);
-        function DTableHeader(table, columns, frozen, offset, options) {
-            var _this = _super.call(this, columns, frozen, options) || this;
-            _this._table = table;
-            _this._offset = offset;
-            _this.transform.position.y = offset;
-            _this.initCells();
-            return _this;
-        }
-        Object.defineProperty(DTableHeader.prototype, "table", {
-            get: function () {
-                return this._table;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        DTableHeader.prototype.onParentMove = function (newX, newY, oldX, oldY) {
-            _super.prototype.onParentMove.call(this, newX, newY, oldX, oldY);
-            this.transform.position.y = -newY + this._offset;
-            this.updateFrozenCellPosition(newX);
-        };
-        DTableHeader.prototype.getContentPositionX = function () {
-            var content = this.parent;
-            if (content) {
-                return content.position.x;
-            }
-            return 0;
-        };
-        DTableHeader.prototype.newCell = function (columnIndex, column, columns, options) {
-            return new DTableHeaderCell(this, columnIndex, column, this.toCellOptions(column, options));
-        };
-        DTableHeader.prototype.toCellOptions = function (column, options) {
-            var result = column.header || (options === null || options === void 0 ? void 0 : options.cell);
-            if (result != null) {
-                if (result.weight === undefined) {
-                    result.weight = column.weight;
-                }
-                if (result.width === undefined) {
-                    result.width = column.width;
-                }
-                if (result.text === undefined) {
-                    result.text = {
-                        value: column.label
-                    };
-                }
-                else if (result.text.value === undefined) {
-                    result.text.value = column.label;
-                }
-                return result;
-            }
-            else {
-                return {
-                    weight: column.weight,
-                    width: column.width,
-                    text: {
-                        value: column.label
-                    }
-                };
-            }
-        };
-        DTableHeader.prototype.getType = function () {
-            return "DTableHeader";
-        };
-        return DTableHeader;
-    }(DTableRow));
-
-    var DTableScrollBar = /** @class */ (function (_super) {
-        __extends(DTableScrollBar, _super);
-        function DTableScrollBar() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        DTableScrollBar.prototype.getOffsetVerticalStart = function (size) {
-            return size * 0.5 + this._parent.body.position.y;
-        };
-        return DTableScrollBar;
-    }(DPaneScrollBar));
-
-    var defaultGetter = function (row, columnIndex) {
-        return row[columnIndex];
-    };
-    var defaultSetter = function (row, columnIndex, cell) {
-        row[columnIndex] = cell;
-    };
-    var defaultGetterEmpty = function () { return ""; };
-    var defaultSetterEmpty = function () {
-        // DO NOTHING
-    };
-    var toPathGetter = function (path, def) {
-        if (path.length <= 1) {
-            var key_1 = path[0];
-            if (def === undefined) {
-                return function (row) {
-                    return row[key_1];
-                };
-            }
-            else {
-                return function (row) {
-                    return Object.prototype.hasOwnProperty.call(row, key_1) ? row[key_1] : def;
-                };
-            }
-        }
-        else {
-            if (def === undefined) {
-                return function (row) {
-                    for (var i = 0, imax = path.length - 1; i < imax; ++i) {
-                        row = row[path[i]];
-                    }
-                    return row[path[path.length - 1]];
-                };
-            }
-            else {
-                return function (row) {
-                    for (var i = 0, imax = path.length - 1; i < imax; ++i) {
-                        row = row[path[i]];
-                    }
-                    var key = path[path.length - 1];
-                    return Object.prototype.hasOwnProperty.call(row, key) ? row[key] : def;
-                };
-            }
-        }
-    };
-    var toPathSetter = function (path) {
-        if (path.length <= 1) {
-            var key_2 = path[0];
-            return function (row, columnIndex, cell) {
-                row[key_2] = cell;
-            };
-        }
-        else {
-            return function (row, columnIndex, cell) {
-                for (var i = 0, imax = path.length - 1; i < imax; ++i) {
-                    row = row[path[i]] || {};
-                }
-                row[path[path.length - 1]] = cell;
-            };
-        }
-    };
-    var toAlign = function (options, type) {
-        var align = options.align;
-        if (align != null) {
-            if (isString(align)) {
-                return DAlignHorizontal[align];
-            }
-            else {
-                return align;
-            }
-        }
-        switch (type) {
-            case DTableColumnType.TEXT:
-            case DTableColumnType.TEXT_AREA:
-                return DAlignHorizontal.LEFT;
-            case DTableColumnType.REAL:
-            case DTableColumnType.INTEGER:
-                return DAlignHorizontal.RIGHT;
-            case DTableColumnType.BUTTON:
-            case DTableColumnType.INDEX:
-            case DTableColumnType.SELECT:
-            case DTableColumnType.ACTION:
-            case DTableColumnType.LINK:
-            case DTableColumnType.CHECK:
-            case DTableColumnType.CHECK_SINGLE:
-            case DTableColumnType.COLOR:
-                return DAlignHorizontal.CENTER;
-            default:
-                return DAlignHorizontal.LEFT;
-        }
-    };
-    var toDataChecker = function (path) {
-        if (path != null) {
-            var pathLength_1 = path.length;
-            if (pathLength_1 <= 1) {
-                var key_3 = path[0];
-                return function (row) {
-                    return Object.prototype.hasOwnProperty.call(row, key_3);
-                };
-            }
-            else {
-                return function (row) {
-                    for (var i = 0; i < pathLength_1; ++i) {
-                        var part = path[i];
-                        if (part in row) {
-                            row = row[part];
-                        }
-                        else {
-                            return false;
-                        }
-                    }
-                    return true;
-                };
-            }
-        }
-        return function (row, columnIndex) {
-            return columnIndex < row.length;
-        };
-    };
-    var toEditingEnable = function (enable, path) {
-        if (isString(enable)) {
-            return toDataChecker(path);
-        }
-        else if (enable != null) {
-            return enable;
-        }
-        else {
-            return false;
-        }
-    };
-    var toEditing = function (options, path) {
-        var _a;
-        var editing = options.editing;
-        var editable = options.editable;
-        if (editing) {
-            return {
-                enable: toEditingEnable((_a = editing.enable) !== null && _a !== void 0 ? _a : editable, path),
-                formatter: editing.formatter,
-                unformatter: editing.unformatter,
-                validator: editing.validator
-            };
-        }
-        return {
-            enable: toEditingEnable(editable, path)
-        };
-    };
-    var toComparator = function (getter, index) {
-        return function (rowA, rowB) {
-            var valueA = getter(rowA, index);
-            var valueB = getter(rowB, index);
-            return valueA < valueB ? -1 : valueB < valueA ? +1 : 0;
-        };
-    };
-    var toSorting = function (getter, index, options) {
-        var sorting = options.sorting;
-        var sortable = options.sortable;
-        if (sorting) {
-            if (sorting.enable || sortable) {
-                return {
-                    enable: true,
-                    comparator: sorting.comparator || toComparator(getter, index)
-                };
-            }
-            return {
-                enable: false
-            };
-        }
-        if (sortable) {
-            return {
-                enable: true,
-                comparator: toComparator(getter, index)
-            };
-        }
-        return {
-            enable: false
-        };
-    };
-    var toMenu = function (options) {
-        if (options == null) {
-            return undefined;
-        }
-        else if (options instanceof DMenu) {
-            return options;
-        }
-        else {
-            return new DMenu(options);
-        }
-    };
-    var toDialog = function (options) {
-        if (options == null) {
-            return undefined;
-        }
-        else if ("open" in options) {
-            return options;
-        }
-        else {
-            return new DDialogSelect(options);
-        }
-    };
-    var defaultSelectingGetter = function (dialog) {
-        return dialog.value;
-    };
-    var defaultSelectingSetter = function () {
-        // DO NOTHING
-    };
-    var toSelecting = function (options) {
-        if (options) {
-            return {
-                getter: options.getter || defaultSelectingGetter,
-                setter: options.setter || defaultSelectingSetter,
-                menu: toMenu(options.menu),
-                multiple: toMenu(options.multiple),
-                dialog: toDialog(options.dialog),
-                promise: options.promise
-            };
-        }
-        return {
-            getter: defaultSelectingGetter,
-            setter: defaultSelectingSetter
-        };
-    };
-    var toGetter = function (options, type, parts) {
-        var getter = options.getter;
-        if (getter) {
-            return getter;
-        }
-        switch (type) {
-            case DTableColumnType.ACTION:
-            case DTableColumnType.LINK:
-                return defaultGetterEmpty;
-            default:
-                if (parts == null) {
-                    return defaultGetter;
-                }
-                else {
-                    return toPathGetter(parts, options.default);
-                }
-        }
-    };
-    var toSetter = function (options, type, path) {
-        var setter = options.setter;
-        if (setter) {
-            return setter;
-        }
-        switch (type) {
-            case DTableColumnType.BUTTON:
-            case DTableColumnType.ACTION:
-            case DTableColumnType.LINK:
-                return defaultSetterEmpty;
-            default:
-                if (path == null) {
-                    return defaultSetter;
+                this._isFilterable = isFilterable;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(DTableHeaderCellCheck.prototype, "isEmittable", {
+            get: function () {
+                return this._isEmittable;
+            },
+            set: function (isEmittable) {
+                this._isEmittable = isEmittable;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DTableHeaderCellCheck.prototype.newIteratee = function (table, isChecked) {
+            var parent = this._parent;
+            var column = parent.column;
+            var columnIndex = parent.columnIndex;
+            if (column != null && columnIndex != null) {
+                var getter_1 = column.getter;
+                var setter_1 = column.setter;
+                if (this._isEmittable) {
+                    var data_1 = table.data;
+                    return function (row, rowIndex) {
+                        if (getter_1(row, columnIndex) !== isChecked) {
+                            setter_1(row, columnIndex, isChecked);
+                            data_1.emit("change", isChecked, !isChecked, row, rowIndex, columnIndex, data_1);
+                            return true;
+                        }
+                        return false;
+                    };
                 }
                 else {
-                    return toPathSetter(path);
+                    return function (row) {
+                        if (getter_1(row, columnIndex) !== isChecked) {
+                            setter_1(row, columnIndex, isChecked);
+                            return true;
+                        }
+                        return false;
+                    };
                 }
-        }
-    };
-    var toState = function (options) {
-        var state = options.state;
-        if (state != null) {
-            if (isString(state) || isArray(state)) {
-                return {
-                    initial: state,
-                    modifier: undefined
-                };
-            }
-            else {
-                return {
-                    initial: undefined,
-                    modifier: state
-                };
             }
-        }
-        return {
-            initial: undefined,
-            modifier: undefined
+            return null;
         };
-    };
-    var toPath = function (options) {
-        return options.path != null ? options.path.split(".") : null;
-    };
-    var toRenderable = function (options, path) {
-        var renderable = options.renderable;
-        if (isString(renderable)) {
-            return toDataChecker(path);
-        }
-        else if (renderable != null) {
-            return renderable;
-        }
-        return true;
-    };
-    var DTableColumnImpl = /** @class */ (function (_super) {
-        __extends(DTableColumnImpl, _super);
-        function DTableColumnImpl(index, options) {
-            var _a, _b, _c;
-            var _this = _super.call(this) || this;
-            var weight = options.weight;
-            var width = options.width;
-            if (weight != null) {
-                if (width != null) {
-                    width = undefined;
+        DTableHeaderCellCheck.prototype.execute = function (isChecked) {
+            var _a;
+            var table = (_a = this._parent.header) === null || _a === void 0 ? void 0 : _a.table;
+            if (table) {
+                var iteratee_1 = this.newIteratee(table, isChecked);
+                if (iteratee_1) {
+                    var isChanged_1 = false;
+                    if (this._isFilterable) {
+                        table.data.mapped.each(function (row, supplimental, index, unmappedIndex) {
+                            if (iteratee_1(row, unmappedIndex)) {
+                                isChanged_1 = true;
+                            }
+                        });
+                    }
+                    else {
+                        table.data.each(function (row, index) {
+                            if (iteratee_1(row, index)) {
+                                isChanged_1 = true;
+                            }
+                        });
+                    }
+                    if (isChanged_1) {
+                        table.body.update(true);
+                    }
                 }
             }
-            else if (width == null) {
-                weight = 1;
+        };
+        return DTableHeaderCellCheck;
+    }());
+
+    /*
+     * Copyright (C) 2019 Toshiba Corporation
+     * SPDX-License-Identifier: Apache-2.0
+     */
+    var DTableHeaderCellEdge = {
+        NONE: 0,
+        LEFT: 1,
+        RIGHT: 2,
+        BOTH: 3
+    };
+    var DTableHeaderCell = /** @class */ (function (_super) {
+        __extends(DTableHeaderCell, _super);
+        function DTableHeaderCell(header, columnIndex, column, options) {
+            var _this = _super.call(this, options) || this;
+            _this._header = header;
+            _this._column = column;
+            _this._columnIndex = columnIndex;
+            var check = new DTableHeaderCellCheck(_this, options === null || options === void 0 ? void 0 : options.check);
+            _this._check = check;
+            _this._edgeSize = _this.theme.getEdgeWidth();
+            _this._wasResizing = false;
+            var sortable = column.sorting.enable;
+            var checkable = check.isEnabled;
+            if (checkable || sortable) {
+                _this.on(UtilPointerEvent.tap, function (e) {
+                    _this.onClick(e);
+                });
+                var state = _this.state;
+                state.lock();
+                state.set(DTableState.SORTABLE, sortable);
+                state.set(DTableState.CHECKABLE, checkable);
+                state.unlock();
             }
-            var type = toEnum((_a = options.type) !== null && _a !== void 0 ? _a : DTableColumnType.TEXT, DTableColumnType);
-            var align = toAlign(options, type);
-            var label = options.label || "";
-            var path = toPath(options);
-            var getter = toGetter(options, type, path);
-            var setter = toSetter(options, type, path);
-            _this._weight = weight;
-            _this._width = width;
-            _this.resizable = (_b = options.resizable) !== null && _b !== void 0 ? _b : false;
-            _this.type = type;
-            _this.label = label;
-            _this.getter = getter;
-            _this.setter = setter;
-            _this.formatter = options.formatter;
-            _this.renderable = toRenderable(options, path);
-            _this.align = align;
-            _this.state = toState(options);
-            _this.editing = toEditing(options, path);
-            _this.sorting = toSorting(getter, index, options);
-            _this.header = options.header;
-            _this.body = options.body;
-            _this.selecting = toSelecting(options.selecting);
-            _this.category = options.category;
-            _this.frozen = options.frozen;
-            _this.offset = 0.0;
-            _this.link = options.link;
-            _this.update = toEnum((_c = options.update) !== null && _c !== void 0 ? _c : DTableColumnUpdate.CELL, DTableColumnUpdate);
             return _this;
         }
-        Object.defineProperty(DTableColumnImpl.prototype, "weight", {
+        Object.defineProperty(DTableHeaderCell.prototype, "column", {
             get: function () {
-                return this._weight;
+                return this._column;
             },
-            set: function (weight) {
-                if (this._weight != null && this._weight !== weight) {
-                    this._weight = weight;
-                    this.emit("resize", this);
-                }
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(DTableHeaderCell.prototype, "columnIndex", {
+            get: function () {
+                return this._columnIndex;
             },
             enumerable: false,
             configurable: true
         });
-        Object.defineProperty(DTableColumnImpl.prototype, "width", {
+        Object.defineProperty(DTableHeaderCell.prototype, "header", {
             get: function () {
-                return this._width;
+                return this._header;
             },
-            set: function (width) {
-                if (this._width != null && this._width !== width) {
-                    this._width = width;
-                    this.emit("resize", this);
-                }
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(DTableHeaderCell.prototype, "check", {
+            get: function () {
+                return this._check;
             },
             enumerable: false,
             configurable: true
         });
-        return DTableColumnImpl;
-    }(pixi_js.utils.EventEmitter));
-
-    var DTableColumnContainerImpl = /** @class */ (function (_super) {
-        __extends(DTableColumnContainerImpl, _super);
-        function DTableColumnContainerImpl(parent, options) {
-            var _this = _super.call(this) || this;
-            _this.parent = parent;
-            var columns = [];
-            if (options != null) {
-                for (var i = 0, imax = options.length; i < imax; ++i) {
-                    var column = new DTableColumnImpl(i, options[i]);
-                    columns.push(column);
-                    column.on("resize", _this.newOnColumnResize(i, column));
+        DTableHeaderCell.prototype.onDown = function (e) {
+            var edges = this.state.valueOf(DTableState.HOVERED_ON_EDGE);
+            if (edges != null) {
+                this._wasResizing = true;
+                var layer = DApplications.getLayer(this);
+                if (layer != null) {
+                    var interactionManager = layer.renderer.plugins.interaction;
+                    var columnIndex = this._columnIndex;
+                    if (edges === DTableHeaderCellEdge.LEFT) {
+                        this.onDownEdge(e.data.global.x, columnIndex - 1, interactionManager);
+                    }
+                    else {
+                        this.onDownEdge(e.data.global.x, columnIndex, interactionManager);
+                    }
                 }
             }
-            _this.items = columns;
-            var frozen = 0;
-            for (var i = columns.length - 1; 0 <= i; --i) {
-                if (columns[i].frozen === true) {
-                    frozen = i + 1;
-                    break;
+            else {
+                this._wasResizing = false;
+                _super.prototype.onDown.call(this, e);
+            }
+        };
+        DTableHeaderCell.prototype.findLeftResizableCell = function (columnIndex) {
+            var children = this._header.children;
+            var childrenLength = children.length;
+            for (var i = columnIndex; 0 <= i; --i) {
+                var child = children[childrenLength - i - 1];
+                if (child.column.resizable) {
+                    return child;
                 }
             }
-            _this.frozen = frozen;
-            return _this;
-        }
-        DTableColumnContainerImpl.prototype.newOnColumnResize = function (index, column) {
-            var _this = this;
-            return function () {
-                _this.onColumnResize(index, column);
-            };
+            return null;
         };
-        DTableColumnContainerImpl.prototype.onColumnResize = function (index, column) {
-            this.onColumnResizeHeader(index, column);
-            this.onColumnResizeBody(index, column);
-            this.emit("resize", index, column, this);
+        DTableHeaderCell.prototype.findRightResizableCellOfWeight = function (columnIndex) {
+            var children = this._header.children;
+            var childrenLength = children.length;
+            for (var i = columnIndex + 1; i < childrenLength; ++i) {
+                var child = children[childrenLength - i - 1];
+                var childColumn = child.column;
+                if (childColumn.resizable) {
+                    var childColumnWeight = childColumn.weight;
+                    if (childColumnWeight != null) {
+                        return child;
+                    }
+                }
+            }
+            return null;
         };
-        DTableColumnContainerImpl.prototype.onColumnResizeHeader = function (index, column) {
-            var header = this.parent.header;
-            if (header != null) {
-                var columnWeight = column.weight;
-                if (columnWeight != null) {
-                    this.onColumnResizeWeight(header, index, columnWeight);
+        DTableHeaderCell.prototype.checkIfEdgeResizable = function (columnIndex) {
+            var target = this.findLeftResizableCell(columnIndex);
+            if (target != null) {
+                if (target.column.weight != null) {
+                    return this.findRightResizableCellOfWeight(target.columnIndex) != null;
                 }
                 else {
-                    var columnWidth = column.width;
-                    if (columnWidth != null) {
-                        this.onColumnResizeWidth(header, index, columnWidth);
-                    }
+                    return true;
                 }
             }
+            return false;
         };
-        DTableColumnContainerImpl.prototype.onColumnResizeBody = function (index, column) {
-            var rows = this.parent.body.children;
-            var columnWeight = column.weight;
-            if (columnWeight != null) {
-                for (var i = 0, imax = rows.length; i < imax; ++i) {
-                    this.onColumnResizeWeight(rows[i], index, columnWeight);
+        DTableHeaderCell.prototype.getResizableEdges = function () {
+            var result = this._resizableEdges;
+            if (result == null) {
+                var columnIndex = this._columnIndex;
+                if (this.checkIfEdgeResizable(columnIndex - 1)) {
+                    if (this.checkIfEdgeResizable(columnIndex)) {
+                        result = DTableHeaderCellEdge.BOTH;
+                    }
+                    else {
+                        result = DTableHeaderCellEdge.LEFT;
+                    }
                 }
-            }
-            else {
-                var columnWidth = column.width;
-                if (columnWidth != null) {
-                    for (var i = 0, imax = rows.length; i < imax; ++i) {
-                        this.onColumnResizeWidth(rows[i], index, columnWidth);
+                else {
+                    if (this.checkIfEdgeResizable(columnIndex)) {
+                        result = DTableHeaderCellEdge.RIGHT;
+                    }
+                    else {
+                        result = DTableHeaderCellEdge.NONE;
                     }
                 }
+                this._resizableEdges = result;
             }
+            return result;
         };
-        DTableColumnContainerImpl.prototype.onColumnResizeWeight = function (row, index, columnWeight) {
-            var cells = row.children;
-            var cellsLength = cells.length;
-            var cellsIndex = cellsLength - index - 1;
-            if (0 <= cellsIndex && cellsIndex < cellsLength) {
-                cells[cellsIndex].weight = columnWeight;
+        DTableHeaderCell.prototype.onOver = function (e) {
+            var _this = this;
+            var _a;
+            _super.prototype.onOver.call(this, e);
+            if (this.getResizableEdges() !== DTableHeaderCellEdge.NONE) {
+                var onHoveredBound = ((_a = this._onHoveredBound) !== null && _a !== void 0 ? _a : (this._onHoveredBound = function (event) {
+                    _this.onHovered(event);
+                }));
+                this.on(UtilPointerEvent.move, onHoveredBound);
+                // Since the cursor is set by InteractionManager before this method is called,
+                // the cursor need to be overriden.
+                this.onHovered(e);
+                var layer = DApplications.getLayer(this);
+                if (layer != null) {
+                    layer.renderer.plugins.interaction.cursor = this.cursor;
+                }
             }
         };
-        DTableColumnContainerImpl.prototype.onColumnResizeWidth = function (row, index, columnWidth) {
-            var cells = row.children;
-            var cellsLength = cells.length;
-            var cellsIndex = cellsLength - index - 1;
-            if (0 <= cellsIndex && cellsIndex < cellsLength) {
-                cells[cellsIndex].width = columnWidth;
+        DTableHeaderCell.prototype.onOut = function (e) {
+            _super.prototype.onOut.call(this, e);
+            var onHoveredBound = this._onHoveredBound;
+            if (onHoveredBound != null) {
+                this.state.remove(DTableState.HOVERED_ON_EDGE);
+                this.off(UtilPointerEvent.move, onHoveredBound);
             }
         };
-        Object.defineProperty(DTableColumnContainerImpl.prototype, "width", {
-            get: function () {
-                var result = 0;
-                var items = this.items;
-                var length = items.length;
-                for (var i = 0; i < length; ++i) {
-                    var item = items[i];
-                    var itemWidth = item.width;
-                    if (itemWidth != null) {
-                        result += itemWidth;
-                    }
+        DTableHeaderCell.prototype.onHovered = function (e) {
+            var width = this.width;
+            var x = this.toClickPosition(e);
+            var edgeSize = this._edgeSize;
+            if (0 <= x && x <= edgeSize) {
+                if (this.getResizableEdges() & DTableHeaderCellEdge.LEFT) {
+                    this.state.add(DTableState.HOVERED_ON_EDGE, DTableHeaderCellEdge.LEFT);
                 }
-                return result;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        DTableColumnContainerImpl.prototype.get = function (index) {
-            var columns = this.items;
-            if (0 <= index && index < columns.length) {
-                return columns[index];
-            }
-            return null;
-        };
-        DTableColumnContainerImpl.prototype.each = function (iteratee) {
-            var columns = this.items;
-            for (var i = 0, imax = columns.length; i < imax; ++i) {
-                if (iteratee(columns[i], i) === false) {
-                    break;
+                else {
+                    this.state.remove(DTableState.HOVERED_ON_EDGE);
                 }
             }
-            return this;
-        };
-        DTableColumnContainerImpl.prototype.size = function () {
-            return this.items.length;
-        };
-        return DTableColumnContainerImpl;
-    }(pixi_js.utils.EventEmitter));
-
-    /*
-     * Copyright (C) 2019 Toshiba Corporation
-     * SPDX-License-Identifier: Apache-2.0
-     */
-    var DTableCategoryColumnImpl = /** @class */ (function (_super) {
-        __extends(DTableCategoryColumnImpl, _super);
-        function DTableCategoryColumnImpl(index, column) {
-            var _this = _super.call(this) || this;
-            // Label
-            var category = column.category;
-            if (category) {
-                if (isString(category)) {
-                    if (index === 0) {
-                        _this.label = category;
-                    }
+            else if (width - edgeSize <= x && x <= width) {
+                if (this.getResizableEdges() & DTableHeaderCellEdge.RIGHT) {
+                    this.state.add(DTableState.HOVERED_ON_EDGE, DTableHeaderCellEdge.RIGHT);
                 }
                 else {
-                    if (index < category.length) {
-                        _this.label = category[index];
-                    }
+                    this.state.remove(DTableState.HOVERED_ON_EDGE);
                 }
             }
-            _this._weight = column.weight;
-            _this._width = column.width;
-            _this._isLocked = false;
-            _this.offset = 0.0;
-            _this._columns = [column];
-            _this._nresizable = column.resizable ? 1 : 0;
-            var onResizeBound = function () {
-                _this.onResize();
-            };
-            _this._onResizeBound = onResizeBound;
-            column.on("resize", onResizeBound);
-            return _this;
-        }
-        DTableCategoryColumnImpl.prototype.onResize = function () {
-            if (this._isLocked) {
+            else {
+                this.state.remove(DTableState.HOVERED_ON_EDGE);
+            }
+        };
+        DTableHeaderCell.prototype.onDownEdge = function (onDownPoint, columnIndex, interactionManager) {
+            // Find the resizable cell
+            var left = this.findLeftResizableCell(columnIndex);
+            if (left == null) {
+                // No resizable cell
                 return;
             }
-            var columns = this._columns;
-            if (this._weight != null) {
-                var newWeight = 0;
-                for (var i = 0, imax = columns.length; i < imax; ++i) {
-                    var weight = columns[i].weight;
-                    if (weight != null) {
-                        newWeight += weight;
-                    }
-                }
-                if (this._weight !== newWeight) {
-                    this._weight = newWeight;
-                    this.emit("resize", this);
-                }
+            var header = this._header;
+            var leftColumn = left.column;
+            var leftOldWidth = left.width;
+            var leftOldWeight = left.weight;
+            if (leftColumn.weight == null) {
+                header.state.add(DTableState.RESIZING);
+                var onMove_1 = function (e) {
+                    leftColumn.width = Math.max(1, leftOldWidth + e.data.global.x - onDownPoint);
+                };
+                var onUp_1 = function (e) {
+                    header.state.remove(DTableState.RESIZING);
+                    interactionManager.off(UtilPointerEvent.move, onMove_1);
+                    interactionManager.off(UtilPointerEvent.up, onUp_1);
+                    interactionManager.off(UtilPointerEvent.upoutside, onUp_1);
+                    interactionManager.off(UtilPointerEvent.cancel, onUp_1);
+                };
+                interactionManager.on(UtilPointerEvent.move, onMove_1);
+                interactionManager.on(UtilPointerEvent.up, onUp_1);
+                interactionManager.on(UtilPointerEvent.upoutside, onUp_1);
+                interactionManager.on(UtilPointerEvent.cancel, onUp_1);
             }
             else {
-                var newWidth = 0;
-                for (var i = 0, imax = columns.length; i < imax; ++i) {
-                    var width = columns[i].width;
-                    if (width != null) {
-                        newWidth += width;
-                    }
+                var right = this.findRightResizableCellOfWeight(left.columnIndex);
+                if (right == null) {
+                    // No right resizable cell found
+                    return;
                 }
-                if (this._width !== newWidth) {
-                    this._width = newWidth;
-                    this.emit("resize", this);
+                var rightColumn_1 = right.column;
+                var rightOldWeight = right.weight;
+                var rightOldWidth = right.width;
+                var totalWidth_1 = leftOldWidth + rightOldWidth;
+                var totalWeight_1 = leftOldWeight + rightOldWeight;
+                if (totalWidth_1 <= 0) {
+                    // The left and right resizable cells doesn't have non-zero width
+                    return;
                 }
+                header.state.add(DTableState.RESIZING);
+                var onMove_2 = function (e) {
+                    var leftNewWidth = Math.max(0, Math.min(totalWidth_1, leftOldWidth + e.data.global.x - onDownPoint));
+                    var leftNewWeight = totalWeight_1 * (leftNewWidth / totalWidth_1);
+                    leftColumn.weight = leftNewWeight;
+                    rightColumn_1.weight = totalWeight_1 - leftNewWeight;
+                };
+                var onUp_2 = function (e) {
+                    header.state.remove(DTableState.RESIZING);
+                    interactionManager.off(UtilPointerEvent.move, onMove_2);
+                    interactionManager.off(UtilPointerEvent.up, onUp_2);
+                    interactionManager.off(UtilPointerEvent.upoutside, onUp_2);
+                    interactionManager.off(UtilPointerEvent.cancel, onUp_2);
+                };
+                interactionManager.on(UtilPointerEvent.move, onMove_2);
+                interactionManager.on(UtilPointerEvent.up, onUp_2);
+                interactionManager.on(UtilPointerEvent.upoutside, onUp_2);
+                interactionManager.on(UtilPointerEvent.cancel, onUp_2);
             }
         };
-        Object.defineProperty(DTableCategoryColumnImpl.prototype, "resizable", {
-            get: function () {
-                return 0 < this._nresizable;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(DTableCategoryColumnImpl.prototype, "weight", {
+        Object.defineProperty(DTableHeaderCell.prototype, "sorter", {
             get: function () {
-                return this._weight;
-            },
-            set: function (weight) {
-                var oldWeight = this._weight;
-                var nresizable = this._nresizable;
-                if (0 < nresizable && oldWeight != null && oldWeight !== weight) {
-                    var columns = this._columns;
-                    var columnsLength = columns.length;
-                    var minWeight = this.minWeight;
-                    var newWeight = Math.max(minWeight, weight);
-                    if (this._weight !== newWeight) {
-                        this._isLocked = true;
-                        if (minWeight < oldWeight) {
-                            var columnWeightRatio = (newWeight - minWeight) / (oldWeight - minWeight);
-                            for (var i = 0; i < columnsLength; ++i) {
-                                var column = columns[i];
-                                var columnWeight = column.weight;
-                                if (column.resizable && columnWeight != null) {
-                                    column.weight = columnWeight * columnWeightRatio;
-                                }
-                            }
+                var _this = this;
+                var sorter = this._sorter;
+                if (sorter == null) {
+                    var header = this._header;
+                    if (header) {
+                        var table = header.table;
+                        if (table) {
+                            sorter = table.data.sorter;
+                            this._sorter = sorter;
+                            this._onSorterChangeBound =
+                                this._onSorterChangeBound ||
+                                    (function () {
+                                        _this.onSorterChange();
+                                    });
+                            sorter.on("change", this._onSorterChangeBound);
                         }
                         else {
-                            var newColumnWeight = (newWeight - minWeight) / this._nresizable;
-                            for (var i = 0; i < columnsLength; ++i) {
-                                var column = columns[i];
-                                var columnWeight = column.weight;
-                                if (column.resizable && columnWeight != null) {
-                                    column.weight = newColumnWeight;
-                                }
-                            }
+                            return null;
                         }
-                        this._isLocked = false;
-                        this.onResize();
+                    }
+                    else {
+                        return null;
                     }
                 }
+                return sorter;
             },
             enumerable: false,
             configurable: true
         });
-        Object.defineProperty(DTableCategoryColumnImpl.prototype, "minWeight", {
+        Object.defineProperty(DTableHeaderCell.prototype, "comparator", {
             get: function () {
-                var result = 0;
-                var columns = this._columns;
-                var columnsLength = columns.length;
-                for (var i = 0; i < columnsLength; ++i) {
-                    var column = columns[i];
-                    var columnWeight = column.weight;
-                    if (!column.resizable && columnWeight != null) {
-                        result += columnWeight;
-                    }
-                }
-                return result;
+                return this._column.sorting.comparator || null;
             },
             enumerable: false,
             configurable: true
         });
-        Object.defineProperty(DTableCategoryColumnImpl.prototype, "width", {
-            get: function () {
-                return this._width;
-            },
-            set: function (width) {
-                var oldWidth = this._width;
-                var nresizable = this._nresizable;
-                if (0 < nresizable && oldWidth != null && oldWidth !== width) {
-                    var columns = this._columns;
-                    var columnsLength = columns.length;
-                    var minWidth = this.minWidth;
-                    var newWidth = Math.max(minWidth, width);
-                    if (oldWidth !== newWidth) {
-                        this._isLocked = true;
-                        if (minWidth < oldWidth) {
-                            var columnWidthRatio = (newWidth - minWidth) / (oldWidth - minWidth);
-                            for (var i = 0; i < columnsLength; ++i) {
-                                var column = columns[i];
-                                var columnWidth = column.width;
-                                if (column.resizable && columnWidth != null) {
-                                    column.width = columnWidth * columnWidthRatio;
-                                }
-                            }
+        DTableHeaderCell.prototype.onSorterChange = function () {
+            var comparator = this.comparator;
+            if (comparator) {
+                var sorter = this._sorter;
+                if (sorter) {
+                    var SORTED_ASCENDING = DTableState.SORTED_ASCENDING;
+                    var SORTED_DESCENDING = DTableState.SORTED_DESCENDING;
+                    if (sorter.isApplied() && sorter.get() === comparator) {
+                        if (sorter.order === DTableDataOrder.ASCENDING) {
+                            this.state.set(SORTED_ASCENDING, SORTED_DESCENDING);
                         }
                         else {
-                            var newColumnWidth = (newWidth - minWidth) / this._nresizable;
-                            for (var i = 0; i < columnsLength; ++i) {
-                                var column = columns[i];
-                                var columnWidth = column.width;
-                                if (column.resizable && columnWidth != null) {
-                                    column.width = newColumnWidth;
-                                }
-                            }
+                            this.state.set(SORTED_DESCENDING, SORTED_ASCENDING);
                         }
-                        this._isLocked = false;
-                        this.onResize();
                     }
-                }
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(DTableCategoryColumnImpl.prototype, "minWidth", {
-            get: function () {
-                var result = 0;
-                var columns = this._columns;
-                var columnsLength = columns.length;
-                for (var i = 0; i < columnsLength; ++i) {
-                    var column = columns[i];
-                    var columnWidth = column.width;
-                    if (!column.resizable && columnWidth != null) {
-                        result += columnWidth;
-                    }
-                }
-                return result;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        DTableCategoryColumnImpl.prototype.add = function (column) {
-            this._columns.push(column);
-            if (this._weight != null) {
-                var weight = column.weight;
-                if (weight != null) {
-                    this._weight += weight;
-                    if (column.resizable) {
-                        this._nresizable += 1;
+                    else {
+                        this.state.removeAll(SORTED_ASCENDING, SORTED_DESCENDING);
                     }
-                    column.on("resize", this._onResizeBound);
                 }
             }
-            else if (this._width != null) {
-                var width = column.width;
-                if (width != null) {
-                    this._width += width;
-                    if (column.resizable) {
-                        this._nresizable += 1;
+        };
+        DTableHeaderCell.prototype.toClickPosition = function (e) {
+            var _a;
+            var checkWork = ((_a = this._checkWork) !== null && _a !== void 0 ? _a : (this._checkWork = new pixi_js.Point()));
+            return e.data.getLocalPosition(this, checkWork).x;
+        };
+        DTableHeaderCell.prototype.isCheckClicked = function (e) {
+            if (e instanceof pixi_js.InteractionEvent && this._check.isEnabled) {
+                if (this.isSortable) {
+                    var image = this.image.get(1);
+                    if (image) {
+                        var position = this.toClickPosition(e);
+                        var object = image.object;
+                        if (object != null) {
+                            var bound = object.getLocalBounds();
+                            var margin = image.margin.horizontal;
+                            var x = object.x;
+                            return (x + bound.left - margin <= position &&
+                                position <= x + bound.right + margin);
+                        }
                     }
-                    column.on("resize", this._onResizeBound);
+                }
+                else {
+                    return true;
                 }
             }
+            return false;
         };
-        return DTableCategoryColumnImpl;
-    }(pixi_js.utils.EventEmitter));
-
-    var DTableCategoryContainerImpl = /** @class */ (function () {
-        function DTableCategoryContainerImpl(columns, frozen, options) {
-            var count = this.toCount(columns);
-            var items = [];
-            var offset = 0;
-            for (var i = count - 1; 0 <= i; --i) {
-                var item = new DTableCategory(this.toColumns(i, columns, frozen), frozen, offset, options);
-                items.push(item);
-                offset += item.height;
+        DTableHeaderCell.prototype.isEdgeClicked = function (e) {
+            return (e instanceof pixi_js.InteractionEvent &&
+                (this.state.is(DTableState.HOVERED_ON_EDGE) || this._wasResizing));
+        };
+        DTableHeaderCell.prototype.onClick = function (e) {
+            if (this.state.isActionable) {
+                this.activate(e);
             }
-            this.items = items;
-        }
-        DTableCategoryContainerImpl.prototype.toCount = function (columns) {
-            var result = 0;
-            for (var i = 0, imax = columns.length; i < imax; ++i) {
-                var category = columns[i].category;
-                if (category != null) {
-                    var count = isString(category) ? 1 : category.length;
-                    result = Math.max(result, count);
+        };
+        DTableHeaderCell.prototype.activate = function (e) {
+            this.onActivate(e);
+        };
+        DTableHeaderCell.prototype.onActivate = function (e) {
+            if (!this.isEdgeClicked(e)) {
+                if (this.isCheckClicked(e)) {
+                    this.onToggleStart();
+                    this.onToggleEnd();
+                }
+                else {
+                    this.doSort(e);
+                    this.emit("active", this);
                 }
             }
-            return result;
         };
-        DTableCategoryContainerImpl.prototype.isCategory = function (index, a, b) {
-            if (a != null) {
-                if (b != null) {
-                    if (isString(a)) {
-                        if (isString(b)) {
-                            if (0 < index) {
-                                return true;
-                            }
-                            else {
-                                return a === b;
-                            }
-                        }
-                        else {
-                            if (0 < index) {
-                                return b.length <= index;
-                            }
-                            else {
-                                return b.length === 1 && a === b[0];
-                            }
-                        }
-                    }
-                    else {
-                        if (isString(b)) {
-                            if (0 < index) {
-                                return a.length <= index;
+        DTableHeaderCell.prototype.doSort = function (e) {
+            if (this.isSortable) {
+                var comparator = this.comparator;
+                if (comparator) {
+                    var sorter = this.sorter;
+                    if (sorter) {
+                        if (sorter.get() === comparator) {
+                            if (sorter.order === DTableDataOrder.ASCENDING) {
+                                sorter.order = DTableDataOrder.DESCENDING;
+                                sorter.apply();
                             }
                             else {
-                                return a.length === 1 && a[0] === b;
+                                sorter.set(null);
+                                sorter.apply();
                             }
                         }
                         else {
-                            if (a.length <= index && b.length <= index) {
-                                return true;
-                            }
-                            else if (b.length === a.length) {
-                                for (var i = index, imax = a.length; i < imax; ++i) {
-                                    if (a[i] !== b[i]) {
-                                        return false;
-                                    }
-                                }
-                                return true;
-                            }
-                            return false;
+                            sorter.set(comparator);
+                            sorter.order = DTableDataOrder.ASCENDING;
+                            sorter.apply();
                         }
                     }
                 }
-                else {
-                    if (isString(a)) {
-                        if (0 < index) {
-                            return true;
-                        }
-                        else {
-                            return false;
-                        }
-                    }
-                    else {
-                        if (a.length <= index) {
-                            return true;
-                        }
-                        else {
-                            return false;
-                        }
-                    }
+            }
+        };
+        Object.defineProperty(DTableHeaderCell.prototype, "isSortable", {
+            get: function () {
+                return this._column.sorting.enable;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(DTableHeaderCell.prototype, "isResizable", {
+            get: function () {
+                return this._column.resizable;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(DTableHeaderCell.prototype, "isToggle", {
+            get: function () {
+                return this._check.isEnabled;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DTableHeaderCell.prototype.toggle = function () {
+            if (this.state.isActionable) {
+                if (this.isToggle) {
+                    this.onToggleStart();
+                    this.onToggleEnd();
                 }
             }
+        };
+        DTableHeaderCell.prototype.onToggleStart = function () {
+            this.state.isActive = !this.state.isActive;
+        };
+        DTableHeaderCell.prototype.onToggleEnd = function () {
+            if (this.state.isActive) {
+                this._check.execute(true);
+                this.emit("active", this);
+            }
             else {
-                if (b != null) {
-                    if (isString(b)) {
-                        if (0 < index) {
-                            return true;
-                        }
-                        else {
-                            return false;
-                        }
-                    }
-                    else {
-                        if (b.length <= index) {
-                            return true;
-                        }
-                        else {
-                            return false;
-                        }
-                    }
+                this._check.execute(false);
+                this.emit("inactive", this);
+            }
+        };
+        DTableHeaderCell.prototype.onActivateKeyDown = function (e) {
+            if (this.state.isActionable) {
+                if (this.isToggle) {
+                    this.onToggleStart();
                 }
                 else {
-                    return true;
+                    this.state.isPressed = true;
                 }
             }
         };
-        DTableCategoryContainerImpl.prototype.toColumns = function (index, columns, frozen) {
-            var result = [];
-            var tcolumn = null;
-            var ccolumn = null;
-            for (var i = 0, imax = columns.length; i < imax; ++i) {
-                var column = columns[i];
-                if (i !== frozen &&
-                    ccolumn &&
-                    tcolumn &&
-                    this.isCategory(index, tcolumn.category, column.category)) {
-                    if (ccolumn.weight != null && column.weight != null) {
-                        ccolumn.add(column);
-                    }
-                    else if (ccolumn.width != null && column.width != null) {
-                        ccolumn.add(column);
-                    }
-                    else {
-                        tcolumn = column;
-                        ccolumn = new DTableCategoryColumnImpl(index, column);
-                        result.push(ccolumn);
-                    }
+        DTableHeaderCell.prototype.onActivateKeyUp = function (e) {
+            if (this.state.isActionable) {
+                if (this.isToggle) {
+                    this.onToggleEnd();
                 }
                 else {
-                    tcolumn = column;
-                    ccolumn = new DTableCategoryColumnImpl(index, column);
-                    result.push(ccolumn);
+                    if (this.state.isPressed) {
+                        this.activate(e);
+                    }
+                    this.state.isPressed = false;
                 }
             }
-            return result;
         };
-        return DTableCategoryContainerImpl;
-    }());
+        DTableHeaderCell.prototype.onKeyDown = function (e) {
+            if (UtilKeyboardEvent.isActivateKey(e)) {
+                this.onActivateKeyDown(e);
+            }
+            return _super.prototype.onKeyDown.call(this, e);
+        };
+        DTableHeaderCell.prototype.onKeyUp = function (e) {
+            if (UtilKeyboardEvent.isActivateKey(e)) {
+                this.onActivateKeyUp(e);
+            }
+            return _super.prototype.onKeyUp.call(this, e);
+        };
+        DTableHeaderCell.prototype.getType = function () {
+            return "DTableHeaderCell";
+        };
+        DTableHeaderCell.prototype.destroy = function () {
+            var sorter = this._sorter;
+            var onSorterChangeBound = this._onSorterChangeBound;
+            if (sorter && onSorterChangeBound) {
+                sorter.off("change", onSorterChangeBound);
+            }
+            this._sorter = undefined;
+            this._onSorterChangeBound = undefined;
+            _super.prototype.destroy.call(this);
+        };
+        return DTableHeaderCell;
+    }(DImage));
+
+    /*
+     * Copyright (C) 2019 Toshiba Corporation
+     * SPDX-License-Identifier: Apache-2.0
+     */
+    var DTableHeader = /** @class */ (function (_super) {
+        __extends(DTableHeader, _super);
+        function DTableHeader(table, columns, frozen, offset, options) {
+            var _this = _super.call(this, columns, frozen, options) || this;
+            _this._table = table;
+            _this._offset = offset;
+            _this.transform.position.y = offset;
+            _this.initCells();
+            return _this;
+        }
+        Object.defineProperty(DTableHeader.prototype, "table", {
+            get: function () {
+                return this._table;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DTableHeader.prototype.onParentMove = function (newX, newY, oldX, oldY) {
+            _super.prototype.onParentMove.call(this, newX, newY, oldX, oldY);
+            this.transform.position.y = -newY + this._offset;
+            this.updateFrozenCellPosition(newX);
+        };
+        DTableHeader.prototype.getContentPositionX = function () {
+            var content = this.parent;
+            if (content) {
+                return content.position.x;
+            }
+            return 0;
+        };
+        DTableHeader.prototype.newCell = function (columnIndex, column, columns, options) {
+            return new DTableHeaderCell(this, columnIndex, column, this.toCellOptions(column, options));
+        };
+        DTableHeader.prototype.toCellOptions = function (column, options) {
+            var result = column.header || (options === null || options === void 0 ? void 0 : options.cell);
+            if (result != null) {
+                if (result.weight === undefined) {
+                    result.weight = column.weight;
+                }
+                if (result.width === undefined) {
+                    result.width = column.width;
+                }
+                if (result.text === undefined) {
+                    result.text = {
+                        value: column.label
+                    };
+                }
+                else if (result.text.value === undefined) {
+                    result.text.value = column.label;
+                }
+                return result;
+            }
+            else {
+                return {
+                    weight: column.weight,
+                    width: column.width,
+                    text: {
+                        value: column.label
+                    }
+                };
+            }
+        };
+        DTableHeader.prototype.getType = function () {
+            return "DTableHeader";
+        };
+        return DTableHeader;
+    }(DTableRow));
+
+    var DTableScrollBar = /** @class */ (function (_super) {
+        __extends(DTableScrollBar, _super);
+        function DTableScrollBar() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        DTableScrollBar.prototype.getOffsetVerticalStart = function (size) {
+            return size * 0.5 + this._parent.body.position.y;
+        };
+        return DTableScrollBar;
+    }(DPaneScrollBar));
 
     /*
      * Copyright (C) 2019 Toshiba Corporation
@@ -79231,6 +79236,7 @@
         DImagePieceMarginImpl: DImagePieceMarginImpl,
         DImagePieceTintImpl: DImagePieceTintImpl,
         DImage: DImage,
+        DIndicatorProcessingState: DIndicatorProcessingState,
         DIndicatorProcessing: DIndicatorProcessing,
         DInputAndLabel: DInputAndLabel,
         DInputBooleanButtonOff: DInputBooleanButtonOff,
@@ -79432,7 +79438,11 @@
         DTableBody: DTableBody,
         DTableCategoryCellEdge: DTableCategoryCellEdge,
         DTableCategoryCell: DTableCategoryCell,
+        DTableCategoryColumnImpl: DTableCategoryColumnImpl,
+        DTableCategoryContainerImpl: DTableCategoryContainerImpl,
         DTableCategory: DTableCategory,
+        DTableColumnContainerImpl: DTableColumnContainerImpl,
+        DTableColumnImpl: DTableColumnImpl,
         DTableColumnType: DTableColumnType,
         DTableColumnUpdate: DTableColumnUpdate,
         DTableDataListFilter: DTableDataListFilter,