Disabled cells

Make specified cells read-only to protect them from unwanted changes but still allow navigation and copying of data.

Overview

Disabling a cell makes the cell read-only or non-editable. Both have similar outcomes, with the following differences:

Read-only cell `readOnly: true`	Non-editable cell `editor: false`
Has an additional CSS class (`htDimmed`)	Has no additional CSS class
Copy works, paste doesn’t work	Copy-paste works
Drag-to-fill doesn’t work	Drag-to-fill works
Can’t be changed by `populateFromArray()`	Can be changed by `populateFromArray()`

Read-only grid

You can make the entire grid read-only by setting readOnly to true as a top-level grid option.

1
import { HotTable } from '@handsontable/react-wrapper';
2
import { registerAllModules } from 'handsontable/registry';
3

4
// register Handsontable's modules
5
registerAllModules();
6

7
const ExampleComponent = () => {
8
  return (
9
    <HotTable
10
      data={[
11
        { car: 'Tesla', year: 2017, chassis: 'black', bumper: 'black' },
12
        { car: 'Nissan', year: 2018, chassis: 'blue', bumper: 'blue' },
13
        { car: 'Chrysler', year: 2019, chassis: 'yellow', bumper: 'black' },
14
        { car: 'Volvo', year: 2020, chassis: 'white', bumper: 'gray' },
15
      ]}
16
      height="auto"
17
      colHeaders={['Car', 'Year', 'Chassis color', 'Bumper color']}
18
      autoWrapRow={true}
19
      autoWrapCol={true}
20
      licenseKey="non-commercial-and-evaluation"
21
      readOnly={true}
22
    />
23
  );
24
};
25

26
export default ExampleComponent;

1
import { HotTable } from '@handsontable/react-wrapper';
2
import { registerAllModules } from 'handsontable/registry';
3

4
// register Handsontable's modules
5
registerAllModules();
6

7
const ExampleComponent = () => {
8
  return (
9
    <HotTable
10
      data={[
11
        { car: 'Tesla', year: 2017, chassis: 'black', bumper: 'black' },
12
        { car: 'Nissan', year: 2018, chassis: 'blue', bumper: 'blue' },
13
        { car: 'Chrysler', year: 2019, chassis: 'yellow', bumper: 'black' },
14
        { car: 'Volvo', year: 2020, chassis: 'white', bumper: 'gray' },
15
      ]}
16
      height="auto"
17
      colHeaders={['Car', 'Year', 'Chassis color', 'Bumper color']}
18
      autoWrapRow={true}
19
      autoWrapCol={true}
20
      licenseKey="non-commercial-and-evaluation"
21
      readOnly={true}
22
    />
23
  );
24
};
25

26
export default ExampleComponent;

Read-only columns

In many use cases, you will need to configure a certain column to be read-only. This column will be available for keyboard navigation and copying data (Ctrl/Cmd+C). Editing and pasting data will be disabled.

To make a column read-only, declare it in the columns configuration option. You can also define a special renderer function that will dim the read-only values, providing a visual cue for the user that the cells are read-only.

1
import { HotTable } from '@handsontable/react-wrapper';
2
import { registerAllModules } from 'handsontable/registry';
3

4
// register Handsontable's modules
5
registerAllModules();
6

7
const ExampleComponent = () => {
8
  return (
9
    <HotTable
10
      data={[
11
        { car: 'Tesla', year: 2017, chassis: 'black', bumper: 'black' },
12
        { car: 'Nissan', year: 2018, chassis: 'blue', bumper: 'blue' },
13
        { car: 'Chrysler', year: 2019, chassis: 'yellow', bumper: 'black' },
14
        { car: 'Volvo', year: 2020, chassis: 'white', bumper: 'gray' },
15
      ]}
16
      height="auto"
17
      colHeaders={['Car', 'Year', 'Chassis color', 'Bumper color']}
18
      autoWrapRow={true}
19
      autoWrapCol={true}
20
      licenseKey="non-commercial-and-evaluation"
21
      columns={[
22
        {
23
          data: 'car',
24
          readOnly: true,
25
        },
26
        {
27
          data: 'year',
28
        },
29
        {
30
          data: 'chassis',
31
        },
32
        {
33
          data: 'bumper',
34
        },
35
      ]}
36
    />
37
  );
38
};
39

40
export default ExampleComponent;

1
import { HotTable } from '@handsontable/react-wrapper';
2
import { registerAllModules } from 'handsontable/registry';
3

4
// register Handsontable's modules
5
registerAllModules();
6

7
const ExampleComponent = () => {
8
  return (
9
    <HotTable
10
      data={[
11
        { car: 'Tesla', year: 2017, chassis: 'black', bumper: 'black' },
12
        { car: 'Nissan', year: 2018, chassis: 'blue', bumper: 'blue' },
13
        { car: 'Chrysler', year: 2019, chassis: 'yellow', bumper: 'black' },
14
        { car: 'Volvo', year: 2020, chassis: 'white', bumper: 'gray' },
15
      ]}
16
      height="auto"
17
      colHeaders={['Car', 'Year', 'Chassis color', 'Bumper color']}
18
      autoWrapRow={true}
19
      autoWrapCol={true}
20
      licenseKey="non-commercial-and-evaluation"
21
      columns={[
22
        {
23
          data: 'car',
24
          readOnly: true,
25
        },
26
        {
27
          data: 'year',
28
        },
29
        {
30
          data: 'chassis',
31
        },
32
        {
33
          data: 'bumper',
34
        },
35
      ]}
36
    />
37
  );
38
};
39

40
export default ExampleComponent;

Read-only specific cells

This example makes cells that contain the word “Nissan” read-only. It forces all cells to be processed by the cells function which will decide whether a cell’s metadata should have the readOnly property set.

1
import { useRef, useEffect } from 'react';
2
import { HotTable } from '@handsontable/react-wrapper';
3
import { registerAllModules } from 'handsontable/registry';
4

5
// register Handsontable's modules
6
registerAllModules();
7

8
const ExampleComponent = () => {
9
  const hotRef = useRef(null);
10

11
  useEffect(() => {
12
    const hot = hotRef.current?.hotInstance;
13

14
    hot?.updateSettings({
15
      cells(row, col) {
16
        const cellProperties = {};
17

18
        if (hot.getData()[row][col] === 'Nissan') {
19
          cellProperties.readOnly = true;
20
        }
21

22
        return cellProperties;
23
      },
24
    });
25
  });
26

27
  return (
28
    <HotTable
29
      ref={hotRef}
30
      data={[
31
        { car: 'Tesla', year: 2017, chassis: 'black', bumper: 'black' },
32
        { car: 'Nissan', year: 2018, chassis: 'blue', bumper: 'blue' },
33
        { car: 'Chrysler', year: 2019, chassis: 'yellow', bumper: 'black' },
34
        { car: 'Volvo', year: 2020, chassis: 'white', bumper: 'gray' },
35
      ]}
36
      colHeaders={['Car', 'Year', 'Chassis color', 'Bumper color']}
37
      height="auto"
38
      autoWrapRow={true}
39
      autoWrapCol={true}
40
      licenseKey="non-commercial-and-evaluation"
41
    />
42
  );
43
};
44

45
export default ExampleComponent;

1
import { useRef, useEffect } from 'react';
2
import Handsontable from 'handsontable/base';
3
import { HotTable, HotTableRef } from '@handsontable/react-wrapper';
4
import { registerAllModules } from 'handsontable/registry';
5

6
// register Handsontable's modules
7
registerAllModules();
8

9
const ExampleComponent = () => {
10
  const hotRef = useRef<HotTableRef>(null);
11

12
  useEffect(() => {
13
    const hot = hotRef.current?.hotInstance;
14

15
    hot?.updateSettings({
16
      cells(row, col) {
17
        const cellProperties: Handsontable.CellMeta = {};
18

19
        if (hot.getData()[row][col] === 'Nissan') {
20
          cellProperties.readOnly = true;
21
        }
22

23
        return cellProperties;
24
      },
25
    });
26
  });
27

28
  return (
29
    <HotTable
30
      ref={hotRef}
31
      data={[
32
        { car: 'Tesla', year: 2017, chassis: 'black', bumper: 'black' },
33
        { car: 'Nissan', year: 2018, chassis: 'blue', bumper: 'blue' },
34
        { car: 'Chrysler', year: 2019, chassis: 'yellow', bumper: 'black' },
35
        { car: 'Volvo', year: 2020, chassis: 'white', bumper: 'gray' },
36
      ]}
37
      colHeaders={['Car', 'Year', 'Chassis color', 'Bumper color']}
38
      height="auto"
39
      autoWrapRow={true}
40
      autoWrapCol={true}
41
      licenseKey="non-commercial-and-evaluation"
42
    />
43
  );
44
};
45

46
export default ExampleComponent;

Non-editable cells behave like any other cells apart from preventing you from manually changing their values.

Non-editable columns

In many cases, you will need to configure a certain column to be non-editable. Doing this does not change its basic behaviour, apart from editing. This means that you can still use the keyboard navigation Ctrl/Cmd+C, and Ctrl/Cmd+V functionalities, and drag-to-fill, etc.

To make a column non-editable, declare it in the columns configuration option. You can also define a special renderer function that will dim the editor value. This will provide the user with a visual cue that the cell is non-editable.

1
import { HotTable } from '@handsontable/react-wrapper';
2
import { registerAllModules } from 'handsontable/registry';
3

4
// register Handsontable's modules
5
registerAllModules();
6

7
const ExampleComponent = () => {
8
  return (
9
    <HotTable
10
      data={[
11
        { car: 'Tesla', year: 2017, chassis: 'black', bumper: 'black' },
12
        { car: 'Nissan', year: 2018, chassis: 'blue', bumper: 'blue' },
13
        { car: 'Chrysler', year: 2019, chassis: 'yellow', bumper: 'black' },
14
        { car: 'Volvo', year: 2020, chassis: 'white', bumper: 'gray' },
15
      ]}
16
      height="auto"
17
      colHeaders={['Car', 'Year', 'Chassis color', 'Bumper color']}
18
      autoWrapRow={true}
19
      autoWrapCol={true}
20
      licenseKey="non-commercial-and-evaluation"
21
      columns={[
22
        {
23
          data: 'car',
24
          editor: false,
25
        },
26
        {
27
          data: 'year',
28
          editor: 'numeric',
29
        },
30
        {
31
          data: 'chassis',
32
          editor: 'text',
33
        },
34
        {
35
          data: 'bumper',
36
          editor: 'text',
37
        },
38
      ]}
39
    />
40
  );
41
};
42

43
export default ExampleComponent;

1
import { HotTable } from '@handsontable/react-wrapper';
2
import { registerAllModules } from 'handsontable/registry';
3

4
// register Handsontable's modules
5
registerAllModules();
6

7
const ExampleComponent = () => {
8
  return (
9
    <HotTable
10
      data={[
11
        { car: 'Tesla', year: 2017, chassis: 'black', bumper: 'black' },
12
        { car: 'Nissan', year: 2018, chassis: 'blue', bumper: 'blue' },
13
        { car: 'Chrysler', year: 2019, chassis: 'yellow', bumper: 'black' },
14
        { car: 'Volvo', year: 2020, chassis: 'white', bumper: 'gray' },
15
      ]}
16
      height="auto"
17
      colHeaders={['Car', 'Year', 'Chassis color', 'Bumper color']}
18
      autoWrapRow={true}
19
      autoWrapCol={true}
20
      licenseKey="non-commercial-and-evaluation"
21
      columns={[
22
        {
23
          data: 'car',
24
          editor: false,
25
        },
26
        {
27
          data: 'year',
28
          editor: 'numeric',
29
        },
30
        {
31
          data: 'chassis',
32
          editor: 'text',
33
        },
34
        {
35
          data: 'bumper',
36
          editor: 'text',
37
        },
38
      ]}
39
    />
40
  );
41
};
42

43
export default ExampleComponent;

Non-editable specific cells

The following example shows the table with non-editable cells containing the word “Nissan”. This cell property is optional and you can easily set it in the Handsontable configuration.

1
import { useRef, useEffect } from 'react';
2
import { HotTable } from '@handsontable/react-wrapper';
3
import { registerAllModules } from 'handsontable/registry';
4

5
// register Handsontable's modules
6
registerAllModules();
7

8
const ExampleComponent = () => {
9
  const hotRef = useRef(null);
10

11
  useEffect(() => {
12
    const hot = hotRef.current?.hotInstance;
13

14
    hot?.updateSettings({
15
      cells(row, _col, prop) {
16
        const cellProperties = {};
17

18
        if (hot.getDataAtRowProp(row, prop) === 'Nissan') {
19
          cellProperties.editor = false;
20
        } else {
21
          cellProperties.editor = 'text';
22
        }
23

24
        return cellProperties;
25
      },
26
    });
27
  });
28

29
  return (
30
    <HotTable
31
      ref={hotRef}
32
      data={[
33
        { car: 'Tesla', year: 2017, chassis: 'black', bumper: 'black' },
34
        { car: 'Nissan', year: 2018, chassis: 'blue', bumper: 'blue' },
35
        { car: 'Chrysler', year: 2019, chassis: 'yellow', bumper: 'black' },
36
        { car: 'Volvo', year: 2020, chassis: 'white', bumper: 'gray' },
37
      ]}
38
      colHeaders={['Car', 'Year', 'Chassis color', 'Bumper color']}
39
      height="auto"
40
      autoWrapRow={true}
41
      autoWrapCol={true}
42
      licenseKey="non-commercial-and-evaluation"
43
    />
44
  );
45
};
46

47
export default ExampleComponent;

1
import { useRef, useEffect } from 'react';
2
import Handsontable from 'handsontable/base';
3
import { HotTable, HotTableRef } from '@handsontable/react-wrapper';
4
import { registerAllModules } from 'handsontable/registry';
5

6
// register Handsontable's modules
7
registerAllModules();
8

9
const ExampleComponent = () => {
10
  const hotRef = useRef<HotTableRef>(null);
11

12
  useEffect(() => {
13
    const hot = hotRef.current?.hotInstance;
14

15
    hot?.updateSettings({
16
      cells(row, _col, prop) {
17
        const cellProperties: Handsontable.CellMeta = {};
18

19
        if (hot.getDataAtRowProp(row, prop as string) === 'Nissan') {
20
          cellProperties.editor = false;
21
        } else {
22
          cellProperties.editor = 'text';
23
        }
24

25
        return cellProperties;
26
      },
27
    });
28
  });
29

30
  return (
31
    <HotTable
32
      ref={hotRef}
33
      data={[
34
        { car: 'Tesla', year: 2017, chassis: 'black', bumper: 'black' },
35
        { car: 'Nissan', year: 2018, chassis: 'blue', bumper: 'blue' },
36
        { car: 'Chrysler', year: 2019, chassis: 'yellow', bumper: 'black' },
37
        { car: 'Volvo', year: 2020, chassis: 'white', bumper: 'gray' },
38
      ]}
39
      colHeaders={['Car', 'Year', 'Chassis color', 'Bumper color']}
40
      height="auto"
41
      autoWrapRow={true}
42
      autoWrapCol={true}
43
      licenseKey="non-commercial-and-evaluation"
44
    />
45
  );
46
};
47

48
export default ExampleComponent;

Configuration options

readOnly

readOnlyCellClassName