Changeset 561 for trunk/tools/qdoc3/cppcodemarker.cpp

Timestamp:

Feb 11, 2010, 11:19:06 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• tools/qdoc3/cppcodemarker.cpp (modified) (15 diffs)

trunk/tools/qdoc3/cppcodemarker.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the tools applications of the Qt Toolkit.
@@ -21 +22 @@
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
+** 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.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -44 +44 @@
 */
 
+#include <qdebug.h>
 #include "atom.h"
 #include "cppcodemarker.h"
@@ -194 +195 @@
         break;
     case Node::Function:
+    case Node::QmlSignal:
+    case Node::QmlMethod:
         func = (const FunctionNode *) node;
         if (style != SeparateList && !func->returnType().isEmpty())
@@ -284 +287 @@
             else {
                 for (int i = 0; i < documentedItems.size(); ++i) {
-                    if (i < MaxEnumValues - 2 || i == documentedItems.size() - 1) {
+                    if (i < MaxEnumValues-2 || i == documentedItems.size()-1) {
                         if (i != 0)
                             synopsis += ", ";
@@ -345 +348 @@
 }
 
+#ifdef QDOC_QML
+/*!
+ */
+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);
+        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);
+        synopsis += " : " + typified(pn->dataType());
+    }
+
+    QString extra;
+    if (summary) {
+        if (node->status() == Node::Preliminary) {
+            extra += " (preliminary)";
+        }
+        else if (node->status() == Node::Deprecated) {
+            extra += " (deprecated)";
+        }
+        else if (node->status() == Node::Obsolete) {
+            extra += " (obsolete)";
+        }
+    }
+
+    if (!extra.isEmpty()) {
+        extra.prepend("<@extra>");
+        extra.append("</@extra>");
+    }
+    return synopsis + extra;
+}
+#endif
+
 QString CppCodeMarker::markedUpName(const Node *node)
 {
@@ -412 +456 @@
 }
 
+#if 0
+            FastSection privateReimpFuncs(classe,
+                                          "Private Reimplemented Functions",
+                                          "private reimplemented function",
+                                          "private reimplemented functions");
+            FastSection protectedReimpFuncs(classe,
+                                            "Protected Reimplemented Functions",
+                                            "protected reimplemented function",
+                                            "protected reimplemented functions");
+            FastSection publicReimpFuncs(classe,
+                                         "Public Reimplemented Functions",
+                                         "public reimplemented function",
+                                         "public reimplemented functions");
+#endif
+
 QList<Section> CppCodeMarker::sections(const InnerNode *inner,
                                        SynopsisStyle style,
@@ -422 +481 @@
 
         if (style == Summary) {
-            FastSection privateFunctions(classe, "Private Functions", "private function",
+            FastSection privateFunctions(classe,
+                                         "Private Functions",
+                                         "private function",
                                          "private functions");
             FastSection privateSlots(classe, "Private Slots", "private slot", "private slots");
             FastSection privateTypes(classe, "Private Types", "private type", "private types");
-            FastSection protectedFunctions(classe, "Protected Functions", "protected function",
+            FastSection protectedFunctions(classe,
+                                           "Protected Functions",
+                                           "protected function",
                                            "protected functions");
-            FastSection protectedSlots(classe, "Protected Slots", "protected slot", "protected slots");
-            FastSection protectedTypes(classe, "Protected Types", "protected type", "protected types");
-            FastSection protectedVariables(classe, "Protected Variables", "protected type", "protected variables");
-            FastSection publicFunctions(classe, "Public Functions", "public function",
-                                        "public functions");
+            FastSection protectedSlots(classe,
+                                       "Protected Slots",
+                                       "protected slot",
+                                       "protected slots");
+            FastSection protectedTypes(classe,
+                                       "Protected Types",
+                                       "protected type",
+                                       "protected types");
+            FastSection protectedVariables(classe,
+                                           "Protected Variables",
+                                           "protected type",
+                                           "protected variables");
+            FastSection publicFunctions(classe,
+                                        "Public Functions",
+                                        "public function",
+                                        "public functions");
             FastSection publicSignals(classe, "Signals", "signal", "signals");
             FastSection publicSlots(classe, "Public Slots", "public slot", "public slots");
             FastSection publicTypes(classe, "Public Types", "public type", "public types");
-            FastSection publicVariables(classe, "Public Variables", "public type", "public variables");
+            FastSection publicVariables(classe,
+                                        "Public Variables",
+                                        "public type",
+                                        "public variables");
             FastSection properties(classe, "Properties", "property", "properties");
-            FastSection relatedNonMembers(classe, "Related Non-Members", "related non-member",
+            FastSection relatedNonMembers(classe,
+                                          "Related Non-Members",
+                                          "related non-member",
                                           "related non-members");
-            FastSection staticPrivateMembers(classe, "Static Private Members", "static private member",
+            FastSection staticPrivateMembers(classe,
+                                             "Static Private Members",
+                                             "static private member",
                                              "static private members");
-            FastSection staticProtectedMembers(classe, "Static Protected Members",
-                                               "static protected member", "static protected members");
-            FastSection staticPublicMembers(classe, "Static Public Members", "static public member",
+            FastSection staticProtectedMembers(classe,
+                                               "Static Protected Members",
+                                               "static protected member",
+                                               "static protected members");
+            FastSection staticPublicMembers(classe,
+                                            "Static Public Members",
+                                            "static public member",
                                             "static public members");
             FastSection macros(inner, "Macros", "macro", "macros");
@@ -496 +581 @@
                             if ((*c)->type() != Node::Variable
                                     || !(*c)->doc().isEmpty())
-                                insert(staticPublicMembers, *c, style, status);
+                                insert(staticPublicMembers,*c,style,status);
                         }
                         else if ((*c)->type() == Node::Property) {
@@ -506 +591 @@
                         }
                         else if ((*c)->type() == Node::Function) {
-                            insert(publicFunctions, *c, style, status);
+                            if (!insertReimpFunc(publicFunctions,*c,status))
+                                insert(publicFunctions, *c, style, status);
                         }
                         else {
@@ -519 +605 @@
                             if ((*c)->type() != Node::Variable
                                     || !(*c)->doc().isEmpty())
-                                insert(staticProtectedMembers, *c, style, status);
+                                insert(staticProtectedMembers,*c,style,status);
                         }
                         else if ((*c)->type() == Node::Variable) {
                             if (!(*c)->doc().isEmpty())
-                                insert(protectedVariables, *c, style, status);
+                                insert(protectedVariables,*c,style,status);
                         }
                         else if ((*c)->type() == Node::Function) {
-                            insert(protectedFunctions, *c, style, status);
+                            if (!insertReimpFunc(protectedFunctions,*c,status))
+                                insert(protectedFunctions, *c, style, status);
                         }
                         else {
@@ -539 +626 @@
                             if ((*c)->type() != Node::Variable
                                     || !(*c)->doc().isEmpty())
-                                insert(staticPrivateMembers, *c, style, status);
+                                insert(staticPrivateMembers,*c,style,status);
                         }
                         else if ((*c)->type() == Node::Function) {
-                            insert(privateFunctions, *c, style, status);
+                            if (!insertReimpFunc(privateFunctions,*c,status))
+                                insert(privateFunctions, *c, style, status);
                         }
                         else {
-                            insert(privateTypes, *c, style, status);
+                            insert(privateTypes,*c,style,status);
                         }
                     }
@@ -662 +750 @@
                                    "namespace",
                                    "namespaces");
-            FastSection classes(inner, "Classes", "class", "classes");
+            FastSection classes(inner,
+                                "Classes",
+                                "class",
+                                "classes");
             FastSection types(inner,
-                              style == Summary ? "Types" : "Type Documentation",
+                              style == Summary ?
+                              "Types" : "Type Documentation",
                               "type",
                               "types");
             FastSection functions(inner,
-                                  style == Summary ? "Functions" : "Function Documentation",
+                                  style == Summary ?
+                                  "Functions" : "Function Documentation",
                                   "function",
                                   "functions");
             FastSection macros(inner,
-                               style == Summary ? "Macros" : "Macro Documentation",
+                               style == Summary ?
+                               "Macros" : "Macro Documentation",
                                "macro",
                                "macros");
@@ -1007 +1101 @@
 }
 
+#ifdef QDOC_QML
+/*!
+  This function is for documenting QML properties. It returns
+  the list of documentation sections for the children of the
+  \a qmlClassNode.
+
+  Currently, it only handles QML property groups.
+ */
+QList<Section> CppCodeMarker::qmlSections(const QmlClassNode* qmlClassNode,
+                                          SynopsisStyle style)
+{
+    QList<Section> sections;
+    if (qmlClassNode) {
+        if (style == Summary) {
+            FastSection qmlproperties(qmlClassNode,
+                                      "Properties",
+                                      "property",
+                                      "properties");
+            FastSection qmlattachedproperties(qmlClassNode,
+                                              "Attached Properties",
+                                              "property",
+                                              "properties");
+            FastSection qmlsignals(qmlClassNode,
+                                "Signals",
+                                "signal",
+                                "signals");
+            FastSection qmlattachedsignals(qmlClassNode,
+                                           "QML Attached Signals",
+                                           "signal",
+                                           "signals");
+            FastSection qmlmethods(qmlClassNode,
+                                   "Methods",
+                                   "method",
+                                   "methods");
+            FastSection qmlattachedmethods(qmlClassNode,
+                                           "QML Attached Methods",
+                                           "method",
+                                           "methods");
+
+            NodeList::ConstIterator c = qmlClassNode->childNodes().begin();
+            while (c != qmlClassNode->childNodes().end()) {
+                if ((*c)->subType() == Node::QmlPropertyGroup) {
+                    const QmlPropGroupNode* qpgn = static_cast<const QmlPropGroupNode*>(*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 (pn->isAttached())
+                                insert(qmlattachedproperties,*p,style,Okay);
+                            else
+                                insert(qmlproperties,*p,style,Okay);
+                        }
+                        ++p;
+                    }
+                }
+                else if ((*c)->type() == Node::QmlSignal) {
+                    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) {
+                    const FunctionNode* mn = static_cast<const FunctionNode*>(*c);
+                    if (mn->isAttached())
+                        insert(qmlattachedmethods,*c,style,Okay);
+                    else
+                        insert(qmlmethods,*c,style,Okay);
+                }
+                ++c;
+            }
+            append(sections,qmlproperties);
+            append(sections,qmlattachedproperties);
+            append(sections,qmlsignals);
+            append(sections,qmlattachedsignals);
+            append(sections,qmlmethods);
+            append(sections,qmlattachedmethods);
+        }
+        else if (style == Detailed) {
+            FastSection qmlproperties(qmlClassNode, "Property Documentation");
+            FastSection qmlattachedproperties(qmlClassNode,"Attached Property Documentation");
+            FastSection qmlsignals(qmlClassNode,"Signal Documentation");
+            FastSection qmlattachedsignals(qmlClassNode,"Attached Signal Documentation");
+            FastSection qmlmethods(qmlClassNode,"Method Documentation");
+            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 (pgn->isAttached())
+                        insert(qmlattachedproperties,*c,style,Okay);
+                    else
+                        insert(qmlproperties,*c,style,Okay);
+                }
+                else if ((*c)->type() == Node::QmlSignal) {
+                    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) {
+                    const FunctionNode* mn = static_cast<const FunctionNode*>(*c);
+                    if (mn->isAttached())
+                        insert(qmlattachedmethods,*c,style,Okay);
+                    else
+                        insert(qmlmethods,*c,style,Okay);
+                }
+                ++c;
+            }
+            append(sections,qmlproperties);
+            append(sections,qmlattachedproperties);
+            append(sections,qmlsignals);
+            append(sections,qmlattachedsignals);
+            append(sections,qmlmethods);
+            append(sections,qmlattachedmethods);
+        }
+    }
+
+    return sections;
+}
+#endif
+
 QT_END_NAMESPACE