Appendix A: TableTree and TableTreeItem

This appendix contains the source code for the TableTree and TableTreeItem classes.

TableTree

package org.eclipse.swt.custom;

* (c) Copyright IBM Corp. 2000, 2001.

import java.util.Enumeration;

import java.util.Vector;

import org.eclipse.swt.*;

import org.eclipse.swt.events.*;

import org.eclipse.swt.graphics.*;

import org.eclipse.swt.widgets.*;

/**

* A TableTree is a selectable user interface object

* that displays a hierarchy of items, and issues

* notification when an item is selected.

* A TableTree may be single or multi select.

*

* The item children that may be added to instances of this class

* must be of type <code>TableTreeItem</code>.

*

* Note that although this class is a subclass of <code>Composite</code>,

* it does not make sense to add <code>Control</code> children to it,

* or set a layout on it.

*

* <dl>

* <dt>Styles: <dd> SINGLE, MULTI, CHECK, FULL_SELECTION

* <dt>Events: <dd> Selection, DefaultSelection, Collapse, Expand

* </dl>

public class TableTree extends Composite {

Table table;

TableTreeItem[] items = EMPTY_ITEMS;

Image plusImage, minusImage, sizeImage;

* TableTreeItems are not treated as children but rather as items.

* When the TableTree is disposed, all children are disposed because

* TableTree inherits this behaviour from Composite. The items

* must be disposed separately. Because TableTree is not part of

* the org.eclipse.swt.widgets package, the method releaseWidget can

* not be overriden (this is how items are disposed of in Table and Tree).

* Instead, the items are disposed of in response to the dispose event on the

* TableTree. The "inDispose" flag is used to distinguish between disposing

* one TableTreeItem (e.g. when removing an entry from the TableTree) and

* disposing the entire TableTree.

boolean inDispose = false;

static final TableTreeItem[] EMPTY_ITEMS = new TableTreeItem [0];

static final String[] EMPTY_TEXTS = new String [0];

static final Image[] EMPTY_IMAGES = new Image [0];

/**

* Creates a new instance of the widget.

* @param parent a composite widget

* @param style the bitwise OR'ing of widget styles

public TableTree(Composite parent, int style) {

super(parent, SWT.NONE);

table = new Table(this, style);

setBackground(table.getBackground());

setForeground(table.getForeground());

setFont(table.getFont());

table.addListener(SWT.MouseDown, new Listener() {

public void handleEvent(Event e) {

onMouseDown(e);

}

});

table.addListener(SWT.Selection, new Listener() {

public void handleEvent(Event e) {

onSelection(e);

}

});

table.addListener(SWT.DefaultSelection, new Listener() {

public void handleEvent(Event e) {

onSelection(e);

}

});

addListener(SWT.Dispose, new Listener() {

public void handleEvent(Event e) {

onDispose();

}

});

addListener(SWT.Resize, new Listener() {

public void handleEvent(Event e) {

onResize();

}

});

addListener(SWT.FocusIn, new Listener() {

public void handleEvent(Event e) {

onFocusIn();

}

});

}

int addItem(TableTreeItem item, int index) {

if (index < 0 || index > items.length) throw new SWTError(SWT.ERROR_INVALID_ARGUMENT);

TableTreeItem[] newItems = new TableTreeItem[items.length + 1];

System.arraycopy(items, 0, newItems, 0, index);

newItems[index] = item;

System.arraycopy(items, index, newItems, index + 1, items.length - index);

items = newItems;

/* Return the index in the table where this table should be inserted */

if (index == items.length - 1 )

return table.getItemCount();

else

return table.indexOf(items[index+1].tableItem);

}

/**

* Adds the listener to receive selection events.

*

* @param listener the selection listener

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed

* <li>ERROR_NULL_ARGUMENT when listener is null

* </ul>

public void addSelectionListener(SelectionListener listener) {

if (listener == null) throw new SWTError (SWT.ERROR_NULL_ARGUMENT);

TypedListener typedListener = new TypedListener (listener);

addListener (SWT.Selection,typedListener);

addListener (SWT.DefaultSelection,typedListener);

}

/**

* Adds the listener to receive tree events.

*

* @param listener the tree listener

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed

* <li>ERROR_NULL_ARGUMENT when listener is null

* </ul>

public void addTreeListener(TreeListener listener) {

if (listener == null) throw new SWTError (SWT.ERROR_NULL_ARGUMENT);

TypedListener typedListener = new TypedListener (listener);

addListener (SWT.Expand, typedListener);

addListener (SWT.Collapse, typedListener);

}

/**

* Computes the preferred size of the widget.

*

* Calculate the preferred size of the widget based

* on the current contents. The hint arguments allow

* a specific client area width and/or height to be

* requested. The hints may be honored depending on

* the platform and the layout.

* @param wHint the width hint (can be SWT.DEFAULT)

* @param hHint the height hint (can be SWT.DEFAULT)

* @return a point containing the preferred size of the widget including trim

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>

* </ul>

public Point computeSize (int wHint, int hHint) {

return table.computeSize (wHint, hHint, true);

}

/**

* Computes the widget trim.

*

* Trim is widget specific and may include scroll

* bars and menu bar in addition to other trimmings

* that are outside of the widget's client area.

* @param x the x location of the client area

* @param y the y location of the client area

* @param width the width of the client area

* @param height the height of the client area

* @return a rectangle containing the trim of the widget.

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>

* </ul>

public Rectangle computeTrim (int x, int y, int width, int height) {

return table.computeTrim(x, y, width, height);

}

/**

* Deselects all items.

*

* If an item is selected, it is deselected.

* If an item is not selected, it remains unselected.

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed

* </ul>

public void deselectAll () {

table.deselectAll();

}

/* Expand upward from the specified leaf item. */

void expandItem (TableTreeItem item) {

if (item == null || item.getExpanded()) return;

expandItem(item.parentItem);

item.setExpanded(true);

Event event = new Event();

event.item = item;

notifyListeners(SWT.Expand, event);

}

/**

* Gets the number of items.

*

* @return the number of items in the widget

public int getItemCount () {

return items.length;

}

/**

* Gets the height of one item.

*

* This operation will fail if the height of

* one item could not be queried from the OS.

* @return the height of one item in the widget

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed

* <li>ERROR_CANNOT_GET_ITEM_HEIGHT when the operation fails

* </ul>

public int getItemHeight () {

return table.getItemHeight();

}

/**

* Gets the items.

*

* @return the items in the widget

public TableTreeItem [] getItems () {

TableTreeItem[] newItems = new TableTreeItem[items.length];

System.arraycopy(items, 0, newItems, 0, items.length);

return newItems;

}

/**

* Gets the selected items.

*

* This operation will fail if the selected

* items cannot be queried from the OS.

* @return the selected items in the widget

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>

* <li>ERROR_CANNOT_GET_SELECTION when the operation fails</li>

* </ul>

public TableTreeItem [] getSelection () {

TableItem[] selection = table.getSelection();

TableTreeItem [] result = new TableTreeItem[selection.length];

for (int i = 0; i < selection.length; i++){

result[i] = (TableTreeItem) selection[i].getData();

}

return result;

}

/**

* Gets the number of selected items.

*

* This operation will fail if the number of selected

* items cannot be queried from the OS.

* @return the number of selected items in the widget

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>

* <li>ERROR_CANNOT_GET_COUNT when the operation fails</li>

* </ul>

public int getSelectionCount () {

return table.getSelectionCount();

}

/**

* Returns the underlying Table control.

* @return the underlying Table control

public Table getTable () {

return table;

}

void createImages () {

int itemHeight = sizeImage.getBounds().height;

// Calculate border around image.

// At least 9 pixels are needed to draw the image

// Leave at least a 6 pixel border.

int indent = Math.min(6, (itemHeight - 9) / 2);

indent = Math.max(0, indent);

int size = Math.max (10, itemHeight - 2 * indent);

size = ((size + 1) / 2) * 2; // size must be an even number

int midpoint = indent + size / 2;

Color foreground = getForeground();

Color plusMinus = getDisplay().getSystemColor(SWT.COLOR_WIDGET_NORMAL_SHADOW);

Color background = getBackground();

/* Plus image */

PaletteData palette = new PaletteData(new RGB[]{foreground.getRGB(), background.getRGB(), plusMinus.getRGB()});

ImageData imageData = new ImageData(itemHeight, itemHeight, 4, palette);

imageData.transparentPixel = 1;

plusImage = new Image(getDisplay(), imageData);

GC gc = new GC(plusImage);

gc.setBackground(background);

gc.fillRectangle(0, 0, itemHeight, itemHeight);

gc.setForeground(plusMinus);

gc.drawRectangle(indent, indent, size, size);

gc.setForeground(foreground);

gc.drawLine(midpoint, indent + 2, midpoint, indent + size - 2);

gc.drawLine(indent + 2, midpoint, indent + size - 2, midpoint);

gc.dispose();

/* Minus image */

palette = new PaletteData(new RGB[]{foreground.getRGB(), background.getRGB(), plusMinus.getRGB()});

imageData = new ImageData(itemHeight, itemHeight, 4, palette);

imageData.transparentPixel = 1;

minusImage = new Image(getDisplay(), imageData);

gc = new GC(minusImage);

gc.setBackground(background);

gc.fillRectangle(0, 0, itemHeight, itemHeight);

gc.setForeground(plusMinus);

gc.drawRectangle(indent, indent, size, size);

gc.setForeground(foreground);

gc.drawLine(indent + 2, midpoint, indent + size - 2, midpoint);

gc.dispose();

}

Image getPlusImage() {

if (plusImage == null) createImages();

return plusImage;

}

Image getMinusImage() {

if (minusImage == null) createImages();

return minusImage;

}

/**

* Gets the index of an item.

* The widget is searched starting at 0 until an

* item is found that is equal to the search item.

* If no item is found, -1 is returned. Indexing

* is zero based. This index is relative to the parent only.

* @param item the search item

* @return the index of the item or -1

public int indexOf (TableTreeItem item) {

for (int i = 0; i < items.length; i++) {

if (item == items[i]) return i;

}

return -1;

}

void onDispose() {

inDispose = true;

for (int i = 0; i < items.length; i++) {

items[i].dispose();

}

inDispose = false;

if (plusImage != null) plusImage.dispose();

if (minusImage != null) minusImage.dispose();

if (sizeImage != null) sizeImage.dispose();

plusImage = minusImage = sizeImage = null;

}

void onResize () {

Rectangle area = getClientArea();

table.setBounds(0, 0, area.width, area.height);

}

void onSelection (Event e) {

Event event = new Event();

TableItem tableItem = (TableItem)e.item;

TableTreeItem item = getItem(tableItem);

event.item = item;

if (e.type == SWT.Selection

&& e.detail == SWT.CHECK

&& item != null) {

event.detail = SWT.CHECK;

item.checked = tableItem.getChecked();

}

notifyListeners(e.type, event);

}

public TableTreeItem getItem(Point point) {

TableItem item = table.getItem(point);

if (item == null) return null;

return getItem(item);

}

TableTreeItem getItem(TableItem tableItem) {

if (tableItem == null) return null;

for (int i = 0; i < items.length; i++) {

TableTreeItem item = items[i].getItem(tableItem);

if (item != null) return item;

}

return null;

}

void onFocusIn () {

table.setFocus();

}

void onMouseDown(Event event) {

/* If user clicked on the [+] or [-], expand or collapse the tree. */

TableItem[] items = table.getItems();

for (int i = 0; i < items.length; i++) {

Rectangle rect = items[i].getImageBounds(0);

if (rect.contains(event.x, event.y)) {

TableTreeItem item = (TableTreeItem) items[i].getData();

event = new Event();

event.item = item;

item.setExpanded(!item.getExpanded());

if (item.getExpanded()) {

notifyListeners(SWT.Expand, event);

} else {

notifyListeners(SWT.Collapse, event);

}

return;

}

/**

* Removes all items.

*

* This operation will fail when an item

* could not be removed in the OS.

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed

* <li>ERROR_ITEM_NOT_REMOVED when the operation fails

* </ul>

public void removeAll () {

setRedraw(false);

for (int i = items.length - 1; i >= 0; i--) {

items[i].dispose();

}

items = EMPTY_ITEMS;

setRedraw(true);

}

void removeItem(TableTreeItem item) {

int index = 0;

while (index < items.length && items[index] != item) index++;

if (index == items.length) return;

TableTreeItem[] newItems = new TableTreeItem[items.length - 1];

System.arraycopy(items, 0, newItems, 0, index);

System.arraycopy(items, index + 1, newItems, index, items.length - index - 1);

items = newItems;

}

/**

* Removes the listener.

*

* @param listener the listener

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed

* <li>ERROR_NULL_ARGUMENT when listener is null

* </ul>

public void removeSelectionListener (SelectionListener listener) {

if (listener == null) throw new SWTError (SWT.ERROR_NULL_ARGUMENT);

removeListener(SWT.Selection, listener);

removeListener(SWT.DefaultSelection, listener);

}

/**

* Removes the listener.

* @param listener the listener

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed

* <li>ERROR_NULL_ARGUMENT when listener is null

* </ul>

public void removeTreeListener (TreeListener listener) {

if (listener == null) throw new SWTError (SWT.ERROR_NULL_ARGUMENT);

removeListener(SWT.Expand, listener);

removeListener(SWT.Collapse, listener);

}

/**

* Selects all items.

*

* If an item is not selected, it is selected.

* If an item is selected, it remains selected.

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed

* </ul>

public void selectAll () {

table.selectAll();

}

/**

* Sets the widget background color.

*

* When new color is null, the background reverts

* to the default system color for the widget.

* @param color the new color (or null)

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>

* </ul>

public void setBackground (Color color) {

super.setBackground(color);

table.setBackground(color);

if (sizeImage != null) {

GC gc = new GC (sizeImage);

gc.setBackground(getBackground());

Rectangle size = sizeImage.getBounds();

gc.fillRectangle(size);

gc.dispose();

}

/**

* Sets the enabled state.

*

* A disabled widget is typically not selectable from

* the user interface and draws with an inactive or

* grayed look.

* @param enabled the new enabled state

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>

* </ul>

public void setEnabled (boolean enabled) {

super.setEnabled(enabled);

table.setEnabled(enabled);

}

/**

* Sets the widget font.

*

* When new font is null, the font reverts

* to the default system font for the widget.

* @param font the new font (or null)

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>

* </ul>

public void setFont (Font font) {

super.setFont(font);

table.setFont(font);

}

/**

* Gets the widget foreground color.

*

* @return the widget foreground color

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>

* </ul>

public void setForeground (Color color) {

super.setForeground(color);

table.setForeground(color);

}

/**

* Sets the pop up menu.

*

* Every control has an optional pop up menu that is

* displayed when the user requests a popup menu for

* the control. The sequence of key strokes/button

* presses/button releases that is used to request

* a pop up menu is platform specific.

* @param menu the new pop up menu

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>

* <li>ERROR_MENU_NOT_POP_UP when the menu is not a POP_UP</li>

* <li>ERROR_NO_COMMON_PARENT when the menu is not in the same widget tree</li>

* </ul>

public void setMenu (Menu menu) {

super.setMenu(menu);

table.setMenu(menu);

}

/**

* Sets the selection.

*

* @param items new selection

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed

* <li>ERROR_NULL_ARGUMENT when items is null

* </ul>

public void setSelection (TableTreeItem[] items) {

TableItem[] tableItems = new TableItem[items.length];

for (int i = 0; i < items.length; i++) {

if (items[i] == null) throw new SWTError(SWT.ERROR_NULL_ARGUMENT);

if (!items[i].getVisible()) expandItem (items[i]);

tableItems[i] = items[i].tableItem;

}

table.setSelection(tableItems);

}

/**

* Sets the tool tip text.

*

* @param string the new tool tip text (or null)

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>

* </ul>

public void setToolTipText (String string) {

super.setToolTipText(string);

table.setToolTipText(string);

}

/**

* Shows the item.

*

* @param item the item to be shown

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed

* <li>ERROR_NULL_ARGUMENT when item is null

* </ul>

public void showItem (TableTreeItem item) {

if (item == null) throw new SWTError (SWT.ERROR_NULL_ARGUMENT);

if (!item.getVisible()) expandItem (item);

TableItem tableItem = item.tableItem;

table.showItem(tableItem);

}

/**

* Shows the selection.

*

* If there is no selection or the selection

* is already visible, this method does nothing.

* If the selection is scrolled out of view,

* the top index of the widget is changed such

* that selection becomes visible.

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed

* </ul>

public void showSelection () {

table.showSelection();

}

TableTreeItem

package org.eclipse.swt.custom;

* (c) Copyright IBM Corp. 2000, 2001.

import org.eclipse.swt.*;

import org.eclipse.swt.events.*;

import org.eclipse.swt.graphics.*;

import org.eclipse.swt.widgets.*;

/**

* A TableTreeItem is a selectable user interface object

* that represents an item in a heirarchy of items in a

* TableTree.

public class TableTreeItem extends Item {

TableItem tableItem;

TableTree parent;

TableTreeItem parentItem;

TableTreeItem [] items = TableTree.EMPTY_ITEMS;

String[] texts = TableTree.EMPTY_TEXTS;

Image[] images = TableTree.EMPTY_IMAGES;

boolean expanded;

boolean checked;

/**

* Create a new instance of a root item.

* @param parent the TableTree that contains this root item

* @param style the bitwise OR'ing of widget styles

public TableTreeItem(TableTree parent, int style) {

this (parent, style, parent.getItemCount());

}

/**

* Create a new instance of a root item in the position

* indicated by the specified index.

* @param parent the TableTree that contains this root item

* @param style the bitwise OR'ing of widget styles

* @param index specifies the position of this item in the TableTree

* relative to other root items

public TableTreeItem(TableTree parent, int style, int index) {

this (parent, null, style, index);

}

/**

* Create a new instance of a sub item.

* @param parent this item's parent in the hierarchy of TableTree items

* @param style the bitwise OR'ing of widget styles

public TableTreeItem(TableTreeItem parent, int style) {

this (parent, style, parent.getItemCount());

}

/**

* Create a new instance of a sub item in the position

* indicated by the specified index.

* @param parent this item's parent in the hierarchy of TableTree items

* @param style the bitwise OR'ing of widget styles

* @param index specifies the position of this item in the TableTree

* relative to other children of the same parent

public TableTreeItem(TableTreeItem parent, int style, int index) {

this (parent.getParent(), parent, style, index);

}

TableTreeItem(TableTree parent, TableTreeItem parentItem, int style, int index) {

super(parent, style);

this.parent = parent;

this.parentItem = parentItem;

if (parentItem == null) {

/* Root items are visible immediately */

int tableIndex = parent.addItem(this, index);

tableItem = new TableItem(parent.getTable(), style, tableIndex);

tableItem.setData(this);

addCheck();

* Feature in the Table. The table uses the first image that

* is inserted into the table to size the table rows. If the

* user is allowed to insert the first image, this will cause

* the +/- images to be scaled. The fix is to insert a dummy

* image to force the size.

if (parent.sizeImage == null) {

int itemHeight = parent.getItemHeight();

parent.sizeImage = new Image(null, itemHeight, itemHeight);

GC gc = new GC (parent.sizeImage);

gc.setBackground(parent.getBackground());

gc.fillRectangle(0, 0, itemHeight, itemHeight);

gc.dispose();

tableItem.setImage(0, parent.sizeImage);

}

} else {

parentItem.addItem(this, index);

}

void addCheck() {

Table table = parent.getTable();

if ((table.getStyle() & SWT.CHECK) == 0) return;

tableItem.setChecked(checked);

}

void addItem(TableTreeItem item, int index) {

if (item == null) throw new SWTError(SWT.ERROR_NULL_ARGUMENT);

if (index < 0 || index > items.length) throw new SWTError(SWT.ERROR_INVALID_ARGUMENT);

/* Now that item has a sub-node it must indicate that it can be expanded */

if (items.length == 0 && index == 0) {

if (tableItem != null) {

Image image = expanded ? parent.getMinusImage() : parent.getPlusImage();

tableItem.setImage(0, image);

}

/* Put the item in the items list */

TableTreeItem[] newItems = new TableTreeItem[items.length + 1];

System.arraycopy(items, 0, newItems, 0, index);

newItems[index] = item;

System.arraycopy(items, index, newItems, index + 1, items.length - index);

items = newItems;

if (expanded) item.setVisible(true);

}

/**

* Gets the widget bounds at the specified index.

*

* @return the widget bounds at the specified index

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>

* </ul>

public Rectangle getBounds (int index) {

if (tableItem != null) {

return tableItem.getBounds(index);

} else {

return new Rectangle(0, 0, 0, 0);

}

/**

* Gets the checked state.

*

* @return the item checked state.

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>

* </ul>

public boolean getChecked () {

if (tableItem == null) {

return checked;

}

return tableItem.getChecked();

}

/**

* Gets the Display.

*

* This method gets the Display that is associated

* with the widget.

* @return the widget data

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>

* </ul>

public Display getDisplay () {

TableTree parent = this.parent;

if (parent == null) throw new SWTError (SWT.ERROR_WIDGET_DISPOSED);

return parent.getDisplay ();

}

/**

* Gets the expanded state of the widget.

*

* @return a boolean that is the expanded state of the widget

public boolean getExpanded () {

return expanded;

}

/**

* Gets the first image.

*

* The image in column 0 is reserved for the [+] and [-]

* images of the tree, therefore getImage(0) will return null.

* @return the image at index 0

public Image getImage () {

return getImage(0);

}

/**

* Gets the image at the specified index.

*

* Indexing is zero based. The image can be null.

* The image in column 0 is reserved for the [+] and [-]

* images of the tree, therefore getImage(0) will return null.

* Return null if the index is out of range.

* @param index the index of the image

* @return the image at the specified index or null

public Image getImage (int index) {

if (0 < index && index < images.length) return images[index];

return null;

}

int getIndent() {

if (parentItem == null) return 0;

return parentItem.getIndent() + 1;

}

/**

* Gets the number of sub items.

*

* @return the number of sub items

public int getItemCount () {

return items.length;

}

/**

* Gets the sub items.

*

* @return the sub items

public TableTreeItem[] getItems () {

TableTreeItem[] newItems = new TableTreeItem[items.length];

System.arraycopy(items, 0, newItems, 0, items.length);

return newItems;

}

TableTreeItem getItem(TableItem tableItem) {

if (tableItem == null) return null;

if (this.tableItem == tableItem) return this;

for (int i = 0; i < items.length; i++) {

TableTreeItem item = items[i].getItem(tableItem);

if (item != null) return item;

}

return null;

}

/**

* Gets the parent.

*

* @return the parent

public TableTree getParent () {

return parent;

}

/**

* Gets the parent item.

*

* @return the parent item.

public TableTreeItem getParentItem () {

return parentItem;

}

/**

* Gets the first item text.

*

* @return the item text at index 0, which can be null

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>

* <li>ERROR_CANNOT_GET_TEXT when the operation fails</li>

* </ul>

public String getText () {

return getText(0);

}

/**

* Gets the item text at the specified index.

*

* Indexing is zero based.

* This operation will fail when the index is out

* of range or an item could not be queried from

* the OS.

* @param index the index of the item

* @return the item text at the specified index, which can be null

public String getText(int index) {

if (0 <= index && index < texts.length) return texts[index];

return null;

}

boolean getVisible () {

return tableItem != null;

}

/**

* Gets the index of the specified item.

* The widget is searched starting at 0 until an

* item is found that is equal to the search item.

* If no item is found, -1 is returned. Indexing

* is zero based. This index is relative to the parent only.

* @param item the search item

* @return the index of the item or -1 if the item is not found

public int indexOf (TableTreeItem item) {

for (int i = 0; i < items.length; i++) {

if (items[i] == item) return i;

}

return -1;

}

int expandedIndexOf (TableTreeItem item) {

int index = 0;

for (int i = 0; i < items.length; i++) {

if (items[i] == item) return index;

if (items[i].expanded) index += items[i].visibleChildrenCount ();

index++;

}

return -1;

}

int visibleChildrenCount () {

int count = 0;

for (int i = 0; i < items.length; i++) {

if (items[i].getVisible ()) {

count += 1 + items[i].visibleChildrenCount ();

}

return count;

}

public void dispose () {

for (int i = items.length - 1; i >= 0; i--) {

items[i].dispose();

}

super.dispose();

if (!parent.inDispose) {

if (parentItem != null) {

parentItem.removeItem(this);

} else {

parent.removeItem(this);

}

if (tableItem != null) tableItem.dispose();

}

items = null;

parentItem = null;

parent = null;

images = null;

texts = null;

tableItem = null;

}

void removeItem(TableTreeItem item) {

int index = 0;

while (index < items.length && items[index] != item) index++;

if (index == items.length) return;

TableTreeItem[] newItems = new TableTreeItem[items.length - 1];

System.arraycopy(items, 0, newItems, 0, index);

System.arraycopy(items, index + 1, newItems, index, items.length - index - 1);

items = newItems;

if (items.length == 0) {

if (tableItem != null) tableItem.setImage(0, null);

}

/**

* Sets the checked state.

*

* @param checked the new checked state.

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>

* </ul>

public void setChecked (boolean checked) {

if (tableItem != null) {

tableItem.setChecked(checked);

}

this.checked = checked;

}

/**

* Sets the expanded state.

*

* @param expanded the new expanded state.

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>

* </ul>

public void setExpanded (boolean expanded) {

if (items.length == 0) return;

this.expanded = expanded;

if (tableItem == null) return;

parent.setRedraw(false);

for (int i = 0; i < items.length; i++) {

items[i].setVisible(expanded);

}

Image image = expanded ? parent.getMinusImage() : parent.getPlusImage();

tableItem.setImage(0, image);

parent.setRedraw(true);

}

/**

* Sets the image at an index.

*

* The image can be null.

* The image in column 0 is reserved for the [+] and [-]

* images of the tree, therefore do nothing if index is 0.

* @param image the new image or null

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>

* </ul>

public void setImage (int index, Image image) {

int columnCount = Math.max(parent.getTable().getColumnCount(), 1);

if (index <= 0 || index >= columnCount) return;

if (images.length < columnCount) {

Image[] newImages = new Image[columnCount];

System.arraycopy(images, 0, newImages, 0, images.length);

images = newImages;

}

images[index] = image;

if (tableItem != null) tableItem.setImage(index, image);

}

/**

* Sets the first image.

*

* The image can be null.

* The image in column 0 is reserved for the [+] and [-]

* images of the tree, therefore do nothing.

* @param image the new image or null

public void setImage (Image image) {

setImage(0, image);

}

/**

* Sets the widget text.

*

* The widget text for an item is the label of the

* item or the label of the text specified by a column

* number.

* @param index the column number

* @param text the new text

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>

* <li>ERROR_NULL_ARGUMENT when string is null</li>

* </ul>

public void setText(int index, String text) {

int columnCount = Math.max(parent.getTable().getColumnCount(), 1);

if (index < 0 || index >= columnCount) return;

if (texts.length < columnCount) {

String[] newTexts = new String[columnCount];

System.arraycopy(texts, 0, newTexts, 0, texts.length);

texts = newTexts;

}

texts[index] = text;

if (tableItem != null) tableItem.setText(index, text);

}

/**

* Sets the widget text.

*

* The widget text for an item is the label of the

* item or the label of the text specified by a column

* number.

* @param index the column number

* @param text the new text

* @exception SWTError <ul>

* <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>

* <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>

* <li>ERROR_NULL_ARGUMENT when string is null</li>

* </ul>

public void setText (String string) {

setText(0, string);

}

void setVisible (boolean show) {

if (parentItem == null) return; // this is a root and can not be toggled between visible and hidden

if (getVisible() == show) return;

if (show) {

if (!parentItem.getVisible()) return; // parentItem must already be visible

// create underlying table item and set data in table item to stored data

Table table = parent.getTable();

int parentIndex = table.indexOf(parentItem.tableItem);

int index = parentItem.expandedIndexOf(this) + parentIndex + 1;

if (index < 0) return;

tableItem = new TableItem(table, getStyle(), index);

tableItem.setData(this);

tableItem.setImageIndent(getIndent());

addCheck();

// restore fields to item

// ignore any images in the first column

int columnCount = Math.max(table.getColumnCount(), 1);

for (int i = 0; i < columnCount; i++) {

if (i < texts.length && texts[i] != null) setText(i, texts[i]);

if (i < images.length && images[i] != null) setImage(i, images[i]);

}

// display the children and the appropriate [+]/[-] symbol as required

if (items.length != 0) {

if (expanded) {

tableItem.setImage(0, parent.getMinusImage());

for (int i = 0, length = items.length; i < length; i++) {

items[i].setVisible(true);

}

} else {

tableItem.setImage(0, parent.getPlusImage());

}

} else {

for (int i = 0, length = items.length; i < length; i++) {

items[i].setVisible(false);

}

// remove row from table

tableItem.dispose();

tableItem = null;

}