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

    43 

    44 #ifndef QT_NO_GRAPHICSVIEW

    45 

    46 #include <math.h>

    47 

    48 #include "qgraphicslayoutitem.h"

    49 #include "qgridlayoutengine_p.h"

    50 #include "qstyleoption.h"

    51 #include "qvarlengtharray.h"

    52 

    53 #include <QtDebug>

    54 #include <QtCore/qmath.h>

    55 

    56 QT_BEGIN_NAMESPACE

    57 

    58 template <typename T>

    59 static void insertOrRemoveItems(QVector<T> &items, int index, int delta)

    60 {

    61     int count = items.count();

    62     if (index < count) {

    63         if (delta > 0) {

    64             items.insert(index, delta, T());

    65         } else if (delta < 0) {

    66             items.remove(index, qMin(-delta, count - index));

    67         }

    68     }

    69 }

    70 

    71 static qreal growthFactorBelowPreferredSize(qreal desired, qreal sumAvailable, qreal sumDesired)

    72 {

    73     Q_ASSERT(sumDesired != 0.0);

    74     return desired * qPow(sumAvailable / sumDesired, desired / sumDesired);

    75 }

    76 

    77 static qreal fixedDescent(qreal descent, qreal ascent, qreal targetSize)

    78 {

    79     if (descent < 0.0)

    80         return -1.0;

    81 

    82     Q_ASSERT(descent >= 0.0);

    83     Q_ASSERT(ascent >= 0.0);

    84     Q_ASSERT(targetSize >= ascent + descent);

    85 

    86     qreal extra = targetSize - (ascent + descent);

    87     return descent + (extra / 2.0);

    88 }

    89 

    90 static qreal compare(const QGridLayoutBox &box1, const QGridLayoutBox &box2, int which)

    91 {

    92     qreal size1 = box1.q_sizes(which);

    93     qreal size2 = box2.q_sizes(which);

    94 

    95     if (which == MaximumSize) {

    96         return size2 - size1;

    97     } else {

    98         return size1 - size2;

    99     }

   100 }

   101 

   102 void QGridLayoutBox::add(const QGridLayoutBox &other, int stretch, qreal spacing)

   103 {

   104     Q_ASSERT(q_minimumDescent < 0.0);

   105 

   106     q_minimumSize += other.q_minimumSize + spacing;

   107     q_preferredSize += other.q_preferredSize + spacing;

   108     q_maximumSize += ((stretch == 0) ? other.q_preferredSize : other.q_maximumSize) + spacing;

   109 }

   110 

   111 void QGridLayoutBox::combine(const QGridLayoutBox &other)

   112 {

   113     q_minimumDescent = qMax(q_minimumDescent, other.q_minimumDescent);

   114     q_minimumAscent = qMax(q_minimumAscent, other.q_minimumAscent);

   115 

   116     q_minimumSize = qMax(q_minimumAscent + q_minimumDescent,

   117                          qMax(q_minimumSize, other.q_minimumSize));

   118     qreal maxMax;

   119     if (q_maximumSize == FLT_MAX && other.q_maximumSize != FLT_MAX)

   120         maxMax = other.q_maximumSize;

   121     else if (other.q_maximumSize == FLT_MAX && q_maximumSize != FLT_MAX)

   122         maxMax = q_maximumSize;

   123     else

   124         maxMax = qMax(q_maximumSize, other.q_maximumSize);

   125 

   126     q_maximumSize = qMax(q_minimumSize, maxMax);

   127     q_preferredSize = qBound(q_minimumSize, qMax(q_preferredSize, other.q_preferredSize),

   128                              q_maximumSize);

   129 }

   130 

   131 void QGridLayoutBox::normalize()

   132 {

   133     q_maximumSize = qMax(qreal(0.0), q_maximumSize);

   134     q_minimumSize = qBound(qreal(0.0), q_minimumSize, q_maximumSize);

   135     q_preferredSize = qBound(q_minimumSize, q_preferredSize, q_maximumSize);

   136     q_minimumDescent = qMin(q_minimumDescent, q_minimumSize);

   137 

   138     Q_ASSERT((q_minimumDescent < 0.0) == (q_minimumAscent < 0.0));

   139 }

   140 

   141 #ifdef QT_DEBUG

   142 void QGridLayoutBox::dump(int indent) const

   143 {

   144     qDebug("%*sBox (%g <= %g <= %g [%g/%g])", indent, "", q_minimumSize, q_preferredSize,

   145            q_maximumSize, q_minimumAscent, q_minimumDescent);

   146 }

   147 #endif

   148 

   149 bool operator==(const QGridLayoutBox &box1, const QGridLayoutBox &box2)

   150 {

   151     for (int i = 0; i < NSizes; ++i) {

   152         if (box1.q_sizes(i) != box2.q_sizes(i))

   153             return false;

   154     }

   155     return box1.q_minimumDescent == box2.q_minimumDescent

   156            && box1.q_minimumAscent == box2.q_minimumAscent;

   157 }

   158 

   159 void QGridLayoutRowData::reset(int count)

   160 {

   161     ignore.fill(false, count);

   162     boxes.fill(QGridLayoutBox(), count);

   163     multiCellMap.clear();

   164     stretches.fill(0, count);

   165     spacings.fill(0.0, count);

   166     hasIgnoreFlag = false;

   167 }

   168 

   169 void QGridLayoutRowData::distributeMultiCells()

   170 {

   171     MultiCellMap::const_iterator i = multiCellMap.constBegin();

   172     for (; i != multiCellMap.constEnd(); ++i) {

   173         int start = i.key().first;

   174         int span = i.key().second;

   175         int end = start + span;

   176         const QGridLayoutBox &box = i.value().q_box;

   177         int stretch = i.value().q_stretch;

   178 

   179         QGridLayoutBox totalBox = this->totalBox(start, end);

   180         QVarLengthArray<QGridLayoutBox> extras(span);

   181         QVarLengthArray<qreal> dummy(span);

   182         QVarLengthArray<qreal> newSizes(span);

   183 

   184         for (int j = 0; j < NSizes; ++j) {

   185             qreal extra = compare(box, totalBox, j);

   186             if (extra > 0.0) {

   187                 calculateGeometries(start, end, box.q_sizes(j), dummy.data(), newSizes.data(),

   188                                     0, totalBox);

   189 

   190                 for (int k = 0; k < span; ++k)

   191                     extras[k].q_sizes(j) = newSizes[k];

   192             }

   193         }

   194 

   195         for (int k = 0; k < span; ++k) {

   196             boxes[start + k].combine(extras[k]);

   197             stretches[start + k] = qMax(stretches[start + k], stretch);

   198         }

   199     }

   200     multiCellMap.clear();

   201 }

   202 

   203 void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSize, qreal *positions,

   204                                              qreal *sizes, qreal *descents,

   205                                              const QGridLayoutBox &totalBox)

   206 {

   207     Q_ASSERT(end > start);

   208 

   209     targetSize = qBound(totalBox.q_minimumSize, targetSize, totalBox.q_maximumSize);

   210 

   211     int n = end - start;

   212     QVarLengthArray<qreal> newSizes(n);

   213     QVarLengthArray<qreal> factors(n);

   214     qreal sumFactors = 0.0;

   215     int sumStretches = 0;

   216     qreal sumAvailable;

   217 

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

   219         if (stretches[start + i] > 0)

   220             sumStretches += stretches[start + i];

   221     }

   222 

   223     if (targetSize < totalBox.q_preferredSize) {

   224         stealBox(start, end, MinimumSize, positions, sizes);

   225 

   226         sumAvailable = targetSize - totalBox.q_minimumSize;

   227         if (sumAvailable > 0.0) {

   228             qreal sumDesired = totalBox.q_preferredSize - totalBox.q_minimumSize;

   229 

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

   231                 if (ignore.testBit(start + i)) {

   232                     factors[i] = 0.0;

   233                     continue;

   234                 }

   235 

   236                 const QGridLayoutBox &box = boxes.at(start + i);

   237                 qreal desired = box.q_preferredSize - box.q_minimumSize;

   238                 factors[i] = growthFactorBelowPreferredSize(desired, sumAvailable, sumDesired);

   239                 sumFactors += factors[i];

   240             }

   241 

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

   243                 Q_ASSERT(sumFactors > 0.0);

   244                 qreal delta = sumAvailable * factors[i] / sumFactors;

   245                 newSizes[i] = sizes[i] + delta;

   246             }

   247         }

   248     } else {

   249         stealBox(start, end, PreferredSize, positions, sizes);

   250 

   251         sumAvailable = targetSize - totalBox.q_preferredSize;

   252         if (sumAvailable > 0.0) {

   253             bool somethingHasAMaximumSize = false;

   254 

   255             qreal sumPreferredSizes = 0.0;

   256             for (int i = 0; i < n; ++i)

   257                 sumPreferredSizes += sizes[i];

   258 

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

   260                 if (ignore.testBit(start + i)) {

   261                     newSizes[i] = 0.0;

   262                     factors[i] = 0.0;

   263                     continue;

   264                 }

   265 

   266                 const QGridLayoutBox &box = boxes.at(start + i);

   267                 qreal desired = box.q_maximumSize - box.q_preferredSize;

   268                 if (desired == 0.0) {

   269                     newSizes[i] = sizes[i];

   270                     factors[i] = 0.0;

   271                 } else {

   272                     Q_ASSERT(desired > 0.0);

   273 

   274                     int stretch = stretches[start + i];

   275                     if (sumStretches == 0) {

   276                         if (hasIgnoreFlag) {

   277                             factors[i] = (stretch < 0) ? 1.0 : 0.0;

   278                         } else {

   279                             factors[i] = (stretch < 0) ? sizes[i] : 0.0;

   280                         }

   281                     } else if (stretch == sumStretches) {

   282                         factors[i] = 1.0;

   283                     } else if (stretch <= 0) {

   284                         factors[i] = 0.0;

   285                     } else {

   286                         qreal ultimatePreferredSize;

   287                         qreal ultimateSumPreferredSizes;

   288                         qreal x = ((stretch * sumPreferredSizes)

   289                                    - (sumStretches * box.q_preferredSize))

   290                                   / (sumStretches - stretch);

   291                         if (x >= 0.0) {

   292                             ultimatePreferredSize = box.q_preferredSize + x;

   293                             ultimateSumPreferredSizes = sumPreferredSizes + x;

   294                         } else {

   295                             ultimatePreferredSize = box.q_preferredSize;

   296                             ultimateSumPreferredSizes = (sumStretches * box.q_preferredSize)

   297                                                         / stretch;

   298                         }

   299 

   300                         /*

   301                             We multiply these by 1.5 to give some space for a smooth transition

   302                             (at the expense of the stretch factors, which are not fully respected

   303                             during the transition).

   304                         */

   305                         ultimatePreferredSize = ultimatePreferredSize * 3 / 2;

   306                         ultimateSumPreferredSizes = ultimateSumPreferredSizes * 3 / 2;

   307 

   308                         qreal ultimateFactor = (stretch * ultimateSumPreferredSizes

   309                                                 / sumStretches)

   310                                                - (box.q_preferredSize);

   311                         qreal transitionalFactor = sumAvailable

   312                                                    * (ultimatePreferredSize - box.q_preferredSize)

   313                                                    / (ultimateSumPreferredSizes

   314                                                       - sumPreferredSizes);

   315 

   316                         qreal alpha = qMin(sumAvailable,

   317                                            ultimateSumPreferredSizes - sumPreferredSizes);

   318                         qreal beta = ultimateSumPreferredSizes - sumPreferredSizes;

   319 

   320                         factors[i] = ((alpha * ultimateFactor)

   321                                       + ((beta - alpha) * transitionalFactor)) / beta;

   322                     }

   323                     sumFactors += factors[i];

   324                     if (desired < sumAvailable)

   325                         somethingHasAMaximumSize = true;

   326 

   327                     newSizes[i] = -1.0;

   328                 }

   329             }

   330 

   331             bool keepGoing = somethingHasAMaximumSize;

   332             while (keepGoing) {

   333                 keepGoing = false;

   334 

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

   336                     if (newSizes[i] >= 0.0)

   337                         continue;

   338 

   339                     const QGridLayoutBox &box = boxes.at(start + i);

   340                     qreal avail = sumAvailable * factors[i] / sumFactors;

   341                     if (sizes[i] + avail >= box.q_maximumSize) {

   342                         newSizes[i] = box.q_maximumSize;

   343                         sumAvailable -= box.q_maximumSize - sizes[i];

   344                         sumFactors -= factors[i];

   345                         keepGoing = (sumAvailable > 0.0);

   346                         if (!keepGoing)

   347                             break;

   348                     }

   349                 }

   350             }

   351 

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

   353                 if (newSizes[i] < 0.0) {

   354                     qreal delta = (sumFactors == 0.0) ? 0.0

   355                                                       : sumAvailable * factors[i] / sumFactors;

   356                     newSizes[i] = sizes[i] + delta;

   357                 }

   358             }

   359         }

   360     }

   361 

   362     if (sumAvailable > 0) {

   363         qreal offset = 0;

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

   365             qreal delta = newSizes[i] - sizes[i];

   366             positions[i] += offset;

   367             sizes[i] += delta;

   368             offset += delta;

   369         }

   370 

   371 #if 0 // some "pixel allocation"

   372         int surplus = targetSize - (positions[n - 1] + sizes[n - 1]);

   373         Q_ASSERT(surplus >= 0 && surplus <= n);

   374 

   375         int prevSurplus = -1;

   376         while (surplus > 0 && surplus != prevSurplus) {

   377             prevSurplus = surplus;

   378 

   379             int offset = 0;

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

   381                 const QGridLayoutBox &box = boxes.at(start + i);

   382                 int delta = (!ignore.testBit(start + i) && surplus > 0

   383                              && factors[i] > 0 && sizes[i] < box.q_maximumSize)

   384                     ? 1 : 0;

   385 

   386                 positions[i] += offset;

   387                 sizes[i] += delta;

   388                 offset += delta;

   389                 surplus -= delta;

   390             }

   391         }

   392         Q_ASSERT(surplus == 0);

   393 #endif

   394     }

   395 

   396     if (descents) {

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

   398             if (ignore.testBit(start + i))

   399                 continue;

   400             const QGridLayoutBox &box = boxes.at(start + i);

   401             descents[i] = fixedDescent(box.q_minimumDescent, box.q_minimumAscent, sizes[i]);

   402         }

   403     }

   404 }

   405 

   406 QGridLayoutBox QGridLayoutRowData::totalBox(int start, int end) const

   407 {

   408     QGridLayoutBox result;

   409     if (start < end) {

   410         result.q_maximumSize = 0.0;

   411         qreal nextSpacing = 0.0;

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

   413             result.add(boxes.at(i), stretches.at(i), nextSpacing);

   414             nextSpacing = spacings.at(i);

   415         }

   416     }

   417     return result;

   418 }

   419 

   420 void QGridLayoutRowData::stealBox(int start, int end, int which, qreal *positions, qreal *sizes)

   421 {

   422     qreal offset = 0.0;

   423     qreal nextSpacing = 0.0;

   424 

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

   426         qreal avail = 0.0;

   427 

   428         if (!ignore.testBit(i)) {

   429             const QGridLayoutBox &box = boxes.at(i);

   430             avail = box.q_sizes(which);

   431             offset += nextSpacing;

   432             nextSpacing = spacings.at(i);

   433         }

   434 

   435         *positions++ = offset;

   436         *sizes++ = avail;

   437         offset += avail;

   438     }

   439 }

   440 

   441 #ifdef QT_DEBUG

   442 void QGridLayoutRowData::dump(int indent) const

   443 {

   444     qDebug("%*sData", indent, "");

   445 

   446     for (int i = 0; i < ignore.count(); ++i) {

   447         qDebug("%*s Row %d (stretch %d, spacing %g)", indent, "", i, stretches.at(i),

   448                spacings.at(i));

   449         if (ignore.testBit(i))

   450             qDebug("%*s  Ignored", indent, "");

   451         boxes.at(i).dump(indent + 2);

   452     }

   453 

   454     MultiCellMap::const_iterator it = multiCellMap.constBegin();

   455     while (it != multiCellMap.constEnd()) {

   456         qDebug("%*s Multi-cell entry <%d, %d> (stretch %d)", indent, "", it.key().first,

   457                it.key().second, it.value().q_stretch);

   458         it.value().q_box.dump(indent + 2);

   459     }

   460 }

   461 #endif

   462 

   463 QGridLayoutItem::QGridLayoutItem(QGridLayoutEngine *engine, QGraphicsLayoutItem *layoutItem,

   464                                  int row, int column, int rowSpan, int columnSpan,

   465                                  Qt::Alignment alignment, int itemAtIndex)

   466     : q_engine(engine), q_layoutItem(layoutItem), q_alignment(alignment)

   467 {

   468     q_firstRows[Hor] = column;

   469     q_firstRows[Ver] = row;

   470     q_rowSpans[Hor] = columnSpan;

   471     q_rowSpans[Ver] = rowSpan;

   472     q_stretches[Hor] = -1;

   473     q_stretches[Ver] = -1;

   474 

   475     q_engine->insertItem(this, itemAtIndex);

   476 }

   477 

   478 int QGridLayoutItem::firstRow(Qt::Orientation orientation) const

   479 {

   480     return q_firstRows[orientation == Qt::Vertical];

   481 }

   482 

   483 int QGridLayoutItem::firstColumn(Qt::Orientation orientation) const

   484 {

   485     return q_firstRows[orientation == Qt::Horizontal];

   486 }

   487 

   488 int QGridLayoutItem::lastRow(Qt::Orientation orientation) const

   489 {

   490     return firstRow(orientation) + rowSpan(orientation) - 1;

   491 }

   492 

   493 int QGridLayoutItem::lastColumn(Qt::Orientation orientation) const

   494 {

   495     return firstColumn(orientation) + columnSpan(orientation) - 1;

   496 }

   497 

   498 int QGridLayoutItem::rowSpan(Qt::Orientation orientation) const

   499 {

   500     return q_rowSpans[orientation == Qt::Vertical];

   501 }

   502 

   503 int QGridLayoutItem::columnSpan(Qt::Orientation orientation) const

   504 {

   505     return q_rowSpans[orientation == Qt::Horizontal];

   506 }

   507 

   508 void QGridLayoutItem::setFirstRow(int row, Qt::Orientation orientation)

   509 {

   510     q_firstRows[orientation == Qt::Vertical] = row;

   511 }

   512 

   513 void QGridLayoutItem::setRowSpan(int rowSpan, Qt::Orientation orientation)

   514 {

   515     q_rowSpans[orientation == Qt::Vertical] = rowSpan;

   516 }

   517 

   518 int QGridLayoutItem::stretchFactor(Qt::Orientation orientation) const

   519 {

   520     int stretch = q_stretches[orientation == Qt::Vertical];

   521     if (stretch >= 0)

   522         return stretch;

   523 

   524     QSizePolicy::Policy policy = sizePolicy(orientation);

   525 

   526     if (policy & QSizePolicy::ExpandFlag) {

   527         return 1;

   528     } else if (policy & QSizePolicy::GrowFlag) {

   529         return -1;  // because we max it up

   530     } else {

   531         return 0;

   532     }

   533 }

   534 

   535 void QGridLayoutItem::setStretchFactor(int stretch, Qt::Orientation orientation)

   536 {

   537     Q_ASSERT(stretch >= 0); // ### deal with too big stretches

   538     q_stretches[orientation == Qt::Vertical] = stretch;

   539 }

   540 

   541 QSizePolicy::Policy QGridLayoutItem::sizePolicy(Qt::Orientation orientation) const

   542 {

   543     QSizePolicy sizePolicy(q_layoutItem->sizePolicy());

   544     return (orientation == Qt::Horizontal) ? sizePolicy.horizontalPolicy()

   545                                            : sizePolicy.verticalPolicy();

   546 }

   547 

   548 QSizePolicy::ControlTypes QGridLayoutItem::controlTypes(LayoutSide /* side */) const

   549 {

   550     return q_layoutItem->sizePolicy().controlType();

   551 }

   552 

   553 QSizeF QGridLayoutItem::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const

   554 {

   555     return q_layoutItem->effectiveSizeHint(which, constraint);

   556 }

   557 

   558 QGridLayoutBox QGridLayoutItem::box(Qt::Orientation orientation, qreal constraint) const

   559 {

   560     QGridLayoutBox result;

   561     QSizePolicy::Policy policy = sizePolicy(orientation);

   562 

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

   564         QSizeF constraintSize(-1.0, constraint);

   565 

   566         result.q_preferredSize = sizeHint(Qt::PreferredSize, constraintSize).width();

   567 

   568         if (policy & QSizePolicy::ShrinkFlag) {

   569             result.q_minimumSize = sizeHint(Qt::MinimumSize, constraintSize).width();

   570         } else {

   571             result.q_minimumSize = result.q_preferredSize;

   572         }

   573 

   574         if (policy & (QSizePolicy::GrowFlag | QSizePolicy::ExpandFlag)) {

   575             result.q_maximumSize = sizeHint(Qt::MaximumSize, constraintSize).width();

   576         } else {

   577             result.q_maximumSize = result.q_preferredSize;

   578         }

   579     } else {

   580         QSizeF constraintSize(constraint, -1.0);

   581 

   582         result.q_preferredSize = sizeHint(Qt::PreferredSize, constraintSize).height();

   583 

   584         if (policy & QSizePolicy::ShrinkFlag) {

   585             result.q_minimumSize = sizeHint(Qt::MinimumSize, constraintSize).height();

   586         } else {

   587             result.q_minimumSize = result.q_preferredSize;

   588         }

   589 

   590         if (policy & (QSizePolicy::GrowFlag | QSizePolicy::ExpandFlag)) {

   591             result.q_maximumSize = sizeHint(Qt::MaximumSize, constraintSize).height();

   592         } else {

   593             result.q_maximumSize = result.q_preferredSize;

   594         }

   595 

   596         result.q_minimumDescent = sizeHint(Qt::MinimumDescent, constraintSize).height();

   597         if (result.q_minimumDescent >= 0.0)

   598             result.q_minimumAscent = result.q_minimumSize - result.q_minimumDescent;

   599     }

   600     if (policy & QSizePolicy::IgnoreFlag)

   601         result.q_preferredSize = result.q_minimumSize;

   602 

   603     return result;

   604 }

   605 

   606 QRectF QGridLayoutItem::geometryWithin(qreal x, qreal y, qreal width, qreal height,

   607                                        qreal rowDescent) const

   608 {

   609     rowDescent = -1.0; // ### This disables the descent

   610 

   611     QGridLayoutBox vBox = box(Qt::Vertical);

   612     if (vBox.q_minimumDescent < 0.0 || rowDescent < 0.0) {

   613         qreal cellWidth = width;

   614         qreal cellHeight = height;

   615 

   616         QSizeF size = effectiveMaxSize().boundedTo(QSizeF(cellWidth, cellHeight));

   617         width = size.width();

   618         height = size.height();

   619 

   620         Qt::Alignment align = q_engine->effectiveAlignment(this);

   621         switch (align & Qt::AlignHorizontal_Mask) {

   622         case Qt::AlignHCenter:

   623             x += (cellWidth - width)/2;

   624             break;

   625         case Qt::AlignRight:

   626             x += cellWidth - width;

   627             break;

   628         default:

   629             break;

   630         }

   631         switch (align & Qt::AlignVertical_Mask) {

   632         case Qt::AlignVCenter:

   633             y += (cellHeight - height)/2;

   634             break;

   635         case Qt::AlignBottom:

   636             y += cellHeight - height;

   637             break;

   638         default:

   639             break;

   640         }

   641         return QRectF(x, y, width, height);

   642     } else {

   643         qreal descent = vBox.q_minimumDescent;

   644         qreal ascent = vBox.q_minimumSize - descent;

   645         return QRectF(x, y + height - rowDescent - ascent, width, ascent + descent);

   646     }

   647 }

   648 

   649 void QGridLayoutItem::setGeometry(const QRectF &rect)

   650 {

   651     q_layoutItem->setGeometry(rect);

   652 }

   653 

   654 void QGridLayoutItem::transpose()

   655 {

   656     qSwap(q_firstRows[Hor], q_firstRows[Ver]);

   657     qSwap(q_rowSpans[Hor], q_rowSpans[Ver]);

   658     qSwap(q_stretches[Hor], q_stretches[Ver]);

   659 }

   660 

   661 void QGridLayoutItem::insertOrRemoveRows(int row, int delta, Qt::Orientation orientation)

   662 {

   663     int oldFirstRow = firstRow(orientation);

   664     if (oldFirstRow >= row) {

   665         setFirstRow(oldFirstRow + delta, orientation);

   666     } else if (lastRow(orientation) >= row) {

   667         setRowSpan(rowSpan(orientation) + delta, orientation);

   668     }

   669 }

   670 /*!

   671     \internal

   672     returns the effective maximumSize, will take the sizepolicy into

   673     consideration. (i.e. if sizepolicy does not have QSizePolicy::Grow, then

   674     maxSizeHint will be the preferredSize)

   675     Note that effectiveSizeHint does not take sizePolicy into consideration,

   676     (since it only evaluates the hints, as the name implies)

   677 */

   678 QSizeF QGridLayoutItem::effectiveMaxSize() const

   679 {

   680     QSizeF size;

   681     bool vGrow = (sizePolicy(Qt::Vertical) & QSizePolicy::GrowFlag) == QSizePolicy::GrowFlag;

   682     bool hGrow = (sizePolicy(Qt::Horizontal) & QSizePolicy::GrowFlag) == QSizePolicy::GrowFlag;

   683     if (!vGrow || !hGrow) {

   684         QSizeF pref = layoutItem()->effectiveSizeHint(Qt::PreferredSize);

   685         if (!vGrow)

   686             size.setHeight(pref.height());

   687         if (!hGrow)

   688             size.setWidth(pref.width());

   689     }

   690 

   691     if (!size.isValid()) {

   692         QSizeF maxSize = layoutItem()->effectiveSizeHint(Qt::MaximumSize);

   693         if (size.width() == -1)

   694             size.setWidth(maxSize.width());

   695         if (size.height() == -1)

   696             size.setHeight(maxSize.height());

   697     }

   698     return size;

   699 }

   700 

   701 #ifdef QT_DEBUG

   702 void QGridLayoutItem::dump(int indent) const

   703 {

   704     qDebug("%*s%p (%d, %d) %d x %d", indent, "", q_layoutItem, firstRow(), firstColumn(),

   705            rowSpan(), columnSpan());

   706 

   707     if (q_stretches[Hor] >= 0)

   708         qDebug("%*s Horizontal stretch: %d", indent, "", q_stretches[Hor]);

   709     if (q_stretches[Ver] >= 0)

   710         qDebug("%*s Vertical stretch: %d", indent, "", q_stretches[Ver]);

   711     if (q_alignment != 0)

   712         qDebug("%*s Alignment: %x", indent, "", uint(q_alignment));

   713     qDebug("%*s Horizontal size policy: %x Vertical size policy: %x",

   714         indent, "", sizePolicy(Qt::Horizontal), sizePolicy(Qt::Vertical));

   715 }

   716 #endif

   717 

   718 void QGridLayoutRowInfo::insertOrRemoveRows(int row, int delta)

   719 {

   720     count += delta;

   721 

   722     insertOrRemoveItems(stretches, row, delta);

   723     insertOrRemoveItems(spacings, row, delta);

   724     insertOrRemoveItems(alignments, row, delta);

   725     insertOrRemoveItems(boxes, row, delta);

   726 }

   727 

   728 #ifdef QT_DEBUG

   729 void QGridLayoutRowInfo::dump(int indent) const

   730 {

   731     qDebug("%*sInfo (count: %d)", indent, "", count);

   732     for (int i = 0; i < count; ++i) {

   733         QString message;

   734 

   735         if (stretches.value(i).value() >= 0)

   736             message += QString::fromAscii(" stretch %1").arg(stretches.value(i).value());

   737         if (spacings.value(i).value() >= 0.0)

   738             message += QString::fromAscii(" spacing %1").arg(spacings.value(i).value());

   739         if (alignments.value(i) != 0)

   740             message += QString::fromAscii(" alignment %1").arg(int(alignments.value(i)), 16);

   741 

   742         if (!message.isEmpty() || boxes.value(i) != QGridLayoutBox()) {

   743             qDebug("%*s Row %d:%s", indent, "", i, qPrintable(message));

   744             if (boxes.value(i) != QGridLayoutBox())

   745                 boxes.value(i).dump(indent + 1);

   746         }

   747     }

   748 }

   749 #endif

   750 

   751 QGridLayoutEngine::QGridLayoutEngine()

   752 {

   753     m_visualDirection = Qt::LeftToRight;

   754     invalidate();

   755 }

   756 

   757 int QGridLayoutEngine::rowCount(Qt::Orientation orientation) const

   758 {

   759     return q_infos[orientation == Qt::Vertical].count;

   760 }

   761 

   762 int QGridLayoutEngine::columnCount(Qt::Orientation orientation) const

   763 {

   764     return q_infos[orientation == Qt::Horizontal].count;

   765 }

   766 

   767 int QGridLayoutEngine::itemCount() const

   768 {

   769     return q_items.count();

   770 }

   771 

   772 QGridLayoutItem *QGridLayoutEngine::itemAt(int index) const

   773 {

   774     Q_ASSERT(index >= 0 && index < itemCount());

   775     return q_items.at(index);

   776 }

   777 

   778 int QGridLayoutEngine::effectiveFirstRow(Qt::Orientation orientation) const

   779 {

   780     ensureEffectiveFirstAndLastRows();

   781     return q_cachedEffectiveFirstRows[orientation == Qt::Vertical];

   782 }

   783 

   784 int QGridLayoutEngine::effectiveLastRow(Qt::Orientation orientation) const

   785 {

   786     ensureEffectiveFirstAndLastRows();

   787     return q_cachedEffectiveLastRows[orientation == Qt::Vertical];

   788 }

   789 

   790 void QGridLayoutEngine::setSpacing(qreal spacing, Qt::Orientations orientations)

   791 {

   792     Q_ASSERT(spacing >= 0.0);

   793     if (orientations & Qt::Horizontal)

   794         q_defaultSpacings[Hor].setUserValue(spacing);

   795     if (orientations & Qt::Vertical)

   796         q_defaultSpacings[Ver].setUserValue(spacing);

   797 

   798     invalidate();

   799 }

   800 

   801 qreal QGridLayoutEngine::spacing(const QLayoutStyleInfo &styleInfo, Qt::Orientation orientation) const

   802 {

   803     if (q_defaultSpacings[orientation == Qt::Vertical].isDefault()) {

   804         QStyle *style = styleInfo.style();

   805         QStyleOption option;

   806         option.initFrom(styleInfo.widget());

   807         qreal defaultSpacing = (qreal)style->pixelMetric(orientation == Qt::Vertical ? QStyle::PM_LayoutVerticalSpacing

   808                                                : QStyle::PM_LayoutHorizontalSpacing, &option, styleInfo.widget());

   809         q_defaultSpacings[orientation == Qt::Vertical].setCachedValue(defaultSpacing);

   810     }

   811     return q_defaultSpacings[orientation == Qt::Vertical].value();

   812 }

   813 

   814 void QGridLayoutEngine::setRowSpacing(int row, qreal spacing, Qt::Orientation orientation)

   815 {

   816     Q_ASSERT(row >= 0);

   817 

   818     QGridLayoutRowInfo &rowInfo = q_infos[orientation == Qt::Vertical];

   819     if (row >= rowInfo.spacings.count())

   820         rowInfo.spacings.resize(row + 1);

   821     if (spacing >= 0)

   822         rowInfo.spacings[row].setUserValue(spacing);

   823     else

   824         rowInfo.spacings[row] = QLayoutParameter<qreal>();

   825     invalidate();

   826 }

   827 

   828 qreal QGridLayoutEngine::rowSpacing(int row, Qt::Orientation orientation) const

   829 {

   830     QLayoutParameter<qreal> spacing = q_infos[orientation == Qt::Vertical].spacings.value(row);

   831     if (!spacing.isDefault())

   832         return spacing.value();

   833     return q_defaultSpacings[orientation == Qt::Vertical].value();

   834 }

   835 

   836 void QGridLayoutEngine::setRowStretchFactor(int row, int stretch, Qt::Orientation orientation)

   837 {

   838     Q_ASSERT(row >= 0);

   839     Q_ASSERT(stretch >= 0);

   840 

   841     maybeExpandGrid(row, -1, orientation);

   842 

   843     QGridLayoutRowInfo &rowInfo = q_infos[orientation == Qt::Vertical];

   844     if (row >= rowInfo.stretches.count())

   845         rowInfo.stretches.resize(row + 1);

   846     rowInfo.stretches[row].setUserValue(stretch);

   847 }

   848 

   849 int QGridLayoutEngine::rowStretchFactor(int row, Qt::Orientation orientation) const

   850 {

   851     QStretchParameter stretch = q_infos[orientation == Qt::Vertical].stretches.value(row);

   852     if (!stretch.isDefault())

   853         return stretch.value();

   854     return 0;

   855 }

   856 

   857 void QGridLayoutEngine::setStretchFactor(QGraphicsLayoutItem *layoutItem, int stretch,

   858                                          Qt::Orientation orientation)

   859 {

   860     Q_ASSERT(stretch >= 0);

   861 

   862     if (QGridLayoutItem *item = findLayoutItem(layoutItem))

   863         item->setStretchFactor(stretch, orientation);

   864 }

   865 

   866 int QGridLayoutEngine::stretchFactor(QGraphicsLayoutItem *layoutItem, Qt::Orientation orientation) const

   867 {

   868     if (QGridLayoutItem *item = findLayoutItem(layoutItem))

   869         return item->stretchFactor(orientation);

   870     return 0;

   871 }

   872 

   873 void QGridLayoutEngine::setRowSizeHint(Qt::SizeHint which, int row, qreal size,

   874                                        Qt::Orientation orientation)

   875 {

   876     Q_ASSERT(row >= 0);

   877     Q_ASSERT(size >= 0.0);

   878 

   879     maybeExpandGrid(row, -1, orientation);

   880 

   881     QGridLayoutRowInfo &rowInfo = q_infos[orientation == Qt::Vertical];

   882     if (row >= rowInfo.boxes.count())

   883         rowInfo.boxes.resize(row + 1);

   884     rowInfo.boxes[row].q_sizes(which) = size;

   885 }

   886 

   887 qreal QGridLayoutEngine::rowSizeHint(Qt::SizeHint which, int row, Qt::Orientation orientation) const

   888 {

   889     return q_infos[orientation == Qt::Vertical].boxes.value(row).q_sizes(which);

   890 }

   891 

   892 void QGridLayoutEngine::setRowAlignment(int row, Qt::Alignment alignment,

   893                                         Qt::Orientation orientation)

   894 {

   895     Q_ASSERT(row >= 0);

   896 

   897     maybeExpandGrid(row, -1, orientation);

   898 

   899     QGridLayoutRowInfo &rowInfo = q_infos[orientation == Qt::Vertical];

   900     if (row >= rowInfo.alignments.count())

   901         rowInfo.alignments.resize(row + 1);

   902     rowInfo.alignments[row] = alignment;

   903 }

   904 

   905 Qt::Alignment QGridLayoutEngine::rowAlignment(int row, Qt::Orientation orientation) const

   906 {

   907     Q_ASSERT(row >= 0);

   908     return q_infos[orientation == Qt::Vertical].alignments.value(row);

   909 }

   910 

   911 void QGridLayoutEngine::setAlignment(QGraphicsLayoutItem *layoutItem, Qt::Alignment alignment)

   912 {

   913     if (QGridLayoutItem *item = findLayoutItem(layoutItem))

   914         item->setAlignment(alignment);

   915     invalidate();

   916 }

   917 

   918 Qt::Alignment QGridLayoutEngine::alignment(QGraphicsLayoutItem *layoutItem) const

   919 {

   920     if (QGridLayoutItem *item = findLayoutItem(layoutItem))

   921         return item->alignment();

   922     return 0;

   923 }

   924 

   925 Qt::Alignment QGridLayoutEngine::effectiveAlignment(const QGridLayoutItem *layoutItem) const

   926 {

   927     Qt::Alignment align = layoutItem->alignment();

   928     if (!(align & Qt::AlignVertical_Mask)) {

   929         // no vertical alignment, respect the row alignment

   930         int y = layoutItem->firstRow();

   931         align |= (rowAlignment(y, Qt::Vertical) & Qt::AlignVertical_Mask);

   932     }

   933     if (!(align & Qt::AlignHorizontal_Mask)) {

   934         // no horizontal alignment, respect the column alignment

   935         int x = layoutItem->firstColumn();

   936         align |= (rowAlignment(x, Qt::Horizontal) & Qt::AlignHorizontal_Mask);

   937     }

   938     return align;

   939 }

   940 

   941 /*!

   942     \internal

   943     The \a index is only used by QGraphicsLinearLayout to ensure that itemAt() reflects the order

   944     of visual arrangement. Strictly speaking it does not have to, but most people expect it to.

   945     (And if it didn't we would have to add itemArrangedAt(int index) or something..)

   946  */

   947 void QGridLayoutEngine::insertItem(QGridLayoutItem *item, int index)

   948 {

   949     maybeExpandGrid(item->lastRow(), item->lastColumn());

   950 

   951     if (index == -1)

   952         q_items.append(item);

   953     else

   954         q_items.insert(index, item);

   955 

   956     for (int i = item->firstRow(); i <= item->lastRow(); ++i) {

   957         for (int j = item->firstColumn(); j <= item->lastColumn(); ++j) {

   958             if (itemAt(i, j))

   959                 qWarning("QGridLayoutEngine::addItem: Cell (%d, %d) already taken", i, j);

   960             setItemAt(i, j, item);

   961         }

   962     }

   963 }

   964 

   965 void QGridLayoutEngine::addItem(QGridLayoutItem *item)

   966 {

   967     insertItem(item, -1);

   968 }

   969 

   970 void QGridLayoutEngine::removeItem(QGridLayoutItem *item)

   971 {

   972     Q_ASSERT(q_items.contains(item));

   973 

   974     invalidate();

   975 

   976     for (int i = item->firstRow(); i <= item->lastRow(); ++i) {

   977         for (int j = item->firstColumn(); j <= item->lastColumn(); ++j) {

   978             if (itemAt(i, j) == item)

   979                 setItemAt(i, j, 0);

   980         }

   981     }

   982 

   983     q_items.removeAll(item);

   984 }

   985 

   986 QGridLayoutItem *QGridLayoutEngine::findLayoutItem(QGraphicsLayoutItem *layoutItem) const

   987 {

   988     for (int i = q_items.count() - 1; i >= 0; --i) {

   989         QGridLayoutItem *item = q_items.at(i);

   990         if (item->layoutItem() == layoutItem)

   991             return item;

   992     }

   993     return 0;

   994 }

   995 

   996 QGridLayoutItem *QGridLayoutEngine::itemAt(int row, int column, Qt::Orientation orientation) const

   997 {

   998     if (orientation == Qt::Horizontal)

   999         qSwap(row, column);

  1000     if (uint(row) >= uint(rowCount()) || uint(column) >= uint(columnCount()))

  1001         return 0;

  1002     return q_grid.at((row * internalGridColumnCount()) + column);

  1003 }

  1004 

  1005 void QGridLayoutEngine::invalidate()

  1006 {

  1007     q_cachedEffectiveFirstRows[Hor] = -1;

  1008     q_cachedEffectiveFirstRows[Ver] = -1;

  1009     q_cachedEffectiveLastRows[Hor] = -1;

  1010     q_cachedEffectiveLastRows[Ver] = -1;

  1011     q_cachedDataForStyleInfo.invalidate();

  1012     q_cachedSize = QSizeF();

  1013 }

  1014 

  1015 static void visualRect(QRectF *geom, Qt::LayoutDirection dir, const QRectF &contentsRect)

  1016 {

  1017     if (dir == Qt::RightToLeft)

  1018         geom->moveRight(contentsRect.right() - (geom->left() - contentsRect.left()));

  1019 }

  1020 

  1021 void QGridLayoutEngine::setGeometries(const QLayoutStyleInfo &styleInfo,

  1022                                       const QRectF &contentsGeometry)

  1023 {

  1024     if (rowCount() < 1 || columnCount() < 1)

  1025         return;

  1026 

  1027     ensureGeometries(styleInfo, contentsGeometry.size());

  1028 

  1029     for (int i = q_items.count() - 1; i >= 0; --i) {

  1030         QGridLayoutItem *item = q_items.at(i);

  1031 

  1032         qreal x = q_xx[item->firstColumn()];

  1033         qreal y = q_yy[item->firstRow()];

  1034         qreal width = q_widths[item->lastColumn()];

  1035         qreal height = q_heights[item->lastRow()];

  1036 

  1037         if (item->columnSpan() != 1)

  1038             width += q_xx[item->lastColumn()] - x;

  1039         if (item->rowSpan() != 1)

  1040             height += q_yy[item->lastRow()] - y;

  1041 

  1042         QRectF geom = item->geometryWithin(contentsGeometry.x() + x, contentsGeometry.y() + y,

  1043                                                width, height, q_descents[item->lastRow()]);

  1044         visualRect(&geom, visualDirection(), contentsGeometry);

  1045         item->setGeometry(geom);

  1046     }

  1047 }

  1048 

  1049 // ### candidate for deletion

  1050 QRectF QGridLayoutEngine::cellRect(const QLayoutStyleInfo &styleInfo,

  1051                                    const QRectF &contentsGeometry, int row, int column, int rowSpan,

  1052                                    int columnSpan) const

  1053 {

  1054     if (uint(row) >= uint(rowCount()) || uint(column) >= uint(columnCount())

  1055             || rowSpan < 1 || columnSpan < 1)

  1056         return QRectF();

  1057 

  1058     ensureGeometries(styleInfo, contentsGeometry.size());

  1059 

  1060     int lastColumn = qMax(column + columnSpan, columnCount()) - 1;

  1061     int lastRow = qMax(row + rowSpan, rowCount()) - 1;

  1062 

  1063     qreal x = q_xx[column];

  1064     qreal y = q_yy[row];

  1065     qreal width = q_widths[lastColumn];

  1066     qreal height = q_heights[lastRow];

  1067 

  1068     if (columnSpan != 1)

  1069         width += q_xx[lastColumn] - x;

  1070     if (rowSpan != 1)

  1071         height += q_yy[lastRow] - y;

  1072 

  1073     return QRectF(contentsGeometry.x() + x, contentsGeometry.y() + y, width, height);

  1074 }

  1075 

  1076 QSizeF QGridLayoutEngine::sizeHint(const QLayoutStyleInfo &styleInfo, Qt::SizeHint which,

  1077                                    const QSizeF & /* constraint */) const

  1078 {

  1079     ensureColumnAndRowData(styleInfo);

  1080 

  1081     switch (which) {

  1082     case Qt::MinimumSize:

  1083         return QSizeF(q_totalBoxes[Hor].q_minimumSize, q_totalBoxes[Ver].q_minimumSize);

  1084     case Qt::PreferredSize:

  1085         return QSizeF(q_totalBoxes[Hor].q_preferredSize, q_totalBoxes[Ver].q_preferredSize);

  1086     case Qt::MaximumSize:

  1087         return QSizeF(q_totalBoxes[Hor].q_maximumSize, q_totalBoxes[Ver].q_maximumSize);

  1088     case Qt::MinimumDescent:

  1089         return QSizeF(-1.0, q_totalBoxes[Hor].q_minimumDescent);    // ### doesn't work

  1090     default:

  1091         break;

  1092     }

  1093     return QSizeF();

  1094 }

  1095 

  1096 QSizePolicy::ControlTypes QGridLayoutEngine::controlTypes(LayoutSide side) const

  1097 {

  1098     Qt::Orientation orientation = (side == Top || side == Bottom) ? Qt::Vertical : Qt::Horizontal;

  1099     int row = (side == Top || side == Left) ? effectiveFirstRow(orientation)

  1100                                             : effectiveLastRow(orientation);

  1101     QSizePolicy::ControlTypes result = 0;

  1102 

  1103     for (int column = columnCount(orientation) - 1; column >= 0; --column) {

  1104         if (QGridLayoutItem *item = itemAt(row, column, orientation))

  1105             result |= item->controlTypes(side);

  1106     }

  1107     return result;

  1108 }

  1109 

  1110 void QGridLayoutEngine::transpose()

  1111 {

  1112     invalidate();

  1113 

  1114     for (int i = q_items.count() - 1; i >= 0; --i)

  1115         q_items.at(i)->transpose();

  1116 

  1117     qSwap(q_defaultSpacings[Hor], q_defaultSpacings[Ver]);

  1118     qSwap(q_infos[Hor], q_infos[Ver]);

  1119 

  1120     regenerateGrid();

  1121 }

  1122 

  1123 void QGridLayoutEngine::setVisualDirection(Qt::LayoutDirection direction)

  1124 {

  1125     m_visualDirection = direction;

  1126 }

  1127 

  1128 Qt::LayoutDirection QGridLayoutEngine::visualDirection() const

  1129 {

  1130     return m_visualDirection;

  1131 }

  1132 

  1133 #ifdef QT_DEBUG

  1134 void QGridLayoutEngine::dump(int indent) const

  1135 {