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

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the test suite of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

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

#include <QtTest/QtTest>

#include <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