@deephaven/grid 0.15.1 → 0.15.2

package/dist/mouse-handlers/GridColumnMoveMouseHandler.js

@@ -1,9 +1,84 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
+import clamp from 'lodash.clamp';
 import GridUtils from "../GridUtils.js";
 import GridMouseHandler from "../GridMouseHandler.js";
-import { getOrThrow } from "../GridMetricCalculator.js";
 var SLOPPY_CLICK_DISTANCE = 5;
+var SCROLL_INTERVAL = 1000 / 60;
+var SCROLL_DELTA = 10;
+
+/**
+ * Gets info about a visible column
+ * @param visibleIndex The visible index to get info for
+ * @param depth The header depth to get info for
+ * @param metrics Grid metrics
+ * @param model Grid model
+ * @returns The column info at the depth.
+ * If the column is not in a group at that depth, returns the info for the base column.
+ * Returns null if the column is not visible.
+ */
+function getColumnInfo(visibleIndex, depth, metrics, model) {
+  var _modelColumns$get;
+
+  var {
+    modelColumns,
+    movedColumns,
+    visibleColumnXs,
+    columnCount,
+    visibleColumnWidths,
+    userColumnWidths,
+    calculatedColumnWidths,
+    floatingLeftWidth,
+    maxX
+  } = metrics;
+
+  if (depth == null || visibleIndex == null || visibleIndex > columnCount || visibleIndex < 0) {
+    return null;
+  }
+
+  var modelIndex = (_modelColumns$get = modelColumns.get(visibleIndex)) !== null && _modelColumns$get !== void 0 ? _modelColumns$get : GridUtils.getModelIndex(visibleIndex, movedColumns);
+  var group = model.getColumnHeaderGroup(modelIndex, depth);
+  var isColumnGroup = group != null;
+  var left;
+  var right;
+  var range;
+
+  if (group != null) {
+    var _visibleColumnXs$get, _visibleColumnXs$get2, _visibleColumnWidths$;
+
+    var [startVisibleIndex, endVisibleIndex] = group.getVisibleRange(movedColumns);
+    left = (_visibleColumnXs$get = visibleColumnXs.get(startVisibleIndex)) !== null && _visibleColumnXs$get !== void 0 ? _visibleColumnXs$get : floatingLeftWidth;
+    right = ((_visibleColumnXs$get2 = visibleColumnXs.get(endVisibleIndex)) !== null && _visibleColumnXs$get2 !== void 0 ? _visibleColumnXs$get2 : maxX) + ((_visibleColumnWidths$ = visibleColumnWidths.get(endVisibleIndex)) !== null && _visibleColumnWidths$ !== void 0 ? _visibleColumnWidths$ : 0);
+    range = [startVisibleIndex, endVisibleIndex];
+  } else {
+    var _ref, _ref2, _visibleColumnWidths$2;
+
+    var possibleLeft = visibleColumnXs.get(visibleIndex);
+
+    if (possibleLeft == null) {
+      return null;
+    }
+
+    left = possibleLeft;
+    right = left + ((_ref = (_ref2 = (_visibleColumnWidths$2 = visibleColumnWidths.get(visibleIndex)) !== null && _visibleColumnWidths$2 !== void 0 ? _visibleColumnWidths$2 : userColumnWidths.get(modelIndex)) !== null && _ref2 !== void 0 ? _ref2 : calculatedColumnWidths.get(modelIndex)) !== null && _ref !== void 0 ? _ref : 0);
+    range = [visibleIndex, visibleIndex];
+  }
+
+  return {
+    visibleIndex,
+    modelIndex,
+    left,
+    right,
+    width: right - left,
+    isColumnGroup,
+    range,
+    depth
+  };
+}
 
 class GridColumnMoveMouseHandler extends GridMouseHandler {
   constructor() {
@@ -13,9 +88,116 @@ class GridColumnMoveMouseHandler extends GridMouseHandler {
 
     _defineProperty(this, "draggingOffset", void 0);
 
-    _defineProperty(this, "startingGridPoint", void 0);
+    _defineProperty(this, "initialOffset", void 0);
+
+    _defineProperty(this, "initialGridPoint", void 0);
+
+    _defineProperty(this, "scrollingInterval", void 0);
+
+    _defineProperty(this, "scrollingDirection", void 0);
+
+    _defineProperty(this, "draggingColumn", null);
+  }
+
+  setScrollInterval(grid, direction) {
+    if (this.scrollingInterval != null && direction === this.scrollingDirection) {
+      return;
+    }
+
+    this.scrollingDirection = direction;
+    this.scrollingInterval = window.setInterval(() => {
+      var {
+        metrics
+      } = grid;
+
+      if (!metrics) {
+        return;
+      }
+
+      var {
+        left,
+        lastLeft,
+        leftOffset,
+        userColumnWidths,
+        calculatedColumnWidths,
+        movedColumns,
+        visibleColumnWidths
+      } = metrics;
+      var nextLeft = left;
+      var nextOffset = leftOffset;
+
+      if (direction === 'left') {
+        nextOffset -= SCROLL_DELTA;
+
+        while (nextOffset < 0) {
+          var _userColumnWidths$get;
+
+          nextLeft -= 1;
+          var modelIndex = GridUtils.getModelIndex(left - 1, movedColumns);
+          var prevColumnWidth = (_userColumnWidths$get = userColumnWidths.get(modelIndex)) !== null && _userColumnWidths$get !== void 0 ? _userColumnWidths$get : calculatedColumnWidths.get(modelIndex);
+
+          if (prevColumnWidth === undefined) {
+            nextOffset = 0;
+          } else {
+            nextOffset += prevColumnWidth;
+          }
+
+          if (nextLeft < 0) {
+            nextOffset = 0;
+            nextLeft = 0;
+          }
+        }
+      } else {
+        nextOffset += SCROLL_DELTA;
+        var leftColumnWidth = visibleColumnWidths.get(left);
+
+        while (leftColumnWidth !== undefined && nextOffset > leftColumnWidth) {
+          var _userColumnWidths$get2;
+
+          nextLeft += 1;
+          nextOffset -= leftColumnWidth;
+
+          var _modelIndex = GridUtils.getModelIndex(left + 1, movedColumns);
+
+          leftColumnWidth = (_userColumnWidths$get2 = userColumnWidths.get(_modelIndex)) !== null && _userColumnWidths$get2 !== void 0 ? _userColumnWidths$get2 : calculatedColumnWidths.get(_modelIndex);
+
+          if (nextLeft > lastLeft) {
+            nextOffset = 0;
+            nextLeft = lastLeft;
+          }
+        }
+      }
+
+      var {
+        mouseX,
+        mouseY
+      } = grid.state;
 
-    _defineProperty(this, "sloppyClickThreshold", false);
+      if (!metrics || mouseX == null || mouseY == null) {
+        return;
+      }
+
+      this.moveDraggingColumn(mouseX, grid, direction === 'left' ? -SCROLL_DELTA : SCROLL_DELTA);
+      grid.setState({
+        left: nextLeft,
+        leftOffset: nextOffset
+      });
+
+      if (direction === 'left' && nextLeft === 0 && leftOffset === 0 || direction === 'right' && nextLeft === lastLeft) {
+        this.clearScrollInterval();
+      }
+    }, SCROLL_INTERVAL);
+  }
+
+  clearScrollInterval() {
+    this.scrollingDirection = undefined;
+    window.clearInterval(this.scrollingInterval);
+    this.scrollingInterval = undefined;
+  }
+
+  onLeave() {
+    this.clearScrollInterval();
+    return false;
   }
 
   onDown(gridPoint, grid) {
@@ -24,151 +206,375 @@ class GridColumnMoveMouseHandler extends GridMouseHandler {
     } = grid.props;
     var {
       x,
-      y,
-      column
+      column,
+      columnHeaderDepth
     } = gridPoint;
     var {
       metrics
     } = grid;
     if (!metrics) throw new Error('Metrics not set');
+    var columnInfo = getColumnInfo(column, columnHeaderDepth, metrics, model);
+
+    if (column == null || columnInfo == null || columnHeaderDepth == null) {
+      return false;
+    } // Can't drag a base column from the empty group area
+
+
+    if (columnHeaderDepth > 0 && !columnInfo.isColumnGroup) {
+      return false;
+    }
+
     var {
-      columnHeaderHeight,
-      rowHeaderWidth,
-      visibleColumnXs
+      rowHeaderWidth
     } = metrics;
-    this.startingGridPoint = gridPoint;
-    this.sloppyClickThreshold = false;
+    this.initialGridPoint = gridPoint;
+    this.draggingColumn = null;
     this.cursor = null;
 
-    if (column != null && y <= columnHeaderHeight && model.isColumnMovable(grid.getModelColumn(column))) {
-      var columnX = getOrThrow(visibleColumnXs, column);
-      this.draggingOffset = x - columnX - rowHeaderWidth;
-      grid.setState({
-        draggingColumnOffset: this.draggingOffset
-      });
+    if (columnInfo.modelIndex != null && columnHeaderDepth != null && model.isColumnMovable(columnInfo.modelIndex, columnHeaderDepth)) {
+      this.draggingOffset = x - columnInfo.left - rowHeaderWidth;
+      this.initialOffset = this.draggingOffset;
     }
 
     return false;
   }
 
-  onDrag(gridPoint, grid) {
-    if (this.draggingOffset === undefined || this.startingGridPoint === undefined) {
+  onDrag(gridPoint, grid, event) {
+    if (this.draggingOffset === undefined || this.initialGridPoint === undefined || this.initialOffset === undefined) {
       return false;
     }
 
+    var {
+      x: mouseX,
+      y: mouseY
+    } = gridPoint;
+    var {
+      columnHeaderDepth
+    } = this.initialGridPoint;
     var {
       model
     } = grid.props;
     var {
       draggingColumn
-    } = grid.state;
+    } = this;
     var {
-      mouseX,
-      mouseY,
-      isDragging
-    } = grid.state;
-
-    if (mouseX == null || mouseY == null) {
-      return false;
-    } // before considering it a drag, the mouse must have moved a minimum distance
+      metrics
+    } = grid;
+    if (!metrics) throw new Error('Metrics not set'); // before considering it a drag, the mouse must have moved a minimum distance
     // this prevents click actions from triggering a drag state
 
-
-    if (!this.sloppyClickThreshold && Math.abs(this.startingGridPoint.x - mouseX) >= SLOPPY_CLICK_DISTANCE || Math.abs(this.startingGridPoint.y - mouseY) >= SLOPPY_CLICK_DISTANCE) {
-      this.sloppyClickThreshold = true;
-    } else if (!this.sloppyClickThreshold && !isDragging) {
+    if (!draggingColumn && Math.abs(this.initialGridPoint.x - mouseX) < SLOPPY_CLICK_DISTANCE && Math.abs(this.initialGridPoint.y - mouseY) < SLOPPY_CLICK_DISTANCE) {
       return false;
-    }
+    } // Get the initial dragging column info
+
 
     if (draggingColumn == null) {
-      var {
-        column
-      } = grid.getGridPointFromXY(mouseX, mouseY);
+      var initialColumnInfo = getColumnInfo(this.initialGridPoint.column, columnHeaderDepth, metrics, model);
 
-      if (column != null && !model.isColumnMovable(grid.getModelColumn(column))) {
+      if (!initialColumnInfo || columnHeaderDepth == null) {
         return false;
       }
 
-      draggingColumn = column;
+      if (!model.isColumnMovable(initialColumnInfo.modelIndex)) {
+        return false;
+      } // Disallow dragging from the blank space in column header groups
+
+
+      if (columnHeaderDepth > 0 && !initialColumnInfo.isColumnGroup) {
+        return false;
+      }
+
+      if (initialColumnInfo.range[0] == null) {
+        return false;
+      }
+
+      draggingColumn = {
+        range: initialColumnInfo.range,
+        depth: columnHeaderDepth,
+        left: initialColumnInfo.left,
+        width: initialColumnInfo.width
+      };
+      var startColumn = getColumnInfo(draggingColumn.range[0], 0, metrics, model);
+      var endColumn = getColumnInfo(draggingColumn.range[1], 0, metrics, model); // Group goes off the table. Drag and drop could be wonky here
+      // Column draws only use columns that are partially visible too
+      // So this could cause rendering errors if we tried dragging it
+
+      if (!startColumn || !endColumn) {
+        return false;
+      }
+
+      this.draggingColumn = draggingColumn;
       grid.setState({
         draggingColumn,
         isDragging: true
       });
+    }
+    /**
+     * At this point, we have determined we are actually dragging a column
+     */
 
-      if (draggingColumn == null) {
-        return false;
+
+    this.cursor = 'move';
+    this.moveDraggingColumn(gridPoint.x, grid, event.movementX);
+    return true;
+  }
+  /**
+   * Moves a dragging column, if possible, the specified distance
+   * @param mouseX The point the move was initiated from
+   * @param grid The Grid component
+   * @param deltaX The distance of the move
+   */
+
+
+  moveDraggingColumn(mouseX, grid, deltaX) {
+    var _draggingParentGroup$;
+
+    if (this.draggingOffset === undefined || this.initialGridPoint === undefined || this.initialOffset === undefined || this.draggingColumn == null || deltaX === 0) {
+      return;
+    } // Cursor has moved past the column drag bounds, don't move the column until we hit the initial offset point again
+
+
+    if (this.initialOffset !== this.draggingOffset) {
+      // Pre move < Initial < Post move or vice-versa
+      // User crossed back past the iniital offset point, so we can start moving again
+      if (this.draggingOffset < this.initialOffset && this.initialOffset < this.draggingOffset + deltaX || this.draggingOffset > this.initialOffset && this.initialOffset > this.draggingOffset + deltaX) {
+        this.draggingOffset = this.initialOffset;
+      } else {
+        // Column can't move since we aren't back at the initial offset yet
+        this.draggingOffset += deltaX;
       }
+
+      this.draggingColumn = _objectSpread(_objectSpread({}, this.draggingColumn), {}, {
+        left: mouseX - this.draggingOffset
+      });
+      grid.setState({
+        draggingColumn: this.draggingColumn
+      });
+      return;
     }
 
-    this.cursor = 'move';
+    var {
+      depth: draggingColumnDepth
+    } = this.draggingColumn;
+    var {
+      model
+    } = grid.props;
+    var {
+      movedColumns
+    } = grid.state;
     var {
       metrics
     } = grid;
     if (!metrics) throw new Error('Metrics not set');
     var {
-      left,
-      lastLeft,
-      right,
-      rightVisible,
-      columnCount,
-      rowHeaderWidth,
-      visibleColumnWidths,
-      visibleColumnXs,
-      width
+      floatingLeftWidth,
+      width,
+      columnHeaderMaxDepth,
+      visibleColumnXs
     } = metrics;
-    var minX = rowHeaderWidth;
+    var isDraggingLeft = deltaX < 0;
+    var draggingColumn = getColumnInfo(this.draggingColumn.range[0], draggingColumnDepth, metrics, model);
+
+    if (!draggingColumn) {
+      return;
+    } // The returned left/right are the original position, not dragged position
+    // This is where the dragging column's floating position accounting for dragged distance
+
+
+    var floatingDraggingLeft = mouseX - this.draggingOffset;
+    var floatingDraggingRight = floatingDraggingLeft + draggingColumn.width;
+    this.draggingColumn = _objectSpread(_objectSpread({}, this.draggingColumn), {}, {
+      left: floatingDraggingLeft
+    });
+    grid.setState({
+      draggingColumn: this.draggingColumn
+    });
+    var swapColumn = getColumnInfo(GridUtils.getColumnAtX(clamp(isDraggingLeft ? floatingDraggingLeft : floatingDraggingRight, floatingLeftWidth, width), metrics, true), draggingColumnDepth, metrics, model);
+    var parentGroup = model.getColumnHeaderParentGroup(draggingColumn.modelIndex, draggingColumn.depth);
+
+    if (!swapColumn) {
+      return;
+    } // Check if we should pin to the edge of the parent
+
+
+    if (parentGroup) {
+      var parentVisibleRange = parentGroup.getVisibleRange(movedColumns); // Cannot move to this left position, pin to left of parent
+
+      if (swapColumn.visibleIndex < parentVisibleRange[0]) {
+        var _visibleColumnXs$get3;
+
+        var _newMovedColumns = this.moveColumn(draggingColumn, parentVisibleRange[0], movedColumns);
+
+        this.draggingOffset = mouseX - ((_visibleColumnXs$get3 = visibleColumnXs.get(parentVisibleRange[0])) !== null && _visibleColumnXs$get3 !== void 0 ? _visibleColumnXs$get3 : 0);
+        this.draggingColumn = _objectSpread(_objectSpread({}, this.draggingColumn), {}, {
+          left: mouseX - this.draggingOffset
+        });
+        this.clearScrollInterval();
+        grid.setState({
+          draggingColumn: this.draggingColumn,
+          movedColumns: _newMovedColumns
+        });
+        return;
+      } // Pin to the right of parent
+
+
+      if (swapColumn.visibleIndex > parentVisibleRange[1]) {
+        var _getColumnInfo;
+
+        var _newMovedColumns2 = this.moveColumn(draggingColumn, parentVisibleRange[1] - (draggingColumn.range[1] - draggingColumn.range[0]), movedColumns);
+
+        var {
+          right: parentRight = 0
+        } = (_getColumnInfo = getColumnInfo(parentVisibleRange[1], 0, metrics, model)) !== null && _getColumnInfo !== void 0 ? _getColumnInfo : {};
+        this.draggingOffset = mouseX - (parentRight - draggingColumn.width);
+        this.draggingColumn = _objectSpread(_objectSpread({}, this.draggingColumn), {}, {
+          left: mouseX - this.draggingOffset
+        });
+        this.clearScrollInterval();
+        grid.setState({
+          draggingColumn: this.draggingColumn,
+          movedColumns: _newMovedColumns2
+        });
+        return;
+      }
+    } // Hit an unmovable column, move to the first available position next to it
+
+
+    if (!model.isColumnMovable(swapColumn.modelIndex)) {
+      var toVisibleIndex = swapColumn.visibleIndex;
+
+      if (isDraggingLeft) {
+        toVisibleIndex += 1;
+
+        while (toVisibleIndex < draggingColumn.visibleIndex && !model.isColumnMovable(GridUtils.getModelIndex(toVisibleIndex, movedColumns))) {
+          toVisibleIndex += 1;
+        }
+      } else {
+        toVisibleIndex -= 1;
+
+        while (toVisibleIndex > draggingColumn.visibleIndex && !model.isColumnMovable(GridUtils.getModelIndex(toVisibleIndex, movedColumns))) {
+          toVisibleIndex -= 1;
+        }
+      }
+
+      if (toVisibleIndex !== draggingColumn.visibleIndex) {
+        if (!isDraggingLeft) {
+          // Offset for range if dragging right
+          toVisibleIndex -= draggingColumn.range[1] - draggingColumn.range[0];
+        }
+
+        var _newMovedColumns3 = this.moveColumn(draggingColumn, toVisibleIndex, movedColumns);
+
+        grid.setState({
+          movedColumns: _newMovedColumns3,
+          draggingColumn: this.draggingColumn
+        });
+      }
+
+      var toColumnInfo = getColumnInfo(toVisibleIndex, 0, metrics, model);
+
+      if (isDraggingLeft) {
+        var _toColumnInfo$left;
+
+        this.draggingOffset = mouseX - ((_toColumnInfo$left = toColumnInfo === null || toColumnInfo === void 0 ? void 0 : toColumnInfo.left) !== null && _toColumnInfo$left !== void 0 ? _toColumnInfo$left : 0);
+      } else {
+        var _toColumnInfo$right;
+
+        this.draggingOffset = mouseX - (((_toColumnInfo$right = toColumnInfo === null || toColumnInfo === void 0 ? void 0 : toColumnInfo.right) !== null && _toColumnInfo$right !== void 0 ? _toColumnInfo$right : 0) - draggingColumn.width);
+      }
 
-    if (left < draggingColumn) {
-      var leftColumn = draggingColumn - 1;
-      minX = getOrThrow(visibleColumnXs, leftColumn) + getOrThrow(visibleColumnWidths, leftColumn) * 0.5 + this.draggingOffset + rowHeaderWidth;
+      this.draggingColumn = _objectSpread(_objectSpread({}, this.draggingColumn), {}, {
+        left: mouseX - this.draggingOffset
+      });
+      grid.setState({
+        draggingColumn: this.draggingColumn
+      });
+      return;
     }
 
-    var maxX = width;
+    if (floatingDraggingLeft <= floatingLeftWidth) {
+      this.setScrollInterval(grid, 'left');
+    } else if (floatingDraggingRight > width) {
+      this.setScrollInterval(grid, 'right');
+    } else {
+      this.clearScrollInterval();
+    } // Can't swap a column with itself
+
 
-    if (draggingColumn < right) {
-      var rightColumn = draggingColumn + 1;
-      maxX = getOrThrow(visibleColumnXs, rightColumn) + getOrThrow(visibleColumnWidths, rightColumn) * 0.5 - getOrThrow(visibleColumnWidths, draggingColumn) + this.draggingOffset + rowHeaderWidth;
+    if (swapColumn.visibleIndex === draggingColumn.visibleIndex) {
+      return;
+    } // Can't swap a column to the left when dragging right or vice versa
+
+
+    if (isDraggingLeft && draggingColumn.visibleIndex < swapColumn.visibleIndex || !isDraggingLeft && draggingColumn.visibleIndex > swapColumn.visibleIndex) {
+      return;
     }
 
-    var {
-      movedColumns
-    } = grid.state;
+    var switchPoint = swapColumn.left + swapColumn.width * 0.5;
+    var draggingParentGroup = model.getColumnHeaderParentGroup(draggingColumn.modelIndex, draggingColumn.depth); // Get the highest level group that is not the common base group
+    // This group is what we need to drag past
+
+    var maxDepthSwapGroup;
+    var maxSwapDepth = ((_draggingParentGroup$ = draggingParentGroup === null || draggingParentGroup === void 0 ? void 0 : draggingParentGroup.depth) !== null && _draggingParentGroup$ !== void 0 ? _draggingParentGroup$ : columnHeaderMaxDepth) - 1;
+
+    while (maxSwapDepth >= 0 && maxDepthSwapGroup === undefined) {
+      maxDepthSwapGroup = model.getColumnHeaderGroup(swapColumn.modelIndex, maxSwapDepth);
+      maxSwapDepth -= 1;
+    }
+
+    var newMovedColumns;
+
+    if (isDraggingLeft && floatingDraggingLeft < switchPoint && (!maxDepthSwapGroup || swapColumn.visibleIndex === maxDepthSwapGroup.getVisibleRange(movedColumns)[0])) {
+      newMovedColumns = this.moveColumn(draggingColumn, swapColumn.range[0], movedColumns);
+    }
+
+    if (!isDraggingLeft && floatingDraggingRight > switchPoint && (!maxDepthSwapGroup || swapColumn.visibleIndex === maxDepthSwapGroup.getVisibleRange(movedColumns)[1])) {
+      newMovedColumns = this.moveColumn(draggingColumn, swapColumn.range[1] - (draggingColumn.range[1] - draggingColumn.range[0]), movedColumns);
+    }
 
-    if (mouseX < minX && draggingColumn > 0 && model.isColumnMovable(grid.getModelColumn(draggingColumn - 1))) {
-      movedColumns = GridUtils.moveItem(draggingColumn, draggingColumn - 1, movedColumns);
-      draggingColumn -= 1;
-    } else if (maxX < mouseX && draggingColumn < columnCount - 1 && model.isColumnMovable(grid.getModelColumn(draggingColumn + 1))) {
-      movedColumns = GridUtils.moveItem(draggingColumn, draggingColumn + 1, movedColumns);
-      draggingColumn += 1;
+    if (!newMovedColumns) {
+      return;
     }
 
+    this.draggingColumn = _objectSpread(_objectSpread({}, this.draggingColumn), {}, {
+      left: floatingDraggingLeft
+    });
     grid.setState({
-      movedColumns,
-      draggingColumn
+      movedColumns: newMovedColumns,
+      draggingColumn: this.draggingColumn
     });
-    var minMoveX = rowHeaderWidth + getOrThrow(visibleColumnWidths, left) * 0.5;
-    var maxMoveX = rowHeaderWidth + getOrThrow(visibleColumnXs, rightVisible) + getOrThrow(visibleColumnWidths, rightVisible) * 0.5;
-
-    if (mouseX < minMoveX && left > 0) {
-      grid.setState({
-        left: left - 1
-      });
-    } else if (mouseX > maxMoveX && left < lastLeft) {
-      grid.setState({
-        left: left + 1
+  }
+  /**
+   * Applies the column move and updates draggingColumn in the mouse handler
+   * Does not check if the move is valid
+   * @param draggingColumn The dragging column info
+   * @param to The index to move the column or range to
+   * @param movedColumns The array of column moves
+   * @returns A new array of column moves
+   */
+
+
+  moveColumn(draggingColumn, to, movedColumns) {
+    var newMovedColumns = draggingColumn.isColumnGroup ? GridUtils.moveRange(draggingColumn.range, to, movedColumns) : GridUtils.moveItem(draggingColumn.visibleIndex, to, movedColumns);
+    var moveDistance = to - draggingColumn.range[0];
+    var newDraggingRange = [draggingColumn.range[0] + moveDistance, draggingColumn.range[1] + moveDistance];
+
+    if (this.draggingColumn) {
+      this.draggingColumn = _objectSpread(_objectSpread({}, this.draggingColumn), {}, {
+        range: newDraggingRange
       });
     }
 
-    return true;
+    return newMovedColumns;
   }
 
   onUp(gridPoint, grid) {
     this.cursor = null;
+    this.clearScrollInterval();
 
     if (this.draggingOffset != null) {
       this.draggingOffset = undefined;
       grid.setState({
-        draggingColumnOffset: null,
         draggingColumn: null,
         isDragging: false
       });