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

**

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

#include "private/qdeclarativecomponent_p.h"

#include "private/qdeclarativecompiler_p.h"

#include "private/qdeclarativecontext_p.h"

#include "private/qdeclarativecompositetypedata_p.h"

#include "private/qdeclarativeengine_p.h"

#include "private/qdeclarativevme_p.h"

#include "qdeclarative.h"

#include "qdeclarativeengine.h"

#include "private/qdeclarativebinding_p.h"

#include "private/qdeclarativebinding_p_p.h"

#include "private/qdeclarativeglobal_p.h"

#include "private/qdeclarativescriptparser_p.h"

#include "private/qdeclarativedebugtrace_p.h"

#include <QStack>

#include <QStringList>

#include <QFileInfo>

#include <QtCore/qdebug.h>

#include <QApplication>

QT_BEGIN_NAMESPACE

class QByteArray;

/*!

    \class QDeclarativeComponent

    \since 4.7

    \brief The QDeclarativeComponent class encapsulates a QML component definition.

    \mainclass

    Components are reusable, encapsulated QML elements with well-defined interfaces.

    They are often defined in \l {qdeclarativedocuments.html}{Component Files}.

    A QDeclarativeComponent instance can be created from a QML file.

    For example, if there is a \c main.qml file like this:

    \qml

    import Qt 4.7

    Item {

        width: 200

        height: 200

    }

    \endqml

    The following code loads this QML file as a component, creates an instance of

    this component using create(), and then queries the \l Item's \l {Item::}{width}

    value:

    \code

    QDeclarativeEngine *engine = new QDeclarativeEngine;

    QDeclarativeComponent component(engine, QUrl::fromLocalFile("main.qml"));

    QObject *myObject = component.create();

    QDeclarativeItem *item = qobject_cast<QDeclarativeItem*>(myObject);

    int width = item->width();  // width = 200

    \endcode

    \sa {Using QML in C++ Applications}, {Integrating QML with existing Qt UI code}

*/

/*!

    \qmlclass Component QDeclarativeComponent

    \since 4.7

    \brief The Component element encapsulates a QML component definition.

    Components are reusable, encapsulated QML elements with well-defined interfaces.

    Components are often defined by \l {qdeclarativedocuments.html}{component files} -

    that is, \c .qml files. The \e Component element allows components to be defined

    within QML items rather than in a separate file. This may be useful for reusing 

    a small component within a QML file, or for defining a component that logically 

    belongs with other QML components within a file.

    For example, here is a component that is used by multiple \l Loader objects:

    \qml

    Item {

        Component {

            id: redSquare

            Rectangle {

                color: "red"

                width: 10

                height: 10

            }

        }

        Loader { sourceComponent: redSquare }

        Loader { sourceComponent: redSquare; x: 20 }

    }

    \endqml

    Notice that while a \l Rectangle by itself would be automatically 

    rendered and displayed, this is not the case for the above rectangle

    because it is defined inside a \c Component. The component encapsulates the

    QML elements within, as if they were defined in a separate \c .qml

    file, and is not loaded until requested (in this case, by the

    two \l Loader objects).

    The Component element is commonly used to provide graphical components

    for views. For example, the ListView::delegate property requires a Component

    to specify how each list item is to be displayed.

    Component objects can also be dynamically generated using

    \l{Qt::createComponent}{Qt.createComponent()}.

*/

/*!

    \qmlattachedsignal Component::onCompleted()

    Emitted after component "startup" has completed.  This can be used to

    execute script code at startup, once the full QML environment has been

    established.

    The \c {Component::onCompleted} attached property can be applied to

    any element.  The order of running the \c onCompleted scripts is

    undefined.

    \qml

    Rectangle {

        Component.onCompleted: console.log("Completed Running!")

        Rectangle {

            Component.onCompleted: console.log("Nested Completed Running!")

        }

    }

    \endqml

*/

/*!

    \qmlattachedsignal Component::onDestruction()

    Emitted as the component begins destruction.  This can be used to undo

    work done in the onCompleted signal, or other imperative code in your

    application.

    The \c {Component::onDestruction} attached property can be applied to

    any element.  However, it applies to the destruction of the component as

    a whole, and not the destruction of the specific object.  The order of

    running the \c onDestruction scripts is undefined.

    \qml

    Rectangle {

        Component.onDestruction: console.log("Destruction Beginning!")

        Rectangle {

            Component.onDestruction: console.log("Nested Destruction Beginning!")

        }

    }

    \endqml

    \sa QtDeclarative

*/

/*!

    \enum QDeclarativeComponent::Status

    Specifies the loading status of the QDeclarativeComponent.

    \value Null This QDeclarativeComponent has no data.  Call loadUrl() or setData() to add QML content.

    \value Ready This QDeclarativeComponent is ready and create() may be called.

    \value Loading This QDeclarativeComponent is loading network data.

    \value Error An error has occured.  Call errors() to retrieve a list of \{QDeclarativeError}{errors}.

*/

void QDeclarativeComponentPrivate::typeDataReady()

{

    Q_Q(QDeclarativeComponent);

    Q_ASSERT(typeData);

    fromTypeData(typeData);

    typeData = 0;

    emit q->statusChanged(q->status());

}

void QDeclarativeComponentPrivate::updateProgress(qreal p)

{

    Q_Q(QDeclarativeComponent);

    progress = p;

    emit q->progressChanged(p);

}

void QDeclarativeComponentPrivate::fromTypeData(QDeclarativeCompositeTypeData *data)

{

    url = data->imports.baseUrl();

    QDeclarativeCompiledData *c = data->toCompiledComponent(engine);

    if (!c) {

        Q_ASSERT(data->status == QDeclarativeCompositeTypeData::Error);

        state.errors = data->errors;

    } else {

        cc = c;

    }

    data->release();

}

void QDeclarativeComponentPrivate::clear()

{

    if (typeData) {

        typeData->remWaiter(this);

        typeData->release();

        typeData = 0;

    }

    if (cc) { 

        cc->release();

        cc = 0;

    }

}

/*!

    \internal

*/

QDeclarativeComponent::QDeclarativeComponent(QObject *parent)

    : QObject(*(new QDeclarativeComponentPrivate), parent)

{

}

/*!

    Destruct the QDeclarativeComponent.

*/

QDeclarativeComponent::~QDeclarativeComponent()

{

    Q_D(QDeclarativeComponent);

    if (d->state.completePending) {

        qWarning("QDeclarativeComponent: Component destroyed while completion pending");

        d->completeCreate();

    }

    if (d->typeData) {

        d->typeData->remWaiter(d);

        d->typeData->release();

    }

    if (d->cc)

        d->cc->release();

}

/*!

    \qmlproperty enumeration Component::status

    This property holds the status of component loading.  It can be one of:

    \list

    \o Component.Null - no data is available for the component

    \o Component.Ready - the component has been loaded, and can be used to create instances.

    \o Component.Loading - the component is currently being loaded

    \o Component.Error - an error occurred while loading the component.

               Calling errorString() will provide a human-readable description of any errors.

    \endlist

 */

/*!

    \property QDeclarativeComponent::status

    The component's current \l{QDeclarativeComponent::Status} {status}.

 */

QDeclarativeComponent::Status QDeclarativeComponent::status() const

{

    Q_D(const QDeclarativeComponent);

    if (d->typeData)

        return Loading;

    else if (!d->state.errors.isEmpty())

        return Error;

    else if (d->engine && d->cc)

        return Ready;

    else

        return Null;

}

/*!

    Returns true if status() == QDeclarativeComponent::Null.

*/

bool QDeclarativeComponent::isNull() const

{

    return status() == Null;

}

/*!

    Returns true if status() == QDeclarativeComponent::Ready.

*/

bool QDeclarativeComponent::isReady() const

{

    return status() == Ready;

}

/*!

    Returns true if status() == QDeclarativeComponent::Error.

*/

bool QDeclarativeComponent::isError() const

{

    return status() == Error;

}

/*!

    Returns true if status() == QDeclarativeComponent::Loading.

*/

bool QDeclarativeComponent::isLoading() const

{

    return status() == Loading;

}

/*!

    \qmlproperty real Component::progress

    The progress of loading the component, from 0.0 (nothing loaded)

    to 1.0 (finished).

*/

/*!

    \property QDeclarativeComponent::progress

    The progress of loading the component, from 0.0 (nothing loaded)

    to 1.0 (finished).

*/

qreal QDeclarativeComponent::progress() const

{

    Q_D(const QDeclarativeComponent);

    return d->progress;

}

/*!

    \fn void QDeclarativeComponent::progressChanged(qreal progress)

    Emitted whenever the component's loading progress changes.  \a progress will be the

    current progress between 0.0 (nothing loaded) and 1.0 (finished).

*/

/*!

    \fn void QDeclarativeComponent::statusChanged(QDeclarativeComponent::Status status)

    Emitted whenever the component's status changes.  \a status will be the

    new status.

*/

/*!

    Create a QDeclarativeComponent with no data and give it the specified

    \a engine and \a parent. Set the data with setData().

*/

QDeclarativeComponent::QDeclarativeComponent(QDeclarativeEngine *engine, QObject *parent)

    : QObject(*(new QDeclarativeComponentPrivate), parent)

{

    Q_D(QDeclarativeComponent);

    d->engine = engine;

}

/*!

    Create a QDeclarativeComponent from the given \a url and give it the

    specified \a parent and \a engine.

    Ensure that the URL provided is full and correct, in particular, use

    \l QUrl::fromLocalFile() when loading a file from the local filesystem.

    \sa loadUrl()

*/

QDeclarativeComponent::QDeclarativeComponent(QDeclarativeEngine *engine, const QUrl &url, QObject *parent)

: QObject(*(new QDeclarativeComponentPrivate), parent)

{

    Q_D(QDeclarativeComponent);

    d->engine = engine;

    loadUrl(url);

}

/*!

    Create a QDeclarativeComponent from the given \a fileName and give it the specified 

    \a parent and \a engine.

    \sa loadUrl()

*/

QDeclarativeComponent::QDeclarativeComponent(QDeclarativeEngine *engine, const QString &fileName, 

                           QObject *parent)

: QObject(*(new QDeclarativeComponentPrivate), parent)

{

    Q_D(QDeclarativeComponent);

    d->engine = engine;

    loadUrl(d->engine->baseUrl().resolved(QUrl::fromLocalFile(fileName)));

}

/*!

    \internal

*/

QDeclarativeComponent::QDeclarativeComponent(QDeclarativeEngine *engine, QDeclarativeCompiledData *cc, int start, int count, QObject *parent)

    : QObject(*(new QDeclarativeComponentPrivate), parent)

{

    Q_D(QDeclarativeComponent);

    d->engine = engine;

    d->cc = cc;

    cc->addref();

    d->start = start;

    d->count = count;

    d->url = cc->url;

    d->progress = 1.0;

}

/*!

    Sets the QDeclarativeComponent to use the given QML \a data.  If \a url

    is provided, it is used to set the component name and to provide

    a base path for items resolved by this component.

*/

void QDeclarativeComponent::setData(const QByteArray &data, const QUrl &url)

{

    Q_D(QDeclarativeComponent);

    d->clear();

    d->url = url;

    QDeclarativeCompositeTypeData *typeData = 

        QDeclarativeEnginePrivate::get(d->engine)->typeManager.getImmediate(data, url);

    if (typeData->status == QDeclarativeCompositeTypeData::Waiting

     || typeData->status == QDeclarativeCompositeTypeData::WaitingResources)

    {

        d->typeData = typeData;

        d->typeData->addWaiter(d);

    } else {

        d->fromTypeData(typeData);

    }

    d->progress = 1.0;

    emit statusChanged(status());

    emit progressChanged(d->progress);

}

/*!

Returns the QDeclarativeContext the component was created in.  This is only

valid for components created directly from QML.

*/

QDeclarativeContext *QDeclarativeComponent::creationContext() const

{

    Q_D(const QDeclarativeComponent);

    if(d->creationContext)

        return d->creationContext->asQDeclarativeContext();

    return qmlContext(this);

}

/*!

    Load the QDeclarativeComponent from the provided \a url.

    Ensure that the URL provided is full and correct, in particular, use

    \l QUrl::fromLocalFile() when loading a file from the local filesystem.

*/

void QDeclarativeComponent::loadUrl(const QUrl &url)

{

    Q_D(QDeclarativeComponent);

    d->clear();

    if ((url.isRelative() && !url.isEmpty())

    || url.scheme() == QLatin1String("file")) // Workaround QTBUG-11929

        d->url = d->engine->baseUrl().resolved(url);

    else

        d->url = url;

    if (url.isEmpty()) {

        QDeclarativeError error;

        error.setDescription(tr("Invalid empty URL"));

        d->state.errors << error;

        return;

    }

    QDeclarativeCompositeTypeData *data = 

        QDeclarativeEnginePrivate::get(d->engine)->typeManager.get(d->url);

    if (data->status == QDeclarativeCompositeTypeData::Waiting

     || data->status == QDeclarativeCompositeTypeData::WaitingResources)

    {

        d->typeData = data;

        d->typeData->addWaiter(d);

        d->progress = data->progress;

    } else {

        d->fromTypeData(data);

        d->progress = 1.0;