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.

Cell Editor Selection Snippet

Table Cell Editor Selection Snippet

Example demonstrating TableCellEditorSelectionSnippet.

TableCellEditorSelectionSnippet.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
package dev.equo.jface;

import java.util.EventObject;

import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.ColumnLabelProvider;
import org.eclipse.jface.viewers.ColumnViewer;
import org.eclipse.jface.viewers.ColumnViewerEditor;
import org.eclipse.jface.viewers.ColumnViewerEditorActivationEvent;
import org.eclipse.jface.viewers.ColumnViewerEditorActivationStrategy;
import org.eclipse.jface.viewers.EditingSupport;
import org.eclipse.jface.viewers.FocusCellOwnerDrawHighlighter;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TableViewerColumn;
import org.eclipse.jface.viewers.TableViewerEditor;
import org.eclipse.jface.viewers.TableViewerFocusCellManager;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.jface.viewers.ViewerCell;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

public class TableCellEditorSelectionSnippet {

    private static final int ACTIVATION_BIT_MASK = ColumnViewerEditor.TABBING_HORIZONTAL
            | ColumnViewerEditor.TABBING_MOVE_TO_ROW_NEIGHBOR | ColumnViewerEditor.KEYBOARD_ACTIVATION;

    public static void main(String[] args) {
        Display display = new Display();
        Shell shell = new Shell(display);
        shell.setText("Table cell editor / selection");
        shell.setLayout(new FillLayout());
        shell.setSize(600, 500);

        final TableViewer tableViewer = new TableViewer(shell, SWT.BORDER | SWT.FULL_SELECTION | SWT.MULTI);
        tableViewer.getTable().setHeaderVisible(true);
        tableViewer.getTable().setLinesVisible(true);

        TableViewerColumn nameCol = new TableViewerColumn(tableViewer, SWT.NONE);
        nameCol.getColumn().setText("Name");
        nameCol.getColumn().setWidth(260);
        nameCol.setLabelProvider(new ColumnLabelProvider() {
            @Override
            public String getText(Object element) {
                return String.valueOf(element);
            }
        });
        nameCol.setEditingSupport(new EditingSupport(tableViewer) {
            @Override
            protected CellEditor getCellEditor(Object element) {
                return new TextCellEditor(tableViewer.getTable());
            }

            @Override
            protected boolean canEdit(Object element) {
                return true;
            }

            @Override
            protected Object getValue(Object element) {
                return String.valueOf(element);
            }

            @Override
            protected void setValue(Object element, Object value) {
            }
        });

        TableViewerColumn typeCol = new TableViewerColumn(tableViewer, SWT.NONE);
        typeCol.getColumn().setText("Value Type");
        typeCol.getColumn().setWidth(160);
        typeCol.setLabelProvider(new ColumnLabelProvider() {
            @Override
            public String getText(Object element) {
                return "String";
            }
        });

        final TableViewerFocusCellManager focusCellManager = new TableViewerFocusCellManager(tableViewer,
                new FocusCellOwnerDrawHighlighter(tableViewer));

        ColumnViewerEditorActivationStrategy activationStrategy = new ColumnViewerEditorActivationStrategy(tableViewer) {
            @Override
            protected boolean isEditorActivationEvent(ColumnViewerEditorActivationEvent event) {
                switch (event.eventType) {
                    case ColumnViewerEditorActivationEvent.MOUSE_CLICK_SELECTION:
                        Object src = event.getSource();
                        return src instanceof ViewerCell && src.equals(focusCellManager.getFocusCell())
                                && isLeftClick(event.sourceEvent);
                    case ColumnViewerEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION:
                        return isLeftClick(event.sourceEvent);
                    case ColumnViewerEditorActivationEvent.KEY_PRESSED:
                        return event.keyCode == SWT.CR;
                    case ColumnViewerEditorActivationEvent.PROGRAMMATIC:
                        return true;
                }
                return false;
            }

            private boolean isLeftClick(EventObject e) {
                return e instanceof MouseEvent && ((MouseEvent) e).button == 1;
            }
        };

        TableViewerEditor.create(tableViewer, focusCellManager, activationStrategy, ACTIVATION_BIT_MASK);

        String[] rows = new String[40];
        for (int i = 0; i < rows.length; i++) {
            rows[i] = "variable_" + i;
        }
        tableViewer.setContentProvider(ArrayContentProvider.getInstance());
        tableViewer.setInput(rows);

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

View on GitHub

Drag Drop Snippet

Table Drag Drop Snippet

Exercises dragging a row within a Table to reorder it, using the same

TableViewer#addDragSupport / #addDropSupport idiom

(DND.DROP_MOVE + TextTransfer, index-as-string payload).

TableDragDropSnippet.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
package dev.equo;

import dev.equo.swt.Config;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DragSource;
import org.eclipse.swt.dnd.DragSourceAdapter;
import org.eclipse.swt.dnd.DragSourceEvent;
import org.eclipse.swt.dnd.DropTarget;
import org.eclipse.swt.dnd.DropTargetAdapter;
import org.eclipse.swt.dnd.DropTargetEvent;
import org.eclipse.swt.dnd.TextTransfer;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableItem;

import java.util.ArrayList;
import java.util.List;

/**
 * Exercises dragging a row within a Table to reorder it, using the same
 * TableViewer#addDragSupport / #addDropSupport idiom
 * (DND.DROP_MOVE + TextTransfer, index-as-string payload).
 */
public class TableDragDropSnippet {

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

        Display display = new Display();
        Shell shell = new Shell(display);
        shell.setLayout(new FillLayout(SWT.VERTICAL));
        shell.setText("TableDragDropSnippet");
        shell.setSize(300, 300);

        Label hint = new Label(shell, SWT.NONE);
        hint.setText("Drag a row and drop it on another row to reorder.");

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

        List<String> order = new ArrayList<>(List.of(
                "id", "name", "css selector", "xpath", "link text"));

        for (String s : order) {
            TableItem item = new TableItem(table, SWT.NONE);
            item.setText(s);
        }

        DragSource dragSource = new DragSource(table, DND.DROP_MOVE);
        dragSource.setTransfer(new Transfer[]{TextTransfer.getInstance()});
        dragSource.addDragListener(new DragSourceAdapter() {
            @Override
            public void dragSetData(DragSourceEvent event) {
                int index = table.getSelectionIndex();
                event.data = String.valueOf(index);
            }
        });

        DropTarget dropTarget = new DropTarget(table, DND.DROP_MOVE);
        dropTarget.setTransfer(new Transfer[]{TextTransfer.getInstance()});
        dropTarget.addDropListener(new DropTargetAdapter() {
            @Override
            public void drop(DropTargetEvent event) {
                if (event.data == null) return;
                // event.item == null means the drop landed past the last row (there is no
                // TableItem there to resolve) rather than an invalid drop — treat it as
                // "append at the end", the same convention Snippet91 uses for Tree.
                TableItem targetItem = (TableItem) event.item;
                int newIndex = targetItem != null ? table.indexOf(targetItem) : order.size();
                int oldIndex = Integer.parseInt((String) event.data);
                if (oldIndex == newIndex) return;

                String moved = order.remove(oldIndex);
                // Removing the source before inserting shifts every later index down by one,
                // so a downward drag (oldIndex < newIndex) must target newIndex - 1 to land the
                // moved row on the drop target's own position rather than one row past it.
                if (oldIndex < newIndex) {
                    newIndex--;
                }
                order.add(newIndex, moved);

                table.removeAll();
                for (String s : order) {
                    TableItem item = new TableItem(table, SWT.NONE);
                    item.setText(s);
                }
                table.setSelection(newIndex);
            }
        });

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

View on GitHub

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

No Columns Snippet

Table No Columns Snippet

Example demonstrating TableNoColumnsSnippet.

TableNoColumnsSnippet.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
package dev.equo;

import dev.equo.swt.Config;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
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 TableNoColumnsSnippet {

    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.setText("TableNoColumnsSnippet");
        shell.setLayout(new GridLayout(1, false));

        new Label(shell, SWT.NONE).setText("Ranges:");

        Table ranges = new Table(shell, SWT.BORDER | SWT.V_SCROLL);
        ranges.setLayoutData(new GridData(SWT.BEGINNING, SWT.BEGINNING, false, false));
        for (String range : new String[] {
                "Current range", "Range linked to current", "Editable range", "Final caret location" }) {
            new TableItem(ranges, SWT.NONE).setText(range);
        }

        new Label(shell, SWT.NONE).setText("Annotation types:");

        Table annotations = new Table(shell, SWT.BORDER | SWT.V_SCROLL);
        annotations.setLayoutData(new GridData(SWT.BEGINNING, SWT.BEGINNING, false, false));
        for (String annotation : new String[] {
                "Bookmarks", "Breakpoints", "Cucumber unmatched step", "Debug Call Stack", "Errors",
                "Spelling Errors" }) {
            new TableItem(annotations, SWT.NONE).setText(annotation);
        }

        shell.pack();
        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: drawText + textExtent + drawImage.
  • "Selected" column: 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: drawText +
 *   textExtent + drawImage.</li>
 *   <li>"Selected" column: 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