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

**

** 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 QtGui module 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$

**

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

/*!

    \class QMdiSubWindow

    \brief The QMdiSubWindow class provides a subwindow class for

    QMdiArea.

    \since 4.3

    \ingroup mainwindow-classes

    QMdiSubWindow represents a top-level window in a QMdiArea, and consists

    of a title bar with window decorations, an internal widget, and

    (depending on the current style) a window frame and a size

    grip. QMdiSubWindow has its own layout, which consists of the

    title bar and a center area for the internal widget.

    \image qmdisubwindowlayout.png

    The most common way to construct a QMdiSubWindow is to call

    QMdiArea::addSubWindow() with the internal widget as the argument.

    You can also create a subwindow yourself, and set an internal

    widget by calling setWidget().

    You use the same API when programming with subwindows as with

    regular top-level windows (e.g., you can call functions such as

    show(), hide(), showMaximized(), and setWindowTitle()).

    \section1 Subwindow Handling

    QMdiSubWindow also supports behavior specific to subwindows in

    an MDI area.

    By default, each QMdiSubWindow is visible inside the MDI area

    viewport when moved around, but it is also possible to specify

    transparent window movement and resizing behavior, where only

    the outline of a subwindow is updated during these operations.

    The setOption() function is used to enable this behavior.

    The isShaded() function detects whether the subwindow is

    currently shaded (i.e., the window is collapsed so that only the

    title bar is visible). To enter shaded mode, call showShaded().

    QMdiSubWindow emits the windowStateChanged() signal whenever the

    window state has changed (e.g., when the window becomes minimized,

    or is restored). It also emits aboutToActivate() before it is

    activated.

    In keyboard-interactive mode, the windows are moved and resized

    with the keyboard. You can enter this mode through the system menu

    of the window. The keyboardSingleStep and keyboardPageStep

    properties control the distance the widget is moved or resized for

    each keypress event. When shift is pressed down page step is used;

    otherwise single step is used.

    You can also change the active window with the keyboard. By

    pressing the control and tab keys at the same time, the next

    (using the current \l{QMdiArea::}{WindowOrder}) subwindow will be

    activated. By pressing control, shift, and tab, you will activate

    the previous window. This is equivalent to calling

    \l{QMdiArea::}{activateNextSubWindow()} and

    \l{QMdiArea::}{activatePreviousSubWindow()}. Note that these

    shortcuts overrides global shortcuts, but not the \l{QMdiArea}s

    shortcuts.

    \sa QMdiArea

*/

/*!

    \enum QMdiSubWindow::SubWindowOption

    This enum describes options that customize the behavior

    of QMdiSubWindow.

    \omitvalue AllowOutsideAreaHorizontally

    \omitvalue AllowOutsideAreaVertically

    \value RubberBandResize If you enable this option, a rubber band

    control is used to represent the subwindow's outline, and the user

    resizes this instead of the subwindow itself.

    As a result, the subwindow maintains its original position and size

    until the resize operation has been completed, at which time it will

    receive a single QResizeEvent.

    By default, this option is disabled.

    \value RubberBandMove If you enable this option, a rubber band

    control is used to represent the subwindow's outline, and the user

    moves this instead of the subwindow itself.

    As a result, the subwindow remains in its original position until

    the move operation has completed, at which time a QMoveEvent is

    sent to the window. By default, this option is disabled.

*/

/*!

    \fn QMdiSubWindow::windowStateChanged(Qt::WindowStates oldState, Qt::WindowStates newState)

    QMdiSubWindow emits this signal after the window state changes. \a

    oldState is the window state before it changed, and \a newState is the

    new, current state.

*/

/*!

    \fn QMdiSubWindow::aboutToActivate()

    QMdiSubWindow emits this signal immediately before it is

    activated. After the subwindow has been activated, the QMdiArea that

    manages the subwindow will also emit the

    \l{QMdiArea::}{subWindowActivated()} signal.

    \sa QMdiArea::subWindowActivated()

*/

#include "qmdisubwindow_p.h"

#ifndef QT_NO_MDIAREA

#include <QApplication>

#include <QStylePainter>

#include <QVBoxLayout>

#include <QMouseEvent>

#include <QWhatsThis>

#include <QToolTip>

#include <QMainWindow>

#include <QScrollBar>

#include <QDebug>

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

#include <QMacStyle>

#endif

#include <QMdiArea>

QT_BEGIN_NAMESPACE

using namespace QMdi;

static const QStyle::SubControl SubControls[] =

{

    QStyle::SC_TitleBarLabel, // 1

    QStyle::SC_TitleBarSysMenu, // 2

    QStyle::SC_TitleBarMinButton, // 3

    QStyle::SC_TitleBarMaxButton, // 4

    QStyle::SC_TitleBarShadeButton, // 5

    QStyle::SC_TitleBarCloseButton, // 6

    QStyle::SC_TitleBarNormalButton, // 7

    QStyle::SC_TitleBarUnshadeButton, // 8

    QStyle::SC_TitleBarContextHelpButton // 9

};

static const int NumSubControls = sizeof(SubControls) / sizeof(SubControls[0]);

static const QStyle::StandardPixmap ButtonPixmaps[] =

{

    QStyle::SP_TitleBarMinButton,

    QStyle::SP_TitleBarNormalButton,

    QStyle::SP_TitleBarCloseButton

};

static const int NumButtonPixmaps = sizeof(ButtonPixmaps) / sizeof(ButtonPixmaps[0]);

static const Qt::WindowFlags CustomizeWindowFlags =

      Qt::FramelessWindowHint

    | Qt::CustomizeWindowHint

    | Qt::WindowTitleHint

    | Qt::WindowSystemMenuHint

    | Qt::WindowMinimizeButtonHint

    | Qt::WindowMaximizeButtonHint

    | Qt::WindowMinMaxButtonsHint;

static const int BoundaryMargin = 5;

static inline int getMoveDeltaComponent(uint cflags, uint moveFlag, uint resizeFlag,

                                        int delta, int maxDelta, int minDelta)

{

    if (cflags & moveFlag) {

        if (delta > 0)

            return (cflags & resizeFlag) ? qMin(delta, maxDelta) : delta;

        return (cflags & resizeFlag) ? qMax(delta, minDelta) : delta;

    }

    return 0;

}

static inline int getResizeDeltaComponent(uint cflags, uint resizeFlag,

                                          uint resizeReverseFlag, int delta)

{

    if (cflags & resizeFlag) {

        if (cflags & resizeReverseFlag)

            return -delta;

        return delta;

    }

    return 0;

}

static inline bool isChildOfQMdiSubWindow(const QWidget *child)

{

    Q_ASSERT(child);

    QWidget *parent = child->parentWidget();

    while (parent) {

        if (qobject_cast<QMdiSubWindow *>(parent))

            return true;

        parent = parent->parentWidget();

    }

    return false;

}

static inline bool isChildOfTabbedQMdiArea(const QMdiSubWindow *child)

{

    Q_ASSERT(child);

    if (QMdiArea *mdiArea = child->mdiArea()) {

        if (mdiArea->viewMode() == QMdiArea::TabbedView)

            return true;

    }

    return false;

}

template<typename T>

static inline ControlElement<T> *ptr(QWidget *widget)

{

    if (widget && widget->qt_metacast("ControlElement")

            && strcmp(widget->metaObject()->className(), T::staticMetaObject.className()) == 0) {

        return static_cast<ControlElement<T> *>(widget);

    }

    return 0;

}

QString QMdiSubWindowPrivate::originalWindowTitle()

{

    Q_Q(QMdiSubWindow);

    if (originalTitle.isNull()) {

        originalTitle = q->window()->windowTitle();

        if (originalTitle.isNull())

            originalTitle = QLatin1String("");

    }

    return originalTitle;

}

void QMdiSubWindowPrivate::setNewWindowTitle()

{

    Q_Q(QMdiSubWindow);

    QString childTitle = q->windowTitle();

    if (childTitle.isEmpty())

        return;

    QString original = originalWindowTitle();

    if (!original.isEmpty()) {

        if (!original.contains(QMdiSubWindow::tr("- [%1]").arg(childTitle)))

            q->window()->setWindowTitle(QMdiSubWindow::tr("%1 - [%2]").arg(original, childTitle));

    } else {

        q->window()->setWindowTitle(childTitle);

    }

}

static inline bool isHoverControl(QStyle::SubControl control)

{

    return control != QStyle::SC_None && control != QStyle::SC_TitleBarLabel;

}

#if defined(Q_WS_WIN)

static inline QRgb colorref2qrgb(COLORREF col)

{

    return qRgb(GetRValue(col),GetGValue(col),GetBValue(col));

}

#endif

#ifndef QT_NO_TOOLTIP

static void showToolTip(QHelpEvent *helpEvent, QWidget *widget, const QStyleOptionComplex &opt,

                        QStyle::ComplexControl complexControl, QStyle::SubControl subControl)

{

    Q_ASSERT(helpEvent);

    Q_ASSERT(helpEvent->type() == QEvent::ToolTip);

    Q_ASSERT(widget);

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

    // Native Mac windows don't show tool tip.

    if (qobject_cast<QMacStyle *>(widget->style()))

        return;

#endif

    // Convert CC_MdiControls to CC_TitleBar. Sub controls of different complex

    // controls cannot be in the same switch as they might have the same value.

    if (complexControl == QStyle::CC_MdiControls) {

        if (subControl == QStyle::SC_MdiMinButton)

            subControl = QStyle::SC_TitleBarMinButton;

        else if (subControl == QStyle::SC_MdiCloseButton)

            subControl = QStyle::SC_TitleBarCloseButton;

        else if (subControl == QStyle::SC_MdiNormalButton)

            subControl = QStyle::SC_TitleBarNormalButton;

        else

            subControl = QStyle::SC_None;

    }

    // Don't change the tooltip for the base widget itself.

    if (subControl == QStyle::SC_None)

        return;

    QString toolTip;

    switch (subControl) {

    case QStyle::SC_TitleBarMinButton:

        toolTip = QMdiSubWindow::tr("Minimize");

        break;

    case QStyle::SC_TitleBarMaxButton:

        toolTip = QMdiSubWindow::tr("Maximize");

        break;

    case QStyle::SC_TitleBarUnshadeButton:

        toolTip = QMdiSubWindow::tr("Unshade");

        break;

    case QStyle::SC_TitleBarShadeButton:

        toolTip = QMdiSubWindow::tr("Shade");

        break;

    case QStyle::SC_TitleBarNormalButton:

        if (widget->isMaximized() || !qobject_cast<QMdiSubWindow *>(widget))

            toolTip = QMdiSubWindow::tr("Restore Down");

        else

            toolTip = QMdiSubWindow::tr("Restore");

        break;

    case QStyle::SC_TitleBarCloseButton:

        toolTip = QMdiSubWindow::tr("Close");

        break;

    case QStyle::SC_TitleBarContextHelpButton:

        toolTip = QMdiSubWindow::tr("Help");

        break;

    case QStyle::SC_TitleBarSysMenu:

        toolTip = QMdiSubWindow::tr("Menu");

        break;

    default:

        break;

    }

    const QRect rect = widget->style()->subControlRect(complexControl, &opt, subControl, widget);

    QToolTip::showText(helpEvent->globalPos(), toolTip, widget, rect);

}

#endif // QT_NO_TOOLTIP

namespace QMdi {

/*

    \class ControlLabel

    \internal

*/

class ControlLabel : public QWidget

{

    Q_OBJECT

public:

    ControlLabel(QMdiSubWindow *subWindow, QWidget *parent = 0);

    QSize sizeHint() const;

signals:

    void _q_clicked();

    void _q_doubleClicked();

protected:

    bool event(QEvent *event);

    void paintEvent(QPaintEvent *paintEvent);

    void mousePressEvent(QMouseEvent *mouseEvent);

    void mouseDoubleClickEvent(QMouseEvent *mouseEvent);

    void mouseReleaseEvent(QMouseEvent *mouseEvent);

private:

    QPixmap label;

    bool isPressed;

    void updateWindowIcon();

};

} // namespace QMdi

ControlLabel::ControlLabel(QMdiSubWindow *subWindow, QWidget *parent)

    : QWidget(parent), isPressed(false)

{

    Q_UNUSED(subWindow);

    setFocusPolicy(Qt::NoFocus);

    updateWindowIcon();

    setFixedSize(label.size());

}

/*

    \internal

*/

QSize ControlLabel::sizeHint() const

{

    return label.size();

}

/*

    \internal

*/

bool ControlLabel::event(QEvent *event)

{

    if (event->type() == QEvent::WindowIconChange)

        updateWindowIcon();

#ifndef QT_NO_TOOLTIP

    else if (event->type() == QEvent::ToolTip) {

        QStyleOptionTitleBar options;

        options.initFrom(this);

        showToolTip(static_cast<QHelpEvent *>(event), this, options,

                    QStyle::CC_TitleBar, QStyle::SC_TitleBarSysMenu);

    }

#endif

    return QWidget::event(event);

}

/*

    \internal

*/

void ControlLabel::paintEvent(QPaintEvent * /*paintEvent*/)

{

    QPainter painter(this);

    painter.drawPixmap(0, 0, label);

}

/*

    \internal

*/

void ControlLabel::mousePressEvent(QMouseEvent *mouseEvent)

{

    if (mouseEvent->button() != Qt::LeftButton) {

        mouseEvent->ignore();

        return;

    }

    isPressed = true;

}

/*

    \internal

*/

void ControlLabel::mouseDoubleClickEvent(QMouseEvent *mouseEvent)

{

    if (mouseEvent->button() != Qt::LeftButton) {

        mouseEvent->ignore();

        return;

    }

    isPressed = false;

    emit _q_doubleClicked();

}

/*

    \internal

*/

void ControlLabel::mouseReleaseEvent(QMouseEvent *mouseEvent)

{

    if (mouseEvent->button() != Qt::LeftButton) {

        mouseEvent->ignore();

        return;

    }

    if (isPressed) {

        isPressed = false;

        emit _q_clicked();

    }

}

/*

    \internal

*/

void ControlLabel::updateWindowIcon()

{

    QIcon menuIcon = windowIcon();

    if (menuIcon.isNull())

        menuIcon = style()->standardIcon(QStyle::SP_TitleBarMenuButton, 0, parentWidget());

    label = menuIcon.pixmap(16, 16);

    update();

}

namespace QMdi {

/*

    \class ControllerWidget

    \internal

*/

class ControllerWidget : public QWidget

{

    Q_OBJECT

public:

    ControllerWidget(QMdiSubWindow *subWindow, QWidget *parent = 0);

    QSize sizeHint() const;

    void setControlVisible(QMdiSubWindowPrivate::WindowStateAction action, bool visible);

    inline bool hasVisibleControls() const

    {

        return (visibleControls & QStyle::SC_MdiMinButton)

               || (visibleControls & QStyle::SC_MdiNormalButton)

               || (visibleControls & QStyle::SC_MdiCloseButton);

    }

signals:

    void _q_minimize();

    void _q_restore();

    void _q_close();

protected:

    void paintEvent(QPaintEvent *event);

    void mousePressEvent(QMouseEvent *event);

    void mouseReleaseEvent(QMouseEvent *event);

    void mouseMoveEvent(QMouseEvent *event);

    void leaveEvent(QEvent *event);

    bool event(QEvent *event);

private: