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

**

** 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 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 <QtGui>

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

#include <private/qlayoutengine_p.h>    // qSmartMin functions...

#if defined(Q_WS_MAC) && !defined(QT_NO_STYLE_MAC)

#include <QMacStyle>

#endif

#ifdef Q_WS_X11

#include <private/qt_x11_p.h>

#endif

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

{

    QMouseEvent event(QEvent::MouseMove, point, widget->mapToGlobal(point), button, button, 0);

    QApplication::sendEvent(widget, &event);

}

#ifndef QT_NO_STYLE_CLEANLOOKS

/*

    Notes:

    1) The proxy and the widget geometries are linked.

       proxy resize => widget resize => stop (no livelock)

       widget resize => proxy resize => stop (no livelock)

    2) As far as possible, the properties are linked.

       proxy enable => widget enable => stop

       widget disabled => proxy disabled => stop

    3) Windowed state is linked

       Windowed proxy state => windowed widget state => stop

       Windowed widget state => windowed proxy state => stop

*/

class EventSpy : public QObject

{

public:

    EventSpy(QObject *receiver)

    {

        receiver->installEventFilter(this);

    }

    QMap<QEvent::Type, int> counts;

protected:

    bool eventFilter(QObject *, QEvent *event)

    {

        ++counts[event->type()];

        return false;

    }

};

class tst_QGraphicsProxyWidget : public QObject

{

    Q_OBJECT

public slots:

    void initTestCase();

    void cleanupTestCase();

    void init();

    void cleanup();

private slots:

    void qgraphicsproxywidget_data();

    void qgraphicsproxywidget();

    void paint();

    void paint_2();

    void setWidget_data();

    void setWidget();

    void eventFilter_data();

    void eventFilter();

    void focusInEvent_data();

    void focusInEvent();

    void focusInEventNoWidget();

    void focusNextPrevChild_data();

    void focusNextPrevChild();

    void focusOutEvent_data();

    void focusOutEvent();

    void hoverEnterLeaveEvent_data();

    void hoverEnterLeaveEvent();

    void hoverMoveEvent_data();

    void hoverMoveEvent();

    void keyPressEvent_data();

    void keyPressEvent();

    void keyReleaseEvent_data();

    void keyReleaseEvent();

    void mouseDoubleClickEvent_data();

    void mouseDoubleClickEvent();

    void mousePressReleaseEvent_data();

    void mousePressReleaseEvent();

    void resizeEvent_data();

    void resizeEvent();

    void paintEvent();

    void wheelEvent();

    void sizeHint_data();

    void sizeHint();

    void sizePolicy();

    void minimumSize();

    void maximumSize();

    void scrollUpdate();

    void setWidget_simple();

    void setWidget_ownership();

    void resize_simple_data();

    void resize_simple();

    void symmetricMove();

    void symmetricResize();

    void symmetricEnabled();

    void symmetricVisible();

    void tabFocus_simpleWidget();

    void tabFocus_simpleTwoWidgets();

    void tabFocus_complexWidget();

    void tabFocus_complexTwoWidgets();

    void setFocus_simpleWidget();

    void setFocus_simpleTwoWidgets();

    void setFocus_complexTwoWidgets();

    void popup_basic();

    void popup_subwidget();

    void changingCursor_basic();

    void tooltip_basic();

    void childPos_data();

    void childPos();

    void autoShow();

    void windowOpacity();

    void stylePropagation();

    void palettePropagation();

    void fontPropagation();

    void dontCrashWhenDie();

    void createProxyForChildWidget();

    void actionsContextMenu();

    void actionsContextMenu_data();

    void deleteProxyForChildWidget();

    void bypassGraphicsProxyWidget_data();

    void bypassGraphicsProxyWidget();

    void dragDrop();

    void windowFlags_data();

    void windowFlags();

    void comboboxWindowFlags();

    void updateAndDelete();

    void inputMethod();

    void clickFocus();

};

// Subclass that exposes the protected functions.

class SubQGraphicsProxyWidget : public QGraphicsProxyWidget

{

public:

    SubQGraphicsProxyWidget(QGraphicsItem *parent = 0) : QGraphicsProxyWidget(parent),

    paintCount(0), keyPress(0), focusOut(0)

        {}

    bool call_eventFilter(QObject* object, QEvent* event)

        { return SubQGraphicsProxyWidget::eventFilter(object, event); }

    void call_focusInEvent(QFocusEvent* event)

        { return SubQGraphicsProxyWidget::focusInEvent(event); }

    bool call_focusNextPrevChild(bool next)

        { return SubQGraphicsProxyWidget::focusNextPrevChild(next); }

    void call_focusOutEvent(QFocusEvent* event)

        { return SubQGraphicsProxyWidget::focusOutEvent(event); }

    void call_hideEvent(QHideEvent* event)

        { return SubQGraphicsProxyWidget::hideEvent(event); }

    void call_hoverEnterEvent(QGraphicsSceneHoverEvent* event)

        { return SubQGraphicsProxyWidget::hoverEnterEvent(event); }

    void call_hoverLeaveEvent(QGraphicsSceneHoverEvent* event)

        { return SubQGraphicsProxyWidget::hoverLeaveEvent(event); }

    void call_hoverMoveEvent(QGraphicsSceneHoverEvent* event)

        { return SubQGraphicsProxyWidget::hoverMoveEvent(event); }

    void call_keyPressEvent(QKeyEvent* event)

        { return SubQGraphicsProxyWidget::keyPressEvent(event); }

    void call_keyReleaseEvent(QKeyEvent* event)

        { return SubQGraphicsProxyWidget::keyReleaseEvent(event); }

    void call_mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event)

        { return SubQGraphicsProxyWidget::mouseDoubleClickEvent(event); }

    void call_mouseMoveEvent(QGraphicsSceneMouseEvent* event)

        { return SubQGraphicsProxyWidget::mouseMoveEvent(event); }

    void call_mousePressEvent(QGraphicsSceneMouseEvent* event)

        { return SubQGraphicsProxyWidget::mousePressEvent(event); }

    void call_mouseReleaseEvent(QGraphicsSceneMouseEvent* event)

        { return SubQGraphicsProxyWidget::mouseReleaseEvent(event); }

    void call_resizeEvent(QGraphicsSceneResizeEvent* event)

        { return SubQGraphicsProxyWidget::resizeEvent(event); }

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

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

    void call_showEvent(QShowEvent* event)

        { return SubQGraphicsProxyWidget::showEvent(event); }

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

        paintCount++;

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

    }

    void focusOutEvent(QFocusEvent *event)

    {

        focusOut++;

        QGraphicsProxyWidget::focusOutEvent(event);

    }

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

        if (event->type() == QEvent::KeyPress && object == widget())

            keyPress++;

        return QGraphicsProxyWidget::eventFilter(object, event);

    }

    int paintCount;

    int keyPress;

    int focusOut;

};

class WheelWidget : public QWidget

{

public:

    WheelWidget() : wheelEventCalled(false) { setFocusPolicy(Qt::WheelFocus); }

    virtual void wheelEvent(QWheelEvent *event) { event->accept(); wheelEventCalled = true; }

    bool wheelEventCalled;

};

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

// It is only called once.

void tst_QGraphicsProxyWidget::initTestCase()

{

#ifdef Q_OS_WINCE //disable magic for WindowsCE

    qApp->setAutoMaximizeThreshold(-1);

#endif

}

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

// It is only called once.

void tst_QGraphicsProxyWidget::cleanupTestCase()

{

}

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

void tst_QGraphicsProxyWidget::init()

{

}

// This will be called after every test function.

void tst_QGraphicsProxyWidget::cleanup()

{

}

void tst_QGraphicsProxyWidget::qgraphicsproxywidget_data()

{

}

void tst_QGraphicsProxyWidget::qgraphicsproxywidget()

{

    SubQGraphicsProxyWidget proxy;

    proxy.paint(0, 0, 0);

    proxy.setWidget(0);

    QVERIFY(proxy.type() == QGraphicsProxyWidget::Type);

    QVERIFY(!proxy.widget());

    QEvent event(QEvent::None);

    proxy.call_eventFilter(0, &event);

    QFocusEvent focusEvent(QEvent::FocusIn);

    focusEvent.ignore();

    proxy.call_focusInEvent(&focusEvent);

    QCOMPARE(focusEvent.isAccepted(), false);

    QCOMPARE(proxy.call_focusNextPrevChild(false), false);

    QCOMPARE(proxy.call_focusNextPrevChild(true), false);

    proxy.call_focusOutEvent(&focusEvent);

    QHideEvent hideEvent;

    proxy.call_hideEvent(&hideEvent);

    QGraphicsSceneHoverEvent hoverEvent;

    proxy.call_hoverEnterEvent(&hoverEvent);

    proxy.call_hoverLeaveEvent(&hoverEvent);

    proxy.call_hoverMoveEvent(&hoverEvent);

    QKeyEvent keyEvent(QEvent::KeyPress, 0, Qt::NoModifier);

    proxy.call_keyPressEvent(&keyEvent);

    proxy.call_keyReleaseEvent(&keyEvent);

    QGraphicsSceneMouseEvent mouseEvent;

    proxy.call_mouseDoubleClickEvent(&mouseEvent);

    proxy.call_mouseMoveEvent(&mouseEvent);

    proxy.call_mousePressEvent(&mouseEvent);

    proxy.call_mouseReleaseEvent(&mouseEvent);

    QGraphicsSceneResizeEvent resizeEvent;

    proxy.call_resizeEvent(&resizeEvent);

    QShowEvent showEvent;

    proxy.call_showEvent(&showEvent);

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

}

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

void tst_QGraphicsProxyWidget::paint()

{

    SubQGraphicsProxyWidget proxy;

    proxy.paint(0, 0, 0);

}

class MyProxyWidget : public QGraphicsProxyWidget

{

public:

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

    {

        // Make sure QGraphicsProxyWidget::paint does not modify the render hints set on the painter.

        painter->setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform

                                | QPainter::NonCosmeticDefaultPen | QPainter::TextAntialiasing);

        const QPainter::RenderHints oldRenderHints = painter->renderHints();

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

        QCOMPARE(painter->renderHints(), oldRenderHints);

    }

};

void tst_QGraphicsProxyWidget::paint_2()

{

    MyProxyWidget *proxyWidget = new MyProxyWidget;

    proxyWidget->setWidget(new QLineEdit);

    QGraphicsScene scene;

    scene.addItem(proxyWidget);

    scene.setSceneRect(scene.itemsBoundingRect());

    // Trigger repaint.

    QPixmap pixmap(scene.sceneRect().toRect().size());

    QPainter painter(&pixmap);

    scene.render(&painter);

}

void tst_QGraphicsProxyWidget::setWidget_data()

{

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

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

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

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

    QTest::newRow("setWidget(0)") << false << false << false << false;

    QTest::newRow("setWidget(widget)") << false << true << false << false;

    QTest::newRow("setWidget(widgetWParent)") << false << true << true << false;

    QTest::newRow("setWidget(1), setWidget(0)") << true << false << false << false;

    QTest::newRow("setWidget(1), setWidget(widget)") << true << true << false << false;

    QTest::newRow("setWidget(1), setWidget(widgetWParent)") << true << true << true << false;

    QTest::newRow("p setWidget(0)") << false << false << false << true;

    QTest::newRow("p setWidget(widget)") << false << true << false << true;

    QTest::newRow("p setWidget(widgetWParent)") << false << true << true << true;

    QTest::newRow("p setWidget(1), setWidget(0)") << true << false << false << true;

    QTest::newRow("p setWidget(1), setWidget(widget)") << true << true << false << true;

    QTest::newRow("p setWidget(1), setWidget(widgetWParent)") << true << true << true << true;

}

// public void setWidget(QWidget* widget)

void tst_QGraphicsProxyWidget::setWidget()

{

    QFETCH(bool, widgetExists);

    QFETCH(bool, insertWidget);

    QFETCH(bool, hasParent);

    QFETCH(bool, proxyHasParent);

    QGraphicsScene scene;

    QGraphicsView view(&scene);

    view.show();

#ifdef Q_WS_X11

    qt_x11_wait_for_window_manager(&view);

#endif

    QPointer<SubQGraphicsProxyWidget> proxy = new SubQGraphicsProxyWidget;

    SubQGraphicsProxyWidget parentProxy;

    scene.addItem(proxy);

    scene.addItem(&parentProxy);

    if (proxyHasParent)

        proxy->setParent(&parentProxy);

    QPointer<QWidget> existingSubWidget = new QWidget;

    proxy->setVisible(false);

    proxy->setEnabled(false);

    if (widgetExists) {

        existingSubWidget->setAttribute(Qt::WA_QuitOnClose, true);

        proxy->setWidget(existingSubWidget);

    }

    QWidget *widget = new QWidget;

#ifndef QT_NO_CURSOR

    widget->setCursor(Qt::IBeamCursor);

#endif

    widget->setPalette(QPalette(Qt::magenta));

    widget->setLayoutDirection(Qt::RightToLeft);

    QCleanlooksStyle cleanlooksStyle;

    widget->setStyle(&cleanlooksStyle);

    widget->setFont(QFont("Times"));

    widget->setVisible(true);

    QApplication::setActiveWindow(widget);

    widget->activateWindow();

    widget->setEnabled(true);

    widget->resize(325, 241);

    widget->setMinimumSize(100, 200);

    widget->setMaximumSize(1000, 2000);

    widget->setFocusPolicy(Qt::TabFocus);

    widget->setContentsMargins(10, 29, 19, 81);

    widget->setFocus(Qt::TabFocusReason);

    widget->setAcceptDrops(true);

    QTRY_VERIFY(widget->hasFocus());

    QVERIFY(widget->isActiveWindow());

    QWidget parentWidget;

    if (hasParent)

        widget->setParent(&parentWidget);

    QWidget *subWidget = insertWidget ? widget : 0;

    bool shouldBeInsertable = !hasParent && subWidget;

    if (shouldBeInsertable)

        subWidget->setAttribute(Qt::WA_QuitOnClose, true);

    proxy->setWidget(subWidget);

    if (shouldBeInsertable) {

        QCOMPARE(proxy->widget(), subWidget);

        QVERIFY(subWidget->testAttribute(Qt::WA_DontShowOnScreen));

        QVERIFY(!subWidget->testAttribute(Qt::WA_QuitOnClose));

        QCOMPARE(proxy->acceptHoverEvents(), true);

#ifndef QT_NO_CURSOR

        QVERIFY(proxy->hasCursor());

        // These should match

        QCOMPARE(proxy->cursor().shape(), widget->cursor().shape());

#endif

        //###QCOMPARE(proxy->palette(), widget->palette());

        QCOMPARE(proxy->layoutDirection(), widget->layoutDirection());

        QCOMPARE(proxy->style(), widget->style());

        QCOMPARE(proxy->isVisible(), widget->isVisible());

        QCOMPARE(proxy->isEnabled(), widget->isEnabled());

        QVERIFY(proxy->flags() & QGraphicsItem::ItemIsFocusable);

        QCOMPARE(proxy->effectiveSizeHint(Qt::MinimumSize).toSize(),

            qSmartMinSize(widget));

        QCOMPARE(proxy->minimumSize().toSize(),

                 qSmartMinSize(widget) );

        QCOMPARE(proxy->maximumSize().toSize(), QSize(1000, 2000));

        QCOMPARE(proxy->effectiveSizeHint(Qt::PreferredSize).toSize(),

                qSmartMinSize(widget));

        QCOMPARE(proxy->size().toSize(), widget->size());

        QCOMPARE(proxy->rect().toRect(), widget->rect());

        QCOMPARE(proxy->focusPolicy(), Qt::WheelFocus);

        QVERIFY(proxy->acceptDrops());

        QCOMPARE(proxy->acceptsHoverEvents(), true); // to get widget enter events

        int left, top, right, bottom;

        widget->getContentsMargins(&left, &top, &right, &bottom);

        qreal rleft, rtop, rright, rbottom;

        proxy->getContentsMargins(&rleft, &rtop, &rright, &rbottom);

        QCOMPARE((qreal)left, rleft);

        QCOMPARE((qreal)top, rtop);

        QCOMPARE((qreal)right, rright);

        QCOMPARE((qreal)bottom, rbottom);

    } else {

        // proxy shouldn't mess with the widget if it can't insert it.

        QCOMPARE(proxy->widget(), (QWidget*)0);

        QCOMPARE(proxy->acceptHoverEvents(), false);

        if (subWidget) {

            QVERIFY(!subWidget->testAttribute(Qt::WA_DontShowOnScreen));

            QVERIFY(subWidget->testAttribute(Qt::WA_QuitOnClose));

            // reset

            subWidget->setAttribute(Qt::WA_QuitOnClose, false);

        }

    }

    if (widgetExists) {

        QCOMPARE(existingSubWidget->parent(), static_cast<QObject*>(0));

        QVERIFY(!existingSubWidget->testAttribute(Qt::WA_DontShowOnScreen));

        QVERIFY(!existingSubWidget->testAttribute(Qt::WA_QuitOnClose));

    }

    if (hasParent)

        widget->setParent(0);

    delete widget;

    if (shouldBeInsertable)

        QVERIFY(!proxy);

    delete existingSubWidget;

    if (!shouldBeInsertable) {

        QVERIFY(proxy);

        delete proxy;

    }