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 Qt Designer of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qlayout_widget_p.h"

    43 #include "qdesigner_utils_p.h"

    44 #include "layout_p.h"

    45 #include "layoutinfo_p.h"

    46 #include "invisible_widget_p.h"

    47 #include "qdesigner_widgetitem_p.h"

    48 

    49 #include <QtDesigner/QDesignerFormWindowInterface>

    50 #include <QtDesigner/QExtensionManager>

    51 #include <QtDesigner/QDesignerFormEditorInterface>

    52 #include <QtDesigner/QDesignerPropertySheetExtension>

    53 #include <QtDesigner/QDesignerWidgetFactoryInterface>

    54 

    55 #include <QtGui/QPainter>

    56 #include <QtGui/QHBoxLayout>

    57 #include <QtGui/QVBoxLayout>

    58 #include <QtGui/QGridLayout>

    59 #include <QtGui/QFormLayout>

    60 #include <QtGui/qevent.h>

    61 

    62 #include <QtCore/qdebug.h>

    63 #include <QtCore/QtAlgorithms>

    64 #include <QtCore/QMap>

    65 #include <QtCore/QStack>

    66 #include <QtCore/QPair>

    67 #include <QtCore/QSet>

    68 

    69 enum { ShiftValue = 1 };

    70 enum { debugLayout = 0 };

    71 enum { FormLayoutColumns = 2 };

    72 enum { indicatorSize = 2 };

    73 // Grid/form Helpers: get info (overloads to make templates work)

    74 

    75 namespace { // Do not use static, will break HP-UX due to templates

    76 

    77 QT_USE_NAMESPACE

    78 

    79 // overloads to make templates over QGridLayout/QFormLayout work

    80 inline int gridRowCount(const QGridLayout *gridLayout)

    81 {

    82     return  gridLayout->rowCount();

    83 }

    84 

    85 inline int gridColumnCount(const QGridLayout *gridLayout)

    86 {

    87     return  gridLayout->columnCount();

    88 }

    89 

    90 // QGridLayout/QFormLayout Helpers: get item position (overloads to make templates work)

    91 inline void getGridItemPosition(QGridLayout *gridLayout, int index,

    92     int *row, int *column, int *rowspan, int *colspan)

    93 {

    94     gridLayout->getItemPosition(index, row, column, rowspan, colspan);

    95 }

    96 

    97 QRect gridItemInfo(QGridLayout *grid, int index)

    98 {

    99     int row, column, rowSpan, columnSpan;

   100     // getItemPosition is not const, grmbl..

   101     grid->getItemPosition(index, &row, &column, &rowSpan, &columnSpan);

   102     return QRect(column, row, columnSpan, rowSpan);

   103 }

   104 

   105 inline int gridRowCount(const QFormLayout *formLayout)    { return  formLayout->rowCount(); }

   106 inline int gridColumnCount(const QFormLayout *) { return FormLayoutColumns; }

   107 

   108 inline void getGridItemPosition(QFormLayout *formLayout, int index, int *row, int *column, int *rowspan, int *colspan)

   109 {

   110     qdesigner_internal::getFormLayoutItemPosition(formLayout, index, row, column, rowspan, colspan);

   111 }

   112 

   113 QRect gridItemInfo(const QFormLayout *form, int index)

   114 {

   115     int row;

   116     int column;

   117     int colspan;

   118     qdesigner_internal::getFormLayoutItemPosition(form, index, &row, &column, 0, &colspan);

   119     return QRect(column, row, colspan, 1);

   120 }

   121 } // namespace anonymous

   122 

   123 QT_BEGIN_NAMESPACE

   124 

   125 static const char *objectNameC = "objectName";

   126 static const char *sizeConstraintC = "sizeConstraint";

   127 

   128 /* A padding spacer element that is used to represent an empty form layout cell. It should grow with its cell.

   129  * Should not be used on a grid as it causes resizing inconsistencies */

   130 namespace qdesigner_internal {

   131     class PaddingSpacerItem : public QSpacerItem {

   132     public:

   133         PaddingSpacerItem() : QSpacerItem(0, 0, QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding) {}

   134         virtual Qt::Orientations expandingDirections () const { return Qt::Vertical | Qt::Horizontal; }

   135     };

   136 }

   137 

   138 static inline QSpacerItem *createGridSpacer()

   139 {

   140     return new QSpacerItem(0, 0);

   141 }

   142 

   143 static inline QSpacerItem *createFormSpacer()

   144 {

   145     return new qdesigner_internal::PaddingSpacerItem;

   146 }

   147 

   148 // QGridLayout/QFormLayout Helpers: Debug items of GridLikeLayout

   149 template <class GridLikeLayout>

   150 static QDebug debugGridLikeLayout(QDebug str, const GridLikeLayout &gl)

   151 {

   152     const int count = gl.count();

   153     str << "Grid: " << gl.objectName() <<   gridRowCount(&gl) << " rows x " <<  gridColumnCount(&gl)

   154         << " cols " << count << " items\n";

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

   156         QLayoutItem *item = gl.itemAt(i);

   157         str << "Item " << i << item << item->widget() << gridItemInfo(const_cast<GridLikeLayout *>(&gl), i) << " empty=" << qdesigner_internal::LayoutInfo::isEmptyItem(item) << "\n";

   158     }

   159     return str;

   160 }

   161 

   162 static inline QDebug operator<<(QDebug str, const QGridLayout &gl) { return debugGridLikeLayout(str, gl); }

   163 static inline QDebug operator<<(QDebug str, const QFormLayout &fl) { return debugGridLikeLayout(str, fl); }

   164 

   165 static inline bool isEmptyFormLayoutRow(const QFormLayout *fl, int row)

   166 {

   167     // Spanning can never be empty

   168     if (fl->itemAt(row, QFormLayout::SpanningRole))

   169         return false;

   170     return qdesigner_internal::LayoutInfo::isEmptyItem(fl->itemAt(row, QFormLayout::LabelRole)) && qdesigner_internal::LayoutInfo::isEmptyItem(fl->itemAt(row, QFormLayout::FieldRole));

   171 }

   172 

   173 static inline bool canSimplifyFormLayout(const QFormLayout *formLayout, const QRect &restrictionArea)

   174 {

   175     if (restrictionArea.x() >= FormLayoutColumns)

   176         return false;

   177     // Try to find empty rows

   178     const int bottomCheckRow = qMin(formLayout->rowCount(), restrictionArea.top() + restrictionArea.height());

   179     for (int r = restrictionArea.y(); r < bottomCheckRow; r++)

   180         if (isEmptyFormLayoutRow(formLayout, r))

   181             return true;

   182     return false;

   183 }

   184 

   185 // recreate a managed layout (which does not automagically remove

   186 // empty rows/columns like grid or form layout) in case it needs to shrink

   187 

   188 static QLayout *recreateManagedLayout(const QDesignerFormEditorInterface *core, QWidget *w, QLayout *lt)

   189 {

   190     const qdesigner_internal::LayoutInfo::Type t = qdesigner_internal::LayoutInfo::layoutType(core, lt);

   191     qdesigner_internal::LayoutProperties properties;

   192     const int mask = properties.fromPropertySheet(core, lt, qdesigner_internal::LayoutProperties::AllProperties);

   193     qdesigner_internal::LayoutInfo::deleteLayout(core, w);

   194     QLayout *rc = core->widgetFactory()->createLayout(w, 0, t);

   195     properties.toPropertySheet(core, rc, mask, true);

   196     return rc;

   197 }

   198 

   199 // QGridLayout/QFormLayout Helpers: find an item on a form/grid. Return index

   200 template <class GridLikeLayout>

   201 int findGridItemAt(GridLikeLayout *gridLayout, int at_row, int at_column)

   202 {

   203     Q_ASSERT(gridLayout);

   204     const int count = gridLayout->count();

   205     for (int index = 0; index <  count; index++) {

   206         int row, column, rowspan, colspan;

   207         getGridItemPosition(gridLayout, index, &row, &column, &rowspan, &colspan);

   208         if (at_row >= row && at_row < (row + rowspan)

   209             && at_column >= column && at_column < (column + colspan)) {

   210             return index;

   211         }

   212     }

   213     return -1;

   214 }

   215 // QGridLayout/QFormLayout  Helpers: remove dummy spacers on form/grid

   216 template <class GridLikeLayout>

   217 static bool removeEmptyCellsOnGrid(GridLikeLayout *grid, const QRect &area)

   218 {

   219     // check if there are any items in the way. Should be only spacers

   220     // Unique out items that span rows/columns.

   221     QVector<int> indexesToBeRemoved;

   222     indexesToBeRemoved.reserve(grid->count());

   223     const int rightColumn = area.x() + area.width();

   224     const int bottomRow = area.y() + area.height();

   225     for (int c = area.x(); c < rightColumn; c++)

   226         for (int r = area.y(); r < bottomRow; r++) {

   227             const int index = findGridItemAt(grid, r ,c);

   228             if (index != -1)

   229                 if (QLayoutItem *item = grid->itemAt(index)) {

   230                     if (qdesigner_internal::LayoutInfo::isEmptyItem(item)) {

   231                         if (indexesToBeRemoved.indexOf(index) == -1)

   232                             indexesToBeRemoved.push_back(index);

   233                     } else {

   234                         return false;

   235                     }

   236                 }

   237         }

   238     // remove, starting from last

   239     if (!indexesToBeRemoved.empty()) {

   240         qStableSort(indexesToBeRemoved.begin(), indexesToBeRemoved.end());

   241         for (int i = indexesToBeRemoved.size() - 1; i >= 0; i--)

   242             delete grid->takeAt(indexesToBeRemoved[i]);

   243     }

   244     return true;

   245 }

   246 

   247 namespace qdesigner_internal {

   248 // --------- LayoutProperties

   249 

   250 LayoutProperties::LayoutProperties()

   251 {

   252     clear();

   253 }

   254 

   255 void LayoutProperties::clear()

   256 {

   257     qFill(m_margins, m_margins + MarginCount, 0);

   258     qFill(m_marginsChanged, m_marginsChanged + MarginCount, false);

   259     qFill(m_spacings, m_spacings + SpacingsCount, 0);

   260     qFill(m_spacingsChanged, m_spacingsChanged + SpacingsCount, false);

   261 

   262     m_objectName = QVariant();

   263     m_objectNameChanged = false;

   264     m_sizeConstraint = QVariant(QLayout::SetDefaultConstraint);

   265     m_sizeConstraintChanged = false;

   266 

   267     m_fieldGrowthPolicyChanged = m_rowWrapPolicyChanged =  m_labelAlignmentChanged = m_formAlignmentChanged = false;

   268     m_fieldGrowthPolicy =  m_rowWrapPolicy =  m_formAlignment = QVariant();

   269 

   270     m_boxStretchChanged = m_gridRowStretchChanged = m_gridColumnStretchChanged = m_gridRowMinimumHeightChanged = false;

   271     m_boxStretch = m_gridRowStretch =  m_gridColumnStretch =  m_gridRowMinimumHeight = QVariant();

   272 }

   273 

   274 int LayoutProperties::visibleProperties(const  QLayout *layout)

   275 {

   276     // Grid like layout have 2 spacings.

   277     const bool isFormLayout = qobject_cast<const QFormLayout*>(layout);

   278     const bool isGridLike = qobject_cast<const QGridLayout*>(layout) || isFormLayout;

   279     int rc = ObjectNameProperty|LeftMarginProperty|TopMarginProperty|RightMarginProperty|BottomMarginProperty|

   280              SizeConstraintProperty;

   281 

   282     rc |= isGridLike ? (HorizSpacingProperty|VertSpacingProperty) : SpacingProperty;

   283     if (isFormLayout) {

   284         rc |= FieldGrowthPolicyProperty|RowWrapPolicyProperty|LabelAlignmentProperty|FormAlignmentProperty;

   285     } else {

   286         if (isGridLike) {

   287             rc |=  GridRowStretchProperty|GridColumnStretchProperty|GridRowMinimumHeightProperty|GridColumnMinimumWidthProperty;

   288         } else {

   289             rc |=  BoxStretchProperty;

   290         }

   291     }

   292     return rc;

   293 }

   294 

   295 static const char *marginPropertyNamesC[] = {"leftMargin", "topMargin", "rightMargin", "bottomMargin"};

   296 static const char *spacingPropertyNamesC[] = {"spacing", "horizontalSpacing", "verticalSpacing" };

   297 static const char *fieldGrowthPolicyPropertyC = "fieldGrowthPolicy";

   298 static const char *rowWrapPolicyPropertyC = "rowWrapPolicy";

   299 static const char *labelAlignmentPropertyC = "labelAlignment";

   300 static const char *formAlignmentPropertyC = "formAlignment";

   301 static const char *boxStretchPropertyC = "stretch";

   302 static const char *gridRowStretchPropertyC = "rowStretch";

   303 static const char *gridColumnStretchPropertyC = "columnStretch";

   304 static const char *gridRowMinimumHeightPropertyC = "rowMinimumHeight";

   305 static const char *gridColumnMinimumWidthPropertyC = "columnMinimumWidth";

   306 

   307 static bool intValueFromSheet(const QDesignerPropertySheetExtension *sheet, const QString &name, int *value, bool *changed)

   308 {

   309     const int sheetIndex = sheet->indexOf(name);

   310     if (sheetIndex == -1)

   311         return false;

   312     *value = sheet->property(sheetIndex).toInt();

   313     *changed = sheet->isChanged(sheetIndex);

   314     return true;

   315 }

   316 

   317 static void variantPropertyFromSheet(int mask, int flag, const QDesignerPropertySheetExtension *sheet, const QString &name,

   318                                      QVariant *value, bool *changed, int *returnMask)

   319 {

   320     if (mask & flag) {

   321         const int sIndex = sheet->indexOf(name);

   322         if (sIndex != -1) {

   323             *value = sheet->property(sIndex);

   324             *changed = sheet->isChanged(sIndex);

   325             *returnMask |= flag;

   326         }

   327     }

   328 }

   329 

   330 int LayoutProperties::fromPropertySheet(const QDesignerFormEditorInterface *core, QLayout *l, int mask)

   331 {

   332     int rc = 0;

   333     const QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(core->extensionManager(), l);

   334     Q_ASSERT(sheet);

   335     // name

   336     if (mask & ObjectNameProperty) {

   337         const int nameIndex = sheet->indexOf(QLatin1String(objectNameC));

   338         Q_ASSERT(nameIndex != -1);

   339         m_objectName = sheet->property(nameIndex);

   340         m_objectNameChanged =  sheet->isChanged(nameIndex);

   341         rc |= ObjectNameProperty;

   342     }

   343     // -- Margins

   344     const int marginFlags[MarginCount] = { LeftMarginProperty, TopMarginProperty, RightMarginProperty, BottomMarginProperty};

   345     for (int i = 0; i < MarginCount; i++)

   346         if (mask & marginFlags[i])

   347             if (intValueFromSheet(sheet, QLatin1String(marginPropertyNamesC[i]), m_margins + i, m_marginsChanged + i))

   348                 rc |= marginFlags[i];

   349 

   350     const int spacingFlags[] = { SpacingProperty, HorizSpacingProperty, VertSpacingProperty};

   351     for (int i = 0; i < SpacingsCount; i++)

   352         if (mask & spacingFlags[i])

   353             if (intValueFromSheet(sheet, QLatin1String(spacingPropertyNamesC[i]), m_spacings + i, m_spacingsChanged + i))

   354                 rc |= spacingFlags[i];

   355     // sizeConstraint, flags

   356     variantPropertyFromSheet(mask, SizeConstraintProperty, sheet, QLatin1String(sizeConstraintC), &m_sizeConstraint, &m_sizeConstraintChanged, &rc);

   357     variantPropertyFromSheet(mask, FieldGrowthPolicyProperty, sheet, QLatin1String(fieldGrowthPolicyPropertyC), &m_fieldGrowthPolicy, &m_fieldGrowthPolicyChanged, &rc);

   358     variantPropertyFromSheet(mask, RowWrapPolicyProperty, sheet, QLatin1String(rowWrapPolicyPropertyC), &m_rowWrapPolicy, &m_rowWrapPolicyChanged, &rc);

   359     variantPropertyFromSheet(mask, LabelAlignmentProperty, sheet, QLatin1String(labelAlignmentPropertyC), &m_labelAlignment, &m_labelAlignmentChanged, &rc);

   360     variantPropertyFromSheet(mask, FormAlignmentProperty, sheet, QLatin1String(formAlignmentPropertyC), &m_formAlignment, &m_formAlignmentChanged, &rc);

   361     variantPropertyFromSheet(mask, BoxStretchProperty, sheet, QLatin1String(boxStretchPropertyC), &m_boxStretch, & m_boxStretchChanged, &rc);

   362     variantPropertyFromSheet(mask, GridRowStretchProperty, sheet, QLatin1String(gridRowStretchPropertyC), &m_gridRowStretch, &m_gridRowStretchChanged, &rc);

   363     variantPropertyFromSheet(mask, GridColumnStretchProperty, sheet, QLatin1String(gridColumnStretchPropertyC), &m_gridColumnStretch, &m_gridColumnStretchChanged, &rc);

   364     variantPropertyFromSheet(mask, GridRowMinimumHeightProperty, sheet, QLatin1String(gridRowMinimumHeightPropertyC), &m_gridRowMinimumHeight, &m_gridRowMinimumHeightChanged, &rc);

   365     variantPropertyFromSheet(mask, GridColumnMinimumWidthProperty, sheet, QLatin1String(gridColumnMinimumWidthPropertyC), &m_gridColumnMinimumWidth, &m_gridColumnMinimumWidthChanged, &rc);

   366     return rc;

   367 }

   368 

   369 static bool intValueToSheet(QDesignerPropertySheetExtension *sheet, const QString &name, int value, bool changed, bool applyChanged)

   370 

   371 {

   372 

   373     const int sheetIndex = sheet->indexOf(name);

   374     if (sheetIndex == -1) {

   375         qWarning() << " LayoutProperties: Attempt to set property " << name << " that does not exist for the layout.";

   376         return false;

   377     }

   378     sheet->setProperty(sheetIndex, QVariant(value));

   379     if (applyChanged)

   380         sheet->setChanged(sheetIndex, changed);

   381     return true;

   382 }

   383 

   384 static void variantPropertyToSheet(int mask, int flag, bool applyChanged, QDesignerPropertySheetExtension *sheet, const QString &name,

   385                                    const QVariant &value, bool changed, int *returnMask)

   386 {

   387     if (mask & flag) {

   388         const int sIndex = sheet->indexOf(name);

   389         if (sIndex != -1) {

   390             sheet->setProperty(sIndex, value);

   391             if (applyChanged)

   392                 sheet->setChanged(sIndex, changed);

   393             *returnMask |= flag;

   394         }

   395     }

   396 }

   397 

   398 int LayoutProperties::toPropertySheet(const QDesignerFormEditorInterface *core, QLayout *l, int mask, bool applyChanged) const

   399 {

   400     int rc = 0;

   401     QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(core->extensionManager(), l);

   402     Q_ASSERT(sheet);

   403     // name

   404     if (mask & ObjectNameProperty) {

   405         const int nameIndex = sheet->indexOf(QLatin1String(objectNameC));

   406         Q_ASSERT(nameIndex != -1);

   407         sheet->setProperty(nameIndex, m_objectName);

   408         if (applyChanged)

   409            sheet->setChanged(nameIndex, m_objectNameChanged);

   410         rc |= ObjectNameProperty;

   411     }

   412     // margins

   413     const int marginFlags[MarginCount] = { LeftMarginProperty, TopMarginProperty, RightMarginProperty, BottomMarginProperty};

   414     for (int i = 0; i < MarginCount; i++)

   415         if (mask & marginFlags[i])

   416             if (intValueToSheet(sheet, QLatin1String(marginPropertyNamesC[i]), m_margins[i], m_marginsChanged[i], applyChanged))

   417                 rc |= marginFlags[i];

   418 

   419     const int spacingFlags[] = { SpacingProperty, HorizSpacingProperty, VertSpacingProperty};

   420     for (int i = 0; i < SpacingsCount; i++)

   421         if (mask & spacingFlags[i])

   422             if (intValueToSheet(sheet, QLatin1String(spacingPropertyNamesC[i]), m_spacings[i], m_spacingsChanged[i], applyChanged))

   423                 rc |= spacingFlags[i];

   424     // sizeConstraint

   425     variantPropertyToSheet(mask, SizeConstraintProperty, applyChanged, sheet, QLatin1String(sizeConstraintC), m_sizeConstraint, m_sizeConstraintChanged, &rc);

   426     variantPropertyToSheet(mask, FieldGrowthPolicyProperty, applyChanged, sheet, QLatin1String(fieldGrowthPolicyPropertyC), m_fieldGrowthPolicy, &m_fieldGrowthPolicyChanged, &rc);

   427     variantPropertyToSheet(mask, RowWrapPolicyProperty, applyChanged, sheet, QLatin1String(rowWrapPolicyPropertyC), m_rowWrapPolicy, m_rowWrapPolicyChanged, &rc);

   428     variantPropertyToSheet(mask, LabelAlignmentProperty, applyChanged, sheet, QLatin1String(labelAlignmentPropertyC), m_labelAlignment, m_labelAlignmentChanged, &rc);

   429     variantPropertyToSheet(mask, FormAlignmentProperty, applyChanged, sheet, QLatin1String(formAlignmentPropertyC), m_formAlignment, m_formAlignmentChanged, &rc);

   430     variantPropertyToSheet(mask, BoxStretchProperty, applyChanged, sheet, QLatin1String(boxStretchPropertyC), m_boxStretch, m_boxStretchChanged, &rc);

   431     variantPropertyToSheet(mask, GridRowStretchProperty, applyChanged, sheet, QLatin1String(gridRowStretchPropertyC), m_gridRowStretch, m_gridRowStretchChanged, &rc);

   432     variantPropertyToSheet(mask, GridColumnStretchProperty, applyChanged, sheet, QLatin1String(gridColumnStretchPropertyC), m_gridColumnStretch, m_gridColumnStretchChanged, &rc);

   433     variantPropertyToSheet(mask, GridRowMinimumHeightProperty, applyChanged, sheet, QLatin1String(gridRowMinimumHeightPropertyC), m_gridRowMinimumHeight, m_gridRowMinimumHeightChanged, &rc);

   434     variantPropertyToSheet(mask, GridColumnMinimumWidthProperty, applyChanged, sheet, QLatin1String(gridColumnMinimumWidthPropertyC), m_gridColumnMinimumWidth, m_gridColumnMinimumWidthChanged, &rc);

   435     return rc;

   436 }

   437 

   438 // ---------------- LayoutHelper

   439 LayoutHelper::LayoutHelper()

   440 {

   441 }

   442 

   443 LayoutHelper::~LayoutHelper()

   444 {

   445 }

   446 

   447 int LayoutHelper::indexOf(const QLayout *lt, const QWidget *widget)

   448 {

   449     if (!lt)

   450         return -1;

   451 

   452     const int itemCount = lt->count();

   453     for (int i = 0; i < itemCount; i++)

   454         if (lt->itemAt(i)->widget() == widget)

   455             return i;

   456     return -1;

   457 }

   458 

   459 QRect LayoutHelper::itemInfo(QLayout *lt, const QWidget *widget) const

   460 {

   461     const int index = indexOf(lt, widget);

   462     if (index == -1) {

   463         qWarning() << "LayoutHelper::itemInfo: " << widget << " not in layout " << lt;

   464         return QRect(0, 0, 1, 1);

   465     }

   466     return itemInfo(lt, index);

   467 }

   468 

   469     // ---------------- BoxLayoutHelper

   470     class BoxLayoutHelper : public  LayoutHelper {

   471     public:

   472         BoxLayoutHelper(const Qt::Orientation orientation) : m_orientation(orientation) {}

   473 

   474         virtual QRect itemInfo(QLayout *lt, int index) const;

   475         virtual void insertWidget(QLayout *lt, const QRect &info, QWidget *w);

   476         virtual void removeWidget(QLayout *lt, QWidget *widget);

   477         virtual void replaceWidget(QLayout *lt, QWidget *before, QWidget *after);

   478 

   479         virtual void pushState(const QDesignerFormEditorInterface *, const QWidget *);

   480         virtual void popState(const QDesignerFormEditorInterface *, QWidget *);

   481 

   482         virtual bool canSimplify(const QDesignerFormEditorInterface *, const QWidget *, const QRect &) const { return  false; }

   483         virtual void simplify(const QDesignerFormEditorInterface *, QWidget *, const QRect &) {}

   484 

   485         // Helper for restoring layout states

   486         typedef QVector <QLayoutItem *> LayoutItemVector;

   487         static LayoutItemVector disassembleLayout(QLayout *lt);

   488         static QLayoutItem *findItemOfWidget(const LayoutItemVector &lv, QWidget *w);

   489 

   490     private:

   491         typedef QVector<QWidget *> BoxLayoutState;

   492 

   493         static BoxLayoutState state(const QBoxLayout*lt);

   494 

   495         QStack<BoxLayoutState> m_states;

   496         const Qt::Orientation m_orientation;

   497     };

   498 

   499     QRect BoxLayoutHelper::itemInfo(QLayout * /*lt*/, int index) const

   500     {

   501         return m_orientation == Qt::Horizontal ?  QRect(index, 0, 1, 1) : QRect(0, index, 1, 1);

   502     }

   503 

   504     void BoxLayoutHelper::insertWidget(QLayout *lt, const QRect &info, QWidget *w)

   505     {

   506         QDesignerWidgetItemInstaller wii; // Make sure we use QDesignerWidgetItem.

   507         QBoxLayout *boxLayout = qobject_cast<QBoxLayout *>(lt);

   508         Q_ASSERT(boxLayout);

   509         boxLayout->insertWidget(m_orientation == Qt::Horizontal ? info.x() : info.y(), w);

   510     }

   511 

   512     void BoxLayoutHelper::removeWidget(QLayout *lt, QWidget *widget)

   513     {

   514         QBoxLayout *boxLayout = qobject_cast<QBoxLayout *>(lt);

   515         Q_ASSERT(boxLayout);

   516         boxLayout->removeWidget(widget);

   517     }

   518 

   519     void BoxLayoutHelper::replaceWidget(QLayout *lt, QWidget *before, QWidget *after)

   520     {

   521         bool ok = false;

   522         QDesignerWidgetItemInstaller wii; // Make sure we use QDesignerWidgetItem.

   523         if (QBoxLayout *boxLayout = qobject_cast<QBoxLayout *>(lt)) {

   524             const int index = boxLayout->indexOf(before);

   525             if (index != -1) {

   526                 const bool visible = before->isVisible();

   527                 delete boxLayout->takeAt(index);

   528                 if (visible)

   529                     before->hide();

   530                 before->setParent(0);

   531                 boxLayout->insertWidget(index, after);

   532                 ok = true;

   533             }

   534         }

   535         if (!ok)

   536             qWarning() << "BoxLayoutHelper::replaceWidget : Unable to replace " << before << " by " << after << " in " << lt;

   537     }

   538 

   539     BoxLayoutHelper::BoxLayoutState BoxLayoutHelper::state(const QBoxLayout*lt)

   540     {

   541         BoxLayoutState rc;

   542         if (const int count = lt->count()) {

   543             rc.reserve(count);

   544             for (int i = 0; i < count; i++)

   545                 if (QWidget *w = lt->itemAt(i)->widget())

   546                     rc.push_back(w);

   547         }

   548         return rc;

   549     }

   550 

   551     void BoxLayoutHelper::pushState(const QDesignerFormEditorInterface *core, const QWidget *w)

   552     {

   553         const QBoxLayout *boxLayout = qobject_cast<const QBoxLayout *>(LayoutInfo::managedLayout(core, w));

   554         Q_ASSERT(boxLayout);

   555         m_states.push(state(boxLayout));

   556     }

   557 

   558     QLayoutItem *BoxLayoutHelper::findItemOfWidget(const LayoutItemVector &lv, QWidget *w)

   559     {

   560         const LayoutItemVector::const_iterator cend = lv.constEnd();

   561         for (LayoutItemVector::const_iterator it = lv.constBegin(); it != cend; ++it)

   562             if ( (*it)->widget() == w)

   563                 return *it;

   564 

   565         return 0;

   566     }

   567 

   568     BoxLayoutHelper::LayoutItemVector BoxLayoutHelper::disassembleLayout(QLayout *lt)

   569     {

   570         // Take items

   571         const int count = lt->count();

   572         if (count == 0)

   573             return LayoutItemVector();

   574         LayoutItemVector rc;

   575         rc.reserve(count);

   576         for (int i = count - 1; i >= 0; i--)

   577             rc.push_back(lt->takeAt(i));

   578         return rc;

   579     }

   580 

   581     void BoxLayoutHelper::popState(const QDesignerFormEditorInterface *core, QWidget *w)

   582     {

   583         QBoxLayout *boxLayout = qobject_cast<QBoxLayout *>(LayoutInfo::managedLayout(core, w));

   584         Q_ASSERT(boxLayout);

   585         const BoxLayoutState savedState = m_states.pop();

   586         const BoxLayoutState currentState = state(boxLayout);

   587         // Check for equality/empty. Note that this will currently

   588         // always trigger as box layouts do not have a state apart from

   589         // the order and there is no layout order editor yet.

   590         if (savedState == state(boxLayout))

   591             return;

   592 

   593         const int count = savedState.size();

   594         Q_ASSERT(count == currentState.size());

   595         // Take items and reassemble in saved order

   596         const LayoutItemVector items = disassembleLayout(boxLayout);

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

   598             QLayoutItem *item = findItemOfWidget(items, savedState[i]);

   599             Q_ASSERT(item);

   600             boxLayout->addItem(item);

   601         }

   602     }

   603 

   604     // Grid Layout state. Datatypically store the state of a GridLayout as a map of

   605     // widgets to QRect(columns, rows) and size. Used to store the state for undo operations

   606     // that do not change the widgets within the layout; also provides some manipulation

   607     // functions and ability to apply the state to a layout provided its widgets haven't changed.

   608     struct GridLayoutState {

   609         GridLayoutState();

   610 

   611         void fromLayout(QGridLayout *l);

   612         void applyToLayout(const QDesignerFormEditorInterface *core, QWidget *w) const;

   613 

   614         void insertRow(int row);

   615         void insertColumn(int column);

   616 

   617         bool simplify(const QRect &r, bool testOnly);

   618         void removeFreeRow(int row);

   619         void removeFreeColumn(int column);

   620 

   621 

   622         // State of a cell in one dimension

   623         enum DimensionCellState {

   624             Free,

   625             Spanned,  // Item spans it

   626             Occupied  // Item bordering on it

   627         };

   628         // Horiontal, Vertical pair of state

   629         typedef QPair<DimensionCellState, DimensionCellState> CellState;

   630         typedef QVector<CellState> CellStates;

   631 

   632         // Figure out states of a cell and return as a flat vector of

   633         // [column1, column2,...] (address as  row * columnCount + col)

   634         static CellStates cellStates(const QList<QRect> &rects, int numRows, int numColumns);

   635 

   636         typedef QMap<QWidget *, QRect> WidgetItemMap;

   637         WidgetItemMap widgetItemMap;

   638         int rowCount;

   639         int colCount;

   640     };

   641 

   642     static inline bool needsSpacerItem(const GridLayoutState::CellState &cs) {

   643         return cs.first == GridLayoutState::Free && cs.second == GridLayoutState::Free;

   644     }

   645 

   646     static inline QDebug operator<<(QDebug str, const GridLayoutState &gs)

   647     {

   648         str << "GridLayoutState: " <<  gs.rowCount << " rows x " <<  gs.colCount

   649             << " cols " << gs.widgetItemMap.size() << " items\n";

   650 

   651         const GridLayoutState::WidgetItemMap::const_iterator wcend = gs.widgetItemMap.constEnd();

   652         for (GridLayoutState::WidgetItemMap::const_iterator it = gs.widgetItemMap.constBegin(); it != wcend; ++it)

   653             str << "Item " << it.key() << it.value() << '\n';

   654         return str;

   655     }

   656 

   657     GridLayoutState::GridLayoutState() :

   658          rowCount(0),

   659          colCount(0)

   660     {

   661     }

   662 

   663     GridLayoutState::CellStates GridLayoutState::cellStates(const QList<QRect> &rects, int numRows, int numColumns)

   664     {

   665         CellStates rc = CellStates(numRows * numColumns, CellState(Free, Free));

   666         const QList<QRect>::const_iterator rcend = rects.constEnd();

   667         for (QList<QRect>::const_iterator it = rects.constBegin(); it != rcend; ++it) {

   668             const int leftColumn = it->x();

   669             const int topRow = it->y();

   670             const int rightColumn = leftColumn + it->width() - 1;

   671             const int bottomRow = topRow + it->height() - 1;

   672             for (int r = topRow; r <= bottomRow; r++)

   673                 for (int c = leftColumn; c <= rightColumn; c++) {

   674                     const int flatIndex = r * numColumns + c;

   675                     // Bordering horizontally?

   676                     DimensionCellState &horizState = rc[flatIndex].first;

   677                     if (c == leftColumn || c == rightColumn) {

   678                         horizState = Occupied;

   679                     } else {

   680                         if (horizState < Spanned)

   681                             horizState = Spanned;

   682                     }

   683                     // Bordering vertically?

   684                     DimensionCellState &vertState = rc[flatIndex].second;

   685                     if (r == topRow || r == bottomRow) {

   686                         vertState = Occupied;

   687                     } else {

   688                         if (vertState < Spanned)

   689                             vertState = Spanned;

   690                     }

   691                 }

   692         }

   693         if (debugLayout) {

   694             qDebug() << "GridLayoutState::cellStates: " << numRows << " x " << numColumns;

   695             for (int r = 0; r < numRows; r++)

   696                 for (int c = 0; c < numColumns; c++)

   697                     qDebug() << "  Row: " << r << " column: " << c <<  rc[r * numColumns + c];

   698         }

   699         return rc;

   700     }

   701 

   702     void GridLayoutState::fromLayout(QGridLayout *l)

   703     {

   704         rowCount = l->rowCount();

   705         colCount = l->columnCount();

   706         const int count = l->count();

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

   708             QLayoutItem *item = l->itemAt(i);

   709             if (!LayoutInfo::isEmptyItem(item))

   710                 widgetItemMap.insert(item->widget(), gridItemInfo(l, i));

   711         }

   712     }

   713 

   714     void GridLayoutState::applyToLayout(const QDesignerFormEditorInterface *core, QWidget *w) const

   715     {

   716         typedef QMap<QLayoutItem *, QRect> LayoutItemRectMap;

   717         QGridLayout *grid = qobject_cast<QGridLayout *>(LayoutInfo::managedLayout(core, w));

   718         Q_ASSERT(grid);

   719         if (debugLayout)

   720             qDebug() << ">GridLayoutState::applyToLayout" <<  *this << *grid;

   721         const bool shrink = grid->rowCount() > rowCount || grid->columnCount() > colCount;

   722         // Build a map of existing items to rectangles via widget map, delete spacers

   723         LayoutItemRectMap itemMap;

   724         while (grid->count()) {

   725             QLayoutItem *item = grid->takeAt(0);

   726             if (!LayoutInfo::isEmptyItem(item)) {

   727                 QWidget *itemWidget = item->widget();

   728                 const WidgetItemMap::const_iterator it = widgetItemMap.constFind(itemWidget);

   729                 if (it == widgetItemMap.constEnd())

   730                     qFatal("GridLayoutState::applyToLayout: Attempt to apply to a layout that has a widget '%s'/'%s' added after saving the state.",

   731                            itemWidget->metaObject()->className(), itemWidget->objectName().toUtf8().constData());

   732                 itemMap.insert(item, it.value());

   733             } else {

   734                 delete item;

   735             }

   736         }

   737         Q_ASSERT(itemMap.size() == widgetItemMap.size());

   738         // recreate if shrink

   739         if (shrink)

   740             grid = static_cast<QGridLayout*>(recreateManagedLayout(core, w, grid));

   741 

   742         // Add widgets items

   743         const LayoutItemRectMap::const_iterator icend = itemMap.constEnd();

   744         for (LayoutItemRectMap::const_iterator it = itemMap.constBegin(); it != icend; ++it) {

   745             const QRect info = it.value();

   746             grid->addItem(it.key(), info.y(), info.x(), info.height(), info.width());

   747         }

   748         // create spacers

   749         const CellStates cs = cellStates(itemMap.values(), rowCount, colCount);

   750         for (int r = 0; r < rowCount; r++)

   751             for (int c = 0; c < colCount; c++)

   752                 if (needsSpacerItem(cs[r * colCount  + c]))

   753                     grid->addItem(createGridSpacer(), r, c);

   754         grid->activate();

   755         if (debugLayout)

   756             qDebug() << "<GridLayoutState::applyToLayout" <<  *grid;

   757     }

   758 

   759     void GridLayoutState::insertRow(int row)

   760     {

   761         rowCount++;

   762         const WidgetItemMap::iterator iend = widgetItemMap.end();

   763         for (WidgetItemMap::iterator it = widgetItemMap.begin(); it != iend; ++it) {

   764             const int topRow = it.value().y();

   765             if (topRow >= row) {

   766                 it.value().translate(0, 1);

   767             } else {  //Over  it: Does it span it -> widen?

   768                 const int rowSpan = it.value().height();

   769                 if (rowSpan > 1 && topRow + rowSpan > row)

   770                     it.value().setHeight(rowSpan + 1);

   771             }

   772         }

   773     }

   774 

   775     void GridLayoutState::insertColumn(int column)

   776     {

   777         colCount++;

   778         const WidgetItemMap::iterator iend = widgetItemMap.end();

   779         for (WidgetItemMap::iterator it = widgetItemMap.begin(); it != iend; ++it) {

   780             const int leftColumn = it.value().x();

   781             if (leftColumn >= column) {

   782                 it.value().translate(1, 0);

   783             } else { // Left of it: Does it span it -> widen?

   784                 const int colSpan = it.value().width();

   785                 if (colSpan  > 1 &&  leftColumn + colSpan > column)

   786                     it.value().setWidth(colSpan + 1);

   787             }

   788         }

   789     }

   790 

   791     // Simplify: Remove empty columns/rows and such ones that are only spanned (shrink

   792     // spanning items).

   793     // 'AB.C.'           'ABC'

   794     // 'DDDD.'     ==>   'DDD'

   795     // 'EF.G.'           'EFG'

   796     bool GridLayoutState::simplify(const QRect &r, bool testOnly)

   797     {

   798         // figure out free rows/columns.

   799         QVector<bool> occupiedRows(rowCount, false);

   800         QVector<bool> occupiedColumns(colCount, false);

   801         // Mark everything outside restriction rectangle as occupied

   802         const int restrictionLeftColumn = r.x();

   803         const int restrictionRightColumn = restrictionLeftColumn + r.width();

   804         const int restrictionTopRow = r.y();

   805         const int restrictionBottomRow = restrictionTopRow + r.height();

   806         if (restrictionLeftColumn > 0 || restrictionRightColumn < colCount ||

   807             restrictionTopRow     > 0 || restrictionBottomRow   < rowCount) {

   808             for (int r = 0; r <  rowCount; r++)

   809                 if (r < restrictionTopRow || r >= restrictionBottomRow)

   810                     occupiedRows[r] = true;

   811             for (int c = 0; c < colCount; c++)

   812                 if (c < restrictionLeftColumn ||  c >= restrictionRightColumn)

   813                     occupiedColumns[c] = true;

   814         }

   815         // figure out free fields and tick off occupied rows and columns

   816         const CellStates cs = cellStates(widgetItemMap.values(), rowCount, colCount);

   817         for (int r = 0; r < rowCount; r++)

   818             for (int c = 0; c < colCount; c++) {

   819                 const CellState &state = cs[r * colCount  + c];

   820                 if (state.first == Occupied)

   821                     occupiedColumns[c] = true;

   822                 if (state.second == Occupied)

   823                     occupiedRows[r] = true;

   824             }

   825         // Any free rows/columns?

   826         if (occupiedRows.indexOf(false) ==  -1 && occupiedColumns.indexOf(false) == -1)

   827             return false;

   828         if (testOnly)

   829             return true;

   830         // remove rows

   831         for (int r = rowCount - 1; r >= 0; r--)

   832             if (!occupiedRows[r])

   833                 removeFreeRow(r);

   834         // remove columns

   835         for (int c = colCount - 1; c >= 0; c--)

   836             if (!occupiedColumns[c])

   837                 removeFreeColumn(c);

   838         return true;

   839     }

   840 

   841     void GridLayoutState::removeFreeRow(int removeRow)

   842     {

   843         const WidgetItemMap::iterator iend = widgetItemMap.end();

   844         for (WidgetItemMap::iterator it = widgetItemMap.begin(); it != iend; ++it) {

   845             const int r = it.value().y();

   846             Q_ASSERT(r != removeRow); // Free rows only

   847             if (r < removeRow) { // Does the item span it? - shrink it

   848                 const int rowSpan = it.value().height();

   849                 if (rowSpan > 1) {

   850                     const int bottomRow = r + rowSpan;

   851                     if (bottomRow > removeRow)

   852                         it.value().setHeight(rowSpan - 1);

   853                 }

   854             } else

   855                 if (r > removeRow) // Item below it? - move.

   856                     it.value().translate(0, -1);

   857         }

   858         rowCount--;

   859     }

   860 

   861     void GridLayoutState::removeFreeColumn(int removeColumn)

   862     {

   863         const WidgetItemMap::iterator iend = widgetItemMap.end();

   864         for (WidgetItemMap::iterator it = widgetItemMap.begin(); it != iend; ++it) {

   865             const int c = it.value().x();

   866             Q_ASSERT(c != removeColumn); // Free columns only

   867             if (c < removeColumn) { // Does the item span it? - shrink it

   868                 const int colSpan = it.value().width();

   869                 if (colSpan > 1) {

   870                     const int rightColumn = c + colSpan;

   871                     if (rightColumn > removeColumn)

   872                         it.value().setWidth(colSpan - 1);

   873                 }

   874             } else

   875                 if (c > removeColumn) // Item to the right of it?  - move.

   876                     it.value().translate(-1, 0);

   877         }

   878         colCount--;

   879     }

   880 

   881     // ---------------- GridLayoutHelper

   882     class GridLayoutHelper : public  LayoutHelper {

   883     public:

   884         GridLayoutHelper() {}

   885 

   886         virtual QRect itemInfo(QLayout *lt, int index) const;

   887         virtual void insertWidget(QLayout *lt, const QRect &info, QWidget *w);

   888         virtual void removeWidget(QLayout *lt, QWidget *widget);

   889         virtual void replaceWidget(QLayout *lt, QWidget *before, QWidget *after);

   890 

   891         virtual void pushState(const QDesignerFormEditorInterface *core, const QWidget *widgetWithManagedLayout);

   892         virtual void popState(const QDesignerFormEditorInterface *core, QWidget *widgetWithManagedLayout);

   893 

   894         virtual bool canSimplify(const QDesignerFormEditorInterface *core, const QWidget *widgetWithManagedLayout, const QRect &restrictionArea) const;

   895         virtual void simplify(const QDesignerFormEditorInterface *core, QWidget *widgetWithManagedLayout, const QRect &restrictionArea);

   896 

   897         static void insertRow(QGridLayout *grid, int row);

   898 

   899     private:

   900         QStack<GridLayoutState> m_states;

   901     };

   902 

   903     void GridLayoutHelper::insertRow(QGridLayout *grid, int row)

   904     {

   905         GridLayoutState state;

   906         state.fromLayout(grid);

   907         state.insertRow(row);

   908         QDesignerFormWindowInterface *fw = QDesignerFormWindowInterface::findFormWindow(grid);

   909         state.applyToLayout(fw->core(), grid->parentWidget());

   910     }

   911 

   912     QRect GridLayoutHelper::itemInfo(QLayout * lt, int index) const

   913     {

   914         QGridLayout *grid = qobject_cast<QGridLayout *>(lt);

   915         Q_ASSERT(grid);

   916         return gridItemInfo(grid, index);

   917     }

   918 

   919     void GridLayoutHelper::insertWidget(QLayout *lt, const QRect &info, QWidget *w)

   920     {

   921         QDesignerWidgetItemInstaller wii; // Make sure we use QDesignerWidgetItem.

   922         QGridLayout *gridLayout = qobject_cast<QGridLayout *>(lt);

   923         Q_ASSERT(gridLayout);

   924         // check if there are any items. Should be only spacers, else something is wrong

   925         const int row = info.y();

   926         int column = info.x();

   927         int colSpan = info.width();

   928         int rowSpan = info.height();

   929         // If not empty: A multiselection was dropped on an empty item, insert row

   930         // and spread items along new row

   931         if (!removeEmptyCellsOnGrid(gridLayout, info)) {

   932             int freeColumn = -1;

   933             colSpan = rowSpan = 1;

   934             // First look to the right for a free column

   935             const int columnCount = gridLayout->columnCount();

   936             for (int c = column; c <  columnCount; c++) {

   937                 const int idx = findGridItemAt(gridLayout, row, c);

   938                 if (idx != -1 && LayoutInfo::isEmptyItem(gridLayout->itemAt(idx))) {

   939                     freeColumn = c;

   940                     break;

   941                 }

   942             }

   943             if (freeColumn != -1) {

   944                 removeEmptyCellsOnGrid(gridLayout, QRect(freeColumn, row, 1, 1));

   945                 column = freeColumn;

   946             } else {

   947                 GridLayoutHelper::insertRow(gridLayout, row);

   948                 column = 0;

   949             }

   950         }

   951         gridLayout->addWidget(w, row , column, rowSpan, colSpan);

   952     }

   953 

   954     void GridLayoutHelper::removeWidget(QLayout *lt, QWidget *widget)

   955     {

   956         QGridLayout *gridLayout = qobject_cast<QGridLayout *>(lt);

   957         Q_ASSERT(gridLayout);

   958         const int index = gridLayout->indexOf(widget);

   959         if (index == -1) {

   960             qWarning() << "GridLayoutHelper::removeWidget : Attempt to remove " << widget <<  " which is not in the layout.";

   961             return;

   962         }

   963         // delete old item and pad with  by spacer items

   964         int row, column, rowspan, colspan;

   965         gridLayout->getItemPosition(index, &row, &column, &rowspan, &colspan);

   966         delete gridLayout->takeAt(index);

   967         const int rightColumn = column + colspan;

   968         const int bottomRow = row +  rowspan;

   969         for (int c = column; c < rightColumn; c++)

   970             for (int r = row; r < bottomRow; r++)

   971                 gridLayout->addItem(createGridSpacer(), r, c);

   972     }

   973 

   974     void GridLayoutHelper::replaceWidget(QLayout *lt, QWidget *before, QWidget *after)

   975     {

   976         bool ok = false;

   977         QDesignerWidgetItemInstaller wii; // Make sure we use QDesignerWidgetItem.

   978         if (QGridLayout *gridLayout = qobject_cast<QGridLayout *>(lt)) {

   979             const int index = gridLayout->indexOf(before);

   980             if (index != -1) {

   981                 int row, column, rowSpan, columnSpan;

   982                 gridLayout->getItemPosition (index,  &row, &column, &rowSpan, &columnSpan);

   983                 const bool visible = before->isVisible();

   984                 delete gridLayout->takeAt(index);

   985                 if (visible)

   986                     before->hide();

   987                 before->setParent(0);

   988                 gridLayout->addWidget(after, row, column, rowSpan, columnSpan);

   989                 ok = true;

   990             }

   991         }

   992         if (!ok)

   993             qWarning() << "GridLayoutHelper::replaceWidget : Unable to replace " << before << " by " << after << " in " << lt;

   994     }

   995 

   996     void GridLayoutHelper::pushState(const QDesignerFormEditorInterface *core, const QWidget *widgetWithManagedLayout)

   997     {

   998         QGridLayout *gridLayout = qobject_cast<QGridLayout *>(LayoutInfo::managedLayout(core, widgetWithManagedLayout));

   999         Q_ASSERT(gridLayout);

  1000         GridLayoutState gs;

  1001         gs.fromLayout(gridLayout);

  1002         m_states.push(gs);

  1003     }

  1004 

  1005     void GridLayoutHelper::popState(const QDesignerFormEditorInterface *core, QWidget *widgetWithManagedLayout)

  1006     {

  1007         Q_ASSERT(!m_states.empty());

  1008         const GridLayoutState state = m_states.pop();

  1009         state.applyToLayout(core, widgetWithManagedLayout);

  1010     }

  1011 

  1012     bool GridLayoutHelper::canSimplify(const QDesignerFormEditorInterface *core, const QWidget *widgetWithManagedLayout, const QRect &restrictionArea) const

  1013     {

  1014         QGridLayout *gridLayout = qobject_cast<QGridLayout *>(LayoutInfo::managedLayout(core, widgetWithManagedLayout));

  1015         Q_ASSERT(gridLayout);

  1016         GridLayoutState gs;

  1017         gs.fromLayout(gridLayout);

  1018         return gs.simplify(restrictionArea, true);

  1019     }

  1020 

  1021     void GridLayoutHelper::simplify(const QDesignerFormEditorInterface *core, QWidget *widgetWithManagedLayout, const QRect &restrictionArea)

  1022     {

  1023         QGridLayout *gridLayout = qobject_cast<QGridLayout *>(LayoutInfo::managedLayout(core, widgetWithManagedLayout));

  1024         Q_ASSERT(gridLayout);

  1025         if (debugLayout)

  1026             qDebug() << ">GridLayoutHelper::simplify" <<  *gridLayout;

  1027         GridLayoutState gs;

  1028         gs.fromLayout(gridLayout);

  1029         if (gs.simplify(restrictionArea, false))

  1030             gs.applyToLayout(core, widgetWithManagedLayout);

  1031         if (debugLayout)

  1032             qDebug() << "<GridLayoutHelper::simplify" <<  *gridLayout;

  1033    }

  1034 

  1035     // ---------------- FormLayoutHelper

  1036     class FormLayoutHelper : public  LayoutHelper {

  1037     public:

  1038         typedef QPair<QWidget *, QWidget *> WidgetPair;

  1039         typedef QVector<WidgetPair> FormLayoutState;

  1040 

  1041         FormLayoutHelper() {}

  1042 

  1043         virtual QRect itemInfo(QLayout *lt, int index) const;

  1044         virtual void insertWidget(QLayout *lt, const QRect &info, QWidget *w);

  1045         virtual void removeWidget(QLayout *lt, QWidget *widget);

  1046         virtual void replaceWidget(QLayout *lt, QWidget *before, QWidget *after);

  1047 

  1048         virtual void pushState(const QDesignerFormEditorInterface *core, const QWidget *widgetWithManagedLayout);

  1049         virtual void popState(const QDesignerFormEditorInterface *core, QWidget *widgetWithManagedLayout);

  1050 

  1051         virtual bool canSimplify(const QDesignerFormEditorInterface *core, const QWidget *, const QRect &) const;

  1052         virtual void simplify(const QDesignerFormEditorInterface *, QWidget *, const QRect &);

  1053 

  1054     private:

  1055         static FormLayoutState state(const QFormLayout *lt);

  1056 

  1057         QStack<FormLayoutState> m_states;

  1058     };

  1059 

  1060     QRect FormLayoutHelper::itemInfo(QLayout * lt, int index) const

  1061     {

  1062         QFormLayout *form = qobject_cast<QFormLayout *>(lt);

  1063         Q_ASSERT(form);

  1064         int row, column, colspan;

  1065         getFormLayoutItemPosition(form, index, &row, &column, 0, &colspan);

  1066         return QRect(column, row, colspan, 1);

  1067     }

  1068 

  1069     void FormLayoutHelper::insertWidget(QLayout *lt, const QRect &info, QWidget *w)

  1070     {

  1071         if (debugLayout)

  1072             qDebug() << "FormLayoutHelper::insertWidget:" << w << info;

  1073         QDesignerWidgetItemInstaller wii; // Make sure we use QDesignerWidgetItem.

  1074         QFormLayout *formLayout = qobject_cast<QFormLayout *>(lt);

  1075         Q_ASSERT(formLayout);

  1076         // check if there are any nonspacer items? (Drop on 3rd column or drop of a multiselection

  1077         // on an empty item. As the Form layout does not have insert semantics; we need to manually insert a row

  1078         const bool insert = !removeEmptyCellsOnGrid(formLayout, info);

  1079         formLayoutAddWidget(formLayout, w, info, insert);

  1080         QLayoutSupport::createEmptyCells(formLayout);

  1081     }

  1082 

  1083     void FormLayoutHelper::removeWidget(QLayout *lt, QWidget *widget)

  1084     {

  1085         QFormLayout *formLayout = qobject_cast<QFormLayout *>(lt);

  1086         Q_ASSERT(formLayout);

  1087         const int index = formLayout->indexOf(widget);

  1088         if (index == -1) {

  1089             qWarning() << "FormLayoutHelper::removeWidget : Attempt to remove " << widget <<  " which is not in the layout.";

  1090             return;

  1091         }

  1092         // delete old item and pad with  by spacer items

  1093         int row, column, colspan;

  1094         getFormLayoutItemPosition(formLayout, index, &row, &column, 0, &colspan);

  1095         if (debugLayout)

  1096             qDebug() << "FormLayoutHelper::removeWidget: #" << index << widget << " at " << row << column <<  colspan;

  1097         delete formLayout->takeAt(index);

  1098         if (colspan > 1 || column == 0)

  1099             formLayout->setItem(row, QFormLayout::LabelRole, createFormSpacer());

  1100         if (colspan > 1 || column == 1)

  1101             formLayout->setItem(row, QFormLayout::FieldRole, createFormSpacer());

  1102     }

  1103 

  1104     void FormLayoutHelper::replaceWidget(QLayout *lt, QWidget *before, QWidget *after)

  1105     {

  1106         bool ok = false;

  1107         QDesignerWidgetItemInstaller wii; // Make sure we use QDesignerWidgetItem.

  1108         if (QFormLayout *formLayout = qobject_cast<QFormLayout *>(lt)) {

  1109             const int index = formLayout->indexOf(before);

  1110             if (index != -1) {

  1111                 int row;

  1112                 QFormLayout::ItemRole role;

  1113                 formLayout->getItemPosition (index, &row, &role);

  1114                 const bool visible = before->isVisible();

  1115                 delete formLayout->takeAt(index);

  1116                 if (visible)

  1117                     before->hide();

  1118                 before->setParent(0);

  1119                 formLayout->setWidget(row, role, after);

  1120                 ok = true;

  1121             }

  1122         }

  1123         if (!ok)

  1124             qWarning() << "FormLayoutHelper::replaceWidget : Unable to replace " << before << " by " << after << " in " << lt;

  1125     }

  1126 

  1127     FormLayoutHelper::FormLayoutState FormLayoutHelper::state(const QFormLayout *lt)

  1128     {

  1129         const int rowCount = lt->rowCount();

  1130         if (rowCount == 0)

  1131             return FormLayoutState();

  1132         FormLayoutState rc(rowCount, WidgetPair(0, 0));

  1133         const int count = lt->count();

  1134         int row, column, colspan;