@refinitiv-ui/efx-grid 6.0.37 → 6.0.39

package/lib/tr-grid-column-stack/es6/ColumnStack.js

@@ -115,6 +115,7 @@ var ColumnStackPlugin = function () {
 	this._onColumnAdded = this._onColumnAdded.bind(this);
 	this._onBeforeBatchOperation = this._onBeforeBatchOperation.bind(this);
 	this._onAfterBatchOperation = this._onAfterBatchOperation.bind(this);
+	this._onPinningChanged = this._onPinningChanged.bind(this);
 
 	this._onStackButtonClicked = this._onStackButtonClicked.bind(this);
 	this._updateUI = this._updateUI.bind(this);
@@ -159,7 +160,10 @@ ColumnStackPlugin.prototype._inReordering = false;
 * @private
 */
 ColumnStackPlugin.prototype._inResetting = false;
-
+/** @type {boolean}
+* @private
+*/
+ColumnStackPlugin.prototype._inPinning = false;
 
 /** @type {number}
 * @private
@@ -214,6 +218,7 @@ ColumnStackPlugin.prototype.initialize = function (host, options) {
 		host.listen("columnAdded", this._onColumnAdded);
 		host.listen("beforeBatchOperation", this._onBeforeBatchOperation);
 		host.listen("afterBatchOperation", this._onAfterBatchOperation);
+		host.listen("pinningChanged", this._onPinningChanged);
 	}
 	host.listen("preSectionRender", this._onPreSectionRender);
 
@@ -234,6 +239,7 @@ ColumnStackPlugin.prototype.unload = function (host) {
 	host.unlisten("beforeBatchOperation", this._onBeforeBatchOperation);
 	host.unlisten("afterBatchOperation", this._onAfterBatchOperation);
 	host.unlisten("preSectionRender", this._onPreSectionRender);
+	host.unlisten("pinningChanged", this._onPinningChanged);
 
 	if(this._hosts.length <= 0) {
 		this._conflator.reset();
@@ -392,9 +398,6 @@ ColumnStackPlugin.prototype.config = function (options) {
 */
 ColumnStackPlugin.prototype.getConfigObject = function (gridOptions) {
 	var obj = gridOptions || {};
-	var host = this._host || this._hosts[0];
-
-	var columnOptions = obj["columns"];
 
 	var stacks = this._groupDefs.getGroupMap();
 	var stackOptions = [];
@@ -403,17 +406,6 @@ ColumnStackPlugin.prototype.getConfigObject = function (gridOptions) {
 		var stackOption = stacks[stackKey];
 		var activeColIndex = this.getColumnIndex(stackOption.activeColumn);
 
-		if(columnOptions && columnOptions.length){
-			var memberIndices = this.getStackMemberIndices(stackOption.id);
-			for(var i = 0; i < memberIndices.length; i++){
-				var colIndex = memberIndices[i];
-				var colOption = columnOptions[colIndex];
-				if(colOption && host.isColumnVisible(colIndex)){
-					colOption.hidden = colIndex !== activeColIndex;
-				}
-			}
-		}
-
 		var stackConfigObj = {
 			id: stackOption.id
 		};
@@ -526,7 +518,8 @@ ColumnStackPlugin.prototype._applyUserConfigs = function(stacks) {
 * @return {Object}
 */
 ColumnStackPlugin.prototype._getColumnStackOptions = function(colIndex) {
-	if(colIndex >= 0) {
+	var colCount = this.getColumnCount();
+	if(colIndex >= 0 && colIndex < colCount) {
 		var colId = this.getColumnId(colIndex);
 		var stack = this._groupDefs.getParentGroup(colId);
 		if(stack) {
@@ -556,7 +549,7 @@ ColumnStackPlugin.prototype._getSelectedColumns = function() {
 */
 ColumnStackPlugin.prototype._hideStackedColumns = function(stack, colRefs, activeRef) {
 	if(stack.spreading && !stack.collapsed) {
-		return; // In spreading mode, columns in an expanded stack don't need to be hiden
+		return; // In spreading mode, columns in an expanded stack don't need to be hidden
 	}
 	// WARNING: activeIndex may not be valid
 	var activeIndex = (typeof activeRef === "number") ? activeRef : this.getColumnIndex(stack.activeColumn);
@@ -964,30 +957,39 @@ ColumnStackPlugin.prototype.isColumnActive = function(colIndex) {
 };
 
 /** @public
-* @param {number} colIndex
+* @param {number|string} colRef Column index, id, or field
 * @return {string}
 */
-ColumnStackPlugin.prototype.getStackId = function(colIndex) {
-	var stackOpt = this._getColumnStackOptions(colIndex);
-	return stackOpt ? stackOpt.id : "";
+ColumnStackPlugin.prototype.getStackId = function(colRef) {
+	var colIndex = (typeof colRef === "number") ? colRef : this.getColumnIndex(colRef);
+	if(colIndex >= 0) {
+		var stackOpt = this._getColumnStackOptions(colIndex);
+		if(stackOpt) {
+			return stackOpt.id || "";
+		}
+	}
+	return "";
 };
 /** @public
 * @param {Array.<number|string>=} colRefs Names of fields or column indices. If not specified, selected columns will be used.
 * @param {string=} stackId Must be unique
 * @param {ColumnStackPlugin~StackConfiguration=} options
-* @return {boolean} Return true if all of the given columns is stacked together
+* @return {boolean} Return true if there is any change.
 */
 ColumnStackPlugin.prototype.stackColumns = function(colRefs, stackId, options) {
-	var i, sid;
-	options = options || {};
+	if(!options) {
+		options = {};
+	}
 
-	if(stackId) {
-		if(this._groupDefs.getGroup(stackId)) {
-			return false; // Cannot store the same stack Id
+	var updateRequired = false;
+	var sid = stackId;
+	if(sid) {
+		if(this._removeStack(sid)) {
+			// TODO: pinning state are removed and may need to be kept
+			updateRequired = true;
 		}
-		sid = stackId;
 	} else {
-		sid = stackId = this._generateStackId();
+		sid = this._generateStackId();
 	}
 
 	if(!colRefs) {
@@ -996,7 +998,10 @@ ColumnStackPlugin.prototype.stackColumns = function(colRefs, stackId, options) {
 
 	var refCount = colRefs ? colRefs.length : 0;
 	if(refCount < 2) {
-		return false; // Only two or more columns can be stacked
+		if(updateRequired) {
+			this._updateUI();
+		}
+		return updateRequired; // Only two or more columns can be stacked
 	}
 
 	// Clone user data
@@ -1035,7 +1040,10 @@ ColumnStackPlugin.prototype.stackColumns = function(colRefs, stackId, options) {
 
 	// Prevent columns already in a stack from moving out to another stack
 	if(!this.isColumnStackable(colIndices)) {
-		return false;
+		if(updateRequired) {
+			this._updateUI();
+		}
+		return updateRequired;
 	}
 
 	// TODO: If columns are stored as column id and activeColumn is a field, active index could not be found
@@ -1068,8 +1076,8 @@ ColumnStackPlugin.prototype.stackColumns = function(colRefs, stackId, options) {
 		var csp = this._getPlugin("ColumnSelectionPlugin");
 		if(csp && csp.isEnabled()){
 			var stackSelection = false;
-			for(i = 0; i < validCount; ++i){
-				colIndex = colIndices[i];
+			for(var i = 0; i < validCount; ++i){
+				var colIndex = colIndices[i];
 				if(colIndex === activeIndex){
 					continue;
 				}
@@ -1087,6 +1095,8 @@ ColumnStackPlugin.prototype.stackColumns = function(colRefs, stackId, options) {
 		}
 	}
 
+	this._verifyColumnPinning(stack);
+
 	this._groupDefs.setGroup(sid, stack);
 
 	var cfp = this._getPlugin("ColumnFilterPlugin");
@@ -1097,26 +1107,75 @@ ColumnStackPlugin.prototype.stackColumns = function(colRefs, stackId, options) {
 	return true;
 };
 
+/** @private
+* @param {Object} stack
+*/
+ColumnStackPlugin.prototype._verifyColumnPinning = function(stack) {
+	stack.leftPinned = false;
+	stack.rightPinned = false;
+
+	var host = this._hosts[0];
+	var leftPinnedIndex = host.getFrozenColumnCount() - 1;
+	var rightPinnedIndex = host.getFirstPinnedRightIndex();
+	var colCount = this.getColumnCount();
+
+	if (leftPinnedIndex < 0 && rightPinnedIndex === colCount) {
+		return;
+	}
+
+	var colIndices = this.getColumnIndices(stack.children);
+	var min = colIndices[0];
+	var max = colIndices[0];
+	for (var i = 1; i < colIndices.length; i++) {
+		var colIndex = colIndices[i];
+		if (colIndex > max) { max = colIndex; }
+		if (colIndex < min) { min = colIndex; }
+	}
+
+	if (min <= leftPinnedIndex) {
+		stack.leftPinned = true;
+		if (max > leftPinnedIndex) {
+			this._freezeColumn(max, colCount - rightPinnedIndex);
+		}
+	} else if (max >= rightPinnedIndex) {
+		stack.rightPinned = true;
+		if (min < rightPinnedIndex) {
+			this._freezeColumn(leftPinnedIndex, colCount - min);
+		}
+	}
+};
+
+/** @private
+* @param {number} frozenColIndex
+* @param {number=} numRightColumn
+*/
+ColumnStackPlugin.prototype._freezeColumn = function(frozenColIndex, numRightColumn) {
+	this._inPinning = true;
+	var hosts = this._hosts;
+	for (var i = 0; i < hosts.length; i++) {
+		hosts[i].freezeColumn(frozenColIndex, numRightColumn);
+	}
+	this._inPinning = false;
+};
+
 /** @public
 * @description Replace all of the stacking in the Grid with a new one.
-*  Grid stores the stacked fields indefinitely.
-*  When adding columns, Grid will attempt to restore stacking
-*  if there are at least two visible columns that match to the retained fields.
+* Grid stores the stacked fields indefinitely.
+* When adding columns, Grid will attempt to restore stacking,
+* if there are at least two visible columns that match to the retained fields.
 * @param {Array.<number|string>=} colRefs Field names or column indices
 * @param {number|string=} activeColRef Field names or column index  of active column
 * @return {boolean} If the stack has been updated, return true.
 */
 ColumnStackPlugin.prototype.setStack = function(colRefs, activeColRef) {
-	var sid = "_uniqueStack"; // WARNING : This hardcode for assign uniqe stacking id
-
 	this.removeAllStacks();
 
 	var stackOptions = {};
-
 	if(activeColRef) {
 		stackOptions.activeColumn = activeColRef;
 	}
-	this.stackColumns(colRefs, sid, stackOptions);
+	// WARNING: Id is hardcoded for assign uniqe stacking id
+	this.stackColumns(colRefs, "_uniqueStack", stackOptions);
 
 	return true;
 };
@@ -1221,22 +1280,47 @@ ColumnStackPlugin.prototype.removeAllStacks = function(enableUpdateUI) {
 	}
 	return groupCount ? true : false;
 };
-/** @public
+/** If the column is in a stack, the column become an activeColumn of the stack.
+* @public
+* @param {number|string} activeColumn Column index, id, or field
+* @return {boolean}
+*/
+ColumnStackPlugin.prototype.setActiveColumn = function(activeColumn) {
+	var colIndex = this.getColumnIndex(activeColumn);
+	if(colIndex < 0) {
+		return false;
+	}
+	var colCount = this.getColumnCount();
+	if(colIndex >= colCount) {
+		return false;
+	}
+
+	var colId = this.getColumnId(colIndex);
+	var stack = this._groupDefs.getParentGroup(colId);
+	var field = "";
+	if(!stack) {
+		field = this._getField(colIndex);
+		stack = this._groupDefs.getParentGroup(field);
+	}
+	if(!stack) {
+		return false;
+	}
+	var chdr = stack.children;
+	var memberIndex = field ? chdr.indexOf(field) : chdr.indexOf(colId);
+	if(memberIndex < 0) {
+		return false;
+	}
+	return this._setActiveColumn(stack, chdr[memberIndex]);
+};
+/** This method is deprecated in favor of setActiveColumn. Make the specified column switch place with the item in the stack.
+* @public
 * @param {number|Event} colRef
 * @param {number} swappingIndex
 * @return {boolean}
+* @see {@link ColumnStackPlugin#setActiveColumn}
 */
 ColumnStackPlugin.prototype.swapColumn = function(colRef, swappingIndex) {
-	var colIndex = -1;
-	if(typeof colRef == "number") {
-		colIndex = colRef;
-	} else {
-		var grid = this.getRelativeGrid(colRef);
-		if(grid) {
-			var pos = grid.getRelativePosition(colRef);
-			colIndex = pos["colIndex"];
-		}
-	}
+	var colIndex = (typeof colRef === "number") ? colRef : this.getColumnIndex(colRef);
 
 	var stackOpt = this._getColumnStackOptions(colIndex);
 	if(!stackOpt) {
@@ -1246,22 +1330,32 @@ ColumnStackPlugin.prototype.swapColumn = function(colRef, swappingIndex) {
 	if(!children) {
 		return false; // Invalid column type
 	}
-	var newActiveColumn = children[swappingIndex];
+
+	return this._setActiveColumn(stackOpt, children[swappingIndex]);
+};
+/** @private
+* @param {Object} stack Stack object
+* @param {string} newActiveColumn Column id or field
+* @return {boolean}
+*/
+ColumnStackPlugin.prototype._setActiveColumn = function(stack, newActiveColumn) {
 	if(!newActiveColumn) {
-		return false; // Invalid selected index
+		return false; // Invalid active column
 	}
-
-	if(newActiveColumn === stackOpt.activeColumn) {
+	if(newActiveColumn === stack.activeColumn) {
 		return false; // The given index is already active stacked column
 	}
 
-	var prevActiveColumnIndex = this.getColumnIndex(stackOpt.activeColumn);
+	var prevActiveColumnIndex = this.getColumnIndex(stack.activeColumn);
 	var newActiveColumnIndex = this.getColumnIndex(newActiveColumn);
-	stackOpt.activeColumn = newActiveColumn; // Change active column
+	stack.activeColumn = newActiveColumn; // Change active column
 
 	this._setColumnVisibility(newActiveColumnIndex, true);
 	this._setColumnVisibility(prevActiveColumnIndex, false); // Hide current active column
 
+	this._updateIcon(prevActiveColumnIndex, stack);
+	this._updateIcon(newActiveColumnIndex, stack);
+
 	var csp = this._getPlugin("ColumnSelectionPlugin");
 	if(csp && csp.isEnabled()) {
 		csp.selectSingleColumn(newActiveColumnIndex);
@@ -1273,11 +1367,6 @@ ColumnStackPlugin.prototype.swapColumn = function(colRef, swappingIndex) {
 	if(cfp) {
 		cfp["refresh"]();
 	}
-
-	stackOpt = this._getColumnStackOptions(prevActiveColumnIndex);
-	this._updateIcon(prevActiveColumnIndex, stackOpt);
-	this._updateIcon(newActiveColumnIndex, stackOpt);
-
 	return true;
 };
 
@@ -1307,7 +1396,7 @@ ColumnStackPlugin.prototype._onColumnRemoved = function (e) {
 	} else {
 		var colData = /** @type{Object} */(e.columnData);
 		var field = colData ? colData.field : "";
-		stackOpt = this._groupDefs.getParentGroup(fields);
+		stackOpt = this._groupDefs.getParentGroup(field);
 		if(stackOpt) {
 			colRef = field;
 		} else {
@@ -1426,7 +1515,17 @@ ColumnStackPlugin.prototype._onAfterBatchOperation = function (e) {
 		this._inReordering = false;
 	}
 };
-
+/** @private
+* @param {Object} e
+*/
+ColumnStackPlugin.prototype._onPinningChanged = function (e) {
+	if (!this._inPinning) {
+		var stacks = this._groupDefs.getGroups();
+		for (var i = 0; i < stacks.length; i++) {
+			this._verifyColumnPinning(stacks[i]);
+		}
+	}
+};
 /** @private
 * @param {number} colIndex
 * @return {Object} stackOption
@@ -1477,6 +1576,7 @@ ColumnStackPlugin.prototype._removeRefFromStack = function (stackOption, colRef,
 		this._setColumnVisibility(colIndex, true);
 	}
 	this._updateActiveColumn(stackOption); // This may trigger _updateUI
+
 	return true;
 };
 
@@ -1670,9 +1770,26 @@ ColumnStackPlugin.prototype.addColumnToStack = function(colRef, stackId) {
 	// apply stacking
 	this._groupDefs.addGroupChild(stackId, colId);
 
+	// To avoid state interference from Core Grid, keep the pin state before moving the columns
+	var host = this._hosts[0];
+	var leftPinnedIndex = host.getFrozenColumnCount() - 1;
+	var rightPinnedCount = host.getPinnedRightColumnCount();
+	var colIndex = this.getColumnIndex(colId);
+
 	// Pack stacked columns together
 	this._moveStackedColumns(stack.children);
 
+	// If an unpinned column is added to a pinned stack, the pinning position should be updated
+	if(stack.leftPinned || stack.rightPinned) {
+		if(stack.leftPinned && colIndex > leftPinnedIndex) {
+			leftPinnedIndex++;
+			this._freezeColumn(leftPinnedIndex, rightPinnedCount);
+		} else if(stack.rightPinned && colIndex < (colCount - rightPinnedCount)) {
+			rightPinnedCount++;
+			this._freezeColumn(leftPinnedIndex, rightPinnedCount);
+		}
+	}
+
 	this._updateUI();
 };
 
@@ -1719,6 +1836,7 @@ ColumnStackPlugin.prototype.removeColumnFromStack = function(colRef) {
 	this._removeRefFromStack(stack, colRef, colIndex);
 
 	this.moveColumnById(colIndex, colIndices[memberCount - 1] + 1); // This assumes that the column order is already in correct position
+
 	this._updateUI();
 };
 
@@ -1829,11 +1947,8 @@ ColumnStackPlugin.prototype.addStackChild = function(stackId, colRef) {
 * @param {number|string} colRef Column field or column index
 */
 ColumnStackPlugin.prototype.removeStackChild = function(stackId, colRef) {
-	var colIndex = (typeof colRef === "string") ? this.getColumnIndex(colRef) : colRef;
-	if(colIndex >= 0) {
-		if(stackId === this.getStackId(colIndex)) {
-			this.removeColumnFromStack(colIndex);
-		}
+	if(stackId === this.getStackId(colRef)) {
+		this.removeColumnFromStack(colIndex);
 	}
 };
 /** @public
@@ -1960,6 +2075,103 @@ ColumnStackPlugin.prototype.moveStack = function(stackId, destCol) {
 	return dirty;
 };
 
+/** @public
+* @param {string} stackId
+* @param {string=} side Available values are: left|right. If no value is supplied, all columns will be pinned to the left.
+*/
+ColumnStackPlugin.prototype.pinStack = function(stackId, side) {
+	if(!stackId) {
+		return;
+	}
+
+	var stack = this._groupDefs.getGroup(stackId);
+	if(!stack) {
+		return;
+	}
+
+	var host = this._hosts[0];
+	var leftPinnedIndex = host.getFrozenColumnCount() - 1;
+	var rightPinnedCount = host.getPinnedRightColumnCount();
+	var colCount = this.getColumnCount();
+	var colList = this.getStackMemberIds(stackId); // WARNING: column ids or fields
+	var len = colList.length;
+
+	var dest;
+	if(side === "right") {
+		if(stack.rightPinned) {
+			return;
+		}
+		if(stack.leftPinned) {
+			this.unpinStack(stackId);
+			leftPinnedIndex = host.getFrozenColumnCount() - 1;
+		}
+		stack.rightPinned = true;
+		dest = colCount - rightPinnedCount;
+		rightPinnedCount = rightPinnedCount + len;
+	} else {
+		if(stack.leftPinned) {
+			return;
+		}
+		if(stack.rightPinned) {
+			this.unpinStack(stackId);
+			rightPinnedCount = host.getPinnedRightColumnCount();
+		}
+		stack.leftPinned = true;
+		dest = leftPinnedIndex === -1 ? 0 : leftPinnedIndex + 1;
+		leftPinnedIndex = leftPinnedIndex + len;
+	}
+
+	this.reorderColumns(colList, dest);
+	this._freezeColumn(leftPinnedIndex, rightPinnedCount);
+};
+
+/** @public
+* @param {string} stackId
+* @param {(number|string)=} dest The unpinned stack will be placed before the destination position after the operation
+*/
+ColumnStackPlugin.prototype.unpinStack = function(stackId, dest) {
+	if(!stackId) {
+		return;
+	}
+
+	var stack = this._groupDefs.getGroup(stackId);
+	if(!stack) {
+		return;
+	}
+
+	if(!stack.leftPinned && !stack.rightPinned) {
+		return;
+	}
+
+	var host = this._hosts[0];
+	var leftPinnedCount = host.getFrozenColumnCount();
+	var rightPinnedCount = host.getPinnedRightColumnCount();
+	var colCount = this.getColumnCount();
+	var firstRightPinnedIndex = colCount - rightPinnedCount;
+	var colList = this.getStackMemberIds(stackId); // WARNING: column ids or fields
+	var len = colList.length;
+
+	var destId = null;
+	if(dest != null) {
+		var destIdx = this.getColumnIndex(dest);
+		destId = this.getColumnId(destIdx);
+	}
+
+	if(stack.leftPinned) {
+		stack.leftPinned = false;
+		this.reorderColumns(colList, leftPinnedCount);
+		this._freezeColumn(leftPinnedCount - (1 + len));
+	} else if(stack.rightPinned) {
+		stack.rightPinned = false;
+		this.reorderColumns(colList, firstRightPinnedIndex);
+		this._freezeColumn(leftPinnedCount - 1, rightPinnedCount - len);
+	}
+
+	if(destId != null) {
+		this.reorderColumns(colList, destId);
+	}
+};
+
 
 
 export default ColumnStackPlugin;

package/lib/tr-grid-row-dragging/es6/RowDragging.js

@@ -195,6 +195,10 @@ RowDraggingPlugin.prototype._pos = null;
 * @private
 */
 RowDraggingPlugin.prototype._startingRid = "";
+/** @type {string}
+* @private
+*/
+RowDraggingPlugin.prototype._startingRowType = "";
 /** Core grid instance
 * @type {Object}
 * @private
@@ -721,6 +725,9 @@ RowDraggingPlugin.prototype._onDragStart = function (e, fromJET) {
 			var dv = grid.getDataSource();
 			this._startingRid = dv.getRowId(rowIndex);
 			this._startingGrid = grid;
+			var api = this.getGridApi();
+			var rowType =  api.getRowType(rowIndex);
+			this._startingRowType = rowType;
 
 			if (this._dragBoxRenderer) { // For custom drag box rendering
 				var arg = cloneObject(e); // TODO: Check if cloning is necessary
@@ -777,18 +784,21 @@ RowDraggingPlugin.prototype._onMouseMove = function (e) {
 	}
 
 	this._pos = this._hitTest(e); // A new object is created
+	this._pos["dragBox"] = this._dragBox; // assign dragBox for user determine valid target
+
+	// need to check grid properties because row can be move outside the grid
+	if(this._pos["grid"] && this._shouldPreventDrop(this._pos["rowIndex"])) {
+		this._pos.dragBoxIcon = "void";
+	}
 
 	var dropable = true;
 	if(this._entryPoint === 'JET' && !this._jetContentHasRic) {
 		dropable = false;
 	}
-
 	if(dropable) {
 		this._updateGuidePosition(e);
 	}
 
-	this._pos.dragBox = this._dragBox; // assign dragBox for user determine valid target
-
 	// Dispatch drag event to let user determine valid drop target using allowDrag (allowDrop) method
 	this._dispatch("drag", this._pos);
 	if(!this._uiDisabled && dropable) {
@@ -1051,6 +1061,10 @@ RowDraggingPlugin.prototype._updateGuidePosition = function (e) {
 	if (this._uiDisabled || !pos || pos["invalidTarget"]) {
 		return;
 	}
+	if(pos["dragBoxIcon"] === "not-allowed" || pos["dragBoxIcon"] === "void" ) {
+		Dom.removeParent(this._guideline);
+		return;
+	}
 
 	if (_isInContentSection(pos)) {
 		var guideline = this._guideline;
@@ -1087,6 +1101,72 @@ RowDraggingPlugin.prototype._updateGuidePosition = function (e) {
 	}
 };
 
+
+/** @private
+* @param {string|number} destRowRef
+* @return {boolean}
+*/
+RowDraggingPlugin.prototype._shouldPreventDrop = function (destRowRef) {
+
+	var api = this.getGridApi();
+	if(!api) { // It should not move the row if api doesn't initialize
+		return false;
+	}
+
+	if(this._startingRowType === "CONSTITUENT" || this._startingRowType === "SUBGROUP_HEADER") {
+		return true;
+	}
+
+	var grid = this._pos["grid"];
+	var rsp = grid.getPlugin("RowSegmentingPlugin");
+	if(!rsp) { // If row segment extension is not used, row drag and drop will not be protected by default.
+		return false;
+	}
+	var destParentId = rsp.getSegmentParentRowId(destRowRef);
+	var startingParentId = rsp.getSegmentParentRowId(this._startingRid);
+	var destParentType;
+	if(this._startingRowType === "GROUP_MEMBER") {
+		var startingParentType = api.getRowType(startingParentId);
+		if(startingParentType === "SUBGROUP_HEADER") {
+			destParentType = api.getRowType(destParentId);
+
+			if(!startingParentId || !destParentId) {
+				return true;
+			}
+
+			if(destParentId === startingParentId) { // GROUP_MEMBER same parent can be move inside
+				return false;
+			}
+			return true;
+		}
+		// else { } starting have GROUP_HEADER case, it can be move outside the group
+
+	} else if(this._startingRowType === "CHAIN" ) {
+		if(destParentId) { // CHAIN can not move inside the member that have parent
+			return true;
+		}
+	} else if (this._startingRowType === "GROUP_HEADER") {
+		if( destParentId !== startingParentId) { // GROUP_HEADER can't move inside another GROUP or SUBGROUP
+			return true;
+		}
+	}
+
+	var destRowType =  api.getRowType(destRowRef);
+	if(destRowType === "CONSTITUENT" || destRowType === "SUBGROUP_HEADER") { // Do not allow dropping this type when starting with any row types
+		return true;
+	}
+
+	if(destRowType === "GROUP_MEMBER") {
+		destParentType = api.getRowType(destParentId);
+		if(destParentType === "SUBGROUP_HEADER") { // Do not allow to drop group member that have parent is SUBGROUP_HEADER
+			return true;
+		}
+	}
+
+	return false;
+
+};
+
 /** @private */
 RowDraggingPlugin.prototype._clearCache = function () {
 	if (this._dragPulseId) {