Skip to content

Tree Examples

Instances of this class provide a selectable user interface object that displays a hierarchy of items and issues notification when an item in the hierarchy is selected.

Snippet

Tree Snippet

Example demonstrating TreeSnippet.

TreeSnippet.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
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.Tree;
import org.eclipse.swt.widgets.TreeItem;

public class TreeSnippet {

public static void main (String [] args) {
    Config.forceEquo();
    Display display = new Display ();
    Shell shell = new Shell (display);
    shell.setText("TreeSnippet");
    shell.setLayout (new FillLayout ());
    final Tree tree = new Tree (shell, SWT.BORDER | SWT.MULTI | SWT.V_SCROLL);
    for (int i=0; i<4; i++) {
        TreeItem item0 = new TreeItem (tree, 0);
        item0.setText ("Item " + i);
        for (int j=0; j<4; j++) {
            TreeItem item1 = new TreeItem (item0, 0);
            item1.setText ("SubItem " + i + " " + j);
            for (int k=0; k<4; k++) {
                TreeItem item2 = new TreeItem (item1, 0);
                item2.setText ("SubItem " + i + " " + j + " " + k);
            }
        }
    }
    tree.addListener (SWT.Selection, e -> {
        String string = "";
        for (TreeItem item : tree.getSelection ())
            string += item + " ";
        System.out.println ("Selection={" + string + "}");
    });
    tree.addListener (SWT.DefaultSelection, e -> {
        String string = "";
        for (TreeItem item : tree.getSelection ())
            string += item + " ";
        System.out.println ("DefaultSelection={" + string + "}");
    });
    tree.addListener (SWT.Expand, e -> System.out.println ("Expand={" + e.item + "}"));
    tree.addListener (SWT.Collapse, e -> System.out.println ("Collapse={" + e.item + "}"));
    tree.getItems () [0].setExpanded (true);
    shell.pack ();
    shell.setSize(250,  300);
    shell.open ();
    while (!shell.isDisposed ()) {
        if (!display.readAndDispatch ()) display.sleep ();
    }
    display.dispose ();
}
}

View on GitHub

With Editors Example

Tree With Editors Example

Example demonstrating TreeWithEditorsExample.

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

import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.TreeEditor;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.*;

public class TreeWithEditorsExample {

    public static void main(String[] args) {
        Display display = new Display();
        Shell shell = new Shell(display);
        shell.setText("SWT Tree with Editors");
        shell.setSize(700, 400);
        shell.setLayout(new FillLayout());

        Tree tree = new Tree(shell, SWT.BORDER | SWT.FULL_SELECTION);
        tree.setHeaderVisible(true);
        tree.setLinesVisible(true);

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

        TreeItem parent1 = new TreeItem(tree, SWT.NONE);
        createItem(parent1, "P 1", "Category", "N/A", true);

        TreeItem parent2 = new TreeItem(tree, SWT.NONE);
        createItem(parent2, "P 2", "Category", "N/A", false);

        TreeItem child1 = new TreeItem(parent1, SWT.NONE);
        createItem(child1, "C 1.1", "Text", "Editable", true);

        TreeItem child2 = new TreeItem(parent1, SWT.NONE);
        createItem(child2, "C 1.2", "Combo", "Option 1", false);

        TreeItem child3 = new TreeItem(parent2, SWT.NONE);
        createItem(child3, "C 2.1", "Text", "Editable", true);

        parent1.setExpanded(true);
        parent2.setExpanded(true);

        TreeEditor editor = new TreeEditor(tree);
        editor.horizontalAlignment = SWT.CENTER;
        editor.grabHorizontal = false;

        tree.addListener(SWT.MouseDoubleClick, event -> {
            Point point = new Point(event.x, event.y);
            TreeItem item = tree.getItem(point);
            if (item == null) return;

            for (int i = 0; i < tree.getColumnCount(); i++) {
                if (item.getBounds(i).contains(point)) {

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

                    // Name y Value → Text
                    if (i == 0 || i == 2) {
                        Text text = new Text(tree, SWT.NONE);
                        text.setText(item.getText(i));
                        text.selectAll();
                        text.setFocus();

                        int columnIndex = i;

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

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

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

                    // Type → Combo
                    else if (i == 1) {
                        Combo combo = new Combo(tree, SWT.READ_ONLY);
                        combo.setItems("Text", "Combo", "Category");
                        combo.setText(item.getText(i));
                        combo.setFocus();

                        int columnIndex = i;

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

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

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

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

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

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

                        check.setFocus();

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

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

                        editor.setEditor(check, item, i);
                    }

                    break;
                }
            }
        });

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

    private static void createItem(TreeItem item, String name, String type, String value, boolean enabled) {
        item.setText(new String[]{
                name,
                type,
                value,
                enabled ? "Yes" : "No"
        });
        item.setData("enabled", enabled);
    }
}

View on GitHub

With J Face Tree Viewer Example

Tree With J Face Tree Viewer Example

Example demonstrating TreeWithJFaceTreeViewerExample.

TreeWithJFaceTreeViewerExample.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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
package dev.equo;

import dev.equo.swt.Config;
import org.eclipse.jface.viewers.*;
import org.eclipse.jface.window.ApplicationWindow;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.*;

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

public class TreeWithJFaceTreeViewerExample extends ApplicationWindow {

    public TreeWithJFaceTreeViewerExample() {
        super(null);
    }

    @Override
    protected Control createContents(Composite parent) {
        TreeViewer treeViewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
        treeViewer.setContentProvider(new ViewContentProvider());
        treeViewer.setLabelProvider(new ViewLabelProvider());
        treeViewer.setInput(createModel());

        treeViewer.addSelectionChangedListener(new ISelectionChangedListener() {
            public void selectionChanged(SelectionChangedEvent event) {
                IStructuredSelection selection = (IStructuredSelection) event.getSelection();
                Object selectedNode = selection.getFirstElement();

                if (selectedNode instanceof TreeNode) {
                    TreeNode node = (TreeNode) selectedNode;
                    if (!node.hasChildren()) { // It's a leaf
                        System.out.println("Leaf node clicked: " + node.getName());
                    }
                }
            }
        });

        return treeViewer.getControl();
    }

    private List<TreeNode> createModel() {
        List<TreeNode> roots = new ArrayList<>();

        // Three-level tree
        TreeNode root1 = new TreeNode("Root 1 (3 Levels)");
        TreeNode child1_1 = new TreeNode("Child 1.1");
        TreeNode leaf1_1_1 = new TreeNode("Leaf 1.1.1");
        TreeNode leaf1_1_2 = new TreeNode("Leaf 1.1.2");
        TreeNode leaf1_1_3 = new TreeNode("Leaf 1.1.3");
        TreeNode leaf1_1_4 = new TreeNode("Leaf 1.1.4");
        child1_1.addChild(leaf1_1_1);
        child1_1.addChild(leaf1_1_2);
        child1_1.addChild(leaf1_1_3);
        child1_1.addChild(leaf1_1_4);
        root1.addChild(child1_1);
        roots.add(root1);

        // Four-level tree
        TreeNode root2 = new TreeNode("Root 2 (4 Levels)");
        TreeNode child2_1 = new TreeNode("Child 2.1");
        TreeNode child2_1_1 = new TreeNode("Child 2.1.1");
        TreeNode leaf2_1_1_1 = new TreeNode("Leaf 2.1.1.1");
        child2_1_1.addChild(leaf2_1_1_1);
        child2_1.addChild(child2_1_1);
        root2.addChild(child2_1);
        roots.add(root2);

        // Another three-level tree for variety
        TreeNode root3 = new TreeNode("Root 3 (3 Levels)");
        TreeNode child3_1 = new TreeNode("Child 3.1");
        TreeNode leaf3_1_1 = new TreeNode("Leaf 3.1.1");
        child3_1.addChild(leaf3_1_1);
        root3.addChild(child3_1);
        roots.add(root3);


        return roots;
    }

    public static void main(String[] args) {
        Config.useEquo(Tree.class);
        Config.useEquo(TreeItem.class);
        Config.useEquo(TreeColumn.class);
        TreeWithJFaceTreeViewerExample window = new TreeWithJFaceTreeViewerExample();
        window.setBlockOnOpen(true);
        window.open();
        Display.getCurrent().dispose();
    }

    @Override
    protected void configureShell(Shell shell) {
        super.configureShell(shell);
        shell.setText("Tree with JFace TreeViewer Example");
        shell.setSize(400, 300);
    }

    public static class ViewLabelProvider extends LabelProvider {

        @Override
        public String getText(Object element) {
            if (element instanceof TreeNode) {
                return ((TreeNode) element).getName();
            }
            return super.getText(element);
        }
    }

    public static class ViewContentProvider implements ITreeContentProvider {

        @Override
        public Object[] getElements(Object inputElement) {
            if (inputElement instanceof List) {
                return ((List<?>) inputElement).toArray();
            }
            return new Object[0];
        }

        @Override
        public Object[] getChildren(Object parentElement) {
            if (parentElement instanceof TreeNode) {
                return ((TreeNode) parentElement).getChildren().toArray();
            }
            return new Object[0];
        }

        @Override
        public Object getParent(Object element) {
            if (element instanceof TreeNode) {
                return ((TreeNode) element).getParent();
            }
            return null;
        }

        @Override
        public boolean hasChildren(Object element) {
            if (element instanceof TreeNode) {
                return ((TreeNode) element).hasChildren();
            }
            return false;
        }

        @Override
        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
            // Not used in this example
        }

        @Override
        public void dispose() {
            // Not used in this example
        }
    }

    public static class TreeNode {
        private String name;
        private List<TreeNode> children = new ArrayList<>();
        private TreeNode parent;

        public TreeNode(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void addChild(TreeNode child) {
            children.add(child);
            child.setParent(this);
        }

        public List<TreeNode> getChildren() {
            return children;
        }

        public TreeNode getParent() {
            return parent;
        }

        public void setParent(TreeNode parent) {
            this.parent = parent;
        }

        public boolean hasChildren() {
            return !children.isEmpty();
        }

        @Override
        public String toString() {
            return getName();
        }
    }
}

View on GitHub