FCL/sf/mw/qt: comparison src/gui/widgets/qmdiarea.cpp

equal deleted inserted replaced

--1:000000000000
+:1918ee327afb
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the 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 the next window in the list of child
+windows.  The windows are activated in the order in which they are
+created (CreationOrder).
+\sa activatePreviousSubWindow()
+*/
+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 the previous window in the list of
+child windows. The windows are activated in the order in which
+they are created (CreationOrder).
+\sa activateNextSubWindow()
+*/
+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 that the subwindow is not deleted by QMdiArea
+and that its parent is set to 0.
+\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

changeset 0	1918ee327afb
child 3	41300fa6a67c