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

**

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

#include "private/qdeclarativedom_p_p.h"

#include "private/qdeclarativecompiler_p.h"

#include "private/qdeclarativeengine_p.h"

#include "private/qdeclarativescriptparser_p.h"

#include "private/qdeclarativeglobal_p.h"

#include <QtCore/QByteArray>

#include <QtCore/QDebug>

#include <QtCore/QString>

QT_BEGIN_NAMESPACE

QDeclarativeDomDocumentPrivate::QDeclarativeDomDocumentPrivate()

: root(0)

{

}

QDeclarativeDomDocumentPrivate::~QDeclarativeDomDocumentPrivate()

{

    if (root) root->release();

}

/*!

    \class QDeclarativeDomDocument

    \internal

    \brief The QDeclarativeDomDocument class represents the root of a QML document

    A QML document is a self-contained snippet of QML, usually contained in a

    single file. Each document has a root object, accessible through

    QDeclarativeDomDocument::rootObject().

    The QDeclarativeDomDocument class allows the programmer to inspect a QML document by

    calling QDeclarativeDomDocument::load().

    The following example loads a QML file from disk, and prints out its root

    object type and the properties assigned in the root object.

    \code

    QFile file(inputFileName);

    file.open(QIODevice::ReadOnly);

    QByteArray xmlData = file.readAll();

    QDeclarativeDomDocument document;

    document.load(qmlengine, xmlData);

    QDeclarativeDomObject rootObject = document.rootObject();

    qDebug() << rootObject.objectType();

    foreach(QDeclarativeDomProperty property, rootObject.properties())

        qDebug() << property.propertyName();

    \endcode

*/

/*!

    Construct an empty QDeclarativeDomDocument.

*/

QDeclarativeDomDocument::QDeclarativeDomDocument()

: d(new QDeclarativeDomDocumentPrivate)

{

}

/*!

    Create a copy of \a other QDeclarativeDomDocument.

*/

QDeclarativeDomDocument::QDeclarativeDomDocument(const QDeclarativeDomDocument &other)

: d(other.d)

{

}

/*!

    Destroy the QDeclarativeDomDocument

*/

QDeclarativeDomDocument::~QDeclarativeDomDocument()

{

}

/*!

    Assign \a other to this QDeclarativeDomDocument.

*/

QDeclarativeDomDocument &QDeclarativeDomDocument::operator=(const QDeclarativeDomDocument &other)

{

    d = other.d;

    return *this;

}

/*!

    Returns all import statements in qml.

*/

QList<QDeclarativeDomImport> QDeclarativeDomDocument::imports() const

{

    return d->imports;

}

/*!

    Loads a QDeclarativeDomDocument from \a data.  \a data should be valid QML

    data.  On success, true is returned.  If the \a data is malformed, false

    is returned and QDeclarativeDomDocument::errors() contains an error description.

    \sa QDeclarativeDomDocument::loadError()

*/

bool QDeclarativeDomDocument::load(QDeclarativeEngine *engine, const QByteArray &data, const QUrl &url)

{

    d->errors.clear();

    d->imports.clear();

        td->release();

        return false;

        QDeclarativeError error;

        error.setDescription(QLatin1String("QDeclarativeDomDocument supports local types only"));

        d->errors << error;

        td->release();

        return false;

    }

        QDeclarativeDomImport domImport;

        domImport.d->type = static_cast<QDeclarativeDomImportPrivate::Type>(parserImport.type);

        domImport.d->uri = parserImport.uri;

        domImport.d->qualifier = parserImport.qualifier;

        domImport.d->version = parserImport.version;

        d->imports += domImport;

    }

        d->root->addref();

    }

    return true;

}

/*!

    Returns the last load errors.  The load errors will be reset after a

    successful call to load().

    \sa load()

*/

QList<QDeclarativeError> QDeclarativeDomDocument::errors() const

{

    return d->errors;

}

/*!

    Returns the document's root object, or an invalid QDeclarativeDomObject if the

    document has no root.

    In the sample QML below, the root object will be the QDeclarativeItem type.

    \qml

Item {

    Text {

        text: "Hello World"

    }

}

    \endqml

*/

QDeclarativeDomObject QDeclarativeDomDocument::rootObject() const

{

    QDeclarativeDomObject rv;

    rv.d->object = d->root;

    if (rv.d->object) rv.d->object->addref();

    return rv;

}

QDeclarativeDomPropertyPrivate::QDeclarativeDomPropertyPrivate()

: property(0)

{

}

QDeclarativeDomPropertyPrivate::~QDeclarativeDomPropertyPrivate()

{

    if (property) property->release();

}

QDeclarativeDomDynamicPropertyPrivate::QDeclarativeDomDynamicPropertyPrivate():

        valid(false)

{

}

QDeclarativeDomDynamicPropertyPrivate::~QDeclarativeDomDynamicPropertyPrivate()

{

    if (valid && property.defaultValue) property.defaultValue->release();

}

/*!

    \class QDeclarativeDomProperty

    \internal

    \brief The QDeclarativeDomProperty class represents one property assignment in the

    QML DOM tree

    Properties in QML can be assigned QML \l {QDeclarativeDomValue}{values}.

    \sa QDeclarativeDomObject

*/

/*!

    Construct an invalid QDeclarativeDomProperty.

*/

QDeclarativeDomProperty::QDeclarativeDomProperty()

: d(new QDeclarativeDomPropertyPrivate)

{

}

/*!

    Create a copy of \a other QDeclarativeDomProperty.

*/

QDeclarativeDomProperty::QDeclarativeDomProperty(const QDeclarativeDomProperty &other)

: d(other.d)

{

}

/*!

    Destroy the QDeclarativeDomProperty.

*/

QDeclarativeDomProperty::~QDeclarativeDomProperty()

{

}

/*!

    Assign \a other to this QDeclarativeDomProperty.

*/

QDeclarativeDomProperty &QDeclarativeDomProperty::operator=(const QDeclarativeDomProperty &other)

{

    d = other.d;

    return *this;

}

/*!

    Returns true if this is a valid QDeclarativeDomProperty, false otherwise.

*/

bool QDeclarativeDomProperty::isValid() const

{

    return d->property != 0;

}

/*!

    Return the name of this property.

    \qml

Text {

    x: 10

    y: 10

    font.bold: true

}

    \endqml

    As illustrated above, a property name can be a simple string, such as "x" or

    "y", or a more complex "dot property", such as "font.bold".  In both cases

    the full name is returned ("x", "y" and "font.bold") by this method.

    For dot properties, a split version of the name can be accessed by calling

    QDeclarativeDomProperty::propertyNameParts().

    \sa QDeclarativeDomProperty::propertyNameParts()

*/

QByteArray QDeclarativeDomProperty::propertyName() const

{

    return d->propertyName;

}

/*!

    Return the name of this property, split into multiple parts in the case

    of dot properties.

    \qml

Text {

    x: 10

    y: 10

    font.bold: true

}

    \endqml

    For each of the properties shown above, this method would return ("x"),

    ("y") and ("font", "bold").

    \sa QDeclarativeDomProperty::propertyName()

*/

QList<QByteArray> QDeclarativeDomProperty::propertyNameParts() const

{

    if (d->propertyName.isEmpty()) return QList<QByteArray>();

    else return d->propertyName.split('.');

}

/*!

    Return true if this property is used as a default property in the QML

    document.

    \qml

<Text text="hello"/>

<Text>hello</Text>

    \endqml

    The above two examples return the same DOM tree, except that the second has

    the default property flag set on the text property.  Observe that whether

    or not a property has isDefaultProperty set is determined by how the

    property is used, and not only by whether the property is the types default

    property.

*/

bool QDeclarativeDomProperty::isDefaultProperty() const

{

    return d->property && d->property->isDefault;

}

/*!

    Returns the QDeclarativeDomValue that is assigned to this property, or an invalid

    QDeclarativeDomValue if no value is assigned.

*/

QDeclarativeDomValue QDeclarativeDomProperty::value() const

{

    QDeclarativeDomValue rv;

    if (d->property) {

        rv.d->property = d->property;

        if (d->property->values.count())

            rv.d->value = d->property->values.at(0);

        else

            rv.d->value = d->property->onValues.at(0);

        rv.d->property->addref();

        rv.d->value->addref();

    }

    return rv;

}

/*!

    Returns the position in the input data where the property ID startd, or -1 if

 the property is invalid.

*/

int QDeclarativeDomProperty::position() const

{

    if (d && d->property) {

        return d->property->location.range.offset;

    } else

        return -1;

}

/*!

    Returns the length in the input data from where the property ID started upto

 the end of it, or -1 if the property is invalid.

*/

int QDeclarativeDomProperty::length() const

{

    if (d && d->property)

        return d->property->location.range.length;

    else

        return -1;

}

/*!

    Construct an invalid QDeclarativeDomDynamicProperty.

*/

QDeclarativeDomDynamicProperty::QDeclarativeDomDynamicProperty():

        d(new QDeclarativeDomDynamicPropertyPrivate)

{

}

/*!

    Create a copy of \a other QDeclarativeDomDynamicProperty.

*/

QDeclarativeDomDynamicProperty::QDeclarativeDomDynamicProperty(const QDeclarativeDomDynamicProperty &other):

        d(other.d)

{

}

/*!

    Destroy the QDeclarativeDomDynamicProperty.

*/

QDeclarativeDomDynamicProperty::~QDeclarativeDomDynamicProperty()

{

}

/*!

    Assign \a other to this QDeclarativeDomDynamicProperty.

*/

QDeclarativeDomDynamicProperty &QDeclarativeDomDynamicProperty::operator=(const QDeclarativeDomDynamicProperty &other)

{

    d = other.d;

    return *this;

}

bool QDeclarativeDomDynamicProperty::isValid() const

{

    return d && d->valid;

}

/*!

    Return the name of this dynamic property.

    \qml

Item {

    property int count: 10;

}

    \endqml

    As illustrated above, a dynamic property name can have a name and a

    default value ("10").

*/

QByteArray QDeclarativeDomDynamicProperty::propertyName() const

{

    if (isValid())

        return d->property.name;

    else

        return QByteArray();

}

/*!

   Returns the type of the dynamic property. Note that when the property is an

   alias property, this will return -1. Use QDeclarativeDomProperty::isAlias() to check

   if the property is an alias.

*/

int QDeclarativeDomDynamicProperty::propertyType() const

{

    if (isValid()) {

        switch (d->property.type) {

            case QDeclarativeParser::Object::DynamicProperty::Bool:

                return QMetaType::type("bool");

            case QDeclarativeParser::Object::DynamicProperty::Color:

                return QMetaType::type("QColor");

            case QDeclarativeParser::Object::DynamicProperty::Time:

                return QMetaType::type("QTime");

            case QDeclarativeParser::Object::DynamicProperty::Date:

                return QMetaType::type("QDate");

            case QDeclarativeParser::Object::DynamicProperty::DateTime:

                return QMetaType::type("QDateTime");

            case QDeclarativeParser::Object::DynamicProperty::Int:

                return QMetaType::type("int");

            case QDeclarativeParser::Object::DynamicProperty::Real:

                return sizeof(qreal) == sizeof(double) ? QMetaType::type("double") : QMetaType::type("float");

            case QDeclarativeParser::Object::DynamicProperty::String:

                return QMetaType::type("QString");

            case QDeclarativeParser::Object::DynamicProperty::Url:

                return QMetaType::type("QUrl");

            case QDeclarativeParser::Object::DynamicProperty::Variant:

                return QMetaType::type("QVariant");

            default:

                break;

        }

    }

    return -1;

}

QByteArray QDeclarativeDomDynamicProperty::propertyTypeName() const

{

    if (isValid())

        return d->property.customType;

    return QByteArray();

}

/*!

    Return true if this property is used as a default property in the QML

    document.

    \qml

<Text text="hello"/>

<Text>hello</Text>

    \endqml

    The above two examples return the same DOM tree, except that the second has

    the default property flag set on the text property.  Observe that whether

    or not a property has isDefaultProperty set is determined by how the

    property is used, and not only by whether the property is the types default

    property.

*/

bool QDeclarativeDomDynamicProperty::isDefaultProperty() const

{

    if (isValid())

        return d->property.isDefaultProperty;

    else