1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 /*!

    43     \class QMdiSubWindow

    44     \brief The QMdiSubWindow class provides a subwindow class for

    45     QMdiArea.

    46     \since 4.3

    47     \ingroup mainwindow-classes

    48 

    49 

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

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

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

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

    54     title bar and a center area for the internal widget.

    55 

    56     \image qmdisubwindowlayout.png

    57 

    58     The most common way to construct a QMdiSubWindow is to call

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

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

    61     widget by calling setWidget().

    62 

    63     You use the same API when programming with subwindows as with

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

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

    66 

    67     \section1 Subwindow Handling

    68 

    69     QMdiSubWindow also supports behavior specific to subwindows in

    70     an MDI area.

    71 

    72     By default, each QMdiSubWindow is visible inside the MDI area

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

    74     transparent window movement and resizing behavior, where only

    75     the outline of a subwindow is updated during these operations.

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

    77 

    78     The isShaded() function detects whether the subwindow is

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

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

    81     QMdiSubWindow emits the windowStateChanged() signal whenever the

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

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

    84     activated.

    85 

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

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

    88     of the window. The keyboardSingleStep and keyboardPageStep

    89     properties control the distance the widget is moved or resized for

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

    91     otherwise single step is used.

    92 

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

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

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

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

    97     the previous window. This is equivalent to calling

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

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

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

   101     shortcuts.

   102 

   103     \sa QMdiArea

   104 */

   105 

   106 /*!

   107     \enum QMdiSubWindow::SubWindowOption

   108 

   109     This enum describes options that customize the behavior

   110     of QMdiSubWindow.

   111 

   112     \omitvalue AllowOutsideAreaHorizontally

   113     \omitvalue AllowOutsideAreaVertically

   114 

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

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

   117     resizes this instead of the subwindow itself.

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

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

   120     receive a single QResizeEvent.

   121     By default, this option is disabled.

   122 

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

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

   125     moves this instead of the subwindow itself.

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

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

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

   129 */

   130 

   131 /*!

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

   133 

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

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

   136     new, current state.

   137 */

   138 

   139 /*!

   140     \fn QMdiSubWindow::aboutToActivate()

   141 

   142     QMdiSubWindow emits this signal immediately before it is

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

   144     manages the subwindow will also emit the

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

   146 

   147     \sa QMdiArea::subWindowActivated()

   148 */

   149 

   150 #include "qmdisubwindow_p.h"

   151 

   152 #ifndef QT_NO_MDIAREA

   153 

   154 #include <QApplication>

   155 #include <QStylePainter>

   156 #include <QVBoxLayout>

   157 #include <QMouseEvent>

   158 #include <QWhatsThis>

   159 #include <QToolTip>

   160 #include <QMainWindow>

   161 #include <QScrollBar>

   162 #include <QDebug>

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

   164 #include <QMacStyle>

   165 #endif

   166 #include <QMdiArea>

   167 

   168 QT_BEGIN_NAMESPACE

   169 

   170 using namespace QMdi;

   171 

   172 static const QStyle::SubControl SubControls[] =

   173 {

   174     QStyle::SC_TitleBarLabel, // 1

   175     QStyle::SC_TitleBarSysMenu, // 2

   176     QStyle::SC_TitleBarMinButton, // 3

   177     QStyle::SC_TitleBarMaxButton, // 4

   178     QStyle::SC_TitleBarShadeButton, // 5

   179     QStyle::SC_TitleBarCloseButton, // 6

   180     QStyle::SC_TitleBarNormalButton, // 7

   181     QStyle::SC_TitleBarUnshadeButton, // 8

   182     QStyle::SC_TitleBarContextHelpButton // 9

   183 };

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

   185 

   186 static const QStyle::StandardPixmap ButtonPixmaps[] =

   187 {

   188     QStyle::SP_TitleBarMinButton,

   189     QStyle::SP_TitleBarNormalButton,

   190     QStyle::SP_TitleBarCloseButton

   191 };

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

   193 

   194 static const Qt::WindowFlags CustomizeWindowFlags =

   195       Qt::FramelessWindowHint

   196     | Qt::CustomizeWindowHint

   197     | Qt::WindowTitleHint

   198     | Qt::WindowSystemMenuHint

   199     | Qt::WindowMinimizeButtonHint

   200     | Qt::WindowMaximizeButtonHint

   201     | Qt::WindowMinMaxButtonsHint;

   202 

   203 

   204 static const int BoundaryMargin = 5;

   205 

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

   207                                         int delta, int maxDelta, int minDelta)

   208 {

   209     if (cflags & moveFlag) {

   210         if (delta > 0)

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

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

   213     }

   214     return 0;

   215 }

   216 

   217 static inline int getResizeDeltaComponent(uint cflags, uint resizeFlag,

   218                                           uint resizeReverseFlag, int delta)

   219 {

   220     if (cflags & resizeFlag) {

   221         if (cflags & resizeReverseFlag)

   222             return -delta;

   223         return delta;

   224     }

   225     return 0;

   226 }

   227 

   228 static inline bool isChildOfQMdiSubWindow(const QWidget *child)

   229 {

   230     Q_ASSERT(child);

   231     QWidget *parent = child->parentWidget();

   232     while (parent) {

   233         if (qobject_cast<QMdiSubWindow *>(parent))

   234             return true;

   235         parent = parent->parentWidget();

   236     }

   237     return false;

   238 }

   239 

   240 static inline bool isChildOfTabbedQMdiArea(const QMdiSubWindow *child)

   241 {

   242     Q_ASSERT(child);

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

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

   245             return true;

   246     }

   247     return false;

   248 }

   249 

   250 template<typename T>

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

   252 {

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

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

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

   256     }

   257     return 0;

   258 }

   259 

   260 QString QMdiSubWindowPrivate::originalWindowTitle()

   261 {

   262     Q_Q(QMdiSubWindow);

   263     if (originalTitle.isNull()) {

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

   265         if (originalTitle.isNull())

   266             originalTitle = QLatin1String("");

   267     }

   268     return originalTitle;

   269 }

   270 

   271 void QMdiSubWindowPrivate::setNewWindowTitle()

   272 {

   273     Q_Q(QMdiSubWindow);

   274     QString childTitle = q->windowTitle();

   275     if (childTitle.isEmpty())

   276         return;

   277     QString original = originalWindowTitle();

   278     if (!original.isEmpty()) {

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

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

   281 

   282     } else {

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

   284     }

   285 }

   286 

   287 static inline bool isHoverControl(QStyle::SubControl control)

   288 {

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

   290 }

   291 

   292 #if defined(Q_WS_WIN)

   293 static inline QRgb colorref2qrgb(COLORREF col)

   294 {

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

   296 }

   297 #endif

   298 

   299 #ifndef QT_NO_TOOLTIP

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

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

   302 {

   303     Q_ASSERT(helpEvent);

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

   305     Q_ASSERT(widget);

   306 

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

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

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

   310         return;

   311 #endif

   312 

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

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

   315     if (complexControl == QStyle::CC_MdiControls) {

   316         if (subControl == QStyle::SC_MdiMinButton)

   317             subControl = QStyle::SC_TitleBarMinButton;

   318         else if (subControl == QStyle::SC_MdiCloseButton)

   319             subControl = QStyle::SC_TitleBarCloseButton;

   320         else if (subControl == QStyle::SC_MdiNormalButton)

   321             subControl = QStyle::SC_TitleBarNormalButton;

   322         else

   323             subControl = QStyle::SC_None;

   324     }

   325 

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

   327     if (subControl == QStyle::SC_None)

   328         return;

   329 

   330     QString toolTip;

   331 

   332     switch (subControl) {

   333     case QStyle::SC_TitleBarMinButton:

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

   335         break;

   336     case QStyle::SC_TitleBarMaxButton:

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

   338         break;

   339     case QStyle::SC_TitleBarUnshadeButton:

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

   341         break;

   342     case QStyle::SC_TitleBarShadeButton:

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

   344         break;

   345     case QStyle::SC_TitleBarNormalButton:

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

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

   348         else

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

   350         break;

   351     case QStyle::SC_TitleBarCloseButton:

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

   353         break;

   354     case QStyle::SC_TitleBarContextHelpButton:

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

   356         break;

   357     case QStyle::SC_TitleBarSysMenu:

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

   359         break;

   360     default:

   361         break;

   362     }

   363 

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

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

   366 }

   367 #endif // QT_NO_TOOLTIP

   368 

   369 namespace QMdi {

   370 /*

   371     \class ControlLabel

   372     \internal

   373 */

   374 class ControlLabel : public QWidget

   375 {

   376     Q_OBJECT

   377 public:

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

   379 

   380     QSize sizeHint() const;

   381 

   382 signals:

   383     void _q_clicked();

   384     void _q_doubleClicked();

   385 

   386 protected:

   387     bool event(QEvent *event);

   388     void paintEvent(QPaintEvent *paintEvent);

   389     void mousePressEvent(QMouseEvent *mouseEvent);

   390     void mouseDoubleClickEvent(QMouseEvent *mouseEvent);

   391     void mouseReleaseEvent(QMouseEvent *mouseEvent);

   392 

   393 private:

   394     QPixmap label;

   395     bool isPressed;

   396     void updateWindowIcon();

   397 };

   398 } // namespace QMdi

   399 

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

   401     : QWidget(parent), isPressed(false)

   402 {

   403     Q_UNUSED(subWindow);

   404     setFocusPolicy(Qt::NoFocus);

   405     updateWindowIcon();

   406     setFixedSize(label.size());

   407 }

   408 

   409 /*

   410     \internal

   411 */

   412 QSize ControlLabel::sizeHint() const

   413 {

   414     return label.size();

   415 }

   416 

   417 /*

   418     \internal

   419 */

   420 bool ControlLabel::event(QEvent *event)

   421 {

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

   423         updateWindowIcon();

   424 #ifndef QT_NO_TOOLTIP

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

   426         QStyleOptionTitleBar options;

   427         options.initFrom(this);

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

   429                     QStyle::CC_TitleBar, QStyle::SC_TitleBarSysMenu);

   430     }

   431 #endif

   432     return QWidget::event(event);

   433 }

   434 

   435 /*

   436     \internal

   437 */

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

   439 {

   440     QPainter painter(this);

   441     painter.drawPixmap(0, 0, label);

   442 }

   443 

   444 /*

   445     \internal

   446 */

   447 void ControlLabel::mousePressEvent(QMouseEvent *mouseEvent)

   448 {

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

   450         mouseEvent->ignore();

   451         return;

   452     }

   453     isPressed = true;

   454 }

   455 

   456 /*

   457     \internal

   458 */

   459 void ControlLabel::mouseDoubleClickEvent(QMouseEvent *mouseEvent)

   460 {

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

   462         mouseEvent->ignore();

   463         return;

   464     }

   465     isPressed = false;

   466     emit _q_doubleClicked();

   467 }

   468 

   469 /*

   470     \internal

   471 */

   472 void ControlLabel::mouseReleaseEvent(QMouseEvent *mouseEvent)

   473 {

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

   475         mouseEvent->ignore();

   476         return;

   477     }

   478     if (isPressed) {

   479         isPressed = false;

   480         emit _q_clicked();

   481     }

   482 }

   483 

   484 /*

   485     \internal

   486 */

   487 void ControlLabel::updateWindowIcon()

   488 {

   489     QIcon menuIcon = windowIcon();

   490     if (menuIcon.isNull())

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

   492     label = menuIcon.pixmap(16, 16);

   493     update();

   494 }

   495 

   496 namespace QMdi {

   497 /*

   498     \class ControllerWidget

   499     \internal

   500 */

   501 class ControllerWidget : public QWidget

   502 {

   503     Q_OBJECT

   504 public:

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

   506     QSize sizeHint() const;

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

   508     inline bool hasVisibleControls() const

   509     {

   510         return (visibleControls & QStyle::SC_MdiMinButton)

   511                || (visibleControls & QStyle::SC_MdiNormalButton)

   512                || (visibleControls & QStyle::SC_MdiCloseButton);

   513     }

   514 

   515 signals:

   516     void _q_minimize();

   517     void _q_restore();

   518     void _q_close();

   519 

   520 protected:

   521     void paintEvent(QPaintEvent *event);

   522     void mousePressEvent(QMouseEvent *event);

   523     void mouseReleaseEvent(QMouseEvent *event);

   524     void mouseMoveEvent(QMouseEvent *event);

   525     void leaveEvent(QEvent *event);

   526     bool event(QEvent *event);

   527 

   528 private:

   529     QStyle::SubControl activeControl;

   530     QStyle::SubControl hoverControl;

   531     QStyle::SubControls visibleControls;

   532     void initStyleOption(QStyleOptionComplex *option) const;

   533     QMdiArea *mdiArea;

   534     inline QStyle::SubControl getSubControl(const QPoint &pos) const

   535     {

   536         QStyleOptionComplex opt;

   537         initStyleOption(&opt);

   538         return style()->hitTestComplexControl(QStyle::CC_MdiControls, &opt, pos, mdiArea);

   539     }

   540 };

   541 } // namespace QMdi

   542 

   543 /*

   544     \internal

   545 */

   546 ControllerWidget::ControllerWidget(QMdiSubWindow *subWindow, QWidget *parent)

   547     : QWidget(parent),

   548       activeControl(QStyle::SC_None),

   549       hoverControl(QStyle::SC_None),

   550       visibleControls(QStyle::SC_None),

   551       mdiArea(0)

   552 {

   553     if (subWindow->parentWidget())

   554         mdiArea = qobject_cast<QMdiArea *>(subWindow->parentWidget()->parentWidget());

   555     setFocusPolicy(Qt::NoFocus);

   556     setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);

   557     setMouseTracking(true);

   558 }

   559 

   560 /*

   561     \internal

   562 */

   563 QSize ControllerWidget::sizeHint() const

   564 {

   565     ensurePolished();

   566     QStyleOptionComplex opt;

   567     initStyleOption(&opt);

   568     QSize size(48, 16);

   569     return style()->sizeFromContents(QStyle::CT_MdiControls, &opt, size, mdiArea);

   570 }

   571 

   572 void ControllerWidget::setControlVisible(QMdiSubWindowPrivate::WindowStateAction action, bool visible)

   573 {

   574     QStyle::SubControl subControl = QStyle::SC_None;

   575 

   576     // Map action from QMdiSubWindowPrivate::WindowStateAction to QStyle::SubControl.

   577     if (action == QMdiSubWindowPrivate::MaximizeAction)

   578         subControl = QStyle::SC_MdiNormalButton;

   579     else if (action == QMdiSubWindowPrivate::CloseAction)

   580         subControl = QStyle::SC_MdiCloseButton;

   581     else if (action == QMdiSubWindowPrivate::MinimizeAction)

   582         subControl = QStyle::SC_MdiMinButton;

   583 

   584     if (subControl == QStyle::SC_None)

   585         return;

   586 

   587     if (visible && !(visibleControls & subControl))

   588         visibleControls |= subControl;

   589     else if (!visible && (visibleControls & subControl))

   590         visibleControls &= ~subControl;

   591 }

   592 

   593 /*

   594     \internal

   595 */

   596 void ControllerWidget::paintEvent(QPaintEvent * /*paintEvent*/)

   597 {

   598     QStyleOptionComplex opt;

   599     initStyleOption(&opt);

   600     if (activeControl == hoverControl) {

   601         opt.activeSubControls = activeControl;

   602         opt.state |= QStyle::State_Sunken;

   603     } else if (hoverControl != QStyle::SC_None && (activeControl == QStyle::SC_None)) {

   604         opt.activeSubControls = hoverControl;

   605         opt.state |= QStyle::State_MouseOver;

   606     }

   607     QPainter painter(this);

   608     style()->drawComplexControl(QStyle::CC_MdiControls, &opt, &painter, mdiArea);

   609 }

   610 

   611 /*

   612     \internal

   613 */

   614 void ControllerWidget::mousePressEvent(QMouseEvent *event)

   615 {

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

   617         event->ignore();

   618         return;

   619     }

   620     activeControl = getSubControl(event->pos());

   621     update();

   622 }

   623 

   624 /*

   625     \internal

   626 */

   627 void ControllerWidget::mouseReleaseEvent(QMouseEvent *event)

   628 {

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

   630         event->ignore();

   631         return;

   632     }

   633 

   634     QStyle::SubControl under_mouse = getSubControl(event->pos());

   635     if (under_mouse == activeControl) {

   636         switch (activeControl) {

   637         case QStyle::SC_MdiCloseButton:

   638             emit _q_close();

   639             break;

   640         case QStyle::SC_MdiNormalButton:

   641             emit _q_restore();

   642             break;

   643         case QStyle::SC_MdiMinButton:

   644             emit _q_minimize();

   645             break;

   646         default:

   647             break;

   648         }

   649     }

   650 

   651     activeControl = QStyle::SC_None;

   652     update();

   653 }

   654 

   655 /*

   656     \internal

   657 */

   658 void ControllerWidget::mouseMoveEvent(QMouseEvent *event)

   659 {

   660     QStyle::SubControl under_mouse = getSubControl(event->pos());

   661     //test if hover state changes

   662     if (hoverControl != under_mouse) {

   663         hoverControl = under_mouse;

   664         update();

   665     }

   666 }

   667 

   668 /*

   669     \internal

   670 */

   671 void ControllerWidget::leaveEvent(QEvent * /*event*/)

   672 {

   673     hoverControl = QStyle::SC_None;

   674     update();

   675 }

   676 

   677 /*

   678     \internal

   679 */

   680 bool ControllerWidget::event(QEvent *event)

   681 {

   682 #ifndef QT_NO_TOOLTIP

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

   684         QStyleOptionComplex opt;

   685         initStyleOption(&opt);

   686         QHelpEvent *helpEvent = static_cast<QHelpEvent *>(event);

   687         showToolTip(helpEvent, this, opt, QStyle::CC_MdiControls, getSubControl(helpEvent->pos()));

   688     }

   689 #endif // QT_NO_TOOLTIP

   690     return QWidget::event(event);

   691 }

   692 

   693 /*

   694     \internal

   695 */

   696 void ControllerWidget::initStyleOption(QStyleOptionComplex *option) const

   697 {

   698     option->initFrom(this);

   699     option->subControls = visibleControls;

   700     option->activeSubControls = QStyle::SC_None;

   701 }

   702 

   703 /*

   704     \internal

   705 */

   706 ControlContainer::ControlContainer(QMdiSubWindow *mdiChild)

   707     : QObject(mdiChild),

   708       previousLeft(0),

   709       previousRight(0),

   710 #ifndef QT_NO_MENUBAR

   711       m_menuBar(0),

   712 #endif

   713       mdiChild(mdiChild)

   714 {

   715     Q_ASSERT(mdiChild);

   716 

   717     m_controllerWidget = new ControlElement<ControllerWidget>(mdiChild);

   718     connect(m_controllerWidget, SIGNAL(_q_close()), mdiChild, SLOT(close()));

   719     connect(m_controllerWidget, SIGNAL(_q_restore()), mdiChild, SLOT(showNormal()));

   720     connect(m_controllerWidget, SIGNAL(_q_minimize()), mdiChild, SLOT(showMinimized()));

   721 

   722     m_menuLabel = new ControlElement<ControlLabel>(mdiChild);

   723     m_menuLabel->setWindowIcon(mdiChild->windowIcon());

   724 #ifndef QT_NO_MENU

   725     connect(m_menuLabel, SIGNAL(_q_clicked()), mdiChild, SLOT(showSystemMenu()));

   726 #endif

   727     connect(m_menuLabel, SIGNAL(_q_doubleClicked()), mdiChild, SLOT(close()));

   728 }

   729 

   730 ControlContainer::~ControlContainer()

   731 {

   732 #ifndef QT_NO_MENUBAR

   733     removeButtonsFromMenuBar();

   734 #endif

   735     delete m_menuLabel;

   736     m_menuLabel = 0;

   737     delete m_controllerWidget;

   738     m_controllerWidget = 0;

   739 }

   740 

   741 #ifndef QT_NO_MENUBAR

   742 /*

   743     \internal

   744 */

   745 QMenuBar *QMdiSubWindowPrivate::menuBar() const

   746 {

   747 #if defined(QT_NO_MAINWINDOW)

   748     return 0;

   749 #else

   750     Q_Q(const QMdiSubWindow);

   751     if (!q->isMaximized() || drawTitleBarWhenMaximized() || isChildOfTabbedQMdiArea(q))

   752         return 0;

   753 

   754     if (QMainWindow *mainWindow = qobject_cast<QMainWindow *>(q->window()))

   755         return mainWindow->menuBar();

   756 

   757     return 0;

   758 #endif

   759 }

   760 

   761 /*

   762     \internal

   763 */

   764 void ControlContainer::showButtonsInMenuBar(QMenuBar *menuBar)

   765 {

   766     if (!menuBar || !mdiChild || mdiChild->windowFlags() & Qt::FramelessWindowHint)

   767         return;

   768     m_menuBar = menuBar;

   769 

   770     if (m_menuLabel && mdiChild->windowFlags() & Qt::WindowSystemMenuHint) {

   771         QWidget *currentLeft = menuBar->cornerWidget(Qt::TopLeftCorner);

   772         if (currentLeft)

   773             currentLeft->hide();

   774         if (currentLeft != m_menuLabel) {

   775             menuBar->setCornerWidget(m_menuLabel, Qt::TopLeftCorner);

   776             previousLeft = currentLeft;

   777         }

   778         m_menuLabel->show();

   779     }

   780     ControllerWidget *controllerWidget = qobject_cast<ControllerWidget *>(m_controllerWidget);

   781     if (controllerWidget && controllerWidget->hasVisibleControls()) {

   782         QWidget *currentRight = menuBar->cornerWidget(Qt::TopRightCorner);

   783         if (currentRight)

   784             currentRight->hide();

   785         if (currentRight != m_controllerWidget) {

   786             menuBar->setCornerWidget(m_controllerWidget, Qt::TopRightCorner);

   787             previousRight = currentRight;

   788         }

   789         m_controllerWidget->show();

   790     }

   791     mdiChild->d_func()->setNewWindowTitle();

   792 }

   793 

   794 /*

   795     \internal

   796 */

   797 void ControlContainer::removeButtonsFromMenuBar(QMenuBar *menuBar)

   798 {

   799     if (menuBar && menuBar != m_menuBar) {

   800         // m_menubar was deleted while sub-window was maximized

   801         previousRight = 0;

   802         previousLeft = 0;

   803         m_menuBar = menuBar;

   804     }

   805 

   806     if (!m_menuBar || !mdiChild || qt_widget_private(mdiChild->window())->data.in_destructor)

   807         return;

   808 

   809     QMdiSubWindow *child = 0;

   810     if (m_controllerWidget) {

   811         QWidget *currentRight = m_menuBar->cornerWidget(Qt::TopRightCorner);

   812         if (currentRight == m_controllerWidget) {

   813             if (ControlElement<ControllerWidget> *ce = ptr<ControllerWidget>(previousRight)) {

   814                 if (!ce->mdiChild || !ce->mdiChild->isMaximized())

   815                     previousRight = 0;

   816                 else

   817                     child = ce->mdiChild;

   818             }

   819             m_menuBar->setCornerWidget(previousRight, Qt::TopRightCorner);

   820             if (previousRight) {

   821                 previousRight->show();

   822                 previousRight = 0;

   823             }

   824         }

   825         m_controllerWidget->hide();

   826         m_controllerWidget->setParent(0);

   827     }

   828     if (m_menuLabel) {

   829         QWidget *currentLeft = m_menuBar->cornerWidget(Qt::TopLeftCorner);

   830         if (currentLeft == m_menuLabel) {

   831             if (ControlElement<ControlLabel> *ce = ptr<ControlLabel>(previousLeft)) {

   832                 if (!ce->mdiChild || !ce->mdiChild->isMaximized())

   833                     previousLeft = 0;

   834                 else if (!child)

   835                     child = mdiChild;

   836             }

   837             m_menuBar->setCornerWidget(previousLeft, Qt::TopLeftCorner);

   838             if (previousLeft) {

   839                 previousLeft->show();

   840                 previousLeft = 0;

   841             }

   842         }

   843         m_menuLabel->hide();

   844         m_menuLabel->setParent(0);

   845     }

   846     m_menuBar->update();

   847     if (child)

   848         child->d_func()->setNewWindowTitle();

   849     else if (mdiChild)

   850         mdiChild->window()->setWindowTitle(mdiChild->d_func()->originalWindowTitle());

   851 }

   852 

   853 #endif // QT_NO_MENUBAR

   854 

   855 void ControlContainer::updateWindowIcon(const QIcon &windowIcon)

   856 {

   857     if (m_menuLabel)

   858         m_menuLabel->setWindowIcon(windowIcon);

   859 }

   860 

   861 /*!

   862     \internal

   863 */

   864 QMdiSubWindowPrivate::QMdiSubWindowPrivate()

   865     : baseWidget(0),

   866       restoreFocusWidget(0),

   867       controlContainer(0),

   868 #ifndef QT_NO_SIZEGRIP

   869       sizeGrip(0),

   870 #endif

   871 #ifndef QT_NO_RUBBERBAND

   872       rubberBand(0),

   873 #endif

   874       userMinimumSize(0,0),

   875       resizeEnabled(true),

   876       moveEnabled(true),

   877       isInInteractiveMode(false),

   878 #ifndef QT_NO_RUBBERBAND

   879       isInRubberBandMode(false),

   880 #endif

   881       isShadeMode(false),

   882       ignoreWindowTitleChange(false),

   883       ignoreNextActivationEvent(false),

   884       activationEnabled(true),

   885       isShadeRequestFromMinimizeMode(false),

   886       isMaximizeMode(false),

   887       isWidgetHiddenByUs(false),

   888       isActive(false),

   889       isExplicitlyDeactivated(false),

   890       keyboardSingleStep(5),

   891       keyboardPageStep(20),

   892       resizeTimerId(-1),

   893       currentOperation(None),

   894       hoveredSubControl(QStyle::SC_None),

   895       activeSubControl(QStyle::SC_None),

   896       focusInReason(Qt::ActiveWindowFocusReason)

   897 {

   898     initOperationMap();

   899 }

   900 

   901 /*!

   902     \internal

   903 */

   904 void QMdiSubWindowPrivate::_q_updateStaysOnTopHint()

   905 {

   906 #ifndef QT_NO_ACTION

   907     Q_Q(QMdiSubWindow);

   908     if (QAction *senderAction = qobject_cast<QAction *>(q->sender())) {

   909         if (senderAction->isChecked()) {

   910             q->setWindowFlags(q->windowFlags() | Qt::WindowStaysOnTopHint);

   911             q->raise();

   912         } else {

   913             q->setWindowFlags(q->windowFlags() & ~Qt::WindowStaysOnTopHint);

   914             q->lower();

   915         }

   916     }

   917 #endif // QT_NO_ACTION

   918 }

   919 

   920 /*!

   921     \internal

   922 */

   923 void QMdiSubWindowPrivate::_q_enterInteractiveMode()

   924 {

   925 #ifndef QT_NO_ACTION

   926     Q_Q(QMdiSubWindow);

   927     QAction *action = qobject_cast<QAction *>(q->sender());

   928     if (!action)

   929         return;

   930 

   931     QPoint pressPos;

   932     if (actions[MoveAction] && actions[MoveAction] == action) {

   933         currentOperation = Move;

   934         pressPos = QPoint(q->width() / 2, titleBarHeight() - 1);

   935     } else if (actions[ResizeAction] && actions[ResizeAction] == action) {

   936         currentOperation = q->isLeftToRight() ? BottomRightResize : BottomLeftResize;

   937         int offset = q->style()->pixelMetric(QStyle::PM_MdiSubWindowFrameWidth, 0, q) / 2;

   938         int x = q->isLeftToRight() ? q->width() - offset : offset;

   939         pressPos = QPoint(x, q->height() - offset);

   940     } else {

   941         return;

   942     }

   943 

   944     updateCursor();

   945 #ifndef QT_NO_CURSOR

   946     q->cursor().setPos(q->mapToGlobal(pressPos));

   947 #endif

   948     mousePressPosition = q->mapToParent(pressPos);

   949     oldGeometry = q->geometry();

   950     isInInteractiveMode = true;

   951     q->setFocus();

   952 #ifndef QT_NO_RUBBERBAND

   953     if ((q->testOption(QMdiSubWindow::RubberBandResize)

   954             && (currentOperation == BottomRightResize || currentOperation == BottomLeftResize))

   955             || (q->testOption(QMdiSubWindow::RubberBandMove) && currentOperation == Move)) {

   956         enterRubberBandMode();

   957     } else

   958 #endif // QT_NO_RUBBERBAND

   959     {

   960         q->grabMouse();

   961     }

   962 #endif // QT_NO_ACTION

   963 }

   964 

   965 /*!

   966     \internal

   967 */

   968 void QMdiSubWindowPrivate::_q_processFocusChanged(QWidget *old, QWidget *now)

   969 {

   970     Q_UNUSED(old);

   971     Q_Q(QMdiSubWindow);

   972     if (now && (now == q || q->isAncestorOf(now))) {

   973         if (now == q && !isInInteractiveMode)

   974             setFocusWidget();

   975         setActive(true);

   976     }

   977 }

   978 

   979 /*!

   980     \internal

   981 */

   982 void QMdiSubWindowPrivate::leaveInteractiveMode()

   983 {

   984     Q_Q(QMdiSubWindow);

   985 #ifndef QT_NO_RUBBERBAND

   986     if (isInRubberBandMode)

   987         leaveRubberBandMode();

   988     else

   989 #endif

   990         q->releaseMouse();

   991     isInInteractiveMode = false;

   992     currentOperation = None;

   993     updateDirtyRegions();

   994     updateCursor();

   995     if (baseWidget && baseWidget->focusWidget())

   996         baseWidget->focusWidget()->setFocus();

   997 }

   998 

   999 /*!

  1000     \internal

  1001 */

  1002 void QMdiSubWindowPrivate::removeBaseWidget()

  1003 {

  1004     if (!baseWidget)

  1005         return;

  1006 

  1007     Q_Q(QMdiSubWindow);

  1008     baseWidget->removeEventFilter(q);

  1009     if (layout)

  1010         layout->removeWidget(baseWidget);

  1011     if (baseWidget->windowTitle() == q->windowTitle()) {

  1012         ignoreWindowTitleChange = true;

  1013         q->setWindowTitle(QString());

  1014         ignoreWindowTitleChange = false;

  1015         q->setWindowModified(false);

  1016     }

  1017     lastChildWindowTitle.clear();

  1018     baseWidget->setParent(0);

  1019     baseWidget = 0;

  1020     isWidgetHiddenByUs = false;

  1021 }

  1022 

  1023 /*!

  1024     \internal

  1025 */

  1026 void QMdiSubWindowPrivate::initOperationMap()

  1027 {

  1028     operationMap.insert(Move, OperationInfo(HMove | VMove, Qt::ArrowCursor, false));

  1029     operationMap.insert(TopResize, OperationInfo(VMove | VResize | VResizeReverse, Qt::SizeVerCursor));

  1030     operationMap.insert(BottomResize, OperationInfo(VResize, Qt::SizeVerCursor));

  1031     operationMap.insert(LeftResize, OperationInfo(HMove | HResize | HResizeReverse, Qt::SizeHorCursor));

  1032     operationMap.insert(RightResize, OperationInfo(HResize, Qt::SizeHorCursor));

  1033     operationMap.insert(TopLeftResize, OperationInfo(HMove | VMove | HResize | VResize | VResizeReverse

  1034                                                      | HResizeReverse, Qt::SizeFDiagCursor));

  1035     operationMap.insert(TopRightResize, OperationInfo(VMove | HResize | VResize

  1036                                                       | VResizeReverse, Qt::SizeBDiagCursor));

  1037     operationMap.insert(BottomLeftResize, OperationInfo(HMove | HResize | VResize | HResizeReverse,

  1038                                                         Qt::SizeBDiagCursor));

  1039     operationMap.insert(BottomRightResize, OperationInfo(HResize | VResize, Qt::SizeFDiagCursor));

  1040 }

  1041 

  1042 #ifndef QT_NO_MENU

  1043 

  1044 /*!

  1045     \internal

  1046 */

  1047 void QMdiSubWindowPrivate::createSystemMenu()

  1048 {

  1049     Q_Q(QMdiSubWindow);

  1050     Q_ASSERT_X(q, "QMdiSubWindowPrivate::createSystemMenu",

  1051                "You can NOT call this function before QMdiSubWindow's ctor");

  1052     systemMenu = new QMenu(q);

  1053     const QStyle *style = q->style();

  1054     addToSystemMenu(RestoreAction, QMdiSubWindow::tr("&Restore"), SLOT(showNormal()));

  1055     actions[RestoreAction]->setIcon(style->standardIcon(QStyle::SP_TitleBarNormalButton, 0, q));

  1056     actions[RestoreAction]->setEnabled(false);

  1057     addToSystemMenu(MoveAction, QMdiSubWindow::tr("&Move"), SLOT(_q_enterInteractiveMode()));

  1058     addToSystemMenu(ResizeAction, QMdiSubWindow::tr("&Size"), SLOT(_q_enterInteractiveMode()));

  1059     addToSystemMenu(MinimizeAction, QMdiSubWindow::tr("Mi&nimize"), SLOT(showMinimized()));

  1060     actions[MinimizeAction]->setIcon(style->standardIcon(QStyle::SP_TitleBarMinButton, 0, q));

  1061     addToSystemMenu(MaximizeAction, QMdiSubWindow::tr("Ma&ximize"), SLOT(showMaximized()));

  1062     actions[MaximizeAction]->setIcon(style->standardIcon(QStyle::SP_TitleBarMaxButton, 0, q));

  1063     addToSystemMenu(StayOnTopAction, QMdiSubWindow::tr("Stay on &Top"), SLOT(_q_updateStaysOnTopHint()));

  1064     actions[StayOnTopAction]->setCheckable(true);

  1065     systemMenu->addSeparator();

  1066     addToSystemMenu(CloseAction, QMdiSubWindow::tr("&Close"), SLOT(close()));

  1067     actions[CloseAction]->setIcon(style->standardIcon(QStyle::SP_TitleBarCloseButton, 0, q));

  1068 #if !defined(QT_NO_SHORTCUT)

  1069     actions[CloseAction]->setShortcuts(QKeySequence::Close);

  1070 #endif

  1071     updateActions();

  1072 }

  1073 #endif

  1074 

  1075 /*!

  1076     \internal

  1077 */

  1078 void QMdiSubWindowPrivate::updateCursor()

  1079 {

  1080 #ifndef QT_NO_CURSOR

  1081     Q_Q(QMdiSubWindow);

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

  1083     if (qobject_cast<QMacStyle *>(q->style()))

  1084         return;

  1085 #endif

  1086 

  1087     if (currentOperation == None) {

  1088         q->unsetCursor();

  1089         return;

  1090     }

  1091 

  1092     if (currentOperation == Move || operationMap.find(currentOperation).value().hover) {

  1093         q->setCursor(operationMap.find(currentOperation).value().cursorShape);

  1094         return;

  1095     }

  1096 #endif

  1097 }

  1098 

  1099 /*!

  1100     \internal

  1101 */

  1102 void QMdiSubWindowPrivate::updateDirtyRegions()

  1103 {

  1104     // No update necessary

  1105     if (!parent)

  1106         return;

  1107 

  1108     foreach (Operation operation, operationMap.keys())

  1109         operationMap.find(operation).value().region = getRegion(operation);

  1110 }

  1111 

  1112 /*!

  1113     \internal

  1114 */

  1115 void QMdiSubWindowPrivate::updateGeometryConstraints()

  1116 {

  1117     Q_Q(QMdiSubWindow);

  1118     if (!parent)

  1119         return;

  1120 

  1121     internalMinimumSize = (!q->isMinimized() && !q->minimumSize().isNull())

  1122                           ? q->minimumSize() : q->minimumSizeHint();

  1123     int margin, minWidth;

  1124     sizeParameters(&margin, &minWidth);

  1125     q->setContentsMargins(margin, titleBarHeight(), margin, margin);

  1126     if (q->isMaximized() || (q->isMinimized() && !q->isShaded())) {

  1127         moveEnabled = false;

  1128         resizeEnabled = false;

  1129     } else {

  1130         moveEnabled = true;

  1131         if ((q->windowFlags() & Qt::MSWindowsFixedSizeDialogHint) || q->isShaded())

  1132             resizeEnabled = false;

  1133         else

  1134             resizeEnabled = true;