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

**

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

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

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

  QObject. See the QObject documentation for further details.

*/

/*!

*/

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

\section1 Enums

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

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

\endlist

\section1 Date/Time Formatters

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

\list

\endlist

\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

\endlist

*/

QDeclarativeEnginePrivate::QDeclarativeEnginePrivate(QDeclarativeEngine *e)

  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);

}

/*!

*/

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}.