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

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

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

#include "qabstractitemview.h"

#ifndef QT_NO_ITEMVIEWS

#include <qpointer.h>

#include <qapplication.h>

#include <qclipboard.h>

#include <qpainter.h>

#include <qstyle.h>

#include <qdrag.h>

#include <qevent.h>

#include <qscrollbar.h>

#include <qwhatsthis.h>

#include <qtooltip.h>

#include <qdatetime.h>

#include <qlineedit.h>

#include <qspinbox.h>

#include <qstyleditemdelegate.h>

#include <private/qabstractitemview_p.h>

#include <private/qabstractitemmodel_p.h>

#ifndef QT_NO_ACCESSIBILITY

#include <qaccessible.h>

#endif

#include <private/qsoftkeymanager_p.h>

QT_BEGIN_NAMESPACE

QAbstractItemViewPrivate::QAbstractItemViewPrivate()

    :   model(QAbstractItemModelPrivate::staticEmptyModel()),

        itemDelegate(0),

        selectionModel(0),

        ctrlDragSelectionFlag(QItemSelectionModel::NoUpdate),

        noSelectionOnMousePress(false),

        selectionMode(QAbstractItemView::ExtendedSelection),

        selectionBehavior(QAbstractItemView::SelectItems),

        currentlyCommittingEditor(0),

        pressedModifiers(Qt::NoModifier),

        pressedPosition(QPoint(-1, -1)),

        pressedAlreadySelected(false),

        viewportEnteredNeeded(false),

        state(QAbstractItemView::NoState),

        editTriggers(QAbstractItemView::DoubleClicked|QAbstractItemView::EditKeyPressed),

        lastTrigger(QAbstractItemView::NoEditTriggers),

        tabKeyNavigation(false),

#ifndef QT_NO_DRAGANDDROP

        showDropIndicator(true),

        dragEnabled(false),

        dragDropMode(QAbstractItemView::NoDragDrop),

        overwrite(false),

        dropIndicatorPosition(QAbstractItemView::OnItem),

        defaultDropAction(Qt::IgnoreAction),

#endif

#ifdef QT_SOFTKEYS_ENABLED

        doneSoftKey(0),

#endif

        autoScroll(true),

        autoScrollMargin(16),

        autoScrollCount(0),

        shouldScrollToCurrentOnShow(false),

        shouldClearStatusTip(false),

        alternatingColors(false),

        textElideMode(Qt::ElideRight),

        verticalScrollMode(QAbstractItemView::ScrollPerItem),

        horizontalScrollMode(QAbstractItemView::ScrollPerItem),

        currentIndexSet(false),

        wrapItemText(false),

        delayedPendingLayout(false)

{

}

QAbstractItemViewPrivate::~QAbstractItemViewPrivate()

{

}

void QAbstractItemViewPrivate::init()

{

    Q_Q(QAbstractItemView);

    q->setItemDelegate(new QStyledItemDelegate(q));

    vbar->setRange(0, 0);

    hbar->setRange(0, 0);

    QObject::connect(vbar, SIGNAL(actionTriggered(int)),

                     q, SLOT(verticalScrollbarAction(int)));

    QObject::connect(hbar, SIGNAL(actionTriggered(int)),

                     q, SLOT(horizontalScrollbarAction(int)));

    QObject::connect(vbar, SIGNAL(valueChanged(int)),

                     q, SLOT(verticalScrollbarValueChanged(int)));

    QObject::connect(hbar, SIGNAL(valueChanged(int)),

                     q, SLOT(horizontalScrollbarValueChanged(int)));

    viewport->setBackgroundRole(QPalette::Base);

    doDelayedItemsLayout();

    q->setAttribute(Qt::WA_InputMethodEnabled);

#ifdef QT_SOFTKEYS_ENABLED

    doneSoftKey = QSoftKeyManager::createKeyedAction(QSoftKeyManager::DoneSoftKey, Qt::Key_Back, q);

#endif

}

void QAbstractItemViewPrivate::setHoverIndex(const QPersistentModelIndex &index)

{

    Q_Q(QAbstractItemView);

    if (hover == index)

        return;

    if (selectionBehavior != QAbstractItemView::SelectRows) {

        q->update(hover); //update the old one

        q->update(index); //update the new one

    } else {

        QRect oldHoverRect = q->visualRect(hover);

        QRect newHoverRect = q->visualRect(index);

        viewport->update(QRect(0, newHoverRect.y(), viewport->width(), newHoverRect.height()));

        viewport->update(QRect(0, oldHoverRect.y(), viewport->width(), oldHoverRect.height()));

    }

    hover = index;

}

void QAbstractItemViewPrivate::checkMouseMove(const QPersistentModelIndex &index)

{

    //we take a persistent model index because the model might change by emitting signals

    Q_Q(QAbstractItemView);

    setHoverIndex(index);

    if (viewportEnteredNeeded || enteredIndex != index) {

        viewportEnteredNeeded = false;

        if (index.isValid()) {

            emit q->entered(index);

#ifndef QT_NO_STATUSTIP

            QString statustip = model->data(index, Qt::StatusTipRole).toString();

            if (parent && (shouldClearStatusTip || !statustip.isEmpty())) {

                QStatusTipEvent tip(statustip);

                QApplication::sendEvent(parent, &tip);

                shouldClearStatusTip = !statustip.isEmpty();

            }

#endif

        } else {

#ifndef QT_NO_STATUSTIP

            if (parent && shouldClearStatusTip) {

                QString emptyString;

                QStatusTipEvent tip( emptyString );

                QApplication::sendEvent(parent, &tip);

            }

#endif

            emit q->viewportEntered();

        }

        enteredIndex = index;

    }

}

/*!

    \class QAbstractItemView

    \brief The QAbstractItemView class provides the basic functionality for

    item view classes.

    \ingroup model-view

    QAbstractItemView class is the base class for every standard view

    that uses a QAbstractItemModel. QAbstractItemView is an abstract

    class and cannot itself be instantiated. It provides a standard

    interface for interoperating with models through the signals and

    slots mechanism, enabling subclasses to be kept up-to-date with

    changes to their models.  This class provides standard support for

    keyboard and mouse navigation, viewport scrolling, item editing,

    and selections. The keyboard navigation implements this

    functionality:

    \table

        \header

            \o Keys

            \o Functionality

        \row

            \o Arrow keys

            \o Changes the current item and selects it.

        \row

            \o Ctrl+Arrow keys

            \o Changes the current item but does not select it.

        \row

            \o Shift+Arrow keys

            \o Changes the current item and selects it. The previously

               selected item(s) is not deselected.

        \row

            \o Ctr+Space

            \o Toggles selection of the current item.

        \row

            \o Tab/Backtab

            \o Changes the current item to the next/previous item.

        \row

            \o Home/End

            \o Selects the first/last item in the model.

        \row

            \o Page up/Page down

            \o Scrolls the rows shown up/down by the number of

               visible rows in the view.

        \row

            \o Ctrl+A

            \o Selects all items in the model.

    \endtable

    Note that the above table assumes that the

    \l{selectionMode}{selection mode} allows the operations. For

    instance, you cannot select items if the selection mode is

    QAbstractItemView::NoSelection.

    The QAbstractItemView class is one of the \l{Model/View Classes}

    and is part of Qt's \l{Model/View Programming}{model/view framework}.

    The view classes that inherit QAbstractItemView only need

    to implement their own view-specific functionality, such as

    drawing items, returning the geometry of items, finding items,

    etc.

    QAbstractItemView provides common slots such as edit() and

    setCurrentIndex(). Many protected slots are also provided, including

    dataChanged(), rowsInserted(), rowsAboutToBeRemoved(), selectionChanged(),

    and currentChanged().

    The root item is returned by rootIndex(), and the current item by

    currentIndex(). To make sure that an item is visible use

    scrollTo().

    Some of QAbstractItemView's functions are concerned with

    scrolling, for example setHorizontalScrollMode() and

    setVerticalScrollMode(). To set the range of the scroll bars, you

    can, for example, reimplement the view's resizeEvent() function:

    \snippet doc/src/snippets/code/src_gui_itemviews_qabstractitemview.cpp 0

    Note that the range is not updated until the widget is shown.

    Several other functions are concerned with selection control; for

    example setSelectionMode(), and setSelectionBehavior(). This class

    provides a default selection model to work with

    (selectionModel()), but this can be replaced by using

    setSelectionModel() with an instance of QItemSelectionModel.

    For complete control over the display and editing of items you can

    specify a delegate with setItemDelegate().

    QAbstractItemView provides a lot of protected functions. Some are

    concerned with editing, for example, edit(), and commitData(),

    whilst others are keyboard and mouse event handlers.

    \note If you inherit QAbstractItemView and intend to update the contents

    of the viewport, you should use viewport->update() instead of

    \l{QWidget::update()}{update()} as all painting operations take place on the

    viewport.

    \sa {View Classes}, {Model/View Programming}, QAbstractItemModel, {Chart Example}

*/

/*!

    \enum QAbstractItemView::SelectionMode

    This enum indicates how the view responds to user selections:

    \value SingleSelection  When the user selects an item, any already-selected

    item becomes unselected, and the user cannot unselect the selected item by

    clicking on it.

    \value ContiguousSelection When the user selects an item in the usual way,

    the selection is cleared and the new item selected. However, if the user

    presses the Shift key while clicking on an item, all items between the

    current item and the clicked item are selected or unselected, depending on

    the state of the clicked item.

    \value ExtendedSelection When the user selects an item in the usual way,

    the selection is cleared and the new item selected. However, if the user

    presses the Ctrl key when clicking on an item, the clicked item gets

    toggled and all other items are left untouched. If the user presses the

    Shift key while clicking on an item, all items between the current item

    and the clicked item are selected or unselected, depending on the state of

    the clicked item. Multiple items can be selected by dragging the mouse over

    them.

    \value MultiSelection When the user selects an item in the usual way, the

    selection status of that item is toggled and the other items are left

    alone. Multiple items can be toggled by dragging the mouse over them.

    \value NoSelection Items cannot be selected.

    The most commonly used modes are SingleSelection and ExtendedSelection.

*/

/*!

    \enum QAbstractItemView::SelectionBehavior

    \value SelectItems   Selecting single items.

    \value SelectRows    Selecting only rows.

    \value SelectColumns Selecting only columns.

*/

/*!

    \enum QAbstractItemView::ScrollHint

    \value EnsureVisible  Scroll to ensure that the item is visible.

    \value PositionAtTop  Scroll to position the item at the top of the

           viewport.

    \value PositionAtBottom  Scroll to position the item at the bottom of the

           viewport.

    \value PositionAtCenter  Scroll to position the item at the center of the

           viewport.

*/

/*!

    \enum QAbstractItemView::EditTrigger

    This enum describes actions which will initiate item editing.

    \value NoEditTriggers  No editing possible.

    \value CurrentChanged  Editing start whenever current item changes.

    \value DoubleClicked   Editing starts when an item is double clicked.

    \value SelectedClicked Editing starts when clicking on an already selected

           item.

    \value EditKeyPressed  Editing starts when the platform edit key has been

           pressed over an item.

    \value AnyKeyPressed   Editing starts when any key is pressed over an item.

    \value AllEditTriggers Editing starts for all above actions.

*/

/*!

    \enum QAbstractItemView::CursorAction

    This enum describes the different ways to navigate between items,

    \sa moveCursor()

    \value MoveUp       Move to the item above the current item.

    \value MoveDown     Move to the item below the current item.

    \value MoveLeft     Move to the item left of the current item.

    \value MoveRight    Move to the item right of the current item.

    \value MoveHome     Move to the top-left corner item.

    \value MoveEnd      Move to the bottom-right corner item.

    \value MovePageUp   Move one page up above the current item.

    \value MovePageDown Move one page down below the current item.

    \value MoveNext     Move to the item after the current item.

    \value MovePrevious Move to the item before the current item.

*/

/*!

    \enum QAbstractItemView::State

    Describes the different states the view can be in. This is usually

    only interesting when reimplementing your own view.

    \value NoState        The is the default state.

    \value DraggingState  The user is dragging items.

    \value DragSelectingState The user is selecting items.

    \value EditingState   The user is editing an item in a widget editor.

    \value ExpandingState   The user is opening a branch of items.

    \value CollapsingState   The user is closing a branch of items.

    \value AnimatingState The item view is performing an animation.

*/

/*!

    \since 4.2

    \enum QAbstractItemView::ScrollMode

    \value ScrollPerItem    The view will scroll the contents one item at a time.

    \value ScrollPerPixel   The view will scroll the contents one pixel at a time.

*/

/*!

    \fn QRect QAbstractItemView::visualRect(const QModelIndex &index) const = 0

    Returns the rectangle on the viewport occupied by the item at \a index.

    If your item is displayed in several areas then visualRect should return

    the primary area that contains index and not the complete area that index

    might encompasses, touch or cause drawing.

    In the base class this is a pure virtual function.

    \sa indexAt(), visualRegionForSelection()

*/

/*!

    \fn void QAbstractItemView::scrollTo(const QModelIndex &index, ScrollHint hint) = 0

    Scrolls the view if necessary to ensure that the item at \a index

    is visible. The view will try to position the item according to the given \a hint.

    In the base class this is a pure virtual function.

*/

/*!

    \fn QModelIndex QAbstractItemView::indexAt(const QPoint &point) const = 0

    Returns the model index of the item at the viewport coordinates \a point.

    In the base class this is a pure virtual function.

    \sa visualRect()

*/

/*!

    \fn void QAbstractItemView::activated(const QModelIndex &index)

    This signal is emitted when the item specified by \a index is

    activated by the user. How to activate items depends on the

    platform; e.g., by single- or double-clicking the item, or by

    pressing the Return or Enter key when the item is current.

    \sa clicked(), doubleClicked(), entered(), pressed()

*/

/*!

    \fn void QAbstractItemView::entered(const QModelIndex &index)

    This signal is emitted when the mouse cursor enters the item

    specified by \a index.

    Mouse tracking needs to be enabled for this feature to work.

    \sa viewportEntered(), activated(), clicked(), doubleClicked(), pressed()

*/

/*!

    \fn void QAbstractItemView::viewportEntered()

    This signal is emitted when the mouse cursor enters the viewport.

    Mouse tracking needs to be enabled for this feature to work.

    \sa entered()

*/

/*!

    \fn void QAbstractItemView::pressed(const QModelIndex &index)

    This signal is emitted when a mouse button is pressed. The item

    the mouse was pressed on is specified by \a index. The signal is

    only emitted when the index is valid.

    Use the QApplication::mouseButtons() function to get the state

    of the mouse buttons.

    \sa activated(), clicked(), doubleClicked(), entered()

*/

/*!

    \fn void QAbstractItemView::clicked(const QModelIndex &index)

    This signal is emitted when a mouse button is clicked. The item

    the mouse was clicked on is specified by \a index. The signal is

    only emitted when the index is valid.

    \sa activated(), doubleClicked(), entered(), pressed()

*/

/*!

    \fn void QAbstractItemView::doubleClicked(const QModelIndex &index)

    This signal is emitted when a mouse button is double-clicked. The

    item the mouse was double-clicked on is specified by \a index.

    The signal is only emitted when the index is valid.

    \sa clicked(), activated()

*/

/*!

    \fn QModelIndex QAbstractItemView::moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers) = 0

    Returns a QModelIndex object pointing to the next object in the view,

    based on the given \a cursorAction and keyboard modifiers specified

    by \a modifiers.

    In the base class this is a pure virtual function.

*/

/*!

    \fn int QAbstractItemView::horizontalOffset() const = 0

    Returns the horizontal offset of the view.

    In the base class this is a pure virtual function.

    \sa verticalOffset()

*/

/*!

    \fn int QAbstractItemView::verticalOffset() const = 0