@refinitiv-ui/efx-grid 6.0.13 → 6.0.15

package/lib/rt-grid/dist/rt-grid.js

@@ -9711,7 +9711,7 @@ DataCache_DataCache.prototype._cloneRowData = function (obj, ric, newSubId) {
 
 /** @protected
  * @ignore
- * @type {!Object.<string, Object.<string, *>>}
+ * @type {!Object.<string, Object>}
  */
 DataCache_DataCache.prototype._rows;
 
@@ -9797,14 +9797,56 @@ DataCache_DataCache._proto = DataCache_DataCache.prototype;
 
 
 // CONCATENATED MODULE: ./node_modules/@grid/core/es6/data/Segment.js
+
+
+
 /** @constructor
 * @param {string} rid
+* @param {!Object} sharedObj
 */
-var Segment = function(rid) {
+var Segment = function(rid, sharedObj) {
 	this._rid = rid;
 	this._children = {};
+	this._shared = sharedObj;
 };
+Ext["b" /* default */].inherits(Segment, EventDispatcher["b" /* default */]);
 
+/** @private
+* @function
+* @param {string} a
+* @param {string} b
+* @return {number}
+*/
+Segment._subSegSortLogic = function(a, b) {
+	if(a === "Uncategorized") {
+		return 1;
+	}
+	if(b === "Uncategorized") {
+		return -1;
+	}
+
+	if(a < b) {
+		return -1;
+	}
+	if(b < a) {
+		return 1;
+	}
+
+	return 0;
+};
+/** @private
+* @function
+* @param {Segment} segment
+* @param {number} idx
+*/
+Segment._assignSubSegmentOrder = function(segment, idx) {
+	segment.setOrder(idx + 1);
+};
+
+/** @type {Object}
+* @private
+*/
+Segment.prototype._shared = null;
 
 /** @type {string}
 * @private
@@ -9825,13 +9867,67 @@ Segment.prototype._collapsed = false;
 /** @type {number}
 * @private
 */
-Segment.prototype._value = 0;
+Segment.prototype._order = 0;
+/** @type {boolean}
+* @private
+*/
+Segment.prototype._disposed = false;
+
+/** @type {Object}
+* @private
+*/
+Segment.prototype._subSegDef = null;
 /** @type {number}
 * @private
 */
-Segment.prototype._order = 0;
+Segment.prototype._subSegLevel = 0;
+/** @type {Object.<string, Segment>}
+* @private
+*/
+Segment.prototype._subSegMap = null; // For immediate sub-segment children
+/** @type {Array.<string>}
+* @private
+*/
+Segment.prototype._subSegNames = null; // For immediate sub-segment child names
+/** @type {string}
+* @private
+*/
+Segment.prototype._subSegName = "";
+/** @type {*}
+* @private
+*/
+Segment.prototype._subSegVal;
+/** @type {Segment}
+* @private
+*/
+Segment.prototype._subSegParent = null;
 
 
+/** @public
+*/
+Segment.prototype.dispose = function() {
+	if(this._disposed) {
+		return;
+	}
+	this._disposed = true;
+
+	this.removeAllEventListeners();
+	var segmentNames = this._subSegNames;
+	if(segmentNames) {
+		var segmentCount = segmentNames.length;
+		var segmentMap = this._subSegMap;
+		for(var i = 0; i < segmentCount; ++i) {
+			segmentMap[segmentNames[i]].dispose();
+		}
+		this._subSegMap = this._subSegNames = null;
+	}
+	if(this._collapsed) {
+		this._shared.dirtyCollapsingState = true;
+	}
+
+	this._shared = null;
+	this._subSegParent = this._subSegDef = this._subSegVal = null;
+};
 /** @public
 * @return {string}
 */
@@ -9839,32 +9935,66 @@ Segment.prototype.getId = function() {
 	return this._rid;
 };
 /** @public
+* @return {string}
+*/
+Segment.prototype.getParentId = function() {
+	if(this._subSegParent) {
+		return this._subSegParent.getId();
+	}
+	return "";
+};
+/** @public
+* @param {Array.<string>=} out_ary
+* @return {Array.<string>}
+*/
+Segment.prototype.getSubSegmentIds = function(out_ary) {
+	var segmentNames = this._subSegNames;
+	if(segmentNames) {
+		if(!out_ary) {
+			out_ary = [];
+		}
+		var segmentCount = segmentNames.length;
+		var segmentMap = this._subSegMap;
+		for(var i = 0; i < segmentCount; ++i) {
+			var segmentName = segmentNames[i];
+			var segment = segmentMap[segmentName];
+			out_ary.push(segment.getId());
+			segment.getSubSegmentIds(out_ary);
+		}
+
+		return out_ary;
+	}
+	return null;
+};
+/** @public
 * @param {string} rid
-* @param {Object=} objMap
+* @param {string=} dataId Row id for retrieving data
 * @return {boolean}
 */
-Segment.prototype.addChild = function(rid, objMap) {
-	if(rid && !this._children[rid]) {
-		if(objMap) {
-			objMap[rid] = this._rid;
+Segment.prototype.addChild = function(rid, dataId) {
+	if(rid) {
+		this._shared.childToSegment[rid] = this._rid;
+		if(this._collapsed) {
+			this._shared.dirtyCollapsingState = true; // TODO: Check if we need to update this only when new child is added
+		}
+		if(!this._children[rid]) {
+			this._children[rid] = dataId || rid;
+			++this._childCount;
+			return true;
 		}
-		this._children[rid] = 1;
-		++this._childCount;
-		return true;
 	}
 	return false;
 };
 /** @public
 * @param {Array.<string>} rids
-* @param {Object=} objMap
 * @return {boolean}
 */
-Segment.prototype.addChildren = function(rids, objMap) {
+Segment.prototype.addChildren = function(rids) {
 	var rowIds = Array.isArray(rids) ? rids : [rids];
 	var rowCount = rowIds.length;
 	var dirty = 0;
 	for(var i = 0; i < rowCount; ++i) {
-		dirty |= this.addChild(rowIds[i], objMap);
+		dirty |= this.addChild(rowIds[i]);
 	}
 	return dirty ? true : false;
 };
@@ -9877,26 +10007,37 @@ Segment.prototype.containsChild = function(rid) {
 };
 /** @public
 * @param {string} rid
-* @param {Object=} objMap
 * @return {boolean}
 */
-Segment.prototype.removeChild = function(rid, objMap) {
-	if(this._childCount && this._children[rid]) {
-		if(objMap) {
-			delete objMap[rid];
-		}
-		delete this._children[rid]; // Slow
-		--this._childCount;
-		return true;
+Segment.prototype.removeChild = function(rid) {
+	if(this._subSegLevel) {
+		return false; // Sub segments are not allowed to remove its children
 	}
-	return false;
+	if(!this._childCount) {
+		return false;
+	}
+	if(!this._children[rid]) {
+		return false; // The specified rid is not a child of this segment
+	}
+
+	var objMap = this._shared.childToSegment;
+	delete objMap[rid];
+	delete this._children[rid]; // Slow
+	--this._childCount;
+
+	if(this._collapsed) {
+		this._shared.dirtyCollapsingState = true;
+	}
+	return true;
 };
 /** @public
 * @param {Array.<string>} rids
-* @param {Object=} objMap
 * @return {boolean}
 */
-Segment.prototype.removeChildren = function(rids, objMap) {
+Segment.prototype.removeChildren = function(rids) {
+	if(this._subSegLevel) {
+		return false; // Sub segments are not allowed to remove its children
+	}
 	if(!this._childCount) {
 		return false;
 	}
@@ -9904,7 +10045,7 @@ Segment.prototype.removeChildren = function(rids, objMap) {
 	var rowCount = rowIds.length;
 	var dirty = 0;
 	for(var i = 0; i < rowCount; ++i) {
-		dirty |= this.removeChild(rowIds[i], objMap);
+		dirty |= this.removeChild(rowIds[i]);
 	}
 	return dirty ? true : false;
 };
@@ -9912,21 +10053,27 @@ Segment.prototype.removeChildren = function(rids, objMap) {
 * @param {Object=} objMap
 * @return {boolean}
 */
-Segment.prototype.removeAllChildren = function(objMap) {
-	if(this._childCount) {
-		if(objMap) {
-			var chdr = this._children;
-			for(var rid in chdr) {
-				if(objMap[rid]) {
-					delete objMap[rid];
-				}
-			}
+Segment.prototype.removeAllChildren = function() {
+	if(this._subSegLevel) {
+		return false; // Sub segments are not allowed to remove its children
+	}
+	if(!this._childCount) {
+		return false;
+	}
+	var objMap = this._shared.childToSegment;
+	var chdr = this._children;
+	for(var rid in chdr) {
+		if(objMap[rid]) {
+			delete objMap[rid]; // TODO: Check if we need to do this
 		}
-		this._children = {};
-		this._childCount = 0;
-		return true;
 	}
-	return false;
+	this._children = {};
+	this._childCount = 0;
+
+	if(this._collapsed) {
+		this._shared.dirtyCollapsingState = true;
+	}
+	return true;
 };
 /** @public
 * @return {!Array.<string>}
@@ -9942,6 +10089,309 @@ Segment.prototype.getChildCount = function() {
 };
 
 
+/** @public
+* @return {Array.<string>} fields
+*/
+Segment.prototype.getClassification = function() {
+	if(this._subSegDef) {
+		return this._subSegDef.classifiers || null;
+	}
+	return null;
+};
+/** @public
+* @param {string|Array.<string>} fields
+* @return {boolean}
+*/
+Segment.prototype.setClassification = function(fields) {
+	if(this._subSegLevel) {
+		return false; // non-root segment cannot be classified
+	}
+	var classifiers = null;
+	if(this._subSegDef) {
+		classifiers = this._subSegDef.classifiers;
+	}
+
+	var newClassifiers = null;
+	if(fields) {
+		if(typeof fields === "string") {
+			newClassifiers = [fields];
+		} else if(Array.isArray(fields)) {
+			newClassifiers = fields;
+		}
+	}
+	var i;
+	var fieldCount = newClassifiers ? newClassifiers.length : 0;
+
+	if(fieldCount) {
+		var curCount = classifiers ? classifiers.length : 0;
+		if(curCount === fieldCount) { // Check duplication
+			for(i = 0; i < fieldCount; ++i) {
+				if(newClassifiers[i] !== classifiers[i]) {
+					break;
+				}
+			}
+			if(i >= fieldCount) {
+				return false; // nothing has change
+			}
+		}
+
+		if(!this._subSegDef) {
+			this._subSegDef = {
+				root: this,
+				subSegments: null
+			};
+		}
+
+		this._subSegDef.classifiers = newClassifiers;
+		// this._subSegDef.classifierChanged = true;
+		return true;
+	} else if(classifiers) { // Remove existing ones
+		this._subSegDef.classifiers = null;
+		this._subSegDef.subSegments = null;
+		// this._subSegDef.classifierChanged = true;
+		this._subSegDef = null; // WARNING: All sub segments remain existing
+		return true;
+	}
+	return false;
+};
+/** @public
+* @param {Object.<string, Object>=} rows Object maps between row id and its record
+* @return {boolean}
+*/
+Segment.prototype.classify = function(rows) {
+	var classifiers = this._subSegDef ? this._subSegDef.classifiers : null;
+	var classifierCount = classifiers ? classifiers.length : 0;
+
+	var segmentNames = this._subSegNames;
+	var segmentCount = segmentNames ? segmentNames.length : 0;
+
+	if(!segmentCount) {
+		if(this._subSegLevel >= classifierCount) {
+			return false; // Current segment level is beyond existing classification level and this segment should already be removed
+		}
+	}
+
+	// Prepare existing sub segments for checking change in its members
+	var i;
+	var segmentName = "";
+	var nonExistenceGroups = {};
+	var removalCount = 0;
+	var segmentMap = this._subSegMap;
+	var segment = null;
+	if(segmentCount) {
+		removalCount = segmentCount;
+		for(i = 0; i < removalCount; ++i) {
+			segmentName = segmentNames[i];
+			nonExistenceGroups[segmentName] = 1;
+
+			segment = segmentMap[segmentName];
+			if(segment._childCount) { // Quick cleaning up
+				segment._children = {};
+				segment._childCount = 0;
+			}
+		}
+	}
+
+	// Loop through row children and assign them to their corresponding sub segment
+	var isRootSegment = !this._subSegLevel;
+	var rid;
+	var children = this._children;
+	if(this._subSegLevel < classifierCount && rows) {
+		if(!segmentMap) {
+			segmentMap = this._subSegMap = {};
+			segmentNames = this._subSegNames = [];
+		}
+
+		var classifier = classifiers[this._subSegLevel];
+
+		for(rid in children) {
+			var dataId = children[rid];
+			var record = rows[dataId];
+			var val = record ? record[classifier] : null; // WARNING: row could already be removed
+
+			this._shared.childToSegment[rid] = this._rid; // Relocate child in case of it has been moved to a non existence group
+
+			segmentName = "Uncategorized";
+			if(val || val === 0 || val === false) { // Check for null, undefined, "", and NaN value
+				segmentName = val + "";
+			}
+			if(nonExistenceGroups[segmentName]) {
+				nonExistenceGroups[segmentName] = 0;
+				--removalCount;
+			}
+
+			segment = segmentMap[segmentName];
+			if(!segment) { // New group is detected
+				segment = new Segment(this._rid + "/" + segmentName, this._shared);
+				segment._subSegDef = this._subSegDef;
+				segment._subSegLevel = this._subSegLevel + 1;
+				segment._subSegName = segmentName;
+				segment._subSegVal = val;
+				segment._subSegParent = this;
+
+				segmentMap[segmentName] = segment;
+				segmentNames.push(segmentName);
+
+				this._dispatch("subSegmentAdded", {
+					"rid": segment.getId(),
+					"segment": segment
+				});
+			}
+
+			segment.addChild(rid, dataId);
+		}
+	} else if(isRootSegment) { // In case of no classification
+		for(rid in children) {
+			this._shared.childToSegment[rid] = this._rid; // Relocate child in case of it has been moved to a non existence group
+		}
+	}
+
+	// Remove all sub segments with no members
+	if(removalCount > 0) {
+		if(removalCount >= segmentNames.length) {
+			segmentNames.length = 0;
+		}
+		for(segmentName in nonExistenceGroups) {
+			if(nonExistenceGroups[segmentName]) {
+				segment = segmentMap[segmentName];
+				delete segmentMap[segmentName];
+				// TODO: Slow
+				var at = segmentNames.indexOf(segmentName);
+				if(at >= 0) {
+					segmentNames.splice(at, 1);
+				}
+
+				this._dispatch("subSegmentRemoved", {
+					"rid": segment.getId(),
+					"segment": segment
+				});
+
+				// segment.dispose(); Already done by segment collection
+			}
+		}
+		if(!segmentNames.length) {
+			segmentNames = this._subSegMap = this._subSegNames = null;
+		}
+	}
+
+	// Sort and classify existing sub segments
+	segmentCount = segmentNames ? segmentNames.length : 0;
+	if(segmentCount) {
+		segmentNames.sort(Segment._subSegSortLogic);
+		for(i = 0; i < segmentCount; ++i) {
+			segment = segmentMap[segmentNames[i]];
+			segment.classify(rows);
+		}
+	}
+
+	// Collecting all sub segments including all descendants and reassigning segment order.
+	if(isRootSegment) { // If this is a root segment
+		if(this._subSegDef) {
+			if(segmentCount) {
+				var subSegments = this._subSegDef.subSegments = [];
+				this.getAllSubSegments(subSegments);
+				subSegments.forEach(Segment._assignSubSegmentOrder);
+			} else {
+				this._subSegDef.subSegments = null;
+			}
+			// this._subSegDef.classifierChanged = false;
+		}
+	}
+	return true;
+};
+/** @public
+* @return {boolean}
+*/
+Segment.prototype.hasSubSegments = function() {
+	if(this._subSegNames) {
+		return this._subSegNames.length ? true : false;
+	}
+	return false;
+};
+/** @public
+* @return {boolean}
+*/
+Segment.prototype.isSubSegment = function() {
+	return this._subSegLevel ? true : false;
+};
+/** @public
+* @return {Segment}
+*/
+Segment.prototype.getFirstAncestor = function() {
+	if(this._subSegLevel && this._subSegDef) {
+		var ancestor = this._subSegDef.root;
+		return /** @type{Segment} */(ancestor) || null;
+	}
+	return null;
+};
+/** @public
+* @param {Array.<Segment>=} out_ary
+* @return {Array.<Segment>}
+*/
+Segment.prototype.getAllSubSegments = function(out_ary) {
+	var segmentNames = this._subSegNames;
+	if(segmentNames) {
+		if(!out_ary) {
+			out_ary = [];
+		}
+		var segmentMap = this._subSegMap;
+		var segmentCount = segmentNames.length;
+		for(var i = 0; i < segmentCount; ++i) {
+			var segment = segmentMap[segmentNames[i]];
+			out_ary.push(segment);
+			segment.getAllSubSegments(out_ary);
+		}
+	}
+	return out_ary;
+};
+/** @public
+* @return {number}
+*/
+Segment.prototype.getSegmentLevel = function() {
+	return this._subSegLevel;
+};
+/** This method will be called on sub segments only
+* @public
+* @param {Object=} rows
+* @param {Object=} clsSource
+*/
+Segment.prototype.setRowData = function(rows, clsSource) {
+	if(!rows) {
+		return;
+	}
+	var row = rows[this._rid];
+	if(!row) {
+		row = rows[this._rid] = {};
+	}
+
+	if(!clsSource) {
+		clsSource = rows;
+	}
+	row = clsSource[this._rid];
+	if(!row) {
+		row = clsSource[this._rid] = {};
+	}
+
+	var segment = this;
+	while(segment && segment.isSubSegment()) {
+		segment.getSubSegmentName(row);
+		segment = segment._subSegParent;
+	}
+};
+/** @public
+* @param {Object=} row
+* @return {string}
+*/
+Segment.prototype.getSubSegmentName = function(row) {
+	if(row && this._subSegLevel) {
+		var classifiers = this.getClassification();
+		var field = classifiers[this._subSegLevel - 1];
+		if(field) {
+			row[field] = this._subSegName;
+		}
+	}
+	return this._subSegName;
+};
 
 /** @public
 * @param {boolean=} bool
@@ -9951,6 +10401,7 @@ Segment.prototype.collapse = function(bool) {
 	bool = (bool !== false);
 	if(this._collapsed !== bool) {
 		this._collapsed = bool;
+		this._shared.dirtyCollapsingState = true;
 		return true;
 	}
 	return false;
@@ -9970,44 +10421,109 @@ Segment.prototype.isCollapsed = function() {
 };
 /** @public
 * @param {Object=} objMap
-* @return {!Object}
+* @param {boolean=} parentState=false Collapsing state from parent segment
+* @return {number}
 */
-Segment.prototype.getCollapsingStates = function(objMap) {
+Segment.prototype.getCollapsingStates = function(objMap, parentState) {
+	var segmentNames = this._subSegNames;
+	if(!this._subSegLevel) { // Only root segment
+		if(!segmentNames) { // No sub segment
+			if(!this._collapsed) {
+				return false;
+			}
+		}
+	}
+
 	if(!objMap) {
 		objMap = {};
 	}
+	var dirty = false;
+	if(this._subSegLevel) { // Sub segments are also subjected to collapsing
+		if(parentState) {
+			objMap[this._rid] = true;
+			dirty = true;
+		}
+	}
 	if(this._childCount) {
-		var chdr = this._children;
-		var collapsed = this._collapsed;
-		for(var rid in chdr) {
-			objMap[rid] = collapsed;
+		var collapsed = parentState || this._collapsed;
+		if(segmentNames) {
+			var segmentMap = this._subSegMap;
+			var segmentCount = segmentNames.length;
+			for(var i = 0; i < segmentCount; ++i) {
+				var segment = segmentMap[segmentNames[i]];
+				objMap[segment.getId()] = !!parentState;
+				if(segment.getCollapsingStates(objMap, collapsed)) {
+					dirty = true;
+				}
+			}
+		} else if(collapsed) {
+			var chdr = this._children;
+			for(var rid in chdr) {
+				objMap[rid] = collapsed;
+			}
+			dirty = true;
 		}
 	}
-	return objMap;
+	return dirty;
 };
+
 /** @public
 * @return {number}
 */
-Segment.prototype.getValue = function() {
-	return this._value;
+Segment.prototype.getOrder = function() {
+	if(this._subSegLevel) {
+		var ancestor = this.getFirstAncestor();
+		if(ancestor) {
+			// WARNING: this._order cannot be greater than 9999
+			return ancestor.getOrder() + this._order;
+		}
+	}
+	return this._order * 10000;
 };
 /** @public
 * @param {number} val
 */
-Segment.prototype.setValue = function(val) {
-	this._value = val;
+Segment.prototype.setOrder = function(val) {
+	this._order = val;
 };
-/** @public
-* @return {number}
+
+/** @private
+* @type {Array.<string>}
 */
-Segment.prototype.getOrder = function() {
-	return this._order;
-};
+Segment._tabs = null;
 /** @public
-* @param {number} val
+* @param {Array.<string>} lines
+* @return {Array.<string>} lines
 */
-Segment.prototype.setOrder = function(val) {
-	this._order = val;
+Segment.prototype.log = function(lines) {
+	var i;
+	var tabs = Segment._tabs;
+	if(!tabs) {
+		tabs = Segment._tabs = [];
+		var tabCh = "";
+		for(i = 0; i < 11; ++i) {
+			tabs[i] = tabCh;
+			tabCh += "  ";
+		}
+	}
+	var collapsedCh = this._collapsed ? "+ " : "- ";
+	lines.push(tabs[this._subSegLevel] + collapsedCh + this._rid);
+
+	var segmentNames = this._subSegNames;
+	if(segmentNames) {
+		var segmentCount = segmentNames.length;
+		var segmentMap = this._subSegMap;
+		for(i = 0; i < segmentCount; ++i) {
+			segmentMap[segmentNames[i]].log(lines);
+		}
+	} else if(this._childCount) {
+		var indent = tabs[this._subSegLevel + 1];
+		for(var rid in this._children) {
+			lines.push(indent + "- " + rid);
+		}
+	}
+
+	return lines;
 };
 
 
@@ -10017,18 +10533,30 @@ Segment.prototype.setOrder = function(val) {
 // CONCATENATED MODULE: ./node_modules/@grid/core/es6/data/SegmentCollection.js
 
 
+
+
 /** @constructor
 */
 var SegmentCollection = function() {
+	this._onSubSegmentAdded = this._onSubSegmentAdded.bind(this);
+	this._onSubSegmentRemoved = this._onSubSegmentRemoved.bind(this);
+
 	this._segments = {};
-	this._childToSegmentId = {};
+	this._insertionList = [];
+	this._removalList = [];
+
+	this._shared = {
+		childToSegment: {}, // child Id to segment Id
+		dirtyCollapsingState: false
+	};
 };
+Ext["b" /* default */].inherits(SegmentCollection, EventDispatcher["b" /* default */]);
 
 
 /** @type {!Object.<string, Segment>}
 * @private
 */
-SegmentCollection.prototype._segments;
+SegmentCollection.prototype._segments; // Contains both segment and their sub segments
 /** @type {number}
 * @private
 */
@@ -10037,28 +10565,53 @@ SegmentCollection.prototype._segmentCount = 0;
 * @private
 */
 SegmentCollection.prototype._collapsedRids = null;
+/** @type {!Object}
+* @private
+*/
+SegmentCollection.prototype._shared;
+/** @type {Array.<Segment>}
+* @private
+*/
+SegmentCollection.prototype._segmentList = null; // Array of main segments
+/** @type {Array.<Segment>}
+* @private
+*/
+SegmentCollection.prototype._insertionList = null; // Array of sub segments
+/** @type {Array.<string>}
+* @private
+*/
+SegmentCollection.prototype._removalList = null; // Array of sub segment ids
 /** @type {boolean}
 * @private
 */
-SegmentCollection.prototype._dirtyCollapsingState = false;
-/** @type {!Object.<string, string>}
+SegmentCollection.prototype._classification = false;
+/** @type {boolean}
 * @private
 */
-SegmentCollection.prototype._childToSegmentId;
-
+SegmentCollection.prototype._classifierChanged = false;
 
+/** @public
+*/
+SegmentCollection.prototype.dispose = function() {
+	this.removeAllSegments();
+	this._collapsedRids = null;
+	this._segmentList = this._insertionList = this._removalList = null;
+};
 /** @public
 * @param {string} rid
 * @return {boolean} Returns true if there is any change. Otherwise, returns false
 */
 SegmentCollection.prototype.addSegment = function(rid) {
 	if(rid && !this._segments[rid]) {
-		if(this._childToSegmentId[rid]) {
+		if(this.getParentRowId(rid)) {
 			console.log("child of a segment cannot be set as a segment separator");
 			return false;
 		}
-		this._segments[rid] = new data_Segment(rid);
+		var segment = this._segments[rid] = new data_Segment(rid, this._shared);
+		segment.addEventListener("subSegmentAdded", this._onSubSegmentAdded);
+		segment.addEventListener("subSegmentRemoved", this._onSubSegmentRemoved);
 		++this._segmentCount;
+		this._segmentList = null; // order could be changed
 		return true;
 	}
 	return false;
@@ -10088,7 +10641,7 @@ SegmentCollection.prototype.containsSegment = function(rid) {
 * @return {string} parent row id of this segmentation. If the parent row id for this segmentation cannot be found, return ""
 */
 SegmentCollection.prototype.getParentRowId = function(rid) {
-	return this._childToSegmentId[rid] || "";
+	return this._shared.childToSegment[rid] || "";
 };
 /** @public
 * @param {string} rid
@@ -10097,10 +10650,27 @@ SegmentCollection.prototype.getParentRowId = function(rid) {
 SegmentCollection.prototype.removeSegment = function(rid) {
 	var segment = this._segments[rid];
 	if(segment) {
-		if(segment.isCollapsed()) {
-			this._dirtyCollapsingState = true;
+		if(this._segmentCount <= 1) {
+			return this.removeAllSegments();
+		}
+		if(segment.isSubSegment()) {
+			this._removalList.push(segment.getId());
 		}
-		segment.removeAllChildren(this._childToSegmentId);
+		var subSegIds = segment.getSubSegmentIds();
+		if(subSegIds) {
+			var len = subSegIds.length;
+			for(var i = 0; i < len; ++i) {
+				var subSegId = subSegIds[i];
+				if(this._segments[subSegId]) {
+					this._removalList.push(subSegId);
+					delete this._segments[subSegId]; // Slow
+					--this._segmentCount;
+				}
+			}
+		}
+		segment.removeAllChildren(); // This is important for updating childToSegment
+		segment.dispose();
+
 		delete this._segments[rid]; // Slow
 		--this._segmentCount;
 		return true;
@@ -10112,10 +10682,15 @@ SegmentCollection.prototype.removeSegment = function(rid) {
 */
 SegmentCollection.prototype.removeAllSegments = function() {
 	if(this._segmentCount) {
+		for(var key in this._segments) {
+			this._segments[key].dispose();
+		}
 		this._segments = {};
-		this._childToSegmentId = {};
 		this._segmentCount = 0;
-		this._dirtyCollapsingState = true;
+		this._segmentList = null;
+		this._shared.childToSegment = {};
+
+		this._classification = this._classifierChanged = false;
 		return true;
 	}
 	return false;
@@ -10156,11 +10731,7 @@ SegmentCollection.prototype.getSegmentIds = function() {
 SegmentCollection.prototype.collapseSegment = function(segmentId, bool) {
 	var segment = this._segments[segmentId];
 	if(segment) {
-		var dirty = segment.collapse(bool);
-		if(dirty) {
-			this._dirtyCollapsingState = true;
-			return true;
-		}
+		return segment.collapse(bool);
 	}
 	return false;
 };
@@ -10183,7 +10754,6 @@ SegmentCollection.prototype.expandAllSegments = function() {
 			dirty |= segmentSeparators[rid].expand();
 		}
 		if(dirty) {
-			this._dirtyCollapsingState = true;
 			return true;
 		}
 	}
@@ -10204,17 +10774,19 @@ SegmentCollection.prototype.isCollapsedSegment = function(segmentId) {
 * @return {Object}
 */
 SegmentCollection.prototype.getCollapsedRows = function() {
-	if(this._dirtyCollapsingState) {
-		this._dirtyCollapsingState = false;
+	if(this._shared.dirtyCollapsingState) {
+		this._shared.dirtyCollapsingState = false;
 		var collapsedRids = null;
 		var count = 0;
 		if(this._segmentCount) {
 			var segmentSeparators = this._segments;
 			collapsedRids = {};
 			for(var rid in segmentSeparators) {
-				if(segmentSeparators[rid].isCollapsed()) {
-					segmentSeparators[rid].getCollapsingStates(collapsedRids);
-					++count;
+				var segment = segmentSeparators[rid];
+				if(!segment.isSubSegment()) {
+					if(segment.getCollapsingStates(collapsedRids)) {
+						++count;
+					}
 				}
 			}
 		}
@@ -10226,18 +10798,13 @@ SegmentCollection.prototype.getCollapsedRows = function() {
 /** @public
 * @param {string} segmentId
 * @param {string} rid
+* @param {string=} dataId Row id for retrieving data
 * @return {boolean} Returns true if there is any change. Otherwise, returns false
 */
-SegmentCollection.prototype.addSegmentChild = function(segmentId, rid) {
+SegmentCollection.prototype.addSegmentChild = function(segmentId, rid, dataId) {
 	var segment = this._segments[segmentId];
-	if(segment) {
-		var dirty = segment.addChild(rid, this._childToSegmentId);
-		if(dirty) {
-			if(segment.isCollapsed()) {
-				this._dirtyCollapsingState = true;
-			}
-			return true;
-		}
+	if(segment && !segment.isSubSegment()) {
+		return segment.addChild(rid, dataId);
 	}
 	return false;
 };
@@ -10248,14 +10815,8 @@ SegmentCollection.prototype.addSegmentChild = function(segmentId, rid) {
 */
 SegmentCollection.prototype.addSegmentChildren = function(segmentId, rids) {
 	var segment = this._segments[segmentId];
-	if(segment) {
-		var dirty = segment.addChildren(rids, this._childToSegmentId);
-		if(dirty) {
-			if(segment.isCollapsed()) {
-				this._dirtyCollapsingState = true;
-			}
-			return true;
-		}
+	if(segment && !segment.isSubSegment()) {
+		return segment.addChildren(rids);
 	}
 	return false;
 };
@@ -10279,13 +10840,7 @@ SegmentCollection.prototype.containsSegmentChild = function(segmentId, rid) {
 SegmentCollection.prototype.removeSegmentChild = function(segmentId, rid) {
 	var segment = this._segments[segmentId];
 	if(segment) {
-		var dirty = segment.removeChild(rid, this._childToSegmentId);
-		if(dirty) {
-			if(segment.isCollapsed()) {
-				this._dirtyCollapsingState = true;
-			}
-			return true;
-		}
+		return segment.removeChild(rid);
 	}
 	return false;
 };
@@ -10297,13 +10852,7 @@ SegmentCollection.prototype.removeSegmentChild = function(segmentId, rid) {
 SegmentCollection.prototype.removeSegmentChildren = function(segmentId, rids) {
 	var segment = this._segments[segmentId];
 	if(segment) {
-		var dirty = segment.removeChildren(rids, this._childToSegmentId);
-		if(dirty) {
-			if(segment.isCollapsed()) {
-				this._dirtyCollapsingState = true;
-			}
-			return true;
-		}
+		return segment.removeChildren(rids);
 	}
 	return false;
 };
@@ -10311,20 +10860,20 @@ SegmentCollection.prototype.removeSegmentChildren = function(segmentId, rids) {
 * @return {boolean} Returns true if there is any change. Otherwise, returns false
 */
 SegmentCollection.prototype.removeAllSegmentChildren = function() {
-	this._childToSegmentId = {};
+	this._shared.childToSegment = {};
 	var segmentSeparators = this._segments;
-	var dirtyCollapsingState = this._dirtyCollapsingState;
 	var dirty = false;
 	for(var rid in segmentSeparators) {
-		var segment = this._segments[rid];
+		var segment = segmentSeparators[rid];
 		if(segment.removeAllChildren()) {
 			dirty = true;
-			if(!dirtyCollapsingState && segment.isCollapsed()) {
-				dirtyCollapsingState = this._dirtyCollapsingState = true;
-			}
 		}
 	}
 
+	if(dirty) {
+		this.classify();
+	}
+
 	return dirty;
 };
 
@@ -10338,22 +10887,18 @@ SegmentCollection.prototype.fillSegment = function(segmentId, rids) {
 		return;
 	}
 	var segmentSeparators = this._segments;
-	var childToSegmentId = this._childToSegmentId;
 	var curSegment = segmentSeparators[segmentId];
-	if(curSegment) {
+	if(curSegment && !curSegment.isSubSegment()) {
 		var segmentAt = rids.indexOf(segmentId);
 		if(segmentAt >= 0) {
-			if(curSegment.isCollapsed()) {
-				this._dirtyCollapsingState = true;
-			}
-			curSegment.removeAllChildren(childToSegmentId);
+			curSegment.removeAllChildren();
 			for(var r = segmentAt + 1; r < rowCount; ++r) {
 				var rid = rids[r];
 				var segmentSeparator = segmentSeparators[rid];
 				if(segmentSeparator) {
 					break;
 				}
-				curSegment.addChild(rid, childToSegmentId);
+				curSegment.addChild(rid);
 			}
 		}
 	}
@@ -10363,23 +10908,20 @@ SegmentCollection.prototype.fillSegment = function(segmentId, rids) {
 * @return {boolean} Return true if the fill segments have changed, otherwise return false
 */
 SegmentCollection.prototype.fillSegments = function(rids) {
+	this._shared.childToSegment = {};
+
 	var rowCount = Array.isArray(rids) ? rids.length : 0;
-	this._childToSegmentId = {};
 	var segmentSeparators = this._segments;
-	var childToSegmentId = this._childToSegmentId;
 	var curSegment = null;
 	var change = false;
 	for(var r = 0; r < rowCount; ++r) {
 		var rid = rids[r];
 		var segmentSeparator = segmentSeparators[rid];
-		if(segmentSeparator) {
+		if(segmentSeparator && !segmentSeparator.isSubSegment()) {
 			curSegment = segmentSeparator;
-			if(curSegment.isCollapsed()) {
-				this._dirtyCollapsingState = true;
-			}
 			curSegment.removeAllChildren();
-		} else if(curSegment) {
-			curSegment.addChild(rid, childToSegmentId);
+		} else if(curSegment && !curSegment.isSubSegment()) {
+			curSegment.addChild(rid);
 			change = true;
 		}
 	}
@@ -10389,6 +10931,13 @@ SegmentCollection.prototype.fillSegments = function(rids) {
 * @param {Array.<string>} rids
 */
 SegmentCollection.prototype.calcSegmentOrder = function(rids) {
+	var segmentList = this._segmentList;
+	if(segmentList) {
+		segmentList.length = 0;
+	} else {
+		segmentList = this._segmentList = [];
+	}
+
 	var ridCount = rids ? rids.length : 0;
 	var segmentSeparators = this._segments;
 	var segmentCount = this._segmentCount;
@@ -10397,8 +10946,11 @@ SegmentCollection.prototype.calcSegmentOrder = function(rids) {
 		var rid = rids[i];
 		var segment = segmentSeparators[rid];
 		if(segment) {
-			segment.setOrder(++order);
-			if(order >= segmentCount) {
+			if(!segment.isSubSegment()) {
+				this._segmentList.push(segment);
+				segment.setOrder(++order); // WARNING: Segments and sub segments start with 1
+			}
+			if(--segmentCount <= 0) {
 				break;
 			}
 		}
@@ -10414,7 +10966,7 @@ SegmentCollection.prototype.getSegmentValues = function(rids) {
 		return null;
 	}
 	var segmentSeparators = this._segments;
-	var childToSegmentId = this._childToSegmentId;
+	var childToSegmentId = this._shared.childToSegment;
 	var curSegment = null;
 	var prevSegment = null;
 	var segmentValues = new Array(rowCount);
@@ -10444,6 +10996,126 @@ SegmentCollection.prototype.getSegmentValues = function(rids) {
 
 	return prevSegment ? segmentValues : null;
 };
+/** @public
+* @return {string}
+*/
+SegmentCollection.prototype.logStructure = function() {
+	var segmentList = this._segmentList;
+	if(!segmentList) {
+		return "";
+	}
+	var segmentCount = segmentList.length;
+	var lines = [];
+	for(var i = 0; i < segmentCount; ++i) {
+		segmentList[i].log(lines);
+	}
+
+	return lines.join("\n");
+};
+/** @public
+* @return {string}
+*/
+SegmentCollection.prototype.logRowIdMap = function() {
+	var lines = [];
+	var childToSegmentId = this._shared.childToSegment;
+	for(var rid in childToSegmentId) {
+		var segmentId = childToSegmentId[rid];
+		lines.push(rid + " > " + segmentId);
+	}
+
+	return lines.join("\n");
+};
+
+
+/** @public
+* @param {string} segmentId
+* @param {string|Array.<string>} fields
+* @return {boolean}
+*/
+SegmentCollection.prototype.setSegmentClassification = function(segmentId, fields) {
+	var segment = this._segments[segmentId];
+	if(segment) {
+		if(segment.setClassification(fields)) {
+			if(segment.getClassification()) {
+				this._classification = true;
+			}
+			this._classifierChanged = true;
+
+			return true;
+		}
+	}
+	return false;
+};
+/** @public
+* @return {boolean}
+*/
+SegmentCollection.prototype.hasClassification = function() {
+	// WARNING: This include the time when classification is removed
+	return this._classification || this._classifierChanged;
+};
+/** @public
+* @param {Object.<string, Object>} rows Object maps between row id and its record
+* @return {boolean}
+*/
+SegmentCollection.prototype.classify = function(rows) {
+	if(!this._segmentCount) {
+		return false;
+	}
+	if(!this.hasClassification()) {
+		return false;
+	}
+	this._classification = this._classifierChanged = false;
+
+	var segmentSeparators = this._segments;
+	for(var rid in segmentSeparators) {
+		var segment = this._segments[rid];
+		if(!segment.isSubSegment()) {
+			if(segment.getClassification()) {
+				this._classification = true;
+			}
+			segment.classify(rows);
+		}
+	}
+	if(this._insertionList.length || this._removalList.length) {
+		this._dispatch("subSegmentChanged", {
+			"insertionList": this._insertionList,
+			"removalList": this._removalList
+		});
+		this._insertionList.length = 0;
+		this._removalList.length = 0;
+
+		this._dispatch("classified", {});
+		return true;
+	}
+
+	this._dispatch("classified", {});
+	return false;
+};
+
+/** @private
+* @param {!Object} e
+*/
+SegmentCollection.prototype._onSubSegmentAdded = function(e) {
+	var rid = e["rid"];
+	if(!this._segments[rid]) {
+		var segment = /** @type{Segment} */(e["segment"]);
+		this._insertionList.push(segment);
+		this._segments[rid] = segment;
+		this._segmentCount++;
+
+		segment.addEventListener("subSegmentAdded", this._onSubSegmentAdded);
+		segment.addEventListener("subSegmentRemoved", this._onSubSegmentRemoved);
+	} else {
+		console.log("Incorrect logic detected.");
+	}
+};
+/** @private
+* @param {!Object} e
+*/
+SegmentCollection.prototype._onSubSegmentRemoved = function(e) {
+	var rid = e["rid"];
+	this.removeSegment(rid);
+};
 
 
 /* harmony default export */ var data_SegmentCollection = (SegmentCollection);
@@ -10453,6 +11125,7 @@ SegmentCollection.prototype.getSegmentValues = function(rids) {
 
 
 
+ // eslint-disable-line
 
 
 /** Trigger when data within the table has been changed
@@ -10475,11 +11148,15 @@ var DataTable = function() {
 
 	this._removeRows = this._removeRows.bind(this);
 	this._bySegmentSeparator = this._bySegmentSeparator.bind(this);
+	this._onClassifyingTimer = this._onClassifyingTimer.bind(this);
+	this._onSubSegmentChanged = this._onSubSegmentChanged.bind(this);
 
 	this._prevData = {};
 	this._rids = [];
 
 	this._compMap = {};
+
+	this._addEvent("subSegmentChanged");
 };
 Ext["b" /* default */].inherits(DataTable, data_DataCache);
 
@@ -10522,6 +11199,14 @@ DataTable.prototype._removedRows = null;
 * @type {Function}
 */
 DataTable.prototype._userSegmentComparer = null;
+/** @private
+* @type {Object.<string, Object>}
+*/
+DataTable.prototype._clsSource = null;
+/** @private
+* @type {number}
+*/
+DataTable.prototype._classifyingTimer = 0;
 
 
 /** @typedef {Function} DataTable~SortLogic
@@ -10550,8 +11235,17 @@ DataTable.prototype.dispose = function() {
 	this.unlistenAll();
 	this.clearAllData(true);
 
+	if(this._classifyingTimer) {
+		clearTimeout(this._onClassifyingTimer);
+		this._classifyingTimer = 0;
+	}
+
 	this._compMap = null; // Release user function that may be bound
-	this._segments = null;
+	this._clsSource = null;
+	if(this._segments) {
+		this._segments.dispose();
+		this._segments = null;
+	}
 };
 
 /** {@link DataCache#getColumnData}
@@ -10701,6 +11395,7 @@ DataTable.prototype.setRowData = function(rid, values, eventArg) { // Data chang
 				var segment = this._segments.getSegment(rid);
 				if(segment) {
 					if(this._segments.removeSegment(rid)) {
+						// TODO: Handle sub segment removal
 						segmentChanged = true;
 						if(!this._segments.getSegmentCount()) {
 							this._segments = null;
@@ -10708,12 +11403,7 @@ DataTable.prototype.setRowData = function(rid, values, eventArg) { // Data chang
 					}
 				}
 			}
-			for(var i = this._rids.length; --i >= 0;) {
-				if(this._rids[i] === rid) {
-					this._rids.splice(i, 1);
-					break;
-				}
-			}
+			DataTable._removeArrayItem(this._rids, rid);
 			dirty = true;
 		}
 	}
@@ -10732,7 +11422,7 @@ DataTable.prototype.setRowData = function(rid, values, eventArg) { // Data chang
 			}
 			this._dispatchDataChange(e);
 		}
-
+		this.requestClassifying(); // TODO: Check if needFiring method should have an effect on this request
 	}
 	return dirty;
 };
@@ -11033,12 +11723,34 @@ DataTable.prototype.removeRows = function(refs) {
 DataTable.prototype._removeRows = function(rid) {
 	return !this._removedRows[rid];
 };
+
+/** @private
+* @param {Array} ary
+* @param {*} item
+* @return {boolean}
+*/
+DataTable._removeArrayItem = function(ary, item) {
+	var at = ary.indexOf(item);
+	if(at >= 0) {
+		if(at >= ary.length) {
+			ary.pop(); // Array.pop is 100 times faster than Array.splice
+		} else {
+			ary.splice(at, 1);
+		}
+		return true;
+	}
+	return false;
+};
 /** Remove all existing rows
 * @override
 */
 DataTable.prototype.clearAllData = function(suppressEvent) {
 	DataTable.base(this, "clearAllData", true);
 	this._prevData = {};
+	// TODO: Clear all segments
+	if(this._segments) {
+		this._segments.removeAllSegmentChildren(); // This immediately remove all sub segments
+	}
 
 	if(this._rids.length) {
 		this._rids.length = 0;
@@ -11345,6 +12057,7 @@ DataTable.prototype.setSegmentSeparator = function(rid, enabled) {
 		if(enabled !== false) {
 			if(!this._segments) {
 				this._segments = new data_SegmentCollection();
+				this._segments.addEventListener("subSegmentChanged", this._onSubSegmentChanged);
 			}
 			if(this._autoSegmentFilling) {
 				var parentId = this._segments.getParentRowId(rid);
@@ -11417,6 +12130,29 @@ DataTable.prototype.isSegmentSeparator = function(rid) {
 	}
 	return false;
 };
+/** Get Segment object
+* @public
+* @param {string} rid Row id
+* @return {Segment} Return 0 if the given rid is not a segment
+*/
+DataTable.prototype.getSegment = function(rid) {
+	if(this._segments) {
+		return this._segments.getSegment(rid);
+	}
+	return null;
+};
+/** Segment level starts from 1
+* @public
+* @param {string} rid
+* @return {number} Return 0 if the given rid is not a segment
+*/
+DataTable.prototype.getSegmentLevel = function(rid) {
+	var segment = this.getSegment(rid);
+	if(segment) {
+		return segment.getSegmentLevel() + 1;
+	}
+	return 0;
+};
 /**
 * @public
 * @param {string} rid
@@ -11490,6 +12226,7 @@ DataTable.prototype.fillSegment = function(segmentId) {
 	if(this._segments) {
 		this._segments.fillSegment(segmentId, this._rids);
 		this.dispatchGlobalChange();
+		this.requestClassifying();
 	}
 };
 /** Remove all existing segment children in each segment and fill the segments with all contnet rows before the next segment separator
@@ -11501,6 +12238,7 @@ DataTable.prototype.fillSegments = function() {
 		var dirty = this._segments.fillSegments(this._rids);
 		if(dirty) {
 			this.dispatchGlobalChange();
+			this.requestClassifying();
 		}
 		return dirty;
 	}
@@ -11509,15 +12247,17 @@ DataTable.prototype.fillSegments = function() {
 /** @public
 * @param {string} segmentId Row id
 * @param {string} rid Row id
+* @param {string=} dataId Row id for retrieving data
 * @return {boolean} Return true if there is any change
 */
-DataTable.prototype.addSegmentChild = function(segmentId, rid) {
+DataTable.prototype.addSegmentChild = function(segmentId, rid, dataId) {
 	if(this._segments) {
-		var dirty = this._segments.addSegmentChild(segmentId, rid);
+		var dirty = this._segments.addSegmentChild(segmentId, rid, dataId);
 		if(dirty) {
 			if(this._sort(null)) {
 				this._dispatchPositionChange();
 			}
+			this.requestClassifying();
 			return true;
 		}
 	}
@@ -11535,6 +12275,7 @@ DataTable.prototype.addSegmentChildren = function(segmentId, rids) {
 			if(this._sort(null)) {
 				this._dispatchPositionChange();
 			}
+			this.requestClassifying();
 			return true;
 		}
 	}
@@ -11550,6 +12291,7 @@ DataTable.prototype.removeSegmentChild = function(segmentId, rid) {
 		var dirty = this._segments.removeSegmentChild(segmentId, rid);
 		if(dirty) {
 			this.dispatchGlobalChange();
+			this.requestClassifying();
 		}
 		return dirty;
 	}
@@ -11565,6 +12307,7 @@ DataTable.prototype.removeSegmentChildren = function(segmentId, rids) {
 		var dirty = this._segments.removeSegmentChildren(segmentId, rids);
 		if(dirty) {
 			this.dispatchGlobalChange();
+			this.requestClassifying();
 		}
 		return dirty;
 	}
@@ -11575,7 +12318,7 @@ DataTable.prototype.removeSegmentChildren = function(segmentId, rids) {
 */
 DataTable.prototype.removeAllSegmentChildren = function() {
 	if(this._segments) {
-		var dirty = this._segments.removeAllSegmentChildren();
+		var dirty = this._segments.removeAllSegmentChildren(); // This immediately remove all sub segments
 		if (dirty) {
 			this.dispatchGlobalChange();
 		}
@@ -11611,10 +12354,15 @@ DataTable.prototype.getSegmentChildIds = function(segmentId) {
 /** Sort all of existing segments by given compare function
 * @public
 * @param {Function} compare
+* @return {boolean}
 */
 DataTable.prototype.sortSegments = function (compare) {
-	if(!this._segments || typeof compare !== "function") {
-		return;
+	if(!this._segments) {
+		return false;
+	}
+	if(typeof compare !== "function") {
+		this._segments.calcSegmentOrder(this._rids);
+		return false;
 	}
 	var rids = this._rids;
 	var segments = this._segments;
@@ -11658,7 +12406,9 @@ DataTable.prototype.sortSegments = function (compare) {
 		this._segments.calcSegmentOrder(rids);
 		this._sort(null);
 		this._dispatchPositionChange();
+		return true;
 	}
+	return false;
 };
 /** Sort all of existing segments by given compare function
 * @private
@@ -11673,6 +12423,112 @@ DataTable.prototype._bySegmentSeparator = function (segmentA, segmentB) {
 	));
 };
 
+/** A data source to be used with segment classification
+* @public
+* @param {DataCache} dc
+*/
+DataTable.prototype.setClassificationSource = function(dc) {
+	this._clsSource = null;
+
+	if(dc && dc._rows) {
+		this._clsSource = dc._rows;
+	}
+};
+/**
+* @public
+* @param {string} segmentId
+* @param {string|Array.<string>} fields
+* @return {boolean}
+*/
+DataTable.prototype.setSegmentClassification = function(segmentId, fields) {
+	if(this._segments) {
+		var dirty = this._segments.setSegmentClassification(segmentId, fields);
+		if(dirty) {
+			return this.classifySegments();
+		}
+	}
+	return false;
+};
+/** @public
+* @return {boolean}
+*/
+DataTable.prototype.classifySegments = function() {
+	if(this._segments) {
+		if(this._rids.length) {
+			return this._segments.classify(this._clsSource || this._rows);
+		}
+	}
+	return false;
+};
+
+/** @public
+*/
+DataTable.prototype.requestClassifying = function() {
+	if(this._segments && !this._classifyingTimer) {
+		if(this._segments.hasClassification()) {
+			this._classifyingTimer = setTimeout(this._onClassifyingTimer, 10);
+		}
+	}
+};
+/** @private
+*/
+DataTable.prototype._onClassifyingTimer = function() {
+	this._classifyingTimer = 0;
+	this.classifySegments();
+};
+/** @private
+* @param {Object} e
+*/
+DataTable.prototype._onSubSegmentChanged = function(e) {
+	var insertionList = /** @type{Array.<Segment>} */(e["insertionList"]);
+	var removalList = /** @type{Array.<string>} */(e["removalList"]);
+
+	var dirty = false;
+	var rows = this._rows;
+	var clsSource = this._clsSource || rows;
+	var rids = this._rids;
+	var prevData = this._prevData;
+	var i;
+
+	var removalCount = removalList.length;
+	var removedRows = {};
+	for(i = 0; i < removalCount; i++) {
+		var rid = removalList[i];
+		if(rows[rid]) {
+			removedRows[rid] = prevData[rid] = rows[rid];
+			delete rows[rid];
+			DataTable._removeArrayItem(rids, rid);
+			dirty = true;
+			// TODO: Remove classification source
+		}
+	}
+
+	var insertionCount = insertionList.length;
+	for(i = 0; i < insertionCount; i++) {
+		var segment = insertionList[i];
+		var parentId = segment.getParentId();
+		var segmentId = segment.getId();
+
+		if(!rows[segmentId]) {
+			prevData[segmentId] = {};
+			segment.setRowData(rows, clsSource);
+
+			var parentAt = rids.indexOf(parentId);
+			if(parentAt < 0 || parentAt + 1 >= rids.length) {
+				rids.push(segmentId);
+			} else {
+				rids.splice(parentAt + 1, 0, segmentId);
+			}
+			dirty = true;
+		}
+	}
+	if(dirty) {
+		e["removedRows"] = removedRows;
+		this._dispatch("subSegmentChanged", e);
+		this.dispatchGlobalChange(); // Rerender everything
+	}
+};
+
 
 /**
 * @public
@@ -12191,6 +13047,13 @@ var ROW_DEF = "ROW_DEF";
 */
 var RowDefinition = function(rowOptions) {
 	this._changes = {};
+	if(rowOptions && rowOptions["segmentId"]) {
+		this._dataId = this._rowId = rowOptions["segmentId"];
+		this._autoGenerated = true;
+		this._subSegment = true;
+		return;
+	}
+
 	this._rowId = "_" + RowDefinition._runningId++ + "_";
 	this._dataId = this._rowId;
 
@@ -12259,6 +13122,10 @@ RowDefinition.prototype._expanded = false;
 * @private
 */
 RowDefinition.prototype._autoGenerated = false;
+/** @type {boolean}
+* @private
+*/
+RowDefinition.prototype._subSegment = false;
 /** @type {Object.<string, *>}
 * @private
 */
@@ -12822,7 +13689,16 @@ RowDefinition.prototype.registerToView = function(view, rowId) {
 	}
 	this._view = view;
 
-	var rowData = {};
+	var rowData = null;
+	if(this._subSegment) {
+		rowData = this._view.getRowData(this.getRowId());
+		if(rowData) {
+			rowData[ROW_DEF] = this; // no event trigger
+		}
+		return;
+	}
+
+	rowData = {};
 	rowData[ROW_DEF] = this;
 
 	var newRowId = this._view.insertRow(rowId, rowData, this.getRowId());
@@ -12903,11 +13779,68 @@ RowDefinition.prototype.addConstituent = function(ric) {
 		var rowId = this.getRowId();
 		var rowIndex = this._view.getRowIndex(rowId) + this.getChildCount(); // Children must be directly under its parent
 		childDef.registerToView(this._view, this._view.getRowId(rowIndex));
-		this._view.addSegmentChild(rowId, childDef.getRowId());
+		this._view.addSegmentChild(rowId, childDef.getRowId(), childDef.getDataId());
 	}
 
 	return newChild ? childDef : null;
 };
+
+/** Used to convert autogenerated row to regular real-time row
+* @public
+*/
+RowDefinition.prototype._toRealTimeRow = function() {
+	if(!this._ric) { // Empty row
+		return;
+	}
+	if(this.isRowHeader()) {
+		return;
+	}
+
+	this._realTimeField = true;
+	this._dataId = this._rowId + this._ric; // JET/RTK will generate data id to be rowId (given from this rowDef) + ric;
+
+	this._autoGenerated = false;
+	this._parent = null;
+	this._depthLevel = 0;
+
+	this.subscribeForUpdates();
+};
+
+/** @public
+*/
+RowDefinition.prototype.unlinkChain = function() {
+	if(!this._isChain) {
+		return;
+	}
+
+	if(this.isChainExpanded()) {
+		var rowDefs = this.getDescendants();
+		var len = rowDefs.length;
+		for(var i = 0; i < len; i++) {
+			rowDefs[i]._toRealTimeRow();
+		}
+	}
+
+	this.unsubscribeForUpdates();
+
+	var view = this._view;
+	if(view) {
+		var rid = this.getRowId();
+		var segment = view.getSegment(rid);
+		if(segment) {
+			segment.setClassification(null);
+		}
+		view.setSegmentSeparator(rid, false);
+	}
+
+	this._isChain = this._expanded = false;
+	this._chainRic = "";
+	this._userInput = this._ric;
+	this._children = null;
+
+	this.subscribeForUpdates();
+};
+
 /** @public
 * @return {boolean} Returns true if there is a change in view
 */
@@ -26333,6 +27266,7 @@ WrappedView.prototype.isRowFiltered = function(rid, rowData) {
 
  // eslint-disable-line
 
+ // eslint-disable-line
 
 
 
@@ -28677,6 +29611,22 @@ DataView.prototype.isSegmentSeparator = function(rid) {
 	return this._dt.isSegmentSeparator(rid);
 };
 
+/** Get Segment object
+* @public
+* @param {string} rid Row id
+* @return {Segment} Return 0 if the given rid is not a segment
+*/
+DataView.prototype.getSegment = function(rid) {
+	return this._dt.getSegment(rid);
+};
+/** Segment level starts from 1
+* @public
+* @param {string} rid Row id
+* @return {number} Return 0 if the given rid is not a segment
+*/
+DataView.prototype.getSegmentLevel = function(rid) {
+	return this._dt.getSegmentLevel(rid);
+};
 /**
 * @public
 * @param {string} rid
@@ -28758,13 +29708,14 @@ DataView.prototype.fillSegments = function() {
 /** @public
 * @param {string|number} segmentRef Row id or row index
 * @param {string|number} rowRef Row id, row index
+* @param {string=} dataId Row id for retrieving data
 * @return {boolean} Return true if there is any change
 */
-DataView.prototype.addSegmentChild = function(segmentRef, rowRef) {
+DataView.prototype.addSegmentChild = function(segmentRef, rowRef, dataId) {
 	if(this._dt._getSegmentSeparators()) {
 		var segmentId = this._toRowId(segmentRef);
 		var rowId = this._toRowId(rowRef);
-		return this._dt.addSegmentChild(segmentId, rowId);
+		return this._dt.addSegmentChild(segmentId, rowId, dataId);
 	}
 	return false;
 };
@@ -28836,6 +29787,16 @@ DataView.prototype.sortSegments = function (compare) {
 	this._dt.sortSegments(compare);
 };
 
+/**
+* @public
+* @param {string|number} segmentRef Row id or row index
+* @param {string|Array.<string>} fields
+* @return {boolean}
+*/
+DataView.prototype.setSegmentClassification = function(segmentRef, fields) {
+	return this._dt.setSegmentClassification(this._toRowId(segmentRef), fields);
+};
+
 /** @public
 * @ignore
 * @return {Object}
@@ -33292,7 +34253,7 @@ Core.prototype._rowHeightTimerId = 0;
 * @return {string}
 */
 Core.getVersion = function () {
-	return "5.1.20";
+	return "5.1.25";
 };
 /** {@link ElementWrapper#dispose}
 * @override
@@ -40825,6 +41786,7 @@ var Grid = function(placeholder, config) {
 
 	t._onDataChanged = t._onDataChanged.bind(t);
 	t._onDataComposed = t._onDataComposed.bind(t);
+	t._onSubSegmentChanged = t._onSubSegmentChanged.bind(t);
 	t._recalculateFormulas = t._recalculateFormulas.bind(t);
 	t._updateStreamingData = t._updateStreamingData.bind(t);
 	t.updateColumnTitle = t.updateColumnTitle.bind(t);
@@ -40888,6 +41850,8 @@ var Grid = function(placeholder, config) {
 
 		t._dt = new DataTable();
 		t._dt.setSortingLogic(/** @type{Function} */(t._mainSorter));
+		t._dt.setClassificationSource(t._dc);
+		t._dt.listen("subSegmentChanged", t._onSubSegmentChanged);
 		t._dv = new DataView(t._dt);
 		t._dv.listen("pageIndexChanged", t._dispatch.bind(t, "pageIndexChanged"));
 		t._dv.listen("pageCountChanged", t._dispatch.bind(t, "pageCountChanged")); // TODO: When implementing filtered row, it may need to implement the conflator
@@ -42837,6 +43801,28 @@ Grid.prototype.setRic = function(rowRef, str) {
 		}
 	}
 };
+/** Unlink the chain and its constituents. When the chain is expanded,
+ * the chain row and its members are converted from autogenerated to
+ * regular real-time rows. Only the chain row will be transformed to
+ * a conventional real-time row if the chain is collapsed.
+ * All converted rows will continue to have their data updated.
+ *
+ * @public
+ * @param {Grid~RowReference} rowRef
+ */
+Grid.prototype.unlinkChain = function(rowRef) {
+	var rowDef = this._getRowDefinition(rowRef);
+	if(!rowDef) {
+		return;
+	}
+
+	if(!rowDef.isChain()) {
+		return;
+	}
+
+	rowDef.unlinkChain();
+};
+
 /** Alias to setRic
 * @public
 * @function
@@ -43452,6 +44438,7 @@ Grid.prototype._updateStreamingData = function() {
 	}
 
 	if(this._dt) {
+		this._dt.classifySegments();
 		this._dt.dispatchGlobalChange();
 	}
 };
@@ -43573,6 +44560,20 @@ Grid.prototype.toggleChain = function(rowRef) {
 		rowDef.toggleChain();
 	}
 };
+/**
+ * @public
+ * @param {Grid~RowReference} rowRef
+ * @param {Array.<string>} fields
+ * @return {boolean}
+ */
+Grid.prototype.setClassification = function(rowRef, fields) {
+	var rowDef = this._getRowDefinition(rowRef);
+	if(rowDef) {
+		return this._dt.setSegmentClassification(rowDef.getRowId(), fields);
+	}
+	return false;
+};
+
 /** @description Focus grid element without moving window scrollbar
  * @public
  */
@@ -43677,6 +44678,41 @@ Grid.prototype._onDataComposed = function(e) {
 
 	this._recalculateFormulas(e);
 };
+/** @private
+* @param {Object} e
+*/
+Grid.prototype._onSubSegmentChanged = function(e) {
+	var insertionList = /** @type{Array.<Segment>} */(e["insertionList"]);
+	var removalList = /** @type{Array.<string>} */(e["removalList"]);
+	var removedRows = /** @type{Object} */(e["removedRows"]);
+
+	var i;
+	var removalCount = removalList.length;
+	var rowDef = null;
+	for(i = 0; i < removalCount; i++) {
+		var rid = removalList[i];
+		var removedRow = removedRows[rid];
+		if(removedRow) {
+			rowDef = removedRow[ROW_DEF];
+			if(rowDef) {
+				rowDef.dispose();
+				removedRow[ROW_DEF] = null;
+			}
+		}
+	}
+
+	var insertionCount = insertionList.length;
+	for(i = 0; i < insertionCount; i++) {
+		var segment = insertionList[i];
+		// var parentId = segment.getParentId();
+		var segmentId = segment.getId();
+		rowDef = new RowDefinition({
+			"segmentId": segmentId
+		});
+		rowDef.setDataSource(this._dc);
+		rowDef.registerToView(this._dv);
+	}
+};
 
 /** @private
 * @param {Object=} e