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

**

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

  \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 can be useful to create a QtObject if you need an extremely

  lightweight element to enclose a set of custom properties:

  \snippet doc/src/snippets/declarative/qtobject.qml 0

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

  QObject. See the QObject documentation for further details.

*/

/*!

  \qmlproperty string QML:QtObject::objectName

  This property holds the QObject::objectName for this specific object instance.

  This allows a C++ application to locate an item within a QML component

  using the QObject::findChild() method. For example, the following C++ 

  application locates the child \l Rectangle item and dynamically changes its

  \c color value:

    \qml

    // MyRect.qml

    import Qt 4.7

    Item {

        width: 200; height: 200

        Rectangle {

            anchors.fill: parent

            color: "red" 

            objectName: "myRect"

        }

    }

    \endqml

    \code

    // main.cpp

    QDeclarativeView view;

    view.setSource(QUrl::fromLocalFile("MyRect.qml"));

    view.show();

    QDeclarativeItem *item = view.rootObject()->findChild<QDeclarativeItem*>("myRect");

    if (item) 

        item->setProperty("color", QColor(Qt::yellow));

    \endcode

*/

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

}

/*!

\brief The QML global Qt object provides useful enums and functions from Qt.

The \c Qt object is not a QML element; it cannot be instantiated. It is a global object 

with enums and functions.  To use it, call the members of the global \c Qt object directly. 

For example:

\qml

import Qt 4.7

Text {

    color: Qt.rgba(255, 0, 0, 1)

    text: Qt.md5("hello, world")

}

\endqml

\section1 Enums

\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 \c color - use \l{QML:Qt::rgba()}{Qt.rgba()}, \l{QML:Qt::hsla()}{Qt.hsla()}, \l{QML:Qt::darker()}{Qt.darker()}, \l{QML:Qt::lighter()}{Qt.lighter()} or \l{QML:Qt::tint()}{Qt.tint()}

\o \c rect - use \l{QML:Qt::rect()}{Qt.rect()}

\o \c point - use \l{QML:Qt::point()}{Qt.point()}

\o \c size - use \l{QML:Qt::size()}{Qt.size()}

\o \c vector3d - use \l{QML:Qt::vector3d()}{Qt.vector3d()}

\endlist

There are also string based constructors for these types. See \l{qdeclarativebasictypes.html}{QML Basic Types} for more information.

\section1 Date/Time Formatters

\list

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

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

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

\endlist

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

\section1 Dynamic Object Creation

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

of their use.

\list

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

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

\endlist

*/

QDeclarativeEnginePrivate::QDeclarativeEnginePrivate(QDeclarativeEngine *e)

: captureProperties(false), rootContext(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),

{

    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)

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

#endif

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

}

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()) {

        isDebugging = true;

    }

}

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