diff options
Diffstat (limited to 'tests/auto/qdockwidget/tst_qdockwidget.cpp')
| -rw-r--r-- | tests/auto/qdockwidget/tst_qdockwidget.cpp | 905 |
1 files changed, 905 insertions, 0 deletions
diff --git a/tests/auto/qdockwidget/tst_qdockwidget.cpp b/tests/auto/qdockwidget/tst_qdockwidget.cpp new file mode 100644 index 0000000000..d42739600c --- /dev/null +++ b/tests/auto/qdockwidget/tst_qdockwidget.cpp @@ -0,0 +1,905 @@ +/**************************************************************************** +** +** Copyright (C) 2011 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 <qaction.h> +#include <qdockwidget.h> +#include <qmainwindow.h> +#include <qlineedit.h> +#include <QDesktopWidget> +#include <QtGui/QPainter> +#include "private/qdockwidget_p.h" + +bool hasFeature(QDockWidget *dockwidget, QDockWidget::DockWidgetFeature feature) +{ return (dockwidget->features() & feature) == feature; } + +void setFeature(QDockWidget *dockwidget, QDockWidget::DockWidgetFeature feature, bool on = true) +{ + const QDockWidget::DockWidgetFeatures features = dockwidget->features(); + dockwidget->setFeatures(on ? features | feature : features & ~feature); +} + +//TESTED_FILES= + +class tst_QDockWidget : public QObject +{ + Q_OBJECT + +public: + tst_QDockWidget(); + +private slots: + void getSetCheck(); + void widget(); + void setWidget(); + void setFeatures(); + void features(); + void setFloating(); + void setAllowedAreas(); + void allowedAreas(); + void isAreaAllowed(); + void toggleViewAction(); + void featuresChanged(); + void topLevelChanged(); + void allowedAreasChanged(); + void visibilityChanged(); + void dockLocationChanged(); + void setTitleBarWidget(); + void titleBarDoubleClick(); + void restoreStateOfFloating(); + // task specific tests: + void task165177_deleteFocusWidget(); + void task169808_setFloating(); + void task237438_setFloatingCrash(); + void task248604_infiniteResize(); + void task258459_visibilityChanged(); + void taskQTBUG_1665_closableChanged(); + void taskQTBUG_9758_undockedGeometry(); +}; + +// Testing get/set functions +void tst_QDockWidget::getSetCheck() +{ + QDockWidget obj1; + // QWidget * QDockWidget::widget() + // void QDockWidget::setWidget(QWidget *) + QWidget *var1 = new QWidget(); + obj1.setWidget(var1); + QCOMPARE(var1, obj1.widget()); + obj1.setWidget((QWidget *)0); + QCOMPARE((QWidget *)0, obj1.widget()); + delete var1; + + // DockWidgetFeatures QDockWidget::features() + // void QDockWidget::setFeatures(DockWidgetFeatures) + obj1.setFeatures(QDockWidget::DockWidgetFeatures(QDockWidget::DockWidgetClosable)); + QCOMPARE(QDockWidget::DockWidgetFeatures(QDockWidget::DockWidgetClosable), obj1.features()); + obj1.setFeatures(QDockWidget::DockWidgetFeatures(QDockWidget::DockWidgetMovable)); + QCOMPARE(QDockWidget::DockWidgetFeatures(QDockWidget::DockWidgetMovable), obj1.features()); + obj1.setFeatures(QDockWidget::DockWidgetFeatures(QDockWidget::DockWidgetFloatable)); + QCOMPARE(QDockWidget::DockWidgetFeatures(QDockWidget::DockWidgetFloatable), obj1.features()); + obj1.setFeatures(QDockWidget::DockWidgetFeatures(QDockWidget::AllDockWidgetFeatures)); + QCOMPARE(QDockWidget::DockWidgetFeatures(QDockWidget::AllDockWidgetFeatures), obj1.features()); + obj1.setFeatures(QDockWidget::DockWidgetFeatures(QDockWidget::NoDockWidgetFeatures)); + QCOMPARE(QDockWidget::DockWidgetFeatures(QDockWidget::NoDockWidgetFeatures), obj1.features()); +} + +tst_QDockWidget::tst_QDockWidget() +{ + qRegisterMetaType<QDockWidget::DockWidgetFeatures>("QDockWidget::DockWidgetFeatures"); + qRegisterMetaType<Qt::DockWidgetAreas>("Qt::DockWidgetAreas"); +} + +void tst_QDockWidget::widget() +{ + { + QDockWidget dw; + QVERIFY(dw.widget() == 0); + } + + { + QDockWidget dw; + QWidget *w1 = new QWidget; + QWidget *w2 = new QWidget; + + dw.setWidget(w1); + QVERIFY(dw.widget() != 0); + QVERIFY(dw.widget() == w1); + QCOMPARE(w1->parentWidget(), (QWidget*)&dw); + + dw.setWidget(0); + QVERIFY(dw.widget() == 0); + + dw.setWidget(w2); + QVERIFY(dw.widget() != 0); + QVERIFY(dw.widget() == w2); + QCOMPARE(w2->parentWidget(), (QWidget*)&dw); + + dw.setWidget(0); + QVERIFY(dw.widget() == 0); + + dw.setWidget(w1); + QVERIFY(dw.widget() != 0); + QVERIFY(dw.widget() == w1); + QCOMPARE(w1->parentWidget(), (QWidget*)&dw); + + dw.setWidget(w2); + QVERIFY(dw.widget() != 0); + QVERIFY(dw.widget() == w2); + QCOMPARE(w2->parentWidget(), (QWidget*)&dw); + + dw.setWidget(0); + QVERIFY(dw.widget() == 0); + } + + { + QDockWidget dw; + QWidget *w1 = new QWidget; + QWidget *w2 = new QWidget; + + dw.setWidget(w1); + QVERIFY(dw.widget() != 0); + QVERIFY(dw.widget() == w1); + QCOMPARE(w1->parentWidget(), (QWidget*)&dw); + + w1->setParent(0); + QVERIFY(dw.widget() == 0); + + dw.setWidget(w2); + QVERIFY(dw.widget() != 0); + QVERIFY(dw.widget() == w2); + QCOMPARE(w2->parentWidget(), (QWidget*)&dw); + + w2->setParent(0); + QVERIFY(dw.widget() == 0); + + dw.setWidget(w1); + QVERIFY(dw.widget() != 0); + QVERIFY(dw.widget() == w1); + QCOMPARE(w1->parentWidget(), (QWidget*)&dw); + + dw.setWidget(w2); + QVERIFY(dw.widget() != 0); + QVERIFY(dw.widget() == w2); + QCOMPARE(w2->parentWidget(), (QWidget*)&dw); + + w1->setParent(0); + QVERIFY(dw.widget() != 0); + QVERIFY(dw.widget() == w2); + QCOMPARE(w2->parentWidget(), (QWidget*)&dw); + + w2->setParent(0); + QVERIFY(dw.widget() == 0); + delete w1; + delete w2; + } +} + +void tst_QDockWidget::setWidget() +{ DEPENDS_ON("setWidget()"); } + +void tst_QDockWidget::setFeatures() +{ DEPENDS_ON("features()"); } + +void tst_QDockWidget::features() +{ + QDockWidget dw; + + QSignalSpy spy(&dw, SIGNAL(featuresChanged(QDockWidget::DockWidgetFeatures))); + + // default features for dock widgets + int allDockWidgetFeatures = QDockWidget::DockWidgetClosable | + QDockWidget::DockWidgetMovable | + QDockWidget::DockWidgetFloatable; + + // defaults + QCOMPARE(dw.features(), allDockWidgetFeatures); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetClosable)); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetMovable)); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetFloatable)); + + // test individual setting + setFeature(&dw, QDockWidget::DockWidgetClosable, false); + QCOMPARE(dw.features(), QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable); + QVERIFY(!hasFeature(&dw, QDockWidget::DockWidgetClosable)); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetMovable)); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetFloatable)); + QCOMPARE(spy.count(), 1); + QCOMPARE((int)*(static_cast<const QDockWidget::DockWidgetFeature *>(spy.at(0).value(0).constData())), + (int)dw.features()); + spy.clear(); + dw.setFeatures(dw.features()); + QCOMPARE(spy.count(), 0); + spy.clear(); + + setFeature(&dw, QDockWidget::DockWidgetClosable); + QCOMPARE(dw.features(), allDockWidgetFeatures); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetClosable)); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetMovable)); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetFloatable)); + QCOMPARE(spy.count(), 1); + QCOMPARE((int)*static_cast<const QDockWidget::DockWidgetFeature *>(spy.at(0).value(0).constData()), + (int)dw.features()); + spy.clear(); + dw.setFeatures(dw.features()); + QCOMPARE(spy.count(), 0); + spy.clear(); + + setFeature(&dw, QDockWidget::DockWidgetMovable, false); + QCOMPARE(dw.features(), QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetFloatable); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetClosable)); + QVERIFY(!hasFeature(&dw, QDockWidget::DockWidgetMovable)); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetFloatable)); + QCOMPARE(spy.count(), 1); + QCOMPARE((int)*static_cast<const QDockWidget::DockWidgetFeature *>(spy.at(0).value(0).constData()), + (int)dw.features()); + spy.clear(); + dw.setFeatures(dw.features()); + QCOMPARE(spy.count(), 0); + spy.clear(); + + setFeature(&dw, QDockWidget::DockWidgetMovable); + QCOMPARE(dw.features(), allDockWidgetFeatures); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetClosable)); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetMovable)); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetFloatable)); + QCOMPARE(spy.count(), 1); + QCOMPARE((int)*static_cast<const QDockWidget::DockWidgetFeature *>(spy.at(0).value(0).constData()), + (int)dw.features()); + spy.clear(); + dw.setFeatures(dw.features()); + QCOMPARE(spy.count(), 0); + spy.clear(); + + setFeature(&dw, QDockWidget::DockWidgetFloatable, false); + QCOMPARE(dw.features(), QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetMovable); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetClosable)); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetMovable)); + QVERIFY(!hasFeature(&dw, QDockWidget::DockWidgetFloatable)); + QCOMPARE(spy.count(), 1); + QCOMPARE((int)*static_cast<const QDockWidget::DockWidgetFeature *>(spy.at(0).value(0).constData()), + (int)dw.features()); + spy.clear(); + dw.setFeatures(dw.features()); + QCOMPARE(spy.count(), 0); + spy.clear(); + + setFeature(&dw, QDockWidget::DockWidgetFloatable); + QCOMPARE(dw.features(), allDockWidgetFeatures); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetClosable)); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetMovable)); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetFloatable)); + QCOMPARE(spy.count(), 1); + QCOMPARE((int)*static_cast<const QDockWidget::DockWidgetFeature *>(spy.at(0).value(0).constData()), + (int)dw.features()); + spy.clear(); + dw.setFeatures(dw.features()); + QCOMPARE(spy.count(), 0); + spy.clear(); + + // set all at once + dw.setFeatures(QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetMovable); + QCOMPARE(dw.features(), QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetMovable); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetClosable)); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetMovable)); + QVERIFY(!hasFeature(&dw, QDockWidget::DockWidgetFloatable)); + QCOMPARE(spy.count(), 1); + QCOMPARE((int)*static_cast<const QDockWidget::DockWidgetFeature *>(spy.at(0).value(0).constData()), + (int)dw.features()); + spy.clear(); + dw.setFeatures(dw.features()); + QCOMPARE(spy.count(), 0); + spy.clear(); + + dw.setFeatures(QDockWidget::DockWidgetClosable); + QCOMPARE(dw.features(), QDockWidget::DockWidgetClosable); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetClosable)); + QVERIFY(!hasFeature(&dw, QDockWidget::DockWidgetMovable)); + QVERIFY(!hasFeature(&dw, QDockWidget::DockWidgetFloatable)); + QCOMPARE(spy.count(), 1); + QCOMPARE((int)*static_cast<const QDockWidget::DockWidgetFeature *>(spy.at(0).value(0).constData()), + (int)dw.features()); + spy.clear(); + dw.setFeatures(dw.features()); + QCOMPARE(spy.count(), 0); + spy.clear(); + + dw.setFeatures(QDockWidget::AllDockWidgetFeatures); + QCOMPARE(dw.features(), QDockWidget::AllDockWidgetFeatures); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetClosable)); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetMovable)); + QVERIFY(hasFeature(&dw, QDockWidget::DockWidgetFloatable)); + QCOMPARE(spy.count(), 1); + QCOMPARE((int)*static_cast<const QDockWidget::DockWidgetFeature *>(spy.at(0).value(0).constData()), + (int)dw.features()); + spy.clear(); + dw.setFeatures(dw.features()); + QCOMPARE(spy.count(), 0); + spy.clear(); +} + +void tst_QDockWidget::setFloating() +{ + QMainWindow mw; + QDockWidget dw; + mw.addDockWidget(Qt::LeftDockWidgetArea, &dw); + + mw.show(); +#ifdef Q_WS_X11 + qt_x11_wait_for_window_manager(&mw); +#endif + + QVERIFY(!dw.isFloating()); + + QSignalSpy spy(&dw, SIGNAL(topLevelChanged(bool))); + + dw.setFloating(true); + QVERIFY(dw.isFloating()); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.at(0).value(0).toBool(), dw.isFloating()); + spy.clear(); + dw.setFloating(dw.isFloating()); + QCOMPARE(spy.count(), 0); + spy.clear(); + + dw.setFloating(false); + QVERIFY(!dw.isFloating()); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.at(0).value(0).toBool(), dw.isFloating()); + spy.clear(); + dw.setFloating(dw.isFloating()); + QCOMPARE(spy.count(), 0); + spy.clear(); +} + +void tst_QDockWidget::setAllowedAreas() +{ DEPENDS_ON("allowedAreas()"); } + +void tst_QDockWidget::allowedAreas() +{ + QDockWidget dw; + + QSignalSpy spy(&dw, SIGNAL(allowedAreasChanged(Qt::DockWidgetAreas))); + + // default + QCOMPARE(dw.allowedAreas(), Qt::AllDockWidgetAreas); + QVERIFY(dw.isAreaAllowed(Qt::LeftDockWidgetArea)); + QVERIFY(dw.isAreaAllowed(Qt::RightDockWidgetArea)); + QVERIFY(dw.isAreaAllowed(Qt::TopDockWidgetArea)); + QVERIFY(dw.isAreaAllowed(Qt::BottomDockWidgetArea)); + + // a single dock window area + dw.setAllowedAreas(Qt::LeftDockWidgetArea); + QCOMPARE(dw.allowedAreas(), Qt::LeftDockWidgetArea); + QVERIFY(dw.isAreaAllowed(Qt::LeftDockWidgetArea)); + QVERIFY(!dw.isAreaAllowed(Qt::RightDockWidgetArea)); + QVERIFY(!dw.isAreaAllowed(Qt::TopDockWidgetArea)); + QVERIFY(!dw.isAreaAllowed(Qt::BottomDockWidgetArea)); + QCOMPARE(spy.count(), 1); + QCOMPARE(*static_cast<const Qt::DockWidgetAreas *>(spy.at(0).value(0).constData()), + dw.allowedAreas()); + spy.clear(); + dw.setAllowedAreas(dw.allowedAreas()); + QCOMPARE(spy.count(), 0); + + dw.setAllowedAreas(Qt::RightDockWidgetArea); + QCOMPARE(dw.allowedAreas(), Qt::RightDockWidgetArea); + QVERIFY(!dw.isAreaAllowed(Qt::LeftDockWidgetArea)); + QVERIFY(dw.isAreaAllowed(Qt::RightDockWidgetArea)); + QVERIFY(!dw.isAreaAllowed(Qt::TopDockWidgetArea)); + QVERIFY(!dw.isAreaAllowed(Qt::BottomDockWidgetArea)); + QCOMPARE(spy.count(), 1); + QCOMPARE(*static_cast<const Qt::DockWidgetAreas *>(spy.at(0).value(0).constData()), + dw.allowedAreas()); + spy.clear(); + dw.setAllowedAreas(dw.allowedAreas()); + QCOMPARE(spy.count(), 0); + + dw.setAllowedAreas(Qt::TopDockWidgetArea); + QCOMPARE(dw.allowedAreas(), Qt::TopDockWidgetArea); + QVERIFY(!dw.isAreaAllowed(Qt::LeftDockWidgetArea)); + QVERIFY(!dw.isAreaAllowed(Qt::RightDockWidgetArea)); + QVERIFY(dw.isAreaAllowed(Qt::TopDockWidgetArea)); + QVERIFY(!dw.isAreaAllowed(Qt::BottomDockWidgetArea)); + QCOMPARE(spy.count(), 1); + QCOMPARE(*static_cast<const Qt::DockWidgetAreas *>(spy.at(0).value(0).constData()), + dw.allowedAreas()); + spy.clear(); + dw.setAllowedAreas(dw.allowedAreas()); + QCOMPARE(spy.count(), 0); + + dw.setAllowedAreas(Qt::BottomDockWidgetArea); + QCOMPARE(dw.allowedAreas(), Qt::BottomDockWidgetArea); + QVERIFY(!dw.isAreaAllowed(Qt::LeftDockWidgetArea)); + QVERIFY(!dw.isAreaAllowed(Qt::RightDockWidgetArea)); + QVERIFY(!dw.isAreaAllowed(Qt::TopDockWidgetArea)); + QVERIFY(dw.isAreaAllowed(Qt::BottomDockWidgetArea)); + QCOMPARE(spy.count(), 1); + QCOMPARE(*static_cast<const Qt::DockWidgetAreas *>(spy.at(0).value(0).constData()), + dw.allowedAreas()); + spy.clear(); + dw.setAllowedAreas(dw.allowedAreas()); + QCOMPARE(spy.count(), 0); + + // multiple dock window areas + dw.setAllowedAreas(Qt::TopDockWidgetArea | Qt::BottomDockWidgetArea); + QCOMPARE(dw.allowedAreas(), Qt::TopDockWidgetArea | Qt::BottomDockWidgetArea); + QVERIFY(!dw.isAreaAllowed(Qt::LeftDockWidgetArea)); + QVERIFY(!dw.isAreaAllowed(Qt::RightDockWidgetArea)); + QVERIFY(dw.isAreaAllowed(Qt::TopDockWidgetArea)); + QVERIFY(dw.isAreaAllowed(Qt::BottomDockWidgetArea)); + QCOMPARE(spy.count(), 1); + QCOMPARE(*static_cast<const Qt::DockWidgetAreas *>(spy.at(0).value(0).constData()), + dw.allowedAreas()); + spy.clear(); + dw.setAllowedAreas(dw.allowedAreas()); + QCOMPARE(spy.count(), 0); + + dw.setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea); + QCOMPARE(dw.allowedAreas(), Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea); + QVERIFY(dw.isAreaAllowed(Qt::LeftDockWidgetArea)); + QVERIFY(dw.isAreaAllowed(Qt::RightDockWidgetArea)); + QVERIFY(!dw.isAreaAllowed(Qt::TopDockWidgetArea)); + QVERIFY(!dw.isAreaAllowed(Qt::BottomDockWidgetArea)); + QCOMPARE(spy.count(), 1); + QCOMPARE(*static_cast<const Qt::DockWidgetAreas *>(spy.at(0).value(0).constData()), + dw.allowedAreas()); + spy.clear(); + dw.setAllowedAreas(dw.allowedAreas()); + QCOMPARE(spy.count(), 0); + + dw.setAllowedAreas(Qt::TopDockWidgetArea | Qt::LeftDockWidgetArea); + QCOMPARE(dw.allowedAreas(), Qt::TopDockWidgetArea | Qt::LeftDockWidgetArea); + QVERIFY(dw.isAreaAllowed(Qt::LeftDockWidgetArea)); + QVERIFY(!dw.isAreaAllowed(Qt::RightDockWidgetArea)); + QVERIFY(dw.isAreaAllowed(Qt::TopDockWidgetArea)); + QVERIFY(!dw.isAreaAllowed(Qt::BottomDockWidgetArea)); + QCOMPARE(spy.count(), 1); + QCOMPARE(*static_cast<const Qt::DockWidgetAreas *>(spy.at(0).value(0).constData()), + dw.allowedAreas()); + spy.clear(); + dw.setAllowedAreas(dw.allowedAreas()); + QCOMPARE(spy.count(), 0); + + dw.setAllowedAreas(Qt::BottomDockWidgetArea | Qt::RightDockWidgetArea); + QCOMPARE(dw.allowedAreas(), Qt::BottomDockWidgetArea | Qt::RightDockWidgetArea); + QVERIFY(!dw.isAreaAllowed(Qt::LeftDockWidgetArea)); + QVERIFY(dw.isAreaAllowed(Qt::RightDockWidgetArea)); + QVERIFY(!dw.isAreaAllowed(Qt::TopDockWidgetArea)); + QVERIFY(dw.isAreaAllowed(Qt::BottomDockWidgetArea)); + QCOMPARE(spy.count(), 1); + QCOMPARE(*static_cast<const Qt::DockWidgetAreas *>(spy.at(0).value(0).constData()), + dw.allowedAreas()); + spy.clear(); + dw.setAllowedAreas(dw.allowedAreas()); + QCOMPARE(spy.count(), 0); +} + +void tst_QDockWidget::isAreaAllowed() +{ DEPENDS_ON("allowedAreas()"); } + +void tst_QDockWidget::toggleViewAction() +{ + QMainWindow mw; + QDockWidget dw(&mw); + mw.addDockWidget(Qt::LeftDockWidgetArea, &dw); + mw.show(); + QAction *toggleViewAction = dw.toggleViewAction(); + QVERIFY(!dw.isHidden()); + toggleViewAction->trigger(); + QVERIFY(dw.isHidden()); + toggleViewAction->trigger(); + QVERIFY(!dw.isHidden()); + toggleViewAction->trigger(); + QVERIFY(dw.isHidden()); +} + +void tst_QDockWidget::visibilityChanged() +{ + QMainWindow mw; + QDockWidget dw; + QSignalSpy spy(&dw, SIGNAL(visibilityChanged(bool))); + + mw.addDockWidget(Qt::LeftDockWidgetArea, &dw); + mw.show(); + + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.at(0).at(0).toBool(), true); + spy.clear(); + + dw.hide(); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.at(0).at(0).toBool(), false); + spy.clear(); + + dw.hide(); + QCOMPARE(spy.count(), 0); + + dw.show(); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.at(0).at(0).toBool(), true); + spy.clear(); + + dw.show(); + QCOMPARE(spy.count(), 0); + + QDockWidget dw2; + mw.tabifyDockWidget(&dw, &dw2); + dw2.show(); + dw2.raise(); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.at(0).at(0).toBool(), false); + spy.clear(); + + dw2.hide(); + qApp->processEvents(); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.at(0).at(0).toBool(), true); + spy.clear(); + + dw2.show(); + dw2.raise(); + qApp->processEvents(); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.at(0).at(0).toBool(), false); + spy.clear(); + + dw.raise(); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.at(0).at(0).toBool(), true); + spy.clear(); + + dw.raise(); + QCOMPARE(spy.count(), 0); + + dw2.raise(); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.at(0).at(0).toBool(), false); + spy.clear(); + + dw2.raise(); + QCOMPARE(spy.count(), 0); + + mw.addDockWidget(Qt::RightDockWidgetArea, &dw2); + QTest::qWait(200); + QCOMPARE(spy.count(), 1); + QCOMPARE(spy.at(0).at(0).toBool(), true); +} + +Q_DECLARE_METATYPE(Qt::DockWidgetArea) + +void tst_QDockWidget::dockLocationChanged() +{ + qRegisterMetaType<Qt::DockWidgetArea>("Qt::DockWidgetArea"); + + QMainWindow mw; + QDockWidget dw; + dw.setObjectName("dock1"); + QSignalSpy spy(&dw, SIGNAL(dockLocationChanged(Qt::DockWidgetArea))); + + mw.addDockWidget(Qt::LeftDockWidgetArea, &dw); + QCOMPARE(spy.count(), 1); + QCOMPARE(qvariant_cast<Qt::DockWidgetArea>(spy.at(0).at(0)), + Qt::LeftDockWidgetArea); + spy.clear(); + + mw.addDockWidget(Qt::LeftDockWidgetArea, &dw); + QCOMPARE(spy.count(), 1); + QCOMPARE(qvariant_cast<Qt::DockWidgetArea>(spy.at(0).at(0)), + Qt::LeftDockWidgetArea); + spy.clear(); + + mw.addDockWidget(Qt::RightDockWidgetArea, &dw); + QCOMPARE(spy.count(), 1); + QCOMPARE(qvariant_cast<Qt::DockWidgetArea>(spy.at(0).at(0)), + Qt::RightDockWidgetArea); + spy.clear(); + + mw.removeDockWidget(&dw); + QCOMPARE(spy.count(), 0); + + QDockWidget dw2; + dw2.setObjectName("dock2"); + mw.addDockWidget(Qt::TopDockWidgetArea, &dw2); + mw.tabifyDockWidget(&dw2, &dw); + QCOMPARE(spy.count(), 1); + QCOMPARE(qvariant_cast<Qt::DockWidgetArea>(spy.at(0).at(0)), + Qt::TopDockWidgetArea); + spy.clear(); + + mw.splitDockWidget(&dw2, &dw, Qt::Horizontal); + QCOMPARE(spy.count(), 1); + QCOMPARE(qvariant_cast<Qt::DockWidgetArea>(spy.at(0).at(0)), + Qt::TopDockWidgetArea); + spy.clear(); + + dw.setFloating(true); + QTest::qWait(100); + dw.setFloating(false); + QTest::qWait(100); + QCOMPARE(spy.count(), 1); + QCOMPARE(qvariant_cast<Qt::DockWidgetArea>(spy.at(0).at(0)), + Qt::TopDockWidgetArea); + spy.clear(); + + QByteArray ba = mw.saveState(); + mw.restoreState(ba); + QCOMPARE(spy.count(), 1); + QCOMPARE(qvariant_cast<Qt::DockWidgetArea>(spy.at(0).at(0)), + Qt::TopDockWidgetArea); +} + +void tst_QDockWidget::featuresChanged() +{ DEPENDS_ON("features()"); } + +void tst_QDockWidget::topLevelChanged() +{ DEPENDS_ON("setFloating()"); } + +void tst_QDockWidget::allowedAreasChanged() +{ DEPENDS_ON("allowedAreas()"); } + +void tst_QDockWidget::setTitleBarWidget() +{ + //test the successive usage of setTitleBarWidget + + QDockWidget dock; + QWidget w, w2; + + dock.show(); + qApp->processEvents(); + + dock.setTitleBarWidget(&w); + qApp->processEvents(); + QCOMPARE(w.isVisible(), true); + + //set another widget as the titlebar widget + dock.setTitleBarWidget(&w2); // this used to crash (task 184668) + qApp->processEvents(); + QCOMPARE(w.isVisible(), false); + QCOMPARE(w2.isVisible(), true); + + //tries to reset the titlebarwidget to none + dock.setTitleBarWidget(0); + qApp->processEvents(); + QCOMPARE(w.isVisible(), false); + QCOMPARE(w2.isVisible(), false); +} + +void tst_QDockWidget::titleBarDoubleClick() +{ + QMainWindow win; + QDockWidget dock(&win); + win.show(); + dock.setFloating(true); + + QEvent e(QEvent::NonClientAreaMouseButtonDblClick); + QApplication::sendEvent(&dock, &e); + QVERIFY(dock.isFloating()); + QCOMPARE(win.dockWidgetArea(&dock), Qt::NoDockWidgetArea); + + win.addDockWidget(Qt::TopDockWidgetArea, &dock); + dock.setFloating(true); + QApplication::sendEvent(&dock, &e); + QVERIFY(!dock.isFloating()); + QCOMPARE(win.dockWidgetArea(&dock), Qt::TopDockWidgetArea); +} + +void tst_QDockWidget::restoreStateOfFloating() +{ + QMainWindow mw; + QDockWidget dock; + dock.setObjectName("dock1"); + mw.addDockWidget(Qt::TopDockWidgetArea, &dock); + QVERIFY(!dock.isFloating()); + QByteArray ba = mw.saveState(); + dock.setFloating(true); + QVERIFY(dock.isFloating()); + QVERIFY(mw.restoreState(ba)); + QVERIFY(!dock.isFloating()); +} + + +void tst_QDockWidget::task165177_deleteFocusWidget() +{ + QMainWindow mw; + QDockWidget *dw = new QDockWidget(&mw); + mw.addDockWidget(Qt::LeftDockWidgetArea, dw); + QLineEdit *ledit = new QLineEdit; + dw->setWidget(ledit); + mw.show(); +#ifdef Q_WS_X11 + qt_x11_wait_for_window_manager(&mw); +#endif + qApp->processEvents(); + dw->setFloating(true); + delete ledit; + QCOMPARE(mw.focusWidget(), (QWidget *)0); + QCOMPARE(dw->focusWidget(), (QWidget *)0); +} + +void tst_QDockWidget::task169808_setFloating() +{ + //we try to test if the sizeHint of the dock widget widget is taken into account + + class MyWidget : public QWidget + { + public: + QSize sizeHint() const + { + const QRect& deskRect = qApp->desktop()->availableGeometry(); + return QSize(qMin(300, deskRect.width()), 300); + } + + QSize minimumSizeHint() const + { + return QSize(20,20); + } + + void paintEvent(QPaintEvent *) + { + QPainter p(this); + p.fillRect(rect(), Qt::red); + } + }; + QMainWindow mw; + mw.setCentralWidget(new MyWidget); + QDockWidget *dw = new QDockWidget("my dock"); + dw->setWidget(new MyWidget); + mw.addDockWidget(Qt::LeftDockWidgetArea, dw); + dw->setFloating(true); + mw.show(); +#ifdef Q_WS_X11 + qt_x11_wait_for_window_manager(&mw); +#endif + + QCOMPARE(dw->widget()->size(), dw->widget()->sizeHint()); + + //and now we try to test if the contents margin is taken into account + dw->widget()->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed); + dw->setFloating(false); +#ifdef Q_WS_X11 + qt_x11_wait_for_window_manager(&mw); +#endif + QTest::qWait(100); //leave time processing events + + + const QSize oldSize = dw->size(); + const int margin = 20; + + dw->setContentsMargins(margin, margin, margin, margin); + +#ifdef Q_WS_X11 + qt_x11_wait_for_window_manager(&mw); +#endif + QTest::qWait(100); //leave time processing events + + //widget size shouldn't have changed + QCOMPARE(dw->widget()->size(), dw->widget()->sizeHint()); + //dockwidget should be bigger + QCOMPARE(dw->size(), oldSize + QSize(margin * 2, margin * 2)); + + +} + +void tst_QDockWidget::task237438_setFloatingCrash() +{ + //should not crash + QDockWidget pqdwDock; + pqdwDock.setFloating(false); + pqdwDock.show(); +} + +void tst_QDockWidget::task248604_infiniteResize() +{ + QDockWidget d; + QTabWidget *t = new QTabWidget; + t->addTab(new QWidget, "Foo"); + d.setWidget(t); + d.setContentsMargins(2, 2, 2, 2); + d.setMinimumSize(320, 240); + d.show(); + QTest::qWait(400); + QCOMPARE(d.size(), QSize(320, 240)); +} + + +void tst_QDockWidget::task258459_visibilityChanged() +{ + QMainWindow win; + QDockWidget dock1, dock2; + win.addDockWidget(Qt::RightDockWidgetArea, &dock1); + win.tabifyDockWidget(&dock1, &dock2); + QSignalSpy spy1(&dock1, SIGNAL(visibilityChanged(bool))); + QSignalSpy spy2(&dock2, SIGNAL(visibilityChanged(bool))); + win.show(); + QTest::qWait(200); + QCOMPARE(spy1.count(), 1); + QCOMPARE(spy1.first().first().toBool(), false); //dock1 is invisible + QCOMPARE(spy2.count(), 1); + QCOMPARE(spy2.first().first().toBool(), true); //dock1 is visible +} + +void tst_QDockWidget::taskQTBUG_1665_closableChanged() +{ + QDockWidget dock; + dock.show(); + QTest::qWaitForWindowShown(&dock); + + QDockWidgetLayout *l = qobject_cast<QDockWidgetLayout*>(dock.layout()); + + if (l && !l->nativeWindowDeco()) + QSKIP("this machine doesn't support native dock widget", SkipAll); + + QVERIFY(dock.windowFlags() & Qt::WindowCloseButtonHint); + + //now let's remove the closable attribute + dock.setFeatures(dock.features() ^ QDockWidget::DockWidgetClosable); + QVERIFY(!(dock.windowFlags() & Qt::WindowCloseButtonHint)); +} + +void tst_QDockWidget::taskQTBUG_9758_undockedGeometry() +{ + QMainWindow window; + QDockWidget dock1(&window); + QDockWidget dock2(&window); + window.addDockWidget(Qt::RightDockWidgetArea, &dock1); + window.addDockWidget(Qt::RightDockWidgetArea, &dock2); + window.tabifyDockWidget(&dock1, &dock2); + dock1.hide(); + dock2.hide(); + window.show(); + QTest::qWaitForWindowShown(&window); + dock1.setFloating(true); + dock1.show(); + QTest::qWaitForWindowShown(&dock1); + + QVERIFY(dock1.x() >= 0); + QVERIFY(dock1.y() >= 0); +} + + + +QTEST_MAIN(tst_QDockWidget) +#include "tst_qdockwidget.moc" |