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

**

** 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 test suite 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 <QtTest/QtTest>

#include <qabstractitemview.h>

#include <qstandarditemmodel.h>

#include <qapplication.h>

#include <qdatetimeedit.h>

#include <qspinbox.h>

#include <qlistview.h>

#include <qtableview.h>

#include <qtreeview.h>

#include <qheaderview.h>

#include <qitemeditorfactory.h>

#include <qlineedit.h>

#include <qvalidator.h>

#include <qtablewidget.h>

#include <qtreewidget.h>

#include <QItemDelegate>

#include <QAbstractItemDelegate>

#include <QTextEdit>

#include <QPlainTextEdit>

#include <QDialog>

#include "../../shared/util.h"

Q_DECLARE_METATYPE(QAbstractItemDelegate::EndEditHint)

//TESTED_CLASS=

//TESTED_FILES=

#if defined (Q_OS_WIN) && !defined(Q_OS_WINCE)

#include <windows.h>

#define Q_CHECK_PAINTEVENTS \

    if (::SwitchDesktop(::GetThreadDesktop(::GetCurrentThreadId())) == 0) \

        QSKIP("The widgets don't get the paint events", SkipSingle);

#else

#define Q_CHECK_PAINTEVENTS

#endif

//Begin of class definitions

class TestItemDelegate : public QItemDelegate

{

public:

    TestItemDelegate(QObject *parent = 0) : QItemDelegate(parent) {}

    ~TestItemDelegate() {}

    void drawDisplay(QPainter *painter,

                     const QStyleOptionViewItem &option,

                     const QRect &rect, const QString &text) const

    {

        displayText = text;

        displayFont = option.font;

        QItemDelegate::drawDisplay(painter, option, rect, text);

    }

    void drawDecoration(QPainter *painter,

                        const QStyleOptionViewItem &option,

                        const QRect &rect, const QPixmap &pixmap) const

    {

        decorationPixmap = pixmap;

        decorationRect = rect;

        QItemDelegate::drawDecoration(painter, option, rect, pixmap);

    }

    inline QRect textRectangle(QPainter * painter, const QRect &rect,

                               const QFont &font, const QString &text) const

    {

        return QItemDelegate::textRectangle(painter, rect, font, text);

    }

    inline void doLayout(const QStyleOptionViewItem &option,

                         QRect *checkRect, QRect *pixmapRect,

                         QRect *textRect, bool hint) const

    {

        QItemDelegate::doLayout(option, checkRect, pixmapRect, textRect, hint);

    }

    inline QRect rect(const QStyleOptionViewItem &option,

                      const QModelIndex &index, int role) const

    {

        return QItemDelegate::rect(option, index, role);

    }

    inline bool eventFilter(QObject *object, QEvent *event)

    {

        return QItemDelegate::eventFilter(object, event);

    }

    inline bool editorEvent(QEvent *event,

                            QAbstractItemModel *model,

                            const QStyleOptionViewItem &option,

                            const QModelIndex &index)

    {

        return QItemDelegate::editorEvent(event, model, option, index);

    }

    // stored values for testing

    mutable QString displayText;

    mutable QFont displayFont;

    mutable QPixmap decorationPixmap;

    mutable QRect decorationRect;

};

class TestItemModel : public QAbstractTableModel

{

public:

    enum Roles {

        PixmapTestRole,

        ImageTestRole,

        IconTestRole,

        ColorTestRole,

        DoubleTestRole

    };

    TestItemModel(const QSize &size) : size(size) {}

    ~TestItemModel() {}

    int rowCount(const QModelIndex &parent) const

    {

        Q_UNUSED(parent);

        return 1;

    }

    int columnCount(const QModelIndex &parent) const

    {

        Q_UNUSED(parent);

        return 1;

    }

    QVariant data(const QModelIndex& index, int role) const

    {

        Q_UNUSED(index);

        static QPixmap pixmap(size);

        static QImage image(size, QImage::Format_Mono);

        static QIcon icon(pixmap);

        static QColor color(Qt::green);

        switch (role) {

        case PixmapTestRole: return pixmap;

        case ImageTestRole:  return image;

        case IconTestRole:   return icon;

        case ColorTestRole:  return color;

        case DoubleTestRole:  return 10.00000001;

        default: break;

        }

        return QVariant();

    }

private:

    QSize size;

};

class tst_QItemDelegate : public QObject

{

    Q_OBJECT

public:

    tst_QItemDelegate();

    virtual ~tst_QItemDelegate();

private slots:

    void initTestCase();

    void cleanupTestCase();

    void init();

    void cleanup();

    void getSetCheck();

    void textRectangle_data();

    void textRectangle();

    void sizeHint_data();

    void sizeHint();

    void editorKeyPress_data();

    void editorKeyPress();

    void doubleEditorNegativeInput();

    void font_data();

    void font();

    void doLayout_data();

    void doLayout();

    void rect_data();

    void rect();

    void eventFilter();

    void dateTimeEditor_data();

    void dateTimeEditor();

    void decoration_data();

    void decoration();

    void editorEvent_data();

    void editorEvent();

    void enterKey_data();

    void enterKey();

    void task257859_finalizeEdit();

};

//End of class definitions

// Testing get/set functions

void tst_QItemDelegate::getSetCheck()

{

    QItemDelegate obj1;

    // QItemEditorFactory * QItemDelegate::itemEditorFactory()

    // void QItemDelegate::setItemEditorFactory(QItemEditorFactory *)

    QItemEditorFactory *var1 = new QItemEditorFactory;

    obj1.setItemEditorFactory(var1);

    QCOMPARE(var1, obj1.itemEditorFactory());

    obj1.setItemEditorFactory((QItemEditorFactory *)0);

    QCOMPARE((QItemEditorFactory *)0, obj1.itemEditorFactory());

    delete var1;

    QCOMPARE(obj1.hasClipping(), true);

    obj1.setClipping(false);

    QCOMPARE(obj1.hasClipping(), false);

    obj1.setClipping(true);

    QCOMPARE(obj1.hasClipping(), true);

}

tst_QItemDelegate::tst_QItemDelegate()

{

}

tst_QItemDelegate::~tst_QItemDelegate()

{

}

void tst_QItemDelegate::initTestCase()

{

}

void tst_QItemDelegate::cleanupTestCase()

{

}

void tst_QItemDelegate::init()

{

}

void tst_QItemDelegate::cleanup()

{

}

void tst_QItemDelegate::textRectangle_data()

{

    QFont font;

    QFontMetrics fontMetrics(font);

    int pm = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin);

    int margins = 2 * (pm + 1); // margin on each side of the text

    int height = fontMetrics.height();

    QTest::addColumn<QString>("text");

    QTest::addColumn<QRect>("rect");

    QTest::addColumn<QRect>("expected");

    QTest::newRow("empty") << QString()

                           << QRect()

                           << QRect(0, 0, margins, height);

}

void tst_QItemDelegate::textRectangle()

{

    QFETCH(QString, text);

    QFETCH(QRect, rect);

    QFETCH(QRect, expected);

    QFont font;

    TestItemDelegate delegate;

    QRect result = delegate.textRectangle(0, rect, font, text);

    QCOMPARE(result, expected);

}

void tst_QItemDelegate::sizeHint_data()

{

    QTest::addColumn<QSize>("expected");

    QFont font;

    QFontMetrics fontMetrics(font);

    //int m = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin) + 1;

    QTest::newRow("empty")

        << QSize(0, fontMetrics.height());

}

void tst_QItemDelegate::sizeHint()

{

    QFETCH(QSize, expected);

    QModelIndex index;

    QStyleOptionViewItem option;

    TestItemDelegate delegate;

    QSize result = delegate.sizeHint(option, index);

    QCOMPARE(result, expected);

}

void tst_QItemDelegate::editorKeyPress_data()

{

    QTest::addColumn<QString>("initial");

    QTest::addColumn<QString>("expected");

    QTest::newRow("foo bar")

        << QString("foo")

        << QString("bar");

}

void tst_QItemDelegate::editorKeyPress()

{

    QFETCH(QString, initial);

    QFETCH(QString, expected);

    QStandardItemModel model;

    model.appendRow(new QStandardItem(initial));

    QListView view;

    view.setModel(&model);

    view.show();

    QModelIndex index = model.index(0, 0);

    view.setCurrentIndex(index); // the editor will only selectAll on the current index

    view.edit(index);

    QList<QLineEdit*> lineEditors = qFindChildren<QLineEdit *>(view.viewport());

    QCOMPARE(lineEditors.count(), 1);

    QLineEdit *editor = lineEditors.at(0);

    QCOMPARE(editor->selectedText(), initial);

    QTest::keyClicks(editor, expected);

    QTest::keyClick(editor, Qt::Key_Enter);

    QApplication::processEvents();

    QCOMPARE(index.data().toString(), expected);

}

void tst_QItemDelegate::doubleEditorNegativeInput()

{

    QStandardItemModel model;

    QStandardItem *item = new QStandardItem;

    item->setData(10.0, Qt::DisplayRole);

    model.appendRow(item);

    QListView view;

    view.setModel(&model);

    view.show();

    QModelIndex index = model.index(0, 0);

    view.setCurrentIndex(index); // the editor will only selectAll on the current index

    view.edit(index);

    QList<QDoubleSpinBox*> editors = qFindChildren<QDoubleSpinBox *>(view.viewport());

    QCOMPARE(editors.count(), 1);

    QDoubleSpinBox *editor = editors.at(0);

    QCOMPARE(editor->value(), double(10));

    QTest::keyClick(editor, Qt::Key_Minus);

    QTest::keyClick(editor, Qt::Key_1);

    QTest::keyClick(editor, Qt::Key_0);

    QTest::keyClick(editor, Qt::Key_Comma); //support both , and . locales

    QTest::keyClick(editor, Qt::Key_Period);

    QTest::keyClick(editor, Qt::Key_0);

    QTest::keyClick(editor, Qt::Key_Enter);

    QApplication::processEvents();

    QCOMPARE(index.data().toString(), QString("-10"));

}

void tst_QItemDelegate::font_data()

{

    QTest::addColumn<QString>("itemText");

    QTest::addColumn<QString>("properties");

    QTest::addColumn<QFont>("itemFont");

    QTest::addColumn<QFont>("viewFont");

    QFont itemFont;

    itemFont.setItalic(true);

    QFont viewFont;

    QTest::newRow("foo italic")

        << QString("foo")

        << QString("italic")

        << itemFont

        << viewFont;

    itemFont.setItalic(true);

    QTest::newRow("foo bold")

        << QString("foo")

        << QString("bold")

        << itemFont

        << viewFont;

    itemFont.setFamily(itemFont.defaultFamily());

    QTest::newRow("foo family")

        << QString("foo")

        << QString("family")

        << itemFont

        << viewFont;

 }

void tst_QItemDelegate::font()

{

    Q_CHECK_PAINTEVENTS

    QFETCH(QString, itemText);

    QFETCH(QString, properties);

    QFETCH(QFont, itemFont);

    QFETCH(QFont, viewFont);

    QTableWidget table(1, 1);

    table.setFont(viewFont);

    TestItemDelegate *delegate = new TestItemDelegate(&table);

    table.setItemDelegate(delegate);

    table.show();

#ifdef Q_WS_X11

    qt_x11_wait_for_window_manager(&table);

#endif

    QTableWidgetItem *item = new QTableWidgetItem;

    item->setText(itemText);

    item->setFont(itemFont);

    table.setItem(0, 0, item);

    QApplication::processEvents();

#ifdef Q_WS_QWS

    QApplication::sendPostedEvents(); //glib workaround

#endif

    QTRY_COMPARE(delegate->displayText, item->text());

    if (properties.contains("italic")) {

        QCOMPARE(delegate->displayFont.italic(), item->font().italic());

    }

    if (properties.contains("bold")){

        QCOMPARE(delegate->displayFont.bold(), item->font().bold());

    }

    if (properties.contains("family")){

        QCOMPARE(delegate->displayFont.family(), item->font().family());

    }

}

//Testing the different QRect created by the doLayout function.

//Tests are made with different values for the QStyleOptionViewItem properties:

//decorationPosition and position.

void tst_QItemDelegate::doLayout_data()

{

    QTest::addColumn<int>("position");

    QTest::addColumn<int>("direction");

    QTest::addColumn<bool>("hint");

    QTest::addColumn<QRect>("itemRect");

    QTest::addColumn<QRect>("checkRect");

    QTest::addColumn<QRect>("pixmapRect");

    QTest::addColumn<QRect>("textRect");

    QTest::addColumn<QRect>("expectedCheckRect");

    QTest::addColumn<QRect>("expectedPixmapRect");

    QTest::addColumn<QRect>("expectedTextRect");

    int m = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin) + 1;

    //int item = 400;

    //int check = 50;

    //int pixmap = 1000;

    //int text = 400;

    QTest::newRow("top, left to right, hint")

        << (int)QStyleOptionViewItem::Top

        << (int)Qt::LeftToRight

        << true

        << QRect(0, 0, 400, 400)

        << QRect(0, 0, 50, 50)

        << QRect(0, 0, 1000, 1000)

        << QRect(0, 0, 400, 400)

        << QRect(m, 0, 50 + 2*m, 1000)

        << QRect(50 + 2*m, 0, 1000 + 2*m, 1000 + m)

        << QRect(50 + 2*m, 1000 + m, 1000 + 2*m, 400);

    /*

    QTest::newRow("top, left to right, limited")

        << (int)QStyleOptionViewItem::Top

        << (int)Qt::LeftToRight

        << false