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

**

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

#include "qdesigner_propertycommand_p.h"

#include "qdesigner_utils_p.h"

#include "layout_p.h"

#include "qlayout_widget_p.h"

#include "qdesigner_widget_p.h"

#include "qdesigner_menu_p.h"

#include "shared_enums_p.h"

#include "metadatabase_p.h"

#include "formwindowbase_p.h"

#include <abstractformbuilder.h>

#include <QtDesigner/QDesignerFormWindowInterface>

#include <QtDesigner/QDesignerFormEditorInterface>

#include <QtDesigner/QDesignerPropertySheetExtension>

#include <QtDesigner/QDesignerActionEditorInterface>

#include <QtDesigner/QDesignerPropertyEditorInterface>

#include <QtDesigner/QExtensionManager>

#include <QtDesigner/QDesignerContainerExtension>

#include <QtDesigner/QDesignerLayoutDecorationExtension>

#include <QtDesigner/QDesignerWidgetFactoryInterface>

#include <QtDesigner/QDesignerObjectInspectorInterface>

#include <QtDesigner/QDesignerIntegrationInterface>

#include <QtDesigner/QDesignerFormWindowCursorInterface>

#include <QtCore/qdebug.h>

#include <QtCore/QTextStream>

#include <QtCore/QQueue>

#include <QtGui/QMenuBar>

#include <QtGui/QStatusBar>

#include <QtGui/QToolBar>

#include <QtGui/QToolBox>

#include <QtGui/QStackedWidget>

#include <QtGui/QTabWidget>

#include <QtGui/QTableWidget>

#include <QtGui/QTreeWidget>

#include <QtGui/QListWidget>

#include <QtGui/QComboBox>

#include <QtGui/QSplitter>

#include <QtGui/QDockWidget>

#include <QtGui/QMainWindow>

#include <QtGui/QWizardPage>

#include <QtGui/QApplication>

#include <QtGui/QFormLayout>

Q_DECLARE_METATYPE(QWidgetList)

QT_BEGIN_NAMESPACE

static inline void setPropertySheetWindowTitle(const QDesignerFormEditorInterface *core, QObject *o, const QString &t)

{

    if (QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(core->extensionManager(), o)) {

        const int idx = sheet->indexOf(QLatin1String("windowTitle"));

        if (idx != -1) {

            sheet->setProperty(idx, t);

            sheet->setChanged(idx, true);

        }

    }

}

namespace qdesigner_internal {

// Helpers for the dynamic properties that store Z/Widget order

static const char *widgetOrderPropertyC = "_q_widgetOrder";

static const char *zOrderPropertyC = "_q_zOrder";

static void addToWidgetListDynamicProperty(QWidget *parentWidget, QWidget *widget, const char *name, int index = -1)

{

    QWidgetList list = qVariantValue<QWidgetList>(parentWidget->property(name));

    list.removeAll(widget);

    if (index >= 0 && index < list.size()) {

        list.insert(index, widget);

    } else {

        list.append(widget);

    }

    parentWidget->setProperty(name, qVariantFromValue(list));

}

static int removeFromWidgetListDynamicProperty(QWidget *parentWidget, QWidget *widget, const char *name)

{

    QWidgetList list = qVariantValue<QWidgetList>(parentWidget->property(name));

    const int firstIndex = list.indexOf(widget);

    if (firstIndex != -1) {

        list.removeAll(widget);

        parentWidget->setProperty(name, qVariantFromValue(list));

    }

    return firstIndex;

}

// ---- InsertWidgetCommand ----

InsertWidgetCommand::InsertWidgetCommand(QDesignerFormWindowInterface *formWindow)  :

    QDesignerFormWindowCommand(QString(), formWindow),

    m_insertMode(QDesignerLayoutDecorationExtension::InsertWidgetMode),

    m_layoutHelper(0),

    m_widgetWasManaged(false)

{

}

InsertWidgetCommand::~InsertWidgetCommand()

{

    delete m_layoutHelper;

}

void InsertWidgetCommand::init(QWidget *widget, bool already_in_form, int layoutRow, int layoutColumn)

{

    m_widget = widget;

    setText(QApplication::translate("Command", "Insert '%1'").arg(widget->objectName()));

    QWidget *parentWidget = m_widget->parentWidget();

    QDesignerFormEditorInterface *core = formWindow()->core();

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

    m_insertMode = deco ? deco->currentInsertMode() : QDesignerLayoutDecorationExtension::InsertWidgetMode;

    if (layoutRow >= 0 && layoutColumn >= 0) {

        m_cell.first = layoutRow;

        m_cell.second = layoutColumn;

    } else {

        m_cell = deco ? deco->currentCell() : qMakePair(0, 0);

    }

    m_widgetWasManaged = already_in_form;

}

static void recursiveUpdate(QWidget *w)

{

    w->update();

    const QObjectList &l = w->children();

    const QObjectList::const_iterator cend = l.end();

    for ( QObjectList::const_iterator it = l.begin(); it != cend; ++it) {

        if (QWidget *w = qobject_cast<QWidget*>(*it))

            recursiveUpdate(w);

    }

}

void InsertWidgetCommand::redo()

{

    QWidget *parentWidget = m_widget->parentWidget();

    Q_ASSERT(parentWidget);

    addToWidgetListDynamicProperty(parentWidget, m_widget, widgetOrderPropertyC);

    addToWidgetListDynamicProperty(parentWidget, m_widget, zOrderPropertyC);

    QDesignerFormEditorInterface *core = formWindow()->core();

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

    if (deco != 0) {

        const LayoutInfo::Type type = LayoutInfo::layoutType(core, LayoutInfo::managedLayout(core, parentWidget));

        m_layoutHelper = LayoutHelper::createLayoutHelper(type);

        m_layoutHelper->pushState(core, parentWidget);

        if (type == LayoutInfo::Grid) {

            switch (m_insertMode) {

                case QDesignerLayoutDecorationExtension::InsertRowMode: {

                    deco->insertRow(m_cell.first);

                } break;

                case QDesignerLayoutDecorationExtension::InsertColumnMode: {

                    deco->insertColumn(m_cell.second);

                } break;

                default: break;

            } // end switch

        }

        deco->insertWidget(m_widget, m_cell);

    }

    if (!m_widgetWasManaged)

        formWindow()->manageWidget(m_widget);

    m_widget->show();

    formWindow()->emitSelectionChanged();

    if (parentWidget && parentWidget->layout()) {

        recursiveUpdate(parentWidget);

        parentWidget->layout()->invalidate();

    }

    refreshBuddyLabels();

}

void InsertWidgetCommand::undo()

{

    QWidget *parentWidget = m_widget->parentWidget();

    QDesignerFormEditorInterface *core = formWindow()->core();

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

    if (deco) {

        deco->removeWidget(m_widget);

        m_layoutHelper->popState(core, parentWidget);

    }

    if (!m_widgetWasManaged) {

        formWindow()->unmanageWidget(m_widget);

        m_widget->hide();

    }

    removeFromWidgetListDynamicProperty(parentWidget, m_widget, widgetOrderPropertyC);

    removeFromWidgetListDynamicProperty(parentWidget, m_widget, zOrderPropertyC);

    formWindow()->emitSelectionChanged();

    refreshBuddyLabels();

}

void InsertWidgetCommand::refreshBuddyLabels()

{

    typedef QList<QLabel*> LabelList;

    const LabelList label_list = qFindChildren<QLabel*>(formWindow());

    if (label_list.empty())

        return;

    const QString buddyProperty = QLatin1String("buddy");

    const QByteArray objectNameU8 = m_widget->objectName().toUtf8();

    // Re-set the buddy (The sheet locates the object by name and sets it)

    const LabelList::const_iterator cend = label_list.constEnd();

    for (LabelList::const_iterator it = label_list.constBegin(); it != cend; ++it ) {

        if (QDesignerPropertySheetExtension* sheet = propertySheet(*it)) {

            const int idx = sheet->indexOf(buddyProperty);

            if (idx != -1) {

                const QVariant value = sheet->property(idx);

                if (value.toByteArray() == objectNameU8)

                    sheet->setProperty(idx, value);

            }

        }

    }

}

// ---- ChangeZOrderCommand ----

ChangeZOrderCommand::ChangeZOrderCommand(QDesignerFormWindowInterface *formWindow)

    : QDesignerFormWindowCommand(QString(), formWindow)

{

}

void ChangeZOrderCommand::init(QWidget *widget)

{

    Q_ASSERT(widget);

    m_widget = widget;

    setText(QApplication::translate("Command", "Change Z-order of '%1'").arg(widget->objectName()));

    m_oldParentZOrder = qVariantValue<QWidgetList>(widget->parentWidget()->property("_q_zOrder"));

    const int index = m_oldParentZOrder.indexOf(m_widget);

    if (index != -1 && index + 1 < m_oldParentZOrder.count())

        m_oldPreceding = m_oldParentZOrder.at(index + 1);

}

void ChangeZOrderCommand::redo()

{

    m_widget->parentWidget()->setProperty("_q_zOrder", qVariantFromValue(reorderWidget(m_oldParentZOrder, m_widget)));

    reorder(m_widget);

}

void ChangeZOrderCommand::undo()

{

    m_widget->parentWidget()->setProperty("_q_zOrder", qVariantFromValue(m_oldParentZOrder));

    if (m_oldPreceding)

        m_widget->stackUnder(m_oldPreceding);

    else

        m_widget->raise();

}

// ---- RaiseWidgetCommand ----

RaiseWidgetCommand::RaiseWidgetCommand(QDesignerFormWindowInterface *formWindow)

    : ChangeZOrderCommand(formWindow)

{

}

void RaiseWidgetCommand::init(QWidget *widget)

{

    ChangeZOrderCommand::init(widget);

    setText(QApplication::translate("Command", "Raise '%1'").arg(widget->objectName()));

}

QWidgetList RaiseWidgetCommand::reorderWidget(const QWidgetList &list, QWidget *widget) const

{

    QWidgetList l = list;

    l.removeAll(widget);

    l.append(widget);

    return l;

}

void RaiseWidgetCommand::reorder(QWidget *widget) const

{

    widget->raise();

}

// ---- LowerWidgetCommand ----

LowerWidgetCommand::LowerWidgetCommand(QDesignerFormWindowInterface *formWindow)

    : ChangeZOrderCommand(formWindow)

{

}

QWidgetList LowerWidgetCommand::reorderWidget(const QWidgetList &list, QWidget *widget) const

{

    QWidgetList l = list;

    l.removeAll(widget);

    l.prepend(widget);

    return l;

}

void LowerWidgetCommand::init(QWidget *widget)

{

    ChangeZOrderCommand::init(widget);

    setText(QApplication::translate("Command", "Lower '%1'").arg(widget->objectName()));

}

void LowerWidgetCommand::reorder(QWidget *widget) const

{

    widget->lower();

}

// ---- ManageWidgetCommandHelper

ManageWidgetCommandHelper::ManageWidgetCommandHelper() :

    m_widget(0)

{

}

void ManageWidgetCommandHelper::init(const QDesignerFormWindowInterface *fw, QWidget *widget)

{

    m_widget = widget;

    m_managedChildren.clear();

    const QWidgetList children = qFindChildren<QWidget *>(m_widget);

    if (children.empty())

        return;

    m_managedChildren.reserve(children.size());

    const QWidgetList::const_iterator lcend = children.constEnd();

    for (QWidgetList::const_iterator it = children.constBegin(); it != lcend; ++it)

        if (fw->isManaged(*it))

            m_managedChildren.push_back(*it);

}

void ManageWidgetCommandHelper::init(QWidget *widget, const WidgetVector &managedChildren)

{

    m_widget = widget;

    m_managedChildren = managedChildren;

}

void ManageWidgetCommandHelper::manage(QDesignerFormWindowInterface *fw)

{

    // Manage the managed children after parent

    fw->manageWidget(m_widget);

    if (!m_managedChildren.empty()) {

        const WidgetVector::const_iterator lcend = m_managedChildren.constEnd();

        for (WidgetVector::const_iterator it = m_managedChildren.constBegin(); it != lcend; ++it)

            fw->manageWidget(*it);

    }

}

void ManageWidgetCommandHelper::unmanage(QDesignerFormWindowInterface *fw)

{

    // Unmanage the managed children first

    if (!m_managedChildren.empty()) {

        const WidgetVector::const_iterator lcend = m_managedChildren.constEnd();

        for (WidgetVector::const_iterator it = m_managedChildren.constBegin(); it != lcend; ++it)

            fw->unmanageWidget(*it);

    }

    fw->unmanageWidget(m_widget);

}

// ---- DeleteWidgetCommand ----

DeleteWidgetCommand::DeleteWidgetCommand(QDesignerFormWindowInterface *formWindow) :

    QDesignerFormWindowCommand(QString(), formWindow),

    m_layoutType(LayoutInfo::NoLayout),

    m_layoutHelper(0),

    m_flags(0),

    m_splitterIndex(-1),

    m_layoutSimplified(false),

    m_formItem(0),

    m_tabOrderIndex(-1),

    m_widgetOrderIndex(-1),

    m_zOrderIndex(-1)

{

}

DeleteWidgetCommand::~DeleteWidgetCommand()

{

    delete  m_layoutHelper;

}

void DeleteWidgetCommand::init(QWidget *widget, unsigned flags)

{

    m_widget = widget;

    m_parentWidget = widget->parentWidget();

    m_geometry = widget->geometry();

    m_flags = flags;

    m_layoutType = LayoutInfo::NoLayout;

    m_splitterIndex = -1;

    bool isManaged; // Check for a managed layout

    QLayout *layout;

    m_layoutType = LayoutInfo::laidoutWidgetType(formWindow()->core(), m_widget, &isManaged, &layout);

    if (!isManaged)

        m_layoutType = LayoutInfo::NoLayout;

    switch (m_layoutType) {

    case LayoutInfo::HSplitter:

    case LayoutInfo::VSplitter: {

        QSplitter *splitter = qobject_cast<QSplitter *>(m_parentWidget);

        Q_ASSERT(splitter);

        m_splitterIndex = splitter->indexOf(widget);

    }

        break;

    case LayoutInfo::NoLayout:

        break;

    default:

        m_layoutHelper = LayoutHelper::createLayoutHelper(m_layoutType);

        m_layoutPosition = m_layoutHelper->itemInfo(layout, m_widget);

        break;

    }

    m_formItem = formWindow()->core()->metaDataBase()->item(formWindow());

    m_tabOrderIndex = m_formItem->tabOrder().indexOf(widget);

    // Build the list of managed children

    m_manageHelper.init(formWindow(), m_widget);

    setText(QApplication::translate("Command", "Delete '%1'").arg(widget->objectName()));

}

void DeleteWidgetCommand::redo()

{

    formWindow()->clearSelection();

    QDesignerFormEditorInterface *core = formWindow()->core();

    if (QDesignerContainerExtension *c = qt_extension<QDesignerContainerExtension*>(core->extensionManager(), m_parentWidget)) {

        const int count = c->count();

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

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

                c->remove(i);

                return;

            }

        }

    }

    m_widgetOrderIndex = removeFromWidgetListDynamicProperty(m_parentWidget, m_widget, widgetOrderPropertyC);

    m_zOrderIndex = removeFromWidgetListDynamicProperty(m_parentWidget, m_widget, zOrderPropertyC);

    if (QDesignerLayoutDecorationExtension *deco = qt_extension<QDesignerLayoutDecorationExtension*>(core->extensionManager(), m_parentWidget))

        deco->removeWidget(m_widget);

    if (m_layoutHelper)

        switch (m_layoutType) {

        case LayoutInfo::NoLayout:

        case LayoutInfo::HSplitter:

        case LayoutInfo::VSplitter:

            break;

        default:

            // Attempt to simplify grids if a row/column becomes empty

            m_layoutSimplified = (m_flags & DoNotSimplifyLayout) ? false : m_layoutHelper->canSimplify(core, m_parentWidget, m_layoutPosition);

            if (m_layoutSimplified) {

                m_layoutHelper->pushState(core, m_parentWidget);

                m_layoutHelper->simplify(core, m_parentWidget, m_layoutPosition);

            }

            break;

        }

    if (!(m_flags & DoNotUnmanage))

        m_manageHelper.unmanage(formWindow());

    m_widget->setParent(formWindow());

    m_widget->hide();

    if (m_tabOrderIndex != -1) {

        QList<QWidget*> tab_order = m_formItem->tabOrder();

        tab_order.removeAt(m_tabOrderIndex);

        m_formItem->setTabOrder(tab_order);

    }

}

void DeleteWidgetCommand::undo()

{

    QDesignerFormEditorInterface *core = formWindow()->core();

    formWindow()->clearSelection();

    m_widget->setParent(m_parentWidget);

    if (QDesignerContainerExtension *c = qt_extension<QDesignerContainerExtension*>(core->extensionManager(), m_parentWidget)) {

        c->addWidget(m_widget);

        return;

    }

    addToWidgetListDynamicProperty(m_parentWidget, m_widget, widgetOrderPropertyC, m_widgetOrderIndex);

    addToWidgetListDynamicProperty(m_parentWidget, m_widget, zOrderPropertyC, m_zOrderIndex);