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

**

** Copyright (C) 2009 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 "qstyleditemdelegate.h"

#ifndef QT_NO_ITEMVIEWS

#include <qabstractitemmodel.h>

#include <qapplication.h>

#include <qbrush.h>

#include <qlineedit.h>

#include <qtextedit.h>

#include <qplaintextedit.h>

#include <qpainter.h>

#include <qpalette.h>

#include <qpoint.h>

#include <qrect.h>

#include <qsize.h>

#include <qstyle.h>

#include <qdatetime.h>

#include <qstyleoption.h>

#include <qevent.h>

#include <qpixmap.h>

#include <qbitmap.h>

#include <qpixmapcache.h>

#include <qitemeditorfactory.h>

#include <private/qitemeditorfactory_p.h>

#include <qmetaobject.h>

#include <qtextlayout.h>

#include <private/qobject_p.h>

#include <private/qdnd_p.h>

#include <private/qtextengine_p.h>

#include <private/qlayoutengine_p.h>

#include <qdebug.h>

#include <qlocale.h>

#include <qdialog.h>

#include <qtableview.h>

#include <limits.h>

QT_BEGIN_NAMESPACE

class QStyledItemDelegatePrivate : public QObjectPrivate

{

    Q_DECLARE_PUBLIC(QStyledItemDelegate)

public:

    QStyledItemDelegatePrivate() : factory(0) { }

    static const QWidget *widget(const QStyleOptionViewItem &option)

    {

        if (const QStyleOptionViewItemV3 *v3 = qstyleoption_cast<const QStyleOptionViewItemV3 *>(&option))

            return v3->widget;

        return 0;

    }

    const QItemEditorFactory *editorFactory() const

    {

        return factory ? factory : QItemEditorFactory::defaultFactory();

    }

    void _q_commitDataAndCloseEditor(QWidget *editor)

    {

        Q_Q(QStyledItemDelegate);

        emit q->commitData(editor);

        emit q->closeEditor(editor, QAbstractItemDelegate::SubmitModelCache);

    }

    QItemEditorFactory *factory;

};

/*!

    \class QStyledItemDelegate

    \brief The QStyledItemDelegate class provides display and editing facilities for

    data items from a model.

    \ingroup model-view

    \since 4.4

    When displaying data from models in Qt item views, e.g., a

    QTableView, the individual items are drawn by a delegate. Also,

    when an item is edited, it provides an editor widget, which is

    placed on top of the item view while editing takes place.

    QStyledItemDelegate is the default delegate for all Qt item

    views, and is installed upon them when they are created.

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

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

    framework}. The delegate allows the display and editing of items

    to be developed independently from the model and view.

    The data of items in models are assigned an

    \l{Qt::}{ItemDataRole}; each item can store a QVariant for each

    role. QStyledItemDelegate implements display and editing for the

    most common datatypes expected by users, including booleans,

    integers, and strings.

    The data will be drawn differently depending on which role they

    have in the model. The following table describes the roles and the

    data types the delegate can handle for each of them. It is often

    sufficient to ensure that the model returns appropriate data for

    each of the roles to determine the appearance of items in views.

    \table

    \header \o Role \o Accepted Types

    \omit

    \row    \o \l Qt::AccessibleDescriptionRole \o QString

    \row    \o \l Qt::AccessibleTextRole \o QString

    \endomit

    \row    \o \l Qt::BackgroundRole \o QBrush

    \row    \o \l Qt::BackgroundColorRole \o QColor (obsolete; use Qt::BackgroundRole instead)

    \row    \o \l Qt::CheckStateRole \o Qt::CheckState

    \row    \o \l Qt::DisplayRole \o QString and types with a string representation

    \row    \o \l Qt::EditRole \o See QItemEditorFactory for details

    \row    \o \l Qt::FontRole \o QFont

    \row    \o \l Qt::SizeHintRole \o QSize

    \omit

    \row    \o \l Qt::StatusTipRole \o

    \endomit

    \row    \o \l Qt::TextAlignmentRole \o Qt::Alignment

    \row    \o \l Qt::ForegroundRole \o QBrush

    \row    \o \l Qt::TextColorRole \o QColor (obsolete; use Qt::ForegroundRole instead)

    \omit

    \row    \o \l Qt::ToolTipRole

    \row    \o \l Qt::WhatsThisRole

    \endomit

    \endtable

    Editors are created with a QItemEditorFactory; a default static

    instance provided by QItemEditorFactory is installed on all item

    delegates. You can set a custom factory using

    setItemEditorFactory() or set a new default factory with

    QItemEditorFactory::setDefaultFactory(). It is the data stored in

    the item model with the \l{Qt::}{EditRole} that is edited. See the

    QItemEditorFactory class for a more high-level introduction to

    item editor factories. The \l{Color Editor Factory Example}{Color

    Editor Factory} example shows how to create custom editors with a

    factory.

    \section1 Subclassing QStyledItemDelegate

    If the delegate does not support painting of the data types you

    need or you want to customize the drawing of items, you need to

    subclass QStyledItemDelegate, and reimplement paint() and possibly

    sizeHint(). The paint() function is called individually for each

    item, and with sizeHint(), you can specify the hint for each

    of them.

    When reimplementing paint(), one would typically handle the

    datatypes one would like to draw and use the superclass

    implementation for other types.

    The painting of check box indicators are performed by the current

    style. The style also specifies the size and the bounding

    rectangles in which to draw the data for the different data roles.

    The bounding rectangle of the item itself is also calculated by

    the style. When drawing already supported datatypes, it is

    therefore a good idea to ask the style for these bounding

    rectangles. The QStyle class description describes this in

    more detail.

    If you wish to change any of the bounding rectangles calculated by

    the style or the painting of check box indicators, you can

    subclass QStyle. Note, however, that the size of the items can

    also be affected by reimplementing sizeHint().

    It is possible for a custom delegate to provide editors

    without the use of an editor item factory. In this case, the

    following virtual functions must be reimplemented:

    \list

        \o createEditor() returns the widget used to change data from the model

           and can be reimplemented to customize editing behavior.

        \o setEditorData() provides the widget with data to manipulate.

        \o updateEditorGeometry() ensures that the editor is displayed correctly

           with respect to the item view.

        \o setModelData() returns updated data to the model.

    \endlist

    The \l{Star Delegate Example}{Star Delegate} example creates

    editors by reimplementing these methods.

    \section1 QStyledItemDelegate vs. QItemDelegate

    Since Qt 4.4, there are two delegate classes: QItemDelegate and

    QStyledItemDelegate. However, the default delegate is QStyledItemDelegate.

    These two classes are independent alternatives to painting and providing

    editors for items in views. The difference between them is that

    QStyledItemDelegate uses the current style to paint its items. We therefore

    recommend using QStyledItemDelegate as the base class when implementing

    custom delegates or when working with Qt style sheets. The code required

    for either class should be equal unless the custom delegate needs to use

    the style for drawing.

    If you wish to customize the painting of item views, you should

    implement a custom style. Please see the QStyle class

    documentation for details.

    \sa {Delegate Classes}, QItemDelegate, QAbstractItemDelegate, QStyle,

        {Spin Box Delegate Example}, {Star Delegate Example}, {Color

         Editor Factory Example}

*/

/*!

    Constructs an item delegate with the given \a parent.

*/

QStyledItemDelegate::QStyledItemDelegate(QObject *parent)

    : QAbstractItemDelegate(*new QStyledItemDelegatePrivate(), parent)

{

}

/*!

    Destroys the item delegate.

*/

QStyledItemDelegate::~QStyledItemDelegate()

{

}

/*!

    This function returns the string that the delegate will use to display the

    Qt::DisplayRole of the model in \a locale. \a value is the value of the Qt::DisplayRole

    provided by the model.

    The default implementation uses the QLocale::toString to convert \a value into

    a QString.

*/

QString QStyledItemDelegate::displayText(const QVariant &value, const QLocale& locale) const

{

    QString text;

    switch (value.userType()) {

    case QMetaType::Float:

    case QVariant::Double:

        text = locale.toString(value.toReal());

        break;

    case QVariant::Int:

    case QVariant::LongLong:

        text = locale.toString(value.toLongLong());

        break;

    case QVariant::UInt:

    case QVariant::ULongLong:

        text = locale.toString(value.toULongLong());

        break;

    case QVariant::Date:

        text = locale.toString(value.toDate(), QLocale::ShortFormat);

        break;

    case QVariant::Time:

        text = locale.toString(value.toTime(), QLocale::ShortFormat);

        break;

    case QVariant::DateTime:

        text = locale.toString(value.toDateTime().date(), QLocale::ShortFormat);

        text += QLatin1Char(' ');

        text += locale.toString(value.toDateTime().time(), QLocale::ShortFormat);

        break;

    default:

        // convert new lines into line separators

        text = value.toString();

        for (int i = 0; i < text.count(); ++i) {

            if (text.at(i) == QLatin1Char('\n'))

                text[i] = QChar::LineSeparator;

        }

        break;

    }

    return text;

}

/*!

    Initialize \a option with the values using the index \a index. This method

    is useful for subclasses when they need a QStyleOptionViewItem, but don't want

    to fill in all the information themselves. This function will check the version

    of the QStyleOptionViewItem and fill in the additional values for a

    QStyleOptionViewItemV2, QStyleOptionViewItemV3 and QStyleOptionViewItemV4.

    \sa QStyleOption::initFrom()

*/

void QStyledItemDelegate::initStyleOption(QStyleOptionViewItem *option,

                                         const QModelIndex &index) const

{

    QVariant value = index.data(Qt::FontRole);

    if (value.isValid() && !value.isNull()) {

        option->font = qvariant_cast<QFont>(value).resolve(option->font);

        option->fontMetrics = QFontMetrics(option->font);

    }

    value = index.data(Qt::TextAlignmentRole);

    if (value.isValid() && !value.isNull())

        option->displayAlignment = Qt::Alignment(value.toInt());

    value = index.data(Qt::ForegroundRole);

    if (qVariantCanConvert<QBrush>(value))

        option->palette.setBrush(QPalette::Text, qvariant_cast<QBrush>(value));

    if (QStyleOptionViewItemV4 *v4 = qstyleoption_cast<QStyleOptionViewItemV4 *>(option)) {

        v4->index = index;

        QVariant value = index.data(Qt::CheckStateRole);

        if (value.isValid() && !value.isNull()) {

            v4->features |= QStyleOptionViewItemV2::HasCheckIndicator;

            v4->checkState = static_cast<Qt::CheckState>(value.toInt());

        }

        value = index.data(Qt::DecorationRole);

        if (value.isValid() && !value.isNull()) {

            v4->features |= QStyleOptionViewItemV2::HasDecoration;

            switch (value.type()) {

            case QVariant::Icon: {

                v4->icon = qvariant_cast<QIcon>(value);

                QIcon::Mode mode;

                if (!(option->state & QStyle::State_Enabled))

                    mode = QIcon::Disabled;

                else if (option->state & QStyle::State_Selected)

                    mode = QIcon::Selected;

                else

                    mode = QIcon::Normal;

                QIcon::State state = option->state & QStyle::State_Open ? QIcon::On : QIcon::Off;

                v4->decorationSize = v4->icon.actualSize(option->decorationSize, mode, state);

                break;

            }

            case QVariant::Color: {

                QPixmap pixmap(option->decorationSize);

                pixmap.fill(qvariant_cast<QColor>(value));

                v4->icon = QIcon(pixmap);

                break;

            }

            case QVariant::Image: {

                QImage image = qvariant_cast<QImage>(value);

                v4->icon = QIcon(QPixmap::fromImage(image));

                v4->decorationSize = image.size();

                break;

            }

            case QVariant::Pixmap: {

                QPixmap pixmap = qvariant_cast<QPixmap>(value);

                v4->icon = QIcon(pixmap);

                v4->decorationSize = pixmap.size();

                break;

            }

            default:

                break;

            }

        }

        value = index.data(Qt::DisplayRole);

        if (value.isValid() && !value.isNull()) {

            v4->features |= QStyleOptionViewItemV2::HasDisplay;

            v4->text = displayText(value, v4->locale);

        }

        v4->backgroundBrush = qvariant_cast<QBrush>(index.data(Qt::BackgroundRole));

    }

}

/*!

    Renders the delegate using the given \a painter and style \a option for

    the item specified by \a index.

    This function paints the item using the view's QStyle.

    When reimplementing paint in a subclass. Use the initStyleOption()

    to set up the \a option in the same way as the

    QStyledItemDelegate; the option will always be an instance of

    QStyleOptionViewItemV4. Please see its class description for

    information on its contents.

    Whenever possible, use the \a option while painting.

    Especially its \l{QStyleOption::}{rect} variable to decide

    where to draw and its \l{QStyleOption::}{state} to determine

    if it is enabled or selected.

    After painting, you should ensure that the painter is returned to

    its the state it was supplied in when this function was called.

    For example, it may be useful to call QPainter::save() before

    painting and QPainter::restore() afterwards.

    \sa QItemDelegate::paint(), QStyle::drawControl(), QStyle::CE_ItemViewItem

*/

void QStyledItemDelegate::paint(QPainter *painter,

        const QStyleOptionViewItem &option, const QModelIndex &index) const

{

    Q_ASSERT(index.isValid());

    QStyleOptionViewItemV4 opt = option;

    initStyleOption(&opt, index);

    const QWidget *widget = QStyledItemDelegatePrivate::widget(option);

    QStyle *style = widget ? widget->style() : QApplication::style();

    style->drawControl(QStyle::CE_ItemViewItem, &opt, painter, widget);

}

/*!

    Returns the size needed by the delegate to display the item

    specified by \a index, taking into account the style information

    provided by \a option.

    This function uses the view's QStyle to determine the size of the

    item.

    \sa QStyle::sizeFromContents(), QStyle::CT_ItemViewItem

*/

QSize QStyledItemDelegate::sizeHint(const QStyleOptionViewItem &option,

                                   const QModelIndex &index) const

{

    QVariant value = index.data(Qt::SizeHintRole);

    if (value.isValid())

        return qvariant_cast<QSize>(value);

    QStyleOptionViewItemV4 opt = option;

    initStyleOption(&opt, index);

    const QWidget *widget = QStyledItemDelegatePrivate::widget(option);

    QStyle *style = widget ? widget->style() : QApplication::style();

    return style->sizeFromContents(QStyle::CT_ItemViewItem, &opt, QSize(), widget);

}

/*!

    Returns the widget used to edit the item specified by \a index

    for editing. The \a parent widget and style \a option are used to

    control how the editor widget appears.

    \sa QAbstractItemDelegate::createEditor()

*/

QWidget *QStyledItemDelegate::createEditor(QWidget *parent,

                                     const QStyleOptionViewItem &,

                                     const QModelIndex &index) const

{

    Q_D(const QStyledItemDelegate);

    if (!index.isValid())

        return 0;

    QVariant::Type t = static_cast<QVariant::Type>(index.data(Qt::EditRole).userType());

    return d->editorFactory()->createEditor(t, parent);

}

/*!

    Sets the data to be displayed and edited by the \a editor from the

    data model item specified by the model \a index.

    The default implementation stores the data in the \a editor

    widget's \l {Qt's Property System} {user property}.

    \sa QMetaProperty::isUser()

*/

void QStyledItemDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const

{

#ifdef QT_NO_PROPERTIES

    Q_UNUSED(editor);

    Q_UNUSED(index);

#else

    Q_D(const QStyledItemDelegate);

    QVariant v = index.data(Qt::EditRole);

    QByteArray n = editor->metaObject()->userProperty().name();

    // ### Qt 5: remove

    // A work-around for missing "USER true" in qdatetimeedit.h for

    // QTimeEdit's time property and QDateEdit's date property.

    // It only triggers if the default user property "dateTime" is

    // reported for QTimeEdit and QDateEdit.

    if (n == "dateTime") {

        if (editor->inherits("QTimeEdit"))

            n = "time";

        else if (editor->inherits("QDateEdit"))

            n = "date";

    }

    // ### Qt 5: give QComboBox a USER property

    if (n.isEmpty() && editor->inherits("QComboBox"))

        n = d->editorFactory()->valuePropertyName(static_cast<QVariant::Type>(v.userType()));

    if (!n.isEmpty()) {

        if (!v.isValid())

            v = QVariant(editor->property(n).userType(), (const void *)0);

        editor->setProperty(n, v);

    }

#endif

}

/*!

    Gets data from the \a editor widget and stores it in the specified

    \a model at the item \a index.

    The default implementation gets the value to be stored in the data

    model from the \a editor widget's \l {Qt's Property System} {user

    property}.

    \sa QMetaProperty::isUser()

*/

void QStyledItemDelegate::setModelData(QWidget *editor,

                                 QAbstractItemModel *model,

                                 const QModelIndex &index) const

{

#ifdef QT_NO_PROPERTIES

    Q_UNUSED(model);

    Q_UNUSED(editor);

    Q_UNUSED(index);