/****************************************************************************+
−
**+
−
** 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 QMdiArea+
−
    \brief The QMdiArea widget provides an area in which MDI windows are displayed.+
−
    \since 4.3+
−
    \ingroup mainwindow-classes+
−
+
−
+
−
    QMdiArea functions, essentially, like a window manager for MDI+
−
    windows. For instance, it draws the windows it manages on itself+
−
    and arranges them in a cascading or tile pattern. QMdiArea is+
−
    commonly used as the center widget in a QMainWindow to create MDI+
−
    applications, but can also be placed in any layout. The following+
−
    code adds an area to a main window:+
−
+
−
    \snippet doc/src/snippets/mdiareasnippets.cpp 0+
−
+
−
    Unlike the window managers for top-level windows, all window flags+
−
    (Qt::WindowFlags) are supported by QMdiArea as long as the flags+
−
    are supported by the current widget style. If a specific flag is+
−
    not supported by the style (e.g., the+
−
    \l{Qt::}{WindowShadeButtonHint}), you can still shade the window+
−
    with showShaded().+
−
+
−
    Subwindows in QMdiArea are instances of QMdiSubWindow. They+
−
    are added to an MDI area with addSubWindow(). It is common to pass+
−
    a QWidget, which is set as the internal widget, to this function,+
−
    but it is also possible to pass a QMdiSubWindow directly.The class+
−
    inherits QWidget, and you can use the same API as with a normal+
−
    top-level window when programming. QMdiSubWindow also has behavior+
−
    that is specific to MDI windows. See the QMdiSubWindow class+
−
    description for more details.+
−
+
−
    A subwindow becomes active when it gets the keyboard focus, or+
−
    when setFocus() is called. The user activates a window by moving+
−
    focus in the usual ways. The MDI area emits the+
−
    subWindowActivated() signal when the active window changes, and+
−
    the activeSubWindow() function returns the active subwindow.+
−
+
−
    The convenience function subWindowList() returns a list of all+
−
    subwindows. This information could be used in a popup menu+
−
    containing a list of windows, for example.+
−
+
−
    The subwindows are sorted by the current+
−
    \l{QMdiArea::}{WindowOrder}. This is used for the subWindowList()+
−
    and for activateNextSubWindow() and acivatePreviousSubWindow().+
−
    Also, it is used when cascading or tiling the windows with+
−
    cascadeSubWindows() and tileSubWindows().+
−
+
−
    QMdiArea provides two built-in layout strategies for+
−
    subwindows: cascadeSubWindows() and tileSubWindows(). Both are+
−
    slots and are easily connected to menu entries.+
−
+
−
    \table+
−
    \row \o \inlineimage mdi-cascade.png+
−
         \o \inlineimage mdi-tile.png+
−
    \endtable+
−
+
−
    \note The default scroll bar property for QMdiArea is Qt::ScrollBarAlwaysOff.+
−
+
−
    \sa QMdiSubWindow+
−
*/+
−
+
−
/*!+
−
    \fn QMdiArea::subWindowActivated(QMdiSubWindow *window)+
−
+
−
    QMdiArea emits this signal after \a window has been activated. When \a+
−
    window is 0, QMdiArea has just deactivated its last active window, and+
−
    there are no active windows on the workspace.+
−
+
−
    \sa QMdiArea::activeSubWindow()+
−
*/+
−
+
−
/*!+
−
    \enum QMdiArea::AreaOption+
−
+
−
    This enum describes options that customize the behavior of the+
−
    QMdiArea.+
−
+
−
    \value DontMaximizeSubWindowOnActivation When the active subwindow+
−
    is maximized, the default behavior is to maximize the next+
−
    subwindow that is activated. Set this option if you do not want+
−
    this behavior.+
−
*/+
−
+
−
/*!+
−
    \enum QMdiArea::WindowOrder+
−
+
−
    Specifies the criteria to use for ordering the list of child windows+
−
    returned by subWindowList(). The functions cascadeSubWindows() and+
−
    tileSubWindows() follow this order when arranging the windows.+
−
+
−
    \value CreationOrder The windows are returned in the order of+
−
    their creation.+
−
+
−
    \value StackingOrder The windows are returned in the order in+
−
    which they are stacked, with the top-most window being last in+
−
    the list.+
−
+
−
    \value ActivationHistoryOrder The windows are returned in the order in+
−
    which they were activated.+
−
+
−
    \sa subWindowList()+
−
*/+
−
+
−
/*!+
−
    \enum QMdiArea::ViewMode+
−
    \since 4.4+
−
+
−
    This enum describes the view mode of the area; i.e. how sub-windows+
−
    will be displayed.+
−
+
−
    \value SubWindowView Display sub-windows with window frames (default).+
−
    \value TabbedView Display sub-windows with tabs in a tab bar.+
−
+
−
    \sa setViewMode()+
−
*/+
−
+
−
#include "qmdiarea_p.h"+
−
+
−
#ifndef QT_NO_MDIAREA+
−
+
−
#include <QApplication>+
−
#include <QStyle>+
−
#if defined(Q_WS_MAC) && !defined(QT_NO_STYLE_MAC)+
−
#include <QMacStyle>+
−
#endif+
−
#include <QChildEvent>+
−
#include <QResizeEvent>+
−
#include <QScrollBar>+
−
#include <QtAlgorithms>+
−
#include <QMutableListIterator>+
−
#include <QPainter>+
−
#include <QFontMetrics>+
−
#include <QStyleOption>+
−
#include <QDesktopWidget>+
−
#include <QDebug>+
−
#include <qmath.h>+
−
#include <private/qlayoutengine_p.h>+
−
+
−
QT_BEGIN_NAMESPACE+
−
+
−
using namespace QMdi;+
−
+
−
// Asserts in debug mode, gives warning otherwise.+
−
static bool sanityCheck(const QMdiSubWindow * const child, const char *where)+
−
{+
−
    if (!child) {+
−
        const char error[] = "null pointer";+
−
        Q_ASSERT_X(false, where, error);+
−
        qWarning("%s:%s", where, error);+
−
        return false;+
−
    }+
−
    return true;+
−
}+
−
+
−
static bool sanityCheck(const QList<QWidget *> &widgets, const int index, const char *where)+
−
{+
−
    if (index < 0 || index >= widgets.size()) {+
−
        const char error[] = "index out of range";+
−
        Q_ASSERT_X(false, where, error);+
−
        qWarning("%s:%s", where, error);+
−
        return false;+
−
    }+
−
    if (!widgets.at(index)) {+
−
        const char error[] = "null pointer";+
−
        Q_ASSERT_X(false, where, error);+
−
        qWarning("%s:%s", where, error);+
−
        return false;+
−
    }+
−
    return true;+
−
}+
−
+
−
static void setIndex(int *index, int candidate, int min, int max, bool isIncreasing)+
−
{+
−
    if (!index)+
−
        return;+
−
+
−
    if (isIncreasing) {+
−
        if (candidate > max)+
−
            *index = min;+
−
        else+
−
            *index = qMax(candidate, min);+
−
    } else {+
−
        if (candidate < min)+
−
            *index = max;+
−
        else+
−
            *index = qMin(candidate, max);+
−
    }+
−
    Q_ASSERT(*index >= min && *index <= max);+
−
}+
−
+
−
static inline bool useScrollBar(const QRect &childrenRect, const QSize &maxViewportSize,+
−
                                Qt::Orientation orientation)+
−
{+
−
    if (orientation == Qt::Horizontal)+
−
        return  childrenRect.width() > maxViewportSize.width()+
−
                || childrenRect.left() < 0+
−
                || childrenRect.right() >= maxViewportSize.width();+
−
    else+
−
        return childrenRect.height() > maxViewportSize.height()+
−
               || childrenRect.top() < 0+
−
               || childrenRect.bottom() >= maxViewportSize.height();+
−
}+
−
+
−
// Returns the closest mdi area containing the widget (if any).+
−
static inline QMdiArea *mdiAreaParent(QWidget *widget)+
−
{+
−
    if (!widget)+
−
        return 0;+
−
+
−
    QWidget *parent = widget->parentWidget();+
−
    while (parent) {+
−
        if (QMdiArea *area = qobject_cast<QMdiArea *>(parent))+
−
            return area;+
−
        parent = parent->parentWidget();+
−
    }+
−
    return 0;+
−
}+
−
+
−
#ifndef QT_NO_TABWIDGET+
−
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;+
−
}+
−
#endif // QT_NO_TABWIDGET+
−
+
−
static inline QString tabTextFor(QMdiSubWindow *subWindow)+
−
{+
−
    if (!subWindow)+
−
        return QString();+
−
+
−
    QString title = subWindow->windowTitle();+
−
    if (subWindow->isWindowModified()) {+
−
        title.replace(QLatin1String("[*]"), QLatin1String("*"));+
−
    } else {+
−
        extern QString qt_setWindowTitle_helperHelper(const QString&, const QWidget*);+
−
        title = qt_setWindowTitle_helperHelper(title, subWindow);+
−
    }+
−
+
−
    return title.isEmpty() ? QMdiArea::tr("(Untitled)") : title;+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void RegularTiler::rearrange(QList<QWidget *> &widgets, const QRect &domain) const+
−
{+
−
    if (widgets.isEmpty())+
−
        return;+
−
+
−
    const int n = widgets.size();+
−
    const int ncols = qMax(qCeil(qSqrt(qreal(n))), 1);+
−
    const int nrows = qMax((n % ncols) ? (n / ncols + 1) : (n / ncols), 1);+
−
    const int nspecial = (n % ncols) ? (ncols - n % ncols) : 0;+
−
    const int dx = domain.width()  / ncols;+
−
    const int dy = domain.height() / nrows;+
−
+
−
    int i = 0;+
−
    for (int row = 0; row < nrows; ++row) {+
−
        const int y1 = int(row * (dy + 1));+
−
        for (int col = 0; col < ncols; ++col) {+
−
            if (row == 1 && col < nspecial)+
−
                continue;+
−
            const int x1 = int(col * (dx + 1));+
−
            int x2 = int(x1 + dx);+
−
            int y2 = int(y1 + dy);+
−
            if (row == 0 && col < nspecial) {+
−
                y2 *= 2;+
−
                if (nrows != 2)+
−
                    y2 += 1;+
−
                else+
−
                    y2 = domain.bottom();+
−
            }+
−
            if (col == ncols - 1 && x2 != domain.right())+
−
                x2 = domain.right();+
−
            if (row == nrows - 1 && y2 != domain.bottom())+
−
                y2 = domain.bottom();+
−
            if (!sanityCheck(widgets, i, "RegularTiler"))+
−
                continue;+
−
            QWidget *widget = widgets.at(i++);+
−
            QRect newGeometry = QRect(QPoint(x1, y1), QPoint(x2, y2));+
−
            widget->setGeometry(QStyle::visualRect(widget->layoutDirection(), domain, newGeometry));+
−
        }+
−
    }+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void SimpleCascader::rearrange(QList<QWidget *> &widgets, const QRect &domain) const+
−
{+
−
    if (widgets.isEmpty())+
−
        return;+
−
+
−
    // Tunables:+
−
    const int topOffset = 0;+
−
    const int bottomOffset = 50;+
−
    const int leftOffset = 0;+
−
    const int rightOffset = 100;+
−
    const int dx = 10;+
−
+
−
    QStyleOptionTitleBar options;+
−
    options.initFrom(widgets.at(0));+
−
    int titleBarHeight = widgets.at(0)->style()->pixelMetric(QStyle::PM_TitleBarHeight, &options, widgets.at(0));+
−
#if defined(Q_WS_MAC) && !defined(QT_NO_STYLE_MAC)+
−
    // ### Remove this after the mac style has been fixed+
−
    if (qobject_cast<QMacStyle *>(widgets.at(0)->style()))+
−
        titleBarHeight -= 4;+
−
#endif+
−
    const QFontMetrics fontMetrics = QFontMetrics(QApplication::font("QWorkspaceTitleBar"));+
−
    const int dy = qMax(titleBarHeight - (titleBarHeight - fontMetrics.height()) / 2, 1);+
−
+
−
    const int n = widgets.size();+
−
    const int nrows = qMax((domain.height() - (topOffset + bottomOffset)) / dy, 1);+
−
    const int ncols = qMax(n / nrows + ((n % nrows) ? 1 : 0), 1);+
−
    const int dcol = (domain.width() - (leftOffset + rightOffset)) / ncols;+
−
+
−
    int i = 0;+
−
    for (int row = 0; row < nrows; ++row) {+
−
        for (int col = 0; col < ncols; ++col) {+
−
            const int x = leftOffset + row * dx + col * dcol;+
−
            const int y = topOffset + row * dy;+
−
            if (!sanityCheck(widgets, i, "SimpleCascader"))+
−
                continue;+
−
            QWidget *widget = widgets.at(i++);+
−
            QRect newGeometry = QRect(QPoint(x, y), widget->sizeHint());+
−
            widget->setGeometry(QStyle::visualRect(widget->layoutDirection(), domain, newGeometry));+
−
            if (i == n)+
−
                return;+
−
        }+
−
    }+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void IconTiler::rearrange(QList<QWidget *> &widgets, const QRect &domain) const+
−
{+
−
    if (widgets.isEmpty() || !sanityCheck(widgets, 0, "IconTiler"))+
−
        return;+
−
+
−
    const int n = widgets.size();+
−
    const int width = widgets.at(0)->width();+
−
    const int height = widgets.at(0)->height();+
−
    const int ncols = qMax(domain.width() / width, 1);+
−
    const int nrows = n / ncols + ((n % ncols) ? 1 : 0);+
−
+
−
    int i = 0;+
−
    for (int row = 0; row < nrows; ++row) {+
−
        for (int col = 0; col < ncols; ++col) {+
−
            const int x = col * width;+
−
            const int y = domain.height() - height - row * height;+
−
            if (!sanityCheck(widgets, i, "IconTiler"))+
−
                continue;+
−
            QWidget *widget = widgets.at(i++);+
−
            QPoint newPos(x, y);+
−
            QRect newGeometry = QRect(newPos.x(), newPos.y(), widget->width(), widget->height());+
−
            widget->setGeometry(QStyle::visualRect(widget->layoutDirection(), domain, newGeometry));+
−
            if (i == n)+
−
                return;+
−
        }+
−
    }+
−
}+
−
+
−
/*!+
−
    \internal+
−
    Calculates the accumulated overlap (intersection area) between 'source' and 'rects'.+
−
*/+
−
int MinOverlapPlacer::accumulatedOverlap(const QRect &source, const QList<QRect> &rects)+
−
{+
−
    int accOverlap = 0;+
−
    foreach (const QRect &rect, rects) {+
−
        QRect intersection = source.intersected(rect);+
−
        accOverlap += intersection.width() * intersection.height();+
−
    }+
−
    return accOverlap;+
−
}+
−
+
−
+
−
/*!+
−
    \internal+
−
    Finds among 'source' the rectangle with the minimum accumulated overlap with the+
−
    rectangles in 'rects'.+
−
*/+
−
QRect MinOverlapPlacer::findMinOverlapRect(const QList<QRect> &source, const QList<QRect> &rects)+
−
{+
−
    int minAccOverlap = -1;+
−
    QRect minAccOverlapRect;+
−
    foreach (const QRect &srcRect, source) {+
−
        const int accOverlap = accumulatedOverlap(srcRect, rects);+
−
        if (accOverlap < minAccOverlap || minAccOverlap == -1) {+
−
            minAccOverlap = accOverlap;+
−
            minAccOverlapRect = srcRect;+
−
        }+
−
    }+
−
    return minAccOverlapRect;+
−
}+
−
+
−
/*!+
−
    \internal+
−
    Gets candidates for the final placement.+
−
*/+
−
void MinOverlapPlacer::getCandidatePlacements(const QSize &size, const QList<QRect> &rects,+
−
                                              const QRect &domain,QList<QRect> &candidates)+
−
{+
−
    QSet<int> xset;+
−
    QSet<int> yset;+
−
    xset << domain.left() << domain.right() - size.width() + 1;+
−
    yset << domain.top();+
−
    if (domain.bottom() - size.height() + 1 >= 0)+
−
        yset << domain.bottom() - size.height() + 1;+
−
    foreach (const QRect &rect, rects) {+
−
        xset << rect.right() + 1;+
−
        yset << rect.bottom() + 1;+
−
    }+
−
+
−
    QList<int> xlist = xset.values();+
−
    qSort(xlist.begin(), xlist.end());+
−
    QList<int> ylist = yset.values();+
−
    qSort(ylist.begin(), ylist.end());+
−
+
−
    foreach (int y, ylist)+
−
        foreach (int x, xlist)+
−
            candidates << QRect(QPoint(x, y), size);+
−
}+
−
+
−
/*!+
−
    \internal+
−
    Finds all rectangles in 'source' not completely inside 'domain'. The result is stored+
−
    in 'result' and also removed from 'source'.+
−
*/+
−
void MinOverlapPlacer::findNonInsiders(const QRect &domain, QList<QRect> &source,+
−
                                       QList<QRect> &result)+
−
{+
−
    QMutableListIterator<QRect> it(source);+
−
    while (it.hasNext()) {+
−
        const QRect srcRect = it.next();+
−
        if (!domain.contains(srcRect)) {+
−
            result << srcRect;+
−
            it.remove();+
−
        }+
−
    }+
−
}+
−
+
−
/*!+
−
   \internal+
−
    Finds all rectangles in 'source' that overlaps 'domain' by the maximum overlap area+
−
    between 'domain' and any rectangle in 'source'. The result is stored in 'result'.+
−
*/+
−
void MinOverlapPlacer::findMaxOverlappers(const QRect &domain, const QList<QRect> &source,+
−
                                          QList<QRect> &result)+
−
{+
−
    int maxOverlap = -1;+
−
    foreach (const QRect &srcRect, source) {+
−
        QRect intersection = domain.intersected(srcRect);+
−
        const int overlap = intersection.width() * intersection.height();+
−
        if (overlap >= maxOverlap || maxOverlap == -1) {+
−
            if (overlap > maxOverlap) {+
−
                maxOverlap = overlap;+
−
                result.clear();+
−
            }+
−
            result << srcRect;+
−
        }+
−
    }+
−
}+
−
+
−
/*!+
−
   \internal+
−
    Finds among the rectangles in 'source' the best placement. Here, 'best' means the+
−
    placement that overlaps the rectangles in 'rects' as little as possible while at the+
−
    same time being as much as possible inside 'domain'.+
−
*/+
−
QPoint MinOverlapPlacer::findBestPlacement(const QRect &domain, const QList<QRect> &rects,+
−
                                           QList<QRect> &source)+
−
{+
−
    QList<QRect> nonInsiders;+
−
    findNonInsiders(domain, source, nonInsiders);+
−
+
−
    if (!source.empty())+
−
        return findMinOverlapRect(source, rects).topLeft();+
−
+
−
    QList<QRect> maxOverlappers;+
−
    findMaxOverlappers(domain, nonInsiders, maxOverlappers);+
−
    return findMinOverlapRect(maxOverlappers, rects).topLeft();+
−
}+
−
+
−
+
−
/*!+
−
    \internal+
−
    Places the rectangle defined by 'size' relative to 'rects' and 'domain' so that it+
−
    overlaps 'rects' as little as possible and 'domain' as much as possible.+
−
    Returns the position of the resulting rectangle.+
−
*/+
−
QPoint MinOverlapPlacer::place(const QSize &size, const QList<QRect> &rects,+
−
                               const QRect &domain) const+
−
{+
−
    if (size.isEmpty() || !domain.isValid())+
−
        return QPoint();+
−
    foreach (const QRect &rect, rects) {+
−
        if (!rect.isValid())+
−
            return QPoint();+
−
    }+
−
+
−
    QList<QRect> candidates;+
−
    getCandidatePlacements(size, rects, domain, candidates);+
−
    return findBestPlacement(domain, rects, candidates);+
−
}+
−
+
−
#ifndef QT_NO_TABBAR+
−
class QMdiAreaTabBar : public QTabBar+
−
{+
−
public:+
−
    QMdiAreaTabBar(QWidget *parent) : QTabBar(parent) {}+
−
+
−
protected:+
−
    void mousePressEvent(QMouseEvent *event);+
−
#ifndef QT_NO_CONTEXTMENU+
−
    void contextMenuEvent(QContextMenuEvent *event);+
−
#endif+
−
+
−
private:+
−
    QMdiSubWindow *subWindowFromIndex(int index) const;+
−
};+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void QMdiAreaTabBar::mousePressEvent(QMouseEvent *event)+
−
{+
−
    if (event->button() != Qt::MidButton) {+
−
        QTabBar::mousePressEvent(event);+
−
        return;+
−
    }+
−
+
−
    QMdiSubWindow *subWindow = subWindowFromIndex(tabAt(event->pos()));+
−
    if (!subWindow) {+
−
        event->ignore();+
−
        return;+
−
    }+
−
+
−
    subWindow->close();+
−
}+
−
+
−
#ifndef QT_NO_CONTEXTMENU+
−
/*!+
−
    \internal+
−
*/+
−
void QMdiAreaTabBar::contextMenuEvent(QContextMenuEvent *event)+
−
{+
−
    QPointer<QMdiSubWindow> subWindow = subWindowFromIndex(tabAt(event->pos()));+
−
    if (!subWindow || subWindow->isHidden()) {+
−
        event->ignore();+
−
        return;+
−
    }+
−
+
−
#ifndef QT_NO_MENU+
−
    QMdiSubWindowPrivate *subWindowPrivate = subWindow->d_func();+
−
    if (!subWindowPrivate->systemMenu) {+
−
        event->ignore();+
−
        return;+
−
    }+
−
+
−
    QMdiSubWindow *currentSubWindow = subWindowFromIndex(currentIndex());+
−
    Q_ASSERT(currentSubWindow);+
−
+
−
    // We don't want these actions to show up in the system menu when the+
−
    // current sub-window is maximized, i.e. covers the entire viewport.+
−
    if (currentSubWindow->isMaximized()) {+
−
        subWindowPrivate->setVisible(QMdiSubWindowPrivate::MoveAction, false);+
−
        subWindowPrivate->setVisible(QMdiSubWindowPrivate::ResizeAction, false);+
−
        subWindowPrivate->setVisible(QMdiSubWindowPrivate::MinimizeAction, false);+
−
        subWindowPrivate->setVisible(QMdiSubWindowPrivate::MaximizeAction, false);+
−
        subWindowPrivate->setVisible(QMdiSubWindowPrivate::MaximizeAction, false);+
−
        subWindowPrivate->setVisible(QMdiSubWindowPrivate::StayOnTopAction, false);+
−
    }+
−
+
−
    // Show system menu.+
−
    subWindowPrivate->systemMenu->exec(event->globalPos());+
−
    if (!subWindow)+
−
        return;+
−
+
−
    // Restore action visibility.+
−
    subWindowPrivate->updateActions();+
−
#endif // QT_NO_MENU+
−
}+
−
#endif // QT_NO_CONTEXTMENU+
−
+
−
/*!+
−
    \internal+
−
*/+
−
QMdiSubWindow *QMdiAreaTabBar::subWindowFromIndex(int index) const+
−
{+
−
    if (index < 0 || index >= count())+
−
        return 0;+
−
+
−
    QMdiArea *mdiArea = qobject_cast<QMdiArea *>(parentWidget());+
−
    Q_ASSERT(mdiArea);+
−
+
−
    const QList<QMdiSubWindow *> subWindows = mdiArea->subWindowList();+
−
    Q_ASSERT(index < subWindows.size());+
−
+
−
    QMdiSubWindow *subWindow = mdiArea->subWindowList().at(index);+
−
    Q_ASSERT(subWindow);+
−
+
−
    return subWindow;+
−
}+
−
#endif // QT_NO_TABBAR+
−
+
−
/*!+
−
    \internal+
−
*/+
−
QMdiAreaPrivate::QMdiAreaPrivate()+
−
    : cascader(0),+
−
      regularTiler(0),+
−
      iconTiler(0),+
−
      placer(0),+
−
#ifndef QT_NO_RUBBERBAND+
−
      rubberBand(0),+
−
#endif+
−
#ifndef QT_NO_TABBAR+
−
      tabBar(0),+
−
#endif+
−
      activationOrder(QMdiArea::CreationOrder),+
−
      viewMode(QMdiArea::SubWindowView),+
−
#ifndef QT_NO_TABBAR+
−
      documentMode(false),+
−
#endif+
−
#ifndef QT_NO_TABWIDGET+
−
      tabShape(QTabWidget::Rounded),+
−
      tabPosition(QTabWidget::North),+
−
#endif+
−
      ignoreGeometryChange(false),+
−
      ignoreWindowStateChange(false),+
−
      isActivated(false),+
−
      isSubWindowsTiled(false),+
−
      showActiveWindowMaximized(false),+
−
      tileCalledFromResizeEvent(false),+
−
      updatesDisabledByUs(false),+
−
      inViewModeChange(false),+
−
      indexToNextWindow(-1),+
−
      indexToPreviousWindow(-1),+
−
      indexToHighlighted(-1),+
−
      indexToLastActiveTab(-1),+
−
      resizeTimerId(-1),+
−
      tabToPreviousTimerId(-1)+
−
{+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void QMdiAreaPrivate::_q_deactivateAllWindows(QMdiSubWindow *aboutToActivate)+
−
{+
−
    if (ignoreWindowStateChange)+
−
        return;+
−
+
−
    Q_Q(QMdiArea);+
−
    if (!aboutToActivate)+
−
        aboutToBecomeActive = qobject_cast<QMdiSubWindow *>(q->sender());+
−
    else+
−
        aboutToBecomeActive = aboutToActivate;+
−
    Q_ASSERT(aboutToBecomeActive);+
−
+
−
    foreach (QMdiSubWindow *child, childWindows) {+
−
        if (!sanityCheck(child, "QMdiArea::deactivateAllWindows") || aboutToBecomeActive == child)+
−
            continue;+
−
        // We don't want to handle signals caused by child->showNormal().+
−
        ignoreWindowStateChange = true;+
−
        if(!(options & QMdiArea::DontMaximizeSubWindowOnActivation) && !showActiveWindowMaximized)+
−
            showActiveWindowMaximized = child->isMaximized() && child->isVisible();+
−
        if (showActiveWindowMaximized && child->isMaximized()) {+
−
            if (q->updatesEnabled()) {+
−
                updatesDisabledByUs = true;+
−
                q->setUpdatesEnabled(false);+
−
            }+
−
            child->showNormal();+
−
        }+
−
        if (child->isMinimized() && !child->isShaded() && !windowStaysOnTop(child))+
−
            child->lower();+
−
        ignoreWindowStateChange = false;+
−
        child->d_func()->setActive(false);+
−
    }+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void QMdiAreaPrivate::_q_processWindowStateChanged(Qt::WindowStates oldState,+
−
                                                   Qt::WindowStates newState)+
−
{+
−
    if (ignoreWindowStateChange)+
−
        return;+
−
+
−
    Q_Q(QMdiArea);+
−
    QMdiSubWindow *child = qobject_cast<QMdiSubWindow *>(q->sender());+
−
    if (!child)+
−
        return;+
−
+
−
    // windowActivated+
−
    if (!(oldState & Qt::WindowActive) && (newState & Qt::WindowActive))+
−
        emitWindowActivated(child);+
−
    // windowDeactivated+
−
    else if ((oldState & Qt::WindowActive) && !(newState & Qt::WindowActive))+
−
        resetActiveWindow(child);+
−
+
−
    // windowMinimized+
−
    if (!(oldState & Qt::WindowMinimized) && (newState & Qt::WindowMinimized)) {+
−
        isSubWindowsTiled = false;+
−
        arrangeMinimizedSubWindows();+
−
    // windowMaximized+
−
    } else if (!(oldState & Qt::WindowMaximized) && (newState & Qt::WindowMaximized)) {+
−
        internalRaise(child);+
−
    // windowRestored+
−
    } else if (!(newState & (Qt::WindowMaximized | Qt::WindowMinimized))) {+
−
        internalRaise(child);+
−
        if (oldState & Qt::WindowMinimized)+
−
            arrangeMinimizedSubWindows();+
−
    }+
−
}+
−
+
−
void QMdiAreaPrivate::_q_currentTabChanged(int index)+
−
{+
−
#ifdef QT_NO_TABBAR+
−
    Q_UNUSED(index);+
−
#else+
−
    if (!tabBar || index < 0)+
−
        return;+
−
+
−
    // If the previous active sub-window was hidden, disable the tab.+
−
    if (indexToLastActiveTab >= 0 && indexToLastActiveTab < tabBar->count()+
−
        && indexToLastActiveTab < childWindows.count()) {+
−
        QMdiSubWindow *lastActive = childWindows.at(indexToLastActiveTab);+
−
        if (lastActive && lastActive->isHidden())+
−
            tabBar->setTabEnabled(indexToLastActiveTab, false);+
−
    }+
−
+
−
    indexToLastActiveTab = index;+
−
    Q_ASSERT(childWindows.size() > index);+
−
    QMdiSubWindow *subWindow = childWindows.at(index);+
−
    Q_ASSERT(subWindow);+
−
    activateWindow(subWindow);+
−
#endif // QT_NO_TABBAR+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void QMdiAreaPrivate::appendChild(QMdiSubWindow *child)+
−
{+
−
    Q_Q(QMdiArea);+
−
    Q_ASSERT(child && childWindows.indexOf(child) == -1);+
−
+
−
    if (child->parent() != viewport)+
−
        child->setParent(viewport, child->windowFlags());+
−
    childWindows.append(QPointer<QMdiSubWindow>(child));+
−
+
−
    if (!child->testAttribute(Qt::WA_Resized) && q->isVisible()) {+
−
        QSize newSize(child->sizeHint().boundedTo(viewport->size()));+
−
        child->resize(newSize.expandedTo(qSmartMinSize(child)));+
−
    }+
−
+
−
    if (!placer)+
−
        placer = new MinOverlapPlacer;+
−
    place(placer, child);+
−
+
−
    if (hbarpolicy != Qt::ScrollBarAlwaysOff)+
−
        child->setOption(QMdiSubWindow::AllowOutsideAreaHorizontally, true);+
−
    else+
−
        child->setOption(QMdiSubWindow::AllowOutsideAreaHorizontally, false);+
−
+
−
    if (vbarpolicy != Qt::ScrollBarAlwaysOff)+
−
        child->setOption(QMdiSubWindow::AllowOutsideAreaVertically, true);+
−
    else+
−
        child->setOption(QMdiSubWindow::AllowOutsideAreaVertically, false);+
−
+
−
    internalRaise(child);+
−
    indicesToActivatedChildren.prepend(childWindows.size() - 1);+
−
    Q_ASSERT(indicesToActivatedChildren.size() == childWindows.size());+
−
+
−
#ifndef QT_NO_TABBAR+
−
    if (tabBar) {+
−
        tabBar->addTab(child->windowIcon(), tabTextFor(child));+
−
        updateTabBarGeometry();+
−
        if (childWindows.count() == 1 && !(options & QMdiArea::DontMaximizeSubWindowOnActivation))+
−
            showActiveWindowMaximized = true;+
−
    }+
−
#endif+
−
+
−
    if (!(child->windowFlags() & Qt::SubWindow))+
−
        child->setWindowFlags(Qt::SubWindow);+
−
    child->installEventFilter(q);+
−
+
−
    QObject::connect(child, SIGNAL(aboutToActivate()), q, SLOT(_q_deactivateAllWindows()));+
−
    QObject::connect(child, SIGNAL(windowStateChanged(Qt::WindowStates,Qt::WindowStates)),+
−
                     q, SLOT(_q_processWindowStateChanged(Qt::WindowStates,Qt::WindowStates)));+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void QMdiAreaPrivate::place(Placer *placer, QMdiSubWindow *child)+
−
{+
−
    if (!placer || !child)+
−
        return;+
−
+
−
    Q_Q(QMdiArea);+
−
    if (!q->isVisible()) {+
−
        // The window is only laid out when it's added to QMdiArea,+
−
        // so there's no need to check that we don't have it in the+
−
        // list already. appendChild() ensures that.+
−
        pendingPlacements.append(child);+
−
        return;+
−
    }+
−
+
−
    QList<QRect> rects;+
−
    QRect parentRect = q->rect();+
−
    foreach (QMdiSubWindow *window, childWindows) {+
−
        if (!sanityCheck(window, "QMdiArea::place") || window == child || !window->isVisibleTo(q)+
−
                || !window->testAttribute(Qt::WA_Moved)) {+
−
            continue;+
−
        }+
−
        QRect occupiedGeometry;+
−
        if (window->isMaximized()) {+
−
            occupiedGeometry = QRect(window->d_func()->oldGeometry.topLeft(),+
−
                                     window->d_func()->restoreSize);+
−
        } else {+
−
            occupiedGeometry = window->geometry();+
−
        }+
−
        rects.append(QStyle::visualRect(child->layoutDirection(), parentRect, occupiedGeometry));+
−
    }+
−
    QPoint newPos = placer->place(child->size(), rects, parentRect);+
−
    QRect newGeometry = QRect(newPos.x(), newPos.y(), child->width(), child->height());+
−
    child->setGeometry(QStyle::visualRect(child->layoutDirection(), parentRect, newGeometry));+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void QMdiAreaPrivate::rearrange(Rearranger *rearranger)+
−
{+
−
    if (!rearranger)+
−
        return;+
−
+
−
    Q_Q(QMdiArea);+
−
    if (!q->isVisible()) {+
−
        // Compress if we already have the rearranger in the list.+
−
        int index = pendingRearrangements.indexOf(rearranger);+
−
        if (index != -1)+
−
            pendingRearrangements.move(index, pendingRearrangements.size() - 1);+
−
        else+
−
            pendingRearrangements.append(rearranger);+
−
        return;+
−
    }+
−
+
−
    QList<QWidget *> widgets;+
−
    const bool reverseList = rearranger->type() == Rearranger::RegularTiler;+
−
    const QList<QMdiSubWindow *> subWindows = subWindowList(activationOrder, reverseList);+
−
    QSize minSubWindowSize;+
−
    foreach (QMdiSubWindow *child, subWindows) {+
−
        if (!sanityCheck(child, "QMdiArea::rearrange") || !child->isVisible())+
−
            continue;+
−
        if (rearranger->type() == Rearranger::IconTiler) {+
−
            if (child->isMinimized() && !child->isShaded() && !(child->windowFlags() & Qt::FramelessWindowHint))+
−
                widgets.append(child);+
−
        } else {+
−
            if (child->isMinimized() && !child->isShaded())+
−
                continue;+
−
            if (child->isMaximized() || child->isShaded())+
−
                child->showNormal();+
−
            minSubWindowSize = minSubWindowSize.expandedTo(child->minimumSize())+
−
                               .expandedTo(child->d_func()->internalMinimumSize);+
−
            widgets.append(child);+
−
        }+
−
    }+
−
+
−
    if (active && rearranger->type() == Rearranger::RegularTiler) {+
−
        // Move active window in front if necessary. That's the case if we+
−
        // have any windows with staysOnTopHint set.+
−
        int indexToActive = widgets.indexOf((QWidget *)active);+
−
        if (indexToActive > 0)+
−
            widgets.move(indexToActive, 0);+
−
    }+
−
+
−
    QRect domain = viewport->rect();+
−
    if (rearranger->type() == Rearranger::RegularTiler && !widgets.isEmpty())+
−
        domain = resizeToMinimumTileSize(minSubWindowSize, widgets.count());+
−
+
−
    rearranger->rearrange(widgets, domain);+
−
+
−
    if (rearranger->type() == Rearranger::RegularTiler && !widgets.isEmpty()) {+
−
        isSubWindowsTiled = true;+
−
        updateScrollBars();+
−
    } else if (rearranger->type() == Rearranger::SimpleCascader) {+
−
        isSubWindowsTiled = false;+
−
    }+
−
}+
−
+
−
/*!+
−
    \internal+
−
+
−
    Arranges all minimized windows at the bottom of the workspace.+
−
*/+
−
void QMdiAreaPrivate::arrangeMinimizedSubWindows()+
−
{+
−
    if (!iconTiler)+
−
        iconTiler = new IconTiler;+
−
    rearrange(iconTiler);+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void QMdiAreaPrivate::activateWindow(QMdiSubWindow *child)+
−
{+
−
    if (childWindows.isEmpty()) {+
−
        Q_ASSERT(!child);+
−
        Q_ASSERT(!active);+
−
        return;+
−
    }+
−
+
−
    if (!child) {+
−
        if (active) {+
−
            Q_ASSERT(active->d_func()->isActive);+
−
            active->d_func()->setActive(false);+
−
            resetActiveWindow();+
−
        }+
−
        return;+
−
    }+
−
+
−
    if (child->isHidden() || child == active)+
−
        return;+
−
    child->d_func()->setActive(true);+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void QMdiAreaPrivate::activateCurrentWindow()+
−
{+
−
    QMdiSubWindow *current = q_func()->currentSubWindow();+
−
    if (current && !isExplicitlyDeactivated(current)) {+
−
        current->d_func()->activationEnabled = true;+
−
        current->d_func()->setActive(true, /*changeFocus=*/false);+
−
    }+
−
}+
−
+
−
void QMdiAreaPrivate::activateHighlightedWindow()+
−
{+
−
    if (indexToHighlighted < 0)+
−
        return;+
−
+
−
    Q_ASSERT(indexToHighlighted < childWindows.size());+
−
    if (tabToPreviousTimerId != -1)+
−
        activateWindow(nextVisibleSubWindow(-1, QMdiArea::ActivationHistoryOrder));+
−
    else+
−
        activateWindow(childWindows.at(indexToHighlighted));+
−
#ifndef QT_NO_RUBBERBAND+
−
    hideRubberBand();+
−
#endif+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void QMdiAreaPrivate::emitWindowActivated(QMdiSubWindow *activeWindow)+
−
{+
−
    Q_Q(QMdiArea);+
−
    Q_ASSERT(activeWindow);+
−
    if (activeWindow == active)+
−
        return;+
−
    Q_ASSERT(activeWindow->d_func()->isActive);+
−
+
−
    if (!aboutToBecomeActive)+
−
        _q_deactivateAllWindows(activeWindow);+
−
    Q_ASSERT(aboutToBecomeActive);+
−
+
−
    // This is true only if 'DontMaximizeSubWindowOnActivation' is disabled+
−
    // and the previous active window was maximized.+
−
    if (showActiveWindowMaximized) {+
−
        if (!activeWindow->isMaximized())+
−
            activeWindow->showMaximized();+
−
        showActiveWindowMaximized = false;+
−
    }+
−
+
−
    // Put in front to update activation order.+
−
    const int indexToActiveWindow = childWindows.indexOf(activeWindow);+
−
    Q_ASSERT(indexToActiveWindow != -1);+
−
    const int index = indicesToActivatedChildren.indexOf(indexToActiveWindow);+
−
    Q_ASSERT(index != -1);+
−
    indicesToActivatedChildren.move(index, 0);+
−
    internalRaise(activeWindow);+
−
+
−
    if (updatesDisabledByUs) {+
−
        q->setUpdatesEnabled(true);+
−
        updatesDisabledByUs = false;+
−
    }+
−
+
−
    Q_ASSERT(aboutToBecomeActive == activeWindow);+
−
    active = activeWindow;+
−
    aboutToBecomeActive = 0;+
−
    Q_ASSERT(active->d_func()->isActive);+
−
+
−
#ifndef QT_NO_TABBAR+
−
    if (tabBar && tabBar->currentIndex() != indexToActiveWindow)+
−
        tabBar->setCurrentIndex(indexToActiveWindow);+
−
#endif+
−
+
−
    if (active->isMaximized() && scrollBarsEnabled())+
−
        updateScrollBars();+
−
+
−
    emit q->subWindowActivated(active);+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void QMdiAreaPrivate::resetActiveWindow(QMdiSubWindow *deactivatedWindow)+
−
{+
−
    Q_Q(QMdiArea);+
−
    if (deactivatedWindow) {+
−
        if (deactivatedWindow != active)+
−
            return;+
−
        active = 0;+
−
        if ((aboutToBecomeActive || isActivated || lastWindowAboutToBeDestroyed())+
−
            && !isExplicitlyDeactivated(deactivatedWindow) && !q->window()->isMinimized()) {+
−
            return;+
−
        }+
−
        emit q->subWindowActivated(0);+
−
        return;+
−
    }+
−
+
−
    if (aboutToBecomeActive)+
−
        return;+
−
+
−
    active = 0;+
−
    emit q->subWindowActivated(0);+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void QMdiAreaPrivate::updateActiveWindow(int removedIndex, bool activeRemoved)+
−
{+
−
    Q_ASSERT(indicesToActivatedChildren.size() == childWindows.size());+
−
+
−
#ifndef QT_NO_TABBAR+
−
    if (tabBar && removedIndex >= 0) {+
−
        tabBar->blockSignals(true);+
−
        tabBar->removeTab(removedIndex);+
−
        updateTabBarGeometry();+
−
        tabBar->blockSignals(false);+
−
    }+
−
#endif+
−
+
−
    if (childWindows.isEmpty()) {+
−
        showActiveWindowMaximized = false;+
−
        resetActiveWindow();+
−
        return;+
−
    }+
−
+
−
    if (indexToHighlighted >= 0) {+
−
#ifndef QT_NO_RUBBERBAND+
−
        // Hide rubber band if highlighted window is removed.+
−
        if (indexToHighlighted == removedIndex)+
−
            hideRubberBand();+
−
        else+
−
#endif+
−
        // or update index if necessary.+
−
        if (indexToHighlighted > removedIndex)+
−
            --indexToHighlighted;+
−
    }+
−
+
−
    // Update indices list+
−
    for (int i = 0; i < indicesToActivatedChildren.size(); ++i) {+
−
        int *index = &indicesToActivatedChildren[i];+
−
        if (*index > removedIndex)+
−
            --*index;+
−
    }+
−
+
−
    if (!activeRemoved)+
−
        return;+
−
+
−
    // Activate next window.+
−
    QMdiSubWindow *next = nextVisibleSubWindow(0, activationOrder, removedIndex);+
−
    if (next)+
−
        activateWindow(next);+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void QMdiAreaPrivate::updateScrollBars()+
−
{+
−
    if (ignoreGeometryChange || !scrollBarsEnabled())+
−
        return;+
−
+
−
    Q_Q(QMdiArea);+
−
    QSize maxSize = q->maximumViewportSize();+
−
    QSize hbarExtent = hbar->sizeHint();+
−
    QSize vbarExtent = vbar->sizeHint();+
−
+
−
    if (q->style()->styleHint(QStyle::SH_ScrollView_FrameOnlyAroundContents, 0, q)) {+
−
        const int doubleFrameWidth = frameWidth * 2;+
−
        if (hbarpolicy == Qt::ScrollBarAlwaysOn)+
−
            maxSize.rheight() -= doubleFrameWidth;+
−
        if (vbarpolicy == Qt::ScrollBarAlwaysOn)+
−
            maxSize.rwidth() -= doubleFrameWidth;+
−
        hbarExtent.rheight() += doubleFrameWidth;+
−
        vbarExtent.rwidth() += doubleFrameWidth;+
−
    }+
−
+
−
    const QRect childrenRect = active && active->isMaximized()+
−
                               ? active->geometry() : viewport->childrenRect();+
−
    bool useHorizontalScrollBar = useScrollBar(childrenRect, maxSize, Qt::Horizontal);+
−
    bool useVerticalScrollBar = useScrollBar(childrenRect, maxSize, Qt::Vertical);+
−
+
−
    if (useHorizontalScrollBar && !useVerticalScrollBar) {+
−
        const QSize max = maxSize - QSize(0, hbarExtent.height());+
−
        useVerticalScrollBar = useScrollBar(childrenRect, max, Qt::Vertical);+
−
    }+
−
+
−
    if (useVerticalScrollBar && !useHorizontalScrollBar) {+
−
        const QSize max = maxSize - QSize(vbarExtent.width(), 0);+
−
        useHorizontalScrollBar = useScrollBar(childrenRect, max, Qt::Horizontal);+
−
    }+
−
+
−
    if (useHorizontalScrollBar && hbarpolicy != Qt::ScrollBarAlwaysOn)+
−
        maxSize.rheight() -= hbarExtent.height();+
−
    if (useVerticalScrollBar && vbarpolicy != Qt::ScrollBarAlwaysOn)+
−
        maxSize.rwidth() -= vbarExtent.width();+
−
+
−
    QRect viewportRect(QPoint(0, 0), maxSize);+
−
    const int startX = q->isLeftToRight() ? childrenRect.left() : viewportRect.right()+
−
                                                                  - childrenRect.right();+
−
+
−
    // Horizontal scroll bar.+
−
    if (isSubWindowsTiled && hbar->value() != 0)+
−
        hbar->setValue(0);+
−
    const int xOffset = startX + hbar->value();+
−
    hbar->setRange(qMin(0, xOffset),+
−
                   qMax(0, xOffset + childrenRect.width() - viewportRect.width()));+
−
    hbar->setPageStep(childrenRect.width());+
−
    hbar->setSingleStep(childrenRect.width() / 20);+
−
+
−
    // Vertical scroll bar.+
−
    if (isSubWindowsTiled && vbar->value() != 0)+
−
        vbar->setValue(0);+
−
    const int yOffset = childrenRect.top() + vbar->value();+
−
    vbar->setRange(qMin(0, yOffset),+
−
                   qMax(0, yOffset + childrenRect.height() - viewportRect.height()));+
−
    vbar->setPageStep(childrenRect.height());+
−
    vbar->setSingleStep(childrenRect.height() / 20);+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void QMdiAreaPrivate::internalRaise(QMdiSubWindow *mdiChild) const+
−
{+
−
    if (!sanityCheck(mdiChild, "QMdiArea::internalRaise") || childWindows.size() < 2)+
−
        return;+
−
+
−
    QMdiSubWindow *stackUnderChild = 0;+
−
    if (!windowStaysOnTop(mdiChild)) {+
−
        foreach (QObject *object, viewport->children()) {+
−
            QMdiSubWindow *child = qobject_cast<QMdiSubWindow *>(object);+
−
            if (!child || !childWindows.contains(child))+
−
                continue;+
−
            if (!child->isHidden() && windowStaysOnTop(child)) {+
−
                if (stackUnderChild)+
−
                    child->stackUnder(stackUnderChild);+
−
                else+
−
                    child->raise();+
−
                stackUnderChild = child;+
−
            }+
−
        }+
−
    }+
−
+
−
    if (stackUnderChild)+
−
        mdiChild->stackUnder(stackUnderChild);+
−
    else+
−
        mdiChild->raise();+
−
}+
−
+
−
QRect QMdiAreaPrivate::resizeToMinimumTileSize(const QSize &minSubWindowSize, int subWindowCount)+
−
{+
−
    Q_Q(QMdiArea);+
−
    if (!minSubWindowSize.isValid() || subWindowCount <= 0)+
−
        return viewport->rect();+
−
+
−
    // Calculate minimum size.+
−
    const int columns = qMax(qCeil(qSqrt(qreal(subWindowCount))), 1);+
−
    const int rows = qMax((subWindowCount % columns) ? (subWindowCount / columns + 1)+
−
                                                     : (subWindowCount / columns), 1);+
−
    const int minWidth = minSubWindowSize.width() * columns;+
−
    const int minHeight = minSubWindowSize.height() * rows;+
−
+
−
    // Increase area size if necessary. Scroll bars are provided if we're not able+
−
    // to resize to the minimum size.+
−
    if (!tileCalledFromResizeEvent) {+
−
        QWidget *topLevel = q;+
−
        // Find the topLevel for this area, either a real top-level or a sub-window.+
−
        while (topLevel && !topLevel->isWindow() && topLevel->windowType() != Qt::SubWindow)+
−
            topLevel = topLevel->parentWidget();+
−
        // We don't want sub-subwindows to be placed at the edge, thus add 2 pixels.+
−
        int minAreaWidth = minWidth + left + right + 2;+
−
        int minAreaHeight = minHeight + top + bottom + 2;+
−
        if (hbar->isVisible())+
−
            minAreaHeight += hbar->height();+
−
        if (vbar->isVisible())+
−
            minAreaWidth += vbar->width();+
−
        if (q->style()->styleHint(QStyle::SH_ScrollView_FrameOnlyAroundContents, 0, q)) {+
−
            const int frame = q->style()->pixelMetric(QStyle::PM_DefaultFrameWidth, 0, q);+
−
            minAreaWidth += 2 * frame;+
−
            minAreaHeight += 2 * frame;+
−
        }+
−
        const QSize diff = QSize(minAreaWidth, minAreaHeight).expandedTo(q->size()) - q->size();+
−
        topLevel->resize(topLevel->size() + diff);+
−
    }+
−
+
−
    QRect domain = viewport->rect();+
−
+
−
    // Adjust domain width and provide horizontal scroll bar.+
−
    if (domain.width() < minWidth) {+
−
        domain.setWidth(minWidth);+
−
        if (hbarpolicy == Qt::ScrollBarAlwaysOff)+
−
            q->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);+
−
        else+
−
            hbar->setValue(0);+
−
    }+
−
    // Adjust domain height and provide vertical scroll bar.+
−
    if (domain.height() < minHeight) {+
−
        domain.setHeight(minHeight);+
−
        if (vbarpolicy  == Qt::ScrollBarAlwaysOff)+
−
            q->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);+
−
        else+
−
            vbar->setValue(0);+
−
    }+
−
    return domain;+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
bool QMdiAreaPrivate::scrollBarsEnabled() const+
−
{+
−
    return hbarpolicy != Qt::ScrollBarAlwaysOff || vbarpolicy != Qt::ScrollBarAlwaysOff;+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
bool QMdiAreaPrivate::lastWindowAboutToBeDestroyed() const+
−
{+
−
    if (childWindows.count() != 1)+
−
        return false;+
−
+
−
    QMdiSubWindow *last = childWindows.at(0);+
−
    if (!last)+
−
        return true;+
−
+
−
    if (!last->testAttribute(Qt::WA_DeleteOnClose))+
−
        return false;+
−
+
−
    return last->d_func()->data.is_closing;+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void QMdiAreaPrivate::setChildActivationEnabled(bool enable, bool onlyNextActivationEvent) const+
−
{+
−
    foreach (QMdiSubWindow *subWindow, childWindows) {+
−
        if (!subWindow || !subWindow->isVisible())+
−
            continue;+
−
        if (onlyNextActivationEvent)+
−
            subWindow->d_func()->ignoreNextActivationEvent = !enable;+
−
        else+
−
            subWindow->d_func()->activationEnabled = enable;+
−
    }+
−
}+
−
+
−
/*!+
−
    \internal+
−
    \reimp+
−
*/+
−
void QMdiAreaPrivate::scrollBarPolicyChanged(Qt::Orientation orientation, Qt::ScrollBarPolicy policy)+
−
{+
−
    if (childWindows.isEmpty())+
−
        return;+
−
+
−
    const QMdiSubWindow::SubWindowOption option = orientation == Qt::Horizontal ?+
−
        QMdiSubWindow::AllowOutsideAreaHorizontally : QMdiSubWindow::AllowOutsideAreaVertically;+
−
    const bool enable = policy != Qt::ScrollBarAlwaysOff;+
−
    foreach (QMdiSubWindow *child, childWindows) {+
−
        if (!sanityCheck(child, "QMdiArea::scrollBarPolicyChanged"))+
−
            continue;+
−
        child->setOption(option, enable);+
−
    }+
−
    updateScrollBars();+
−
}+
−
+
−
QList<QMdiSubWindow*>+
−
QMdiAreaPrivate::subWindowList(QMdiArea::WindowOrder order, bool reversed) const+
−
{+
−
    QList<QMdiSubWindow *> list;+
−
    if (childWindows.isEmpty())+
−
        return list;+
−
+
−
    if (order == QMdiArea::CreationOrder) {+
−
        foreach (QMdiSubWindow *child, childWindows) {+
−
            if (!child)+
−
                continue;+
−
            if (!reversed)+
−
                list.append(child);+
−
            else+
−
                list.prepend(child);+
−
        }+
−
    } else if (order == QMdiArea::StackingOrder) {+
−
        foreach (QObject *object, viewport->children()) {+
−
            QMdiSubWindow *child = qobject_cast<QMdiSubWindow *>(object);+
−
            if (!child || !childWindows.contains(child))+
−
                continue;+
−
            if (!reversed)+
−
                list.append(child);+
−
            else+
−
                list.prepend(child);+
−
        }+
−
    } else { // ActivationHistoryOrder+
−
        Q_ASSERT(indicesToActivatedChildren.size() == childWindows.size());+
−
        for (int i = indicesToActivatedChildren.count() - 1; i >= 0; --i) {+
−
            QMdiSubWindow *child = childWindows.at(indicesToActivatedChildren.at(i));+
−
            if (!child)+
−
                continue;+
−
            if (!reversed)+
−
                list.append(child);+
−
            else+
−
                list.prepend(child);+
−
        }+
−
    }+
−
    return list;+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void QMdiAreaPrivate::disconnectSubWindow(QObject *subWindow)+
−
{+
−
    if (!subWindow)+
−
        return;+
−
+
−
    Q_Q(QMdiArea);+
−
    QObject::disconnect(subWindow, 0, q, 0);+
−
    subWindow->removeEventFilter(q);+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
QMdiSubWindow *QMdiAreaPrivate::nextVisibleSubWindow(int increaseFactor, QMdiArea::WindowOrder order,+
−
                                                     int removedIndex, int fromIndex) const+
−
{+
−
    if (childWindows.isEmpty())+
−
        return 0;+
−
+
−
    Q_Q(const QMdiArea);+
−
    const QList<QMdiSubWindow *> subWindows = q->subWindowList(order);+
−
    QMdiSubWindow *current = 0;+
−
+
−
    if (removedIndex < 0) {+
−
        if (fromIndex >= 0 && fromIndex < subWindows.size())+
−
            current = childWindows.at(fromIndex);+
−
        else+
−
            current = q->currentSubWindow();+
−
    }+
−
+
−
    // There's no current sub-window (removed or deactivated),+
−
    // so we have to pick the last active or the next in creation order.+
−
    if (!current) {+
−
        if (removedIndex >= 0 && order == QMdiArea::CreationOrder) {+
−
            int candidateIndex = -1;+
−
            setIndex(&candidateIndex, removedIndex, 0, subWindows.size() - 1, true);+
−
            current = childWindows.at(candidateIndex);+
−
        } else {+
−
            current = subWindows.back();+
−
        }+
−
    }+
−
    Q_ASSERT(current);+
−
+
−
    // Find the index for the current sub-window in the given activation order+
−
    const int indexToCurrent = subWindows.indexOf(current);+
−
    const bool increasing = increaseFactor > 0 ? true : false;+
−
+
−
    // and use that index + increseFactor as a candidate.+
−
    int index = -1;+
−
    setIndex(&index, indexToCurrent + increaseFactor, 0, subWindows.size() - 1, increasing);+
−
    Q_ASSERT(index != -1);+
−
+
−
    // Try to find another window if the candidate is hidden.+
−
    while (subWindows.at(index)->isHidden()) {+
−
        setIndex(&index, index + increaseFactor, 0, subWindows.size() - 1, increasing);+
−
        if (index == indexToCurrent)+
−
            break;+
−
    }+
−
+
−
    if (!subWindows.at(index)->isHidden())+
−
        return subWindows.at(index);+
−
    return 0;+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void QMdiAreaPrivate::highlightNextSubWindow(int increaseFactor)+
−
{+
−
    if (childWindows.size() == 1)+
−
        return;+
−
+
−
    Q_Q(QMdiArea);+
−
    // There's no highlighted sub-window atm, use current.+
−
    if (indexToHighlighted < 0) {+
−
        QMdiSubWindow *current = q->currentSubWindow();+
−
        if (!current)+
−
            return;+
−
        indexToHighlighted = childWindows.indexOf(current);+
−
    }+
−
+
−
    Q_ASSERT(indexToHighlighted >= 0);+
−
    Q_ASSERT(indexToHighlighted < childWindows.size());+
−
+
−
    QMdiSubWindow *highlight = nextVisibleSubWindow(increaseFactor, activationOrder, -1, indexToHighlighted);+
−
    if (!highlight)+
−
        return;+
−
+
−
#ifndef QT_NO_RUBBERBAND+
−
    if (!rubberBand) {+
−
        rubberBand = new QRubberBand(QRubberBand::Rectangle, viewport);+
−
        // For accessibility to identify this special widget.+
−
        rubberBand->setObjectName(QLatin1String("qt_rubberband"));+
−
        rubberBand->setWindowFlags(rubberBand->windowFlags() | Qt::WindowStaysOnTopHint);+
−
    }+
−
#endif+
−
+
−
    // Only highlight if we're not switching back to the previously active window (Ctrl-Tab once).+
−
#ifndef QT_NO_RUBBERBAND+
−
    if (tabToPreviousTimerId == -1)+
−
        showRubberBandFor(highlight);+
−
#endif+
−
+
−
    indexToHighlighted = childWindows.indexOf(highlight);+
−
    Q_ASSERT(indexToHighlighted >= 0);+
−
}+
−
+
−
/*!+
−
    \internal+
−
    \since 4.4+
−
*/+
−
void QMdiAreaPrivate::setViewMode(QMdiArea::ViewMode mode)+
−
{+
−
    Q_Q(QMdiArea);+
−
    if (viewMode == mode || inViewModeChange)+
−
        return;+
−
+
−
    // Just a guard since we cannot set viewMode = mode here.+
−
    inViewModeChange = true;+
−
+
−
#ifndef QT_NO_TABBAR+
−
    if (mode == QMdiArea::TabbedView) {+
−
        Q_ASSERT(!tabBar);+
−
        tabBar = new QMdiAreaTabBar(q);+
−
        tabBar->setDocumentMode(documentMode);+
−
#ifndef QT_NO_TABWIDGET+
−
        tabBar->setShape(tabBarShapeFrom(tabShape, tabPosition));+
−
#endif+
−
+
−
        isSubWindowsTiled = false;+
−
+
−
        foreach (QMdiSubWindow *subWindow, childWindows)+
−
            tabBar->addTab(subWindow->windowIcon(), tabTextFor(subWindow));+
−
+
−
        QMdiSubWindow *current = q->currentSubWindow();+
−
        if (current) {+
−
            tabBar->setCurrentIndex(childWindows.indexOf(current));+
−
            // Restore sub-window (i.e. cleanup buttons in menu bar and window title).+
−
            if (current->isMaximized())+
−
                current->showNormal();+
−
+
−
            viewMode = mode;+
−
+
−
            // Now, maximize it.+
−
            if (!q->testOption(QMdiArea::DontMaximizeSubWindowOnActivation)) {+
−
                current->showMaximized();+
−
            }+
−
        } else {+
−
            viewMode = mode;+
−
        }+
−
+
−
        if (q->isVisible())+
−
            tabBar->show();+
−
        updateTabBarGeometry();+
−
+
−
        QObject::connect(tabBar, SIGNAL(currentChanged(int)), q, SLOT(_q_currentTabChanged(int)));+
−
    } else+
−
#endif // QT_NO_TABBAR+
−
    { // SubWindowView+
−
#ifndef QT_NO_TABBAR+
−
        delete tabBar;+
−
        tabBar = 0;+
−
#endif // QT_NO_TABBAR+
−
+
−
        viewMode = mode;+
−
        q->setViewportMargins(0, 0, 0, 0);+
−
        indexToLastActiveTab = -1;+
−
+
−
        QMdiSubWindow *current = q->currentSubWindow();+
−
        if (current && current->isMaximized())+
−
            current->showNormal();+
−
    }+
−
+
−
    Q_ASSERT(viewMode == mode);+
−
    inViewModeChange = false;+
−
}+
−
+
−
#ifndef QT_NO_TABBAR+
−
/*!+
−
    \internal+
−
*/+
−
void QMdiAreaPrivate::updateTabBarGeometry()+
−
{+
−
    if (!tabBar)+
−
        return;+
−
+
−
    Q_Q(QMdiArea);+
−
#ifndef QT_NO_TABWIDGET+
−
    Q_ASSERT(tabBarShapeFrom(tabShape, tabPosition) == tabBar->shape());+
−
#endif+
−
    const QSize tabBarSizeHint = tabBar->sizeHint();+
−
+
−
    int areaHeight = q->height();+
−
    if (hbar && hbar->isVisible())+
−
        areaHeight -= hbar->height();+
−
+
−
    int areaWidth = q->width();+
−
    if (vbar && vbar->isVisible())+
−
        areaWidth -= vbar->width();+
−
+
−
    QRect tabBarRect;+
−
#ifndef QT_NO_TABWIDGET+
−
    switch (tabPosition) {+
−
    case QTabWidget::North:+
−
        q->setViewportMargins(0, tabBarSizeHint.height(), 0, 0);+
−
        tabBarRect = QRect(0, 0, areaWidth, tabBarSizeHint.height());+
−
        break;+
−
    case QTabWidget::South:+
−
        q->setViewportMargins(0, 0, 0, tabBarSizeHint.height());+
−
        tabBarRect = QRect(0, areaHeight - tabBarSizeHint.height(), areaWidth, tabBarSizeHint.height());+
−
        break;+
−
    case QTabWidget::East:+
−
        if (q->layoutDirection() == Qt::LeftToRight)+
−
            q->setViewportMargins(0, 0, tabBarSizeHint.width(), 0);+
−
        else+
−
            q->setViewportMargins(tabBarSizeHint.width(), 0, 0, 0);+
−
        tabBarRect = QRect(areaWidth - tabBarSizeHint.width(), 0, tabBarSizeHint.width(), areaHeight);+
−
        break;+
−
    case QTabWidget::West:+
−
        if (q->layoutDirection() == Qt::LeftToRight)+
−
            q->setViewportMargins(tabBarSizeHint.width(), 0, 0, 0);+
−
        else+
−
            q->setViewportMargins(0, 0, tabBarSizeHint.width(), 0);+
−
        tabBarRect = QRect(0, 0, tabBarSizeHint.width(), areaHeight);+
−
        break;+
−
    default:+
−
        break;+
−
    }+
−
#endif // QT_NO_TABWIDGET+
−
+
−
    tabBar->setGeometry(QStyle::visualRect(q->layoutDirection(), q->contentsRect(), tabBarRect));+
−
}+
−
+
−
/*!+
−
    \internal+
−
*/+
−
void QMdiAreaPrivate::refreshTabBar()+
−
{+
−
    if (!tabBar)+
−
        return;+
−
+
−
    tabBar->setDocumentMode(documentMode);+
−
#ifndef QT_NO_TABWIDGET+
−
    tabBar->setShape(tabBarShapeFrom(tabShape, tabPosition));+
−
#endif+
−
    updateTabBarGeometry();+
−
}+
−
#endif // QT_NO_TABBAR+
−
+
−
/*!+
−
    Constructs an empty mdi area. \a parent is passed to QWidget's+
−
    constructor.+
−
*/+
−
QMdiArea::QMdiArea(QWidget *parent)+
−
    : QAbstractScrollArea(*new QMdiAreaPrivate, parent)+
−
{+
−
    setBackground(palette().brush(QPalette::Dark));+
−
    setFrameStyle(QFrame::NoFrame);+
−
    setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);+
−
    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);+
−
    setViewport(0);+
−
    setFocusPolicy(Qt::NoFocus);+
−
    QApplication::instance()->installEventFilter(this);+
−
}+
−
+
−
/*!+
−
    Destroys the MDI area.+
−
*/+
−
QMdiArea::~QMdiArea()+
−
{+
−
    Q_D(QMdiArea);+
−
    delete d->cascader;+
−
    d->cascader = 0;+
−
+
−
    delete d->regularTiler;+
−
    d->regularTiler = 0;+
−
+
−
    delete d->iconTiler;+
−
    d->iconTiler = 0;+
−
+
−
    delete d->placer;+
−
    d->placer = 0;+
−
}+
−
+
−
/*!+
−
    \reimp+
−
*/+
−
QSize QMdiArea::sizeHint() const+
−
{+
−
    // Calculate a proper scale factor for QDesktopWidget::size().+
−
    // This also takes into account that we can have nested workspaces.+
−
    int nestedCount = 0;+
−
    QWidget *widget = this->parentWidget();+
−
    while (widget) {+
−
        if (qobject_cast<QMdiArea *>(widget))+
−
            ++nestedCount;+
−
        widget = widget->parentWidget();+
−
    }+
−
    const int scaleFactor = 3 * (nestedCount + 1);+
−
+
−
    QSize desktopSize = QApplication::desktop()->size();+
−
    QSize size(desktopSize.width() * 2 / scaleFactor, desktopSize.height() * 2 / scaleFactor);+
−
    foreach (QMdiSubWindow *child, d_func()->childWindows) {+
−
        if (!sanityCheck(child, "QMdiArea::sizeHint"))+
−
            continue;+
−
        size = size.expandedTo(child->sizeHint());+
−
    }+
−
    return size.expandedTo(QApplication::globalStrut());+
−
}+
−
+
−
/*!+
−
    \reimp+
−
*/+
−
QSize QMdiArea::minimumSizeHint() const+
−
{+
−
    Q_D(const QMdiArea);+
−
    QSize size(style()->pixelMetric(QStyle::PM_MdiSubWindowMinimizedWidth, 0, this),+
−
               style()->pixelMetric(QStyle::PM_TitleBarHeight, 0, this));+
−
    size = size.expandedTo(QAbstractScrollArea::minimumSizeHint());+
−
    if (!d->scrollBarsEnabled()) {+
−
        foreach (QMdiSubWindow *child, d->childWindows) {+
−
            if (!sanityCheck(child, "QMdiArea::sizeHint"))+
−
                continue;+
−
            size = size.expandedTo(child->minimumSizeHint());+
−
        }+
−
    }+
−
    return size.expandedTo(QApplication::globalStrut());+
−
}+
−
+
−
/*!+
−
    Returns a pointer to the current subwindow, or 0 if there is+
−
    no current subwindow.+
−
+
−
    This function will return the same as activeSubWindow() if+
−
    the QApplication containing QMdiArea is active.+
−
+
−
    \sa activeSubWindow(), QApplication::activeWindow()+
−
*/+
−
QMdiSubWindow *QMdiArea::currentSubWindow() const+
−
{+
−
    Q_D(const QMdiArea);+
−
    if (d->childWindows.isEmpty())+
−
        return 0;+
−
+
−
    if (d->active)+
−
        return d->active;+
−
+
−
    if (d->isActivated && !window()->isMinimized())+
−
        return 0;+
−
+
−
    Q_ASSERT(d->indicesToActivatedChildren.count() > 0);+
−
    int index = d->indicesToActivatedChildren.at(0);+
−
    Q_ASSERT(index >= 0 && index < d->childWindows.size());+
−
    QMdiSubWindow *current = d->childWindows.at(index);+
−
    Q_ASSERT(current);+
−
    return current;+
−
}+
−
+
−
/*!+
−
    Returns a pointer to the current active subwindow. If no+
−
    window is currently active, 0 is returned.+
−
+
−
    Subwindows are treated as top-level windows with respect to+
−
    window state, i.e., if a widget outside the MDI area is the active+
−
    window, no subwindow will be active. Note that if a widget in the+
−
    window in which the MDI area lives gains focus, the window will be+
−
    activated.+
−
+
−
    \sa setActiveSubWindow(), Qt::WindowState+
−
*/+
−
QMdiSubWindow *QMdiArea::activeSubWindow() const+
−
{+
−
    Q_D(const QMdiArea);+
−
    return d->active;+
−
}+
−
+
−
/*!+
−
    Activates the subwindow \a window. If \a window is 0, any+
−
    current active window is deactivated.+
−
+
−
    \sa activeSubWindow()+
−
*/+
−
void QMdiArea::setActiveSubWindow(QMdiSubWindow *window)+
−
{+
−
    Q_D(QMdiArea);+
−
    if (!window) {+
−
        d->activateWindow(0);+
−
        return;+
−
    }+
−
+
−
    if (d->childWindows.isEmpty()) {+
−
        qWarning("QMdiArea::setActiveSubWindow: workspace is empty");+
−
        return;+
−
    }+
−
+
−
    if (d->childWindows.indexOf(window) == -1) {+
−
        qWarning("QMdiArea::setActiveSubWindow: window is not inside workspace");+
−
        return;+
−
    }+
−
+
−
    d->activateWindow(window);+
−
}+
−
+
−
/*!+
−
    Closes the active subwindow.+
−
+
−
    \sa closeAllSubWindows()+
−
*/+
−
void QMdiArea::closeActiveSubWindow()+
−
{+
−
    Q_D(QMdiArea);+
−
    if (d->active)+
−
        d->active->close();+
−
}+
−
+
−
/*!+
−
    Returns a list of all subwindows in the MDI area. If \a order is+
−
    CreationOrder (the default), the windows are sorted in the order+
−
    in which they were inserted into the workspace. If \a order is+
−
    StackingOrder, the windows are listed in their stacking order,+
−
    with the topmost window as the last item in the list. If \a order+
−
    is ActivationHistoryOrder, the windows are listed according to+
−
    their recent activation history.+
−
+
−
    \sa WindowOrder+
−
*/+
−
QList<QMdiSubWindow *> QMdiArea::subWindowList(WindowOrder order) const+
−
{+
−
    Q_D(const QMdiArea);+
−
    return d->subWindowList(order, false);+
−
}+
−
+
−
/*!+
−
    Closes all subwindows by sending a QCloseEvent to each window.+
−
    You may receive subWindowActivated() signals from subwindows+
−
    before they are closed (if the MDI area activates the subwindow+
−
    when another is closing).+
−
+
−
    Subwindows that ignore the close event will remain open.+
−
+
−
    \sa closeActiveSubWindow()+
−
*/+
−
void QMdiArea::closeAllSubWindows()+
−
{+
−
    Q_D(QMdiArea);+
−
    if (d->childWindows.isEmpty())+
−
        return;+
−
+
−
    d->isSubWindowsTiled = false;+
−
    foreach (QMdiSubWindow *child, d->childWindows) {+
−
        if (!sanityCheck(child, "QMdiArea::closeAllSubWindows"))+
−
            continue;+
−
        child->close();+
−
    }+
−
+
−
    d->updateScrollBars();+
−
}+
−
+
−
/*!+
−
    Gives the keyboard focus to another window in the list of child+
−
    windows.  The window activated will be the next one determined+
−
    by the current \l{QMdiArea::WindowOrder} {activation order}.+
−
+
−
    \sa activatePreviousSubWindow(), QMdiArea::WindowOrder+
−
*/+
−
void QMdiArea::activateNextSubWindow()+
−
{+
−
    Q_D(QMdiArea);+
−
    if (d->childWindows.isEmpty())+
−
        return;+
−
+
−
    QMdiSubWindow *next = d->nextVisibleSubWindow(1, d->activationOrder);+
−
    if (next)+
−
        d->activateWindow(next);+
−
}+
−
+
−
/*!+
−
    Gives the keyboard focus to another window in the list of child+
−
    windows.  The window activated will be the previous one determined+
−
    by the current \l{QMdiArea::WindowOrder} {activation order}.+
−
+
−
    \sa activateNextSubWindow(), QMdiArea::WindowOrder+
−
*/+
−
void QMdiArea::activatePreviousSubWindow()+
−
{+
−
    Q_D(QMdiArea);+
−
    if (d->childWindows.isEmpty())+
−
        return;+
−
+
−
    QMdiSubWindow *previous = d->nextVisibleSubWindow(-1, d->activationOrder);+
−
    if (previous)+
−
        d->activateWindow(previous);+
−
}+
−
+
−
/*!+
−
    Adds \a widget as a new subwindow to the MDI area.  If \a+
−
    windowFlags are non-zero, they will override the flags set on the+
−
    widget.+
−
+
−
    The \a widget can be either a QMdiSubWindow or another QWidget+
−
    (in which case the MDI area will create a subwindow and set the \a+
−
    widget as the internal widget).+
−
+
−
    \note Once the subwindow has been added, its parent will be the+
−
    \e{viewport widget} of the QMdiArea.+
−
+
−
    \snippet doc/src/snippets/mdiareasnippets.cpp 1+
−
+
−
    When you create your own subwindow, you must set the+
−
    Qt::WA_DeleteOnClose widget attribute if you want the window to be+
−
    deleted when closed in the MDI area. If not, the window will be+
−
    hidden and the MDI area will not activate the next subwindow.+
−
+
−
    Returns the QMdiSubWindow that is added to the MDI area.+
−
+
−
    \sa removeSubWindow()+
−
*/+
−
QMdiSubWindow *QMdiArea::addSubWindow(QWidget *widget, Qt::WindowFlags windowFlags)+
−
{+
−
    if (!widget) {+
−
        qWarning("QMdiArea::addSubWindow: null pointer to widget");+
−
        return 0;+
−
    }+
−
+
−
    Q_D(QMdiArea);+
−
    // QWidget::setParent clears focusWidget so store it+
−
    QWidget *childFocus = widget->focusWidget();+
−
    QMdiSubWindow *child = qobject_cast<QMdiSubWindow *>(widget);+
−
+
−
    // Widget is already a QMdiSubWindow+
−
    if (child) {+
−
        if (d->childWindows.indexOf(child) != -1) {+
−
            qWarning("QMdiArea::addSubWindow: window is already added");+
−
            return child;+
−
        }+
−
        child->setParent(viewport(), windowFlags ? windowFlags : child->windowFlags());+
−
    // Create a QMdiSubWindow+
−
    } else {+
−
        child = new QMdiSubWindow(viewport(), windowFlags);+
−
        child->setAttribute(Qt::WA_DeleteOnClose);+
−
        child->setWidget(widget);+
−
        Q_ASSERT(child->testAttribute(Qt::WA_DeleteOnClose));+
−
    }+
−
+
−
    if (childFocus)+
−
        childFocus->setFocus();+
−
    d->appendChild(child);+
−
    return child;+
−
}+
−
+
−
/*!+
−
    Removes \a widget from the MDI area. The \a widget must be+
−
    either a QMdiSubWindow or a widget that is the internal widget of+
−
    a subwindow. Note \a widget is never actually deleted by QMdiArea.+
−
    If a QMdiSubWindow is passed in its parent is set to 0 and it is+
−
    removed, but if an internal widget is passed in the child widget+
−
    is set to 0 but the QMdiSubWindow is not removed.+
−
+
−
    \sa addSubWindow()+
−
*/+
−
void QMdiArea::removeSubWindow(QWidget *widget)+
−
{+
−
    if (!widget) {+
−
        qWarning("QMdiArea::removeSubWindow: null pointer to widget");+
−
        return;+
−
    }+
−
+
−
    Q_D(QMdiArea);+
−
    if (d->childWindows.isEmpty())+
−
        return;+
−
+
−
    if (QMdiSubWindow *child = qobject_cast<QMdiSubWindow *>(widget)) {+
−
        int index = d->childWindows.indexOf(child);+
−
        if (index == -1) {+
−
            qWarning("QMdiArea::removeSubWindow: window is not inside workspace");+
−
            return;+
−
        }+
−
        d->disconnectSubWindow(child);+
−
        d->childWindows.removeAll(child);+
−
        d->indicesToActivatedChildren.removeAll(index);+
−
        d->updateActiveWindow(index, d->active == child);+
−
        child->setParent(0);+
−
        return;+
−
    }+
−
+
−
    bool found = false;+
−
    foreach (QMdiSubWindow *child, d->childWindows) {+
−
        if (!sanityCheck(child, "QMdiArea::removeSubWindow"))+
−
            continue;+
−
        if (child->widget() == widget) {+
−
            child->setWidget(0);+
−
            Q_ASSERT(!child->widget());+
−
            found = true;+
−
            break;+
−
        }+
−
    }+
−
+
−
    if (!found)+
−
        qWarning("QMdiArea::removeSubWindow: widget is not child of any window inside QMdiArea");+
−
}+
−
+
−
/*!+
−
    \property QMdiArea::background+
−
    \brief the background brush for the workspace+
−
+
−
    This property sets the background brush for the workspace area+
−
    itself. By default, it is a gray color, but can be any brush+
−
    (e.g., colors, gradients or pixmaps).+
−
*/+
−
QBrush QMdiArea::background() const+
−
{+
−
    return d_func()->background;+
−
}+
−
+
−
void QMdiArea::setBackground(const QBrush &brush)+
−
{+
−
    Q_D(QMdiArea);+
−
    if (d->background != brush) {+
−
        d->background = brush;+
−
        d->viewport->setAttribute(Qt::WA_OpaquePaintEvent, brush.isOpaque());+
−
        update();+
−
    }+
−
}+
−
+
−
+
−
/*!+
−
    \property QMdiArea::activationOrder+
−
    \brief the ordering criteria for subwindow lists+
−
    \since 4.4+
−
+
−
    This property specifies the ordering criteria for the list of+
−
    subwindows returned by subWindowList(). By default, it is the window+
−
    creation order.+
−
+
−
    \sa subWindowList()+
−
*/+
−
QMdiArea::WindowOrder QMdiArea::activationOrder() const+
−
{+
−
    Q_D(const QMdiArea);+
−
    return d->activationOrder;+
−
}+
−
+
−
void QMdiArea::setActivationOrder(WindowOrder order)+
−
{+
−
    Q_D(QMdiArea);+
−
    if (order != d->activationOrder)+
−
        d->activationOrder = order;+
−
}+
−
+
−
/*!+
−
    If \a on is true, \a option is enabled on the MDI area; otherwise+
−
    it is disabled. See AreaOption for the effect of each option.+
−
+
−
    \sa AreaOption, testOption()+
−
*/+
−
void QMdiArea::setOption(AreaOption option, bool on)+
−
{+
−
    Q_D(QMdiArea);+
−
    if (on && !(d->options & option))+
−
        d->options |= option;+
−
    else if (!on && (d->options & option))+
−
        d->options &= ~option;+
−
}+
−
+
−
/*!+
−
    Returns true if \a option is enabled; otherwise returns false.+
−
+
−
    \sa AreaOption, setOption()+
−
*/+
−
bool QMdiArea::testOption(AreaOption option) const+
−
{+
−
    return d_func()->options & option;+
−
}+
−
+
−
/*!+
−
    \property QMdiArea::viewMode+
−
    \brief the way sub-windows are displayed in the QMdiArea.+
−
    \since 4.4+
−
+
−
    By default, the SubWindowView is used to display sub-windows.+
−
+
−
    \sa ViewMode, setTabShape(), setTabPosition()+
−
*/+
−
QMdiArea::ViewMode QMdiArea::viewMode() const+
−
{+
−
    Q_D(const QMdiArea);+
−
    return d->viewMode;+
−
}+
−
+
−
void QMdiArea::setViewMode(ViewMode mode)+
−
{+
−
    Q_D(QMdiArea);+
−
    d->setViewMode(mode);+
−
}+
−
+
−
#ifndef QT_NO_TABBAR+
−
/*!+
−
    \property QMdiArea::documentMode+
−
    \brief whether the tab bar is set to document mode in tabbed view mode.+
−
    \since 4.5+
−
+
−
    Document mode is disabled by default.+
−
+
−
    \sa QTabBar::documentMode, setViewMode()+
−
*/+
−
bool QMdiArea::documentMode() const+
−
{+
−
    Q_D(const QMdiArea);+
−
    return d->documentMode;+
−
}+
−
+
−
void QMdiArea::setDocumentMode(bool enabled)+
−
{+
−
    Q_D(QMdiArea);+
−
    if (d->documentMode == enabled)+
−
        return;+
−
+
−
    d->documentMode = enabled;+
−
    d->refreshTabBar();+
−
}+
−
#endif // QT_NO_TABBAR+
−
+
−
#ifndef QT_NO_TABWIDGET+
−
/*!+
−
    \property QMdiArea::tabShape+
−
    \brief the shape of the tabs in tabbed view mode.+
−
    \since 4.4+
−
+
−
    Possible values for this property are QTabWidget::Rounded+
−
    (default) or QTabWidget::Triangular.+
−
+
−
    \sa QTabWidget::TabShape, setViewMode()+
−
*/+
−
QTabWidget::TabShape QMdiArea::tabShape() const+
−
{+
−
    Q_D(const QMdiArea);+
−
    return d->tabShape;+
−
}+
−
+
−
void QMdiArea::setTabShape(QTabWidget::TabShape shape)+
−
{+
−
    Q_D(QMdiArea);+
−
    if (d->tabShape == shape)+
−
        return;+
−
+
−
    d->tabShape = shape;+
−
    d->refreshTabBar();+
−
}+
−
+
−
/*!+
−
    \property QMdiArea::tabPosition+
−
    \brief the position of the tabs in tabbed view mode.+
−
    \since 4.4+
−
+
−
    Possible values for this property are described by the+
−
    QTabWidget::TabPosition enum.+
−
+
−
    \sa QTabWidget::TabPosition, setViewMode()+
−
*/+
−
QTabWidget::TabPosition QMdiArea::tabPosition() const+
−
{+
−
    Q_D(const QMdiArea);+
−
    return d->tabPosition;+
−
}+
−
+
−
void QMdiArea::setTabPosition(QTabWidget::TabPosition position)+
−
{+
−
    Q_D(QMdiArea);+
−
    if (d->tabPosition == position)+
−
        return;+
−
+
−
    d->tabPosition = position;+
−
    d->refreshTabBar();+
−
}+
−
#endif // QT_NO_TABWIDGET+
−
+
−
/*!+
−
    \reimp+
−
*/+
−
void QMdiArea::childEvent(QChildEvent *childEvent)+
−
{+
−
    Q_D(QMdiArea);+
−
    if (childEvent->type() == QEvent::ChildPolished) {+
−
        if (QMdiSubWindow *mdiChild = qobject_cast<QMdiSubWindow *>(childEvent->child())) {+
−
            if (d->childWindows.indexOf(mdiChild) == -1)+
−
                d->appendChild(mdiChild);+
−
        }+
−
    }+
−
}+
−
+
−
/*!+
−
    \reimp+
−
*/+
−
void QMdiArea::resizeEvent(QResizeEvent *resizeEvent)+
−
{+
−
    Q_D(QMdiArea);+
−
    if (d->childWindows.isEmpty()) {+
−
        resizeEvent->ignore();+
−
        return;+
−
    }+
−
+
−
#ifndef QT_NO_TABBAR+
−
    d->updateTabBarGeometry();+
−
#endif+
−
+
−
    // Re-tile the views if we're in tiled mode. Re-tile means we will change+
−
    // the geometry of the children, which in turn means 'isSubWindowsTiled'+
−
    // is set to false, so we have to update the state at the end.+
−
    if (d->isSubWindowsTiled) {+
−
        d->tileCalledFromResizeEvent = true;+
−
        tileSubWindows();+
−
        d->tileCalledFromResizeEvent = false;+
−
        d->isSubWindowsTiled = true;+
−
        d->startResizeTimer();+
−
        // We don't have scroll bars or any maximized views.+
−
        return;+
−
    }+
−
+
−
    // Resize maximized views.+
−
    bool hasMaximizedSubWindow = false;+
−
    foreach (QMdiSubWindow *child, d->childWindows) {+
−
        if (sanityCheck(child, "QMdiArea::resizeEvent") && child->isMaximized()+
−
                && child->size() != resizeEvent->size()) {+
−
            child->resize(resizeEvent->size());+
−
            if (!hasMaximizedSubWindow)+
−
                hasMaximizedSubWindow = true;+
−
        }+
−
    }+
−
+
−
    d->updateScrollBars();+
−
+
−
    // Minimized views are stacked under maximized views so there's+
−
    // no need to re-arrange minimized views on-demand. Start a timer+
−
    // just to make things faster with subsequent resize events.+
−
    if (hasMaximizedSubWindow)+
−
        d->startResizeTimer();+
−
    else+
−
        d->arrangeMinimizedSubWindows();+
−
}+
−
+
−
/*!+
−
    \reimp+
−
*/+
−
void QMdiArea::timerEvent(QTimerEvent *timerEvent)+
−
{+
−
    Q_D(QMdiArea);+
−
    if (timerEvent->timerId() == d->resizeTimerId) {+
−
        killTimer(d->resizeTimerId);+
−
        d->resizeTimerId = -1;+
−
        d->arrangeMinimizedSubWindows();+
−
    } else if (timerEvent->timerId() == d->tabToPreviousTimerId) {+
−
        killTimer(d->tabToPreviousTimerId);+
−
        d->tabToPreviousTimerId = -1;+
−
        if (d->indexToHighlighted < 0)+
−
            return;+
−
#ifndef QT_NO_RUBBERBAND+
−
        // We're not doing a "quick switch" ... show rubber band.+
−
        Q_ASSERT(d->indexToHighlighted < d->childWindows.size());+
−
        Q_ASSERT(d->rubberBand);+
−
        d->showRubberBandFor(d->childWindows.at(d->indexToHighlighted));+
−
#endif+
−
    }+
−
}+
−
+
−
/*!+
−
    \reimp+
−
*/+
−
void QMdiArea::showEvent(QShowEvent *showEvent)+
−
{+
−
    Q_D(QMdiArea);+
−
    if (!d->pendingRearrangements.isEmpty()) {+
−
        bool skipPlacement = false;+
−
        foreach (Rearranger *rearranger, d->pendingRearrangements) {+
−
            // If this is the case, we don't have to lay out pending child windows+
−
            // since the rearranger will find a placement for them.+
−
            if (rearranger->type() != Rearranger::IconTiler && !skipPlacement)+
−
                skipPlacement = true;+
−
            d->rearrange(rearranger);+
−
        }+
−
        d->pendingRearrangements.clear();+
−
+
−
        if (skipPlacement && !d->pendingPlacements.isEmpty())+
−
            d->pendingPlacements.clear();+
−
    }+
−
+
−
    if (!d->pendingPlacements.isEmpty()) {+
−
        foreach (QMdiSubWindow *window, d->pendingPlacements) {+
−
            if (!window)+
−
                continue;+
−
            if (!window->testAttribute(Qt::WA_Resized)) {+
−
                QSize newSize(window->sizeHint().boundedTo(viewport()->size()));+
−
                window->resize(newSize.expandedTo(qSmartMinSize(window)));+
−
            }+
−
            if (!window->testAttribute(Qt::WA_Moved) && !window->isMinimized()+
−
                    && !window->isMaximized()) {+
−
                d->place(d->placer, window);+
−
            }+
−
        }+
−
        d->pendingPlacements.clear();+
−
    }+
−
+
−
    d->setChildActivationEnabled(true);+
−
    d->activateCurrentWindow();+
−
+
−
    QAbstractScrollArea::showEvent(showEvent);+
−
}+
−
+
−
/*!+
−
    \reimp+
−
*/+
−
bool QMdiArea::viewportEvent(QEvent *event)+
−
{+
−
    Q_D(QMdiArea);+
−
    switch (event->type()) {+
−
    case QEvent::ChildRemoved: {+
−
        d->isSubWindowsTiled = false;+
−
        QObject *removedChild = static_cast<QChildEvent *>(event)->child();+
−
        for (int i = 0; i < d->childWindows.size(); ++i) {+
−
            QObject *child = d->childWindows.at(i);+
−
            if (!child || child == removedChild || !child->parent()+
−
                    || child->parent() != viewport()) {+
−
                if (!testOption(DontMaximizeSubWindowOnActivation)) {+
−
                    // In this case we can only rely on the child being a QObject+
−
                    // (or 0), but let's try and see if we can get more information.+
−
                    QWidget *mdiChild = qobject_cast<QWidget *>(removedChild);+
−
                    if (mdiChild && mdiChild->isMaximized())+
−
                        d->showActiveWindowMaximized = true;+
−
                }+
−
                d->disconnectSubWindow(child);+
−
                const bool activeRemoved = i == d->indicesToActivatedChildren.at(0);+
−
                d->childWindows.removeAt(i);+
−
                d->indicesToActivatedChildren.removeAll(i);+
−
                d->updateActiveWindow(i, activeRemoved);+
−
                d->arrangeMinimizedSubWindows();+
−
                break;+
−
            }+
−
        }+
−
        d->updateScrollBars();+
−
        break;+
−
    }+
−
    case QEvent::Destroy:+
−
        d->isSubWindowsTiled = false;+
−
        d->resetActiveWindow();+
−
        d->childWindows.clear();+
−
        qWarning("QMdiArea: Deleting the view port is undefined, use setViewport instead.");+
−
        break;+
−
    default:+
−
        break;+
−
    }+
−
    return QAbstractScrollArea::viewportEvent(event);+
−
}+
−
+
−
/*!+
−
    \reimp+
−
*/+
−
void QMdiArea::scrollContentsBy(int dx, int dy)+
−
{+
−
    Q_D(QMdiArea);+
−
    const bool wasSubWindowsTiled = d->isSubWindowsTiled;+
−
    d->ignoreGeometryChange = true;+
−
    viewport()->scroll(isLeftToRight() ? dx : -dx, dy);+
−
    d->arrangeMinimizedSubWindows();+
−
    d->ignoreGeometryChange = false;+
−
    if (wasSubWindowsTiled)+
−
        d->isSubWindowsTiled = true;+
−
}+
−
+
−
/*!+
−
    Arranges all child windows in a tile pattern.+
−
+
−
    \sa cascadeSubWindows()+
−
*/+
−
void QMdiArea::tileSubWindows()+
−
{+
−
    Q_D(QMdiArea);+
−
    if (!d->regularTiler)+
−
        d->regularTiler = new RegularTiler;+
−
    d->rearrange(d->regularTiler);+
−
}+
−
+
−
/*!+
−
    Arranges all the child windows in a cascade pattern.+
−
+
−
    \sa tileSubWindows()+
−
*/+
−
void QMdiArea::cascadeSubWindows()+
−
{+
−
    Q_D(QMdiArea);+
−
    if (!d->cascader)+
−
        d->cascader = new SimpleCascader;+
−
    d->rearrange(d->cascader);+
−
}+
−
+
−
/*!+
−
    \reimp+
−
*/+
−
bool QMdiArea::event(QEvent *event)+
−
{+
−
    Q_D(QMdiArea);+
−
    switch (event->type()) {+
−
#ifdef Q_WS_WIN+
−
    // QWidgetPrivate::hide_helper activates another sub-window when closing a+
−
    // modal dialog on Windows (see activateWindow() inside the the ifdef).+
−
    case QEvent::WindowUnblocked:+
−
        d->activateCurrentWindow();+
−
        break;+
−
#endif+
−
    case QEvent::WindowActivate: {+
−
        d->isActivated = true;+
−
        if (d->childWindows.isEmpty())+
−
            break;+
−
        if (!d->active)+
−
            d->activateCurrentWindow();+
−
        d->setChildActivationEnabled(false, true);+
−
        break;+
−
    }+
−
    case QEvent::WindowDeactivate:+
−
        d->isActivated = false;+
−
        d->setChildActivationEnabled(false, true);+
−
        break;+
−
    case QEvent::StyleChange:+
−
        // Re-tile the views if we're in tiled mode. Re-tile means we will change+
−
        // the geometry of the children, which in turn means 'isSubWindowsTiled'+
−
        // is set to false, so we have to update the state at the end.+
−
        if (d->isSubWindowsTiled) {+
−
            tileSubWindows();+
−
            d->isSubWindowsTiled = true;+
−
        }+
−
        break;+
−
    case QEvent::WindowIconChange:+
−
        foreach (QMdiSubWindow *window, d->childWindows) {+
−
            if (sanityCheck(window, "QMdiArea::WindowIconChange"))+
−
                QApplication::sendEvent(window, event);+
−
        }+
−
        break;+
−
    case QEvent::Hide:+
−
        d->setActive(d->active, false, false);+
−
        d->setChildActivationEnabled(false);+
−
        break;+
−
#ifndef QT_NO_TABBAR+
−
    case QEvent::LayoutDirectionChange:+
−
        d->updateTabBarGeometry();+
−
        break;+
−
#endif+
−
    default:+
−
        break;+
−
    }+
−
    return QAbstractScrollArea::event(event);+
−
}+
−
+
−
/*!+
−
    \reimp+
−
*/+
−
bool QMdiArea::eventFilter(QObject *object, QEvent *event)+
−
{+
−
    if (!object)+
−
        return QAbstractScrollArea::eventFilter(object, event);+
−
+
−
    Q_D(QMdiArea);+
−
    // Global key events with Ctrl modifier.+
−
    if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) {+
−
+
−
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);+
−
        // Ingore key events without a Ctrl modifier (except for press/release on the modifier itself).+
−
#ifdef Q_WS_MAC+
−
        if (!(keyEvent->modifiers() & Qt::MetaModifier) && keyEvent->key() != Qt::Key_Meta)+
−
#else+
−
        if (!(keyEvent->modifiers() & Qt::ControlModifier) && keyEvent->key() != Qt::Key_Control)+
−
#endif+
−
            return QAbstractScrollArea::eventFilter(object, event);+
−
+
−
        // Find closest mdi area (in case we have a nested workspace).+
−
        QMdiArea *area = mdiAreaParent(static_cast<QWidget *>(object));+
−
        if (!area)+
−
            return QAbstractScrollArea::eventFilter(object, event);+
−
+
−
        const bool keyPress = (event->type() == QEvent::KeyPress) ? true : false;+
−
+
−
        // 1) Ctrl-Tab once -> activate the previously active window.+
−
        // 2) Ctrl-Tab (Tab, Tab, ...) -> iterate through all windows (activateNextSubWindow()).+
−
        // 3) Ctrl-Shift-Tab (Tab, Tab, ...) -> iterate through all windows in the opposite+
−
        //    direction (activatePreviousSubWindow())+
−
        switch (keyEvent->key()) {+
−
#ifdef Q_WS_MAC+
−
        case Qt::Key_Meta:+
−
#else+
−
        case Qt::Key_Control:+
−
#endif+
−
            if (keyPress)+
−
                area->d_func()->startTabToPreviousTimer();+
−
            else+
−
                area->d_func()->activateHighlightedWindow();+
−
            break;+
−
        case Qt::Key_Tab:+
−
        case Qt::Key_Backtab:+
−
            if (keyPress)+
−
                area->d_func()->highlightNextSubWindow(keyEvent->key() == Qt::Key_Tab ? 1 : -1);+
−
            return true;+
−
#ifndef QT_NO_RUBBERBAND+
−
        case Qt::Key_Escape:+
−
            area->d_func()->hideRubberBand();+
−
            break;+
−
#endif+
−
        default:+
−
            break;+
−
        }+
−
        return QAbstractScrollArea::eventFilter(object, event);+
−
    }+
−
+
−
    QMdiSubWindow *subWindow = qobject_cast<QMdiSubWindow *>(object);+
−
+
−
    if (!subWindow) {+
−
        // QApplication events:+
−
        if (event->type() == QEvent::ApplicationActivate && !d->active+
−
            && isVisible() && !window()->isMinimized()) {+
−
            d->activateCurrentWindow();+
−
        } else if (event->type() == QEvent::ApplicationDeactivate && d->active) {+
−
            d->setActive(d->active, false, false);+
−
        }+
−
        return QAbstractScrollArea::eventFilter(object, event);+
−
    }+
−
+
−
    // QMdiSubWindow events:+
−
    switch (event->type()) {+
−
    case QEvent::Move:+
−
    case QEvent::Resize:+
−
        if (d->tileCalledFromResizeEvent)+
−
            break;+
−
        d->updateScrollBars();+
−
        if (!subWindow->isMinimized())+
−
            d->isSubWindowsTiled = false;+
−
        break;+
−
    case QEvent::Show:+
−
#ifndef QT_NO_TABBAR+
−
        if (d->tabBar) {+
−
            const int tabIndex = d->childWindows.indexOf(subWindow);+
−
            if (!d->tabBar->isTabEnabled(tabIndex))+
−
                d->tabBar->setTabEnabled(tabIndex, true);+
−
        }+
−
#endif // QT_NO_TABBAR+
−
        // fall through+
−
    case QEvent::Hide:+
−
        d->isSubWindowsTiled = false;+
−
        break;+
−
#ifndef QT_NO_RUBBERBAND+
−
    case QEvent::Close:+
−
        if (d->childWindows.indexOf(subWindow) == d->indexToHighlighted)+
−
            d->hideRubberBand();+
−
        break;+
−
#endif+
−
#ifndef QT_NO_TABBAR+
−
    case QEvent::WindowTitleChange:+
−
    case QEvent::ModifiedChange:+
−
        if (d->tabBar)+
−
            d->tabBar->setTabText(d->childWindows.indexOf(subWindow), tabTextFor(subWindow));+
−
        break;+
−
    case QEvent::WindowIconChange:+
−
        if (d->tabBar)+
−
            d->tabBar->setTabIcon(d->childWindows.indexOf(subWindow), subWindow->windowIcon());+
−
        break;+
−
#endif // QT_NO_TABBAR+
−
    default:+
−
        break;+
−
    }+
−
    return QAbstractScrollArea::eventFilter(object, event);+
−
}+
−
+
−
/*!+
−
    \reimp+
−
*/+
−
void QMdiArea::paintEvent(QPaintEvent *paintEvent)+
−
{+
−
    Q_D(QMdiArea);+
−
    QPainter painter(d->viewport);+
−
    const QVector<QRect> &exposedRects = paintEvent->region().rects();+
−
    for (int i = 0; i < exposedRects.size(); ++i)+
−
        painter.fillRect(exposedRects.at(i), d->background);+
−
}+
−
+
−
/*!+
−
    This slot is called by QAbstractScrollArea after setViewport() has been+
−
    called. Reimplement this function in a subclass of QMdiArea to+
−
    initialize the new \a viewport before it is used.+
−
+
−
    \sa setViewport()+
−
*/+
−
void QMdiArea::setupViewport(QWidget *viewport)+
−
{+
−
    Q_D(QMdiArea);+
−
    if (viewport)+
−
        viewport->setAttribute(Qt::WA_OpaquePaintEvent, d->background.isOpaque());+
−
    foreach (QMdiSubWindow *child, d->childWindows) {+
−
        if (!sanityCheck(child, "QMdiArea::setupViewport"))+
−
            continue;+
−
        child->setParent(viewport, child->windowFlags());+
−
    }+
−
}+
−
+
−
QT_END_NAMESPACE+
−
+
−
#include "moc_qmdiarea.cpp"+
−
+
−
#endif // QT_NO_MDIAREA+
−