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

**

** 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.h"

#include "qmdiarea.h"

#include <QLayout>

#include <QLineEdit>

#include <QMainWindow>

#include <QMenuBar>

#include <QMenu>

#include <QGroupBox>

#include <QTextEdit>

#include <QLayout>

#include <QHBoxLayout>

#include <QByteArray>

#include <QStyle>

#include <QStyleOptionTitleBar>

#include <QPushButton>

#include <QSizeGrip>

#if defined(Q_WS_MAC) && !defined(QT_NO_STYLE_MAC)

#include <QMacStyle>

#endif

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

QT_BEGIN_NAMESPACE

#if defined(Q_WS_X11)

extern void qt_x11_wait_for_window_manager(QWidget *w);

#endif

#if !defined(Q_WS_WIN)

extern bool qt_tab_all_widgets;

#endif

QT_END_NAMESPACE

static inline bool tabAllWidgets()

{

#if !defined(Q_WS_WIN)

    if (qApp->style()->inherits("QMacStyle"))

        return qt_tab_all_widgets;

#endif

    return true;

}

static inline void triggerSignal(QMdiSubWindow *window, QMdiArea *workspace,

                                 const QByteArray &signal)

{

    if (signal == SIGNAL(windowMaximized())) {

        window->showMaximized();

        qApp->processEvents();

        if (window->parent())

            QVERIFY(window->isMaximized());

    } else if (signal == SIGNAL(windowMinimized())) {

        window->showMinimized();

        qApp->processEvents();

        if (window->parent())

            QVERIFY(window->isMinimized());

    } else if (signal == SIGNAL(windowRestored())) {

        window->showMaximized();

        qApp->processEvents();

        window->showNormal();

        qApp->processEvents();

        QVERIFY(!window->isMinimized());

        QVERIFY(!window->isMaximized());

        QVERIFY(!window->isShaded());

    } else if (signal == SIGNAL(aboutToActivate())) {

        if (window->parent()) {

            workspace->setActiveSubWindow(window);

            qApp->processEvents();

        }

    } else if (signal == SIGNAL(windowActivated())) {

        if (window->parent()) {

            workspace->setActiveSubWindow(window);

            qApp->processEvents();

        }

    } else if (signal == SIGNAL(windowDeactivated())) {

        if (!window->parent())

            return;

        workspace->setActiveSubWindow(window);

        qApp->processEvents();

        workspace->setActiveSubWindow(0);

        qApp->processEvents();

    }

}

// --- from tst_qgraphicsview.cpp ---

static void sendMousePress(QWidget *widget, const QPoint &point, Qt::MouseButton button = Qt::LeftButton)

{

    QMouseEvent event(QEvent::MouseButtonPress, point, widget->mapToGlobal(point), button, 0, 0);

    QApplication::sendEvent(widget, &event);

}

static void sendMouseMove(QWidget *widget, const QPoint &point, Qt::MouseButton button = Qt::LeftButton)

{

    QMouseEvent event(QEvent::MouseMove, point, widget->mapToGlobal(point), button, button, 0);

    QApplication::sendEvent(widget, &event);

}

static void sendMouseRelease(QWidget *widget, const QPoint &point, Qt::MouseButton button = Qt::LeftButton)

{

    QMouseEvent event(QEvent::MouseButtonRelease, point, widget->mapToGlobal(point), button, 0, 0);

    QApplication::sendEvent(widget, &event);

}

// ---

static void sendMouseDoubleClick(QWidget *widget, const QPoint &point, Qt::MouseButton button = Qt::LeftButton)

{

    sendMousePress(widget, point, button);

    sendMouseRelease(widget, point, button);

    QMouseEvent event(QEvent::MouseButtonDblClick, point, widget->mapToGlobal(point), button, 0, 0);

    QApplication::sendEvent(widget, &event);

}

static const Qt::WindowFlags StandardWindowFlags

    = Qt::WindowTitleHint | Qt::WindowSystemMenuHint | Qt::WindowMinMaxButtonsHint;

static const Qt::WindowFlags DialogWindowFlags

    = Qt::WindowTitleHint | Qt::WindowSystemMenuHint;

Q_DECLARE_METATYPE(Qt::WindowState);

Q_DECLARE_METATYPE(Qt::WindowStates);

Q_DECLARE_METATYPE(Qt::WindowType);

Q_DECLARE_METATYPE(Qt::WindowFlags);

//TESTED_CLASS=

//TESTED_FILES=

class tst_QMdiSubWindow : public QObject

{

    Q_OBJECT

private slots:

    void initTestCase();

    void sizeHint();

    void minimumSizeHint();

    void minimumSize();

    void setWidget();

    void setWindowState_data();

    void setWindowState();

    void mainWindowSupport();

    void emittingOfSignals_data();

    void emittingOfSignals();

    void showShaded();

    void showNormal_data();

    void showNormal();

    void setOpaqueResizeAndMove_data();

    void setOpaqueResizeAndMove();

    void setWindowFlags_data();

    void setWindowFlags();

    void mouseDoubleClick();

    void setSystemMenu();

    void restoreFocus();

    void changeFocusWithTab();

    void closeEvent();

    void setWindowTitle();

    void resizeEvents_data();

    void resizeEvents();

#if defined(Q_WS_MAC)

    void defaultSizeGrip();

#endif

    void hideAndShow();

    void keepWindowMaximizedState();

    void explicitlyHiddenWidget();

    void resizeTimer();

    void fixedMinMaxSize();

#if !defined (Q_WS_MAC) && !defined (Q_OS_WINCE)

    void replaceMenuBarWhileMaximized();

    void closeOnDoubleClick();

#endif

    void setFont();

    void task_188849();

    void mdiArea();

    void task_182852();

    void task_233197();

    void task_226929();

};

void tst_QMdiSubWindow::initTestCase()

{

    qRegisterMetaType<Qt::WindowStates>("Qt::WindowStates");

}

void tst_QMdiSubWindow::sizeHint()

{

    QMdiSubWindow *window = new QMdiSubWindow;

    QCOMPARE(window->sizeHint(), window->minimumSizeHint());

    window->show();

    QCOMPARE(window->sizeHint(), window->minimumSizeHint());

    QMdiArea workspace;

    workspace.addSubWindow(window);

    QCOMPARE(window->sizeHint(), window->minimumSizeHint());

}

void tst_QMdiSubWindow::minimumSizeHint()

{

    QMdiSubWindow window;

    window.show();

    QCOMPARE(window.minimumSizeHint(), qApp->globalStrut());

    window.setWidget(new QWidget);

    QCOMPARE(window.minimumSizeHint(), window.layout()->minimumSize()

                                       .expandedTo(qApp->globalStrut()));

    delete window.widget();

    delete window.layout();

    window.setWidget(new QWidget);

    QCOMPARE(window.minimumSizeHint(), qApp->globalStrut());

    window.widget()->show();

    QCOMPARE(window.minimumSizeHint(), window.widget()->minimumSizeHint()

                                       .expandedTo(qApp->globalStrut()));

}

void tst_QMdiSubWindow::minimumSize()

{

    QMdiArea mdiArea;

    mdiArea.resize(200, 200);

    // Check that we respect the minimum size set on the sub-window itself.

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

    subWindow1->setMinimumSize(1000, 1000);

    mdiArea.show();

#if defined(Q_WS_X11)

    qt_x11_wait_for_window_manager(&mdiArea);

#endif

    QCOMPARE(subWindow1->size(), QSize(1000, 1000));

    // Check that we respect the minimum size set on the internal widget.

    QWidget *widget = new QWidget;

    widget->setMinimumSize(1000, 1000);

    QMdiSubWindow *subWindow2 = mdiArea.addSubWindow(widget);

    QVERIFY(subWindow2->size() != mdiArea.viewport()->size());

    QCOMPARE(subWindow2->size(), subWindow2->minimumSizeHint());

}

void tst_QMdiSubWindow::setWidget()

{

    QMdiSubWindow window;

    window.show();

    QVERIFY(window.layout());

    QVERIFY(!window.widget());

    // QPointer so we can check if the widget is deleted

    QPointer<QWidget> widget = new QWidget;

    widget->setWindowTitle(QString::fromLatin1("DummyTitle"));

    QCOMPARE(widget->windowTitle(), QString::fromLatin1("DummyTitle"));

    window.setWidget(widget);

    QCOMPARE(window.windowTitle(), window.widget()->windowTitle());

    QCOMPARE(widget->parentWidget(), static_cast<QWidget *>(&window));

    QVERIFY(!widget->isVisible());

    QCOMPARE(window.layout()->count(), 1);

    QTest::ignoreMessage(QtWarningMsg,"QMdiSubWindow::setWidget: widget is already set");

    window.setWidget(widget);

    QCOMPARE(window.widget(), static_cast<QWidget *>(widget));

    QCOMPARE(widget->parentWidget(), static_cast<QWidget *>(&window));

    window.setWidget(0);

    QVERIFY(widget);

    QVERIFY(!widget->parent());

    QVERIFY(!window.widget());

    QCOMPARE(window.layout()->count(), 0);

    window.setWidget(widget);

    delete window.layout();

    QVERIFY(!window.layout());

    QVERIFY(window.widget());

    QCOMPARE(window.widget()->parentWidget(), static_cast<QWidget *>(&window));

    delete window.widget();

    QVERIFY(!widget);

    QVERIFY(!window.widget());

}

void tst_QMdiSubWindow::setWindowState_data()

{

    QTest::addColumn<Qt::WindowState>("windowState");

    QTest::newRow("maximized") << Qt::WindowMaximized;

    QTest::newRow("minimized") << Qt::WindowMinimized;

    QTest::newRow("normalized") << Qt::WindowNoState;

}

void tst_QMdiSubWindow::setWindowState()

{

    QFETCH(Qt::WindowState, windowState);

    QMdiArea workspace;

    QMdiSubWindow *window = qobject_cast<QMdiSubWindow *>(workspace.addSubWindow(new QLineEdit));

    window->show();

    workspace.show();

#if defined(Q_WS_X11)

    qt_x11_wait_for_window_manager(&workspace);

#endif

    QWidget *testWidget = 0;

    for (int iteration = 0; iteration < 2; ++iteration) {

        if (iteration == 0)

            testWidget = window;

        else

            testWidget = window->widget();

        testWidget->setWindowState(windowState);

        Qt::WindowStates windowStateWindow = window->windowState();

        windowStateWindow &= ~Qt::WindowActive;

        Qt::WindowStates windowStateWidget = window->widget()->windowState();

        windowStateWidget &= ~Qt::WindowActive;

        QCOMPARE(windowStateWindow, windowStateWidget);

        switch (windowState) {

        case Qt::WindowNoState:

            QVERIFY(!window->widget()->isMinimized());

            QVERIFY(!window->widget()->isMaximized());

            QVERIFY(!window->isMinimized());

            QVERIFY(!window->isMaximized());

            break;

        case Qt::WindowMinimized:

            QVERIFY(window->widget()->isMinimized());

            QVERIFY(window->isMinimized());

            break;

        case Qt::WindowMaximized:

            QVERIFY(window->widget()->isMaximized());

            QVERIFY(window->isMaximized());

            break;

        default:

            break;

        }

    }

}

void tst_QMdiSubWindow::mainWindowSupport()

{

    QList<QMdiSubWindow *> windows;

    QMdiArea *workspace = new QMdiArea;

    QMainWindow mainWindow;

    mainWindow.setCentralWidget(workspace);

    mainWindow.show();

    mainWindow.menuBar()->setVisible(true);

    qApp->setActiveWindow(&mainWindow);

    // QMainWindow's window title is empty

#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE)

    {

    QCOMPARE(mainWindow.windowTitle(), QString());

    QMdiSubWindow *window = workspace->addSubWindow(new QPushButton(QLatin1String("Test")));

    QString expectedTitle = QLatin1String("MainWindow's title is empty");

    window->setWindowTitle(expectedTitle);

    QCOMPARE(window->windowTitle(), expectedTitle);

    window->showMaximized();

    QVERIFY(window->isMaximized());

    QCOMPARE(window->windowTitle(), expectedTitle);

    QCOMPARE(mainWindow.windowTitle(), expectedTitle);

    window->showNormal();

    QCOMPARE(window->windowTitle(), expectedTitle);

    QCOMPARE(mainWindow.windowTitle(), QString());

    window->close();

    }

#endif

    QString originalWindowTitle = QString::fromLatin1("MainWindow");

    mainWindow.setWindowTitle(originalWindowTitle);

    for (int i = 0; i < 5; ++i) {

        mainWindow.menuBar()->setVisible(false);

        QMdiSubWindow *window = new QMdiSubWindow;

        windows.append(window);

        QVERIFY(!window->maximizedButtonsWidget());

        QVERIFY(!window->maximizedSystemMenuIconWidget());

        QMdiArea *nestedWorkspace = new QMdiArea; // :-)

        window->setWidget(nestedWorkspace);

        window->widget()->setWindowTitle(QString::fromLatin1("Window %1").arg(i));

        workspace->addSubWindow(window);

        QVERIFY(!window->maximizedButtonsWidget());

        QVERIFY(!window->maximizedSystemMenuIconWidget());

        window->show();

        // mainWindow.menuBar() is not visible

        window->showMaximized();

        qApp->processEvents();

        QVERIFY(window->isMaximized());

        QVERIFY(!window->maximizedButtonsWidget());

        QVERIFY(!window->maximizedSystemMenuIconWidget());

        window->showNormal();

        // Now it is

        mainWindow.menuBar()->setVisible(true);

        window->showMaximized();

        qApp->processEvents();

        QVERIFY(window->isMaximized());

#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE)

        QVERIFY(window->maximizedButtonsWidget());

        QCOMPARE(window->maximizedButtonsWidget(), mainWindow.menuBar()->cornerWidget(Qt::TopRightCorner));

        QVERIFY(window->maximizedSystemMenuIconWidget());

        QCOMPARE(window->maximizedSystemMenuIconWidget(), qobject_cast<QWidget *>(mainWindow.menuBar()

                                                                    ->cornerWidget(Qt::TopLeftCorner)));

        QCOMPARE(mainWindow.windowTitle(), QString::fromLatin1("%1 - [%2]")

                                           .arg(originalWindowTitle, window->widget()->windowTitle()));

#endif

        // Check that nested child windows don't set window title

        nestedWorkspace->show();

        QMdiSubWindow *nestedWindow = new QMdiSubWindow;

        nestedWindow->setWidget(new QWidget);

        nestedWorkspace->addSubWindow(nestedWindow);

        nestedWindow->widget()->setWindowTitle(QString::fromLatin1("NestedWindow %1").arg(i));

        nestedWindow->showMaximized();

        qApp->processEvents();

        QVERIFY(nestedWindow->isMaximized());

        QVERIFY(!nestedWindow->maximizedButtonsWidget());

        QVERIFY(!nestedWindow->maximizedSystemMenuIconWidget());

#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE)

        QCOMPARE(mainWindow.windowTitle(), QString::fromLatin1("%1 - [%2]")

                                           .arg(originalWindowTitle, window->widget()->windowTitle()));

#endif

    }

#if defined(Q_WS_MAC) || defined(Q_OS_WINCE)

    return;

#endif

    workspace->activateNextSubWindow();

    qApp->processEvents();

    foreach (QMdiSubWindow *window, windows) {

        QCOMPARE(workspace->activeSubWindow(), window);

        QVERIFY(window->isMaximized());

        QVERIFY(window->maximizedButtonsWidget());

        QCOMPARE(window->maximizedButtonsWidget(), mainWindow.menuBar()->cornerWidget(Qt::TopRightCorner));

        QVERIFY(window->maximizedSystemMenuIconWidget());

        QCOMPARE(window->maximizedSystemMenuIconWidget(), qobject_cast<QWidget *>(mainWindow.menuBar()

                                                                   ->cornerWidget(Qt::TopLeftCorner)));

        QCOMPARE(mainWindow.windowTitle(), QString::fromLatin1("%1 - [%2]")

                                           .arg(originalWindowTitle, window->widget()->windowTitle()));

        workspace->activateNextSubWindow();

        qApp->processEvents();

    }

}

// This test was written when QMdiSubWindow emitted separate signals

void tst_QMdiSubWindow::emittingOfSignals_data()

{

    QTest::addColumn<QByteArray>("signal");

    QTest::addColumn<Qt::WindowState>("watchedState");

    QTest::newRow("windowMaximized") << QByteArray(SIGNAL(windowMaximized())) << Qt::WindowMaximized;

    QTest::newRow("windowMinimized") << QByteArray(SIGNAL(windowMinimized())) << Qt::WindowMinimized;

    QTest::newRow("windowRestored") << QByteArray(SIGNAL(windowRestored())) << Qt::WindowNoState;

    QTest::newRow("aboutToActivate") << QByteArray(SIGNAL(aboutToActivate())) << Qt::WindowNoState;

    QTest::newRow("windowActivated") << QByteArray(SIGNAL(windowActivated())) << Qt::WindowActive;

    QTest::newRow("windowDeactivated") << QByteArray(SIGNAL(windowDeactivated())) << Qt::WindowActive;

}

void tst_QMdiSubWindow::emittingOfSignals()

{

    QFETCH(QByteArray, signal);

    QFETCH(Qt::WindowState, watchedState);

    QMdiArea workspace;

    workspace.show();

    qApp->processEvents();

    qApp->setActiveWindow(&workspace);

    QMdiSubWindow *window = qobject_cast<QMdiSubWindow *>(workspace.addSubWindow(new QWidget));

    qApp->processEvents();

    window->show();

    if (signal != SIGNAL(windowRestored()))

        workspace.setActiveSubWindow(0);

    qApp->processEvents();

    QSignalSpy spy(window, signal == SIGNAL(aboutToActivate())

                           ? signal.data()

                           : SIGNAL(windowStateChanged(Qt::WindowStates, Qt::WindowStates)));

    QVERIFY(spy.isEmpty());

    triggerSignal(window, &workspace, signal);

    // Unless the signal is windowRestored or windowDeactivated,

    // we're already in correct state and nothing should happen.

    if (signal != SIGNAL(windowRestored()) && signal != SIGNAL(windowDeactivated()))

        triggerSignal(window, &workspace, signal);

    int count = 0;

    if (signal == SIGNAL(aboutToActivate())) {

        count += spy.count();

    } else {

        for (int i = 0; i < spy.count(); ++i) {

            Qt::WindowStates oldState = qvariant_cast<Qt::WindowStates>(spy.at(i).at(0));