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

**

** 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 QtDeclarative module 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 "private/qdeclarativeengine_p.h"

#include "qdeclarativeengine.h"

#include "private/qdeclarativecontext_p.h"

#include "private/qdeclarativecompiler_p.h"

#include "private/qdeclarativeglobalscriptclass_p.h"

#include "qdeclarative.h"

#include "qdeclarativecontext.h"

#include "qdeclarativeexpression.h"

#include "qdeclarativecomponent.h"

#include "private/qdeclarativebinding_p_p.h"

#include "private/qdeclarativevme_p.h"

#include "private/qdeclarativeenginedebug_p.h"

#include "private/qdeclarativestringconverters_p.h"

#include "private/qdeclarativexmlhttprequest_p.h"

#include "private/qdeclarativesqldatabase_p.h"

#include "private/qdeclarativetypenamescriptclass_p.h"

#include "private/qdeclarativelistscriptclass_p.h"

#include "qdeclarativescriptstring.h"

#include "private/qdeclarativeglobal_p.h"

#include "private/qdeclarativeworkerscript_p.h"

#include "private/qdeclarativecomponent_p.h"

#include "qdeclarativenetworkaccessmanagerfactory.h"

#include "qdeclarativeimageprovider.h"

#include "private/qdeclarativedirparser_p.h"

#include "qdeclarativeextensioninterface.h"

#include "private/qdeclarativelist_p.h"

#include "private/qdeclarativetypenamecache_p.h"

#include "private/qdeclarativeinclude_p.h"

#include <QtCore/qmetaobject.h>

#include <QScriptClass>

#include <QNetworkReply>

#include <QNetworkRequest>

#include <QNetworkAccessManager>

#include <QDesktopServices>

#include <QTimer>

#include <QList>

#include <QPair>

#include <QDebug>

#include <QMetaObject>

#include <QStack>

#include <QMap>

#include <QPluginLoader>

#include <QtGui/qfontdatabase.h>

#include <QtCore/qlibraryinfo.h>

#include <QtCore/qthreadstorage.h>

#include <QtCore/qthread.h>

#include <QtCore/qcoreapplication.h>

#include <QtCore/qdir.h>

#include <QtCore/qmutex.h>

#include <QtGui/qcolor.h>

#include <QtGui/qvector3d.h>

#include <QtGui/qsound.h>

#include <QGraphicsObject>

#include <QtCore/qcryptographichash.h>

#include <private/qobject_p.h>

#include <private/qscriptdeclarativeclass_p.h>

#include <private/qdeclarativeitemsmodule_p.h>

#include <private/qdeclarativeutilmodule_p.h>

#ifdef Q_OS_WIN // for %APPDATA%

#include <qt_windows.h>

#include <qlibrary.h>

#define CSIDL_APPDATA		0x001a	// <username>\Application Data

#endif

Q_DECLARE_METATYPE(QDeclarativeProperty)

QT_BEGIN_NAMESPACE

/*!

  \qmlclass QtObject QObject

  \since 4.7

  \brief The QtObject element is the most basic element in QML

  The QtObject element is a non-visual element which contains only the

  objectName property. It is useful for when you need an extremely

  lightweight element to place your own custom properties in.

  It can also be useful for C++ integration, as it is just a plain

  QObject. See the QObject documentation for further details.

*/

/*!

  \qmlproperty string QtObject::objectName

  This property allows you to give a name to this specific object instance.

  See \l{scripting.html#accessing-child-qobjects}{Accessing Child QObjects}

  in the scripting documentation for details how objectName can be used from

  scripts.

*/

struct StaticQtMetaObject : public QObject

{

    static const QMetaObject *get()

        { return &static_cast<StaticQtMetaObject*> (0)->staticQtMetaObject; }

};

static bool qt_QmlQtModule_registered = false;

void QDeclarativeEnginePrivate::defineModule()

{

    qmlRegisterType<QDeclarativeComponent>("Qt",4,7,"Component");

    qmlRegisterType<QObject>("Qt",4,7,"QtObject");

    qmlRegisterType<QDeclarativeWorkerScript>("Qt",4,7,"WorkerScript");

    qmlRegisterType<QDeclarativeBinding>();

}

/*!

\qmlclass Qt QDeclarativeEnginePrivate

\brief The QML Global Qt Object

The Qt object provides useful enums and functions from Qt, for use in all QML

files. Note that you do note create instances of this type, but instead use

the members of the global "Qt" object.

\section1 Enums

The Qt object contains all enums in the Qt namespace. For example, you can

access the AlignLeft member of the Qt::AlignmentFlag enum with \c Qt.AlignLeft.

For a full list of enums, see the \l{Qt Namespace} documentation.

\section1 Types

The Qt object also contains helper functions for creating objects of specific

data types. This is primarily useful when setting the properties of an item

when the property has one of the following types:

\list

\o Color

\o Rect

\o Point

\o Size

\o Vector3D

\endlist

There are also string based constructors for these types, see \l{qdeclarativebasictypes.html}{Qml Types}.

\section1 Date/Time Formatters

The Qt object contains several functions for formatting dates and times.

\list

    \o \l{Qt::formatDateTime}{string Qt.formatDateTime(datetime date, variant format)

    \o \l{Qt::formatDate}{string Qt.formatDate(datetime date, variant format)

    \o \l{Qt::formatTime}{string Qt.formatTime(datetime date, variant format)

\endlist

The format specification is described at \l{Qt::formatDateTime}{Qt.formatDateTime}.

\section1 Dynamic Object Creation

The following functions on the global object allow you to dynamically create QML

items from files or strings. See \l{Dynamic Object Management} for an overview

of their use.

\list

    \o \l{Qt::createComponent}{object Qt.createComponent(url)}

    \o \l{Qt::createQmlObject}{object Qt.createQmlObject(string qml, object parent, string filepath)}

\endlist

*/

QDeclarativeEnginePrivate::QDeclarativeEnginePrivate(QDeclarativeEngine *e)

: captureProperties(false), rootContext(0), currentExpression(0), isDebugging(false),

  outputWarningsToStdErr(true), contextClass(0), sharedContext(0), sharedScope(0),

  objectClass(0), valueTypeClass(0), globalClass(0), cleanup(0), erroredBindings(0),

  inProgressCreations(0), scriptEngine(this), workerScriptEngine(0), componentAttached(0),

  inBeginCreate(false), networkAccessManager(0), networkAccessManagerFactory(0),

  typeManager(e), importDatabase(e), uniqueId(1)

{

    if (!qt_QmlQtModule_registered) {

        qt_QmlQtModule_registered = true;

        QDeclarativeItemModule::defineModule();

        QDeclarativeUtilModule::defineModule();

        QDeclarativeEnginePrivate::defineModule();

        QDeclarativeValueTypeFactory::registerValueTypes();

    }

    globalClass = new QDeclarativeGlobalScriptClass(&scriptEngine);

}

/*!

\qmlmethod url Qt::resolvedUrl(url)

This function returns \c url resolved relative to the URL of the

caller.

*/

QUrl QDeclarativeScriptEngine::resolvedUrl(QScriptContext *context, const QUrl& url)

{

    if (p) {

        QDeclarativeContextData *ctxt = QDeclarativeEnginePrivate::get(this)->getContext(context);

        Q_ASSERT(ctxt);

        return ctxt->resolvedUrl(url);

    }

    return baseUrl.resolved(url);

}

QDeclarativeScriptEngine::QDeclarativeScriptEngine(QDeclarativeEnginePrivate *priv)

: p(priv), sqlQueryClass(0), namedNodeMapClass(0), nodeListClass(0)

{

    // Note that all documentation for stuff put on the global object goes in

    // doc/src/declarative/globalobject.qdoc

    bool mainthread = priv != 0;

    QScriptValue qtObject =

        newQMetaObject(StaticQtMetaObject::get());

    globalObject().setProperty(QLatin1String("Qt"), qtObject);

#ifndef QT_NO_DESKTOPSERVICES

    offlineStoragePath = QDesktopServices::storageLocation(QDesktopServices::DataLocation).replace(QLatin1Char('/'), QDir::separator())

        + QDir::separator() + QLatin1String("QML")

        + QDir::separator() + QLatin1String("OfflineStorage");

#endif

    qt_add_qmlxmlhttprequest(this);

    qt_add_qmlsqldatabase(this);

    // XXX A Multimedia "Qt.Sound" class also needs to be made available,

    // XXX but we don't want a dependency in that cirection.

    // XXX When the above a done some better way, that way should also be

    // XXX used to add Qt.Sound class.

    //types

    if (mainthread)

        qtObject.setProperty(QLatin1String("include"), newFunction(QDeclarativeInclude::include, 2));

    else

        qtObject.setProperty(QLatin1String("include"), newFunction(QDeclarativeInclude::worker_include, 2));

    qtObject.setProperty(QLatin1String("isQtObject"), newFunction(QDeclarativeEnginePrivate::isQtObject, 1));

    qtObject.setProperty(QLatin1String("rgba"), newFunction(QDeclarativeEnginePrivate::rgba, 4));

    qtObject.setProperty(QLatin1String("hsla"), newFunction(QDeclarativeEnginePrivate::hsla, 4));

    qtObject.setProperty(QLatin1String("rect"), newFunction(QDeclarativeEnginePrivate::rect, 4));

    qtObject.setProperty(QLatin1String("point"), newFunction(QDeclarativeEnginePrivate::point, 2));

    qtObject.setProperty(QLatin1String("size"), newFunction(QDeclarativeEnginePrivate::size, 2));

    qtObject.setProperty(QLatin1String("vector3d"), newFunction(QDeclarativeEnginePrivate::vector3d, 3));

    if (mainthread) {

        //color helpers

        qtObject.setProperty(QLatin1String("lighter"), newFunction(QDeclarativeEnginePrivate::lighter, 1));

        qtObject.setProperty(QLatin1String("darker"), newFunction(QDeclarativeEnginePrivate::darker, 1));

        qtObject.setProperty(QLatin1String("tint"), newFunction(QDeclarativeEnginePrivate::tint, 2));

    }

    //date/time formatting

    qtObject.setProperty(QLatin1String("formatDate"),newFunction(QDeclarativeEnginePrivate::formatDate, 2));

    qtObject.setProperty(QLatin1String("formatTime"),newFunction(QDeclarativeEnginePrivate::formatTime, 2));

    qtObject.setProperty(QLatin1String("formatDateTime"),newFunction(QDeclarativeEnginePrivate::formatDateTime, 2));

    //misc methods

    qtObject.setProperty(QLatin1String("openUrlExternally"),newFunction(QDeclarativeEnginePrivate::desktopOpenUrl, 1));

    qtObject.setProperty(QLatin1String("fontFamilies"),newFunction(QDeclarativeEnginePrivate::fontFamilies, 0));

    qtObject.setProperty(QLatin1String("md5"),newFunction(QDeclarativeEnginePrivate::md5, 1));

    qtObject.setProperty(QLatin1String("btoa"),newFunction(QDeclarativeEnginePrivate::btoa, 1));

    qtObject.setProperty(QLatin1String("atob"),newFunction(QDeclarativeEnginePrivate::atob, 1));

    qtObject.setProperty(QLatin1String("quit"), newFunction(QDeclarativeEnginePrivate::quit, 0));

    qtObject.setProperty(QLatin1String("resolvedUrl"),newFunction(QDeclarativeScriptEngine::resolvedUrl, 1));

    if (mainthread) {

        qtObject.setProperty(QLatin1String("createQmlObject"),

                newFunction(QDeclarativeEnginePrivate::createQmlObject, 1));

        qtObject.setProperty(QLatin1String("createComponent"),

                newFunction(QDeclarativeEnginePrivate::createComponent, 1));

    }

    //firebug/webkit compat

    QScriptValue consoleObject = newObject();

    consoleObject.setProperty(QLatin1String("log"),newFunction(QDeclarativeEnginePrivate::consoleLog, 1));

    consoleObject.setProperty(QLatin1String("debug"),newFunction(QDeclarativeEnginePrivate::consoleLog, 1));

    globalObject().setProperty(QLatin1String("console"), consoleObject);

    // translation functions need to be installed

    // before the global script class is constructed (QTBUG-6437)

    installTranslatorFunctions();

}

QDeclarativeScriptEngine::~QDeclarativeScriptEngine()

{

    delete sqlQueryClass;

    delete nodeListClass;

    delete namedNodeMapClass;

}

QScriptValue QDeclarativeScriptEngine::resolvedUrl(QScriptContext *ctxt, QScriptEngine *engine)

{

    QString arg = ctxt->argument(0).toString();

    QUrl r = QDeclarativeScriptEngine::get(engine)->resolvedUrl(ctxt,QUrl(arg));

    return QScriptValue(r.toString());

}

QNetworkAccessManager *QDeclarativeScriptEngine::networkAccessManager()

{

    return p->getNetworkAccessManager();

}

QDeclarativeEnginePrivate::~QDeclarativeEnginePrivate()

{

    Q_ASSERT(inProgressCreations == 0);

    Q_ASSERT(bindValues.isEmpty());

    Q_ASSERT(parserStatus.isEmpty());

    while (cleanup) {

        QDeclarativeCleanup *c = cleanup;

        cleanup = c->next;

        if (cleanup) cleanup->prev = &cleanup;

        c->next = 0;

        c->prev = 0;

        c->clear();

    }

    delete rootContext;

    rootContext = 0;

    delete contextClass;

    contextClass = 0;

    delete objectClass;

    objectClass = 0;

    delete valueTypeClass;

    valueTypeClass = 0;

    delete typeNameClass;

    typeNameClass = 0;

    delete listClass;

    listClass = 0;

    delete globalClass;

    globalClass = 0;

    for(QHash<int, QDeclarativeCompiledData*>::ConstIterator iter = m_compositeTypes.constBegin(); iter != m_compositeTypes.constEnd(); ++iter)

        (*iter)->release();

    for(QHash<const QMetaObject *, QDeclarativePropertyCache *>::Iterator iter = propertyCache.begin(); iter != propertyCache.end(); ++iter)

        (*iter)->release();

}

void QDeclarativeEnginePrivate::clear(SimpleList<QDeclarativeAbstractBinding> &bvs)

{

    bvs.clear();

}

void QDeclarativeEnginePrivate::clear(SimpleList<QDeclarativeParserStatus> &pss)

{

    for (int ii = 0; ii < pss.count; ++ii) {

        QDeclarativeParserStatus *ps = pss.at(ii);

        if(ps)

            ps->d = 0;

    }

    pss.clear();

}

Q_GLOBAL_STATIC(QDeclarativeEngineDebugServer, qmlEngineDebugServer);

void QDeclarativePrivate::qdeclarativeelement_destructor(QObject *o)

{

    QObjectPrivate *p = QObjectPrivate::get(o);

    if (p->declarativeData) {

        QDeclarativeData *d = static_cast<QDeclarativeData*>(p->declarativeData);

        if (d->ownContext && d->context) {

            d->context->destroy();

            d->context = 0;

        }

    }

}

void QDeclarativeData::destroyed(QAbstractDeclarativeData *d, QObject *o)

{

    static_cast<QDeclarativeData *>(d)->destroyed(o);

}

void QDeclarativeData::parentChanged(QAbstractDeclarativeData *d, QObject *o, QObject *p)

{

    static_cast<QDeclarativeData *>(d)->parentChanged(o, p);

}

void QDeclarativeEnginePrivate::init()

{

    Q_Q(QDeclarativeEngine);

    qRegisterMetaType<QVariant>("QVariant");

    qRegisterMetaType<QDeclarativeScriptString>("QDeclarativeScriptString");

    qRegisterMetaType<QScriptValue>("QScriptValue");

    qRegisterMetaType<QDeclarativeComponent::Status>("QDeclarativeComponent::Status");

    QDeclarativeData::init();

    contextClass = new QDeclarativeContextScriptClass(q);

    objectClass = new QDeclarativeObjectScriptClass(q);

    valueTypeClass = new QDeclarativeValueTypeScriptClass(q);

    typeNameClass = new QDeclarativeTypeNameScriptClass(q);

    listClass = new QDeclarativeListScriptClass(q);

    rootContext = new QDeclarativeContext(q,true);

    if (QCoreApplication::instance()->thread() == q->thread() &&

        QDeclarativeEngineDebugServer::isDebuggingEnabled()) {

        qmlEngineDebugServer();

        isDebugging = true;

        QDeclarativeEngineDebugServer::addEngine(q);

    }

}

QDeclarativeWorkerScriptEngine *QDeclarativeEnginePrivate::getWorkerScriptEngine()

{

    Q_Q(QDeclarativeEngine);

    if (!workerScriptEngine)

        workerScriptEngine = new QDeclarativeWorkerScriptEngine(q);

    return workerScriptEngine;

}

/*!

  \class QDeclarativeEngine

  \since 4.7

  \brief The QDeclarativeEngine class provides an environment for instantiating QML components.

  \mainclass

  Each QML component is instantiated in a QDeclarativeContext.

  QDeclarativeContext's are essential for passing data to QML

  components.  In QML, contexts are arranged hierarchically and this

  hierarchy is managed by the QDeclarativeEngine.

  Prior to creating any QML components, an application must have

  created a QDeclarativeEngine to gain access to a QML context.  The

  following example shows how to create a simple Text item.

  \code

  QDeclarativeEngine engine;

  QDeclarativeComponent component(&engine);

  component.setData("import Qt 4.7\nText { text: \"Hello world!\" }", QUrl());

  QDeclarativeItem *item = qobject_cast<QDeclarativeItem *>(component.create());

  //add item to view, etc

  ...

  \endcode

  In this case, the Text item will be created in the engine's

  \l {QDeclarativeEngine::rootContext()}{root context}.

  \sa QDeclarativeComponent QDeclarativeContext

*/

/*!

  Create a new QDeclarativeEngine with the given \a parent.

*/

QDeclarativeEngine::QDeclarativeEngine(QObject *parent)

: QObject(*new QDeclarativeEnginePrivate(this), parent)

{

    Q_D(QDeclarativeEngine);

    d->init();

}

/*!

  Destroys the QDeclarativeEngine.

  Any QDeclarativeContext's created on this engine will be

  invalidated, but not destroyed (unless they are parented to the

  QDeclarativeEngine object).

*/

QDeclarativeEngine::~QDeclarativeEngine()

{

    Q_D(QDeclarativeEngine);

    if (d->isDebugging)

        QDeclarativeEngineDebugServer::remEngine(this);

}

/*! \fn void QDeclarativeEngine::quit()

    This signal is emitted when the QDeclarativeEngine quits.

 */

/*! \fn void QDeclarativeEngine::warnings(const QList<QDeclarativeError> &warnings)

    This signal is emitted when \a warnings messages are generated by QML.

 */

/*!

  Clears the engine's internal component cache.

  Normally the QDeclarativeEngine caches components loaded from qml

  files.  This method clears this cache and forces the component to be

  reloaded.

 */

void QDeclarativeEngine::clearComponentCache()

{

    Q_D(QDeclarativeEngine);

    d->typeManager.clearCache();

}

/*!

  Returns the engine's root context.

  The root context is automatically created by the QDeclarativeEngine.

  Data that should be available to all QML component instances