Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

1 files changed, 1835 insertions, 0 deletions

diff --git a/src/declarative/qml/qdeclarativedom.cpp b/src/declarative/qml/qdeclarativedom.cpp
new file mode 100644
index 0000000000..f1296aaf18
--- /dev/null
+++ b/src/declarative/qml/qdeclarativedom.cpp
@@ -0,0 +1,1835 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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();
+
+    QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(engine);
+    QDeclarativeTypeData *td = ep->typeLoader.get(data, url, QDeclarativeTypeLoader::PreserveParser);
+
+    if(td->isError()) {
+        d->errors = td->errors();
+        td->release();
+        return false;
+    } else if(!td->isCompleteOrError()) {
+        QDeclarativeError error;
+        error.setDescription(QLatin1String("QDeclarativeDomDocument supports local types only"));
+        d->errors << error;
+        td->release();
+        return false;
+    }
+
+    for (int i = 0; i < td->parser().imports().size(); ++i) {
+        QDeclarativeScriptParser::Import parserImport = td->parser().imports().at(i);
+        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;
+    }
+
+    if (td->parser().tree()) {
+        d->root = td->parser().tree();
+        d->root->addref();
+    }
+
+    td->release();
+    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.
+
+    \code
+<Text text="hello"/>
+<Text>hello</Text>
+    \endcode
+
+    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.
+
+    \code
+<Text text="hello"/>
+<Text>hello</Text>
+    \endcode
+
+    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
+        return false;
+}
+
+/*!
+    Returns the default value as a QDeclarativeDomProperty.
+*/
+QDeclarativeDomProperty QDeclarativeDomDynamicProperty::defaultValue() const
+{
+    QDeclarativeDomProperty rp;
+
+    if (isValid() && d->property.defaultValue) {
+        rp.d->property = d->property.defaultValue;
+        rp.d->propertyName = propertyName();
+        rp.d->property->addref();
+    }
+
+    return rp;
+}
+
+/*!
+    Returns true if this dynamic property is an alias for another property,
+    false otherwise.
+*/
+bool QDeclarativeDomDynamicProperty::isAlias() const
+{
+    if (isValid())
+        return d->property.type == QDeclarativeParser::Object::DynamicProperty::Alias;
+    else
+        return false;
+}
+
+/*!
+    Returns the position in the input data where the property ID startd, or 0 if
+ the property is invalid.
+*/
+int QDeclarativeDomDynamicProperty::position() const
+{
+    if (isValid()) {
+        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 0 if the property is invalid.
+*/
+int QDeclarativeDomDynamicProperty::length() const
+{
+    if (isValid())
+        return d->property.location.range.length;
+    else
+        return -1;
+}
+
+QDeclarativeDomObjectPrivate::QDeclarativeDomObjectPrivate()
+: object(0)
+{
+}
+
+QDeclarativeDomObjectPrivate::~QDeclarativeDomObjectPrivate()
+{
+    if (object) object->release();
+}
+
+QDeclarativeDomObjectPrivate::Properties
+QDeclarativeDomObjectPrivate::properties() const
+{
+    Properties rv;
+
+    for (QHash<QByteArray, QDeclarativeParser::Property *>::ConstIterator iter =
+            object->properties.begin();
+            iter != object->properties.end();
+            ++iter) {
+
+        rv << properties(*iter);
+
+    }
+    return rv;
+}
+
+QDeclarativeDomObjectPrivate::Properties
+QDeclarativeDomObjectPrivate::properties(QDeclarativeParser::Property *property) const
+{
+    Properties rv;
+
+    if (property->value) {
+
+        for (QHash<QByteArray, QDeclarativeParser::Property *>::ConstIterator iter =
+                property->value->properties.begin();
+                iter != property->value->properties.end();
+                ++iter) {
+
+            rv << properties(*iter);
+
+        }
+
+        QByteArray name(property->name + '.');
+        for (Properties::Iterator iter = rv.begin(); iter != rv.end(); ++iter)
+            iter->second.prepend(name);
+
+    } else {
+        rv << qMakePair(property, property->name);
+    }
+
+    return rv;
+}
+
+/*!
+    \class QDeclarativeDomObject
+    \internal
+    \brief The QDeclarativeDomObject class represents an object instantiation.
+
+    Each object instantiated in a QML file has a corresponding QDeclarativeDomObject
+    node in the QML DOM.
+
+    In addition to the type information that determines the object to
+    instantiate, QDeclarativeDomObject's also have a set of associated QDeclarativeDomProperty's.
+    Each QDeclarativeDomProperty represents a QML property assignment on the instantiated
+    object.  For example,
+
+    \qml
+QGraphicsWidget {
+    opacity: 0.5
+    size: "100x100"
+}
+    \endqml
+
+    describes a single QDeclarativeDomObject - "QGraphicsWidget" - with two properties,
+    "opacity" and "size".  Obviously QGraphicsWidget has many more properties than just
+    these two, but the QML DOM representation only contains those assigned
+    values (or bindings) in the QML file.
+*/
+
+/*!
+    Construct an invalid QDeclarativeDomObject.
+*/
+QDeclarativeDomObject::QDeclarativeDomObject()
+: d(new QDeclarativeDomObjectPrivate)
+{
+}
+
+/*!
+    Create a copy of \a other QDeclarativeDomObject.
+*/
+QDeclarativeDomObject::QDeclarativeDomObject(const QDeclarativeDomObject &other)
+: d(other.d)
+{
+}
+
+/*!
+    Destroy the QDeclarativeDomObject.
+*/
+QDeclarativeDomObject::~QDeclarativeDomObject()
+{
+}
+
+/*!
+    Assign \a other to this QDeclarativeDomObject.
+*/
+QDeclarativeDomObject &QDeclarativeDomObject::operator=(const QDeclarativeDomObject &other)
+{
+    d = other.d;
+    return *this;
+}
+
+/*!
+    Returns true if this is a valid QDeclarativeDomObject, false otherwise.
+*/
+bool QDeclarativeDomObject::isValid() const
+{
+    return d->object != 0;
+}
+
+/*!
+    Returns the fully-qualified type name of this object.
+
+    For example, the type of this object would be "Qt/4.6/Rectangle".
+    \qml
+Rectangle { }
+    \endqml
+*/
+QByteArray QDeclarativeDomObject::objectType() const
+{
+    if (d->object) return d->object->typeName;
+    else return QByteArray();
+}
+
+/*!
+    Returns the type name as referenced in the qml file.
+
+    For example, the type of this object would be "Rectangle".
+    \qml
+Rectangle { }
+    \endqml
+*/
+QByteArray QDeclarativeDomObject::objectClassName() const
+{
+    if (d->object)
+        return d->object->className;
+    else
+        return QByteArray();
+}
+
+int QDeclarativeDomObject::objectTypeMajorVersion() const
+{
+    if (d->object)
+        return d->object->majorVersion;
+    else
+        return -1;
+}
+
+int QDeclarativeDomObject::objectTypeMinorVersion() const
+{
+    if (d->object)
+        return d->object->minorVersion;
+    else
+        return -1;
+}
+
+/*!
+    Returns the QML id assigned to this object, or an empty QByteArray if no id
+    has been assigned.
+
+    For example, the object id of this object would be "MyText".
+    \qml
+Text { id: myText }
+    \endqml
+*/
+QString QDeclarativeDomObject::objectId() const
+{
+    if (d->object) {
+        return d->object->id;
+    } else {
+        return QString();
+    }
+}
+
+/*!
+    Returns the list of assigned properties on this object.
+
+    In the following example, "text" and "x" properties would be returned.
+    \qml
+Text {
+    text: "Hello world!"
+    x: 100
+}
+    \endqml
+*/
+QList<QDeclarativeDomProperty> QDeclarativeDomObject::properties() const
+{
+    QList<QDeclarativeDomProperty> rv;
+
+    if (!d->object || isComponent())
+        return rv;
+
+    QDeclarativeDomObjectPrivate::Properties properties = d->properties();
+    for (int ii = 0; ii < properties.count(); ++ii) {
+
+        QDeclarativeDomProperty domProperty;
+        domProperty.d->property = properties.at(ii).first;
+        domProperty.d->property->addref();
+        domProperty.d->propertyName = properties.at(ii).second;
+        rv << domProperty;
+
+    }
+
+    if (d->object->defaultProperty) {
+        QDeclarativeDomProperty domProperty;
+        domProperty.d->property = d->object->defaultProperty;
+        domProperty.d->property->addref();
+        domProperty.d->propertyName = d->object->defaultProperty->name;
+        rv << domProperty;
+    }
+
+    return rv;
+}
+
+/*!
+    Returns the object's \a name property if a value has been assigned to
+    it, or an invalid QDeclarativeDomProperty otherwise.
+
+    In the example below, \c {object.property("source")} would return a valid
+    QDeclarativeDomProperty, and \c {object.property("tile")} an invalid QDeclarativeDomProperty.
+
+    \qml
+Image { source: "sample.jpg" }
+    \endqml
+*/
+QDeclarativeDomProperty QDeclarativeDomObject::property(const QByteArray &name) const
+{
+    QList<QDeclarativeDomProperty> props = properties();
+    for (int ii = 0; ii < props.count(); ++ii)
+        if (props.at(ii).propertyName() == name)
+            return props.at(ii);
+    return QDeclarativeDomProperty();
+}
+
+QList<QDeclarativeDomDynamicProperty> QDeclarativeDomObject::dynamicProperties() const
+{
+    QList<QDeclarativeDomDynamicProperty> properties;
+
+    for (int i = 0; i < d->object->dynamicProperties.size(); ++i) {
+        QDeclarativeDomDynamicProperty p;
+        p.d = new QDeclarativeDomDynamicPropertyPrivate;
+        p.d->property = d->object->dynamicProperties.at(i);
+        p.d->valid = true;
+
+        if (p.d->property.defaultValue)
+            p.d->property.defaultValue->addref();
+
+        properties.append(p);
+    }
+
+    return properties;
+}
+
+QDeclarativeDomDynamicProperty QDeclarativeDomObject::dynamicProperty(const QByteArray &name) const
+{
+    QDeclarativeDomDynamicProperty p;
+
+    if (!isValid())
+        return p;
+
+    for (int i = 0; i < d->object->dynamicProperties.size(); ++i) {
+        if (d->object->dynamicProperties.at(i).name == name) {
+            p.d = new QDeclarativeDomDynamicPropertyPrivate;
+            p.d->property = d->object->dynamicProperties.at(i);
+            if (p.d->property.defaultValue) p.d->property.defaultValue->addref();
+            p.d->valid = true;
+        }
+    }
+
+    return p;
+}
+
+/*!
+    Returns true if this object is a custom type.  Custom types are special
+    types that allow embeddeding non-QML data, such as SVG or HTML data,
+    directly into QML files.
+
+    \note Currently this method will always return false, and is a placekeeper
+    for future functionality.
+
+    \sa QDeclarativeDomObject::customTypeData()
+*/
+bool QDeclarativeDomObject::isCustomType() const
+{
+    return false;
+}
+
+/*!
+    If this object represents a custom type, returns the data associated with
+    the custom type, otherwise returns an empty QByteArray().
+    QDeclarativeDomObject::isCustomType() can be used to check if this object represents
+    a custom type.
+*/
+QByteArray QDeclarativeDomObject::customTypeData() const
+{
+    return QByteArray();
+}
+
+/*!
+    Returns true if this object is a sub-component object.  Sub-component
+    objects can be converted into QDeclarativeDomComponent instances by calling
+    QDeclarativeDomObject::toComponent().
+
+    \sa QDeclarativeDomObject::toComponent()
+*/
+bool QDeclarativeDomObject::isComponent() const
+{
+    return (d->object && (d->object->typeName == "Qt/Component" || d->object->typeName == "QtQuick/Component"));
+}
+
+/*!
+    Returns a QDeclarativeDomComponent for this object if it is a sub-component, or
+    an invalid QDeclarativeDomComponent if not.  QDeclarativeDomObject::isComponent() can be used
+    to check if this object represents a sub-component.
+
+    \sa QDeclarativeDomObject::isComponent()
+*/
+QDeclarativeDomComponent QDeclarativeDomObject::toComponent() const
+{
+    QDeclarativeDomComponent rv;
+    if (isComponent())
+        rv.d = d;
+    return rv;
+}
+
+/*!
+    Returns the position in the input data where the property assignment started
+, or -1 if the property is invalid.
+*/
+int QDeclarativeDomObject::position() const
+{
+    if (d && d->object)
+        return d->object->location.range.offset;
+    else
+        return -1;
+}
+
+/*!
+    Returns the length in the input data from where the property assignment star
+ted upto the end of it, or -1 if the property is invalid.
+*/
+int QDeclarativeDomObject::length() const
+{
+    if (d && d->object)
+        return d->object->location.range.length;
+    else
+        return -1;
+}
+
+// Returns the URL of the type, if it is an external type, or an empty URL if
+// not
+QUrl QDeclarativeDomObject::url() const
+{
+    if (d && d->object)
+        return d->object->url;
+    else
+        return QUrl();
+}
+
+QDeclarativeDomBasicValuePrivate::QDeclarativeDomBasicValuePrivate()
+: value(0)
+{
+}
+
+QDeclarativeDomBasicValuePrivate::~QDeclarativeDomBasicValuePrivate()
+{
+    if (value) value->release();
+}
+
+/*!
+    \class QDeclarativeDomValueLiteral
+    \internal
+    \brief The QDeclarativeDomValueLiteral class represents a literal value.
+
+    A literal value is a simple value, written inline with the QML.  In the
+    example below, the "x", "y" and "color" properties are being assigned
+    literal values.
+
+    \qml
+Rectangle {
+    x: 10
+    y: 10
+    color: "red"
+}
+    \endqml
+*/
+
+/*!
+    Construct an empty QDeclarativeDomValueLiteral.
+*/
+QDeclarativeDomValueLiteral::QDeclarativeDomValueLiteral():
+    d(new QDeclarativeDomBasicValuePrivate)
+{
+}
+
+/*!
+    Create a copy of \a other QDeclarativeDomValueLiteral.
+*/
+QDeclarativeDomValueLiteral::QDeclarativeDomValueLiteral(const QDeclarativeDomValueLiteral &other)
+: d(other.d)
+{
+}
+
+/*!
+    Destroy the QDeclarativeDomValueLiteral.
+*/
+QDeclarativeDomValueLiteral::~QDeclarativeDomValueLiteral()
+{
+}
+
+/*!
+    Assign \a other to this QDeclarativeDomValueLiteral.
+*/
+QDeclarativeDomValueLiteral &QDeclarativeDomValueLiteral::operator=(const QDeclarativeDomValueLiteral &other)
+{
+    d = other.d;
+    return *this;
+}
+
+/*!
+    Return the literal value.
+
+    In the example below, the literal value will be the string "10".
+    \qml
+Rectangle { x: 10 }
+    \endqml
+*/
+QString QDeclarativeDomValueLiteral::literal() const
+{
+    if (d->value) return d->value->primitive();
+    else return QString();
+}
+
+/*!
+    \class QDeclarativeDomValueBinding
+    \internal
+    \brief The QDeclarativeDomValueBinding class represents a property binding.
+
+    A property binding is an ECMAScript expression assigned to a property.  In
+    the example below, the "x" property is being assigned a property binding.
+
+    \qml
+Rectangle { x: Other.x }
+    \endqml
+*/
+
+/*!
+    Construct an empty QDeclarativeDomValueBinding.
+*/
+QDeclarativeDomValueBinding::QDeclarativeDomValueBinding():
+        d(new QDeclarativeDomBasicValuePrivate)
+{
+}
+
+/*!
+    Create a copy of \a other QDeclarativeDomValueBinding.
+*/
+QDeclarativeDomValueBinding::QDeclarativeDomValueBinding(const QDeclarativeDomValueBinding &other)
+: d(other.d)
+{
+}
+
+/*!
+    Destroy the QDeclarativeDomValueBinding.
+*/
+QDeclarativeDomValueBinding::~QDeclarativeDomValueBinding()
+{
+}
+
+/*!
+    Assign \a other to this QDeclarativeDomValueBinding.
+*/
+QDeclarativeDomValueBinding &QDeclarativeDomValueBinding::operator=(const QDeclarativeDomValueBinding &other)
+{
+    d = other.d;
+    return *this;
+}
+
+/*!
+    Return the binding expression.
+
+    In the example below, the string "Other.x" will be returned.
+    \qml
+Rectangle { x: Other.x }
+    \endqml
+*/
+QString QDeclarativeDomValueBinding::binding() const
+{
+    if (d->value)
+        return d->value->value.asScript();
+    else
+        return QString();
+}
+
+/*!
+    \class QDeclarativeDomValueValueSource
+    \internal
+    \brief The QDeclarativeDomValueValueSource class represents a value source assignment value.
+
+    In QML, value sources are special value generating types that may be
+    assigned to properties.  Value sources inherit the QDeclarativePropertyValueSource
+    class.  In the example below, the "x" property is being assigned the
+    NumberAnimation value source.
+
+    \qml
+Rectangle {
+    x: NumberAnimation {
+        from: 0
+        to: 100
+        loops: Animation.Infinite
+    }
+}
+    \endqml
+*/
+
+/*!
+    Construct an empty QDeclarativeDomValueValueSource.
+*/
+QDeclarativeDomValueValueSource::QDeclarativeDomValueValueSource():
+        d(new QDeclarativeDomBasicValuePrivate)
+{
+}
+
+/*!
+    Create a copy of \a other QDeclarativeDomValueValueSource.
+*/
+QDeclarativeDomValueValueSource::QDeclarativeDomValueValueSource(const QDeclarativeDomValueValueSource &other)
+: d(other.d)
+{
+}
+
+/*!
+    Destroy the QDeclarativeDomValueValueSource.
+*/
+QDeclarativeDomValueValueSource::~QDeclarativeDomValueValueSource()
+{
+}
+
+/*!
+    Assign \a other to this QDeclarativeDomValueValueSource.
+*/
+QDeclarativeDomValueValueSource &QDeclarativeDomValueValueSource::operator=(const QDeclarativeDomValueValueSource &other)
+{
+    d = other.d;
+    return *this;
+}
+
+/*!
+    Return the value source object.
+
+    In the example below, an object representing the NumberAnimation will be
+    returned.
+    \qml
+Rectangle {
+    x: NumberAnimation {
+        from: 0
+        to: 100
+        loops: Animation.Infinite
+    }
+}
+    \endqml
+*/
+QDeclarativeDomObject QDeclarativeDomValueValueSource::object() const
+{
+    QDeclarativeDomObject rv;
+    if (d->value) {
+        rv.d->object = d->value->object;
+        rv.d->object->addref();
+    }
+    return rv;
+}
+
+/*!
+    \class QDeclarativeDomValueValueInterceptor
+    \internal
+    \brief The QDeclarativeDomValueValueInterceptor class represents a value interceptor assignment value.
+
+    In QML, value interceptor are special write-intercepting types that may be
+    assigned to properties.  Value interceptor inherit the QDeclarativePropertyValueInterceptor
+    class.  In the example below, the "x" property is being assigned the
+    Behavior value interceptor.
+
+    \qml
+Rectangle {
+    Behavior on x { NumberAnimation { duration: 500 } }
+}
+    \endqml
+*/
+
+/*!
+    Construct an empty QDeclarativeDomValueValueInterceptor.
+*/
+QDeclarativeDomValueValueInterceptor::QDeclarativeDomValueValueInterceptor():
+        d(new QDeclarativeDomBasicValuePrivate)
+{
+}
+
+/*!
+    Create a copy of \a other QDeclarativeDomValueValueInterceptor.
+*/
+QDeclarativeDomValueValueInterceptor::QDeclarativeDomValueValueInterceptor(const QDeclarativeDomValueValueInterceptor &other)
+: d(other.d)
+{
+}
+
+/*!
+    Destroy the QDeclarativeDomValueValueInterceptor.
+*/
+QDeclarativeDomValueValueInterceptor::~QDeclarativeDomValueValueInterceptor()
+{
+}
+
+/*!
+    Assign \a other to this QDeclarativeDomValueValueInterceptor.
+*/
+QDeclarativeDomValueValueInterceptor &QDeclarativeDomValueValueInterceptor::operator=(const QDeclarativeDomValueValueInterceptor &other)
+{
+    d = other.d;
+    return *this;
+}
+
+/*!
+    Return the value interceptor object.
+
+    In the example below, an object representing the Behavior will be
+    returned.
+    \qml
+Rectangle {
+    Behavior on x { NumberAnimation { duration: 500 } }
+}
+    \endqml
+*/
+QDeclarativeDomObject QDeclarativeDomValueValueInterceptor::object() const
+{
+    QDeclarativeDomObject rv;
+    if (d->value) {
+        rv.d->object = d->value->object;
+        rv.d->object->addref();
+    }
+    return rv;
+}
+
+QDeclarativeDomValuePrivate::QDeclarativeDomValuePrivate()
+: property(0), value(0)
+{
+}
+
+QDeclarativeDomValuePrivate::~QDeclarativeDomValuePrivate()
+{
+    if (property) property->release();
+    if (value) value->release();
+}
+
+/*!
+    \class QDeclarativeDomValue
+    \internal
+    \brief The QDeclarativeDomValue class represents a generic Qml value.
+
+    QDeclarativeDomValue's can be assigned to QML \l {QDeclarativeDomProperty}{properties}.  In
+    QML, properties can be assigned various different values, including basic
+    literals, property bindings, property value sources, objects and lists of
+    values.  The QDeclarativeDomValue class allows a programmer to determine the specific
+    value type being assigned and access more detailed information through a
+    corresponding value type class.
+
+    For example, in the following example,
+
+    \qml
+Text {
+    text: "Hello World!"
+    y: Other.y
+}
+    \endqml
+
+    The text property is being assigned a literal, and the y property a property
+    binding.  To output the values assigned to the text and y properties in the
+    above example from C++,
+
+    \code
+    QDeclarativeDomDocument document;
+    QDeclarativeDomObject root = document.rootObject();
+
+    QDeclarativeDomProperty text = root.property("text");
+    if (text.value().isLiteral()) {
+        QDeclarativeDomValueLiteral literal = text.value().toLiteral();
+        qDebug() << literal.literal();
+    }
+
+    QDeclarativeDomProperty y = root.property("y");
+    if (y.value().isBinding()) {
+        QDeclarativeDomValueBinding binding = y.value().toBinding();
+        qDebug() << binding.binding();
+    }
+    \endcode
+*/
+
+/*!
+    Construct an invalid QDeclarativeDomValue.
+*/
+QDeclarativeDomValue::QDeclarativeDomValue()
+: d(new QDeclarativeDomValuePrivate)
+{
+}
+
+/*!
+    Create a copy of \a other QDeclarativeDomValue.
+*/
+QDeclarativeDomValue::QDeclarativeDomValue(const QDeclarativeDomValue &other)
+: d(other.d)
+{
+}
+
+/*!
+    Destroy the QDeclarativeDomValue
+*/
+QDeclarativeDomValue::~QDeclarativeDomValue()
+{
+}
+
+/*!
+    Assign \a other to this QDeclarativeDomValue.
+*/
+QDeclarativeDomValue &QDeclarativeDomValue::operator=(const QDeclarativeDomValue &other)
+{
+    d = other.d;
+    return *this;
+}
+
+/*!
+    \enum QDeclarativeDomValue::Type
+
+    The type of the QDeclarativeDomValue node.
+
+    \value Invalid The QDeclarativeDomValue is invalid.
+    \value Literal The QDeclarativeDomValue is a literal value assignment.  Use QDeclarativeDomValue::toLiteral() to access the type instance.
+    \value PropertyBinding The QDeclarativeDomValue is a property binding.  Use QDeclarativeDomValue::toBinding() to access the type instance.
+    \value ValueSource The QDeclarativeDomValue is a property value source.  Use QDeclarativeDomValue::toValueSource() to access the type instance.
+    \value ValueInterceptor The QDeclarativeDomValue is a property value interceptor.  Use QDeclarativeDomValue::toValueInterceptor() to access the type instance.
+    \value Object The QDeclarativeDomValue is an object assignment.  Use QDeclarativeDomValue::toObject() to access the type instnace.
+    \value List The QDeclarativeDomValue is a list of other values.  Use QDeclarativeDomValue::toList() to access the type instance.
+*/
+
+/*!
+    Returns the type of this QDeclarativeDomValue.
+*/
+QDeclarativeDomValue::Type QDeclarativeDomValue::type() const
+{
+    if (d->property)
+        if (QDeclarativeMetaType::isList(d->property->type) ||
+           (d->property && (d->property->values.count() + d->property->onValues.count()) > 1))
+            return List;
+
+    QDeclarativeParser::Value *value = d->value;
+    if (!value && !d->property)
+        return Invalid;
+
+    switch(value->type) {
+    case QDeclarativeParser::Value::Unknown:
+        return Invalid;
+    case QDeclarativeParser::Value::Literal:
+        return Literal;
+    case QDeclarativeParser::Value::PropertyBinding:
+        return PropertyBinding;
+    case QDeclarativeParser::Value::ValueSource:
+        return ValueSource;
+    case QDeclarativeParser::Value::ValueInterceptor:
+        return ValueInterceptor;
+    case QDeclarativeParser::Value::CreatedObject:
+        return Object;
+    case QDeclarativeParser::Value::SignalObject:
+        return Invalid;
+    case QDeclarativeParser::Value::SignalExpression:
+        return Literal;
+    case QDeclarativeParser::Value::Id:
+        return Literal;
+    }
+    return Invalid;
+}
+
+/*!
+    Returns true if this is an invalid value, otherwise false.
+*/
+bool QDeclarativeDomValue::isInvalid() const
+{
+    return type() == Invalid;
+}
+
+/*!
+    Returns true if this is a literal value, otherwise false.
+*/
+bool QDeclarativeDomValue::isLiteral() const
+{
+    return type() == Literal;
+}
+
+/*!
+    Returns true if this is a property binding value, otherwise false.
+*/
+bool QDeclarativeDomValue::isBinding() const
+{
+    return type() == PropertyBinding;
+}
+
+/*!
+    Returns true if this is a value source value, otherwise false.
+*/
+bool QDeclarativeDomValue::isValueSource() const
+{
+    return type() == ValueSource;
+}
+
+/*!
+    Returns true if this is a value interceptor value, otherwise false.
+*/
+bool QDeclarativeDomValue::isValueInterceptor() const
+{
+    return type() == ValueInterceptor;
+}
+
+/*!
+    Returns true if this is an object value, otherwise false.
+*/
+bool QDeclarativeDomValue::isObject() const
+{
+    return type() == Object;
+}
+
+/*!
+    Returns true if this is a list value, otherwise false.
+*/
+bool QDeclarativeDomValue::isList() const
+{
+    return type() == List;
+}
+
+/*!
+    Returns a QDeclarativeDomValueLiteral if this value is a literal type, otherwise
+    returns an invalid QDeclarativeDomValueLiteral.
+
+    \sa QDeclarativeDomValue::type()
+*/
+QDeclarativeDomValueLiteral QDeclarativeDomValue::toLiteral() const
+{
+    QDeclarativeDomValueLiteral rv;
+    if (type() == Literal) {
+        rv.d->value = d->value;
+        rv.d->value->addref();
+    }
+    return rv;
+}
+
+/*!
+    Returns a QDeclarativeDomValueBinding if this value is a property binding type,
+    otherwise returns an invalid QDeclarativeDomValueBinding.
+
+    \sa QDeclarativeDomValue::type()
+*/
+QDeclarativeDomValueBinding QDeclarativeDomValue::toBinding() const
+{
+    QDeclarativeDomValueBinding rv;
+    if (type() == PropertyBinding) {
+        rv.d->value = d->value;
+        rv.d->value->addref();
+    }
+    return rv;
+}
+
+/*!
+    Returns a QDeclarativeDomValueValueSource if this value is a property value source
+    type, otherwise returns an invalid QDeclarativeDomValueValueSource.
+
+    \sa QDeclarativeDomValue::type()
+*/
+QDeclarativeDomValueValueSource QDeclarativeDomValue::toValueSource() const
+{
+    QDeclarativeDomValueValueSource rv;
+    if (type() == ValueSource) {
+        rv.d->value = d->value;
+        rv.d->value->addref();
+    }
+    return rv;
+}
+
+/*!
+    Returns a QDeclarativeDomValueValueInterceptor if this value is a property value interceptor
+    type, otherwise returns an invalid QDeclarativeDomValueValueInterceptor.
+
+    \sa QDeclarativeDomValue::type()
+*/
+QDeclarativeDomValueValueInterceptor QDeclarativeDomValue::toValueInterceptor() const
+{
+    QDeclarativeDomValueValueInterceptor rv;
+    if (type() == ValueInterceptor) {
+        rv.d->value = d->value;
+        rv.d->value->addref();
+    }
+    return rv;
+}
+
+/*!
+    Returns a QDeclarativeDomObject if this value is an object assignment type, otherwise
+    returns an invalid QDeclarativeDomObject.
+
+    \sa QDeclarativeDomValue::type()
+*/
+QDeclarativeDomObject QDeclarativeDomValue::toObject() const
+{
+    QDeclarativeDomObject rv;
+    if (type() == Object) {
+        rv.d->object = d->value->object;
+        rv.d->object->addref();
+    }
+    return rv;
+}
+
+/*!
+    Returns a QDeclarativeDomList if this value is a list type, otherwise returns an
+    invalid QDeclarativeDomList.
+
+    \sa QDeclarativeDomValue::type()
+*/
+QDeclarativeDomList QDeclarativeDomValue::toList() const
+{
+    QDeclarativeDomList rv;
+    if (type() == List) {
+        rv.d = d;
+    }
+    return rv;
+}
+
+/*!
+    Returns the position in the input data where the property value startd, or -1
+ if the value is invalid.
+*/
+int QDeclarativeDomValue::position() const
+{
+    if (type() == Invalid)
+        return -1;
+    else
+        return d->value->location.range.offset;
+}
+
+/*!
+    Returns the length in the input data from where the property value started u
+pto the end of it, or -1 if the value is invalid.
+*/
+int QDeclarativeDomValue::length() const
+{
+    if (type() == Invalid)
+        return -1;
+    else
+        return d->value->location.range.length;
+}
+
+/*!
+    \class QDeclarativeDomList
+    \internal
+    \brief The QDeclarativeDomList class represents a list of values assigned to a QML property.
+
+    Lists of values can be assigned to properties.  For example, the following
+    example assigns multiple objects to Item's "children" property
+    \qml
+Item {
+    children: [
+        Text { },
+        Rectangle { }
+    ]
+}
+    \endqml
+
+    Lists can also be implicitly created by assigning multiple
+    \l {QDeclarativeDomValueValueSource}{value sources} or constants to a property.
+    \qml
+Item {
+    x: 10
+    x: NumberAnimation {
+        running: false
+        from: 0
+        to: 100
+    }
+}
+    \endqml
+*/
+
+/*!
+    Construct an empty QDeclarativeDomList.
+*/
+QDeclarativeDomList::QDeclarativeDomList()
+{
+}
+
+/*!
+    Create a copy of \a other QDeclarativeDomList.
+*/
+QDeclarativeDomList::QDeclarativeDomList(const QDeclarativeDomList &other)
+: d(other.d)
+{
+}
+
+/*!
+    Destroy the QDeclarativeDomList.
+*/
+QDeclarativeDomList::~QDeclarativeDomList()
+{
+}
+
+/*!
+    Assign \a other to this QDeclarativeDomList.
+*/
+QDeclarativeDomList &QDeclarativeDomList::operator=(const QDeclarativeDomList &other)
+{
+    d = other.d;
+    return *this;
+}
+
+/*!
+    Returns the list of QDeclarativeDomValue's.
+*/
+QList<QDeclarativeDomValue> QDeclarativeDomList::values() const
+{
+    QList<QDeclarativeDomValue> rv;
+    if (!d->property)
+        return rv;
+
+    for (int ii = 0; ii < d->property->values.count(); ++ii) {
+        QDeclarativeDomValue v;
+        v.d->value = d->property->values.at(ii);
+        v.d->value->addref();
+        rv << v;
+    }
+
+    for (int ii = 0; ii < d->property->onValues.count(); ++ii) {
+        QDeclarativeDomValue v;
+        v.d->value = d->property->onValues.at(ii);
+        v.d->value->addref();
+        rv << v;
+    }
+
+    return rv;
+}
+
+/*!
+    Returns the position in the input data where the list started, or -1 if
+ the property is invalid.
+*/
+int QDeclarativeDomList::position() const
+{
+    if (d && d->property) {
+        return d->property->listValueRange.offset;
+    } else
+        return -1;
+}
+
+/*!
+    Returns the length in the input data from where the list started upto
+ the end of it, or 0 if the property is invalid.
+*/
+int QDeclarativeDomList::length() const
+{
+    if (d && d->property)
+        return d->property->listValueRange.length;
+    else
+        return -1;
+}
+
+/*!
+  Returns a list of positions of the commas in the QML file.
+*/
+QList<int> QDeclarativeDomList:: commaPositions() const
+{
+    if (d && d->property)
+        return d->property->listCommaPositions;
+    else
+        return QList<int>();
+}
+
+/*!
+    \class QDeclarativeDomComponent
+    \internal
+    \brief The QDeclarativeDomComponent class represents sub-component within a QML document.
+
+    Sub-components are QDeclarativeComponents defined within a QML document.  The
+    following example shows the definition of a sub-component with the id
+    "listDelegate".
+
+    \qml
+Item {
+    Component {
+        id: listDelegate
+        Text {
+            text: modelData.text
+        }
+    }
+}
+    \endqml
+
+    Like QDeclarativeDomDocument's, components contain a single root object.
+*/
+
+/*!
+    Construct an empty QDeclarativeDomComponent.
+*/
+QDeclarativeDomComponent::QDeclarativeDomComponent()
+{
+}
+
+/*!
+    Create a copy of \a other QDeclarativeDomComponent.
+*/
+QDeclarativeDomComponent::QDeclarativeDomComponent(const QDeclarativeDomComponent &other)
+: QDeclarativeDomObject(other)
+{
+}
+
+/*!
+    Destroy the QDeclarativeDomComponent.
+*/
+QDeclarativeDomComponent::~QDeclarativeDomComponent()
+{
+}
+
+/*!
+    Assign \a other to this QDeclarativeDomComponent.
+*/
+QDeclarativeDomComponent &QDeclarativeDomComponent::operator=(const QDeclarativeDomComponent &other)
+{
+    static_cast<QDeclarativeDomObject &>(*this) = other;
+    return *this;
+}
+
+/*!
+    Returns the component's root object.
+
+    In the example below, the root object is the "Text" object.
+    \qml
+Item {
+    Component {
+        id: listDelegate
+        Text {
+            text: modelData.text
+        }
+    }
+}
+    \endqml
+*/
+QDeclarativeDomObject QDeclarativeDomComponent::componentRoot() const
+{
+    QDeclarativeDomObject rv;
+    if (d->object) {
+        QDeclarativeParser::Object *obj = 0;
+        if (d->object->defaultProperty &&
+           d->object->defaultProperty->values.count() == 1 &&
+           d->object->defaultProperty->values.at(0)->object)
+            obj = d->object->defaultProperty->values.at(0)->object;
+
+        if (obj) {
+            rv.d->object = obj;
+            rv.d->object->addref();
+        }
+    }
+
+    return rv;
+}
+
+QDeclarativeDomImportPrivate::QDeclarativeDomImportPrivate()
+: type(File)
+{
+}
+
+QDeclarativeDomImportPrivate::~QDeclarativeDomImportPrivate()
+{
+}
+
+/*!
+    \class QDeclarativeDomImport
+    \internal
+    \brief The QDeclarativeDomImport class represents an import statement.
+*/
+
+/*!
+    Construct an empty QDeclarativeDomImport.
+*/
+QDeclarativeDomImport::QDeclarativeDomImport()
+: d(new QDeclarativeDomImportPrivate)
+{
+}
+
+/*!
+    Create a copy of \a other QDeclarativeDomImport.
+*/
+QDeclarativeDomImport::QDeclarativeDomImport(const QDeclarativeDomImport &other)
+: d(other.d)
+{
+}
+
+/*!
+    Destroy the QDeclarativeDomImport.
+*/
+QDeclarativeDomImport::~QDeclarativeDomImport()
+{
+}
+
+/*!
+    Assign \a other to this QDeclarativeDomImport.
+*/
+QDeclarativeDomImport &QDeclarativeDomImport::operator=(const QDeclarativeDomImport &other)
+{
+    d = other.d;
+    return *this;
+}
+
+/*!
+  Returns the type of the import.
+  */
+QDeclarativeDomImport::Type QDeclarativeDomImport::type() const
+{
+    return static_cast<QDeclarativeDomImport::Type>(d->type);
+}
+
+/*!
+  Returns the URI of the import (e.g. 'subdir' or 'com.nokia.Qt')
+  */
+QString QDeclarativeDomImport::uri() const
+{
+    return d->uri;
+}
+
+/*!
+  Returns the version specified by the import. An empty string if no version was specified.
+  */
+QString QDeclarativeDomImport::version() const
+{
+    return d->version;
+}
+
+/*!
+  Returns the (optional) qualifier string (the token following the 'as' keyword) of the import.
+  */
+QString QDeclarativeDomImport::qualifier() const
+{
+    return d->qualifier;
+}
+
+QT_END_NAMESPACE