/*******************************************************************************
 * Copyright (c) 2004, 2005 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.jface.viewers;

import java.util.Iterator;
import java.util.List;

import org.eclipse.jface.util.Assert;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.TreeEditor;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
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.Event;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.swt.widgets.Widget;

/**
 * A concrete viewer based on an SWT <code>Tree</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 tree control and
 * configured with a domain-specific content provider, label provider, element
 * filter (optional), and element sorter (optional).
 * </p>
 * <p>
 * Content providers for tree viewers must implement the
 * <code>ITreeContentProvider</code> interface.
 * </p>
 */
public class TreeViewer extends AbstractTreeViewer {

	/**
	 * TreeColorAndFontCollector is an helper class for color and font support
	 * for trees that support the ITableFontProvider and the
	 * ITableColorProvider.
	 * 
	 * @see ITableColorProvider
	 * @see ITableFontProvider
	 */

	private class TreeColorAndFontCollector {

		ITableFontProvider fontProvider = null;

		ITableColorProvider colorProvider = null;

		/**
		 * Create an instance of the receiver. Set the color and font providers
		 * if provider can be cast to the correct type.
		 * 
		 * @param provider
		 *            IBaseLabelProvider
		 */
		public TreeColorAndFontCollector(IBaseLabelProvider provider) {
			if (provider instanceof ITableFontProvider)
				fontProvider = (ITableFontProvider) provider;
			if (provider instanceof ITableColorProvider)
				colorProvider = (ITableColorProvider) provider;
		}

		/**
		 * Create an instance of the receiver with no color and font providers.
		 */
		public TreeColorAndFontCollector() {
		}

		/**
		 * Set the fonts and colors for the treeItem if there is a color and
		 * font provider available.
		 * 
		 * @param treeItem
		 *            The item to update.
		 * @param element
		 *            The element being represented
		 * @param column
		 *            The column index
		 */
		public void setFontsAndColors(TreeItem treeItem, Object element,
				int column) {
			if (colorProvider != null) {
				treeItem.setBackground(column, colorProvider.getBackground(
						element, column));
				treeItem.setForeground(column, colorProvider.getForeground(
						element, column));
			}
			if (fontProvider != null)
				treeItem.setFont(column, fontProvider.getFont(element, column));
		}

	}

	/**
	 * Internal tree viewer implementation.
	 */
	private TreeEditorImpl treeViewerImpl;

	/**
	 * This viewer's control.
	 */
	private Tree tree;

	/**
	 * This viewer's tree editor.
	 */
	private TreeEditor treeEditor;

	/**
	 * The color and font collector for the cells.
	 */
	private TreeColorAndFontCollector treeColorAndFont = new TreeColorAndFontCollector();

	/**
	 * Creates a tree viewer on a newly-created tree control under the given
	 * parent. The tree control is created using the SWT style bits
	 * <code>MULTI, H_SCROLL, V_SCROLL,</code> and <code>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 TreeViewer(Composite parent) {
		this(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER);
	}

	/**
	 * Creates a tree viewer on a newly-created tree control under the given
	 * parent. The 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 used to create the tree.
	 */
	public TreeViewer(Composite parent, int style) {
		this(new Tree(parent, style));
	}

	/**
	 * Creates a tree viewer on the given tree control. The viewer has no input,
	 * no content provider, a default label provider, no sorter, and no filters.
	 * 
	 * @param tree
	 *            the tree control
	 */
	public TreeViewer(Tree tree) {
		super();
		this.tree = tree;
		hookControl(tree);
		treeEditor = new TreeEditor(tree);
		initTreeViewerImpl();
	}

	/*
	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */
	protected void addTreeListener(Control c, TreeListener listener) {
		((Tree) c).addTreeListener(listener);
	}

	/**
	 * Cancels a currently active cell editor. All changes already done in the
	 * cell editor are lost.
	 * 
	 * @since 3.1
	 */
	public void cancelEditing() {
		treeViewerImpl.cancelEditing();
	}

	/*
	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */
	protected void doUpdateItem(final Item item, Object element) {
		if (!(item instanceof TreeItem))
			return;
		TreeItem treeItem = (TreeItem) item;
		if (treeItem.isDisposed()) {
			unmapElement(element, treeItem);
			return;
		}

		getColorAndFontCollector().setFontsAndColors(element);

		IBaseLabelProvider prov = getLabelProvider();
		ITableLabelProvider tprov = null;
		ILabelProvider lprov = null;
		IViewerLabelProvider vprov = null;
		
		if(prov instanceof ILabelProvider)
			lprov = (ILabelProvider) prov;
		
		if (prov instanceof IViewerLabelProvider) {
			vprov = (IViewerLabelProvider) prov;
		} 
		
		if (prov instanceof ITableLabelProvider) {
			tprov = (ITableLabelProvider) prov;
		}
		
		
		int columnCount = tree.getColumnCount();
		if (columnCount == 0) {// If no columns were created use the label
								// provider

			ViewerLabel updateLabel = new ViewerLabel(treeItem.getText(),
					treeItem.getImage());
			if(vprov != null)
				buildLabel(updateLabel,element,vprov);
			else{
				if(lprov != null)
					buildLabel(updateLabel,element,lprov);
			}

			// As it is possible for user code to run the event
			// loop check here.
			if (treeItem.isDisposed()) {
				unmapElement(element, treeItem);
				return;
			}

			if (updateLabel.hasNewText())
				treeItem.setText(updateLabel.getText());
			if (updateLabel.hasNewImage())
				treeItem.setImage(updateLabel.getImage());

		} else {// Use the table based support
			for (int column = 0; column < columnCount; column++) {
				// Similar code in TableViewer.doUpdateItem()
				String text = "";//$NON-NLS-1$
				Image image = null;
				treeColorAndFont.setFontsAndColors(treeItem, element, column);

				if (tprov == null) {
					if (column == 0) {
						ViewerLabel updateLabel = new ViewerLabel(treeItem
								.getText(), treeItem.getImage());
						if(vprov != null)
							buildLabel(updateLabel,element,vprov);
						else{
							if(lprov != null)
								buildLabel(updateLabel,element,lprov);
						}

						// As it is possible for user code to run the event
						// loop check here.
						if (treeItem.isDisposed()) {
							unmapElement(element, treeItem);
							return;
						}

						text = updateLabel.getText();
						image = updateLabel.getImage();
					}
				} else {
					text = tprov.getColumnText(element, column);
					image = tprov.getColumnImage(element, column);
				}

				// Avoid setting text to null
				if (text == null)
					text = ""; //$NON-NLS-1$
				treeItem.setText(column, text);
				if (treeItem.getImage(column) != image) {
					treeItem.setImage(column, image);
				}
			}
		}
		getColorAndFontCollector().applyFontsAndColors(treeItem);
	}

	/**
	 * Starts editing the given element.
	 * 
	 * @param element
	 *            the element
	 * @param column
	 *            the column number
	 * @since 3.1
	 */
	public void editElement(Object element, int column) {
		treeViewerImpl.editElement(element, column);
	}

	/**
	 * Returns the cell editors of this tree viewer.
	 * 
	 * @return the list of cell editors
	 * @since 3.1
	 */
	public CellEditor[] getCellEditors() {
		return treeViewerImpl.getCellEditors();
	}

	/**
	 * Returns the cell modifier of this tree viewer.
	 * 
	 * @return the cell modifier
	 * @since 3.1
	 */
	public ICellModifier getCellModifier() {
		return treeViewerImpl.getCellModifier();
	}

	/*
	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */
	protected Item[] getChildren(Widget o) {
		if (o instanceof TreeItem)
			return ((TreeItem) o).getItems();
		if (o instanceof Tree)
			return ((Tree) o).getItems();
		return null;
	}

	/**
	 * Returns 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.
	 * 
	 * @return the list of column properties
	 * @since 3.1
	 */
	public Object[] getColumnProperties() {
		return treeViewerImpl.getColumnProperties();
	}

	/*
	 * (non-Javadoc) Method declared in Viewer.
	 */
	public Control getControl() {
		return tree;
	}

	/*
	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */
	protected boolean getExpanded(Item item) {
		return ((TreeItem) item).getExpanded();
	}

	/*
	 * (non-Javadoc) Method declared in StructuredViewer.
	 */
	protected Item getItem(int x, int y) {
		return getTree().getItem(getTree().toControl(new Point(x, y)));
	}

	/*
	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */
	protected int getItemCount(Control widget) {
		return ((Tree) widget).getItemCount();
	}

	/*
	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */
	protected int getItemCount(Item item) {
		return ((TreeItem) item).getItemCount();
	}

	/*
	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */
	protected Item[] getItems(Item item) {
		return ((TreeItem) item).getItems();
	}

	/**
	 * 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>. 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 in AbstractTreeViewer.
	 */
	protected Item getParentItem(Item item) {
		return ((TreeItem) item).getParentItem();
	}
	
	/*
	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */
	protected Item[] getSelection(Control widget) {
		return ((Tree) widget).getSelection();
	}

	/**
	 * Returns this tree viewer's tree control.
	 * 
	 * @return the tree control
	 */
	public Tree getTree() {
		return tree;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.AbstractTreeViewer#hookControl(org.eclipse.swt.widgets.Control)
	 */
	protected void hookControl(Control control) {
		super.hookControl(control);
		Tree treeControl = (Tree) control;
		treeControl.addMouseListener(new MouseAdapter() {
			public void mouseDown(MouseEvent e) {
				treeViewerImpl.handleMouseDown(e);
			}
		});
		if ((treeControl.getStyle() & SWT.VIRTUAL) != 0) {
			treeControl.addListener(SWT.SetData, new Listener(){

				public void handleEvent(Event event) {
					if (getContentProvider() instanceof ILazyTreeContentProvider) {
						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
	 * <code>ILabelProvider</code>.
	 */
	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 (!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)items[i]).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())) {
			updateItem(tree.getItem(index), element);
		} else {
			Widget[] parentItems = findItems(parent);
			for (int i = 0; i < parentItems.length; i++) {
				TreeItem item = ((TreeItem) parentItems[i]).getItem(index);
				updateItem(item, 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) {
    		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();
    		}
    		int childCount;
    		if (widget instanceof Tree) {
    			childCount = ((Tree) widget).getItemCount();
    		} else {
    			childCount = ((TreeItem) widget).getItemCount();
    		}
    		if (element != null && childCount > 0) {
    			for (int i = 0; i < childCount; 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;
    			ti.setItemCount(ti.getItemCount() + 1);
    			ti.clearAll(false);
    		} else {
    			Tree t = (Tree) widget;
    			t.setItemCount(t.getItemCount() + 1);
    			t.clearAll(false);
    		}
    		return;
    	}
    	super.internalAdd(widget, parentElement, childElements);
    }

	protected 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);
		}
	}
}