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 "qlayout.h"

    43 

    44 #include "qapplication.h"

    45 #include "qlayoutengine_p.h"

    46 #include "qmenubar.h"

    47 #include "qtoolbar.h"

    48 #include "qsizegrip.h"

    49 #include "qevent.h"

    50 #include "qstyle.h"

    51 #include "qvariant.h"

    52 #include "qwidget_p.h"

    53 #include "qlayout_p.h"

    54 #include "qformlayout.h"

    55 

    56 QT_BEGIN_NAMESPACE

    57 

    58 static int menuBarHeightForWidth(QWidget *menubar, int w)

    59 {

    60     if (menubar && !menubar->isHidden() && !menubar->isWindow()) {

    61         int result = menubar->heightForWidth(qMax(w, menubar->minimumWidth()));

    62         if (result != -1)

    63             return result;

    64         result = menubar->sizeHint()

    65             .expandedTo(menubar->minimumSize())

    66             .expandedTo(menubar->minimumSizeHint())

    67             .boundedTo(menubar->maximumSize()).height();

    68         if (result != -1)

    69             return result;

    70     }

    71     return 0;

    72 }

    73 

    74 /*!

    75     \class QLayout

    76     \brief The QLayout class is the base class of geometry managers.

    77 

    78     \ingroup geomanagement

    79 

    80     This is an abstract base class inherited by the concrete classes

    81     QBoxLayout, QGridLayout, QFormLayout, and QStackedLayout.

    82 

    83     For users of QLayout subclasses or of QMainWindow there is seldom

    84     any need to use the basic functions provided by QLayout, such as

    85     setSizeConstraint() or setMenuBar(). See \l{Layout Management}

    86     for more information.

    87 

    88     To make your own layout manager, implement the functions

    89     addItem(), sizeHint(), setGeometry(), itemAt() and takeAt(). You

    90     should also implement minimumSize() to ensure your layout isn't

    91     resized to zero size if there is too little space. To support

    92     children whose heights depend on their widths, implement

    93     hasHeightForWidth() and heightForWidth(). See the

    94     \l{layouts/borderlayout}{Border Layout} and

    95     \l{layouts/flowlayout}{Flow Layout} examples for

    96     more information about implementing custom layout managers.

    97 

    98     Geometry management stops when the layout manager is deleted.

    99 

   100     \sa QLayoutItem, {Layout Management}, {Basic Layouts Example},

   101         {Border Layout Example}, {Flow Layout Example}

   102 */

   103 

   104 

   105 /*!

   106     Constructs a new top-level QLayout, with parent \a parent.

   107     \a parent may not be 0.

   108 

   109     There can be only one top-level layout for a widget. It is

   110     returned by QWidget::layout().

   111 */

   112 QLayout::QLayout(QWidget *parent)

   113     : QObject(*new QLayoutPrivate, parent)

   114 {

   115     if (!parent)

   116         return;

   117     parent->setLayout(this);

   118 }

   119 

   120 /*!

   121     Constructs a new child QLayout.

   122 

   123     This layout has to be inserted into another layout before geometry

   124     management will work.

   125 */

   126 QLayout::QLayout()

   127     : QObject(*new QLayoutPrivate, 0)

   128 {

   129 }

   130 

   131 

   132 /*! \internal

   133  */

   134 QLayout::QLayout(QLayoutPrivate &dd, QLayout *lay, QWidget *w)

   135     : QObject(dd, lay ? static_cast<QObject*>(lay) : static_cast<QObject*>(w))

   136 {

   137     Q_D(QLayout);

   138     if (lay) {

   139         lay->addItem(this);

   140     } else if (w) {

   141         if (w->layout()) {

   142             qWarning("QLayout: Attempting to add QLayout \"%s\" to %s \"%s\", which"

   143                      " already has a layout",

   144                      qPrintable(QObject::objectName()), w->metaObject()->className(),

   145                      w->objectName().toLocal8Bit().data());

   146             setParent(0);

   147         } else {

   148             d->topLevel = true;

   149             w->d_func()->layout = this;

   150             QT_TRY {

   151                 invalidate();

   152             } QT_CATCH(...) {

   153                 w->d_func()->layout = 0;

   154                 QT_RETHROW;

   155             }

   156         }

   157     }

   158 }

   159 

   160 QLayoutPrivate::QLayoutPrivate()

   161     : QObjectPrivate(), insideSpacing(-1), userLeftMargin(-1), userTopMargin(-1), userRightMargin(-1),

   162       userBottomMargin(-1), topLevel(false), enabled(true), activated(true), autoNewChild(false),

   163       constraint(QLayout::SetDefaultConstraint), menubar(0)

   164 {

   165 }

   166 

   167 void QLayoutPrivate::getMargin(int *result, int userMargin, QStyle::PixelMetric pm) const

   168 {

   169     if (!result)

   170         return;

   171 

   172     Q_Q(const QLayout);

   173     if (userMargin >= 0) {

   174         *result = userMargin;

   175     } else if (!topLevel) {

   176         *result = 0;

   177     } else if (QWidget *pw = q->parentWidget()) {

   178         *result = pw->style()->pixelMetric(pm, 0, pw);

   179     } else {

   180         *result = 0;

   181     }

   182 }

   183 

   184 // Static item factory functions that allow for hooking things in Designer

   185 

   186 QLayoutPrivate::QWidgetItemFactoryMethod QLayoutPrivate::widgetItemFactoryMethod = 0;

   187 QLayoutPrivate::QSpacerItemFactoryMethod QLayoutPrivate::spacerItemFactoryMethod = 0;

   188 

   189 QWidgetItem *QLayoutPrivate::createWidgetItem(const QLayout *layout, QWidget *widget)

   190 {

   191     if (widgetItemFactoryMethod)

   192         if (QWidgetItem *wi = (*widgetItemFactoryMethod)(layout, widget))

   193             return wi;

   194     return new QWidgetItemV2(widget);

   195 }

   196 

   197 QSpacerItem *QLayoutPrivate::createSpacerItem(const QLayout *layout, int w, int h, QSizePolicy::Policy hPolicy, QSizePolicy::Policy vPolicy)

   198 {

   199     if (spacerItemFactoryMethod)

   200         if (QSpacerItem *si = (*spacerItemFactoryMethod)(layout, w, h, hPolicy, vPolicy))

   201             return si;

   202     return new QSpacerItem(w, h,  hPolicy, vPolicy);

   203 }

   204 

   205 #ifdef QT3_SUPPORT

   206 /*!

   207     Constructs a new top-level QLayout called \a name, with parent

   208     widget \a parent. \a parent may not be 0.

   209 

   210     The \a margin is the number of pixels between the edge of the

   211     widget and the managed children. The \a spacing sets the value of

   212     spacing(), which gives the spacing between the managed widgets. If

   213     \a spacing is -1 (the default), spacing is set to the value of \a

   214     margin.

   215 

   216     There can be only one top-level layout for a widget. It is

   217     returned by QWidget::layout()

   218 

   219     \sa QWidget::setLayout()

   220 */

   221 QLayout::QLayout(QWidget *parent, int margin, int spacing, const char *name)

   222     : QObject(*new QLayoutPrivate,parent)

   223 {

   224     Q_D(QLayout);

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

   226     setMargin(margin);

   227     if (spacing < 0)

   228         d->insideSpacing = margin;

   229     else

   230         d->insideSpacing = spacing;

   231     if (parent) {

   232         if (parent->layout()) {

   233             qWarning("QLayout \"%s\" added to %s \"%s\", which already has a layout",

   234                      QObject::objectName().toLocal8Bit().data(), parent->metaObject()->className(),

   235                      parent->objectName().toLocal8Bit().data());

   236             parent->layout()->setParent(0);

   237         } else {

   238             d->topLevel = true;

   239             parent->d_func()->layout = this;

   240             QT_TRY {

   241                 invalidate();

   242             } QT_CATCH(...) {

   243                 parent->d_func()->layout = 0;

   244                 QT_RETHROW;

   245             }

   246         }

   247     }

   248 }

   249 

   250 /*!

   251     Constructs a new child QLayout called \a name, and places it

   252     inside \a parentLayout by using the default placement defined by

   253     addItem().

   254 

   255     If \a spacing is -1, this QLayout inherits \a parentLayout's

   256     spacing(), otherwise the value of \a spacing is used.

   257 */

   258 QLayout::QLayout(QLayout *parentLayout, int spacing, const char *name)

   259     : QObject(*new QLayoutPrivate,parentLayout)

   260 

   261 {

   262     Q_D(QLayout);

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

   264     d->insideSpacing = spacing;

   265     parentLayout->addItem(this);

   266 }

   267 

   268 /*!

   269     Constructs a new child QLayout called \a name. If \a spacing is

   270     -1, this QLayout inherits its parent's spacing(); otherwise the

   271     value of \a spacing is used.

   272 

   273     This layout has to be inserted into another layout before geometry

   274     management will work.

   275 */

   276 QLayout::QLayout(int spacing, const char *name)

   277     : QObject(*new QLayoutPrivate, 0)

   278 {

   279     Q_D(QLayout);

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

   281     d->insideSpacing = spacing;

   282 }

   283 

   284 /*!

   285     Automatically adding widgets is deprecated. Use addWidget() or

   286     addLayout() instead.

   287 */

   288 void QLayout::setAutoAdd(bool a) { Q_D(QLayout); d->autoNewChild = a; }

   289 

   290 /*!

   291     Automatically adding widgets is deprecated. Use addWidget() or

   292     addLayout() instead.

   293 */

   294 bool QLayout::autoAdd() const { Q_D(const QLayout); return d->autoNewChild; }

   295 #endif

   296 

   297 

   298 /*!

   299     \fn void QLayout::addItem(QLayoutItem *item)

   300 

   301     Implemented in subclasses to add an \a item. How it is added is

   302     specific to each subclass.

   303 

   304     This function is not usually called in application code. To add a widget

   305     to a layout, use the addWidget() function; to add a child layout, use the

   306     addLayout() function provided by the relevant QLayout subclass.

   307 

   308     \bold{Note:} The ownership of \a item is transferred to the layout, and it's

   309     the layout's responsibility to delete it.

   310 

   311     \sa addWidget(), QBoxLayout::addLayout(), QGridLayout::addLayout()

   312 */

   313 

   314 /*!

   315     Adds widget \a w to this layout in a manner specific to the

   316     layout. This function uses addItem().

   317 */

   318 void QLayout::addWidget(QWidget *w)

   319 {

   320     addChildWidget(w);

   321     addItem(QLayoutPrivate::createWidgetItem(this, w));

   322 }

   323 

   324 

   325 

   326 /*!

   327     Sets the alignment for widget \a w to \a alignment and returns

   328     true if \a w is found in this layout (not including child

   329     layouts); otherwise returns false.

   330 */

   331 bool QLayout::setAlignment(QWidget *w, Qt::Alignment alignment)

   332 {

   333     int i = 0;

   334     QLayoutItem *item = itemAt(i);

   335     while (item) {

   336         if (item->widget() == w) {

   337             item->setAlignment(alignment);

   338             invalidate();

   339             return true;

   340         }

   341         ++i;

   342         item = itemAt(i);

   343     }

   344     return false;

   345 }

   346 

   347 /*!

   348   \overload

   349 

   350   Sets the alignment for the layout \a l to \a alignment and

   351   returns true if \a l is found in this layout (not including child

   352   layouts); otherwise returns false.

   353 */

   354 bool QLayout::setAlignment(QLayout *l, Qt::Alignment alignment)

   355 {

   356     int i = 0;

   357     QLayoutItem *item = itemAt(i);

   358     while (item) {

   359         if (item->layout() == l) {

   360             item->setAlignment(alignment);

   361             invalidate();

   362             return true;

   363         }

   364         ++i;

   365         item = itemAt(i);

   366     }

   367     return false;

   368 }

   369 

   370 /*!

   371     \fn void QLayout::setAlignment(Qt::Alignment alignment)

   372 

   373     Sets the alignment of this item to \a alignment.

   374 

   375     \sa QLayoutItem::setAlignment()

   376 */

   377 

   378 /*!

   379     \fn bool QLayout::isTopLevel() const

   380 

   381     Returns true if this layout is a top-level layout, i.e. not a

   382     child of another layout; otherwise returns false.

   383 */

   384 

   385 /*!

   386     \property QLayout::margin

   387     \brief the width of the outside border of the layout

   388     \obsolete

   389 

   390     Use setContentsMargins() and getContentsMargins() instead.

   391 

   392     \sa contentsRect(), spacing

   393 */

   394 

   395 /*!

   396     \obsolete

   397 */

   398 int QLayout::margin() const

   399 {

   400     int left, top, right, bottom;

   401     getContentsMargins(&left, &top, &right, &bottom);

   402     if (left == top && top == right && right == bottom) {

   403         return left;

   404     } else {

   405         return -1;

   406     }

   407 }

   408 

   409 /*!

   410     \property QLayout::spacing

   411     \brief the spacing between widgets inside the layout

   412 

   413     If no value is explicitly set, the layout's spacing is inherited

   414     from the parent layout, or from the style settings for the parent

   415     widget.

   416 

   417     For QGridLayout and QFormLayout, it is possible to set different horizontal and

   418     vertical spacings using \l{QGridLayout::}{setHorizontalSpacing()}

   419     and \l{QGridLayout::}{setVerticalSpacing()}. In that case,

   420     spacing() returns -1.

   421 

   422     \sa contentsRect(), getContentsMargins(), QStyle::layoutSpacing(),

   423         QStyle::pixelMetric()

   424 */

   425 

   426 int QLayout::spacing() const

   427 {

   428     if (const QBoxLayout* boxlayout = qobject_cast<const QBoxLayout*>(this)) {

   429         return boxlayout->spacing();

   430     } else if (const QGridLayout* gridlayout = qobject_cast<const QGridLayout*>(this)) {

   431         return gridlayout->spacing();

   432     } else if (const QFormLayout* formlayout = qobject_cast<const QFormLayout*>(this)) {

   433         return formlayout->spacing();

   434     } else {

   435         Q_D(const QLayout);

   436         if (d->insideSpacing >=0) {

   437             return d->insideSpacing;

   438         } else {

   439             // arbitrarily prefer horizontal spacing to vertical spacing

   440             return qSmartSpacing(this, QStyle::PM_LayoutHorizontalSpacing);

   441         }

   442     }

   443 }

   444 

   445 /*!

   446     \obsolete

   447 */

   448 void QLayout::setMargin(int margin)

   449 {

   450     setContentsMargins(margin, margin, margin, margin);

   451 }

   452 

   453 void QLayout::setSpacing(int spacing)

   454 {

   455     if (QBoxLayout* boxlayout = qobject_cast<QBoxLayout*>(this)) {

   456         boxlayout->setSpacing(spacing);

   457     } else if (QGridLayout* gridlayout = qobject_cast<QGridLayout*>(this)) {

   458         gridlayout->setSpacing(spacing);

   459     } else if (QFormLayout* formlayout = qobject_cast<QFormLayout*>(this)) {

   460         formlayout->setSpacing(spacing);

   461     } else {

   462         Q_D(QLayout);

   463         d->insideSpacing = spacing;

   464         invalidate();

   465     }

   466 }

   467 

   468 /*!

   469     \since 4.3

   470 

   471     Sets the \a left, \a top, \a right, and \a bottom margins to use

   472     around the layout.

   473 

   474     By default, QLayout uses the values provided by the style. On

   475     most platforms, the margin is 11 pixels in all directions.

   476 

   477     \sa getContentsMargins(), QStyle::pixelMetric(),

   478         {QStyle::}{PM_LayoutLeftMargin},

   479         {QStyle::}{PM_LayoutTopMargin},

   480         {QStyle::}{PM_LayoutRightMargin},

   481         {QStyle::}{PM_LayoutBottomMargin}

   482 */

   483 void QLayout::setContentsMargins(int left, int top, int right, int bottom)

   484 {

   485     Q_D(QLayout);

   486 

   487     if (d->userLeftMargin == left && d->userTopMargin == top &&

   488         d->userRightMargin == right && d->userBottomMargin == bottom)

   489         return;

   490 

   491     d->userLeftMargin = left;

   492     d->userTopMargin = top;

   493     d->userRightMargin = right;

   494     d->userBottomMargin = bottom;

   495     invalidate();

   496 }

   497 

   498 /*!

   499     \since 4.3

   500 

   501     Extracts the left, top, right, and bottom margins used around the

   502     layout, and assigns them to *\a left, *\a top, *\a right, and *\a

   503     bottom (unless they are null pointers).

   504 

   505     By default, QLayout uses the values provided by the style. On

   506     most platforms, the margin is 11 pixels in all directions.

   507 

   508     \sa setContentsMargins(), QStyle::pixelMetric(),

   509         {QStyle::}{PM_LayoutLeftMargin},

   510         {QStyle::}{PM_LayoutTopMargin},

   511         {QStyle::}{PM_LayoutRightMargin},

   512         {QStyle::}{PM_LayoutBottomMargin}

   513 */

   514 void QLayout::getContentsMargins(int *left, int *top, int *right, int *bottom) const

   515 {

   516     Q_D(const QLayout);

   517     d->getMargin(left, d->userLeftMargin, QStyle::PM_LayoutLeftMargin);

   518     d->getMargin(top, d->userTopMargin, QStyle::PM_LayoutTopMargin);

   519     d->getMargin(right, d->userRightMargin, QStyle::PM_LayoutRightMargin);

   520     d->getMargin(bottom, d->userBottomMargin, QStyle::PM_LayoutBottomMargin);

   521 }

   522 

   523 /*!

   524     \since 4.3

   525 

   526     Returns the layout's geometry() rectangle, but taking into account the

   527     contents margins.

   528 

   529     \sa setContentsMargins(), getContentsMargins()

   530 */

   531 QRect QLayout::contentsRect() const

   532 {

   533     Q_D(const QLayout);

   534     int left, top, right, bottom;

   535     getContentsMargins(&left, &top, &right, &bottom);

   536     return d->rect.adjusted(+left, +top, -right, -bottom);

   537 }

   538 

   539 #ifdef QT3_SUPPORT

   540 bool QLayout::isTopLevel() const

   541 {

   542     Q_D(const QLayout);

   543     return d->topLevel;

   544 }

   545 #endif

   546 

   547 /*!

   548     Returns the parent widget of this layout, or 0 if this layout is

   549     not installed on any widget.

   550 

   551     If the layout is a sub-layout, this function returns the parent

   552     widget of the parent layout.

   553 

   554     \sa parent()

   555 */

   556 QWidget *QLayout::parentWidget() const

   557 {

   558     Q_D(const QLayout);

   559     if (!d->topLevel) {

   560         if (parent()) {

   561             QLayout *parentLayout = qobject_cast<QLayout*>(parent());

   562             if (!parentLayout) {

   563                 qWarning("QLayout::parentWidget: A layout can only have another layout as a parent.");

   564                 return 0;

   565             }

   566             return parentLayout->parentWidget();

   567         } else {

   568             return 0;

   569         }

   570     } else {

   571         Q_ASSERT(parent() && parent()->isWidgetType());

   572         return static_cast<QWidget *>(parent());

   573     }

   574 }

   575 

   576 /*!

   577     \reimp

   578 */

   579 bool QLayout::isEmpty() const

   580 {

   581     int i = 0;

   582     QLayoutItem *item = itemAt(i);

   583     while (item) {

   584         if (!item->isEmpty())

   585             return false;

   586         ++i;

   587         item = itemAt(i);

   588     }

   589     return true;

   590 }

   591 

   592 /*!

   593     \reimp

   594 */

   595 void QLayout::setGeometry(const QRect &r)

   596 {

   597     Q_D(QLayout);

   598     d->rect = r;

   599 }

   600 

   601 /*!

   602     \reimp

   603 */

   604 QRect QLayout::geometry() const

   605 {

   606     Q_D(const QLayout);

   607     return d->rect;

   608 }

   609 

   610 /*!

   611     \reimp

   612 */

   613 void QLayout::invalidate()

   614 {

   615     Q_D(QLayout);

   616     d->rect = QRect();

   617     update();

   618 }

   619 

   620 static bool removeWidgetRecursively(QLayoutItem *li, QWidget *w)

   621 {

   622     QLayout *lay = li->layout();

   623     if (!lay)

   624         return false;

   625     int i = 0;

   626     QLayoutItem *child;

   627     while ((child = lay->itemAt(i))) {

   628         if (child->widget() == w) {

   629             delete lay->takeAt(i);

   630             lay->invalidate();

   631             return true;

   632         } else if (removeWidgetRecursively(child, w)) {

   633             return true;

   634         } else {

   635             ++i;

   636         }

   637     }

   638     return false;

   639 }

   640 

   641 

   642 void QLayoutPrivate::doResize(const QSize &r)

   643 {

   644     Q_Q(QLayout);

   645     int mbh = menuBarHeightForWidth(menubar, r.width());

   646     QWidget *mw = q->parentWidget();

   647     QRect rect = mw->testAttribute(Qt::WA_LayoutOnEntireRect) ? mw->rect() : mw->contentsRect();

   648     rect.setTop(rect.top() + mbh);

   649     q->setGeometry(rect);

   650 #ifndef QT_NO_MENUBAR

   651     if (menubar)

   652         menubar->setGeometry(0,0,r.width(), mbh);

   653 #endif

   654 }

   655 

   656 

   657 /*!

   658     \internal

   659     Performs child widget layout when the parent widget is

   660     resized.  Also handles removal of widgets. \a e is the

   661     event

   662 */

   663 void QLayout::widgetEvent(QEvent *e)

   664 {

   665     Q_D(QLayout);

   666     if (!d->enabled)

   667         return;

   668 

   669     switch (e->type()) {

   670     case QEvent::Resize:

   671         if (d->activated) {

   672             QResizeEvent *r = (QResizeEvent *)e;

   673             d->doResize(r->size());

   674         } else {

   675             activate();

   676         }

   677         break;

   678     case QEvent::ChildRemoved:

   679         {

   680             QChildEvent *c = (QChildEvent *)e;

   681             if (c->child()->isWidgetType()) {

   682                 QWidget *w = (QWidget *)c->child();

   683 #ifndef QT_NO_MENUBAR

   684                 if (w == d->menubar)

   685                     d->menubar = 0;

   686 #endif

   687                 removeWidgetRecursively(this, w);

   688             }

   689         }

   690         break;

   691 #ifdef QT3_SUPPORT

   692     case QEvent::ChildInserted:

   693         if (d->topLevel && d->autoNewChild) {

   694             QChildEvent *c = (QChildEvent *)e;

   695             if (c->child()->isWidgetType()) {

   696                 QWidget *w = (QWidget *)c->child();

   697                 if (!w->isWindow()) {

   698 #if !defined(QT_NO_MENUBAR) && !defined(QT_NO_TOOLBAR)

   699                     if (qobject_cast<QMenuBar*>(w) && !qobject_cast<QToolBar*>(w->parentWidget())) {

   700                         d->menubar = (QMenuBar *)w;

   701                         invalidate();

   702                     } else

   703 #endif

   704 #ifndef QT_NO_SIZEGRIP

   705                     if (qobject_cast<QSizeGrip*>(w) ) {

   706                         //SizeGrip is handled by the dialog itself.

   707                     } else

   708 #endif

   709                         addItem(QLayoutPrivate::createWidgetItem(this, w));

   710                 }

   711             }

   712         }

   713         break;

   714     case QEvent::LayoutHint:

   715         d->activated = false;

   716         // fall through

   717 #endif

   718     case QEvent::LayoutRequest:

   719         if (static_cast<QWidget *>(parent())->isVisible())

   720             activate();

   721         break;

   722     default:

   723         break;

   724     }

   725 }

   726 

   727 /*!

   728     \reimp

   729 */

   730 void QLayout::childEvent(QChildEvent *e)

   731 {

   732     Q_D(QLayout);

   733     if (!d->enabled)

   734         return;

   735 

   736     if (e->type() == QEvent::ChildRemoved) {

   737         QChildEvent *c = (QChildEvent*)e;

   738         int i = 0;

   739 

   740         QLayoutItem *item;

   741         while ((item = itemAt(i))) {

   742             if (item == static_cast<QLayout*>(c->child())) {

   743                 takeAt(i);

   744                 invalidate();

   745                 break;

   746             } else {

   747                 ++i;

   748             }

   749         }

   750     }

   751 }

   752 

   753 /*!

   754   \internal

   755   Also takes contentsMargins and menu bar into account.

   756 */

   757 int QLayout::totalHeightForWidth(int w) const

   758 {

   759     Q_D(const QLayout);

   760     int side=0, top=0;

   761     if (d->topLevel) {

   762         QWidget *parent = parentWidget();

   763         parent->ensurePolished();

   764         QWidgetPrivate *wd = parent->d_func();

   765         side += wd->leftmargin + wd->rightmargin;

   766         top += wd->topmargin + wd->bottommargin;

   767     }

   768     int h = heightForWidth(w - side) + top;

   769 #ifndef QT_NO_MENUBAR

   770     h += menuBarHeightForWidth(d->menubar, w);

   771 #endif

   772     return h;

   773 }

   774 

   775 /*!

   776   \internal

   777   Also takes contentsMargins and menu bar into account.

   778 */

   779 QSize QLayout::totalMinimumSize() const

   780 {

   781     Q_D(const QLayout);

   782     int side=0, top=0;

   783     if (d->topLevel) {

   784         QWidget *pw = parentWidget();

   785         pw->ensurePolished();

   786         QWidgetPrivate *wd = pw->d_func();

   787         side += wd->leftmargin + wd->rightmargin;

   788         top += wd->topmargin + wd->bottommargin;

   789     }

   790 

   791     QSize s = minimumSize();

   792 #ifndef QT_NO_MENUBAR

   793     top += menuBarHeightForWidth(d->menubar, s.width() + side);

   794 #endif

   795     return s + QSize(side, top);

   796 }

   797 

   798 /*!

   799   \internal

   800   Also takes contentsMargins and menu bar into account.

   801 */

   802 QSize QLayout::totalSizeHint() const

   803 {

   804     Q_D(const QLayout);

   805     int side=0, top=0;

   806     if (d->topLevel) {

   807         QWidget *pw = parentWidget();

   808         pw->ensurePolished();

   809         QWidgetPrivate *wd = pw->d_func();

   810         side += wd->leftmargin + wd->rightmargin;

   811         top += wd->topmargin + wd->bottommargin;

   812     }

   813 

   814     QSize s = sizeHint();

   815     if (hasHeightForWidth())

   816         s.setHeight(heightForWidth(s.width() + side));

   817 #ifndef QT_NO_MENUBAR

   818     top += menuBarHeightForWidth(d->menubar, s.width());

   819 #endif

   820     return s + QSize(side, top);

   821 }

   822 

   823 /*!

   824   \internal

   825   Also takes contentsMargins and menu bar into account.

   826 */

   827 QSize QLayout::totalMaximumSize() const

   828 {

   829     Q_D(const QLayout);

   830     int side=0, top=0;

   831     if (d->topLevel) {

   832         QWidget *pw = parentWidget();

   833         pw->ensurePolished();

   834         QWidgetPrivate *wd = pw->d_func();

   835         side += wd->leftmargin + wd->rightmargin;

   836         top += wd->topmargin + wd->bottommargin;

   837     }

   838 

   839     QSize s = maximumSize();

   840 #ifndef QT_NO_MENUBAR

   841     top += menuBarHeightForWidth(d->menubar, s.width());

   842 #endif

   843 

   844     if (d->topLevel)

   845         s = QSize(qMin(s.width() + side, QLAYOUTSIZE_MAX),

   846                    qMin(s.height() + top, QLAYOUTSIZE_MAX));

   847     return s;

   848 }

   849 

   850 /*!

   851   \internal

   852   Destroys the layout, deleting all child layouts.

   853   Geometry management stops when a top-level layout is deleted.

   854 

   855   The layout classes will probably be fatally confused if you delete

   856   a sublayout.

   857 */

   858 QLayout::~QLayout()

   859 {

   860     Q_D(QLayout);

   861     /*

   862       This function may be called during the QObject destructor,

   863       when the parent no longer is a QWidget.

   864     */

   865     if (d->topLevel && parent() && parent()->isWidgetType() &&

   866          ((QWidget*)parent())->layout() == this)

   867         ((QWidget*)parent())->d_func()->layout = 0;

   868 }

   869 

   870 #ifdef QT3_SUPPORT

   871 /*!

   872     Removes and deletes all items in this layout.

   873 */

   874 void QLayout::deleteAllItems()

   875 {

   876     QLayoutItem *l;

   877     while ((l = takeAt(0)))

   878         delete l;

   879 }

   880 #endif

   881 

   882 /*!

   883     This function is called from \c addLayout() or \c insertLayout() functions in

   884     subclasses to add layout \a l as a sub-layout.

   885 

   886     The only scenario in which you need to call it directly is if you

   887     implement a custom layout that supports nested layouts.

   888 

   889     \sa QBoxLayout::addLayout(), QBoxLayout::insertLayout(), QGridLayout::addLayout()

   890 */

   891 void QLayout::addChildLayout(QLayout *l)

   892 {

   893     if (l->parent()) {

   894         qWarning("QLayout::addChildLayout: layout \"%s\" already has a parent",

   895                  l->objectName().toLocal8Bit().data());

   896         return;

   897     }

   898     l->setParent(this);

   899 

   900     if (QWidget *mw = parentWidget()) {

   901         l->d_func()->reparentChildWidgets(mw);

   902     }

   903 

   904 }

   905 

   906 #ifdef QT_DEBUG

   907 static bool layoutDebug()

   908 {

   909     static int checked_env = -1;

   910     if(checked_env == -1)

   911         checked_env = !!qgetenv("QT_LAYOUT_DEBUG").toInt();

   912 

   913     return checked_env;

   914 }

   915 #endif

   916 

   917 void QLayoutPrivate::reparentChildWidgets(QWidget *mw)

   918 {

   919     Q_Q(QLayout);

   920     int n =  q->count();

   921 

   922 #ifndef QT_NO_MENUBAR

   923     if (menubar && menubar->parentWidget() != mw) {

   924         menubar->setParent(mw);

   925     }

   926 #endif

   927     bool mwVisible = mw && mw->isVisible();

   928     for (int i = 0; i < n; ++i) {

   929         QLayoutItem *item = q->itemAt(i);

   930         if (QWidget *w = item->widget()) {

   931             QWidget *pw = w->parentWidget();

   932 #ifdef QT_DEBUG

   933             if (pw && pw != mw && layoutDebug()) {

   934                 qWarning("QLayout::addChildLayout: widget %s \"%s\" in wrong parent; moved to correct parent",

   935                          w->metaObject()->className(), w->objectName().toLocal8Bit().data());

   936             }

   937 #endif

   938             bool needShow = mwVisible && !(w->isHidden() && w->testAttribute(Qt::WA_WState_ExplicitShowHide));

   939             if (pw != mw)

   940                 w->setParent(mw);

   941             if (needShow)

   942                 QMetaObject::invokeMethod(w, "_q_showIfNotHidden", Qt::QueuedConnection); //show later

   943         } else if (QLayout *l = item->layout()) {

   944             l->d_func()->reparentChildWidgets(mw);

   945         }

   946     }

   947 }

   948 

   949 /*!

   950     This function is called from \c addWidget() functions in

   951     subclasses to add \a w as a child widget.

   952 

   953     If \a w is already in a layout, this function will give a warning

   954     and remove \a w from the layout. This function must therefore be

   955     called before adding \a w to the layout's data structure.

   956 */

   957 void QLayout::addChildWidget(QWidget *w)

   958 {

   959     QWidget *mw = parentWidget();

   960     QWidget *pw = w->parentWidget();

   961 

   962     //Qt::WA_LaidOut is never reset. It only means that the widget at some point has

   963     //been in a layout.

   964     if (pw && w->testAttribute(Qt::WA_LaidOut)) {

   965         QLayout *l = pw->layout();

   966         if (l && removeWidgetRecursively(l, w)) {

   967 #ifdef QT_DEBUG

   968             if (layoutDebug())

   969                 qWarning("QLayout::addChildWidget: %s \"%s\" is already in a layout; moved to new layout",

   970                          w->metaObject()->className(), w->objectName().toLocal8Bit().data());

   971 #endif

   972         }

   973     }

   974     if (pw && mw && pw != mw) {

   975 #ifdef QT_DEBUG

   976             if (layoutDebug())

   977                 qWarning("QLayout::addChildWidget: %s \"%s\" in wrong parent; moved to correct parent",

   978                          w->metaObject()->className(), w->objectName().toLocal8Bit().data());

   979 #endif

   980         pw = 0;

   981     }

   982     bool needShow = mw && mw->isVisible() && !(w->isHidden() && w->testAttribute(Qt::WA_WState_ExplicitShowHide));

   983     if (!pw && mw)

   984         w->setParent(mw);

   985     w->setAttribute(Qt::WA_LaidOut);

   986     if (needShow)

   987         QMetaObject::invokeMethod(w, "_q_showIfNotHidden", Qt::QueuedConnection); //show later

   988 }

   989 

   990 #ifdef QT3_SUPPORT

   991 /*!

   992   \compat

   993 

   994     Sets this layout's parent widget to a fixed size with width \a w

   995     and height \a h, stopping the user from resizing it, and also

   996     prevents the layout from resizing it, even if the layout's size

   997     hint should change. Does nothing if this is not a top-level

   998     layout (i.e., if parent()->isWidgetType()).

   999 

  1000     As a special case, if both \a w and \a h are 0, then the layout's

  1001     current sizeHint() is used.

  1002 

  1003     Use \c setResizeMode(Fixed) to stop the widget from being resized

  1004     by the user, while still allowing the layout to resize it when

  1005     the sizeHint() changes.

  1006 

  1007     Use \c setResizeMode(FreeResize) to allow the user to resize the

  1008     widget, while preventing the layout from resizing it.

  1009 

  1010 */

  1011 void QLayout::freeze(int w, int h)

  1012 {

  1013     Q_D(QLayout);

  1014     if (!d->topLevel)

  1015         return;

  1016     if (w <= 0 || h <= 0) {

  1017         QSize s = totalSizeHint();

  1018         w = s.width();

  1019         h = s.height();

  1020     }

  1021     setSizeConstraint(SetNoConstraint); // layout will not change min/max size

  1022     QWidget *parent = parentWidget();

  1023     if (parent)

  1024         parent->setFixedSize(w, h);

  1025 }

  1026 

  1027 #endif

  1028 

  1029 

  1030 

  1031 

  1032 

  1033 

  1034 

  1035 /*!

  1036     Tells the geometry manager to place the menu bar \a widget at the

  1037     top of parentWidget(), outside QWidget::contentsMargins(). All

  1038     child widgets are placed below the bottom edge of the menu bar.

  1039 */

  1040 void QLayout::setMenuBar(QWidget *widget)

  1041 {

  1042     Q_D(QLayout);

  1043 

  1044 #ifdef Q_OS_WINCE_WM

  1045     if (widget && widget->size().height() > 0)

  1046 #else

  1047         if (widget)

  1048 #endif

  1049             addChildWidget(widget);

  1050     d->menubar = widget;

  1051 }

  1052 

  1053 /*!

  1054     Returns the menu bar set for this layout, or 0 if no menu bar is

  1055     set.

  1056 */

  1057 

  1058 QWidget *QLayout::menuBar() const

  1059 {

  1060     Q_D(const QLayout);

  1061     return d->menubar;

  1062 }

  1063 

  1064 

  1065 /*!

  1066     Returns the minimum size of this layout. This is the smallest

  1067     size that the layout can have while still respecting the

  1068     specifications.

  1069 

  1070     The returned value doesn't include the space required by

  1071     QWidget::setContentsMargins() or menuBar().

  1072 

  1073     The default implementation allows unlimited resizing.

  1074 */

  1075 QSize QLayout::minimumSize() const

  1076 {

  1077     return QSize(0, 0);

  1078 }

  1079 

  1080 /*!

  1081     Returns the maximum size of this layout. This is the largest size

  1082     that the layout can have while still respecting the

  1083     specifications.

  1084 

  1085     The returned value doesn't include the space required by

  1086     QWidget::setContentsMargins() or menuBar().

  1087 

  1088     The default implementation allows unlimited resizing.

  1089 */

  1090 QSize QLayout::maximumSize() const

  1091 {

  1092     return QSize(QLAYOUTSIZE_MAX, QLAYOUTSIZE_MAX);

  1093 }

  1094 

  1095 /*!

  1096     Returns whether this layout can make use of more space than

  1097     sizeHint(). A value of Qt::Vertical or Qt::Horizontal means that

  1098     it wants to grow in only one dimension, whereas Qt::Vertical |

  1099     Qt::Horizontal means that it wants to grow in both dimensions.

  1100 

  1101     The default implementation returns Qt::Horizontal | Qt::Vertical.

  1102     Subclasses reimplement it to return a meaningful value based on

  1103     their child widgets's \l{QSizePolicy}{size policies}.

  1104 

  1105     \sa sizeHint()

  1106 */

  1107 Qt::Orientations QLayout::expandingDirections() const

  1108 {

  1109     return Qt::Horizontal | Qt::Vertical;

  1110 }

  1111 

  1112 void QLayout::activateRecursiveHelper(QLayoutItem *item)

  1113 {

  1114     item->invalidate();

  1115     QLayout *layout = item->layout();

  1116     if (layout) {

  1117         QLayoutItem *child;

  1118         int i=0;

  1119         while ((child = layout->itemAt(i++)))

  1120             activateRecursiveHelper(child);

  1121         layout->d_func()->activated = true;

  1122     }

  1123 }

  1124 

  1125 /*!

  1126   Updates the layout for parentWidget().

  1127 

  1128   You should generally not need to call this because it is

  1129   automatically called at the most appropriate times.

  1130 

  1131   \sa activate(), invalidate()

  1132 */

  1133 

  1134 void QLayout::update()