1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtDeclarative module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "private/qdeclarativedom_p.h"

    43 #include "private/qdeclarativedom_p_p.h"

    44 

    45 #include "private/qdeclarativecompositetypedata_p.h"

    46 #include "private/qdeclarativecompiler_p.h"

    47 #include "private/qdeclarativeengine_p.h"

    48 #include "private/qdeclarativescriptparser_p.h"

    49 #include "private/qdeclarativeglobal_p.h"

    50 

    51 #include <QtCore/QByteArray>

    52 #include <QtCore/QDebug>

    53 #include <QtCore/QString>

    54 

    55 QT_BEGIN_NAMESPACE

    56 

    57 QDeclarativeDomDocumentPrivate::QDeclarativeDomDocumentPrivate()

    58 : root(0)

    59 {

    60 }

    61 

    62 QDeclarativeDomDocumentPrivate::~QDeclarativeDomDocumentPrivate()

    63 {

    64     if (root) root->release();

    65 }

    66 

    67 /*!

    68     \class QDeclarativeDomDocument

    69     \internal

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

    71 

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

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

    74     QDeclarativeDomDocument::rootObject().

    75 

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

    77     calling QDeclarativeDomDocument::load().

    78 

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

    80     object type and the properties assigned in the root object.

    81     \code

    82     QFile file(inputFileName);

    83     file.open(QIODevice::ReadOnly);

    84     QByteArray xmlData = file.readAll();

    85 

    86     QDeclarativeDomDocument document;

    87     document.load(qmlengine, xmlData);

    88 

    89     QDeclarativeDomObject rootObject = document.rootObject();

    90     qDebug() << rootObject.objectType();

    91     foreach(QDeclarativeDomProperty property, rootObject.properties())

    92         qDebug() << property.propertyName();

    93     \endcode

    94 */

    95 

    96 /*!

    97     Construct an empty QDeclarativeDomDocument.

    98 */

    99 QDeclarativeDomDocument::QDeclarativeDomDocument()

   100 : d(new QDeclarativeDomDocumentPrivate)

   101 {

   102 }

   103 

   104 /*!

   105     Create a copy of \a other QDeclarativeDomDocument.

   106 */

   107 QDeclarativeDomDocument::QDeclarativeDomDocument(const QDeclarativeDomDocument &other)

   108 : d(other.d)

   109 {

   110 }

   111 

   112 /*!

   113     Destroy the QDeclarativeDomDocument

   114 */

   115 QDeclarativeDomDocument::~QDeclarativeDomDocument()

   116 {

   117 }

   118 

   119 /*!

   120     Assign \a other to this QDeclarativeDomDocument.

   121 */

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

   123 {

   124     d = other.d;

   125     return *this;

   126 }

   127 

   128 /*!

   129     Returns all import statements in qml.

   130 */

   131 QList<QDeclarativeDomImport> QDeclarativeDomDocument::imports() const

   132 {

   133     return d->imports;

   134 }

   135 

   136 /*!

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

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

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

   140 

   141     \sa QDeclarativeDomDocument::loadError()

   142 */

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

   144 {

   145     d->errors.clear();

   146     d->imports.clear();

   147 

   148     QDeclarativeCompiledData *component = new QDeclarativeCompiledData(engine);

   149     QDeclarativeCompiler compiler;

   150 

   151     QDeclarativeCompositeTypeData *td = ((QDeclarativeEnginePrivate *)QDeclarativeEnginePrivate::get(engine))->typeManager.getImmediate(data, url);

   152 

   153     if(td->status == QDeclarativeCompositeTypeData::Error) {

   154         d->errors = td->errors;

   155         td->release();

   156         component->release();

   157         return false;

   158     } else if(td->status == QDeclarativeCompositeTypeData::Waiting ||

   159               td->status == QDeclarativeCompositeTypeData::WaitingResources) {

   160         QDeclarativeError error;

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

   162         d->errors << error;

   163         td->release();

   164         component->release();

   165         return false;

   166     }

   167 

   168     compiler.compile(engine, td, component);

   169 

   170     if (compiler.isError()) {

   171         d->errors = compiler.errors();

   172         td->release();

   173         component->release();

   174         return false;

   175     }

   176 

   177     for (int i = 0; i < td->data.imports().size(); ++i) {

   178         QDeclarativeScriptParser::Import parserImport = td->data.imports().at(i);

   179         QDeclarativeDomImport domImport;

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

   181         domImport.d->uri = parserImport.uri;

   182         domImport.d->qualifier = parserImport.qualifier;

   183         domImport.d->version = parserImport.version;

   184         d->imports += domImport;

   185     }

   186 

   187     if (td->data.tree()) {

   188         d->root = td->data.tree();

   189         d->root->addref();

   190     }

   191 

   192     component->release();

   193     return true;

   194 }

   195 

   196 /*!

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

   198     successful call to load().

   199 

   200     \sa load()

   201 */

   202 QList<QDeclarativeError> QDeclarativeDomDocument::errors() const

   203 {

   204     return d->errors;

   205 }

   206 

   207 /*!

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

   209     document has no root.

   210 

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

   212     \qml

   213 Item {

   214     Text {

   215         text: "Hello World"

   216     }

   217 }

   218     \endqml

   219 */

   220 QDeclarativeDomObject QDeclarativeDomDocument::rootObject() const

   221 {

   222     QDeclarativeDomObject rv;

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

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

   225     return rv;

   226 }

   227 

   228 QDeclarativeDomPropertyPrivate::QDeclarativeDomPropertyPrivate()

   229 : property(0)

   230 {

   231 }

   232 

   233 QDeclarativeDomPropertyPrivate::~QDeclarativeDomPropertyPrivate()

   234 {

   235     if (property) property->release();

   236 }

   237 

   238 QDeclarativeDomDynamicPropertyPrivate::QDeclarativeDomDynamicPropertyPrivate():

   239         valid(false)

   240 {

   241 }

   242 

   243 QDeclarativeDomDynamicPropertyPrivate::~QDeclarativeDomDynamicPropertyPrivate()

   244 {

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

   246 }

   247 

   248 /*!

   249     \class QDeclarativeDomProperty

   250     \internal

   251     \brief The QDeclarativeDomProperty class represents one property assignment in the

   252     QML DOM tree

   253 

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

   255 

   256     \sa QDeclarativeDomObject

   257 */

   258 

   259 /*!

   260     Construct an invalid QDeclarativeDomProperty.

   261 */

   262 QDeclarativeDomProperty::QDeclarativeDomProperty()

   263 : d(new QDeclarativeDomPropertyPrivate)

   264 {

   265 }

   266 

   267 /*!

   268     Create a copy of \a other QDeclarativeDomProperty.

   269 */

   270 QDeclarativeDomProperty::QDeclarativeDomProperty(const QDeclarativeDomProperty &other)

   271 : d(other.d)

   272 {

   273 }

   274 

   275 /*!

   276     Destroy the QDeclarativeDomProperty.

   277 */

   278 QDeclarativeDomProperty::~QDeclarativeDomProperty()

   279 {

   280 }

   281 

   282 /*!

   283     Assign \a other to this QDeclarativeDomProperty.

   284 */

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

   286 {

   287     d = other.d;

   288     return *this;

   289 }

   290 

   291 /*!

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

   293 */

   294 bool QDeclarativeDomProperty::isValid() const

   295 {

   296     return d->property != 0;

   297 }

   298 

   299 

   300 /*!

   301     Return the name of this property.

   302 

   303     \qml

   304 Text {

   305     x: 10

   306     y: 10

   307     font.bold: true

   308 }

   309     \endqml

   310 

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

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

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

   314 

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

   316     QDeclarativeDomProperty::propertyNameParts().

   317 

   318     \sa QDeclarativeDomProperty::propertyNameParts()

   319 */

   320 QByteArray QDeclarativeDomProperty::propertyName() const

   321 {

   322     return d->propertyName;

   323 }

   324 

   325 /*!

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

   327     of dot properties.

   328 

   329     \qml

   330 Text {

   331     x: 10

   332     y: 10

   333     font.bold: true

   334 }

   335     \endqml

   336 

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

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

   339 

   340     \sa QDeclarativeDomProperty::propertyName()

   341 */

   342 QList<QByteArray> QDeclarativeDomProperty::propertyNameParts() const

   343 {

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

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

   346 }

   347 

   348 /*!

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

   350     document.

   351 

   352     \qml

   353 <Text text="hello"/>

   354 <Text>hello</Text>

   355     \endqml

   356 

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

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

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

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

   361     property.

   362 */

   363 bool QDeclarativeDomProperty::isDefaultProperty() const

   364 {

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

   366 }

   367 

   368 /*!

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

   370     QDeclarativeDomValue if no value is assigned.

   371 */

   372 QDeclarativeDomValue QDeclarativeDomProperty::value() const

   373 {

   374     QDeclarativeDomValue rv;

   375     if (d->property) {

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

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

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

   379         else

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

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

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

   383     }

   384     return rv;

   385 }

   386 

   387 /*!

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

   389  the property is invalid.

   390 */

   391 int QDeclarativeDomProperty::position() const

   392 {

   393     if (d && d->property) {

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

   395     } else

   396         return -1;

   397 }

   398 

   399 /*!

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

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

   402 */

   403 int QDeclarativeDomProperty::length() const

   404 {

   405     if (d && d->property)

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

   407     else

   408         return -1;

   409 }

   410 

   411 /*!

   412     Construct an invalid QDeclarativeDomDynamicProperty.

   413 */

   414 QDeclarativeDomDynamicProperty::QDeclarativeDomDynamicProperty():

   415         d(new QDeclarativeDomDynamicPropertyPrivate)

   416 {

   417 }

   418 

   419 /*!

   420     Create a copy of \a other QDeclarativeDomDynamicProperty.

   421 */

   422 QDeclarativeDomDynamicProperty::QDeclarativeDomDynamicProperty(const QDeclarativeDomDynamicProperty &other):

   423         d(other.d)

   424 {

   425 }

   426 

   427 /*!

   428     Destroy the QDeclarativeDomDynamicProperty.

   429 */

   430 QDeclarativeDomDynamicProperty::~QDeclarativeDomDynamicProperty()

   431 {

   432 }

   433 

   434 /*!

   435     Assign \a other to this QDeclarativeDomDynamicProperty.

   436 */

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

   438 {

   439     d = other.d;

   440     return *this;

   441 }

   442 

   443 bool QDeclarativeDomDynamicProperty::isValid() const

   444 {

   445     return d && d->valid;

   446 }

   447 

   448 /*!

   449     Return the name of this dynamic property.

   450 

   451     \qml

   452 Item {

   453     property int count: 10;

   454 }

   455     \endqml

   456 

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

   458     default value ("10").

   459 */

   460 QByteArray QDeclarativeDomDynamicProperty::propertyName() const

   461 {

   462     if (isValid())

   463         return d->property.name;

   464     else

   465         return QByteArray();

   466 }

   467 

   468 /*!

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

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

   471    if the property is an alias.

   472 */

   473 int QDeclarativeDomDynamicProperty::propertyType() const

   474 {

   475     if (isValid()) {

   476         switch (d->property.type) {

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

   478                 return QMetaType::type("bool");

   479 

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

   481                 return QMetaType::type("QColor");

   482 

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

   484                 return QMetaType::type("QTime");

   485 

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

   487                 return QMetaType::type("QDate");

   488 

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

   490                 return QMetaType::type("QDateTime");

   491 

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

   493                 return QMetaType::type("int");

   494 

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

   496                 return QMetaType::type("double");

   497 

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

   499                 return QMetaType::type("QString");

   500 

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

   502                 return QMetaType::type("QUrl");

   503 

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

   505                 return QMetaType::type("QVariant");

   506 

   507             default:

   508                 break;

   509         }

   510     }

   511 

   512     return -1;

   513 }

   514 

   515 QByteArray QDeclarativeDomDynamicProperty::propertyTypeName() const

   516 {

   517     if (isValid())

   518         return d->property.customType;

   519 

   520     return QByteArray();

   521 }

   522 

   523 /*!

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

   525     document.

   526 

   527     \qml

   528 <Text text="hello"/>

   529 <Text>hello</Text>

   530     \endqml

   531 

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

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

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

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

   536     property.

   537 */

   538 bool QDeclarativeDomDynamicProperty::isDefaultProperty() const

   539 {

   540     if (isValid())

   541         return d->property.isDefaultProperty;

   542     else

   543         return false;

   544 }

   545 

   546 /*!

   547     Returns the default value as a QDeclarativeDomProperty.

   548 */

   549 QDeclarativeDomProperty QDeclarativeDomDynamicProperty::defaultValue() const

   550 {

   551     QDeclarativeDomProperty rp;

   552 

   553     if (isValid() && d->property.defaultValue) {

   554         rp.d->property = d->property.defaultValue;

   555         rp.d->propertyName = propertyName();

   556         rp.d->property->addref();

   557     }

   558 

   559     return rp;

   560 }

   561 

   562 /*!

   563     Returns true if this dynamic property is an alias for another property,

   564     false otherwise.

   565 */

   566 bool QDeclarativeDomDynamicProperty::isAlias() const

   567 {

   568     if (isValid())

   569         return d->property.type == QDeclarativeParser::Object::DynamicProperty::Alias;

   570     else

   571         return false;

   572 }

   573 

   574 /*!

   575     Returns the position in the input data where the property ID startd, or 0 if

   576  the property is invalid.

   577 */

   578 int QDeclarativeDomDynamicProperty::position() const

   579 {

   580     if (isValid()) {

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

   582     } else

   583         return -1;

   584 }

   585 

   586 /*!

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

   588  the end of it, or 0 if the property is invalid.

   589 */

   590 int QDeclarativeDomDynamicProperty::length() const

   591 {

   592     if (isValid())

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

   594     else

   595         return -1;

   596 }

   597 

   598 QDeclarativeDomObjectPrivate::QDeclarativeDomObjectPrivate()

   599 : object(0)

   600 {

   601 }

   602 

   603 QDeclarativeDomObjectPrivate::~QDeclarativeDomObjectPrivate()

   604 {

   605     if (object) object->release();

   606 }

   607 

   608 QDeclarativeDomObjectPrivate::Properties

   609 QDeclarativeDomObjectPrivate::properties() const

   610 {

   611     Properties rv;

   612 

   613     for (QHash<QByteArray, QDeclarativeParser::Property *>::ConstIterator iter =

   614             object->properties.begin();

   615             iter != object->properties.end();

   616             ++iter) {

   617 

   618         rv << properties(*iter);

   619 

   620     }

   621     return rv;

   622 }

   623 

   624 QDeclarativeDomObjectPrivate::Properties

   625 QDeclarativeDomObjectPrivate::properties(QDeclarativeParser::Property *property) const

   626 {

   627     Properties rv;

   628 

   629     if (property->value) {

   630 

   631         for (QHash<QByteArray, QDeclarativeParser::Property *>::ConstIterator iter =

   632                 property->value->properties.begin();

   633                 iter != property->value->properties.end();

   634                 ++iter) {

   635 

   636             rv << properties(*iter);

   637 

   638         }

   639 

   640         QByteArray name(property->name + '.');

   641         for (Properties::Iterator iter = rv.begin(); iter != rv.end(); ++iter)

   642             iter->second.prepend(name);

   643 

   644     } else {

   645         rv << qMakePair(property, property->name);

   646     }

   647 

   648     return rv;

   649 }

   650 

   651 /*!

   652     \class QDeclarativeDomObject

   653     \internal

   654     \brief The QDeclarativeDomObject class represents an object instantiation.

   655 

   656     Each object instantiated in a QML file has a corresponding QDeclarativeDomObject

   657     node in the QML DOM.

   658 

   659     In addition to the type information that determines the object to

   660     instantiate, QDeclarativeDomObject's also have a set of associated QDeclarativeDomProperty's.

   661     Each QDeclarativeDomProperty represents a QML property assignment on the instantiated

   662     object.  For example,

   663 

   664     \qml

   665 QGraphicsWidget {

   666     opacity: 0.5

   667     size: "100x100"

   668 }

   669     \endqml

   670 

   671     describes a single QDeclarativeDomObject - "QGraphicsWidget" - with two properties,

   672     "opacity" and "size".  Obviously QGraphicsWidget has many more properties than just

   673     these two, but the QML DOM representation only contains those assigned

   674     values (or bindings) in the QML file.

   675 */

   676 

   677 /*!

   678     Construct an invalid QDeclarativeDomObject.

   679 */

   680 QDeclarativeDomObject::QDeclarativeDomObject()

   681 : d(new QDeclarativeDomObjectPrivate)

   682 {

   683 }

   684 

   685 /*!

   686     Create a copy of \a other QDeclarativeDomObject.

   687 */

   688 QDeclarativeDomObject::QDeclarativeDomObject(const QDeclarativeDomObject &other)

   689 : d(other.d)

   690 {

   691 }

   692 

   693 /*!

   694     Destroy the QDeclarativeDomObject.

   695 */

   696 QDeclarativeDomObject::~QDeclarativeDomObject()

   697 {

   698 }

   699 

   700 /*!

   701     Assign \a other to this QDeclarativeDomObject.

   702 */

   703 QDeclarativeDomObject &QDeclarativeDomObject::operator=(const QDeclarativeDomObject &other)

   704 {

   705     d = other.d;

   706     return *this;

   707 }

   708 

   709 /*!

   710     Returns true if this is a valid QDeclarativeDomObject, false otherwise.

   711 */

   712 bool QDeclarativeDomObject::isValid() const

   713 {

   714     return d->object != 0;

   715 }

   716 

   717 /*!

   718     Returns the fully-qualified type name of this object.

   719 

   720     For example, the type of this object would be "Qt/4.6/Rectangle".

   721     \qml

   722 Rectangle { }

   723     \endqml

   724 */

   725 QByteArray QDeclarativeDomObject::objectType() const

   726 {

   727     if (d->object) return d->object->typeName;

   728     else return QByteArray();

   729 }

   730 

   731 /*!

   732     Returns the type name as referenced in the qml file.

   733 

   734     For example, the type of this object would be "Rectangle".

   735     \qml

   736 Rectangle { }

   737     \endqml

   738 */

   739 QByteArray QDeclarativeDomObject::objectClassName() const

   740 {

   741     if (d->object)

   742         return d->object->className;

   743     else

   744         return QByteArray();

   745 }

   746 

   747 int QDeclarativeDomObject::objectTypeMajorVersion() const

   748 {

   749     if (d->object)

   750         return d->object->majorVersion;

   751     else

   752         return -1;

   753 }

   754 

   755 int QDeclarativeDomObject::objectTypeMinorVersion() const

   756 {

   757     if (d->object)

   758         return d->object->minorVersion;

   759     else

   760         return -1;

   761 }

   762 

   763 /*!

   764     Returns the QML id assigned to this object, or an empty QByteArray if no id

   765     has been assigned.

   766 

   767     For example, the object id of this object would be "MyText".

   768     \qml

   769 Text { id: myText }

   770     \endqml

   771 */

   772 QString QDeclarativeDomObject::objectId() const

   773 {

   774     if (d->object) {

   775         return d->object->id;

   776     } else {

   777         return QString();

   778     }

   779 }

   780 

   781 /*!

   782     Returns the list of assigned properties on this object.

   783 

   784     In the following example, "text" and "x" properties would be returned.

   785     \qml

   786 Text {

   787     text: "Hello world!"

   788     x: 100

   789 }

   790     \endqml

   791 */

   792 QList<QDeclarativeDomProperty> QDeclarativeDomObject::properties() const

   793 {

   794     QList<QDeclarativeDomProperty> rv;

   795 

   796     if (!d->object || isComponent())

   797         return rv;

   798 

   799     QDeclarativeDomObjectPrivate::Properties properties = d->properties();

   800     for (int ii = 0; ii < properties.count(); ++ii) {

   801 

   802         QDeclarativeDomProperty domProperty;

   803         domProperty.d->property = properties.at(ii).first;

   804         domProperty.d->property->addref();

   805         domProperty.d->propertyName = properties.at(ii).second;

   806         rv << domProperty;

   807 

   808     }

   809 

   810     if (d->object->defaultProperty) {

   811         QDeclarativeDomProperty domProperty;

   812         domProperty.d->property = d->object->defaultProperty;

   813         domProperty.d->property->addref();

   814         domProperty.d->propertyName = d->object->defaultProperty->name;

   815         rv << domProperty;

   816     }

   817 

   818     return rv;

   819 }

   820 

   821 /*!

   822     Returns the object's \a name property if a value has been assigned to

   823     it, or an invalid QDeclarativeDomProperty otherwise.

   824 

   825     In the example below, \c {object.property("source")} would return a valid

   826     QDeclarativeDomProperty, and \c {object.property("tile")} an invalid QDeclarativeDomProperty.

   827 

   828     \qml

   829 Image { source: "sample.jpg" }

   830     \endqml

   831 */

   832 QDeclarativeDomProperty QDeclarativeDomObject::property(const QByteArray &name) const

   833 {

   834     QList<QDeclarativeDomProperty> props = properties();

   835     for (int ii = 0; ii < props.count(); ++ii)

   836         if (props.at(ii).propertyName() == name)

   837             return props.at(ii);

   838     return QDeclarativeDomProperty();

   839 }

   840 

   841 QList<QDeclarativeDomDynamicProperty> QDeclarativeDomObject::dynamicProperties() const

   842 {

   843     QList<QDeclarativeDomDynamicProperty> properties;

   844 

   845     for (int i = 0; i < d->object->dynamicProperties.size(); ++i) {

   846         QDeclarativeDomDynamicProperty p;

   847         p.d = new QDeclarativeDomDynamicPropertyPrivate;

   848         p.d->property = d->object->dynamicProperties.at(i);

   849         p.d->valid = true;

   850 

   851         if (p.d->property.defaultValue)

   852             p.d->property.defaultValue->addref();

   853 

   854         properties.append(p);

   855     }

   856 

   857     return properties;

   858 }

   859 

   860 QDeclarativeDomDynamicProperty QDeclarativeDomObject::dynamicProperty(const QByteArray &name) const

   861 {

   862     QDeclarativeDomDynamicProperty p;

   863 

   864     if (!isValid())

   865         return p;

   866 

   867     for (int i = 0; i < d->object->dynamicProperties.size(); ++i) {

   868         if (d->object->dynamicProperties.at(i).name == name) {

   869             p.d = new QDeclarativeDomDynamicPropertyPrivate;

   870             p.d->property = d->object->dynamicProperties.at(i);

   871             if (p.d->property.defaultValue) p.d->property.defaultValue->addref();

   872             p.d->valid = true;

   873         }

   874     }

   875 

   876     return p;

   877 }

   878 

   879 /*!

   880     Returns true if this object is a custom type.  Custom types are special

   881     types that allow embeddeding non-QML data, such as SVG or HTML data,

   882     directly into QML files.

   883 

   884     \note Currently this method will always return false, and is a placekeeper

   885     for future functionality.

   886 

   887     \sa QDeclarativeDomObject::customTypeData()

   888 */

   889 bool QDeclarativeDomObject::isCustomType() const

   890 {

   891     return false;

   892 }

   893 

   894 /*!

   895     If this object represents a custom type, returns the data associated with

   896     the custom type, otherwise returns an empty QByteArray().

   897     QDeclarativeDomObject::isCustomType() can be used to check if this object represents

   898     a custom type.

   899 */

   900 QByteArray QDeclarativeDomObject::customTypeData() const

   901 {

   902     return QByteArray();

   903 }

   904 

   905 /*!

   906     Returns true if this object is a sub-component object.  Sub-component

   907     objects can be converted into QDeclarativeDomComponent instances by calling

   908     QDeclarativeDomObject::toComponent().

   909 

   910     \sa QDeclarativeDomObject::toComponent()

   911 */

   912 bool QDeclarativeDomObject::isComponent() const

   913 {

   914     return (d->object && d->object->typeName == "Qt/Component");

   915 }

   916 

   917 /*!

   918     Returns a QDeclarativeDomComponent for this object if it is a sub-component, or

   919     an invalid QDeclarativeDomComponent if not.  QDeclarativeDomObject::isComponent() can be used

   920     to check if this object represents a sub-component.

   921 

   922     \sa QDeclarativeDomObject::isComponent()

   923 */

   924 QDeclarativeDomComponent QDeclarativeDomObject::toComponent() const

   925 {

   926     QDeclarativeDomComponent rv;

   927     if (isComponent())

   928         rv.d = d;

   929     return rv;

   930 }

   931 

   932 /*!

   933     Returns the position in the input data where the property assignment started

   934 , or -1 if the property is invalid.

   935 */

   936 int QDeclarativeDomObject::position() const

   937 {

   938     if (d && d->object)

   939         return d->object->location.range.offset;

   940     else

   941         return -1;

   942 }

   943 

   944 /*!

   945     Returns the length in the input data from where the property assignment star

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

   947 */

   948 int QDeclarativeDomObject::length() const

   949 {

   950     if (d && d->object)

   951         return d->object->location.range.length;

   952     else

   953         return -1;

   954 }

   955 

   956 // Returns the URL of the type, if it is an external type, or an empty URL if

   957 // not

   958 QUrl QDeclarativeDomObject::url() const

   959 {

   960     if (d && d->object)

   961         return d->object->url;

   962     else

   963         return QUrl();

   964 }

   965 

   966 QDeclarativeDomBasicValuePrivate::QDeclarativeDomBasicValuePrivate()

   967 : value(0)

   968 {

   969 }

   970 

   971 QDeclarativeDomBasicValuePrivate::~QDeclarativeDomBasicValuePrivate()

   972 {

   973     if (value) value->release();

   974 }

   975 

   976 /*!

   977     \class QDeclarativeDomValueLiteral

   978     \internal

   979     \brief The QDeclarativeDomValueLiteral class represents a literal value.

   980 

   981     A literal value is a simple value, written inline with the QML.  In the

   982     example below, the "x", "y" and "color" properties are being assigned

   983     literal values.

   984 

   985     \qml

   986 Rectangle {

   987     x: 10

   988     y: 10

   989     color: "red"

   990 }

   991     \endqml

   992 */

   993 

   994 /*!

   995     Construct an empty QDeclarativeDomValueLiteral.

   996 */

   997 QDeclarativeDomValueLiteral::QDeclarativeDomValueLiteral():

   998     d(new QDeclarativeDomBasicValuePrivate)

   999 {

  1000 }

  1001 

  1002 /*!

  1003     Create a copy of \a other QDeclarativeDomValueLiteral.

  1004 */

  1005 QDeclarativeDomValueLiteral::QDeclarativeDomValueLiteral(const QDeclarativeDomValueLiteral &other)

  1006 : d(other.d)

  1007 {

  1008 }

  1009 

  1010 /*!

  1011     Destroy the QDeclarativeDomValueLiteral.

  1012 */

  1013 QDeclarativeDomValueLiteral::~QDeclarativeDomValueLiteral()

  1014 {

  1015 }

  1016 

  1017 /*!

  1018     Assign \a other to this QDeclarativeDomValueLiteral.

  1019 */

  1020 QDeclarativeDomValueLiteral &QDeclarativeDomValueLiteral::operator=(const QDeclarativeDomValueLiteral &other)

  1021 {

  1022     d = other.d;

  1023     return *this;

  1024 }

  1025 

  1026 /*!

  1027     Return the literal value.

  1028 

  1029     In the example below, the literal value will be the string "10".

  1030     \qml

  1031 Rectangle { x: 10 }

  1032     \endqml

  1033 */

  1034 QString QDeclarativeDomValueLiteral::literal() const

  1035 {

  1036     if (d->value) return d->value->primitive();

  1037     else return QString();

  1038 }

  1039 

  1040 /*!

  1041     \class QDeclarativeDomValueBinding

  1042     \internal

  1043     \brief The QDeclarativeDomValueBinding class represents a property binding.

  1044 

  1045     A property binding is an ECMAScript expression assigned to a property.  In

  1046     the example below, the "x" property is being assigned a property binding.

  1047 

  1048     \qml

  1049 Rectangle { x: Other.x }

  1050     \endqml

  1051 */

  1052 

  1053 /*!

  1054     Construct an empty QDeclarativeDomValueBinding.

  1055 */

  1056 QDeclarativeDomValueBinding::QDeclarativeDomValueBinding():

  1057         d(new QDeclarativeDomBasicValuePrivate)

  1058 {

  1059 }

  1060 

  1061 /*!

  1062     Create a copy of \a other QDeclarativeDomValueBinding.

  1063 */

  1064 QDeclarativeDomValueBinding::QDeclarativeDomValueBinding(const QDeclarativeDomValueBinding &other)

  1065 : d(other.d)

  1066 {

  1067 }

  1068 

  1069 /*!

  1070     Destroy the QDeclarativeDomValueBinding.

  1071 */

  1072 QDeclarativeDomValueBinding::~QDeclarativeDomValueBinding()

  1073 {

  1074 }

  1075 

  1076 /*!

  1077     Assign \a other to this QDeclarativeDomValueBinding.

  1078 */

  1079 QDeclarativeDomValueBinding &QDeclarativeDomValueBinding::operator=(const QDeclarativeDomValueBinding &other)

  1080 {

  1081     d = other.d;

  1082     return *this;

  1083 }

  1084 

  1085 /*!

  1086     Return the binding expression.

  1087 

  1088     In the example below, the string "Other.x" will be returned.

  1089     \qml

  1090 Rectangle { x: Other.x }

  1091     \endqml

  1092 */

  1093 QString QDeclarativeDomValueBinding::binding() const

  1094 {

  1095     if (d->value)

  1096         return d->value->value.asScript();

  1097     else

  1098         return QString();

  1099 }

  1100 

  1101 /*!

  1102     \class QDeclarativeDomValueValueSource

  1103     \internal

  1104     \brief The QDeclarativeDomValueValueSource class represents a value source assignment value.

  1105 

  1106     In QML, value sources are special value generating types that may be

  1107     assigned to properties.  Value sources inherit the QDeclarativePropertyValueSource

  1108     class.  In the example below, the "x" property is being assigned the

  1109     NumberAnimation value source.

  1110 

  1111     \qml

  1112 Rectangle {

  1113     x: NumberAnimation {

  1114         from: 0

  1115         to: 100

  1116         loops: Animation.Infinite

  1117     }

  1118 }

  1119     \endqml

  1120 */

  1121 

  1122 /*!

  1123     Construct an empty QDeclarativeDomValueValueSource.

  1124 */

  1125 QDeclarativeDomValueValueSource::QDeclarativeDomValueValueSource():

  1126         d(new QDeclarativeDomBasicValuePrivate)

  1127 {

  1128 }

  1129 

  1130 /*!

  1131     Create a copy of \a other QDeclarativeDomValueValueSource.

  1132 */

  1133 QDeclarativeDomValueValueSource::QDeclarativeDomValueValueSource(const QDeclarativeDomValueValueSource &other)

  1134 : d(other.d)