Merge branch '4.7-review' into 4.7-staging

6 files changed, 364 insertions, 54 deletions

diff --git a/tests/auto/q3combobox/tst_q3combobox.cpp b/tests/auto/q3combobox/tst_q3combobox.cpp
index 17bd861..825acb2 100644
--- a/tests/auto/q3combobox/tst_q3combobox.cpp
+++ b/tests/auto/q3combobox/tst_q3combobox.cpp
@@ -1004,6 +1004,10 @@ void tst_Q3ComboBox::wheelEvent()
 
 void tst_Q3ComboBox::task231724_clear()
 {
+#ifdef Q_WS_MACX
+    return; // On Mac, we don't use a ListBox for the popup
+#endif
+
     Q3ComboBox box;
     
     for ( int i = 0; i <50; i++ ) {
diff --git a/tests/auto/q3progressbar/tst_q3progressbar.cpp b/tests/auto/q3progressbar/tst_q3progressbar.cpp
index 745e2d5..3a0c3e2 100644
--- a/tests/auto/q3progressbar/tst_q3progressbar.cpp
+++ b/tests/auto/q3progressbar/tst_q3progressbar.cpp
@@ -45,6 +45,7 @@
 #include <qapplication.h>
 #include <qdebug.h>
 #include <q3progressbar.h>
+#include "../../shared/util.h"
 
 //TESTED_CLASS=
 //TESTED_FILES=
@@ -106,7 +107,7 @@ void tst_Q3ProgressBar::setProgress()
 {
     MyCustomProgressBar * m_progressBar = new MyCustomProgressBar();
     m_progressBar->show();
-    QApplication::processEvents();
+    QTest::qWaitForWindowShown(m_progressBar);
 
     //case with total steps = 0
     m_progressBar->setTotalSteps(0);
@@ -114,10 +115,9 @@ void tst_Q3ProgressBar::setProgress()
     m_progressBar->paintNumber = 0;
     m_progressBar->setProgress(m_progressBar->progress() + 1);
     QCOMPARE(oldValue + 1,m_progressBar->progress());
-    QApplication::processEvents();
 
     // It might be > 1 because it is animated.
-    QVERIFY(m_progressBar->paintNumber >= 1);
+    QTRY_VERIFY(m_progressBar->paintNumber >= 1);
     qDebug() << "Animation test: paintNumber =" << m_progressBar->paintNumber;
     
     //standard case
@@ -125,10 +125,9 @@ void tst_Q3ProgressBar::setProgress()
     m_progressBar->setProgress(0);
     m_progressBar->paintNumber = 0;
     m_progressBar->setProgress(m_progressBar->progress() + 1);
-    QApplication::processEvents();
 
     // It might be > 1 because other events might cause painting.
-    QVERIFY(m_progressBar->paintNumber >= 1);
+    QTRY_VERIFY(m_progressBar->paintNumber >= 1);
     qDebug() << "Standard test: paintNumber =" << m_progressBar->paintNumber;
 }
 
diff --git a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
index e7c63d5..447385a 100644
--- a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
+++ b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
@@ -1091,6 +1091,9 @@ void tst_QGraphicsAnchorLayout::setSpacing()
 #ifdef Q_WS_MAC
     QTest::qWait(200);
 #endif
+
+    // 21x21
+    QCOMPARE(p->size(), QSizeF(41, 41));
     QCOMPARE(a->geometry(), QRectF(0, 0, 20, 20));
     QCOMPARE(b->geometry(), QRectF(21, 0, 20, 20));
     QCOMPARE(c->geometry(), QRectF(0, 21, 41, 20));
diff --git a/tests/auto/qgraphicslayout/tst_qgraphicslayout.cpp b/tests/auto/qgraphicslayout/tst_qgraphicslayout.cpp
index 979f03d..29ea074 100644
--- a/tests/auto/qgraphicslayout/tst_qgraphicslayout.cpp
+++ b/tests/auto/qgraphicslayout/tst_qgraphicslayout.cpp
@@ -62,6 +62,7 @@ private slots:
     void compressLayoutRequest();
     void automaticReparenting();
     void verifyActivate();
+    void invalidate();
     void constructors();
     void alternativeLayoutItems();
     void ownership();
@@ -95,6 +96,14 @@ void tst_QGraphicsLayout::sizeHints()
 
 }
 
+enum FunctionType {
+    SetGeometry = 0,
+    Invalidate,
+    NumFunctionTypes
+};
+
+
+
 class TestGraphicsWidget : public QGraphicsWidget {
 public:
     TestGraphicsWidget(QGraphicsWidget *parent = 0) : QGraphicsWidget(parent)
@@ -108,9 +117,28 @@ public:
     int eventCount(QEvent::Type type) {
         return m_eventCount.value(int(type));
     }
+
     void clearEventCount() {
         m_eventCount.clear();
     }
+
+    void clearCounters() {
+        m_eventCount.clear();
+        functionCount.clear();
+    }
+
+    void setGeometry(const QRectF &rect)
+    {
+        QGraphicsWidget::setGeometry(rect);
+        ++(functionCount[SetGeometry]);
+    }
+
+    void callUpdateGeometry()
+    {
+        // updateGeometry() is protected
+        QGraphicsWidget::updateGeometry();
+    }
+    QMap<FunctionType, int> functionCount;
 private:
     QMap<int, int> m_eventCount;
 };
@@ -122,6 +150,8 @@ void tst_QGraphicsLayout::compressLayoutRequest()
     TestGraphicsWidget *tw = new TestGraphicsWidget();
     scene.addItem(tw);
     view.show();
+
+    QTest::qWaitForWindowShown(&view);
     QGraphicsLinearLayout *lout = new QGraphicsLinearLayout(tw);
     for (int i = 0; i < 4; ++i) {
         QGraphicsWidget *gw = new QGraphicsWidget(tw);
@@ -217,17 +247,27 @@ class TestLayout : public QGraphicsLinearLayout
     TestLayout(QGraphicsLayoutItem *parent = 0)
         : QGraphicsLinearLayout(parent)
     {
-        m_count = 0;
+        setContentsMargins(0,0,0,0);
+        setSpacing(0);
     }
 
-    void setGeometry(const QRectF &rect) {
-
-        ++m_count;
+    void setGeometry(const QRectF &rect)
+    {
+        ++(functionCount[SetGeometry]);
         QGraphicsLinearLayout::setGeometry(rect);
     }
 
+    void invalidate()
+    {
+        ++(functionCount[Invalidate]);
+        QGraphicsLinearLayout::invalidate();
+    }
+
+    void clearCounters() {
+        functionCount.clear();
+    }
 
-    int m_count;
+    QMap<FunctionType, int> functionCount;
 };
 
 void tst_QGraphicsLayout::verifyActivate()
@@ -242,13 +282,278 @@ void tst_QGraphicsLayout::verifyActivate()
     lout->addItem(w);
     window->setLayout(lout);
 
-    QCOMPARE(lout->m_count, 0);
+    QCOMPARE(lout->functionCount[SetGeometry], 0);
     window->setVisible(false);
-    QCOMPARE(lout->m_count, 0);
+    QCOMPARE(lout->functionCount[SetGeometry], 0);
     window->setVisible(true);
     // on polish or the first time a widget is shown, the widget is resized.
-    QCOMPARE(lout->m_count, 1);
+    QCOMPARE(lout->functionCount[SetGeometry], 1);
+
+}
+
+static void clearAllCounters(TestGraphicsWidget *widget)
+{
+    if (!widget)
+        return;
+    widget->clearCounters();
+    TestLayout *layout = static_cast<TestLayout *>(widget->layout());
+    if (layout) {
+        layout->clearCounters();
+        for (int i = layout->count() - 1; i >=0; --i) {
+            QGraphicsLayoutItem *item = layout->itemAt(i);
+            if (item->isLayout()) {
+                // ### Not used ATM
+                //TestLayout *lay = static_cast<TestLayout*>(static_cast<QGraphicsLayout*>(item));
+                //clearAllCounters(lay);
+            } else {
+                TestGraphicsWidget *wid = static_cast<TestGraphicsWidget *>(item);
+                clearAllCounters(wid);
+            }
+        }
+    }
+}
+
+static void activateAndReset(TestGraphicsWidget *widget)
+{
+    QApplication::sendPostedEvents();
+    QApplication::processEvents();
+    if (widget->layout())
+        widget->layout()->activate();
+    clearAllCounters(widget);
+}
+
+
+void tst_QGraphicsLayout::invalidate()
+{
+    QGraphicsLayout::setInstantInvalidatePropagation(true);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    TestGraphicsWidget *a = new TestGraphicsWidget;
+    a->setData(0, QString("a"));
+    scene.addItem(a);
+    TestLayout *alay = new TestLayout(a);
+    TestGraphicsWidget *b = new TestGraphicsWidget;
+    b->setData(0, QString("b"));
+    alay->addItem(b);
+    TestLayout *blay = new TestLayout(b);
+    TestGraphicsWidget *e = new TestGraphicsWidget;
+    e->setData(0, QString("e"));
+    blay->addItem(e);
+
+
+    TestGraphicsWidget *c = new TestGraphicsWidget;
+    c->setData(0, QString("c"));
+    alay->addItem(c);
+    TestLayout *clay = new TestLayout(c);
+    TestGraphicsWidget *f = new TestGraphicsWidget;
+    f->setData(0, QString("f"));
+    clay->addItem(f);
+
+    TestGraphicsWidget *d = new TestGraphicsWidget;
+    d->setData(0, QString("d"));
+    alay->addItem(d);
+    TestLayout *dlay = new TestLayout(d);
+    TestGraphicsWidget *g = new TestGraphicsWidget;
+    g->setData(0, QString("g"));
+    dlay->addItem(g);
+
+    view.show();
+
+    {
+        clearAllCounters(a);
+
+        QCoreApplication::sendPostedEvents();
+        QCoreApplication::processEvents();
+
+        alay->activate();
+        QCOMPARE(alay->isActivated(), true);
+        QCOMPARE(blay->isActivated(), true);
+        QCOMPARE(clay->isActivated(), true);
+        QCOMPARE(dlay->isActivated(), true);
+    }
+
+    {
+        clearAllCounters(a);
+        e->callUpdateGeometry();
+        QCOMPARE(alay->isActivated(), false);
+        QCOMPARE(blay->isActivated(), false);
+        QCOMPARE(clay->isActivated(), true);
+        QCOMPARE(dlay->isActivated(), true);
+        QCOMPARE(a->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(b->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(d->eventCount(QEvent::LayoutRequest), 0);
+
+        // should only invalidate ascendants of e
+        QCOMPARE(blay->functionCount[Invalidate], 1);
+        QCOMPARE(alay->functionCount[Invalidate], 1);
+        // not siblings
+        QCOMPARE(clay->functionCount[Invalidate], 0);
+        QCOMPARE(dlay->functionCount[Invalidate], 0);
+
+        QApplication::sendPostedEvents();
+        QCOMPARE(a->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(b->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(d->eventCount(QEvent::LayoutRequest), 0);
+    }
 
+
+    {
+        activateAndReset(a);
+        f->callUpdateGeometry();
+        QCOMPARE(alay->isActivated(), false);
+        QCOMPARE(blay->isActivated(), true);
+        QCOMPARE(clay->isActivated(), false);
+        QCOMPARE(dlay->isActivated(), true);
+
+        QCoreApplication::sendPostedEvents();
+        QCOMPARE(a->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(b->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(d->eventCount(QEvent::LayoutRequest), 0);
+
+        QCOMPARE(a->functionCount[SetGeometry], 1);
+        QCOMPARE(alay->functionCount[SetGeometry], 1);
+
+        QCOMPARE(b->functionCount[SetGeometry], 1);
+        QCOMPARE(c->functionCount[SetGeometry], 1);
+        QCOMPARE(d->functionCount[SetGeometry], 1);
+        // Since nothing really changed, blay and dlay don't need
+        // to be resized.
+        QCOMPARE(blay->functionCount[SetGeometry], 0);
+        QCOMPARE(clay->functionCount[SetGeometry], 1);
+        QCOMPARE(dlay->functionCount[SetGeometry], 0);
+
+        QCOMPARE(f->functionCount[SetGeometry], 1);
+
+        QCOMPARE(a->size(), QSizeF(150, 50));
+    }
+
+    {
+        activateAndReset(a);
+        f->setPreferredSize(QSizeF(60,50));
+        QCOMPARE(alay->isActivated(), false);
+        QCOMPARE(blay->isActivated(), true);
+        QCOMPARE(clay->isActivated(), false);
+        QCOMPARE(dlay->isActivated(), true);
+
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 0);
+        QCoreApplication::sendPostedEvents();
+        QCOMPARE(a->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(b->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(d->eventCount(QEvent::LayoutRequest), 0);
+
+        QCOMPARE(a->functionCount[SetGeometry], 1);
+        QCOMPARE(alay->functionCount[SetGeometry], 1);
+
+        QCOMPARE(b->functionCount[SetGeometry], 1);
+        QCOMPARE(c->functionCount[SetGeometry], 1);
+        QCOMPARE(d->functionCount[SetGeometry], 1);
+        // f actually got wider, need to rearrange its siblings
+        QCOMPARE(blay->functionCount[SetGeometry], 1);
+        QCOMPARE(clay->functionCount[SetGeometry], 1);
+        QCOMPARE(dlay->functionCount[SetGeometry], 1);
+
+        QCOMPARE(e->functionCount[SetGeometry], 1);
+        QCOMPARE(f->functionCount[SetGeometry], 1);
+        QCOMPARE(g->functionCount[SetGeometry], 1);
+
+        QVERIFY(e->size().width() < f->size().width());
+        QVERIFY(g->size().width() < f->size().width());
+    }
+
+    {
+        // resize f so much that it'll force a resize of the top widget
+        // this will currently generate two setGeometry() calls on the child layout
+        // of the top widget.
+        activateAndReset(a);
+        f->setPreferredSize(QSizeF());
+        f->setMinimumSize(QSizeF(200,50));
+        QCOMPARE(alay->isActivated(), false);
+        QCOMPARE(blay->isActivated(), true);
+        QCOMPARE(clay->isActivated(), false);
+        QCOMPARE(dlay->isActivated(), true);
+
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 0);
+        QCoreApplication::sendPostedEvents();
+        QCOMPARE(a->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(b->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(d->eventCount(QEvent::LayoutRequest), 0);
+
+        QCOMPARE(a->functionCount[SetGeometry], 1);
+
+        /* well, ideally one call to setGeometry(), but it will currently
+         * get two calls to setGeometry():
+         *   1. The first LayoutRequest will call activate() - that will call
+         *      setGeometry() on the layout. This geometry will be based on
+         *      the widget geometry which is not correct at this moment.
+         *      (it is still 150 wide)
+         *   2. Next, we check if the widget is top level, and then we call
+         *      parentWidget->resize(parentWidget->size());
+         *      This will be adjusted to be minimum 200 pixels wide.
+         *      The new size will then be propagated down to the layout
+         *
+         */
+        QCOMPARE(alay->functionCount[SetGeometry], 2);
+
+        QCOMPARE(b->functionCount[SetGeometry], 2);
+        QCOMPARE(c->functionCount[SetGeometry], 2);
+        QCOMPARE(d->functionCount[SetGeometry], 2);
+        // f actually got wider, need to rearrange its siblings
+        QCOMPARE(blay->functionCount[SetGeometry], 1);
+        QCOMPARE(clay->functionCount[SetGeometry], 1);
+        QCOMPARE(dlay->functionCount[SetGeometry], 1);
+
+        QCOMPARE(e->functionCount[SetGeometry], 1);
+        QCOMPARE(f->functionCount[SetGeometry], 1);
+        QCOMPARE(g->functionCount[SetGeometry], 1);
+
+        QVERIFY(e->size().width() < f->size().width());
+        QVERIFY(g->size().width() < f->size().width());
+    }
+
+    {
+        f->setPreferredSize(QSizeF());
+        f->setMinimumSize(QSizeF());
+        a->adjustSize();
+        activateAndReset(a);
+        // update two different leaf widgets,
+        // eventCount and functionCount should never be >= 2
+        e->callUpdateGeometry();
+        g->callUpdateGeometry();
+        QCOMPARE(alay->isActivated(), false);
+        QCOMPARE(blay->isActivated(), false);
+        QCOMPARE(clay->isActivated(), true);
+        QCOMPARE(dlay->isActivated(), false);
+
+        QCoreApplication::sendPostedEvents();
+        QCOMPARE(a->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(b->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(d->eventCount(QEvent::LayoutRequest), 1);
+
+        QCOMPARE(a->functionCount[SetGeometry], 1);
+        QCOMPARE(alay->functionCount[SetGeometry], 1);
+
+        QCOMPARE(b->functionCount[SetGeometry], 1);
+        QCOMPARE(c->functionCount[SetGeometry], 1);
+        QCOMPARE(d->functionCount[SetGeometry], 1);
+        // f actually got wider, need to rearrange its siblings
+        QCOMPARE(blay->functionCount[SetGeometry], 1);
+        QCOMPARE(clay->functionCount[SetGeometry], 0);
+        QCOMPARE(dlay->functionCount[SetGeometry], 1);
+
+        QCOMPARE(e->functionCount[SetGeometry], 1);
+        QCOMPARE(f->functionCount[SetGeometry], 0);
+        QCOMPARE(g->functionCount[SetGeometry], 1);
+
+    }
+
+    QGraphicsLayout::setInstantInvalidatePropagation(false);
 }
 
 class Layout : public QGraphicsLayout
diff --git a/tests/auto/qgraphicslinearlayout/tst_qgraphicslinearlayout.cpp b/tests/auto/qgraphicslinearlayout/tst_qgraphicslinearlayout.cpp
index 62ba1b4..8f8ac67 100644
--- a/tests/auto/qgraphicslinearlayout/tst_qgraphicslinearlayout.cpp
+++ b/tests/auto/qgraphicslinearlayout/tst_qgraphicslinearlayout.cpp
@@ -94,6 +94,7 @@ private slots:
     void itemSpacing();
     void setStretchFactor_data();
     void setStretchFactor();
+    void testStretch();
     void defaultStretchFactors_data();
     void defaultStretchFactors();
     void sizeHint_data();
@@ -667,6 +668,10 @@ void tst_QGraphicsLinearLayout::invalidate()
     layout.setContentsMargins(0, 0, 0, 0);
     view.show();
     widget->show();
+    //QTest::qWait(1000);
+    QTest::qWaitForWindowShown(&view);
+    qApp->processEvents();
+    layout.layoutRequest = 0;
 
     layout.setContentsMargins(1, 2, 3, 4);
     QApplication::sendPostedEvents(0, 0);
@@ -1130,6 +1135,41 @@ void tst_QGraphicsLinearLayout::setStretchFactor()
     delete widget;
 }
 
+void tst_QGraphicsLinearLayout::testStretch()
+{
+    QGraphicsScene scene;
+    QGraphicsView *view = new QGraphicsView(&scene);
+    QGraphicsWidget *form = new QGraphicsWidget(0, Qt::Window);
+
+    scene.addItem(form);
+    form->setMinimumSize(600, 600);
+    form->setMaximumSize(600, 600);
+    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Horizontal, form);
+    QGraphicsWidget *w1 = new RectWidget;
+    w1->setPreferredSize(100,100);
+    w1->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
+    QGraphicsWidget *w2 = new RectWidget;
+    w2->setPreferredSize(200,200);
+    w2->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
+    layout->setSpacing(0);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->addItem(w1);
+    layout->addStretch(2);
+    layout->addItem(w2);
+    QCOMPARE(layout->count(), 2);
+    QVERIFY(layout->itemAt(0) == w1);
+    QVERIFY(layout->itemAt(1) == w2);
+    layout->activate();
+
+    //view->setSceneRect(-50, -50, 800, 800);
+    //view->show();
+    //QTest::qWaitForWindowShown(view);
+    //QTest::qWait(5000);
+    QCOMPARE(form->geometry().size(), QSizeF(600,600));
+    QCOMPARE(w1->geometry(), QRectF(0, 0, 100, 100));
+    QCOMPARE(w2->geometry(), QRectF(400, 0, 200, 200));
+}
+
 void tst_QGraphicsLinearLayout::defaultStretchFactors_data()
 {
     QTest::addColumn<Qt::Orientation>("orientation");
diff --git a/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp b/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp
index e8e2e23..887026c 100644
--- a/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp
+++ b/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp
@@ -186,7 +186,6 @@ private slots:
     void task250119_shortcutContext();
     void QT_BUG_6544_tabFocusFirstUnsetWhenRemovingItems();
     void QT_BUG_12056_tabFocusFirstUnsetWhenRemovingItems();
-    void QT_BUG_13865_doublePaintWhenAddingASubItem();
 };
 
 
@@ -3367,46 +3366,6 @@ void tst_QGraphicsWidget::QT_BUG_12056_tabFocusFirstUnsetWhenRemovingItems()
     //This should not crash
 }
 
-
-struct GreenWidget : public QGraphicsWidget
-{
-    GreenWidget() : count(0)
-    {
-    }
-
-    void paint ( QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * )
-    {
-        count++;
-        painter->setPen(Qt::green);
-        painter->drawRect(option->rect.adjusted(0,0,-1,-1));
-    }
-
-    int count;
-};
-
-void tst_QGraphicsWidget::QT_BUG_13865_doublePaintWhenAddingASubItem()
-{
-    QGraphicsScene scene;
-    QGraphicsView view(&scene);
-    QGraphicsWidget *widget =  new QGraphicsWidget;
-    widget->resize(100, 100);
-    scene.addItem(widget);
-    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(widget);
-
-    view.show();
-    QTest::qWaitForWindowShown(&view);
-    QApplication::processEvents();
-
-
-    GreenWidget *sub =  new GreenWidget;
-    layout->addItem(sub);
-
-    QTest::qWait(100);
-    QCOMPARE(sub->count, 1); //it should only be painted once
-
-}
-
-
 QTEST_MAIN(tst_QGraphicsWidget)
 #include "tst_qgraphicswidget.moc"