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

**

** 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 <qgraphicswidget.h>

#include <qgraphicsscene.h>

#include <qgraphicssceneevent.h>

#include <qgraphicsview.h>

#include <qstyleoption.h>

#include <qgraphicslinearlayout.h>

#include <qcleanlooksstyle.h>

#include <qlineedit.h>

#include <qboxlayout.h>

#include <qaction.h>

#include <qwidgetaction.h>

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

class EventSpy : public QObject

{

    Q_OBJECT

public:

    EventSpy(QObject *watched, QEvent::Type type)

        : _count(0), spied(type)

    {

        watched->installEventFilter(this);

    }

    int count() const { return _count; }

protected:

    bool eventFilter(QObject *watched, QEvent *event)

    {

        Q_UNUSED(watched);

        if (event->type() == spied)

            ++_count;

        return false;

    }

    int _count;

    QEvent::Type spied;

};

#ifndef QT_NO_STYLE_CLEANLOOKS

class tst_QGraphicsWidget : public QObject {

Q_OBJECT

public slots:

    void initTestCase();

    void cleanupTestCase();

    void init();

    void cleanup();

private slots:

    void qgraphicswidget();

    void activation();

    void boundingRect_data();

    void boundingRect();

    void dumpFocusChain_data();

    void dumpFocusChain();

    void focusWidget_data();

    void focusWidget();

    void focusWidget2();

    void focusPolicy_data();

    void focusPolicy();

    void font_data();

    void font();

    void fontPropagation();

    void fontChangedEvent();

    void fontPropagationWidgetItemWidget();

    void fontPropagationSceneChange();

    void geometry_data();

    void geometry();

    void width();

    void height();

    void getContentsMargins_data();

    void getContentsMargins();

    void initStyleOption_data();

    void initStyleOption();

    void layout_data();

    void layout();

    void layoutDirection_data();

    void layoutDirection();

    void paint_data();

    void paint();

    void palettePropagation();

    void parentWidget_data();

    void parentWidget();

    void resize_data();

    void resize();

    void setAttribute_data();

    void setAttribute();

    void setStyle_data();

    void setStyle();

    void setTabOrder_data();

    void setTabOrder();

    void setTabOrderAndReparent();

    void topLevelWidget_data();

    void topLevelWidget();

    void unsetLayoutDirection_data();

    void unsetLayoutDirection();

    void focusNextPrevChild_data();

    void focusNextPrevChild();

    void verifyFocusChain();

    void updateFocusChainWhenChildDie();

    void sizeHint_data();

    void sizeHint();

    void consistentPosSizeGeometry_data();

    void consistentPosSizeGeometry();

    void setSizes_data();

    void setSizes();

    void closePopupOnOutsideClick();

    void defaultSize();

    void explicitMouseGrabber();

    void implicitMouseGrabber();

    void doubleClickAfterExplicitMouseGrab();

    void popupMouseGrabber();

    void windowFlags_data();

    void windowFlags();

    void shortcutsDeletion();

    void painterStateProtectionOnWindowFrame();

    void ensureClipping();

    void widgetSendsGeometryChanges();

    void respectHFW();

    void addChildInpolishEvent();

    void polishEvent();

    void polishEvent2();

    void autoFillBackground();

    void initialShow();

    void initialShow2();

    void itemChangeEvents();

    void itemSendGeometryPosChangesDeactivated();

    // Task fixes

    void task236127_bspTreeIndexFails();

    void task243004_setStyleCrash();

    void task250119_shortcutContext();

    void QT_BUG_6544_tabFocusFirstUnsetWhenRemovingItems();

    void QT_BUG_12056_tabFocusFirstUnsetWhenRemovingItems();

};

static void sendMouseMove(QWidget *widget, const QPoint &point, Qt::MouseButton button = Qt::NoButton, Qt::MouseButtons buttons = 0)

{

    QTest::mouseMove(widget, point);

    QMouseEvent event(QEvent::MouseMove, point, button, buttons, 0);

    QApplication::sendEvent(widget, &event);

}

// Subclass that exposes the protected functions.

class SubQGraphicsWidget : public QGraphicsWidget {

public:

    SubQGraphicsWidget(QGraphicsItem *parent = 0, Qt::WindowFlags windowFlags = 0)

        : QGraphicsWidget(parent, windowFlags), eventCount(0)

        { }

    void initStyleOption(QStyleOption *option)

        { QGraphicsWidget::initStyleOption(option); }

    void call_changeEvent(QEvent* event)

        { return QGraphicsWidget::changeEvent(event); }

    bool call_event(QEvent *e)

        { return event(e); }

    void call_focusInEvent(QFocusEvent* event)

        { return QGraphicsWidget::focusInEvent(event); }

    bool call_focusNextPrevChild(bool next)

        { return QGraphicsWidget::focusNextPrevChild(next); }

    void call_focusOutEvent(QFocusEvent* event)

        { return QGraphicsWidget::focusOutEvent(event); }

    void call_hideEvent(QHideEvent* event)

        { return QGraphicsWidget::hideEvent(event); }

    QVariant call_itemChange(QGraphicsItem::GraphicsItemChange change, QVariant const& value)

        { return QGraphicsWidget::itemChange(change, value); }

    void call_moveEvent(QGraphicsSceneMoveEvent* event)

        { return QGraphicsWidget::moveEvent(event); }

    void call_polishEvent()

        { return QGraphicsWidget::polishEvent(); }

    QVariant call_propertyChange(QString const& propertyName, QVariant const& value)

        { return QGraphicsWidget::propertyChange(propertyName, value); }

    void call_resizeEvent(QGraphicsSceneResizeEvent* event)

        { return QGraphicsWidget::resizeEvent(event); }

    bool call_sceneEvent(QEvent* event)

        { return QGraphicsWidget::sceneEvent(event); }

    void call_showEvent(QShowEvent* event)

        { return QGraphicsWidget::showEvent(event); }

    QSizeF call_sizeHint(Qt::SizeHint which, QSizeF const& constraint = QSizeF()) const

        { return QGraphicsWidget::sizeHint(which, constraint); }

    void call_updateGeometry()

        { return QGraphicsWidget::updateGeometry(); }

    int eventCount;

    Qt::LayoutDirection m_painterLayoutDirection;

    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)

    {

        m_painterLayoutDirection = painter->layoutDirection();

        QGraphicsWidget::paint(painter, option, widget);

        if (hasFocus()) {

            painter->setPen(Qt::DotLine);

            painter->drawRect(rect());

        }

        //painter->drawText(QPointF(0,15), data(0).toString());

    }

protected:

    bool event(QEvent *event)

    {

        eventCount++;

        return QGraphicsWidget::event(event);

    }

};

// This will be called before the first test function is executed.

// It is only called once.

void tst_QGraphicsWidget::initTestCase()

{

}

// This will be called after the last test function is executed.

// It is only called once.

void tst_QGraphicsWidget::cleanupTestCase()

{

}

// This will be called before each test function is executed.

void tst_QGraphicsWidget::init()

{

}

// This will be called after every test function.

void tst_QGraphicsWidget::cleanup()

{

}

class SizeHinter : public QGraphicsWidget

{

public:

    SizeHinter(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0,

                const QSizeF &min = QSizeF(5,5),

                const QSizeF &pref = QSizeF(50, 50),

                const QSizeF &max = QSizeF(500, 500))

        : QGraphicsWidget(parent, wFlags)

    {

        m_sizes[Qt::MinimumSize] = min;

        m_sizes[Qt::PreferredSize] = pref;

        m_sizes[Qt::MaximumSize] = max;

    }

    void setSizeHint(Qt::SizeHint which, const QSizeF &newSizeHint)

    {

        m_sizes[which] = newSizeHint;

    }

protected:

    QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const

    {

        Q_UNUSED(constraint);

        return m_sizes[which];

    }

private:

    QSizeF m_sizes[4];

};

void tst_QGraphicsWidget::qgraphicswidget()

{

    SubQGraphicsWidget widget;

    QVERIFY(widget.isVisible());

    QVERIFY(!widget.isWindow());

    QCOMPARE(widget.boundingRect(), QRectF(0, 0, 0, 0));

    QCOMPARE(widget.focusWidget(), (QGraphicsWidget*)0);

    QCOMPARE(widget.focusPolicy(), Qt::NoFocus);

    QCOMPARE(widget.font(), QFont());

    QCOMPARE(widget.geometry(), QRectF(widget.pos(), widget.size()));

    QCOMPARE(widget.layout(), (QGraphicsLayout*)0);

    QCOMPARE(widget.layoutDirection(), Qt::LeftToRight);

    QCOMPARE(widget.palette(), QPalette());

    QCOMPARE(widget.parentWidget(), (QGraphicsWidget*)0);

    QCOMPARE(widget.rect(), QRectF(QPointF(), widget.size()));

    QCOMPARE(widget.size(), QSizeF(0, 0));

    QVERIFY(widget.style() != (QStyle*)0);

    QCOMPARE(widget.testAttribute(Qt::WA_AcceptDrops), false);

    QCOMPARE(widget.topLevelWidget(), (QGraphicsWidget*)&widget);

    QCOMPARE(widget.type(), (int)QGraphicsWidget::Type);

    QCOMPARE(widget.call_propertyChange(QString(), QVariant()), QVariant());

    widget.call_sizeHint(Qt::PreferredSize, QSizeF());

    QGraphicsScene scene;

    QGraphicsWidget *parent = new QGraphicsWidget;

    SizeHinter *child = new SizeHinter(parent);

    QCOMPARE(child->minimumSize(), QSizeF(5, 5));

}

void tst_QGraphicsWidget::activation()

{

    QGraphicsWidget *widget = new QGraphicsWidget;

    QGraphicsWidget *window1 = new QGraphicsWidget(0, Qt::Window);

    QGraphicsWidget *window2 = new QGraphicsWidget(0, Qt::Window);

    QVERIFY(!widget->isActiveWindow());

    QVERIFY(!window1->isActiveWindow());

    QVERIFY(!window2->isActiveWindow());

    QGraphicsScene scene;

    scene.addItem(widget);

    scene.addItem(window1);

    scene.addItem(window2);

    QVERIFY(!widget->isActiveWindow());

    QVERIFY(!window1->isActiveWindow());

    QVERIFY(!window2->isActiveWindow());

    QEvent activateEvent(QEvent::WindowActivate);

    QApplication::sendEvent(&scene, &activateEvent);

    QVERIFY(!widget->isActiveWindow());

    QVERIFY(window1->isActiveWindow());

    QVERIFY(!window2->isActiveWindow());

    scene.setActiveWindow(window1);

    QVERIFY(!widget->isActiveWindow());

    QVERIFY(window1->isActiveWindow());

    QVERIFY(!window2->isActiveWindow());

    QEvent deactivateEvent(QEvent::WindowDeactivate);

    QApplication::sendEvent(&scene, &deactivateEvent);

    QVERIFY(!widget->isActiveWindow());

    QVERIFY(!window1->isActiveWindow());

    QVERIFY(!window2->isActiveWindow());

}

void tst_QGraphicsWidget::boundingRect_data()

{

    QTest::addColumn<QSizeF>("size");

    QTest::newRow("null") << QSizeF(0, 0);

    QTest::newRow("avg") << QSizeF(10, 10);

}

// QRectF boundingRect() const public

void tst_QGraphicsWidget::boundingRect()

{

    QFETCH(QSizeF, size);

    SubQGraphicsWidget widget;

    widget.resize(size);

    QCOMPARE(widget.rect(), QRectF(QPointF(), size));

    QCOMPARE(widget.boundingRect(), QRectF(QPointF(0, 0), size));

}

void tst_QGraphicsWidget::dumpFocusChain_data()

{

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

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

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

    QTest::newRow("empty world") << false << 0 << false;

    QTest::newRow("one world") << true << 2 << false;

    QTest::newRow("one world w/focus") << true << 2 << true;

}

// void dumpFocusChain(QGraphicsScene* scene) public (static)

void tst_QGraphicsWidget::dumpFocusChain()

{

    // ### this test is very strange...

    QFETCH(bool, scene);

    SubQGraphicsWidget *parent = new SubQGraphicsWidget;

    QGraphicsScene *theScene = 0;

    if (scene) {

        theScene = new QGraphicsScene(this);

        theScene->addItem(parent);

    }

    QFETCH(int, children);

    QFETCH(bool, setFocus);

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

        SubQGraphicsWidget *widget = new SubQGraphicsWidget(parent);

        if (setFocus) {

            widget->setFlag(QGraphicsItem::ItemIsFocusable, true);

            if (scene)

                theScene->setFocusItem(widget);

        }

    }

    if (!scene)

        delete parent;

}

void tst_QGraphicsWidget::focusWidget_data()

{

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

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

    QTest::newRow("none") << 0 << 0;

    QTest::newRow("first") << 3 << 0;

    QTest::newRow("last") << 3 << 2;

}

// QGraphicsWidget* focusWidget() const public

void tst_QGraphicsWidget::focusWidget()

{

    SubQGraphicsWidget *parent = new SubQGraphicsWidget;

    QCOMPARE(parent->focusWidget(), (QGraphicsWidget *)0);

    QGraphicsScene scene;

    QEvent windowActivate(QEvent::WindowActivate);

    qApp->sendEvent(&scene, &windowActivate);

    scene.addItem(parent);

    QFETCH(int, childCount);

    QList<SubQGraphicsWidget *> children;

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

        SubQGraphicsWidget *widget = new SubQGraphicsWidget(parent);

        widget->setFlag(QGraphicsItem::ItemIsFocusable, true);

        children.append(widget);

    }

    if (childCount > 0) {

        QFETCH(int, childWithFocus);

        SubQGraphicsWidget *widget = children[childWithFocus];

        widget->setFocus();

        QTRY_VERIFY(widget->hasFocus());

        QCOMPARE(parent->focusWidget(), static_cast<QGraphicsWidget*>(widget));

    }

}

void tst_QGraphicsWidget::focusWidget2()

{

    QGraphicsScene scene;

    QEvent windowActivate(QEvent::WindowActivate);

    qApp->sendEvent(&scene, &windowActivate);

    QGraphicsWidget *widget = new QGraphicsWidget;

    EventSpy focusInSpy(widget, QEvent::FocusIn);

    EventSpy focusOutSpy(widget, QEvent::FocusOut);

    scene.addItem(widget);

    QTRY_VERIFY(!widget->hasFocus());

    widget->setFocusPolicy(Qt::StrongFocus);

    QTRY_VERIFY(!widget->hasFocus());

    QGraphicsWidget *subWidget = new QGraphicsWidget(widget);

    QTRY_VERIFY(!subWidget->hasFocus());

    scene.setFocus();

    QTRY_VERIFY(!widget->hasFocus());

    QTRY_VERIFY(!subWidget->hasFocus());

    widget->setFocus();

    QTRY_VERIFY(widget->hasFocus());

    QTRY_COMPARE(focusInSpy.count(), 1);

    QTRY_VERIFY(!subWidget->hasFocus());

    QGraphicsWidget *otherSubWidget = new QGraphicsWidget;

    EventSpy otherFocusInSpy(otherSubWidget, QEvent::FocusIn);

    EventSpy otherFocusOutSpy(otherSubWidget, QEvent::FocusOut);

    otherSubWidget->setFocusPolicy(Qt::StrongFocus);

    otherSubWidget->setParentItem(widget);

    QTRY_VERIFY(widget->hasFocus());

    QCOMPARE(scene.focusItem(), (QGraphicsItem *)widget);

    QTRY_VERIFY(!subWidget->hasFocus());

    QTRY_VERIFY(!otherSubWidget->hasFocus());

    widget->hide();

    QTRY_VERIFY(!widget->hasFocus()); // lose but still has subfocus

    QCOMPARE(focusInSpy.count(), 1);

    QCOMPARE(focusOutSpy.count(), 1);

    widget->show();

    QTRY_VERIFY(!widget->hasFocus()); // no regain

    QCOMPARE(focusInSpy.count(), 1);