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

**

** 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 "layout_p.h"

#include "qdesigner_utils_p.h"

#include "qlayout_widget_p.h"

#include "spacer_widget_p.h"

#include "layoutdecoration.h"

#include "widgetfactory_p.h"

#include "qdesigner_widgetitem_p.h"

#include <QtDesigner/QDesignerFormEditorInterface>

#include <QtDesigner/QDesignerFormWindowInterface>

#include <QtDesigner/QDesignerContainerExtension>

#include <QtDesigner/QExtensionManager>

#include <QtDesigner/QDesignerPropertySheetExtension>

#include <QtDesigner/QDesignerWidgetDataBaseInterface>

#include <QtDesigner/QDesignerMetaDataBaseInterface>

#include <QtCore/qdebug.h>

#include <QtCore/QVector>

#include <QtGui/qevent.h>

#include <QtGui/QGridLayout>

#include <QtGui/QPainter>

#include <QtGui/QBitmap>

#include <QtGui/QSplitter>

#include <QtGui/QMainWindow>

#include <QtGui/QApplication>

#include <QtGui/QScrollArea>

#include <QtGui/QFormLayout>

#include <QtGui/QLabel>

#include <QtGui/QWizardPage>

#include <QtGui/QWizard>

#include <QtCore/QDebug>

#include <QtCore/QSet>

QT_BEGIN_NAMESPACE

enum { FormLayoutColumns = 2 };

namespace qdesigner_internal {

/* The wizard has a policy of setting a size policy of its external children

 * according to the page being expanding or not (in the latter case, the

 * page will be pushed to the top). When setting/breaking layouts, this needs

 * to be updated, which happens via a fake style change event. */

void updateWizardLayout(QWidget *layoutBase);

class FriendlyWizardPage : public  QWizardPage {

    friend void updateWizardLayout(QWidget *);

};

void updateWizardLayout(QWidget *layoutBase)

{

    if (QWizardPage *wizardPage = qobject_cast<QWizardPage*>(layoutBase))

        if (QWizard *wizard = static_cast<FriendlyWizardPage*>(wizardPage)->wizard()) {

            QEvent event(QEvent::StyleChange);

            QApplication::sendEvent(wizard, &event);

        }

}

/*!

  \class Layout layout.h

  \brief Baseclass for layouting widgets in the Designer (Helper for Layout commands)

  \internal

  Classes derived from this abstract base class are used for layouting

  operations in the Designer (creating/breaking layouts).

  Instances live in the Layout/BreakLayout commands.

*/

/*!  \a p specifies the parent of the layoutBase \a lb. The parent

  might be changed in setup(). If the layoutBase is a

  container, the parent and the layoutBase are the same. Also they

  always have to be a widget known to the designer (e.g. in the case

  of the tabwidget parent and layoutBase are the tabwidget and not the

  page which actually gets laid out. For actual usage the correct

  widget is found later by Layout.)

 */

Layout::Layout(const QWidgetList &wl, QWidget *p, QDesignerFormWindowInterface *fw, QWidget *lb, LayoutInfo::Type layoutType) :

    m_widgets(wl),

    m_parentWidget(p),

    m_layoutBase(lb),

    m_formWindow(fw),

    m_layoutType(layoutType),

    m_reparentLayoutWidget(true),

    m_isBreak(false)

{

    if (m_layoutBase)

        m_oldGeometry = m_layoutBase->geometry();

}

Layout::~Layout()

{

}

/*!  The widget list we got in the constructor might contain too much

  widgets (like widgets with different parents, already laid out

  widgets, etc.). Here we set up the list and so the only the "best"

  widgets get laid out.

*/

void Layout::setup()

{

    m_startPoint = QPoint(32767, 32767);

    // Go through all widgets of the list we got. As we can only

    // layout widgets which have the same parent, we first do some

    // sorting which means create a list for each parent containing

    // its child here. After that we keep working on the list of

    // children which has the most entries.

    // Widgets which are already laid out are thrown away here too

    QMultiMap<QWidget*, QWidget*> lists;

    foreach (QWidget *w, m_widgets) {

        QWidget *p = w->parentWidget();

        if (p && LayoutInfo::layoutType(m_formWindow->core(), p) != LayoutInfo::NoLayout

                && m_formWindow->core()->metaDataBase()->item(p->layout()) != 0)

            continue;

        lists.insert(p, w);

    }

    QWidgetList lastList;

    QWidgetList parents = lists.keys();

    foreach (QWidget *p, parents) {

        QWidgetList children = lists.values(p);

        if (children.count() > lastList.count())

            lastList = children;

    }

    // If we found no list (because no widget did fit at all) or the

    // best list has only one entry and we do not layout a container,

    // we leave here.

    QDesignerWidgetDataBaseInterface *widgetDataBase = m_formWindow->core()->widgetDataBase();

    if (lastList.count() < 2 &&

                        (!m_layoutBase ||

                          (!widgetDataBase->isContainer(m_layoutBase, false) &&

                            m_layoutBase != m_formWindow->mainContainer()))

                       ) {

        m_widgets.clear();

        m_startPoint = QPoint(0, 0);

        return;

    }

    // Now we have a new and clean widget list, which makes sense

    // to layout

    m_widgets = lastList;

    // Also use the only correct parent later, so store it

    Q_ASSERT(m_widgets.isEmpty() == false);

    m_parentWidget = m_formWindow->core()->widgetFactory()->widgetOfContainer(m_widgets.first()->parentWidget());

    // Now calculate the position where the layout-meta-widget should

    // be placed and connect to widgetDestroyed() signals of the

    // widgets to get informed if one gets deleted to be able to

    // handle that and do not crash in this case

    foreach (QWidget *w, m_widgets) {

        connect(w, SIGNAL(destroyed()), this, SLOT(widgetDestroyed()));

        m_startPoint = QPoint(qMin(m_startPoint.x(), w->x()), qMin(m_startPoint.y(), w->y()));

        const QRect rc(w->geometry());

        m_geometries.insert(w, rc);

        // Change the Z-order, as saving/loading uses the Z-order for

        // writing/creating widgets and this has to be the same as in

        // the layout. Else saving + loading will give different results

        w->raise();

    }

    sort();

}

void Layout::widgetDestroyed()

{

    if (QWidget *w = qobject_cast<QWidget *>(sender())) {

        m_widgets.removeAt(m_widgets.indexOf(w));

        m_geometries.remove(w);

    }

}

bool Layout::prepareLayout(bool &needMove, bool &needReparent)

{

    foreach (QWidget *widget, m_widgets) {

        widget->raise();

    }

    needMove = !m_layoutBase;

    needReparent = needMove || (m_reparentLayoutWidget && qobject_cast<QLayoutWidget*>(m_layoutBase)) || qobject_cast<QSplitter*>(m_layoutBase);

    QDesignerWidgetFactoryInterface *widgetFactory = m_formWindow->core()->widgetFactory();

    QDesignerMetaDataBaseInterface *metaDataBase = m_formWindow->core()->metaDataBase();

    if (m_layoutBase == 0) {

        const bool useSplitter = m_layoutType == LayoutInfo::HSplitter || m_layoutType == LayoutInfo::VSplitter;

        const QString baseWidgetClassName = useSplitter ? QLatin1String("QSplitter") : QLatin1String("QLayoutWidget");

        m_layoutBase = widgetFactory->createWidget(baseWidgetClassName, widgetFactory->containerOfWidget(m_parentWidget));

        if (useSplitter) {

            m_layoutBase->setObjectName(QLatin1String("splitter"));

            m_formWindow->ensureUniqueObjectName(m_layoutBase);

        }

    } else {

        LayoutInfo::deleteLayout(m_formWindow->core(), m_layoutBase);

    }

    metaDataBase->add(m_layoutBase);

    Q_ASSERT(m_layoutBase->layout() == 0 || metaDataBase->item(m_layoutBase->layout()) == 0);

    return true;

}

static bool isMainContainer(QDesignerFormWindowInterface *fw, const QWidget *w)

{

    return w && (w == fw || w == fw->mainContainer());

}

static bool isPageOfContainerWidget(QDesignerFormWindowInterface *fw, QWidget *widget)

{

    QDesignerContainerExtension *c = qt_extension<QDesignerContainerExtension*>(

            fw->core()->extensionManager(), widget->parentWidget());

    if (c != 0) {

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

            if (widget == c->widget(i))

                return true;

        }

    }

    return false;

}

void Layout::finishLayout(bool needMove, QLayout *layout)

{

    if (m_parentWidget == m_layoutBase) {

        QWidget *widget = m_layoutBase;

        m_oldGeometry = widget->geometry();

        bool done = false;

        while (!isMainContainer(m_formWindow, widget) && !done) {

            if (!m_formWindow->isManaged(widget)) {

                widget = widget->parentWidget();

                continue;

            } else if (LayoutInfo::isWidgetLaidout(m_formWindow->core(), widget)) {

                widget = widget->parentWidget();

                continue;

            } else if (isPageOfContainerWidget(m_formWindow, widget)) {

                widget = widget->parentWidget();

                continue;

            } else if (widget->parentWidget()) {

                QScrollArea *area = qobject_cast<QScrollArea*>(widget->parentWidget()->parentWidget());

                if (area && area->widget() == widget) {

                    widget = area;

                    continue;

                }

            }

            done = true;

        }

        updateWizardLayout(m_layoutBase);

        QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);

        // We don't want to resize the form window

        if (!Utils::isCentralWidget(m_formWindow, widget))

            widget->adjustSize();

        return;

    }

    if (needMove)

        m_layoutBase->move(m_startPoint);

    const QRect g(m_layoutBase->pos(), m_layoutBase->size());

    if (LayoutInfo::layoutType(m_formWindow->core(), m_layoutBase->parentWidget()) == LayoutInfo::NoLayout && !m_isBreak)

        m_layoutBase->adjustSize();

    else if (m_isBreak)

        m_layoutBase->setGeometry(m_oldGeometry);

    m_oldGeometry = g;

    if (layout)

        layout->invalidate();

    m_layoutBase->show();

    if (qobject_cast<QLayoutWidget*>(m_layoutBase) || qobject_cast<QSplitter*>(m_layoutBase)) {

        m_formWindow->clearSelection(false);

        m_formWindow->manageWidget(m_layoutBase);

        m_formWindow->selectWidget(m_layoutBase);

    }

}

void Layout::undoLayout()

{

    if (!m_widgets.count())

        return;

    m_formWindow->selectWidget(m_layoutBase, false);

    QDesignerWidgetFactoryInterface *widgetFactory = m_formWindow->core()->widgetFactory();

    QHashIterator<QWidget *, QRect> it(m_geometries);

    while (it.hasNext()) {

        it.next();

        if (!it.key())

            continue;

        QWidget* w = it.key();

        const QRect rc = it.value();

        const bool showIt = w->isVisibleTo(m_formWindow);

        QWidget *container = widgetFactory->containerOfWidget(m_parentWidget);

        // ### remove widget here

        QWidget *parentWidget = w->parentWidget();

        QDesignerFormEditorInterface *core = m_formWindow->core();

        QDesignerLayoutDecorationExtension *deco = qt_extension<QDesignerLayoutDecorationExtension*>(core->extensionManager(), parentWidget);

        if (deco)

            deco->removeWidget(w);

        w->setParent(container);

        w->setGeometry(rc);

        if (showIt)

            w->show();

    }

    LayoutInfo::deleteLayout(m_formWindow->core(), m_layoutBase);

    if (m_parentWidget != m_layoutBase && !qobject_cast<QMainWindow*>(m_layoutBase)) {

        m_formWindow->unmanageWidget(m_layoutBase);

        m_layoutBase->hide();

    } else {

        QMainWindow *mw = qobject_cast<QMainWindow*>(m_formWindow->mainContainer());

        if (m_layoutBase != m_formWindow->mainContainer() &&

                    (!mw || mw->centralWidget() != m_layoutBase))

            m_layoutBase->setGeometry(m_oldGeometry);

    }

}

void Layout::breakLayout()

{

    typedef QMap<QWidget *, QRect> WidgetRectMap;

    WidgetRectMap rects;

    /* Store the geometry of the widgets. The idea is to give the user space

     * to rearrange them, so, we do a adjustSize() on them, unless they want

     * to grow (expanding widgets like QTextEdit), in which the geometry is

     * preserved. Note that historically, geometries were re-applied

     * only after breaking splitters. */

    foreach (QWidget *w, m_widgets) {

        const QRect geom = w->geometry();

        const QSize sizeHint = w->sizeHint();

        const bool restoreGeometry = sizeHint.isEmpty() || sizeHint.width() > geom.width() || sizeHint.height() > geom.height();

        rects.insert(w, restoreGeometry ? w->geometry() : QRect(geom.topLeft(), QSize()));

    }

    const QPoint m_layoutBasePos = m_layoutBase->pos();

    QDesignerWidgetDataBaseInterface *widgetDataBase = m_formWindow->core()->widgetDataBase();

    LayoutInfo::deleteLayout(m_formWindow->core(), m_layoutBase);

    const bool needReparent = (m_reparentLayoutWidget && qobject_cast<QLayoutWidget*>(m_layoutBase)) ||

                        qobject_cast<QSplitter*>(m_layoutBase)     ||

                        (!widgetDataBase->isContainer(m_layoutBase, false) &&

                          m_layoutBase != m_formWindow->mainContainer());

    const bool add = m_geometries.isEmpty();

    QMapIterator<QWidget*, QRect> it(rects);

    while (it.hasNext()) {

        it.next();

        QWidget *w = it.key();

        if (needReparent) {

            w->setParent(m_layoutBase->parentWidget(), 0);

            w->move(m_layoutBasePos + it.value().topLeft());

            w->show();

        }

        const QRect oldGeometry = it.value();

        if (oldGeometry.isEmpty()) {

            w->adjustSize();

        } else {

            w->resize(oldGeometry.size());

        }

        if (add)

            m_geometries.insert(w, QRect(w->pos(), w->size()));

    }

    if (needReparent) {

        m_layoutBase->hide();

        m_parentWidget = m_layoutBase->parentWidget();

        m_formWindow->unmanageWidget(m_layoutBase);

    } else {

        m_parentWidget = m_layoutBase;

    }

    updateWizardLayout(m_layoutBase);

    if (!m_widgets.isEmpty() && m_widgets.first() && m_widgets.first()->isVisibleTo(m_formWindow))

        m_formWindow->selectWidget(m_widgets.first());

    else

        m_formWindow->selectWidget(m_formWindow);

}

static QString suggestLayoutName(const char *className)

{

    // Legacy

    if (!qstrcmp(className, "QHBoxLayout"))

        return QLatin1String("horizontalLayout");

    if (!qstrcmp(className, "QVBoxLayout"))

        return QLatin1String("verticalLayout");

    if (!qstrcmp(className, "QGridLayout"))

        return QLatin1String("gridLayout");

    return qtify(QString::fromUtf8(className));

}

QLayout *Layout::createLayout(int type)

{

    Q_ASSERT(m_layoutType != LayoutInfo::HSplitter && m_layoutType != LayoutInfo::VSplitter);

    QLayout *layout = m_formWindow->core()->widgetFactory()->createLayout(m_layoutBase, 0, type);

    // set a name

    layout->setObjectName(suggestLayoutName(layout->metaObject()->className()));

    m_formWindow->ensureUniqueObjectName(layout);

    // QLayoutWidget

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

    if (sheet && qobject_cast<QLayoutWidget*>(m_layoutBase)) {

        sheet->setProperty(sheet->indexOf(QLatin1String("leftMargin")), 0);

        sheet->setProperty(sheet->indexOf(QLatin1String("topMargin")), 0);

        sheet->setProperty(sheet->indexOf(QLatin1String("rightMargin")), 0);

        sheet->setProperty(sheet->indexOf(QLatin1String("bottomMargin")), 0);

    }

    return layout;

}

void Layout::reparentToLayoutBase(QWidget *w)

{

    if (w->parent() != m_layoutBase) {

        w->setParent(m_layoutBase, 0);

        w->move(QPoint(0,0));

    }

}

namespace { // within qdesigner_internal

// ----- PositionSortPredicate: Predicate to be usable as LessThan function to sort widgets by position

class PositionSortPredicate {

public:

    PositionSortPredicate(Qt::Orientation orientation) : m_orientation(orientation) {}

    bool operator()(const QWidget* w1, const QWidget* w2) {

        return m_orientation == Qt::Horizontal ? w1->x() < w2->x() : w1->y() < w2->y();

    }

    private:

    const Qt::Orientation m_orientation;

};

// -------- BoxLayout

class BoxLayout : public Layout

{

public:

    BoxLayout(const QWidgetList &wl, QWidget *p, QDesignerFormWindowInterface *fw, QWidget *lb,

              Qt::Orientation orientation);

    virtual void doLayout();

    virtual void sort();

private:

    const Qt::Orientation m_orientation;

};

BoxLayout::BoxLayout(const QWidgetList &wl, QWidget *p, QDesignerFormWindowInterface *fw, QWidget *lb,

                     Qt::Orientation orientation)  :

    Layout(wl, p, fw, lb, orientation == Qt::Horizontal ? LayoutInfo::HBox : LayoutInfo::VBox),

    m_orientation(orientation)

{

}

void BoxLayout::sort()

{

    QWidgetList wl = widgets();

    qStableSort(wl.begin(), wl.end(), PositionSortPredicate(m_orientation));

    setWidgets(wl);

}

void BoxLayout::doLayout()

{

    bool needMove, needReparent;

    if (!prepareLayout(needMove, needReparent))