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 #include "qworkspace.h"

    43 #ifndef QT_NO_WORKSPACE

    44 #include "qapplication.h"

    45 #include "qbitmap.h"

    46 #include "qcursor.h"

    47 #include "qdatetime.h"

    48 #include "qdesktopwidget.h"

    49 #include "qevent.h"

    50 #include "qhash.h"

    51 #include "qicon.h"

    52 #include "qimage.h"

    53 #include "qlabel.h"

    54 #include "qlayout.h"

    55 #include "qmenubar.h"

    56 #include "qmenu.h"

    57 #include "qpainter.h"

    58 #include "qpointer.h"

    59 #include "qscrollbar.h"

    60 #include "qstyle.h"

    61 #include "qstyleoption.h"

    62 #include "qtooltip.h"

    63 #include "qdebug.h"

    64 #include <private/qwidget_p.h>

    65 #include <private/qwidgetresizehandler_p.h>

    66 #include <private/qlayoutengine_p.h>

    67 

    68 QT_BEGIN_NAMESPACE

    69 

    70 class QWorkspaceTitleBarPrivate;

    71 

    72 

    73 /**************************************************************

    74 * QMDIControl

    75 *

    76 * Used for displaying MDI controls in a maximized MDI window

    77 *

    78 */

    79 class QMDIControl : public QWidget

    80 {

    81     Q_OBJECT

    82 signals:

    83     void _q_minimize();

    84     void _q_restore();

    85     void _q_close();

    86 

    87 public:

    88     QMDIControl(QWidget *widget);

    89 

    90 private:

    91     QSize sizeHint() const;

    92     void paintEvent(QPaintEvent *event);

    93     void mousePressEvent(QMouseEvent *event);

    94     void mouseReleaseEvent(QMouseEvent *event);

    95     void mouseMoveEvent(QMouseEvent *event);

    96     void leaveEvent(QEvent *event);

    97     bool event(QEvent *event);

    98     void initStyleOption(QStyleOptionComplex *option) const;

    99     QStyle::SubControl activeControl; //control locked by pressing and holding the mouse

   100     QStyle::SubControl hoverControl; //previously active hover control, used for tracking repaints

   101 };

   102 

   103 bool QMDIControl::event(QEvent *event)

   104 {

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

   106         QStyleOptionComplex opt;

   107         initStyleOption(&opt);

   108 #ifndef QT_NO_TOOLTIP

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

   110         QStyle::SubControl ctrl = style()->hitTestComplexControl(QStyle::CC_MdiControls, &opt,

   111                                                                  helpEvent->pos(), this);

   112         if (ctrl == QStyle::SC_MdiCloseButton)

   113             QToolTip::showText(helpEvent->globalPos(), QWorkspace::tr("Close"), this);

   114         else if (ctrl == QStyle::SC_MdiMinButton)

   115             QToolTip::showText(helpEvent->globalPos(), QWorkspace::tr("Minimize"), this);

   116         else if (ctrl == QStyle::SC_MdiNormalButton)

   117             QToolTip::showText(helpEvent->globalPos(), QWorkspace::tr("Restore Down"), this);

   118         else

   119             QToolTip::hideText();

   120 #endif // QT_NO_TOOLTIP

   121     }

   122     return QWidget::event(event);

   123 }

   124 

   125 void QMDIControl::initStyleOption(QStyleOptionComplex *option) const

   126 {

   127     option->initFrom(this);

   128     option->subControls = QStyle::SC_All;

   129     option->activeSubControls = QStyle::SC_None;

   130 }

   131 

   132 QMDIControl::QMDIControl(QWidget *widget)

   133     : QWidget(widget), activeControl(QStyle::SC_None),

   134       hoverControl(QStyle::SC_None)

   135 {

   136     setObjectName(QLatin1String("qt_maxcontrols"));

   137     setFocusPolicy(Qt::NoFocus);

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

   139     setMouseTracking(true);

   140 }

   141 

   142 QSize QMDIControl::sizeHint() const

   143 {

   144     ensurePolished();

   145     QStyleOptionComplex opt;

   146     initStyleOption(&opt);

   147     QSize size(48, 16);

   148     return style()->sizeFromContents(QStyle::CT_MdiControls, &opt, size, this);

   149 }

   150 

   151 void QMDIControl::mousePressEvent(QMouseEvent *event)

   152 {

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

   154         event->ignore();

   155         return;

   156     }

   157     QStyleOptionComplex opt;

   158     initStyleOption(&opt);

   159     QStyle::SubControl ctrl = style()->hitTestComplexControl(QStyle::CC_MdiControls, &opt,

   160                                                              event->pos(), this);

   161     activeControl = ctrl;

   162     update();

   163 }

   164 

   165 void QMDIControl::mouseReleaseEvent(QMouseEvent *event)

   166 {

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

   168         event->ignore();

   169         return;

   170     }

   171     QStyleOptionTitleBar opt;

   172     initStyleOption(&opt);

   173     QStyle::SubControl under_mouse = style()->hitTestComplexControl(QStyle::CC_MdiControls, &opt,

   174                                                                     event->pos(), this);

   175     if (under_mouse == activeControl) {

   176         switch (activeControl) {

   177         case QStyle::SC_MdiCloseButton:

   178             emit _q_close();

   179             break;

   180         case QStyle::SC_MdiNormalButton:

   181             emit _q_restore();

   182             break;

   183         case QStyle::SC_MdiMinButton:

   184             emit _q_minimize();

   185             break;

   186         default:

   187             break;

   188         }

   189     }

   190     activeControl = QStyle::SC_None;

   191     update();

   192 }

   193 

   194 void QMDIControl::leaveEvent(QEvent * /*event*/)

   195 {

   196     hoverControl = QStyle::SC_None;

   197     update();

   198 }

   199 

   200 void QMDIControl::mouseMoveEvent(QMouseEvent *event)

   201 {

   202     QStyleOptionTitleBar opt;

   203     initStyleOption(&opt);

   204     QStyle::SubControl under_mouse = style()->hitTestComplexControl(QStyle::CC_MdiControls, &opt,

   205                                                                     event->pos(), this);

   206     //test if hover state changes

   207     if (hoverControl != under_mouse) {

   208         hoverControl = under_mouse;

   209         update();

   210     }

   211 }

   212 

   213 void QMDIControl::paintEvent(QPaintEvent *)

   214 {

   215     QPainter p(this);

   216     QStyleOptionComplex opt;

   217     initStyleOption(&opt);

   218     if (activeControl == hoverControl) {

   219         opt.activeSubControls = activeControl;

   220         opt.state |= QStyle::State_Sunken;

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

   222         opt.activeSubControls = hoverControl;

   223         opt.state |= QStyle::State_MouseOver;

   224     }

   225     style()->drawComplexControl(QStyle::CC_MdiControls, &opt, &p, this);

   226 }

   227 

   228 class QWorkspaceTitleBar : public QWidget

   229 {

   230     Q_OBJECT

   231     Q_DECLARE_PRIVATE(QWorkspaceTitleBar)

   232     Q_PROPERTY(bool autoRaise READ autoRaise WRITE setAutoRaise)

   233     Q_PROPERTY(bool movable READ isMovable WRITE setMovable)

   234 

   235 public:

   236     QWorkspaceTitleBar (QWidget *w, QWidget *parent, Qt::WindowFlags f = 0);

   237     ~QWorkspaceTitleBar();

   238 

   239     bool isActive() const;

   240     bool usesActiveColor() const;

   241 

   242     bool isMovable() const;

   243     void setMovable(bool);

   244 

   245     bool autoRaise() const;

   246     void setAutoRaise(bool);

   247 

   248     QWidget *window() const;

   249     bool isTool() const;

   250 

   251     QSize sizeHint() const;

   252     void initStyleOption(QStyleOptionTitleBar *option) const;

   253 

   254 public slots:

   255     void setActive(bool);

   256 

   257 signals:

   258     void doActivate();

   259     void doNormal();

   260     void doClose();

   261     void doMaximize();

   262     void doMinimize();

   263     void doShade();

   264     void showOperationMenu();

   265     void popupOperationMenu(const QPoint&);

   266     void doubleClicked();

   267 

   268 protected:

   269     bool event(QEvent *);

   270 #ifndef QT_NO_CONTEXTMENU

   271     void contextMenuEvent(QContextMenuEvent *);

   272 #endif

   273     void mousePressEvent(QMouseEvent *);

   274     void mouseDoubleClickEvent(QMouseEvent *);

   275     void mouseReleaseEvent(QMouseEvent *);

   276     void mouseMoveEvent(QMouseEvent *);

   277     void enterEvent(QEvent *e);

   278     void leaveEvent(QEvent *e);

   279     void paintEvent(QPaintEvent *p);

   280 

   281 private:

   282     Q_DISABLE_COPY(QWorkspaceTitleBar)

   283 };

   284 

   285 

   286 class QWorkspaceTitleBarPrivate : public QWidgetPrivate

   287 {

   288     Q_DECLARE_PUBLIC(QWorkspaceTitleBar)

   289 public:

   290     QWorkspaceTitleBarPrivate()

   291         :

   292         lastControl(QStyle::SC_None),

   293 #ifndef QT_NO_TOOLTIP

   294         toolTip(0),

   295 #endif

   296         act(0), window(0), movable(1), pressed(0), autoraise(0), moving(0)

   297     {

   298     }

   299 

   300     Qt::WindowFlags flags;

   301     QStyle::SubControl buttonDown;

   302     QStyle::SubControl lastControl;

   303     QPoint moveOffset;

   304 #ifndef QT_NO_TOOLTIP

   305     QToolTip *toolTip;

   306 #endif

   307     bool act                    :1;

   308     QPointer<QWidget> window;

   309     bool movable            :1;

   310     bool pressed            :1;

   311     bool autoraise          :1;

   312     bool moving : 1;

   313 

   314     int titleBarState() const;

   315     void readColors();

   316 };

   317 

   318 inline int QWorkspaceTitleBarPrivate::titleBarState() const

   319 {

   320     Q_Q(const QWorkspaceTitleBar);

   321     uint state = window ? window->windowState() : static_cast<Qt::WindowStates>(Qt::WindowNoState);

   322     state |= uint((act && q->isActiveWindow()) ? QStyle::State_Active : QStyle::State_None);

   323     return (int)state;

   324 }

   325 

   326 void QWorkspaceTitleBar::initStyleOption(QStyleOptionTitleBar *option) const

   327 {

   328     Q_D(const QWorkspaceTitleBar);

   329     option->initFrom(this);

   330     //################

   331     if (d->window && (d->flags & Qt::WindowTitleHint)) {

   332         option->text = d->window->windowTitle();

   333         QIcon icon = d->window->windowIcon();

   334         QSize s = icon.actualSize(QSize(64, 64));

   335         option->icon = icon.pixmap(s);

   336     }

   337     option->subControls = QStyle::SC_All;

   338     option->activeSubControls = QStyle::SC_None;

   339     option->titleBarState = d->titleBarState();

   340     option->titleBarFlags = d->flags;

   341     option->state &= ~QStyle::State_MouseOver;

   342 }

   343 

   344 QWorkspaceTitleBar::QWorkspaceTitleBar(QWidget *w, QWidget *parent, Qt::WindowFlags f)

   345     : QWidget(*new QWorkspaceTitleBarPrivate, parent, Qt::FramelessWindowHint)

   346 {

   347     Q_D(QWorkspaceTitleBar);

   348     if (f == 0 && w)

   349         f = w->windowFlags();

   350     d->flags = f;

   351     d->window = w;

   352     d->buttonDown = QStyle::SC_None;

   353     d->act = 0;

   354     if (w) {

   355         if (w->maximumSize() != QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX))

   356             d->flags &= ~Qt::WindowMaximizeButtonHint;

   357         setWindowTitle(w->windowTitle());

   358     }

   359 

   360     d->readColors();

   361     setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));

   362     setMouseTracking(true);

   363     setAutoRaise(style()->styleHint(QStyle::SH_TitleBar_AutoRaise, 0, this));

   364 }

   365 

   366 QWorkspaceTitleBar::~QWorkspaceTitleBar()

   367 {

   368 }

   369 

   370 

   371 #ifdef Q_WS_WIN

   372 static inline QRgb colorref2qrgb(COLORREF col)

   373 {

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

   375 }

   376 #endif

   377 

   378 void QWorkspaceTitleBarPrivate::readColors()

   379 {

   380     Q_Q(QWorkspaceTitleBar);

   381     QPalette pal = q->palette();

   382 

   383     bool colorsInitialized = false;

   384 

   385 #ifdef Q_WS_WIN // ask system properties on windows

   386 #ifndef SPI_GETGRADIENTCAPTIONS

   387 #define SPI_GETGRADIENTCAPTIONS 0x1008

   388 #endif

   389 #ifndef COLOR_GRADIENTACTIVECAPTION

   390 #define COLOR_GRADIENTACTIVECAPTION 27

   391 #endif

   392 #ifndef COLOR_GRADIENTINACTIVECAPTION

   393 #define COLOR_GRADIENTINACTIVECAPTION 28

   394 #endif

   395     if (QApplication::desktopSettingsAware()) {

   396         pal.setColor(QPalette::Active, QPalette::Highlight, colorref2qrgb(GetSysColor(COLOR_ACTIVECAPTION)));

   397         pal.setColor(QPalette::Inactive, QPalette::Highlight, colorref2qrgb(GetSysColor(COLOR_INACTIVECAPTION)));

   398         pal.setColor(QPalette::Active, QPalette::HighlightedText, colorref2qrgb(GetSysColor(COLOR_CAPTIONTEXT)));

   399         pal.setColor(QPalette::Inactive, QPalette::HighlightedText, colorref2qrgb(GetSysColor(COLOR_INACTIVECAPTIONTEXT)));

   400 

   401         colorsInitialized = true;

   402         BOOL gradient = false;

   403         SystemParametersInfo(SPI_GETGRADIENTCAPTIONS, 0, &gradient, 0);

   404 

   405         if (gradient) {

   406             pal.setColor(QPalette::Active, QPalette::Base, colorref2qrgb(GetSysColor(COLOR_GRADIENTACTIVECAPTION)));

   407             pal.setColor(QPalette::Inactive, QPalette::Base, colorref2qrgb(GetSysColor(COLOR_GRADIENTINACTIVECAPTION)));

   408         } else {

   409             pal.setColor(QPalette::Active, QPalette::Base, pal.color(QPalette::Active, QPalette::Highlight));

   410             pal.setColor(QPalette::Inactive, QPalette::Base, pal.color(QPalette::Inactive, QPalette::Highlight));

   411         }

   412     }

   413 #endif // Q_WS_WIN

   414     if (!colorsInitialized) {

   415         pal.setColor(QPalette::Active, QPalette::Highlight,

   416                       pal.color(QPalette::Active, QPalette::Highlight));

   417         pal.setColor(QPalette::Active, QPalette::Base,

   418                       pal.color(QPalette::Active, QPalette::Highlight));

   419         pal.setColor(QPalette::Inactive, QPalette::Highlight,

   420                       pal.color(QPalette::Inactive, QPalette::Dark));

   421         pal.setColor(QPalette::Inactive, QPalette::Base,

   422                       pal.color(QPalette::Inactive, QPalette::Dark));

   423         pal.setColor(QPalette::Inactive, QPalette::HighlightedText,

   424                       pal.color(QPalette::Inactive, QPalette::Window));

   425     }

   426 

   427     q->setPalette(pal);

   428     q->setActive(act);

   429 }

   430 

   431 void QWorkspaceTitleBar::mousePressEvent(QMouseEvent *e)

   432 {

   433     Q_D(QWorkspaceTitleBar);

   434     if (!d->act)

   435         emit doActivate();

   436     if (e->button() == Qt::LeftButton) {

   437         if (style()->styleHint(QStyle::SH_TitleBar_NoBorder, 0, 0)

   438             && !rect().adjusted(5, 5, -5, 0).contains(e->pos())) {

   439             // propagate border events to the QWidgetResizeHandler

   440             e->ignore();

   441             return;

   442         }

   443 

   444         d->pressed = true;

   445         QStyleOptionTitleBar opt;

   446         initStyleOption(&opt);

   447         QStyle::SubControl ctrl = style()->hitTestComplexControl(QStyle::CC_TitleBar, &opt,

   448                                                                  e->pos(), this);

   449         switch (ctrl) {

   450         case QStyle::SC_TitleBarSysMenu:

   451             if (d->flags & Qt::WindowSystemMenuHint) {

   452                 d->buttonDown = QStyle::SC_None;

   453                 static QTime *t = 0;

   454                 static QWorkspaceTitleBar *tc = 0;

   455                 if (!t)

   456                     t = new QTime;

   457                 if (tc != this || t->elapsed() > QApplication::doubleClickInterval()) {

   458                     emit showOperationMenu();

   459                     t->start();

   460                     tc = this;

   461                 } else {

   462                     tc = 0;

   463                     emit doClose();

   464                     return;

   465                 }

   466             }

   467             break;

   468 

   469         case QStyle::SC_TitleBarShadeButton:

   470         case QStyle::SC_TitleBarUnshadeButton:

   471             if (d->flags & Qt::WindowShadeButtonHint)

   472                 d->buttonDown = ctrl;

   473             break;

   474 

   475         case QStyle::SC_TitleBarNormalButton:

   476                 d->buttonDown = ctrl;

   477             break;

   478 

   479         case QStyle::SC_TitleBarMinButton:

   480             if (d->flags & Qt::WindowMinimizeButtonHint)

   481                 d->buttonDown = ctrl;

   482             break;

   483 

   484         case QStyle::SC_TitleBarMaxButton:

   485             if (d->flags & Qt::WindowMaximizeButtonHint)

   486                 d->buttonDown = ctrl;

   487             break;

   488 

   489         case QStyle::SC_TitleBarCloseButton:

   490             if (d->flags & Qt::WindowSystemMenuHint)

   491                 d->buttonDown = ctrl;

   492             break;

   493 

   494         case QStyle::SC_TitleBarLabel:

   495             d->buttonDown = ctrl;

   496             d->moveOffset = mapToParent(e->pos());

   497             break;

   498 

   499         default:

   500             break;

   501         }

   502         update();

   503     } else {

   504         d->pressed = false;

   505     }

   506 }

   507 

   508 #ifndef QT_NO_CONTEXTMENU

   509 void QWorkspaceTitleBar::contextMenuEvent(QContextMenuEvent *e)

   510 {

   511     QStyleOptionTitleBar opt;

   512     initStyleOption(&opt);

   513     QStyle::SubControl ctrl = style()->hitTestComplexControl(QStyle::CC_TitleBar, &opt, e->pos(),

   514                                                              this);

   515     if(ctrl == QStyle::SC_TitleBarLabel || ctrl == QStyle::SC_TitleBarSysMenu) {

   516         e->accept();

   517         emit popupOperationMenu(e->globalPos());

   518     } else {

   519         e->ignore();

   520     }

   521 }

   522 #endif // QT_NO_CONTEXTMENU

   523 

   524 void QWorkspaceTitleBar::mouseReleaseEvent(QMouseEvent *e)

   525 {

   526     Q_D(QWorkspaceTitleBar);

   527     if (!d->window) {

   528         // could have been deleted as part of a double click event on the sysmenu

   529         return;

   530     }

   531     if (e->button() == Qt::LeftButton && d->pressed) {

   532         if (style()->styleHint(QStyle::SH_TitleBar_NoBorder, 0, 0)

   533             && !rect().adjusted(5, 5, -5, 0).contains(e->pos())) {

   534             // propagate border events to the QWidgetResizeHandler

   535             e->ignore();

   536             d->buttonDown = QStyle::SC_None;

   537             d->pressed = false;

   538             return;

   539         }

   540         e->accept();

   541         QStyleOptionTitleBar opt;

   542         initStyleOption(&opt);

   543         QStyle::SubControl ctrl = style()->hitTestComplexControl(QStyle::CC_TitleBar, &opt,

   544                                                                  e->pos(), this);

   545 

   546         if (d->pressed) {

   547             update();

   548             d->pressed = false;

   549             d->moving = false;

   550         }

   551         if (ctrl == d->buttonDown) {

   552             d->buttonDown = QStyle::SC_None;

   553             switch(ctrl) {

   554             case QStyle::SC_TitleBarShadeButton:

   555             case QStyle::SC_TitleBarUnshadeButton:

   556                 if(d->flags & Qt::WindowShadeButtonHint)

   557                     emit doShade();

   558                 break;

   559 

   560             case QStyle::SC_TitleBarNormalButton:

   561                 if(d->flags & Qt::WindowMinMaxButtonsHint)

   562                     emit doNormal();

   563                 break;

   564 

   565             case QStyle::SC_TitleBarMinButton:

   566                 if(d->flags & Qt::WindowMinimizeButtonHint) {

   567                     if (d->window && d->window->isMinimized())

   568                         emit doNormal();

   569                     else

   570                         emit doMinimize();

   571                 }

   572                 break;

   573 

   574             case QStyle::SC_TitleBarMaxButton:

   575                 if(d->flags & Qt::WindowMaximizeButtonHint) {

   576                     if(d->window && d->window->isMaximized())

   577                         emit doNormal();

   578                     else

   579                         emit doMaximize();

   580                 }

   581                 break;

   582 

   583             case QStyle::SC_TitleBarCloseButton:

   584                 if(d->flags & Qt::WindowSystemMenuHint) {

   585                     d->buttonDown = QStyle::SC_None;

   586                     emit doClose();

   587                     return;

   588                 }

   589                 break;

   590 

   591             default:

   592                 break;

   593             }

   594         }

   595     } else {

   596         e->ignore();

   597     }

   598 }

   599 

   600 void QWorkspaceTitleBar::mouseMoveEvent(QMouseEvent *e)

   601 {

   602     Q_D(QWorkspaceTitleBar);

   603     e->ignore();

   604     if ((e->buttons() & Qt::LeftButton) && style()->styleHint(QStyle::SH_TitleBar_NoBorder, 0, 0)

   605         && !rect().adjusted(5, 5, -5, 0).contains(e->pos()) && !d->pressed) {

   606         // propagate border events to the QWidgetResizeHandler

   607         return;

   608     }

   609 

   610     QStyleOptionTitleBar opt;

   611     initStyleOption(&opt);

   612     QStyle::SubControl under_mouse = style()->hitTestComplexControl(QStyle::CC_TitleBar, &opt,

   613                                                                     e->pos(), this);

   614     if(under_mouse != d->lastControl) {

   615         d->lastControl = under_mouse;

   616         update();

   617     }

   618 

   619     switch (d->buttonDown) {

   620     case QStyle::SC_None:

   621         break;

   622     case QStyle::SC_TitleBarSysMenu:

   623         break;

   624     case QStyle::SC_TitleBarLabel:

   625         if (d->buttonDown == QStyle::SC_TitleBarLabel && d->movable && d->pressed) {

   626             if (d->moving || (d->moveOffset - mapToParent(e->pos())).manhattanLength() >= 4) {

   627                 d->moving = true;

   628                 QPoint p = mapFromGlobal(e->globalPos());

   629 

   630                 QWidget *parent = d->window ? d->window->parentWidget() : 0;

   631                 if(parent && parent->inherits("QWorkspaceChild")) {

   632                     QWidget *workspace = parent->parentWidget();

   633                     p = workspace->mapFromGlobal(e->globalPos());

   634                     if (!workspace->rect().contains(p)) {

   635                         if (p.x() < 0)

   636                             p.rx() = 0;

   637                         if (p.y() < 0)

   638                             p.ry() = 0;

   639                         if (p.x() > workspace->width())

   640                             p.rx() = workspace->width();

   641                         if (p.y() > workspace->height())

   642                             p.ry() = workspace->height();

   643                     }

   644                 }

   645 

   646                 QPoint pp = p - d->moveOffset;

   647                 if (!parentWidget()->isMaximized())

   648                     parentWidget()->move(pp);

   649             }

   650         }

   651         e->accept();

   652         break;

   653     default:

   654         break;

   655     }

   656 }

   657 

   658 bool QWorkspaceTitleBar::isTool() const

   659 {

   660     Q_D(const QWorkspaceTitleBar);

   661     return (d->flags & Qt::WindowType_Mask) == Qt::Tool;

   662 }

   663 

   664 // from qwidget.cpp

   665 extern QString qt_setWindowTitle_helperHelper(const QString &, const QWidget*);

   666 

   667 void QWorkspaceTitleBar::paintEvent(QPaintEvent *)

   668 {

   669     Q_D(QWorkspaceTitleBar);

   670     QStyleOptionTitleBar opt;

   671     initStyleOption(&opt);

   672     opt.subControls = QStyle::SC_TitleBarLabel;

   673     opt.activeSubControls = d->buttonDown;

   674 

   675     if (d->window && (d->flags & Qt::WindowTitleHint)) {

   676         QString title = qt_setWindowTitle_helperHelper(opt.text, d->window);

   677         int maxw = style()->subControlRect(QStyle::CC_TitleBar, &opt, QStyle::SC_TitleBarLabel,

   678                                        this).width();

   679         opt.text = fontMetrics().elidedText(title, Qt::ElideRight, maxw);

   680     }

   681 

   682     if (d->flags & Qt::WindowSystemMenuHint) {

   683         opt.subControls |= QStyle::SC_TitleBarSysMenu | QStyle::SC_TitleBarCloseButton;

   684         if (d->window && (d->flags & Qt::WindowShadeButtonHint)) {

   685             if (d->window->isMinimized())

   686                 opt.subControls |= QStyle::SC_TitleBarUnshadeButton;

   687             else

   688                 opt.subControls |= QStyle::SC_TitleBarShadeButton;

   689         }

   690         if (d->window && (d->flags & Qt::WindowMinMaxButtonsHint)) {

   691             if(d->window && d->window->isMinimized())

   692                 opt.subControls |= QStyle::SC_TitleBarNormalButton;

   693             else

   694                 opt.subControls |= QStyle::SC_TitleBarMinButton;

   695         }

   696         if (d->window && (d->flags & Qt::WindowMaximizeButtonHint) && !d->window->isMaximized())

   697             opt.subControls |= QStyle::SC_TitleBarMaxButton;

   698     }

   699 

   700     QStyle::SubControl under_mouse = QStyle::SC_None;

   701     under_mouse = style()->hitTestComplexControl(QStyle::CC_TitleBar, &opt,

   702                                                      mapFromGlobal(QCursor::pos()), this);

   703     if ((d->buttonDown == under_mouse) && d->pressed) {

   704         opt.state |= QStyle::State_Sunken;

   705     } else if( autoRaise() && under_mouse != QStyle::SC_None && !d->pressed) {

   706         opt.activeSubControls = under_mouse;

   707         opt.state |= QStyle::State_MouseOver;

   708     }

   709     opt.palette.setCurrentColorGroup(usesActiveColor() ? QPalette::Active : QPalette::Inactive);

   710 

   711     QPainter p(this);

   712     style()->drawComplexControl(QStyle::CC_TitleBar, &opt, &p, this);

   713 }

   714 

   715 void QWorkspaceTitleBar::mouseDoubleClickEvent(QMouseEvent *e)

   716 {

   717     Q_D(QWorkspaceTitleBar);

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

   719         e->ignore();

   720         return;

   721     }

   722     e->accept();

   723     QStyleOptionTitleBar opt;

   724     initStyleOption(&opt);

   725     switch (style()->hitTestComplexControl(QStyle::CC_TitleBar, &opt, e->pos(), this)) {

   726     case QStyle::SC_TitleBarLabel:

   727         emit doubleClicked();

   728         break;

   729 

   730     case QStyle::SC_TitleBarSysMenu:

   731         if (d->flags & Qt::WindowSystemMenuHint)

   732             emit doClose();

   733         break;

   734 

   735     default:

   736         break;

   737     }

   738 }

   739 

   740 void QWorkspaceTitleBar::leaveEvent(QEvent *)

   741 {

   742     Q_D(QWorkspaceTitleBar);

   743     d->lastControl = QStyle::SC_None;

   744     if(autoRaise() && !d->pressed)

   745         update();

   746 }

   747 

   748 void QWorkspaceTitleBar::enterEvent(QEvent *)

   749 {

   750     Q_D(QWorkspaceTitleBar);

   751     if(autoRaise() && !d->pressed)

   752         update();

   753     QEvent e(QEvent::Leave);

   754     QApplication::sendEvent(parentWidget(), &e);

   755 }

   756 

   757 void QWorkspaceTitleBar::setActive(bool active)

   758 {

   759     Q_D(QWorkspaceTitleBar);

   760     if (d->act == active)

   761         return ;

   762 

   763     d->act = active;

   764     update();

   765 }

   766 

   767 bool QWorkspaceTitleBar::isActive() const

   768 {

   769     Q_D(const QWorkspaceTitleBar);

   770     return d->act;

   771 }

   772 

   773 bool QWorkspaceTitleBar::usesActiveColor() const

   774 {

   775     return (isActive() && isActiveWindow()) ||

   776         (!window() && QWidget::window()->isActiveWindow());

   777 }

   778 

   779 QWidget *QWorkspaceTitleBar::window() const

   780 {

   781     Q_D(const QWorkspaceTitleBar);

   782     return d->window;

   783 }

   784 

   785 bool QWorkspaceTitleBar::event(QEvent *e)

   786 {

   787     Q_D(QWorkspaceTitleBar);

   788     if (e->type() == QEvent::ApplicationPaletteChange) {

   789         d->readColors();

   790     } else if (e->type() == QEvent::WindowActivate

   791                || e->type() == QEvent::WindowDeactivate) {

   792         if (d->act)

   793             update();

   794     }

   795     return QWidget::event(e);

   796 }

   797 

   798 void QWorkspaceTitleBar::setMovable(bool b)

   799 {

   800     Q_D(QWorkspaceTitleBar);

   801     d->movable = b;

   802 }

   803 

   804 bool QWorkspaceTitleBar::isMovable() const

   805 {

   806     Q_D(const QWorkspaceTitleBar);

   807     return d->movable;

   808 }

   809 

   810 void QWorkspaceTitleBar::setAutoRaise(bool b)

   811 {

   812     Q_D(QWorkspaceTitleBar);

   813     d->autoraise = b;

   814 }

   815 

   816 bool QWorkspaceTitleBar::autoRaise() const

   817 {

   818     Q_D(const QWorkspaceTitleBar);

   819     return d->autoraise;

   820 }

   821 

   822 QSize QWorkspaceTitleBar::sizeHint() const

   823 {

   824     ensurePolished();

   825     QStyleOptionTitleBar opt;

   826     initStyleOption(&opt);

   827     QRect menur = style()->subControlRect(QStyle::CC_TitleBar, &opt,

   828                                           QStyle::SC_TitleBarSysMenu, this);

   829     return QSize(menur.width(), style()->pixelMetric(QStyle::PM_TitleBarHeight, &opt, this));

   830 }

   831 

   832 /*!

   833     \class QWorkspace

   834     \obsolete

   835     \brief The QWorkspace widget provides a workspace window that can be

   836     used in an MDI application.

   837 

   838     This class is deprecated. Use QMdiArea instead.

   839 

   840     Multiple Document Interface (MDI) applications are typically

   841     composed of a main window containing a menu bar, a toolbar, and

   842     a central QWorkspace widget. The workspace itself is used to display

   843     a number of child windows, each of which is a widget.

   844 

   845     The workspace itself is an ordinary Qt widget. It has a standard

   846     constructor that takes a parent widget.

   847     Workspaces can be placed in any layout, but are typically given

   848     as the central widget in a QMainWindow:

   849 

   850     \snippet doc/src/snippets/code/src_gui_widgets_qworkspace.cpp 0

   851 

   852     Child windows (MDI windows) are standard Qt widgets that are

   853     inserted into the workspace with addWindow(). As with top-level

   854     widgets, you can call functions such as show(), hide(),

   855     showMaximized(), and setWindowTitle() on a child window to change

   856     its appearance within the workspace. You can also provide widget

   857     flags to determine the layout of the decoration or the behavior of

   858     the widget itself.

   859 

   860     To change or retrieve the geometry of a child window, you must

   861     operate on its parentWidget(). The parentWidget() provides

   862     access to the decorated frame that contains the child window

   863     widget. When a child window is maximised, its decorated frame

   864     is hidden. If the top-level widget contains a menu bar, it will display

   865     the maximised window's operations menu to the left of the menu

   866     entries, and the window's controls to the right.

   867 

   868     A child window becomes active when it gets the keyboard focus,

   869     or when setFocus() is called. The user can activate a window by moving

   870     focus in the usual ways, for example by clicking a window or by pressing

   871     Tab. The workspace emits a signal windowActivated() when the active

   872     window changes, and the function activeWindow() returns a pointer to the

   873     active child window, or 0 if no window is active.

   874 

   875     The convenience function windowList() returns a list of all child

   876     windows. This information could be used in a popup menu

   877     containing a list of windows, for example. This feature is also

   878     available as part of the \l{Window Menu} Solution.

   879 

   880     QWorkspace provides two built-in layout strategies for child

   881     windows: cascade() and tile(). Both are slots so you can easily

   882     connect menu entries to them.

   883 

   884     \table

   885     \row \o \inlineimage mdi-cascade.png

   886          \o \inlineimage mdi-tile.png

   887     \endtable

   888 

   889     If you want your users to be able to work with child windows

   890     larger than the visible workspace area, set the scrollBarsEnabled

   891     property to true.

   892 

   893     \sa QDockWidget, {MDI Example}

   894 */

   895 

   896 

   897 class QWorkspaceChild : public QWidget

   898 {

   899     Q_OBJECT

   900 

   901     friend class QWorkspacePrivate;

   902     friend class QWorkspace;

   903     friend class QWorkspaceTitleBar;

   904 

   905 public:

   906     QWorkspaceChild(QWidget* window, QWorkspace* parent=0, Qt::WindowFlags flags = 0);

   907     ~QWorkspaceChild();

   908 

   909     void setActive(bool);

   910     bool isActive() const;

   911 

   912     void adjustToFullscreen();

   913 

   914     QWidget* windowWidget() const;

   915     QWidget* iconWidget() const;

   916 

   917     void doResize();

   918     void doMove();

   919 

   920     QSize sizeHint() const;

   921     QSize minimumSizeHint() const;

   922 

   923     QSize baseSize() const;

   924 

   925     int frameWidth() const;

   926 

   927     void show();

   928 

   929     bool isWindowOrIconVisible() const;

   930 

   931 signals:

   932     void showOperationMenu();

   933     void popupOperationMenu(const QPoint&);

   934 

   935 public slots:

   936     void activate();

   937     void showMinimized();

   938     void showMaximized();

   939     void showNormal();

   940     void showShaded();

   941     void internalRaise();

   942     void titleBarDoubleClicked();

   943 

   944 protected:

   945     void enterEvent(QEvent *);

   946     void leaveEvent(QEvent *);

   947     void childEvent(QChildEvent*);

   948     void resizeEvent(QResizeEvent *);

   949     void moveEvent(QMoveEvent *);

   950     bool eventFilter(QObject *, QEvent *);

   951 

   952     void paintEvent(QPaintEvent *);

   953     void changeEvent(QEvent *);

   954 

   955 private:

   956     void updateMask();

   957 

   958     Q_DISABLE_COPY(QWorkspaceChild)

   959 

   960     QWidget *childWidget;

   961     QWidgetResizeHandler *widgetResizeHandler;

   962     QWorkspaceTitleBar *titlebar;

   963     QPointer<QWorkspaceTitleBar> iconw;

   964     QSize windowSize;

   965     QSize shadeRestore;

   966     QSize shadeRestoreMin;

   967     bool act                  :1;

   968     bool shademode            :1;

   969 };

   970 

   971 int QWorkspaceChild::frameWidth() const

   972 {

   973     return contentsRect().left();

   974 }

   975 

   976 

   977 

   978 class QWorkspacePrivate : public QWidgetPrivate {

   979     Q_DECLARE_PUBLIC(QWorkspace)

   980 public:

   981     QWorkspaceChild* active;

   982     QList<QWorkspaceChild *> windows;

   983     QList<QWorkspaceChild *> focus;

   984     QList<QWidget *> icons;

   985     QWorkspaceChild* maxWindow;

   986     QRect maxRestore;

   987     QPointer<QMDIControl> maxcontrols;

   988     QPointer<QMenuBar> maxmenubar;

   989     QHash<int, const char*> shortcutMap;

   990 

   991     int px;

   992     int py;

   993     QWidget *becomeActive;

   994     QPointer<QLabel> maxtools;

   995     QString topTitle;

   996 

   997     QMenu *popup, *toolPopup;

   998     enum WSActs { RestoreAct, MoveAct, ResizeAct, MinimizeAct, MaximizeAct, CloseAct, StaysOnTopAct, ShadeAct, NCountAct };

   999     QAction *actions[NCountAct];

  1000 

  1001     QScrollBar *vbar, *hbar;

  1002     QWidget *corner;

  1003     int yoffset, xoffset;

  1004     QBrush background;

  1005 

  1006     void init();

  1007     void insertIcon(QWidget* w);

  1008     void removeIcon(QWidget* w);

  1009     void place(QWidget*);

  1010 

  1011     QWorkspaceChild* findChild(QWidget* w);

  1012     void showMaximizeControls();

  1013     void hideMaximizeControls();

  1014     void activateWindow(QWidget* w, bool change_focus = true);

  1015     void hideChild(QWorkspaceChild *c);

  1016     void showWindow(QWidget* w);

  1017     void maximizeWindow(QWidget* w);

  1018     void minimizeWindow(QWidget* w);

  1019     void normalizeWindow(QWidget* w);

  1020 

  1021     QRect updateWorkspace();

  1022 

  1023 private:

  1024     void _q_normalizeActiveWindow();

  1025     void _q_minimizeActiveWindow();

  1026     void _q_showOperationMenu();

  1027     void _q_popupOperationMenu(const QPoint&);

  1028     void _q_operationMenuActivated(QAction *);

  1029     void _q_scrollBarChanged();

  1030     void _q_updateActions();

  1031     bool inTitleChange;

  1032 };

  1033 

  1034 static bool isChildOf(QWidget * child, QWidget * parent)

  1035 {

  1036     if (!parent || !child)

  1037         return false;

  1038     QWidget * w = child;

  1039     while(w && w != parent)

  1040         w = w->parentWidget();

  1041     return w != 0;

  1042 }

  1043 

  1044 /*!

  1045     Constructs a workspace with the given \a parent.

  1046 */

  1047 QWorkspace::QWorkspace(QWidget *parent)

  1048     : QWidget(*new QWorkspacePrivate, parent, 0)

  1049 {

  1050     Q_D(QWorkspace);

  1051     d->init();

  1052 }

  1053 

  1054 #ifdef QT3_SUPPORT

  1055 /*!

  1056     Use one of the constructors that doesn't take the \a name

  1057     argument and then use setObjectName() instead.

  1058 */

  1059 QWorkspace::QWorkspace(QWidget *parent, const char *name)

  1060     : QWidget(*new QWorkspacePrivate, parent, 0)

  1061 {

  1062     Q_D(QWorkspace);

  1063     setObjectName(QString::fromAscii(name));

  1064     d->init();

  1065 }

  1066 #endif // QT3_SUPPORT

  1067 

  1068 /*!

  1069     \internal

  1070 */

  1071 void

  1072 QWorkspacePrivate::init()

  1073 {

  1074     Q_Q(QWorkspace);

  1075 

  1076     maxcontrols = 0;

  1077     active = 0;

  1078     maxWindow = 0;

  1079     maxtools = 0;

  1080     px = 0;

  1081     py = 0;

  1082     becomeActive = 0;

  1083     popup = new QMenu(q);

  1084     toolPopup = new QMenu(q);

  1085     popup->setObjectName(QLatin1String("qt_internal_mdi_popup"));

  1086     toolPopup->setObjectName(QLatin1String("qt_internal_mdi_tool_popup"));

  1087 

  1088     actions[QWorkspacePrivate::RestoreAct] = new QAction(QIcon(q->style()->standardPixmap(QStyle::SP_TitleBarNormalButton, 0, q)),

  1089                                                          QWorkspace::tr("&Restore"), q);

  1090     actions[QWorkspacePrivate::MoveAct] = new QAction(QWorkspace::tr("&Move"), q);

  1091     actions[QWorkspacePrivate::ResizeAct] = new QAction(QWorkspace::tr("&Size"), q);

  1092     actions[QWorkspacePrivate::MinimizeAct] = new QAction(QIcon(q->style()->standardPixmap(QStyle::SP_TitleBarMinButton, 0, q)),

  1093                                                           QWorkspace::tr("Mi&nimize"), q);

  1094     actions[QWorkspacePrivate::MaximizeAct] = new QAction(QIcon(q->style()->standardPixmap(QStyle::SP_TitleBarMaxButton, 0, q)),

  1095                                                           QWorkspace::tr("Ma&ximize"), q);

  1096     actions[QWorkspacePrivate::CloseAct] = new QAction(QIcon(q->style()->standardPixmap(QStyle::SP_TitleBarCloseButton, 0, q)),

  1097                                                           QWorkspace::tr("&Close")

  1098 #ifndef QT_NO_SHORTCUT

  1099                                                           +QLatin1Char('\t')+(QString)QKeySequence(Qt::CTRL+Qt::Key_F4)

  1100 #endif

  1101                                                           ,q);

  1102     QObject::connect(actions[QWorkspacePrivate::CloseAct], SIGNAL(triggered()), q, SLOT(closeActiveWindow()));

  1103     actions[QWorkspacePrivate::StaysOnTopAct] = new QAction(QWorkspace::tr("Stay on &Top"), q);

  1104     actions[QWorkspacePrivate::StaysOnTopAct]->setChecked(true);

  1105     actions[QWorkspacePrivate::ShadeAct] = new QAction(QIcon(q->style()->standardPixmap(QStyle::SP_TitleBarShadeButton, 0, q)),

  1106                                                           QWorkspace::tr("Sh&ade"), q);

  1107 

  1108     QObject::connect(popup, SIGNAL(aboutToShow()), q, SLOT(_q_updateActions()));

  1109     QObject::connect(popup, SIGNAL(triggered(QAction*)), q, SLOT(_q_operationMenuActivated(QAction*)));

  1110     popup->addAction(actions[QWorkspacePrivate::RestoreAct]);

  1111     popup->addAction(actions[QWorkspacePrivate::MoveAct]);

  1112     popup->addAction(actions[QWorkspacePrivate::ResizeAct]);

  1113     popup->addAction(actions[QWorkspacePrivate::MinimizeAct]);

  1114     popup->addAction(actions[QWorkspacePrivate::MaximizeAct]);

  1115     popup->addSeparator();

  1116     popup->addAction(actions[QWorkspacePrivate::CloseAct]);

  1117 

  1118     QObject::connect(toolPopup, SIGNAL(aboutToShow()), q, SLOT(_q_updateActions()));

  1119     QObject::connect(toolPopup, SIGNAL(triggered(QAction*)), q, SLOT(_q_operationMenuActivated(QAction*)));

  1120     toolPopup->addAction(actions[QWorkspacePrivate::MoveAct]);

  1121     toolPopup->addAction(actions[QWorkspacePrivate::ResizeAct]);

  1122     toolPopup->addAction(actions[QWorkspacePrivate::StaysOnTopAct]);

  1123     toolPopup->addSeparator();

  1124     toolPopup->addAction(actions[QWorkspacePrivate::ShadeAct]);

  1125     toolPopup->addAction(actions[QWorkspacePrivate::CloseAct]);

  1126 

  1127 #ifndef QT_NO_SHORTCUT

  1128     // Set up shortcut bindings (id -> slot), most used first

  1129     QList <QKeySequence> shortcuts = QKeySequence::keyBindings(QKeySequence::NextChild);

  1130     foreach (const QKeySequence &seq, shortcuts)

  1131         shortcutMap.insert(q->grabShortcut(seq), "activateNextWindow");

  1132 

  1133     shortcuts = QKeySequence::keyBindings(QKeySequence::PreviousChild);

  1134     foreach (const QKeySequence &seq, shortcuts)