/****************************************************************************

**

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

** All rights reserved.

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

**

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

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

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

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

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

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

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

** 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.1, included in the file LGPL_EXCEPTION.txt in this package.

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

/*

  webxmlgenerator.cpp

*/

#include <QtXml>

#include "codemarker.h"

#include "pagegenerator.h"

#include "webxmlgenerator.h"

#include "node.h"

#include "separator.h"

#include "tree.h"

QT_BEGIN_NAMESPACE

#define COMMAND_VERSION                 Doc::alias("version")

WebXMLGenerator::WebXMLGenerator()

    : PageGenerator()

{

}

WebXMLGenerator::~WebXMLGenerator()

{

}

void WebXMLGenerator::initializeGenerator(const Config &config)

{

    Generator::initializeGenerator(config);

    project = config.getString(CONFIG_PROJECT);

    projectDescription = config.getString(CONFIG_DESCRIPTION);

    if (projectDescription.isEmpty() && !project.isEmpty())

        projectDescription = project + " Reference Documentation";

    projectUrl = config.getString(CONFIG_URL);

    generateIndex = config.getBool(CONFIG_GENERATEINDEX);

}

void WebXMLGenerator::terminateGenerator()

{

    PageGenerator::terminateGenerator();

}

QString WebXMLGenerator::format()

{

    return "WebXML";

}

QString WebXMLGenerator::fileExtension(const Node * /* node */)

{

    return "xml";

}

void WebXMLGenerator::generateTree(const Tree *tree, CodeMarker *marker)

{

    tre = tree;

    moduleClassMap.clear();

    moduleNamespaceMap.clear();

    serviceClasses.clear();

    findAllClasses(tree->root());

    findAllNamespaces(tree->root());

    PageGenerator::generateTree(tree, marker);

    if (generateIndex)

        tre->generateIndex(outputDir() + "/" + project.toLower() + ".index",

                           projectUrl, projectDescription, false);

}

void WebXMLGenerator::startText(const Node *relative, CodeMarker *marker)

{

    inLink = false;

    inContents = false;

    inSectionHeading = false;

    numTableRows = 0;

    sectionNumber.clear();

    PageGenerator::startText(relative, marker);

}

int WebXMLGenerator::generateAtom(QXmlStreamWriter &writer, const Atom *atom,

                                  const Node *relative, CodeMarker *marker)

{

    Q_UNUSED(writer);

    int skipAhead = 0;

    switch (atom->type()) {

    default:

        PageGenerator::generateAtom(atom, relative, marker);

    }

    return skipAhead;

}

void WebXMLGenerator::generateClassLikeNode(const InnerNode *inner,

                                            CodeMarker *marker)

{

    QByteArray data;

    QXmlStreamWriter writer(&data);

    writer.setAutoFormatting(true);

    writer.writeStartDocument();

    writer.writeStartElement("WebXML");

    writer.writeStartElement("document");

    generateIndexSections(writer, inner, marker);

    writer.writeEndElement(); // document

    writer.writeEndElement(); // WebXML

    writer.writeEndDocument();

    out() << data;

    out().flush();

}

void WebXMLGenerator::generateFakeNode(const FakeNode *fake, CodeMarker *marker)

{

    QByteArray data;

    QXmlStreamWriter writer(&data);

    writer.setAutoFormatting(true);

    writer.writeStartDocument();

    writer.writeStartElement("WebXML");

    writer.writeStartElement("document");

    generateIndexSections(writer, fake, marker);

    writer.writeEndElement(); // document

    writer.writeEndElement(); // WebXML

    writer.writeEndDocument();

    out() << data;

    out().flush();

}

void WebXMLGenerator::generateIndexSections(QXmlStreamWriter &writer,

                                 const Node *node, CodeMarker *marker)

{

    if (tre->generateIndexSection(writer, node, true)) {

        // Add documentation to this node if it exists.

        writer.writeStartElement("description");

        writer.writeAttribute("path", node->doc().location().filePath());

        writer.writeAttribute("line", QString::number(node->doc().location().lineNo()));

        writer.writeAttribute("column", QString::number(node->doc().location().columnNo()));

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

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

            generateRelations(writer, node, marker);

            if (fake->subType() == Node::Module) {

                writer.writeStartElement("generatedlist");

                writer.writeAttribute("contents", "classesbymodule");

                if (moduleNamespaceMap.contains(fake->name())) {

                    writer.writeStartElement("section");

                    writer.writeStartElement("heading");

                    writer.writeAttribute("level", "1");

                    writer.writeCharacters("Namespaces");

                    writer.writeEndElement(); // heading

                    generateAnnotatedList(writer, fake, marker, moduleNamespaceMap[fake->name()]);

                    writer.writeEndElement(); // section

                }

                if (moduleClassMap.contains(fake->name())) {

                    writer.writeStartElement("section");

                    writer.writeStartElement("heading");

                    writer.writeAttribute("level", "1");

                    writer.writeCharacters("Classes");

                    writer.writeEndElement(); // heading

                    generateAnnotatedList(writer, fake, marker, moduleClassMap[fake->name()]);

                    writer.writeEndElement(); // section

                }

                writer.writeEndElement(); // generatedlist

            }

        }

        startText(node, marker);

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

        while (atom)

            atom = addAtomElements(writer, atom, node, marker);

        QList<Text> alsoList = node->doc().alsoList();

        supplementAlsoList(node, alsoList);

        if (!alsoList.isEmpty()) {

            writer.writeStartElement("see-also");

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

                const Atom *atom = alsoList.at(i).firstAtom();

                while (atom)

                    atom = addAtomElements(writer, atom, node, marker);

            }

            writer.writeEndElement(); // see-also

        }

        writer.writeEndElement(); // description

        if (node->isInnerNode()) {

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

            // Recurse to generate an element for this child node and all its children.

            foreach (const Node *child, inner->childNodes())

                generateIndexSections(writer, child, marker);

            writer.writeStartElement("related");

            if (inner->relatedNodes().size() > 0) {

                foreach (const Node *child, inner->relatedNodes())

                    generateIndexSections(writer, child, marker);

            }

            writer.writeEndElement(); // related

        }

        writer.writeEndElement();

    }

}

void WebXMLGenerator::generateInnerNode(const InnerNode *node, CodeMarker *marker)

{

    if (!node->url().isNull())

        return;

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

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

        if (fakeNode->subType() == Node::ExternalPage)

            return;

    }

    if ( node->parent() != 0 ) {

	beginSubPage( node->location(), fileName(node) );

	if ( node->type() == Node::Namespace || node->type() == Node::Class) {

	    generateClassLikeNode(node, marker);

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

	    generateFakeNode(static_cast<const FakeNode *>(node), marker);

	}

	endSubPage();

    }

    NodeList::ConstIterator c = node->childNodes().begin();

    while ( c != node->childNodes().end() ) {

	if ((*c)->isInnerNode() && (

            (*c)->access() != Node::Private || (*c)->status() == Node::Internal))

	    generateInnerNode( (const InnerNode *) *c, marker );

	++c;

    }

}

const Atom *WebXMLGenerator::addAtomElements(QXmlStreamWriter &writer,

     const Atom *atom, const Node *relative, CodeMarker *marker)

{

    switch (atom->type()) {

    case Atom::AbstractLeft:

    case Atom::AbstractRight:

        break;

    case Atom::AutoLink:

        if (!inLink && !inSectionHeading) {

            const Node *node = findNode(atom, relative, marker);

            if (node) {

                startLink(writer, atom, node, relative);

                if (inLink) {

                    writer.writeCharacters(atom->string());

                    writer.writeEndElement(); // link

                    inLink = false;

                }

            } else

                writer.writeCharacters(atom->string());

        } else

            writer.writeCharacters(atom->string());

        break;

    case Atom::BaseName:

        break;

    case Atom::BriefLeft:

        writer.writeStartElement("brief");

        switch (relative->type()) {

        case Node::Property:

            writer.writeCharacters("This property");

            break;

        case Node::Variable:

            writer.writeCharacters("This variable");

            break;

        default:

            break;

        }

        if (relative->type() == Node::Property || relative->type() == Node::Variable) {

            QString str;

            const Atom *a = atom->next();

            while (a != 0 && a->type() != Atom::BriefRight) {

                if (a->type() == Atom::String || a->type() == Atom::AutoLink)

                    str += a->string();

                a = a->next();

            }

            str[0] = str[0].toLower();

            if (str.right(1) == ".")

                str.chop(1);

            QStringList words = str.split(" ");

            if (!(words.first() == "contains" || words.first() == "specifies"

                || words.first() == "describes" || words.first() == "defines"

                || words.first() == "holds" || words.first() == "determines"))

                writer.writeCharacters(" holds ");

            else

                writer.writeCharacters(" ");

        }

        break;

    case Atom::BriefRight:

        if (relative->type() == Node::Property || relative->type() == Node::Variable)

            writer.writeCharacters(".");

        writer.writeEndElement(); // brief

        break;

    case Atom::C:

        writer.writeStartElement("teletype");

        if (inLink)

            writer.writeAttribute("type", "normal");

        else

            writer.writeAttribute("type", "highlighted");

        writer.writeCharacters(plainCode(atom->string()));

        writer.writeEndElement(); // teletype

        break;

    case Atom::Code:

        writer.writeTextElement("code", trimmedTrailing(plainCode(atom->string())));

        break;

#ifdef QDOC_QML        

    case Atom::Qml:

        writer.writeTextElement("qml", trimmedTrailing(plainCode(atom->string())));

#endif

    case Atom::CodeBad:

        writer.writeTextElement("badcode", trimmedTrailing(plainCode(atom->string())));

        break;

    case Atom::CodeNew:

        writer.writeTextElement("para", "you can rewrite it as");

        writer.writeTextElement("newcode", trimmedTrailing(plainCode(atom->string())));

        break;

    case Atom::CodeOld:

        writer.writeTextElement("para", "For example, if you have code like");

        writer.writeTextElement("oldcode", trimmedTrailing(plainCode(atom->string())));

        break;

    case Atom::CodeQuoteArgument:

        if (quoteCommand == "dots") {

            writer.writeAttribute("indent", atom->string());

            writer.writeCharacters("...");

        } else

            writer.writeCharacters(atom->string());

        writer.writeEndElement(); // code

        break;

    case Atom::CodeQuoteCommand:

        quoteCommand = atom->string();

        writer.writeStartElement(quoteCommand);

        break;

    case Atom::FootnoteLeft:

        writer.writeStartElement("footnote");

        break;

    case Atom::FootnoteRight:

        writer.writeEndElement(); // footnote

        break;

/*

    case Atom::FormatElse:

        writer.writeStartElement("else");

        writer.writeEndElement(); // else

        break;

*/

    case Atom::FormatEndif:

        writer.writeEndElement(); // raw

        break;

    case Atom::FormatIf:

        writer.writeStartElement("raw");

        writer.writeAttribute("format", atom->string());

        break;

    case Atom::FormattingLeft:

	{

            if (atom->string() == ATOM_FORMATTING_BOLD)

                writer.writeStartElement("bold");

	    else if (atom->string() == ATOM_FORMATTING_ITALIC)

                writer.writeStartElement("italic");

	    else if (atom->string() == ATOM_FORMATTING_UNDERLINE)

                writer.writeStartElement("underline");

	    else if (atom->string() == ATOM_FORMATTING_SUBSCRIPT)

                writer.writeStartElement("subscript");

	    else if (atom->string() == ATOM_FORMATTING_SUPERSCRIPT)

                writer.writeStartElement("superscript");

	    else if (atom->string() == ATOM_FORMATTING_TELETYPE)

                writer.writeStartElement("teletype");

	    else if (atom->string() == ATOM_FORMATTING_PARAMETER)

                writer.writeStartElement("argument");

	    else if (atom->string() == ATOM_FORMATTING_INDEX)

                writer.writeStartElement("index");

        }

        break;

/*        out() << formattingLeftMap()[atom->string()];

        if ( atom->string() == ATOM_FORMATTING_PARAMETER ) {

            if ( atom->next() != 0 && atom->next()->type() == Atom::String ) {

                QRegExp subscriptRegExp( "([a-z]+)_([0-9n])" );

                if ( subscriptRegExp.exactMatch(atom->next()->string()) ) {

                    out() << subscriptRegExp.cap( 1 ) << "<sub>"

                          << subscriptRegExp.cap( 2 ) << "</sub>";

                    skipAhead = 1;

                }

            }

        }*/

    case Atom::FormattingRight:

	{

            if (atom->string() == ATOM_FORMATTING_BOLD)

                writer.writeEndElement();

	    else if (atom->string() == ATOM_FORMATTING_ITALIC)

                writer.writeEndElement();

	    else if (atom->string() == ATOM_FORMATTING_UNDERLINE)

                writer.writeEndElement();

	    else if (atom->string() == ATOM_FORMATTING_SUBSCRIPT)

                writer.writeEndElement();

	    else if (atom->string() == ATOM_FORMATTING_SUPERSCRIPT)

                writer.writeEndElement();

	    else if (atom->string() == ATOM_FORMATTING_TELETYPE)

                writer.writeEndElement();

	    else if (atom->string() == ATOM_FORMATTING_PARAMETER)

                writer.writeEndElement();

	    else if (atom->string() == ATOM_FORMATTING_INDEX)

                writer.writeEndElement();

        }

        if (inLink) {

            writer.writeEndElement(); // link

            inLink = false;

        }

	break;

/*        if ( atom->string() == ATOM_FORMATTING_LINK ) {

            if (inLink) {

                if ( link.isEmpty() ) {

                    if (showBrokenLinks)

                        out() << "</i>";

                } else {

                    out() << "</a>";

                }

            }

            inLink = false;

        } else {

            out() << formattingRightMap()[atom->string()];

        }*/

    case Atom::GeneratedList:

        writer.writeStartElement("generatedlist");

        writer.writeAttribute("contents", atom->string());

        writer.writeEndElement(); // generatedlist

/*

        if (atom->string() == "annotatedclasses") {

            generateAnnotatedList(relative, marker, nonCompatClasses);

        } else if (atom->string() == "classes") {

            generateCompactList(relative, marker, nonCompatClasses);

        } else if (atom->string().contains("classesbymodule")) {

            QString arg = atom->string().trimmed();

            QString moduleName = atom->string().mid(atom->string().indexOf(

                "classesbymodule") + 15).trimmed();

            if (moduleClassMap.contains(moduleName))

                generateAnnotatedList(relative, marker, moduleClassMap[moduleName]);

        } else if (atom->string().contains("classesbyedition")) {

            QString arg = atom->string().trimmed();

            QString editionName = atom->string().mid(atom->string().indexOf(

                "classesbyedition") + 16).trimmed();

            if (editionModuleMap.contains(editionName)) {

                QMap<QString, const Node *> editionClasses;

                foreach (const QString &moduleName, editionModuleMap[editionName]) {

                    if (moduleClassMap.contains(moduleName))

                        editionClasses.unite(moduleClassMap[moduleName]);

                }

                generateAnnotatedList(relative, marker, editionClasses);

            }

        } else if (atom->string() == "classhierarchy") {

            generateClassHierarchy(relative, marker, nonCompatClasses);

        } else if (atom->string() == "compatclasses") {

            generateCompactList(relative, marker, compatClasses);

        } else if (atom->string() == "functionindex") {

            generateFunctionIndex(relative, marker);

        } else if (atom->string() == "legalese") {

            generateLegaleseList(relative, marker);

        } else if (atom->string() == "mainclasses") {

            generateCompactList(relative, marker, mainClasses);

        } else if (atom->string() == "services") {