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

**

** Copyright (C) 2009 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$

**

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

#include "cppwriteinitialization.h"

#include "cppwriteiconinitialization.h"

#include "driver.h"

#include "ui4.h"

#include "utils.h"

#include "uic.h"

#include "databaseinfo.h"

#include "globaldefs.h"

#include <QtCore/QTextStream>

#include <QtCore/QDebug>

#include <ctype.h>

QT_BEGIN_NAMESPACE

namespace {

    // Fixup an enumeration name from class Qt.

    // They are currently stored as "BottomToolBarArea" instead of "Qt::BottomToolBarArea".

    // due to MO issues. This might be fixed in the future.

    void fixQtEnumerationName(QString& name) {

        static const QLatin1String prefix("Qt::");

        if (name.indexOf(prefix) != 0)

            name.prepend(prefix);

    }

    // figure out the toolbar area of a DOM attrib list.

    // By legacy, it is stored as an integer. As of 4.3.0, it is the enumeration value.

    QString toolBarAreaStringFromDOMAttributes(const CPP::WriteInitialization::DomPropertyMap &attributes) {

        const DomProperty *pstyle = attributes.value(QLatin1String("toolBarArea"));

        if (!pstyle)

            return QString();

        switch (pstyle->kind()) {

        case DomProperty::Number: {

            QString area = QLatin1String("static_cast<Qt::ToolBarArea>(");

            area += QString::number(pstyle->elementNumber());

            area += QLatin1String("), ");

            return area;

        }

        case DomProperty::Enum: {

            QString area = pstyle->elementEnum();

            fixQtEnumerationName(area);

            area += QLatin1String(", ");

            return area;

        }

        default:

            break;

        }

        return QString();

    }

    // Write a statement to create a spacer item.

    void writeSpacerItem(const DomSpacer *node, QTextStream &output) {

        const QHash<QString, DomProperty *> properties = propertyMap(node->elementProperty());

                output << "new QSpacerItem(";

        if (properties.contains(QLatin1String("sizeHint"))) {

            const DomSize *sizeHint = properties.value(QLatin1String("sizeHint"))->elementSize();

            output << sizeHint->elementWidth() << ", " << sizeHint->elementHeight() << ", ";

        }

        // size type

        QString sizeType = properties.contains(QLatin1String("sizeType"))  ?

                           properties.value(QLatin1String("sizeType"))->elementEnum() :

                           QString::fromLatin1("Expanding");

        if (!sizeType.startsWith(QLatin1String("QSizePolicy::")))

            sizeType.prepend(QLatin1String("QSizePolicy::"));

        // orientation

        bool isVspacer = false;

        if (properties.contains(QLatin1String("orientation"))) {

            const QString orientation = properties.value(QLatin1String("orientation"))->elementEnum();

            if (orientation == QLatin1String("Qt::Vertical") || orientation == QLatin1String("Vertical"))  isVspacer = true;

        }

        if (isVspacer)

            output << "QSizePolicy::Minimum, " << sizeType << ')';

        else

            output << sizeType << ", QSizePolicy::Minimum)";

    }

    // Helper for implementing comparison functions for integers.

    int compareInt(int i1, int i2) {

        if (i1 < i2) return -1;

        if (i1 > i2) return  1;

        return  0;

    }

    // Write object->setFoo(x);

    template <class Value>

        void writeSetter(const QString &indent, const QString &varName,const QString &setter, Value v, QTextStream &str) {

            str << indent << varName << "->" << setter << '(' << v << ");\n";

        }

    void writeSetupUIScriptVariableDeclarations(const QString &indent, QTextStream &str)  {

        str << indent << "ScriptContext scriptContext;\n"

            << indent << "QWidgetList childWidgets;\n";

    }

    static inline bool isIconFormat44(const DomResourceIcon *i) {

        return i->hasElementNormalOff()   || i->hasElementNormalOn() ||

               i->hasElementDisabledOff() || i->hasElementDisabledOn() ||

               i->hasElementActiveOff()   || i->hasElementActiveOn() ||

               i->hasElementSelectedOff() || i->hasElementSelectedOn();

    }

    // Check on properties. Filter out empty legacy pixmap/icon properties

    // as Designer pre 4.4 used to remove missing resource references.

    // This can no longer be handled by the code as we have 'setIcon(QIcon())' as well as 'QIcon icon'

    static bool checkProperty(const QString &fileName, const DomProperty *p) {

        switch (p->kind()) {

        case DomProperty::IconSet:

            if (const DomResourceIcon *dri = p->elementIconSet()) {

                if (!isIconFormat44(dri)) {

                    if (dri->text().isEmpty())  {

                        const QString msg = QString::fromUtf8("%1: An invalid icon property '%2' was encountered.").arg(fileName).arg(p->attributeName());

                        qWarning("%s", qPrintable(msg));

                        return false;

                    }

                }

            }

            break;

        case DomProperty::Pixmap:

            if (const DomResourcePixmap *drp = p->elementPixmap())

                if (drp->text().isEmpty()) {

                    const QString msg = QString::fromUtf8("%1: An invalid pixmap property '%2' was encountered.").arg(fileName).arg(p->attributeName());

                    qWarning("%s", qPrintable(msg));

                    return false;

                }

            break;

        default:

            break;

        }

        return  true;

    }

    inline void openIfndef(QTextStream &str, const QString &symbol) { if (!symbol.isEmpty()) str << QLatin1String("#ifndef ") << symbol << endl;  }

    inline void closeIfndef(QTextStream &str, const QString &symbol) { if (!symbol.isEmpty()) str << QLatin1String("#endif // ") << symbol << endl; }

    const char *accessibilityDefineC = "QT_NO_ACCESSIBILITY";

    const char *toolTipDefineC = "QT_NO_TOOLTIP";

    const char *whatsThisDefineC = "QT_NO_WHATSTHIS";

    const char *statusTipDefineC = "QT_NO_STATUSTIP";

    const char *shortcutDefineC = "QT_NO_SHORTCUT";

}

namespace CPP {

FontHandle::FontHandle(const DomFont *domFont) :

      m_domFont(domFont)

{

}

int FontHandle::compare(const FontHandle &rhs) const

{

    const QString family    = m_domFont->hasElementFamily()     ?     m_domFont->elementFamily() : QString();

    const QString rhsFamily = rhs.m_domFont->hasElementFamily() ? rhs.m_domFont->elementFamily() : QString();

    if (const int frc = family.compare(rhsFamily))

        return frc;

    const int pointSize    = m_domFont->hasElementPointSize()     ?     m_domFont->elementPointSize() : -1;

    const int rhsPointSize = rhs.m_domFont->hasElementPointSize() ? rhs.m_domFont->elementPointSize() : -1;

    if (const int crc = compareInt(pointSize, rhsPointSize))

        return crc;

    const int bold    = m_domFont->hasElementBold()     ? (m_domFont->elementBold()     ? 1 : 0) : -1;

    const int rhsBold = rhs.m_domFont->hasElementBold() ? (rhs.m_domFont->elementBold() ? 1 : 0) : -1;

    if (const int crc = compareInt(bold, rhsBold))

        return crc;

    const int italic    = m_domFont->hasElementItalic()     ? (m_domFont->elementItalic()     ? 1 : 0) : -1;

    const int rhsItalic = rhs.m_domFont->hasElementItalic() ? (rhs.m_domFont->elementItalic() ? 1 : 0) : -1;

    if (const int crc = compareInt(italic, rhsItalic))

        return crc;

    const int underline    = m_domFont->hasElementUnderline()     ? (m_domFont->elementUnderline()     ? 1 : 0) : -1;

    const int rhsUnderline = rhs.m_domFont->hasElementUnderline() ? (rhs.m_domFont->elementUnderline() ? 1 : 0) : -1;

    if (const int crc = compareInt(underline, rhsUnderline))

        return crc;

    const int weight    = m_domFont->hasElementWeight()     ?     m_domFont->elementWeight() : -1;

    const int rhsWeight = rhs.m_domFont->hasElementWeight() ? rhs.m_domFont->elementWeight() : -1;

    if (const int crc = compareInt(weight, rhsWeight))

        return crc;

    const int strikeOut    = m_domFont->hasElementStrikeOut()     ? (m_domFont->elementStrikeOut()     ? 1 : 0) : -1;

    const int rhsStrikeOut = rhs.m_domFont->hasElementStrikeOut() ? (rhs.m_domFont->elementStrikeOut() ? 1 : 0) : -1;

    if (const int crc = compareInt(strikeOut, rhsStrikeOut))

        return crc;

    const int kerning    = m_domFont->hasElementKerning()     ? (m_domFont->elementKerning()     ? 1 : 0) : -1;

    const int rhsKerning = rhs.m_domFont->hasElementKerning() ? (rhs.m_domFont->elementKerning() ? 1 : 0) : -1;

    if (const int crc = compareInt(kerning, rhsKerning))

        return crc;

    const int antialiasing    = m_domFont->hasElementAntialiasing()     ? (m_domFont->elementAntialiasing()     ? 1 : 0) : -1;

    const int rhsAntialiasing = rhs.m_domFont->hasElementAntialiasing() ? (rhs.m_domFont->elementAntialiasing() ? 1 : 0) : -1;

    if (const int crc = compareInt(antialiasing, rhsAntialiasing))

        return crc;

    const QString styleStrategy    = m_domFont->hasElementStyleStrategy()     ?     m_domFont->elementStyleStrategy() : QString();

    const QString rhsStyleStrategy = rhs.m_domFont->hasElementStyleStrategy() ? rhs.m_domFont->elementStyleStrategy() : QString();

    if (const int src = styleStrategy.compare(rhsStyleStrategy))

        return src;

    return 0;

}

IconHandle::IconHandle(const DomResourceIcon *domIcon) :

      m_domIcon(domIcon)

{

}

int IconHandle::compare(const IconHandle &rhs) const

{

    const QString normalOff    =     m_domIcon->hasElementNormalOff() ?     m_domIcon->elementNormalOff()->text() : QString();

    const QString rhsNormalOff = rhs.m_domIcon->hasElementNormalOff() ? rhs.m_domIcon->elementNormalOff()->text() : QString();

    if (const int comp = normalOff.compare(rhsNormalOff))

        return comp;

    const QString normalOn    =     m_domIcon->hasElementNormalOn() ?     m_domIcon->elementNormalOn()->text() : QString();

    const QString rhsNormalOn = rhs.m_domIcon->hasElementNormalOn() ? rhs.m_domIcon->elementNormalOn()->text() : QString();

    if (const int comp = normalOn.compare(rhsNormalOn))

        return comp;

    const QString disabledOff    =     m_domIcon->hasElementDisabledOff() ?     m_domIcon->elementDisabledOff()->text() : QString();

    const QString rhsDisabledOff = rhs.m_domIcon->hasElementDisabledOff() ? rhs.m_domIcon->elementDisabledOff()->text() : QString();

    if (const int comp = disabledOff.compare(rhsDisabledOff))

        return comp;

    const QString disabledOn    =     m_domIcon->hasElementDisabledOn() ?     m_domIcon->elementDisabledOn()->text() : QString();

    const QString rhsDisabledOn = rhs.m_domIcon->hasElementDisabledOn() ? rhs.m_domIcon->elementDisabledOn()->text() : QString();

    if (const int comp = disabledOn.compare(rhsDisabledOn))

        return comp;

    const QString activeOff    =     m_domIcon->hasElementActiveOff() ?     m_domIcon->elementActiveOff()->text() : QString();

    const QString rhsActiveOff = rhs.m_domIcon->hasElementActiveOff() ? rhs.m_domIcon->elementActiveOff()->text() : QString();

    if (const int comp = activeOff.compare(rhsActiveOff))

        return comp;

    const QString activeOn    =     m_domIcon->hasElementActiveOn() ?     m_domIcon->elementActiveOn()->text() : QString();

    const QString rhsActiveOn = rhs.m_domIcon->hasElementActiveOn() ? rhs.m_domIcon->elementActiveOn()->text() : QString();

    if (const int comp = activeOn.compare(rhsActiveOn))

        return comp;

    const QString selectedOff    =     m_domIcon->hasElementSelectedOff() ?     m_domIcon->elementSelectedOff()->text() : QString();

    const QString rhsSelectedOff = rhs.m_domIcon->hasElementSelectedOff() ? rhs.m_domIcon->elementSelectedOff()->text() : QString();

    if (const int comp = selectedOff.compare(rhsSelectedOff))

        return comp;

    const QString selectedOn    =     m_domIcon->hasElementSelectedOn() ?     m_domIcon->elementSelectedOn()->text() : QString();

    const QString rhsSelectedOn = rhs.m_domIcon->hasElementSelectedOn() ? rhs.m_domIcon->elementSelectedOn()->text() : QString();

    if (const int comp = selectedOn.compare(rhsSelectedOn))

        return comp;

    // Pre 4.4 Legacy

    if (const int comp = m_domIcon->text().compare(rhs.m_domIcon->text()))

        return comp;

    return 0;

}

#if defined(Q_OS_MAC) && defined(Q_CC_GNU) && (__GNUC__ == 3 && __GNUC_MINOR__ == 3)

inline uint qHash(const SizePolicyHandle &handle) { return qHash(handle.m_domSizePolicy); }

inline uint qHash(const FontHandle &handle) { return qHash(handle.m_domFont); }

inline uint qHash(const IconHandle &handle) { return qHash(handle.m_domIcon); }

#endif

SizePolicyHandle::SizePolicyHandle(const DomSizePolicy *domSizePolicy) :

    m_domSizePolicy(domSizePolicy)

{

}

int SizePolicyHandle::compare(const SizePolicyHandle &rhs) const

{

    const int hSizeType    = m_domSizePolicy->hasElementHSizeType()     ? m_domSizePolicy->elementHSizeType()     : -1;

    const int rhsHSizeType = rhs.m_domSizePolicy->hasElementHSizeType() ? rhs.m_domSizePolicy->elementHSizeType() : -1;

    if (const int crc = compareInt(hSizeType, rhsHSizeType))

        return crc;

    const int vSizeType    = m_domSizePolicy->hasElementVSizeType()     ? m_domSizePolicy->elementVSizeType()     : -1;

    const int rhsVSizeType = rhs.m_domSizePolicy->hasElementVSizeType() ? rhs.m_domSizePolicy->elementVSizeType() : -1;

    if (const int crc = compareInt(vSizeType, rhsVSizeType))

        return crc;

    const int hStretch    =  m_domSizePolicy->hasElementHorStretch()     ? m_domSizePolicy->elementHorStretch()     : -1;

    const int rhsHStretch =  rhs.m_domSizePolicy->hasElementHorStretch() ? rhs.m_domSizePolicy->elementHorStretch() : -1;

    if (const int crc = compareInt(hStretch, rhsHStretch))

        return crc;

    const int vStretch    =  m_domSizePolicy->hasElementVerStretch()     ? m_domSizePolicy->elementVerStretch()     : -1;

    const int rhsVStretch =  rhs.m_domSizePolicy->hasElementVerStretch() ? rhs.m_domSizePolicy->elementVerStretch() : -1;

    if (const int crc = compareInt(vStretch, rhsVStretch))

        return crc;

    const QString attributeHSizeType    = m_domSizePolicy->hasAttributeHSizeType()     ? m_domSizePolicy->attributeHSizeType()     : QString();

    const QString rhsAttributeHSizeType = rhs.m_domSizePolicy->hasAttributeHSizeType() ? rhs.m_domSizePolicy->attributeHSizeType() : QString();

    if (const int hrc = attributeHSizeType.compare(rhsAttributeHSizeType))

        return hrc;

    const QString attributeVSizeType    = m_domSizePolicy->hasAttributeVSizeType()     ? m_domSizePolicy->attributeVSizeType()     : QString();

    const QString rhsAttributeVSizeType = rhs.m_domSizePolicy->hasAttributeVSizeType() ? rhs.m_domSizePolicy->attributeVSizeType() : QString();

    return attributeVSizeType.compare(rhsAttributeVSizeType);

}

// ---  WriteInitialization: LayoutDefaultHandler

WriteInitialization::LayoutDefaultHandler::LayoutDefaultHandler()

{

    qFill(m_state, m_state + NumProperties, 0u);

    qFill(m_defaultValues, m_defaultValues + NumProperties, 0);

}

void WriteInitialization::LayoutDefaultHandler::acceptLayoutDefault(DomLayoutDefault *node)

{

    if (!node)

        return;

    if (node->hasAttributeMargin()) {

        m_state[Margin] |= HasDefaultValue;

        m_defaultValues[Margin] = node->attributeMargin();

    }

    if (node->hasAttributeSpacing()) {

        m_state[Spacing] |= HasDefaultValue;

        m_defaultValues[Spacing]  = node->attributeSpacing();

    }

}

void WriteInitialization::LayoutDefaultHandler::acceptLayoutFunction(DomLayoutFunction *node)

{

    if (!node)

        return;

    if (node->hasAttributeMargin()) {

        m_state[Margin]     |= HasDefaultFunction;

        m_functions[Margin] =  node->attributeMargin();

        m_functions[Margin] += QLatin1String("()");

    }

    if (node->hasAttributeSpacing()) {

        m_state[Spacing]     |= HasDefaultFunction;

        m_functions[Spacing] =  node->attributeSpacing();

        m_functions[Spacing] += QLatin1String("()");

    }

}

static inline void writeContentsMargins(const QString &indent, const QString &objectName, int value, QTextStream &str)

{

     QString contentsMargins;

     QTextStream(&contentsMargins) << value << ", " << value << ", " << value << ", " << value;

     writeSetter(indent, objectName, QLatin1String("setContentsMargins"), contentsMargins, str);

 }

void WriteInitialization::LayoutDefaultHandler::writeProperty(int p, const QString &indent, const QString &objectName,

                                                              const DomPropertyMap &properties, const QString &propertyName, const QString &setter,

                                                              int defaultStyleValue, bool suppressDefault, QTextStream &str) const

{

    // User value

    const DomPropertyMap::const_iterator mit = properties.constFind(propertyName);

    const bool found = mit != properties.constEnd();

    if (found) {

        const int value = mit.value()->elementNumber();

        // Emulate the pre 4.3 behaviour: The value form default value was only used to determine

        // the default value, layout properties were always written

        const bool useLayoutFunctionPre43 = !suppressDefault && (m_state[p] == (HasDefaultFunction|HasDefaultValue)) && value == m_defaultValues[p];

        if (!useLayoutFunctionPre43) {

            bool ifndefMac = (!(m_state[p] & (HasDefaultFunction|HasDefaultValue))

                             && value == defaultStyleValue);

            if (ifndefMac)

                str << "#ifndef Q_OS_MAC\n";

            if (p == Margin) { // Use setContentsMargins for numeric values

                writeContentsMargins(indent, objectName, value, str);

            } else {

                writeSetter(indent, objectName, setter, value, str);

            }

            if (ifndefMac)

                str << "#endif\n";

            return;

        }

    }

    if (suppressDefault)

        return;

    // get default.

    if (m_state[p] & HasDefaultFunction) {

        // Do not use setContentsMargins to avoid repetitive evaluations.

        writeSetter(indent, objectName, setter, m_functions[p], str);

        return;

    }

    if (m_state[p] & HasDefaultValue) {

        if (p == Margin) { // Use setContentsMargins for numeric values

            writeContentsMargins(indent, objectName, m_defaultValues[p], str);

        } else {

            writeSetter(indent, objectName, setter, m_defaultValues[p], str);

        }

    }

    return;

}

void WriteInitialization::LayoutDefaultHandler::writeProperties(const QString &indent, const QString &varName,

                                                                const DomPropertyMap &properties, int marginType,

                                                                bool suppressMarginDefault,

                                                                QTextStream &str) const {

    // Write out properties and ignore the ones found in

    // subsequent writing of the property list.

    int defaultSpacing = marginType == WriteInitialization::Use43UiFile ? -1 : 6;

    writeProperty(Spacing, indent, varName, properties, QLatin1String("spacing"), QLatin1String("setSpacing"),

                  defaultSpacing, false, str);

    // We use 9 as TopLevelMargin, since Designer seem to always use 9.

    static const int layoutmargins[4] = {-1, 9, 9, 0};

    writeProperty(Margin,  indent, varName, properties, QLatin1String("margin"),  QLatin1String("setMargin"),

                  layoutmargins[marginType], suppressMarginDefault, str);

}

static bool needsTranslation(DomString *str)

{

    if (!str)

        return false;

    return !str->hasAttributeNotr() || !toBool(str->attributeNotr());

}

// ---  WriteInitialization

WriteInitialization::WriteInitialization(Uic *uic, bool activateScripts) :

      m_uic(uic),

      m_driver(uic->driver()), m_output(uic->output()), m_option(uic->option()),

      m_indent(m_option.indent + m_option.indent),

      m_dindent(m_indent + m_option.indent),

      m_stdsetdef(true),

      m_layoutMarginType(TopLevelMargin),

      m_mainFormUsedInRetranslateUi(false),

      m_delayedOut(&m_delayedInitialization, QIODevice::WriteOnly),

      m_refreshOut(&m_refreshInitialization, QIODevice::WriteOnly),

      m_actionOut(&m_delayedActionInitialization, QIODevice::WriteOnly),

      m_activateScripts(activateScripts), m_layoutWidget(false)

{

}

void WriteInitialization::acceptUI(DomUI *node)

{

    m_registeredImages.clear();

    m_actionGroupChain.push(0);

    m_widgetChain.push(0);

    m_layoutChain.push(0);

    acceptLayoutDefault(node->elementLayoutDefault());

    acceptLayoutFunction(node->elementLayoutFunction());

    if (node->elementCustomWidgets())

        TreeWalker::acceptCustomWidgets(node->elementCustomWidgets());

    if (node->elementImages())

        TreeWalker::acceptImages(node->elementImages());

    if (m_option.generateImplemetation)

        m_output << "#include <" << m_driver->headerFileName() << ">\n\n";

    m_stdsetdef = true;

    if (node->hasAttributeStdSetDef())

        m_stdsetdef = node->attributeStdSetDef();

    const QString className = node->elementClass() + m_option.postfix;

    m_generatedClass = className;

    const QString varName = m_driver->findOrInsertWidget(node->elementWidget());

    m_mainFormVarName = varName;

    m_registeredWidgets.insert(varName, node->elementWidget()); // register the main widget

    const QString widgetClassName = node->elementWidget()->attributeClass();

    m_output << m_option.indent << "void " << "setupUi(" << widgetClassName << " *" << varName << ")\n"

           << m_option.indent << "{\n";

    if (m_activateScripts)

        writeSetupUIScriptVariableDeclarations(m_indent, m_output);

    const QStringList connections = m_uic->databaseInfo()->connections();

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

        QString connection = connections.at(i);

        if (connection == QLatin1String("(default)"))

            continue;