org.eclipse.swt.custom.TableTreeItem Maven / Gradle / Ivy
Show all versions of org.eclipse.swt.win32.win32.x86 Show documentation
/*******************************************************************************
* Copyright (c) 2000, 2011 IBM Corporation 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
*******************************************************************************/
package org.eclipse.swt.custom;
import org.eclipse.swt.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.widgets.*;
/**
* 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;
}
}
}