/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Designer of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

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

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

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

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

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

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

**

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

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

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

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qlayout_widget_p.h"

#include "qdesigner_utils_p.h"

#include "layout_p.h"

#include "layoutinfo_p.h"

#include "invisible_widget_p.h"

#include "qdesigner_widgetitem_p.h"

#include <QtDesigner/QDesignerFormWindowInterface>

#include <QtDesigner/QExtensionManager>

#include <QtDesigner/QDesignerFormEditorInterface>

#include <QtDesigner/QDesignerPropertySheetExtension>

#include <QtDesigner/QDesignerWidgetFactoryInterface>

#include <QtGui/QPainter>

#include <QtGui/QHBoxLayout>

#include <QtGui/QVBoxLayout>

#include <QtGui/QGridLayout>

#include <QtGui/QFormLayout>

#include <QtGui/qevent.h>

#include <QtCore/qdebug.h>

#include <QtCore/QtAlgorithms>

#include <QtCore/QMap>

#include <QtCore/QStack>

#include <QtCore/QPair>

#include <QtCore/QSet>

enum { ShiftValue = 1 };

enum { debugLayout = 0 };

enum { FormLayoutColumns = 2 };

enum { indicatorSize = 2 };

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

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

QT_USE_NAMESPACE

// overloads to make templates over QGridLayout/QFormLayout work

inline int gridRowCount(const QGridLayout *gridLayout)

{

    return  gridLayout->rowCount();

}

inline int gridColumnCount(const QGridLayout *gridLayout)

{

    return  gridLayout->columnCount();

}

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

inline void getGridItemPosition(QGridLayout *gridLayout, int index,

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

{

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

}

QRect gridItemInfo(QGridLayout *grid, int index)

{

    int row, column, rowSpan, columnSpan;

    // getItemPosition is not const, grmbl..

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

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

}

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

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

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

{

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

}

QRect gridItemInfo(const QFormLayout *form, int index)

{

    int row;

    int column;

    int colspan;

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

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

}

} // namespace anonymous

QT_BEGIN_NAMESPACE

static const char *objectNameC = "objectName";

static const char *sizeConstraintC = "sizeConstraint";

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

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

namespace qdesigner_internal {

    class PaddingSpacerItem : public QSpacerItem {

    public:

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

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

    };

}

static inline QSpacerItem *createGridSpacer()

{

    return new QSpacerItem(0, 0);

}

static inline QSpacerItem *createFormSpacer()

{

    return new qdesigner_internal::PaddingSpacerItem;

}

// QGridLayout/QFormLayout Helpers: Debug items of GridLikeLayout

template <class GridLikeLayout>

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

{

    const int count = gl.count();

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

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

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

        QLayoutItem *item = gl.itemAt(i);

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

    }

    return str;

}

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

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

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

{

    // Spanning can never be empty

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

        return false;

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

}

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

{

    if (restrictionArea.x() >= FormLayoutColumns)

        return false;

    // Try to find empty rows

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

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

        if (isEmptyFormLayoutRow(formLayout, r))

            return true;

    return false;

}

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

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

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

{

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

    qdesigner_internal::LayoutProperties properties;

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

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

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

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

    return rc;

}

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

template <class GridLikeLayout>

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

{

    Q_ASSERT(gridLayout);

    const int count = gridLayout->count();

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

        int row, column, rowspan, colspan;

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

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

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

            return index;

        }

    }

    return -1;

}

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

template <class GridLikeLayout>

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

{

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

    // Unique out items that span rows/columns.

    QVector<int> indexesToBeRemoved;

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

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

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

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

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

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

            if (index != -1)

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

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

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

                            indexesToBeRemoved.push_back(index);

                    } else {

                        return false;

                    }

                }

        }

    // remove, starting from last

    if (!indexesToBeRemoved.empty()) {

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

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

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

    }

    return true;

}

namespace qdesigner_internal {

// --------- LayoutProperties

LayoutProperties::LayoutProperties()

{

    clear();

}

void LayoutProperties::clear()

{

    qFill(m_margins, m_margins + MarginCount, 0);

    qFill(m_marginsChanged, m_marginsChanged + MarginCount, false);

    qFill(m_spacings, m_spacings + SpacingsCount, 0);

    qFill(m_spacingsChanged, m_spacingsChanged + SpacingsCount, false);

    m_objectName = QVariant();

    m_objectNameChanged = false;

    m_sizeConstraint = QVariant(QLayout::SetDefaultConstraint);

    m_sizeConstraintChanged = false;

    m_fieldGrowthPolicyChanged = m_rowWrapPolicyChanged =  m_labelAlignmentChanged = m_formAlignmentChanged = false;

    m_fieldGrowthPolicy =  m_rowWrapPolicy =  m_formAlignment = QVariant();

    m_boxStretchChanged = m_gridRowStretchChanged = m_gridColumnStretchChanged = m_gridRowMinimumHeightChanged = false;

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

}

int LayoutProperties::visibleProperties(const  QLayout *layout)

{

    // Grid like layout have 2 spacings.

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

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

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

             SizeConstraintProperty;

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

    if (isFormLayout) {

        rc |= FieldGrowthPolicyProperty|RowWrapPolicyProperty|LabelAlignmentProperty|FormAlignmentProperty;

    } else {

        if (isGridLike) {

            rc |=  GridRowStretchProperty|GridColumnStretchProperty|GridRowMinimumHeightProperty|GridColumnMinimumWidthProperty;

        } else {

            rc |=  BoxStretchProperty;

        }

    }

    return rc;

}

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

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

static const char *fieldGrowthPolicyPropertyC = "fieldGrowthPolicy";

static const char *rowWrapPolicyPropertyC = "rowWrapPolicy";

static const char *labelAlignmentPropertyC = "labelAlignment";

static const char *formAlignmentPropertyC = "formAlignment";

static const char *boxStretchPropertyC = "stretch";

static const char *gridRowStretchPropertyC = "rowStretch";

static const char *gridColumnStretchPropertyC = "columnStretch";

static const char *gridRowMinimumHeightPropertyC = "rowMinimumHeight";

static const char *gridColumnMinimumWidthPropertyC = "columnMinimumWidth";

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

{

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

    if (sheetIndex == -1)

        return false;

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

    *changed = sheet->isChanged(sheetIndex);

    return true;

}

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

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

{

    if (mask & flag) {

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

        if (sIndex != -1) {

            *value = sheet->property(sIndex);

            *changed = sheet->isChanged(sIndex);

            *returnMask |= flag;

        }

    }

}

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

{

    int rc = 0;

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

    Q_ASSERT(sheet);

    // name

    if (mask & ObjectNameProperty) {

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

        Q_ASSERT(nameIndex != -1);

        m_objectName = sheet->property(nameIndex);

        m_objectNameChanged =  sheet->isChanged(nameIndex);

        rc |= ObjectNameProperty;

    }

    // -- Margins

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

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

        if (mask & marginFlags[i])

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

                rc |= marginFlags[i];

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

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

        if (mask & spacingFlags[i])

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

                rc |= spacingFlags[i];

    // sizeConstraint, flags

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

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

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

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

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

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

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

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

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

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

    return rc;

}

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

{

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

    if (sheetIndex == -1) {

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

        return false;

    }

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

    if (applyChanged)

        sheet->setChanged(sheetIndex, changed);

    return true;

}

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

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

{

    if (mask & flag) {

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

        if (sIndex != -1) {

            sheet->setProperty(sIndex, value);

            if (applyChanged)

                sheet->setChanged(sIndex, changed);

            *returnMask |= flag;

        }

    }

}

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

{

    int rc = 0;

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

    Q_ASSERT(sheet);

    // name

    if (mask & ObjectNameProperty) {

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

        Q_ASSERT(nameIndex != -1);

        sheet->setProperty(nameIndex, m_objectName);

        if (applyChanged)

           sheet->setChanged(nameIndex, m_objectNameChanged);

        rc |= ObjectNameProperty;

    }

    // margins

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

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

        if (mask & marginFlags[i])

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

                rc |= marginFlags[i];

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

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

        if (mask & spacingFlags[i])

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

                rc |= spacingFlags[i];

    // sizeConstraint

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

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

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

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

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

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

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

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

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

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

    return rc;

}

// ---------------- LayoutHelper

LayoutHelper::LayoutHelper()

{

}

LayoutHelper::~LayoutHelper()

{

}

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

{

    if (!lt)

        return -1;

    const int itemCount = lt->count();

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

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

            return i;

    return -1;

}

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

{

    const int index = indexOf(lt, widget);

    if (index == -1) {

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

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

    }

    return itemInfo(lt, index);

}

    // ---------------- BoxLayoutHelper

    class BoxLayoutHelper : public  LayoutHelper {

    public:

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

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

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

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

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

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

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

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

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

        // Helper for restoring layout states

        typedef QVector <QLayoutItem *> LayoutItemVector;

        static LayoutItemVector disassembleLayout(QLayout *lt);

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

    private:

        typedef QVector<QWidget *> BoxLayoutState;

        static BoxLayoutState state(const QBoxLayout*lt);

        QStack<BoxLayoutState> m_states;

        const Qt::Orientation m_orientation;

    };

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

    {

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

    }

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

    {

        QDesignerWidgetItemInstaller wii; // Make sure we use QDesignerWidgetItem.

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

        Q_ASSERT(boxLayout);

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

    }

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

    {

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

        Q_ASSERT(boxLayout);

        boxLayout->removeWidget(widget);

    }

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

    {

        bool ok = false;

        QDesignerWidgetItemInstaller wii; // Make sure we use QDesignerWidgetItem.

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

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

            if (index != -1) {

                const bool visible = before->isVisible();

                delete boxLayout->takeAt(index);

                if (visible)