/*******************************************************************************

 * Copyright (c) 2000, 2006 IBM Corporation and others.

 * Portion Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

 * 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

 *     Nokia Corporation - S60 implementation

 *     Nokia Corporation - Qt implementation

 *******************************************************************************/

package org.eclipse.swt.widgets;

import org.eclipse.swt.SWT;

import org.eclipse.swt.SWTException;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.events.TreeListener;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.internal.qt.OS;

import org.eclipse.swt.internal.qt.WidgetState;

/**

 * Instances of this class provide a selectable user interface object that

 * displays a hierarchy of items and issues notification when an item in the

 * hierarchy is selected.

 * <p>

 * The item children that may be added to instances of this class must be of

 * type <code>TreeItem</code>.

 * </p>

 * <p>

 * Style <code>VIRTUAL</code> is used to create a <code>Tree</code> whose

 * <code>TreeItem</code>s are to be populated by the client on an on-demand

 * basis instead of up-front. This can provide significant performance

 * improvements for trees that are very large or for which <code>TreeItem</code>

 * population is expensive (for example, retrieving values from an external

 * source).

 * </p>

 * <p>

 * 

 * Here is an example of using a <code>Tree</code> with style

 * <code>VIRTUAL</code>: <code><pre>

 *  final Tree tree = new Tree(parent, SWT.VIRTUAL | SWT.BORDER);

 *  tree.setItemCount(20);

 *  tree.addListener(SWT.SetData, new Listener() {

 *      public void handleEvent(Event event) {

 *          TreeItem item = (TreeItem)event.item;

 *          TreeItem parentItem = item.getParentItem();

 *          String text = null;

 *          if (parentItem == null) {

 *              text = "node " + tree.indexOf(item);

 *          } else {

 *              text = parentItem.getText() + " - " + parentItem.indexOf(item);

 *          }

 *          item.setText(text);

 *          System.out.println(text);

 *          item.setItemCount(10);

 *      }

 *  });

 * </pre></code>

 * </p>

 * <p>

 * Note that although this class is a subclass of <code>Composite</code>, it

 * does not normally make sense to add <code>Control</code> children to it, or

 * set a layout on it, unless implementing something like a cell editor.

 * </p>

 * <p>

 * 

 * <dl>

 * <dt><b>Styles:</b></dt>

 * <dd>SINGLE, MULTI, CHECK, VIRTUAL</dd>

 * <dt><b>Events:</b></dt>

 * <dd>Selection, DefaultSelection, Collapse, Expand, SetData,</dd>

 * </dl>

 * </p>

 * <p>

 * 

 * Note: Only one of the styles SINGLE and MULTI may be specified.

 * </p>

 * <p>

 * IMPORTANT: This class is <em>not</em> intended to be subclassed.

 * </p>

 **/

public class Tree extends Composite {

    static int checkStyle(int style) {

        style |= SWT.H_SCROLL | SWT.V_SCROLL;

        return checkBits(style, SWT.SINGLE, SWT.MULTI, 0, 0, 0, 0);

    }

    // The root items of the Tree.

    TreeItem[] topLevelItems;

    int topLevelItemCount;

    boolean ignoreSelectionEvent;

    boolean ignoreExpandEvent;

    int[] topLevelItemsHandle;

    // Tells if any item has expanded used for SWT.VIRTUAL style Tree

    int expandedItemCount = 0;

    /**

     * Constructs a new instance of this class given its parent and a style

     * value describing its behavior and appearance.

     * <p>

     * The style value is either one of the style constants defined in class

     * <code>SWT</code> which is applicable to instances of this class, or must

     * be built by <em>bitwise OR</em>'ing together (that is, using the

     * <code>int</code> "|" operator) two or more of those <code>SWT</code>

     * style constants. The class description lists the style constants that are

     * applicable to the class. Style bits are also inherited from superclasses.

     * </p>

     * 

     * @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

     *                <ul>

     *                <li>ERROR_NULL_ARGUMENT - if the parent is null</li>

     *                </ul>

     * @exception SWTException

     *                <ul>

     *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the

     *                thread that created the parent</li>

     *                <li>ERROR_INVALID_SUBCLASS - if this class is not an

     *                allowed subclass</li>

     *                </ul>

     * 

     * @see SWT#SINGLE

     * @see SWT#MULTI

     * @see SWT#CHECK

     * @see Widget#checkSubclass

     * @see Widget#getStyle

     */

    public Tree(Composite parent, int style) {

        super(parent, checkStyle(style));

    }

    TreeItem _getItem(int index) {

        if ((style & SWT.VIRTUAL) == 0)

            return topLevelItems[index];

        if (topLevelItems[index] != null)

            return topLevelItems[index];

        return topLevelItems[index] = new TreeItem(this, SWT.NONE, index, false);

    }

    void _showItem(TreeItem item, int aScrollHint ){

        if (item == null)

            error(SWT.ERROR_NULL_ARGUMENT);

        if (item.isDisposed())

            error(SWT.ERROR_INVALID_ARGUMENT);

        if (item.getParent() != this)

            return;

        int itemHandle = item.internal_itemHandle();

        if((style & SWT.VIRTUAL)!=0 && !item.cached){

            TreeItem parentItem = item.getParentItem();

            if(parentItem!=null) {

                for(int i=0;i<parentItem.childrenItemCount;i++){

                    if(item==parentItem.childrenItems[i]){ 

                        itemHandle = parentItem.childrenItemsHandle[i];

                        break;

                    }

                }

            } else {

                for(int i=0;i<topLevelItemCount;i++){

                    if(item==topLevelItems[i]){ 

                        itemHandle = topLevelItemsHandle[i];

                        break;

                    }

                }

            }

        }

        OS.QTreeWidget_scrollToItem(topHandle, itemHandle, aScrollHint);

    }

    /**

     * Adds the listener to the collection of listeners who will be notified

     * when the receiver's selection changes, by sending it one of the messages

     * defined in the <code>SelectionListener</code> interface.

     * <p>

     * When <code>widgetSelected</code> is called, the item field of the event

     * object is valid. If the reciever has <code>SWT.CHECK</code> style set and

     * the check selection changes, the event object detail field contains the

     * value <code>SWT.CHECK</code>. <code>widgetDefaultSelected</code> is

     * typically called when an item is double-clicked. The item field of the

     * event object is valid for default selection, but the detail field is not

     * used.

     * </p>

     * 

     * @param listener

     *            the listener which should be notified

     * 

     * @exception IllegalArgumentException

     *                <ul>

     *                <li>ERROR_NULL_ARGUMENT - if the listener is null</li>

     *                </ul>

     * @exception SWTException

     *                <ul>

     *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been

     *                disposed</li>

     *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the

     *                thread that created the receiver</li>

     *                </ul>

     * 

     * @see SelectionListener

     * @see #removeSelectionListener

     * @see SelectionEvent

     */

    public void addSelectionListener(SelectionListener listener) {

        checkWidget();

        if (listener == null)

            error(SWT.ERROR_NULL_ARGUMENT);

        TypedListener typedListener = new TypedListener(listener);

        addListener(SWT.Selection, typedListener);

        addListener(SWT.DefaultSelection, typedListener);

    }

    /*

     * Add a new child to the Tree's list of children. Add the item at the given

     * index. An index of -1 implies that the child should be added to the end

     * of the Tree's list of children.

     */

    void addTopLevelItem(TreeItem item, int index, int itemHandle) {

        if (!(0 <= index && index <= topLevelItemCount))

            error(SWT.ERROR_INVALID_RANGE);

        increaseArraySize();

        // Put the new item in the correct place in item array

        System.arraycopy(topLevelItems, index, topLevelItems, index + 1,

                topLevelItemCount + 1 - index);

        topLevelItems[index] = item;

        // itemCount is already increase in the previous line.

        System.arraycopy(topLevelItemsHandle, index, topLevelItemsHandle,

                index + 1, topLevelItemCount + 1 - index);

        topLevelItemsHandle[index] = itemHandle;

        topLevelItemCount++;

    }

    /**

     * Adds the listener to the collection of listeners who will be notified

     * when an item in the receiver is expanded or collapsed by sending it one

     * of the messages defined in the <code>TreeListener</code> interface.

     * 

     * @param listener

     *            the listener which should be notified

     * 

     * @exception IllegalArgumentException

     *                <ul>

     *                <li>ERROR_NULL_ARGUMENT - if the listener is null</li>

     *                </ul>

     * @exception SWTException

     *                <ul>

     *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been

     *                disposed</li>

     *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the

     *                thread that created the receiver</li>

     *                </ul>

     * 

     * @see TreeListener

     * @see #removeTreeListener

     */

    public void addTreeListener(TreeListener listener) {

        checkWidget();

        if (listener == null)

            error(SWT.ERROR_NULL_ARGUMENT);

        TypedListener typedListener = new TypedListener(listener);

        addListener(SWT.Expand, typedListener);

        addListener(SWT.Collapse, typedListener);

    }

    boolean checkData(TreeItem item, int index) {

        if (item.cached)

            return true;

        if ((style & SWT.VIRTUAL) != 0) {

            if (index == -1)

                return false;

            Event event = new Event();

            event.item = item;

            event.index = index;

            item.ensureValid(index);

            sendEvent(SWT.SetData, event);

            if (isDisposed())

                return false;

            if (item.isDisposed())

                return false;

        }

        if (isDisposed())

            return false;

        if (item == null || item.isDisposed())

            return false;

        return true;

    }

    boolean checkData(TreeItem item, TreeItem parentItem) {

        return checkData(item, parentItem == null ? getItemIndex(item)

                : parentItem.getChildItemIndex(item));

    }

    protected void checkSubclass() {

        if (!isValidSubclass())

            error(SWT.ERROR_INVALID_SUBCLASS);

    }

    void clearSelection(){

        for(int i=0;i<topLevelItemCount;i++){

            TreeItem topItem = _getItem(i);

            topItem.selection=false;

            topItem.clearSelection();

        }

    }

    void createHandle_pp(int index) {

        topHandle = scrollAreaHandle = frameHandle = OS.QTreeWidget_new();

        handle = OS.QAbstractScrollArea_viewPort(topHandle);

        state |= WidgetState.HANDLE;

        state &= ~WidgetState.CANVAS;

        OS.QTreeWidget_setColumnCount(topHandle, 1);

        // Set up selection mode (MULTI/SINGLE)

        if ((style & SWT.MULTI) != 0) {

            OS.QAbstractItemView_setSelectionMode(topHandle,

                    OS.QT_ABSTRACTITEMVIEW_SELECTIONMODE_MULTI);

        } else {

            OS.QAbstractItemView_setSelectionMode(topHandle,

                    OS.QT_ABSTRACTITEMVIEW_SELECTIONMODE_SINGLE);

        }

        OS.QTreeWidget_swt_setHeaderVisible(topHandle, false);

    }

    void createWidget(int index) {

        super.createWidget(index);

        topLevelItems = new TreeItem[4];

        topLevelItemCount = 0;

        topLevelItemsHandle = new int[4];

    }

    /**

     * Deselects all selected items in the receiver.

     * 

     * @exception SWTException

     *                <ul>

     *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been

     *                disposed</li>

     *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the

     *                thread that created the receiver</li>

     *                </ul>

     */

    public void deselectAll() {

        checkWidget();

        if ((style & SWT.SINGLE) != 0) {

            return;

        }

        ignoreSelectionEvent = true;

        OS.QAbstractItemView_clearSelection(topHandle);

        if((style&SWT.VIRTUAL)!=0){

            clearSelection();

        }

        ignoreSelectionEvent = false;

    }

    /*

     *  Its a recursive function executed only in virtual tree style.

     *  It takes item handle as a parameter, finds and return. If it 

     *  can't find the item with that handle it just returns null. 

     */

    TreeItem findParentItem(int itemHandle) {

        TreeItem item = null;

        for (int i = 0; i < topLevelItemCount; i++) {

            if (topLevelItemsHandle[i] == itemHandle) {

                item = _getItem(i);

                break;

            } else {

                TreeItem topLevelItem = _getItem(i);

                if(topLevelItem.cached){

                    if (topLevelItem.getExpanded()) {

                        item = topLevelItem.findItem(itemHandle);

                    }}

                if (item != null)

                    break;

            }

        }

        return item;

    }

    /**

     * Returns the item at the given point in the receiver or null if no such

     * item exists. The point is in the coordinate system of the receiver.

     * 

     * @param point

     *            the point used to locate the item

     * @return the item at the given point

     * 

     * @exception IllegalArgumentException

     *                <ul>

     *                <li>ERROR_NULL_ARGUMENT - if the point is null</li>

     *                </ul>

     * @exception SWTException

     *                <ul>

     *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been

     *                disposed</li>

     *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the

     *                thread that created the receiver</li>

     *                </ul>

     */

    public TreeItem getItem(Point point) {

        checkWidget();

        if (point == null)

            error(SWT.ERROR_NULL_ARGUMENT);

        int itemHandle = OS.QTreeWidget_itemAt(topHandle, point.x,

                point.y);

        if (itemHandle == -1)

            return null;

        TreeItem item = null;

        for (int i = 0; i < topLevelItemCount; i++) {

            if (topLevelItemsHandle[i] == itemHandle) {

                item = _getItem(i);

                break;

            } else {

                item = _getItem(i).getItem(itemHandle);

                if (item != null)

                    break;

            }

        }

        return item;

    }

    /**

     * Returns the number of items contained in the receiver that are direct

     * item children of the receiver. The number that is returned is the number

     * of roots in the tree.

     * 

     * @return the number of items

     * 

     * @exception SWTException

     *                <ul>

     *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been

     *                disposed</li>

     *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the

     *                thread that created the receiver</li>

     *                </ul>

     */

    public int getItemCount() {

        checkWidget();

        return topLevelItemCount;

    }

    /**

     * Returns the height of the area which would be used to display

     * <em>one</em> of the items in the tree.

     * 

     * @return the height of one item

     * 

     * @exception SWTException

     *                <ul>

     *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been

     *                disposed</li>

     *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the

     *                thread that created the receiver</li>

     *                </ul>

     */

    public int getItemHeight() {

        checkWidget();

        int itemHeight = 0;

        if (topLevelItemCount > 0) {

            itemHeight = OS.QAbstractItemView_sizeHintForRow(

                    topHandle, 0);

        } else {

            OS.QTreeWidget_addTopLevelItem(topHandle, OS

                    .QTreeWidgetItem_new());

            itemHeight = OS.QAbstractItemView_sizeHintForRow(

                    topHandle, 0);

            OS.QTreeWidget_clear(topHandle);

        }

        return itemHeight;

    }

    int getItemIndex(TreeItem item) {

        if (item == null)

            error(SWT.ERROR_NULL_ARGUMENT);

        if (topLevelItemCount == 0 || topLevelItems == null || item.getParent() != this)

            return -1;

        return OS.QTreeWidget_indexOfTopLevelItem(topHandle,

                item.internal_itemHandle());

    }

    /**

     * Returns a (possibly empty) array of items contained in the receiver that

     * are direct item children of the receiver. These

     * <p>

     * 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.

     * </p>

     * 

     * @return the items

     * 

     * @exception SWTException

     *                <ul>

     *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been

     *                disposed</li>

     *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the

     *                thread that created the receiver</li>

     *                </ul>

     */

    public TreeItem[] getItems() {

        checkWidget();

        if (topLevelItemCount == 0)

            return new TreeItem[0];

        TreeItem[] result = new TreeItem[topLevelItemCount];

        if ((style & SWT.VIRTUAL) != 0) {

            for (int i = 0; i < topLevelItemCount; i++) {

                result[i] = _getItem(i);

                checkData(result[i], i);