Row features

DataGrid row selection, expansion, tree data

Row selection

Pass withRowSelection to useDataGrid to add a checkbox column with a select-all checkbox in the header. getRowId is required to provide stable row ids. Selected rows have the data-selected attribute, use it to style a custom selection column:

Selected rows: []

First Name
Last Name
Department
Salary
Status
AliceJohnsonEngineering95000active
BobSmithMarketing72000active
CarolWilliamsSales68000active
DavidBrownHR65000inactive
EvaDavisFinance88000active
FrankMillerEngineering102000active
GraceWilsonMarketing76000active
HenryTaylorSales71000inactive
IreneAndersonEngineering97000active
JamesThomasFinance91000active
KarenJacksonHR63000active
LeoWhiteEngineering110000active
MiaHarrisSales74000active
NathanMartinMarketing69000inactive
OliviaGarciaFinance85000active
PatrickMartinezEngineering99000active
QuinnRobinsonHR67000active
RachelClarkSales73000active
import { useState } from 'react';
import { RowSelectionState } from '@tanstack/react-table';
import { Code, Text } from '@mantine/core';
import { DataGrid, useDataGrid } from '@mantine/data-grid';
import { employees } from './data';

function Demo() {
  const [rowSelection, setRowSelection] = useState<RowSelectionState>({});

  const store = useDataGrid({
    data: employees,
    columns: [
      { accessorKey: 'firstName', header: 'First Name' },
      { accessorKey: 'lastName', header: 'Last Name' },
      { accessorKey: 'department', header: 'Department' },
      { accessorKey: 'salary', header: 'Salary' },
      { accessorKey: 'status', header: 'Status' },
    ],
    withRowSelection: true,
    rowSelection,
    onRowSelectionChange: setRowSelection,
    getRowId: (row) => row.id,
  });

  return (
    <>
      <Text mb="md">
        Selected rows: <Code>{JSON.stringify(Object.keys(rowSelection))}</Code>
      </Text>
      <DataGrid store={store} />
    </>
  );
}

Controlled selection

Pass rowSelection and onRowSelectionChange to useDataGrid to control selection state. The state is keyed by row ids from getRowId:

Selected rows: 0

First Name
Last Name
Department
Status
Salary
AliceJohnsonEngineeringactive95000
BobSmithMarketingactive72000
CarolWilliamsSalesactive68000
DavidBrownHRinactive65000
EvaDavisFinanceactive88000
FrankMillerEngineeringactive102000
GraceWilsonMarketingactive76000
HenryTaylorSalesinactive71000
IreneAndersonEngineeringactive97000
JamesThomasFinanceactive91000
KarenJacksonHRactive63000
LeoWhiteEngineeringactive110000
MiaHarrisSalesactive74000
NathanMartinMarketinginactive69000
OliviaGarciaFinanceactive85000
PatrickMartinezEngineeringactive99000
QuinnRobinsonHRactive67000
RachelClarkSalesactive73000
import { useState } from 'react';
import { RowSelectionState } from '@tanstack/react-table';
import { Button, Code, Group, Paper, Text } from '@mantine/core';
import { DataGrid, useDataGrid } from '@mantine/data-grid';
import { employees } from './data';

function Demo() {
  const [rowSelection, setRowSelection] = useState<RowSelectionState>({});

  const store = useDataGrid({
    data: employees,
    columns: [
      { accessorKey: 'firstName', header: 'First Name' },
      { accessorKey: 'lastName', header: 'Last Name' },
      { accessorKey: 'department', header: 'Department' },
      { accessorKey: 'status', header: 'Status' },
      { accessorKey: 'salary', header: 'Salary' },
    ],
    withRowSelection: true,
    rowSelection,
    onRowSelectionChange: setRowSelection,
    getRowId: (row) => row.id,
  });

  const selectedIds = Object.keys(rowSelection);

  return (
    <>
      <Paper withBorder p="md" mb="md">
        <Group justify="space-between" mb={selectedIds.length > 0 ? 'xs' : undefined}>
          <Text size="sm" fw={500}>
            Selected rows: {selectedIds.length}
          </Text>
          <Button
            size="xs"
            variant="default"
            disabled={selectedIds.length === 0}
            onClick={() => setRowSelection({})}
          >
            Clear selection
          </Button>
        </Group>
        {selectedIds.length > 0 && <Code block>{JSON.stringify(selectedIds, null, 2)}</Code>}
      </Paper>
      <DataGrid store={store} />
    </>
  );
}

Single selection

Set enableMultiRowSelection: false to allow selecting one row at a time. Rows render a radio control instead of a checkbox:

Selected row ID: none

First Name
Last Name
Department
Status
Salary
AliceJohnsonEngineeringactive95000
BobSmithMarketingactive72000
CarolWilliamsSalesactive68000
DavidBrownHRinactive65000
EvaDavisFinanceactive88000
FrankMillerEngineeringactive102000
GraceWilsonMarketingactive76000
HenryTaylorSalesinactive71000
IreneAndersonEngineeringactive97000
JamesThomasFinanceactive91000
KarenJacksonHRactive63000
LeoWhiteEngineeringactive110000
MiaHarrisSalesactive74000
NathanMartinMarketinginactive69000
OliviaGarciaFinanceactive85000
PatrickMartinezEngineeringactive99000
QuinnRobinsonHRactive67000
RachelClarkSalesactive73000
import { useState } from 'react';
import { RowSelectionState } from '@tanstack/react-table';
import { Code, Text } from '@mantine/core';
import { DataGrid, useDataGrid } from '@mantine/data-grid';
import { employees } from './data';

function Demo() {
  const [rowSelection, setRowSelection] = useState<RowSelectionState>({});

  const store = useDataGrid({
    data: employees,
    columns: [
      { accessorKey: 'firstName', header: 'First Name' },
      { accessorKey: 'lastName', header: 'Last Name' },
      { accessorKey: 'department', header: 'Department' },
      { accessorKey: 'status', header: 'Status' },
      { accessorKey: 'salary', header: 'Salary' },
    ],
    withRowSelection: true,
    enableMultiRowSelection: false,
    rowSelection,
    onRowSelectionChange: setRowSelection,
    getRowId: (row) => row.id,
  });

  const selectedId = Object.keys(rowSelection)[0] ?? null;

  return (
    <>
      <Text mb="md" size="sm">
        Selected row ID: <Code>{selectedId ?? 'none'}</Code>
      </Text>
      <DataGrid store={store} />
    </>
  );
}

Conditional selection

Pass a function to enableRowSelection to control which rows can be selected. Other rows render a disabled checkbox:

Only active rows can be selected. Inactive rows show a disabled checkbox.

First Name
Last Name
Department
Status
Salary
AliceJohnsonEngineeringactive95000
BobSmithMarketingactive72000
CarolWilliamsSalesactive68000
DavidBrownHRinactive65000
EvaDavisFinanceactive88000
FrankMillerEngineeringactive102000
GraceWilsonMarketingactive76000
HenryTaylorSalesinactive71000
IreneAndersonEngineeringactive97000
JamesThomasFinanceactive91000
KarenJacksonHRactive63000
LeoWhiteEngineeringactive110000
MiaHarrisSalesactive74000
NathanMartinMarketinginactive69000
OliviaGarciaFinanceactive85000
PatrickMartinezEngineeringactive99000
QuinnRobinsonHRactive67000
RachelClarkSalesactive73000
import { useState } from 'react';
import { RowSelectionState } from '@tanstack/react-table';
import { Code, Text } from '@mantine/core';
import { DataGrid, useDataGrid } from '@mantine/data-grid';
import { employees } from './data';

function Demo() {
  const [rowSelection, setRowSelection] = useState<RowSelectionState>({});

  const store = useDataGrid({
    data: employees,
    columns: [
      { accessorKey: 'firstName', header: 'First Name' },
      { accessorKey: 'lastName', header: 'Last Name' },
      { accessorKey: 'department', header: 'Department' },
      { accessorKey: 'status', header: 'Status' },
      { accessorKey: 'salary', header: 'Salary' },
    ],
    withRowSelection: true,
    enableRowSelection: (row) => row.original.status === 'active',
    rowSelection,
    onRowSelectionChange: setRowSelection,
    getRowId: (row) => row.id,
  });

  return (
    <>
      <Text mb="md" size="sm">
        Only <Code>active</Code> rows can be selected. Inactive rows show a disabled checkbox.
      </Text>
      <DataGrid store={store} />
    </>
  );
}

Select on row click

Set selectOnRowClick on DataGrid to select rows by clicking anywhere on a row:

  • Click selects only that row
  • Shift + click extends the selection to a range from the last selected row
  • Ctrl / Cmd + click toggles the row without changing the others
  • Space toggles the focused row, Shift + Space extends the range
import { DataGrid, useDataGrid } from '@mantine/data-grid';
import { columns, data } from './data';

function Demo() {
  const store = useDataGrid({
    data,
    columns,
    getRowId: (row) => row.id,
    withRowSelection: true,
  });

  return <DataGrid store={store} selectOnRowClick />;
}

Bulk actions

Add DataGrid.SelectionBar next to DataGrid.Toolbar. While rows are selected, it replaces the toolbar with the selected count, your bulk action controls and a clear button. Get the selected rows with store.table.getSelectedRowModel().rows. See Customization for the floating variant:

First Name
Last Name
Department
Status
Salary
AliceJohnsonEngineeringactive95000
BobSmithMarketingactive72000
CarolWilliamsSalesactive68000
DavidBrownHRinactive65000
EvaDavisFinanceactive88000
FrankMillerEngineeringactive102000
GraceWilsonMarketingactive76000
HenryTaylorSalesinactive71000
IreneAndersonEngineeringactive97000
JamesThomasFinanceactive91000
KarenJacksonHRactive63000
LeoWhiteEngineeringactive110000
MiaHarrisSalesactive74000
NathanMartinMarketinginactive69000
OliviaGarciaFinanceactive85000
PatrickMartinezEngineeringactive99000
QuinnRobinsonHRactive67000
RachelClarkSalesactive73000
import { useState } from 'react';
import { RowSelectionState } from '@tanstack/react-table';
import { Button } from '@mantine/core';
import { DataGrid, useDataGrid } from '@mantine/data-grid';
import { employees } from './data';

function Demo() {
  const [data, setData] = useState(employees);
  const [rowSelection, setRowSelection] = useState<RowSelectionState>({});

  const store = useDataGrid({
    data,
    columns: [
      { accessorKey: 'firstName', header: 'First Name' },
      { accessorKey: 'lastName', header: 'Last Name' },
      { accessorKey: 'department', header: 'Department' },
      { accessorKey: 'status', header: 'Status' },
      { accessorKey: 'salary', header: 'Salary' },
    ],
    withRowSelection: true,
    withGlobalFilter: true,
    rowSelection,
    onRowSelectionChange: setRowSelection,
    getRowId: (row) => row.id,
  });

  const handleDeleteSelected = () => {
    const selectedIds = new Set(Object.keys(rowSelection));
    setData((current) => current.filter((row) => !selectedIds.has(row.id)));
    setRowSelection({});
  };

  return (
    <DataGrid store={store}>
      <DataGrid.Toolbar />
      <DataGrid.SelectionBar>
        <Button size={store.getControlSize()} variant="default" onClick={handleDeleteSelected}>
          Delete selected
        </Button>
      </DataGrid.SelectionBar>
    </DataGrid>
  );
}

Row expansion

Pass withRowExpansion to useDataGrid to add an expand column. Set renderExpandedRow prop on DataGrid to define the expanded content. Click the expand icon or press Enter on a focused row to toggle it:

First Name
Last Name
Department
Status
AliceJohnsonEngineeringactive
BobSmithMarketingactive
CarolWilliamsSalesactive
DavidBrownHRinactive
EvaDavisFinanceactive
FrankMillerEngineeringactive
GraceWilsonMarketingactive
HenryTaylorSalesinactive
IreneAndersonEngineeringactive
JamesThomasFinanceactive
KarenJacksonHRactive
LeoWhiteEngineeringactive
MiaHarrisSalesactive
NathanMartinMarketinginactive
OliviaGarciaFinanceactive
PatrickMartinezEngineeringactive
QuinnRobinsonHRactive
RachelClarkSalesactive
import { Group, Text } from '@mantine/core';
import { DataGrid, useDataGrid } from '@mantine/data-grid';
import { employees } from './data';

function Demo() {
  const store = useDataGrid({
    data: employees,
    columns: [
      { accessorKey: 'firstName', header: 'First Name' },
      { accessorKey: 'lastName', header: 'Last Name' },
      { accessorKey: 'department', header: 'Department' },
      { accessorKey: 'status', header: 'Status' },
    ],
    withRowExpansion: true,
    getRowId: (row) => row.id,
  });

  return (
    <DataGrid
      store={store}
      renderExpandedRow={({ row }) => (
        <Group gap="xl">
          <Text size="sm">Email: {row.original.email}</Text>
          <Text size="sm">Start date: {row.original.startDate}</Text>
          <Text size="sm">
            Salary: {new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' }).format(row.original.salary)}
          </Text>
        </Group>
      )}
    />
  );
}

Set withTintedExpandedRows to paint the expanded row and its panel with the striped color:

First Name
Last Name
Department
Status
AliceJohnsonEngineeringactive
BobSmithMarketingactive

Email: bob.smith@example.com

Start date: 2020-07-01

CarolWilliamsSalesactive
DavidBrownHRinactive
EvaDavisFinanceactive
FrankMillerEngineeringactive
GraceWilsonMarketingactive
HenryTaylorSalesinactive
IreneAndersonEngineeringactive
JamesThomasFinanceactive
KarenJacksonHRactive
LeoWhiteEngineeringactive
MiaHarrisSalesactive
NathanMartinMarketinginactive
OliviaGarciaFinanceactive
PatrickMartinezEngineeringactive
QuinnRobinsonHRactive
RachelClarkSalesactive
import { Group, Text } from '@mantine/core';
import { DataGrid, useDataGrid } from '@mantine/data-grid';
import { employees } from './data';

function Demo() {
  const store = useDataGrid({
    data: employees,
    columns: [
      { accessorKey: 'firstName', header: 'First Name' },
      { accessorKey: 'lastName', header: 'Last Name' },
      { accessorKey: 'department', header: 'Department' },
      { accessorKey: 'status', header: 'Status' },
    ],
    withRowExpansion: true,
    getRowId: (row) => row.id,
    tableOptions: { initialState: { expanded: { '2': true } } },
  });

  return (
    <DataGrid
      store={store}
      withTintedExpandedRows
      expandOnRowClick
      renderExpandedRow={({ row }) => (
        <Group gap="xl">
          <Text size="sm">Email: {row.original.email}</Text>
          <Text size="sm">Start date: {row.original.startDate}</Text>
        </Group>
      )}
    />
  );
}

Controlled expansion

Pass expanded and onExpandedChange to useDataGrid to control expansion state:

Expanded rows: 0

First Name
Last Name
Department
Status
Salary
AliceJohnsonEngineeringactive95000
BobSmithMarketingactive72000
CarolWilliamsSalesactive68000
DavidBrownHRinactive65000
EvaDavisFinanceactive88000
FrankMillerEngineeringactive102000
GraceWilsonMarketingactive76000
HenryTaylorSalesinactive71000
IreneAndersonEngineeringactive97000
JamesThomasFinanceactive91000
KarenJacksonHRactive63000
LeoWhiteEngineeringactive110000
MiaHarrisSalesactive74000
NathanMartinMarketinginactive69000
OliviaGarciaFinanceactive85000
PatrickMartinezEngineeringactive99000
QuinnRobinsonHRactive67000
RachelClarkSalesactive73000
import { useState } from 'react';
import { ExpandedState } from '@tanstack/react-table';
import { Button, Group, Text } from '@mantine/core';
import { DataGrid, useDataGrid } from '@mantine/data-grid';
import { employees } from './data';

function Demo() {
  const [expanded, setExpanded] = useState<ExpandedState>({});

  const store = useDataGrid({
    data: employees,
    columns: [
      { accessorKey: 'firstName', header: 'First Name' },
      { accessorKey: 'lastName', header: 'Last Name' },
      { accessorKey: 'department', header: 'Department' },
      { accessorKey: 'status', header: 'Status' },
      { accessorKey: 'salary', header: 'Salary' },
    ],
    withRowExpansion: true,
    expanded,
    onExpandedChange: setExpanded,
    getRowId: (row) => row.id,
  });

  const expandedCount = typeof expanded === 'boolean' ? 'all' : Object.keys(expanded).length;

  return (
    <>
      <Group mb="md">
        <Button size="xs" variant="default" onClick={() => store.table.toggleAllRowsExpanded(true)}>
          Expand all
        </Button>
        <Button size="xs" variant="default" onClick={() => store.table.toggleAllRowsExpanded(false)}>
          Collapse all
        </Button>
        <Text size="sm" c="dimmed">
          Expanded rows: {expandedCount}
        </Text>
      </Group>
      <DataGrid
        store={store}
        renderExpandedRow={({ row }) => (
          <Group gap="xl">
            <Text size="sm">Email: {row.original.email}</Text>
            <Text size="sm">Start date: {row.original.startDate}</Text>
            <Text size="sm">
              Salary:{' '}
              {new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' }).format(
                row.original.salary
              )}
            </Text>
          </Group>
        )}
      />
    </>
  );
}

Expand all rows

Call store.table.toggleAllRowsExpanded() to expand or collapse all rows:

store.table.toggleAllRowsExpanded(true);
store.table.toggleAllRowsExpanded(false);

Conditional expansion

Use getRowCanExpand in useDataGrid to control which rows display the expand toggle:

const store = useDataGrid({
  data,
  columns,
  withRowExpansion: true,
  getRowCanExpand: (row) => row.original.hasDetails,
});

Expand on click

Set expandOnRowClick on DataGrid to toggle row expansion by clicking anywhere on the row. With tree data, expansion reveals child rows and renderExpandedRow is ignored:

import { DataGrid, useDataGrid } from '@mantine/data-grid';
import { columns, data } from './data';

function Demo() {
  const store = useDataGrid({ data, columns, withRowExpansion: true });

  return (
    <DataGrid
      store={store}
      expandOnRowClick
      renderExpandedRow={({ row }) => <div>{row.original.email}</div>}
    />
  );
}

Row numbers

Set withRowNumbers in useDataGrid to add a row number column. Numbers count data rows only and continue across pages:

import { DataGrid, useDataGrid } from '@mantine/data-grid';
import { columns, data } from './data';

function Demo() {
  const store = useDataGrid({ data, columns, withRowNumbers: true, pageSize: 10 });

  return (
    <DataGrid store={store}>
      <DataGrid.Footer />
    </DataGrid>
  );
}

Row focus and keyboard navigation

Without cell selection, rows are the focus targets. The same keys work in the table body, the virtualized body and the list view:

KeyAction
ArrowDown / ArrowUpMove focus to the next / previous row
Home / EndMove focus to the first / last rendered row
EnterCalls onRowClick and toggles expansion, or starts editing when the row is editable
F2Starts editing the row when editing is enabled
SpaceToggles selection under selectOnRowClick, on a group row toggles the group
Shift + SpaceExtends the selection range under selectOnRowClick
EscapeBlurs the row

Keys pressed inside controls within a row (checkboxes, buttons, editors) are not handled by the row. See Accessibility for the full list of keyboard interactions.

Row click and double-click

Use onRowClick and onRowDoubleClick props on DataGrid to respond to row interactions. Both callbacks receive the row object and the event:

<DataGrid
  store={store}
  onRowClick={(row, event) => {
    console.log('Clicked row:', row.original);
  }}
  onRowDoubleClick={(row, event) => {
    console.log('Double-clicked row:', row.original);
  }}
/>

Cell selection

Pass withCellSelection to useDataGrid to enable spreadsheet-style cell range selection. Cells become the focus targets instead of rows and text selection inside cells is disabled. Set enableCellSelection: false on a column definition to exclude it from selection:

First Name
Last Name
Department
Salary
Status
AliceJohnsonEngineering95000active
BobSmithMarketing72000active
CarolWilliamsSales68000active
DavidBrownHR65000inactive
EvaDavisFinance88000active
FrankMillerEngineering102000active
GraceWilsonMarketing76000active
HenryTaylorSales71000inactive
IreneAndersonEngineering97000active
JamesThomasFinance91000active
KarenJacksonHR63000active
LeoWhiteEngineering110000active
MiaHarrisSales74000active
NathanMartinMarketing69000inactive
OliviaGarciaFinance85000active
PatrickMartinezEngineering99000active
QuinnRobinsonHR67000active
RachelClarkSales73000active
import { DataGrid, useDataGrid } from '@mantine/data-grid';
import { employees } from './data';

function Demo() {
  const store = useDataGrid({
    data: employees,
    columns: [
      { accessorKey: 'firstName', header: 'First Name' },
      { accessorKey: 'lastName', header: 'Last Name' },
      { accessorKey: 'department', header: 'Department' },
      { accessorKey: 'salary', header: 'Salary' },
      { accessorKey: 'status', header: 'Status' },
    ],
    withCellSelection: true,
  });

  return <DataGrid store={store} />;
}
InteractionAction
ClickFocuses the cell and starts a new single-cell range
DragSelects the range from the pressed cell to the cell under the pointer
Shift + clickExtends the current range to the clicked cell
Ctrl / Cmd + clickAdds or removes a cell from the selection as another range
Arrow keysMove the focused cell and start a new range there
Shift + ArrowExtends the current range in that direction
Enter / F2Starts editing the focused cell when editing is enabled

Use cellSelection and onCellSelectionChange to control the state. To read the current selection, use store.getCellSelection() or the table helpers:

const store = useDataGrid({ data, columns, withCellSelection: true });

store.table.getSelectedCellIds();
store.table.getSelectedCellCount();
store.table.getSelectedCellRangesData(); // values as [region][row][column]

List view

Set listView on DataGrid to render rows as a list instead of a table, for example on narrow screens. listView="cards" (default) renders bordered cards, listView="flat" renders items divided by rules. Editing and row reorder are not available in list view:

18 rows
First NameAlice
Last NameJohnson
Emailalice.johnson@example.com
DepartmentEngineering
Salary$95,000
First NameBob
Last NameSmith
Emailbob.smith@example.com
DepartmentMarketing
Salary$72,000
First NameCarol
Last NameWilliams
Emailcarol.williams@example.com
DepartmentSales
Salary$68,000
First NameDavid
Last NameBrown
Emaildavid.brown@example.com
DepartmentHR
Salary$65,000
import { useState } from 'react';
import { SegmentedControl } from '@mantine/core';
import { DataGrid, useDataGrid } from '@mantine/data-grid';
import { employees } from './data';

function Demo() {
  const [view, setView] = useState<'table' | 'cards' | 'flat'>('cards');

  const store = useDataGrid({
    data: employees,
    columns: [
      { accessorKey: 'firstName', header: 'First Name' },
      { accessorKey: 'lastName', header: 'Last Name' },
      { accessorKey: 'email', header: 'Email' },
      { accessorKey: 'department', header: 'Department' },
      {
        accessorKey: 'salary',
        header: 'Salary',
        meta: { align: 'end' },
        cell: ({ getValue }) => `$${getValue<number>().toLocaleString()}`,
      },
    ],
    getRowId: (row) => row.id,
    withRowSelection: true,
    pageSize: 4,
  });

  return (
    <>
      <SegmentedControl
        size="xs"
        mb="md"
        data={[
          { label: 'Table', value: 'table' },
          { label: 'Cards', value: 'cards' },
          { label: 'Flat', value: 'flat' },
        ]}
        value={view}
        onChange={(value) => setView(value as typeof view)}
      />
      <DataGrid store={store} listView={view === 'table' ? false : view} selectOnRowClick>
        <DataGrid.Toolbar>
          <DataGrid.RowCount />
        </DataGrid.Toolbar>
        <DataGrid.Footer />
      </DataGrid>
    </>
  );
}

By default, an item displays one label / value pair per visible data column. Use renderListItem to render your own content inside the item:

<DataGrid
  store={store}
  listView
  renderListItem={({ row }) => (
    <Group justify="space-between">
      <Text fw={500}>
        {row.original.firstName} {row.original.lastName}
      </Text>
      <Badge>{row.original.department}</Badge>
    </Group>
  )}
/>

With height set, the list scrolls inside a container of that height and pinned items stick to its edges. Without height, pinned items are moved to the start / end of the list.

Row reorder

Pass withRowReorder to useDataGrid to add a drag handle column. onRowOrderChange is called with a new copy of the data array after rows are reordered:

const [data, setData] = useState(initialData);

const store = useDataGrid({
  data,
  columns,
  withRowReorder: true,
  onRowOrderChange: setData,
});

Reordering is pointer-only: the handle has no keyboard alternative. If keyboard users need to reorder rows, provide your own controls, for example move up/down actions in a row menu.

Sorting is disabled when withRowReorder is set. Row reorder is not available with tree data, grouping, virtualize and list view. Pinned rows cannot be reordered, unpin a row to reorder it.