JavaScript Data Grid: Range Selection

Range selection allows Excel-like range selection of cells. Range selections are useful for visually highlighting data, copying data to the Clipboard, or for doing aggregations using the Status Bar.

Selecting Ranges

Range Selection is enabled using the following grid option property enableRangeSelection=true. When enabled, ranges can be selected in the following ways:

• Mouse Drag: Click the mouse down on a cell and drag and release the mouse over another cell. A range will be created between the two cells and clear any existing ranges.
• Ctrl & Mouse Drag: Holding Ctrl key while creating a range using mouse drag outside an existing range will create a new range selection and keep any existing ranges.
• Shift & Click: Clicking on one cell to focus that cell, then holding down Shift while clicking another cell, will create a range between both cells.
• Shift & Arrow Keys: Focusing a cell and then holding down Shift and using the arrow keys will create a range starting from the focused cell.
• Ctrl & Shift & Arrow Keys: Focusing a cell and then holding down Ctrl + Shift and using the arrow keys will create a range starting from the focused cell to the last cell in the direction of the Arrow pressed.

Range Deselection

It is possible to deselect part of existing ranges in the following ways:

• Ctrl & Mouse Drag: Holding Ctrl and dragging a range starting within an existing range will cause any cells covered by the new range to be deselected.
• Ctrl & Click: Holding Ctrl and clicking a cell will deselect just that cell.

Note that deselecting part of a range can split the range into multiple ranges, since individual ranges have the limitation of being rectangular.

The example below demonstrates simple range selection. Ranges can be selected in all the ways described above.

// Loading...

Suppress Multi Range Selection

By default multiple ranges can be selected. To restrict range selection to a single range, even if the Ctrl key is held down, enable the following grid options property: suppressMultiRangeSelection=true.

The following example demonstrates single range selection:

// Loading...

Ranges with Pinning and Floating

It is possible to select a range that spans pinned and non-pinned sections of the grid. If you do this, the selected range will not have any gaps with regards to the column order. For example, if you start the drag on the left pinned area and drag to the right pinned area, then all of the columns in the center area will also be part of the range.

Likewise with floating, no row gaps will occur if a range spans into pinned rows. A range will be continuous between the floating top rows, the center, and the floating bottom rows.

The above two (pinning and floating) can be thought of as follows: if you have a grid with pinning and / or floating, then 'flatten out' the grid in your head so that all rows and columns are visible, then the range selection will work as you would expect in the flattened out version where only full rectangles can be selectable.

Range Selection Changed Event

The rangeSelectionChanged event tells you that the range selection has changed. The event has two properties, started and finished, which are true when the selection is starting or finishing. For example, if selecting a range of 10 cells in a row, the user will click the first cell and drag to the last cell. This will result in up to 11 events. The first event will have started=true, the last will have finished=true, and all the intermediary events will have both of these values as false.

onRangeSelectionChanged = (
    event: RangeSelectionChangedEvent<TData>
) => void;

interface RangeSelectionChangedEvent<TData = any, TContext = any> {
  id?: string;
  // True for the first change event, otherwise false 
  started: boolean;
  // True for the last change event, otherwise false 
  finished: boolean;
  // The grid api. 
  api: GridApi<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
  // Event identifier 
  type: string;
}

Range Selection API

The following methods are available on the GridApi for managing range selection.

getCellRanges()

Get the selected ranges using api.getCellRanges(). This will return back a list of cell range objects, each of which contains the details of one range.

The start is the first cell the user clicked on and the end is the cell where the user stopped dragging. Do not assume that the start cell's index is numerically before the end cell, as the user could have dragged up.

getCellRanges = () => CellRange[] | null;

interface CellRange {
  id?: string;
  type?: CellRangeType;
  // The start row of the range 
  startRow?: RowPosition;
  // The end row of the range 
  endRow?: RowPosition;
  // The columns in the range 
  columns: Column[];
  // The start column for the range 
  startColumn: Column;
}

enum CellRangeType {
  VALUE
  DIMENSION
}

interface RowPosition {
  // A positive number from 0 to n, where n is the last row the grid is rendering
  // or -1 if you want to navigate to the grid header 
  rowIndex: number;
  // Either 'top', 'bottom' or null/undefined (for not pinned) 
  rowPinned: RowPinnedType;
}

type RowPinnedType = 
      'top' 
    | 'bottom' 
    | null 
    | undefined

clearRangeSelection()

clearRangeSelection = () => void;

addCellRange(rangeSelection)

Adds a range to the selection. This keeps any previous ranges. If you wish to only have the new range selected, then call clearRangeSelection() first. The method takes the params of type CellRangeParams.

addCellRange = (
    params: CellRangeParams
) => void;

interface CellRangeParams {
  // Start row index 
  rowStartIndex: number | null;
  // Pinned state of start row. Either 'top', 'bottom' or null 
  rowStartPinned?: RowPinnedType;
  // End row index 
  rowEndIndex: number | null;
  // Pinned state of end row. Either 'top', 'bottom' or null 
  rowEndPinned?: RowPinnedType;
  // Starting column for range 
  columnStart?: string | Column;
  // End column for range 
  columnEnd?: string | Column;
  // Specify Columns to include instead of using `columnStart` and `columnEnd` 
  columns?: (string | Column)[];
}

type RowPinnedType = 
      'top' 
    | 'bottom' 
    | null 
    | undefined

Ranges are normally bounded by a start and end row. However it is also possible to define a range unbounded by rows (i.e. to contain all rows). For an unbounded range, do not provide start or end row positions.

Row positions are defined by a row index and pinned. Row indexes start at zero and increment. Pinned can be either 'top' (row is in pinned top section), 'bottom' (row is in pinned bottom section) or null (row is in the main body). See Row Pinning for information on row pinning.

Ranges are defined by a list of columns. Pass in either a) a list of columns or b) a start and end column and let the grid work out the columns in between. Passing a list of columns instead of a start and end column has the advantage that the columns do not need to be contiguous.

Copy Range Down

When you have more than one row selected in a range, pressing keys Ctrl+D will copy the top row values to all other rows in the selected range.

Example: Advanced Range Selection

The example below demonstrates a more complex range selection scenario. The example listens for the rangeSelectionChanged event and creates a sum of all the number values that are in the range (it ignores all non-number values). The finished flag is used to update the eager and lazy figures separately.

The example also shows use of the processCellForClipboard and processCellFromClipboard callbacks by making all the athlete names uppercase when copying into the clipboard and lowercase when copying from the clipboard.

// Loading...