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

     2 **

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

     4 ** All rights reserved.

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

     6 **

     7 ** This file is part of the tools applications of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

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

    41 

    42 #include <QtXml>

    43 #include <QHash>

    44 #include <QMap>

    45 

    46 #include "atom.h"

    47 #include "helpprojectwriter.h"

    48 #include "htmlgenerator.h"

    49 #include "config.h"

    50 #include "node.h"

    51 #include "tree.h"

    52 

    53 QT_BEGIN_NAMESPACE

    54 

    55 HelpProjectWriter::HelpProjectWriter(const Config &config, const QString &defaultFileName)

    56 {

    57     // The output directory should already have been checked by the calling

    58     // generator.

    59     outputDir = config.getString(CONFIG_OUTPUTDIR);

    60 

    61     QStringList names = config.getStringList(CONFIG_QHP + Config::dot + "projects");

    62 

    63     foreach (const QString &projectName, names) {

    64         HelpProject project;

    65         project.name = projectName;

    66 

    67         QString prefix = CONFIG_QHP + Config::dot + projectName + Config::dot;

    68         project.helpNamespace = config.getString(prefix + "namespace");

    69         project.virtualFolder = config.getString(prefix + "virtualFolder");

    70         project.fileName = config.getString(prefix + "file");

    71         if (project.fileName.isEmpty())

    72             project.fileName = defaultFileName;

    73         project.extraFiles = config.getStringSet(prefix + "extraFiles");

    74         project.indexTitle = config.getString(prefix + "indexTitle");

    75         project.indexRoot = config.getString(prefix + "indexRoot");

    76         project.filterAttributes = config.getStringList(prefix + "filterAttributes").toSet();

    77         QSet<QString> customFilterNames = config.subVars(prefix + "customFilters");

    78         foreach (const QString &filterName, customFilterNames) {

    79             QString name = config.getString(prefix + "customFilters" + Config::dot + filterName + Config::dot + "name");

    80             QSet<QString> filters = config.getStringList(prefix + "customFilters" + Config::dot + filterName + Config::dot + "filterAttributes").toSet();

    81             project.customFilters[name] = filters;

    82         }

    83         //customFilters = config.defs.

    84 

    85         foreach (QString name, config.getStringSet(prefix + "excluded"))

    86             project.excluded.insert(name.replace("\\", "/"));

    87 

    88         foreach (const QString &name, config.getStringList(prefix + "subprojects")) {

    89             SubProject subproject;

    90             QString subprefix = prefix + "subprojects" + Config::dot + name + Config::dot;

    91             subproject.title = config.getString(subprefix + "title");

    92             subproject.indexTitle = config.getString(subprefix + "indexTitle");

    93             subproject.sortPages = config.getBool(subprefix + "sortPages");

    94             readSelectors(subproject, config.getStringList(subprefix + "selectors"));

    95             project.subprojects[name] = subproject;

    96         }

    97 

    98         if (project.subprojects.isEmpty()) {

    99             SubProject subproject;

   100             readSelectors(subproject, config.getStringList(prefix + "selectors"));

   101             project.subprojects[""] = subproject;

   102         }

   103 

   104         projects.append(project);

   105     }

   106 }

   107 

   108 void HelpProjectWriter::readSelectors(SubProject &subproject, const QStringList &selectors)

   109 {

   110     QHash<QString, Node::Type> typeHash;

   111     typeHash["namespace"] = Node::Namespace;

   112     typeHash["class"] = Node::Class;

   113     typeHash["fake"] = Node::Fake;

   114     typeHash["enum"] = Node::Enum;

   115     typeHash["typedef"] = Node::Typedef;

   116     typeHash["function"] = Node::Function;

   117     typeHash["property"] = Node::Property;

   118     typeHash["variable"] = Node::Variable;

   119     typeHash["target"] = Node::Target;

   120 

   121     QHash<QString, Node::SubType> subTypeHash;

   122     subTypeHash["example"] = Node::Example;

   123     subTypeHash["headerfile"] = Node::HeaderFile;

   124     subTypeHash["file"] = Node::File;

   125     subTypeHash["group"] = Node::Group;

   126     subTypeHash["module"] = Node::Module;

   127     subTypeHash["page"] = Node::Page;

   128     subTypeHash["externalpage"] = Node::ExternalPage;

   129 #ifdef QDOC_QML

   130     subTypeHash["qmlclass"] = Node::QmlClass;

   131 #endif

   132 

   133     QSet<Node::SubType> allSubTypes = QSet<Node::SubType>::fromList(subTypeHash.values());

   134 

   135     foreach (const QString &selector, selectors) {

   136         QStringList pieces = selector.split(":");

   137         if (pieces.size() == 1) {

   138             QString lower = selector.toLower();

   139             if (typeHash.contains(lower))

   140                 subproject.selectors[typeHash[lower]] = allSubTypes;

   141         } else if (pieces.size() >= 2) {

   142             QString lower = pieces[0].toLower();

   143             pieces = pieces[1].split(",");

   144             if (typeHash.contains(lower)) {

   145                 QSet<Node::SubType> subTypes;

   146                 for (int i = 0; i < pieces.size(); ++i) {

   147                     QString lower = pieces[i].toLower();

   148                     if (subTypeHash.contains(lower))

   149                         subTypes.insert(subTypeHash[lower]);

   150                 }

   151                 subproject.selectors[typeHash[lower]] = subTypes;

   152             }

   153         }

   154     }

   155 }

   156 

   157 void HelpProjectWriter::addExtraFile(const QString &file)

   158 {

   159     for (int i = 0; i < projects.size(); ++i)

   160         projects[i].extraFiles.insert(file);

   161 }

   162 

   163 void HelpProjectWriter::addExtraFiles(const QSet<QString> &files)

   164 {

   165     for (int i = 0; i < projects.size(); ++i)

   166         projects[i].extraFiles.unite(files);

   167 }

   168 

   169 /*

   170     Returns a list of strings describing the keyword details for a given node.

   171 

   172     The first string is the human-readable name to be shown in Assistant.

   173     The second string is a unique identifier.

   174     The third string is the location of the documentation for the keyword.

   175 */

   176 QStringList HelpProjectWriter::keywordDetails(const Node *node) const

   177 {

   178     QStringList details;

   179 

   180     if (node->parent() && !node->parent()->name().isEmpty()) {

   181         // "name"

   182         if (node->type() == Node::Enum || node->type() == Node::Typedef)

   183             details << node->parent()->name()+"::"+node->name();

   184         else

   185             details << node->name();

   186         // "id"

   187         details << node->parent()->name()+"::"+node->name();

   188     } else if (node->type() == Node::Fake) {

   189         const FakeNode *fake = static_cast<const FakeNode *>(node);

   190 #ifdef QDOC_QML

   191         if (fake->subType() == Node::QmlClass) {

   192             details << (QmlClassNode::qmlOnly ? fake->name() : fake->fullTitle());

   193             details << "QML." + fake->name();

   194         } else

   195 #endif

   196         {

   197             details << fake->fullTitle();

   198             details << fake->fullTitle();

   199         }

   200     } else {

   201         details << node->name();

   202         details << node->name();

   203     }

   204     details << tree->fullDocumentLocation(node);

   205 

   206     return details;

   207 }

   208 

   209 bool HelpProjectWriter::generateSection(HelpProject &project,

   210                         QXmlStreamWriter & /* writer */, const Node *node)

   211 {

   212     if (!node->url().isEmpty())

   213         return false;

   214 

   215     if (node->access() == Node::Private || node->status() == Node::Internal)

   216         return false;

   217 

   218     if (node->name().isEmpty())

   219         return true;

   220 

   221     QString docPath = node->doc().location().filePath();

   222     if (!docPath.isEmpty() && project.excluded.contains(docPath))

   223         return false;

   224 

   225     QString objName;

   226     if (node->type() == Node::Fake) {

   227         const FakeNode *fake = static_cast<const FakeNode *>(node);

   228         objName = fake->fullTitle();

   229     } else

   230         objName = tree->fullDocumentName(node);

   231 

   232     // Only add nodes to the set for each subproject if they match a selector.

   233     // Those that match will be listed in the table of contents.

   234 

   235     foreach (const QString &name, project.subprojects.keys()) {

   236         SubProject subproject = project.subprojects[name];

   237         // No selectors: accept all nodes.

   238         if (subproject.selectors.isEmpty())

   239             project.subprojects[name].nodes[objName] = node;

   240         else if (subproject.selectors.contains(node->type())) {

   241             // Accept only the node types in the selectors hash.

   242             if (node->type() != Node::Fake)

   243                 project.subprojects[name].nodes[objName] = node;

   244             else {

   245                 // Accept only fake nodes with subtypes contained in the selector's

   246                 // mask.

   247                 const FakeNode *fakeNode = static_cast<const FakeNode *>(node);

   248                 if (subproject.selectors[node->type()].contains(fakeNode->subType()) &&

   249                     fakeNode->subType() != Node::ExternalPage &&

   250                     !fakeNode->fullTitle().isEmpty())

   251 

   252                     project.subprojects[name].nodes[objName] = node;

   253             }

   254         }

   255     }

   256 

   257     switch (node->type()) {

   258 

   259         case Node::Class:

   260             project.keywords.append(keywordDetails(node));

   261             project.files.insert(tree->fullDocumentLocation(node));

   262             break;

   263 

   264         case Node::Namespace:

   265             project.keywords.append(keywordDetails(node));

   266             project.files.insert(tree->fullDocumentLocation(node));

   267             break;

   268 

   269         case Node::Enum:

   270             project.keywords.append(keywordDetails(node));

   271             {

   272                 const EnumNode *enumNode = static_cast<const EnumNode*>(node);

   273                 foreach (const EnumItem &item, enumNode->items()) {

   274                     QStringList details;

   275                     

   276                     if (enumNode->itemAccess(item.name()) == Node::Private)

   277                         continue;

   278 

   279                     if (!node->parent()->name().isEmpty()) {

   280                         details << node->parent()->name()+"::"+item.name(); // "name"

   281                         details << node->parent()->name()+"::"+item.name(); // "id"

   282                     } else {

   283                         details << item.name(); // "name"

   284                         details << item.name(); // "id"

   285                     }

   286                     details << tree->fullDocumentLocation(node);

   287                     project.keywords.append(details);

   288                 }

   289             }

   290             break;

   291 

   292         case Node::Property:

   293             project.keywords.append(keywordDetails(node));

   294             break;

   295 

   296         case Node::Function:

   297             {

   298                 const FunctionNode *funcNode = static_cast<const FunctionNode *>(node);

   299 

   300                 // Only insert keywords for non-constructors. Constructors are covered

   301                 // by the classes themselves.

   302 

   303                 if (funcNode->metaness() != FunctionNode::Ctor)

   304                     project.keywords.append(keywordDetails(node));

   305 

   306                 // Insert member status flags into the entries for the parent

   307                 // node of the function, or the node it is related to.

   308                 // Since parent nodes should have already been inserted into

   309                 // the set of files, we only need to ensure that related nodes

   310                 // are inserted.

   311 

   312                 if (node->relates()) {

   313                     project.memberStatus[node->relates()].insert(node->status());

   314                     project.files.insert(tree->fullDocumentLocation(node->relates()));

   315                 } else if (node->parent())

   316                     project.memberStatus[node->parent()].insert(node->status());

   317             }

   318             break;

   319 

   320         case Node::Typedef:

   321             {

   322                 const TypedefNode *typedefNode = static_cast<const TypedefNode *>(node);

   323                 QStringList typedefDetails = keywordDetails(node);

   324                 const EnumNode *enumNode = typedefNode->associatedEnum();

   325                 // Use the location of any associated enum node in preference

   326                 // to that of the typedef.

   327                 if (enumNode)

   328                     typedefDetails[2] = tree->fullDocumentLocation(enumNode);

   329 

   330                 project.keywords.append(typedefDetails);

   331             }

   332             break;

   333 

   334         // Fake nodes (such as manual pages) contain subtypes, titles and other

   335         // attributes.

   336         case Node::Fake: {

   337             const FakeNode *fakeNode = static_cast<const FakeNode*>(node);

   338             if (fakeNode->subType() != Node::ExternalPage &&

   339                 !fakeNode->fullTitle().isEmpty()) {

   340 

   341                 if (fakeNode->subType() != Node::File) {

   342                     if (fakeNode->doc().hasKeywords()) {

   343                         foreach (const Atom *keyword, fakeNode->doc().keywords()) {

   344                             if (!keyword->string().isEmpty()) {

   345                                 QStringList details;

   346                                 details << keyword->string()

   347                                         << keyword->string()

   348                                         << tree->fullDocumentLocation(node) + "#" + Doc::canonicalTitle(keyword->string());

   349                                 project.keywords.append(details);

   350                             } else

   351                                 fakeNode->doc().location().warning(

   352                                     tr("Bad keyword in %1").arg(tree->fullDocumentLocation(node))

   353                                     );

   354                         }

   355                     }

   356                     project.keywords.append(keywordDetails(node));

   357                 }

   358 /*

   359                 if (fakeNode->doc().hasTableOfContents()) {

   360                     foreach (const Atom *item, fakeNode->doc().tableOfContents()) {

   361                         QString title = Text::sectionHeading(item).toString();

   362                         if (!title.isEmpty()) {

   363                             QStringList details;

   364                             details << title

   365                                     << title

   366                                     << tree->fullDocumentLocation(node) + "#" + Doc::canonicalTitle(title);

   367                             project.keywords.append(details);

   368                         } else

   369                             fakeNode->doc().location().warning(

   370                                 tr("Bad contents item in %1").arg(tree->fullDocumentLocation(node))

   371                                 );

   372                     }

   373                 }

   374 */

   375                 project.files.insert(tree->fullDocumentLocation(node));

   376             }

   377             break;

   378             }

   379         default:

   380             ;

   381     }

   382 

   383     // Add all images referenced in the page to the set of files to include.

   384     const Atom *atom = node->doc().body().firstAtom();

   385     while (atom) {

   386         if (atom->type() == Atom::Image || atom->type() == Atom::InlineImage) {

   387             // Images are all placed within a single directory regardless of

   388             // whether the source images are in a nested directory structure.

   389             QStringList pieces = atom->string().split("/");

   390             project.files.insert("images/" + pieces.last());

   391         }

   392         atom = atom->next();

   393     }

   394 

   395     return true;

   396 }

   397 

   398 void HelpProjectWriter::generateSections(HelpProject &project,

   399                         QXmlStreamWriter &writer, const Node *node)

   400 {

   401     if (!generateSection(project, writer, node))

   402         return;

   403 

   404     if (node->isInnerNode()) {

   405         const InnerNode *inner = static_cast<const InnerNode *>(node);

   406 

   407         // Ensure that we don't visit nodes more than once.

   408         QMap<QString, const Node*> childMap;

   409         foreach (const Node *node, inner->childNodes()) {

   410             if (node->access() == Node::Private)

   411                 continue;

   412             if (node->type() == Node::Fake)

   413                 childMap[static_cast<const FakeNode *>(node)->fullTitle()] = node;

   414             else {

   415                 if (node->type() == Node::Function) {

   416                     const FunctionNode *funcNode = static_cast<const FunctionNode *>(node);

   417                     if (funcNode->isOverload())

   418                         continue;

   419                 }

   420                 childMap[tree->fullDocumentName(node)] = node;

   421             }

   422         }

   423 

   424         foreach (const Node *child, childMap)

   425             generateSections(project, writer, child);

   426     }

   427 }

   428 

   429 void HelpProjectWriter::generate(const Tree *tre)

   430 {

   431     this->tree = tre;

   432     for (int i = 0; i < projects.size(); ++i)

   433         generateProject(projects[i]);

   434 }

   435 

   436 void HelpProjectWriter::writeNode(HelpProject &project, QXmlStreamWriter &writer,

   437                                   const Node *node)

   438 {

   439     QString href = tree->fullDocumentLocation(node);

   440     QString objName = node->name();

   441 

   442     switch (node->type()) {

   443 

   444         case Node::Class:

   445             writer.writeStartElement("section");

   446             writer.writeAttribute("ref", href);

   447             if (node->parent() && !node->parent()->name().isEmpty())

   448                 writer.writeAttribute("title", tr("%1::%2 Class Reference").arg(node->parent()->name()).arg(objName));

   449             else

   450                 writer.writeAttribute("title", tr("%1 Class Reference").arg(objName));

   451 

   452             // Write subsections for all members, obsolete members and Qt 3

   453             // members.

   454             if (!project.memberStatus[node].isEmpty()) {

   455                 QString membersPath = href.left(href.size()-5) + "-members.html";

   456                 writer.writeStartElement("section");

   457                 writer.writeAttribute("ref", membersPath);

   458                 writer.writeAttribute("title", tr("List of all members"));

   459                 writer.writeEndElement(); // section

   460                 project.files.insert(membersPath);

   461             }

   462             if (project.memberStatus[node].contains(Node::Compat)) {

   463                 QString compatPath = href.left(href.size()-5) + "-qt3.html";

   464                 writer.writeStartElement("section");

   465                 writer.writeAttribute("ref", compatPath);

   466                 writer.writeAttribute("title", tr("Qt 3 support members"));

   467                 writer.writeEndElement(); // section

   468                 project.files.insert(compatPath);

   469             }

   470             if (project.memberStatus[node].contains(Node::Obsolete)) {

   471                 QString obsoletePath = href.left(href.size()-5) + "-obsolete.html";

   472                 writer.writeStartElement("section");

   473                 writer.writeAttribute("ref", obsoletePath);

   474                 writer.writeAttribute("title", tr("Obsolete members"));

   475                 writer.writeEndElement(); // section

   476                 project.files.insert(obsoletePath);

   477             }

   478 

   479             writer.writeEndElement(); // section

   480             break;

   481 

   482         case Node::Namespace:

   483             writer.writeStartElement("section");

   484             writer.writeAttribute("ref", href);

   485             writer.writeAttribute("title", objName);

   486             writer.writeEndElement(); // section

   487             break;

   488 

   489         case Node::Fake: {

   490             // Fake nodes (such as manual pages) contain subtypes, titles and other

   491             // attributes.

   492             const FakeNode *fakeNode = static_cast<const FakeNode*>(node);

   493 

   494             writer.writeStartElement("section");

   495             writer.writeAttribute("ref", href);

   496             writer.writeAttribute("title", fakeNode->fullTitle());

   497             //            qDebug() << "Title:" << fakeNode->fullTitle();

   498             

   499             if (fakeNode->subType() == Node::HeaderFile) {

   500 

   501                 // Write subsections for all members, obsolete members and Qt 3

   502                 // members.

   503                 if (!project.memberStatus[node].isEmpty()) {

   504                     QString membersPath = href.left(href.size()-5) + "-members.html";

   505                     writer.writeStartElement("section");

   506                     writer.writeAttribute("ref", membersPath);

   507                     writer.writeAttribute("title", tr("List of all members"));

   508                     writer.writeEndElement(); // section

   509                     project.files.insert(membersPath);

   510                 }

   511                 if (project.memberStatus[node].contains(Node::Compat)) {

   512                     QString compatPath = href.left(href.size()-5) + "-qt3.html";

   513                     writer.writeStartElement("section");

   514                     writer.writeAttribute("ref", compatPath);

   515                     writer.writeAttribute("title", tr("Qt 3 support members"));

   516                     writer.writeEndElement(); // section

   517                     project.files.insert(compatPath);

   518                 }

   519                 if (project.memberStatus[node].contains(Node::Obsolete)) {

   520                     QString obsoletePath = href.left(href.size()-5) + "-obsolete.html";

   521                     writer.writeStartElement("section");

   522                     writer.writeAttribute("ref", obsoletePath);

   523                     writer.writeAttribute("title", tr("Obsolete members"));

   524                     writer.writeEndElement(); // section

   525                     project.files.insert(obsoletePath);

   526                 }

   527             }

   528 

   529             writer.writeEndElement(); // section

   530             }

   531             break;

   532         default:

   533             ;

   534     }

   535 }

   536 

   537 void HelpProjectWriter::generateProject(HelpProject &project)

   538 {

   539     const Node *rootNode;

   540     if (!project.indexRoot.isEmpty())

   541         rootNode = tree->findFakeNodeByTitle(project.indexRoot);

   542     else

   543         rootNode = tree->root();

   544 

   545     if (!rootNode)

   546         return;

   547 

   548     project.files.clear();

   549     project.keywords.clear();

   550 

   551     QFile file(outputDir + QDir::separator() + project.fileName);

   552     if (!file.open(QFile::WriteOnly | QFile::Text))

   553         return;

   554 

   555     QXmlStreamWriter writer(&file);

   556     writer.setAutoFormatting(true);

   557     writer.writeStartDocument();

   558     writer.writeStartElement("QtHelpProject");

   559     writer.writeAttribute("version", "1.0");

   560 

   561     // Write metaData, virtualFolder and namespace elements.

   562     writer.writeTextElement("namespace", project.helpNamespace);

   563     writer.writeTextElement("virtualFolder", project.virtualFolder);

   564 

   565     // Write customFilter elements.

   566     QHash<QString, QSet<QString> >::ConstIterator it;

   567     for (it = project.customFilters.begin(); it != project.customFilters.end(); ++it) {

   568         writer.writeStartElement("customFilter");

   569         writer.writeAttribute("name", it.key());

   570         foreach (const QString &filter, it.value())

   571             writer.writeTextElement("filterAttribute", filter);

   572         writer.writeEndElement(); // customFilter

   573     }

   574 

   575     // Start the filterSection.

   576     writer.writeStartElement("filterSection");

   577 

   578     // Write filterAttribute elements.

   579     foreach (const QString &filterName, project.filterAttributes)

   580         writer.writeTextElement("filterAttribute", filterName);

   581 

   582     writer.writeStartElement("toc");

   583     writer.writeStartElement("section");

   584     QString indexPath = tree->fullDocumentLocation(tree->findFakeNodeByTitle(project.indexTitle));

   585     if (indexPath.isEmpty())

   586         indexPath = "index.html";

   587     writer.writeAttribute("ref", HtmlGenerator::cleanRef(indexPath));

   588     writer.writeAttribute("title", project.indexTitle);

   589     project.files.insert(tree->fullDocumentLocation(rootNode));

   590 

   591     generateSections(project, writer, rootNode);

   592 

   593     foreach (const QString &name, project.subprojects.keys()) {

   594         SubProject subproject = project.subprojects[name];

   595 

   596         if (!name.isEmpty()) {

   597             writer.writeStartElement("section");

   598             QString indexPath = tree->fullDocumentLocation(tree->findFakeNodeByTitle(subproject.indexTitle));

   599             writer.writeAttribute("ref", HtmlGenerator::cleanRef(indexPath));

   600             writer.writeAttribute("title", subproject.title);

   601             project.files.insert(indexPath);

   602         }

   603         if (subproject.sortPages) {

   604             QStringList titles = subproject.nodes.keys();

   605             titles.sort();

   606             foreach (const QString &title, titles)

   607                 writeNode(project, writer, subproject.nodes[title]);

   608         } else {

   609             // Find a contents node and navigate from there, using the NextLink values.

   610             foreach (const Node *node, subproject.nodes) {

   611                 QString nextTitle = node->links().value(Node::NextLink).first;

   612                 if (!nextTitle.isEmpty() &&

   613                     node->links().value(Node::ContentsLink).first.isEmpty()) {

   614 

   615                     FakeNode *nextPage = const_cast<FakeNode *>(tree->findFakeNodeByTitle(nextTitle));

   616 

   617                     // Write the contents node.

   618                     writeNode(project, writer, node);

   619 

   620                     while (nextPage) {

   621                         writeNode(project, writer, nextPage);

   622                         nextTitle = nextPage->links().value(Node::NextLink).first;

   623                         if(nextTitle.isEmpty())

   624                             break;

   625                         nextPage = const_cast<FakeNode *>(tree->findFakeNodeByTitle(nextTitle));

   626                     }

   627                     break;

   628                 }

   629             }

   630         }

   631 

   632         if (!name.isEmpty())

   633             writer.writeEndElement(); // section

   634     }

   635 

   636     writer.writeEndElement(); // section

   637     writer.writeEndElement(); // toc

   638 

   639     writer.writeStartElement("keywords");

   640     foreach (const QStringList &details, project.keywords) {

   641         writer.writeStartElement("keyword");

   642         writer.writeAttribute("name", details[0]);

   643         writer.writeAttribute("id", details[1]);

   644         writer.writeAttribute("ref", HtmlGenerator::cleanRef(details[2]));

   645         writer.writeEndElement(); //keyword

   646     }

   647     writer.writeEndElement(); // keywords

   648 

   649     writer.writeStartElement("files");

   650     foreach (const QString &usedFile, project.files) {

   651         if (!usedFile.isEmpty())

   652             writer.writeTextElement("file", usedFile);

   653     }

   654     foreach (const QString &usedFile, project.extraFiles)

   655         writer.writeTextElement("file", usedFile);

   656     writer.writeEndElement(); // files

   657 

   658     writer.writeEndElement(); // filterSection

   659     writer.writeEndElement(); // QtHelpProject

   660     writer.writeEndDocument();

   661     file.close();

   662 }

   663 

   664 QT_END_NAMESPACE