/****************************************************************************
**
** 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 <QMdiSubWindow>
#include <QMdiArea>

#include <QApplication>
#include <QMainWindow>
#include <QMenuBar>
#include <QPushButton>
#include <QStyle>
#include <QStyleOption>
#include <QVBoxLayout>
#include <QLineEdit>
#include <QDesktopWidget>
#include <QDockWidget>
#include <QScrollBar>
#include <QTextEdit>
#ifndef QT_NO_OPENGL
#include <QtOpenGL>
#endif
#include <QMacStyle>

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

static const Qt::WindowFlags DefaultWindowFlags
    = Qt::SubWindow | Qt::WindowSystemMenuHint
      | Qt::WindowTitleHint | Qt::WindowMinMaxButtonsHint | Qt::WindowCloseButtonHint;

Q_DECLARE_METATYPE(QMdiArea::WindowOrder)
Q_DECLARE_METATYPE(QMdiSubWindow *)
Q_DECLARE_METATYPE(QList<int>)
Q_DECLARE_METATYPE(QTabWidget::TabPosition)

//TESTED_CLASS=
//TESTED_FILES=

static bool tabBetweenSubWindowsIn(QMdiArea *mdiArea, int tabCount = -1, bool reverse = false)
{
    if (!mdiArea) {
        qWarning("Null pointer to mdi area");
        return false;
    }

    QList<QMdiSubWindow *> subWindows = mdiArea->subWindowList();
    const bool walkThrough = tabCount == -1;

    if (walkThrough) {
        QMdiSubWindow *active = reverse ? subWindows.front() : subWindows.back();
        mdiArea->setActiveSubWindow(active);
        if (mdiArea->activeSubWindow() != active) {
            qWarning("Failed to set active sub window");
            return false;
        }
        tabCount = subWindows.size();
    }

    QWidget *focusWidget = qApp->focusWidget();
    if (!focusWidget) {
        qWarning("No focus widget");
        return false;
    }

    Qt::KeyboardModifiers modifiers = reverse ? Qt::ShiftModifier : Qt::NoModifier;
    Qt::Key key;
#ifdef Q_WS_MAC
    key = Qt::Key_Meta;
    modifiers |= Qt::MetaModifier;
#else
    key = Qt::Key_Control;
    modifiers |= Qt::ControlModifier;
#endif

    QTest::keyPress(focusWidget, key, modifiers);
    for (int i = 0; i < tabCount; ++i) {
        QTest::keyPress(focusWidget, reverse ? Qt::Key_Backtab : Qt::Key_Tab, modifiers);
        if (tabCount > 1)
            QTest::qWait(500);
        if (walkThrough) {
            QRubberBand *rubberBand = qFindChild<QRubberBand *>(mdiArea->viewport());
            if (!rubberBand) {
                qWarning("No rubber band");
                return false;
            }
            QMdiSubWindow *subWindow = subWindows.at(reverse ? subWindows.size() -1 - i : i);
            if (rubberBand->geometry() != subWindow->geometry()) {
                qWarning("Rubber band has different geometry");
                return false;
            }
        }
        qApp->processEvents();
    }
    QTest::keyRelease(focusWidget, key);

    return true;
}

static inline QTabBar::Shape tabBarShapeFrom(QTabWidget::TabShape shape, QTabWidget::TabPosition position)
{
    const bool rounded = (shape == QTabWidget::Rounded);
    if (position == QTabWidget::North)
        return rounded ? QTabBar::RoundedNorth : QTabBar::TriangularNorth;
    if (position == QTabWidget::South)
        return rounded ? QTabBar::RoundedSouth : QTabBar::TriangularSouth;
    if (position == QTabWidget::East)
        return rounded ? QTabBar::RoundedEast : QTabBar::TriangularEast;
    if (position == QTabWidget::West)
        return rounded ? QTabBar::RoundedWest : QTabBar::TriangularWest;
    return QTabBar::RoundedNorth;
}

enum Arrangement {
    Tiled,
    Cascaded
};

static bool verifyArrangement(QMdiArea *mdiArea, Arrangement arrangement, const QList<int> &expectedIndices)
{
    if (!mdiArea || expectedIndices.isEmpty() || mdiArea->subWindowList().isEmpty())
        return false;

    const QList<QMdiSubWindow *> subWindows = mdiArea->subWindowList();
    const QMdiSubWindow *const firstSubWindow = subWindows.at(0);

    switch (arrangement) {
    case Tiled:
    {
        // Calculate the number of rows and columns.
        const int n = subWindows.count();
        const int numColumns = qMax(qCeil(qSqrt(qreal(n))), 1);
        const int numRows = qMax((n % numColumns) ? (n / numColumns + 1) : (n / numColumns), 1);

        // Ensure that the geometry of all the subwindows are as expected by using
        // QWidget::childAt starting from the middle of the topleft cell and subsequently
        // adding rowWidth and rowHeight (going from left to right).
        const int columnWidth = mdiArea->viewport()->width() / numColumns;
        const int rowHeight = mdiArea->viewport()->height() / numRows;
        QPoint subWindowPos(columnWidth / 2, rowHeight / 2);
        for (int i = 0; i < numRows; ++i) {
            for (int j = 0; j < numColumns; ++j) {
                const int index = expectedIndices.at(i * numColumns + j);
                QWidget *actual = mdiArea->viewport()->childAt(subWindowPos);
                QMdiSubWindow *expected = subWindows.at(index);
                if (actual != expected && !expected->isAncestorOf(actual))
                    return false;
                subWindowPos.rx() += columnWidth;
            }
            subWindowPos.rx() = columnWidth / 2;
            subWindowPos.ry() += rowHeight;
        }
        break;
    }
    case Cascaded:
    {
        // Calculate the delta (dx, dy) between two cascaded subwindows.
        QStyleOptionTitleBar options;
        options.initFrom(firstSubWindow);
        int titleBarHeight = firstSubWindow->style()->pixelMetric(QStyle::PM_TitleBarHeight, &options);
#ifdef Q_WS_MAC
        // ### Remove this after the mac style has been fixed
        if (qobject_cast<QMacStyle *>(firstSubWindow->style()))
            titleBarHeight -= 4;
#endif
        const QFontMetrics fontMetrics = QFontMetrics(QApplication::font("QWorkspaceTitleBar"));
        const int dy = qMax(titleBarHeight - (titleBarHeight - fontMetrics.height()) / 2, 1);
        const int dx = 10;

        // Current activation/stacking order.
        const QList<QMdiSubWindow *> activationOrderList = mdiArea->subWindowList(QMdiArea::ActivationHistoryOrder);

        // Ensure that the geometry of all the subwindows are as expected by using
        // QWidget::childAt with the position of the first one and subsequently adding
        // dx and dy.
        QPoint subWindowPos(20, 5);
        foreach (int expectedIndex, expectedIndices) {
            QMdiSubWindow *expected = subWindows.at(expectedIndex);
            expected->raise();
            if (mdiArea->viewport()->childAt(subWindowPos) != expected)
                return false;
            expected->lower();
            subWindowPos.rx() += dx;
            subWindowPos.ry() += dy;
        }

        // Restore stacking order.
        foreach (QMdiSubWindow *subWindow, activationOrderList) {
            mdiArea->setActiveSubWindow(subWindow);
            qApp->processEvents();
        }
        break;
    }
    default:
        return false;
    }
    return true;
}

class tst_QMdiArea : public QObject
{
    Q_OBJECT
public:
    tst_QMdiArea();
public slots:
    void initTestCase();
protected slots:
    void activeChanged(QMdiSubWindow *child);

private slots:
    // Tests from QWorkspace
    void subWindowActivated_data();
    void subWindowActivated();
    void subWindowActivated2();
    void subWindowActivatedWithMinimize();
    void showWindows();
    void changeWindowTitle();
    void changeModified();
    void childSize();
    void fixedSize();
    // New tests
    void minimumSizeHint();
    void sizeHint();
    void setActiveSubWindow();
    void activeSubWindow();
    void currentSubWindow();
    void addAndRemoveWindows();
    void addAndRemoveWindowsWithReparenting();
    void removeSubWindow_2();
    void closeWindows();
    void activateNextAndPreviousWindow();
    void subWindowList_data();
    void subWindowList();
    void setBackground();
    void setViewport();
    void tileSubWindows();
    void cascadeAndTileSubWindows();
    void resizeMaximizedChildWindows_data();
    void resizeMaximizedChildWindows();
    void focusWidgetAfterAddSubWindow();
    void dontMaximizeSubWindowOnActivation();
    void delayedPlacement();
    void iconGeometryInMenuBar();
    void resizeTimer();
    void updateScrollBars();
    void setActivationOrder_data();
    void setActivationOrder();
    void tabBetweenSubWindows();
    void setViewMode();
    void setTabShape();
    void setTabPosition_data();
    void setTabPosition();
#if defined(Q_WS_WIN) || defined(Q_WS_X11)
    void nativeSubWindows();
#endif
    void task_209615();
    void task_236750();

private:
    QMdiSubWindow *activeWindow;
    bool accelPressed;
};

tst_QMdiArea::tst_QMdiArea()
    : activeWindow(0)
{
    qRegisterMetaType<QMdiSubWindow *>();
}

void tst_QMdiArea::initTestCase()
{
#ifdef Q_OS_WINCE //disable magic for WindowsCE
    qApp->setAutoMaximizeThreshold(-1);
#endif
}

// Old QWorkspace tests
void tst_QMdiArea::activeChanged(QMdiSubWindow *child)
{
    activeWindow = child;
}

void tst_QMdiArea::subWindowActivated_data()
{
    // define the test elements we're going to use
    QTest::addColumn<int>("count");

    // create a first testdata instance and fill it with data
    QTest::newRow( "data0" ) << 0;
    QTest::newRow( "data1" ) << 1;
    QTest::newRow( "data2" ) << 2;
}

void tst_QMdiArea::subWindowActivated()
{
    QMainWindow mw(0) ;
    mw.menuBar();
    QMdiArea *workspace = new QMdiArea(&mw);
    workspace->setObjectName(QLatin1String("testWidget"));
    mw.setCentralWidget(workspace);
    QSignalSpy spy(workspace, SIGNAL(subWindowActivated(QMdiSubWindow *)));
    connect( workspace, SIGNAL(subWindowActivated(QMdiSubWindow *)), this, SLOT(activeChanged(QMdiSubWindow *)));
    mw.show();
    qApp->setActiveWindow(&mw);

    QFETCH( int, count );
    int i;

    for ( i = 0; i < count; ++i ) {
        QWidget *widget = new QWidget(workspace, 0);
        widget->setAttribute(Qt::WA_DeleteOnClose);
        workspace->addSubWindow(widget)->show();
        widget->show();
        qApp->processEvents();
        QVERIFY( activeWindow == workspace->activeSubWindow() );
        QCOMPARE(spy.count(), 1);
        spy.clear();
    }

    QList<QMdiSubWindow *> windows = workspace->subWindowList();
    QCOMPARE( (int)windows.count(), count );

    for ( i = 0; i < count; ++i ) {
        QMdiSubWindow *window = windows.at(i);
        window->showMinimized();
        qApp->processEvents();
        QVERIFY( activeWindow == workspace->activeSubWindow() );
        if ( i == 1 )
            QVERIFY( activeWindow == window );
    }

    for ( i = 0; i < count; ++i ) {
        QMdiSubWindow *window = windows.at(i);
        window->showNormal();
        qApp->processEvents();
        QVERIFY( window == activeWindow );
        QVERIFY( activeWindow == workspace->activeSubWindow() );
    }
    spy.clear();

    while (workspace->activeSubWindow() ) {
        workspace->activeSubWindow()->close();
        qApp->processEvents();
        QVERIFY(activeWindow == workspace->activeSubWindow());
        QCOMPARE(spy.count(), 1);
        spy.clear();
    }

    QVERIFY(activeWindow == 0);
    QVERIFY(workspace->activeSubWindow() == 0);
    QCOMPARE(workspace->subWindowList().count(), 0);

    {
        workspace->hide();
        QWidget *widget = new QWidget(workspace);
        widget->setAttribute(Qt::WA_DeleteOnClose);
        QMdiSubWindow *window = workspace->addSubWindow(widget);
        widget->show();
        QCOMPARE(spy.count(), 0);
        workspace->show();
        QCOMPARE(spy.count(), 1);
        spy.clear();
        QVERIFY( activeWindow == window );
        window->close();
        qApp->processEvents();
        QCOMPARE(spy.count(), 1);
        spy.clear();
        QVERIFY( activeWindow == 0 );
    }

    {
        workspace->hide();
        QWidget *widget = new QWidget(workspace);
        widget->setAttribute(Qt::WA_DeleteOnClose);
        QMdiSubWindow *window = workspace->addSubWindow(widget);
        widget->showMaximized();
        qApp->sendPostedEvents();
        QCOMPARE(spy.count(), 0);
        spy.clear();
        workspace->show();
        QCOMPARE(spy.count(), 1);
        spy.clear();
        QVERIFY( activeWindow == window );
        window->close();
        qApp->processEvents();
        QCOMPARE(spy.count(), 1);
        spy.clear();
        QVERIFY( activeWindow == 0 );
    }

    {
        QWidget *widget = new QWidget(workspace);
        widget->setAttribute(Qt::WA_DeleteOnClose);
        QMdiSubWindow *window = workspace->addSubWindow(widget);
        widget->showMinimized();
        QCOMPARE(spy.count(), 1);
        spy.clear();
        QVERIFY( activeWindow == window );
        QVERIFY(workspace->activeSubWindow() == window);
        window->close();
        qApp->processEvents();
        QCOMPARE(spy.count(), 1);
        spy.clear();
        QVERIFY(workspace->activeSubWindow() == 0);
        QVERIFY( activeWindow == 0 );
    }
}

#ifdef Q_WS_MAC
#include <Security/AuthSession.h>
bool macHasAccessToWindowsServer()
{
    SecuritySessionId mySession;
    SessionAttributeBits sessionInfo;
    SessionGetInfo(callerSecuritySession, &mySession, &sessionInfo);
    return (sessionInfo & sessionHasGraphicAccess);
}
#endif


void tst_QMdiArea::subWindowActivated2()
{
    QMdiArea mdiArea;
    QSignalSpy spy(&mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow *)));
    for (int i = 0; i < 5; ++i)
        mdiArea.addSubWindow(new QWidget);
    QCOMPARE(spy.count(), 0);
    mdiArea.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#endif
    QTest::qWait(100);

    QTRY_COMPARE(spy.count(), 5);
    QCOMPARE(mdiArea.activeSubWindow(), mdiArea.subWindowList().back());
    spy.clear();

    // Just to make sure another widget is on top wrt. stacking order.
    // This will typically become the active window if things are broken.
    QMdiSubWindow *staysOnTopWindow = mdiArea.subWindowList().at(3);
    staysOnTopWindow->setWindowFlags(Qt::WindowStaysOnTopHint);
    mdiArea.setActiveSubWindow(staysOnTopWindow);
    QCOMPARE(spy.count(), 1);
    QCOMPARE(mdiArea.activeSubWindow(), staysOnTopWindow);
    spy.clear();

    QMdiSubWindow *activeSubWindow = mdiArea.subWindowList().at(2);
    mdiArea.setActiveSubWindow(activeSubWindow);
    QCOMPARE(spy.count(), 1);
    QCOMPARE(mdiArea.activeSubWindow(), activeSubWindow);
    spy.clear();

    // Check that we only emit _one_ signal and the active window
    // is unchanged after hide/show.
    mdiArea.hide();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#endif
    QTest::qWait(100);
    QTRY_COMPARE(spy.count(), 1);
    QVERIFY(!mdiArea.activeSubWindow());
    QCOMPARE(mdiArea.currentSubWindow(), activeSubWindow);
    spy.clear();

    mdiArea.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#endif
    QTest::qWait(100);
    QTRY_COMPARE(spy.count(), 1);
    QCOMPARE(mdiArea.activeSubWindow(), activeSubWindow);
    spy.clear();

    // Check that we only emit _one_ signal and the active window
    // is unchanged after showMinimized/showNormal.
    mdiArea.showMinimized();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#elif defined (Q_WS_MAC)
    if (!macHasAccessToWindowsServer())
        QEXPECT_FAIL("", "showMinimized doesn't really minimize if you don't have access to the server", Abort);
#endif
    QTest::qWait(10);
#if defined(Q_WS_QWS)
    QEXPECT_FAIL("", "task 168682", Abort);
#endif
#ifdef Q_OS_WINCE
    QSKIP("Not fixed yet. See Task 197453", SkipAll);
#endif
    QTRY_COMPARE(spy.count(), 1);
    QVERIFY(!mdiArea.activeSubWindow());
    QCOMPARE(mdiArea.currentSubWindow(), activeSubWindow);
    spy.clear();

    mdiArea.showNormal();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#endif
    QTest::qWait(100);
    QTRY_COMPARE(spy.count(), 1);
    QCOMPARE(mdiArea.activeSubWindow(), activeSubWindow);
    spy.clear();
}

void tst_QMdiArea::subWindowActivatedWithMinimize()
{
    QMainWindow mw(0) ;
    mw.menuBar();
    QMdiArea *workspace = new QMdiArea(&mw);
    workspace->setObjectName(QLatin1String("testWidget"));
    mw.setCentralWidget(workspace);
    QSignalSpy spy(workspace, SIGNAL(subWindowActivated(QMdiSubWindow *)));
    connect( workspace, SIGNAL(subWindowActivated(QMdiSubWindow *)), this, SLOT(activeChanged(QMdiSubWindow *)) );
    mw.show();
    qApp->setActiveWindow(&mw);
    QWidget *widget = new QWidget(workspace);
    widget->setAttribute(Qt::WA_DeleteOnClose);
    QMdiSubWindow *window1 = workspace->addSubWindow(widget);
    QWidget *widget2 = new QWidget(workspace);
    widget2->setAttribute(Qt::WA_DeleteOnClose);
    QMdiSubWindow *window2 = workspace->addSubWindow(widget2);

    widget->showMinimized();
    QVERIFY( activeWindow == window1 );
    widget2->showMinimized();
    QVERIFY( activeWindow == window2 );

    window2->close();
    qApp->processEvents();
    QVERIFY( activeWindow == window1 );

    window1->close();
    qApp->processEvents();
    QVERIFY(workspace->activeSubWindow() == 0);
    QVERIFY( activeWindow == 0 );

    QVERIFY( workspace->subWindowList().count() == 0 );
}

void tst_QMdiArea::showWindows()
{
    QMdiArea *ws = new QMdiArea( 0 );

    QWidget *widget = 0;
    ws->show();

    widget = new QWidget(ws);
    widget->show();
    QVERIFY( widget->isVisible() );

    widget = new QWidget(ws);
    widget->showMaximized();
    QVERIFY( widget->isMaximized() );
    widget->showNormal();
    QVERIFY( !widget->isMaximized() );

    widget = new QWidget(ws);
    widget->showMinimized();
    QVERIFY( widget->isMinimized() );
    widget->showNormal();
    QVERIFY( !widget->isMinimized() );

    ws->hide();

    widget = new QWidget(ws);
    ws->show();
    QVERIFY( widget->isVisible() );

    ws->hide();

    widget = new QWidget(ws);
    widget->showMaximized();
    QVERIFY( widget->isMaximized() );
    ws->show();
    QVERIFY( widget->isVisible() );
    QVERIFY( widget->isMaximized() );
    ws->hide();

    widget = new QWidget(ws);
    widget->showMinimized();
    ws->show();
    QVERIFY( widget->isMinimized() );
    ws->hide();

    delete ws;
}


//#define USE_SHOW

void tst_QMdiArea::changeWindowTitle()
{
    const QString mwc = QString::fromLatin1("MainWindow's Caption");
    const QString mwc2 = QString::fromLatin1("MainWindow's New Caption");
    const QString wc = QString::fromLatin1("Widget's Caption");
    const QString wc2 = QString::fromLatin1("Widget's New Caption");

    QMainWindow *mw = new QMainWindow;
    mw->setWindowTitle( mwc );
    QMdiArea *ws = new QMdiArea( mw );
    mw->setCentralWidget( ws );
    mw->menuBar();
    mw->show();
    QTest::qWaitForWindowShown(mw);

    QWidget *widget = new QWidget( ws );
    widget->setWindowTitle( wc );
    ws->addSubWindow(widget);

    QCOMPARE( mw->windowTitle(), mwc );

#ifdef USE_SHOW
    widget->showMaximized();
#else
    widget->setWindowState(Qt::WindowMaximized);
#endif
#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE)
    QTRY_COMPARE( mw->windowTitle(), QString::fromLatin1("%1 - [%2]").arg(mwc).arg(wc) );
#endif

    mw->hide();
    qApp->processEvents();
    mw->show();
    qApp->processEvents();
    QTest::qWaitForWindowShown(mw);

#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE)
    QTRY_COMPARE( mw->windowTitle(), QString::fromLatin1("%1 - [%2]").arg(mwc).arg(wc) );
#endif

#ifdef USE_SHOW
    widget->showNormal();
#else
    widget->setWindowState(Qt::WindowNoState);
#endif
    qApp->processEvents();
    QCOMPARE( mw->windowTitle(), mwc );

#ifdef USE_SHOW
    widget->showMaximized();
#else
    widget->setWindowState(Qt::WindowMaximized);
#endif
    qApp->processEvents();
#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE)
    QTRY_COMPARE( mw->windowTitle(), QString::fromLatin1("%1 - [%2]").arg(mwc).arg(wc) );
    widget->setWindowTitle( wc2 );
    QCOMPARE( mw->windowTitle(), QString::fromLatin1("%1 - [%2]").arg(mwc).arg(wc2) );
    mw->setWindowTitle( mwc2 );
    QCOMPARE( mw->windowTitle(), QString::fromLatin1("%1 - [%2]").arg(mwc2).arg(wc2) );
#endif

    mw->show();
    qApp->setActiveWindow(mw);

#ifdef USE_SHOW
    mw->showFullScreen();
#else
    mw->setWindowState(Qt::WindowFullScreen);
#endif

    qApp->processEvents();
#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE)
    QCOMPARE( mw->windowTitle(), QString::fromLatin1("%1 - [%2]").arg(mwc2).arg(wc2) );
#endif
#ifdef USE_SHOW
    widget->showNormal();
#else
    widget->setWindowState(Qt::WindowNoState);
#endif
    qApp->processEvents();
#if defined(Q_WS_MAC) || defined(Q_OS_WINCE)
    QCOMPARE(mw->windowTitle(), mwc);
#else
    QCOMPARE( mw->windowTitle(), mwc2 );
#endif

#ifdef USE_SHOW
    widget->showMaximized();
#else
    widget->setWindowState(Qt::WindowMaximized);
#endif
    qApp->processEvents();
#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE)
    QCOMPARE( mw->windowTitle(), QString::fromLatin1("%1 - [%2]").arg(mwc2).arg(wc2) );
#endif

#ifdef USE_SHOW
    mw->showNormal();
#else
    mw->setWindowState(Qt::WindowNoState);
#endif
    qApp->processEvents();
#ifdef USE_SHOW
    widget->showNormal();
#else
    widget->setWindowState(Qt::WindowNoState);
#endif

    delete mw;
}

void tst_QMdiArea::changeModified()
{
    const QString mwc = QString::fromLatin1("MainWindow's Caption");
    const QString wc = QString::fromLatin1("Widget's Caption[*]");

    QMainWindow *mw = new QMainWindow(0);
    mw->setWindowTitle( mwc );
    QMdiArea *ws = new QMdiArea( mw );
    mw->setCentralWidget( ws );
    mw->menuBar();
    mw->show();

    QWidget *widget = new QWidget( ws );
    widget->setWindowTitle( wc );
    ws->addSubWindow(widget);

    QCOMPARE( mw->isWindowModified(), false);
    QCOMPARE( widget->isWindowModified(), false);
    widget->setWindowState(Qt::WindowMaximized);
    QCOMPARE( mw->isWindowModified(), false);
    QCOMPARE( widget->isWindowModified(), false);

    widget->setWindowState(Qt::WindowNoState);
    QCOMPARE( mw->isWindowModified(), false);
    QCOMPARE( widget->isWindowModified(), false);

    widget->setWindowModified(true);
    QCOMPARE( mw->isWindowModified(), false);
    QCOMPARE( widget->isWindowModified(), true);
    widget->setWindowState(Qt::WindowMaximized);
#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE)
    QCOMPARE( mw->isWindowModified(), true);
#endif
    QCOMPARE( widget->isWindowModified(), true);

    widget->setWindowState(Qt::WindowNoState);
    QCOMPARE( mw->isWindowModified(), false);
    QCOMPARE( widget->isWindowModified(), true);

    widget->setWindowState(Qt::WindowMaximized);
#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE)
    QCOMPARE( mw->isWindowModified(), true);
#endif
    QCOMPARE( widget->isWindowModified(), true);

    widget->setWindowModified(false);
    QCOMPARE( mw->isWindowModified(), false);
    QCOMPARE( widget->isWindowModified(), false);

    widget->setWindowModified(true);
#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE)
    QCOMPARE( mw->isWindowModified(), true);
#endif
    QCOMPARE( widget->isWindowModified(), true);

    widget->setWindowState(Qt::WindowNoState);
    QCOMPARE( mw->isWindowModified(), false);
    QCOMPARE( widget->isWindowModified(), true);

    delete mw;
}

class MyChild : public QWidget
{
public:
    MyChild(QWidget *parent = 0) : QWidget(parent) {}
    QSize sizeHint() const { return QSize(234, 123); }
};

void tst_QMdiArea::childSize()
{
    QMdiArea ws;

    MyChild *child = new MyChild(&ws);
    child->show();
    QCOMPARE(child->size(), child->sizeHint());
    delete child;

    child = new MyChild(&ws);
    child->setFixedSize(200, 200);
    child->show();
    QCOMPARE(child->size(), child->minimumSize());
    delete child;

    child = new MyChild(&ws);
    child->resize(150, 150);
    child->show();
    QCOMPARE(child->size(), QSize(150,150));
    delete child;
}

void tst_QMdiArea::fixedSize()
{
    QMdiArea *ws = new QMdiArea;
    int i;

    ws->resize(500, 500);
//     ws->show();

    QSize fixed(300, 300);
    for (i = 0; i < 4; ++i) {
        QWidget *child = new QWidget(ws);
        child->setFixedSize(fixed);
        child->show();
    }

    QList<QMdiSubWindow *> windows = ws->subWindowList();
    for (i = 0; i < (int)windows.count(); ++i) {
        QMdiSubWindow *child = windows.at(i);
        QCOMPARE(child->size(), fixed);
    }

    ws->cascadeSubWindows();
    ws->resize(800, 800);
    for (i = 0; i < (int)windows.count(); ++i) {
        QMdiSubWindow *child = windows.at(i);
        QCOMPARE(child->size(), fixed);
    }
    ws->resize(500, 500);

    ws->tileSubWindows();
    ws->resize(800, 800);
    for (i = 0; i < (int)windows.count(); ++i) {
        QMdiSubWindow *child = windows.at(i);
        QCOMPARE(child->size(), fixed);
    }
    ws->resize(500, 500);

    for (i = 0; i < (int)windows.count(); ++i) {
        QMdiSubWindow *child = windows.at(i);
        delete child;
    }

    delete ws;
}

class LargeWidget : public QWidget
{
public:
    LargeWidget(QWidget *parent = 0) : QWidget(parent) {}
    QSize sizeHint() const { return QSize(1280, 1024); }
    QSize minimumSizeHint() const { return QSize(300, 300); }
};

// New tests
void tst_QMdiArea::minimumSizeHint()
{
    QMdiArea workspace;
    workspace.show();
    QSize expectedSize(workspace.style()->pixelMetric(QStyle::PM_MDIMinimizedWidth),
                       workspace.style()->pixelMetric(QStyle::PM_TitleBarHeight));
    qApp->processEvents();
    QAbstractScrollArea dummyScrollArea;
    dummyScrollArea.setFrameStyle(QFrame::NoFrame);
    expectedSize = expectedSize.expandedTo(dummyScrollArea.minimumSizeHint());
    QCOMPARE(workspace.minimumSizeHint(), expectedSize.expandedTo(qApp->globalStrut()));

    QWidget *window = workspace.addSubWindow(new QWidget);
    qApp->processEvents();
    window->show();
    QCOMPARE(workspace.minimumSizeHint(), expectedSize.expandedTo(window->minimumSizeHint()));

    QMdiSubWindow *subWindow = workspace.addSubWindow(new LargeWidget);
    subWindow->show();
    QCOMPARE(workspace.minimumSizeHint(), expectedSize.expandedTo(subWindow->minimumSizeHint()));

    workspace.setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
    workspace.setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
    QCOMPARE(workspace.minimumSizeHint(), expectedSize);
}

void tst_QMdiArea::sizeHint()
{
    QMdiArea workspace;
    workspace.show();
    QSize desktopSize = QApplication::desktop()->size();
    QSize expectedSize(desktopSize.width() * 2/3, desktopSize.height() * 2/3);
    QCOMPARE(workspace.sizeHint(), expectedSize.expandedTo(qApp->globalStrut()));

    QWidget *window = workspace.addSubWindow(new QWidget);
    qApp->processEvents();
    window->show();
    QCOMPARE(workspace.sizeHint(), expectedSize.expandedTo(window->sizeHint()));

    QMdiSubWindow *nested = workspace.addSubWindow(new QMdiArea);
    expectedSize = QSize(desktopSize.width() * 2/6, desktopSize.height() * 2/6);
    QCOMPARE(nested->widget()->sizeHint(), expectedSize);
}

void tst_QMdiArea::setActiveSubWindow()
{
    QMdiArea workspace;
    workspace.show();

    QSignalSpy spy(&workspace, SIGNAL(subWindowActivated(QMdiSubWindow *)));
    connect(&workspace, SIGNAL(subWindowActivated(QMdiSubWindow *)), this, SLOT(activeChanged(QMdiSubWindow *)));
    qApp->setActiveWindow(&workspace);

    // Activate hidden windows
    const int windowCount = 10;
    QMdiSubWindow *windows[windowCount];
    for (int i = 0; i < windowCount; ++i) {
        windows[i] = qobject_cast<QMdiSubWindow *>(workspace.addSubWindow(new QWidget));
        qApp->processEvents();
        QVERIFY(windows[i]->isHidden());
        workspace.setActiveSubWindow(windows[i]);
    }
    QCOMPARE(spy.count(), 0);
    QVERIFY(!activeWindow);
    spy.clear();

    // Activate visible windows
    for (int i = 0; i < windowCount; ++i) {
        windows[i]->show();
        QVERIFY(!windows[i]->isHidden());
        workspace.setActiveSubWindow(windows[i]);
        qApp->processEvents();
        QCOMPARE(spy.count(), 1);
        QCOMPARE(activeWindow, windows[i]);
        spy.clear();
    }

    // Deactivate active window
    QCOMPARE(workspace.activeSubWindow(), windows[windowCount - 1]);
    workspace.setActiveSubWindow(0);
    QCOMPARE(spy.count(), 1);
    QVERIFY(!activeWindow);
    QVERIFY(!workspace.activeSubWindow());

    // Activate widget which is not child of any window inside workspace
    QMdiSubWindow fakeWindow;
    QTest::ignoreMessage(QtWarningMsg, "QMdiArea::setActiveSubWindow: window is not inside workspace");
    workspace.setActiveSubWindow(&fakeWindow);

}

void tst_QMdiArea::activeSubWindow()
{
    QMainWindow mainWindow;

    QMdiArea *mdiArea = new QMdiArea;
    QLineEdit *subWindowLineEdit = new QLineEdit;
    QMdiSubWindow *subWindow = mdiArea->addSubWindow(subWindowLineEdit);
    mainWindow.setCentralWidget(mdiArea);

    QDockWidget *dockWidget = new QDockWidget(QLatin1String("Dock Widget"), &mainWindow);
    dockWidget->setAllowedAreas(Qt::LeftDockWidgetArea);
    QLineEdit *dockWidgetLineEdit = new QLineEdit;
    dockWidget->setWidget(dockWidgetLineEdit);
    mainWindow.addDockWidget(Qt::LeftDockWidgetArea, dockWidget);

    mainWindow.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mainWindow);
#endif

    qApp->setActiveWindow(&mainWindow);
    QCOMPARE(mdiArea->activeSubWindow(), subWindow);
    QCOMPARE(qApp->focusWidget(), (QWidget *)subWindowLineEdit);

    dockWidgetLineEdit->setFocus();
    QCOMPARE(qApp->focusWidget(), (QWidget *)dockWidgetLineEdit);
    QCOMPARE(mdiArea->activeSubWindow(), subWindow);

    QEvent deactivateEvent(QEvent::WindowDeactivate);
    qApp->sendEvent(subWindow, &deactivateEvent);
    QVERIFY(!mdiArea->activeSubWindow());
    QCOMPARE(qApp->focusWidget(), (QWidget *)dockWidgetLineEdit);

    QEvent activateEvent(QEvent::WindowActivate);
    qApp->sendEvent(subWindow, &activateEvent);
    QCOMPARE(mdiArea->activeSubWindow(), subWindow);
    QCOMPARE(qApp->focusWidget(), (QWidget *)subWindowLineEdit);

    QLineEdit dummyTopLevel;
    dummyTopLevel.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&dummyTopLevel);
#endif

    qApp->setActiveWindow(&dummyTopLevel);
    QCOMPARE(mdiArea->activeSubWindow(), subWindow);

    qApp->setActiveWindow(&mainWindow);
    QCOMPARE(mdiArea->activeSubWindow(), subWindow);

#if !defined(Q_WS_MAC) && !defined(Q_WS_WIN)
    qApp->setActiveWindow(0);
    QVERIFY(!mdiArea->activeSubWindow());
#endif

    //task 202657
    dockWidgetLineEdit->setFocus();
    qApp->setActiveWindow(&mainWindow);
    QVERIFY(dockWidgetLineEdit->hasFocus());
}

void tst_QMdiArea::currentSubWindow()
{
    QMdiArea mdiArea;
    mdiArea.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#endif

    for (int i = 0; i < 5; ++i)
        mdiArea.addSubWindow(new QLineEdit)->show();

    qApp->setActiveWindow(&mdiArea);
    QCOMPARE(qApp->activeWindow(), (QWidget *)&mdiArea);

    // Check that the last added window is the active and the current.
    QMdiSubWindow *active = mdiArea.activeSubWindow();
    QVERIFY(active);
    QCOMPARE(mdiArea.subWindowList().back(), active);
    QCOMPARE(mdiArea.currentSubWindow(), active);

    QLineEdit dummyTopLevel;
    dummyTopLevel.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&dummyTopLevel);
#endif

    // Move focus to another top-level and check that we still
    // have an active window.
    qApp->setActiveWindow(&dummyTopLevel);
    QCOMPARE(qApp->activeWindow(), (QWidget *)&dummyTopLevel);
    QVERIFY(mdiArea.activeSubWindow());

    delete active;
    active = 0;

    // We just deleted the current sub-window -> current should then
    // be the next in list (which in this case is the first sub-window).
    QVERIFY(mdiArea.currentSubWindow());
    QCOMPARE(mdiArea.currentSubWindow(), mdiArea.subWindowList().front());

    // Activate mdi area and check that active == current.
    qApp->setActiveWindow(&mdiArea);
    active = mdiArea.activeSubWindow();
    QVERIFY(active);
    QCOMPARE(mdiArea.activeSubWindow(), mdiArea.subWindowList().front());

    active->hide();
    QCOMPARE(mdiArea.activeSubWindow(), active);
    QCOMPARE(mdiArea.currentSubWindow(), active);

    qApp->setActiveWindow(&dummyTopLevel);
    QVERIFY(mdiArea.activeSubWindow());
    QCOMPARE(mdiArea.currentSubWindow(), active);

    qApp->setActiveWindow(&mdiArea);
    active->show();
    QCOMPARE(mdiArea.activeSubWindow(), active);

    mdiArea.setActiveSubWindow(0);
    QVERIFY(!mdiArea.activeSubWindow());
    QVERIFY(!mdiArea.currentSubWindow());

    mdiArea.setActiveSubWindow(active);
    QCOMPARE(mdiArea.activeSubWindow(), active);
    QEvent windowDeactivate(QEvent::WindowDeactivate);
    qApp->sendEvent(active, &windowDeactivate);
    QVERIFY(!mdiArea.activeSubWindow());
    QVERIFY(!mdiArea.currentSubWindow());

    QEvent windowActivate(QEvent::WindowActivate);
    qApp->sendEvent(active, &windowActivate);
    QVERIFY(mdiArea.activeSubWindow());
    QVERIFY(mdiArea.currentSubWindow());

#if !defined(Q_WS_MAC) && !defined(Q_WS_WIN)
    qApp->setActiveWindow(0);
    QVERIFY(!mdiArea.activeSubWindow());
    QVERIFY(mdiArea.currentSubWindow());
#endif
}

void tst_QMdiArea::addAndRemoveWindows()
{
    QMdiArea workspace;
    workspace.resize(800, 600);
    workspace.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&workspace);
#endif

    { // addSubWindow with large widget
    QCOMPARE(workspace.subWindowList().count(), 0);
    QWidget *window = workspace.addSubWindow(new LargeWidget);
    QVERIFY(window);
    qApp->processEvents();
    QCOMPARE(workspace.subWindowList().count(), 1);
    QVERIFY(window->windowFlags() == DefaultWindowFlags);
    QCOMPARE(window->size(), workspace.viewport()->size());
    }

    { // addSubWindow, minimumSize set.
    QMdiSubWindow *window = new QMdiSubWindow;
    window->setMinimumSize(900, 900);
    workspace.addSubWindow(window);
    QVERIFY(window);
    qApp->processEvents();
    QCOMPARE(workspace.subWindowList().count(), 2);
    QVERIFY(window->windowFlags() == DefaultWindowFlags);
    QCOMPARE(window->size(), window->minimumSize());
    }

    { // addSubWindow, resized
    QMdiSubWindow *window = new QMdiSubWindow;
    window->setWidget(new QWidget);
    window->resize(1500, 1500);
    workspace.addSubWindow(window);
    QVERIFY(window);
    qApp->processEvents();
    QCOMPARE(workspace.subWindowList().count(), 3);
    QVERIFY(window->windowFlags() == DefaultWindowFlags);
    QCOMPARE(window->size(), QSize(1500, 1500));
    }

    { // addSubWindow with 0 pointer
    QTest::ignoreMessage(QtWarningMsg, "QMdiArea::addSubWindow: null pointer to widget");
    QWidget *window = workspace.addSubWindow(0);
    QVERIFY(!window);
    QCOMPARE(workspace.subWindowList().count(), 3);
    }

    { // addChildWindow
    QMdiSubWindow *window = new QMdiSubWindow;
    workspace.addSubWindow(window);
    qApp->processEvents();
    QVERIFY(window->windowFlags() == DefaultWindowFlags);
    window->setWidget(new QWidget);
    QCOMPARE(workspace.subWindowList().count(), 4);
    QTest::ignoreMessage(QtWarningMsg, "QMdiArea::addSubWindow: window is already added");
    workspace.addSubWindow(window);
    }

    { // addChildWindow with 0 pointer
    QTest::ignoreMessage(QtWarningMsg, "QMdiArea::addSubWindow: null pointer to widget");
    workspace.addSubWindow(0);
    QCOMPARE(workspace.subWindowList().count(), 4);
    }

    // removeSubWindow
    foreach (QWidget *window, workspace.subWindowList()) {
        workspace.removeSubWindow(window);
        delete window;
    }
    QCOMPARE(workspace.subWindowList().count(), 0);

    // removeSubWindow with 0 pointer
    QTest::ignoreMessage(QtWarningMsg, "QMdiArea::removeSubWindow: null pointer to widget");
    workspace.removeSubWindow(0);

    workspace.addSubWindow(new QPushButton(QLatin1String("Dummy to make workspace non-empty")));
    qApp->processEvents();
    QCOMPARE(workspace.subWindowList().count(), 1);

    // removeSubWindow with window not inside workspace
    QTest::ignoreMessage(QtWarningMsg,"QMdiArea::removeSubWindow: window is not inside workspace");
    QMdiSubWindow *fakeWindow = new QMdiSubWindow;
    workspace.removeSubWindow(fakeWindow);
    delete fakeWindow;

    // Check that newly added windows don't occupy maximized windows'
    // restore space.
    workspace.closeAllSubWindows();
    workspace.setOption(QMdiArea::DontMaximizeSubWindowOnActivation);
    workspace.show();
    QMdiSubWindow *window1 = workspace.addSubWindow(new QWidget);
    window1->show();
    const QRect window1RestoreGeometry = window1->geometry();
    QCOMPARE(window1RestoreGeometry.topLeft(), QPoint(0, 0));

    window1->showMinimized();

    // Occupy space.
    QMdiSubWindow *window2 = workspace.addSubWindow(new QWidget);
    window2->show();
    const QRect window2RestoreGeometry = window2->geometry();
    QCOMPARE(window2RestoreGeometry.topLeft(), QPoint(0, 0));

    window2->showMaximized();

    // Don't occupy space.
    QMdiSubWindow *window3 = workspace.addSubWindow(new QWidget);
    window3->show();
    QCOMPARE(window3->geometry().topLeft(), QPoint(window2RestoreGeometry.right() + 1, 0));
}

void tst_QMdiArea::addAndRemoveWindowsWithReparenting()
{
    QMdiArea workspace;
    QMdiSubWindow window(&workspace);
    QVERIFY(window.windowFlags() == DefaultWindowFlags);

    // 0 because the window list contains widgets and not actual
    // windows. Silly, but that's the behavior.
    QCOMPARE(workspace.subWindowList().count(), 0);
    window.setWidget(new QWidget);
    qApp->processEvents();

    QCOMPARE(workspace.subWindowList().count(), 1);
    window.setParent(0); // Will also reset window flags
    QCOMPARE(workspace.subWindowList().count(), 0);
    window.setParent(&workspace);
    QCOMPARE(workspace.subWindowList().count(), 1);
    QVERIFY(window.windowFlags() == DefaultWindowFlags);

    QTest::ignoreMessage(QtWarningMsg, "QMdiArea::addSubWindow: window is already added");
    workspace.addSubWindow(&window);
    QCOMPARE(workspace.subWindowList().count(), 1);
}

class MySubWindow : public QMdiSubWindow
{
public:
    using QObject::receivers;
};

static int numberOfConnectedSignals(MySubWindow *subWindow)
{
    if (!subWindow)
        return 0;

    int numConnectedSignals = 0;
    for (int i = 0; i < subWindow->metaObject()->methodCount(); ++i) {
        QMetaMethod method = subWindow->metaObject()->method(i);
        if (method.methodType() == QMetaMethod::Signal) {
            QString signature(QLatin1String("2"));
            signature += QLatin1String(method.signature());
            numConnectedSignals += subWindow->receivers(signature.toLatin1());
        }
    }
    return numConnectedSignals;
}

void tst_QMdiArea::removeSubWindow_2()
{
    QMdiArea mdiArea;
    MySubWindow *subWindow = new MySubWindow;
    QCOMPARE(numberOfConnectedSignals(subWindow), 0);

    // Connected to aboutToActivate() and windowStateChanged().
    mdiArea.addSubWindow(subWindow);
    QVERIFY(numberOfConnectedSignals(subWindow) >= 2);

    // Ensure we disconnect from all signals.
    mdiArea.removeSubWindow(subWindow);
    QCOMPARE(numberOfConnectedSignals(subWindow), 0);

    mdiArea.addSubWindow(subWindow);
    QVERIFY(numberOfConnectedSignals(subWindow) >= 2);
    subWindow->setParent(0);
    QCOMPARE(numberOfConnectedSignals(subWindow), 0);
}

void tst_QMdiArea::closeWindows()
{
    QMdiArea workspace;
    workspace.show();
    qApp->setActiveWindow(&workspace);

    // Close widget
    QWidget *widget = new QWidget;
    QMdiSubWindow *subWindow = workspace.addSubWindow(widget);
    qApp->processEvents();
    QCOMPARE(workspace.subWindowList().count(), 1);
    subWindow->close();
    QCOMPARE(workspace.subWindowList().count(), 0);

    // Close window
    QWidget *window = workspace.addSubWindow(new QWidget);
    qApp->processEvents();
    QCOMPARE(workspace.subWindowList().count(), 1);
    window->close();
    qApp->processEvents();
    QCOMPARE(workspace.subWindowList().count(), 0);

    const int windowCount = 10;

    // Close active window
    for (int i = 0; i < windowCount; ++i)
        workspace.addSubWindow(new QWidget)->show();
    qApp->processEvents();
    QCOMPARE(workspace.subWindowList().count(), windowCount);
    int activeSubWindowCount = 0;
    while (workspace.activeSubWindow()) {
        workspace.activeSubWindow()->close();
        qApp->processEvents();
        ++activeSubWindowCount;
    }
    QCOMPARE(activeSubWindowCount, windowCount);
    QCOMPARE(workspace.subWindowList().count(), 0);

    // Close all windows
    for (int i = 0; i < windowCount; ++i)
        workspace.addSubWindow(new QWidget)->show();
    qApp->processEvents();
    QCOMPARE(workspace.subWindowList().count(), windowCount);
    QSignalSpy spy(&workspace, SIGNAL(subWindowActivated(QMdiSubWindow *)));
    connect(&workspace, SIGNAL(subWindowActivated(QMdiSubWindow *)), this, SLOT(activeChanged(QMdiSubWindow *)));
    workspace.closeAllSubWindows();
    qApp->processEvents();
    QCOMPARE(workspace.subWindowList().count(), 0);
    QCOMPARE(spy.count(), 1);
    QVERIFY(!activeWindow);
}

void tst_QMdiArea::activateNextAndPreviousWindow()
{
    QMdiArea workspace;
    workspace.show();
    qApp->setActiveWindow(&workspace);

    const int windowCount = 10;
    QMdiSubWindow *windows[windowCount];
    for (int i = 0; i < windowCount; ++i) {
        windows[i] = qobject_cast<QMdiSubWindow *>(workspace.addSubWindow(new QWidget));
        windows[i]->show();
        qApp->processEvents();
    }

    QSignalSpy spy(&workspace, SIGNAL(subWindowActivated(QMdiSubWindow *)));
    connect(&workspace, SIGNAL(subWindowActivated(QMdiSubWindow *)), this, SLOT(activeChanged(QMdiSubWindow *)));

    // activateNextSubWindow
    for (int i = 0; i < windowCount; ++i) {
        workspace.activateNextSubWindow();
        qApp->processEvents();
        QCOMPARE(workspace.activeSubWindow(), windows[i]);
        QCOMPARE(spy.count(), 1);
        spy.clear();
    }
    QVERIFY(activeWindow);
    QCOMPARE(workspace.activeSubWindow(), windows[windowCount - 1]);
    QCOMPARE(workspace.activeSubWindow(), activeWindow);

    // activatePreviousSubWindow
    for (int i = windowCount - 2; i >= 0; --i) {
        workspace.activatePreviousSubWindow();
        qApp->processEvents();
        QCOMPARE(workspace.activeSubWindow(), windows[i]);
        QCOMPARE(spy.count(), 1);
        spy.clear();
        if (i % 2 == 0)
            windows[i]->hide(); // 10, 8, 6, 4, 2, 0
    }
    QVERIFY(activeWindow);
    QCOMPARE(workspace.activeSubWindow(), windows[0]);
    QCOMPARE(workspace.activeSubWindow(), activeWindow);

    // activateNextSubWindow with every 2nd window hidden
    for (int i = 0; i < windowCount / 2; ++i) {
        workspace.activateNextSubWindow(); // 1, 3, 5, 7, 9
        QCOMPARE(spy.count(), 1);
        spy.clear();
    }
    QCOMPARE(workspace.activeSubWindow(), windows[windowCount - 1]);

    // activatePreviousSubWindow with every 2nd window hidden
    for (int i = 0; i < windowCount / 2; ++i) {
        workspace.activatePreviousSubWindow(); // 7, 5, 3, 1, 9
        QCOMPARE(spy.count(), 1);
        spy.clear();
    }
    QCOMPARE(workspace.activeSubWindow(), windows[windowCount - 1]);

    workspace.setActiveSubWindow(0);
    QVERIFY(!activeWindow);
}

void tst_QMdiArea::subWindowList_data()
{
    QTest::addColumn<QMdiArea::WindowOrder>("windowOrder");
    QTest::addColumn<int>("windowCount");
    QTest::addColumn<int>("activeSubWindow");
    QTest::addColumn<int>("staysOnTop1");
    QTest::addColumn<int>("staysOnTop2");

    QTest::newRow("CreationOrder") << QMdiArea::CreationOrder << 10 << 4 << 8 << 5;
    QTest::newRow("StackingOrder") << QMdiArea::StackingOrder << 10 << 6 << 3 << 9;
    QTest::newRow("ActivationHistoryOrder") << QMdiArea::ActivationHistoryOrder << 10 << 7 << 2 << 1;
}
void tst_QMdiArea::subWindowList()
{
    QFETCH(QMdiArea::WindowOrder, windowOrder);
    QFETCH(int, windowCount);
    QFETCH(int, activeSubWindow);
    QFETCH(int, staysOnTop1);
    QFETCH(int, staysOnTop2);

    QMdiArea workspace;
    workspace.show();
    qApp->setActiveWindow(&workspace);

    QList<QMdiSubWindow *> activationOrder;
    QVector<QMdiSubWindow *> windows;
    for (int i = 0; i < windowCount; ++i) {
        windows.append(qobject_cast<QMdiSubWindow *>(workspace.addSubWindow(new QWidget)));
        windows[i]->show();
        activationOrder.append(windows[i]);
    }

    {
    QList<QMdiSubWindow *> widgets = workspace.subWindowList(windowOrder);
    QCOMPARE(widgets.count(), windowCount);
    for (int i = 0; i < widgets.count(); ++i)
        QCOMPARE(widgets.at(i), windows[i]);
    }

    windows[staysOnTop1]->setWindowFlags(windows[staysOnTop1]->windowFlags() | Qt::WindowStaysOnTopHint);
    workspace.setActiveSubWindow(windows[activeSubWindow]);
    qApp->processEvents();
    QCOMPARE(workspace.activeSubWindow(), windows[activeSubWindow]);
    activationOrder.move(activationOrder.indexOf(windows[activeSubWindow]), windowCount - 1);

    QList<QMdiSubWindow *> subWindows = workspace.subWindowList(windowOrder);
    if (windowOrder == QMdiArea::CreationOrder) {
        QCOMPARE(subWindows.at(activeSubWindow), windows[activeSubWindow]);
        QCOMPARE(subWindows.at(staysOnTop1), windows[staysOnTop1]);
        for (int i = 0; i < windowCount; ++i)
            QCOMPARE(subWindows.at(i), windows[i]);
        return;
    }

    if (windowOrder == QMdiArea::StackingOrder) {
        QCOMPARE(subWindows.at(subWindows.count() - 1), windows[staysOnTop1]);
        QCOMPARE(subWindows.at(subWindows.count() - 2), windows[activeSubWindow]);
        QCOMPARE(subWindows.count(), windowCount);
    } else { // ActivationHistoryOrder
        QCOMPARE(subWindows, activationOrder);
    }

    windows[staysOnTop2]->setWindowFlags(windows[staysOnTop2]->windowFlags() | Qt::WindowStaysOnTopHint);
    workspace.setActiveSubWindow(windows[staysOnTop2]);
    qApp->processEvents();
    QCOMPARE(workspace.activeSubWindow(), windows[staysOnTop2]);
    activationOrder.move(activationOrder.indexOf(windows[staysOnTop2]), windowCount - 1);

    workspace.setActiveSubWindow(windows[activeSubWindow]);
    qApp->processEvents();
    QCOMPARE(workspace.activeSubWindow(), windows[activeSubWindow]);
    activationOrder.move(activationOrder.indexOf(windows[activeSubWindow]), windowCount - 1);

    QList<QMdiSubWindow *> widgets = workspace.subWindowList(windowOrder);
    QCOMPARE(widgets.count(), windowCount);
    if (windowOrder == QMdiArea::StackingOrder) {
        QCOMPARE(widgets.at(widgets.count() - 1), windows[staysOnTop2]);
        QCOMPARE(widgets.at(widgets.count() - 2), windows[staysOnTop1]);
        QCOMPARE(widgets.at(widgets.count() - 3), windows[activeSubWindow]);
    } else { // ActivationHistory
        QCOMPARE(widgets, activationOrder);
    }

    windows[activeSubWindow]->raise();
    windows[staysOnTop2]->lower();

    widgets = workspace.subWindowList(windowOrder);
    if (windowOrder == QMdiArea::StackingOrder) {
        QCOMPARE(widgets.at(widgets.count() - 1), windows[activeSubWindow]);
        QCOMPARE(widgets.at(widgets.count() - 2), windows[staysOnTop1]);
        QCOMPARE(widgets.at(0), windows[staysOnTop2]);
    } else { // ActivationHistoryOrder
        QCOMPARE(widgets, activationOrder);
    }

    windows[activeSubWindow]->stackUnder(windows[staysOnTop1]);
    windows[staysOnTop2]->raise();

    widgets = workspace.subWindowList(windowOrder);
    if (windowOrder == QMdiArea::StackingOrder) {
        QCOMPARE(widgets.at(widgets.count() - 1), windows[staysOnTop2]);
        QCOMPARE(widgets.at(widgets.count() - 2), windows[staysOnTop1]);
        QCOMPARE(widgets.at(widgets.count() - 3), windows[activeSubWindow]);
    } else { // ActivationHistoryOrder
        QCOMPARE(widgets, activationOrder);
    }

    workspace.setActiveSubWindow(windows[staysOnTop1]);
    activationOrder.move(activationOrder.indexOf(windows[staysOnTop1]), windowCount - 1);

    widgets = workspace.subWindowList(windowOrder);
    if (windowOrder == QMdiArea::StackingOrder) {
        QCOMPARE(widgets.at(widgets.count() - 1), windows[staysOnTop1]);
        QCOMPARE(widgets.at(widgets.count() - 2), windows[staysOnTop2]);
        QCOMPARE(widgets.at(widgets.count() - 3), windows[activeSubWindow]);
    } else { // ActivationHistoryOrder
        QCOMPARE(widgets, activationOrder);
    }
}

void tst_QMdiArea::setBackground()
{
    QMdiArea workspace;
    QCOMPARE(workspace.background(), workspace.palette().brush(QPalette::Dark));
    workspace.setBackground(QBrush(Qt::green));
    QCOMPARE(workspace.background(), QBrush(Qt::green));
}

void tst_QMdiArea::setViewport()
{
    QMdiArea workspace;
    workspace.show();

    QWidget *firstViewport = workspace.viewport();
    QVERIFY(firstViewport);

    const int windowCount = 10;
    for (int i = 0; i < windowCount; ++i) {
        QMdiSubWindow *window = workspace.addSubWindow(new QWidget);
        window->show();
        if (i % 2 == 0) {
            window->showMinimized();
            QVERIFY(window->isMinimized());
        } else {
            window->showMaximized();
            QVERIFY(window->isMaximized());
        }
    }

    qApp->processEvents();
    QList<QMdiSubWindow *> windowsBeforeViewportChange = workspace.subWindowList();
    QCOMPARE(windowsBeforeViewportChange.count(), windowCount);

    workspace.setViewport(new QWidget);
    qApp->processEvents();
    QVERIFY(workspace.viewport() != firstViewport);

    QList<QMdiSubWindow *> windowsAfterViewportChange = workspace.subWindowList();
    QCOMPARE(windowsAfterViewportChange.count(), windowCount);
    QCOMPARE(windowsAfterViewportChange, windowsBeforeViewportChange);

    //    for (int i = 0; i < windowCount; ++i) {
    //        QMdiSubWindow *window = windowsAfterViewportChange.at(i);
    //        if (i % 2 == 0)
    //            QVERIFY(!window->isMinimized());
    //else
    //    QVERIFY(!window->isMaximized());
    //    }

    QTest::ignoreMessage(QtWarningMsg, "QMdiArea: Deleting the view port is undefined, "
                                       "use setViewport instead.");
    delete workspace.viewport();
    qApp->processEvents();

    QCOMPARE(workspace.subWindowList().count(), 0);
    QVERIFY(!workspace.activeSubWindow());
}

void tst_QMdiArea::tileSubWindows()
{
    QMdiArea workspace;
    workspace.resize(600,480);
    workspace.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&workspace);
#endif

    const int windowCount = 10;
    for (int i = 0; i < windowCount; ++i) {
        QMdiSubWindow *subWindow = workspace.addSubWindow(new QWidget);
        subWindow->setMinimumSize(50, 30);
        subWindow->show();
    }
    workspace.tileSubWindows();
    workspace.setActiveSubWindow(0);
    QCOMPARE(workspace.viewport()->childrenRect(), workspace.viewport()->rect());

    QList<QMdiSubWindow *> windows = workspace.subWindowList();
    for (int i = 0; i < windowCount; ++i) {
        QMdiSubWindow *window = windows.at(i);
        for (int j = 0; j < windowCount; ++j) {
            if (i == j)
                continue;
            QVERIFY(!window->geometry().intersects(windows.at(j)->geometry()));
        }
    }

    // Keep the views tiled through any subsequent resize events.
    for (int i = 0; i < 5; ++i) {
        workspace.resize(workspace.size() - QSize(10, 10));
        qApp->processEvents();
    }
    workspace.setActiveSubWindow(0);
#ifndef Q_OS_WINCE //See Task 197453 ToDo
    QCOMPARE(workspace.viewport()->childrenRect(), workspace.viewport()->rect());
#endif

    QMdiSubWindow *window = windows.at(0);

    // Change the geometry of one of the children and verify
    // that the views are not tiled anymore.
    window->move(window->x() + 1, window->y());
    workspace.resize(workspace.size() - QSize(10, 10));
    workspace.setActiveSubWindow(0);
    QVERIFY(workspace.viewport()->childrenRect() != workspace.viewport()->rect());
    qApp->processEvents();

    // Re-tile.
    workspace.tileSubWindows();
    workspace.setActiveSubWindow(0);
    QCOMPARE(workspace.viewport()->childrenRect(), workspace.viewport()->rect());

    // Close one of the children and verify that the views
    // are not tiled anymore.
    window->close();
    workspace.resize(workspace.size() - QSize(10, 10));
    workspace.setActiveSubWindow(0);
    QVERIFY(workspace.viewport()->childrenRect() != workspace.viewport()->rect());
    qApp->processEvents();

    // Re-tile.
    workspace.tileSubWindows();
    workspace.setActiveSubWindow(0);
    QCOMPARE(workspace.viewport()->childrenRect(), workspace.viewport()->rect());

    window = windows.at(1);

    // Maximize one of the children and verify that the views
    // are not tiled anymore.
    workspace.tileSubWindows();
    window->showMaximized();
    workspace.resize(workspace.size() - QSize(10, 10));
    workspace.setActiveSubWindow(0);
    QVERIFY(workspace.viewport()->childrenRect() != workspace.viewport()->rect());
    qApp->processEvents();

    // Re-tile.
    workspace.tileSubWindows();
    workspace.setActiveSubWindow(0);
    QCOMPARE(workspace.viewport()->childrenRect(), workspace.viewport()->rect());

    // Minimize one of the children and verify that the views
    // are not tiled anymore.
    workspace.tileSubWindows();
    window->showMinimized();
    workspace.resize(workspace.size() - QSize(10, 10));
    workspace.setActiveSubWindow(0);
    QVERIFY(workspace.viewport()->childrenRect() != workspace.viewport()->rect());
    qApp->processEvents();

    // Re-tile.
    workspace.tileSubWindows();
    workspace.setActiveSubWindow(0);
    QCOMPARE(workspace.viewport()->childrenRect(), workspace.viewport()->rect());

    // Active/deactivate windows and verify that the views are tiled.
    workspace.setActiveSubWindow(windows.at(5));
    workspace.resize(workspace.size() - QSize(10, 10));
    workspace.setActiveSubWindow(0);
    QTest::qWait(250); // delayed re-arrange of minimized windows
    QTRY_COMPARE(workspace.viewport()->childrenRect(), workspace.viewport()->rect());

    // Add another window and verify that the views are not tiled anymore.
    workspace.addSubWindow(new QPushButton(QLatin1String("I'd like to mess up tiled views")))->show();
    workspace.resize(workspace.size() - QSize(10, 10));
    workspace.setActiveSubWindow(0);
    QVERIFY(workspace.viewport()->childrenRect() != workspace.viewport()->rect());

    // Re-tile.
    workspace.tileSubWindows();
    workspace.setActiveSubWindow(0);
    QCOMPARE(workspace.viewport()->childrenRect(), workspace.viewport()->rect());

    // Cascade and verify that the views are not tiled anymore.
    workspace.cascadeSubWindows();
    workspace.resize(workspace.size() - QSize(10, 10));
    workspace.setActiveSubWindow(0);
    QVERIFY(workspace.viewport()->childrenRect() != workspace.viewport()->rect());

    // Make sure the active window is placed in top left corner regardless
    // of whether we have any windows with staysOnTopHint or not.
    windows.at(3)->setWindowFlags(windows.at(3)->windowFlags() | Qt::WindowStaysOnTopHint);
    QMdiSubWindow *activeSubWindow = windows.at(6);
    workspace.setActiveSubWindow(activeSubWindow);
    QCOMPARE(workspace.activeSubWindow(), activeSubWindow);
    workspace.tileSubWindows();
    QCOMPARE(activeSubWindow->geometry().topLeft(), QPoint(0, 0));

    // Verify that we try to resize the area such that all sub-windows are visible.
    // It's important that tiled windows are NOT overlapping.
    workspace.resize(350, 150);
    qApp->processEvents();
    QTRY_COMPARE(workspace.size(), QSize(350, 150));

    const QSize minSize(300, 100);
    foreach (QMdiSubWindow *subWindow, workspace.subWindowList())
        subWindow->setMinimumSize(minSize);

    QCOMPARE(workspace.size(), QSize(350, 150));
    workspace.tileSubWindows();
    // The sub-windows are now tiled like this:
    // | win 1 || win 2 || win 3 |
    // +-------++-------++-------+
    // +-------++-------++-------+
    // | win 4 || win 5 || win 6 |
    // +-------++-------++-------+
    // +-------++-------++-------+
    // | win 7 || win 8 || win 9 |
    workspace.setActiveSubWindow(0);
    int frameWidth = 0;
    if (workspace.style()->styleHint(QStyle::SH_ScrollView_FrameOnlyAroundContents, 0, &workspace))
        frameWidth = workspace.style()->pixelMetric(QStyle::PM_DefaultFrameWidth);
    const int spacing = 2 * frameWidth + 2;
    const QSize expectedViewportSize(3 * minSize.width() + spacing, 3 * minSize.height() + spacing);
#ifdef Q_OS_WINCE
    QSKIP("Not fixed yet! See task 197453", SkipAll);
#endif
    QTRY_COMPARE(workspace.viewport()->rect().size(), expectedViewportSize);

    // Not enough space for all sub-windows to be visible -> provide scroll bars.
    workspace.resize(150, 150);
    qApp->processEvents();
    QTRY_COMPARE(workspace.size(), QSize(150, 150));

    // Horizontal scroll bar.
    QScrollBar *hBar = workspace.horizontalScrollBar();
    QCOMPARE(workspace.horizontalScrollBarPolicy(), Qt::ScrollBarAsNeeded);
    QTRY_VERIFY(hBar->isVisible());
    QCOMPARE(hBar->value(), 0);
    QCOMPARE(hBar->minimum(), 0);

    // Vertical scroll bar.
    QScrollBar *vBar = workspace.verticalScrollBar();
    QCOMPARE(workspace.verticalScrollBarPolicy(), Qt::ScrollBarAsNeeded);
    QVERIFY(vBar->isVisible());
    QCOMPARE(vBar->value(), 0);
    QCOMPARE(vBar->minimum(), 0);

    workspace.tileSubWindows();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&workspace);
#endif
    qApp->processEvents();

    QTRY_VERIFY(workspace.size() != QSize(150, 150));
    QTRY_VERIFY(!vBar->isVisible());
    QTRY_VERIFY(!hBar->isVisible());
}

void tst_QMdiArea::cascadeAndTileSubWindows()
{
    QMdiArea workspace;
    workspace.resize(400, 400);
    workspace.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&workspace);
#endif

    const int windowCount = 10;
    QList<QMdiSubWindow *> windows;
    for (int i = 0; i < windowCount; ++i) {
        QMdiSubWindow *window = workspace.addSubWindow(new MyChild);
        if (i % 3 == 0) {
            window->showMinimized();
            QVERIFY(window->isMinimized());
        } else {
            window->showMaximized();
            QVERIFY(window->isMaximized());
        }
        windows.append(window);
    }

    // cascadeSubWindows
    qApp->processEvents();
    workspace.cascadeSubWindows();
    qApp->processEvents();

    // Check dy between two cascaded windows
    QStyleOptionTitleBar options;
    options.initFrom(windows.at(1));
    int titleBarHeight = windows.at(1)->style()->pixelMetric(QStyle::PM_TitleBarHeight, &options);
    // ### Remove this after the mac style has been fixed
    if (windows.at(1)->style()->inherits("QMacStyle"))
        titleBarHeight -= 4;
    const QFontMetrics fontMetrics = QFontMetrics(QApplication::font("QWorkspaceTitleBar"));
    const int dy = qMax(titleBarHeight - (titleBarHeight - fontMetrics.height()) / 2, 1);
    QCOMPARE(windows.at(2)->geometry().top() - windows.at(1)->geometry().top(), dy);

    for (int i = 0; i < windows.count(); ++i) {
        QMdiSubWindow *window = windows.at(i);
        if (i % 3 == 0) {
            QVERIFY(window->isMinimized());
        } else {
            QVERIFY(!window->isMaximized());
            QCOMPARE(window->size(), window->sizeHint());
            window->showMaximized();
            QVERIFY(window->isMaximized());
        }
    }
}

void tst_QMdiArea::resizeMaximizedChildWindows_data()
{
    QTest::addColumn<int>("startSize");
    QTest::addColumn<int>("increment");
    QTest::addColumn<int>("windowCount");

    QTest::newRow("multiple children") << 400 << 20 << 10;
}

void tst_QMdiArea::resizeMaximizedChildWindows()
{
    QFETCH(int, startSize);
    QFETCH(int, increment);
    QFETCH(int, windowCount);

    QMdiArea workspace;
    workspace.show();
#if defined(Q_WS_X11)
    qt_x11_wait_for_window_manager(&workspace);
#endif
    QTest::qWait(100);
    workspace.resize(startSize, startSize);
    workspace.setOption(QMdiArea::DontMaximizeSubWindowOnActivation);
    QSize workspaceSize = workspace.size();
    QVERIFY(workspaceSize.isValid());
    QCOMPARE(workspaceSize, QSize(startSize, startSize));

    QList<QMdiSubWindow *> windows;
    for (int i = 0; i < windowCount; ++i) {
        QMdiSubWindow *window = workspace.addSubWindow(new QWidget);
        windows.append(window);
        qApp->processEvents();
        window->showMaximized();
        QTest::qWait(100);
        QVERIFY(window->isMaximized());
        QSize windowSize = window->size();
        QVERIFY(windowSize.isValid());
        QCOMPARE(window->rect(), workspace.contentsRect());

        workspace.resize(workspaceSize + QSize(increment, increment));
        QTest::qWait(100);
        qApp->processEvents();
        QTRY_COMPARE(workspace.size(), workspaceSize + QSize(increment, increment));
        QTRY_COMPARE(window->size(), windowSize + QSize(increment, increment));
        workspaceSize = workspace.size();
    }

    int newSize = startSize + increment * windowCount;
    QCOMPARE(workspaceSize, QSize(newSize, newSize));
    foreach (QWidget *window, windows)
        QCOMPARE(window->rect(), workspace.contentsRect());
}

// QWidget::setParent clears focusWidget so make sure
// we restore it after QMdiArea::addSubWindow.
void tst_QMdiArea::focusWidgetAfterAddSubWindow()
{
    QWidget *view = new QWidget;
    view->setLayout(new QVBoxLayout);

    QLineEdit *lineEdit1 = new QLineEdit;
    QLineEdit *lineEdit2 = new QLineEdit;
    view->layout()->addWidget(lineEdit1);
    view->layout()->addWidget(lineEdit2);

    lineEdit2->setFocus();
    QCOMPARE(view->focusWidget(), static_cast<QWidget *>(lineEdit2));

    QMdiArea mdiArea;
    mdiArea.addSubWindow(view);
    QCOMPARE(view->focusWidget(), static_cast<QWidget *>(lineEdit2));

    mdiArea.show();
    view->show();
    qApp->setActiveWindow(&mdiArea);
    QCOMPARE(qApp->focusWidget(), static_cast<QWidget *>(lineEdit2));
}

void tst_QMdiArea::dontMaximizeSubWindowOnActivation()
{
    QMdiArea mdiArea;
    mdiArea.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#endif
    qApp->setActiveWindow(&mdiArea);

    // Add one maximized window.
    mdiArea.addSubWindow(new QWidget)->showMaximized();
    QVERIFY(mdiArea.activeSubWindow());
    QVERIFY(mdiArea.activeSubWindow()->isMaximized());

    // Add few more windows and verify that they are maximized.
    for (int i = 0; i < 5; ++i) {
        QMdiSubWindow *window = mdiArea.addSubWindow(new QWidget);
        window->show();
        QVERIFY(window->isMaximized());
        qApp->processEvents();
    }

    // Verify that activated windows still are maximized on activation.
    QList<QMdiSubWindow *> subWindows = mdiArea.subWindowList();
    for (int i = 0; i < subWindows.count(); ++i) {
        mdiArea.activateNextSubWindow();
        QMdiSubWindow *window = subWindows.at(i);
        QCOMPARE(mdiArea.activeSubWindow(), window);
        QVERIFY(window->isMaximized());
        qApp->processEvents();
    }

    // Restore active window and verify that other windows aren't
    // maximized on activation.
    mdiArea.activeSubWindow()->showNormal();
    for (int i = 0; i < subWindows.count(); ++i) {
        mdiArea.activateNextSubWindow();
        QMdiSubWindow *window = subWindows.at(i);
        QCOMPARE(mdiArea.activeSubWindow(), window);
        QVERIFY(!window->isMaximized());
        qApp->processEvents();
    }

    // Enable 'DontMaximizedSubWindowOnActivation' and maximize the active window.
    mdiArea.setOption(QMdiArea::DontMaximizeSubWindowOnActivation);
    mdiArea.activeSubWindow()->showMaximized();
    int indexOfMaximized = subWindows.indexOf(mdiArea.activeSubWindow());

    // Verify that windows are not maximized on activation.
    for (int i = 0; i < subWindows.count(); ++i) {
        mdiArea.activateNextSubWindow();
        QMdiSubWindow *window = subWindows.at(i);
        QCOMPARE(mdiArea.activeSubWindow(), window);
        if (indexOfMaximized != i)
            QVERIFY(!window->isMaximized());
        qApp->processEvents();
    }
    QVERIFY(mdiArea.activeSubWindow()->isMaximized());

    // Minimize all windows.
    foreach (QMdiSubWindow *window, subWindows) {
        window->showMinimized();
        QVERIFY(window->isMinimized());
        qApp->processEvents();
    }

    // Disable 'DontMaximizedSubWindowOnActivation' and maximize the active window.
    mdiArea.setOption(QMdiArea::DontMaximizeSubWindowOnActivation, false);
    mdiArea.activeSubWindow()->showMaximized();

    // Verify that minimized windows are maximized on activation.
    for (int i = 0; i < subWindows.count(); ++i) {
        mdiArea.activateNextSubWindow();
        QMdiSubWindow *window = subWindows.at(i);
        QCOMPARE(mdiArea.activeSubWindow(), window);
        QVERIFY(window->isMaximized());
        qApp->processEvents();
    }

    // Verify that activated windows are maximized after closing
    // the active window
    for (int i = 0; i < subWindows.count(); ++i) {
        QVERIFY(mdiArea.activeSubWindow());
        QVERIFY(mdiArea.activeSubWindow()->isMaximized());
        mdiArea.activeSubWindow()->close();
        qApp->processEvents();
    }

    QVERIFY(!mdiArea.activeSubWindow());
    QCOMPARE(mdiArea.subWindowList().size(), 0);

    // Verify that new windows are not maximized.
    mdiArea.addSubWindow(new QWidget)->show();
    QVERIFY(mdiArea.activeSubWindow());
    QVERIFY(!mdiArea.activeSubWindow()->isMaximized());
}

void tst_QMdiArea::delayedPlacement()
{
    QMdiArea mdiArea;

    QMdiSubWindow *window1 = mdiArea.addSubWindow(new QWidget);
    QCOMPARE(window1->geometry().topLeft(), QPoint(0, 0));

    QMdiSubWindow *window2 = mdiArea.addSubWindow(new QWidget);
    QCOMPARE(window2->geometry().topLeft(), QPoint(0, 0));

    QMdiSubWindow *window3 = mdiArea.addSubWindow(new QWidget);
    QCOMPARE(window3->geometry().topLeft(), QPoint(0, 0));

    mdiArea.resize(window3->minimumSizeHint().width() * 3, 400);
    mdiArea.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#endif

    QCOMPARE(window1->geometry().topLeft(), QPoint(0, 0));
    QCOMPARE(window2->geometry().topLeft(), window1->geometry().topRight() + QPoint(1, 0));
    QCOMPARE(window3->geometry().topLeft(), window2->geometry().topRight() + QPoint(1, 0));
}

void tst_QMdiArea::iconGeometryInMenuBar()
{
#if !defined (Q_WS_MAC) && !defined(Q_OS_WINCE)
    QMainWindow mainWindow;
    QMenuBar *menuBar = mainWindow.menuBar();
    QMdiArea *mdiArea = new QMdiArea;
    QMdiSubWindow *subWindow = mdiArea->addSubWindow(new QWidget);
    mainWindow.setCentralWidget(mdiArea);
    mainWindow.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mainWindow);
#endif

    subWindow->showMaximized();
    QVERIFY(subWindow->isMaximized());

    QWidget *leftCornerWidget = menuBar->cornerWidget(Qt::TopLeftCorner);
    QVERIFY(leftCornerWidget);
    int topMargin = (menuBar->height() - leftCornerWidget->height()) / 2;
    int leftMargin = qApp->style()->pixelMetric(QStyle::PM_MenuBarHMargin)
                   + qApp->style()->pixelMetric(QStyle::PM_MenuBarPanelWidth);
    QPoint pos(leftMargin, topMargin);
    QRect geometry = QStyle::visualRect(qApp->layoutDirection(), menuBar->rect(),
                                        QRect(pos, leftCornerWidget->size()));
    QCOMPARE(leftCornerWidget->geometry(), geometry);
#endif
}

class EventSpy : public QObject
{
public:
    EventSpy(QObject *object, QEvent::Type event)
        : eventToSpy(event), _count(0)
    {
        if (object)
            object->installEventFilter(this);
    }

    int count() const { return _count; }
    void clear() { _count = 0; }

protected:
    bool eventFilter(QObject *object, QEvent *event)
    {
        if (event->type() == eventToSpy)
            ++_count;
        return  QObject::eventFilter(object, event);
    }

private:
    QEvent::Type eventToSpy;
    int _count;
};

void tst_QMdiArea::resizeTimer()
{
    QMdiArea mdiArea;
    QMdiSubWindow *subWindow = mdiArea.addSubWindow(new QWidget);
    mdiArea.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#endif

#ifndef Q_OS_WINCE
    int time = 250;
#else
    int time = 1000;
#endif

    QTest::qWait(time);

    EventSpy timerEventSpy(subWindow, QEvent::Timer);
    QCOMPARE(timerEventSpy.count(), 0);

    mdiArea.tileSubWindows();
    QTest::qWait(time); // Wait for timer events to occur.
    QCOMPARE(timerEventSpy.count(), 1);
    timerEventSpy.clear();

    mdiArea.resize(mdiArea.size() + QSize(2, 2));
    QTest::qWait(time); // Wait for timer events to occur.
    QCOMPARE(timerEventSpy.count(), 1);
    timerEventSpy.clear();

    // Check that timers are killed.
    QTest::qWait(time); // Wait for timer events to occur.
    QCOMPARE(timerEventSpy.count(), 0);
}

void tst_QMdiArea::updateScrollBars()
{
    QMdiArea mdiArea;
    mdiArea.setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
    mdiArea.setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);

    QMdiSubWindow *subWindow1 = mdiArea.addSubWindow(new QWidget);
    QMdiSubWindow *subWindow2 = mdiArea.addSubWindow(new QWidget);

    mdiArea.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#endif
    qApp->processEvents();

    QScrollBar *hbar = mdiArea.horizontalScrollBar();
    QVERIFY(hbar);
    QVERIFY(!hbar->isVisible());

    QScrollBar *vbar = mdiArea.verticalScrollBar();
    QVERIFY(vbar);
    QVERIFY(!vbar->isVisible());

    // Move sub-window 2 away.
    subWindow2->move(10000, 10000);
    qApp->processEvents();
    QVERIFY(hbar->isVisible());
    QVERIFY(vbar->isVisible());

    for (int i = 0; i < 2; ++i) {
    // Maximize sub-window 1 and make sure we don't have any scroll bars.
    subWindow1->showMaximized();
    qApp->processEvents();
    QVERIFY(subWindow1->isMaximized());
    QVERIFY(!hbar->isVisible());
    QVERIFY(!vbar->isVisible());

    // We still shouldn't get any scroll bars.
    mdiArea.resize(mdiArea.size() - QSize(20, 20));
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#endif
    qApp->processEvents();
    QVERIFY(subWindow1->isMaximized());
    QVERIFY(!hbar->isVisible());
    QVERIFY(!vbar->isVisible());

    // Restore sub-window 1 and make sure we have scroll bars again.
    subWindow1->showNormal();
    qApp->processEvents();
    QVERIFY(!subWindow1->isMaximized());
    QVERIFY(hbar->isVisible());
    QVERIFY(vbar->isVisible());
        if (i == 0) {
            // Now, do the same when the viewport is scrolled.
            hbar->setValue(1000);
            vbar->setValue(1000);
        }
    }
}

void tst_QMdiArea::setActivationOrder_data()
{
    QTest::addColumn<QMdiArea::WindowOrder>("activationOrder");
    QTest::addColumn<int>("subWindowCount");
    QTest::addColumn<int>("staysOnTopIndex");
    QTest::addColumn<int>("firstActiveIndex");
    QTest::addColumn<QList<int> >("expectedActivationIndices");
    // The order of expectedCascadeIndices:
    // window 1 -> (index 0)
    //   window 2 -> (index 1)
    //     window 3 -> (index 2)
    // ....
    QTest::addColumn<QList<int> >("expectedCascadeIndices");

    // The order of expectedTileIndices (the same as reading a book LTR).
    // +--------------------+--------------------+--------------------+
    // | window 1 (index 0) | window 2 (index 1) | window 3 (index 2) |
    // |                    +--------------------+--------------------+
    // |          (index 3) | window 4 (index 4) | window 5 (index 5) |
    // +--------------------------------------------------------------+
    QTest::addColumn<QList<int> >("expectedTileIndices");

    QList<int> list;
    QList<int> list2;
    QList<int> list3;

    list << 2 << 1 << 0 << 1 << 2 << 3 << 4;
    list2 << 0 << 1 << 2 << 3 << 4;
    list3 << 1 << 4 << 3 << 1 << 2 << 0;
    QTest::newRow("CreationOrder") << QMdiArea::CreationOrder << 5 << 3 << 1 << list << list2 << list3;

    list = QList<int>();
    list << 3 << 1 << 4 << 3 << 1 << 2 << 0;
    list2 = QList<int>();
    list2 << 0 << 2 << 4 << 1 << 3;
    list3 = QList<int>();
    list3 << 1 << 3 << 4 << 1 << 2 << 0;
    QTest::newRow("StackingOrder") << QMdiArea::StackingOrder << 5 << 3 << 1 << list << list2 << list3;

    list = QList<int>();
    list << 0 << 1 << 0 << 1 << 4 << 3 << 2;
    list2 = QList<int>();
    list2 << 0 << 2 << 3 << 4 << 1;
    list3 = QList<int>();
    list3 << 1 << 4 << 3 << 1 << 2 << 0;
    QTest::newRow("ActivationHistoryOrder") << QMdiArea::ActivationHistoryOrder << 5 << 3 << 1 << list << list2 << list3;
}

void tst_QMdiArea::setActivationOrder()
{
    QFETCH(QMdiArea::WindowOrder, activationOrder);
    QFETCH(int, subWindowCount);
    QFETCH(int, staysOnTopIndex);
    QFETCH(int, firstActiveIndex);
    QFETCH(QList<int>, expectedActivationIndices);
    QFETCH(QList<int>, expectedCascadeIndices);
    QFETCH(QList<int>, expectedTileIndices);

    // Default order.
    QMdiArea mdiArea;
    QCOMPARE(mdiArea.activationOrder(), QMdiArea::CreationOrder);

    // New order.
    mdiArea.setActivationOrder(activationOrder);
    QCOMPARE(mdiArea.activationOrder(), activationOrder);

    QList<QMdiSubWindow *> subWindows;
    for (int i = 0; i < subWindowCount; ++i)
        subWindows << mdiArea.addSubWindow(new QPushButton(tr("%1").arg(i)));
    QCOMPARE(mdiArea.subWindowList(activationOrder), subWindows);

    mdiArea.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#endif

    for (int i = 0; i < subWindows.count(); ++i) {
        mdiArea.activateNextSubWindow();
        QCOMPARE(mdiArea.activeSubWindow(), subWindows.at(i));
        qApp->processEvents();
    }

    QMdiSubWindow *staysOnTop = subWindows.at(staysOnTopIndex);
    staysOnTop->setWindowFlags(staysOnTop->windowFlags() | Qt::WindowStaysOnTopHint);
    staysOnTop->raise();

    mdiArea.setActiveSubWindow(subWindows.at(firstActiveIndex));
    QCOMPARE(mdiArea.activeSubWindow(), subWindows.at(firstActiveIndex));

    // Verify the actual arrangement/geometry.
    mdiArea.tileSubWindows();
    QTest::qWait(100);
    QVERIFY(verifyArrangement(&mdiArea, Tiled, expectedTileIndices));

    mdiArea.cascadeSubWindows();
    QVERIFY(verifyArrangement(&mdiArea, Cascaded, expectedCascadeIndices));
    QTest::qWait(100);

    mdiArea.activateNextSubWindow();
    QCOMPARE(mdiArea.activeSubWindow(), subWindows.at(expectedActivationIndices.takeFirst()));

    mdiArea.activatePreviousSubWindow();
    QCOMPARE(mdiArea.activeSubWindow(), subWindows.at(expectedActivationIndices.takeFirst()));

    mdiArea.activatePreviousSubWindow();
    QCOMPARE(mdiArea.activeSubWindow(), subWindows.at(expectedActivationIndices.takeFirst()));

    for (int i = 0; i < subWindowCount; ++i) {
        mdiArea.closeActiveSubWindow();
        qApp->processEvents();
        if (i == subWindowCount - 1) { // Last window closed.
            QVERIFY(!mdiArea.activeSubWindow());
            break;
        }
        QVERIFY(mdiArea.activeSubWindow());
        QCOMPARE(mdiArea.activeSubWindow(), subWindows.at(expectedActivationIndices.takeFirst()));
    }

    QVERIFY(mdiArea.subWindowList(activationOrder).isEmpty());
    QVERIFY(expectedActivationIndices.isEmpty());
}

void tst_QMdiArea::tabBetweenSubWindows()
{
    QMdiArea mdiArea;
    QList<QMdiSubWindow *> subWindows;
    for (int i = 0; i < 5; ++i)
        subWindows << mdiArea.addSubWindow(new QLineEdit);

    mdiArea.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#endif

    qApp->setActiveWindow(&mdiArea);
    QWidget *focusWidget = subWindows.back()->widget();
    QCOMPARE(qApp->focusWidget(), focusWidget);

    QSignalSpy spy(&mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow *)));
    QCOMPARE(spy.count(), 0);

    // Walk through the entire list of sub windows.
    QVERIFY(tabBetweenSubWindowsIn(&mdiArea));
    QCOMPARE(mdiArea.activeSubWindow(), subWindows.back());
    QCOMPARE(spy.count(), 0);

    mdiArea.setActiveSubWindow(subWindows.front());
    QCOMPARE(mdiArea.activeSubWindow(), subWindows.front());
    spy.clear();

    // Walk through the entire list of sub windows in the opposite direction (Ctrl-Shift-Tab).
    QVERIFY(tabBetweenSubWindowsIn(&mdiArea, -1, true));
    QCOMPARE(mdiArea.activeSubWindow(), subWindows.front());
    QCOMPARE(spy.count(), 0);

    // Ctrl-Tab-Tab-Tab
    QVERIFY(tabBetweenSubWindowsIn(&mdiArea, 3));
    QCOMPARE(mdiArea.activeSubWindow(), subWindows.at(3));
    QCOMPARE(spy.count(), 1);

    mdiArea.setActiveSubWindow(subWindows.at(1));
    QCOMPARE(mdiArea.activeSubWindow(), subWindows.at(1));
    spy.clear();

    // Quick switch (Ctrl-Tab once) -> switch back to the previously active sub-window.
    QVERIFY(tabBetweenSubWindowsIn(&mdiArea, 1));
    QCOMPARE(mdiArea.activeSubWindow(), subWindows.at(3));
    QCOMPARE(spy.count(), 1);
}

void tst_QMdiArea::setViewMode()
{
    QMdiArea mdiArea;

    QPixmap iconPixmap(16, 16);
    iconPixmap.fill(Qt::red);
    for (int i = 0; i < 5; ++i) {
        QMdiSubWindow *subWindow = mdiArea.addSubWindow(new QWidget);
        subWindow->setWindowTitle(QString(QLatin1String("Title %1")).arg(i));
        subWindow->setWindowIcon(iconPixmap);
    }

    mdiArea.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#endif

    QMdiSubWindow *activeSubWindow = mdiArea.activeSubWindow();
    const QList<QMdiSubWindow *> subWindows = mdiArea.subWindowList();

    // Default.
    QVERIFY(!activeSubWindow->isMaximized());
    QTabBar *tabBar = qFindChild<QTabBar *>(&mdiArea);
    QVERIFY(!tabBar);
    QCOMPARE(mdiArea.viewMode(), QMdiArea::SubWindowView);

    // Tabbed view.
    mdiArea.setViewMode(QMdiArea::TabbedView);
    QCOMPARE(mdiArea.viewMode(), QMdiArea::TabbedView);
    tabBar = qFindChild<QTabBar *>(&mdiArea);
    QVERIFY(tabBar);
    QVERIFY(tabBar->isVisible());

    QCOMPARE(tabBar->count(), subWindows.count());
    QVERIFY(activeSubWindow->isMaximized());
    QCOMPARE(tabBar->currentIndex(), subWindows.indexOf(activeSubWindow));

    // Check that tabIcon and tabText are set properly.
    for (int i = 0; i < subWindows.size(); ++i) {
        QMdiSubWindow *subWindow = subWindows.at(i);
        QCOMPARE(tabBar->tabText(i), subWindow->windowTitle());
        QCOMPARE(tabBar->tabIcon(i), subWindow->windowIcon());
    }

    // Check that tabText and tabIcon are updated.
    activeSubWindow->setWindowTitle(QLatin1String("Dude, I want another window title"));
    QCOMPARE(tabBar->tabText(tabBar->currentIndex()), activeSubWindow->windowTitle());
    iconPixmap.fill(Qt::green);
    activeSubWindow->setWindowIcon(iconPixmap);
    QCOMPARE(tabBar->tabIcon(tabBar->currentIndex()), activeSubWindow->windowIcon());

    // If there's an empty window title, tabText should return "(Untitled)" (as in firefox).
    activeSubWindow->setWindowTitle(QString());
    QCOMPARE(tabBar->tabText(tabBar->currentIndex()), QLatin1String("(Untitled)"));

    // If there's no window icon, tabIcon should return ... an empty icon :)
    activeSubWindow->setWindowIcon(QIcon());
    QCOMPARE(tabBar->tabIcon(tabBar->currentIndex()), QIcon());

    // Check that the current tab changes when activating another sub-window.
    for (int i = 0; i < subWindows.size(); ++i) {
        mdiArea.activateNextSubWindow();
        activeSubWindow = mdiArea.activeSubWindow();
        QCOMPARE(tabBar->currentIndex(), subWindows.indexOf(activeSubWindow));
    }

    activeSubWindow = mdiArea.activeSubWindow();
    const int tabIndex = tabBar->currentIndex();

    // The current tab should not change when the sub-window is hidden.
    activeSubWindow->hide();
    QCOMPARE(tabBar->currentIndex(), tabIndex);
    activeSubWindow->show();
    QCOMPARE(tabBar->currentIndex(), tabIndex);

    // Disable the tab when the sub-window is hidden and another sub-window is activated.
    activeSubWindow->hide();
    mdiArea.activateNextSubWindow();
    QVERIFY(tabBar->currentIndex() != tabIndex);
    QVERIFY(!tabBar->isTabEnabled(tabIndex));

    // Enable it again.
    activeSubWindow->show();
    QCOMPARE(tabBar->currentIndex(), tabIndex);
    QVERIFY(tabBar->isTabEnabled(tabIndex));

    // Remove sub-windows and make sure the tab is removed.
    foreach (QMdiSubWindow *subWindow, subWindows) {
        if (subWindow != activeSubWindow)
            mdiArea.removeSubWindow(subWindow);
    }
    QCOMPARE(tabBar->count(), 1);

    // Go back to default (QMdiArea::SubWindowView).
    mdiArea.setViewMode(QMdiArea::SubWindowView);
    QVERIFY(!activeSubWindow->isMaximized());
    tabBar = qFindChild<QTabBar *>(&mdiArea);
    QVERIFY(!tabBar);
    QCOMPARE(mdiArea.viewMode(), QMdiArea::SubWindowView);
}

void tst_QMdiArea::setTabShape()
{
    QMdiArea mdiArea;
    mdiArea.addSubWindow(new QWidget);
    mdiArea.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#endif

    // Default.
    QCOMPARE(mdiArea.tabShape(), QTabWidget::Rounded);

    // Triangular.
    mdiArea.setTabShape(QTabWidget::Triangular);
    QCOMPARE(mdiArea.tabShape(), QTabWidget::Triangular);

    mdiArea.setViewMode(QMdiArea::TabbedView);

    QTabBar *tabBar = qFindChild<QTabBar *>(&mdiArea);
    QVERIFY(tabBar);
    QCOMPARE(tabBar->shape(), QTabBar::TriangularNorth);

    // Back to default (Rounded).
    mdiArea.setTabShape(QTabWidget::Rounded);
    QCOMPARE(mdiArea.tabShape(), QTabWidget::Rounded);
    QCOMPARE(tabBar->shape(), QTabBar::RoundedNorth);
}

void tst_QMdiArea::setTabPosition_data()
{
    QTest::addColumn<QTabWidget::TabPosition>("tabPosition");
    QTest::addColumn<bool>("hasLeftMargin");
    QTest::addColumn<bool>("hasTopMargin");
    QTest::addColumn<bool>("hasRightMargin");
    QTest::addColumn<bool>("hasBottomMargin");

    QTest::newRow("North") << QTabWidget::North << false << true << false << false;
    QTest::newRow("South") << QTabWidget::South << false << false << false << true;
    QTest::newRow("East") << QTabWidget::East << false << false << true << false;
    QTest::newRow("West") << QTabWidget::West << true << false << false << false;
}

void tst_QMdiArea::setTabPosition()
{
    QFETCH(QTabWidget::TabPosition, tabPosition);
    QFETCH(bool, hasLeftMargin);
    QFETCH(bool, hasTopMargin);
    QFETCH(bool, hasRightMargin);
    QFETCH(bool, hasBottomMargin);

    QMdiArea mdiArea;
    mdiArea.addSubWindow(new QWidget);
    mdiArea.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#endif

    // Make sure there are no margins.
    mdiArea.setContentsMargins(0, 0, 0, 0);

    // Default.
    QCOMPARE(mdiArea.tabPosition(), QTabWidget::North);
    mdiArea.setViewMode(QMdiArea::TabbedView);
    QTabBar *tabBar = qFindChild<QTabBar *>(&mdiArea);
    QVERIFY(tabBar);
    QCOMPARE(tabBar->shape(), QTabBar::RoundedNorth);

    // New position.
    mdiArea.setTabPosition(tabPosition);
    QCOMPARE(mdiArea.tabPosition(), tabPosition);
    QCOMPARE(tabBar->shape(), tabBarShapeFrom(QTabWidget::Rounded, tabPosition));

    const Qt::LayoutDirection originalLayoutDirection = qApp->layoutDirection();

    // Check that we have correct geometry in both RightToLeft and LeftToRight.
    for (int i = 0; i < 2; ++i) {
        // Check viewportMargins.
        const QRect viewportGeometry = mdiArea.viewport()->geometry();
        const int left = viewportGeometry.left();
        const int top = viewportGeometry.y();
        const int right = mdiArea.width() - viewportGeometry.width();
        const int bottom = mdiArea.height() - viewportGeometry.height();

        const QSize sizeHint = tabBar->sizeHint();

        if (hasLeftMargin)
            QCOMPARE(qApp->isLeftToRight() ? left : right, sizeHint.width());
        if (hasRightMargin)
            QCOMPARE(qApp->isLeftToRight() ? right : left, sizeHint.width());
        if (hasTopMargin || hasBottomMargin)
            QCOMPARE(hasTopMargin ? top : bottom, sizeHint.height());

        // Check actual tab bar geometry.
        const QRegion expectedTabBarGeometry = QRegion(mdiArea.rect()).subtracted(viewportGeometry);
        QVERIFY(!expectedTabBarGeometry.isEmpty());
        QCOMPARE(QRegion(tabBar->geometry()), expectedTabBarGeometry);

        if (i == 0)
            qApp->setLayoutDirection(originalLayoutDirection == Qt::LeftToRight ? Qt::RightToLeft : Qt::LeftToRight);
        qApp->processEvents();
    }

    qApp->setLayoutDirection(originalLayoutDirection);
}

#if defined(Q_WS_WIN) || defined(Q_WS_X11)
void tst_QMdiArea::nativeSubWindows()
{
    { // Add native widgets after show.
    QMdiArea mdiArea;
    mdiArea.addSubWindow(new QWidget);
    mdiArea.addSubWindow(new QWidget);
    mdiArea.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#endif

    // No native widgets.
    QVERIFY(!mdiArea.viewport()->internalWinId());
    foreach (QMdiSubWindow *subWindow, mdiArea.subWindowList())
        QVERIFY(!subWindow->internalWinId());

    QWidget *nativeWidget = new QWidget;
    QVERIFY(nativeWidget->winId()); // enforce native window.
    mdiArea.addSubWindow(nativeWidget);

    // The viewport and all the sub-windows must be native.
    QVERIFY(mdiArea.viewport()->internalWinId());
    foreach (QMdiSubWindow *subWindow, mdiArea.subWindowList())
        QVERIFY(subWindow->internalWinId());

    // Add a non-native widget. This should become native.
    QMdiSubWindow *subWindow = new QMdiSubWindow;
    subWindow->setWidget(new QWidget);
    QVERIFY(!subWindow->internalWinId());
    mdiArea.addSubWindow(subWindow);
    QVERIFY(subWindow->internalWinId());
    }

    { // Add native widgets before show.
    QMdiArea mdiArea;
    mdiArea.addSubWindow(new QWidget);
    QWidget *nativeWidget = new QWidget;
    (void)nativeWidget->winId();
    mdiArea.addSubWindow(nativeWidget);
    mdiArea.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#endif

    // The viewport and all the sub-windows must be native.
    QVERIFY(mdiArea.viewport()->internalWinId());
    foreach (QMdiSubWindow *subWindow, mdiArea.subWindowList())
        QVERIFY(subWindow->internalWinId());
    }

    { // Make a sub-window native *after* it's added to the area.
    QMdiArea mdiArea;
    mdiArea.addSubWindow(new QWidget);
    mdiArea.addSubWindow(new QWidget);
    mdiArea.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#endif

    QMdiSubWindow *nativeSubWindow = mdiArea.subWindowList().last();
    QVERIFY(!nativeSubWindow->internalWinId());
    (void)nativeSubWindow->winId();

    // All the sub-windows should be native at this point
    QVERIFY(mdiArea.viewport()->internalWinId());
    foreach (QMdiSubWindow *subWindow, mdiArea.subWindowList())
            QVERIFY(subWindow->internalWinId());
    }

#ifndef QT_NO_OPENGL
    {
    if (!QGLFormat::hasOpenGL())
        QSKIP("QGL not supported on this platform", SkipAll);

    QMdiArea mdiArea;
    QGLWidget *glViewport = new QGLWidget;
    mdiArea.setViewport(glViewport);
    mdiArea.addSubWindow(new QWidget);
    mdiArea.addSubWindow(new QWidget);
    mdiArea.show();
#ifdef Q_WS_X11
    qt_x11_wait_for_window_manager(&mdiArea);
#endif

    const QGLContext *context = glViewport->context();
    if (!context || !context->isValid())
        QSKIP("QGL is broken, cannot continue test", SkipAll);

    // The viewport and all the sub-windows must be native.
    QVERIFY(mdiArea.viewport()->internalWinId());
    foreach (QMdiSubWindow *subWindow, mdiArea.subWindowList())
        QVERIFY(subWindow->internalWinId());
    }
#endif
}
#endif

void tst_QMdiArea::task_209615()
{
    QTabWidget tabWidget;
    QMdiArea *mdiArea1 = new QMdiArea;
    QMdiArea *mdiArea2 = new QMdiArea;
    QMdiSubWindow *subWindow = mdiArea1->addSubWindow(new QLineEdit);

    tabWidget.addTab(mdiArea1, QLatin1String("1"));
    tabWidget.addTab(mdiArea2, QLatin1String("2"));
    tabWidget.show();

    mdiArea1->removeSubWindow(subWindow);
    mdiArea2->addSubWindow(subWindow);

    // Please do not assert/crash.
    tabWidget.setCurrentIndex(1);
}

void tst_QMdiArea::task_236750()
{
    QMdiArea mdiArea;
    QMdiSubWindow *subWindow = mdiArea.addSubWindow(new QTextEdit);
    mdiArea.show();

    subWindow->setWindowFlags(subWindow->windowFlags() | Qt::FramelessWindowHint);
    // Please do not crash (floating point exception).
    subWindow->showMinimized();
}

QTEST_MAIN(tst_QMdiArea)
#include "tst_qmdiarea.moc"

