Skip to content

Table Examples

Instances of this class implement a selectable user interface object that displays a list of images and strings and issues notification when selected.

Multiple Editors

Table Multiple Editors

Example demonstrating TableMultipleEditors.

TableMultipleEditors.java 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
package dev.equo;

import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.TableEditor;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.*;

public class TableMultipleEditors {

    public static void main(String[] args) {
        Display display = new Display();
        Shell shell = new Shell(display);
        shell.setText("Table with multiple editors");
        shell.setLayout(new FillLayout());

        Table table = new Table(shell, SWT.BORDER | SWT.FULL_SELECTION);
        table.setHeaderVisible(true);
        table.setLinesVisible(true);

        String[] titles = { "ID", "Name", "Type", "Active" };
        int[] widths = { 80, 150, 120, 80 };

        for (int i = 0; i < titles.length; i++) {
            TableColumn col = new TableColumn(table, SWT.NONE);
            col.setText(titles[i]);
            col.setWidth(widths[i]);
        }

        for (int i = 1; i <= 5; i++) {
            TableItem item = new TableItem(table, SWT.NONE);
            item.setText(new String[] {
                    String.valueOf(i),
                    "Item " + i,
                    "A",
                    i % 2 == 0 ? "Yes" : "No" // TODO
            });
        }

        for (TableItem item : table.getItems()) {

            TableEditor textEditor = new TableEditor(table);
            Text text = new Text(table, SWT.NONE);
            text.setText(item.getText(1));
            text.addModifyListener(e ->
                    item.setText(1, text.getText())
            );
            textEditor.grabHorizontal = true;
            textEditor.setEditor(text, item, 1);

            TableEditor comboEditor = new TableEditor(table);
            Combo combo = new Combo(table, SWT.READ_ONLY);
            combo.setItems(new String[] { "A", "B", "C" });
            combo.setText(item.getText(2));
            combo.addListener(SWT.Selection, e ->
                    item.setText(2, combo.getText())
            );
            comboEditor.grabHorizontal = true;
            comboEditor.setEditor(combo, item, 2);

            TableEditor checkEditor = new TableEditor(table);
            Button check = new Button(table, SWT.CHECK);
            check.setSelection("Yes".equals(item.getText(3)));
            check.addListener(SWT.Selection, e ->
                    item.setText(3, check.getSelection() ? "Yes" : "No")
            );
            checkEditor.horizontalAlignment = SWT.CENTER;
            checkEditor.setEditor(check, item, 3);
        }

        shell.setSize(500, 300);
        shell.open();

        while (!shell.isDisposed()) {
            if (!display.readAndDispatch()) {
                display.sleep();
            }
        }
        display.dispose();
    }
}

View on GitHub

Paint Item Snippet

Table Paint Item Snippet

Replicates two real-world SWT.PaintItem patterns on the same Table, both driven by

TableHelper.firePaintItemForEmptyCells (the cells have no item.image of their own):

  • "Value" column: like Katalon's Profile editor (MyLabelProvider) - drawText + textExtent + drawImage.
  • "Selected" column: like Katalon's "Append Tags" dialog - only drawImage, toggled on click.
TablePaintItemSnippet.java 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
package dev.equo;

import dev.equo.swt.Config;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;

/**
 * Replicates two real-world SWT.PaintItem patterns on the same Table, both driven by
 * TableHelper.firePaintItemForEmptyCells (the cells have no item.image of their own):
 * <ul>
 *   <li>"Value" column: like Katalon's Profile editor (MyLabelProvider) - drawText +
 *   textExtent + drawImage.</li>
 *   <li>"Selected" column: like Katalon's "Append Tags" dialog - only drawImage,
 *   toggled on click.</li>
 * </ul>
 */
public class TablePaintItemSnippet {

    public static void main(String[] args) {
        Config.useEquo(Table.class);
        Config.useEquo(TableItem.class);
        Config.useEquo(TableColumn.class);

        Display display = new Display();
        Shell shell = new Shell(display);
        shell.setLayout(new FillLayout());
        shell.setText("Table PaintItem - Profile + Checkbox");
        shell.setSize(450, 300);

        Image valueIcon = solidImage(display, 12, 12, new RGB(0, 100, 200));
        Image checkedImage = solidImage(display, 16, 16, new RGB(0, 150, 0));
        Image uncheckedImage = solidImage(display, 16, 16, new RGB(200, 200, 200));

        Table table = new Table(shell, SWT.BORDER | SWT.FULL_SELECTION);
        table.setHeaderVisible(true);
        table.setLinesVisible(true);

        TableColumn valueColumn = new TableColumn(table, SWT.NONE);
        valueColumn.setText("Value");
        valueColumn.setWidth(280);

        TableColumn selectedColumn = new TableColumn(table, SWT.NONE);
        selectedColumn.setText("Selected");
        selectedColumn.setWidth(100);

        int rowCount = 6;
        boolean[] selected = new boolean[rowCount];
        for (int i = 0; i < rowCount; i++) {
            TableItem item = new TableItem(table, SWT.NONE);
            item.setText(0, "Profile value " + i);
            // Column 1 left empty on purpose: getImages() returns null for it,
            // so firePaintItemForEmptyCells fires SWT.PaintItem for that cell.
        }

        table.addListener(SWT.PaintItem, event -> {
            TableItem item = (TableItem) event.item;
            int rowIndex = table.indexOf(item);
            if (event.index == 0) {
                String text = item.getText(0);
                int textX = event.x + 2;
                event.gc.drawText(text, textX, event.y + 2, true);
                int textWidth = event.gc.textExtent(text).x;
                int imageX = textX + textWidth + 5;
                int imageY = event.y + (event.height - valueIcon.getBounds().height) / 2;
                event.gc.drawImage(valueIcon, imageX, imageY);
            } else if (event.index == 1) {
                Image icon = selected[rowIndex] ? checkedImage : uncheckedImage;
                int imageY = event.y + (event.height - icon.getBounds().height) / 2;
                event.gc.drawImage(icon, event.x + 5, imageY);
            }
        });

        table.addListener(SWT.MouseDown, event -> {
            TableItem item = table.getItem(new Point(event.x, event.y));
            if (item == null) return;
            Rectangle cellBounds = item.getBounds(1);
            if (cellBounds.contains(event.x, event.y)) {
                int rowIndex = table.indexOf(item);
                selected[rowIndex] = !selected[rowIndex];
                // Re-sets the same text to mark the item dirty, forcing a re-render
                // so getImages() recomputes the "Selected" cell with the new state.
                item.setText(0, item.getText(0));
            }
        });

        shell.open();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch()) {
                display.sleep();
            }
        }
        valueIcon.dispose();
        checkedImage.dispose();
        uncheckedImage.dispose();
        display.dispose();
    }

    private static Image solidImage(Display display, int width, int height, RGB rgb) {
        Image image = new Image(display, width, height);
        GC gc = new GC(image);
        Color color = new Color(display, rgb);
        gc.setBackground(color);
        gc.fillRectangle(0, 0, width, height);
        gc.dispose();
        color.dispose();
        return image;
    }
}

View on GitHub

Snippet

Table Snippet

Example demonstrating TableSnippet.

TableSnippet.java 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
package dev.equo;

import dev.equo.swt.Config;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;

public class TableSnippet {

    public static void main(String[] args) {
        Config.useEquo(Table.class);
        Config.useEquo(TableItem.class);
        Config.useEquo(TableColumn.class);

        Display display = new Display();
        Shell shell = new Shell(display);
        shell.setLayout(new FillLayout());
        shell.setText("TableSnippet");
        shell.setSize(400, 250);

        Table table = new Table(shell, SWT.BORDER | SWT.FULL_SELECTION);
        table.setHeaderVisible(true);
        table.setLinesVisible(true);

        TableColumn nameColumn = new TableColumn(table, SWT.NONE);
        nameColumn.setText("Name");
        nameColumn.setWidth(150);

        TableColumn ageColumn = new TableColumn(table, SWT.NONE);
        ageColumn.setText("Age");
        ageColumn.setWidth(80);

        TableColumn cityColumn = new TableColumn(table, SWT.NONE);
        cityColumn.setText("City");
        cityColumn.setWidth(120);

        String[][] data = {
                {"John Doe", "25", "New York"},
                {"Jane Smith", "30", "Los Angeles"},
                {"Bob Johnson", "35", "Chicago"},
                {"Alice Brown", "28", "Houston"},
                {"Charlie Wilson", "42", "Phoenix"}
        };

        for (String[] row : data) {
            TableItem item = new TableItem(table, SWT.NONE);
            item.setText(row);
        }

        for (TableColumn column : table.getColumns()) {
            column.pack();
        }

        shell.open();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch()) {
                display.sleep();
            }
        }
        display.dispose();
    }
}

View on GitHub

With Editors Example

Table With Editors Example

Example demonstrating TableWithEditorsExample.

TableWithEditorsExample.java 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
package dev.equo;

import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.TableEditor;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.*;

public class TableWithEditorsExample {

    public static void main(String[] args) {

        Display display = new Display();
        Shell shell = new Shell(display);
        shell.setText("SWT Table with Editors");
        shell.setSize(700, 400);
        shell.setLayout(new FillLayout());

        Table table = new Table(shell, SWT.BORDER | SWT.FULL_SELECTION);
        table.setHeaderVisible(true);
        table.setLinesVisible(true);

        String[] titles = {"Name", "Type", "Value", "Enabled"};
        for (String title : titles) {
            TableColumn column = new TableColumn(table, SWT.NONE);
            column.setText(title);
            column.setWidth(170);
        }

        createItem(table, "Item 1", "Category", "N/A", true);
        createItem(table, "Item 2", "Text", "Editable", false);
        createItem(table, "Item 3", "Combo", "Option 1", true);

        TableEditor editor = new TableEditor(table);
        editor.horizontalAlignment = SWT.LEFT;
        editor.grabHorizontal = true;

//        table.addListener(SWT.MouseDoubleClick, event -> {
            table.addListener(SWT.MouseDown, event -> {

            int row = table.getSelectionIndex();
            if (row == -1) return;

            TableItem item = table.getItem(row);

            // Detectar columna clickeada
            int column = -1;
            for (int i = 0; i < table.getColumnCount(); i++) {
                Rectangle rect = item.getBounds(i);
                if (rect.contains(event.x, event.y)) {
                    column = i;
                    break;
                }
            }

            if (column == -1) return;

            Control oldEditor = editor.getEditor();
            if (oldEditor != null) oldEditor.dispose();

            // Name y Value → Text
            if (column == 0 || column == 2) {

                Text text = new Text(table, SWT.NONE);
                text.setText(item.getText(column));
                text.selectAll();
                text.setFocus();

                int col = column;

                text.addListener(SWT.FocusOut, e -> {
                    item.setText(col, text.getText());
                    text.dispose();
                });

                text.addListener(SWT.Traverse, e -> {
                    if (e.detail == SWT.TRAVERSE_RETURN) {
                        item.setText(col, text.getText());
                        text.dispose();
                        e.doit = false;
                    }
                    if (e.detail == SWT.TRAVERSE_ESCAPE) {
                        text.dispose();
                        e.doit = false;
                    }
                });

                editor.setEditor(text, item, column);
            }

            // Type → Combo
            else if (column == 1) {

                Combo combo = new Combo(table, SWT.READ_ONLY);
                combo.setItems("Text", "Combo", "Category");
                combo.setText(item.getText(column));
                combo.setFocus();

                int col = column;

                combo.addListener(SWT.Selection, e -> {
                    item.setText(col, combo.getText());
                    combo.dispose();
                });

                combo.addListener(SWT.FocusOut, e -> combo.dispose());

                editor.setEditor(combo, item, column);
            }

            // Enabled → Checkbox
            else if (column == 3) {

                Button check = new Button(table, SWT.CHECK);

                Boolean enabled = (Boolean) item.getData("enabled");
                check.setSelection(enabled != null && enabled);
                check.setFocus();

                int col = column;

                check.addListener(SWT.Selection, e -> {
                    boolean value = check.getSelection();
                    item.setData("enabled", value);
                    item.setText(col, value ? "Yes" : "No");
                });

                check.addListener(SWT.FocusOut, e -> check.dispose());

                editor.grabHorizontal = false;
                editor.minimumWidth = 50;
                editor.setEditor(check, item, column);
            }
        });

        shell.open();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch())
                display.sleep();
        }
        display.dispose();
    }

    private static void createItem(Table table, String name, String type, String value, boolean enabled) {

        TableItem item = new TableItem(table, SWT.NONE);
        item.setText(new String[]{
                name,
                type,
                value,
                enabled ? "Yes" : "No"
        });

        item.setData("enabled", enabled);
    }
}

View on GitHub

With Text And Checkbox

Table With Text And Checkbox

Example demonstrating TableWithTextAndCheckbox.

TableWithTextAndCheckbox.java 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package dev.equo;

import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.*;
import org.eclipse.swt.custom.TableEditor;

public class TableWithTextAndCheckbox {

    public static void main(String[] args) {
        Display display = new Display();
        Shell shell = new Shell(display);
        shell.setText("Table with Text and Checkbox");
        shell.setSize(400, 300);
        shell.setLayout(new FillLayout());

        Table table = new Table(shell, SWT.BORDER | SWT.FULL_SELECTION);
        table.setHeaderVisible(true);
        table.setLinesVisible(true);

        TableColumn colText = new TableColumn(table, SWT.NONE);
        colText.setText("Text");

        TableColumn colCheck = new TableColumn(table, SWT.NONE);
        colCheck.setText("Active");

        for (int i = 0; i < 5; i++) {
            TableItem item = new TableItem(table, SWT.NONE);

            TableEditor textEditor = new TableEditor(table);
            Text text = new Text(table, SWT.NONE);
            text.setText("Row " + (i + 1));
            textEditor.grabHorizontal = true;
            textEditor.setEditor(text, item, 0);

            TableEditor checkEditor = new TableEditor(table);
            Button checkbox = new Button(table, SWT.CHECK);
            checkbox.setSelection(false);
            checkEditor.horizontalAlignment = SWT.CENTER;
            checkEditor.setEditor(checkbox, item, 1);
        }

        colText.pack();
        colCheck.pack();

        shell.open();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch()) {
                display.sleep();
            }
        }
        display.dispose();
    }
}

View on GitHub