/**************************************************************************** ** ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). ** 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 #include #if defined(Q_WS_MAC) && !defined(QT_NO_STYLE_MAC) #include #endif #include #include #include #include #include #include #include #include #include #include #include #include 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 &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(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 &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 &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(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 &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 &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 &source, const QList &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 &rects, const QRect &domain,QList &candidates) { QSet xset; QSet 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 xlist = xset.values(); qSort(xlist.begin(), xlist.end()); QList 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 &source, QList &result) { QMutableListIterator 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 &source, QList &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 &rects, QList &source) { QList nonInsiders; findNonInsiders(domain, source, nonInsiders); if (!source.empty()) return findMinOverlapRect(source, rects).topLeft(); QList 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 &rects, const QRect &domain) const { if (size.isEmpty() || !domain.isValid()) return QPoint(); foreach (const QRect &rect, rects) { if (!rect.isValid()) return QPoint(); } QList 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 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(parentWidget()); Q_ASSERT(mdiArea); const QList 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(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(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(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 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 widgets; const bool reverseList = rearranger->type() == Rearranger::RegularTiler; const QList 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(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 QMdiAreaPrivate::subWindowList(QMdiArea::WindowOrder order, bool reversed) const { QList 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(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 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(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 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(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(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(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(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(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(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(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(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 &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