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

**

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

#include "widgetfactory_p.h"

#include "spacer_widget_p.h"

#include "abstractlanguage.h"

#include "pluginmanager_p.h"

#include "qdesigner_widgetbox_p.h"

#include "qdesigner_utils_p.h"

#include <ui4_p.h>

#include <QtDesigner/customwidget.h>

#include <QtDesigner/propertysheet.h>

#include <QtDesigner/QExtensionManager>

#include <QtDesigner/QDesignerFormEditorInterface>

#include <QtXml/QXmlStreamWriter>

#include <QtCore/QtAlgorithms>

#include <QtCore/qdebug.h>

#include <QtCore/QMetaProperty>

#include <QtCore/QTextStream>

#include <QtCore/QRegExp>

#include <QtCore/QCoreApplication>

QT_BEGIN_NAMESPACE

namespace {

    enum { debugWidgetDataBase = 0 };

}

namespace qdesigner_internal {

// ----------------------------------------------------------

WidgetDataBaseItem::WidgetDataBaseItem(const QString &name, const QString &group)

    : m_name(name),

      m_group(group),

      m_compat(0),

      m_container(0),

      m_form(0),

      m_custom(0),

      m_promoted(0)

{

}

QString WidgetDataBaseItem::name() const

{

    return m_name;

}

void WidgetDataBaseItem::setName(const QString &name)

{

    m_name = name;

}

QString WidgetDataBaseItem::group() const

{

    return m_group;

}

void WidgetDataBaseItem::setGroup(const QString &group)

{

    m_group = group;

}

QString WidgetDataBaseItem::toolTip() const

{

    return m_toolTip;

}

void WidgetDataBaseItem::setToolTip(const QString &toolTip)

{

    m_toolTip = toolTip;

}

QString WidgetDataBaseItem::whatsThis() const

{

    return m_whatsThis;

}

void WidgetDataBaseItem::setWhatsThis(const QString &whatsThis)

{

    m_whatsThis = whatsThis;

}

QString WidgetDataBaseItem::includeFile() const

{

    return m_includeFile;

}

void WidgetDataBaseItem::setIncludeFile(const QString &includeFile)

{

    m_includeFile = includeFile;

}

QIcon WidgetDataBaseItem::icon() const

{

    return m_icon;

}

void WidgetDataBaseItem::setIcon(const QIcon &icon)

{

    m_icon = icon;

}

bool WidgetDataBaseItem::isCompat() const

{

    return m_compat;

}

void WidgetDataBaseItem::setCompat(bool b)

{

    m_compat = b;

}

bool WidgetDataBaseItem::isContainer() const

{

    return m_container;

}

void WidgetDataBaseItem::setContainer(bool b)

{

    m_container = b;

}

bool WidgetDataBaseItem::isCustom() const

{

    return m_custom;

}

void WidgetDataBaseItem::setCustom(bool b)

{

    m_custom = b;

}

QString WidgetDataBaseItem::pluginPath() const

{

    return m_pluginPath;

}

void WidgetDataBaseItem::setPluginPath(const QString &path)

{

    m_pluginPath = path;

}

bool WidgetDataBaseItem::isPromoted() const

{

    return m_promoted;

}

void WidgetDataBaseItem::setPromoted(bool b)

{

    m_promoted = b;

}

QString WidgetDataBaseItem::extends() const

{

    return m_extends;

}

void WidgetDataBaseItem::setExtends(const QString &s)

{

    m_extends = s;

}

void WidgetDataBaseItem::setDefaultPropertyValues(const QList<QVariant> &list)

{

    m_defaultPropertyValues = list;

}

QList<QVariant> WidgetDataBaseItem::defaultPropertyValues() const

{

    return m_defaultPropertyValues;

}

QStringList WidgetDataBaseItem::fakeSlots() const

{

    return m_fakeSlots;

}

void WidgetDataBaseItem::setFakeSlots(const QStringList &fs)

{

    m_fakeSlots = fs;

}

QStringList WidgetDataBaseItem::fakeSignals() const

{

     return m_fakeSignals;

}

void WidgetDataBaseItem::setFakeSignals(const QStringList &fs)

{

    m_fakeSignals = fs;

}

QString WidgetDataBaseItem::addPageMethod() const

{

    return m_addPageMethod;

}

void WidgetDataBaseItem::setAddPageMethod(const QString &m)

{

    m_addPageMethod = m;

}

WidgetDataBaseItem *WidgetDataBaseItem::clone(const QDesignerWidgetDataBaseItemInterface *item)

{

    WidgetDataBaseItem *rc = new WidgetDataBaseItem(item->name(), item->group());

    rc->setToolTip(item->toolTip());

    rc->setWhatsThis(item->whatsThis());

    rc->setIncludeFile(item->includeFile());

    rc->setIcon(item->icon());

    rc->setCompat(item->isCompat());

    rc->setContainer(item->isContainer());

    rc->setCustom(item->isCustom() );

    rc->setPluginPath(item->pluginPath());

    rc->setPromoted(item->isPromoted());

    rc->setExtends(item->extends());

    rc->setDefaultPropertyValues(item->defaultPropertyValues());

    // container page method, fake slots and signals ignored here.y

    return rc;

}

// ----------------------------------------------------------

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

    : QDesignerWidgetDataBaseInterface(parent),

      m_core(core)

{

#define DECLARE_LAYOUT(L, C)

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

#define DECLARE_WIDGET(W, C) append(new WidgetDataBaseItem(QString::fromUtf8(#W)));

#include "widgets.table"

#undef DECLARE_COMPAT_WIDGET

#undef DECLARE_LAYOUT

#undef DECLARE_WIDGET

#undef DECLARE_WIDGET_1

    append(new WidgetDataBaseItem(QString::fromUtf8("Line")));

    append(new WidgetDataBaseItem(QString::fromUtf8("Spacer")));

    append(new WidgetDataBaseItem(QString::fromUtf8("QSplitter")));

    append(new WidgetDataBaseItem(QString::fromUtf8("QLayoutWidget")));

    // QDesignerWidget is used as central widget and as container for tab widgets, etc.

    WidgetDataBaseItem *designerWidgetItem = new WidgetDataBaseItem(QString::fromUtf8("QDesignerWidget"));

    designerWidgetItem->setContainer(true);

    append(designerWidgetItem);

    append(new WidgetDataBaseItem(QString::fromUtf8("QDesignerDialog")));

    append(new WidgetDataBaseItem(QString::fromUtf8("QDesignerMenu")));

    append(new WidgetDataBaseItem(QString::fromUtf8("QDesignerMenuBar")));

    append(new WidgetDataBaseItem(QString::fromUtf8("QDesignerDockWidget")));

    append(new WidgetDataBaseItem(QString::fromUtf8("QDesignerQ3WidgetStack")));

    append(new WidgetDataBaseItem(QString::fromUtf8("QAction")));

    append(new WidgetDataBaseItem(QString::fromUtf8("QButtonGroup")));

    // ### remove me

    // ### check the casts

#if 0 // ### enable me after 4.1

    item(indexOfClassName(QLatin1String("QToolBar")))->setContainer(true);

#endif

    item(indexOfClassName(QLatin1String("QTabWidget")))->setContainer(true);

    item(indexOfClassName(QLatin1String("QGroupBox")))->setContainer(true);

    item(indexOfClassName(QLatin1String("QScrollArea")))->setContainer(true);

    item(indexOfClassName(QLatin1String("QStackedWidget")))->setContainer(true);

    item(indexOfClassName(QLatin1String("QToolBox")))->setContainer(true);

    item(indexOfClassName(QLatin1String("QFrame")))->setContainer(true);

    item(indexOfClassName(QLatin1String("QLayoutWidget")))->setContainer(true);

    item(indexOfClassName(QLatin1String("QDesignerWidget")))->setContainer(true);

    item(indexOfClassName(QLatin1String("QDesignerDialog")))->setContainer(true);

    item(indexOfClassName(QLatin1String("QSplitter")))->setContainer(true);

    item(indexOfClassName(QLatin1String("QMainWindow")))->setContainer(true);

    item(indexOfClassName(QLatin1String("QDockWidget")))->setContainer(true);

    item(indexOfClassName(QLatin1String("QDesignerDockWidget")))->setContainer(true);

    item(indexOfClassName(QLatin1String("QDesignerQ3WidgetStack")))->setContainer(true);

    item(indexOfClassName(QLatin1String("QMdiArea")))->setContainer(true);

    item(indexOfClassName(QLatin1String("QWorkspace")))->setContainer(true);

    item(indexOfClassName(QLatin1String("QWizard")))->setContainer(true);

    item(indexOfClassName(QLatin1String("QWizardPage")))->setContainer(true);

    item(indexOfClassName(QLatin1String("QWidget")))->setContainer(true);

    item(indexOfClassName(QLatin1String("QDialog")))->setContainer(true);

}

WidgetDataBase::~WidgetDataBase()

{

}

QDesignerFormEditorInterface *WidgetDataBase::core() const

{

    return m_core;

}

int WidgetDataBase::indexOfObject(QObject *object, bool /*resolveName*/) const

{

    QExtensionManager *mgr = m_core->extensionManager();

    QDesignerLanguageExtension *lang = qt_extension<QDesignerLanguageExtension*> (mgr, m_core);

    QString id;

    if (lang)

        id = lang->classNameOf(object);

    if (id.isEmpty())

        id = WidgetFactory::classNameOf(m_core,object);

    return QDesignerWidgetDataBaseInterface::indexOfClassName(id);

}

static WidgetDataBaseItem *createCustomWidgetItem(const QDesignerCustomWidgetInterface *c,

                                                  const QDesignerCustomWidgetData &data)

{

    WidgetDataBaseItem *item = new WidgetDataBaseItem(c->name(), c->group());

    item->setContainer(c->isContainer());

    item->setCustom(true);

    item->setIcon(c->icon());

    item->setIncludeFile(c->includeFile());

    item->setToolTip(c->toolTip());

    item->setWhatsThis(c->whatsThis());

    item->setPluginPath(data.pluginPath());

    item->setAddPageMethod(data.xmlAddPageMethod());

    item->setExtends(data.xmlExtends());

    return item;

}

void WidgetDataBase::loadPlugins()

{

    typedef QMap<QString, int> NameIndexMap;

    typedef QList<QDesignerWidgetDataBaseItemInterface*> ItemList;

    typedef QMap<QString, QDesignerWidgetDataBaseItemInterface*> NameItemMap;

    typedef QSet<QString> NameSet;

    // 1) create a map of existing custom classes

    NameIndexMap existingCustomClasses;

    NameSet nonCustomClasses;

    const int count = m_items.size();

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

        const QDesignerWidgetDataBaseItemInterface* item =  m_items[i];

        if (item->isCustom() && !item->isPromoted())

            existingCustomClasses.insert(item->name(), i);

        else

            nonCustomClasses.insert(item->name());

    }

    // 2) create a list plugins

    ItemList pluginList;

    const QDesignerPluginManager *pm = m_core->pluginManager();

    foreach(QDesignerCustomWidgetInterface* c, pm->registeredCustomWidgets())

        pluginList += createCustomWidgetItem(c, pm->customWidgetData(c));

    // 3) replace custom classes or add new ones, remove them from existingCustomClasses,

    // leaving behind deleted items

    unsigned replacedPlugins = 0;

    unsigned addedPlugins = 0;

    unsigned removedPlugins = 0;

    if (!pluginList.empty()) {

        ItemList::const_iterator cend = pluginList.constEnd();

        for (ItemList::const_iterator it = pluginList.constBegin();it != cend; ++it )  {

            QDesignerWidgetDataBaseItemInterface* pluginItem = *it;

            const QString pluginName = pluginItem->name();

            NameIndexMap::iterator existingIt = existingCustomClasses.find(pluginName);

            if (existingIt == existingCustomClasses.end()) {

                // Add new class.

                if (nonCustomClasses.contains(pluginName)) {

                    designerWarning(tr("A custom widget plugin whose class name (%1) matches that of an existing class has been found.").arg(pluginName));

                } else {

                    append(pluginItem);

                    addedPlugins++;

                }

            } else {

                // replace existing info

                const int existingIndex = existingIt.value();

                delete m_items[existingIndex];

                m_items[existingIndex] = pluginItem;

                existingCustomClasses.erase(existingIt);

                replacedPlugins++;

            }

        }

    }

    // 4) remove classes that have not been matched. The stored indexes become invalid while deleting.

    if (!existingCustomClasses.empty()) {

        NameIndexMap::const_iterator cend = existingCustomClasses.constEnd();

        for (NameIndexMap::const_iterator it = existingCustomClasses.constBegin();it != cend; ++it )  {

            const int index = indexOfClassName(it.key());

            if (index != -1) {

                remove(index);

                removedPlugins++;

            }

        }

    }

    if (debugWidgetDataBase)

        qDebug() << "WidgetDataBase::loadPlugins(): " << addedPlugins << " added, " << replacedPlugins << " replaced, " << removedPlugins << "deleted.";

}

void WidgetDataBase::remove(int index)

{

    Q_ASSERT(index < m_items.size());

    delete m_items.takeAt(index);

}

QList<QVariant> WidgetDataBase::defaultPropertyValues(const QString &name)

{

    WidgetFactory *factory = qobject_cast<WidgetFactory *>(m_core->widgetFactory());

    Q_ASSERT(factory);

    // Create non-widgets, widgets in order

    QObject* object = factory->createObject(name, 0);

    if (!object)

        object = factory->createWidget(name, 0);

    if (!object) {

        qDebug() << "** WARNING Factory failed to create " << name;

        return QList<QVariant>();

    }

    // Get properties from sheet.

    QList<QVariant> result;

    if (const QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(m_core->extensionManager(), object)) {

        const int propertyCount = sheet->count();

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

            result.append(sheet->property(i));

        }

    }

    delete object;

    return result;

}

void WidgetDataBase::grabDefaultPropertyValues()

{

    const int itemCount = count();

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

        QDesignerWidgetDataBaseItemInterface *dbItem = item(i);

        const QList<QVariant> default_prop_values = defaultPropertyValues(dbItem->name());

        dbItem->setDefaultPropertyValues(default_prop_values);

    }

}

void WidgetDataBase::grabStandardWidgetBoxIcons()

{

    // At this point, grab the default icons for the non-custom widgets from

    // the widget box. They will show up in the object inspector.

    if (const QDesignerWidgetBox *wb = qobject_cast<const QDesignerWidgetBox *>(m_core->widgetBox())) {

        const QString qWidgetClass = QLatin1String("QWidget");

        const int itemCount = count();

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

            QDesignerWidgetDataBaseItemInterface *dbItem = item(i);

            if (!dbItem->isCustom() && dbItem->icon().isNull()) {

                // Careful not to catch the layout icons when looking for

                // QWidget

                const QString name = dbItem->name();

                if (name == qWidgetClass) {

                    dbItem->setIcon(wb->iconForWidget(name, QLatin1String("Containers")));

                } else {

                    dbItem->setIcon(wb->iconForWidget(name));

                }

            }

        }

    }

}

// --------------------- Functions relevant generation of new forms based on widgets (apart from the standard templates)

enum { NewFormWidth = 400, NewFormHeight = 300 };

// Check if class is suitable to generate a form from

static inline bool isExistingTemplate(const QString &className)

{

    return className == QLatin1String("QWidget") || className == QLatin1String("QDialog") || className == QLatin1String("QMainWindow");

}

// Check if class is suitable to generate a form from

static inline bool suitableForNewForm(const QString &className)

{

    if (className.isEmpty()) // Missing custom widget information

        return false;

    if (className == QLatin1String("QWorkspace"))

         return false;

    if (className == QLatin1String("QSplitter"))

         return false;

    if (className.startsWith(QLatin1String("QDesigner")) || className.startsWith(QLatin1String("Q3")) ||  className.startsWith(QLatin1String("QLayout")))

        return false;

    return true;

}

// Return a list of widget classes from which new forms can be generated.

// Suitable for 'New form' wizards in integrations.

QStringList WidgetDataBase::formWidgetClasses(const QDesignerFormEditorInterface *core)

{

    static QStringList rc;

    if (rc.empty()) {

        const QDesignerWidgetDataBaseInterface *wdb = core->widgetDataBase();

        const int widgetCount = wdb->count();