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

**

** 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 "qitemdelegate.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 <qmetaobject.h>

#include <qtextlayout.h>

#include <private/qobject_p.h>

#include <private/qdnd_p.h>

#include <private/qtextengine_p.h>

#include <qdebug.h>

#include <qlocale.h>

#include <qdialog.h>

#include <limits.h>

#ifndef DBL_DIG

#  define DBL_DIG 10

#endif

QT_BEGIN_NAMESPACE

class QItemDelegatePrivate : public QObjectPrivate

{

    Q_DECLARE_PUBLIC(QItemDelegate)

public:

    QItemDelegatePrivate() : f(0), clipPainting(true) {}

    inline const QItemEditorFactory *editorFactory() const

        { return f ? f : QItemEditorFactory::defaultFactory(); }

    inline QIcon::Mode iconMode(QStyle::State state) const

        {

            if (!(state & QStyle::State_Enabled)) return QIcon::Disabled;

            if (state & QStyle::State_Selected) return QIcon::Selected;

            return QIcon::Normal;

        }

    inline QIcon::State iconState(QStyle::State state) const

        { return state & QStyle::State_Open ? QIcon::On : QIcon::Off; }

    inline static QString replaceNewLine(QString text)

        {

            const QChar nl = QLatin1Char('\n');

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

                if (text.at(i) == nl)

                    text[i] = QChar::LineSeparator;

            return text;

        }

    static QString valueToText(const QVariant &value, const QStyleOptionViewItemV4 &option);

    void _q_commitDataAndCloseEditor(QWidget *editor);

    QItemEditorFactory *f;

    bool clipPainting;

    QRect textLayoutBounds(const QStyleOptionViewItemV2 &options) const;

    QSizeF doTextLayout(int lineWidth) const;

    mutable QTextLayout textLayout;

    mutable QTextOption textOption;

    const QWidget *widget(const QStyleOptionViewItem &option) const

    {

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

            return v3->widget;

        return 0;

    }

    // ### temporary hack until we have QStandardItemDelegate

    mutable struct Icon {

        QIcon icon;

        QIcon::Mode mode;

        QIcon::State state;

    } tmp;

};

void QItemDelegatePrivate::_q_commitDataAndCloseEditor(QWidget *editor)

{

    Q_Q(QItemDelegate);

    emit q->commitData(editor);

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

}

QRect QItemDelegatePrivate::textLayoutBounds(const QStyleOptionViewItemV2 &option) const

{

    QRect rect = option.rect;

    const bool wrapText = option.features & QStyleOptionViewItemV2::WrapText;

    switch (option.decorationPosition) {

    case QStyleOptionViewItem::Left:

    case QStyleOptionViewItem::Right:

        rect.setWidth(wrapText && rect.isValid() ? rect.width() : (QFIXED_MAX));

        break;

    case QStyleOptionViewItem::Top:

    case QStyleOptionViewItem::Bottom:

        rect.setWidth(wrapText ? option.decorationSize.width() : (QFIXED_MAX));

        break;

    }

    return rect;

}

QSizeF QItemDelegatePrivate::doTextLayout(int lineWidth) const

{

    qreal height = 0;

    qreal widthUsed = 0;

    textLayout.beginLayout();

    while (true) {

        QTextLine line = textLayout.createLine();

        if (!line.isValid())

            break;

        line.setLineWidth(lineWidth);

        line.setPosition(QPointF(0, height));

        height += line.height();

        widthUsed = qMax(widthUsed, line.naturalTextWidth());

    }

    textLayout.endLayout();

    return QSizeF(widthUsed, height);

}

/*!

    \class QItemDelegate

    \brief The QItemDelegate class provides display and editing facilities for

    data items from a model.

    \ingroup model-view

    QItemDelegate can be used to provide custom display features and editor

    widgets for item views based on QAbstractItemView subclasses. Using a

    delegate for this purpose allows the display and editing mechanisms to be

    customized and developed independently from the model and view.

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

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

    Note that QStyledItemDelegate has taken over the job of drawing

    Qt's item views. We recommend the use of QStyledItemDelegate when

    creating new delegates.

    When displaying items from a custom model in a standard view, it is

    often sufficient to simply ensure that the model returns appropriate

    data for each of the \l{Qt::ItemDataRole}{roles} that determine the

    appearance of items in views. The default delegate used by Qt's

    standard views uses this role information to display items in most

    of the common forms expected by users. However, it is sometimes

    necessary to have even more control over the appearance of items than

    the default delegate can provide.

    This class provides default implementations of the functions for

    painting item data in a view and editing data from item models.

    Default implementations of the paint() and sizeHint() virtual

    functions, defined in QAbstractItemDelegate, are provided to

    ensure that the delegate implements the correct basic behavior

    expected by views. You can reimplement these functions in

    subclasses to customize the appearance of items.

    When editing data in an item view, QItemDelegate provides an

    editor widget, which is a widget that is placed on top of the view

    while editing takes place. 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 Qt::EditRole that is edited.

    Only the standard editing functions for widget-based delegates are

    reimplemented here:

    \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 closeEditor() signal indicates that the user has completed editing the data,

    and that the editor widget can be destroyed.

    \section1 Standard Roles and Data Types

    The default delegate used by the standard views supplied with Qt

    associates each standard role (defined by Qt::ItemDataRole) with certain

    data types. Models that return data in these types can influence the

    appearance of the delegate as described in the following table.

    \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

    If the default delegate does not allow the level of customization that

    you need, either for display purposes or for editing data, it is possible to

    subclass QItemDelegate to implement the desired behavior.

    \section1 Subclassing

    When subclassing QItemDelegate to create a delegate that displays items

    using a custom renderer, it is important to ensure that the delegate can

    render items suitably for all the required states; e.g. selected,

    disabled, checked. The documentation for the paint() function contains

    some hints to show how this can be achieved.

    You can provide custom editors by using a QItemEditorFactory. The

    \l{Color Editor Factory Example} shows how a custom editor can be

    made available to delegates with the default item editor

    factory. This way, there is no need to subclass QItemDelegate.  An

    alternative is to reimplement createEditor(), setEditorData(),

    setModelData(), and updateEditorGeometry(). This process is

    described in the \l{Spin Box Delegate Example}.

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

    \sa {Delegate Classes}, QStyledItemDelegate, QAbstractItemDelegate,

        {Spin Box Delegate Example}, {Settings Editor Example},

        {Icons Example}

*/

/*!

    Constructs an item delegate with the given \a parent.

*/

QItemDelegate::QItemDelegate(QObject *parent)

    : QAbstractItemDelegate(*new QItemDelegatePrivate(), parent)

{

}

/*!

    Destroys the item delegate.

*/

QItemDelegate::~QItemDelegate()

{

}

/*!

  \property QItemDelegate::clipping

  \brief if the delegate should clip the paint events

  \since 4.2

  This property will set the paint clip to the size of the item.

  The default value is on. It is useful for cases such

  as when images are larger than the size of the item.

*/

bool QItemDelegate::hasClipping() const

{

    Q_D(const QItemDelegate);

    return d->clipPainting;

}

void QItemDelegate::setClipping(bool clip)

{

    Q_D(QItemDelegate);

    d->clipPainting = clip;

}

QString QItemDelegatePrivate::valueToText(const QVariant &value, const QStyleOptionViewItemV4 &option)

{

    QString text;

    switch (value.userType()) {

        case QMetaType::Float:

            text = option.locale.toString(value.toFloat(), 'g');

            break;

        case QVariant::Double:

            text = option.locale.toString(value.toDouble(), 'g', DBL_DIG);

            break;

        case QVariant::Int:

        case QVariant::LongLong:

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

            break;

        case QVariant::UInt:

        case QVariant::ULongLong:

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

            break;

        case QVariant::Date:

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

            break;

        case QVariant::Time:

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

            break;

        case QVariant::DateTime:

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

            text += QLatin1Char(' ');

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

            break;

        default:

            text = replaceNewLine(value.toString());

            break;

    }

    return text;

}

/*!

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

    the item specified by \a index.

    When reimplementing this function in a subclass, you should update the area

    held by the option's \l{QStyleOption::rect}{rect} variable, using the

    option's \l{QStyleOption::state}{state} variable to determine the state of

    the item to be displayed, and adjust the way it is painted accordingly.

    For example, a selected item may need to be displayed differently to

    unselected items, as shown in the following code:

    \snippet examples/itemviews/pixelator/pixeldelegate.cpp 2

    \dots

    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 QStyle::State

*/

void QItemDelegate::paint(QPainter *painter,

                          const QStyleOptionViewItem &option,

                          const QModelIndex &index) const

{

    Q_D(const QItemDelegate);

    Q_ASSERT(index.isValid());

    QStyleOptionViewItemV4 opt = setOptions(index, option);

    const QStyleOptionViewItemV2 *v2 = qstyleoption_cast<const QStyleOptionViewItemV2 *>(&option);

    opt.features = v2 ? v2->features

                    : QStyleOptionViewItemV2::ViewItemFeatures(QStyleOptionViewItemV2::None);

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

    opt.locale = v3 ? v3->locale : QLocale();

    opt.widget = v3 ? v3->widget : 0;

    // prepare

    painter->save();

    if (d->clipPainting)

        painter->setClipRect(opt.rect);

    // get the data and the rectangles

    QVariant value;

    QPixmap pixmap;

    QRect decorationRect;

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

    if (value.isValid()) {

        // ### we need the pixmap to call the virtual function

        pixmap = decoration(opt, value);

        if (value.type() == QVariant::Icon) {

            d->tmp.icon = qvariant_cast<QIcon>(value);

            d->tmp.mode = d->iconMode(option.state);

            d->tmp.state = d->iconState(option.state);

            const QSize size = d->tmp.icon.actualSize(option.decorationSize,

                                                      d->tmp.mode, d->tmp.state);

            decorationRect = QRect(QPoint(0, 0), size);

        } else {

            d->tmp.icon = QIcon();

            decorationRect = QRect(QPoint(0, 0), pixmap.size());

        }

    } else {

        d->tmp.icon = QIcon();

        decorationRect = QRect();

    }

    QString text;

    QRect displayRect;

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

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

        text = QItemDelegatePrivate::valueToText(value, opt);

        displayRect = textRectangle(painter, d->textLayoutBounds(opt), opt.font, text);

    }

    QRect checkRect;

    Qt::CheckState checkState = Qt::Unchecked;

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

    if (value.isValid()) {

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

        checkRect = check(opt, opt.rect, value);

    }

    // do the layout

    doLayout(opt, &checkRect, &decorationRect, &displayRect, false);

    // draw the item

    drawBackground(painter, opt, index);

    drawCheck(painter, opt, checkRect, checkState);

    drawDecoration(painter, opt, decorationRect, pixmap);

    drawDisplay(painter, opt, displayRect, text);

    drawFocus(painter, opt, displayRect);

    // done

    painter->restore();

}

/*!

    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.

    When reimplementing this function, note that in case of text

    items, QItemDelegate adds a margin (i.e. 2 *

    QStyle::PM_FocusFrameHMargin) to the length of the text.

*/

QSize QItemDelegate::sizeHint(const QStyleOptionViewItem &option,

                              const QModelIndex &index) const

{

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

    if (value.isValid())

        return qvariant_cast<QSize>(value);

    QRect decorationRect = rect(option, index, Qt::DecorationRole);

    QRect displayRect = rect(option, index, Qt::DisplayRole);

    QRect checkRect = rect(option, index, Qt::CheckStateRole);

    doLayout(option, &checkRect, &decorationRect, &displayRect, true);

    return (decorationRect|displayRect|checkRect).size();

}

/*!

    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 *QItemDelegate::createEditor(QWidget *parent,

                                     const QStyleOptionViewItem &,

                                     const QModelIndex &index) const

{

    Q_D(const QItemDelegate);

    if (!index.isValid())