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

 * Copyright (c) 2000, 2007 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 - Qt implementation

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

package org.eclipse.swt.widgets;

import org.eclipse.swt.SWT;

import org.eclipse.swt.SWTException;

import org.eclipse.swt.events.ControlEvent;

import org.eclipse.swt.events.ControlListener;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.graphics.Rectangle;

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

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

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

/** 

 * Instances of this class implement a selectable user interface

 * object that displays a list of images and strings and issues

 * notification when selected.

 * <p>

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

 * must be of type <code>TableItem</code>.

 * </p><p>

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

 * <code>TableItem</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

 * tables that are very large or for which <code>TableItem</code> population is

 * expensive (for example, retrieving values from an external source).

 * </p><p>

 * Here is an example of using a <code>Table</code> with style <code>VIRTUAL</code>:

 * <code><pre>

 *  final Table table = new Table (parent, SWT.VIRTUAL | SWT.BORDER);

 *  table.setItemCount (1000000);

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

 *      public void handleEvent (Event event) {

 *          TableItem item = (TableItem) event.item;

 *          int index = table.indexOf (item);

 *          item.setText ("Item " + index);

 *          System.out.println (item.getText ());

 *      }

 *  }); 

 * </pre></code>

 * </p><p>

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

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

 * or set a layout on it.

 * </p><p>

 * <dl>

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

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

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

 * <dd>Selection, DefaultSelection, SetData, MeasureItem, EraseItem, PaintItem</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 Table extends Composite {

    /*

     * Items and columns of the Table

     */

    TableItem[] items;

    TableColumn[] columns;

    /*

     * Number of valid items in items and columns arrays (the arrays can be

     * bigger than the amount of items stored in them)

     */

    int itemCount;

    int columnCount; 

    /*

     * The item that currently has focus

     */

    TableItem currentItem;

    /*

     * Minimum item height

     */

    int minimumHeight;

    /*

     * The row that contains the item with biggest preferred height

     */

    int heightRow;

    /*

     * The value returned in the last indexOf() call (in case the item was

     * not found from native QTableWidget. This value gets used when Table

     * is created with SWT.VIRTUAL style.

     */

    int lastIndexOf;

    /*

     * Key code that causes the state of check box to change. Internally focus

     * is always in some other QTableWidget cell than the one that has the 

     * check box, so we must intercept the state change key and change the check 

     * box state manually. 

     */

    int itemStateChangeKey;

    /*

     * Flags apiSelection and apiCheck are used to prevent us from sending

     * selection events when Table state is changed/items are selected through 

     * the API.

     */

    boolean apiSelection;

    boolean apiCheck;

    /*

     * This is used to store the state we think currently focused item is in.

     * If user changes the checked state by clicking on the check box we can

     * check in the signal handler if the current item's check state is the

     * one we think it is. If it's not, a selection event is generated.

     */

    boolean currentItemChecked;

    /*

     * This is used to store the image size of the Table (the first image that

     * is added to the Table sets the size of all images) 

     */

    Point imageSize = null;

    /*

     * Flag indicating if TableItem word wrap extension is in use.

     */

    boolean wrap;

    /*

     * Flag to indicate that selection is happening with mouse in RADIO 

     * style Table

     */

    boolean mouseSelection;

    /*

     * For press and relase mouse events are occured on the same item.

     */

    int oldIndex = -1;

    /**

     * 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 SWT#FULL_SELECTION

     * @see SWT#HIDE_SELECTION

     * @see SWT#VIRTUAL

     * @see Widget#checkSubclass

     * @see Widget#getStyle

     */

    public Table (Composite parent, int style) {

        this(parent, style, false);

    }

    /**

     * <p>

     * <b>IMPORTANT:</b> This constructor is <em>not</em> part of the SWT

     * public API. It should never be referenced from application code. 

     * </p>

     */

    protected Table(Composite parent, int style, boolean isExtended) {

        super (parent, checkStyle (style), 0, null, isExtended);

    }

    TableItem _getItem (int index) {

        if ((style & SWT.VIRTUAL) == 0) return items [index];

        if (items [index] != null) return items [index];    

        return items [index] = new TableItem (this, SWT.NONE, index, false);

    }

    static int checkStyle (int style) {

        /*

         * To be compatible with Windows, force the H_SCROLL

         * and V_SCROLL style bits.  On Windows, it is not

         * possible to create a table without scroll bars.

         */

        style |= SWT.FULL_SELECTION | SWT.H_SCROLL | SWT.V_SCROLL;

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

            style = style & (~SWT.RADIO);

        }

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

    }

    boolean checkData (TableItem item, int index) {

        if (item.cached) return true;

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

            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 (TableItem item) {

        return checkData(item, indexOf(item));

    }

    protected void checkSubclass () {

        if (!isValidSubclass ()) error (SWT.ERROR_INVALID_SUBCLASS);

    }

    int getBackgroundColorRole() {

        return OS.QPALETTE_COLORROLE_BASE;

    }

    int getFocusIndex() {

        checkWidget();

        return OS.QTableWidget_currentRow(topHandle);

    }

    int getForegroundColorRole() {

        return OS.QPALETTE_COLORROLE_TEXT;

    }

    /*

     * Gets the index of an item

     * @param item Item whose index is needed

     * @return the index or -1 if not found

     */

    int getItemIndex(TableItem item) {

        if (itemCount == 0 || items == null ||

            item == null || item.parent != this) return -1;

        int index = OS.QTableWidget_row(topHandle, item.topHandle());

        if (index != -1) return index;

        /**

         * Usually we don't come here at all, but in VIRTUAL style table case

         * we can be searching for an item that does not yet have a native counterpart.

         * In that case use the following algorithm (directly from the GTK implementation)

         *  - See if the wanted item is the one that was searched previously

         *    or a neighbor of the previously searched item

         *  - If last searched item was in the first half of the item list,

         *    start search from the beginning of the list

         *  - If not, start search from the end

         */

        if (1 <= lastIndexOf && lastIndexOf < itemCount - 1) {

            if (items [lastIndexOf] == item) return lastIndexOf;

            if (items [lastIndexOf + 1] == item) return ++lastIndexOf;

            if (items [lastIndexOf - 1] == item) return --lastIndexOf;

        }

        if (lastIndexOf < itemCount / 2) {

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

                if (items [i] == item) return lastIndexOf = i;

            }

        } else {

            for (int i=itemCount - 1; i>=0; --i) {

                if (items [i] == item) return lastIndexOf = i;

            }

        }

        return -1;

    }

    /*

     * Returns the native QTableWidget index of a column

     * @param index Java side index

     * @return native side index

     */

    int getNativeColumnIndex(int index) {

        /**

         * Native table always has check box column, although it may be 

         * invisible. Therefore native column index is always Java side

         * column index + 1.

         */

        return index + 1;

    }

    /*

     * Returns the native QTableWidget index of a column

     * @param column the TableColumn

     * @return native side index

     */

    int getNativeColumnIndex(TableColumn column) {

        int index = getColumnIndex(column);

        if (index != -1) return getNativeColumnIndex(index);

        return -1;

    }

    /*

     * Returns the Java side index of a column

     * @param column the TableColumn

     * @return Java side index

     */

    int getColumnIndex(TableColumn column) {

        if (columnCount == 0 || columns == null) return -1;

        for (int i = 0; i < columns.length; i++) {

            if (columns[i] == column) {

                return i;

            }

        }

        return -1;

    }

    /*

     * Returns the Java side index of the currently focused column

     * @return Java side index

     */

    int getCurrentColumnIndex() {

        return getCurrentColumnIndex(false);

    }

    /*

     * Returns the Native or Java side index of currently focused column

     * @param nativeIndex if true, return native side index, if false return Java side index

     * @return the index

     */

    int getCurrentColumnIndex(boolean nativeIndex) {

        int index = OS.QTableWidget_currentColumn(topHandle);

        if (nativeIndex) {

            return index;

        }

        // Native Table always has check box column which does not exist on

        // the Java side.

        if (index != -1) return index - 1;

        return index;

    }

    /*

     * Inserts a new TableColumn at index

     * @param column the new column

     * @param index index where column is inserted

     */

    void createColumn(TableColumn column, int index) {

        if (columnCount == columns.length) {

            int length = Math.max (4, columns.length * 3 / 2);

            TableColumn [] newColumns = new TableColumn [length]; 

            System.arraycopy (columns, 0, newColumns, 0, columns.length);

            columns = newColumns;

        }

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

        System.arraycopy (columns, index, columns, index + 1, columnCount++ - index);

        columns[index] = column;

        // If the table switched from list mode to column mode we don't need

        // to add a native column, it is already there.

        if (columnCount > 1) {

            OS.QTableWidget_insertColumn(topHandle, getNativeColumnIndex(index));

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

                items[i].addColumn(i, index);

            }

        }

    }

    /*

     * Inserts a new TableItem at index

     * @param item the new item

     * @param index index where item is inserted

     */

    void createItem (TableItem item, int index) {

        if (!(0 <= index && index <= itemCount)) error (SWT.ERROR_INVALID_RANGE);

        if (itemCount == items.length) {

            int length = Math.max (4, items.length * 3 / 2);

            TableItem [] newItems = new TableItem [length]; 

            System.arraycopy (items, 0, newItems, 0, items.length);

            items = newItems;

        }

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

        System.arraycopy (items, index, items, index + 1, itemCount++ - index);

        items[index] = item;

    }

    /*

     * Removes item from index

     * @param index index to remove from

     */

    void removeItem(int index) {

        if (!(0 <= index && index <= itemCount)) error (SWT.ERROR_INVALID_RANGE);

        TableItem item = _getItem(index);

        if (item != null && !item.isDisposed()) {

            // in radio style at least one button should select

            if ((style & SWT.SINGLE) != 0 && (style & SWT.RADIO) != 0 && itemCount > 1) {

                if(OS.QAbstractButton_isChecked(items[index].radioButtonHandle)){

                    if(index>0){

                        OS.QAbstractButton_setChecked(items[index-1].radioButtonHandle, true);

                    } else if(index == 0){

                        OS.QAbstractButton_setChecked(items[index+1].radioButtonHandle, true);

                    }

                }

            }

            item.release(false);

        }

        if (index == heightRow) heightRow = -1;

        OS.QTableWidget_removeRow(topHandle, index);

        System.arraycopy (items, index + 1, items, index, --itemCount - index);

        items [itemCount] = null;

    }

    /*

     * Updates the global image size for Table. After the image size has been set

     * once it cannot be reset.

     * @param width new width

     * @param height new height

     */

    void updateImageSize(int width, int height) {

        if (imageSize == null) {

            imageSize = new Point(width, height);

            OS.QAbstractItemView_setIconSize(topHandle, width, height);

        }

        if (imageSize.y > getItemHeight()) {

            updateRowHeight(false);

        }

    }

    /*

     * Sets row height for a single item in a wrap style Table

     */

    void updateRowHeight(TableItem item) {

        int handle = topHandle;

        int index = indexOf(item);

        if (wrap) {

            int height = OS.QTableView_rowHeight(handle, index);        

            int newHeight = OS.QAbstractItemView_sizeHintForRow(handle, index);

            if (imageSize != null && imageSize.y > newHeight) {

                newHeight = imageSize.y;

            }

            newHeight = Math.max(minimumHeight, newHeight);

            if (newHeight != height) {

                OS.QTableView_setRowHeight(handle, index, newHeight);

            }

        } else {

            int heightHint = OS.QAbstractItemView_sizeHintForRow(handle, index);

            int itemHeight = _getItemHeight();

            if (heightHint > itemHeight) {

                // If height hint is bigger than the current row height, no need

                // to go through the rest of the items, just set the new height

                heightHint = Math.max(minimumHeight, heightHint);

                heightRow = index;

                for (int row = 0; row < itemCount; row++) {

                    OS.QTableView_setRowHeight(handle, row, heightHint);

                }

            } else if (index == heightRow && heightHint < itemHeight) {

                // If the content of the row with bigger preferred height

                // changes, update the row heights

                updateRowHeight(false);

            }

        }

    }

    /*

     * Finds out if some row in the Table would want to be higher than the

     * current row height, and updates the row height if necessary.

     * If ignoreState == true, current state of the table is ignored and

     * the sizes are updated to all items regardless of it seems necessary

     * or not (needed for changing between wrap states).

     */

    void updateRowHeight(boolean ignoreState) {

        if (wrap) {

            int handle = topHandle;

            for (int row = 0; row < itemCount; row++) {

                int height = OS.QTableView_rowHeight(handle, row);

                int newHeight = OS.QAbstractItemView_sizeHintForRow(handle, row);

                if (imageSize != null && imageSize.y > newHeight) {

                    newHeight = imageSize.y;

                }

                newHeight = Math.max(minimumHeight, newHeight);

                if (newHeight != height) {

                    OS.QTableView_setRowHeight(handle, row, newHeight);

                }

            }

        } else {

            int itemHeight = getItemHeight();

            if (ignoreState) itemHeight = minimumHeight;

            int maxHeight = 0;

            int handle = topHandle;