src/tools/qdoc/node.h

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/
   5 **
   6 ** This file is part of the tools applications of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:LGPL$
   9 ** GNU Lesser General Public License Usage
  10 ** This file may be used under the terms of the GNU Lesser General Public
  11 ** License version 2.1 as published by the Free Software Foundation and
  12 ** appearing in the file LICENSE.LGPL included in the packaging of this
  13 ** file. Please review the following information to ensure the GNU Lesser
  14 ** General Public License version 2.1 requirements will be met:
  15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  16 **
  17 ** In addition, as a special exception, Nokia gives you certain additional
  18 ** rights. These rights are described in the Nokia Qt LGPL Exception
  19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  20 **
  21 ** GNU General Public License Usage
  22 ** Alternatively, this file may be used under the terms of the GNU General
  23 ** Public License version 3.0 as published by the Free Software Foundation
  24 ** and appearing in the file LICENSE.GPL included in the packaging of this
  25 ** file. Please review the following information to ensure the GNU General
  26 ** Public License version 3.0 requirements will be met:
  27 ** http://www.gnu.org/copyleft/gpl.html.
  28 **
  29 ** Other Usage
  30 ** Alternatively, this file may be used in accordance with the terms and
  31 ** conditions contained in a signed written agreement between you and Nokia.
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 /*
  43   node.h
  44 */
  45
  46 #ifndef NODE_H
  47 #define NODE_H
  48
  49 #include <qdir.h>
  50 #include <qmap.h>
  51 #include <qpair.h>
  52 #include <qstringlist.h>
  53
  54 #include "codechunk.h"
  55 #include "doc.h"
  56 #include "location.h"
  57 #include "text.h"
  58
  59 QT_BEGIN_NAMESPACE
  60
  61 class Node;
  62 class ClassNode;
  63 class InnerNode;
  64 class ClassNode;
  65 class ExampleNode;
  66 class QmlClassNode;
  67 class Tree;
  68
  69 typedef QMap<QString, const Node*> NodeMap;
  70 typedef QMultiMap<QString, Node*> NodeMultiMap;
  71 typedef QMultiMap<QString, const ExampleNode*> ExampleNodeMap;
  72 typedef QList<QPair<QString,QString> > ImportList;
  73
  74 class Node
  75 {
  76 public:
  77     enum Type {
  78         Namespace,
  79         Class,
  80         Fake,
  81         Enum,
  82         Typedef,
  83         Function,
  84         Property,
  85         Variable,
  86         QmlProperty,
  87         QmlSignal,
  88         QmlSignalHandler,
  89         QmlMethod,
  90         LastType
  91     };
  92
  93     enum SubType {
  94         NoSubType,
  95         Example,
  96         HeaderFile,
  97         File,
  98         Image,
  99         Group,
 100         Module,
 101         Page,
 102         ExternalPage,
 103         QmlClass,
 104         QmlPropertyGroup,
 105         QmlBasicType,
 106         QmlModule,
 107         DitaMap,
 108         Collision,
 109         LastSubtype
 110     };
 111
 112     enum Access { Public, Protected, Private };
 113
 114     enum Status {
 115         Compat,
 116         Obsolete,
 117         Deprecated,
 118         Preliminary,
 119         Commendable,
 120         Main,
 121         Internal
 122     }; // don't reorder this enum
 123
 124     enum ThreadSafeness {
 125         UnspecifiedSafeness,
 126         NonReentrant,
 127         Reentrant,
 128         ThreadSafe
 129     };
 130
 131     enum LinkType {
 132         StartLink,
 133         NextLink,
 134         PreviousLink,
 135         ContentsLink,
 136         IndexLink,
 137         InheritsLink /*,
 138         GlossaryLink,
 139         CopyrightLink,
 140         ChapterLink,
 141         SectionLink,
 142         SubsectionLink,
 143         AppendixLink */
 144     };
 145
 146     enum PageType {
 147         NoPageType,
 148         ApiPage,
 149         ArticlePage,
 150         ExamplePage,
 151         HowToPage,
 152         OverviewPage,
 153         TutorialPage,
 154         FAQPage,
 155         DitaMapPage,
 156         OnBeyondZebra
 157     };
 158
 159     enum FlagValue {
 160         FlagValueDefault = -1,
 161         FlagValueFalse = 0,
 162         FlagValueTrue = 1
 163     };
 164
 165     virtual ~Node();
 166
 167     void setAccess(Access access) { access_ = access; }
 168     void setLocation(const Location& location) { loc = location; }
 169     void setDoc(const Doc& doc, bool replace = false);
 170     void setStatus(Status status) { status_ = status; }
 171     void setThreadSafeness(ThreadSafeness safeness) { safeness_ = safeness; }
 172     void setSince(const QString &since);
 173     void setRelates(InnerNode* pseudoParent);
 174     void setModuleName(const QString &module) { mod = module; }
 175     void setLink(LinkType linkType, const QString &link, const QString &desc);
 176     void setUrl(const QString &url);
 177     void setTemplateStuff(const QString &templateStuff) { templateStuff_ = templateStuff; }
 178     void setPageType(PageType t) { pageType_ = t; }
 179     void setPageType(const QString& t);
 180     void setParent(InnerNode* n) { parent_ = n; }
 181     void setIndexNodeFlag() { indexNodeFlag_ = true; }
 182     virtual void setOutputFileName(const QString& ) { }
 183
 184     virtual bool isInnerNode() const = 0;
 185     virtual bool isLeaf() const { return false; }
 186     virtual bool isReimp() const { return false; }
 187     virtual bool isFunction() const { return false; }
 188     virtual bool isQmlNode() const { return false; }
 189     virtual bool isQtQuickNode() const { return false; }
 190     virtual bool isAbstract() const { return false; }
 191     virtual bool isQmlPropertyGroup() const { return false; }
 192     virtual bool isCollisionNode() const { return false; }
 193     virtual bool isAttached() const { return false; }
 194     virtual void setAbstract(bool ) { }
 195     virtual QString title() const { return QString(); }
 196     virtual bool hasProperty(const QString& ) const { return false; }
 197     bool isInternal() const;
 198     bool isIndexNode() const { return indexNodeFlag_; }
 199     Type type() const { return nodeType_; }
 200     virtual SubType subType() const { return NoSubType; }
 201     InnerNode* parent() const { return parent_; }
 202     InnerNode* relates() const { return relatesTo_; }
 203     const QString& name() const { return name_; }
 204     QMap<LinkType, QPair<QString,QString> > links() const { return linkMap; }
 205     QString moduleName() const;
 206     QString url() const;
 207     virtual QString nameForLists() const { return name_; }
 208     virtual QString outputFileName() const { return QString(); }
 209     virtual void addGroupMember(Node* ) { }
 210     virtual void addQmlModuleMember(Node* ) { }
 211
 212     Access access() const { return access_; }
 213     QString accessString() const;
 214     const Location& location() const { return loc; }
 215     const Doc& doc() const { return d; }
 216     Status status() const { return status_; }
 217     Status inheritedStatus() const;
 218     ThreadSafeness threadSafeness() const;
 219     ThreadSafeness inheritedThreadSafeness() const;
 220     QString since() const { return sinc; }
 221     QString templateStuff() const { return templateStuff_; }
 222     PageType pageType() const { return pageType_; }
 223     QString pageTypeString() const;
 224     QString nodeTypeString() const;
 225     QString nodeSubtypeString() const;
 226     virtual void addPageKeywords(const QString& ) { }
 227
 228     void clearRelated() { relatesTo_ = 0; }
 229
 230     virtual QString fileBase() const;
 231     QString guid() const;
 232     QString ditaXmlHref();
 233     QString extractClassName(const QString &string) const;
 234     virtual QString qmlTypeName() const { return name_; }
 235     virtual QString qmlModuleName() const { return qmlModuleName_; }
 236     virtual QString qmlModuleVersion() const { return qmlModuleVersionMajor_ + "." + qmlModuleVersionMinor_; }
 237     virtual QString qmlModuleIdentifier() const { return qmlModuleName_ + qmlModuleVersionMajor_; }
 238     virtual bool setQmlModule(const ArgLocPair& );
 239     virtual ClassNode* classNode() { return 0; }
 240     virtual void clearCurrentChild() { }
 241     virtual const ImportList* importList() const { return 0; }
 242     virtual void setImportList(const ImportList& ) { }
 243     virtual const Node* applyModuleIdentifier(const Node* ) const { return 0; }
 244     virtual QString idNumber() { return "0"; }
 245     QmlClassNode* qmlClassNode();
 246     ClassNode* declarativeCppNode();
 247     const QString& outputSubdirectory() const { return outSubDir_; }
 248     QString fullDocumentName() const;
 249     static QString cleanId(QString str);
 250     QString idForNode() const;
 251
 252     static FlagValue toFlagValue(bool b);
 253     static bool fromFlagValue(FlagValue fv, bool defaultValue);
 254
 255     static QString pageTypeString(unsigned t);
 256     static QString nodeTypeString(unsigned t);
 257     static QString nodeSubtypeString(unsigned t);
 258     static int incPropertyGroupCount();
 259     static void clearPropertyGroupCount();
 260
 261 protected:
 262     Node(Type type, InnerNode* parent, const QString& name);
 263
 264 private:
 265
 266     Type nodeType_;
 267     Access access_;
 268     ThreadSafeness safeness_;
 269     PageType pageType_;
 270     Status status_;
 271     bool indexNodeFlag_;
 272
 273     InnerNode* parent_;
 274     InnerNode* relatesTo_;
 275     QString name_;
 276     Location loc;
 277     Doc d;
 278     QMap<LinkType, QPair<QString, QString> > linkMap;
 279     QString mod;
 280     QString url_;
 281     QString sinc;
 282     QString templateStuff_;
 283     mutable QString uuid_;
 284     QString outSubDir_;
 285     QString qmlModuleName_;
 286     QString qmlModuleVersionMajor_;
 287     QString qmlModuleVersionMinor_;
 288     static QStringMap operators_;
 289     static int propertyGroupCount_;
 290 };
 291
 292 class FunctionNode;
 293 class EnumNode;
 294 class NameCollisionNode;
 295
 296 typedef QList<Node*> NodeList;
 297 typedef QMap<QString, const Node*> NodeMap;
 298 typedef QMultiMap<QString, Node*> NodeMultiMap;
 299
 300 class InnerNode : public Node
 301 {
 302 public:
 303     virtual ~InnerNode();
 304
 305     Node* findChildNodeByName(const QString& name);
 306     Node* findChildNodeByName(const QString& name, bool qml);
 307     Node* findChildNodeByNameAndType(const QString& name, Type type);
 308     void findNodes(const QString& name, QList<Node*>& n);
 309     FunctionNode* findFunctionNode(const QString& name);
 310     FunctionNode* findFunctionNode(const FunctionNode* clone);
 311     void addInclude(const QString &include);
 312     void setIncludes(const QStringList &includes);
 313     void setOverload(const FunctionNode* func, bool overlode);
 314     void normalizeOverloads();
 315     void makeUndocumentedChildrenInternal();
 316     void clearCurrentChildPointers();
 317     void deleteChildren();
 318     void removeFromRelated();
 319
 320     virtual bool isInnerNode() const { return true; }
 321     virtual bool isLeaf() const { return false; }
 322     const Node* findChildNodeByName(const QString& name) const;
 323     const Node* findChildNodeByName(const QString& name, bool qml) const;
 324     const Node* findChildNodeByNameAndType(const QString& name, Type type) const;
 325     const FunctionNode* findFunctionNode(const QString& name) const;
 326     const FunctionNode* findFunctionNode(const FunctionNode* clone) const;
 327     const EnumNode* findEnumNodeForValue(const QString &enumValue) const;
 328     const NodeList & childNodes() const { return children; }
 329     const NodeList & relatedNodes() const { return related_; }
 330     int count() const { return children.size(); }
 331     int overloadNumber(const FunctionNode* func) const;
 332     NodeList overloads(const QString &funcName) const;
 333     const QStringList& includes() const { return inc; }
 334
 335     QStringList primaryKeys();
 336     QStringList secondaryKeys();
 337     const QStringList& pageKeywords() const { return pageKeywds; }
 338     virtual void addPageKeywords(const QString& t) { pageKeywds << t; }
 339     virtual void setCurrentChild() { }
 340     virtual void setCurrentChild(InnerNode* ) { }
 341     virtual void setOutputFileName(const QString& f) { outputFileName_ = f; }
 342     virtual QString outputFileName() const { return outputFileName_; }
 343
 344 protected:
 345     InnerNode(Type type, InnerNode* parent, const QString& name);
 346
 347 private:
 348     friend class Node;
 349     friend class NameCollisionNode;
 350
 351     static bool isSameSignature(const FunctionNode* f1, const FunctionNode* f2);
 352     void addChild(Node* child);
 353     void removeRelated(Node* pseudoChild);
 354     void removeChild(Node* child);
 355
 356     QString outputFileName_;
 357     QStringList pageKeywds;
 358     QStringList inc;
 359     NodeList children;
 360     NodeList enumChildren;
 361     NodeList related_;
 362     QMap<QString, Node*> childMap;
 363     QMap<QString, Node*> primaryFunctionMap;
 364     QMap<QString, NodeList> secondaryFunctionMap;
 365 };
 366
 367 class LeafNode : public Node
 368 {
 369 public:
 370     LeafNode();
 371     virtual ~LeafNode() { }
 372
 373     virtual bool isInnerNode() const { return false; }
 374     virtual bool isLeaf() const { return true; }
 375
 376 protected:
 377     LeafNode(Type type, InnerNode* parent, const QString& name);
 378     LeafNode(InnerNode* parent, Type type, const QString& name);
 379 };
 380
 381 class NamespaceNode : public InnerNode
 382 {
 383 public:
 384     NamespaceNode(InnerNode* parent, const QString& name);
 385     virtual ~NamespaceNode() { }
 386 };
 387
 388 class ClassNode;
 389
 390 struct RelatedClass
 391 {
 392     RelatedClass() { }
 393     RelatedClass(Node::Access access0,
 394                  ClassNode* node0,
 395                  const QString& dataTypeWithTemplateArgs0 = "")
 396         : access(access0),
 397           node(node0),
 398           dataTypeWithTemplateArgs(dataTypeWithTemplateArgs0) { }
 399     QString accessString() const;
 400
 401     Node::Access        access;
 402     ClassNode*          node;
 403     QString             dataTypeWithTemplateArgs;
 404 };
 405
 406 class PropertyNode;
 407
 408 class ClassNode : public InnerNode
 409 {
 410 public:
 411     ClassNode(InnerNode* parent, const QString& name);
 412     virtual ~ClassNode() { }
 413
 414     void addBaseClass(Access access,
 415                       ClassNode* node,
 416                       const QString &dataTypeWithTemplateArgs = "");
 417     void fixBaseClasses();
 418
 419     const QList<RelatedClass> &baseClasses() const { return bases; }
 420     const QList<RelatedClass> &derivedClasses() const { return derived; }
 421     const QList<RelatedClass> &ignoredBaseClasses() const { return ignoredBases; }
 422
 423     bool hideFromMainList() const { return hidden; }
 424     void setHideFromMainList(bool value) { hidden = value; }
 425
 426     QString serviceName() const { return sname; }
 427     void setServiceName(const QString& value) { sname = value; }
 428     QmlClassNode* qmlElement() { return qmlelement; }
 429     void setQmlElement(QmlClassNode* qcn) { qmlelement = qcn; }
 430     virtual bool isAbstract() const { return abstract_; }
 431     virtual void setAbstract(bool b) { abstract_ = b; }
 432     PropertyNode* findPropertyNode(const QString& name);
 433     QmlClassNode* findQmlBaseNode();
 434
 435 private:
 436     QList<RelatedClass> bases;
 437     QList<RelatedClass> derived;
 438     QList<RelatedClass> ignoredBases;
 439     bool hidden;
 440     bool abstract_;
 441     QString sname;
 442     QmlClassNode* qmlelement;
 443 };
 444
 445 class FakeNode : public InnerNode
 446 {
 447 public:
 448
 449     FakeNode(InnerNode* parent,
 450              const QString& name,
 451              SubType subType,
 452              PageType ptype);
 453     virtual ~FakeNode() { }
 454
 455     void setTitle(const QString &title) { title_ = title; }
 456     void setSubTitle(const QString &subTitle) { subtitle_ = subTitle; }
 457     virtual void addGroupMember(Node* node) { nodeList.append(node); }
 458     virtual void addQmlModuleMember(Node* node) { nodeList.append(node); }
 459
 460     SubType subType() const { return nodeSubtype_; }
 461     virtual QString title() const;
 462     virtual QString fullTitle() const;
 463     virtual QString subTitle() const;
 464     virtual QString imageFileName() const { return QString(); }
 465     const NodeList& groupMembers() const { return nodeList; }
 466     const NodeList& qmlModuleMembers() const { return nodeList; }
 467     virtual QString nameForLists() const { return title(); }
 468     virtual void setImageFileName(const QString& ) { }
 469     virtual bool isQmlPropertyGroup() const { return (nodeSubtype_ == QmlPropertyGroup); }
 470     virtual bool hasProperty(const QString& ) const;
 471
 472     static void insertQmlModuleNode(const QString& qmid, FakeNode* fn);
 473     static FakeNode* lookupQmlModuleNode(Tree* tree, const ArgLocPair& arg);
 474
 475 protected:
 476     SubType nodeSubtype_;
 477     QString title_;
 478     QString subtitle_;
 479     NodeList nodeList; // used for groups and QML modules.
 480
 481     static QMap<QString, FakeNode*> qmlModuleMap_;
 482 };
 483
 484 class NameCollisionNode : public FakeNode
 485 {
 486 public:
 487     NameCollisionNode(InnerNode* child);
 488     ~NameCollisionNode();
 489     const InnerNode* currentChild() const { return current; }
 490     virtual void setCurrentChild(InnerNode* child) { current = child; }
 491     virtual void clearCurrentChild() { current = 0; }
 492     virtual bool isQmlNode() const;
 493     virtual bool isCollisionNode() const { return true; }
 494     virtual const Node* applyModuleIdentifier(const Node* origin) const;
 495     InnerNode* findAny(Node::Type t, Node::SubType st);
 496     void addCollision(InnerNode* child);
 497     const QMap<QString,QString>& linkTargets() const { return targets; }
 498     void addLinkTarget(const QString& t, const QString& v) { targets.insert(t,v); }
 499
 500 private:
 501     InnerNode* current;
 502     QMap<QString,QString> targets;
 503 };
 504
 505 class ExampleNode : public FakeNode
 506 {
 507 public:
 508     ExampleNode(InnerNode* parent, const QString& name);
 509     virtual ~ExampleNode() { }
 510     virtual QString imageFileName() const { return imageFileName_; }
 511     virtual void setImageFileName(const QString& ifn) { imageFileName_ = ifn; }
 512
 513     static void terminate() { exampleNodeMap.clear(); }
 514
 515 public:
 516     static ExampleNodeMap exampleNodeMap;
 517
 518 private:
 519     QString imageFileName_;
 520 };
 521
 522 class QmlClassNode : public FakeNode
 523 {
 524 public:
 525     QmlClassNode(InnerNode* parent,
 526                  const QString& name,
 527                  ClassNode* cn);
 528     virtual ~QmlClassNode();
 529     virtual bool isQmlNode() const { return true; }
 530     virtual bool isQtQuickNode() const { return (qmlModuleName() == QLatin1String("QtQuick")); }
 531     virtual ClassNode* classNode() { return cnode_; }
 532     virtual QString fileBase() const;
 533     virtual void setCurrentChild();
 534     virtual void clearCurrentChild();
 535     virtual const ImportList* importList() const { return &importList_; }
 536     virtual void setImportList(const ImportList& il) { importList_ = il; }
 537     virtual bool isAbstract() const { return abstract_; }
 538     virtual void setAbstract(bool b) { abstract_ = b; }
 539     const FakeNode* qmlBase() const { return base_; }
 540     void resolveInheritance(Tree* tree);
 541     void requireCppClass() { cnodeRequired_ = true; }
 542     bool cppClassRequired() const { return cnodeRequired_; }
 543     static void addInheritedBy(const QString& base, Node* sub);
 544     static void subclasses(const QString& base, NodeList& subs);
 545     static void terminate();
 546
 547     static void insertQmlModuleMember(const QString& qmid, QmlClassNode* qcn);
 548     static QmlClassNode* lookupQmlTypeNode(const QString& qmid, const QString& name);
 549
 550 public:
 551     static bool qmlOnly;
 552     static QMultiMap<QString,Node*> inheritedBy;
 553     static QMap<QString, QmlClassNode*> qmlModuleMemberMap_;
 554
 555 private:
 556     bool abstract_;
 557     bool cnodeRequired_;
 558     ClassNode*    cnode_;
 559     FakeNode*     base_;
 560     ImportList          importList_;
 561 };
 562
 563 class QmlBasicTypeNode : public FakeNode
 564 {
 565 public:
 566     QmlBasicTypeNode(InnerNode* parent,
 567                      const QString& name);
 568     virtual ~QmlBasicTypeNode() { }
 569     virtual bool isQmlNode() const { return true; }
 570 };
 571
 572 class QmlPropGroupNode : public FakeNode
 573 {
 574 public:
 575     QmlPropGroupNode(QmlClassNode* parent, const QString& name);
 576     virtual ~QmlPropGroupNode() { }
 577     virtual bool isQmlNode() const { return true; }
 578     virtual bool isQtQuickNode() const { return parent()->isQtQuickNode(); }
 579     virtual QString qmlTypeName() const { return parent()->qmlTypeName(); }
 580     virtual QString qmlModuleName() const { return parent()->qmlModuleName(); }
 581     virtual QString qmlModuleVersion() const { return parent()->qmlModuleVersion(); }
 582     virtual QString qmlModuleIdentifier() const { return parent()->qmlModuleIdentifier(); }
 583     virtual QString idNumber();
 584
 585     const QString& element() const { return parent()->name(); }
 586
 587  private:
 588     int     idNumber_;
 589 };
 590
 591 class QmlPropertyNode;
 592
 593 class QmlPropertyNode : public LeafNode
 594 {
 595 public:
 596     QmlPropertyNode(QmlClassNode *parent,
 597                     const QString& name,
 598                     const QString& type,
 599                     bool attached);
 600     QmlPropertyNode(QmlPropGroupNode* parent,
 601                     const QString& name,
 602                     const QString& type,
 603                     bool attached);
 604     QmlPropertyNode(QmlPropertyNode* parent,
 605                     const QString& name,
 606                     const QString& type,
 607                     bool attached);
 608     virtual ~QmlPropertyNode() { }
 609
 610     void setDataType(const QString& dataType) { type_ = dataType; }
 611     void setStored(bool stored) { stored_ = toFlagValue(stored); }
 612     void setDesignable(bool designable) { designable_ = toFlagValue(designable); }
 613     void setReadOnly(bool ro) { readOnly_ = toFlagValue(ro); }
 614     void setDefault() { isdefault_ = true; }
 615
 616     const QString &dataType() const { return type_; }
 617     QString qualifiedDataType() const { return type_; }
 618     bool isReadOnlySet() const { return (readOnly_ != FlagValueDefault); }
 619     bool isDefault() const { return isdefault_; }
 620     bool isStored() const { return fromFlagValue(stored_,true); }
 621     bool isDesignable() const { return fromFlagValue(designable_,false); }
 622     bool isWritable(Tree* tree);
 623     bool isReadOnly() const { return fromFlagValue(readOnly_,false); }
 624     virtual bool isAttached() const { return attached_; }
 625     virtual bool isQmlNode() const { return true; }
 626     virtual bool isQtQuickNode() const { return parent()->isQtQuickNode(); }
 627     virtual QString qmlTypeName() const { return parent()->qmlTypeName(); }
 628     virtual QString qmlModuleName() const { return parent()->qmlModuleName(); }
 629     virtual QString qmlModuleVersion() const { return parent()->qmlModuleVersion(); }
 630     virtual QString qmlModuleIdentifier() const { return parent()->qmlModuleIdentifier(); }
 631     virtual bool hasProperty(const QString& name) const;
 632
 633     PropertyNode* correspondingProperty(Tree* tree);
 634
 635     const QString& element() const { return static_cast<QmlPropGroupNode*>(parent())->element(); }
 636     void appendQmlPropNode(QmlPropertyNode* p) { qmlPropNodes_.append(p); }
 637     const NodeList& qmlPropNodes() const { return qmlPropNodes_; }
 638
 639 private:
 640     QString type_;
 641     FlagValue   stored_;
 642     FlagValue   designable_;
 643     bool    isdefault_;
 644     bool    attached_;
 645     FlagValue   readOnly_;
 646     NodeList qmlPropNodes_;
 647 };
 648
 649 class EnumItem
 650 {
 651 public:
 652     EnumItem() { }
 653     EnumItem(const QString& name, const QString& value)
 654         : nam(name), val(value) { }
 655     EnumItem(const QString& name, const QString& value, const Text &txt)
 656         : nam(name), val(value), txt(txt) { }
 657
 658     const QString& name() const { return nam; }
 659     const QString& value() const { return val; }
 660     const Text &text() const { return txt; }
 661
 662 private:
 663     QString nam;
 664     QString val;
 665     Text txt;
 666 };
 667
 668 class TypedefNode;
 669
 670 class EnumNode : public LeafNode
 671 {
 672 public:
 673     EnumNode(InnerNode* parent, const QString& name);
 674     virtual ~EnumNode() { }
 675
 676     void addItem(const EnumItem& item);
 677     void setFlagsType(TypedefNode* typedeff);
 678     bool hasItem(const QString &name) const { return names.contains(name); }
 679
 680     const QList<EnumItem>& items() const { return itms; }
 681     Access itemAccess(const QString& name) const;
 682     const TypedefNode* flagsType() const { return ft; }
 683     QString itemValue(const QString &name) const;
 684
 685 private:
 686     QList<EnumItem> itms;
 687     QSet<QString> names;
 688     const TypedefNode* ft;
 689 };
 690
 691 class TypedefNode : public LeafNode
 692 {
 693 public:
 694     TypedefNode(InnerNode* parent, const QString& name);
 695     virtual ~TypedefNode() { }
 696
 697     const EnumNode* associatedEnum() const { return ae; }
 698
 699 private:
 700     void setAssociatedEnum(const EnumNode* enume);
 701
 702     friend class EnumNode;
 703
 704     const EnumNode* ae;
 705 };
 706
 707 inline void EnumNode::setFlagsType(TypedefNode* typedeff)
 708 {
 709     ft = typedeff;
 710     typedeff->setAssociatedEnum(this);
 711 }
 712
 713
 714 class Parameter
 715 {
 716 public:
 717     Parameter() {}
 718     Parameter(const QString& leftType,
 719               const QString& rightType = "",
 720               const QString& name = "",
 721               const QString& defaultValue = "");
 722     Parameter(const Parameter& p);
 723
 724     Parameter& operator=(const Parameter& p);
 725
 726     void setName(const QString& name) { nam = name; }
 727
 728     bool hasType() const { return lef.length() + rig.length() > 0; }
 729     const QString& leftType() const { return lef; }
 730     const QString& rightType() const { return rig; }
 731     const QString& name() const { return nam; }
 732     const QString& defaultValue() const { return def; }
 733
 734     QString reconstruct(bool value = false) const;
 735
 736 private:
 737     QString lef;
 738     QString rig;
 739     QString nam;
 740     QString def;
 741 };
 742
 743 class PropertyNode;
 744
 745 class FunctionNode : public LeafNode
 746 {
 747 public:
 748     enum Metaness {
 749         Plain,
 750         Signal,
 751         Slot,
 752         Ctor,
 753         Dtor,
 754         MacroWithParams,
 755         MacroWithoutParams,
 756         Native };
 757     enum Virtualness { NonVirtual, ImpureVirtual, PureVirtual };
 758
 759     FunctionNode(InnerNode* parent, const QString &name);
 760     FunctionNode(Type type, InnerNode* parent, const QString &name, bool attached);
 761     virtual ~FunctionNode() { }
 762
 763     void setReturnType(const QString& returnType) { rt = returnType; }
 764     void setParentPath(const QStringList& parentPath) { pp = parentPath; }
 765     void setMetaness(Metaness metaness) { met = metaness; }
 766     void setVirtualness(Virtualness virtualness);
 767     void setConst(bool conste) { con = conste; }
 768     void setStatic(bool statique) { sta = statique; }
 769     void setOverload(bool overlode);
 770     void setReimp(bool r);
 771     void addParameter(const Parameter& parameter);
 772     inline void setParameters(const QList<Parameter>& parameters);
 773     void borrowParameterNames(const FunctionNode* source);
 774     void setReimplementedFrom(FunctionNode* from);
 775
 776     const QString& returnType() const { return rt; }
 777     Metaness metaness() const { return met; }
 778     bool isMacro() const {
 779         return met == MacroWithParams || met == MacroWithoutParams;
 780     }
 781     Virtualness virtualness() const { return vir; }
 782     bool isConst() const { return con; }
 783     bool isStatic() const { return sta; }
 784     bool isOverload() const { return ove; }
 785     bool isReimp() const { return reimp; }
 786     bool isFunction() const { return true; }
 787     int overloadNumber() const;
 788     const QList<Parameter>& parameters() const { return params; }
 789     QStringList parameterNames() const;
 790     QString rawParameters(bool names = false, bool values = false) const;
 791     const FunctionNode* reimplementedFrom() const { return rf; }
 792     const QList<FunctionNode*> &reimplementedBy() const { return rb; }
 793     const PropertyNode* associatedProperty() const { return ap; }
 794     const QStringList& parentPath() const { return pp; }
 795
 796     QStringList reconstructParams(bool values = false) const;
 797     QString signature(bool values = false) const;
 798     const QString& element() const { return parent()->name(); }
 799     virtual bool isAttached() const { return attached_; }
 800     virtual bool isQmlNode() const {
 801         return ((type() == QmlSignal) ||
 802                 (type() == QmlMethod) ||
 803                 (type() == QmlSignalHandler));
 804     }
 805     virtual bool isQtQuickNode() const { return parent()->isQtQuickNode(); }
 806     virtual QString qmlTypeName() const { return parent()->qmlTypeName(); }
 807     virtual QString qmlModuleName() const { return parent()->qmlModuleName(); }
 808     virtual QString qmlModuleVersion() const { return parent()->qmlModuleVersion(); }
 809     virtual QString qmlModuleIdentifier() const { return parent()->qmlModuleIdentifier(); }
 810
 811     void debug() const;
 812
 813 private:
 814     void setAssociatedProperty(PropertyNode* property);
 815
 816     friend class InnerNode;
 817     friend class PropertyNode;
 818
 819     QString     rt;
 820     QStringList pp;
 821 #ifdef Q_WS_WIN
 822     Metaness    met;
 823     Virtualness vir;
 824 #else
 825     Metaness met : 4;
 826     Virtualness vir : 2;
 827 #endif
 828     bool con : 1;
 829     bool sta : 1;
 830     bool ove : 1;
 831     bool reimp: 1;
 832     bool attached_: 1;
 833     QList<Parameter> params;
 834     const FunctionNode* rf;
 835     const PropertyNode* ap;
 836     QList<FunctionNode*> rb;
 837 };
 838
 839 class PropertyNode : public LeafNode
 840 {
 841 public:
 842     enum FunctionRole { Getter, Setter, Resetter, Notifier };
 843     enum { NumFunctionRoles = Notifier + 1 };
 844
 845     PropertyNode(InnerNode* parent, const QString& name);
 846     virtual ~PropertyNode() { }
 847
 848     void setDataType(const QString& dataType) { type_ = dataType; }
 849     void addFunction(FunctionNode* function, FunctionRole role);
 850     void addSignal(FunctionNode* function, FunctionRole role);
 851     void setStored(bool stored) { stored_ = toFlagValue(stored); }
 852     void setDesignable(bool designable) { designable_ = toFlagValue(designable); }
 853     void setScriptable(bool scriptable) { scriptable_ = toFlagValue(scriptable); }
 854     void setWritable(bool writable) { writable_ = toFlagValue(writable); }
 855     void setUser(bool user) { user_ = toFlagValue(user); }
 856     void setOverriddenFrom(const PropertyNode* baseProperty);
 857     void setRuntimeDesFunc(const QString& rdf) { runtimeDesFunc = rdf; }
 858     void setRuntimeScrFunc(const QString& scrf) { runtimeScrFunc = scrf; }
 859     void setConstant() { cst = true; }
 860     void setFinal() { fnl = true; }
 861     void setRevision(int revision) { rev = revision; }
 862
 863     const QString &dataType() const { return type_; }
 864     QString qualifiedDataType() const;
 865     NodeList functions() const;
 866     NodeList functions(FunctionRole role) const { return funcs[(int)role]; }
 867     NodeList getters() const { return functions(Getter); }
 868     NodeList setters() const { return functions(Setter); }
 869     NodeList resetters() const { return functions(Resetter); }
 870     NodeList notifiers() const { return functions(Notifier); }
 871     bool isStored() const { return fromFlagValue(stored_, storedDefault()); }
 872     bool isDesignable() const { return fromFlagValue(designable_, designableDefault()); }
 873     bool isScriptable() const { return fromFlagValue(scriptable_, scriptableDefault()); }
 874     const QString& runtimeDesignabilityFunction() const { return runtimeDesFunc; }
 875     const QString& runtimeScriptabilityFunction() const { return runtimeScrFunc; }
 876     bool isWritable() const { return fromFlagValue(writable_, writableDefault()); }
 877     bool isUser() const { return fromFlagValue(user_, userDefault()); }
 878     bool isConstant() const { return cst; }
 879     bool isFinal() const { return fnl; }
 880     const PropertyNode* overriddenFrom() const { return overrides; }
 881
 882     bool storedDefault() const { return true; }
 883     bool userDefault() const { return false; }
 884     bool designableDefault() const { return !setters().isEmpty(); }
 885     bool scriptableDefault() const { return true; }
 886     bool writableDefault() const { return !setters().isEmpty(); }
 887
 888 private:
 889     QString type_;
 890     QString runtimeDesFunc;
 891     QString runtimeScrFunc;
 892     NodeList funcs[NumFunctionRoles];
 893     FlagValue stored_;
 894     FlagValue designable_;
 895     FlagValue scriptable_;
 896     FlagValue writable_;
 897     FlagValue user_;
 898     bool cst;
 899     bool fnl;
 900     int rev;
 901     const PropertyNode* overrides;
 902 };
 903
 904 inline void FunctionNode::setParameters(const QList<Parameter> &parameters)
 905 {
 906     params = parameters;
 907 }
 908
 909 inline void PropertyNode::addFunction(FunctionNode* function, FunctionRole role)
 910 {
 911     funcs[(int)role].append(function);
 912     function->setAssociatedProperty(this);
 913 }
 914
 915 inline void PropertyNode::addSignal(FunctionNode* function, FunctionRole role)
 916 {
 917     funcs[(int)role].append(function);
 918     function->setAssociatedProperty(this);
 919 }
 920
 921 inline NodeList PropertyNode::functions() const
 922 {
 923     NodeList list;
 924     for (int i = 0; i < NumFunctionRoles; ++i)
 925         list += funcs[i];
 926     return list;
 927 }
 928
 929 class VariableNode : public LeafNode
 930 {
 931 public:
 932     VariableNode(InnerNode* parent, const QString &name);
 933     virtual ~VariableNode() { }
 934
 935     void setLeftType(const QString &leftType) { lt = leftType; }
 936     void setRightType(const QString &rightType) { rt = rightType; }
 937     void setStatic(bool statique) { sta = statique; }
 938
 939     const QString &leftType() const { return lt; }
 940     const QString &rightType() const { return rt; }
 941     QString dataType() const { return lt + rt; }
 942     bool isStatic() const { return sta; }
 943
 944 private:
 945     QString lt;
 946     QString rt;
 947     bool sta;
 948 };
 949
 950 inline VariableNode::VariableNode(InnerNode* parent, const QString &name)
 951     : LeafNode(Variable, parent, name), sta(false)
 952 {
 953     // nothing.
 954 }
 955
 956 class DitaMapNode : public FakeNode
 957 {
 958 public:
 959     DitaMapNode(InnerNode* parent, const QString& name)
 960         : FakeNode(parent, name, Node::Page, Node::DitaMapPage) { }
 961     virtual ~DitaMapNode() { }
 962
 963     const DitaRefList& map() const { return doc().ditamap(); }
 964 };
 965
 966 QT_END_NAMESPACE
 967
 968 #endif