@refinitiv-ui/efx-grid 6.0.147 → 6.0.149

package/lib/core/dist/core.js

@@ -13030,7 +13030,7 @@ EventDispatcher_EventDispatcher.preventDefault = preventDefault;
 */
 let Segment = function(rid, sharedObj) {
 	this._rid = rid;
-	this._children = {};
+	this._childIds = [];
 	this._shared = sharedObj;
 	if(sharedObj.defaultCollapsing) {
 		this._collapsed = true;
@@ -13061,14 +13061,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
@@ -13079,14 +13071,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
 */
@@ -13095,6 +13087,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
 */
@@ -13104,10 +13104,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
 */
@@ -13115,7 +13115,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
 */
@@ -13124,10 +13124,6 @@ Segment.prototype._subSegName = "";
 * @private
 */
 Segment.prototype._subSegVal;
-/** @type {Segment}
-* @private
-*/
-Segment.prototype._subSegParent = null;
 
 
 /** @public
@@ -13149,14 +13145,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}
@@ -13168,10 +13163,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
@@ -13199,22 +13201,44 @@ 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;
 };
 /** @public
@@ -13223,8 +13247,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) {
@@ -13244,27 +13275,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;
@@ -13276,10 +13315,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];
@@ -13294,21 +13333,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;
@@ -13319,24 +13361,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) {
@@ -13349,8 +13408,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) {
@@ -13393,9 +13452,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;
@@ -13412,7 +13470,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
 		}
 	}
@@ -13422,7 +13480,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 = {};
@@ -13436,9 +13494,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;
@@ -13446,20 +13503,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
 
@@ -13476,31 +13536,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;
@@ -13528,7 +13591,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);
@@ -13538,22 +13601,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() {
@@ -13562,21 +13620,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
@@ -13598,13 +13672,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
@@ -13629,7 +13765,7 @@ Segment.prototype.setRowData = function(rows, clsSource) {
 	let segment = this;
 	while(segment && segment.isSubSegment()) {
 		segment.getSubSegmentName(row);
-		segment = segment._subSegParent;
+		segment = segment.getParent();
 	}
 };
 /** @public
@@ -13637,9 +13773,9 @@ 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;
 		}
@@ -13655,9 +13791,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;
@@ -13675,82 +13809,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
@@ -13758,6 +13897,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>}
@@ -13765,9 +13911,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 = [];
 	}
@@ -13782,23 +13929,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;
 };
 
@@ -13823,6 +13990,7 @@ let SegmentCollection = function() {
 	this._removalList = [];
 
 	this._shared = {
+		segments: this._segments,
 		childToSegment: {}, // child Id to segment Id
 		dirtyCollapsingState: false,
 		defaultCollapsing: false
@@ -13883,10 +14051,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);
@@ -13933,33 +14097,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
@@ -13972,6 +14144,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;
@@ -14097,7 +14270,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;
 					}
@@ -14109,6 +14282,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
@@ -14118,6 +14316,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;
@@ -14131,11 +14331,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
@@ -14155,6 +14358,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;
@@ -14167,6 +14371,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;
@@ -14186,6 +14391,7 @@ SegmentCollection.prototype.removeAllSegmentChildren = function() {
 	}
 
 	if(dirty) {
+		this._segmentList = null; // WARNING: not optimized
 		this.classify(null);
 	}
 
@@ -14244,10 +14450,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 = [];
@@ -14261,9 +14471,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;
@@ -14287,7 +14498,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];
@@ -14295,7 +14506,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;
@@ -14307,12 +14518,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;
@@ -14336,7 +14549,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");
@@ -14346,10 +14562,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");
@@ -15481,64 +15701,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);
@@ -15546,11 +15767,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();
@@ -15745,6 +15967,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
@@ -15755,10 +15991,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;
 		}
 	}
@@ -15774,17 +16007,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
 */
@@ -15792,20 +16023,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;
 	}
 
@@ -15820,8 +16047,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;
 	}
@@ -15836,8 +16062,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;
 	}
@@ -15850,7 +16075,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;
 	}
@@ -21053,13 +21278,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);
@@ -21068,12 +21293,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;
 };
@@ -25964,7 +26188,7 @@ Core_Core.prototype._hasPendingRowChange = false;
 * @return {string}
 */
 Core_Core.getVersion = function () {
-	return "5.1.137";
+	return "5.1.139";
 };
 /** {@link ElementWrapper#dispose}
 * @override