Merge branch 'master' of git:qt/qt-qml

Conflicts:
	src/declarative/graphicsitems/qdeclarativeparticles.cpp

17 files changed, 149 insertions, 149 deletions

diff --git a/tools/qdoc3/atom.cpp b/tools/qdoc3/atom.cpp
index 88f44ea..6920e9d 100644
--- a/tools/qdoc3/atom.cpp
+++ b/tools/qdoc3/atom.cpp
@@ -133,7 +133,7 @@ QString Atom::UPPERROMAN_    ("upperroman");
   \value ParaLeft
   \value ParaRight
   \value Qml
-  \value QmlText
+  \value QDeclarativeText
   \value QuotationLeft
   \value QuotationRight
   \value RawString
@@ -210,7 +210,7 @@ static const struct {
     { "ParaRight", Atom::ParaRight },
 #ifdef QDOC_QML
     { "Qml", Atom::Qml},
-    { "QmlText", Atom::QmlText },
+    { "QDeclarativeText", Atom::QDeclarativeText },
 #endif
     { "QuotationLeft", Atom::QuotationLeft },
     { "QuotationRight", Atom::QuotationRight },
diff --git a/tools/qdoc3/atom.h b/tools/qdoc3/atom.h
index 70fbae9..d13afbc 100644
--- a/tools/qdoc3/atom.h
+++ b/tools/qdoc3/atom.h
@@ -103,7 +103,7 @@ class Atom
         ParaRight, 
 #ifdef QDOC_QML
         Qml,
-        QmlText,
+        QDeclarativeText,
 #endif
         QuotationLeft, 
         QuotationRight,
diff --git a/tools/qdoc3/codemarker.cpp b/tools/qdoc3/codemarker.cpp
index 15f2c2d..48e9341 100644
--- a/tools/qdoc3/codemarker.cpp
+++ b/tools/qdoc3/codemarker.cpp
@@ -290,13 +290,13 @@ QString CodeMarker::taggedQmlNode(const Node* node)
 {
     QString tag;
     switch (node->type()) {
-    case Node::QmlProperty:
+    case Node::QDeclarativeProperty:
         tag = QLatin1String("@property");
         break;
-    case Node::QmlSignal:
+    case Node::QDeclarativeSignal:
         tag = QLatin1String("@signal");
         break;
-    case Node::QmlMethod:
+    case Node::QDeclarativeMethod:
         tag = QLatin1String("@method");
         break;
     default:
@@ -369,7 +369,7 @@ void CodeMarker::insert(FastSection &fastSection,
     bool inheritedMember = false;
     if (!node->relates()) {
         if (node->parent() != (const InnerNode*)fastSection.innerNode) {
-            if (node->type() != Node::QmlProperty)
+            if (node->type() != Node::QDeclarativeProperty)
                 inheritedMember = true;
         }
     }
@@ -612,9 +612,9 @@ QString CodeMarker::macName(const Node *node, const QString &name)
 #ifdef QDOC_QML
 /*!
   Get the list of documentation sections for the children of
-  the specified QmlClassNode.
+  the specified QDeclarativeClassNode.
  */
-QList<Section> CodeMarker::qmlSections(const QmlClassNode* , SynopsisStyle )
+QList<Section> CodeMarker::qmlSections(const QDeclarativeClassNode* , SynopsisStyle )
 {
     return QList<Section>();
 }
diff --git a/tools/qdoc3/codemarker.h b/tools/qdoc3/codemarker.h
index 1b21753..9e754a2 100644
--- a/tools/qdoc3/codemarker.h
+++ b/tools/qdoc3/codemarker.h
@@ -138,7 +138,7 @@ class CodeMarker
                                     SynopsisStyle style, 
                                     Status status) = 0;
 #ifdef QDOC_QML
-    virtual QList<Section> qmlSections(const QmlClassNode* qmlClassNode,
+    virtual QList<Section> qmlSections(const QDeclarativeClassNode* qmlClassNode,
                                        SynopsisStyle style);
 #endif
     virtual const Node *resolveTarget(const QString& target, 
diff --git a/tools/qdoc3/cppcodemarker.cpp b/tools/qdoc3/cppcodemarker.cpp
index 657cfbb..ff09bb7 100644
--- a/tools/qdoc3/cppcodemarker.cpp
+++ b/tools/qdoc3/cppcodemarker.cpp
@@ -194,8 +194,8 @@ QString CppCodeMarker::markedUpSynopsis(const Node *node,
 	synopsis = "class " + name;
 	break;
     case Node::Function:
-    case Node::QmlSignal:
-    case Node::QmlMethod:
+    case Node::QDeclarativeSignal:
+    case Node::QDeclarativeMethod:
 	func = (const FunctionNode *) node;
 	if (style != SeparateList && !func->returnType().isEmpty())
 	    synopsis = typified(func->returnType()) + " ";
@@ -355,15 +355,15 @@ QString CppCodeMarker::markedUpQmlItem(const Node* node, bool summary)
     QString name = taggedQmlNode(node);
     if (summary) {
 	name = linkTag(node,name);
-    } else if (node->type() == Node::QmlProperty) {
-        const QmlPropertyNode* pn = static_cast<const QmlPropertyNode*>(node);
+    } else if (node->type() == Node::QDeclarativeProperty) {
+        const QDeclarativePropertyNode* pn = static_cast<const QDeclarativePropertyNode*>(node);
         if (pn->isAttached())
             name.prepend(pn->element() + QLatin1Char('.'));
     }
     name = "<@name>" + name + "</@name>";
     QString synopsis = name;
-    if (node->type() == Node::QmlProperty) {
-        const QmlPropertyNode* pn = static_cast<const QmlPropertyNode*>(node);
+    if (node->type() == Node::QDeclarativeProperty) {
+        const QDeclarativePropertyNode* pn = static_cast<const QDeclarativePropertyNode*>(node);
         synopsis += " : " + typified(pn->dataType());
     }
 
@@ -1108,7 +1108,7 @@ QString CppCodeMarker::addMarkUp(const QString& protectedCode,
 
   Currently, it only handles QML property groups.
  */
-QList<Section> CppCodeMarker::qmlSections(const QmlClassNode* qmlClassNode,
+QList<Section> CppCodeMarker::qmlSections(const QDeclarativeClassNode* qmlClassNode,
                                           SynopsisStyle style)
 {
     QList<Section> sections;
@@ -1141,12 +1141,12 @@ QList<Section> CppCodeMarker::qmlSections(const QmlClassNode* qmlClassNode,
 
             NodeList::ConstIterator c = qmlClassNode->childNodes().begin();
             while (c != qmlClassNode->childNodes().end()) {
-                if ((*c)->subType() == Node::QmlPropertyGroup) {
-                    const QmlPropGroupNode* qpgn = static_cast<const QmlPropGroupNode*>(*c);
+                if ((*c)->subType() == Node::QDeclarativePropertyGroup) {
+                    const QDeclarativePropGroupNode* qpgn = static_cast<const QDeclarativePropGroupNode*>(*c);
                     NodeList::ConstIterator p = qpgn->childNodes().begin();
                     while (p != qpgn->childNodes().end()) {
-                        if ((*p)->type() == Node::QmlProperty) {
-                            const QmlPropertyNode* pn = static_cast<const QmlPropertyNode*>(*p);
+                        if ((*p)->type() == Node::QDeclarativeProperty) {
+                            const QDeclarativePropertyNode* pn = static_cast<const QDeclarativePropertyNode*>(*p);
                             if (pn->isAttached())
                                 insert(qmlattachedproperties,*p,style,Okay);
                             else
@@ -1155,14 +1155,14 @@ QList<Section> CppCodeMarker::qmlSections(const QmlClassNode* qmlClassNode,
                         ++p;
                     }
                 }
-                else if ((*c)->type() == Node::QmlSignal) {
+                else if ((*c)->type() == Node::QDeclarativeSignal) {
                     const FunctionNode* sn = static_cast<const FunctionNode*>(*c);
                     if (sn->isAttached())
                         insert(qmlattachedsignals,*c,style,Okay);
                     else
                         insert(qmlsignals,*c,style,Okay);
                 }
-                else if ((*c)->type() == Node::QmlMethod) {
+                else if ((*c)->type() == Node::QDeclarativeMethod) {
                     const FunctionNode* mn = static_cast<const FunctionNode*>(*c);
                     if (mn->isAttached())
                         insert(qmlattachedmethods,*c,style,Okay);
@@ -1187,21 +1187,21 @@ QList<Section> CppCodeMarker::qmlSections(const QmlClassNode* qmlClassNode,
 	    FastSection qmlattachedmethods(qmlClassNode,"Attached Method Documentation");
 	    NodeList::ConstIterator c = qmlClassNode->childNodes().begin();
 	    while (c != qmlClassNode->childNodes().end()) {
-                if ((*c)->subType() == Node::QmlPropertyGroup) {
-                    const QmlPropGroupNode* pgn = static_cast<const QmlPropGroupNode*>(*c);
+                if ((*c)->subType() == Node::QDeclarativePropertyGroup) {
+                    const QDeclarativePropGroupNode* pgn = static_cast<const QDeclarativePropGroupNode*>(*c);
                     if (pgn->isAttached())
                         insert(qmlattachedproperties,*c,style,Okay);
                     else
                         insert(qmlproperties,*c,style,Okay);
 	        }
-                else if ((*c)->type() == Node::QmlSignal) {
+                else if ((*c)->type() == Node::QDeclarativeSignal) {
                     const FunctionNode* sn = static_cast<const FunctionNode*>(*c);
                     if (sn->isAttached())
                         insert(qmlattachedsignals,*c,style,Okay);
                     else
                         insert(qmlsignals,*c,style,Okay);
                 }
-                else if ((*c)->type() == Node::QmlMethod) {
+                else if ((*c)->type() == Node::QDeclarativeMethod) {
                     const FunctionNode* mn = static_cast<const FunctionNode*>(*c);
                     if (mn->isAttached())
                         insert(qmlattachedmethods,*c,style,Okay);
diff --git a/tools/qdoc3/cppcodemarker.h b/tools/qdoc3/cppcodemarker.h
index 2dcf400..2f6471a 100644
--- a/tools/qdoc3/cppcodemarker.h
+++ b/tools/qdoc3/cppcodemarker.h
@@ -79,7 +79,7 @@ class CppCodeMarker : public CodeMarker
     QList<Section> sections(const InnerNode *innerNode, 
                             SynopsisStyle style, 
                             Status status);
-    QList<Section> qmlSections(const QmlClassNode* qmlClassNode,
+    QList<Section> qmlSections(const QDeclarativeClassNode* qmlClassNode,
                                SynopsisStyle style);
     const Node *resolveTarget(const QString& target, 
                               const Tree *tree, 
diff --git a/tools/qdoc3/cppcodeparser.cpp b/tools/qdoc3/cppcodeparser.cpp
index d9e9c3b..4d30f3a 100644
--- a/tools/qdoc3/cppcodeparser.cpp
+++ b/tools/qdoc3/cppcodeparser.cpp
@@ -728,7 +728,7 @@ Node *CppCodeParser::processTopicCommand(const Doc& doc,
             if (n)
                 classNode = static_cast<const ClassNode*>(n);
         }
-        return new QmlClassNode(tre->root(), names[0], classNode);
+        return new QDeclarativeClassNode(tre->root(), names[0], classNode);
     }
     else if (command == COMMAND_QMLBASICTYPE) {
 #if 0        
@@ -738,11 +738,11 @@ Node *CppCodeParser::processTopicCommand(const Doc& doc,
             FakeNode* pageNode = static_cast<FakeNode*>(tre->root()->findNode(parts[1], Node::Fake));
             if (pageNode) {
                 qDebug() << "FOUND";
-                return new QmlBasicTypeNode(pageNode, parts[0]);
+                return new QDeclarativeBasicTypeNode(pageNode, parts[0]);
             }
         }
 #endif        
-        return new QmlBasicTypeNode(tre->root(), arg);
+        return new QDeclarativeBasicTypeNode(tre->root(), arg);
     }
     else if ((command == COMMAND_QMLSIGNAL) ||
              (command == COMMAND_QMLMETHOD) ||
@@ -750,19 +750,19 @@ Node *CppCodeParser::processTopicCommand(const Doc& doc,
              (command == COMMAND_QMLATTACHEDMETHOD)) {
         QString element;
         QString type;
-        QmlClassNode* qmlClass = 0;
+        QDeclarativeClassNode* qmlClass = 0;
         if (splitQmlMethodArg(doc,arg,type,element)) {
             Node* n = tre->findNode(QStringList(element),Node::Fake);
-            if (n && n->subType() == Node::QmlClass) {
-                qmlClass = static_cast<QmlClassNode*>(n);
+            if (n && n->subType() == Node::QDeclarativeClass) {
+                qmlClass = static_cast<QDeclarativeClassNode*>(n);
                 if (command == COMMAND_QMLSIGNAL)
-                    return makeFunctionNode(doc,arg,qmlClass,Node::QmlSignal,false,COMMAND_QMLSIGNAL);
+                    return makeFunctionNode(doc,arg,qmlClass,Node::QDeclarativeSignal,false,COMMAND_QMLSIGNAL);
                 else if (command == COMMAND_QMLATTACHEDSIGNAL)
-                    return makeFunctionNode(doc,arg,qmlClass,Node::QmlSignal,true,COMMAND_QMLATTACHEDSIGNAL);
+                    return makeFunctionNode(doc,arg,qmlClass,Node::QDeclarativeSignal,true,COMMAND_QMLATTACHEDSIGNAL);
                 else if (command == COMMAND_QMLMETHOD)
-                    return makeFunctionNode(doc,arg,qmlClass,Node::QmlMethod,false,COMMAND_QMLMETHOD);
+                    return makeFunctionNode(doc,arg,qmlClass,Node::QDeclarativeMethod,false,COMMAND_QMLMETHOD);
                 else if (command == COMMAND_QMLATTACHEDMETHOD)
-                    return makeFunctionNode(doc,arg,qmlClass,Node::QmlMethod,true,COMMAND_QMLATTACHEDMETHOD);
+                    return makeFunctionNode(doc,arg,qmlClass,Node::QDeclarativeMethod,true,COMMAND_QMLATTACHEDMETHOD);
                 else
                     return 0; // never get here.
             }
@@ -850,7 +850,7 @@ Node *CppCodeParser::processTopicCommandGroup(const Doc& doc,
                                               const QString& command,
                                               const QStringList& args)
 {
-    QmlPropGroupNode* qmlPropGroup = 0;
+    QDeclarativePropGroupNode* qmlPropGroup = 0;
     if ((command == COMMAND_QMLPROPERTY) ||
         (command == COMMAND_QMLATTACHEDPROPERTY)) {
         QString type;
@@ -860,20 +860,20 @@ Node *CppCodeParser::processTopicCommandGroup(const Doc& doc,
         QStringList::ConstIterator arg = args.begin();
         if (splitQmlPropertyArg(doc,(*arg),type,element,property)) {
             Node* n = tre->findNode(QStringList(element),Node::Fake);
-            if (n && n->subType() == Node::QmlClass) {
-                QmlClassNode* qmlClass = static_cast<QmlClassNode*>(n);
+            if (n && n->subType() == Node::QDeclarativeClass) {
+                QDeclarativeClassNode* qmlClass = static_cast<QDeclarativeClassNode*>(n);
                 if (qmlClass)
-                    qmlPropGroup = new QmlPropGroupNode(qmlClass,
+                    qmlPropGroup = new QDeclarativePropGroupNode(qmlClass,
                                                         property,
                                                         attached);
             }
         }
         if (qmlPropGroup) {
-            const ClassNode *correspondingClass = static_cast<const QmlClassNode*>(qmlPropGroup->parent())->classNode();
+            const ClassNode *correspondingClass = static_cast<const QDeclarativeClassNode*>(qmlPropGroup->parent())->classNode();
             PropertyNode *correspondingProperty = 0;
             if (correspondingClass)
                 correspondingProperty = static_cast<PropertyNode*>((Node*)correspondingClass->findNode(property, Node::Property));
-            QmlPropertyNode *qmlPropNode = new QmlPropertyNode(qmlPropGroup,property,type,attached);
+            QDeclarativePropertyNode *qmlPropNode = new QDeclarativePropertyNode(qmlPropGroup,property,type,attached);
             if (correspondingProperty) {
                 bool writableList = type.startsWith("list") && correspondingProperty->dataType().endsWith('*');
                 qmlPropNode->setWritable(writableList || correspondingProperty->isWritable());
@@ -881,7 +881,7 @@ Node *CppCodeParser::processTopicCommandGroup(const Doc& doc,
             ++arg;
             while (arg != args.end()) {
                 if (splitQmlPropertyArg(doc,(*arg),type,element,property)) {
-                    QmlPropertyNode* qmlPropNode = new QmlPropertyNode(qmlPropGroup,
+                    QDeclarativePropertyNode* qmlPropNode = new QDeclarativePropertyNode(qmlPropGroup,
                                                                        property,
                                                                        type,
                                                                        attached);
@@ -1033,12 +1033,12 @@ void CppCodeParser::processOtherMetaCommand(const Doc& doc,
 #ifdef QDOC_QML
     else if (command == COMMAND_QMLINHERITS) {
         setLink(node, Node::InheritsLink, arg);
-        if (node->subType() == Node::QmlClass) {
-            QmlClassNode::addInheritedBy(arg,node);
+        if (node->subType() == Node::QDeclarativeClass) {
+            QDeclarativeClassNode::addInheritedBy(arg,node);
         }
    }
     else if (command == COMMAND_QMLDEFAULT) {
-        QmlPropGroupNode* qpgn = static_cast<QmlPropGroupNode*>(node);
+        QDeclarativePropGroupNode* qpgn = static_cast<QDeclarativePropGroupNode*>(node);
         qpgn->setDefault();
     }
 #endif
diff --git a/tools/qdoc3/doc.cpp b/tools/qdoc3/doc.cpp
index ad4cdde..78b5d1f 100644
--- a/tools/qdoc3/doc.cpp
+++ b/tools/qdoc3/doc.cpp
@@ -553,7 +553,7 @@ void DocParser::parse(const QString& source,
                         append(Atom::Qml, getCode(CMD_QML, marker));
                         break;
                     case CMD_QMLTEXT:
-                        append(Atom::QmlText);
+                        append(Atom::QDeclarativeText);
                         break;
 #endif                        
                     case CMD_CODELINE:
@@ -2842,7 +2842,7 @@ void Doc::initialize(const Config& config)
     DocParser::quoting = config.getBool(CONFIG_QUOTINGINFORMATION);
 
 #ifdef QDOC_QML
-    QmlClassNode::qmlOnly = config.getBool(CONFIG_QMLONLY);
+    QDeclarativeClassNode::qmlOnly = config.getBool(CONFIG_QMLONLY);
 #endif
 
     QStringMap reverseAliasMap;
diff --git a/tools/qdoc3/generator.cpp b/tools/qdoc3/generator.cpp
index a7ab453..8766696 100644
--- a/tools/qdoc3/generator.cpp
+++ b/tools/qdoc3/generator.cpp
@@ -301,7 +301,7 @@ bool Generator::generateQmlText(const Text& text,
 
     startText(relative, marker);
     while (atom) {
-        if (atom->type() != Atom::QmlText)
+        if (atom->type() != Atom::QDeclarativeText)
             atom = atom->next();
         else {
             atom = atom->next();
@@ -520,7 +520,7 @@ void Generator::generateInherits(const ClassNode *classe, CodeMarker *marker)
 #ifdef QDOC_QML
 /*!
  */
-void Generator::generateQmlInherits(const QmlClassNode* , CodeMarker* )
+void Generator::generateQmlInherits(const QDeclarativeClassNode* , CodeMarker* )
 {
     // stub.
 }
diff --git a/tools/qdoc3/generator.h b/tools/qdoc3/generator.h
index 50ffb0a..8e8eed8 100644
--- a/tools/qdoc3/generator.h
+++ b/tools/qdoc3/generator.h
@@ -101,7 +101,7 @@ class Generator
                                  const Node *relative,
                                  CodeMarker *marker,
                                  const QString& qmlName);
-    virtual void generateQmlInherits(const QmlClassNode* cn, 
+    virtual void generateQmlInherits(const QDeclarativeClassNode* cn, 
                                      CodeMarker* marker);
 #endif
     virtual void generateBody(const Node *node, CodeMarker *marker);
diff --git a/tools/qdoc3/helpprojectwriter.cpp b/tools/qdoc3/helpprojectwriter.cpp
index 2189e02..628fd0f 100644
--- a/tools/qdoc3/helpprojectwriter.cpp
+++ b/tools/qdoc3/helpprojectwriter.cpp
@@ -127,7 +127,7 @@ void HelpProjectWriter::readSelectors(SubProject &subproject, const QStringList
     subTypeHash["page"] = Node::Page;
     subTypeHash["externalpage"] = Node::ExternalPage;
 #ifdef QDOC_QML
-    subTypeHash["qmlclass"] = Node::QmlClass;
+    subTypeHash["qmlclass"] = Node::QDeclarativeClass;
 #endif
 
     QSet<Node::SubType> allSubTypes = QSet<Node::SubType>::fromList(subTypeHash.values());
@@ -188,8 +188,8 @@ QStringList HelpProjectWriter::keywordDetails(const Node *node) const
     } else if (node->type() == Node::Fake) {
         const FakeNode *fake = static_cast<const FakeNode *>(node);
 #ifdef QDOC_QML
-        if (fake->subType() == Node::QmlClass) {
-            details << (QmlClassNode::qmlOnly ? fake->name() : fake->fullTitle());
+        if (fake->subType() == Node::QDeclarativeClass) {
+            details << (QDeclarativeClassNode::qmlOnly ? fake->name() : fake->fullTitle());
             details << "QML." + fake->name();
         } else
 #endif
diff --git a/tools/qdoc3/htmlgenerator.cpp b/tools/qdoc3/htmlgenerator.cpp
index 0477ebb..7db5828 100644
--- a/tools/qdoc3/htmlgenerator.cpp
+++ b/tools/qdoc3/htmlgenerator.cpp
@@ -701,8 +701,8 @@ int HtmlGenerator::generateAtom(const Atom *atom,
                     const Node* node = n.value();
                     switch (node->type()) {
                       case Node::Fake:
-                          if (node->subType() == Node::QmlClass)
-                              sections[QmlClass].appendMember((Node*)node);
+                          if (node->subType() == Node::QDeclarativeClass)
+                              sections[QDeclarativeClass].appendMember((Node*)node);
                           break;
                       case Node::Namespace:
                           sections[Namespace].appendMember((Node*)node);
@@ -745,14 +745,14 @@ int HtmlGenerator::generateAtom(const Atom *atom,
                       case Node::Variable: 
                           sections[Variable].appendMember((Node*)node);
                           break;
-                      case Node::QmlProperty:
-                          sections[QmlProperty].appendMember((Node*)node);
+                      case Node::QDeclarativeProperty:
+                          sections[QDeclarativeProperty].appendMember((Node*)node);
                           break;
-                      case Node::QmlSignal:
-                          sections[QmlSignal].appendMember((Node*)node);
+                      case Node::QDeclarativeSignal:
+                          sections[QDeclarativeSignal].appendMember((Node*)node);
                           break;
-                      case Node::QmlMethod:
-                          sections[QmlMethod].appendMember((Node*)node);
+                      case Node::QDeclarativeMethod:
+                          sections[QDeclarativeMethod].appendMember((Node*)node);
                           break;
                       default:
                           break;
@@ -789,7 +789,7 @@ int HtmlGenerator::generateAtom(const Atom *atom,
                         out() << "<h3>" << protectEnc((*s).name) << "</h3>\n";
                         if (idx == Class)
                             generateCompactList(0, marker, ncmap.value(), QString("Q"));
-                        else if (idx == QmlClass)
+                        else if (idx == QDeclarativeClass)
                             generateCompactList(0, marker, nqcmap.value(), QString("Q"));
                         else if (idx == MemberFunction) {
                             ParentMaps parentmaps;
@@ -1190,7 +1190,7 @@ int HtmlGenerator::generateAtom(const Atom *atom,
               << "</code></b></font>";
         break;
 #ifdef QDOC_QML
-    case Atom::QmlText:
+    case Atom::QDeclarativeText:
     case Atom::EndQmlText:
         // don't do anything with these. They are just tags.
         break;
@@ -1453,7 +1453,7 @@ void HtmlGenerator::generateFakeNode(const FakeNode *fake, CodeMarker *marker)
         subTitleSize = SmallSubTitle;
         htmlTitle += " (" + fake->subTitle() + ")";
     }
-    else if (fake->subType() == Node::QmlBasicType) {
+    else if (fake->subType() == Node::QDeclarativeBasicType) {
         fullTitle = "QML Basic Type: " + fullTitle;
         htmlTitle = fullTitle;
     }
@@ -1527,8 +1527,8 @@ void HtmlGenerator::generateFakeNode(const FakeNode *fake, CodeMarker *marker)
         }
     }
 #ifdef QDOC_QML
-    else if (fake->subType() == Node::QmlClass) {
-        const QmlClassNode* qml_cn = static_cast<const QmlClassNode*>(fake);
+    else if (fake->subType() == Node::QDeclarativeClass) {
+        const QDeclarativeClassNode* qml_cn = static_cast<const QDeclarativeClassNode*>(fake);
         const ClassNode* cn = qml_cn->classNode();
         generateQmlInherits(qml_cn, marker);
         generateQmlInstantiates(qml_cn, marker);
@@ -2342,7 +2342,7 @@ void HtmlGenerator::generateCompactList(const Node *relative,
                         << linkForNode(it.value(), relative)
                         << "\">";
                     QStringList pieces;
-                    if (it.value()->subType() == Node::QmlClass)
+                    if (it.value()->subType() == Node::QDeclarativeClass)
                         pieces << it.value()->name();
                     else
                         pieces = fullName(it.value(), relative, marker).split("::");
@@ -3507,18 +3507,18 @@ QString HtmlGenerator::refForNode(const Node *node)
         break;
 #ifdef QDOC_QML        
     case Node::Fake:
-        if (node->subType() != Node::QmlPropertyGroup)
+        if (node->subType() != Node::QDeclarativePropertyGroup)
             break;
-    case Node::QmlProperty:
+    case Node::QDeclarativeProperty:
 #endif        
     case Node::Property:
         ref = node->name() + "-prop";
         break;
 #ifdef QDOC_QML
-    case Node::QmlSignal:
+    case Node::QDeclarativeSignal:
         ref = node->name() + "-signal";
         break;
-    case Node::QmlMethod:
+    case Node::QDeclarativeMethod:
         ref = node->name() + "-method";
         break;
 #endif        
@@ -3555,7 +3555,7 @@ QString HtmlGenerator::linkForNode(const Node *node, const Node *relative)
 #endif
     link += fn;
 
-    if (!node->isInnerNode() || node->subType() == Node::QmlPropertyGroup) {
+    if (!node->isInnerNode() || node->subType() == Node::QDeclarativePropertyGroup) {
         ref = refForNode(node);
         if (relative && fn == fileName(relative) && ref == refForNode(relative))
             return QString();
@@ -3758,7 +3758,7 @@ void HtmlGenerator::findAllSince(const InnerNode *node)
                     nsmap.value().insert(className,(*child));
                     ncmap.value().insert(className,(*child));
                 }
-                else if ((*child)->subType() == Node::QmlClass) {
+                else if ((*child)->subType() == Node::QDeclarativeClass) {
                     QString className = (*child)->name();
                     if ((*child)->parent() &&
                         (*child)->parent()->type() == Node::Namespace &&
@@ -3865,9 +3865,9 @@ void HtmlGenerator::findAllQmlClasses(const InnerNode *node)
     while (c != node->childNodes().constEnd()) {
         if ((*c)->type() == Node::Fake) {
             const FakeNode* fakeNode = static_cast<const FakeNode *>(*c);
-            if (fakeNode->subType() == Node::QmlClass) {
-                const QmlClassNode* qmlNode =
-                    static_cast<const QmlClassNode*>(fakeNode);
+            if (fakeNode->subType() == Node::QDeclarativeClass) {
+                const QDeclarativeClassNode* qmlNode =
+                    static_cast<const QDeclarativeClassNode*>(fakeNode);
                 const Node* n = qmlNode->classNode();
             }
             qmlClasses.insert(fakeNode->name(),*c);
@@ -4203,7 +4203,7 @@ void HtmlGenerator::generateQmlSummary(const Section& section,
         NodeList::ConstIterator m;
         int count = section.members.size();
         bool twoColumn = false;
-        if (section.members.first()->type() == Node::QmlProperty) {
+        if (section.members.first()->type() == Node::QDeclarativeProperty) {
             twoColumn = (count >= 5);
         }
         if (twoColumn)
@@ -4237,18 +4237,18 @@ void HtmlGenerator::generateDetailedQmlMember(const Node *node,
                                               const InnerNode *relative,
                                               CodeMarker *marker)
 {
-    const QmlPropertyNode* qpn = 0;
+    const QDeclarativePropertyNode* qpn = 0;
     generateMacRef(node, marker);
     out() << "<div class=\"qmlitem\">";
-    if (node->subType() == Node::QmlPropertyGroup) {
-        const QmlPropGroupNode* qpgn = static_cast<const QmlPropGroupNode*>(node);
+    if (node->subType() == Node::QDeclarativePropertyGroup) {
+        const QDeclarativePropGroupNode* qpgn = static_cast<const QDeclarativePropGroupNode*>(node);
         NodeList::ConstIterator p = qpgn->childNodes().begin();
         out() << "<div class=\"qmlproto\">";
         out() << "<table width=\"100%\" class=\"qmlname\">";
 
         while (p != qpgn->childNodes().end()) {
-            if ((*p)->type() == Node::QmlProperty) {
-                qpn = static_cast<const QmlPropertyNode*>(*p);
+            if ((*p)->type() == Node::QDeclarativeProperty) {
+                qpn = static_cast<const QDeclarativePropertyNode*>(*p);
                 out() << "<tr><td>";
                 out() << "<a name=\"" + refForNode(qpn) + "\"></a>";
                 if (!qpn->isWritable())
@@ -4270,7 +4270,7 @@ void HtmlGenerator::generateDetailedQmlMember(const Node *node,
         out() << "</table>";
         out() << "</div>";
     }
-    else if (node->type() == Node::QmlSignal) {
+    else if (node->type() == Node::QDeclarativeSignal) {
         const FunctionNode* qsn = static_cast<const FunctionNode*>(node);
         out() << "<div class=\"qmlproto\">";
         out() << "<table class=\"qmlname\">";
@@ -4282,7 +4282,7 @@ void HtmlGenerator::generateDetailedQmlMember(const Node *node,
         out() << "</table>";
         out() << "</div>";
     }
-    else if (node->type() == Node::QmlMethod) {
+    else if (node->type() == Node::QDeclarativeMethod) {
         const FunctionNode* qmn = static_cast<const FunctionNode*>(node);
         out() << "<div class=\"qmlproto\">";
         out() << "<table class=\"qmlname\">";
@@ -4307,7 +4307,7 @@ void HtmlGenerator::generateDetailedQmlMember(const Node *node,
   Output the "Inherits" line for the QML element,
   if there should be one.
  */
-void HtmlGenerator::generateQmlInherits(const QmlClassNode* cn,
+void HtmlGenerator::generateQmlInherits(const QDeclarativeClassNode* cn,
                                         CodeMarker* marker)
 {
     if (cn && !cn->links().empty()) {
@@ -4316,8 +4316,8 @@ void HtmlGenerator::generateQmlInherits(const QmlClassNode* cn,
             linkPair = cn->links()[Node::InheritsLink];
             QStringList strList(linkPair.first);
             const Node* n = myTree->findNode(strList,Node::Fake);
-            if (n && n->subType() == Node::QmlClass) {
-                const QmlClassNode* qcn = static_cast<const QmlClassNode*>(n);
+            if (n && n->subType() == Node::QDeclarativeClass) {
+                const QDeclarativeClassNode* qcn = static_cast<const QDeclarativeClassNode*>(n);
                 out() << "<p style=\"text-align: center\">";
                 Text text;
                 text << "[Inherits ";
@@ -4337,12 +4337,12 @@ void HtmlGenerator::generateQmlInherits(const QmlClassNode* cn,
   Output the "Inherit by" list for the QML element,
   if it is inherited by any other elements.
  */
-void HtmlGenerator::generateQmlInheritedBy(const QmlClassNode* cn,
+void HtmlGenerator::generateQmlInheritedBy(const QDeclarativeClassNode* cn,
                                            CodeMarker* marker)
 {
     if (cn) {
         NodeList subs;
-        QmlClassNode::subclasses(cn->name(),subs);
+        QDeclarativeClassNode::subclasses(cn->name(),subs);
         if (!subs.isEmpty()) {
             Text text;
             text << Atom::ParaLeft << "Inherited by ";
@@ -4354,13 +4354,13 @@ void HtmlGenerator::generateQmlInheritedBy(const QmlClassNode* cn,
 }
 
 /*!
-  Output the "[Xxx instantiates the C++ class QmlGraphicsXxx]"
+  Output the "[Xxx instantiates the C++ class QDeclarativeXxx]"
   line for the QML element, if there should be one.
 
   If there is no class node, or if the class node status
   is set to Node::Internal, do nothing. 
  */
-void HtmlGenerator::generateQmlInstantiates(const QmlClassNode* qcn,
+void HtmlGenerator::generateQmlInstantiates(const QDeclarativeClassNode* qcn,
                                             CodeMarker* marker)
 {
     const ClassNode* cn = qcn->classNode();
@@ -4384,7 +4384,7 @@ void HtmlGenerator::generateQmlInstantiates(const QmlClassNode* qcn,
 }
 
 /*!
-  Output the "[QmlGraphicsXxx is instantiated by QML element Xxx]"
+  Output the "[QDeclarativeXxx is instantiated by QML element Xxx]"
   line for the class, if there should be one.
 
   If there is no QML element, or if the class node status
@@ -4395,7 +4395,7 @@ void HtmlGenerator::generateInstantiatedBy(const ClassNode* cn,
 {
     if (cn &&  cn->status() != Node::Internal && !cn->qmlElement().isEmpty()) {
         const Node* n = myTree->root()->findNode(cn->qmlElement(),Node::Fake);
-        if (n && n->subType() == Node::QmlClass) {
+        if (n && n->subType() == Node::QDeclarativeClass) {
             out() << "<p style=\"text-align: center\">";
             Text text;
             text << "[";
diff --git a/tools/qdoc3/htmlgenerator.h b/tools/qdoc3/htmlgenerator.h
index 8fe0331..42c94cd 100644
--- a/tools/qdoc3/htmlgenerator.h
+++ b/tools/qdoc3/htmlgenerator.h
@@ -90,10 +90,10 @@ class HtmlGenerator : public PageGenerator
         Typedef, 
         Property,
         Variable, 
-        QmlClass,
-        QmlProperty,
-        QmlSignal,
-        QmlMethod,
+        QDeclarativeClass,
+        QDeclarativeProperty,
+        QDeclarativeSignal,
+        QDeclarativeMethod,
         LastSinceType
     };
 
@@ -185,9 +185,9 @@ class HtmlGenerator : public PageGenerator
     void generateDetailedQmlMember(const Node *node,
                                    const InnerNode *relative,
                                    CodeMarker *marker);
-    void generateQmlInherits(const QmlClassNode* cn, CodeMarker* marker);
-    void generateQmlInheritedBy(const QmlClassNode* cn, CodeMarker* marker);
-    void generateQmlInstantiates(const QmlClassNode* qcn, CodeMarker* marker);
+    void generateQmlInherits(const QDeclarativeClassNode* cn, CodeMarker* marker);
+    void generateQmlInheritedBy(const QDeclarativeClassNode* cn, CodeMarker* marker);
+    void generateQmlInstantiates(const QDeclarativeClassNode* qcn, CodeMarker* marker);
     void generateInstantiatedBy(const ClassNode* cn, CodeMarker* marker);
 #endif
 #ifdef QDOC_NAME_ALIGNMENT
diff --git a/tools/qdoc3/node.cpp b/tools/qdoc3/node.cpp
index 5357597..0ceda39 100644
--- a/tools/qdoc3/node.cpp
+++ b/tools/qdoc3/node.cpp
@@ -580,7 +580,7 @@ bool InnerNode::isSameSignature(const FunctionNode *f1, const FunctionNode *f2)
 void InnerNode::addChild(Node *child)
 {
     children.append(child);
-    if ((child->type() == Function) || (child->type() == QmlMethod)) {
+    if ((child->type() == Function) || (child->type() == QDeclarativeMethod)) {
         FunctionNode *func = (FunctionNode *) child;
         if (!primaryFunctionMap.contains(func->name())) {
             primaryFunctionMap.insert(func->name(), func);
@@ -806,8 +806,8 @@ FakeNode::FakeNode(InnerNode *parent, const QString& name, SubType subtype)
     case Group:
         setPageType(ArticlePage);
         break;
-    case QmlClass:
-    case QmlBasicType:
+    case QDeclarativeClass:
+    case QDeclarativeBasicType:
         setPageType(ApiPage);
         break;
     case Example:
@@ -1256,20 +1256,20 @@ bool TargetNode::isInnerNode() const
 }
 
 #ifdef QDOC_QML
-bool QmlClassNode::qmlOnly = false;
-QMultiMap<QString,Node*> QmlClassNode::inheritedBy;
+bool QDeclarativeClassNode::qmlOnly = false;
+QMultiMap<QString,Node*> QDeclarativeClassNode::inheritedBy;
 
 /*!
   Constructs a Qml class node (i.e. a Fake node with the
-  subtype QmlClass. The new node has the given \a parent
+  subtype QDeclarativeClass. The new node has the given \a parent
   and \a name and is associated with the C++ class node
   specified by \a cn which may be null if the the Qml
   class node is not associated with a C++ class node.
  */
-QmlClassNode::QmlClassNode(InnerNode *parent,
+QDeclarativeClassNode::QDeclarativeClassNode(InnerNode *parent,
                            const QString& name,
                            const ClassNode* cn)
-    : FakeNode(parent, name, QmlClass), cnode(cn)
+    : FakeNode(parent, name, QDeclarativeClass), cnode(cn)
 {
     setTitle((qmlOnly ? "" : "QML ") + name + " Element Reference");
 }
@@ -1280,7 +1280,7 @@ QmlClassNode::QmlClassNode(InnerNode *parent,
 
   But not yet. Still testing.
  */
-QString QmlClassNode::fileBase() const
+QString QDeclarativeClassNode::fileBase() const
 {
 #if 0    
     if (Node::fileBase() == "item")
@@ -1294,7 +1294,7 @@ QString QmlClassNode::fileBase() const
   Record the fact that QML class \a base is inherited by
   QML class \a sub.
  */
-void QmlClassNode::addInheritedBy(const QString& base, Node* sub)
+void QDeclarativeClassNode::addInheritedBy(const QString& base, Node* sub)
 {
     inheritedBy.insert(base,sub);
 }
@@ -1302,7 +1302,7 @@ void QmlClassNode::addInheritedBy(const QString& base, Node* sub)
 /*!
   Loads the list \a subs with the nodes of all the subclasses of \a base.
  */
-void QmlClassNode::subclasses(const QString& base, NodeList& subs)
+void QDeclarativeClassNode::subclasses(const QString& base, NodeList& subs)
 {
     subs.clear();
     if (inheritedBy.contains(base))
@@ -1311,24 +1311,24 @@ void QmlClassNode::subclasses(const QString& base, NodeList& subs)
 
 /*!
   Constructs a Qml basic type node (i.e. a Fake node with
-  the subtype QmlBasicType. The new node has the given
+  the subtype QDeclarativeBasicType. The new node has the given
   \a parent and \a name.
  */
-QmlBasicTypeNode::QmlBasicTypeNode(InnerNode *parent,
+QDeclarativeBasicTypeNode::QDeclarativeBasicTypeNode(InnerNode *parent,
                                    const QString& name)
-    : FakeNode(parent, name, QmlBasicType)
+    : FakeNode(parent, name, QDeclarativeBasicType)
 {
     setTitle(name);
 }
 
 /*!
   Constructor for the Qml property group node. \a parent is
-  always a QmlClassNode. 
+  always a QDeclarativeClassNode. 
  */
-QmlPropGroupNode::QmlPropGroupNode(QmlClassNode* parent,
+QDeclarativePropGroupNode::QDeclarativePropGroupNode(QDeclarativeClassNode* parent,
                                    const QString& name,
                                    bool attached)
-    : FakeNode(parent, name, QmlPropertyGroup),
+    : FakeNode(parent, name, QDeclarativePropertyGroup),
       isdefault(false),
       att(attached)
 {
@@ -1338,11 +1338,11 @@ QmlPropGroupNode::QmlPropGroupNode(QmlClassNode* parent,
 /*!
   Constructor for the QML property node.
  */
-QmlPropertyNode::QmlPropertyNode(QmlPropGroupNode *parent,
+QDeclarativePropertyNode::QDeclarativePropertyNode(QDeclarativePropGroupNode *parent,
                                  const QString& name,
                                  const QString& type,
                                  bool attached)
-    : LeafNode(QmlProperty, parent, name),
+    : LeafNode(QDeclarativeProperty, parent, name),
       dt(type),
       sto(Trool_Default),
       des(Trool_Default),
@@ -1354,7 +1354,7 @@ QmlPropertyNode::QmlPropertyNode(QmlPropGroupNode *parent,
 /*!
   I don't know what this is.
  */
-QmlPropertyNode::Trool QmlPropertyNode::toTrool(bool boolean)
+QDeclarativePropertyNode::Trool QDeclarativePropertyNode::toTrool(bool boolean)
 {
     return boolean ? Trool_True : Trool_False;
 }
@@ -1362,7 +1362,7 @@ QmlPropertyNode::Trool QmlPropertyNode::toTrool(bool boolean)
 /*!
   I don't know what this is either.
  */
-bool QmlPropertyNode::fromTrool(Trool troolean, bool defaultValue)
+bool QDeclarativePropertyNode::fromTrool(Trool troolean, bool defaultValue)
 {
     switch (troolean) {
     case Trool_True:
diff --git a/tools/qdoc3/node.h b/tools/qdoc3/node.h
index 3798e4e..5300efc 100644
--- a/tools/qdoc3/node.h
+++ b/tools/qdoc3/node.h
@@ -74,9 +74,9 @@ class Node
         Variable, 
 #ifdef QDOC_QML
         Target,
-        QmlProperty,
-        QmlSignal,
-        QmlMethod,
+        QDeclarativeProperty,
+        QDeclarativeSignal,
+        QDeclarativeMethod,
         LastType
 #else
         Target,
@@ -95,9 +95,9 @@ class Node
         Page,
 #ifdef QDOC_QML
         ExternalPage,
-        QmlClass,
-        QmlPropertyGroup,
-        QmlBasicType
+        QDeclarativeClass,
+        QDeclarativePropertyGroup,
+        QDeclarativeBasicType
 #else
         ExternalPage
 #endif
@@ -373,13 +373,13 @@ class FakeNode : public InnerNode
 };
 
 #ifdef QDOC_QML
-class QmlClassNode : public FakeNode
+class QDeclarativeClassNode : public FakeNode
 {
  public:
-    QmlClassNode(InnerNode *parent, 
+    QDeclarativeClassNode(InnerNode *parent, 
                  const QString& name, 
                  const ClassNode* cn);
-    virtual ~QmlClassNode() { }
+    virtual ~QDeclarativeClassNode() { }
 
     const ClassNode* classNode() const { return cnode; }
     virtual QString fileBase() const;
@@ -394,21 +394,21 @@ class QmlClassNode : public FakeNode
     const ClassNode*    cnode;
 };
 
-class QmlBasicTypeNode : public FakeNode
+class QDeclarativeBasicTypeNode : public FakeNode
 {
  public:
-    QmlBasicTypeNode(InnerNode *parent, 
+    QDeclarativeBasicTypeNode(InnerNode *parent, 
                      const QString& name);
-    virtual ~QmlBasicTypeNode() { }
+    virtual ~QDeclarativeBasicTypeNode() { }
 };
 
-class QmlPropGroupNode : public FakeNode
+class QDeclarativePropGroupNode : public FakeNode
 {
  public:
-    QmlPropGroupNode(QmlClassNode* parent, 
+    QDeclarativePropGroupNode(QDeclarativeClassNode* parent, 
                      const QString& name,
                      bool attached);
-    virtual ~QmlPropGroupNode() { }
+    virtual ~QDeclarativePropGroupNode() { }
 
     const QString& element() const { return parent()->name(); }
     void setDefault() { isdefault = true; }
@@ -420,14 +420,14 @@ class QmlPropGroupNode : public FakeNode
     bool    att;
 };
 
-class QmlPropertyNode : public LeafNode
+class QDeclarativePropertyNode : public LeafNode
 {
  public:
-    QmlPropertyNode(QmlPropGroupNode* parent, 
+    QDeclarativePropertyNode(QDeclarativePropGroupNode* parent, 
                     const QString& name,
                     const QString& type,
                     bool attached);
-    virtual ~QmlPropertyNode() { }
+    virtual ~QDeclarativePropertyNode() { }
 
     void setDataType(const QString& dataType) { dt = dataType; }
     void setStored(bool stored) { sto = toTrool(stored); }
@@ -441,7 +441,7 @@ class QmlPropertyNode : public LeafNode
     bool isWritable() const { return fromTrool(wri,true); }
     bool isAttached() const { return att; }
 
-    const QString& element() const { return static_cast<QmlPropGroupNode*>(parent())->element(); }
+    const QString& element() const { return static_cast<QDeclarativePropGroupNode*>(parent())->element(); }
 
  private:
     enum Trool { Trool_True, Trool_False, Trool_Default };
diff --git a/tools/qdoc3/pagegenerator.cpp b/tools/qdoc3/pagegenerator.cpp
index 2cad9ed..f129d3a 100644
--- a/tools/qdoc3/pagegenerator.cpp
+++ b/tools/qdoc3/pagegenerator.cpp
@@ -84,7 +84,7 @@ QString PageGenerator::fileBase(const Node *node) const
     else if (!node->isInnerNode())
 	node = node->parent();
 #ifdef QDOC_QML
-    if (node->subType() == Node::QmlPropertyGroup) {
+    if (node->subType() == Node::QDeclarativePropertyGroup) {
         node = node->parent();
     }
 #endif        
@@ -104,8 +104,8 @@ QString PageGenerator::fileBase(const Node *node) const
           we prepend "qml-" to the file name of QML element doc
           files.
          */
-        if ((p->subType() == Node::QmlClass) ||
-            (p->subType() == Node::QmlBasicType)) {
+        if ((p->subType() == Node::QDeclarativeClass) ||
+            (p->subType() == Node::QDeclarativeBasicType)) {
             base.prepend("qml-");
         }
 #endif        
@@ -207,7 +207,7 @@ void PageGenerator::generateInnerNode(const InnerNode *node,
         if (fakeNode->subType() == Node::ExternalPage)
             return;
 #ifdef QDOC_QML            
-        if (fakeNode->subType() == Node::QmlPropertyGroup)
+        if (fakeNode->subType() == Node::QDeclarativePropertyGroup)
             return;
 #endif            
         if (fakeNode->subType() == Node::Page) {
diff --git a/tools/qdoc3/tree.cpp b/tools/qdoc3/tree.cpp
index 6c2502d..96af8d6 100644
--- a/tools/qdoc3/tree.cpp
+++ b/tools/qdoc3/tree.cpp
@@ -1914,8 +1914,8 @@ QString Tree::fullDocumentLocation(const Node *node) const
     }
     else if (node->type() == Node::Fake) {
 #ifdef QDOC_QML
-        if ((node->subType() == Node::QmlClass) ||
-            (node->subType() == Node::QmlBasicType))
+        if ((node->subType() == Node::QDeclarativeClass) ||
+            (node->subType() == Node::QDeclarativeBasicType))
             return "qml-" + node->fileBase() + ".html";
         else
 #endif