@refinitiv-ui/efx-grid 6.0.153 → 6.0.155

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

@@ -9145,7 +9145,7 @@ DataCache.constructTable = function (dataset, opt_options, opt_rowIds) {
 */
 let Segment = function(rid, sharedObj) {
 	this._rid = rid;
-	this._children = {};
+	this._childIds = [];
 	this._shared = sharedObj;
 	if(sharedObj.defaultCollapsing) {
 		this._collapsed = true;
@@ -9176,14 +9176,6 @@ Segment._subSegSortLogic = function(a, b) {
 
 	return 0;
 };
-/** @private
-* @function
-* @param {Segment} segment
-* @param {number} idx
-*/
-Segment._assignSubSegmentOrder = function(segment, idx) {
-	segment.setOrder(idx + 1);
-};
 
 /** @type {Object}
 * @private
@@ -9194,14 +9186,14 @@ Segment.prototype._shared = null;
 * @private
 */
 Segment.prototype._rid;
-/** @type {!Object}
+/** @type {!Array.<string>}
 * @private
 */
-Segment.prototype._children;
-/** @type {number}
+Segment.prototype._childIds;
+/** @type {Object}
 * @private
 */
-Segment.prototype._childCount = 0;
+Segment.prototype._childDataIds = null;
 /** @type {boolean}
 * @private
 */
@@ -9210,6 +9202,14 @@ Segment.prototype._collapsed = false;
 * @private
 */
 Segment.prototype._order = 0;
+/** @type {number}
+* @private
+*/
+Segment.prototype._offsetOrder = 0;
+/** @type {number}
+* @private
+*/
+Segment.prototype._depth = 0;
 /** @type {boolean}
 * @private
 */
@@ -9219,10 +9219,10 @@ Segment.prototype._disposed = false;
 * @private
 */
 Segment.prototype._subSegDef = null;
-/** @type {number}
+/** @type {boolean}
 * @private
 */
-Segment.prototype._subSegLevel = 0;
+Segment.prototype._subSegment = false; // This indicates that the segment is autogenerated (subsegment)
 /** @type {Object.<string, Segment>}
 * @private
 */
@@ -9230,7 +9230,7 @@ Segment.prototype._subSegMap = null; // For immediate sub-segment children
 /** @type {Array.<string>}
 * @private
 */
-Segment.prototype._subSegNames = null; // For immediate sub-segment child names
+Segment.prototype._subSegNames = null; // For immediate sub-segment child names/ids
 /** @type {string}
 * @private
 */
@@ -9239,10 +9239,6 @@ Segment.prototype._subSegName = "";
 * @private
 */
 Segment.prototype._subSegVal;
-/** @type {Segment}
-* @private
-*/
-Segment.prototype._subSegParent = null;
 
 
 /** @public
@@ -9264,14 +9260,13 @@ Segment.prototype.dispose = function() {
 		this._subSegMap = this._subSegNames = null;
 	}
 	if(this._collapsed) {
-		if(this._childCount || this._subSegDef) {
-			this._shared.dirtyCollapsingState = true;
-		}
+		this.markCollapsingStateDirty();
 	}
 
-	this._childCount = 0;
+	this._childDataIds = null;
+	this._childIds.length = 0;
 	this._shared = null;
-	this._subSegParent = this._subSegDef = this._subSegVal = null;
+	this._subSegDef = this._subSegVal = null;
 };
 /** @public
 * @return {string}
@@ -9283,10 +9278,17 @@ Segment.prototype.getId = function() {
 * @return {string}
 */
 Segment.prototype.getParentId = function() {
-	if(this._subSegParent) {
-		return this._subSegParent.getId();
+	return this._shared.childToSegment[this._rid] || "";
+};
+/** @public
+* @return {Segment}
+*/
+Segment.prototype.getParent = function() {
+	let parentId = this.getParentId();
+	if(parentId) {
+		return this._shared.segments[parentId] || null;
 	}
-	return "";
+	return null;
 };
 /** @public
 * @param {Array.<string>=} out_ary
@@ -9314,21 +9316,43 @@ Segment.prototype.getSubSegmentIds = function(out_ary) {
 /** @public
 * @param {string} rid
 * @param {string=} dataId Row id for retrieving data
-* @return {boolean}
+* @return {boolean} Returns true only a new child is added
 */
 Segment.prototype.addChild = function(rid, dataId) {
-	if(rid) {
+	if(!rid) {
+		return false;
+	}
+	let prevSegmentId = this._shared.childToSegment[rid];
+	if(prevSegmentId) {
+		if(prevSegmentId !== this._rid) {
+			let prevSegment = this._shared.segments[prevSegmentId];
+			if(prevSegment && !prevSegment.hasSubSegments()) { // Children of a classified segment always stick the root segment
+				prevSegment.removeChild(rid);
+			}
+			this._shared.childToSegment[rid] = this._rid;
+		}
+	} else {
 		this._shared.childToSegment[rid] = this._rid;
-		if(this._children[rid]) {
-			this._children[rid] = dataId || rid; // Update data id
-		} else {
-			if(this._collapsed) {
-				this._shared.dirtyCollapsingState = true; // TODO: Check if we need to update this only when new child is added
+	}
+
+	if(dataId != null) { // Update data id
+		if(dataId && dataId !== rid) {
+			if(!this._childDataIds) {
+				this._childDataIds = {};
 			}
-			this._children[rid] = dataId || rid;
-			++this._childCount;
-			return true;
+			this._childDataIds[rid] = dataId;
+		} else if(this._childDataIds) {
+			delete this._childDataIds[rid];
+		}
+	}
+
+	let at = this._childIds.indexOf(rid);
+	if(at < 0) {
+		if(this._collapsed) {
+			this._shared.dirtyCollapsingState = true; // TODO: Check if we need to update this only when new child is added
 		}
+		this._childIds.push(rid);
+		return true;
 	}
 	return false;
 };
@@ -9338,8 +9362,15 @@ Segment.prototype.addChild = function(rid, dataId) {
 * @return {boolean}
 */
 Segment.prototype.addChildren = function(rids, dataIds) {
+	if(!rids) {
+		return false;
+	}
 	let rowIds = Array.isArray(rids) ? rids : [rids];
 	let rowCount = rowIds.length;
+	if(!rowCount) {
+		return false;
+	}
+
 	let dirty = 0;
 	let i;
 	if(dataIds != null) {
@@ -9359,27 +9390,35 @@ Segment.prototype.addChildren = function(rids, dataIds) {
 * @return {boolean}
 */
 Segment.prototype.containsChild = function(rid) {
-	return this._children[rid] ? true : false;
+	return this._childIds.indexOf(rid) >= 0;
+};
+/** @public
+* @param {string} rid
+* @return {number}
+*/
+Segment.prototype.getChildIndex = function(rid) {
+	return this._childIds.indexOf(rid);
 };
 /** @public
 * @param {string} rid
 * @return {boolean}
 */
 Segment.prototype.removeChild = function(rid) {
-	if(this._subSegLevel) {
+	if(this._subSegment) {
 		return false; // Sub segments are not allowed to remove its children
 	}
-	if(!this._childCount) {
+	if(!this._childIds.length) {
 		return false;
 	}
-	if(!this._children[rid]) {
+	let at = this._childIds.indexOf(rid);
+	if(at < 0) {
 		return false; // The specified rid is not a child of this segment
 	}
 
-	let objMap = this._shared.childToSegment;
-	delete objMap[rid];
-	delete this._children[rid]; // Slow
-	--this._childCount;
+	if(this._shared.childToSegment[rid] === this._rid) {
+		delete this._shared.childToSegment[rid];
+	}
+	this._childIds.splice(at, 1); // Slow
 
 	if(this._collapsed) {
 		this._shared.dirtyCollapsingState = true;
@@ -9391,10 +9430,10 @@ Segment.prototype.removeChild = function(rid) {
 * @return {boolean}
 */
 Segment.prototype.removeChildren = function(rids) {
-	if(this._subSegLevel) {
+	if(this._subSegment) {
 		return false; // Sub segments are not allowed to remove its children
 	}
-	if(!this._childCount) {
+	if(!this._childIds.length) {
 		return false;
 	}
 	let rowIds = Array.isArray(rids) ? rids : [rids];
@@ -9409,21 +9448,24 @@ Segment.prototype.removeChildren = function(rids) {
 * @return {boolean}
 */
 Segment.prototype.removeAllChildren = function() {
-	if(this._subSegLevel) {
+	if(this._subSegment) {
 		return false; // Sub segments are not allowed to remove its children
 	}
-	if(!this._childCount) {
+	let childCount = this._childIds.length;
+	if(!this._childIds.length) {
 		return false;
 	}
+	let segmentId = this._rid;
 	let objMap = this._shared.childToSegment;
-	let chdr = this._children;
-	for(let rid in chdr) {
-		if(objMap[rid]) {
-			delete objMap[rid]; // TODO: Check if we need to do this
+	let chdr = this._childIds;
+	for(let i = 0; i < childCount; ++i) {
+		let rid = chdr[i];
+		if(objMap[rid] === segmentId) {
+			delete objMap[rid];
 		}
 	}
-	this._children = {};
-	this._childCount = 0;
+	this._childIds.length = 0;
+	this._childDataIds = null;
 
 	if(this._collapsed) {
 		this._shared.dirtyCollapsingState = true;
@@ -9434,24 +9476,41 @@ Segment.prototype.removeAllChildren = function() {
 * @return {!Array.<string>}
 */
 Segment.prototype.getChildIds = function() {
-	return this._childCount ? Object.keys(this._children) : [];
+	return this._childIds; // WARNING: Returns private members
 };
 /** @public
 * @return {!Object}
 */
 Segment.prototype.getChildren = function() {
-	return this._children;
+	let obj = {};
+	let chdr = this._childIds;
+	let childCount = chdr.length;
+	let dataIds = this._childDataIds || {};
+	for(let i = 0; i < childCount; ++i) {
+		let rid = chdr[i];
+		obj[rid] = dataIds[rid] || rid;
+	}
+	return obj;
 };
 /** @public
 * @return {number}
 */
 Segment.prototype.getChildCount = function() {
-	return this._childCount;
+	return this._childIds.length;
+};
+/** When a segment is not empty, the visibility of its content need to be updated.
+* @public
+*/
+Segment.prototype.markCollapsingStateDirty = function() {
+	// A segment can have a child and/or autogenerated segment (subsegment) to not be considered as empty.
+	if(this._childIds.length || this._subSegDef) {
+		this._shared.dirtyCollapsingState = true;
+	}
 };
 
 
 /** @public
-* @return {Array.<string>} fields
+* @return {Array.<string>}
 */
 Segment.prototype.getClassification = function() {
 	if(this._subSegDef) {
@@ -9464,8 +9523,8 @@ Segment.prototype.getClassification = function() {
 * @return {boolean}
 */
 Segment.prototype.setClassification = function(fields) {
-	if(this._subSegLevel) {
-		return false; // non-root segment cannot be classified
+	if(this._subSegment) {
+		return false; // subsegment cannot be classified
 	}
 	let classifiers = null;
 	if(this._subSegDef) {
@@ -9508,9 +9567,8 @@ Segment.prototype.setClassification = function(fields) {
 		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
+		this._subSegDef = null; // WARNING: All subsegments remain existing
 		return true;
 	}
 	return false;
@@ -9527,7 +9585,7 @@ Segment.prototype.classify = function(rows) {
 	let segmentCount = segmentNames ? segmentNames.length : 0;
 
 	if(!segmentCount) {
-		if(this._subSegLevel >= classifierCount) {
+		if(this._depth >= classifierCount) {
 			return false; // Current segment level is beyond existing classification level and this segment should already be removed
 		}
 	}
@@ -9537,7 +9595,7 @@ Segment.prototype.classify = function(rows) {
 		sharedObj.dirtyCollapsingState = true;
 	}
 
-	// Prepare existing sub segments for checking change in its members
+	// Prepare existing subsegments for checking change in its members
 	let i;
 	let segmentName = "";
 	let nonExistenceGroups = {};
@@ -9551,9 +9609,8 @@ Segment.prototype.classify = function(rows) {
 			nonExistenceGroups[segmentName] = 1;
 
 			segment = segmentMap[segmentName];
-			if(segment._childCount) { // Quick cleaning up
-				segment._children = {};
-				segment._childCount = 0;
+			if(segment._childIds.length) { // Quick cleaning up
+				segment._childIds.length = 0;
 			}
 			if(segment._collapsed) {
 				sharedObj.dirtyCollapsingState = true;
@@ -9561,20 +9618,23 @@ Segment.prototype.classify = function(rows) {
 		}
 	}
 
-	// Loop through row children and assign them to their corresponding sub segment
-	let isRootSegment = !this._subSegLevel;
+	// Loop through row children and assign them to their corresponding subsegment
+	let rootSegment = !this._subSegment;
+	let dataIds = this._childDataIds || {};
 	let rid;
-	let children = this._children;
-	if(this._subSegLevel < classifierCount && rows) {
+	let chdr = this._childIds;
+	let childCount = chdr.length;
+	if(this._depth < classifierCount && rows) {
 		if(!segmentMap) {
 			segmentMap = this._subSegMap = {};
 			segmentNames = this._subSegNames = [];
 		}
 
-		let classifier = classifiers[this._subSegLevel];
+		let classifier = classifiers[this._depth];
 
-		for(rid in children) {
-			let dataId = children[rid];
+		for(i = 0; i < childCount; ++i) {
+			rid = chdr[i];
+			let dataId = dataIds[rid] || rid;
 			let record = rows[dataId];
 			let val = record ? record[classifier] : null; // WARNING: row could already be removed
 
@@ -9591,31 +9651,34 @@ Segment.prototype.classify = function(rows) {
 
 			segment = segmentMap[segmentName];
 			if(!segment) { // New group is detected
-				segment = new Segment(this._rid + "/" + segmentName, sharedObj);
+				let subSegId = this._rid + "/" + segmentName;
+				segment = new Segment(subSegId, sharedObj);
 				segment._subSegDef = this._subSegDef;
-				segment._subSegLevel = this._subSegLevel + 1;
+				segment._subSegment = true; // this indicates that the segment is autogenerated (subsegment)
+				segment._depth = this._depth + 1;
 				segment._subSegName = segmentName;
 				segment._subSegVal = val;
-				segment._subSegParent = this;
+				sharedObj.childToSegment[subSegId] = this._rid; // WARNING: this will mix autogenerated rows with actual rows
 
 				segmentMap[segmentName] = segment;
 				segmentNames.push(segmentName);
 
 				this._dispatch("subSegmentAdded", {
-					"rid": segment.getId(),
+					"rid": subSegId,
 					"segment": segment
 				});
 			}
 
 			segment.addChild(rid, dataId);
 		}
-	} else if(isRootSegment) { // In case of no classification
-		for(rid in children) {
+	} else if(rootSegment) { // In case of no classification
+		for(i = 0; i < childCount; ++i) {
+			rid = chdr[i];
 			sharedObj.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
+	// Remove all subsegments with no members
 	if(removalCount > 0) {
 		if(removalCount >= segmentNames.length) {
 			segmentNames.length = 0;
@@ -9643,7 +9706,7 @@ Segment.prototype.classify = function(rows) {
 		}
 	}
 
-	// Sort and classify existing sub segments
+	// Sort and classify existing subsegments
 	segmentCount = segmentNames ? segmentNames.length : 0;
 	if(segmentCount) {
 		segmentNames.sort(Segment._subSegSortLogic);
@@ -9653,22 +9716,17 @@ Segment.prototype.classify = function(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) {
-				let subSegments = this._subSegDef.subSegments = [];
-				this.getAllSubSegments(subSegments);
-				subSegments.forEach(Segment._assignSubSegmentOrder);
-			} else {
-				this._subSegDef.subSegments = null;
-			}
-			// this._subSegDef.classifierChanged = false;
+	// Collecting all subsegments including all descendants and reassigning segment order.
+	if(rootSegment && this._subSegDef) {
+		if(segmentCount) {
+			this.calcSubSegmentOrder(0);
 		}
+		// this._subSegDef.classifierChanged = false;
 	}
 	return true;
 };
-/** @public
+/** SubSegment implies being classified
+* @public
 * @return {boolean}
 */
 Segment.prototype.hasSubSegments = function() {
@@ -9677,21 +9735,37 @@ Segment.prototype.hasSubSegments = function() {
 	}
 	return false;
 };
-/** @public
+/** SubSegment implies autogenerated segment
+* @public
 * @return {boolean}
 */
 Segment.prototype.isSubSegment = function() {
-	return this._subSegLevel ? true : false;
+	return this._subSegment;
+};
+/** @public
+* @return {boolean}
+*/
+Segment.prototype.isRootSegment = function() {
+	return this._shared.childToSegment[this._rid] ? false : true;
 };
 /** @public
 * @return {Segment}
 */
 Segment.prototype.getFirstAncestor = function() {
-	if(this._subSegLevel && this._subSegDef) {
-		let ancestor = this._subSegDef.root;
-		return /** @type{Segment} */(ancestor) || null;
+	let ancestor = null;
+	if(this._subSegment && this._subSegDef) { // Quick way to get root
+		ancestor = this._subSegDef.root;
+	} else { // Slow
+		ancestor = this.getParent();
+		if(ancestor) {
+			let parentSeg = ancestor.getParent();
+			while(parentSeg) { // This could cause infinite loop
+				ancestor = parentSeg;
+				parentSeg = ancestor.getParent();
+			}
+		}
 	}
-	return null;
+	return ancestor || null;
 };
 /** @public
 * @param {Array.<Segment>=} out_ary
@@ -9713,13 +9787,75 @@ Segment.prototype.getAllSubSegments = function(out_ary) {
 	}
 	return out_ary || null;
 };
+/** This method sets order, last order, and depth to entire tree structure in the segment, including the segment itself
+* @public
+* @param {number} counter
+* @return {number}
+*/
+Segment.prototype.updateTreeStructure = function(counter) {
+	if(!counter) {
+		counter = 0;
+		if(!this._subSegment) { // Subsegment's depth cannot be reset back to 0
+			this._depth = 0; // WARNING: this assumes counter at 0 is the root segment
+		}
+	}
+	if(this.hasSubSegments()) {
+		return this.setLastOrder(counter); // Sub segments has already been calculated
+	}
+	let segmentSeparators = this._shared.segments;
+	let childCount = this._childIds.length;
+	let prevSeg = null;
+	for(let i = 0; i < childCount; ++i) {
+		let rid = this._childIds[i];
+		let segment = segmentSeparators[rid];
+		let segmentId = (segment) ? segment.getId() : "Uncategorized";
+		if(prevSeg !== segmentId) {
+			++counter; // 0 become 1
+			prevSeg = segmentId;
+		}
+		if(segment) {
+			segment._depth = this._depth + 1;
+			segment.setOrder(counter);
+			counter = segment.updateTreeStructure(counter);
+		}
+	}
+
+	return this.setLastOrder(counter);
+};
+/** @public
+* @param {number} counter
+* @return {number}
+*/
+Segment.prototype.calcSubSegmentOrder = function(counter) {
+	if(!this.hasSubSegments()) {
+		return this.setLastOrder(counter);
+	}
+
+	let segmentMap = this._subSegMap;
+	let childCount = this._subSegNames.length;
+	let prevSeg = null;
+	for(let i = 0; i < childCount; ++i) {
+		let segmentName = this._subSegNames[i];
+		let segment = segmentMap[segmentName];
+		let segmentId = (segment) ? segment.getId() : "Uncategorized";
+		if(prevSeg !== segmentId) {
+			++counter; // 0 become 1
+			prevSeg = segmentId;
+		}
+		if(segment) {
+			segment.setOrder(counter);
+			counter = segment.calcSubSegmentOrder(counter);
+		}
+	}
+	return this.setLastOrder(counter);
+};
 /** @public
 * @return {number}
 */
 Segment.prototype.getSegmentLevel = function() {
-	return this._subSegLevel;
+	return this._depth;
 };
-/** This method will be called on sub segments only
+/** This method will be called on subsegments only
 * @public
 * @param {Object=} rows
 * @param {Object=} clsSource
@@ -9744,7 +9880,7 @@ Segment.prototype.setRowData = function(rows, clsSource) {
 	let segment = this;
 	while(segment && segment.isSubSegment()) {
 		segment.getSubSegmentName(row);
-		segment = segment._subSegParent;
+		segment = segment.getParent();
 	}
 };
 /** @public
@@ -9752,15 +9888,92 @@ Segment.prototype.setRowData = function(rows, clsSource) {
 * @return {string}
 */
 Segment.prototype.getSubSegmentName = function(row) {
-	if(row && this._subSegLevel) {
+	if(row && this._subSegment) {
 		let classifiers = this.getClassification();
-		let field = classifiers[this._subSegLevel - 1];
+		let field = classifiers[this._depth - 1];
 		if(field) {
 			row[field] = this._subSegName;
 		}
 	}
 	return this._subSegName;
 };
+/**
+* @private
+* @param {!Segment} segment
+* @returns {string}
+*/
+let _toSegmentId = function(segment) {
+	return segment.getId();
+};
+/**
+* @public
+* @param {!Function} comparer
+* @returns {boolean} Returns true if there is any change
+*/
+Segment.prototype.sortSegments = function(comparer) {
+	if(!comparer || this.hasSubSegments()) {
+		return false;
+	}
+
+	let segmentList = [];
+	let rids = [];
+	let childIds = this._childIds;
+	let childCount = childIds.length;
+	let segments = this._shared.segments;
+	for(let i = 0; i < childCount; ++i) {
+		let childId = childIds[i];
+		let childSegment = segments[childId];
+		if(childSegment) {
+			segmentList.push(childSegment);
+		} else {
+			rids.push(childId);
+		}
+	}
+	if(segmentList.length < 2) {
+		return false;
+	}
+	segmentList.sort(comparer);
+	this._childIds = rids.concat(segmentList.map(_toSegmentId));
+	return true;
+};
+/** Get segment id and ids of children, including nested segments, but excluding sub segments
+* @public
+* @param {Array.<string>} ary
+* @return {!Array.<string>}
+*/
+Segment.prototype.getFlattenTreeIds = function(ary) {
+	if(!ary) {
+		ary = [];
+	}
+
+	if(!this._subSegment) { // Sub segments are excluded from tree
+		ary.push(this._rid);
+	}
+	let i;
+	let segmentNames = this._subSegNames;
+	if(segmentNames) { // Classified segment
+		let segmentCount = segmentNames.length;
+		let segmentMap = this._subSegMap;
+		for(i = 0; i < segmentCount; ++i) {
+			segmentMap[segmentNames[i]].getFlattenTreeIds(ary);
+		}
+	} else {
+		let childIds = this._childIds;
+		let childCount = childIds.length;
+		let segments = this._shared.segments;
+		for(i = 0; i < childCount; ++i) {
+			let childId = childIds[i];
+			let childSegment = segments[childId];
+			if(childSegment) {
+				childSegment.getFlattenTreeIds(ary);
+			} else {
+				ary.push(childId);
+			}
+		}
+	}
+
+	return ary;
+};
 
 /** @public
 * @param {boolean=} bool
@@ -9770,9 +9983,7 @@ Segment.prototype.collapse = function(bool) {
 	bool = (bool !== false);
 	if(this._collapsed !== bool) {
 		this._collapsed = bool;
-		if(this._childCount || this._subSegDef) {
-			this._shared.dirtyCollapsingState = true;
-		}
+		this.markCollapsingStateDirty();
 		return true;
 	}
 	return false;
@@ -9790,82 +10001,87 @@ Segment.prototype.expand = function(bool) {
 Segment.prototype.isCollapsed = function() {
 	return this._collapsed;
 };
-/** @public
+/** Get all collapsing state from all children (subsegments and child segments), excluding the segment itself
+* @public
 * @param {Object=} objMap
 * @param {boolean=} parentState=false Collapsing state from parent segment
 * @return {boolean}
 */
 Segment.prototype.getCollapsingStates = function(objMap, parentState) {
-	let segmentNames = this._subSegNames;
-	if(!this._subSegLevel) { // Only root segment
-		if(!segmentNames) { // No sub segment
-			if(!this._collapsed) {
-				return false;
-			}
-		}
+	let childList = this._subSegNames;
+	let segmentMap = this._subSegMap;
+	let subSegment = true; // Normal segments can have subsegments without being subsegment themselve
+	if(!childList && this._shared) { // Ensure that segment has not been disposed
+		childList = this._childIds;
+		segmentMap = this._shared.segments;
+		subSegment = false;
+	}
+	let childCount = childList ? childList.length : 0;
+	if(!childCount) {
+		return false;
 	}
 
+	let dirty = false;
+	let childCollapsed = (parentState || this._collapsed) ? true : false;
+
 	if(!objMap) {
 		objMap = {};
 	}
-	let dirty = false;
-	if(this._subSegLevel) { // Sub segments are also subjected to collapsing
-		if(parentState) {
-			objMap[this._rid] = true;
+	for(let i = 0; i < childCount; ++i) {
+		let rid = "";
+		let segment = null;
+		if(subSegment) {
+			segment = segmentMap[childList[i]]; // Use segment name to retrieve subsegment
+			rid = segment.getId();
+		} else {
+			rid = childList[i];
+			segment = segmentMap[rid]; // Use row id to retrieve segment from shared map
+		}
+		if(childCollapsed) {
+			objMap[rid] = childCollapsed; // Collapsing states for all children is registered here
 			dirty = true;
 		}
-	}
-	if(this._childCount) {
-		let collapsed = parentState || this._collapsed;
-		if(segmentNames) {
-			let segmentMap = this._subSegMap;
-			let segmentCount = segmentNames.length;
-			for(let i = 0; i < segmentCount; ++i) {
-				let segment = segmentMap[segmentNames[i]];
-				objMap[segment.getId()] = !!parentState;
-				if(segment.getCollapsingStates(objMap, collapsed)) {
-					dirty = true;
-				}
-			}
-		} else if(collapsed) {
-			let chdr = this._children;
-			for(let rid in chdr) {
-				objMap[rid] = collapsed;
-			}
+		if(segment && segment.getCollapsingStates(objMap, childCollapsed)) {
 			dirty = true;
 		}
 	}
 	return dirty;
 };
 
+/** @private
+* @return {number}
+*/
+Segment.prototype._getOrder = function() {
+	return this._order * 10000;
+};
+/** @private
+* @return {number}
+*/
+Segment.prototype._getLastOrder = function() {
+	return this._getOrder() + this._offsetOrder;
+};
 /** @public
 * @return {number}
 */
 Segment.prototype.getOrder = function() {
-	if(this._subSegLevel) {
-		let ancestor = this.getFirstAncestor();
-		if(ancestor) {
-			// WARNING: this._order cannot be greater than 9999
-			return ancestor.getOrder() + this._order;
-		}
+	let ancestor = this.getFirstAncestor();
+	if(ancestor) {
+		// WARNING: this._order cannot be greater than 9999
+		return ancestor._getOrder() + this._order;
 	}
-	return this._order * 10000;
+	return this._getOrder();
 };
 /** Get the last (highest) order from the entire tree regardless of the current position segment in the hierachy
 * @public
 * @return {number}
 */
 Segment.prototype.getLastOrder = function() {
-	if(this._subSegDef) {
-		let subSegments = this._subSegDef.subSegments;
-		if(subSegments) {
-			let lastSegment = subSegments[subSegments.length - 1];
-			if(lastSegment) {
-				return lastSegment.getOrder();
-			}
-		}
+	let ancestor = this.getFirstAncestor();
+	if(ancestor) {
+		// WARNING: this._order cannot be greater than 9999
+		return ancestor._getLastOrder();
 	}
-	return this.getOrder();
+	return this._getLastOrder();
 };
 /** @public
 * @param {number} val
@@ -9873,6 +10089,13 @@ Segment.prototype.getLastOrder = function() {
 Segment.prototype.setOrder = function(val) {
 	this._order = val;
 };
+/** @public
+* @param {number} val
+* @returns {number} Returns the number set
+*/
+Segment.prototype.setLastOrder = function(val) {
+	return (this._offsetOrder = val);
+};
 
 /** @private
 * @type {Array.<string>}
@@ -9880,9 +10103,10 @@ Segment.prototype.setOrder = function(val) {
 Segment._tabs = null;
 /** @public
 * @param {Array.<string>=} lines
+* @param {number=} tabLevel
 * @return {!Array.<string>} lines
 */
-Segment.prototype.log = function(lines) {
+Segment.prototype.log = function(lines, tabLevel) {
 	if(!lines) {
 		lines = [];
 	}
@@ -9897,23 +10121,43 @@ Segment.prototype.log = function(lines) {
 			tabCh += "  ";
 		}
 	}
+	if(!tabLevel) {
+		tabLevel = 0;
+	}
+
 	let collapsedCh = this._collapsed ? "+ " : "- ";
-	lines.push(tabs[this._subSegLevel] + collapsedCh + this._rid);
+	lines.push(tabs[tabLevel] + collapsedCh + this._rid);
 
-	let segmentNames = this._subSegNames;
-	if(segmentNames) {
-		let segmentCount = segmentNames.length;
-		let segmentMap = this._subSegMap;
-		for(i = 0; i < segmentCount; ++i) {
-			segmentMap[segmentNames[i]].log(lines);
+	let childLevel = tabLevel + 1;
+	let childIndent = tabs[childLevel];
+
+	let childList = this._subSegNames;
+	let segmentMap = this._subSegMap;
+	let subSegment = true; // Normal segments can have subsegments without being subsegment themselve
+	if(!childList && this._shared) { // Ensure that segment has not been disposed
+		childList = this._childIds;
+		segmentMap = this._shared.segments;
+		subSegment = false;
+	}
+	let childCount = childList ? childList.length : 0;
+
+	for(i = 0; i < childCount; ++i) {
+		let rid = "";
+		let segment = null;
+		if(subSegment) {
+			segment = segmentMap[childList[i]]; // Use segment name to retrieve subsegment
+			rid = segment.getId();
+		} else {
+			rid = childList[i];
+			segment = segmentMap[rid]; // Use row id to retrieve segment from shared map
 		}
-	} else if(this._childCount) {
-		let indent = tabs[this._subSegLevel + 1];
-		for(let rid in this._children) {
-			lines.push(indent + "- " + rid);
+
+		if(segment) {
+			segment.log(lines, childLevel);
+		} else {
+			lines.push(childIndent + "- " + rid);
 		}
 	}
-
 	return lines;
 };
 
@@ -9938,6 +10182,7 @@ let SegmentCollection = function() {
 	this._removalList = [];
 
 	this._shared = {
+		segments: this._segments,
 		childToSegment: {}, // child Id to segment Id
 		dirtyCollapsingState: false,
 		defaultCollapsing: false
@@ -9998,10 +10243,6 @@ SegmentCollection.prototype.dispose = function() {
 */
 SegmentCollection.prototype.addSegment = function(rid, childRids) {
 	if(rid && !this._segments[rid]) {
-		if(this.getParentRowId(rid)) {
-			console.log("child of a segment cannot be set as a segment separator");
-			return false;
-		}
 		let segment = this._segments[rid] = new data_Segment(rid, this._shared);
 		segment.addEventListener("subSegmentAdded", this._onSubSegmentAdded);
 		segment.addEventListener("subSegmentRemoved", this._onSubSegmentRemoved);
@@ -10048,33 +10289,41 @@ SegmentCollection.prototype.getParentRowId = function(rid) {
 */
 SegmentCollection.prototype.removeSegment = function(rid) {
 	let segment = this._segments[rid];
-	if(segment) {
-		if(this._segmentCount <= 1) {
-			return this.removeAllSegments();
-		}
-		if(segment.isSubSegment()) {
-			this._removalList.push(segment.getId());
-		}
-		let subSegIds = segment.getSubSegmentIds();
-		if(subSegIds) {
-			let len = subSegIds.length;
-			for(let i = 0; i < len; ++i) {
-				let subSegId = subSegIds[i];
-				if(this._segments[subSegId]) {
-					this._removalList.push(subSegId);
-					delete this._segments[subSegId]; // Slow
-					--this._segmentCount;
-				}
+	if(!segment) {
+		return false;
+	}
+
+	if(this._segmentCount <= 1) {
+		return this.removeAllSegments();
+	}
+	let subSegment = segment.isSubSegment();
+	if(subSegment) {
+		this._removalList.push(segment.getId());
+	}
+	let subSegIds = segment.getSubSegmentIds();
+	if(subSegIds) {
+		let len = subSegIds.length;
+		for(let i = 0; i < len; ++i) {
+			let 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;
 	}
-	return false;
+	if(!subSegment) {
+		let parentSeg = segment.getParent();
+		if(parentSeg) { // Move existing children to its parent
+			parentSeg.addChildren(segment.getChildIds()); // WARNING: passing private member
+		}
+	}
+	segment.removeAllChildren(); // This is important for updating childToSegment
+	segment.dispose();
+
+	delete this._segments[rid]; // Slow
+	--this._segmentCount;
+	return true;
 };
 /** @public
 * @return {boolean} Returns true if there is any change. Otherwise, returns false
@@ -10087,6 +10336,7 @@ SegmentCollection.prototype.removeAllSegments = function() {
 		this._segments = {};
 		this._segmentCount = 0;
 		this._segmentList = null;
+		this._shared.segments = this._segments;
 		this._shared.childToSegment = {};
 
 		this._classification = this._classifierChanged = false;
@@ -10131,6 +10381,23 @@ SegmentCollection.prototype.getSegments = function() {
 SegmentCollection.prototype.getSegmentIds = function() {
 	return Object.keys(this._segments);
 };
+/** @public
+* @param {!Function} comparer
+* @return {!Array.<Segment>}
+*/
+SegmentCollection.prototype.sortSegments = function(comparer) {
+	let rootSegments = [];
+	let segmentSeparators = this._segments;
+	for(let rid in segmentSeparators) {
+		let segment = segmentSeparators[rid];
+		segment.sortSegments(comparer);
+		if(segment.isRootSegment()) {
+			rootSegments.push(segment);
+		}
+	}
+	rootSegments.sort(comparer);
+	return rootSegments;
+};
 
 
 /** @public
@@ -10212,7 +10479,7 @@ SegmentCollection.prototype.getCollapsedRows = function() {
 			collapsedRids = {};
 			for(let rid in segmentSeparators) {
 				let segment = segmentSeparators[rid];
-				if(!segment.isSubSegment()) {
+				if(segment.isRootSegment()) {
 					if(segment.getCollapsingStates(collapsedRids)) {
 						++count;
 					}
@@ -10224,6 +10491,31 @@ SegmentCollection.prototype.getCollapsedRows = function() {
 	return this._collapsedRids;
 };
 
+/** Invalidate segment order cache, if the given row id is a segment separator
+* @private
+* @param {string|Array.<string>} segmentIds
+* @returns {boolean} Returns true if there is any change
+*/
+SegmentCollection.prototype._invalidateSegmentOrder = function(segmentIds) {
+	if(this._segmentList) {
+		if(typeof segmentIds === "string") {
+			if(this._segments[segmentIds]) {
+				this._segmentList = null;
+				return true;
+			}
+		} else if(Array.isArray(segmentIds)) {
+			let len = segmentIds.length;
+			for(let i = 0; i < len; ++i) {
+				let segmentId = segmentIds[i];
+				if(this._segments[segmentId]) {
+					this._segmentList = null;
+					return true;
+				}
+			}
+		}
+	}
+	return false;
+};
 /** @public
 * @param {string} segmentId
 * @param {string} rid
@@ -10233,6 +10525,8 @@ SegmentCollection.prototype.getCollapsedRows = function() {
 SegmentCollection.prototype.addSegmentChild = function(segmentId, rid, dataId) {
 	let segment = this._segments[segmentId];
 	if(segment && !segment.isSubSegment()) {
+		// If a segment becomes a child of other segment, then the segment order needs to be recalculated
+		this._invalidateSegmentOrder(rid);
 		return segment.addChild(rid, dataId);
 	}
 	return false;
@@ -10246,11 +10540,14 @@ SegmentCollection.prototype.addSegmentChild = function(segmentId, rid, dataId) {
 SegmentCollection.prototype.addSegmentChildren = function(segmentId, rids, dataIds) {
 	let segment = this._segments[segmentId];
 	if(segment && !segment.isSubSegment()) {
+		// If a segment becomes a child of other segment, then the segment order needs to be recalculated
+		this._invalidateSegmentOrder(rids);
 		return segment.addChildren(rids, dataIds);
 	}
 	return false;
 };
-/** @public
+/** This only works for immediate children of the specified segment
+* @public
 * @param {string} segmentId
 * @param {string} rid
 * @return {boolean} Returns true if there is any change. Otherwise, returns false
@@ -10270,6 +10567,7 @@ SegmentCollection.prototype.containsSegmentChild = function(segmentId, rid) {
 SegmentCollection.prototype.removeSegmentChild = function(segmentId, rid) {
 	let segment = this._segments[segmentId];
 	if(segment) {
+		this._invalidateSegmentOrder(rid);
 		return segment.removeChild(rid);
 	}
 	return false;
@@ -10282,6 +10580,7 @@ SegmentCollection.prototype.removeSegmentChild = function(segmentId, rid) {
 SegmentCollection.prototype.removeSegmentChildren = function(segmentId, rids) {
 	let segment = this._segments[segmentId];
 	if(segment) {
+		this._invalidateSegmentOrder(rids);
 		return segment.removeChildren(rids);
 	}
 	return false;
@@ -10301,6 +10600,7 @@ SegmentCollection.prototype.removeAllSegmentChildren = function() {
 	}
 
 	if(dirty) {
+		this._segmentList = null; // WARNING: not optimized
 		this.classify(null);
 	}
 
@@ -10359,10 +10659,14 @@ SegmentCollection.prototype.fillSegments = function(rids) {
 };
 /** @public
 * @param {Array.<string>} rids
+* @param {boolean=} useCache=false If this is true, skip the calculation when there is already a cache for segment order
 */
-SegmentCollection.prototype.calcSegmentOrder = function(rids) {
+SegmentCollection.prototype.calcSegmentOrder = function(rids, useCache) {
 	let segmentList = this._segmentList;
 	if(segmentList) {
+		if(useCache) {
+			return; // Use previous cache for segment order
+		}
 		segmentList.length = 0;
 	} else {
 		segmentList = this._segmentList = [];
@@ -10376,9 +10680,10 @@ SegmentCollection.prototype.calcSegmentOrder = function(rids) {
 		let rid = rids[i];
 		let segment = segmentSeparators[rid];
 		if(segment) {
-			if(!segment.isSubSegment()) {
+			if(segment.isRootSegment()) {
 				this._segmentList.push(segment);
 				segment.setOrder(++order); // WARNING: Segments and sub segments start with 1
+				segment.updateTreeStructure(0);
 			}
 			if(--segmentCount <= 0) {
 				break;
@@ -10402,7 +10707,7 @@ SegmentCollection.prototype.getSegmentValues = function(rids, partial) {
 	let prevSegment = null;
 	let segmentValues = new Array(rowCount);
 	let segmentVal = 0;
-	let highestVal = -10;
+	let highestVal = 0;
 	let offset = 0;
 	for(let r = 0; r < rowCount; ++r) {
 		let rid = rids[r];
@@ -10410,7 +10715,7 @@ SegmentCollection.prototype.getSegmentValues = function(rids, partial) {
 		if(curSegment) { // segment separator
 			segmentVal = curSegment.getOrder() * 100;
 			offset = 0;
-			if(!curSegment.isSubSegment()) {
+			if(curSegment.isRootSegment()) {
 				if(prevSegment !== curSegment) {
 					prevSegment = curSegment;
 					highestVal = curSegment.getLastOrder() * 100;
@@ -10422,12 +10727,14 @@ SegmentCollection.prototype.getSegmentValues = function(rids, partial) {
 				curSegment = segmentSeparators[parentId];
 				segmentVal = curSegment.getOrder() * 100;
 				offset = 1;
-				if(partial) {
+				if(partial) { // This fixes the out of order sub segment
 					highestVal = curSegment.getLastOrder() * 100;
 				}
 			} else { // row outside of segments
 				if(highestVal) {
-					segmentVal = highestVal;
+					if(segmentVal < highestVal) {
+						segmentVal = highestVal;
+					}
 					offset = 10;
 				} else {
 					segmentVal = offset = 0;
@@ -10451,7 +10758,10 @@ SegmentCollection.prototype.logStructure = function() {
 	let segmentCount = segmentList.length;
 	let lines = [];
 	for(let i = 0; i < segmentCount; ++i) {
-		segmentList[i].log(lines);
+		let segment = segmentList[i];
+		if(segment.isRootSegment()) {
+			segment.log(lines);
+		}
 	}
 
 	return lines.join("\n");
@@ -10461,10 +10771,14 @@ SegmentCollection.prototype.logStructure = function() {
 */
 SegmentCollection.prototype.logRowIdMap = function() {
 	let lines = [];
+	let segmentSeparators = this._segments;
 	let childToSegmentId = this._shared.childToSegment;
 	for(let rid in childToSegmentId) {
 		let segmentId = childToSegmentId[rid];
-		lines.push(rid + " > " + segmentId);
+		let segment = segmentSeparators[segmentId];
+		if(!segment || !segment.isSubSegment()) {
+			lines.push(rid + " > " + segmentId);
+		}
 	}
 
 	return lines.join("\n");
@@ -11491,7 +11805,7 @@ DataTable.prototype.getSortingLogics = function() {
 };
 /** @public
 * @param {string|Array.<string>} cid Column id
-* @param {string|number|Array.<string|number>=} sortOrders "a"|"d"|"n"
+* @param {(string|number|Array.<string|number>)=} sortOrders "a"|"d"|"n"
 * @param {DataTable.SortLogic=} customComparer
 * @param {*=} contextObj Context object that will be provided as the forth parameter of the given comparer method
 * @return {boolean} Return true if there is any change, otherwise false
@@ -11596,64 +11910,65 @@ DataTable.prototype._initSegmentCollection = function() {
 		this._segments.addEventListener("subSegmentChanged", this._onSubSegmentChanged);
 	}
 };
-/**
+/** Add or remove all segments from the given row ids
 * @public
 * @param {Array.<string>} rids
 * @param {boolean=} enabled
 * @return {boolean} Return true if there is any change
 */
 DataTable.prototype.setSegmentSeparators = function(rids, enabled) {
-	let change = false;
-	if (rids) {
-		let len = rids.length;
-		let segmentChanged = false;
-		for (let i = 0; i < len; i++) {
-			if(enabled !== false) {
-				let rid = rids[i];
-				this._initSegmentCollection();
-				if(this._autoSegmentFilling) {
-					let parentId = this._segments.getParentRowId(rid);
-					if(parentId) {
-						this._segments.removeSegmentChild(parentId, rid);
-					}
+	if (!rids) {
+		return false;
+	}
+	let adding = (enabled !== false);
+	let segmentAdded = 0;
+	let segmentRemoved = 0;
+
+	let len = rids.length;
+	for (let i = 0; i < len; i++) {
+		let rid = rids[i];
+		if(adding) {
+			this._initSegmentCollection();
+			if(this._autoSegmentFilling) {
+				let parentId = this._segments.getParentRowId(rid);
+				if(parentId) {
+					this._segments.removeSegmentChild(parentId, rid);
 				}
-				segmentChanged = this._segments.addSegment(rid);
-			} else if (this._segments) { // remove case
-				let segment = this._segments.getSegment(rid);
-				if(segment) {
-					if(this._segments.removeSegment(rid)) {
-						change = true;
-						if(!this._segments.getSegmentCount()) {
-							this._segments = null;
-						}
+			}
+			segmentAdded |= this._segments.addSegment(rid);
+		} else if (this._segments) { // Removing
+			let segment = this._segments.getSegment(rid);
+			if(segment) {
+				if(this._segments.removeSegment(rid)) {
+					segmentRemoved = 1;
+					if(!this._segments.getSegmentCount()) {
+						this._segments = null;
 					}
 				}
 			}
-
-		}
-		if (enabled !== false && segmentChanged) {
-			this._segments.calcSegmentOrder(this._rids);
-			change = true;
-		}
-		if(change) {
-			this.dispatchGlobalChange();
 		}
 	}
-	return change;
-
+	if (segmentAdded) {
+		this._segments.calcSegmentOrder(this._rids);
+	}
+	let changed = segmentAdded || segmentRemoved;
+	if(changed && this._needFiring()) {
+		this.dispatchGlobalChange();
+	}
+	return changed ? true : false;
 };
 
 /**
 * @public
 * @param {string} rid
-* @param {boolean=} enabled
+* @param {*=} options=null Segment options. If the value is false, segment separator will be stripped off from the given rid
 * @return {boolean} Return true if there is any change
 */
-DataTable.prototype.setSegmentSeparator = function(rid, enabled) {
+DataTable.prototype.setSegmentSeparator = function(rid, options) {
 	let change = false;
 	let memberCount = 0;
 	if(rid && typeof rid === "string") {
-		if(enabled !== false) {
+		if(options !== false) {
 			this._initSegmentCollection();
 			if(this._autoSegmentFilling) {
 				let parentId = this._segments.getParentRowId(rid);
@@ -11661,11 +11976,12 @@ DataTable.prototype.setSegmentSeparator = function(rid, enabled) {
 					this._segments.removeSegmentChild(parentId, rid);
 				}
 			}
-			if(this._segments.addSegment(rid)) {
+			let children = (options && options["children"]) ? options["children"] : null;
+			if(this._segments.addSegment(rid, children)) {
 				this._segments.calcSegmentOrder(this._rids);
 				change = true;
 			}
-		} else if(this._segments) { // mean remove separator
+		} else if(this._segments) { // Remove the separator
 			let segment = this._segments.getSegment(rid);
 			if(segment) {
 				memberCount = segment.getChildCount();
@@ -11860,6 +12176,20 @@ DataTable.prototype.fillSegments = function() {
 	}
 	return false;
 };
+/** @private
+* @param {boolean=} adding This indicates that segment is changed by adding a new child
+*/
+DataTable.prototype._onSegmentChildChanged = function(adding) {
+	if(this._segments) {
+		this._segments.calcSegmentOrder(this._rids, true);
+	}
+	if(adding !== false) {
+		this._sort(null);
+	}
+	this._dispatchPositionChange(); // Force rerendering, even if there is no position change
+
+	this.requestClassifying();
+};
 /** @public
 * @param {string} segmentId Row id
 * @param {string} rid Row id
@@ -11870,10 +12200,7 @@ DataTable.prototype.addSegmentChild = function(segmentId, rid, dataId) {
 	if(this._segments) {
 		let dirty = this._segments.addSegmentChild(segmentId, rid, dataId);
 		if(dirty) {
-			this._sort(null);
-			this._dispatchPositionChange(); // Force rerendering, even if there is no position change
-
-			this.requestClassifying();
+			this._onSegmentChildChanged();
 			return true;
 		}
 	}
@@ -11889,17 +12216,15 @@ DataTable.prototype.addSegmentChildren = function(segmentId, rids, dataIds) {
 	if(this._segments) {
 		let dirty = this._segments.addSegmentChildren(segmentId, rids, dataIds);
 		if(dirty) {
-			this._sort(null);
-			this._dispatchPositionChange(); // Force rerendering, even if there is no position change
-
-			this.requestClassifying();
+			this._onSegmentChildChanged();
 			return true;
 		}
 	}
 	return false;
 };
 
-/** @public
+/** Deprecated. Remove all existing children and add new children according to the give array
+* @public
 * @param {Array.<Object>} segmentArr Segment array that contain "segmentId", "rowIds" to set segment children
 * @return {boolean} Return true if there is any change
 */
@@ -11907,20 +12232,16 @@ DataTable.prototype.setSegmentChildren = function(segmentArr) {
 	if(!this._segments) {
 		return false;
 	}
-	this.removeAllSegmentChildren();
+	let dirty = this._segments.removeAllSegmentChildren();
 	let len = segmentArr.length;
-	let dirty;
 	for (let i = 0; i < len; i++) {
 		let obj = segmentArr[i];
-		if(this._segments.addSegmentChildren(obj.segmentId, obj.rowIds)) {
+		if(this._segments.addSegmentChildren(obj["segmentId"], obj["rowIds"])) {
 			dirty = true;
 		}
 	}
 	if(dirty) {
-		this._sort(null);
-		this._dispatchPositionChange(); // Force rerendering, even if there is no position change
-
-		this.requestClassifying();
+		this._onSegmentChildChanged();
 		return true;
 	}
 
@@ -11935,8 +12256,7 @@ DataTable.prototype.removeSegmentChild = function(segmentId, rid) {
 	if(this._segments) {
 		let dirty = this._segments.removeSegmentChild(segmentId, rid);
 		if(dirty) {
-			this.dispatchGlobalChange();
-			this.requestClassifying();
+			this._onSegmentChildChanged(false);
 		}
 		return dirty;
 	}
@@ -11951,8 +12271,7 @@ DataTable.prototype.removeSegmentChildren = function(segmentId, rids) {
 	if(this._segments) {
 		let dirty = this._segments.removeSegmentChildren(segmentId, rids);
 		if(dirty) {
-			this.dispatchGlobalChange();
-			this.requestClassifying();
+			this._onSegmentChildChanged(false);
 		}
 		return dirty;
 	}
@@ -11965,7 +12284,7 @@ DataTable.prototype.removeAllSegmentChildren = function() {
 	if(this._segments) {
 		let dirty = this._segments.removeAllSegmentChildren(); // This immediately remove all sub segments
 		if (dirty) {
-			this.dispatchGlobalChange();
+			this._onSegmentChildChanged(false);
 		}
 		return dirty;
 	}
@@ -11996,50 +12315,51 @@ DataTable.prototype.getSegmentChildIds = function(segmentId) {
 	}
 	return null;
 };
+/**
+* @private
+* @param {(Array|number)} sortOrder
+* @param {*} context
+*/
+DataTable.prototype._setSegmentSortContext = function (sortOrder, context) {
+	this._segmentSortOrder = sortOrder;
+	this._segmentSortContext = context;
+};
 /** Sort all of existing segments by multiple sort logics
 * @public
 * @param {Function|Array.<Function>|Object} sortLogics
-* @param {Array.<number>=} sortOrders
+* @param {Array.<number|string>=} sortOrders
 * @param {Array.<string>=} cids
 * @return {boolean}
 */
 DataTable.prototype.sortSeparators = function (sortLogics, sortOrders, cids) {
-	let dirty = false;
 	if(!this._segments){
 		return false;
 	}
 	if(typeof sortLogics === "function"){
+		this._setSegmentSortContext(DataTable._getSortOrder(sortOrders), cids);
 		return this.sortSegments(sortLogics);
 	}
+	if(!cids) {
+		return false;
+	}
 	let sortingDefs = DataTable._buildSortContext(
 		[],
 		cids,
 		sortOrders,
-		sortLogics
+		sortLogics || this._compMap
 	);
-	let defCount = sortingDefs ? sortingDefs.length : 0;
-	if(!defCount){
-		return dirty;
-	}
-
-	let sortOrder = 0;
-	let sortLogic, sortContext;
+	let defCount = sortingDefs.length;
+	let sortLogic = null;
 	if(defCount > 1) {
 		sortLogic = DataTable._multiColumnSeparatorCompareLogic;
-		sortContext = sortingDefs;
-		sortOrder = 1; // sortOrder is not used by _multiColumnSeparatorCompareLogic
-	} else { // Single level sorting
+		this._setSegmentSortContext(1, sortingDefs);
+	} else if(defCount === 1) { // Single level sorting
 		sortLogic = DataTable._singleColumnSeparatorCompareLogic;
-		sortContext = sortingDefs[0];
-		sortOrder = /** @type{number} */(sortContext[3]);
+		this._setSegmentSortContext(sortingDefs[0][3], sortingDefs[0]); // sortOrder and context
+	} else {
+		return false;
 	}
-	this._segmentSortOrder = sortOrder;
-	this._segmentSortContext = sortContext;
-	dirty = this.sortSegments(sortLogic);
-	this._segmentSortOrder = 0;
-	this._segmentSortContext = null;
-
-	return dirty;
+	return this.sortSegments(sortLogic);
 };
 /** Sort all of existing segments by given compare function
 * @public
@@ -12054,40 +12374,33 @@ DataTable.prototype.sortSegments = function (compare) {
 		this._segments.calcSegmentOrder(this._rids);
 		return false;
 	}
-	let rids = this._rids;
-	let segments = this._segments;
-	let segmentCount = segments.getSegmentCount();
-	let segmentList = [];
-	let origOrder = [];
-	let itemCount = 0;
-	let rowCount = rids.length;
-	let rid = "";
-	let segment = null;
-	let i;
-	for(i = 0; i < rowCount; ++i) {
-		rid = rids[i];
-		segment = segments.getSegment(rid);
-		if(segment) {
-			origOrder.push(i);
-			segmentList.push(segment);
-			if(++itemCount >= segmentCount) {
-				break;
-			}
-		}
-	}
 
 	this._userSegmentComparer = compare;
-	segmentList.sort(this._bySegmentSeparator);
+
+	let segments = this._segments;
+	let rootSegments = segments.sortSegments(this._bySegmentSeparator);
+
 	this._userSegmentComparer = null;
+	this._setSegmentSortContext(0, null);
+
+	let rids = this._rids;
+	let origRids = rids.slice();
+	let rowCount = rids.length;
+	rids.length = 0;
 
+	let segmentCount = 0;
 	let dirty = false;
-	for(i = 0; i < itemCount; ++i) {
-		let idx = origOrder[i];
-		rid = rids[idx];
-		segment = segmentList[i];
-		let newRid = segment.getId();
-		if(rid !== newRid) {
-			rids[idx] = newRid;
+	for(let i = 0; i < rowCount; ++i) {
+		let rid = origRids[i];
+		let segment = segments.getSegment(rid);
+		if(segment) {
+			if(segment.isRootSegment()) {
+				rootSegments[segmentCount++].getFlattenTreeIds(rids);
+			}
+		} else if(!segments.getParentRowId(rid)) {
+			rids.push(rid);
+		}
+		if(rid !== rids[i]) {
 			dirty = true;
 		}
 	}
@@ -12096,9 +12409,8 @@ DataTable.prototype.sortSegments = function (compare) {
 		this._segments.calcSegmentOrder(rids);
 		this._sort(null);
 		this._dispatchPositionChange();
-		return true;
 	}
-	return false;
+	return dirty;
 };
 /** Sort all of existing segments by given compare function
 * @private
@@ -12381,7 +12693,7 @@ DataTable._positionChangeArg = {"globalChange": true, "positionChangeOnly": true
 * @function
 * @public
 * @ignore
-* @param {Array.<Array>} out_defs Output object. Array is used to optimize property accessing time.
+* @param {!Array.<Array>} out_defs Output object. Array is used to optimize property accessing time.
 * @param {string|Array.<string>} cids
 * @param {string|number|Array.<string|number>=} sortOrders
 * @param {Function|Array.<Function>|Object.<string, DataTable.SortLogic>=} logics
@@ -31600,13 +31912,13 @@ DataView.prototype.setSegmentSeparators = function(rowIds, enabled) {
 	}
 	return false;
 };
-/** Set visible row as segment separator (hidden or filtered rows cannot be a segment separator)
+/** Set visible row as a segment separator (hidden or filtered rows cannot be a segment separator)
 * @public
 * @param {string|number} rowRef Row id or row index
-* @param {boolean=} enabled
+* @param {*=} options=null Segment options. If the value is false, segment separator will be stripped off from the given rid
 * @return {boolean} Return true if there is any change
 */
-DataView.prototype.setSegmentSeparator = function(rowRef, enabled) {
+DataView.prototype.setSegmentSeparator = function(rowRef, options) {
 	let rowId = "";
 	if(typeof rowRef === "number") {
 		rowId = this.getRowId(rowRef);
@@ -31615,12 +31927,11 @@ DataView.prototype.setSegmentSeparator = function(rowRef, enabled) {
 	}
 
 	if(rowId) {
-		enabled = enabled !== false;
-		if(enabled) {
+		if(options !== false) { // undefined, null, object, or true value
 			this.synchronizeRowOrder();
 		}
 		// TODO: Force expanding of segment before unsetting segment separator
-		return this._dt.setSegmentSeparator(rowId, enabled);
+		return this._dt.setSegmentSeparator(rowId, options);
 	}
 	return false;
 };
@@ -31853,10 +32164,22 @@ DataView.prototype.getSegmentChildIds = function(segmentRef) {
 /** Sort all of existing segments by multiple sort logics
 * @public
 * @param {Function|Array.<Function>|Object} sortLogics
-* @param {Array.<number>=} sortOrders
-* @param {Array.<string>=} cids
+* @param {(number|Array.<number>)=} sortOrders
+* @param {(string|Array.<string>)=} cids
 */
 DataView.prototype.sortSeparators = function (sortLogics, sortOrders, cids) {
+	let sortingDefs = this._sortingDefs;
+	if(sortingDefs.length) {
+		if(!cids) {
+			cids = sortingDefs[0][0]; // field
+		}
+		if(!sortOrders) {
+			sortOrders = sortingDefs[0][3];
+		}
+	} else if(!sortLogics) {
+		return;
+	}
+
 	this._dt.sortSeparators(sortLogics, sortOrders, cids);
 };
 /** Sort all of existing segments by given compare function
@@ -34807,7 +35130,6 @@ VirtualizedLayoutGrid.prototype.setWidth = function (px) {
 };
 /** @override */
 VirtualizedLayoutGrid.prototype.setHeight = function (px) {
-	console.log("unsupported");
 	return false;
 };
 /** {@link ElementWrapper#show}
@@ -34986,7 +35308,6 @@ VirtualizedLayoutGrid.prototype.getMinimumRowHeight = function (index) {
 };
 /** @inheritDoc */
 VirtualizedLayoutGrid.prototype.setMinimumRowHeight = function (index, val) {
-	console.log("unsupported");
 	return false;
 };
 
@@ -35062,7 +35383,6 @@ VirtualizedLayoutGrid.prototype.getRowScalability = function (indexY) {
 };
 /** @inheritDoc */
 VirtualizedLayoutGrid.prototype.setRowScalability = function (index, val) {
-	console.log("unsupported");
 	return false;
 };
 
@@ -35208,17 +35528,15 @@ VirtualizedLayoutGrid.prototype.getRowHighlight = function () {
 /** @inheritDoc */
 VirtualizedLayoutGrid.prototype.setRowHighlight = function (rowIndex) {
 	let prevIndex = this._grid.getRowHighlight();
-	if (prevIndex >= 0) { prevIndex += this._firstIndex; }
 	this._grid.setRowHighlight(rowIndex - this._firstIndex);
-	//Check row highligh is in view
-	rowIndex = this._grid.getRowHighlight();
-	if (rowIndex >= 0) { rowIndex += this._firstIndex; }
 
 	if (this._hasListener("rowHighlighted")) {
-		let e = {};
-		e["prevRowIndex"] = prevIndex;
-		e["rowIndex"] = rowIndex;
-		this._dispatch("rowHighlighted", e);
+		rowIndex = this._grid.getRowHighlight();
+
+		this._dispatch("rowHighlighted", {
+			"prevRowIndex": (prevIndex >= 0) ? prevIndex + this._firstIndex : prevIndex,
+			"rowIndex": (rowIndex >= 0) ? rowIndex + this._firstIndex : rowIndex
+		});
 	}
 };
 
@@ -35969,6 +36287,7 @@ let _createHiddenInput = function () {
 	styleObj.width = styleObj.height = styleObj.padding = styleObj.border = "0";
 	hiddenInput.value = "0";
 	hiddenInput.role = "grid";
+	hiddenInput.readOnly = true;
 	return hiddenInput;
 };
 /** @private
@@ -36515,7 +36834,7 @@ Core.prototype._hasPendingRowChange = false;
 * @return {string}
 */
 Core.getVersion = function () {
-	return "5.1.135";
+	return "5.1.140";
 };
 /** {@link ElementWrapper#dispose}
 * @override
@@ -48877,16 +49196,17 @@ Grid_Grid.prototype._onFormulaDataRequired = function(e) {
 * @param {Object} e
 */
 Grid_Grid.prototype._onDataComposed = function(e) {
-	let values = e["changes"];
-	if(!values) {
+	let changes = e["changes"];
+	if(!changes) {
 		if(e["initialChanges"]) {
-			values = e["changes"] = e["initialChanges"]; // Need to keep e["changes"] for backward compatibility.
+			changes = e["changes"] = e["initialChanges"]; // Need to keep e["changes"] for backward compatibility.
 		} else {
 			return; // Cannot do data composition if there is no change in data
 		}
 	}
 
-	if(!e["rowData"]) {
+	let rowData = e["rowData"];
+	if(!rowData) {
 		return; // Row could already be removed or global change event is sent
 	}
 
@@ -48904,9 +49224,9 @@ Grid_Grid.prototype._onDataComposed = function(e) {
 	}
 
 	if(this._autoDateConversion) { // auto data conversion
-		let field, value, dataType, colDef;
-		for(field in values) {
-			colDef = this._getColumnDefinition(field);
+		let dataType;
+		for(let field in changes) {
+			let colDef = this._getColumnDefinition(field);
 			if(colDef) {
 				dataType = colDef.getDataType();
 			} else {
@@ -48914,7 +49234,7 @@ Grid_Grid.prototype._onDataComposed = function(e) {
 			}
 
 			if(dataType === "datetime") {
-				value = values[field];
+				let value = rowData[field];
 				rowDef.setData(field + "_RAW", value);
 				value = DateTime.toDateObject(value);
 				rowDef.setData(field, value); // TODO: Check if this trigger data change multiple times