treeviewer.java

jfa2ce 源码帮助开发人员更好的理解运用

						ILazyTreeContentProvider lazyContentProvider = (ILazyTreeContentProvider) getContentProvider();
						TreeItem item = (TreeItem) event.item;
						TreeItem parentItem = item.getParentItem();
						Object parent;
						int index;
						if (parentItem != null) {
							parent = parentItem.getData();
							index = parentItem.indexOf(item);
						} else {
							parent = getInput();
							index = getTree().indexOf(item);
						}
						lazyContentProvider.updateElement(parent, index);
					}
				}
			});
		}
	}

	/**
	 * Initializes the tree viewer implementation.
	 */
	private void initTreeViewerImpl() {
		treeViewerImpl = new TreeEditorImpl(this) {
			Rectangle getBounds(Item item, int columnNumber) {
				return ((TreeItem) item).getBounds(columnNumber);
			}

			int getColumnCount() {
				return getTree().getColumnCount();
			}

			Item[] getSelection() {
				return getTree().getSelection();
			}

			void setEditor(Control w, Item item, int columnNumber) {
				treeEditor.setEditor(w, (TreeItem) item, columnNumber);
			}

			void setSelection(IStructuredSelection selection, boolean b) {
				TreeViewer.this.setSelection(selection, b);
			}

			void showSelection() {
				getTree().showSelection();
			}

			void setLayoutData(CellEditor.LayoutData layoutData) {
				treeEditor.grabHorizontal = layoutData.grabHorizontal;
				treeEditor.horizontalAlignment = layoutData.horizontalAlignment;
				treeEditor.minimumWidth = layoutData.minimumWidth;
			}

			void handleDoubleClickEvent() {
				Viewer viewer = getViewer();
				fireDoubleClick(new DoubleClickEvent(viewer, viewer
						.getSelection()));
				fireOpen(new OpenEvent(viewer, viewer.getSelection()));
			}
		};
	}

	/**
	 * Returns whether there is an active cell editor.
	 * 
	 * @return <code>true</code> if there is an active cell editor, and
	 *         <code>false</code> otherwise
	 * @since 3.1
	 */
	public boolean isCellEditorActive() {
		return treeViewerImpl.isCellEditorActive();
	}

	/*
	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */
	protected Item newItem(Widget parent, int flags, int ix) {
		TreeItem item;
		if (ix >= 0) {
			if (parent instanceof TreeItem) {
				item = new TreeItem((TreeItem) parent, flags, ix);
			} else {
				item = new TreeItem((Tree) parent, flags, ix);
			}
		} else {
			if (parent instanceof TreeItem) {
				item = new TreeItem((TreeItem) parent, flags);
			} else {
				item = new TreeItem((Tree) parent, flags);
			}
		}
		return item;
	}

	/*
	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */
	protected void removeAll(Control widget) {
		((Tree) widget).removeAll();
	}

	/**
	 * Sets the cell editors of this tree viewer.
	 * 
	 * @param editors
	 *            the list of cell editors
	 * @since 3.1
	 */
	public void setCellEditors(CellEditor[] editors) {
		treeViewerImpl.setCellEditors(editors);
	}

	/**
	 * Sets the cell modifier of this tree viewer.
	 * 
	 * @param modifier
	 *            the cell modifier
	 * @since 3.1
	 */
	public void setCellModifier(ICellModifier modifier) {
		treeViewerImpl.setCellModifier(modifier);
	}

	/**
	 * Sets the column properties of this tree viewer. The properties must
	 * correspond with the columns of the tree control. They are used to
	 * identify the column in a cell modifier.
	 * 
	 * @param columnProperties
	 *            the list of column properties
	 * @since 3.1
	 */
	public void setColumnProperties(String[] columnProperties) {
		treeViewerImpl.setColumnProperties(columnProperties);
	}

	/*
	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */
	protected void setExpanded(Item node, boolean expand) {
		((TreeItem) node).setExpanded(expand);
		if(getContentProvider() instanceof ILazyTreeContentProvider) {
			// force repaints to happen
			getControl().update();
		}
	}

	/**
	 * The tree viewer implementation of this <code>Viewer</code> framework
	 * method ensures that the given label provider is an instance of either
	 * <code>ITableLabelProvider</code> or <code>ILabelProvider</code>.
	 * <p>
	 * If the label provider is an {@link ITableLabelProvider}, then it
	 * provides a separate label text and image for each column. Implementers of
	 * <code>ITableLabelProvider</code> may also implement
	 * {@link ITableColorProvider} and/or {@link ITableFontProvider} to provide
	 * colors and/or fonts. Note that the underlying {@link Tree} must be
	 * configured with {@link TreeColumn} objects in this case. 
	 * </p>
	 * <p>
	 * If the label provider is an <code>ILabelProvider</code>, then it
	 * provides only the label text and image for the first column, and any
	 * remaining columns are blank. Implementers of <code>ILabelProvider</code>
	 * may also implement {@link IColorProvider} and/or {@link IFontProvider} to
	 * provide colors and/or fonts.
	 * </p>
	 */
	public void setLabelProvider(IBaseLabelProvider labelProvider) {
		Assert.isTrue(labelProvider instanceof ITableLabelProvider
				|| labelProvider instanceof ILabelProvider);
		super.setLabelProvider(labelProvider);
		treeColorAndFont = new TreeColorAndFontCollector(labelProvider);
	}

	/*
	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */
	protected void setSelection(List items) {

		Item[] current = getSelection(getTree());

		// Don't bother resetting the same selection
		if (isSameSelection(items, current)) {
			return;
		}

		TreeItem[] newItems = new TreeItem[items.size()];
		items.toArray(newItems);
		getTree().setSelection(newItems);
	}

	/**
	 * Returns <code>true</code> if the given list and array of items refer to
	 * the same model elements. Order is unimportant.
	 * 
	 * @param items
	 *            the list of items
	 * @param current
	 *            the array of items
	 * @return <code>true</code> if the refer to the same elements,
	 *         <code>false</code> otherwise
	 *         
	 * @since 3.1
	 */
	protected boolean isSameSelection(List items, Item[] current) {
		// If they are not the same size then they are not equivalent
		int n = items.size();
		if (n != current.length) {
			return false;
		}

		CustomHashtable itemSet = newHashtable(n * 2 + 1);
		for (Iterator i = items.iterator(); i.hasNext();) {
			Item item = (Item) i.next();
			Object element = item.getData();
			itemSet.put(element, element);
		}

		// Go through the items of the current collection
		// If there is a mismatch return false
		for (int i = 0; i < current.length; i++) {
			if (current[i].getData() == null || !itemSet.containsKey(current[i].getData())) {
				return false;
			}
		}

		return true;
	}

	/*
	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */
	protected void showItem(Item item) {
		getTree().showItem((TreeItem) item);
	}


	/* (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 TreeItem) {
			return ((TreeItem) widget).getItem(index);
		}
		if (widget instanceof Tree) {
			return ((Tree) widget).getItem(index);
		}
		return null;
	}
	
	protected void assertContentProviderType(IContentProvider provider) {
		if(provider instanceof ILazyTreeContentProvider) {
			return;
		}
		super.assertContentProviderType(provider);
	}
	
    protected Object[] getRawChildren(Object parent) {
    	if(getContentProvider() instanceof ILazyTreeContentProvider) {
    		return new Object[0];
    	}
    	return super.getRawChildren(parent);
    }

    /**
     * For a TreeViewer with a tree with the VIRTUAL style bit set, set the
     * number of children of the given element. To set the number of children
     * of the invisible root of the tree, the input object is passed as the
     * element.
     * 
     * @param element
     * @param count
     * 
	 * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
	 * part of a work in progress. There is no guarantee that this API will remain
	 * unchanged during the 3.2 release cycle. Please do not use this API without
	 * consulting with the Platform/UI team.
	 * </p>
     * 
     * @since 3.2
     */
	public void setChildCount(Object element, int count) {
		Tree tree = (Tree) doFindInputItem(element);
		if (tree != null) {
			tree.setItemCount(count);
			return;
		}
		Widget[] items = findItems(element);
		for (int i = 0; i < items.length; i++) {
			TreeItem treeItem = (TreeItem)items[i];
			treeItem.setItemCount(count);
		}		
	}

	/**
	 * For a TreeViewer with a tree with the VIRTUAL style bit set, replace the
	 * given parent's child at index with the given element. If the given parent
	 * is this viewer's input, this will replace the root element at the given
	 * index.
	 * <p>
	 * This method should be called by implementers of ILazyTreeContentProvider
	 * to populate this viewer.
	 * </p>
	 * @param parent the parent of the element that should be updated
	 * @param index the index in the parent's children
	 * @param element the new element
	 * 
	 * @see #setChildCount(Object, int)
	 * @see ILazyTreeContentProvider
     * 
	 * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
	 * part of a work in progress. There is no guarantee that this API will remain
	 * unchanged during the 3.2 release cycle. Please do not use this API without
	 * consulting with the Platform/UI team.
	 * </p>
     * 
	 * @since 3.2
	 */
	public void replace(Object parent, int index, Object element) {
		if(parent.equals(getInput())) {
			if (index < tree.getItemCount()) {
				updateItem(tree.getItem(index), element);
			}
		} else {
			Widget[] parentItems = findItems(parent);
			for (int i = 0; i < parentItems.length; i++) {
				TreeItem parentItem = (TreeItem) parentItems[i];
				if (index < parentItem.getItemCount()) {
					updateItem(parentItem.getItem(index), element);
				}
			}			
		}
	}
	
    public boolean isExpandable(Object element) {
    	if (getContentProvider() instanceof ILazyTreeContentProvider) {
    		TreeItem treeItem = (TreeItem) internalExpand(element, false);
    		if (treeItem == null) {
    			return false;
    		}
    		virtualMaterializeItem(treeItem);
    		return treeItem.getItemCount() > 0;
    	}
    	return super.isExpandable(element);
    }

    protected Object getParentElement(Object element) {
    	if(!(element instanceof TreePath) && (getContentProvider() instanceof ILazyTreeContentProvider)) {
    		ILazyTreeContentProvider lazyTreeContentProvider = (ILazyTreeContentProvider) getContentProvider();
    		return lazyTreeContentProvider.getParent(element);
    	}
        return super.getParentElement(element);
	}
    
    protected void createChildren(Widget widget) {
    	if (getContentProvider() instanceof ILazyTreeContentProvider) {
    		final Item[] tis = getChildren(widget);
    		if (tis != null && tis.length > 0) {
    			// children already there, touch them
    			for (int i = 0; i < tis.length; i++) {
					tis[i].getText();
				}
    			return;
    		}
    		ILazyTreeContentProvider lazyTreeContentProvider = (ILazyTreeContentProvider) getContentProvider();
    		Object element = widget.getData();
    		if (element == null && widget instanceof TreeItem) {
    			// parent has not been materialized
    			virtualMaterializeItem((TreeItem) widget);
    			// try getting the element now that updateElement was called
    			element = widget.getData();
    		}
    		TreeItem[] children;
    		if (widget instanceof Tree) {
    			children = ((Tree) widget).getItems();
    		} else {
    			children = ((TreeItem) widget).getItems();
    		}
    		if (element != null && children.length > 0) {
    			for (int i = 0; i < children.length; i++) {
    				lazyTreeContentProvider.updateElement(element, i);
    			}
    		}
    		return;
    	}
    	super.createChildren(widget);
    }
    
    protected void internalAdd(Widget widget, Object parentElement,
    		Object[] childElements) {
    	if (getContentProvider() instanceof ILazyTreeContentProvider) {
    		if (widget instanceof TreeItem) {
    			TreeItem ti = (TreeItem) widget;
    			int count = ti.getItemCount() + childElements.length;
				ti.setItemCount(count);
    			ti.clearAll(false);
    		} else {
    			Tree t = (Tree) widget;
    			t.setItemCount(t.getItemCount() + childElements.length);
    			t.clearAll(false);
    		}
    		return;
    	}
    	super.internalAdd(widget, parentElement, childElements);
    }

	private void virtualMaterializeItem(TreeItem treeItem) {
		if (treeItem.getData() != null) {
			// already materialized
			return;
		}
		if (!(getContentProvider() instanceof ILazyTreeContentProvider)) {
			return;
		}
		ILazyTreeContentProvider lazyTreeContentProvider = (ILazyTreeContentProvider) getContentProvider();
		int index;
		Widget parent = treeItem.getParentItem();
		if (parent == null) {
			parent = treeItem.getParent();
		}
		Object parentElement = parent.getData();
		if (parentElement != null) {
			if (parent instanceof Tree) {
				index = ((Tree) parent).indexOf(treeItem);
			} else {
				index = ((TreeItem) parent).indexOf(treeItem);
			}
			lazyTreeContentProvider.updateElement(parentElement, index);
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.AbstractTreeViewer#internalRefreshStruct(org.eclipse.swt.widgets.Widget, java.lang.Object, boolean)
	 */
	protected void internalRefreshStruct(Widget widget, Object element, boolean updateLabels) {
    	if (getContentProvider() instanceof ILazyTreeContentProvider) {
    		// first phase: update child counts
    		virtualRefreshChildCounts(widget, element);
    		// second phase: update labels
    		if (updateLabels) {
    			if (widget instanceof Tree) {
    				((Tree)widget).clearAll(true);
    			} else if (widget instanceof TreeItem) {
    				((TreeItem)widget).clearAll(true);
    			}
    		}
    		return;
    	}
		super.internalRefreshStruct(widget, element, updateLabels);
	}

	/**
	 * Traverses the visible (expanded) part of the tree and updates child counts.
	 * @param widget
	 * @param element
	 * @param updateLabels
	 */
	private void virtualRefreshChildCounts(Widget widget, Object element) {
		ILazyTreeContentProvider lazyTreeContentProvider = (ILazyTreeContentProvider) getContentProvider();
		if (widget instanceof Tree || ((TreeItem)widget).getExpanded()) {
			// widget shows children - it is safe to call getChildren
			if (element != null) {
				lazyTreeContentProvider.updateChildCount(element, getChildren(widget).length);
			} else {
				if (widget instanceof Tree) {
					((Tree)widget).setItemCount(0);
				} else {
					((TreeItem)widget).setItemCount(0);
				}
			}
			// need to get children again because they might have been updated through a callback to setChildCount.
			Item[] items = getChildren(widget);
			for (int i = 0; i < items.length; i++) {
				Item item = items[i];
				Object data = item.getData();
				if (data != null) {
					virtualRefreshChildCounts(item, data);
				}
			}
		}
	}
	
	/*
	 * To unmap elements correctly, we need to register a dispose listener with
	 * the item if the tree is virtual.
	 */
	protected void mapElement(Object element, final Widget item) {
		super.mapElement(element, item);
		// make sure to unmap elements if the tree is virtual
		if ((getTree().getStyle() & SWT.VIRTUAL) != 0) {
			item.addDisposeListener(new DisposeListener(){
				public void widgetDisposed(DisposeEvent e) {
					if (!treeIsDisposed) {
						Object data = item.getData();
						if (usingElementMap() && data != null) {
							unmapElement(data, item);
						}
					}
				}});
		}
	}
}