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

**

** 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$

**

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

#include "widgetfactory_p.h"

#include "widgetdatabase_p.h"

#include "metadatabase_p.h"

#include "qlayout_widget_p.h"

#include "qdesigner_widget_p.h"

#include "qdesigner_tabwidget_p.h"

#include "qdesigner_toolbox_p.h"

#include "qdesigner_stackedbox_p.h"

#include "qdesigner_toolbar_p.h"

#include "qdesigner_menubar_p.h"

#include "qdesigner_menu_p.h"

#include "qdesigner_dockwidget_p.h"

#include "qdesigner_utils_p.h"

#include "formwindowbase_p.h"

// shared

#include "layoutinfo_p.h"

#include "spacer_widget_p.h"

#include "layout_p.h"

#include "abstractintrospection_p.h"

// sdk

#include <QtDesigner/QDesignerFormEditorInterface>

#include <QtDesigner/QDesignerContainerExtension>

#include <QtDesigner/QDesignerCustomWidgetInterface>

#include <QtDesigner/QExtensionManager>

#include <QtDesigner/QDesignerPropertySheetExtension>

#include <QtDesigner/QDesignerLanguageExtension>

#include <QtDesigner/QDesignerFormWindowManagerInterface>

#include <QtDesigner/QDesignerFormWindowCursorInterface>

#include <QtGui/QtGui>

#include <QtGui/QScrollBar>

#include <QtGui/QFontComboBox>

#include <QtGui/QAbstractSpinBox>

#include <QtGui/QLineEdit>

#include <QtGui/QButtonGroup>

#include <QtGui/QStyle>

#include <QtGui/QStyleFactory>

#include <QtGui/QWizard>

#include <QtCore/qdebug.h>

#include <QtCore/QMetaObject>

QT_BEGIN_NAMESPACE

#ifdef Q_OS_WIN

static inline bool isAxWidget(const QObject *o)

{

    // Is it one of  QDesignerAxWidget/QDesignerAxPluginWidget?

    static const char *axWidgetName = "QDesignerAx";

    static const unsigned axWidgetNameLen = qstrlen(axWidgetName);

    return qstrncmp(o->metaObject()->className(), axWidgetName, axWidgetNameLen) == 0;

}

#endif

/* Dynamic boolean property indicating object was created by the factory

 * for the form editor. */

static const char *formEditorDynamicProperty = "_q_formEditorObject";

namespace qdesigner_internal {

// A friendly SpinBox that grants access to its QLineEdit

class FriendlySpinBox : public QAbstractSpinBox {

public:

    friend class WidgetFactory;

};

// An event filter for form-combo boxes that prevents the embedded line edit

// from getting edit focus (and drawing blue artifacts/lines). It catches the

// ChildPolished event when the "editable" property flips to true and the

// QLineEdit is created and turns off the LineEdit's focus policy.

class ComboEventFilter : public QObject {

public:

    explicit ComboEventFilter(QComboBox *parent) : QObject(parent) {}

    virtual bool eventFilter(QObject *watched, QEvent *event);

};

bool ComboEventFilter::eventFilter(QObject *watched, QEvent *event)

{

    if (event->type() == QEvent::ChildPolished) {

        QComboBox *cb = static_cast<QComboBox*>(watched);

        if (QLineEdit *le = cb->lineEdit())

            le->setFocusPolicy(Qt::NoFocus);

    }

    return QObject::eventFilter(watched, event);

}

/* Watch out for QWizards changing their pages and make sure that not some

 * selected widget becomes invisible on a hidden page (causing the selection

 * handles to shine through). Select the wizard in that case  in analogy to

 * the QTabWidget event filters, etc. */

class WizardPageChangeWatcher : public QObject {

    Q_OBJECT

public:

    explicit WizardPageChangeWatcher(QWizard *parent);

public slots:

    void pageChanged();

};

WizardPageChangeWatcher::WizardPageChangeWatcher(QWizard *parent) :

    QObject(parent)

{

    connect(parent, SIGNAL(currentIdChanged(int)), this, SLOT(pageChanged()));

}

void WizardPageChangeWatcher::pageChanged()

{

    /* Use a bit more conservative approach than that for the QTabWidget,

     * change the selection only if a selected child becomes invisible by

     * changing the page. */

    QWizard *wizard = static_cast<QWizard *>(parent());

    QDesignerFormWindowInterface *fw = QDesignerFormWindowInterface::findFormWindow(wizard);

    if (!fw)

        return;

    QDesignerFormWindowCursorInterface *cursor = fw->cursor();

    const int selCount = cursor->selectedWidgetCount();

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

        if (!cursor->selectedWidget(i)->isVisible()) {

            fw->clearSelection(false);

            fw->selectWidget(wizard, true);

            break;

        }

    }

}

// ---------------- WidgetFactory::Strings

WidgetFactory::Strings::Strings() :

    m_alignment(QLatin1String("alignment")),

    m_bottomMargin(QLatin1String("bottomMargin")),

    m_geometry(QLatin1String("geometry")),

    m_leftMargin(QLatin1String("leftMargin")),

    m_line(QLatin1String("Line")),

    m_objectName(QLatin1String("objectName")),

    m_spacerName(QLatin1String("spacerName")),

    m_orientation(QLatin1String("orientation")),

    m_q3WidgetStack(QLatin1String("Q3WidgetStack")),

    m_qAction(QLatin1String("QAction")),

    m_qButtonGroup(QLatin1String("QButtonGroup")),

    m_qAxWidget(QLatin1String("QAxWidget")),

    m_qDialog(QLatin1String("QDialog")),

    m_qDockWidget(QLatin1String("QDockWidget")),

    m_qLayoutWidget(QLatin1String("QLayoutWidget")),

    m_qMenu(QLatin1String("QMenu")),

    m_qMenuBar(QLatin1String("QMenuBar")),

    m_qWidget(QLatin1String("QWidget")),

    m_rightMargin(QLatin1String("rightMargin")),

    m_sizeHint(QLatin1String("sizeHint")),

    m_spacer(QLatin1String("Spacer")),

    m_text(QLatin1String("text")),

    m_title(QLatin1String("title")),

    m_topMargin(QLatin1String("topMargin")),

    m_windowIcon(QLatin1String("windowIcon")),

    m_windowTitle(QLatin1String("windowTitle"))

{

}

// ---------------- WidgetFactory

QPointer<QWidget> *WidgetFactory::m_lastPassiveInteractor = new QPointer<QWidget>();

bool WidgetFactory::m_lastWasAPassiveInteractor = false;

const char *WidgetFactory::disableStyleCustomPaintingPropertyC = "_q_custom_style_disabled";

WidgetFactory::WidgetFactory(QDesignerFormEditorInterface *core, QObject *parent)

    : QDesignerWidgetFactoryInterface(parent),

      m_core(core),

      m_formWindow(0),

      m_currentStyle(0)

{

}

WidgetFactory::~WidgetFactory()

{

}

QDesignerFormWindowInterface *WidgetFactory::currentFormWindow(QDesignerFormWindowInterface *fw)

{

    QDesignerFormWindowInterface *was = m_formWindow;

    m_formWindow = fw;

    return was;

}

void WidgetFactory::loadPlugins()

{

    m_customFactory.clear();

    QDesignerPluginManager *pluginManager = m_core->pluginManager();

    QList<QDesignerCustomWidgetInterface*> lst = pluginManager->registeredCustomWidgets();

    foreach (QDesignerCustomWidgetInterface *c, lst) {

        m_customFactory.insert(c->name(), c);

    }

}

// Convencience to create non-widget objects. Returns 0 if unknown

QObject* WidgetFactory::createObject(const QString &className, QObject* parent) const

{

    if (className.isEmpty()) {

        qWarning("** WARNING %s called with an empty class name", Q_FUNC_INFO);

        return 0;

    }

    if (className == m_strings.m_qAction)

        return new QAction(parent);

    if (className == m_strings.m_qButtonGroup)

        return new QButtonGroup(parent);

    return 0;

}

QWidget*  WidgetFactory::createCustomWidget(const QString &className, QWidget *parentWidget, bool *creationError) const

{

    *creationError = false;

    CustomWidgetFactoryMap::const_iterator it = m_customFactory.constFind(className);

    if (it == m_customFactory.constEnd())

        return 0;

    QDesignerCustomWidgetInterface *factory = it.value();

    QWidget *rc = factory->createWidget(parentWidget);

    // shouldn't happen

    if (!rc) {

        *creationError = true;

        designerWarning(tr("The custom widget factory registered for widgets of class %1 returned 0.").arg(className));

        return 0;

    }

    // Figure out the base class unless it is known

    static QSet<QString> knownCustomClasses;

    if (!knownCustomClasses.contains(className)) {

        QDesignerWidgetDataBaseInterface *wdb = m_core->widgetDataBase();

        const int widgetInfoIndex = wdb->indexOfObject(rc, false);

        if (widgetInfoIndex != -1) {

            if (wdb->item(widgetInfoIndex)->extends().isEmpty()) {

                const QDesignerMetaObjectInterface *mo = core()->introspection()->metaObject(rc)->superClass();

                // If we hit on a 'Q3DesignerXXWidget' that claims to be a 'Q3XXWidget', step

                // over.

                if (mo && mo->className() == className)

                    mo = mo->superClass();

                while (mo != 0) {

                    if (core()->widgetDataBase()->indexOfClassName(mo->className()) != -1) {

                        wdb->item(widgetInfoIndex)->setExtends(mo->className());

                        break;

                    }

                    mo = mo->superClass();

                }

            }

            knownCustomClasses.insert(className);

        }

    }

    // Since a language plugin may lie about its names, like Qt Jambi

    // does, return immediately here...

    QDesignerLanguageExtension *lang =

        qt_extension<QDesignerLanguageExtension *>(m_core->extensionManager(), m_core);

    if (lang)

        return rc;

#ifdef Q_OS_WIN

    if (isAxWidget(rc))

       return rc;

#endif

    // Check for mismatched class names which is hard to track.

    // Perform literal comparison first for QAxWidget, for which a meta object hack is in effect.

    const char *createdClassNameC = rc->metaObject()->className();

    const QByteArray classNameB = className.toUtf8();

    const char *classNameC = classNameB.constData();

    if (qstrcmp(createdClassNameC, classNameC) && !rc->inherits(classNameC))

        designerWarning(tr("A class name mismatch occurred when creating a widget using the custom widget factory registered for widgets of class %1."

                           " It returned a widget of class %2.").arg(className).arg(QString::fromUtf8(createdClassNameC)));

    return rc;

}

QWidget *WidgetFactory::createWidget(const QString &widgetName, QWidget *parentWidget) const

{

    if (widgetName.isEmpty()) {

        qWarning("** WARNING %s called with an empty class name", Q_FUNC_INFO);

        return 0;

    }

    // Preview or for form window?

    QDesignerFormWindowInterface *fw = m_formWindow;

    if (! fw)

        fw = QDesignerFormWindowInterface::findFormWindow(parentWidget);

    QWidget *w = 0;

    do {

        // 1) custom. If there is an explicit failure(factory wants to indicate something is wrong),

        //    return 0, do not try to find fallback, which might be worse in the case of Q3 widget.

        bool customWidgetCreationError;

        w = createCustomWidget(widgetName, parentWidget, &customWidgetCreationError);

        if (w) {

            break;

        } else {

            if (customWidgetCreationError)

                return 0;

        }

        // 2) Special widgets

        if (widgetName == m_strings.m_line) {

            w = new Line(parentWidget);

        } else if (widgetName == m_strings.m_qDockWidget) {

            w = new QDesignerDockWidget(parentWidget);

        } else if (widgetName == m_strings.m_qMenuBar) {

            w = new QDesignerMenuBar(parentWidget);

        } else if (widgetName == m_strings.m_qMenu) {

            w = new QDesignerMenu(parentWidget);

        } else if (widgetName == m_strings.m_spacer) {

            w = new Spacer(parentWidget);

        } else if (widgetName == m_strings.m_qDockWidget) {

            w = new QDesignerDockWidget(parentWidget);

        } else if (widgetName == m_strings.m_qLayoutWidget) {

            w = fw ? new QLayoutWidget(fw, parentWidget) : new QWidget(parentWidget);

        } else if (widgetName == m_strings.m_qDialog) {

            if (fw) {

                w = new QDesignerDialog(fw, parentWidget);

            } else {

                w = new QDialog(parentWidget);

            }

        } else if (widgetName == m_strings.m_qWidget) {

            /* We want a 'QDesignerWidget' that draws a grid only for widget

             * forms and container extension pages (not for preview and not

             * for normal QWidget children on forms (legacy) */

            if (fw && parentWidget) {

                if (qt_extension<QDesignerContainerExtension*>(m_core->extensionManager(), parentWidget)) {

                    w = new QDesignerWidget(fw, parentWidget);

                } else {

                    if (const FormWindowBase *fwb = qobject_cast<FormWindowBase *>(fw))

                        if (parentWidget == fwb->formContainer())

                            w = new QDesignerWidget(fw, parentWidget);

                }

            }

            if (!w)

                w = new QWidget(parentWidget);

        }

        if (w)

            break;

        // 3) table

        const QByteArray widgetNameBA = widgetName.toUtf8();

        const char *widgetNameC = widgetNameBA.constData();

        if (w) { // symmetry for macro

        }

#define DECLARE_LAYOUT(L, C)

#define DECLARE_COMPAT_WIDGET(W, C) /*DECLARE_WIDGET(W, C)*/

#define DECLARE_WIDGET(W, C) else if (!qstrcmp(widgetNameC, #W)) { Q_ASSERT(w == 0); w = new W(parentWidget); }

#define DECLARE_WIDGET_1(W, C) else if (!qstrcmp(widgetNameC, #W)) { Q_ASSERT(w == 0); w = new W(0, parentWidget); }

#include "widgets.table"

#undef DECLARE_COMPAT_WIDGET

#undef DECLARE_LAYOUT

#undef DECLARE_WIDGET

#undef DECLARE_WIDGET_1

        if (w)

            break;

        // 4) fallBack

        const QString fallBackBaseClass = m_strings.m_qWidget;

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

        QDesignerWidgetDataBaseItemInterface *item = db->item(db->indexOfClassName(widgetName));

        if (item == 0) {

            // Emergency: Create, derived from QWidget

            QString includeFile = widgetName.toLower();

            includeFile +=  QLatin1String(".h");

            item = appendDerived(db,widgetName, tr("%1 Widget").arg(widgetName),fallBackBaseClass,

                                 includeFile, true, true);

            Q_ASSERT(item);

        }

        QString baseClass = item->extends();

        if (baseClass.isEmpty()) {

            // Currently happens in the case of Q3-Support widgets

            baseClass =fallBackBaseClass;

        }

        w = createWidget(baseClass, parentWidget);

        promoteWidget(core(),w,widgetName);

    } while (false);

    Q_ASSERT(w != 0);

    if (m_currentStyle)

        w->setStyle(m_currentStyle);

     initializeCommon(w);

    if (fw) { // form editor  initialization

        initialize(w);

    } else { // preview-only initialization

        initializePreview(w);

    }

    return w;

}

QString WidgetFactory::classNameOf(QDesignerFormEditorInterface *c, const QObject* o)

{

    if (o == 0)

        return QString();

    const char *className = o->metaObject()->className();

    if (!o->isWidgetType())

        return QLatin1String(className);

    const QWidget *w = static_cast<const QWidget*>(o);

    // check promoted before designer special

    const QString customClassName = promotedCustomClassName(c, const_cast<QWidget*>(w));

    if (!customClassName.isEmpty())

        return customClassName;

    if (qobject_cast<const QDesignerMenuBar*>(w))

        return QLatin1String("QMenuBar");

    else if (qobject_cast<const QDesignerMenu*>(w))

        return QLatin1String("QMenu");

     else if (qobject_cast<const QDesignerDockWidget*>(w))

        return QLatin1String("QDockWidget");

    else if (qobject_cast<const QDesignerDialog*>(w))

        return QLatin1String("QDialog");

    else if (qobject_cast<const QDesignerWidget*>(w))

        return QLatin1String("QWidget");

#ifdef Q_OS_WIN

    else if (isAxWidget(w))

        return QLatin1String("QAxWidget");

#endif

    else if (qstrcmp(className, "QDesignerQ3WidgetStack") == 0)

        return QLatin1String("Q3WidgetStack");

    return QLatin1String(className);

}

QLayout *WidgetFactory::createUnmanagedLayout(QWidget *parentWidget, int type)

{

    switch (type) {

    case LayoutInfo::HBox:

        return new QHBoxLayout(parentWidget);

    case LayoutInfo::VBox:

        return new QVBoxLayout(parentWidget);

    case LayoutInfo::Grid:

        return new QGridLayout(parentWidget);

    case LayoutInfo::Form:

        return new QFormLayout(parentWidget);

    default:

        Q_ASSERT(0);

        break;

    }

    return 0;

}

/*!  Creates a layout on the widget \a widget of the type \a type

  which can be \c HBox, \c VBox or \c Grid.

*/

QLayout *WidgetFactory::createLayout(QWidget *widget, QLayout *parentLayout, int type) const // ### (sizepolicy)

{

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

    if (parentLayout == 0) {

        QWidget *page = containerOfWidget(widget);

        if (page) {

            widget = page;

        } else {

            const QString msg = tr("The current page of the container '%1' (%2) could not be determined while creating a layout."

"This indicates an inconsistency in the ui-file, probably a layout being constructed on a container widget.").arg(widget->objectName()).arg(classNameOf(core(), widget));

            designerWarning(msg);

        }

    }

    Q_ASSERT(metaDataBase->item(widget) != 0); // ensure the widget is managed

    if (parentLayout == 0 && metaDataBase->item(widget->layout()) == 0) {

        parentLayout = widget->layout();

    }

    QWidget *parentWidget = parentLayout != 0 ? 0 : widget;

    QLayout *layout = createUnmanagedLayout(parentWidget, type);

    metaDataBase->add(layout); // add the layout in the MetaDataBase

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

    sheet->setChanged(sheet->indexOf(m_strings.m_objectName), true);

    if (widget->inherits("Q3GroupBox")) {

        layout->setContentsMargins(widget->style()->pixelMetric(QStyle::PM_LayoutLeftMargin),

                                    widget->style()->pixelMetric(QStyle::PM_LayoutTopMargin),

                                    widget->style()->pixelMetric(QStyle::PM_LayoutRightMargin),

                                    widget->style()->pixelMetric(QStyle::PM_LayoutBottomMargin));

        QGridLayout *grid = qobject_cast<QGridLayout *>(layout);

        if (grid) {

            grid->setHorizontalSpacing(-1);

            grid->setVerticalSpacing(-1);

        } else {

            layout->setSpacing(-1);

        }

        layout->setAlignment(Qt::AlignTop);