| /******************************************************************************* |
| * Copyright (c) 2000, 2008 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 |
| * Tom Schindl <tom.schindl@bestsolution.at> - bug 153993 |
| *******************************************************************************/ |
| |
| package org.eclipse.jface.viewers; |
| |
| import java.util.List; |
| |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.TableTree; |
| import org.eclipse.swt.custom.TableTreeEditor; |
| import org.eclipse.swt.custom.TableTreeItem; |
| import org.eclipse.swt.events.FocusAdapter; |
| import org.eclipse.swt.events.FocusEvent; |
| import org.eclipse.swt.events.FocusListener; |
| import org.eclipse.swt.events.MouseAdapter; |
| import org.eclipse.swt.events.MouseEvent; |
| import org.eclipse.swt.events.MouseListener; |
| import org.eclipse.swt.events.TreeListener; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Item; |
| import org.eclipse.swt.widgets.Widget; |
| |
| /** |
| * A concrete viewer based on a SWT <code>TableTree</code> control. |
| * <p> |
| * This class is not intended to be subclassed outside the viewer framework. It |
| * is designed to be instantiated with a pre-existing SWT table tree control and |
| * configured with a domain-specific content provider, label provider, element |
| * filter (optional), and element sorter (optional). |
| * </p> |
| * <p> |
| * Content providers for table tree viewers must implement the |
| * <code>ITreeContentProvider</code> interface. |
| * </p> |
| * <p> |
| * Label providers for table tree viewers must implement either the |
| * <code>ITableLabelProvider</code> or the <code>ILabelProvider</code> |
| * interface (see <code>TableTreeViewer.setLabelProvider</code> for more |
| * details). |
| * </p> |
| * |
| * @deprecated As of 3.1 use {@link TreeViewer} instead |
| * @noextend This class is not intended to be subclassed by clients. |
| */ |
| public class TableTreeViewer extends AbstractTreeViewer { |
| /** |
| * Internal table viewer implementation. |
| */ |
| private TableTreeEditorImpl tableEditorImpl; |
| |
| /** |
| * This viewer's table tree control. |
| */ |
| private TableTree tableTree; |
| |
| /** |
| * This viewer's table tree editor. |
| */ |
| private TableTreeEditor tableTreeEditor; |
| |
| /** |
| * Copied from original TableEditorImpl and moved here since refactoring |
| * completely wiped out the original implementation in 3.3 |
| * |
| * @since 3.1 |
| */ |
| class TableTreeEditorImpl { |
| |
| private CellEditor cellEditor; |
| |
| private CellEditor[] cellEditors; |
| |
| private ICellModifier cellModifier; |
| |
| private String[] columnProperties; |
| |
| private Item tableItem; |
| |
| private int columnNumber; |
| |
| private ICellEditorListener cellEditorListener; |
| |
| private FocusListener focusListener; |
| |
| private MouseListener mouseListener; |
| |
| private int doubleClickExpirationTime; |
| |
| private ColumnViewer viewer; |
| |
| private TableTreeEditorImpl(ColumnViewer viewer) { |
| this.viewer = viewer; |
| initCellEditorListener(); |
| } |
| |
| /** |
| * Returns this <code>TableViewerImpl</code> viewer |
| * |
| * @return the viewer |
| */ |
| public ColumnViewer getViewer() { |
| return viewer; |
| } |
| |
| private void activateCellEditor() { |
| if( cellEditors != null ) { |
| if( cellEditors[columnNumber] != null && cellModifier != null ) { |
| Object element = tableItem.getData(); |
| String property = columnProperties[columnNumber]; |
| |
| if( cellModifier.canModify(element, property) ) { |
| cellEditor = cellEditors[columnNumber]; |
| |
| cellEditor.addListener(cellEditorListener); |
| |
| Object value = cellModifier.getValue(element, property); |
| cellEditor.setValue(value); |
| // Tricky flow of control here: |
| // activate() can trigger callback to cellEditorListener |
| // which will clear cellEditor |
| // so must get control first, but must still call activate() |
| // even if there is no control. |
| final Control control = cellEditor.getControl(); |
| cellEditor.activate(); |
| if (control == null) { |
| return; |
| } |
| setLayoutData(cellEditor.getLayoutData()); |
| setEditor(control, tableItem, columnNumber); |
| cellEditor.setFocus(); |
| if (focusListener == null) { |
| focusListener = new FocusAdapter() { |
| public void focusLost(FocusEvent e) { |
| applyEditorValue(); |
| } |
| }; |
| } |
| control.addFocusListener(focusListener); |
| mouseListener = new MouseAdapter() { |
| public void mouseDown(MouseEvent e) { |
| // time wrap? |
| // check for expiration of doubleClickTime |
| if (e.time <= doubleClickExpirationTime) { |
| control.removeMouseListener(mouseListener); |
| cancelEditing(); |
| handleDoubleClickEvent(); |
| } else if (mouseListener != null) { |
| control.removeMouseListener(mouseListener); |
| } |
| } |
| }; |
| control.addMouseListener(mouseListener); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Activate a cell editor for the given mouse position. |
| */ |
| private void activateCellEditor(MouseEvent event) { |
| if (tableItem == null || tableItem.isDisposed()) { |
| // item no longer exists |
| return; |
| } |
| int columnToEdit; |
| int columns = getColumnCount(); |
| if (columns == 0) { |
| // If no TableColumn, Table acts as if it has a single column |
| // which takes the whole width. |
| columnToEdit = 0; |
| } else { |
| columnToEdit = -1; |
| for (int i = 0; i < columns; i++) { |
| Rectangle bounds = getBounds(tableItem, i); |
| if (bounds.contains(event.x, event.y)) { |
| columnToEdit = i; |
| break; |
| } |
| } |
| if (columnToEdit == -1) { |
| return; |
| } |
| } |
| |
| columnNumber = columnToEdit; |
| activateCellEditor(); |
| } |
| |
| /** |
| * Deactivates the currently active cell editor. |
| */ |
| public void applyEditorValue() { |
| CellEditor c = this.cellEditor; |
| if (c != null) { |
| // null out cell editor before calling save |
| // in case save results in applyEditorValue being re-entered |
| // see 1GAHI8Z: ITPUI:ALL - How to code event notification when |
| // using cell editor ? |
| this.cellEditor = null; |
| Item t = this.tableItem; |
| // don't null out table item -- same item is still selected |
| if (t != null && !t.isDisposed()) { |
| saveEditorValue(c, t); |
| } |
| setEditor(null, null, 0); |
| c.removeListener(cellEditorListener); |
| Control control = c.getControl(); |
| if (control != null) { |
| if (mouseListener != null) { |
| control.removeMouseListener(mouseListener); |
| } |
| if (focusListener != null) { |
| control.removeFocusListener(focusListener); |
| } |
| } |
| c.deactivate(); |
| } |
| } |
| |
| /** |
| * Cancels the active cell editor, without saving the value back to the |
| * domain model. |
| */ |
| public void cancelEditing() { |
| if (cellEditor != null) { |
| setEditor(null, null, 0); |
| cellEditor.removeListener(cellEditorListener); |
| CellEditor oldEditor = cellEditor; |
| cellEditor = null; |
| oldEditor.deactivate(); |
| } |
| } |
| |
| /** |
| * Start editing the given element. |
| * |
| * @param element |
| * @param column |
| */ |
| public void editElement(Object element, int column) { |
| if (cellEditor != null) { |
| applyEditorValue(); |
| } |
| |
| setSelection(new StructuredSelection(element), true); |
| Item[] selection = getSelection(); |
| if (selection.length != 1) { |
| return; |
| } |
| |
| tableItem = selection[0]; |
| |
| // Make sure selection is visible |
| showSelection(); |
| columnNumber = column; |
| activateCellEditor(); |
| |
| } |
| |
| /** |
| * Return the array of CellEditors used in the viewer |
| * |
| * @return the cell editors |
| */ |
| public CellEditor[] getCellEditors() { |
| return cellEditors; |
| } |
| |
| /** |
| * Get the cell modifier |
| * |
| * @return the cell modifier |
| */ |
| public ICellModifier getCellModifier() { |
| return cellModifier; |
| } |
| |
| /** |
| * Return the properties for the column |
| * |
| * @return the array of column properties |
| */ |
| public Object[] getColumnProperties() { |
| return columnProperties; |
| } |
| |
| /** |
| * Handles the mouse down event; activates the cell editor. |
| * |
| * @param event |
| * the mouse event that should be handled |
| */ |
| public void handleMouseDown(MouseEvent event) { |
| if (event.button != 1) { |
| return; |
| } |
| |
| if (cellEditor != null) { |
| applyEditorValue(); |
| } |
| |
| // activate the cell editor immediately. If a second mouseDown |
| // is received prior to the expiration of the doubleClick time then |
| // the cell editor will be deactivated and a doubleClick event will |
| // be processed. |
| // |
| doubleClickExpirationTime = event.time |
| + Display.getCurrent().getDoubleClickTime(); |
| |
| Item[] items = getSelection(); |
| // Do not edit if more than one row is selected. |
| if (items.length != 1) { |
| tableItem = null; |
| return; |
| } |
| tableItem = items[0]; |
| |
| activateCellEditor(event); |
| } |
| |
| private void initCellEditorListener() { |
| cellEditorListener = new ICellEditorListener() { |
| public void editorValueChanged(boolean oldValidState, |
| boolean newValidState) { |
| // Ignore. |
| } |
| |
| public void cancelEditor() { |
| TableTreeEditorImpl.this.cancelEditing(); |
| } |
| |
| public void applyEditorValue() { |
| TableTreeEditorImpl.this.applyEditorValue(); |
| } |
| }; |
| } |
| |
| /** |
| * Return whether there is an active cell editor. |
| * |
| * @return <code>true</code> if there is an active cell editor; |
| * otherwise <code>false</code> is returned. |
| */ |
| public boolean isCellEditorActive() { |
| return cellEditor != null; |
| } |
| |
| /** |
| * Saves the value of the currently active cell editor, by delegating to |
| * the cell modifier. |
| */ |
| private void saveEditorValue(CellEditor cellEditor, Item tableItem) { |
| if( cellModifier != null ) { |
| if( ! cellEditor.isValueValid() ) { |
| // Do what???? |
| } |
| } |
| String property = null; |
| |
| if( columnProperties != null && columnNumber < columnProperties.length ) { |
| property = columnProperties[columnNumber]; |
| } |
| cellModifier.modify(tableItem, property, cellEditor.getValue()); |
| } |
| |
| /** |
| * Set the cell editors |
| * |
| * @param editors |
| */ |
| public void setCellEditors(CellEditor[] editors) { |
| this.cellEditors = editors; |
| } |
| |
| /** |
| * Set the cell modifier |
| * |
| * @param modifier |
| */ |
| public void setCellModifier(ICellModifier modifier) { |
| this.cellModifier = modifier; |
| } |
| |
| /** |
| * Set the column properties |
| * |
| * @param columnProperties |
| */ |
| public void setColumnProperties(String[] columnProperties) { |
| this.columnProperties = columnProperties; |
| } |
| |
| Rectangle getBounds(Item item, int columnNumber) { |
| return ((TableTreeItem) item).getBounds(columnNumber); |
| } |
| |
| int getColumnCount() { |
| // getColumnCount() should be a API in TableTree. |
| return getTableTree().getTable().getColumnCount(); |
| } |
| |
| Item[] getSelection() { |
| return getTableTree().getSelection(); |
| } |
| |
| void setEditor(Control w, Item item, int columnNumber) { |
| tableTreeEditor.setEditor(w, (TableTreeItem) item, columnNumber); |
| } |
| |
| void setSelection(StructuredSelection selection, boolean b) { |
| TableTreeViewer.this.setSelection(selection, b); |
| } |
| |
| void showSelection() { |
| getTableTree().showSelection(); |
| } |
| |
| void setLayoutData(CellEditor.LayoutData layoutData) { |
| tableTreeEditor.horizontalAlignment = layoutData.horizontalAlignment; |
| tableTreeEditor.grabHorizontal = layoutData.grabHorizontal; |
| tableTreeEditor.minimumWidth = layoutData.minimumWidth; |
| } |
| |
| void handleDoubleClickEvent() { |
| Viewer viewer = getViewer(); |
| fireDoubleClick(new DoubleClickEvent(viewer, viewer.getSelection())); |
| fireOpen(new OpenEvent(viewer, viewer.getSelection())); |
| } |
| } |
| |
| /** |
| * Creates a table tree viewer on the given table tree control. The viewer |
| * has no input, no content provider, a default label provider, no sorter, |
| * and no filters. |
| * |
| * @param tree |
| * the table tree control |
| */ |
| public TableTreeViewer(TableTree tree) { |
| super(); |
| tableTree = tree; |
| hookControl(tree); |
| tableTreeEditor = new TableTreeEditor(tableTree); |
| tableEditorImpl = new TableTreeEditorImpl(this); |
| } |
| |
| /** |
| * Creates a table tree viewer on a newly-created table tree control under |
| * the given parent. The table tree control is created using the SWT style |
| * bits <code>MULTI, H_SCROLL, V_SCROLL, and BORDER</code>. The viewer |
| * has no input, no content provider, a default label provider, no sorter, |
| * and no filters. |
| * |
| * @param parent |
| * the parent control |
| */ |
| public TableTreeViewer(Composite parent) { |
| this(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER); |
| } |
| |
| /** |
| * Creates a table tree viewer on a newly-created table tree control under |
| * the given parent. The table tree control is created using the given SWT |
| * style bits. The viewer has no input, no content provider, a default label |
| * provider, no sorter, and no filters. |
| * |
| * @param parent |
| * the parent control |
| * @param style |
| * the SWT style bits |
| */ |
| public TableTreeViewer(Composite parent, int style) { |
| this(new TableTree(parent, style)); |
| } |
| |
| /* |
| * (non-Javadoc) Method declared on AbstractTreeViewer. |
| */ |
| protected void addTreeListener(Control c, TreeListener listener) { |
| ((TableTree) c).addTreeListener(listener); |
| } |
| |
| /** |
| * Cancels a currently active cell editor. All changes already done in the |
| * cell editor are lost. |
| */ |
| public void cancelEditing() { |
| tableEditorImpl.cancelEditing(); |
| } |
| |
| /* |
| * (non-Javadoc) Method declared on AbstractTreeViewer. |
| */ |
| protected void doUpdateItem(Item item, Object element) { |
| // update icon and label |
| // Similar code in TableTreeViewer.doUpdateItem() |
| IBaseLabelProvider prov = getLabelProvider(); |
| ITableLabelProvider tprov = null; |
| |
| if (prov instanceof ITableLabelProvider) { |
| tprov = (ITableLabelProvider) prov; |
| } |
| |
| int columnCount = tableTree.getTable().getColumnCount(); |
| TableTreeItem ti = (TableTreeItem) item; |
| // Also enter loop if no columns added. See 1G9WWGZ: JFUIF:WINNT - |
| // TableViewer with 0 columns does not work |
| for (int column = 0; column < columnCount || column == 0; column++) { |
| String text = "";//$NON-NLS-1$ |
| Image image = null; |
| if (tprov != null) { |
| text = tprov.getColumnText(element, column); |
| image = tprov.getColumnImage(element, column); |
| } else { |
| if (column == 0) { |
| ViewerLabel updateLabel = new ViewerLabel(item.getText(), |
| item.getImage()); |
| buildLabel(updateLabel, element); |
| |
| // As it is possible for user code to run the event |
| // loop check here. |
| if (item.isDisposed()) { |
| unmapElement(element, item); |
| return; |
| } |
| |
| text = updateLabel.getText(); |
| image = updateLabel.getImage(); |
| } |
| } |
| |
| // Avoid setting text to null |
| if (text == null) { |
| text = ""; //$NON-NLS-1$ |
| } |
| |
| ti.setText(column, text); |
| // Apparently a problem to setImage to null if already null |
| if (ti.getImage(column) != image) { |
| ti.setImage(column, image); |
| } |
| |
| getColorAndFontCollector().setFontsAndColors(element); |
| getColorAndFontCollector().applyFontsAndColors(ti); |
| } |
| |
| } |
| |
| /** |
| * Starts editing the given element. |
| * |
| * @param element |
| * the element |
| * @param column |
| * the column number |
| */ |
| public void editElement(Object element, int column) { |
| tableEditorImpl.editElement(element, column); |
| } |
| |
| /** |
| * Returns the cell editors of this viewer. |
| * |
| * @return the list of cell editors |
| */ |
| public CellEditor[] getCellEditors() { |
| return tableEditorImpl.getCellEditors(); |
| } |
| |
| /** |
| * Returns the cell modifier of this viewer. |
| * |
| * @return the cell modifier |
| */ |
| public ICellModifier getCellModifier() { |
| return tableEditorImpl.getCellModifier(); |
| } |
| |
| /* |
| * (non-Javadoc) Method declared on AbstractTreeViewer. |
| */ |
| protected Item[] getChildren(Widget o) { |
| if (o instanceof TableTreeItem) { |
| return ((TableTreeItem) o).getItems(); |
| } |
| if (o instanceof TableTree) { |
| return ((TableTree) o).getItems(); |
| } |
| return null; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.viewers.AbstractTreeViewer#getChild(org.eclipse.swt.widgets.Widget, |
| * int) |
| */ |
| protected Item getChild(Widget widget, int index) { |
| if (widget instanceof TableTreeItem) { |
| return ((TableTreeItem) widget).getItem(index); |
| } |
| if (widget instanceof TableTree) { |
| return ((TableTree) widget).getItem(index); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the column properties of this viewer. The properties must |
| * correspond with the columns of the table control. They are used to |
| * identify the column in a cell modifier. |
| * |
| * @return the list of column properties |
| */ |
| public Object[] getColumnProperties() { |
| return tableEditorImpl.getColumnProperties(); |
| } |
| |
| /* |
| * (non-Javadoc) Method declared on Viewer. |
| */ |
| public Control getControl() { |
| return tableTree; |
| } |
| |
| /** |
| * Returns the element with the given index from this viewer. Returns |
| * <code>null</code> if the index is out of range. |
| * <p> |
| * This method is internal to the framework. |
| * </p> |
| * |
| * @param index |
| * the zero-based index |
| * @return the element at the given index, or <code>null</code> if the |
| * index is out of range |
| */ |
| public Object getElementAt(int index) { |
| // XXX: Workaround for 1GBCSB1: SWT:WIN2000 - TableTree should have |
| // getItem(int index) |
| TableTreeItem i = tableTree.getItems()[index]; |
| if (i != null) { |
| return i.getData(); |
| } |
| return null; |
| } |
| |
| /* |
| * (non-Javadoc) Method declared on AbstractTreeViewer. |
| */ |
| protected boolean getExpanded(Item item) { |
| return ((TableTreeItem) item).getExpanded(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.viewers.ColumnViewer#getItemAt(org.eclipse.swt.graphics.Point) |
| */ |
| protected Item getItemAt(Point p) { |
| return getTableTree().getTable().getItem(p); |
| } |
| |
| /* |
| * (non-Javadoc) Method declared on AbstractTreeViewer. |
| */ |
| protected int getItemCount(Control widget) { |
| return ((TableTree) widget).getItemCount(); |
| } |
| |
| /* |
| * (non-Javadoc) Method declared on AbstractTreeViewer. |
| */ |
| protected int getItemCount(Item item) { |
| return ((TableTreeItem) item).getItemCount(); |
| } |
| |
| /* |
| * (non-Javadoc) Method declared on AbstractTreeViewer. |
| */ |
| protected org.eclipse.swt.widgets.Item[] getItems( |
| org.eclipse.swt.widgets.Item item) { |
| return ((TableTreeItem) item).getItems(); |
| } |
| |
| /** |
| * The table tree viewer implementation of this <code>Viewer</code> |
| * framework method returns the label provider, which in the case of table |
| * tree viewers will be an instance of either |
| * <code>ITableLabelProvider</code> or <code>ILabelProvider</code>. If |
| * it is an <code>ITableLabelProvider</code>, then it provides a separate |
| * label text and image for each column. If it is an |
| * <code>ILabelProvider</code>, then it provides only the label text and |
| * image for the first column, and any remaining columns are blank. |
| */ |
| public IBaseLabelProvider getLabelProvider() { |
| return super.getLabelProvider(); |
| } |
| |
| /* |
| * (non-Javadoc) Method declared on AbstractTreeViewer. |
| */ |
| protected Item getParentItem(Item item) { |
| return ((TableTreeItem) item).getParentItem(); |
| } |
| |
| /* |
| * (non-Javadoc) Method declared on AbstractTreeViewer. |
| */ |
| protected Item[] getSelection(Control widget) { |
| return ((TableTree) widget).getSelection(); |
| } |
| |
| /** |
| * Returns this table tree viewer's table tree control. |
| * |
| * @return the table tree control |
| */ |
| public TableTree getTableTree() { |
| return tableTree; |
| } |
| |
| /* |
| * (non-Javadoc) Method declared on AbstractTreeViewer. |
| */ |
| protected void hookControl(Control control) { |
| super.hookControl(control); |
| tableTree.getTable().addMouseListener(new MouseAdapter() { |
| public void mouseDown(MouseEvent e) { |
| /* |
| * If user clicked on the [+] or [-], do not activate |
| * CellEditor. |
| */ |
| // XXX: This code should not be here. SWT should either have |
| // support to see |
| // if the user clicked on the [+]/[-] or manage the table editor |
| // activation |
| org.eclipse.swt.widgets.TableItem[] items = tableTree |
| .getTable().getItems(); |
| for (int i = 0; i < items.length; i++) { |
| Rectangle rect = items[i].getImageBounds(0); |
| if (rect.contains(e.x, e.y)) { |
| return; |
| } |
| } |
| |
| tableEditorImpl.handleMouseDown(e); |
| } |
| }); |
| } |
| |
| /** |
| * Returns whether there is an active cell editor. |
| * |
| * @return <code>true</code> if there is an active cell editor, and |
| * <code>false</code> otherwise |
| */ |
| public boolean isCellEditorActive() { |
| return tableEditorImpl.isCellEditorActive(); |
| } |
| |
| /* |
| * (non-Javadoc) Method declared in AbstractTreeViewer. |
| */ |
| protected Item newItem(Widget parent, int flags, int ix) { |
| TableTreeItem item; |
| if (ix >= 0) { |
| if (parent instanceof TableTreeItem) { |
| item = new TableTreeItem((TableTreeItem) parent, flags, ix); |
| } else { |
| item = new TableTreeItem((TableTree) parent, flags, ix); |
| } |
| } else { |
| if (parent instanceof TableTreeItem) { |
| item = new TableTreeItem((TableTreeItem) parent, flags); |
| } else { |
| item = new TableTreeItem((TableTree) parent, flags); |
| } |
| } |
| return item; |
| } |
| |
| /* |
| * (non-Javadoc) Method declared in AbstractTreeViewer. |
| */ |
| protected void removeAll(Control widget) { |
| ((TableTree) widget).removeAll(); |
| } |
| |
| /** |
| * Sets the cell editors of this table viewer. |
| * |
| * @param editors |
| * the list of cell editors |
| */ |
| public void setCellEditors(CellEditor[] editors) { |
| tableEditorImpl.setCellEditors(editors); |
| } |
| |
| /** |
| * Sets the cell modifier of this table viewer. |
| * |
| * @param modifier |
| * the cell modifier |
| */ |
| public void setCellModifier(ICellModifier modifier) { |
| tableEditorImpl.setCellModifier(modifier); |
| } |
| |
| /** |
| * Sets the column properties of this table viewer. The properties must |
| * correspond with the columns of the table control. They are used to |
| * identify the column in a cell modifier. |
| * |
| * @param columnProperties |
| * the list of column properties |
| */ |
| public void setColumnProperties(String[] columnProperties) { |
| tableEditorImpl.setColumnProperties(columnProperties); |
| } |
| |
| /* |
| * (non-Javadoc) Method declared in AbstractTreeViewer. |
| */ |
| protected void setExpanded(Item node, boolean expand) { |
| ((TableTreeItem) node).setExpanded(expand); |
| } |
| |
| /* |
| * (non-Javadoc) Method declared in AbstractTreeViewer. |
| */ |
| protected void setSelection(List items) { |
| TableTreeItem[] newItems = new TableTreeItem[items.size()]; |
| items.toArray(newItems); |
| getTableTree().setSelection(newItems); |
| } |
| |
| /* |
| * (non-Javadoc) Method declared in AbstractTreeViewer. |
| */ |
| protected void showItem(Item item) { |
| getTableTree().showItem((TableTreeItem) item); |
| } |
| } |