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

     2 **

     3 ** Copyright (C) 2010 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.6

   500 

   501     Sets the \a margins to use around the layout.

   502 

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

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

   505 

   506     \sa contentsMargins()

   507 */

   508 void QLayout::setContentsMargins(const QMargins &margins)

   509 {

   510     setContentsMargins(margins.left(), margins.top(), margins.right(), margins.bottom());

   511 }

   512 

   513 /*!

   514     \since 4.3

   515 

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

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

   518     bottom (unless they are null pointers).

   519 

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

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

   522 

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

   524         {QStyle::}{PM_LayoutLeftMargin},

   525         {QStyle::}{PM_LayoutTopMargin},

   526         {QStyle::}{PM_LayoutRightMargin},

   527         {QStyle::}{PM_LayoutBottomMargin}

   528 */

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

   530 {

   531     Q_D(const QLayout);

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

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

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

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

   536 }

   537 

   538 /*!

   539     \since 4.6

   540 

   541     Returns the margins used around the layout.

   542 

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

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

   545 

   546     \sa setContentsMargins()

   547 */

   548 QMargins QLayout::contentsMargins() const

   549 {

   550     int left, top, right, bottom;

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

   552     return QMargins(left, top, right, bottom);

   553 }

   554 

   555 /*!

   556     \since 4.3

   557 

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

   559     contents margins.

   560 

   561     \sa setContentsMargins(), getContentsMargins()

   562 */

   563 QRect QLayout::contentsRect() const

   564 {

   565     Q_D(const QLayout);

   566     int left, top, right, bottom;

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

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

   569 }

   570 

   571 #ifdef QT3_SUPPORT

   572 bool QLayout::isTopLevel() const

   573 {

   574     Q_D(const QLayout);

   575     return d->topLevel;

   576 }

   577 #endif

   578 

   579 /*!

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

   581     not installed on any widget.

   582 

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

   584     widget of the parent layout.

   585 

   586     \sa parent()

   587 */

   588 QWidget *QLayout::parentWidget() const

   589 {

   590     Q_D(const QLayout);

   591     if (!d->topLevel) {

   592         if (parent()) {

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

   594             if (!parentLayout) {

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

   596                 return 0;

   597             }

   598             return parentLayout->parentWidget();

   599         } else {

   600             return 0;

   601         }

   602     } else {

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

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

   605     }

   606 }

   607 

   608 /*!

   609     \reimp

   610 */

   611 bool QLayout::isEmpty() const

   612 {

   613     int i = 0;

   614     QLayoutItem *item = itemAt(i);

   615     while (item) {

   616         if (!item->isEmpty())

   617             return false;

   618         ++i;

   619         item = itemAt(i);

   620     }

   621     return true;

   622 }

   623 

   624 /*!

   625     \reimp

   626 */

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

   628 {

   629     Q_D(QLayout);

   630     d->rect = r;

   631 }

   632 

   633 /*!

   634     \reimp

   635 */

   636 QRect QLayout::geometry() const

   637 {

   638     Q_D(const QLayout);

   639     return d->rect;

   640 }

   641 

   642 /*!

   643     \reimp

   644 */

   645 void QLayout::invalidate()

   646 {

   647     Q_D(QLayout);

   648     d->rect = QRect();

   649     update();

   650 }

   651 

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

   653 {

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

   655     if (!lay)

   656         return false;

   657     int i = 0;

   658     QLayoutItem *child;

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

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

   661             delete lay->takeAt(i);

   662             lay->invalidate();

   663             return true;

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

   665             return true;

   666         } else {

   667             ++i;

   668         }

   669     }

   670     return false;

   671 }

   672 

   673 

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

   675 {

   676     Q_Q(QLayout);

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

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

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

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

   681     q->setGeometry(rect);

   682 #ifndef QT_NO_MENUBAR

   683     if (menubar)

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

   685 #endif

   686 }

   687 

   688 

   689 /*!

   690     \internal

   691     Performs child widget layout when the parent widget is

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

   693     event

   694 */

   695 void QLayout::widgetEvent(QEvent *e)

   696 {

   697     Q_D(QLayout);

   698     if (!d->enabled)

   699         return;

   700 

   701     switch (e->type()) {

   702     case QEvent::Resize:

   703         if (d->activated) {

   704             QResizeEvent *r = (QResizeEvent *)e;

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

   706         } else {

   707             activate();

   708         }

   709         break;

   710     case QEvent::ChildRemoved:

   711         {

   712             QChildEvent *c = (QChildEvent *)e;

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

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

   715 #ifndef QT_NO_MENUBAR

   716                 if (w == d->menubar)

   717                     d->menubar = 0;

   718 #endif

   719                 removeWidgetRecursively(this, w);

   720             }

   721         }

   722         break;

   723 #ifdef QT3_SUPPORT

   724     case QEvent::ChildInserted:

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

   726             QChildEvent *c = (QChildEvent *)e;

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

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

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

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

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

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

   733                         invalidate();

   734                     } else

   735 #endif

   736 #ifndef QT_NO_SIZEGRIP

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

   738                         //SizeGrip is handled by the dialog itself.

   739                     } else

   740 #endif

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

   742                 }

   743             }

   744         }

   745         break;

   746     case QEvent::LayoutHint:

   747         d->activated = false;

   748         // fall through

   749 #endif

   750     case QEvent::LayoutRequest:

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

   752             activate();

   753         break;

   754     default:

   755         break;

   756     }

   757 }

   758 

   759 /*!

   760     \reimp

   761 */

   762 void QLayout::childEvent(QChildEvent *e)

   763 {

   764     Q_D(QLayout);

   765     if (!d->enabled)

   766         return;

   767 

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

   769         QChildEvent *c = (QChildEvent*)e;

   770         int i = 0;

   771 

   772         QLayoutItem *item;

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

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

   775                 takeAt(i);

   776                 invalidate();

   777                 break;

   778             } else {

   779                 ++i;

   780             }

   781         }

   782     }

   783 }

   784 

   785 /*!

   786   \internal

   787   Also takes contentsMargins and menu bar into account.

   788 */

   789 int QLayout::totalHeightForWidth(int w) const

   790 {

   791     Q_D(const QLayout);

   792     int side=0, top=0;

   793     if (d->topLevel) {

   794         QWidget *parent = parentWidget();

   795         parent->ensurePolished();

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

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

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

   799     }

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

   801 #ifndef QT_NO_MENUBAR

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

   803 #endif

   804     return h;

   805 }

   806 

   807 /*!

   808   \internal

   809   Also takes contentsMargins and menu bar into account.

   810 */

   811 QSize QLayout::totalMinimumSize() const

   812 {

   813     Q_D(const QLayout);

   814     int side=0, top=0;

   815     if (d->topLevel) {

   816         QWidget *pw = parentWidget();

   817         pw->ensurePolished();

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

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

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

   821     }

   822 

   823     QSize s = minimumSize();

   824 #ifndef QT_NO_MENUBAR

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

   826 #endif

   827     return s + QSize(side, top);

   828 }

   829 

   830 /*!

   831   \internal

   832   Also takes contentsMargins and menu bar into account.

   833 */

   834 QSize QLayout::totalSizeHint() const

   835 {

   836     Q_D(const QLayout);

   837     int side=0, top=0;

   838     if (d->topLevel) {

   839         QWidget *pw = parentWidget();

   840         pw->ensurePolished();

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

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

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

   844     }

   845 

   846     QSize s = sizeHint();

   847     if (hasHeightForWidth())

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

   849 #ifndef QT_NO_MENUBAR

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

   851 #endif

   852     return s + QSize(side, top);

   853 }

   854 

   855 /*!

   856   \internal

   857   Also takes contentsMargins and menu bar into account.

   858 */

   859 QSize QLayout::totalMaximumSize() const

   860 {

   861     Q_D(const QLayout);

   862     int side=0, top=0;

   863     if (d->topLevel) {

   864         QWidget *pw = parentWidget();

   865         pw->ensurePolished();

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

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

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

   869     }

   870 

   871     QSize s = maximumSize();

   872 #ifndef QT_NO_MENUBAR

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

   874 #endif

   875 

   876     if (d->topLevel)

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

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

   879     return s;

   880 }

   881 

   882 /*!

   883   \internal

   884   Destroys the layout, deleting all child layouts.

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

   886 

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

   888   a sublayout.

   889 */

   890 QLayout::~QLayout()

   891 {

   892     Q_D(QLayout);

   893     /*

   894       This function may be called during the QObject destructor,

   895       when the parent no longer is a QWidget.

   896     */

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

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

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

   900 }

   901 

   902 #ifdef QT3_SUPPORT

   903 /*!

   904     Removes and deletes all items in this layout.

   905 */

   906 void QLayout::deleteAllItems()

   907 {

   908     QLayoutItem *l;

   909     while ((l = takeAt(0)))

   910         delete l;

   911 }

   912 #endif

   913 

   914 /*!

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

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

   917 

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

   919     implement a custom layout that supports nested layouts.

   920 

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

   922 */

   923 void QLayout::addChildLayout(QLayout *l)

   924 {

   925     if (l->parent()) {

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

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

   928         return;

   929     }

   930     l->setParent(this);

   931 

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

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

   934     }

   935 

   936 }

   937 

   938 #ifdef QT_DEBUG

   939 static bool layoutDebug()

   940 {

   941     static int checked_env = -1;

   942     if(checked_env == -1)

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

   944 

   945     return checked_env;

   946 }

   947 #endif

   948 

   949 void QLayoutPrivate::reparentChildWidgets(QWidget *mw)

   950 {

   951     Q_Q(QLayout);

   952     int n =  q->count();

   953 

   954 #ifndef QT_NO_MENUBAR

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

   956         menubar->setParent(mw);

   957     }

   958 #endif

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

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

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

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

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

   964 #ifdef QT_DEBUG

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

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

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

   968             }

   969 #endif

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

   971             if (pw != mw)

   972                 w->setParent(mw);

   973             if (needShow)

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

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

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

   977         }

   978     }

   979 }

   980 

   981 /*!

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

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

   984 

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

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

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

   988 */

   989 void QLayout::addChildWidget(QWidget *w)

   990 {

   991     QWidget *mw = parentWidget();

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

   993 

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

   995     //been in a layout.

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

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

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

   999 #ifdef QT_DEBUG

  1000             if (layoutDebug())

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

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

  1003 #endif

  1004         }

  1005     }

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

  1007 #ifdef QT_DEBUG

  1008             if (layoutDebug())

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

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

  1011 #endif

  1012         pw = 0;

  1013     }

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

  1015     if (!pw && mw)

  1016         w->setParent(mw);

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

  1018     if (needShow)

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

  1020 }

  1021 

  1022 #ifdef QT3_SUPPORT

  1023 /*!

  1024   \compat

  1025 

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

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

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

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

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

  1031 

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

  1033     current sizeHint() is used.

  1034 

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

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

  1037     the sizeHint() changes.

  1038 

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

  1040     widget, while preventing the layout from resizing it.

  1041 

  1042 */

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

  1044 {

  1045     Q_D(QLayout);

  1046     if (!d->topLevel)

  1047         return;

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

  1049         QSize s = totalSizeHint();

  1050         w = s.width();

  1051         h = s.height();

  1052     }

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

  1054     QWidget *parent = parentWidget();

  1055     if (parent)

  1056         parent->setFixedSize(w, h);

  1057 }

  1058 

  1059 #endif

  1060 

  1061 

  1062 

  1063 

  1064 

  1065 

  1066 

  1067 /*!

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

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

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

  1071 */

  1072 void QLayout::setMenuBar(QWidget *widget)

  1073 {

  1074     Q_D(QLayout);

  1075 

  1076 #ifdef Q_OS_WINCE_WM

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

  1078 #else

  1079         if (widget)

  1080 #endif

  1081             addChildWidget(widget);

  1082     d->menubar = widget;

  1083 }

  1084 

  1085 /*!

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

  1087     set.

  1088 */

  1089 

  1090 QWidget *QLayout::menuBar() const

  1091 {

  1092     Q_D(const QLayout);

  1093     return d->menubar;

  1094 }

  1095 

  1096 

  1097 /*!

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

  1099     size that the layout can have while still respecting the

  1100     specifications.

  1101 

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

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

  1104 

  1105     The default implementation allows unlimited resizing.

  1106 */

  1107 QSize QLayout::minimumSize() const

  1108 {

  1109     return QSize(0, 0);

  1110 }

  1111 

  1112 /*!

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

  1114     that the layout can have while still respecting the

  1115     specifications.

  1116 

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

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

  1119 

  1120     The default implementation allows unlimited resizing.

  1121 */

  1122 QSize QLayout::maximumSize() const

  1123 {

  1124     return QSize(QLAYOUTSIZE_MAX, QLAYOUTSIZE_MAX);

  1125 }

  1126 

  1127 /*!

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

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

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

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

  1132 

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

  1134     Subclasses reimplement it to return a meaningful value based on

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