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

    43 #include "qapplication.h"

    44 #include "qwidget.h"

    45 #include "qlist.h"

    46 #include "qsizepolicy.h"

    47 #include "qvector.h"

    48 #include "qvarlengtharray.h"

    49 #include "qlayoutengine_p.h"

    50 #include "qlayout_p.h"

    51 

    52 QT_BEGIN_NAMESPACE

    53 

    54 struct QGridLayoutSizeTriple

    55 {

    56     QSize minS;

    57     QSize hint;

    58     QSize maxS;

    59 };

    60 

    61 /*

    62   Three internal classes related to QGridLayout: (1) QGridBox is a

    63   QLayoutItem with (row, column) information and (torow, tocolumn) information; (3) QGridLayoutData is

    64   the internal representation of a QGridLayout.

    65 */

    66 

    67 class QGridBox

    68 {

    69 public:

    70     QGridBox(QLayoutItem *lit) { item_ = lit; }

    71 

    72     QGridBox(const QLayout *l, QWidget *wid) { item_ = QLayoutPrivate::createWidgetItem(l, wid); }

    73     ~QGridBox() { delete item_; }

    74 

    75     QSize sizeHint() const { return item_->sizeHint(); }

    76     QSize minimumSize() const { return item_->minimumSize(); }

    77     QSize maximumSize() const { return item_->maximumSize(); }

    78     Qt::Orientations expandingDirections() const { return item_->expandingDirections(); }

    79     bool isEmpty() const { return item_->isEmpty(); }

    80 

    81     bool hasHeightForWidth() const { return item_->hasHeightForWidth(); }

    82     int heightForWidth(int w) const { return item_->heightForWidth(w); }

    83 

    84     void setAlignment(Qt::Alignment a) { item_->setAlignment(a); }

    85     void setGeometry(const QRect &r) { item_->setGeometry(r); }

    86     Qt::Alignment alignment() const { return item_->alignment(); }

    87     QLayoutItem *item() { return item_; }

    88     QLayoutItem *takeItem() { QLayoutItem *i = item_; item_ = 0; return i; }

    89 

    90     int hStretch() { return item_->widget() ?

    91                          item_->widget()->sizePolicy().horizontalStretch() : 0; }

    92     int vStretch() { return item_->widget() ?

    93                          item_->widget()->sizePolicy().verticalStretch() : 0; }

    94 

    95 private:

    96     friend class QGridLayoutPrivate;

    97     friend class QGridLayout;

    98 

    99     inline int toRow(int rr) const { return torow >= 0 ? torow : rr - 1; }

   100     inline int toCol(int cc) const { return tocol >= 0 ? tocol : cc - 1; }

   101 

   102     QLayoutItem *item_;

   103     int row, col;

   104     int torow, tocol;

   105 };

   106 

   107 class QGridLayoutPrivate : public QLayoutPrivate

   108 {

   109     Q_DECLARE_PUBLIC(QGridLayout)

   110 public:

   111     QGridLayoutPrivate();

   112 

   113     void add(QGridBox*, int row, int col);

   114     void add(QGridBox*, int row1, int row2, int col1, int col2);

   115     QSize sizeHint(int hSpacing, int vSpacing) const;

   116     QSize minimumSize(int hSpacing, int vSpacing) const;

   117     QSize maximumSize(int hSpacing, int vSpacing) const;

   118 

   119     Qt::Orientations expandingDirections(int hSpacing, int vSpacing) const;

   120 

   121     void distribute(QRect rect, int hSpacing, int vSpacing);

   122     inline int numRows() const { return rr; }

   123     inline int numCols() const { return cc; }

   124     inline void expand(int rows, int cols)

   125         { setSize(qMax(rows, rr), qMax(cols, cc)); }

   126     inline void setRowStretch(int r, int s)

   127         { expand(r + 1, 0); rStretch[r] = s; setDirty(); }

   128     inline void setColStretch(int c, int s)

   129         { expand(0, c + 1); cStretch[c] = s; setDirty(); }

   130     inline int rowStretch(int r) const { return rStretch.at(r); }

   131     inline int colStretch(int c) const { return cStretch.at(c); }

   132     inline void setRowMinimumHeight(int r, int s)

   133         { expand(r + 1, 0); rMinHeights[r] = s; setDirty(); }

   134     inline void setColumnMinimumWidth(int c, int s)

   135         { expand(0, c + 1); cMinWidths[c] = s; setDirty(); }

   136     inline int rowSpacing(int r) const { return rMinHeights.at(r); }

   137     inline int colSpacing(int c) const { return cMinWidths.at(c); }

   138 

   139     inline void setReversed(bool r, bool c) { hReversed = c; vReversed = r; }

   140     inline bool horReversed() const { return hReversed; }

   141     inline bool verReversed() const { return vReversed; }

   142     inline void setDirty() { needRecalc = true; hfw_width = -1; }

   143     inline bool isDirty() const { return needRecalc; }

   144     bool hasHeightForWidth(int hSpacing, int vSpacing);

   145     int heightForWidth(int width, int hSpacing, int vSpacing);

   146     int minimumHeightForWidth(int width, int hSpacing, int vSpacing);

   147 

   148     inline void getNextPos(int &row, int &col) { row = nextR; col = nextC; }

   149     inline int count() const { return things.count(); }

   150     QRect cellRect(int row, int col) const;

   151 

   152     inline QLayoutItem *itemAt(int index) const {

   153         if (index < things.count())

   154             return things.at(index)->item();

   155         else

   156             return 0;

   157     }

   158     inline QLayoutItem *takeAt(int index) {

   159         QLayoutItem *item = 0;

   160         if (index < things.count()) {

   161             QGridBox *b = things.takeAt(index);

   162             if (b) {

   163                 item = b->takeItem();

   164                 delete b;

   165             }

   166         }

   167         return item;

   168     }

   169 

   170     void getItemPosition(int index, int *row, int *column, int *rowSpan, int *columnSpan) {

   171         if (index < things.count()) {

   172             QGridBox *b =  things.at(index);

   173             int toRow = b->toRow(rr);

   174             int toCol = b->toCol(cc);

   175             *row = b->row;

   176             *column = b->col;

   177             *rowSpan = toRow - *row + 1;

   178             *columnSpan = toCol - *column +1;

   179         }

   180     }

   181     void deleteAll();

   182 

   183 private:

   184     void setNextPosAfter(int r, int c);

   185     void recalcHFW(int w);

   186     void addHfwData(QGridBox *box, int width);

   187     void init();

   188     QSize findSize(int QLayoutStruct::*, int hSpacing, int vSpacing) const;

   189     void addData(QGridBox *b, const QGridLayoutSizeTriple &sizes, bool r, bool c);

   190     void setSize(int rows, int cols);

   191     void setupSpacings(QVector<QLayoutStruct> &chain, QGridBox *grid[], int fixedSpacing,

   192                        Qt::Orientation orientation);

   193     void setupLayoutData(int hSpacing, int vSpacing);

   194     void setupHfwLayoutData();

   195     void effectiveMargins(int *left, int *top, int *right, int *bottom) const;

   196 

   197     int rr;

   198     int cc;

   199     QVector<QLayoutStruct> rowData;

   200     QVector<QLayoutStruct> colData;

   201     QVector<QLayoutStruct> *hfwData;

   202     QVector<int> rStretch;

   203     QVector<int> cStretch;

   204     QVector<int> rMinHeights;

   205     QVector<int> cMinWidths;

   206     QList<QGridBox *> things;

   207 

   208     int hfw_width;

   209     int hfw_height;

   210     int hfw_minheight;

   211     int nextR;

   212     int nextC;

   213 

   214     int horizontalSpacing;

   215     int verticalSpacing;

   216     int leftMargin;

   217     int topMargin;

   218     int rightMargin;

   219     int bottomMargin;

   220 

   221     uint hReversed : 1;

   222     uint vReversed : 1;

   223     uint needRecalc : 1;

   224     uint has_hfw : 1;

   225     uint addVertical : 1;

   226 };

   227 

   228 void QGridLayoutPrivate::effectiveMargins(int *left, int *top, int *right, int *bottom) const

   229 {

   230     int l = leftMargin;

   231     int t = topMargin;

   232     int r = rightMargin;

   233     int b = bottomMargin;

   234 #ifdef Q_WS_MAC

   235     int leftMost = INT_MAX;

   236     int topMost = INT_MAX;

   237     int rightMost = 0;

   238     int bottomMost = 0;

   239 

   240     QWidget *w = 0;

   241     const int n = things.count();

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

   243         QGridBox *box = things.at(i);

   244         QLayoutItem *itm = box->item();

   245         w = itm->widget();

   246         if (w) {

   247             bool visualHReversed = hReversed != (w->layoutDirection() == Qt::RightToLeft);

   248             QRect lir = itm->geometry();

   249             QRect wr = w->geometry();

   250             if (box->col <= leftMost) {

   251                 if (box->col < leftMost) {

   252                     // we found an item even closer to the margin, discard.

   253                     leftMost = box->col;

   254                     if (visualHReversed)

   255                         r = rightMargin;

   256                     else

   257                         l = leftMargin;

   258                 }

   259                 if (visualHReversed) {

   260                     r = qMax(r, wr.right() - lir.right());

   261                 } else {

   262                     l = qMax(l, lir.left() - wr.left());

   263                 }

   264             }

   265             if (box->row <= topMost) {

   266                 if (box->row < topMost) {

   267                     // we found an item even closer to the margin, discard.

   268                     topMost = box->row;

   269                     if (vReversed)

   270                         b = bottomMargin;

   271                     else

   272                         t = topMargin;

   273                 }

   274                 if (vReversed)

   275                     b = qMax(b, wr.bottom() - lir.bottom());

   276                 else

   277                     t = qMax(t, lir.top() - wr.top());

   278             }

   279             if (box->toCol(cc) >= rightMost) {

   280                 if (box->toCol(cc) > rightMost) {

   281                     // we found an item even closer to the margin, discard.

   282                     rightMost = box->toCol(cc);

   283                     if (visualHReversed)

   284                         l = leftMargin;

   285                     else

   286                         r = rightMargin;

   287                 }

   288                 if (visualHReversed) {

   289                     l = qMax(l, lir.left() - wr.left());

   290                 } else {

   291                     r = qMax(r, wr.right() - lir.right());

   292                 }

   293 

   294             }

   295             if (box->toRow(rr) >= bottomMost) {

   296                 if (box->toRow(rr) > bottomMost) {

   297                     // we found an item even closer to the margin, discard.

   298                     bottomMost = box->toRow(rr);

   299                     if (vReversed)

   300                         t = topMargin;

   301                     else

   302                         b = bottomMargin;

   303                 }

   304                 if (vReversed)

   305                     t = qMax(t, lir.top() - wr.top());

   306                 else

   307                     b = qMax(b, wr.bottom() - lir.bottom());

   308             }

   309         }

   310     }

   311 

   312 #endif

   313     if (left)

   314         *left = l;

   315     if (top)

   316         *top = t;

   317     if (right)

   318         *right = r;

   319     if (bottom)

   320         *bottom = b;

   321 }

   322 

   323 QGridLayoutPrivate::QGridLayoutPrivate()

   324 {

   325     addVertical = false;

   326     setDirty();

   327     rr = cc = 0;

   328     nextR = nextC = 0;

   329     hfwData = 0;

   330     hReversed = false;

   331     vReversed = false;

   332     horizontalSpacing = -1;

   333     verticalSpacing = -1;

   334 }

   335 

   336 #if 0

   337 QGridLayoutPrivate::QGridLayoutPrivate(int nRows, int nCols)

   338     : rowData(0), colData(0)

   339 {

   340     init();

   341     if (nRows  < 0) {

   342         nRows = 1;

   343         addVertical = false;

   344     }

   345     if (nCols  < 0) {

   346         nCols = 1;

   347         addVertical = true;

   348     }

   349     setSize(nRows, nCols);

   350 }

   351 #endif

   352 

   353 void QGridLayoutPrivate::deleteAll()

   354 {

   355     while (!things.isEmpty())

   356         delete things.takeFirst();

   357     delete hfwData;

   358 }

   359 

   360 bool QGridLayoutPrivate::hasHeightForWidth(int hSpacing, int vSpacing)

   361 {

   362     setupLayoutData(hSpacing, vSpacing);

   363     return has_hfw;

   364 }

   365 

   366 /*

   367   Assumes that setupLayoutData() has been called, and that

   368   qGeomCalc() has filled in colData with appropriate values.

   369 */

   370 void QGridLayoutPrivate::recalcHFW(int w)

   371 {

   372     /*

   373       Go through all children, using colData and heightForWidth()

   374       and put the results in hfwData.

   375     */

   376     if (!hfwData)

   377         hfwData = new QVector<QLayoutStruct>(rr);

   378     setupHfwLayoutData();

   379     QVector<QLayoutStruct> &rData = *hfwData;

   380 

   381     int h = 0;

   382     int mh = 0;

   383     for (int r = 0; r < rr; r++) {

   384         int spacing = rData.at(r).spacing;

   385         h += rData.at(r).sizeHint + spacing;

   386         mh += rData.at(r).minimumSize + spacing;

   387     }

   388 

   389     hfw_width = w;

   390     hfw_height = qMin(QLAYOUTSIZE_MAX, h);

   391     hfw_minheight = qMin(QLAYOUTSIZE_MAX, mh);

   392 }

   393 

   394 int QGridLayoutPrivate::heightForWidth(int w, int hSpacing, int vSpacing)

   395 {

   396     setupLayoutData(hSpacing, vSpacing);

   397     if (!has_hfw)

   398         return -1;

   399     int left, top, right, bottom;

   400     effectiveMargins(&left, &top, &right, &bottom);

   401 

   402     int hMargins = left + right;

   403     if (w - hMargins != hfw_width) {

   404         qGeomCalc(colData, 0, cc, 0, w - hMargins);

   405         recalcHFW(w - hMargins);

   406     }

   407     return hfw_height + top + bottom;

   408 }

   409 

   410 int QGridLayoutPrivate::minimumHeightForWidth(int w, int hSpacing, int vSpacing)

   411 {

   412     (void)heightForWidth(w, hSpacing, vSpacing);

   413     if (!has_hfw)

   414         return -1;

   415     int top, bottom;

   416     effectiveMargins(0, &top, 0, &bottom);

   417     return hfw_minheight + top + bottom;

   418 }

   419 

   420 QSize QGridLayoutPrivate::findSize(int QLayoutStruct::*size, int hSpacing, int vSpacing) const

   421 {

   422     QGridLayoutPrivate *that = const_cast<QGridLayoutPrivate*>(this);

   423     that->setupLayoutData(hSpacing, vSpacing);

   424 

   425     int w = 0;

   426     int h = 0;

   427 

   428     for (int r = 0; r < rr; r++)

   429         h += rowData.at(r).*size + rowData.at(r).spacing;

   430     for (int c = 0; c < cc; c++)

   431         w += colData.at(c).*size + colData.at(c).spacing;

   432 

   433     w = qMin(QLAYOUTSIZE_MAX, w);

   434     h = qMin(QLAYOUTSIZE_MAX, h);

   435 

   436     return QSize(w, h);

   437 }

   438 

   439 Qt::Orientations QGridLayoutPrivate::expandingDirections(int hSpacing, int vSpacing) const

   440 {

   441     QGridLayoutPrivate *that = const_cast<QGridLayoutPrivate*>(this);

   442     that->setupLayoutData(hSpacing, vSpacing);

   443     Qt::Orientations ret;

   444 

   445     for (int r = 0; r < rr; r++) {

   446         if (rowData.at(r).expansive) {

   447             ret |= Qt::Vertical;

   448             break;

   449         }

   450     }

   451     for (int c = 0; c < cc; c++) {

   452         if (colData.at(c).expansive) {

   453             ret |= Qt::Horizontal;

   454             break;

   455         }

   456     }

   457     return ret;

   458 }

   459 

   460 QSize QGridLayoutPrivate::sizeHint(int hSpacing, int vSpacing) const

   461 {

   462     return findSize(&QLayoutStruct::sizeHint, hSpacing, vSpacing);

   463 }

   464 

   465 QSize QGridLayoutPrivate::maximumSize(int hSpacing, int vSpacing) const

   466 {

   467     return findSize(&QLayoutStruct::maximumSize, hSpacing, vSpacing);

   468 }

   469 

   470 QSize QGridLayoutPrivate::minimumSize(int hSpacing, int vSpacing) const

   471 {

   472     return findSize(&QLayoutStruct::minimumSize, hSpacing, vSpacing);

   473 }

   474 

   475 void QGridLayoutPrivate::setSize(int r, int c)

   476 {

   477     if ((int)rowData.size() < r) {

   478         int newR = qMax(r, rr * 2);

   479         rowData.resize(newR);

   480         rStretch.resize(newR);

   481         rMinHeights.resize(newR);

   482         for (int i = rr; i < newR; i++) {

   483             rowData[i].init();

   484             rowData[i].maximumSize = 0;

   485             rowData[i].pos = 0;

   486             rowData[i].size = 0;

   487             rStretch[i] = 0;

   488             rMinHeights[i] = 0;

   489         }

   490     }

   491     if ((int)colData.size() < c) {

   492         int newC = qMax(c, cc * 2);

   493         colData.resize(newC);

   494         cStretch.resize(newC);

   495         cMinWidths.resize(newC);

   496         for (int i = cc; i < newC; i++) {

   497             colData[i].init();

   498             colData[i].maximumSize = 0;

   499             colData[i].pos = 0;

   500             colData[i].size = 0;

   501             cStretch[i] = 0;

   502             cMinWidths[i] = 0;

   503         }

   504     }

   505 

   506     if (hfwData && (int)hfwData->size() < r) {

   507         delete hfwData;

   508         hfwData = 0;

   509         hfw_width = -1;

   510     }

   511     rr = r;

   512     cc = c;

   513 }

   514 

   515 void QGridLayoutPrivate::setNextPosAfter(int row, int col)

   516 {

   517     if (addVertical) {

   518         if (col > nextC || (col == nextC && row >= nextR)) {

   519             nextR = row + 1;

   520             nextC = col;

   521             if (nextR >= rr) {

   522                 nextR = 0;

   523                 nextC++;

   524             }

   525         }

   526     } else {

   527         if (row > nextR || (row == nextR && col >= nextC)) {

   528             nextR = row;

   529             nextC = col + 1;

   530             if (nextC >= cc) {

   531                 nextC = 0;

   532                 nextR++;

   533             }

   534         }

   535     }

   536 }

   537 

   538 void QGridLayoutPrivate::add(QGridBox *box, int row, int col)

   539 {

   540     expand(row + 1, col + 1);

   541     box->row = box->torow = row;

   542     box->col = box->tocol = col;

   543     things.append(box);

   544     setDirty();

   545     setNextPosAfter(row, col);

   546 }

   547 

   548 void QGridLayoutPrivate::add(QGridBox *box, int row1, int row2, int col1, int col2)

   549 {

   550     if (row2 >= 0 && row2 < row1)

   551         qWarning("QGridLayout: Multi-cell fromRow greater than toRow");

   552     if (col2 >= 0 && col2 < col1)

   553         qWarning("QGridLayout: Multi-cell fromCol greater than toCol");

   554     if (row1 == row2 && col1 == col2) {

   555         add(box, row1, col1);

   556         return;

   557     }

   558     expand(row2 + 1, col2 + 1);

   559     box->row = row1;

   560     box->col = col1;

   561 

   562     box->torow = row2;

   563     box->tocol = col2;

   564 

   565     things.append(box);

   566     setDirty();

   567     if (col2 < 0)

   568         col2 = cc - 1;

   569 

   570     setNextPosAfter(row2, col2);

   571 }

   572 

   573 void QGridLayoutPrivate::addData(QGridBox *box, const QGridLayoutSizeTriple &sizes, bool r, bool c)

   574 {

   575     const QWidget *widget = box->item()->widget();

   576 

   577     if (box->isEmpty() && widget)

   578         return;

   579 

   580     if (c) {

   581         QLayoutStruct *data = &colData[box->col];

   582         if (!cStretch.at(box->col))

   583             data->stretch = qMax(data->stretch, box->hStretch());

   584         data->sizeHint = qMax(sizes.hint.width(), data->sizeHint);

   585         data->minimumSize = qMax(sizes.minS.width(), data->minimumSize);

   586 

   587         qMaxExpCalc(data->maximumSize, data->expansive, data->empty, sizes.maxS.width(),

   588                     box->expandingDirections() & Qt::Horizontal, box->isEmpty());

   589     }

   590     if (r) {

   591         QLayoutStruct *data = &rowData[box->row];

   592         if (!rStretch.at(box->row))

   593             data->stretch = qMax(data->stretch, box->vStretch());

   594         data->sizeHint = qMax(sizes.hint.height(), data->sizeHint);

   595         data->minimumSize = qMax(sizes.minS.height(), data->minimumSize);

   596 

   597         qMaxExpCalc(data->maximumSize, data->expansive, data->empty, sizes.maxS.height(),

   598                     box->expandingDirections() & Qt::Vertical, box->isEmpty());

   599     }

   600 }

   601 

   602 static void initEmptyMultiBox(QVector<QLayoutStruct> &chain, int start, int end)

   603 {

   604     for (int i = start; i <= end; i++) {

   605         QLayoutStruct *data = &chain[i];

   606         if (data->empty && data->maximumSize == 0) // truly empty box

   607             data->maximumSize = QWIDGETSIZE_MAX;

   608         data->empty = false;

   609     }

   610 }

   611 

   612 static void distributeMultiBox(QVector<QLayoutStruct> &chain, int start, int end, int minSize,

   613                                int sizeHint, QVector<int> &stretchArray, int stretch)

   614 {

   615     int i;

   616     int w = 0;

   617     int wh = 0;

   618     int max = 0;

   619 

   620     for (i = start; i <= end; i++) {

   621         QLayoutStruct *data = &chain[i];

   622         w += data->minimumSize;

   623         wh += data->sizeHint;

   624         max += data->maximumSize;

   625         if (stretchArray.at(i) == 0)

   626             data->stretch = qMax(data->stretch, stretch);

   627 

   628         if (i != end) {

   629             int spacing = data->spacing;

   630             w += spacing;

   631             wh += spacing;

   632             max += spacing;

   633         }

   634     }

   635 

   636     if (max < minSize) { // implies w < minSize

   637         /*

   638           We must increase the maximum size of at least one of the

   639           items. qGeomCalc() will put the extra space in between the

   640           items. We must recover that extra space and put it

   641           somewhere. It does not really matter where, since the user

   642           can always specify stretch factors and avoid this code.

   643         */

   644         qGeomCalc(chain, start, end - start + 1, 0, minSize);

   645         int pos = 0;

   646         for (i = start; i <= end; i++) {

   647             QLayoutStruct *data = &chain[i];

   648             int nextPos = (i == end) ? minSize : chain.at(i + 1).pos;

   649             int realSize = nextPos - pos;

   650             if (i != end)

   651                 realSize -= data->spacing;

   652             if (data->minimumSize < realSize)

   653                 data->minimumSize = realSize;

   654             if (data->maximumSize < data->minimumSize)

   655                 data->maximumSize = data->minimumSize;

   656             pos = nextPos;

   657         }

   658     } else if (w < minSize) {

   659         qGeomCalc(chain, start, end - start + 1, 0, minSize);

   660         for (i = start; i <= end; i++) {

   661             QLayoutStruct *data = &chain[i];

   662             if (data->minimumSize < data->size)

   663                 data->minimumSize = data->size;

   664         }

   665     }

   666 

   667     if (wh < sizeHint) {

   668         qGeomCalc(chain, start, end - start + 1, 0, sizeHint);

   669         for (i = start; i <= end; i++) {

   670             QLayoutStruct *data = &chain[i];

   671             if (data->sizeHint < data->size)

   672                 data->sizeHint = data->size;

   673         }

   674     }

   675 }

   676 

   677 static QGridBox *&gridAt(QGridBox *grid[], int r, int c, int cc,

   678                          Qt::Orientation orientation = Qt::Vertical)

   679 {

   680     if (orientation == Qt::Horizontal)

   681         qSwap(r, c);

   682     return grid[(r * cc) + c];

   683 }

   684 

   685 void QGridLayoutPrivate::setupSpacings(QVector<QLayoutStruct> &chain,

   686                                        QGridBox *grid[], int fixedSpacing,

   687                                        Qt::Orientation orientation)

   688 {

   689     Q_Q(QGridLayout);

   690     int numRows = rr;       // or columns if orientation is horizontal

   691     int numColumns = cc;    // or rows if orientation is horizontal

   692 

   693     if (orientation == Qt::Horizontal) {

   694         qSwap(numRows, numColumns);

   695     }

   696 

   697     QStyle *style = 0;

   698     if (fixedSpacing < 0) {

   699         if (QWidget *parentWidget = q->parentWidget())

   700             style = parentWidget->style();

   701     }

   702 

   703     for (int c = 0; c < numColumns; ++c) {

   704         QGridBox *previousBox = 0;

   705         int previousRow = -1;       // previous *non-empty* row

   706 

   707         for (int r = 0; r < numRows; ++r) {

   708             if (chain.at(r).empty)

   709                 continue;

   710 

   711             QGridBox *box = gridAt(grid, r, c, cc, orientation);

   712             if (previousRow != -1 && (!box || previousBox != box)) {

   713                 int spacing = fixedSpacing;

   714                 if (spacing < 0) {

   715                     QSizePolicy::ControlTypes controlTypes1 = QSizePolicy::DefaultType;

   716                     QSizePolicy::ControlTypes controlTypes2 = QSizePolicy::DefaultType;

   717                     if (previousBox)

   718                         controlTypes1 = previousBox->item()->controlTypes();

   719                     if (box)

   720                         controlTypes2 = box->item()->controlTypes();

   721 

   722                     if ((orientation == Qt::Horizontal && hReversed)

   723                             || (orientation == Qt::Vertical && vReversed))

   724                         qSwap(controlTypes1, controlTypes2);

   725 

   726                     if (style)

   727                         spacing = style->combinedLayoutSpacing(controlTypes1, controlTypes2,

   728                                              orientation, 0, q->parentWidget());

   729                 } else {

   730                     if (orientation == Qt::Vertical) {

   731                         QGridBox *sibling = vReversed ? previousBox : box;

   732                         if (sibling) {

   733                             QWidget *wid = sibling->item()->widget();

   734                             if (wid)

   735                                 spacing = qMax(spacing, sibling->item()->geometry().top() - wid->geometry().top() );

   736                         }

   737                     }

   738                 }

   739 

   740                 if (spacing > chain.at(previousRow).spacing)

   741                     chain[previousRow].spacing = spacing;

   742             }

   743 

   744             previousBox = box;

   745             previousRow = r;

   746         }

   747     }

   748 }

   749 

   750 //#define QT_LAYOUT_DISABLE_CACHING

   751 

   752 void QGridLayoutPrivate::setupLayoutData(int hSpacing, int vSpacing)

   753 {

   754     Q_Q(QGridLayout);

   755 

   756 #ifndef QT_LAYOUT_DISABLE_CACHING

   757     if (!needRecalc)

   758         return;

   759 #endif

   760     has_hfw = false;

   761     int i;

   762 

   763     for (i = 0; i < rr; i++) {

   764         rowData[i].init(rStretch.at(i), rMinHeights.at(i));

   765         rowData[i].maximumSize = rStretch.at(i) ? QLAYOUTSIZE_MAX : rMinHeights.at(i);

   766     }

   767     for (i = 0; i < cc; i++) {

   768         colData[i].init(cStretch.at(i), cMinWidths.at(i));

   769         colData[i].maximumSize = cStretch.at(i) ? QLAYOUTSIZE_MAX : cMinWidths.at(i);

   770     }

   771 

   772     int n = things.size();

   773     QVarLengthArray<QGridLayoutSizeTriple> sizes(n);

   774 

   775     bool has_multi = false;

   776 

   777     /*

   778         Grid of items. We use it to determine which items are

   779         adjacent to which and compute the spacings correctly.

   780     */

   781     QVarLengthArray<QGridBox *> grid(rr * cc);

   782     qMemSet(grid.data(), 0, rr * cc * sizeof(QGridBox *));

   783 

   784     /*

   785         Initialize 'sizes' and 'grid' data structures, and insert

   786         non-spanning items to our row and column data structures.

   787     */

   788     for (i = 0; i < n; ++i) {

   789         QGridBox * const box = things.at(i);

   790         sizes[i].minS = box->minimumSize();

   791         sizes[i].hint = box->sizeHint();

   792         sizes[i].maxS = box->maximumSize();

   793 

   794         if (box->hasHeightForWidth())

   795             has_hfw = true;

   796 

   797         if (box->row == box->toRow(rr)) {

   798             addData(box, sizes[i], true, false);

   799         } else {

   800             initEmptyMultiBox(rowData, box->row, box->toRow(rr));

   801             has_multi = true;

   802         }

   803 

   804         if (box->col == box->toCol(cc)) {

   805             addData(box, sizes[i], false, true);

   806         } else {

   807             initEmptyMultiBox(colData, box->col, box->toCol(cc));

   808             has_multi = true;

   809         }

   810 

   811         for (int r = box->row; r <= box->toRow(rr); ++r) {

   812             for (int c = box->col; c <= box->toCol(cc); ++c) {

   813                 gridAt(grid.data(), r, c, cc) = box;

   814             }

   815         }

   816     }

   817 

   818     setupSpacings(colData, grid.data(), hSpacing, Qt::Horizontal);

   819     setupSpacings(rowData, grid.data(), vSpacing, Qt::Vertical);

   820 

   821     /*

   822         Insert multicell items to our row and column data structures.

   823         This must be done after the non-spanning items to obtain a

   824         better distribution in distributeMultiBox().

   825     */

   826     if (has_multi) {

   827         for (i = 0; i < n; ++i) {

   828             QGridBox * const box = things.at(i);

   829 

   830             if (box->row != box->toRow(rr))

   831                 distributeMultiBox(rowData, box->row, box->toRow(rr), sizes[i].minS.height(),

   832                                    sizes[i].hint.height(), rStretch, box->vStretch());

   833             if (box->col != box->toCol(cc))

   834                 distributeMultiBox(colData, box->col, box->toCol(cc), sizes[i].minS.width(),

   835                                    sizes[i].hint.width(), cStretch, box->hStretch());

   836         }

   837     }

   838 

   839     for (i = 0; i < rr; i++)

   840         rowData[i].expansive = rowData.at(i).expansive || rowData.at(i).stretch > 0;

   841     for (i = 0; i < cc; i++)

   842         colData[i].expansive = colData.at(i).expansive || colData.at(i).stretch > 0;

   843 

   844     q->getContentsMargins(&leftMargin, &topMargin, &rightMargin, &bottomMargin);

   845 

   846     needRecalc = false;

   847 }

   848 

   849 void QGridLayoutPrivate::addHfwData(QGridBox *box, int width)

   850 {

   851     QVector<QLayoutStruct> &rData = *hfwData;

   852     if (box->hasHeightForWidth()) {

   853         int hint = box->heightForWidth(width);

   854         rData[box->row].sizeHint = qMax(hint, rData.at(box->row).sizeHint);

   855         rData[box->row].minimumSize = qMax(hint, rData.at(box->row).minimumSize);

   856     } else {

   857         QSize hint = box->sizeHint();

   858         QSize minS = box->minimumSize();

   859         rData[box->row].sizeHint = qMax(hint.height(), rData.at(box->row).sizeHint);

   860         rData[box->row].minimumSize = qMax(minS.height(), rData.at(box->row).minimumSize);

   861     }

   862 }

   863 

   864 /*

   865   Similar to setupLayoutData(), but uses heightForWidth(colData)

   866   instead of sizeHint(). Assumes that setupLayoutData() and

   867   qGeomCalc(colData) has been called.

   868 */

   869 void QGridLayoutPrivate::setupHfwLayoutData()

   870 {

   871     QVector<QLayoutStruct> &rData = *hfwData;

   872     for (int i = 0; i < rr; i++) {

   873         rData[i] = rowData.at(i);

   874         rData[i].minimumSize = rData[i].sizeHint = rMinHeights.at(i);

   875     }

   876 

   877     for (int pass = 0; pass < 2; ++pass) {

   878         for (int i = 0; i < things.size(); ++i) {

   879             QGridBox *box = things.at(i);

   880             int r1 = box->row;

   881             int c1 = box->col;

   882             int r2 = box->toRow(rr);

   883             int c2 = box->toCol(cc);

   884             int w = colData.at(c2).pos + colData.at(c2).size - colData.at(c1).pos;

   885 

   886             if (r1 == r2) {

   887                 if (pass == 0)

   888                     addHfwData(box, w);

   889             } else {

   890                 if (pass == 0) {

   891                     initEmptyMultiBox(rData, r1, r2);

   892                 } else {

   893                     QSize hint = box->sizeHint();

   894                     QSize min = box->minimumSize();

   895                     if (box->hasHeightForWidth()) {

   896                         int hfwh = box->heightForWidth(w);

   897                         if (hfwh > hint.height())

   898                             hint.setHeight(hfwh);

   899                         if (hfwh > min.height())

   900                             min.setHeight(hfwh);

   901                     }

   902                     distributeMultiBox(rData, r1, r2, min.height(), hint.height(),

   903                                        rStretch, box->vStretch());

   904                 }

   905             }

   906         }

   907     }

   908     for (int i = 0; i < rr; i++)

   909         rData[i].expansive = rData.at(i).expansive || rData.at(i).stretch > 0;

   910 }

   911 

   912 void QGridLayoutPrivate::distribute(QRect r, int hSpacing, int vSpacing)

   913 {

   914     Q_Q(QGridLayout);

   915     bool visualHReversed = hReversed;

   916     QWidget *parent = q->parentWidget();

   917     if (parent && parent->isRightToLeft())

   918         visualHReversed = !visualHReversed;

   919 

   920     setupLayoutData(hSpacing, vSpacing);

   921 

   922     int left, top, right, bottom;

   923     effectiveMargins(&left, &top, &right, &bottom);

   924     r.adjust(+left, +top, -right, -bottom);

   925 

   926     qGeomCalc(colData, 0, cc, r.x(), r.width());

   927     QVector<QLayoutStruct> *rDataPtr;

   928     if (has_hfw) {

   929         recalcHFW(r.width());

   930         qGeomCalc(*hfwData, 0, rr, r.y(), r.height());

   931         rDataPtr = hfwData;

   932     } else {

   933         qGeomCalc(rowData, 0, rr, r.y(), r.height());

   934         rDataPtr = &rowData;

   935     }

   936     QVector<QLayoutStruct> &rData = *rDataPtr;

   937     int i;

   938 

   939     bool reverse = ((r.bottom() > rect.bottom()) || (r.bottom() == rect.bottom()

   940                                                      && ((r.right() > rect.right()) != visualHReversed)));

   941     int n = things.size();

   942     for (i = 0; i < n; ++i) {

   943         QGridBox *box = things.at(reverse ? n-i-1 : i);

   944         int r2 = box->toRow(rr);

   945         int c2 = box->toCol(cc);

   946 

   947         int x = colData.at(box->col).pos;

   948         int y = rData.at(box->row).pos;

   949         int x2p = colData.at(c2).pos + colData.at(c2).size; // x2+1

   950         int y2p = rData.at(r2).pos + rData.at(r2).size;    // y2+1

   951         int w = x2p - x;

   952         int h = y2p - y;

   953 

   954         if (visualHReversed)

   955             x = r.left() + r.right() - x - w + 1;

   956         if (vReversed)

   957             y = r.top() + r.bottom() - y - h + 1;

   958 

   959         box->setGeometry(QRect(x, y, w, h));

   960     }

   961 }

   962 

   963 QRect QGridLayoutPrivate::cellRect(int row, int col) const

   964 {

   965     if (row < 0 || row >= rr || col < 0 || col >= cc)

   966         return QRect();

   967 

   968     const QVector<QLayoutStruct> *rDataPtr;

   969     if (has_hfw && hfwData)

   970         rDataPtr = hfwData;

   971     else

   972         rDataPtr = &rowData;

   973     return QRect(colData.at(col).pos, rDataPtr->at(row).pos,

   974                  colData.at(col).size, rDataPtr->at(row).size);

   975 }

   976 

   977 /*!

   978     \class QGridLayout

   979 

   980     \brief The QGridLayout class lays out widgets in a grid.

   981 

   982     \ingroup geomanagement

   983 

   984 

   985     QGridLayout takes the space made available to it (by its parent

   986     layout or by the parentWidget()), divides it up into rows and

   987     columns, and puts each widget it manages into the correct cell.

   988 

   989     Columns and rows behave identically; we will discuss columns, but

   990     there are equivalent functions for rows.

   991 

   992     Each column has a minimum width and a stretch factor. The minimum

   993     width is the greatest of that set using setColumnMinimumWidth() and the

   994     minimum width of each widget in that column. The stretch factor is

   995     set using setColumnStretch() and determines how much of the available

   996     space the column will get over and above its necessary minimum.

   997 

   998     Normally, each managed widget or layout is put into a cell of its

   999     own using addWidget(). It is also possible for a widget to occupy

  1000     multiple cells using the row and column spanning overloads of

  1001     addItem() and addWidget(). If you do this, QGridLayout will guess

  1002     how to distribute the size over the columns/rows (based on the

  1003     stretch factors).

  1004 

  1005     To remove a widget from a layout, call removeWidget(). Calling

  1006     QWidget::hide() on a widget also effectively removes the widget

  1007     from the layout until QWidget::show() is called.

  1008 

  1009     This illustration shows a fragment of a dialog with a five-column,

  1010     three-row grid (the grid is shown overlaid in magenta):

  1011 

  1012     \image gridlayout.png A grid layout

  1013 

  1014     Columns 0, 2 and 4 in this dialog fragment are made up of a

  1015     QLabel, a QLineEdit, and a QListBox. Columns 1 and 3 are

  1016     placeholders made with setColumnMinimumWidth(). Row 0 consists of three

  1017     QLabel objects, row 1 of three QLineEdit objects and row 2 of

  1018     three QListBox objects. We used placeholder columns (1 and 3) to

  1019     get the right amount of space between the columns.

  1020 

  1021     Note that the columns and rows are not equally wide or tall. If

  1022     you want two columns to have the same width, you must set their

  1023     minimum widths and stretch factors to be the same yourself. You do

  1024     this using setColumnMinimumWidth() and setColumnStretch().

  1025 

  1026     If the QGridLayout is not the top-level layout (i.e. does not

  1027     manage all of the widget's area and children), you must add it to

  1028     its parent layout when you create it, but before you do anything

  1029     with it. The normal way to add a layout is by calling

  1030     addLayout() on the parent layout.

  1031 

  1032     Once you have added your layout you can start putting widgets and

  1033     other layouts into the cells of your grid layout using

  1034     addWidget(), addItem(), and addLayout().

  1035 

  1036     QGridLayout also includes two margin widths:

  1037     the \l{getContentsMargins()}{contents margin} and the spacing().

  1038     The contents margin is the width of the reserved space along each

  1039     of the QGridLayout's four sides. The spacing() is the width of the

  1040     automatically allocated spacing between neighboring boxes.

  1041 

  1042     The default contents margin values are provided by the

  1043     \l{QStyle::pixelMetric()}{style}. The default value Qt styles specify

  1044     is 9 for child widgets and 11 for windows. The spacing defaults to the same as

  1045     the margin width for a top-level layout, or to the same as the

  1046     parent layout.

  1047 

  1048     \sa QBoxLayout, QStackedLayout, {Layout Management}, {Basic Layouts Example}

  1049 */

  1050 

  1051 

  1052 /*!

  1053     Constructs a new QGridLayout with parent widget, \a parent.  The

  1054     layout has one row and one column initially, and will expand when

  1055     new items are inserted.

  1056 */

  1057 QGridLayout::QGridLayout(QWidget *parent)

  1058     : QLayout(*new QGridLayoutPrivate, 0, parent)

  1059 {

  1060     Q_D(QGridLayout);

  1061     d->expand(1, 1);

  1062 }

  1063 

  1064 /*!

  1065     Constructs a new grid layout.

  1066 

  1067     You must insert this grid into another layout. You can insert

  1068     widgets and layouts into this layout at any time, but laying out

  1069     will not be performed before this is inserted into another layout.

  1070 */

  1071 QGridLayout::QGridLayout()

  1072     : QLayout(*new QGridLayoutPrivate, 0, 0)

  1073 {

  1074     Q_D(QGridLayout);

  1075     d->expand(1, 1);

  1076 }

  1077 

  1078 

  1079 #ifdef QT3_SUPPORT

  1080 /*!

  1081     \obsolete

  1082     Constructs a new QGridLayout with \a nRows rows, \a nCols columns

  1083     and parent widget, \a  parent. \a parent may not be 0. The grid

  1084     layout is called \a name.

  1085 

  1086     \a margin is the number of pixels between the edge of the widget

  1087     and its managed children. \a space is the default number of pixels

  1088     between cells. If \a space is -1, the value of \a margin is used.

  1089 */

  1090 QGridLayout::QGridLayout(QWidget *parent, int nRows, int nCols, int margin,

  1091                          int space, const char *name)

  1092     : QLayout(*new QGridLayoutPrivate, 0, parent)

  1093 {

  1094     Q_D(QGridLayout);

  1095     d->expand(nRows, nCols);

  1096     setMargin(margin);

  1097     setSpacing(space < 0 ? margin : space);

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

  1099 }

  1100 

  1101 /*!

  1102     \obsolete

  1103 

  1104     Constructs a new grid with \a nRows rows and \a nCols columns. If

  1105     \a spacing is -1, this QGridLayout inherits its parent's

  1106     spacing(); otherwise \a spacing is used. The grid layout is called

  1107     \a name.

  1108 

  1109     You must insert this grid into another layout. You can insert

  1110     widgets and layouts into this layout at any time, but laying out

  1111     will not be performed before this is inserted into another layout.

  1112 */

  1113 QGridLayout::QGridLayout(QLayout *parentLayout, int nRows, int nCols,

  1114                          int spacing, const char *name)

  1115     : QLayout(*new QGridLayoutPrivate, parentLayout, 0)

  1116 {

  1117     Q_D(QGridLayout);

  1118     d->expand(nRows, nCols);

  1119     setSpacing(spacing);

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

  1121 }

  1122 

  1123 /*!

  1124     \obsolete

  1125 

  1126     Constructs a new grid with \a nRows rows and \a nCols columns. If

  1127     \a spacing is -1, this QGridLayout inherits its parent's

  1128     spacing(); otherwise \a spacing is used. The grid layout is called

  1129     \a name.

  1130 

  1131     You must insert this grid into another layout. You can insert

  1132     widgets and layouts into this layout at any time, but laying out

  1133     will not be performed before this is inserted into another layout.

  1134 */