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

**

** 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$

**

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

#include "ui3reader.h"

#include "parser.h"

#include "domtool.h"

#include "globaldefs.h"

// uic4

#include "uic.h"

#include "ui4.h"

#include "driver.h"

#include "option.h"

#include <QStringList>

#include <QFile>

#include <QFileInfo>

#include <QDir>

#include <QRegExp>

#include <QtDebug>

QT_BEGIN_NAMESPACE

QByteArray combinePath(const char *infile, const char *outfile)

{

    QFileInfo inFileInfo(QDir::current(), QFile::decodeName(infile));

    QFileInfo outFileInfo(QDir::current(), QFile::decodeName(outfile));

    int numCommonComponents = 0;

    QStringList inSplitted = inFileInfo.dir().canonicalPath().split(QLatin1Char('/'));

    QStringList outSplitted = outFileInfo.dir().canonicalPath().split(QLatin1Char('/'));

    while (!inSplitted.isEmpty() && !outSplitted.isEmpty() &&

            inSplitted.first() == outSplitted.first()) {

        inSplitted.erase(inSplitted.begin());

        outSplitted.erase(outSplitted.begin());

        numCommonComponents++;

    }

    if (numCommonComponents < 2) {

        /*

          The paths don't have the same drive, or they don't have the

          same root directory. Use an absolute path.

        */

        return QFile::encodeName(inFileInfo.absoluteFilePath());

    } else {

        /*

          The paths have something in common. Use a path relative to

          the output file.

        */

        while (!outSplitted.isEmpty()) {

            outSplitted.erase(outSplitted.begin());

            inSplitted.prepend(QLatin1String(".."));

        }

        inSplitted.append(inFileInfo.fileName());

        return QFile::encodeName(inSplitted.join(QLatin1String("/")));

    }

}

/*!

  Creates a declaration (header file) for the form given in \a e

  \sa createFormImpl()

*/

void Ui3Reader::createFormDecl(const QDomElement &e, bool implicitIncludes)

{

    QDomElement body = e;

    QDomElement n;

    QDomNodeList nl;

    int i;

    QString objClass = getClassName(e);

    if (objClass.isEmpty())

        return;

    QString objName = getObjectName(e);

    QStringList typeDefs;

    QMap<QString, CustomInclude> customWidgetIncludes;

    /*

      We are generating a few QImage members that are not strictly

      necessary in some cases. Ideally, we would use requiredImage,

      which is computed elsewhere, to keep the generated .h and .cpp

      files synchronized.

    */

    // at first the images

    QMap<QString, int> customWidgets;

    QStringList forwardDecl;

    QStringList forwardDecl2;

    for (n = e; !n.isNull(); n = n.nextSibling().toElement()) {

        if (n.tagName().toLower() == QLatin1String("customwidgets")) {

            QDomElement n2 = n.firstChild().toElement();

            while (!n2.isNull()) {

                if (n2.tagName().toLower() == QLatin1String("customwidget")) {

                    QDomElement n3 = n2.firstChild().toElement();

                    QString cl;

                    while (!n3.isNull()) {

                        QString tagName = n3.tagName().toLower();

                        if (tagName == QLatin1String("class")) {

                            cl = n3.firstChild().toText().data();

                            if (!nofwd)

                                forwardDecl << cl;

                            customWidgets.insert(cl, 0);

                        } else if (tagName == QLatin1String("header")) {

                            CustomInclude ci;

                            ci.header = n3.firstChild().toText().data();

                            ci.location = n3.attribute(QLatin1String("location"), QLatin1String("global"));

                            if (!ci.header.isEmpty())

                                forwardDecl.removeAll(cl);

                            customWidgetIncludes.insert(cl, ci);

                        }

                        n3 = n3.nextSibling().toElement();

                    }

                }

                n2 = n2.nextSibling().toElement();

            }

        }

    }

    // register the object and unify its name

    objName = registerObject(objName);

    QString protector = objName.toUpper() + QLatin1String("_H");

    protector.replace(QLatin1String("::"), QLatin1String("_"));

    out << "#ifndef " << protector << endl;

    out << "#define " << protector << endl;

    out << endl;

    out << "#include <qvariant.h>" << endl; // for broken HP-UX compilers

    QStringList globalIncludes, localIncludes;

    {

        QMap<QString, CustomInclude>::Iterator it = customWidgetIncludes.find(objClass);

        if (it != customWidgetIncludes.end()) {

            if ((*it).location == QLatin1String("global"))

                globalIncludes += (*it).header;

            else

                localIncludes += (*it).header;

        }

    }

    QStringList::ConstIterator it;

    globalIncludes = unique(globalIncludes);

    for (it = globalIncludes.constBegin(); it != globalIncludes.constEnd(); ++it) {

        if (!(*it).isEmpty()) {

            QString header = fixHeaderName(*it);

            out << "#include <" << header << '>' << endl;

        }

    }

    localIncludes = unique(localIncludes);

    for (it = localIncludes.constBegin(); it != localIncludes.constEnd(); ++it) {

        if (!(*it).isEmpty()) {

            QString header = fixHeaderName(*it);

            out << "#include \"" << header << '\"' << endl;

        }

    }

    out << endl;

    bool dbForm = false;

    registerDatabases(e);

    dbConnections = unique(dbConnections);

    if (dbForms[QLatin1String("(default)")].count())

        dbForm = true;

    bool subDbForms = false;

    for (it = dbConnections.constBegin(); it != dbConnections.constEnd(); ++it) {

        if (!(*it).isEmpty() && (*it) != QLatin1String("(default)")) {

            if (dbForms[(*it)].count()) {

                subDbForms = true;

                break;

            }

        }

    }

    // some typedefs, maybe

    typeDefs = unique(typeDefs);

    for (it = typeDefs.constBegin(); it != typeDefs.constEnd(); ++it) {

        if (!(*it).isEmpty())

            out << "typedef " << *it << ';' << endl;

    }

    nl = e.parentNode().toElement().elementsByTagName(QLatin1String("forward"));

    for (i = 0; i < (int) nl.length(); i++)

        forwardDecl2 << fixDeclaration(nl.item(i).toElement().firstChild().toText().data());

    forwardDecl = unique(forwardDecl);

    for (it = forwardDecl.constBegin(); it != forwardDecl.constEnd(); ++it) {

        if (!(*it).isEmpty() && (*it) != objClass) {

            QString forwardName = *it;

            QStringList forwardNamespaces = forwardName.split(QLatin1String("::"));

            forwardName = forwardNamespaces.last();

            forwardNamespaces.removeAt(forwardNamespaces.size()-1);

            QStringList::ConstIterator ns = forwardNamespaces.constBegin();

            while (ns != forwardNamespaces.constEnd()) {

                out << "namespace " << *ns << " {" << endl;

                ++ns;

            }

            out << "class " << forwardName << ';' << endl;

            for (int i = 0; i < (int) forwardNamespaces.count(); i++)

                out << '}' << endl;

        }

    }

    for (it = forwardDecl2.constBegin(); it != forwardDecl2.constEnd(); ++it) {

        QString fd = *it;

        fd = fd.trimmed();

        if (!fd.endsWith(QLatin1Char(';')))

            fd += QLatin1Char(';');

        out << fd << endl;

    }

    out << endl;

    Driver d;

    d.option().headerProtection = false;

    d.option().copyrightHeader = false;

    d.option().extractImages = m_extractImages;

    d.option().qrcOutputFile = m_qrcOutputFile;

    d.option().implicitIncludes = implicitIncludes;

    if (trmacro.size())

        d.option().translateFunction = trmacro;

    DomUI *ui = generateUi4(e, implicitIncludes);

    d.uic(fileName, ui, &out);

    delete ui;

    createWrapperDeclContents(e);

    out << "#endif // " << protector << endl;

}

void Ui3Reader::createWrapperDecl(const QDomElement &e, const QString &convertedUiFile)

{

    QString objName = getObjectName(e);

    objName = registerObject(objName);

    QString protector = objName.toUpper() + QLatin1String("_H");

    protector.replace(QLatin1String("::"), QLatin1String("_"));

    out << "#ifndef " << protector << endl;

    out << "#define " << protector << endl;

    out << endl;

    out << "#include \"" << convertedUiFile << '\"' << endl;

    createWrapperDeclContents(e);

    out << endl;

    out << "#endif // " << protector << endl;

}

void Ui3Reader::createWrapperDeclContents(const QDomElement &e)

{

    QString objClass = getClassName(e);

    if (objClass.isEmpty())

        return;

    QDomNodeList nl;

    QString exportMacro;

    int i;

    QDomElement n;

    QStringList::ConstIterator it;

    nl = e.parentNode().toElement().elementsByTagName(QLatin1String("exportmacro"));

    if (nl.length() == 1)

        exportMacro = nl.item(0).firstChild().toText().data();

    QStringList::ConstIterator ns = namespaces.constBegin();

    while (ns != namespaces.constEnd()) {

        out << "namespace " << *ns << " {" << endl;

        ++ns;

    }

    out << "class ";

    if (!exportMacro.isEmpty())

        out << exportMacro << ' ';

    out << bareNameOfClass << " : public " << objClass << ", public Ui::" << bareNameOfClass << endl << '{' << endl;

    /* qmake ignore Q_OBJECT */

    out << "    Q_OBJECT" << endl;

    out << endl;

    out << "public:" << endl;

    // constructor

    if (objClass == QLatin1String("QDialog") || objClass == QLatin1String("QWizard")) {

        out << "    " << bareNameOfClass << "(QWidget* parent = 0, const char* name = 0, bool modal = false, Qt::WindowFlags fl = 0);" << endl;

    } else if (objClass == QLatin1String("QWidget")) {

        out << "    " << bareNameOfClass << "(QWidget* parent = 0, const char* name = 0, Qt::WindowFlags fl = 0);" << endl;

    } else if (objClass == QLatin1String("QMainWindow") || objClass == QLatin1String("Q3MainWindow")) {

        out << "    " << bareNameOfClass << "(QWidget* parent = 0, const char* name = 0, Qt::WindowFlags fl = Qt::WType_TopLevel);" << endl;

        isMainWindow = true;

    } else {

        out << "    " << bareNameOfClass << "(QWidget* parent = 0, const char* name = 0);" << endl;

    }

    // destructor

    out << "    ~" << bareNameOfClass << "();" << endl;

    out << endl;

    // database connections

    dbConnections = unique(dbConnections);

    bool hadOutput = false;

    for (it = dbConnections.constBegin(); it != dbConnections.constEnd(); ++it) {

        if (!(*it).isEmpty()) {

            // only need pointers to non-default connections

            if ((*it) != QLatin1String("(default)") && !(*it).isEmpty()) {

                out << indent << "QSqlDatabase* " << *it << "Connection;" << endl;

                hadOutput = true;

            }

        }

    }

    if (hadOutput)

        out << endl;

    QStringList publicSlots, protectedSlots, privateSlots;

    QStringList publicSlotTypes, protectedSlotTypes, privateSlotTypes;

    QStringList publicSlotSpecifier, protectedSlotSpecifier, privateSlotSpecifier;

    nl = e.parentNode().toElement().elementsByTagName(QLatin1String("slot"));

    for (i = 0; i < (int) nl.length(); i++) {

        n = nl.item(i).toElement();

        if (n.parentNode().toElement().tagName() != QLatin1String("slots")

             && n.parentNode().toElement().tagName() != QLatin1String("connections"))

            continue;

        if (n.attribute(QLatin1String("language"), QLatin1String("C++")) != QLatin1String("C++"))

            continue;

        QString returnType = n.attribute(QLatin1String("returnType"), QLatin1String("void"));

        QString functionName = n.firstChild().toText().data().trimmed();

        if (functionName.endsWith(QLatin1Char(';')))

            functionName.chop(1);

        QString specifier = n.attribute(QLatin1String("specifier"));

        QString access = n.attribute(QLatin1String("access"));

        if (access == QLatin1String(QLatin1String("protected"))) {

            protectedSlots += functionName;

            protectedSlotTypes += returnType;

            protectedSlotSpecifier += specifier;

        } else if (access == QLatin1String("private")) {

            privateSlots += functionName;

            privateSlotTypes += returnType;

            privateSlotSpecifier += specifier;

        } else {

            publicSlots += functionName;

            publicSlotTypes += returnType;

            publicSlotSpecifier += specifier;

        }

    }

    QStringList publicFuncts, protectedFuncts, privateFuncts;

    QStringList publicFunctRetTyp, protectedFunctRetTyp, privateFunctRetTyp;

    QStringList publicFunctSpec, protectedFunctSpec, privateFunctSpec;

    nl = e.parentNode().toElement().elementsByTagName(QLatin1String("function"));

    for (i = 0; i < (int) nl.length(); i++) {

        n = nl.item(i).toElement();

        if (n.parentNode().toElement().tagName() != QLatin1String("functions"))

            continue;

        if (n.attribute(QLatin1String("language"), QLatin1String("C++")) != QLatin1String("C++"))

            continue;

        QString returnType = n.attribute(QLatin1String("returnType"), QLatin1String("void"));

        QString functionName = n.firstChild().toText().data().trimmed();

        if (functionName.endsWith(QLatin1Char(';')))

            functionName.chop(1);

        QString specifier = n.attribute(QLatin1String("specifier"));

        QString access = n.attribute(QLatin1String("access"));

        if (access == QLatin1String("protected")) {

            protectedFuncts += functionName;

            protectedFunctRetTyp += returnType;

            protectedFunctSpec += specifier;

        } else if (access == QLatin1String("private")) {

            privateFuncts += functionName;

            privateFunctRetTyp += returnType;

            privateFunctSpec += specifier;

        } else {

            publicFuncts += functionName;

            publicFunctRetTyp += returnType;

            publicFunctSpec += specifier;

        }

    }

    QStringList publicVars, protectedVars, privateVars;

    nl = e.parentNode().toElement().elementsByTagName(QLatin1String("variable"));

    for (i = 0; i < (int)nl.length(); i++) {

        n = nl.item(i).toElement();

        // Because of compatibility the next lines have to be commented out.

        // Someday it should be uncommented.

        //if (n.parentNode().toElement().tagName() != QLatin1String("variables"))

        //    continue;

        QString access = n.attribute(QLatin1String("access"), QLatin1String("protected"));

        QString var = fixDeclaration(n.firstChild().toText().data().trimmed());

        if (!var.endsWith(QLatin1Char(';')))

            var += QLatin1Char(';');

        if (access == QLatin1String("public"))

            publicVars += var;

        else if (access == QLatin1String("private"))

            privateVars += var;

        else

            protectedVars += var;

    }

    if (!publicVars.isEmpty()) {

        for (it = publicVars.constBegin(); it != publicVars.constEnd(); ++it)

            out << indent << *it << endl;

        out << endl;

    }

    if (!publicFuncts.isEmpty())

        writeFunctionsDecl(publicFuncts, publicFunctRetTyp, publicFunctSpec);

    if (!publicSlots.isEmpty()) {

        out << "public slots:" << endl;

        if (!publicSlots.isEmpty())

            writeFunctionsDecl(publicSlots, publicSlotTypes, publicSlotSpecifier);

    }

    // find signals

    QStringList extraSignals;

    nl = e.parentNode().toElement().elementsByTagName(QLatin1String("signal"));

    for (i = 0; i < (int) nl.length(); i++) {

        n = nl.item(i).toElement();

        if (n.parentNode().toElement().tagName() != QLatin1String("signals")

             && n.parentNode().toElement().tagName() != QLatin1String("connections"))

            continue;

        if (n.attribute(QLatin1String("language"), QLatin1String("C++")) != QLatin1String("C++"))

            continue;

        QString sigName = n.firstChild().toText().data().trimmed();

        if (sigName.endsWith(QLatin1Char(';')))

            sigName = sigName.left(sigName.length() - 1);

        extraSignals += fixDeclaration(sigName);

    }

    // create signals

    if (!extraSignals.isEmpty()) {

        out << "signals:" << endl;

        for (it = extraSignals.constBegin(); it != extraSignals.constEnd(); ++it)

            out << "    void " << (*it) << ';' << endl;

        out << endl;

    }

    if (!protectedVars.isEmpty()) {

        out << "protected:" << endl;

        for (it = protectedVars.constBegin(); it != protectedVars.constEnd(); ++it)

            out << indent << *it << endl;

        out << endl;

    }

    if (!protectedFuncts.isEmpty()) {

        if (protectedVars.isEmpty())

            out << "protected:" << endl;

        writeFunctionsDecl(protectedFuncts, protectedFunctRetTyp, protectedFunctSpec);

    }

    out << "protected slots:" << endl;

    out << "    virtual void languageChange();" << endl;

    if (!protectedSlots.isEmpty()) {

        out << endl;

        writeFunctionsDecl(protectedSlots, protectedSlotTypes, protectedSlotSpecifier);

    }

    out << endl;

    // create all private stuff

    if (!privateFuncts.isEmpty() || !privateVars.isEmpty()) {

        out << "private:" << endl;

        if (!privateVars.isEmpty()) {

            for (it = privateVars.constBegin(); it != privateVars.constEnd(); ++it)

                out << indent << *it << endl;

            out << endl;

        }

        if (!privateFuncts.isEmpty())

            writeFunctionsDecl(privateFuncts, privateFunctRetTyp, privateFunctSpec);

    }

    if (!privateSlots.isEmpty()) {

        out << "private slots:" << endl;

        writeFunctionsDecl(privateSlots, privateSlotTypes, privateSlotSpecifier);

    }

    out << "};" << endl;

    for (i = 0; i < (int) namespaces.count(); i++)

        out << '}' << endl;

    out << endl;

}

void Ui3Reader::writeFunctionsDecl(const QStringList &fuLst, const QStringList &typLst, const QStringList &specLst)

{

    QStringList::ConstIterator it, it2, it3;

    for (it = fuLst.begin(), it2 = typLst.begin(), it3 = specLst.begin();

          it != fuLst.end(); ++it, ++it2, ++it3) {

        QString signature = *it;

        QString specifier;

        QString pure;