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

**

** Copyright (C) 2009 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$

**sw

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

#include "abstractformbuilder.h"

#include "formbuilderextra_p.h"

#include "resourcebuilder_p.h"

#include "textbuilder_p.h"

#include "ui4_p.h"

#include "properties_p.h"

#include <QtCore/QVariant>

#include <QtCore/QMetaProperty>

#include <QtCore/QFileInfo>

#include <QtCore/QDir>

#include <QtCore/QQueue>

#include <QtCore/QHash>

#include <QtCore/qdebug.h>

#include <QtCore/QCoreApplication>

#include <QtGui/QAction>

#include <QtGui/QActionGroup>

#include <QtGui/QButtonGroup>

#include <QtGui/QComboBox>

#include <QtGui/QFontComboBox>

#include <QtGui/QGridLayout>

#ifndef QT_NO_FORMLAYOUT

#  include <QtGui/QFormLayout>

#endif

#include <QtGui/QIcon>

#include <QtGui/QListWidget>

#include <QtGui/QMainWindow>

#include <QtGui/QPixmap>

#include <QtGui/QStatusBar>

#include <QtGui/QTreeWidget>

#include <QtGui/QTableWidget>

#include <QtGui/QWidget>

#include <QtGui/QSplitter>

#include <QtGui/QScrollArea>

#include <QtGui/QAbstractButton>

#include <QtGui/QAbstractItemView>

#include <QtGui/QHeaderView>

#ifndef QFORMINTERNAL_NAMESPACE

#  include <private/qlayout_p.h> // Compiling within Designer

#endif

#include <QtXml/QXmlStreamReader>

#include <QtGui/QDialog>

// containers

#include <QtGui/QToolBox>

#include <QtGui/QStackedWidget>

#include <QtGui/QTabWidget>

#include <QtGui/QToolBar>

#include <QtGui/QMenuBar>

#include <QtGui/QDockWidget>

#include <QtGui/QMdiArea>

#include <QtGui/QWorkspace>

#include <QtGui/QWizard>

#include <QtGui/QWizardPage>

#include <QtCore/qdebug.h>

#include <limits.h>

Q_DECLARE_METATYPE(QWidgetList)

static const char *buttonGroupPropertyC = "buttonGroup";

QT_BEGIN_NAMESPACE

#ifdef QFORMINTERNAL_NAMESPACE

using namespace QFormInternal;

#endif

class QFriendlyLayout: public QLayout

{

public:

    inline QFriendlyLayout() { Q_ASSERT(0); }

#ifdef QFORMINTERNAL_NAMESPACE

    friend class QFormInternal::QAbstractFormBuilder;

#else

    friend class QAbstractFormBuilder;

#endif

};

/*!

    \class QAbstractFormBuilder

    \brief The QAbstractFormBuilder class provides a default

    implementation for classes that create user interfaces at

    run-time.

    \inmodule QtDesigner

    QAbstractFormBuilder provides a standard interface and a default

    implementation for constructing forms from user interface

    files. It is not intended to be instantiated directly. Use the

    QFormBuilder class to create user interfaces from UI files at

    run-time. For example:

    \snippet doc/src/snippets/code/tools_designer_src_lib_uilib_abstractformbuilder.cpp 0

    To override certain aspects of the form builder's behavior,

    subclass QAbstractFormBuilder and reimplement the relevant virtual

    functions:

    \list

    \o load() handles reading of UI format files from arbitrary

       QIODevices, and construction of widgets from the XML data

       that they contain.

    \o save() handles saving of widget details in UI format to

       arbitrary QIODevices.

    \o workingDirectory() and setWorkingDirectory() control the

       directory in which forms are held. The form builder looks for

       other resources on paths relative to this directory.

    \endlist

    The QFormBuilder class is typically used by custom components and

    applications that embed \QD. Standalone applications that need to

    dynamically generate user interfaces at run-time use the

    QUiLoader, found in the QtUiTools module.

    \sa {QtUiTools Module}

*/

/*!

    Constructs a new form builder.*/

QAbstractFormBuilder::QAbstractFormBuilder() :

    m_defaultMargin(INT_MIN),

    m_defaultSpacing(INT_MIN)

{

    setResourceBuilder(new QResourceBuilder());

    setTextBuilder(new QTextBuilder());

}

/*!

    Destroys the form builder.*/

QAbstractFormBuilder::~QAbstractFormBuilder()

{

    QFormBuilderExtra::removeInstance(this);

}

/*!

    \fn QWidget *QAbstractFormBuilder::load(QIODevice *device, QWidget *parent)

    Loads an XML representation of a widget from the given \a device,

    and constructs a new widget with the specified \a parent.

    \sa save()

*/

QWidget *QAbstractFormBuilder::load(QIODevice *dev, QWidget *parentWidget)

{

    QXmlStreamReader reader;

    reader.setDevice(dev);

    DomUI ui;

    bool initialized = false;

    const QString uiElement = QLatin1String("ui");

    while (!reader.atEnd()) {

        if (reader.readNext() == QXmlStreamReader::StartElement) {

            if (reader.name().compare(uiElement, Qt::CaseInsensitive) == 0) {

                ui.read(reader);

                initialized = true;

            } else {

                reader.raiseError(QCoreApplication::translate("QAbstractFormBuilder", "Unexpected element <%1>").arg(reader.name().toString()));

            }

        }

    }

    if (reader.hasError()) {

        uiLibWarning(QCoreApplication::translate("QAbstractFormBuilder", "An error has occurred while reading the UI file at line %1, column %2: %3")

                                .arg(reader.lineNumber()).arg(reader.columnNumber())

                                .arg(reader.errorString()));

        return 0;

    }

    if (!initialized) {

        uiLibWarning(QCoreApplication::translate("QAbstractFormBuilder", "Invalid UI file: The root element <ui> is missing."));

        return 0;

    }

    QWidget *widget = create(&ui, parentWidget);

    return widget;

}

/*!

    \internal

*/

QWidget *QAbstractFormBuilder::create(DomUI *ui, QWidget *parentWidget)

{

    typedef QFormBuilderExtra::ButtonGroupHash ButtonGroupHash;

    QFormBuilderExtra *formBuilderPrivate = QFormBuilderExtra::instance(this);

    formBuilderPrivate->clear();

    if (const DomLayoutDefault *def = ui->elementLayoutDefault()) {

       m_defaultMargin = def->hasAttributeMargin() ? def->attributeMargin() : INT_MIN;

        m_defaultSpacing = def->hasAttributeSpacing() ? def->attributeSpacing() : INT_MIN;

    }

    DomWidget *ui_widget = ui->elementWidget();

    if (!ui_widget)

        return 0;

    initialize(ui);

    if (const DomButtonGroups *domButtonGroups = ui->elementButtonGroups())

        formBuilderPrivate->registerButtonGroups(domButtonGroups);

    if (QWidget *widget = create(ui_widget, parentWidget)) {

        // Reparent button groups that were actually created to main container for them to be found in the signal/slot part

        const ButtonGroupHash &buttonGroups = formBuilderPrivate->buttonGroups();

        if (!buttonGroups.empty()) {

            const ButtonGroupHash::const_iterator cend = buttonGroups.constEnd();

            for (ButtonGroupHash::const_iterator it = buttonGroups.constBegin(); it != cend; ++it)

                if (it.value().second)

                    it.value().second->setParent(widget);

        }

        createConnections(ui->elementConnections(), widget);

        createResources(ui->elementResources()); // maybe this should go first, before create()...

        applyTabStops(widget, ui->elementTabStops());

        formBuilderPrivate->applyInternalProperties();

        reset();

        formBuilderPrivate->clear();

        return widget;

    }

    formBuilderPrivate->clear();

    return 0;

}

/*!

    \internal

    Retrieve relevant information from the custom widgets section.

    Called by create(DomUI *, QWidget *); call manually if you

    just use create(DomWidget *, QWidget *) on some child widget of DomUI.

 */

void QAbstractFormBuilder::initialize(const DomUI *ui)

{

    typedef QList<DomCustomWidget*> DomCustomWidgetList;

    DomCustomWidgets *domCustomWidgets  = ui->elementCustomWidgets();

    createCustomWidgets(domCustomWidgets);

    if (domCustomWidgets) {

        const DomCustomWidgetList customWidgets = domCustomWidgets->elementCustomWidget();

        if (!customWidgets.empty()) {

            QFormBuilderExtra *formBuilderPrivate = QFormBuilderExtra::instance(this);

            const DomCustomWidgetList::const_iterator cend = customWidgets.constEnd();

            for (DomCustomWidgetList::const_iterator it = customWidgets.constBegin(); it != cend; ++it) {

                const DomCustomWidget *cw = *it;

#ifndef QT_FORMBUILDER_NO_SCRIPT

                if (const DomScript *domScript = cw->elementScript()) {

                    const QString script = domScript->text();

                    if (!script.isEmpty())

                        formBuilderPrivate->storeCustomWidgetScript(cw->elementClass(), script);

                }

#endif

                const QString addPageMethod = cw->elementAddPageMethod();

                if (!addPageMethod.isEmpty())

                    formBuilderPrivate->storeCustomWidgetAddPageMethod(cw->elementClass(), addPageMethod);

                const QString extends = cw->elementExtends();

                if (!extends.isEmpty())

                    formBuilderPrivate->storeCustomWidgetBaseClass(cw->elementClass(), extends);

            }

        }

    }

}

/*!

    \internal

*/

QWidget *QAbstractFormBuilder::create(DomWidget *ui_widget, QWidget *parentWidget)

{

    QWidget *w = createWidget(ui_widget->attributeClass(), parentWidget, ui_widget->attributeName());

    if (!w)

        return 0;

    applyProperties(w, ui_widget->elementProperty());

    foreach (DomAction *ui_action, ui_widget->elementAction()) {

        QAction *child_action = create(ui_action, w);

        Q_UNUSED( child_action );

    }

    foreach (DomActionGroup *ui_action_group, ui_widget->elementActionGroup()) {

        QActionGroup *child_action_group = create(ui_action_group, w);

        Q_UNUSED( child_action_group );

    }

    QWidgetList children;

    foreach (DomWidget *ui_child, ui_widget->elementWidget()) {

        if (QWidget *child  = create(ui_child, w)) {

            children += child;

        } else {

            const QString className = ui_child->elementClass().empty() ? QString() : ui_child->elementClass().front();

            uiLibWarning(QCoreApplication::translate("QAbstractFormBuilder", "The creation of a widget of the class '%1' failed.").arg(className));

        }

    }

    foreach (DomLayout *ui_lay, ui_widget->elementLayout()) {

        QLayout *child_lay = create(ui_lay, 0, w);

        Q_UNUSED( child_lay );

    }

    const QList<DomActionRef *> addActions = ui_widget->elementAddAction();

    if (!addActions.empty()) {

        const QFormBuilderStrings &strings = QFormBuilderStrings::instance();

        foreach (DomActionRef *ui_action_ref, addActions) {

            const QString name = ui_action_ref->attributeName();

            if (name == strings.separator) {

                QAction *sep = new QAction(w);

                sep->setSeparator(true);

                w->addAction(sep);

                addMenuAction(sep);

            } else if (QAction *a = m_actions.value(name)) {

                w->addAction(a);

            } else if (QActionGroup *g = m_actionGroups.value(name)) {

                w->addActions(g->actions());

            } else if (QMenu *menu = qFindChild<QMenu*>(w, name)) {

                w->addAction(menu->menuAction());

                addMenuAction(menu->menuAction());

            }

        }

    }

    loadExtraInfo(ui_widget, w, parentWidget);

#ifndef QT_FORMBUILDER_NO_SCRIPT

    QString scriptErrorMessage;

    QFormBuilderExtra *extra = QFormBuilderExtra::instance(this);

    extra->formScriptRunner().run(ui_widget,

                                  extra->customWidgetScript(ui_widget->attributeClass()),

                                  w, children, &scriptErrorMessage);

#endif

    addItem(ui_widget, w, parentWidget);

    if (qobject_cast<QDialog *>(w) && parentWidget)

        w->setAttribute(Qt::WA_Moved, false); // So that QDialog::setVisible(true) will center it

    const QStringList zOrderNames = ui_widget->elementZOrder();

    if (!zOrderNames.isEmpty()) {

        QList<QWidget *> zOrder = qVariantValue<QWidgetList>(w->property("_q_zOrder"));

        foreach (QString widgetName, zOrderNames) {

            if (QWidget *child = qFindChild<QWidget*>(w, widgetName)) {

                if (child->parentWidget() == w) {

                    zOrder.removeAll(child);

                    zOrder.append(child);

                    child->raise();

                }

            }

        }

        w->setProperty("_q_zOrder", qVariantFromValue(zOrder));

    }

    return w;

}

/*!

    \internal

*/

QAction *QAbstractFormBuilder::create(DomAction *ui_action, QObject *parent)

{

    QAction *a = createAction(parent, ui_action->attributeName());

    if (!a)

        return 0;

    m_actions.insert(ui_action->attributeName(), a);

    applyProperties(a, ui_action->elementProperty());

    return a;

}

/*!

    \internal

*/

QActionGroup *QAbstractFormBuilder::create(DomActionGroup *ui_action_group, QObject *parent)

{

    QActionGroup *a = createActionGroup(parent, ui_action_group->attributeName());

    if (!a)

        return 0;

    m_actionGroups.insert(ui_action_group->attributeName(), a);

    applyProperties(a, ui_action_group->elementProperty());

    foreach (DomAction *ui_action, ui_action_group->elementAction()) {

        QAction *child_action = create(ui_action, a);

        Q_UNUSED( child_action );

    }

    foreach (DomActionGroup *g, ui_action_group->elementActionGroup()) {

        QActionGroup *child_action_group = create(g, parent);

        Q_UNUSED( child_action_group );

    }

    return a;

}

// figure out the toolbar area of a DOM attrib list.

// By legacy, it is stored as an integer. As of 4.3.0, it is the enumeration value.

Qt::ToolBarArea QAbstractFormBuilder::toolbarAreaFromDOMAttributes(const DomPropertyHash &attributes) {

    const DomProperty *attr = attributes.value(QFormBuilderStrings::instance().toolBarAreaAttribute);

    if (!attr)

        return Qt::TopToolBarArea;

    switch(attr->kind()) {

    case DomProperty::Number:

        return static_cast<Qt::ToolBarArea>(attr->elementNumber());

    case DomProperty::Enum:

        return enumKeyOfObjectToValue<QAbstractFormBuilderGadget, Qt::ToolBarArea>("toolBarArea",  attr->elementEnum().toLatin1());

    default:

        break;

    }

    return Qt::TopToolBarArea;

}

/*!

    \internal

*/

bool QAbstractFormBuilder::addItem(DomWidget *ui_widget, QWidget *widget, QWidget *parentWidget)

{

    const QFormBuilderStrings &strings = QFormBuilderStrings::instance();

    const DomPropertyHash attributes = propertyMap(ui_widget->elementAttribute());

    if (parentWidget == 0)

        return true;

    // Check special cases. First: Custom container

    const QString className = QLatin1String(parentWidget->metaObject()->className());

    const QString addPageMethod = QFormBuilderExtra::instance(this)->customWidgetAddPageMethod(className);

    if (!addPageMethod.isEmpty()) {

        // If this fails ( non-existent or non-slot), use ContainerExtension in Designer, else it can't be helped

        return QMetaObject::invokeMethod(parentWidget, addPageMethod.toUtf8().constData(), Qt::DirectConnection, Q_ARG(QWidget*, widget));

    }

    if (QMainWindow *mw = qobject_cast<QMainWindow*>(parentWidget)) {

#ifndef QT_NO_MENUBAR

        // the menubar

        if (QMenuBar *menuBar = qobject_cast<QMenuBar*>(widget)) {

            mw->setMenuBar(menuBar);

            return true;

        }

#endif

#ifndef QT_NO_TOOLBAR

        // apply the toolbar's attributes

        else if (QToolBar *toolBar = qobject_cast<QToolBar*>(widget)) {

            mw->addToolBar(toolbarAreaFromDOMAttributes(attributes), toolBar);

            // check break

            if (const DomProperty *attr = attributes.value(strings.toolBarBreakAttribute))

                if (attr->elementBool() == strings.trueValue)

                    mw->insertToolBarBreak (toolBar);

            return true;

        }

#endif

#ifndef QT_NO_STATUSBAR

        // statusBar

        else if (QStatusBar *statusBar = qobject_cast<QStatusBar*>(widget)) {

            mw->setStatusBar(statusBar);

            return true;

        }

#endif

#ifndef QT_NO_DOCKWIDGET

        // apply the dockwidget's attributes

        else if (QDockWidget *dockWidget = qobject_cast<QDockWidget*>(widget)) {

            if (const DomProperty *attr = attributes.value(strings.dockWidgetAreaAttribute)) {

                Qt::DockWidgetArea area = static_cast<Qt::DockWidgetArea>(attr->elementNumber());

                if (!dockWidget->isAreaAllowed(area)) {

                    if (dockWidget->isAreaAllowed(Qt::LeftDockWidgetArea))

                        area = Qt::LeftDockWidgetArea;

                    else if (dockWidget->isAreaAllowed(Qt::RightDockWidgetArea))

                        area = Qt::RightDockWidgetArea;

                    else if (dockWidget->isAreaAllowed(Qt::TopDockWidgetArea))

                        area = Qt::TopDockWidgetArea;

                    else if (dockWidget->isAreaAllowed(Qt::BottomDockWidgetArea))

                        area = Qt::BottomDockWidgetArea;

                }

                mw->addDockWidget(area, dockWidget);

            } else {

                mw->addDockWidget(Qt::LeftDockWidgetArea, dockWidget);

            }

            return true;

        }

#endif

        else if (! mw->centralWidget()) {

            mw->setCentralWidget(widget);

            return true;

        }

    }