--- a/Group/bld.inf Fri Jun 11 11:44:06 2010 +0100
+++ b/Group/bld.inf Mon Jun 14 12:26:38 2010 +0100
@@ -35,6 +35,9 @@
#include "../http/group/bld.inf"
#include "../mediamgmt/group/Bld.inf"
#include "../browser/group/Bld.inf"
+#include "../qt/gestures/bld.inf
+#include "../qt/qwidget/bld.inf"
+#include "../qt/qapplication/bld.inf"
PRJ_TESTEXPORTS
smoketest.oby /epoc32/rom/include/smoketest.oby
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/qt/gestures/smoke_qtgestures.cpp Mon Jun 14 12:26:38 2010 +0100
@@ -0,0 +1,491 @@
+/****************************************************************************
+**
+** 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 "../shared/util.h"
+
+#include <qevent.h>
+#include <qwidget.h>
+#include <qlayout.h>
+#include <qgesture.h>
+#include <qgesturerecognizer.h>
+#include <qgraphicsitem.h>
+#include <qgraphicsview.h>
+
+#include <qdebug.h>
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+static QPointF mapToGlobal(const QPointF &pt, QGraphicsItem *item, QGraphicsView *view)
+{
+ return view->mapToGlobal(view->mapFromScene(item->mapToScene(pt)));
+}
+
+class CustomGesture : public QGesture
+{
+ Q_OBJECT
+public:
+ static Qt::GestureType GestureType;
+
+ CustomGesture(QObject *parent = 0)
+ : QGesture(parent), serial(0)
+ {
+ }
+
+ int serial;
+
+ static const int SerialMaybeThreshold;
+ static const int SerialStartedThreshold;
+ static const int SerialFinishedThreshold;
+};
+Qt::GestureType CustomGesture::GestureType = Qt::CustomGesture;
+const int CustomGesture::SerialMaybeThreshold = 1;
+const int CustomGesture::SerialStartedThreshold = 3;
+const int CustomGesture::SerialFinishedThreshold = 6;
+
+class CustomEvent : public QEvent
+{
+public:
+ static int EventType;
+
+ CustomEvent(int serial_ = 0)
+ : QEvent(QEvent::Type(CustomEvent::EventType)),
+ serial(serial_), hasHotSpot(false)
+ {
+ }
+
+ int serial;
+ QPointF hotSpot;
+ bool hasHotSpot;
+};
+int CustomEvent::EventType = 0;
+
+class CustomGestureRecognizer : public QGestureRecognizer
+{
+public:
+ static bool ConsumeEvents;
+
+ CustomGestureRecognizer()
+ {
+ if (!CustomEvent::EventType)
+ CustomEvent::EventType = QEvent::registerEventType();
+ }
+
+ QGesture* create(QObject *)
+ {
+ return new CustomGesture;
+ }
+
+ QGestureRecognizer::Result recognize(QGesture *state, QObject*, QEvent *event)
+ {
+ if (event->type() == CustomEvent::EventType) {
+ QGestureRecognizer::Result result = 0;
+ if (CustomGestureRecognizer::ConsumeEvents)
+ result |= QGestureRecognizer::ConsumeEventHint;
+ CustomGesture *g = static_cast<CustomGesture*>(state);
+ CustomEvent *e = static_cast<CustomEvent*>(event);
+ g->serial = e->serial;
+ if (e->hasHotSpot)
+ g->setHotSpot(e->hotSpot);
+ if (g->serial >= CustomGesture::SerialFinishedThreshold)
+ result |= QGestureRecognizer::FinishGesture;
+ else if (g->serial >= CustomGesture::SerialStartedThreshold)
+ result |= QGestureRecognizer::TriggerGesture;
+ else if (g->serial >= CustomGesture::SerialMaybeThreshold)
+ result |= QGestureRecognizer::MayBeGesture;
+ else
+ result = QGestureRecognizer::CancelGesture;
+ return result;
+ }
+ return QGestureRecognizer::Ignore;
+ }
+
+ void reset(QGesture *state)
+ {
+ CustomGesture *g = static_cast<CustomGesture *>(state);
+ g->serial = 0;
+ QGestureRecognizer::reset(state);
+ }
+};
+bool CustomGestureRecognizer::ConsumeEvents = false;
+
+// same as CustomGestureRecognizer but triggers early without the maybe state
+class CustomContinuousGestureRecognizer : public QGestureRecognizer
+{
+public:
+ CustomContinuousGestureRecognizer()
+ {
+ if (!CustomEvent::EventType)
+ CustomEvent::EventType = QEvent::registerEventType();
+ }
+
+ QGesture* create(QObject *)
+ {
+ return new CustomGesture;
+ }
+
+ QGestureRecognizer::Result recognize(QGesture *state, QObject*, QEvent *event)
+ {
+ if (event->type() == CustomEvent::EventType) {
+ QGestureRecognizer::Result result = QGestureRecognizer::ConsumeEventHint;
+ CustomGesture *g = static_cast<CustomGesture *>(state);
+ CustomEvent *e = static_cast<CustomEvent *>(event);
+ g->serial = e->serial;
+ if (e->hasHotSpot)
+ g->setHotSpot(e->hotSpot);
+ if (g->serial >= CustomGesture::SerialFinishedThreshold)
+ result |= QGestureRecognizer::FinishGesture;
+ else if (g->serial >= CustomGesture::SerialMaybeThreshold)
+ result |= QGestureRecognizer::TriggerGesture;
+ else
+ result = QGestureRecognizer::CancelGesture;
+ return result;
+ }
+ return QGestureRecognizer::Ignore;
+ }
+
+ void reset(QGesture *state)
+ {
+ CustomGesture *g = static_cast<CustomGesture *>(state);
+ g->serial = 0;
+ QGestureRecognizer::reset(state);
+ }
+};
+
+class GestureWidget : public QWidget
+{
+ Q_OBJECT
+public:
+ GestureWidget(const char *name = 0, QWidget *parent = 0)
+ : QWidget(parent)
+ {
+ if (name)
+ setObjectName(QLatin1String(name));
+ reset();
+ acceptGestureOverride = false;
+ }
+ void reset()
+ {
+ customEventsReceived = 0;
+ gestureEventsReceived = 0;
+ gestureOverrideEventsReceived = 0;
+ events.clear();
+ overrideEvents.clear();
+ ignoredGestures.clear();
+ }
+
+ int customEventsReceived;
+ int gestureEventsReceived;
+ int gestureOverrideEventsReceived;
+ struct Events
+ {
+ QList<Qt::GestureType> all;
+ QList<Qt::GestureType> started;
+ QList<Qt::GestureType> updated;
+ QList<Qt::GestureType> finished;
+ QList<Qt::GestureType> canceled;
+
+ void clear()
+ {
+ all.clear();
+ started.clear();
+ updated.clear();
+ finished.clear();
+ canceled.clear();
+ }
+ } events, overrideEvents;
+
+ bool acceptGestureOverride;
+ QSet<Qt::GestureType> ignoredGestures;
+
+protected:
+ bool event(QEvent *event)
+ {
+ Events *eventsPtr = 0;
+ if (event->type() == QEvent::Gesture) {
+ QGestureEvent *e = static_cast<QGestureEvent*>(event);
+ ++gestureEventsReceived;
+ eventsPtr = &events;
+ foreach(Qt::GestureType type, ignoredGestures)
+ e->ignore(e->gesture(type));
+ } else if (event->type() == QEvent::GestureOverride) {
+ ++gestureOverrideEventsReceived;
+ eventsPtr = &overrideEvents;
+ if (acceptGestureOverride)
+ event->accept();
+ }
+ if (eventsPtr) {
+ QGestureEvent *e = static_cast<QGestureEvent*>(event);
+ QList<QGesture*> gestures = e->gestures();
+ foreach(QGesture *g, gestures) {
+ eventsPtr->all << g->gestureType();
+ switch(g->state()) {
+ case Qt::GestureStarted:
+ eventsPtr->started << g->gestureType();
+ break;
+ case Qt::GestureUpdated:
+ eventsPtr->updated << g->gestureType();
+ break;
+ case Qt::GestureFinished:
+ eventsPtr->finished << g->gestureType();
+ break;
+ case Qt::GestureCanceled:
+ eventsPtr->canceled << g->gestureType();
+ break;
+ default:
+ Q_ASSERT(false);
+ }
+ }
+ } else if (event->type() == CustomEvent::EventType) {
+ ++customEventsReceived;
+ } else {
+ return QWidget::event(event);
+ }
+ return true;
+ }
+};
+
+// TODO rename to sendGestureSequence
+static void sendCustomGesture(CustomEvent *event, QObject *object, QGraphicsScene *scene = 0)
+{
+ for (int i = CustomGesture::SerialMaybeThreshold;
+ i <= CustomGesture::SerialFinishedThreshold; ++i) {
+ event->serial = i;
+ if (scene)
+ scene->sendEvent(qobject_cast<QGraphicsObject *>(object), event);
+ else
+ QApplication::sendEvent(object, event);
+ }
+}
+
+class tst_Gestures : public QObject
+{
+Q_OBJECT
+
+public:
+ tst_Gestures();
+ virtual ~tst_Gestures();
+
+public slots:
+ void initTestCase();
+ void cleanupTestCase();
+ void init();
+ void cleanup();
+
+private slots:
+ void customGesture();
+};
+
+tst_Gestures::tst_Gestures()
+{
+}
+
+tst_Gestures::~tst_Gestures()
+{
+}
+
+void tst_Gestures::initTestCase()
+{
+ CustomGesture::GestureType = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
+ QVERIFY(CustomGesture::GestureType != Qt::GestureType(0));
+ QVERIFY(CustomGesture::GestureType != Qt::CustomGesture);
+}
+
+void tst_Gestures::cleanupTestCase()
+{
+ QGestureRecognizer::unregisterRecognizer(CustomGesture::GestureType);
+}
+
+void tst_Gestures::init()
+{
+}
+
+void tst_Gestures::cleanup()
+{
+}
+
+void tst_Gestures::customGesture()
+{
+ GestureWidget widget;
+ widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
+ CustomEvent event;
+ sendCustomGesture(&event, &widget);
+
+ static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
+ static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
+ QCOMPARE(widget.customEventsReceived, TotalCustomEventsCount);
+ QCOMPARE(widget.gestureEventsReceived, TotalGestureEventsCount);
+ QCOMPARE(widget.gestureOverrideEventsReceived, 0);
+ QCOMPARE(widget.events.all.size(), TotalGestureEventsCount);
+ for(int i = 0; i < widget.events.all.size(); ++i)
+ QCOMPARE(widget.events.all.at(i), CustomGesture::GestureType);
+ QCOMPARE(widget.events.started.size(), 1);
+ QCOMPARE(widget.events.updated.size(), TotalGestureEventsCount - 2);
+ QCOMPARE(widget.events.finished.size(), 1);
+ QCOMPARE(widget.events.canceled.size(), 0);
+}
+
+static const QColor InstanceColors[] = {
+ Qt::blue, Qt::red, Qt::green, Qt::gray, Qt::yellow
+};
+
+class GestureItem : public QGraphicsObject
+{
+ static int InstanceCount;
+
+public:
+ GestureItem(const char *name = 0)
+ {
+ instanceNumber = InstanceCount++;
+ if (name)
+ setObjectName(QLatin1String(name));
+ size = QRectF(0, 0, 100, 100);
+ customEventsReceived = 0;
+ gestureEventsReceived = 0;
+ gestureOverrideEventsReceived = 0;
+ events.clear();
+ overrideEvents.clear();
+ acceptGestureOverride = false;
+ }
+ ~GestureItem()
+ {
+ --InstanceCount;
+ }
+
+ int customEventsReceived;
+ int gestureEventsReceived;
+ int gestureOverrideEventsReceived;
+ struct Events
+ {
+ QList<Qt::GestureType> all;
+ QList<Qt::GestureType> started;
+ QList<Qt::GestureType> updated;
+ QList<Qt::GestureType> finished;
+ QList<Qt::GestureType> canceled;
+
+ void clear()
+ {
+ all.clear();
+ started.clear();
+ updated.clear();
+ finished.clear();
+ canceled.clear();
+ }
+ } events, overrideEvents;
+
+ bool acceptGestureOverride;
+ QSet<Qt::GestureType> ignoredGestures;
+
+ QRectF size;
+ int instanceNumber;
+
+ void reset()
+ {
+ customEventsReceived = 0;
+ gestureEventsReceived = 0;
+ gestureOverrideEventsReceived = 0;
+ events.clear();
+ overrideEvents.clear();
+ ignoredGestures.clear();
+ }
+
+protected:
+ QRectF boundingRect() const
+ {
+ return size;
+ }
+ void paint(QPainter *p, const QStyleOptionGraphicsItem *, QWidget *)
+ {
+ QColor color = InstanceColors[instanceNumber % (sizeof(InstanceColors)/sizeof(InstanceColors[0]))];
+ p->fillRect(boundingRect(), color);
+ }
+
+ bool event(QEvent *event)
+ {
+ Events *eventsPtr = 0;
+ if (event->type() == QEvent::Gesture) {
+ ++gestureEventsReceived;
+ eventsPtr = &events;
+ QGestureEvent *e = static_cast<QGestureEvent *>(event);
+ foreach(Qt::GestureType type, ignoredGestures)
+ e->ignore(e->gesture(type));
+ } else if (event->type() == QEvent::GestureOverride) {
+ ++gestureOverrideEventsReceived;
+ eventsPtr = &overrideEvents;
+ if (acceptGestureOverride)
+ event->accept();
+ }
+ if (eventsPtr) {
+ QGestureEvent *e = static_cast<QGestureEvent*>(event);
+ QList<QGesture*> gestures = e->gestures();
+ foreach(QGesture *g, gestures) {
+ eventsPtr->all << g->gestureType();
+ switch(g->state()) {
+ case Qt::GestureStarted:
+ eventsPtr->started << g->gestureType();
+ break;
+ case Qt::GestureUpdated:
+ eventsPtr->updated << g->gestureType();
+ break;
+ case Qt::GestureFinished:
+ eventsPtr->finished << g->gestureType();
+ break;
+ case Qt::GestureCanceled:
+ eventsPtr->canceled << g->gestureType();
+ break;
+ default:
+ Q_ASSERT(false);
+ }
+ }
+ } else if (event->type() == CustomEvent::EventType) {
+ ++customEventsReceived;
+ } else {
+ return QGraphicsObject::event(event);
+ }
+ return true;
+ }
+};
+int GestureItem::InstanceCount = 0;
+
+QTEST_MAIN(tst_Gestures)
+#include "smoke_qtgestures.moc"
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/qt/gestures/smoke_qtgestures.pro Mon Jun 14 12:26:38 2010 +0100
@@ -0,0 +1,5 @@
+load(qttest_p4)
+SOURCES += smoke_qtgestures.cpp
+
+
+
--- a/qt/gestures/smoketest_qgestures.pro Fri Jun 11 11:44:06 2010 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,5 +0,0 @@
-load(qttest_p4)
-SOURCES += tst_gestures.cpp
-
-
-
--- a/qt/gestures/tst_gestures.cpp Fri Jun 11 11:44:06 2010 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1660 +0,0 @@
-/****************************************************************************
-**
-** 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 "../shared/util.h"
-
-#include <qevent.h>
-#include <qwidget.h>
-#include <qlayout.h>
-#include <qgesture.h>
-#include <qgesturerecognizer.h>
-#include <qgraphicsitem.h>
-#include <qgraphicsview.h>
-
-#include <qdebug.h>
-
-//TESTED_CLASS=
-//TESTED_FILES=
-
-static QPointF mapToGlobal(const QPointF &pt, QGraphicsItem *item, QGraphicsView *view)
-{
- return view->mapToGlobal(view->mapFromScene(item->mapToScene(pt)));
-}
-
-class CustomGesture : public QGesture
-{
- Q_OBJECT
-public:
- static Qt::GestureType GestureType;
-
- CustomGesture(QObject *parent = 0)
- : QGesture(parent), serial(0)
- {
- }
-
- int serial;
-
- static const int SerialMaybeThreshold;
- static const int SerialStartedThreshold;
- static const int SerialFinishedThreshold;
-};
-Qt::GestureType CustomGesture::GestureType = Qt::CustomGesture;
-const int CustomGesture::SerialMaybeThreshold = 1;
-const int CustomGesture::SerialStartedThreshold = 3;
-const int CustomGesture::SerialFinishedThreshold = 6;
-
-class CustomEvent : public QEvent
-{
-public:
- static int EventType;
-
- CustomEvent(int serial_ = 0)
- : QEvent(QEvent::Type(CustomEvent::EventType)),
- serial(serial_), hasHotSpot(false)
- {
- }
-
- int serial;
- QPointF hotSpot;
- bool hasHotSpot;
-};
-int CustomEvent::EventType = 0;
-
-class CustomGestureRecognizer : public QGestureRecognizer
-{
-public:
- static bool ConsumeEvents;
-
- CustomGestureRecognizer()
- {
- if (!CustomEvent::EventType)
- CustomEvent::EventType = QEvent::registerEventType();
- }
-
- QGesture* create(QObject *)
- {
- return new CustomGesture;
- }
-
- QGestureRecognizer::Result recognize(QGesture *state, QObject*, QEvent *event)
- {
- if (event->type() == CustomEvent::EventType) {
- QGestureRecognizer::Result result = 0;
- if (CustomGestureRecognizer::ConsumeEvents)
- result |= QGestureRecognizer::ConsumeEventHint;
- CustomGesture *g = static_cast<CustomGesture*>(state);
- CustomEvent *e = static_cast<CustomEvent*>(event);
- g->serial = e->serial;
- if (e->hasHotSpot)
- g->setHotSpot(e->hotSpot);
- if (g->serial >= CustomGesture::SerialFinishedThreshold)
- result |= QGestureRecognizer::FinishGesture;
- else if (g->serial >= CustomGesture::SerialStartedThreshold)
- result |= QGestureRecognizer::TriggerGesture;
- else if (g->serial >= CustomGesture::SerialMaybeThreshold)
- result |= QGestureRecognizer::MayBeGesture;
- else
- result = QGestureRecognizer::CancelGesture;
- return result;
- }
- return QGestureRecognizer::Ignore;
- }
-
- void reset(QGesture *state)
- {
- CustomGesture *g = static_cast<CustomGesture *>(state);
- g->serial = 0;
- QGestureRecognizer::reset(state);
- }
-};
-bool CustomGestureRecognizer::ConsumeEvents = false;
-
-// same as CustomGestureRecognizer but triggers early without the maybe state
-class CustomContinuousGestureRecognizer : public QGestureRecognizer
-{
-public:
- CustomContinuousGestureRecognizer()
- {
- if (!CustomEvent::EventType)
- CustomEvent::EventType = QEvent::registerEventType();
- }
-
- QGesture* create(QObject *)
- {
- return new CustomGesture;
- }
-
- QGestureRecognizer::Result recognize(QGesture *state, QObject*, QEvent *event)
- {
- if (event->type() == CustomEvent::EventType) {
- QGestureRecognizer::Result result = QGestureRecognizer::ConsumeEventHint;
- CustomGesture *g = static_cast<CustomGesture *>(state);
- CustomEvent *e = static_cast<CustomEvent *>(event);
- g->serial = e->serial;
- if (e->hasHotSpot)
- g->setHotSpot(e->hotSpot);
- if (g->serial >= CustomGesture::SerialFinishedThreshold)
- result |= QGestureRecognizer::FinishGesture;
- else if (g->serial >= CustomGesture::SerialMaybeThreshold)
- result |= QGestureRecognizer::TriggerGesture;
- else
- result = QGestureRecognizer::CancelGesture;
- return result;
- }
- return QGestureRecognizer::Ignore;
- }
-
- void reset(QGesture *state)
- {
- CustomGesture *g = static_cast<CustomGesture *>(state);
- g->serial = 0;
- QGestureRecognizer::reset(state);
- }
-};
-
-class GestureWidget : public QWidget
-{
- Q_OBJECT
-public:
- GestureWidget(const char *name = 0, QWidget *parent = 0)
- : QWidget(parent)
- {
- if (name)
- setObjectName(QLatin1String(name));
- reset();
- acceptGestureOverride = false;
- }
- void reset()
- {
- customEventsReceived = 0;
- gestureEventsReceived = 0;
- gestureOverrideEventsReceived = 0;
- events.clear();
- overrideEvents.clear();
- ignoredGestures.clear();
- }
-
- int customEventsReceived;
- int gestureEventsReceived;
- int gestureOverrideEventsReceived;
- struct Events
- {
- QList<Qt::GestureType> all;
- QList<Qt::GestureType> started;
- QList<Qt::GestureType> updated;
- QList<Qt::GestureType> finished;
- QList<Qt::GestureType> canceled;
-
- void clear()
- {
- all.clear();
- started.clear();
- updated.clear();
- finished.clear();
- canceled.clear();
- }
- } events, overrideEvents;
-
- bool acceptGestureOverride;
- QSet<Qt::GestureType> ignoredGestures;
-
-protected:
- bool event(QEvent *event)
- {
- Events *eventsPtr = 0;
- if (event->type() == QEvent::Gesture) {
- QGestureEvent *e = static_cast<QGestureEvent*>(event);
- ++gestureEventsReceived;
- eventsPtr = &events;
- foreach(Qt::GestureType type, ignoredGestures)
- e->ignore(e->gesture(type));
- } else if (event->type() == QEvent::GestureOverride) {
- ++gestureOverrideEventsReceived;
- eventsPtr = &overrideEvents;
- if (acceptGestureOverride)
- event->accept();
- }
- if (eventsPtr) {
- QGestureEvent *e = static_cast<QGestureEvent*>(event);
- QList<QGesture*> gestures = e->gestures();
- foreach(QGesture *g, gestures) {
- eventsPtr->all << g->gestureType();
- switch(g->state()) {
- case Qt::GestureStarted:
- eventsPtr->started << g->gestureType();
- break;
- case Qt::GestureUpdated:
- eventsPtr->updated << g->gestureType();
- break;
- case Qt::GestureFinished:
- eventsPtr->finished << g->gestureType();
- break;
- case Qt::GestureCanceled:
- eventsPtr->canceled << g->gestureType();
- break;
- default:
- Q_ASSERT(false);
- }
- }
- } else if (event->type() == CustomEvent::EventType) {
- ++customEventsReceived;
- } else {
- return QWidget::event(event);
- }
- return true;
- }
-};
-
-// TODO rename to sendGestureSequence
-static void sendCustomGesture(CustomEvent *event, QObject *object, QGraphicsScene *scene = 0)
-{
- for (int i = CustomGesture::SerialMaybeThreshold;
- i <= CustomGesture::SerialFinishedThreshold; ++i) {
- event->serial = i;
- if (scene)
- scene->sendEvent(qobject_cast<QGraphicsObject *>(object), event);
- else
- QApplication::sendEvent(object, event);
- }
-}
-
-class tst_Gestures : public QObject
-{
-Q_OBJECT
-
-public:
- tst_Gestures();
- virtual ~tst_Gestures();
-
-public slots:
- void initTestCase();
- void cleanupTestCase();
- void init();
- void cleanup();
-
-private slots:
- void customGesture();
- /*
- void autoCancelingGestures();
- void gestureOverChild();
- void multipleWidgetOnlyGestureInTree();
- void conflictingGestures();
- void finishedWithoutStarted();
- void unknownGesture();
- void graphicsItemGesture();
- void graphicsItemTreeGesture();
- void explicitGraphicsObjectTarget();
- void gestureOverChildGraphicsItem();
- void twoGesturesOnDifferentLevel();
- void multipleGesturesInTree();
- void multipleGesturesInComplexTree();
- void testMapToScene();
- void ungrabGesture();
- void consumeEventHint();
- void unregisterRecognizer();
- void autoCancelGestures();
- void autoCancelGestures2();
- void panelPropagation();
- void panelStacksBehindParent();
- */
-};
-
-tst_Gestures::tst_Gestures()
-{
-}
-
-tst_Gestures::~tst_Gestures()
-{
-}
-
-void tst_Gestures::initTestCase()
-{
- CustomGesture::GestureType = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
- QVERIFY(CustomGesture::GestureType != Qt::GestureType(0));
- QVERIFY(CustomGesture::GestureType != Qt::CustomGesture);
-}
-
-void tst_Gestures::cleanupTestCase()
-{
- QGestureRecognizer::unregisterRecognizer(CustomGesture::GestureType);
-}
-
-void tst_Gestures::init()
-{
-}
-
-void tst_Gestures::cleanup()
-{
-}
-
-void tst_Gestures::customGesture()
-{
- GestureWidget widget;
- widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
- CustomEvent event;
- sendCustomGesture(&event, &widget);
-
- static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
- static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
- QCOMPARE(widget.customEventsReceived, TotalCustomEventsCount);
- QCOMPARE(widget.gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(widget.gestureOverrideEventsReceived, 0);
- QCOMPARE(widget.events.all.size(), TotalGestureEventsCount);
- for(int i = 0; i < widget.events.all.size(); ++i)
- QCOMPARE(widget.events.all.at(i), CustomGesture::GestureType);
- QCOMPARE(widget.events.started.size(), 1);
- QCOMPARE(widget.events.updated.size(), TotalGestureEventsCount - 2);
- QCOMPARE(widget.events.finished.size(), 1);
- QCOMPARE(widget.events.canceled.size(), 0);
-}
-
-/*
-void tst_Gestures::consumeEventHint()
-{
- GestureWidget widget;
- widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
-
- CustomGestureRecognizer::ConsumeEvents = true;
- CustomEvent event;
- sendCustomGesture(&event, &widget);
- CustomGestureRecognizer::ConsumeEvents = false;
-
- QCOMPARE(widget.customEventsReceived, 0);
-}
-*/
-
-/*
-
-void tst_Gestures::autoCancelingGestures()
-{
- GestureWidget widget;
- widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
- // send partial gesture. The gesture will be in the "maybe" state, but will
- // never get enough events to fire, so Qt will have to kill it.
- CustomEvent ev;
- for (int i = CustomGesture::SerialMaybeThreshold;
- i < CustomGesture::SerialStartedThreshold; ++i) {
- ev.serial = i;
- QApplication::sendEvent(&widget, &ev);
- }
- // wait long enough so the gesture manager will cancel the gesture
- QTest::qWait(5000);
- QCOMPARE(widget.customEventsReceived, CustomGesture::SerialStartedThreshold - CustomGesture::SerialMaybeThreshold);
- QCOMPARE(widget.gestureEventsReceived, 0);
- QCOMPARE(widget.gestureOverrideEventsReceived, 0);
- QCOMPARE(widget.events.all.size(), 0);
-}
-
-void tst_Gestures::gestureOverChild()
-{
- GestureWidget widget("widget");
- QVBoxLayout *l = new QVBoxLayout(&widget);
- GestureWidget *child = new GestureWidget("child");
- l->addWidget(child);
-
- widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
-
- CustomEvent event;
- sendCustomGesture(&event, child);
-
- static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
- static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
-
- QCOMPARE(child->customEventsReceived, TotalCustomEventsCount);
- QCOMPARE(widget.customEventsReceived, 0);
- QCOMPARE(child->gestureEventsReceived, 0);
- QCOMPARE(child->gestureOverrideEventsReceived, 0);
- QCOMPARE(widget.gestureEventsReceived, 0);
- QCOMPARE(widget.gestureOverrideEventsReceived, 0);
-
- // enable gestures over the children
- widget.grabGesture(CustomGesture::GestureType);
-
- widget.reset();
- child->reset();
-
- sendCustomGesture(&event, child);
-
- QCOMPARE(child->customEventsReceived, TotalCustomEventsCount);
- QCOMPARE(widget.customEventsReceived, 0);
-
- QCOMPARE(child->gestureEventsReceived, 0);
- QCOMPARE(child->gestureOverrideEventsReceived, 0);
- QCOMPARE(widget.gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(widget.gestureOverrideEventsReceived, 0);
- for(int i = 0; i < widget.events.all.size(); ++i)
- QCOMPARE(widget.events.all.at(i), CustomGesture::GestureType);
- QCOMPARE(widget.events.started.size(), 1);
- QCOMPARE(widget.events.updated.size(), TotalGestureEventsCount - 2);
- QCOMPARE(widget.events.finished.size(), 1);
- QCOMPARE(widget.events.canceled.size(), 0);
-}
-
-void tst_Gestures::multipleWidgetOnlyGestureInTree()
-{
- GestureWidget parent("parent");
- QVBoxLayout *l = new QVBoxLayout(&parent);
- GestureWidget *child = new GestureWidget("child");
- l->addWidget(child);
-
- parent.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
- child->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
-
- static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
- static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
-
- // sending events to the child and making sure there is no conflict
- CustomEvent event;
- sendCustomGesture(&event, child);
-
- QCOMPARE(child->customEventsReceived, TotalCustomEventsCount);
- QCOMPARE(parent.customEventsReceived, 0);
- QCOMPARE(child->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(child->gestureOverrideEventsReceived, 0);
- QCOMPARE(parent.gestureEventsReceived, 0);
- QCOMPARE(parent.gestureOverrideEventsReceived, 0);
-
- parent.reset();
- child->reset();
-
- // same for the parent widget
- sendCustomGesture(&event, &parent);
-
- QCOMPARE(child->customEventsReceived, 0);
- QCOMPARE(parent.customEventsReceived, TotalCustomEventsCount);
- QCOMPARE(child->gestureEventsReceived, 0);
- QCOMPARE(child->gestureOverrideEventsReceived, 0);
- QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(parent.gestureOverrideEventsReceived, 0);
-}
-
-void tst_Gestures::conflictingGestures()
-{
- GestureWidget parent("parent");
- QVBoxLayout *l = new QVBoxLayout(&parent);
- GestureWidget *child = new GestureWidget("child");
- l->addWidget(child);
-
- parent.grabGesture(CustomGesture::GestureType);
- child->grabGesture(CustomGesture::GestureType);
-
- static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
-
- // child accepts the override, parent will not receive anything
- parent.acceptGestureOverride = false;
- child->acceptGestureOverride = true;
-
- // sending events to the child and making sure there is no conflict
- CustomEvent event;
- sendCustomGesture(&event, child);
-
- QCOMPARE(child->gestureOverrideEventsReceived, 1);
- QCOMPARE(child->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(parent.gestureOverrideEventsReceived, 0);
- QCOMPARE(parent.gestureEventsReceived, 0);
-
- parent.reset();
- child->reset();
-
- // parent accepts the override
- parent.acceptGestureOverride = true;
- child->acceptGestureOverride = false;
-
- // sending events to the child and making sure there is no conflict
- sendCustomGesture(&event, child);
-
- QCOMPARE(child->gestureOverrideEventsReceived, 1);
- QCOMPARE(child->gestureEventsReceived, 0);
- QCOMPARE(parent.gestureOverrideEventsReceived, 1);
- QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);
-
- parent.reset();
- child->reset();
-
- // nobody accepts the override, we will send normal events to the closest
- // context (i.e. to the child widget) and it will be propagated and
- // accepted by the parent widget
- parent.acceptGestureOverride = false;
- child->acceptGestureOverride = false;
- child->ignoredGestures << CustomGesture::GestureType;
-
- // sending events to the child and making sure there is no conflict
- sendCustomGesture(&event, child);
-
- QCOMPARE(child->gestureOverrideEventsReceived, 1);
- QCOMPARE(child->gestureEventsReceived, 1);
- QCOMPARE(parent.gestureOverrideEventsReceived, 1);
- QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);
-
- parent.reset();
- child->reset();
-
- // nobody accepts the override, and nobody accepts the gesture event
- parent.acceptGestureOverride = false;
- child->acceptGestureOverride = false;
- parent.ignoredGestures << CustomGesture::GestureType;
- child->ignoredGestures << CustomGesture::GestureType;
-
- // sending events to the child and making sure there is no conflict
- sendCustomGesture(&event, child);
-
- QCOMPARE(child->gestureOverrideEventsReceived, 1);
- QCOMPARE(child->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(parent.gestureOverrideEventsReceived, 1);
- QCOMPARE(parent.gestureEventsReceived, 1);
-
- parent.reset();
- child->reset();
-
- // we set an attribute to make sure all gesture events are propagated
- parent.grabGesture(CustomGesture::GestureType, Qt::ReceivePartialGestures);
- parent.acceptGestureOverride = false;
- child->acceptGestureOverride = false;
- parent.ignoredGestures << CustomGesture::GestureType;
- child->ignoredGestures << CustomGesture::GestureType;
-
- // sending events to the child and making sure there is no conflict
- sendCustomGesture(&event, child);
-
- QCOMPARE(child->gestureOverrideEventsReceived, 1);
- QCOMPARE(child->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(parent.gestureOverrideEventsReceived, 1);
- QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);
-
- parent.reset();
- child->reset();
-
- Qt::GestureType ContinuousGesture = QGestureRecognizer::registerRecognizer(new CustomContinuousGestureRecognizer);
- static const int ContinuousGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
- child->grabGesture(ContinuousGesture);
- // child accepts override. And it also receives another custom gesture.
- parent.acceptGestureOverride = false;
- child->acceptGestureOverride = true;
- sendCustomGesture(&event, child);
-
- QCOMPARE(child->gestureOverrideEventsReceived, 1);
- QVERIFY(child->gestureEventsReceived > TotalGestureEventsCount);
- QCOMPARE(child->events.all.count(), TotalGestureEventsCount + ContinuousGestureEventsCount);
- QCOMPARE(parent.gestureOverrideEventsReceived, 0);
- QCOMPARE(parent.gestureEventsReceived, 0);
-
- QGestureRecognizer::unregisterRecognizer(ContinuousGesture);
-}
-
-void tst_Gestures::finishedWithoutStarted()
-{
- GestureWidget widget;
- widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
-
- // the gesture will claim it finished, but it was never started.
- CustomEvent ev;
- ev.serial = CustomGesture::SerialFinishedThreshold;
- QApplication::sendEvent(&widget, &ev);
-
- QCOMPARE(widget.customEventsReceived, 1);
- QCOMPARE(widget.gestureEventsReceived, 2);
- QCOMPARE(widget.gestureOverrideEventsReceived, 0);
- QCOMPARE(widget.events.all.size(), 2);
- QCOMPARE(widget.events.started.size(), 1);
- QCOMPARE(widget.events.updated.size(), 0);
- QCOMPARE(widget.events.finished.size(), 1);
- QCOMPARE(widget.events.canceled.size(), 0);
-}
-
-*/
-
-/*
-void tst_Gestures::unknownGesture()
-{
- GestureWidget widget;
- widget.grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
- widget.grabGesture(Qt::CustomGesture, Qt::DontStartGestureOnChildren);
- widget.grabGesture(Qt::GestureType(Qt::PanGesture+512), Qt::DontStartGestureOnChildren);
-
- CustomEvent event;
- sendCustomGesture(&event, &widget);
-
- static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
-
- QCOMPARE(widget.gestureEventsReceived, TotalGestureEventsCount);
-}
-*/
-
-static const QColor InstanceColors[] = {
- Qt::blue, Qt::red, Qt::green, Qt::gray, Qt::yellow
-};
-
-class GestureItem : public QGraphicsObject
-{
- static int InstanceCount;
-
-public:
- GestureItem(const char *name = 0)
- {
- instanceNumber = InstanceCount++;
- if (name)
- setObjectName(QLatin1String(name));
- size = QRectF(0, 0, 100, 100);
- customEventsReceived = 0;
- gestureEventsReceived = 0;
- gestureOverrideEventsReceived = 0;
- events.clear();
- overrideEvents.clear();
- acceptGestureOverride = false;
- }
- ~GestureItem()
- {
- --InstanceCount;
- }
-
- int customEventsReceived;
- int gestureEventsReceived;
- int gestureOverrideEventsReceived;
- struct Events
- {
- QList<Qt::GestureType> all;
- QList<Qt::GestureType> started;
- QList<Qt::GestureType> updated;
- QList<Qt::GestureType> finished;
- QList<Qt::GestureType> canceled;
-
- void clear()
- {
- all.clear();
- started.clear();
- updated.clear();
- finished.clear();
- canceled.clear();
- }
- } events, overrideEvents;
-
- bool acceptGestureOverride;
- QSet<Qt::GestureType> ignoredGestures;
-
- QRectF size;
- int instanceNumber;
-
- void reset()
- {
- customEventsReceived = 0;
- gestureEventsReceived = 0;
- gestureOverrideEventsReceived = 0;
- events.clear();
- overrideEvents.clear();
- ignoredGestures.clear();
- }
-
-protected:
- QRectF boundingRect() const
- {
- return size;
- }
- void paint(QPainter *p, const QStyleOptionGraphicsItem *, QWidget *)
- {
- QColor color = InstanceColors[instanceNumber % (sizeof(InstanceColors)/sizeof(InstanceColors[0]))];
- p->fillRect(boundingRect(), color);
- }
-
- bool event(QEvent *event)
- {
- Events *eventsPtr = 0;
- if (event->type() == QEvent::Gesture) {
- ++gestureEventsReceived;
- eventsPtr = &events;
- QGestureEvent *e = static_cast<QGestureEvent *>(event);
- foreach(Qt::GestureType type, ignoredGestures)
- e->ignore(e->gesture(type));
- } else if (event->type() == QEvent::GestureOverride) {
- ++gestureOverrideEventsReceived;
- eventsPtr = &overrideEvents;
- if (acceptGestureOverride)
- event->accept();
- }
- if (eventsPtr) {
- QGestureEvent *e = static_cast<QGestureEvent*>(event);
- QList<QGesture*> gestures = e->gestures();
- foreach(QGesture *g, gestures) {
- eventsPtr->all << g->gestureType();
- switch(g->state()) {
- case Qt::GestureStarted:
- eventsPtr->started << g->gestureType();
- break;
- case Qt::GestureUpdated:
- eventsPtr->updated << g->gestureType();
- break;
- case Qt::GestureFinished:
- eventsPtr->finished << g->gestureType();
- break;
- case Qt::GestureCanceled:
- eventsPtr->canceled << g->gestureType();
- break;
- default:
- Q_ASSERT(false);
- }
- }
- } else if (event->type() == CustomEvent::EventType) {
- ++customEventsReceived;
- } else {
- return QGraphicsObject::event(event);
- }
- return true;
- }
-};
-int GestureItem::InstanceCount = 0;
-
-/*
-void tst_Gestures::graphicsItemGesture()
-{
- QGraphicsScene scene;
- QGraphicsView view(&scene);
- view.setWindowFlags(Qt::X11BypassWindowManagerHint);
-
- GestureItem *item = new GestureItem("item");
- scene.addItem(item);
- item->setPos(100, 100);
-
- view.show();
- QTest::qWaitForWindowShown(&view);
- view.ensureVisible(scene.sceneRect());
-
- view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
- item->grabGesture(CustomGesture::GestureType);
-
- static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
- static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
-
- CustomEvent event;
- // gesture without hotspot should not be delivered to items in the view
- QTest::ignoreMessage(QtWarningMsg, "QGestureManager::deliverEvent: could not find the target for gesture");
- QTest::ignoreMessage(QtWarningMsg, "QGestureManager::deliverEvent: could not find the target for gesture");
- QTest::ignoreMessage(QtWarningMsg, "QGestureManager::deliverEvent: could not find the target for gesture");
- QTest::ignoreMessage(QtWarningMsg, "QGestureManager::deliverEvent: could not find the target for gesture");
- sendCustomGesture(&event, item, &scene);
-
- QCOMPARE(item->customEventsReceived, TotalCustomEventsCount);
- QCOMPARE(item->gestureEventsReceived, 0);
- QCOMPARE(item->gestureOverrideEventsReceived, 0);
-
- item->reset();
-
- // make sure the event is properly delivered if only the hotspot is set.
- event.hotSpot = mapToGlobal(QPointF(10, 10), item, &view);
- event.hasHotSpot = true;
- sendCustomGesture(&event, item, &scene);
-
- QCOMPARE(item->customEventsReceived, TotalCustomEventsCount);
- QCOMPARE(item->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(item->gestureOverrideEventsReceived, 0);
- QCOMPARE(item->events.all.size(), TotalGestureEventsCount);
- for(int i = 0; i < item->events.all.size(); ++i)
- QCOMPARE(item->events.all.at(i), CustomGesture::GestureType);
- QCOMPARE(item->events.started.size(), 1);
- QCOMPARE(item->events.updated.size(), TotalGestureEventsCount - 2);
- QCOMPARE(item->events.finished.size(), 1);
- QCOMPARE(item->events.canceled.size(), 0);
-
- item->reset();
-
- // send gesture to the item which ignores it.
- item->ignoredGestures << CustomGesture::GestureType;
-
- event.hotSpot = mapToGlobal(QPointF(10, 10), item, &view);
- event.hasHotSpot = true;
- sendCustomGesture(&event, item, &scene);
- QCOMPARE(item->customEventsReceived, TotalCustomEventsCount);
- QCOMPARE(item->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(item->gestureOverrideEventsReceived, 0);
-}
-
-void tst_Gestures::graphicsItemTreeGesture()
-{
- QGraphicsScene scene;
- QGraphicsView view(&scene);
- view.setWindowFlags(Qt::X11BypassWindowManagerHint);
-
- GestureItem *item1 = new GestureItem("item1");
- item1->setPos(100, 100);
- item1->size = QRectF(0, 0, 350, 200);
- scene.addItem(item1);
-
- GestureItem *item1_child1 = new GestureItem("item1_child1");
- item1_child1->setPos(50, 50);
- item1_child1->size = QRectF(0, 0, 100, 100);
- item1_child1->setParentItem(item1);
-
- GestureItem *item1_child2 = new GestureItem("item1_child2");
- item1_child2->size = QRectF(0, 0, 100, 100);
- item1_child2->setPos(200, 50);
- item1_child2->setParentItem(item1);
-
- view.show();
- QTest::qWaitForWindowShown(&view);
- view.ensureVisible(scene.sceneRect());
-
- view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
- item1->grabGesture(CustomGesture::GestureType);
-
- static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
-
- CustomEvent event;
- event.hotSpot = mapToGlobal(QPointF(10, 10), item1_child1, &view);
- event.hasHotSpot = true;
-
- item1->ignoredGestures << CustomGesture::GestureType;
- sendCustomGesture(&event, item1_child1, &scene);
- QCOMPARE(item1_child1->gestureOverrideEventsReceived, 0);
- QCOMPARE(item1_child1->gestureEventsReceived, 0);
- QCOMPARE(item1_child2->gestureEventsReceived, 0);
- QCOMPARE(item1_child2->gestureOverrideEventsReceived, 0);
- QCOMPARE(item1->gestureOverrideEventsReceived, 0);
- QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);
-
- item1->reset(); item1_child1->reset(); item1_child2->reset();
-
- item1_child1->grabGesture(CustomGesture::GestureType);
-
- item1->ignoredGestures << CustomGesture::GestureType;
- item1_child1->ignoredGestures << CustomGesture::GestureType;
- sendCustomGesture(&event, item1_child1, &scene);
- QCOMPARE(item1_child1->gestureOverrideEventsReceived, 1);
- QCOMPARE(item1_child1->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(item1_child2->gestureEventsReceived, 0);
- QCOMPARE(item1_child2->gestureOverrideEventsReceived, 0);
- QCOMPARE(item1->gestureOverrideEventsReceived, 1);
- QCOMPARE(item1->gestureEventsReceived, 1);
-}
-
-void tst_Gestures::explicitGraphicsObjectTarget()
-{
- QGraphicsScene scene;
- QGraphicsView view(&scene);
- view.setWindowFlags(Qt::X11BypassWindowManagerHint);
-
- GestureItem *item1 = new GestureItem("item1");
- scene.addItem(item1);
- item1->setPos(100, 100);
- item1->setZValue(1);
-
- GestureItem *item2 = new GestureItem("item2");
- scene.addItem(item2);
- item2->setPos(100, 100);
- item2->setZValue(5);
-
- GestureItem *item2_child1 = new GestureItem("item2_child1");
- scene.addItem(item2_child1);
- item2_child1->setParentItem(item2);
- item2_child1->setPos(10, 10);
-
- view.show();
- QTest::qWaitForWindowShown(&view);
- view.ensureVisible(scene.sceneRect());
-
- view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
- item1->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
- item2->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
- item2_child1->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
-
- static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
-
- // sending events to item1, but the hotSpot is set to item2
- CustomEvent event;
- event.hotSpot = mapToGlobal(QPointF(15, 15), item2, &view);
- event.hasHotSpot = true;
-
- sendCustomGesture(&event, item1, &scene);
-
- QCOMPARE(item1->gestureEventsReceived, 0);
- QCOMPARE(item1->gestureOverrideEventsReceived, 1);
- QCOMPARE(item2_child1->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(item2_child1->gestureOverrideEventsReceived, 1);
- QCOMPARE(item2_child1->events.all.size(), TotalGestureEventsCount);
- for(int i = 0; i < item2_child1->events.all.size(); ++i)
- QCOMPARE(item2_child1->events.all.at(i), CustomGesture::GestureType);
- QCOMPARE(item2_child1->events.started.size(), 1);
- QCOMPARE(item2_child1->events.updated.size(), TotalGestureEventsCount - 2);
- QCOMPARE(item2_child1->events.finished.size(), 1);
- QCOMPARE(item2_child1->events.canceled.size(), 0);
- QCOMPARE(item2->gestureEventsReceived, 0);
- QCOMPARE(item2->gestureOverrideEventsReceived, 1);
-}
-
-void tst_Gestures::gestureOverChildGraphicsItem()
-{
- QGraphicsScene scene;
- QGraphicsView view(&scene);
- view.setWindowFlags(Qt::X11BypassWindowManagerHint);
-
- GestureItem *item0 = new GestureItem("item0");
- scene.addItem(item0);
- item0->setPos(0, 0);
- item0->grabGesture(CustomGesture::GestureType);
- item0->setZValue(1);
-
- GestureItem *item1 = new GestureItem("item1");
- scene.addItem(item1);
- item1->setPos(100, 100);
- item1->setZValue(5);
-
- GestureItem *item2 = new GestureItem("item2");
- scene.addItem(item2);
- item2->setPos(100, 100);
- item2->setZValue(10);
-
- GestureItem *item2_child1 = new GestureItem("item2_child1");
- scene.addItem(item2_child1);
- item2_child1->setParentItem(item2);
- item2_child1->setPos(0, 0);
-
- view.show();
- QTest::qWaitForWindowShown(&view);
- view.ensureVisible(scene.sceneRect());
-
- view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
- item1->grabGesture(CustomGesture::GestureType);
-
- static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
- static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
-
- CustomEvent event;
- event.hotSpot = mapToGlobal(QPointF(10, 10), item2_child1, &view);
- event.hasHotSpot = true;
- sendCustomGesture(&event, item0, &scene);
-
- QCOMPARE(item0->customEventsReceived, TotalCustomEventsCount);
- QCOMPARE(item2_child1->gestureEventsReceived, 0);
- QCOMPARE(item2_child1->gestureOverrideEventsReceived, 0);
- QCOMPARE(item2->gestureEventsReceived, 0);
- QCOMPARE(item2->gestureOverrideEventsReceived, 0);
- QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(item1->gestureOverrideEventsReceived, 0);
-
- item0->reset(); item1->reset(); item2->reset(); item2_child1->reset();
- item2->grabGesture(CustomGesture::GestureType);
- item2->ignoredGestures << CustomGesture::GestureType;
-
- event.hotSpot = mapToGlobal(QPointF(10, 10), item2_child1, &view);
- event.hasHotSpot = true;
- sendCustomGesture(&event, item0, &scene);
-
- QCOMPARE(item2_child1->gestureEventsReceived, 0);
- QCOMPARE(item2_child1->gestureOverrideEventsReceived, 0);
- QCOMPARE(item2->gestureEventsReceived, 1);
- QCOMPARE(item2->gestureOverrideEventsReceived, 1);
- QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(item1->gestureOverrideEventsReceived, 1);
-
- item0->reset(); item1->reset(); item2->reset(); item2_child1->reset();
- item2->grabGesture(CustomGesture::GestureType);
- item2->ignoredGestures << CustomGesture::GestureType;
- item1->ignoredGestures << CustomGesture::GestureType;
-
- event.hotSpot = mapToGlobal(QPointF(10, 10), item2_child1, &view);
- event.hasHotSpot = true;
- sendCustomGesture(&event, item0, &scene);
-
- QCOMPARE(item2_child1->gestureEventsReceived, 0);
- QCOMPARE(item2_child1->gestureOverrideEventsReceived, 0);
- QCOMPARE(item2->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(item2->gestureOverrideEventsReceived, 1);
- QCOMPARE(item1->gestureEventsReceived, 1);
- QCOMPARE(item1->gestureOverrideEventsReceived, 1);
-
- item0->reset(); item1->reset(); item2->reset(); item2_child1->reset();
- item2->grabGesture(CustomGesture::GestureType);
- item2->ignoredGestures << CustomGesture::GestureType;
- item1->ignoredGestures << CustomGesture::GestureType;
- item1->grabGesture(CustomGesture::GestureType, Qt::ReceivePartialGestures);
-
- event.hotSpot = mapToGlobal(QPointF(10, 10), item2_child1, &view);
- event.hasHotSpot = true;
- sendCustomGesture(&event, item0, &scene);
-
- QCOMPARE(item2_child1->gestureEventsReceived, 0);
- QCOMPARE(item2_child1->gestureOverrideEventsReceived, 0);
- QCOMPARE(item2->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(item2->gestureOverrideEventsReceived, 1);
- QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(item1->gestureOverrideEventsReceived, 1);
-}
-
-void tst_Gestures::twoGesturesOnDifferentLevel()
-{
- GestureWidget parent("parent");
- QVBoxLayout *l = new QVBoxLayout(&parent);
- GestureWidget *child = new GestureWidget("child");
- l->addWidget(child);
-
- Qt::GestureType SecondGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
-
- parent.grabGesture(CustomGesture::GestureType);
- child->grabGesture(SecondGesture);
-
- CustomEvent event;
- // sending events that form a gesture to one widget, but they will be
- // filtered by two different gesture recognizers and will generate two
- // QGesture objects. Check that those gesture objects are delivered to
- // different widgets properly.
- sendCustomGesture(&event, child);
-
- static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
- static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
-
- QCOMPARE(child->customEventsReceived, TotalCustomEventsCount);
- QCOMPARE(child->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(child->gestureOverrideEventsReceived, 0);
- QCOMPARE(child->events.all.size(), TotalGestureEventsCount);
- for(int i = 0; i < child->events.all.size(); ++i)
- QCOMPARE(child->events.all.at(i), SecondGesture);
-
- QCOMPARE(parent.gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(parent.gestureOverrideEventsReceived, 0);
- QCOMPARE(parent.events.all.size(), TotalGestureEventsCount);
- for(int i = 0; i < child->events.all.size(); ++i)
- QCOMPARE(parent.events.all.at(i), CustomGesture::GestureType);
-
- QGestureRecognizer::unregisterRecognizer(SecondGesture);
-}
-
-void tst_Gestures::multipleGesturesInTree()
-{
- GestureWidget a("A");
- GestureWidget *A = &a;
- GestureWidget *B = new GestureWidget("B", A);
- GestureWidget *C = new GestureWidget("C", B);
- GestureWidget *D = new GestureWidget("D", C);
-
- Qt::GestureType FirstGesture = CustomGesture::GestureType;
- Qt::GestureType SecondGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
- Qt::GestureType ThirdGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
-
- Qt::GestureFlags flags = Qt::ReceivePartialGestures;
- A->grabGesture(FirstGesture, flags); // A [1 3]
- A->grabGesture(ThirdGesture, flags); // |
- B->grabGesture(SecondGesture, flags); // B [ 2 3]
- B->grabGesture(ThirdGesture, flags); // |
- C->grabGesture(FirstGesture, flags); // C [1 2 3]
- C->grabGesture(SecondGesture, flags); // |
- C->grabGesture(ThirdGesture, flags); // D [1 3]
- D->grabGesture(FirstGesture, flags);
- D->grabGesture(ThirdGesture, flags);
-
- // make sure all widgets ignore events, so they get propagated.
- A->ignoredGestures << FirstGesture << ThirdGesture;
- B->ignoredGestures << SecondGesture << ThirdGesture;
- C->ignoredGestures << FirstGesture << SecondGesture << ThirdGesture;
- D->ignoredGestures << FirstGesture << ThirdGesture;
-
- CustomEvent event;
- sendCustomGesture(&event, D);
-
- static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
-
- // gesture override events
- QCOMPARE(D->overrideEvents.all.count(FirstGesture), 1);
- QCOMPARE(D->overrideEvents.all.count(SecondGesture), 0);
- QCOMPARE(D->overrideEvents.all.count(ThirdGesture), 1);
-
- QCOMPARE(C->overrideEvents.all.count(FirstGesture), 1);
- QCOMPARE(C->overrideEvents.all.count(SecondGesture), 1);
- QCOMPARE(C->overrideEvents.all.count(ThirdGesture), 1);
-
- QCOMPARE(B->overrideEvents.all.count(FirstGesture), 0);
- QCOMPARE(B->overrideEvents.all.count(SecondGesture), 1);
- QCOMPARE(B->overrideEvents.all.count(ThirdGesture), 1);
-
- QCOMPARE(A->overrideEvents.all.count(FirstGesture), 1);
- QCOMPARE(A->overrideEvents.all.count(SecondGesture), 0);
- QCOMPARE(A->overrideEvents.all.count(ThirdGesture), 1);
-
- // normal gesture events
- QCOMPARE(D->events.all.count(FirstGesture), TotalGestureEventsCount);
- QCOMPARE(D->events.all.count(SecondGesture), 0);
- QCOMPARE(D->events.all.count(ThirdGesture), TotalGestureEventsCount);
-
- QCOMPARE(C->events.all.count(FirstGesture), TotalGestureEventsCount);
- QCOMPARE(C->events.all.count(SecondGesture), TotalGestureEventsCount);
- QCOMPARE(C->events.all.count(ThirdGesture), TotalGestureEventsCount);
-
- QCOMPARE(B->events.all.count(FirstGesture), 0);
- QCOMPARE(B->events.all.count(SecondGesture), TotalGestureEventsCount);
- QCOMPARE(B->events.all.count(ThirdGesture), TotalGestureEventsCount);
-
- QCOMPARE(A->events.all.count(FirstGesture), TotalGestureEventsCount);
- QCOMPARE(A->events.all.count(SecondGesture), 0);
- QCOMPARE(A->events.all.count(ThirdGesture), TotalGestureEventsCount);
-
- QGestureRecognizer::unregisterRecognizer(SecondGesture);
- QGestureRecognizer::unregisterRecognizer(ThirdGesture);
-}
-
-void tst_Gestures::multipleGesturesInComplexTree()
-{
- GestureWidget a("A");
- GestureWidget *A = &a;
- GestureWidget *B = new GestureWidget("B", A);
- GestureWidget *C = new GestureWidget("C", B);
- GestureWidget *D = new GestureWidget("D", C);
-
- Qt::GestureType FirstGesture = CustomGesture::GestureType;
- Qt::GestureType SecondGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
- Qt::GestureType ThirdGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
- Qt::GestureType FourthGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
- Qt::GestureType FifthGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
- Qt::GestureType SixthGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
- Qt::GestureType SeventhGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
-
- Qt::GestureFlags flags = Qt::ReceivePartialGestures;
- A->grabGesture(FirstGesture, flags); // A [1,3,4]
- A->grabGesture(ThirdGesture, flags); // |
- A->grabGesture(FourthGesture, flags); // B [2,3,5]
- B->grabGesture(SecondGesture, flags); // |
- B->grabGesture(ThirdGesture, flags); // C [1,2,3,6]
- B->grabGesture(FifthGesture, flags); // |
- C->grabGesture(FirstGesture, flags); // D [1,3,7]
- C->grabGesture(SecondGesture, flags);
- C->grabGesture(ThirdGesture, flags);
- C->grabGesture(SixthGesture, flags);
- D->grabGesture(FirstGesture, flags);
- D->grabGesture(ThirdGesture, flags);
- D->grabGesture(SeventhGesture, flags);
-
- // make sure all widgets ignore events, so they get propagated.
- QSet<Qt::GestureType> allGestureTypes;
- allGestureTypes << FirstGesture << SecondGesture << ThirdGesture
- << FourthGesture << FifthGesture << SixthGesture << SeventhGesture;
- A->ignoredGestures = B->ignoredGestures = allGestureTypes;
- C->ignoredGestures = D->ignoredGestures = allGestureTypes;
-
- CustomEvent event;
- sendCustomGesture(&event, D);
-
- static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
-
- // gesture override events
- QCOMPARE(D->overrideEvents.all.count(FirstGesture), 1);
- QCOMPARE(D->overrideEvents.all.count(SecondGesture), 0);
- QCOMPARE(D->overrideEvents.all.count(ThirdGesture), 1);
-
- QCOMPARE(C->overrideEvents.all.count(FirstGesture), 1);
- QCOMPARE(C->overrideEvents.all.count(SecondGesture), 1);
- QCOMPARE(C->overrideEvents.all.count(ThirdGesture), 1);
-
- QCOMPARE(B->overrideEvents.all.count(FirstGesture), 0);
- QCOMPARE(B->overrideEvents.all.count(SecondGesture), 1);
- QCOMPARE(B->overrideEvents.all.count(ThirdGesture), 1);
-
- QCOMPARE(A->overrideEvents.all.count(FirstGesture), 1);
- QCOMPARE(A->overrideEvents.all.count(SecondGesture), 0);
- QCOMPARE(A->overrideEvents.all.count(ThirdGesture), 1);
-
- // normal gesture events
- QCOMPARE(D->events.all.count(FirstGesture), TotalGestureEventsCount);
- QCOMPARE(D->events.all.count(SecondGesture), 0);
- QCOMPARE(D->events.all.count(ThirdGesture), TotalGestureEventsCount);
- QCOMPARE(D->events.all.count(FourthGesture), 0);
- QCOMPARE(D->events.all.count(FifthGesture), 0);
- QCOMPARE(D->events.all.count(SixthGesture), 0);
- QCOMPARE(D->events.all.count(SeventhGesture), TotalGestureEventsCount);
-
- QCOMPARE(C->events.all.count(FirstGesture), TotalGestureEventsCount);
- QCOMPARE(C->events.all.count(SecondGesture), TotalGestureEventsCount);
- QCOMPARE(C->events.all.count(ThirdGesture), TotalGestureEventsCount);
- QCOMPARE(C->events.all.count(FourthGesture), 0);
- QCOMPARE(C->events.all.count(FifthGesture), 0);
- QCOMPARE(C->events.all.count(SixthGesture), TotalGestureEventsCount);
- QCOMPARE(C->events.all.count(SeventhGesture), 0);
-
- QCOMPARE(B->events.all.count(FirstGesture), 0);
- QCOMPARE(B->events.all.count(SecondGesture), TotalGestureEventsCount);
- QCOMPARE(B->events.all.count(ThirdGesture), TotalGestureEventsCount);
- QCOMPARE(B->events.all.count(FourthGesture), 0);
- QCOMPARE(B->events.all.count(FifthGesture), TotalGestureEventsCount);
- QCOMPARE(B->events.all.count(SixthGesture), 0);
- QCOMPARE(B->events.all.count(SeventhGesture), 0);
-
- QCOMPARE(A->events.all.count(FirstGesture), TotalGestureEventsCount);
- QCOMPARE(A->events.all.count(SecondGesture), 0);
- QCOMPARE(A->events.all.count(ThirdGesture), TotalGestureEventsCount);
- QCOMPARE(A->events.all.count(FourthGesture), TotalGestureEventsCount);
- QCOMPARE(A->events.all.count(FifthGesture), 0);
- QCOMPARE(A->events.all.count(SixthGesture), 0);
- QCOMPARE(A->events.all.count(SeventhGesture), 0);
-
- QGestureRecognizer::unregisterRecognizer(SecondGesture);
- QGestureRecognizer::unregisterRecognizer(ThirdGesture);
- QGestureRecognizer::unregisterRecognizer(FourthGesture);
- QGestureRecognizer::unregisterRecognizer(FifthGesture);
- QGestureRecognizer::unregisterRecognizer(SixthGesture);
- QGestureRecognizer::unregisterRecognizer(SeventhGesture);
-}
-
-void tst_Gestures::testMapToScene()
-{
- QGesture gesture;
- QList<QGesture*> list;
- list << &gesture;
- QGestureEvent event(list);
- QCOMPARE(event.mapToGraphicsScene(gesture.hotSpot()), QPointF()); // not set, can't do much
-
- QGraphicsScene scene;
- QGraphicsView view(&scene);
- view.setWindowFlags(Qt::X11BypassWindowManagerHint);
-
- GestureItem *item0 = new GestureItem;
- scene.addItem(item0);
- item0->setPos(14, 16);
-
- view.show(); // need to show to give it a global coordinate
- QTest::qWaitForWindowShown(&view);
- view.ensureVisible(scene.sceneRect());
-
- QPoint origin = view.mapToGlobal(QPoint());
- event.setWidget(view.viewport());
-
- QCOMPARE(event.mapToGraphicsScene(origin + QPoint(100, 200)), view.mapToScene(QPoint(100, 200)));
-}
-*/
-
-/*
-void tst_Gestures::ungrabGesture() // a method on QWidget
-{
- class MockGestureWidget : public GestureWidget {
- public:
- MockGestureWidget(const char *name = 0, QWidget *parent = 0)
- : GestureWidget(name, parent) { }
-
-
- QSet<QGesture*> gestures;
- protected:
- bool event(QEvent *event)
- {
- if (event->type() == QEvent::Gesture) {
- QGestureEvent *gestureEvent = static_cast<QGestureEvent*>(event);
- if (gestureEvent)
- foreach (QGesture *g, gestureEvent->gestures())
- gestures.insert(g);
- }
- return GestureWidget::event(event);
- }
- };
-
- MockGestureWidget parent("A");
- MockGestureWidget *a = &parent;
- MockGestureWidget *b = new MockGestureWidget("B", a);
-
- a->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
- b->grabGesture(CustomGesture::GestureType);
- b->ignoredGestures << CustomGesture::GestureType;
-
- CustomEvent event;
- // sending an event will cause the QGesture objects to be instantiated for the widgets
- sendCustomGesture(&event, b);
-
- QCOMPARE(a->gestures.count(), 1);
- QPointer<QGesture> customGestureA;
- customGestureA = *(a->gestures.begin());
- QVERIFY(!customGestureA.isNull());
- QCOMPARE(customGestureA->gestureType(), CustomGesture::GestureType);
-
- QCOMPARE(b->gestures.count(), 1);
- QPointer<QGesture> customGestureB;
- customGestureB = *(b->gestures.begin());
- QVERIFY(!customGestureB.isNull());
- QVERIFY(customGestureA.data() == customGestureB.data());
- QCOMPARE(customGestureB->gestureType(), CustomGesture::GestureType);
-
- a->gestures.clear();
- // sending an event will cause the QGesture objects to be instantiated for the widget
- sendCustomGesture(&event, a);
-
- QCOMPARE(a->gestures.count(), 1);
- customGestureA = *(a->gestures.begin());
- QVERIFY(!customGestureA.isNull());
- QCOMPARE(customGestureA->gestureType(), CustomGesture::GestureType);
- QVERIFY(customGestureA.data() != customGestureB.data());
-
- a->ungrabGesture(CustomGesture::GestureType);
- QVERIFY(customGestureA.isNull());
- QVERIFY(!customGestureB.isNull());
-
- a->gestures.clear();
- a->reset();
- // send again to 'b' and make sure a never gets it.
- sendCustomGesture(&event, b);
- QCOMPARE(a->gestureEventsReceived, 0);
- QCOMPARE(a->gestureOverrideEventsReceived, 0);
-}
-*/
-
-/*
-void tst_Gestures::unregisterRecognizer() // a method on QApplication
-{
- The hardest usecase to get right is when we remove a recognizer while several
- of the gestures it created are in active state and we immediately add a new recognizer
- for the same type (thus replacing the old one).
- The expected result is that all old gestures continue till they are finished/cancelled
- and the new recognizer starts creating gestures immediately at registration.
-
- This implies that deleting of the recognizer happens only when there are no more gestures
- that it created. (since gestures might have a pointer to the recognizer)
-}
-*/
-
-/*
-void tst_Gestures::autoCancelGestures()
-{
- class MockWidget : public GestureWidget {
- public:
- MockWidget(const char *name) : GestureWidget(name) { }
-
- bool event(QEvent *event)
- {
- if (event->type() == QEvent::Gesture) {
- QGestureEvent *ge = static_cast<QGestureEvent*>(event);
- Q_ASSERT(ge->gestures().count() == 1); // can't use QCOMPARE here...
- ge->gestures().first()->setGestureCancelPolicy(QGesture::CancelAllInContext);
- }
- return GestureWidget::event(event);
- }
- };
-
- const Qt::GestureType secondGesture = QGestureRecognizer::registerRecognizer(new CustomGestureRecognizer);
-
- MockWidget parent("parent"); // this one sets the cancel policy to CancelAllInContext
- parent.resize(300, 100);
- parent.setWindowFlags(Qt::X11BypassWindowManagerHint);
- GestureWidget *child = new GestureWidget("child", &parent);
- child->setGeometry(10, 10, 100, 80);
-
- parent.grabGesture(CustomGesture::GestureType);
- child->grabGesture(secondGesture);
- parent.show();
- QTest::qWaitForWindowShown(&parent);
-
- An event is send to both the child and the parent, when the child gets it a gesture is triggered
- and send to the child.
- When the parent gets the event a new gesture is triggered and delivered to the parent. When the
- parent gets it he accepts it and that causes the cancel policy to activate.
- The cause of that is the gesture for the child is cancelled and send to the child as such.
-
- CustomEvent event;
- event.serial = CustomGesture::SerialStartedThreshold;
- QApplication::sendEvent(child, &event);
- QCOMPARE(child->events.all.count(), 2);
- QCOMPARE(child->events.started.count(), 1);
- QCOMPARE(child->events.canceled.count(), 1);
- QCOMPARE(parent.events.all.count(), 1);
-
- // clean up, make the parent gesture finish
- event.serial = CustomGesture::SerialFinishedThreshold;
- QApplication::sendEvent(child, &event);
- QCOMPARE(parent.events.all.count(), 2);
-}
-
-void tst_Gestures::autoCancelGestures2()
-{
- class MockItem : public GestureItem {
- public:
- MockItem(const char *name) : GestureItem(name) { }
-
- bool event(QEvent *event) {
- if (event->type() == QEvent::Gesture) {
- QGestureEvent *ge = static_cast<QGestureEvent*>(event);
- Q_ASSERT(ge->gestures().count() == 1); // can't use QCOMPARE here...
- ge->gestures().first()->setGestureCancelPolicy(QGesture::CancelAllInContext);
- }
- return GestureItem::event(event);
- }
- };
-
- const Qt::GestureType secondGesture = QGestureRecognizer ::registerRecognizer(new CustomGestureRecognizer);
-
- QGraphicsScene scene;
- QGraphicsView view(&scene);
- view.setWindowFlags(Qt::X11BypassWindowManagerHint);
-
- MockItem *parent = new MockItem("parent");
- GestureItem *child = new GestureItem("child");
- child->setParentItem(parent);
- parent->setPos(0, 0);
- child->setPos(10, 10);
- scene.addItem(parent);
- view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
- view.viewport()->grabGesture(secondGesture, Qt::DontStartGestureOnChildren);
- parent->grabGesture(CustomGesture::GestureType);
- child->grabGesture(secondGesture);
-
- view.show();
- QTest::qWaitForWindowShown(&view);
- view.ensureVisible(scene.sceneRect());
-
- CustomEvent event;
- event.serial = CustomGesture::SerialStartedThreshold;
- event.hasHotSpot = true;
- event.hotSpot = mapToGlobal(QPointF(5, 5), child, &view);
- scene.sendEvent(child, &event);
- QCOMPARE(parent->events.all.count(), 1);
- QCOMPARE(child->events.started.count(), 1);
- QCOMPARE(child->events.canceled.count(), 1);
- QCOMPARE(child->events.all.count(), 2);
-
- // clean up, make the parent gesture finish
- event.serial = CustomGesture::SerialFinishedThreshold;
- scene.sendEvent(child, &event);
- QCOMPARE(parent->events.all.count(), 2);
-}
-*/
-
-/*
-void tst_Gestures::panelPropagation()
-{
- QGraphicsScene scene;
- QGraphicsView view(&scene);
- view.setWindowFlags(Qt::X11BypassWindowManagerHint);
-
- GestureItem *item0 = new GestureItem("item0");
- scene.addItem(item0);
- item0->setPos(0, 0);
- item0->size = QRectF(0, 0, 200, 200);
- item0->grabGesture(CustomGesture::GestureType);
- item0->setZValue(1);
-
- GestureItem *item1 = new GestureItem("item1");
- item1->grabGesture(CustomGesture::GestureType);
- scene.addItem(item1);
- item1->setPos(10, 10);
- item1->size = QRectF(0, 0, 180, 180);
- item1->setZValue(2);
-
- GestureItem *item1_child1 = new GestureItem("item1_child1[panel]");
- item1_child1->setFlags(QGraphicsItem::ItemIsPanel);
- item1_child1->setParentItem(item1);
- item1_child1->grabGesture(CustomGesture::GestureType);
- item1_child1->setPos(10, 10);
- item1_child1->size = QRectF(0, 0, 160, 160);
- item1_child1->setZValue(5);
-
- GestureItem *item1_child1_child1 = new GestureItem("item1_child1_child1");
- item1_child1_child1->setParentItem(item1_child1);
- item1_child1_child1->grabGesture(CustomGesture::GestureType);
- item1_child1_child1->setPos(10, 10);
- item1_child1_child1->size = QRectF(0, 0, 140, 140);
- item1_child1_child1->setZValue(10);
-
- view.show();
- QTest::qWaitForWindowShown(&view);
- view.ensureVisible(scene.sceneRect());
-
- view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
-
- static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
- static const int TotalCustomEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialMaybeThreshold + 1;
-
- CustomEvent event;
- event.hotSpot = mapToGlobal(QPointF(5, 5), item1_child1_child1, &view);
- event.hasHotSpot = true;
- sendCustomGesture(&event, item0, &scene);
-
- QCOMPARE(item0->customEventsReceived, TotalCustomEventsCount);
- QCOMPARE(item1_child1_child1->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(item1_child1_child1->gestureOverrideEventsReceived, 1);
- QCOMPARE(item1_child1->gestureOverrideEventsReceived, 1);
- QCOMPARE(item1->gestureEventsReceived, 0);
- QCOMPARE(item1->gestureOverrideEventsReceived, 0);
- QCOMPARE(item0->gestureEventsReceived, 0);
- QCOMPARE(item0->gestureOverrideEventsReceived, 0);
-
- item0->reset(); item1->reset(); item1_child1->reset(); item1_child1_child1->reset();
-
- event.hotSpot = mapToGlobal(QPointF(5, 5), item1, &view);
- event.hasHotSpot = true;
- sendCustomGesture(&event, item1, &scene);
-
- QCOMPARE(item1_child1_child1->gestureEventsReceived, 0);
- QCOMPARE(item1_child1_child1->gestureOverrideEventsReceived, 0);
- QCOMPARE(item1_child1->gestureEventsReceived, 0);
- QCOMPARE(item1_child1->gestureOverrideEventsReceived, 0);
- QCOMPARE(item1->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(item1->gestureOverrideEventsReceived, 1);
- QCOMPARE(item0->gestureEventsReceived, 0);
- QCOMPARE(item0->gestureOverrideEventsReceived, 1);
-
- item0->reset(); item1->reset(); item1_child1->reset(); item1_child1_child1->reset();
- // try with a modal panel
- item1_child1->setPanelModality(QGraphicsItem::PanelModal);
-
- event.hotSpot = mapToGlobal(QPointF(5, 5), item1, &view);
- event.hasHotSpot = true;
- sendCustomGesture(&event, item1, &scene);
-
- QCOMPARE(item1_child1_child1->gestureEventsReceived, 0);
- QCOMPARE(item1_child1_child1->gestureOverrideEventsReceived, 0);
- QCOMPARE(item1_child1->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(item1_child1->gestureOverrideEventsReceived, 0);
- QCOMPARE(item1->gestureEventsReceived, 0);
- QCOMPARE(item1->gestureOverrideEventsReceived, 0);
- QCOMPARE(item0->gestureEventsReceived, 0);
- QCOMPARE(item0->gestureOverrideEventsReceived, 0);
-
- item0->reset(); item1->reset(); item1_child1->reset(); item1_child1_child1->reset();
- // try with a modal panel, however set the hotspot to be outside of the
- // panel and its parent
- item1_child1->setPanelModality(QGraphicsItem::PanelModal);
-
- event.hotSpot = mapToGlobal(QPointF(5, 5), item0, &view);
- event.hasHotSpot = true;
- sendCustomGesture(&event, item1, &scene);
-
- QCOMPARE(item1_child1_child1->gestureEventsReceived, 0);
- QCOMPARE(item1_child1_child1->gestureOverrideEventsReceived, 0);
- QCOMPARE(item1_child1->gestureEventsReceived, 0);
- QCOMPARE(item1_child1->gestureOverrideEventsReceived, 0);
- QCOMPARE(item1->gestureEventsReceived, 0);
- QCOMPARE(item1->gestureOverrideEventsReceived, 0);
- QCOMPARE(item0->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(item0->gestureOverrideEventsReceived, 0);
-
- item0->reset(); item1->reset(); item1_child1->reset(); item1_child1_child1->reset();
- // try with a scene modal panel
- item1_child1->setPanelModality(QGraphicsItem::SceneModal);
-
- event.hotSpot = mapToGlobal(QPointF(5, 5), item0, &view);
- event.hasHotSpot = true;
- sendCustomGesture(&event, item0, &scene);
-
- QCOMPARE(item1_child1_child1->gestureEventsReceived, 0);
- QCOMPARE(item1_child1_child1->gestureOverrideEventsReceived, 0);
- QCOMPARE(item1_child1->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(item1_child1->gestureOverrideEventsReceived, 0);
- QCOMPARE(item1->gestureEventsReceived, 0);
- QCOMPARE(item1->gestureOverrideEventsReceived, 0);
- QCOMPARE(item0->gestureEventsReceived, 0);
- QCOMPARE(item0->gestureOverrideEventsReceived, 0);
-}
-*/
-
-/*
-void tst_Gestures::panelStacksBehindParent()
-{
- QGraphicsScene scene;
- QGraphicsView view(&scene);
- view.setWindowFlags(Qt::X11BypassWindowManagerHint);
-
- GestureItem *item1 = new GestureItem("item1");
- item1->grabGesture(CustomGesture::GestureType);
- scene.addItem(item1);
- item1->setPos(10, 10);
- item1->size = QRectF(0, 0, 180, 180);
- item1->setZValue(2);
-
- GestureItem *panel = new GestureItem("panel");
- panel->setFlags(QGraphicsItem::ItemIsPanel | QGraphicsItem::ItemStacksBehindParent);
- panel->setPanelModality(QGraphicsItem::PanelModal);
- panel->setParentItem(item1);
- panel->grabGesture(CustomGesture::GestureType);
- panel->setPos(-10, -10);
- panel->size = QRectF(0, 0, 200, 200);
- panel->setZValue(5);
-
- view.show();
- QTest::qWaitForWindowShown(&view);
- view.ensureVisible(scene.sceneRect());
-
- view.viewport()->grabGesture(CustomGesture::GestureType, Qt::DontStartGestureOnChildren);
-
- static const int TotalGestureEventsCount = CustomGesture::SerialFinishedThreshold - CustomGesture::SerialStartedThreshold + 1;
-
- CustomEvent event;
- event.hotSpot = mapToGlobal(QPointF(5, 5), item1, &view);
- event.hasHotSpot = true;
- sendCustomGesture(&event, item1, &scene);
-
- QCOMPARE(item1->gestureEventsReceived, 0);
- QCOMPARE(item1->gestureOverrideEventsReceived, 0);
- QCOMPARE(panel->gestureEventsReceived, TotalGestureEventsCount);
- QCOMPARE(panel->gestureOverrideEventsReceived, 0);
-}
-*/
-
-QTEST_MAIN(tst_Gestures)
-#include "tst_gestures.moc"
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/qt/qapplication/smoke_qapplication.cpp Mon Jun 14 12:26:38 2010 +0100
@@ -0,0 +1,153 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+
+//#define QT_TST_QAPP_DEBUG
+#include <qdebug.h>
+
+#include <QtTest/QtTest>
+
+#include "qabstracteventdispatcher.h"
+#include <QtGui>
+
+#include "private/qapplication_p.h"
+#include "private/qstylesheetstyle_p.h"
+#ifdef Q_OS_WINCE
+#include <windows.h>
+#endif
+#ifdef Q_OS_SYMBIAN
+#include <aknenv.h>
+#endif
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+#if defined(Q_OS_SYMBIAN)
+// In Symbian, the PluginsPath doesn't specify the only absolute path; just the dir that can be found on any drive
+/*static void addExpectedSymbianPluginsPath(QStringList& expected)
+{
+ QString installPathPlugins = QDir::fromNativeSeparators(QLibraryInfo::location(QLibraryInfo::PluginsPath));
+ QFileInfoList driveList = QDir::drives();
+ QListIterator<QFileInfo> iter(driveList);
+ while (iter.hasNext()) {
+ QFileInfo testFi(iter.next().canonicalPath().append(installPathPlugins));
+ if (testFi.exists())
+ expected << testFi.canonicalFilePath();
+ }
+}
+*/
+#endif
+
+class tst_QApplication : public QObject
+{
+Q_OBJECT
+
+public:
+ tst_QApplication();
+ virtual ~tst_QApplication();
+
+public slots:
+ void init();
+ void cleanup();
+private slots:
+ void setActiveWindow();
+};
+
+static char *argv0;
+
+tst_QApplication::tst_QApplication()
+{
+#ifdef Q_OS_WINCE
+ // Clean up environment previously to launching test
+ qputenv("QT_PLUGIN_PATH", QByteArray());
+#endif
+}
+
+tst_QApplication::~tst_QApplication()
+{
+
+}
+
+void tst_QApplication::init()
+{
+// TODO: Add initialization code here.
+// This will be executed immediately before each test is run.
+}
+
+void tst_QApplication::cleanup()
+{
+// TODO: Add cleanup code here.
+// This will be executed immediately after each test is run.
+}
+
+void tst_QApplication::setActiveWindow()
+{
+ int argc = 0;
+ QApplication MyApp(argc, 0, QApplication::GuiServer);
+
+ QWidget* w = new QWidget;
+ QVBoxLayout* layout = new QVBoxLayout(w);
+
+ QLineEdit* pb1 = new QLineEdit("Testbutton1", w);
+ QLineEdit* pb2 = new QLineEdit("Test Line Edit", w);
+
+ layout->addWidget(pb1);
+ layout->addWidget(pb2);
+
+ pb2->setFocus();
+ pb2->setParent(0);
+ delete pb2;
+
+ w->show();
+ QApplication::setActiveWindow(w); // needs this on twm (focus follows mouse)
+ QVERIFY(pb1->hasFocus());
+ delete w;
+}
+
+//QTEST_APPLESS_MAIN(tst_QApplication)
+int main(int argc, char *argv[])
+{
+ tst_QApplication tc;
+ argv0 = argv[0];
+ return QTest::qExec(&tc, argc, argv);
+}
+
+#include "smoke_qapplication.moc"
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/qt/qapplication/smoke_qapplication.pro Mon Jun 14 12:26:38 2010 +0100
@@ -0,0 +1,4 @@
+TEMPLATE = subdirs
+SUBDIRS = test \
+
+
--- a/qt/qapplication/smoketest_qapplication.cpp Fri Jun 11 11:44:06 2010 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,2202 +0,0 @@
-/****************************************************************************
-**
-** 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$
-**
-****************************************************************************/
-
-
-//#define QT_TST_QAPP_DEBUG
-#include <qdebug.h>
-
-#include <QtTest/QtTest>
-
-#include "qabstracteventdispatcher.h"
-#include <QtGui>
-
-#include "private/qapplication_p.h"
-#include "private/qstylesheetstyle_p.h"
-#ifdef Q_OS_WINCE
-#include <windows.h>
-#endif
-#ifdef Q_OS_SYMBIAN
-#include <aknenv.h>
-#endif
-
-//TESTED_CLASS=
-//TESTED_FILES=
-
-#if defined(Q_OS_SYMBIAN)
-// In Symbian, the PluginsPath doesn't specify the only absolute path; just the dir that can be found on any drive
-/*static void addExpectedSymbianPluginsPath(QStringList& expected)
-{
- QString installPathPlugins = QDir::fromNativeSeparators(QLibraryInfo::location(QLibraryInfo::PluginsPath));
- QFileInfoList driveList = QDir::drives();
- QListIterator<QFileInfo> iter(driveList);
- while (iter.hasNext()) {
- QFileInfo testFi(iter.next().canonicalPath().append(installPathPlugins));
- if (testFi.exists())
- expected << testFi.canonicalFilePath();
- }
-}
-*/
-#endif
-
-class tst_QApplication : public QObject
-{
-Q_OBJECT
-
-public:
- tst_QApplication();
- virtual ~tst_QApplication();
-
-public slots:
- void init();
- void cleanup();
-private slots:
- /*void sendEventsOnProcessEvents(); // this must be the first test
- void getSetCheck();
- void staticSetup();
-
- void alert();
-
- void multiple_data();
- void multiple();
-
- void nonGui();
-
- void setFont_data();
- void setFont();
-
- void args_data();
- void args();
-
- void lastWindowClosed();
- void quitOnLastWindowClosed();
- void testDeleteLater();
- void testDeleteLaterProcessEvents();
-
- void libraryPaths();
- void libraryPaths_qt_plugin_path();
- void libraryPaths_qt_plugin_path_2();
-
- void sendPostedEvents();
-
- void thread();
- void desktopSettingsAware();*/
-
- void setActiveWindow();
-
- /*void focusChanged();
- void focusOut();
-
- void execAfterExit();
-
- void wheelScrollLines();
-
- void task109149();
-
- void style();
-
- void allWidgets();
- void topLevelWidgets();
-
- void setAttribute();
-
- void windowsCommandLine_data();
- void windowsCommandLine();
-
- void touchEventPropagation();
-
- void symbianNoApplicationPanes();
-
- void symbianNeedForTraps();
- void symbianLeaveThroughMain();*/
-};
-
-/*class EventSpy : public QObject
-{
- Q_OBJECT
-
-public:
- QList<int> recordedEvents;
- bool eventFilter(QObject *, QEvent *event)
- {
- recordedEvents.append(event->type());
- return false;
- }
-};
-*/
-
-/*
-void tst_QApplication::sendEventsOnProcessEvents()
-{
- int argc = 0;
- QApplication app(argc, 0, QApplication::GuiServer);
-
- EventSpy spy;
- app.installEventFilter(&spy);
-
- QCoreApplication::postEvent(&app, new QEvent(QEvent::Type(QEvent::User + 1)));
- QCoreApplication::processEvents();
- QVERIFY(spy.recordedEvents.contains(QEvent::User + 1));
-}
-
-class MyInputContext : public QInputContext
-{
-public:
- MyInputContext() : QInputContext() {}
- QString identifierName() { return QString("NoName"); }
- QString language() { return QString("NoLanguage"); }
- void reset() {}
- bool isComposing() const { return false; }
-};
-
-// Testing get/set functions
-void tst_QApplication::getSetCheck()
-{
- int argc = 0;
- QApplication obj1(argc, 0, QApplication::GuiServer);
- // QInputContext * QApplication::inputContext()
- // void QApplication::setInputContext(QInputContext *)
- MyInputContext *var1 = new MyInputContext;
- obj1.setInputContext(var1);
- QCOMPARE((QInputContext *)var1, obj1.inputContext());
- QTest::ignoreMessage(QtWarningMsg, "QApplication::setInputContext: called with 0 input context");
- obj1.setInputContext((QInputContext *)0);
- QCOMPARE((QInputContext *)var1, obj1.inputContext());
- // delete var1; // No delete, since QApplication takes ownership
-}
-
-class CloseEventTestWindow : public QWidget
-{
-public:
- CloseEventTestWindow(QWidget *parent = 0)
- : QWidget(parent)
- {
- }
-
- void closeEvent(QCloseEvent *event)
- {
- QWidget dialog;
- dialog.show();
- dialog.close();
-
- hide();
- event->ignore();
- }
-};
-*/
-
-static char *argv0;
-
-tst_QApplication::tst_QApplication()
-{
-#ifdef Q_OS_WINCE
- // Clean up environment previously to launching test
- qputenv("QT_PLUGIN_PATH", QByteArray());
-#endif
-}
-
-tst_QApplication::~tst_QApplication()
-{
-
-}
-
-void tst_QApplication::init()
-{
-// TODO: Add initialization code here.
-// This will be executed immediately before each test is run.
-}
-
-void tst_QApplication::cleanup()
-{
-// TODO: Add cleanup code here.
-// This will be executed immediately after each test is run.
-}
-
-/*
-void tst_QApplication::staticSetup()
-{
- QVERIFY(!qApp);
-
- QStyle *style = QStyleFactory::create(QLatin1String("Windows"));
- QVERIFY(style);
- QApplication::setStyle(style);
-
- QPalette pal;
- QApplication::setPalette(pal);
-
- //QFont font;
- //QApplication::setFont(font);
-
- int argc = 0;
- QApplication app(argc, 0, QApplication::GuiServer);
-}
-
-
-// QApp subclass that exits the event loop after 150ms
-class TestApplication : public QApplication
-{
-public:
- TestApplication( int &argc, char **argv )
- : QApplication( argc, argv, QApplication::GuiServer )
- {
- startTimer( 150 );
- }
-
- void timerEvent( QTimerEvent * )
- {
- quit();
- }
-};
-
-void tst_QApplication::alert()
-{
- int argc = 0;
- QApplication app(argc, 0, QApplication::GuiServer);
- app.alert(0, 0);
-
- QWidget widget;
- QWidget widget2;
- app.alert(&widget, 100);
- widget.show();
- widget2.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&widget);
- qt_x11_wait_for_window_manager(&widget2);
-#endif
- QTest::qWait(100);
- app.alert(&widget, -1);
- app.alert(&widget, 250);
- widget2.activateWindow();
- QApplication::setActiveWindow(&widget2);
- app.alert(&widget, 0);
- widget.activateWindow();
- QApplication::setActiveWindow(&widget);
- app.alert(&widget, 200);
- app.syncX();
-}
-
-void tst_QApplication::multiple_data()
-{
- QTest::addColumn<QStringList>("features");
-
- // return a list of things to try
- QTest::newRow( "data0" ) << QStringList( "" );
- QTest::newRow( "data1" ) << QStringList( "QFont" );
- QTest::newRow( "data2" ) << QStringList( "QPixmap" );
- QTest::newRow( "data3" ) << QStringList( "QWidget" );
-}
-
-void tst_QApplication::multiple()
-{
- QFETCH(QStringList,features);
-
- int i = 0;
- int argc = 0;
- while ( i++ < 5 ) {
- TestApplication app( argc, 0 );
-
- if ( features.contains( "QFont" ) ) {
- // create font and force loading
- QFont font( "Arial", 12 );
- QFontInfo finfo( font );
- finfo.exactMatch();
- }
- if ( features.contains( "QPixmap" ) ) {
- QPixmap pix( 100, 100 );
- pix.fill( Qt::black );
- }
- if ( features.contains( "QWidget" ) ) {
- QWidget widget;
- }
-
- QVERIFY(!app.exec());
- }
-}
-
-void tst_QApplication::nonGui()
-{
-#ifdef Q_OS_HPUX
- // ### This is only to allow us to generate a test report for now.
- QSKIP("This test shuts down the window manager on HP-UX.", SkipAll);
-#endif
-
- int argc = 0;
- QApplication app(argc, 0, false);
- QCOMPARE(qApp, &app);
-}
-
-void tst_QApplication::setFont_data()
-{
- QTest::addColumn<QString>("family");
- QTest::addColumn<int>("pointsize");
- QTest::addColumn<bool>("beforeAppConstructor");
-
- int argc = 0;
- QApplication app(argc, 0, QApplication::GuiServer); // Needed for QFontDatabase
-
- int cnt = 0;
- QFontDatabase fdb;
- QStringList families = fdb.families();
- for (QStringList::const_iterator itr = families.begin();
- itr != families.end();
- ++itr) {
- if (cnt < 3) {
- QString family = *itr;
- QStringList styles = fdb.styles(family);
- if (styles.size() > 0) {
- QString style = styles.first();
- QList<int> sizes = fdb.pointSizes(family, style);
- if (!sizes.size())
- sizes = fdb.standardSizes();
- if (sizes.size() > 0) {
- QTest::newRow(QString("data%1a").arg(cnt).toLatin1().constData())
- << family
- << sizes.first()
- << false;
- QTest::newRow(QString("data%1b").arg(cnt).toLatin1().constData())
- << family
- << sizes.first()
- << true;
- }
- }
- }
- ++cnt;
- }
-
- QTest::newRow("nonexistingfont") << "nosuchfont_probably_quiteunlikely"
- << 0 << false;
- QTest::newRow("nonexistingfont") << "nosuchfont_probably_quiteunlikely"
- << 0 << true;
-
- QTest::newRow("largescaleable") << "smoothtimes" << 100 << false;
- QTest::newRow("largescaleable") << "smoothtimes" << 100 << true;
-
- QTest::newRow("largeunscaleale") << "helvetica" << 100 << false;
- QTest::newRow("largeunscaleale") << "helvetica" << 100 << true;
-}
-
-void tst_QApplication::setFont()
-{
- QFETCH( QString, family );
- QFETCH( int, pointsize );
- QFETCH( bool, beforeAppConstructor );
-
- QFont font( family, pointsize );
- if (beforeAppConstructor) {
- QApplication::setFont( font );
- QCOMPARE(QApplication::font(), font);
- }
-
- int argc = 0;
- QApplication app( argc, 0, QApplication::GuiServer );
- if (!beforeAppConstructor)
- QApplication::setFont( font );
-
- QCOMPARE( app.font(), font );
-}
-
-void tst_QApplication::args_data()
-{
- QTest::addColumn<int>("argc_in");
- QTest::addColumn<QString>("args_in");
- QTest::addColumn<int>("argc_out");
- QTest::addColumn<QString>("args_out");
-
- QTest::newRow( "App name" ) << 1 << "/usr/bin/appname" << 1 << "/usr/bin/appname";
- QTest::newRow( "No arguments" ) << 0 << QString() << 0 << QString();
- QTest::newRow( "App name, style" ) << 3 << "/usr/bin/appname -style motif" << 1 << "/usr/bin/appname";
- QTest::newRow( "App name, style, arbitrary, reverse" ) << 5 << "/usr/bin/appname -style motif -arbitrary -reverse"
- << 2 << "/usr/bin/appname -arbitrary";
-}
-
-void tst_QApplication::task109149()
-{
- int argc = 0;
- QApplication app(argc, 0, QApplication::GuiServer);
- QApplication::setFont(QFont("helvetica", 100));
-
- QWidget w;
- w.setWindowTitle("hello");
- w.show();
-
- app.processEvents();
-}
-
-static char ** QString2cstrings( const QString &args )
-{
- static QList<QByteArray> cache;
-
- int i;
- char **argarray = 0;
- QStringList list = args.split(' ');;
- argarray = new char*[list.count()+1];
-
- for (i = 0; i < (int)list.count(); ++i ) {
- QByteArray l1 = list[i].toLatin1();
- argarray[i] = l1.data();
- cache.append(l1);
- }
- argarray[i] = 0;
-
- return argarray;
-}
-
-static QString cstrings2QString( char **args )
-{
- QString string;
- if ( !args )
- return string;
-
- int i = 0;
- while ( args[i] ) {
- string += args[i];
- if ( args[i+1] )
- string += " ";
- ++i;
- }
- return string;
-}
-
-void tst_QApplication::args()
-{
- QFETCH( int, argc_in );
- QFETCH( QString, args_in );
- QFETCH( int, argc_out );
- QFETCH( QString, args_out );
-
- char **argv = QString2cstrings( args_in );
-
- QApplication app( argc_in, argv, QApplication::GuiServer );
- QString argv_out = cstrings2QString(argv);
-
- QCOMPARE( argc_in, argc_out );
- QCOMPARE( argv_out, args_out );
-
- delete [] argv;
-}
-
-class CloseWidget : public QWidget
-{
- Q_OBJECT
-public:
- CloseWidget()
- {
- startTimer(500);
- }
-
-protected:
- void timerEvent(QTimerEvent *)
- {
- close();
- }
-
-};
-
-void tst_QApplication::lastWindowClosed()
-{
- int argc = 0;
- QApplication app(argc, 0, QApplication::GuiServer);
-
- QSignalSpy spy(&app, SIGNAL(lastWindowClosed()));
-
- QPointer<QDialog> dialog = new QDialog;
- QVERIFY(dialog->testAttribute(Qt::WA_QuitOnClose));
- QTimer::singleShot(1000, dialog, SLOT(accept()));
- dialog->exec();
- QVERIFY(dialog);
- QCOMPARE(spy.count(), 0);
-
- QPointer<CloseWidget>widget = new CloseWidget;
- QVERIFY(widget->testAttribute(Qt::WA_QuitOnClose));
- QObject::connect(&app, SIGNAL(lastWindowClosed()), widget, SLOT(deleteLater()));
- app.exec();
- QVERIFY(!widget);
- QCOMPARE(spy.count(), 1);
- spy.clear();
-
-#if 0
- // everything is closed, so doing this should not emit lastWindowClosed() again
- QMetaObject::invokeMethod(dialog, "close", Qt::QueuedConnection);
- QTimer::singleShot(1000, &app, SLOT(quit()));
- app.exec();
- QCOMPARE(spy.count(), 0);
-#endif
-
- delete dialog;
-
- // show 3 windows, close them, should only get lastWindowClosed once
- QWidget w1;
- QWidget w2;
- QWidget w3;
- w1.show();
- w2.show();
- w3.show();
-
- QTimer::singleShot(1000, &app, SLOT(closeAllWindows()));
- app.exec();
- QCOMPARE(spy.count(), 1);
-}
-
-class QuitOnLastWindowClosedDialog : public QDialog
-{
- Q_OBJECT
-public:
- QPushButton *okButton;
-
- QuitOnLastWindowClosedDialog()
- {
- QHBoxLayout *hbox = new QHBoxLayout(this);
- okButton = new QPushButton("&ok", this);
-
- hbox->addWidget(okButton);
- connect(okButton, SIGNAL(clicked()), this, SLOT(accept()));
- connect(okButton, SIGNAL(clicked()), this, SLOT(ok_clicked()));
- }
-
-public slots:
- void ok_clicked()
- {
- QDialog other;
-
- QTimer timer;
- connect(&timer, SIGNAL(timeout()), &other, SLOT(accept()));
- QSignalSpy spy(&timer, SIGNAL(timeout()));
- QSignalSpy appSpy(qApp, SIGNAL(lastWindowClosed()));
-
- timer.start(1000);
- other.exec();
-
- // verify that the eventloop ran and let the timer fire
- QCOMPARE(spy.count(), 1);
- QCOMPARE(appSpy.count(), 1);
- }
-};
-
-class QuitOnLastWindowClosedWindow : public QWidget
-{
- Q_OBJECT
-
-public:
- QuitOnLastWindowClosedWindow()
- { }
-
-public slots:
- void execDialogThenShow()
- {
- QDialog dialog;
- QTimer timer1;
- connect(&timer1, SIGNAL(timeout()), &dialog, SLOT(accept()));
- QSignalSpy spy1(&timer1, SIGNAL(timeout()));
- timer1.setSingleShot(true);
- timer1.start(1000);
- dialog.exec();
- QCOMPARE(spy1.count(), 1);
-
- show();
- }
-};
-
-void tst_QApplication::quitOnLastWindowClosed()
-{
- {
- int argc = 0;
- QApplication app(argc, 0, QApplication::GuiServer);
-
- QuitOnLastWindowClosedDialog d;
- d.show();
- QTimer::singleShot(1000, d.okButton, SLOT(animateClick()));
-
- QSignalSpy appSpy(&app, SIGNAL(lastWindowClosed()));
- app.exec();
-
- // lastWindowClosed() signal should only be sent after the last dialog is closed
- QCOMPARE(appSpy.count(), 2);
- }
- {
- int argc = 0;
- QApplication app(argc, 0, QApplication::GuiServer);
- QSignalSpy appSpy(&app, SIGNAL(lastWindowClosed()));
-
- QDialog dialog;
- QTimer timer1;
- connect(&timer1, SIGNAL(timeout()), &dialog, SLOT(accept()));
- QSignalSpy spy1(&timer1, SIGNAL(timeout()));
- timer1.setSingleShot(true);
- timer1.start(1000);
- dialog.exec();
- QCOMPARE(spy1.count(), 1);
- QCOMPARE(appSpy.count(), 0);
-
- QTimer timer2;
- connect(&timer2, SIGNAL(timeout()), &app, SLOT(quit()));
- QSignalSpy spy2(&timer2, SIGNAL(timeout()));
- timer2.setSingleShot(true);
- timer2.start(1000);
- int returnValue = app.exec();
- QCOMPARE(returnValue, 0);
- QCOMPARE(spy2.count(), 1);
- QCOMPARE(appSpy.count(), 0);
- }
- {
- int argc = 0;
- QApplication app(argc, 0, QApplication::GuiServer);
- QTimer timer;
- timer.setInterval(100);
-
- QSignalSpy spy(&app, SIGNAL(aboutToQuit()));
- QSignalSpy spy2(&timer, SIGNAL(timeout()));
-
- QPointer<QMainWindow> mainWindow = new QMainWindow;
- QPointer<QDialog> dialog = new QDialog(mainWindow);
-
- QVERIFY(app.quitOnLastWindowClosed());
- QVERIFY(mainWindow->testAttribute(Qt::WA_QuitOnClose));
- QVERIFY(dialog->testAttribute(Qt::WA_QuitOnClose));
-
- mainWindow->show();
- dialog->show();
-
- timer.start();
- QTimer::singleShot(1000, mainWindow, SLOT(close())); // This should quit the application
- QTimer::singleShot(2000, &app, SLOT(quit())); // This makes sure we quit even if it didn't
-
- app.exec();
-
- QCOMPARE(spy.count(), 1);
- QVERIFY(spy2.count() < 15); // Should be around 10 if closing caused the quit
- }
- {
- int argc = 0;
- QApplication app(argc, 0, QApplication::GuiServer);
- QTimer timer;
- timer.setInterval(100);
-
- QSignalSpy spy(&app, SIGNAL(aboutToQuit()));
- QSignalSpy spy2(&timer, SIGNAL(timeout()));
-
- QPointer<QMainWindow> mainWindow = new QMainWindow;
- QPointer<QWidget> invisibleTopLevelWidget = new QWidget;
- invisibleTopLevelWidget->setAttribute(Qt::WA_DontShowOnScreen);
-
- QVERIFY(app.quitOnLastWindowClosed());
- QVERIFY(mainWindow->testAttribute(Qt::WA_QuitOnClose));
- QVERIFY(invisibleTopLevelWidget->testAttribute(Qt::WA_QuitOnClose));
- QVERIFY(invisibleTopLevelWidget->testAttribute(Qt::WA_DontShowOnScreen));
-
- mainWindow->show();
- invisibleTopLevelWidget->show();
-
- timer.start();
- QTimer::singleShot(1000, mainWindow, SLOT(close())); // This should quit the application
- QTimer::singleShot(2000, &app, SLOT(quit())); // This makes sure we quit even if it didn't
-
- app.exec();
-
- QCOMPARE(spy.count(), 1);
- QVERIFY(spy2.count() < 15); // Should be around 10 if closing caused the quit
- }
- {
- int argc = 0;
- QApplication app(argc, 0, QApplication::GuiServer);
- QTimer timer;
- timer.setInterval(100);
-
- QSignalSpy spy(&app, SIGNAL(aboutToQuit()));
- QSignalSpy spy2(&timer, SIGNAL(timeout()));
-
- QPointer<CloseEventTestWindow> mainWindow = new CloseEventTestWindow;
-
- QVERIFY(app.quitOnLastWindowClosed());
- QVERIFY(mainWindow->testAttribute(Qt::WA_QuitOnClose));
-
- mainWindow->show();
-
- timer.start();
- QTimer::singleShot(1000, mainWindow, SLOT(close())); // This should quit the application
- QTimer::singleShot(2000, &app, SLOT(quit())); // This makes sure we quit even if it didn't
-
- app.exec();
-
- QCOMPARE(spy.count(), 1);
- QVERIFY(spy2.count() > 15); // Should be around 20 if closing did not caused the quit
- }
- {
- int argc = 0;
- QApplication app(argc, 0, QApplication::GuiServer);
- QSignalSpy appSpy(&app, SIGNAL(lastWindowClosed()));
-
- // exec a dialog for 1 second, then show the window
- QuitOnLastWindowClosedWindow window;
- QTimer::singleShot(0, &window, SLOT(execDialogThenShow()));
-
- QTimer timer;
- QSignalSpy timerSpy(&timer, SIGNAL(timeout()));
- connect(&timer, SIGNAL(timeout()), &window, SLOT(close()));
- timer.setSingleShot(true);
- timer.start(2000);
- int returnValue = app.exec();
- QCOMPARE(returnValue, 0);
- // failure here means the timer above didn't fire, and the
- // quit was caused the the dialog being closed (not the window)
- QCOMPARE(timerSpy.count(), 1);
- QCOMPARE(appSpy.count(), 2);
- }
-}
-
-bool isPathListIncluded(const QStringList &l, const QStringList &r)
-{
- int size = r.count();
- if (size > l.count())
- return false;
-#if defined (Q_OS_WIN)
- Qt::CaseSensitivity cs = Qt::CaseInsensitive;
-#else
- Qt::CaseSensitivity cs = Qt::CaseSensitive;
-#endif
- int i = 0, j = 0;
- for ( ; i < l.count() && j < r.count(); ++i) {
- if (QDir::toNativeSeparators(l[i]).compare(QDir::toNativeSeparators(r[j]), cs) == 0) {
- ++j;
- i = -1;
- }
- }
- return j == r.count();
-}
-
-#define QT_TST_QAPP_DEBUG
-void tst_QApplication::libraryPaths()
-{
- {
-#ifndef Q_OS_WINCE
- QString testDir = QDir::current().canonicalPath() + "/test";
-#else
- // On Windows CE we need QApplication object to have valid
- // current Path. Therefore we need to identify it ourselves
- // here for the test.
- QFileInfo filePath;
- wchar_t module_name[MAX_PATH];
- GetModuleFileName(0, module_name, MAX_PATH);
- filePath = QString::fromWCharArray(module_name);
- QString testDir = filePath.path() + "/test";
-#endif
- QApplication::setLibraryPaths(QStringList() << testDir);
- QCOMPARE(QApplication::libraryPaths(), (QStringList() << testDir));
-
- // creating QApplication adds the applicationDirPath to the libraryPath
- int argc = 1;
- QApplication app(argc, &argv0, QApplication::GuiServer);
- QString appDirPath = QDir(app.applicationDirPath()).canonicalPath();
-
- QStringList actual = QApplication::libraryPaths();
- actual.sort();
- QStringList expected = QSet<QString>::fromList((QStringList() << testDir << appDirPath)).toList();
- expected.sort();
-
- QVERIFY2(isPathListIncluded(actual, expected),
- qPrintable("actual:\n - " + actual.join("\n - ") +
- "\nexpected:\n - " + expected.join("\n - ")));
- }
- {
- // creating QApplication adds the applicationDirPath and plugin install path to the libraryPath
- int argc = 1;
- QApplication app(argc, &argv0, QApplication::GuiServer);
- QString appDirPath = app.applicationDirPath();
- QString installPathPlugins = QLibraryInfo::location(QLibraryInfo::PluginsPath);
-
- QStringList actual = QApplication::libraryPaths();
- actual.sort();
-
-#if defined(Q_OS_SYMBIAN)
- QStringList expected;
- addExpectedSymbianPluginsPath(expected);
- expected << appDirPath;
-#else
- QStringList expected = QSet<QString>::fromList((QStringList() << installPathPlugins << appDirPath)).toList();
-#endif
- expected.sort();
-
- QVERIFY2(isPathListIncluded(actual, expected),
- qPrintable("actual:\n - " + actual.join("\n - ") +
- "\nexpected:\n - " + expected.join("\n - ")));
-
- // setting the library paths overrides everything
- QString testDir = QDir::currentPath() + "/test";
- QApplication::setLibraryPaths(QStringList() << testDir);
- QVERIFY2(isPathListIncluded(QApplication::libraryPaths(), (QStringList() << testDir)),
- qPrintable("actual:\n - " + QApplication::libraryPaths().join("\n - ") +
- "\nexpected:\n - " + testDir));
- }
- {
-#ifdef QT_TST_QAPP_DEBUG
- qDebug() << "Initial library path:" << QApplication::libraryPaths();
-#endif
-
- int count = QApplication::libraryPaths().count();
-#if 0
- // this test doesn't work if KDE 4 is installed
- QCOMPARE(count, 1); // before creating QApplication, only the PluginsPath is in the libraryPaths()
-#endif
- QString installPathPlugins = QLibraryInfo::location(QLibraryInfo::PluginsPath);
- QApplication::addLibraryPath(installPathPlugins);
-#ifdef QT_TST_QAPP_DEBUG
- qDebug() << "installPathPlugins" << installPathPlugins;
- qDebug() << "After adding plugins path:" << QApplication::libraryPaths();
-#endif
- QCOMPARE(QApplication::libraryPaths().count(), count);
-
- QApplication::addLibraryPath(QDir::currentPath() + "/test");
- QCOMPARE(QApplication::libraryPaths().count(), count + 1);
-
- // creating QApplication adds the applicationDirPath to the libraryPath
- int argc = 1;
- QApplication app(argc, &argv0, QApplication::GuiServer);
- QString appDirPath = app.applicationDirPath();
- qDebug() << QApplication::libraryPaths();
- // On Windows CE these are identical and might also be the case for other
- // systems too
- if (appDirPath != installPathPlugins)
- QCOMPARE(QApplication::libraryPaths().count(), count + 2);
- }
- {
- int argc = 1;
- QApplication app(argc, &argv0, QApplication::GuiServer);
-
-#ifdef QT_TST_QAPP_DEBUG
- qDebug() << "Initial library path:" << app.libraryPaths();
-#endif
- int count = app.libraryPaths().count();
- QString installPathPlugins = QLibraryInfo::location(QLibraryInfo::PluginsPath);
- app.addLibraryPath(installPathPlugins);
-#ifdef QT_TST_QAPP_DEBUG
- qDebug() << "installPathPlugins" << installPathPlugins;
- qDebug() << "After adding plugins path:" << app.libraryPaths();
-#endif
- QCOMPARE(app.libraryPaths().count(), count);
-
- QString appDirPath = app.applicationDirPath();
-
- app.addLibraryPath(appDirPath);
-#ifdef Q_OS_WINCE
- app.addLibraryPath(appDirPath + "/../..");
-#else
- app.addLibraryPath(appDirPath + "/..");
-#endif
-#ifdef QT_TST_QAPP_DEBUG
- qDebug() << "appDirPath" << appDirPath;
- qDebug() << "After adding appDirPath && appDirPath + /..:" << app.libraryPaths();
-#endif
- QCOMPARE(app.libraryPaths().count(), count + 1);
-#ifdef Q_OS_MAC
- app.addLibraryPath(appDirPath + "/../MacOS");
-#else
- app.addLibraryPath(appDirPath + "/tmp/..");
-#endif
-#ifdef QT_TST_QAPP_DEBUG
- qDebug() << "After adding appDirPath + /tmp/..:" << app.libraryPaths();
-#endif
- QCOMPARE(app.libraryPaths().count(), count + 1);
- }
-}
-
-void tst_QApplication::libraryPaths_qt_plugin_path()
-{
- int argc = 1;
-
- QApplication app(argc, &argv0, QApplication::GuiServer);
- QString appDirPath = app.applicationDirPath();
-
- // Our hook into libraryPaths() initialization: Set the QT_PLUGIN_PATH environment variable
- QString installPathPluginsDeCanon = appDirPath + QString::fromLatin1("/tmp/..");
- QByteArray ascii = installPathPluginsDeCanon.toAscii();
- qputenv("QT_PLUGIN_PATH", ascii);
-
- QVERIFY(!app.libraryPaths().contains(appDirPath + QString::fromLatin1("/tmp/..")));
-}
-
-void tst_QApplication::libraryPaths_qt_plugin_path_2()
-{
-#ifdef Q_OS_SYMBIAN
- QByteArray validPath = "C:\\data";
- QByteArray nonExistentPath = "Z:\\nonexistent";
- QByteArray pluginPath = validPath + ";" + nonExistentPath;
-#elif defined(Q_OS_UNIX)
- QByteArray validPath = QDir("/tmp").canonicalPath().toLatin1();
- QByteArray nonExistentPath = "/nonexistent";
- QByteArray pluginPath = validPath + ":" + nonExistentPath;
-#elif defined(Q_OS_WIN)
-# ifdef Q_OS_WINCE
- QByteArray validPath = "/Temp";
- QByteArray nonExistentPath = "/nonexistent";
- QByteArray pluginPath = validPath + ";" + nonExistentPath;
-# else
- QByteArray validPath = "C:\\windows";
- QByteArray nonExistentPath = "Z:\\nonexistent";
- QByteArray pluginPath = validPath + ";" + nonExistentPath;
-# endif
-#endif
-
- {
- // Our hook into libraryPaths() initialization: Set the QT_PLUGIN_PATH environment variable
- qputenv("QT_PLUGIN_PATH", pluginPath);
-
- int argc = 1;
-
- QApplication app(argc, &argv0, QApplication::GuiServer);
-
- // library path list should contain the default plus the one valid path
-#if defined(Q_OS_SYMBIAN)
- // In Symbian, the PluginsPath doesn't specify the only absolute path; just the dir that can be found on any drive
- QStringList expected;
- addExpectedSymbianPluginsPath(expected);
- expected << QDir(app.applicationDirPath()).canonicalPath()
- << QDir(QDir::fromNativeSeparators(QString::fromLatin1(validPath))).canonicalPath();
-#else
- QStringList expected =
- QStringList()
- << QLibraryInfo::location(QLibraryInfo::PluginsPath)
- << QDir(app.applicationDirPath()).canonicalPath()
- << QDir(QDir::fromNativeSeparators(QString::fromLatin1(validPath))).canonicalPath();
-# ifdef Q_OS_WINCE
- expected = QSet<QString>::fromList(expected).toList();
-# endif
-#endif
- QVERIFY2(isPathListIncluded(app.libraryPaths(), expected),
- qPrintable("actual:\n - " + app.libraryPaths().join("\n - ") +
- "\nexpected:\n - " + expected.join("\n - ")));
- }
-
- {
- int argc = 1;
-
- QApplication app(argc, &argv0, QApplication::GuiServer);
-
- // library paths are initialized by the QApplication, setting
- // the environment variable here doesn't work
- qputenv("QT_PLUGIN_PATH", pluginPath);
-
- // library path list should contain the default
-#if defined(Q_OS_SYMBIAN)
- QStringList expected;
- addExpectedSymbianPluginsPath(expected);
- expected << app.applicationDirPath();
-#else
- QStringList expected =
- QStringList()
- << QLibraryInfo::location(QLibraryInfo::PluginsPath)
- << app.applicationDirPath();
-# ifdef Q_OS_WINCE
- expected = QSet<QString>::fromList(expected).toList();
-# endif
-#endif
- QVERIFY(isPathListIncluded(app.libraryPaths(), expected));
-
- qputenv("QT_PLUGIN_PATH", QByteArray());
- }
-}
-
-class SendPostedEventsTester : public QObject
-{
- Q_OBJECT
-public:
- QList<int> eventSpy;
- bool event(QEvent *e);
-private slots:
- void doTest();
-};
-
-bool SendPostedEventsTester::event(QEvent *e)
-{
- eventSpy.append(e->type());
- return QObject::event(e);
-}
-
-void SendPostedEventsTester::doTest()
-{
- QPointer<SendPostedEventsTester> p = this;
- QApplication::postEvent(this, new QEvent(QEvent::User));
- // DeferredDelete should not be delivered until returning from this function
- QApplication::postEvent(this, new QEvent(QEvent::DeferredDelete));
-
- QEventLoop eventLoop;
- QMetaObject::invokeMethod(&eventLoop, "quit", Qt::QueuedConnection);
- eventLoop.exec();
- QVERIFY(p != 0);
-
- QCOMPARE(eventSpy.count(), 2);
- QCOMPARE(eventSpy.at(0), int(QEvent::MetaCall));
- QCOMPARE(eventSpy.at(1), int(QEvent::User));
- eventSpy.clear();
-}
-
-void tst_QApplication::sendPostedEvents()
-{
- int argc = 0;
- QApplication app(argc, 0, QApplication::GuiServer);
- SendPostedEventsTester *tester = new SendPostedEventsTester;
- QMetaObject::invokeMethod(tester, "doTest", Qt::QueuedConnection);
- QMetaObject::invokeMethod(&app, "quit", Qt::QueuedConnection);
- QPointer<SendPostedEventsTester> p = tester;
- (void) app.exec();
- QVERIFY(p == 0);
-}
-
-void tst_QApplication::thread()
-{
- QThread *currentThread = QThread::currentThread();
- // no app, but still have a valid thread
- QVERIFY(currentThread != 0);
-
- // the thread should be running and not finished
- QVERIFY(currentThread->isRunning());
- QVERIFY(!currentThread->isFinished());
-
- // this should probably be in the tst_QObject::thread() test, but
- // we put it here since we want to make sure that objects created
- // *before* the QApplication has a thread
- QObject object;
- QObject child(&object);
- QVERIFY(object.thread() == currentThread);
- QVERIFY(child.thread() == currentThread);
-
- {
- int argc = 0;
- QApplication app(argc, 0, QApplication::GuiServer);
-
- // current thread still valid
- QVERIFY(QThread::currentThread() != 0);
- // thread should be the same as before
- QCOMPARE(QThread::currentThread(), currentThread);
-
- // app's thread should be the current thread
- QCOMPARE(app.thread(), currentThread);
-
- // the thread should still be running and not finished
- QVERIFY(currentThread->isRunning());
- QVERIFY(!currentThread->isFinished());
-
- QTestEventLoop::instance().enterLoop(1);
- }
-
- // app dead, current thread still valid
- QVERIFY(QThread::currentThread() != 0);
- QCOMPARE(QThread::currentThread(), currentThread);
-
- // the thread should still be running and not finished
- QVERIFY(currentThread->isRunning());
- QVERIFY(!currentThread->isFinished());
-
- // should still have a thread
- QVERIFY(object.thread() == currentThread);
- QVERIFY(child.thread() == currentThread);
-
- // do the test again, making sure that the thread is the same as
- // before
- {
- int argc = 0;
- QApplication app(argc, 0, QApplication::GuiServer);
-
- // current thread still valid
- QVERIFY(QThread::currentThread() != 0);
- // thread should be the same as before
- QCOMPARE(QThread::currentThread(), currentThread);
-
- // app's thread should be the current thread
- QCOMPARE(app.thread(), currentThread);
-
- // the thread should be running and not finished
- QVERIFY(currentThread->isRunning());
- QVERIFY(!currentThread->isFinished());
-
- // should still have a thread
- QVERIFY(object.thread() == currentThread);
- QVERIFY(child.thread() == currentThread);
-
- QTestEventLoop::instance().enterLoop(1);
- }
-
- // app dead, current thread still valid
- QVERIFY(QThread::currentThread() != 0);
- QCOMPARE(QThread::currentThread(), currentThread);
-
- // the thread should still be running and not finished
- QVERIFY(currentThread->isRunning());
- QVERIFY(!currentThread->isFinished());
-
- // should still have a thread
- QVERIFY(object.thread() == currentThread);
- QVERIFY(child.thread() == currentThread);
-}
-
-class DeleteLaterWidget : public QWidget
-{
- Q_OBJECT
-public:
- DeleteLaterWidget(QApplication *_app, QWidget *parent = 0)
- : QWidget(parent) { app = _app; child_deleted = false; }
-
- bool child_deleted;
- QApplication *app;
-
-public slots:
- void runTest();
- void checkDeleteLater();
- void childDeleted() { child_deleted = true; }
-};
-
-
-void DeleteLaterWidget::runTest()
-{
- QObject *stillAlive = qFindChild<QObject*>(this, "deleteLater");
-
- QWidget *w = new QWidget(this);
- connect(w, SIGNAL(destroyed()), this, SLOT(childDeleted()));
-
- w->deleteLater();
- QVERIFY(!child_deleted);
-
- QDialog dlg;
- QTimer::singleShot(500, &dlg, SLOT(reject()));
- dlg.exec();
-
- QVERIFY(!child_deleted);
- app->processEvents();
- QVERIFY(!child_deleted);
-
- QTimer::singleShot(500, this, SLOT(checkDeleteLater()));
-
- app->processEvents();
-
- QVERIFY(!stillAlive); // verify at the end to make test terminate
-}
-
-void DeleteLaterWidget::checkDeleteLater()
-{
- QVERIFY(child_deleted);
-
- close();
-}
-
-void tst_QApplication::testDeleteLater()
-{
- int argc = 0;
- QApplication app(argc, 0, QApplication::GuiServer);
- connect(&app, SIGNAL(lastWindowClosed()), &app, SLOT(quit()));
-
- DeleteLaterWidget *wgt = new DeleteLaterWidget(&app);
- QTimer::singleShot(500, wgt, SLOT(runTest()));
-
- QObject *object = new QObject(wgt);
- object->setObjectName("deleteLater");
- object->deleteLater();
-
- QObject *stillAlive = qFindChild<QObject*>(wgt, "deleteLater");
- QVERIFY(stillAlive);
-
- app.exec();
-
- delete wgt;
-
-}
-
-class EventLoopNester : public QObject
-{
- Q_OBJECT
-public slots:
- void deleteLaterAndEnterLoop()
- {
- QEventLoop eventLoop;
- QPointer<QObject> p(this);
- deleteLater();
-
- // DeferredDelete events are compressed, meaning this second
- // deleteLater() will *not* delete the object in the nested
- // event loop
- QMetaObject::invokeMethod(this, "deleteLater", Qt::QueuedConnection);
- QTimer::singleShot(1000, &eventLoop, SLOT(quit()));
- eventLoop.exec();
- QVERIFY(p);
- }
- void deleteLaterAndExitLoop()
- {
- // Check that 'p' is not deleted before exec returns, since the call
- // to QEventLoop::quit() should stop 'eventLoop' from processing
- // any more events (that is, delete later) until we return to the
- // _current_ event loop:
- QEventLoop eventLoop;
- QPointer<QObject> p(this);
- QMetaObject::invokeMethod(this, "deleteLater", Qt::QueuedConnection);
- QMetaObject::invokeMethod(&eventLoop, "quit", Qt::QueuedConnection);
- eventLoop.exec();
- QVERIFY(p); // not dead yet
- }
-
- void processEventsOnly()
- {
- QApplication::processEvents();
- }
- void processEventsWithDeferredDeletion()
- {
- QApplication::processEvents(QEventLoop::DeferredDeletion);
- }
- void sendPostedEventsWithDeferredDelete()
- {
- QApplication::sendPostedEvents(0, QEvent::DeferredDelete);
- }
- void deleteLaterAndProcessEvents1()
- {
- QEventLoop eventLoop;
-
- QPointer<QObject> p = this;
- deleteLater();
-
- // trying to delete this object in a deeper eventloop just won't work
- QMetaObject::invokeMethod(this,
- "processEventsOnly",
- Qt::QueuedConnection);
- QMetaObject::invokeMethod(&eventLoop, "quit", Qt::QueuedConnection);
- eventLoop.exec();
- QVERIFY(p);
- QMetaObject::invokeMethod(this,
- "processEventsWithDeferredDeletion",
- Qt::QueuedConnection);
- QMetaObject::invokeMethod(&eventLoop, "quit", Qt::QueuedConnection);
- eventLoop.exec();
- QVERIFY(p);
- QMetaObject::invokeMethod(this,
- "sendPostedEventsWithDeferredDelete",
- Qt::QueuedConnection);
- QMetaObject::invokeMethod(&eventLoop, "quit", Qt::QueuedConnection);
- eventLoop.exec();
- QVERIFY(p);
-
- // trying to delete it from this eventloop still doesn't work
- QApplication::processEvents();
- QVERIFY(p);
-
- // however, it *will* work with this magic incantation
- QApplication::processEvents(QEventLoop::DeferredDeletion);
- QVERIFY(!p);
- }
-
- void deleteLaterAndProcessEvents2()
- {
- QEventLoop eventLoop;
-
- QPointer<QObject> p = this;
- deleteLater();
-
- // trying to delete this object in a deeper eventloop just won't work
- QMetaObject::invokeMethod(this,
- "processEventsOnly",
- Qt::QueuedConnection);
- QMetaObject::invokeMethod(&eventLoop, "quit", Qt::QueuedConnection);
- eventLoop.exec();
- QVERIFY(p);
- QMetaObject::invokeMethod(this,
- "processEventsWithDeferredDeletion",
- Qt::QueuedConnection);
- QMetaObject::invokeMethod(&eventLoop, "quit", Qt::QueuedConnection);
- eventLoop.exec();
- QVERIFY(p);
- QMetaObject::invokeMethod(this,
- "sendPostedEventsWithDeferredDelete",
- Qt::QueuedConnection);
- QMetaObject::invokeMethod(&eventLoop, "quit", Qt::QueuedConnection);
- eventLoop.exec();
- QVERIFY(p);
-
- // trying to delete it from this eventloop still doesn't work
- QApplication::processEvents();
- QVERIFY(p);
-
- // however, it *will* work with this magic incantation
- QApplication::sendPostedEvents(0, QEvent::DeferredDelete);
- QVERIFY(!p);
- }
-};
-
-void tst_QApplication::testDeleteLaterProcessEvents()
-{
- int argc = 0;
-
- // Calling processEvents() with no event dispatcher does nothing.
- QObject *object = new QObject;
- QPointer<QObject> p(object);
- object->deleteLater();
- QApplication::processEvents();
- QVERIFY(p);
- delete object;
-
- {
- QApplication app(argc, 0, QApplication::GuiServer);
- // If you call processEvents() with an event dispatcher present, but
- // outside any event loops, deferred deletes are not processed unless
- // QEventLoop::DeferredDeletion is passed.
- object = new QObject;
- p = object;
- object->deleteLater();
- app.processEvents();
- QVERIFY(p);
- app.processEvents(QEventLoop::ProcessEventsFlag(0x10)); // 0x10 == QEventLoop::DeferredDeletion
- QVERIFY(!p);
-
- // sendPostedEvents(0, DeferredDelete); also works
- object = new QObject;
- p = object;
- object->deleteLater();
- app.processEvents();
- QVERIFY(p);
- QApplication::sendPostedEvents(0, QEvent::DeferredDelete);
- QVERIFY(!p);
-
- // If you call deleteLater() on an object when there is no parent
- // event loop, and then enter an event loop, the object will get
- // deleted.
- object = new QObject;
- p = object;
- object->deleteLater();
- QEventLoop loop;
- QTimer::singleShot(1000, &loop, SLOT(quit()));
- loop.exec();
- QVERIFY(!p);
- }
- {
- // When an object is in an event loop, then calls deleteLater() and enters
- // an event loop recursively, it should not die until the parent event
- // loop continues.
- QApplication app(argc, 0, QApplication::GuiServer);
- QEventLoop loop;
- EventLoopNester *nester = new EventLoopNester;
- p = nester;
- QTimer::singleShot(3000, &loop, SLOT(quit()));
- QTimer::singleShot(0, nester, SLOT(deleteLaterAndEnterLoop()));
-
- loop.exec();
- QVERIFY(!p);
- }
-
- {
- // When the event loop that calls deleteLater() is exited
- // immediately, the object should die when returning to the
- // parent event loop
- QApplication app(argc, 0, QApplication::GuiServer);
- QEventLoop loop;
- EventLoopNester *nester = new EventLoopNester;
- p = nester;
- QTimer::singleShot(3000, &loop, SLOT(quit()));
- QTimer::singleShot(0, nester, SLOT(deleteLaterAndExitLoop()));
-
- loop.exec();
- QVERIFY(!p);
- }
-
- {
- // when the event loop that calls deleteLater() also calls
- // processEvents() immediately afterwards, the object should
- // not die until the parent loop continues
- QApplication app(argc, 0, QApplication::GuiServer);
- QEventLoop loop;
- EventLoopNester *nester = new EventLoopNester();
- p = nester;
- QTimer::singleShot(3000, &loop, SLOT(quit()));
- QTimer::singleShot(0, nester, SLOT(deleteLaterAndProcessEvents1()));
-
- loop.exec();
- QVERIFY(!p);
- }
-
- {
- // when the event loop that calls deleteLater() also calls
- // processEvents() immediately afterwards, the object should
- // not die until the parent loop continues
- QApplication app(argc, 0, QApplication::GuiServer);
- QEventLoop loop;
- EventLoopNester *nester = new EventLoopNester();
- p = nester;
- QTimer::singleShot(3000, &loop, SLOT(quit()));
- QTimer::singleShot(0, nester, SLOT(deleteLaterAndProcessEvents2()));
-
- loop.exec();
- QVERIFY(!p);
- }
-}
-
-
-// Test for crash whith QApplication::setDesktopSettingsAware(false).
-
-void tst_QApplication::desktopSettingsAware()
-{
-#ifndef QT_NO_PROCESS
- QProcess testProcess;
-#ifdef Q_OS_WINCE
- int argc = 0;
- QApplication tmpApp(argc, 0, QApplication::GuiServer);
- testProcess.start("desktopsettingsaware/desktopsettingsaware");
-#else
-#if defined(Q_OS_WIN) && defined(QT_DEBUG)
- testProcess.start("desktopsettingsaware/debug/desktopsettingsaware");
-#elif defined(Q_OS_WIN)
- testProcess.start("desktopsettingsaware/release/desktopsettingsaware");
-#elif defined(Q_OS_SYMBIAN)
- testProcess.start("desktopsettingsaware");
-#if defined(Q_CC_NOKIAX86)
- QEXPECT_FAIL("", "QProcess on Q_CC_NOKIAX86 cannot launch another Qt application, due to DLL conflicts.", Abort);
- // TODO: Remove XFAIL, as soon as we can launch Qt applications from within Qt applications on Symbian
- QVERIFY(testProcess.error() != QProcess::FailedToStart);
-#endif // defined(Q_CC_NOKIAX86)
-#else
- testProcess.start("desktopsettingsaware/desktopsettingsaware");
-#endif
-#endif
- QVERIFY(testProcess.waitForFinished(10000));
- QCOMPARE(int(testProcess.state()), int(QProcess::NotRunning));
- QVERIFY(int(testProcess.error()) != int(QProcess::Crashed));
-#endif
-}
-*/
-
-void tst_QApplication::setActiveWindow()
-{
- int argc = 0;
- QApplication MyApp(argc, 0, QApplication::GuiServer);
-
- QWidget* w = new QWidget;
- QVBoxLayout* layout = new QVBoxLayout(w);
-
- QLineEdit* pb1 = new QLineEdit("Testbutton1", w);
- QLineEdit* pb2 = new QLineEdit("Test Line Edit", w);
-
- layout->addWidget(pb1);
- layout->addWidget(pb2);
-
- pb2->setFocus();
- pb2->setParent(0);
- delete pb2;
-
- w->show();
- QApplication::setActiveWindow(w); // needs this on twm (focus follows mouse)
- QVERIFY(pb1->hasFocus());
- delete w;
-}
-
-
-/* This might fail on some X11 window managers? */
-/*
-void tst_QApplication::focusChanged()
-{
- int argc = 0;
- QApplication app(argc, 0, QApplication::GuiServer);
-
- QSignalSpy spy(&app, SIGNAL(focusChanged(QWidget *, QWidget *)));
- QWidget *now = 0;
- QWidget *old = 0;
-
- QWidget parent1;
- QHBoxLayout hbox1(&parent1);
- QLabel lb1(&parent1);
- QLineEdit le1(&parent1);
- QPushButton pb1(&parent1);
- hbox1.addWidget(&lb1);
- hbox1.addWidget(&le1);
- hbox1.addWidget(&pb1);
-
- QCOMPARE(spy.count(), 0);
-
- parent1.show();
- QApplication::setActiveWindow(&parent1); // needs this on twm (focus follows mouse)
- QCOMPARE(spy.count(), 1);
- QCOMPARE(spy.at(0).count(), 2);
- old = qVariantValue<QWidget*>(spy.at(0).at(0));
- now = qVariantValue<QWidget*>(spy.at(0).at(1));
- QVERIFY(now == &le1);
- QVERIFY(now == QApplication::focusWidget());
- QVERIFY(old == 0);
- spy.clear();
- QCOMPARE(spy.count(), 0);
-
- pb1.setFocus();
- QCOMPARE(spy.count(), 1);
- old = qVariantValue<QWidget*>(spy.at(0).at(0));
- now = qVariantValue<QWidget*>(spy.at(0).at(1));
- QVERIFY(now == &pb1);
- QVERIFY(now == QApplication::focusWidget());
- QVERIFY(old == &le1);
- spy.clear();
-
- lb1.setFocus();
- QCOMPARE(spy.count(), 1);
- old = qVariantValue<QWidget*>(spy.at(0).at(0));
- now = qVariantValue<QWidget*>(spy.at(0).at(1));
- QVERIFY(now == &lb1);
- QVERIFY(now == QApplication::focusWidget());
- QVERIFY(old == &pb1);
- spy.clear();
-
- lb1.clearFocus();
- QCOMPARE(spy.count(), 1);
- old = qVariantValue<QWidget*>(spy.at(0).at(0));
- now = qVariantValue<QWidget*>(spy.at(0).at(1));
- QVERIFY(now == 0);
- QVERIFY(now == QApplication::focusWidget());
- QVERIFY(old == &lb1);
- spy.clear();
-
- QWidget parent2;
- QHBoxLayout hbox2(&parent2);
- QLabel lb2(&parent2);
- QLineEdit le2(&parent2);
- QPushButton pb2(&parent2);
- hbox2.addWidget(&lb2);
- hbox2.addWidget(&le2);
- hbox2.addWidget(&pb2);
-
- parent2.show();
- QApplication::setActiveWindow(&parent2); // needs this on twm (focus follows mouse)
- QVERIFY(spy.count() > 0); // one for deactivation, one for activation on Windows
- old = qVariantValue<QWidget*>(spy.at(spy.count()-1).at(0));
- now = qVariantValue<QWidget*>(spy.at(spy.count()-1).at(1));
- QVERIFY(now == &le2);
- QVERIFY(now == QApplication::focusWidget());
- QVERIFY(old == 0);
- spy.clear();
-
- QTestKeyEvent tab(QTest::Press, Qt::Key_Tab, 0, 0);
- QTestKeyEvent backtab(QTest::Press, Qt::Key_Backtab, 0, 0);
- QTestMouseEvent click(QTest::MouseClick, Qt::LeftButton, 0, QPoint(5, 5), 0);
-
- bool tabAllControls = true;
-#ifdef Q_WS_MAC
- // Mac has two modes, one where you tab to everything, one where you can
- // only tab to input controls, here's what we get. Determine which ones we
- // should get.
- QSettings appleSettings(QLatin1String("apple.com"));
- QVariant appleValue = appleSettings.value(QLatin1String("AppleKeyboardUIMode"), 0);
- tabAllControls = (appleValue.toInt() & 0x2);
-#endif
-
- tab.simulate(now);
- if (!tabAllControls) {
- QVERIFY(spy.count() == 0);
- QVERIFY(now == QApplication::focusWidget());
- } else {
- QVERIFY(spy.count() > 0);
- old = qVariantValue<QWidget*>(spy.at(0).at(0));
- now = qVariantValue<QWidget*>(spy.at(0).at(1));
- QVERIFY(now == &pb2);
- QVERIFY(now == QApplication::focusWidget());
- QVERIFY(old == &le2);
- spy.clear();
- }
-
- if (!tabAllControls) {
- QVERIFY(spy.count() == 0);
- QVERIFY(now == QApplication::focusWidget());
- } else {
- tab.simulate(now);
- QVERIFY(spy.count() > 0);
- old = qVariantValue<QWidget*>(spy.at(0).at(0));
- now = qVariantValue<QWidget*>(spy.at(0).at(1));
- QVERIFY(now == &le2);
- QVERIFY(now == QApplication::focusWidget());
- QVERIFY(old == &pb2);
- spy.clear();
- }
-
- if (!tabAllControls) {
- QVERIFY(spy.count() == 0);
- QVERIFY(now == QApplication::focusWidget());
- } else {
- backtab.simulate(now);
- QVERIFY(spy.count() > 0);
- old = qVariantValue<QWidget*>(spy.at(0).at(0));
- now = qVariantValue<QWidget*>(spy.at(0).at(1));
- QVERIFY(now == &pb2);
- QVERIFY(now == QApplication::focusWidget());
- QVERIFY(old == &le2);
- spy.clear();
- }
-
-
- if (!tabAllControls) {
- QVERIFY(spy.count() == 0);
- QVERIFY(now == QApplication::focusWidget());
- old = &pb2;
- } else {
- backtab.simulate(now);
- QVERIFY(spy.count() > 0);
- old = qVariantValue<QWidget*>(spy.at(0).at(0));
- now = qVariantValue<QWidget*>(spy.at(0).at(1));
- QVERIFY(now == &le2);
- QVERIFY(now == QApplication::focusWidget());
- QVERIFY(old == &pb2);
- spy.clear();
- }
-
- click.simulate(old);
- if (!(pb2.focusPolicy() & Qt::ClickFocus)) {
- QVERIFY(spy.count() == 0);
- QVERIFY(now == QApplication::focusWidget());
- } else {
- QVERIFY(spy.count() > 0);
- old = qVariantValue<QWidget*>(spy.at(0).at(0));
- now = qVariantValue<QWidget*>(spy.at(0).at(1));
- QVERIFY(now == &pb2);
- QVERIFY(now == QApplication::focusWidget());
- QVERIFY(old == &le2);
- spy.clear();
-
- click.simulate(old);
- QVERIFY(spy.count() > 0);
- old = qVariantValue<QWidget*>(spy.at(0).at(0));
- now = qVariantValue<QWidget*>(spy.at(0).at(1));
- QVERIFY(now == &le2);
- QVERIFY(now == QApplication::focusWidget());
- QVERIFY(old == &pb2);
- spy.clear();
- }
-
- parent1.activateWindow();
- QApplication::setActiveWindow(&parent1); // needs this on twm (focus follows mouse)
- QVERIFY(spy.count() == 1 || spy.count() == 2); // one for deactivation, one for activation on Windows
-
- //on windows, the change of focus is made in 2 steps
- //(the focusChanged SIGNAL is emitted twice)
- if (spy.count()==1)
- old = qVariantValue<QWidget*>(spy.at(spy.count()-1).at(0));
- else
- old = qVariantValue<QWidget*>(spy.at(spy.count()-2).at(0));
- now = qVariantValue<QWidget*>(spy.at(spy.count()-1).at(1));
- QVERIFY(now == &le1);
- QVERIFY(now == QApplication::focusWidget());
- QVERIFY(old == &le2);
- spy.clear();
-}
-
-class LineEdit : public QLineEdit
-{
-public:
- LineEdit(QWidget *parent = 0) : QLineEdit(parent) { }
-
-protected:
- void focusOutEvent(QFocusEvent *e) {
- QLineEdit::focusOutEvent(e);
- if (objectName() == "le1")
- setStyleSheet("");
- }
-
- void focusInEvent(QFocusEvent *e) {
- QLineEdit::focusInEvent(e);
- if (objectName() == "le2")
- setStyleSheet("");
- }
-};
-
-void tst_QApplication::focusOut()
-{
- int argc = 1;
- QApplication app(argc, &argv0, QApplication::GuiServer);
-
- // Tests the case where the style pointer changes when on focus in/out
- // (the above is the case when the stylesheet changes)
- QWidget w;
- QLineEdit *le1 = new LineEdit(&w);
- le1->setObjectName("le1");
- le1->setStyleSheet("background: #fee");
- le1->setFocus();
-
- QLineEdit *le2 = new LineEdit(&w);
- le2->setObjectName("le2");
- le2->setStyleSheet("background: #fee");
- le2->move(100, 100);
- w.show();
-
- QTest::qWait(2000);
- le2->setFocus();
- QTest::qWait(2000);
-}
-
-void tst_QApplication::execAfterExit()
-{
- int argc = 1;
- QApplication app(argc, &argv0, QApplication::GuiServer);
- QMetaObject::invokeMethod(&app, "quit", Qt::QueuedConnection);
- // this should be ignored, as exec() will reset the exitCode
- QApplication::exit(1);
- int exitCode = app.exec();
- QCOMPARE(exitCode, 0);
-
- // the quitNow flag should have been reset, so we can spin an
- // eventloop after QApplication::exec() returns
- QEventLoop eventLoop;
- QMetaObject::invokeMethod(&eventLoop, "quit", Qt::QueuedConnection);
- exitCode = eventLoop.exec();
- QCOMPARE(exitCode, 0);
-}
-
-void tst_QApplication::wheelScrollLines()
-{
- int argc = 1;
- QApplication app(argc, &argv0, QApplication::GuiServer);
- // If wheelScrollLines returns 0, the mose wheel will be disabled.
- QVERIFY(app.wheelScrollLines() > 0);
-}
-
-void tst_QApplication::style()
-{
- int argc = 1;
-
- {
- QApplication app(argc, &argv0, QApplication::GuiServer);
- QPointer<QStyle> style = app.style();
- app.setStyle(new QWindowsStyle);
- QVERIFY(style.isNull());
- }
-
- QApplication app(argc, &argv0, QApplication::GuiServer);
-
- // qApp style can never be 0
- QVERIFY(QApplication::style() != 0);
-}
-
-void tst_QApplication::allWidgets()
-{
- int argc = 1;
- QApplication app(argc, &argv0, QApplication::GuiServer);
- QWidget *w = new QWidget;
- QVERIFY(app.allWidgets().contains(w)); // uncreate widget test
- QVERIFY(app.allWidgets().contains(w)); // created widget test
- delete w;
- w = 0;
- QVERIFY(!app.allWidgets().contains(w)); // removal test
-}
-
-void tst_QApplication::topLevelWidgets()
-{
- int argc = 1;
- QApplication app(argc, &argv0, QApplication::GuiServer);
- QWidget *w = new QWidget;
- w->show();
-#ifndef QT_NO_CLIPBOARD
- QClipboard *clipboard = QApplication::clipboard();
- QString originalText = clipboard->text();
- clipboard->setText(QString("newText"));
-#endif
- app.processEvents();
- QVERIFY(QApplication::topLevelWidgets().contains(w));
- QCOMPARE(QApplication::topLevelWidgets().count(), 1);
- delete w;
- w = 0;
- app.processEvents();
- QCOMPARE(QApplication::topLevelWidgets().count(), 0);
-}
-
-
-
-void tst_QApplication::setAttribute()
-{
- int argc = 1;
- QApplication app(argc, &argv0, QApplication::GuiServer);
- QVERIFY(!QApplication::testAttribute(Qt::AA_ImmediateWidgetCreation));
- QWidget *w = new QWidget;
- QVERIFY(!w->testAttribute(Qt::WA_WState_Created));
- delete w;
-
- QApplication::setAttribute(Qt::AA_ImmediateWidgetCreation);
- QVERIFY(QApplication::testAttribute(Qt::AA_ImmediateWidgetCreation));
- w = new QWidget;
- QVERIFY(w->testAttribute(Qt::WA_WState_Created));
- QWidget *w2 = new QWidget(w);
- w2->setParent(0);
- QVERIFY(w2->testAttribute(Qt::WA_WState_Created));
- delete w;
- delete w2;
-
- QApplication::setAttribute(Qt::AA_ImmediateWidgetCreation, false);
- QVERIFY(!QApplication::testAttribute(Qt::AA_ImmediateWidgetCreation));
- w = new QWidget;
- QVERIFY(!w->testAttribute(Qt::WA_WState_Created));
- delete w;
-}
-
-void tst_QApplication::windowsCommandLine_data()
-{
-#if defined(Q_OS_WIN)
- QTest::addColumn<QString>("args");
- QTest::addColumn<QString>("expected");
-
- QTest::newRow("hello world")
- << QString("Hello \"World\"")
- << QString("Hello \"World\"");
- QTest::newRow("sql")
- << QString("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = 'PNR' AND TABLE_TYPE = 'VIEW' ORDER BY TABLE_NAME")
- << QString("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = 'PNR' AND TABLE_TYPE = 'VIEW' ORDER BY TABLE_NAME");
-#endif
-}
-
-void tst_QApplication::windowsCommandLine()
-{
-#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
- QFETCH(QString, args);
- QFETCH(QString, expected);
-
- QProcess testProcess;
-#if defined(QT_DEBUG)
- testProcess.start("wincmdline/debug/wincmdline", QStringList(args));
-#else
- testProcess.start("wincmdline/release/wincmdline", QStringList(args));
-#endif
- QVERIFY(testProcess.waitForFinished(10000));
- QByteArray error = testProcess.readAllStandardError();
- QString procError(error);
- QCOMPARE(procError, expected);
-#endif
-}
-
-class TouchEventPropagationTestWidget : public QWidget
-{
- Q_OBJECT
-
-public:
- bool seenTouchEvent, acceptTouchEvent, seenMouseEvent, acceptMouseEvent;
-
- TouchEventPropagationTestWidget(QWidget *parent = 0)
- : QWidget(parent), seenTouchEvent(false), acceptTouchEvent(false), seenMouseEvent(false), acceptMouseEvent(false)
- { }
-
- void reset()
- {
- seenTouchEvent = acceptTouchEvent = seenMouseEvent = acceptMouseEvent = false;
- }
-
- bool event(QEvent *event)
- {
- switch (event->type()) {
- case QEvent::MouseButtonPress:
- case QEvent::MouseMove:
- case QEvent::MouseButtonRelease:
- // qDebug() << objectName() << "seenMouseEvent = true";
- seenMouseEvent = true;
- event->setAccepted(acceptMouseEvent);
- break;
- case QEvent::TouchBegin:
- case QEvent::TouchUpdate:
- case QEvent::TouchEnd:
- // qDebug() << objectName() << "seenTouchEvent = true";
- seenTouchEvent = true;
- event->setAccepted(acceptTouchEvent);
- break;
- default:
- return QWidget::event(event);
- }
- return true;
- }
-};
-
-void tst_QApplication::touchEventPropagation()
-{
- int argc = 1;
- QApplication app(argc, &argv0, QApplication::GuiServer);
-
- QList<QTouchEvent::TouchPoint> pressedTouchPoints;
- QTouchEvent::TouchPoint press(0);
- press.setState(Qt::TouchPointPressed);
- pressedTouchPoints << press;
-
- QList<QTouchEvent::TouchPoint> releasedTouchPoints;
- QTouchEvent::TouchPoint release(0);
- release.setState(Qt::TouchPointReleased);
- releasedTouchPoints << release;
-
- {
- // touch event behavior on a window
- TouchEventPropagationTestWidget window;
- window.setObjectName("1. window");
-
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, pressedTouchPoints);
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, releasedTouchPoints);
- QVERIFY(!window.seenTouchEvent);
- QVERIFY(!window.seenMouseEvent);
-
- window.reset();
- window.setAttribute(Qt::WA_AcceptTouchEvents);
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, pressedTouchPoints);
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, releasedTouchPoints);
- QVERIFY(window.seenTouchEvent);
- QVERIFY(!window.seenMouseEvent);
-
- window.reset();
- window.acceptTouchEvent = true;
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, pressedTouchPoints);
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, releasedTouchPoints);
- QVERIFY(window.seenTouchEvent);
- QVERIFY(!window.seenMouseEvent);
- }
-
- {
- // touch event behavior on a window with a child widget
- TouchEventPropagationTestWidget window;
- window.setObjectName("2. window");
- TouchEventPropagationTestWidget widget(&window);
- widget.setObjectName("2. widget");
-
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, pressedTouchPoints);
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, releasedTouchPoints);
- QVERIFY(!widget.seenTouchEvent);
- QVERIFY(!widget.seenMouseEvent);
- QVERIFY(!window.seenTouchEvent);
- QVERIFY(!window.seenMouseEvent);
-
- window.reset();
- widget.reset();
- widget.setAttribute(Qt::WA_AcceptTouchEvents);
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, pressedTouchPoints);
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, releasedTouchPoints);
- QVERIFY(widget.seenTouchEvent);
- QVERIFY(!widget.seenMouseEvent);
- QVERIFY(!window.seenTouchEvent);
- QVERIFY(!window.seenMouseEvent);
-
- window.reset();
- widget.reset();
- widget.acceptMouseEvent = true;
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, pressedTouchPoints);
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, releasedTouchPoints);
- QVERIFY(widget.seenTouchEvent);
- QVERIFY(!widget.seenMouseEvent);
- QVERIFY(!window.seenTouchEvent);
- QVERIFY(!window.seenMouseEvent);
-
- window.reset();
- widget.reset();
- widget.acceptTouchEvent = true;
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, pressedTouchPoints);
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, releasedTouchPoints);
- QVERIFY(widget.seenTouchEvent);
- QVERIFY(!widget.seenMouseEvent);
- QVERIFY(!window.seenTouchEvent);
- QVERIFY(!window.seenMouseEvent);
-
- window.reset();
- widget.reset();
- widget.setAttribute(Qt::WA_AcceptTouchEvents, false);
- window.setAttribute(Qt::WA_AcceptTouchEvents);
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, pressedTouchPoints);
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, releasedTouchPoints);
- QVERIFY(!widget.seenTouchEvent);
- QVERIFY(!widget.seenMouseEvent);
- QVERIFY(window.seenTouchEvent);
- QVERIFY(!window.seenMouseEvent);
-
- window.reset();
- widget.reset();
- window.acceptTouchEvent = true;
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, pressedTouchPoints);
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, releasedTouchPoints);
- QVERIFY(!widget.seenTouchEvent);
- QVERIFY(!widget.seenMouseEvent);
- QVERIFY(window.seenTouchEvent);
- QVERIFY(!window.seenMouseEvent);
-
- window.reset();
- widget.reset();
- widget.acceptMouseEvent = true; // doesn't matter, touch events are propagated first
- window.acceptTouchEvent = true;
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, pressedTouchPoints);
- qt_translateRawTouchEvent(&window, QTouchEvent::TouchScreen, releasedTouchPoints);
- QVERIFY(!widget.seenTouchEvent);
- QVERIFY(!widget.seenMouseEvent);
- QVERIFY(window.seenTouchEvent);
- QVERIFY(!window.seenMouseEvent);
- }
-}
-
-void tst_QApplication::symbianNoApplicationPanes()
-{
-#ifndef Q_OS_SYMBIAN
- QSKIP("This is a Symbian only test", SkipAll);
-#else
- QApplication::setAttribute(Qt::AA_S60DontConstructApplicationPanes);
-
- // Run in a block so that QApplication is destroyed before resetting the attribute.
- {
- // Actually I wasn't able to get the forced orientation change to work properly,
- // but I'll leave the code here for the future in case we manage to test that
- // later. If someone knows how to force an orientation switch in an autotest, do
- // feel free to fix this testcase.
- int argc = 0;
- QApplication app(argc, 0);
- QWidget *w;
-
- w = new QWidget;
- w->show();
- QT_TRAP_THROWING(static_cast<CAknAppUi *>(CCoeEnv::Static()->AppUi())
- ->SetOrientationL(CAknAppUi::EAppUiOrientationLandscape));
- app.processEvents();
- delete w;
-
- w = new QWidget;
- w->show();
- QT_TRAP_THROWING(static_cast<CAknAppUi *>(CCoeEnv::Static()->AppUi())
- ->SetOrientationL(CAknAppUi::EAppUiOrientationPortrait));
- app.processEvents();
- delete w;
-
- w = new QWidget;
- w->showMaximized();
- QT_TRAP_THROWING(static_cast<CAknAppUi *>(CCoeEnv::Static()->AppUi())
- ->SetOrientationL(CAknAppUi::EAppUiOrientationLandscape));
- app.processEvents();
- delete w;
-
- w = new QWidget;
- w->showMaximized();
- QT_TRAP_THROWING(static_cast<CAknAppUi *>(CCoeEnv::Static()->AppUi())
- ->SetOrientationL(CAknAppUi::EAppUiOrientationPortrait));
- app.processEvents();
- delete w;
-
- w = new QWidget;
- w->showFullScreen();
- QT_TRAP_THROWING(static_cast<CAknAppUi *>(CCoeEnv::Static()->AppUi())
- ->SetOrientationL(CAknAppUi::EAppUiOrientationLandscape));
- app.processEvents();
- delete w;
-
- w = new QWidget;
- w->showFullScreen();
- QT_TRAP_THROWING(static_cast<CAknAppUi *>(CCoeEnv::Static()->AppUi())
- ->SetOrientationL(CAknAppUi::EAppUiOrientationPortrait));
- app.processEvents();
- delete w;
-
- // These will have no effect, since there is no status pane, but they shouldn't
- // crash either.
- w = new QWidget;
- w->show();
- w->setWindowTitle("Testing title");
- app.processEvents();
- delete w;
-
- w = new QWidget;
- w->show();
- w->setWindowIcon(QIcon(QPixmap("heart.svg")));
- app.processEvents();
- delete w;
-
- QDesktopWidget desktop;
- QCOMPARE(desktop.availableGeometry(), desktop.screenGeometry());
- }
-
- QApplication::setAttribute(Qt::AA_S60DontConstructApplicationPanes, false);
-
- // No other error condition. Program will crash if unsuccessful.
-#endif
-}
-
-#ifdef Q_OS_SYMBIAN
-class CBaseDummy : public CBase
-{
-public:
- CBaseDummy(int *numDestroyed) : numDestroyed(numDestroyed)
- {
- }
- ~CBaseDummy()
- {
- (*numDestroyed)++;
- }
-
-private:
- int *numDestroyed;
-};
-
-static void fakeMain(int *numDestroyed)
-{
- // Push a few objects, just so that the cleanup stack has something to clean up.
- CleanupStack::PushL(new (ELeave) CBaseDummy(numDestroyed));
- int argc = 0;
- QApplication app(argc, 0);
- CleanupStack::PushL(new (ELeave) CBaseDummy(numDestroyed));
-
- User::Leave(KErrGeneral); // Fake error
-}
-#endif
-
-void tst_QApplication::symbianNeedForTraps()
-{
-#ifndef Q_OS_SYMBIAN
- QSKIP("This is a Symbian-only test", SkipAll);
-#else
- int argc = 0;
- QApplication app(argc, 0);
- int numDestroyed = 0;
-
- // This next part should not require a trap. If it does, the test will crash.
- CleanupStack::PushL(new (ELeave) CBaseDummy(&numDestroyed));
- CleanupStack::PopAndDestroy();
-
- QCOMPARE(numDestroyed, 1);
-
- // No other failure condition. The program will crash if it does not pass.
-#endif
-}
-
-void tst_QApplication::symbianLeaveThroughMain()
-{
-#ifndef Q_OS_SYMBIAN
- QSKIP("This is a Symbian-only test", SkipAll);
-#else
- int numDestroyed = 0;
- TInt err;
- TRAP(err, fakeMain(&numDestroyed));
-
- QCOMPARE(numDestroyed, 2);
-#endif
-}
-*/
-
-//QTEST_APPLESS_MAIN(tst_QApplication)
-int main(int argc, char *argv[])
-{
- tst_QApplication tc;
- argv0 = argv[0];
- return QTest::qExec(&tc, argc, argv);
-}
-
-#include "smoketest_qapplication.moc"
--- a/qt/qapplication/smoketest_qapplication.pro Fri Jun 11 11:44:06 2010 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,4 +0,0 @@
-TEMPLATE = subdirs
-SUBDIRS = test \
-
-
--- a/qt/qapplication/test/test.pro Fri Jun 11 11:44:06 2010 +0100
+++ b/qt/qapplication/test/test.pro Mon Jun 14 12:26:38 2010 +0100
@@ -1,7 +1,7 @@
load(qttest_p4)
-SOURCES += ../smoketest_qapplication.cpp
-TARGET = ../smoketest_qapplication
+SOURCES += ../smoke_qapplication.cpp
+TARGET = ../smoke_qapplication
someTest.sources = test.pro
someTest.path = test
@@ -9,7 +9,7 @@
LIBS += -lcone -lavkon
symbian {
- TARGET = ../../release/smoketest_qapplication
+ TARGET = ../../release/tst_smoke_qapplication
}
Binary file qt/qwidget/geometry-fullscreen.dat has changed
Binary file qt/qwidget/geometry-maximized.dat has changed
Binary file qt/qwidget/geometry.dat has changed
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/qt/qwidget/qwidget.qrc Mon Jun 14 12:26:38 2010 +0100
@@ -0,0 +1,7 @@
+<!DOCTYPE RCC><RCC version="1.0">
+ <qresource>
+ <file>geometry.dat</file>
+ <file>geometry-maximized.dat</file>
+ <file>geometry-fullscreen.dat</file>
+ </qresource>
+</RCC>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/qt/qwidget/smoke_qwidget.cpp Mon Jun 14 12:26:38 2010 +0100
@@ -0,0 +1,399 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+
+#if defined(QT3_SUPPORT)
+#include <q3hbox.h>
+#include <q3textedit.h>
+#endif
+#include <qboxlayout.h>
+#include <qapplication.h>
+#include <qbitmap.h>
+#include <qdebug.h>
+#include <qeventloop.h>
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qlineedit.h>
+#include <qlistview.h>
+#include <qmessagebox.h>
+#include <qpainter.h>
+#include <qpoint.h>
+#include <qpushbutton.h>
+#include <qstyle.h>
+#include <qwidget.h>
+#include <qwindowsstyle.h>
+#include <qinputcontext.h>
+#include <qdesktopwidget.h>
+#include <private/qwidget_p.h>
+#include <private/qapplication_p.h>
+#include <qcalendarwidget.h>
+#include <qmainwindow.h>
+#include <qdockwidget.h>
+#include <qtoolbar.h>
+#include <QtGui/qpaintengine.h>
+#include <private/qbackingstore_p.h>
+
+#include <QtGui/QGraphicsView>
+#include <QtGui/QGraphicsProxyWidget>
+
+#include "../shared/util.h"
+
+
+#ifdef Q_WS_S60
+#include <avkon.hrh> // EEikStatusPaneUidTitle
+#include <akntitle.h> // CAknTitlePane
+#include <akncontext.h> // CAknContextPane
+#include <eikspane.h> // CEikStatusPane
+#include <eikbtgpc.h> // CEikButtonGroupContainer
+#endif
+
+#ifdef Q_WS_QWS
+# include <qscreen_qws.h>
+#endif
+
+// I *MUST* have QtTest afterwards or this test won't work with newer headers
+#if defined(Q_WS_MAC)
+# include <private/qt_mac_p.h>
+#undef verify
+#include "tst_qwidget_mac_helpers.h" // Abstract the ObjC stuff out so not everyone must run an ObjC++ compile.
+#endif
+
+#include <QtTest/QtTest>
+
+#if defined(Q_WS_WIN)
+# include <qt_windows.h>
+# if !defined(Q_OS_WINCE)
+#define Q_CHECK_PAINTEVENTS \
+ if (::SwitchDesktop(::GetThreadDesktop(::GetCurrentThreadId())) == 0) \
+ QSKIP("desktop is not visible, this test would fail", SkipSingle);
+# else
+# define Q_CHECK_PAINTEVENTS
+# endif
+#elif defined(Q_WS_X11)
+# include <private/qt_x11_p.h>
+# include <qx11info_x11.h>
+#elif defined(Q_WS_QWS)
+# include <qwindowsystem_qws.h>
+#endif
+
+#if !defined(Q_WS_WIN)
+#define Q_CHECK_PAINTEVENTS
+#endif
+
+#if defined(Bool)
+#undef Bool
+#endif
+
+// Will try to wait for the condition while allowing event processing
+// for a maximum of 2 seconds.
+#define WAIT_FOR_CONDITION(expr, expected) \
+ do { \
+ const int step = 100; \
+ for (int i = 0; i < 2000 && expr != expected; i+=step) { \
+ QTest::qWait(step); \
+ } \
+ } while(0)
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class tst_QWidget : public QObject
+{
+ Q_OBJECT
+
+public:
+ tst_QWidget();
+ virtual ~tst_QWidget();
+
+
+public slots:
+ void initTestCase();
+ void cleanupTestCase();
+ void init();
+ void cleanup();
+private slots:
+ void showFullScreen();
+
+private:
+ bool ensureScreenSize(int width, int height);
+ QWidget *testWidget;
+};
+
+tst_QWidget::tst_QWidget()
+{
+ QFont font;
+ font.setBold(true);
+ font.setPointSize(42);
+ qApp->setFont(font, "QPropagationTestWidget");
+
+ QPalette palette;
+ palette.setColor(QPalette::ToolTipBase, QColor(12, 13, 14));
+ palette.setColor(QPalette::Text, QColor(21, 22, 23));
+ qApp->setPalette(palette, "QPropagationTestWidget");
+
+ testWidget = 0;
+}
+
+tst_QWidget::~tst_QWidget()
+{
+}
+
+class BezierViewer : public QWidget {
+public:
+ BezierViewer( QWidget* parent=0, const char* name=0 );
+ void paintEvent( QPaintEvent* );
+ void setPoints( const QPolygonF& poly );
+private:
+ QPolygonF points;
+
+};
+
+void tst_QWidget::initTestCase()
+{
+ // Create the test class
+ testWidget = new BezierViewer( 0, "testObject");
+ testWidget->resize(200,200);
+#ifdef QT3_SUPPORT
+ qApp->setMainWidget(testWidget);
+#endif
+ testWidget->show();
+ QTest::qWaitForWindowShown(testWidget);
+ QTest::qWait(50);
+}
+
+void tst_QWidget::cleanupTestCase()
+{
+ delete testWidget;
+ testWidget = 0;
+}
+
+
+void tst_QWidget::init()
+{
+// TODO: Add initialization code here.
+// This will be executed immediately before each test is run.
+ testWidget->setFont(QFont());
+ testWidget->setPalette(QPalette());
+}
+
+void tst_QWidget::cleanup()
+{
+}
+
+
+
+// Helper class...
+
+BezierViewer::BezierViewer( QWidget* parent, const char* name )
+ : QWidget( parent )
+{
+ setObjectName(name);
+ QPalette pal;
+ pal.setColor(backgroundRole(), Qt::white);
+ setPalette(pal);
+}
+
+
+void BezierViewer::setPoints( const QPolygonF& a )
+{
+ points = a;
+}
+
+#include "private/qbezier_p.h"
+void BezierViewer::paintEvent( QPaintEvent* )
+{
+ if ( points.size() != 4 ) {
+#if defined(QT_CHECK_RANGE)
+ qWarning( "QPolygon::bezier: The array must have 4 control points" );
+#endif
+ return;
+ }
+
+ // Calculate Bezier curve
+ QPolygonF bezier = QBezier::fromPoints(points.at(0),points.at(1),points.at(2),points.at(3)).toPolygon();
+
+ QPainter painter( this );
+
+ // Calculate scale to fit in window
+ QRectF br = bezier.boundingRect() | points.boundingRect();
+ QRectF pr = rect();
+ int scl = qMax( qMin(pr.width()/br.width(), pr.height()/br.height()), qreal(1.) );
+ int border = scl-1;
+
+ // Scale Bezier curve vertices
+ for ( QPolygonF::Iterator it = bezier.begin(); it != bezier.end(); ++it ) {
+ it->setX( (it->x()-br.x()) * scl + border );
+ it->setY( (it->y()-br.y()) * scl + border );
+ }
+
+ // Draw grid
+ painter.setPen( Qt::lightGray );
+ int i;
+ for ( i = border; i <= pr.width(); i += scl ) {
+ painter.drawLine( i, 0, i, pr.height() );
+ }
+ for ( int j = border; j <= pr.height(); j += scl ) {
+ painter.drawLine( 0, j, pr.width(), j );
+ }
+
+ // Write number of vertices
+ painter.setPen( Qt::red );
+ painter.setFont( QFont("Helvetica", 14, QFont::DemiBold, TRUE ) );
+ QString caption;
+ caption.setNum( bezier.size() );
+ caption += QString::fromLatin1( " vertices" );
+ painter.drawText( 10, pr.height()-10, caption );
+
+ // Draw Bezier curve
+ painter.setPen( Qt::black );
+ painter.drawPolyline( bezier );
+
+ // Scale and draw control points
+ painter.setPen( Qt::darkGreen );
+ for ( QPolygonF::Iterator p1 = points.begin(); p1 != points.end(); ++p1 ) {
+ int x = (p1->x()-br.x()) * scl + border;
+ int y = (p1->y()-br.y()) * scl + border;
+ painter.drawLine( x-4, y-4, x+4, y+4 );
+ painter.drawLine( x+4, y-4, x-4, y+4 );
+ }
+
+ // Draw vertices
+ painter.setPen( Qt::red );
+ painter.setBrush( Qt::red );
+ for ( QPolygonF::Iterator p2 = bezier.begin(); p2 != bezier.end(); ++p2 )
+ painter.drawEllipse( p2->x()-1, p2->y()-1, 3, 3 );
+}
+
+void tst_QWidget::showFullScreen()
+{
+ QWidget plain;
+ QHBoxLayout *layout;
+ QWidget layouted;
+ QLineEdit le;
+ QLineEdit le2;
+ QLineEdit le3;
+ layout = new QHBoxLayout;
+
+ layout->addWidget(&le);
+ layout->addWidget(&le2);
+ layout->addWidget(&le3);
+
+ layouted.setLayout(layout);
+
+ plain.showFullScreen();
+ QVERIFY(plain.windowState() & Qt::WindowFullScreen);
+
+ plain.showNormal();
+ QVERIFY(!(plain.windowState() & Qt::WindowFullScreen));
+
+ layouted.showFullScreen();
+ QVERIFY(layouted.windowState() & Qt::WindowFullScreen);
+
+ layouted.showNormal();
+ QVERIFY(!(layouted.windowState() & Qt::WindowFullScreen));
+
+#if !defined(Q_WS_QWS) && !defined(Q_OS_WINCE) && !defined (Q_WS_S60)
+//embedded may choose a different size to fit on the screen.
+ QCOMPARE(layouted.size(), layouted.sizeHint());
+#endif
+
+ layouted.showFullScreen();
+ QVERIFY(layouted.isFullScreen());
+ QVERIFY(layouted.isVisible());
+
+ layouted.hide();
+ QVERIFY(layouted.isFullScreen());
+ QVERIFY(!layouted.isVisible());
+
+ layouted.showFullScreen();
+ QVERIFY(layouted.isFullScreen());
+ QVERIFY(layouted.isVisible());
+
+ layouted.showMinimized();
+ QVERIFY(layouted.isMinimized());
+ QVERIFY(layouted.isFullScreen());
+
+ layouted.showFullScreen();
+ QVERIFY(!layouted.isMinimized());
+ QVERIFY(layouted.isFullScreen());
+ QVERIFY(layouted.isVisible());
+
+ layouted.showMinimized();
+ QVERIFY(layouted.isMinimized());
+ QVERIFY(layouted.isFullScreen());
+
+ layouted.showFullScreen();
+ QVERIFY(!layouted.isMinimized());
+ QVERIFY(layouted.isFullScreen());
+ QVERIFY(layouted.isVisible());
+
+ {
+ QWidget frame;
+ QWidget widget(&frame);
+ widget.showFullScreen();
+ QVERIFY(widget.isFullScreen());
+ }
+
+#ifdef QT3_SUPPORT
+#if !defined(Q_WS_QWS)
+//embedded respects max/min sizes by design -- maybe wrong design, but that's the way it is now.
+ {
+ Q3HBox box;
+ QWidget widget(&box);
+ widget.setMinimumSize(500, 500);
+ box.showFullScreen();
+ QVERIFY(box.isFullScreen());
+ }
+
+ {
+ Q3HBox box;
+ QWidget widget(&box);
+ widget.setMaximumSize(500, 500);
+
+ box.showFullScreen();
+ QVERIFY(box.isFullScreen());
+ }
+#endif
+#endif // QT3_SUPPORT
+}
+
+QTEST_MAIN(tst_QWidget)
+#include "smoke_qwidget.moc"
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/qt/qwidget/smoke_qwidget.pro Mon Jun 14 12:26:38 2010 +0100
@@ -0,0 +1,17 @@
+load(qttest_p4)
+SOURCES += smoketest_qwidget.cpp
+RESOURCES = qwidget.qrc
+
+contains(QT_CONFIG, qt3support): QT += qt3support
+contains(QT_CONFIG, qt3support):DEFINES+=QT_HAS_QT3SUPPORT
+
+aix-g++*:QMAKE_CXXFLAGS+=-fpermissive
+
+CONFIG += x11inc
+
+symbian {
+ INCLUDEPATH += $$MW_LAYER_SYSTEMINCLUDE
+ LIBS += -leikcore -lcone -leikcoctl
+}
+
+!wince*:!symbian:win32: LIBS += -luser32 -lgdi32
Binary file qt/qwidget/testdata/paintEvent/res_Motif_data0.qsnap has changed
Binary file qt/qwidget/testdata/paintEvent/res_Motif_data1.qsnap has changed
Binary file qt/qwidget/testdata/paintEvent/res_Motif_data2.qsnap has changed
Binary file qt/qwidget/testdata/paintEvent/res_Motif_data3.qsnap has changed
Binary file qt/qwidget/testdata/paintEvent/res_Windows_data0.qsnap has changed
Binary file qt/qwidget/testdata/paintEvent/res_Windows_data1.qsnap has changed
Binary file qt/qwidget/testdata/paintEvent/res_Windows_data2.qsnap has changed
Binary file qt/qwidget/testdata/paintEvent/res_Windows_data3.qsnap has changed