org.eclipse.swt.custom.TableTreeItem Maven / Gradle / Ivy
/*******************************************************************************
* Copyright (c) 2000, 2008, 2012 IBM Corporation, Gerhardt Informatics Kft. and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
* Gerhardt Informatics Kft. - GEFGWT port
*******************************************************************************/
package org.eclipse.swt.custom;
import org.eclipse.swt.SWT;
import org.eclipse.swt.SWTException;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Widget;
/**
* A TableTreeItem is a selectable user interface object that represents an item
* in a hierarchy of items in a TableTree.
*
* @deprecated As of 3.1 use Tree, TreeItem and TreeColumn
*/
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;
Color background;
Color foreground;
Font font;
boolean expanded;
boolean checked;
boolean grayed;
/**
* Constructs a new instance of this class given its parent (which must be a
* TableTree) and a style value describing its behavior and
* appearance. The item is added to the end of the items maintained by its
* parent.
*
* The style value is either one of the style constants defined in class
* SWT which is applicable to instances of this class, or must
* be built by bitwise OR'ing together (that is, using the
* int "|" operator) two or more of those SWT
* style constants. The class description lists the style constants that are
* applicable to the class. Style bits are also inherited from superclasses.
*
*
* @param parent
* a composite control which will be the parent of the new
* instance (cannot be null)
* @param style
* the style of control to construct
*
* @exception IllegalArgumentException
*
* - ERROR_NULL_ARGUMENT - if the parent is null
*
* @exception SWTException
*
* - ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the parent
*
*
* @see SWT
* @see Widget#getStyle()
*/
public TableTreeItem(TableTree parent, int style) {
this(parent, style, parent.getItemCount());
}
/**
* Constructs a new instance of this class given its parent (which must be a
* TableTree, a style value describing its behavior and
* appearance, and the index at which to place it in the items maintained by
* its parent.
*
* The style value is either one of the style constants defined in class
* SWT which is applicable to instances of this class, or must
* be built by bitwise OR'ing together (that is, using the
* int "|" operator) two or more of those SWT
* style constants. The class description lists the style constants that are
* applicable to the class. Style bits are also inherited from superclasses.
*
*
* @param parent
* a composite control which will be the parent of the new
* instance (cannot be null)
* @param style
* the style of control to construct
* @param index
* the index to store the receiver in its parent
*
* @exception IllegalArgumentException
*
* - ERROR_NULL_ARGUMENT - if the parent is null
*
* @exception SWTException
*
* - ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the parent
*
*
* @see SWT
* @see Widget#getStyle()
*/
public TableTreeItem(TableTree parent, int style, int index) {
this(parent, null, style, index);
}
/**
* Constructs a new instance of this class given its parent (which must be a
* TableTreeItem) and a style value describing its behavior and
* appearance. The item is added to the end of the items maintained by its
* parent.
*
* The style value is either one of the style constants defined in class
* SWT which is applicable to instances of this class, or must
* be built by bitwise OR'ing together (that is, using the
* int "|" operator) two or more of those SWT
* style constants. The class description lists the style constants that are
* applicable to the class. Style bits are also inherited from superclasses.
*
*
* @param parent
* a composite control which will be the parent of the new
* instance (cannot be null)
* @param style
* the style of control to construct
*
* @exception IllegalArgumentException
*
* - ERROR_NULL_ARGUMENT - if the parent is null
*
* @exception SWTException
*
* - ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the parent
*
*
* @see SWT
* @see Widget#getStyle()
*/
public TableTreeItem(TableTreeItem parent, int style) {
this(parent, style, parent.getItemCount());
}
/**
* Constructs a new instance of this class given its parent (which must be a
* TableTreeItem), a style value describing its behavior and
* appearance, and the index at which to place it in the items maintained by
* its parent.
*
* The style value is either one of the style constants defined in class
* SWT which is applicable to instances of this class, or must
* be built by bitwise OR'ing together (that is, using the
* int "|" operator) two or more of those SWT
* style constants. The class description lists the style constants that are
* applicable to the class. Style bits are also inherited from superclasses.
*
*
* @param parent
* a composite control which will be the parent of the new
* instance (cannot be null)
* @param style
* the style of control to construct
* @param index
* the index to store the receiver in its parent
*
* @exception IllegalArgumentException
*
* - ERROR_NULL_ARGUMENT - if the parent is null
*
* @exception SWTException
*
* - ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the parent
*
*
* @see SWT
* @see Widget#getStyle()
*/
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(TableTree.ITEMID, 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(parent.getDisplay(), 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);
tableItem.setGrayed(grayed);
}
void addItem(TableTreeItem item, int index) {
if (item == null)
SWT.error(SWT.ERROR_NULL_ARGUMENT);
if (index < 0 || index > items.length)
SWT.error(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);
}
/**
* Returns the receiver's background color.
*
* @return the background color
*
* @exception SWTException
*
* - ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver
*
*
* @since 2.0
*
*/
public Color getBackground() {
checkWidget();
return (background == null) ? parent.getBackground() : background;
}
/**
* Returns a rectangle describing the receiver's size and location relative
* to its parent.
*
* @return the receiver's bounding rectangle
*
* @exception SWTException
*
* - ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver
*
*/
public Rectangle getBounds(int index) {
checkWidget();
if (tableItem != null) {
return tableItem.getBounds(index);
} else {
return new Rectangle(0, 0, 0, 0);
}
}
/**
* Returns true if the receiver is checked, and false
* otherwise. When the parent does not have the
* CHECK style, return false.
*
* @return the checked state of the checkbox
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed
- ERROR_THREAD_INVALID_ACCESS - if not
* called from the thread that created the receiver
*
*/
public boolean getChecked() {
checkWidget();
if (tableItem == null)
return checked;
return tableItem.getChecked();
}
/**
* Returns true if the receiver is grayed, and false otherwise.
* When the parent does not have the CHECK style, return false.
*
* @return the grayed state of the checkbox
*
* @exception SWTException
*
* - ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver
*
*
* @since 2.1
*/
public boolean getGrayed() {
checkWidget();
if (tableItem == null)
return grayed;
return tableItem.getGrayed();
}
/**
* Returns true if the receiver is expanded, and false
* otherwise.
*
*
* @return the expanded state
*/
public boolean getExpanded() {
// checkWidget();
return expanded;
}
/**
* Returns the font that the receiver will use to paint textual information
* for this item.
*
* @return the receiver's font
*
* @exception SWTException
*
* - ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver
*
*
* @since 3.0
*/
public Font getFont() {
checkWidget();
return (font == null) ? parent.getFont() : font;
}
/**
* Returns the foreground color that the receiver will use to draw.
*
* @return the receiver's foreground color
*
* @exception SWTException
*
* - ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver
*
*
* @since 2.0
*
*/
public Color getForeground() {
checkWidget();
return (foreground == null) ? parent.getForeground() : foreground;
}
/**
* 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
*
* @exception SWTException
*
* - ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed
- ERROR_THREAD_INVALID_ACCESS - if not
* called from the thread that created the receiver
*
*/
public Image getImage() {
checkWidget();
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) {
// checkWidget();
if (0 < index && index < images.length)
return images[index];
return null;
}
int getIndent() {
if (parentItem == null)
return 0;
return parentItem.getIndent() + 1;
}
/**
* Returns the item at the given, zero-relative index in the receiver.
* Throws an exception if the index is out of range.
*
* @param index
* the index of the item to return
* @return the item at the given index
*
* @exception IllegalArgumentException
*
* - ERROR_INVALID_RANGE - if the index is not between 0
* and the number of elements in the list minus 1 (inclusive)
*
*
* @exception SWTException
*
* - ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver
*
*
* @since 3.1
*/
public TableTreeItem getItem(int index) {
checkWidget();
int count = items.length;
if (!(0 <= index && index < count))
SWT.error(SWT.ERROR_INVALID_RANGE);
return items[index];
}
/**
* Returns the number of items contained in the receiver that are direct
* item children of the receiver.
*
* @return the number of items
*/
public int getItemCount() {
// checkWidget();
return items.length;
}
/**
* Returns an array of TableTreeItems which are the direct item
* children of the receiver.
*
* Note: This is not the actual structure used by the receiver to maintain
* its list of items, so modifying the array will not affect the receiver.
*
*
* @return the receiver's items
*/
public TableTreeItem[] getItems() {
// checkWidget();
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;
}
/**
* Returns the receiver's parent, which must be a TableTree.
*
* @return the receiver's parent
*/
public TableTree getParent() {
// checkWidget();
return parent;
}
/**
* Returns the receiver's parent item, which must be a
* TableTreeItem or null when the receiver is a root.
*
* @return the receiver's parent item
*/
public TableTreeItem getParentItem() {
// checkWidget();
return parentItem;
}
public String getText() {
checkWidget();
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) {
// checkWidget();
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) {
// checkWidget();
for (int i = 0; i < items.length; i++) {
if (items[i] == item)
return i;
}
return -1;
}
void expandAll(boolean notify) {
if (items.length == 0)
return;
if (!expanded) {
setExpanded(true);
if (notify) {
Event event = new Event();
event.item = this;
parent.notifyListeners(SWT.Expand, event);
}
}
for (int i = 0; i < items.length; i++) {
items[i].expandAll(notify);
}
}
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() {
if (isDisposed())
return;
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;
foreground = null;
background = null;
font = 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 receiver's background color to the color specified by the
* argument, or to the default system color for the item if the argument is
* null.
*
* @param color
* the new color (or null)
*
* @exception IllegalArgumentException
*
* - ERROR_INVALID_ARGUMENT - if the argument has been
* disposed
*
* @exception SWTException
*
* - ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver
*
*
* @since 2.0
*
*/
public void setBackground(Color color) {
checkWidget();
if (color != null && color.isDisposed()) {
SWT.error(SWT.ERROR_INVALID_ARGUMENT);
}
if (tableItem != null) {
tableItem.setBackground(color);
}
background = color;
}
/**
* Sets the checked state of the checkbox for this item. This state change
* only applies if the Table was created with the SWT.CHECK style.
*
* @param checked
* the new checked state of the checkbox
*
* @exception SWTException
*
* - ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver
*
*/
public void setChecked(boolean checked) {
checkWidget();
Table table = parent.getTable();
if ((table.getStyle() & SWT.CHECK) == 0)
return;
if (tableItem != null) {
tableItem.setChecked(checked);
}
this.checked = checked;
}
/**
* Sets the grayed state of the checkbox for this item. This state change
* only applies if the Table was created with the SWT.CHECK style.
*
* @param grayed
* the new grayed state of the checkbox;
*
* @exception SWTException
*
* - ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver
*
*
* @since 2.1
*/
public void setGrayed(boolean grayed) {
checkWidget();
Table table = parent.getTable();
if ((table.getStyle() & SWT.CHECK) == 0)
return;
if (tableItem != null) {
tableItem.setGrayed(grayed);
}
this.grayed = grayed;
}
/**
* Sets the expanded state.
*
*
* @param expanded
* the new expanded state.
*
* @exception SWTException
*
* - ERROR_THREAD_INVALID_ACCESS when called from the wrong
* thread
- ERROR_WIDGET_DISPOSED when the widget has
* been disposed
*
*/
public void setExpanded(boolean expanded) {
checkWidget();
if (items.length == 0)
return;
if (this.expanded == expanded)
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 font that the receiver will use to paint textual information for
* this item to the font specified by the argument, or to the default font
* for that kind of control if the argument is null.
*
* @param font
* the new font (or null)
*
* @exception IllegalArgumentException
*
* - ERROR_INVALID_ARGUMENT - if the argument has been
* disposed
*
* @exception SWTException
*
* - ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver
*
*
* @since 3.0
*/
public void setFont(Font font) {
checkWidget();
if (font != null && font.isDisposed()) {
SWT.error(SWT.ERROR_INVALID_ARGUMENT);
}
if (tableItem != null) {
tableItem.setFont(font);
}
this.font = font;
}
/**
* Sets the receiver's foreground color to the color specified by the
* argument, or to the default system color for the item if the argument is
* null.
*
* @param color
* the new color (or null)
*
* @since 2.0
*
* @exception IllegalArgumentException
*
* - ERROR_INVALID_ARGUMENT - if the argument has been
* disposed
*
* @exception SWTException
*
* - ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed
* - ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver
*
*
* @since 2.0
*
*/
public void setForeground(Color color) {
checkWidget();
if (color != null && color.isDisposed()) {
SWT.error(SWT.ERROR_INVALID_ARGUMENT);
}
if (tableItem != null) {
tableItem.setForeground(color);
}
foreground = color;
}
/**
* 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 SWTException
*
* - ERROR_THREAD_INVALID_ACCESS when called from the wrong
* thread
- ERROR_WIDGET_DISPOSED when the widget has
* been disposed
*
*/
public void setImage(int index, Image image) {
checkWidget();
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
*
* @exception SWTException
*
* - ERROR_THREAD_INVALID_ACCESS when called from the wrong
* thread
- ERROR_WIDGET_DISPOSED when the widget has
* been disposed
*
*/
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 IllegalArgumentException
*
* - ERROR_NULL_ARGUMENT - if the text is null
*
* @exception SWTException
*
* - ERROR_THREAD_INVALID_ACCESS when called from the wrong
* thread
- ERROR_WIDGET_DISPOSED when the widget has
* been disposed
*
*/
public void setText(int index, String text) {
checkWidget();
if (text == null)
SWT.error(SWT.ERROR_NULL_ARGUMENT);
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);
}
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(TableTree.ITEMID, this);
tableItem.setImageIndent(getIndent());
if (background != null)
tableItem.setBackground(background);
if (foreground != null)
tableItem.setForeground(foreground);
if (font != null)
tableItem.setFont(font);
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;
}
}
}