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

     2 **

     3 ** Copyright (C) 2009 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 "cppwriteinitialization.h"

    43 #include "cppwriteiconinitialization.h"

    44 #include "driver.h"

    45 #include "ui4.h"

    46 #include "utils.h"

    47 #include "uic.h"

    48 #include "databaseinfo.h"

    49 #include "globaldefs.h"

    50 

    51 #include <QtCore/QTextStream>

    52 #include <QtCore/QDebug>

    53 

    54 #include <ctype.h>

    55 

    56 QT_BEGIN_NAMESPACE

    57 

    58 namespace {

    59     // Fixup an enumeration name from class Qt.

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

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

    62     void fixQtEnumerationName(QString& name) {

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

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

    65             name.prepend(prefix);

    66     }

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

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

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

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

    71         if (!pstyle)

    72             return QString();

    73 

    74         switch (pstyle->kind()) {

    75         case DomProperty::Number: {

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

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

    78             area += QLatin1String("), ");

    79             return area;

    80         }

    81         case DomProperty::Enum: {

    82             QString area = pstyle->elementEnum();

    83             fixQtEnumerationName(area);

    84             area += QLatin1String(", ");

    85             return area;

    86         }

    87         default:

    88             break;

    89         }

    90         return QString();

    91     }

    92 

    93     // Write a statement to create a spacer item.

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

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

    96                 output << "new QSpacerItem(";

    97 

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

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

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

   101         }

   102 

   103         // size type

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

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

   106                            QString::fromLatin1("Expanding");

   107 

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

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

   110         // orientation

   111         bool isVspacer = false;

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

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

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

   115         }

   116 

   117         if (isVspacer)

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

   119         else

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

   121     }

   122 

   123 

   124     // Helper for implementing comparison functions for integers.

   125     int compareInt(int i1, int i2) {

   126         if (i1 < i2) return -1;

   127         if (i1 > i2) return  1;

   128         return  0;

   129     }

   130 

   131     // Write object->setFoo(x);

   132     template <class Value>

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

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

   135         }

   136 

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

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

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

   140     }

   141 

   142     static inline bool isIconFormat44(const DomResourceIcon *i) {

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

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

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

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

   147     }

   148 

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

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

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

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

   153         switch (p->kind()) {

   154         case DomProperty::IconSet:

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

   156                 if (!isIconFormat44(dri)) {

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

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

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

   160                         return false;

   161                     }

   162                 }

   163             }

   164             break;

   165         case DomProperty::Pixmap:

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

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

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

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

   170                     return false;

   171                 }

   172             break;

   173         default:

   174             break;

   175         }

   176         return  true;

   177     }

   178 

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

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

   181 

   182     const char *accessibilityDefineC = "QT_NO_ACCESSIBILITY";

   183     const char *toolTipDefineC = "QT_NO_TOOLTIP";

   184     const char *whatsThisDefineC = "QT_NO_WHATSTHIS";

   185     const char *statusTipDefineC = "QT_NO_STATUSTIP";

   186     const char *shortcutDefineC = "QT_NO_SHORTCUT";

   187 }

   188 

   189 namespace CPP {

   190 

   191 FontHandle::FontHandle(const DomFont *domFont) :

   192       m_domFont(domFont)

   193 {

   194 }

   195 

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

   197 {

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

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

   200 

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

   202         return frc;

   203 

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

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

   206 

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

   208         return crc;

   209 

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

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

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

   213         return crc;

   214 

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

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

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

   218         return crc;

   219 

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

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

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

   223         return crc;

   224 

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

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

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

   228         return crc;

   229 

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

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

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

   233         return crc;

   234 

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

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

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

   238         return crc;

   239 

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

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

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

   243         return crc;

   244 

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

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

   247 

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

   249         return src;

   250 

   251     return 0;

   252 }

   253 

   254 IconHandle::IconHandle(const DomResourceIcon *domIcon) :

   255       m_domIcon(domIcon)

   256 {

   257 }

   258 

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

   260 {

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

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

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

   264         return comp;

   265 

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

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

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

   269         return comp;

   270 

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

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

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

   274         return comp;

   275 

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

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

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

   279         return comp;

   280 

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

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

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

   284         return comp;

   285 

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

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

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

   289         return comp;

   290 

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

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

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

   294         return comp;

   295 

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

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

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

   299         return comp;

   300     // Pre 4.4 Legacy

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

   302         return comp;

   303 

   304     return 0;

   305 }

   306 

   307 

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

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

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

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

   312 #endif

   313 

   314 SizePolicyHandle::SizePolicyHandle(const DomSizePolicy *domSizePolicy) :

   315     m_domSizePolicy(domSizePolicy)

   316 {

   317 }

   318 

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

   320 {

   321 

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

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

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

   325         return crc;

   326 

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

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

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

   330         return crc;

   331 

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

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

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

   335         return crc;

   336 

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

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

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

   340         return crc;

   341 

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

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

   344 

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

   346         return hrc;

   347 

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

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

   350 

   351     return attributeVSizeType.compare(rhsAttributeVSizeType);

   352 }

   353 

   354 // ---  WriteInitialization: LayoutDefaultHandler

   355 

   356 WriteInitialization::LayoutDefaultHandler::LayoutDefaultHandler()

   357 {

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

   359     qFill(m_defaultValues, m_defaultValues + NumProperties, 0);

   360 }

   361 

   362 

   363 

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

   365 {

   366     if (!node)

   367         return;

   368     if (node->hasAttributeMargin()) {

   369         m_state[Margin] |= HasDefaultValue;

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

   371     }

   372     if (node->hasAttributeSpacing()) {

   373         m_state[Spacing] |= HasDefaultValue;

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

   375     }

   376 }

   377 

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

   379 {

   380     if (!node)

   381         return;

   382     if (node->hasAttributeMargin()) {

   383         m_state[Margin]     |= HasDefaultFunction;

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

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

   386     }

   387     if (node->hasAttributeSpacing()) {

   388         m_state[Spacing]     |= HasDefaultFunction;

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

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

   391     }

   392 }

   393 

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

   395 {

   396      QString contentsMargins;

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

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

   399  }

   400 

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

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

   403                                                               int defaultStyleValue, bool suppressDefault, QTextStream &str) const

   404 {

   405     // User value

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

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

   408     if (found) {

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

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

   411         // the default value, layout properties were always written

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

   413         if (!useLayoutFunctionPre43) {

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

   415                              && value == defaultStyleValue);

   416             if (ifndefMac)

   417                 str << "#ifndef Q_OS_MAC\n";

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

   419                 writeContentsMargins(indent, objectName, value, str);

   420             } else {

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

   422             }

   423             if (ifndefMac)

   424                 str << "#endif\n";

   425             return;

   426         }

   427     }

   428     if (suppressDefault)

   429         return;

   430     // get default.

   431     if (m_state[p] & HasDefaultFunction) {

   432         // Do not use setContentsMargins to avoid repetitive evaluations.

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

   434         return;

   435     }

   436     if (m_state[p] & HasDefaultValue) {

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

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

   439         } else {

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

   441         }

   442     }

   443     return;

   444 }

   445 

   446 

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

   448                                                                 const DomPropertyMap &properties, int marginType,

   449                                                                 bool suppressMarginDefault,

   450                                                                 QTextStream &str) const {

   451     // Write out properties and ignore the ones found in

   452     // subsequent writing of the property list.

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

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

   455                   defaultSpacing, false, str);

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

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

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

   459                   layoutmargins[marginType], suppressMarginDefault, str);

   460 }

   461 

   462 static bool needsTranslation(DomString *str)

   463 {

   464     if (!str)

   465         return false;

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

   467 }

   468 

   469 // ---  WriteInitialization

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

   471       m_uic(uic),

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

   473       m_indent(m_option.indent + m_option.indent),

   474       m_dindent(m_indent + m_option.indent),

   475       m_stdsetdef(true),

   476       m_layoutMarginType(TopLevelMargin),

   477       m_mainFormUsedInRetranslateUi(false),

   478       m_delayedOut(&m_delayedInitialization, QIODevice::WriteOnly),

   479       m_refreshOut(&m_refreshInitialization, QIODevice::WriteOnly),

   480       m_actionOut(&m_delayedActionInitialization, QIODevice::WriteOnly),

   481       m_activateScripts(activateScripts), m_layoutWidget(false)

   482 {

   483 }

   484 

   485 void WriteInitialization::acceptUI(DomUI *node)

   486 {

   487     m_registeredImages.clear();

   488     m_actionGroupChain.push(0);

   489     m_widgetChain.push(0);

   490     m_layoutChain.push(0);

   491 

   492     acceptLayoutDefault(node->elementLayoutDefault());

   493     acceptLayoutFunction(node->elementLayoutFunction());

   494 

   495     if (node->elementCustomWidgets())

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

   497 

   498     if (node->elementImages())

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

   500 

   501     if (m_option.generateImplemetation)

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

   503 

   504     m_stdsetdef = true;

   505     if (node->hasAttributeStdSetDef())

   506         m_stdsetdef = node->attributeStdSetDef();

   507 

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

   509     m_generatedClass = className;

   510 

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

   512     m_mainFormVarName = varName;

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

   514 

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

   516 

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

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

   519 

   520     if (m_activateScripts)

   521         writeSetupUIScriptVariableDeclarations(m_indent, m_output);

   522 

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

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

   525         QString connection = connections.at(i);

   526 

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

   528             continue;

   529 

   530         const QString varConn = connection + QLatin1String("Connection");

   531         m_output << m_indent << varConn << " = QSqlDatabase::database(" << fixString(connection, m_dindent) << ");\n";

   532     }

   533 

   534     acceptWidget(node->elementWidget());

   535 

   536     if (m_buddies.size() > 0)

   537         openIfndef(m_output, QLatin1String(shortcutDefineC));

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

   539         const Buddy &b = m_buddies.at(i);

   540 

   541         if (!m_registeredWidgets.contains(b.objName)) {

   542             fprintf(stderr, "'%s' isn't a valid widget\n", b.objName.toLatin1().data());

   543             continue;

   544         } else if (!m_registeredWidgets.contains(b.buddy)) {

   545             fprintf(stderr, "'%s' isn't a valid widget\n", b.buddy.toLatin1().data());

   546             continue;

   547         }

   548 

   549         m_output << m_indent << b.objName << "->setBuddy(" << b.buddy << ");\n";

   550     }

   551     if (m_buddies.size() > 0)

   552         closeIfndef(m_output, QLatin1String(shortcutDefineC));

   553 

   554     if (node->elementTabStops())

   555         acceptTabStops(node->elementTabStops());

   556 

   557     if (m_delayedActionInitialization.size())

   558         m_output << "\n" << m_delayedActionInitialization;

   559 

   560     m_output << "\n" << m_indent << "retranslateUi(" << varName << ");\n";

   561 

   562     if (node->elementConnections())

   563         acceptConnections(node->elementConnections());

   564 

   565     if (!m_delayedInitialization.isEmpty())

   566         m_output << "\n" << m_delayedInitialization << "\n";

   567 

   568     if (m_option.autoConnection)

   569         m_output << "\n" << m_indent << "QMetaObject::connectSlotsByName(" << varName << ");\n";

   570 

   571     m_output << m_option.indent << "} // setupUi\n\n";

   572 

   573     if (!m_mainFormUsedInRetranslateUi) {

   574         m_refreshInitialization += m_indent;

   575         m_refreshInitialization += QLatin1String("Q_UNUSED(");

   576         m_refreshInitialization += varName ;

   577         m_refreshInitialization += QLatin1String(");\n");

   578     }

   579 

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

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

   582            << m_refreshInitialization

   583            << m_option.indent << "} // retranslateUi\n\n";

   584 

   585     m_layoutChain.pop();

   586     m_widgetChain.pop();

   587     m_actionGroupChain.pop();

   588 }

   589 

   590 void WriteInitialization::addWizardPage(const QString &pageVarName, const DomWidget *page, const QString &parentWidget)

   591 {

   592     /* If the node has a (free-format) string "pageId" attribute (which could

   593      * an integer or an enumeration value), use setPage(), else addPage(). */

   594     QString id;

   595     const DomPropertyList attributes = page->elementAttribute();

   596     if (!attributes.empty()) {

   597         const DomPropertyList::const_iterator acend = attributes.constEnd();

   598         for (DomPropertyList::const_iterator it = attributes.constBegin(); it != acend; ++it)

   599             if ((*it)->attributeName() == QLatin1String("pageId")) {

   600                 if (const DomString *ds = (*it)->elementString())

   601                     id = ds->text();

   602                 break;

   603             }

   604     }

   605     if (id.isEmpty()) {

   606         m_output << m_indent << parentWidget << "->addPage(" << pageVarName << ");\n";

   607     } else {

   608         m_output << m_indent << parentWidget << "->setPage(" << id << ", " << pageVarName << ");\n";

   609     }

   610 }

   611 

   612 void WriteInitialization::acceptWidget(DomWidget *node)

   613 {

   614     m_layoutMarginType = m_widgetChain.count() == 1 ? TopLevelMargin : ChildMargin;

   615     const QString className = node->attributeClass();

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

   617     m_registeredWidgets.insert(varName, node); // register the current widget

   618 

   619     QString parentWidget, parentClass;

   620     if (m_widgetChain.top()) {

   621         parentWidget = m_driver->findOrInsertWidget(m_widgetChain.top());

   622         parentClass = m_widgetChain.top()->attributeClass();

   623     }

   624 

   625     const QString savedParentWidget = parentWidget;

   626 

   627     if (m_uic->isContainer(parentClass) || m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("Q3ToolBar")))

   628         parentWidget.clear();

   629 

   630     if (m_widgetChain.size() != 1)

   631         m_output << m_indent << varName << " = new " << m_uic->customWidgetsInfo()->realClassName(className) << '(' << parentWidget << ");\n";

   632 

   633     parentWidget = savedParentWidget;

   634 

   635     if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("Q3ComboBox"))) {

   636         initializeComboBox3(node);

   637     } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QComboBox"))) {

   638         initializeComboBox(node);

   639     } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QListWidget"))) {

   640         initializeListWidget(node);

   641     } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QTreeWidget"))) {

   642         initializeTreeWidget(node);

   643     } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QTableWidget"))) {

   644         initializeTableWidget(node);

   645     } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("Q3ListBox"))) {

   646         initializeQ3ListBox(node);

   647     } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("Q3ListView"))) {

   648         initializeQ3ListView(node);

   649     } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("Q3IconView"))) {

   650         initializeQ3IconView(node);

   651     } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("Q3Table"))) {

   652         initializeQ3Table(node);

   653     } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("Q3DataTable"))) {

   654         initializeQ3SqlDataTable(node);

   655     } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("Q3DataBrowser"))) {

   656         initializeQ3SqlDataBrowser(node);

   657     }

   658 

   659     if (m_uic->isButton(className))

   660         addButtonGroup(node, varName);

   661 

   662     writeProperties(varName, className, node->elementProperty());

   663 

   664     if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QMenu")) && parentWidget.size()) {

   665         initializeMenu(node, parentWidget);

   666     }

   667 

   668     if (node->elementLayout().isEmpty())

   669         m_layoutChain.push(0);

   670 

   671     m_layoutWidget = false;

   672     if (className == QLatin1String("QWidget") && !node->hasAttributeNative()) {

   673         if (m_widgetChain.top()

   674             && m_widgetChain.top()->attributeClass() != QLatin1String("QMainWindow")

   675             && !m_uic->isContainer(m_widgetChain.top()->attributeClass()))

   676             m_layoutWidget = true;

   677     }

   678     m_widgetChain.push(node);

   679     m_layoutChain.push(0);

   680     TreeWalker::acceptWidget(node);

   681     m_layoutChain.pop();

   682     m_widgetChain.pop();

   683     m_layoutWidget = false;

   684 

   685     const DomPropertyMap attributes = propertyMap(node->elementAttribute());

   686 

   687     const QString pageDefaultString = QLatin1String("Page");

   688 

   689     int id = -1;

   690     if (const DomProperty *pid = attributes.value(QLatin1String("id"))) {

   691         id = pid->elementNumber();

   692     }

   693 

   694     if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QMainWindow"))

   695             || m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("Q3MainWindow"))) {

   696 

   697         if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QMenuBar"))) {

   698             if (!m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("Q3MainWindow")))

   699                 m_output << m_indent << parentWidget << "->setMenuBar(" << varName <<");\n";

   700         } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QToolBar"))) {

   701             m_output << m_indent << parentWidget << "->addToolBar("

   702                      << toolBarAreaStringFromDOMAttributes(attributes) << varName << ");\n";

   703 

   704             if (const DomProperty *pbreak = attributes.value(QLatin1String("toolBarBreak"))) {

   705                 if (pbreak->elementBool() == QLatin1String("true")) {

   706                     m_output << m_indent << parentWidget << "->insertToolBarBreak(" <<  varName << ");\n";

   707                 }

   708             }

   709 

   710         } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QDockWidget"))) {

   711             QString area;

   712             if (DomProperty *pstyle = attributes.value(QLatin1String("dockWidgetArea"))) {

   713                 area += QLatin1String("static_cast<Qt::DockWidgetArea>(");

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

   715                 area += QLatin1String("), ");

   716             }

   717 

   718             m_output << m_indent << parentWidget << "->addDockWidget(" << area << varName << ");\n";

   719         } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QStatusBar"))) {

   720             m_output << m_indent << parentWidget << "->setStatusBar(" << varName << ");\n";

   721         } else if (className == QLatin1String("QWidget")) {

   722             m_output << m_indent << parentWidget << "->setCentralWidget(" << varName << ");\n";

   723         }

   724     }

   725 

   726     // Check for addPageMethod of a custom plugin first

   727     const QString addPageMethod = m_uic->customWidgetsInfo()->customWidgetAddPageMethod(parentClass);

   728     if (!addPageMethod.isEmpty()) {

   729         m_output << m_indent << parentWidget << "->" << addPageMethod << '(' << varName << ");\n";

   730     } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QStackedWidget"))) {

   731         m_output << m_indent << parentWidget << "->addWidget(" << varName << ");\n";

   732     } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QToolBar"))) {

   733         m_output << m_indent << parentWidget << "->addWidget(" << varName << ");\n";

   734     } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("Q3WidgetStack"))) {

   735         m_output << m_indent << parentWidget << "->addWidget(" << varName << ", " << id << ");\n";

   736     } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QDockWidget"))) {

   737         m_output << m_indent << parentWidget << "->setWidget(" << varName << ");\n";

   738     } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QScrollArea"))) {

   739         m_output << m_indent << parentWidget << "->setWidget(" << varName << ");\n";

   740     } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QSplitter"))) {

   741         m_output << m_indent << parentWidget << "->addWidget(" << varName << ");\n";

   742     } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QMdiArea"))) {

   743         m_output << m_indent << parentWidget << "->addSubWindow(" << varName << ");\n";

   744     } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QWorkspace"))) {

   745         m_output << m_indent << parentWidget << "->addWindow(" << varName << ");\n";

   746     } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QWizard"))) {

   747         addWizardPage(varName, node, parentWidget);

   748     } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QToolBox"))) {

   749         QString icon;

   750         if (const DomProperty *picon = attributes.value(QLatin1String("icon"))) {

   751             icon += QLatin1String(", ") ;

   752             icon += iconCall(picon);

   753         }

   754 

   755         const DomProperty *plabel = attributes.value(QLatin1String("label"));

   756         DomString *plabelString = plabel ? plabel->elementString() : 0;

   757 

   758         m_output << m_indent << parentWidget << "->addItem(" << varName << icon << ", " << noTrCall(plabelString, pageDefaultString) << ");\n";

   759 

   760         autoTrOutput(plabelString, pageDefaultString) << m_indent << parentWidget << "->setItemText("

   761                    << parentWidget << "->indexOf(" << varName << "), " << autoTrCall(plabelString, pageDefaultString) << ");\n";

   762 

   763 #ifndef QT_NO_TOOLTIP

   764         if (DomProperty *ptoolTip = attributes.value(QLatin1String("toolTip"))) {

   765             autoTrOutput(ptoolTip->elementString()) << m_indent << parentWidget << "->setItemToolTip("

   766                        << parentWidget << "->indexOf(" << varName << "), " << autoTrCall(ptoolTip->elementString()) << ");\n";

   767         }

   768 #endif // QT_NO_TOOLTIP

   769     } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QTabWidget"))) {

   770         QString icon;

   771         if (const DomProperty *picon = attributes.value(QLatin1String("icon"))) {

   772             icon += QLatin1String(", ");

   773             icon += iconCall(picon);

   774         }

   775 

   776         const DomProperty *ptitle = attributes.value(QLatin1String("title"));

   777         DomString *ptitleString = ptitle ? ptitle->elementString() : 0;

   778 

   779         m_output << m_indent << parentWidget << "->addTab(" << varName << icon << ", " << "QString());\n";

   780 

   781         autoTrOutput(ptitleString, pageDefaultString) << m_indent << parentWidget << "->setTabText("

   782                    << parentWidget << "->indexOf(" << varName << "), " << autoTrCall(ptitleString, pageDefaultString) << ");\n";

   783 

   784 #ifndef QT_NO_TOOLTIP

   785         if (const DomProperty *ptoolTip = attributes.value(QLatin1String("toolTip"))) {

   786             autoTrOutput(ptoolTip->elementString()) << m_indent << parentWidget << "->setTabToolTip("

   787                        << parentWidget << "->indexOf(" << varName << "), " << autoTrCall(ptoolTip->elementString()) << ");\n";

   788         }

   789 #endif // QT_NO_TOOLTIP

   790 #ifndef QT_NO_WHATSTHIS

   791         if (const DomProperty *pwhatsThis = attributes.value(QLatin1String("whatsThis"))) {

   792             autoTrOutput(pwhatsThis->elementString()) << m_indent << parentWidget << "->setTabWhatsThis("

   793                        << parentWidget << "->indexOf(" << varName << "), " << autoTrCall(pwhatsThis->elementString()) << ");\n";

   794         }

   795 #endif // QT_NO_WHATSTHIS

   796     } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("Q3Wizard"))) {

   797         const DomProperty *ptitle = attributes.value(QLatin1String("title"));

   798         DomString *ptitleString = ptitle ? ptitle->elementString() : 0;

   799 

   800         m_output << m_indent << parentWidget << "->addPage(" << varName << ", " << noTrCall(ptitleString, pageDefaultString) << ");\n";

   801 

   802         autoTrOutput(ptitleString, pageDefaultString) << m_indent << parentWidget << "->setTitle("

   803                    << varName << ", " << autoTrCall(ptitleString, pageDefaultString) << ");\n";

   804 

   805     }

   806 

   807     //

   808     // Special handling for qtableview/qtreeview fake header attributes

   809     //

   810     static QStringList realPropertyNames =

   811             (QStringList() << QLatin1String("visible")

   812                            << QLatin1String("cascadingSectionResizes")

   813                            << QLatin1String("defaultSectionSize")

   814                            << QLatin1String("highlightSections")

   815                            << QLatin1String("minimumSectionSize")

   816                            << QLatin1String("showSortIndicator")

   817                            << QLatin1String("stretchLastSection"));

   818 

   819     if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QTreeView"))

   820                || m_uic->customWidgetsInfo()->extends(className, QLatin1String("QTreeWidget"))) {

   821         DomPropertyList headerProperties;

   822         foreach (const QString &realPropertyName, realPropertyNames) {

   823             const QString upperPropertyName = realPropertyName.at(0).toUpper()

   824                                               + realPropertyName.mid(1);

   825             const QString fakePropertyName = QLatin1String("header") + upperPropertyName;

   826             if (DomProperty *fakeProperty = attributes.value(fakePropertyName)) {

   827                 fakeProperty->setAttributeName(realPropertyName);

   828                 headerProperties << fakeProperty;

   829             }

   830         }

   831         writeProperties(varName + QLatin1String("->header()"), QLatin1String("QHeaderView"),

   832                         headerProperties, WritePropertyIgnoreObjectName);

   833 

   834     } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QTableView"))

   835                || m_uic->customWidgetsInfo()->extends(className, QLatin1String("QTableWidget"))) {

   836 

   837         static QStringList headerPrefixes =

   838                 (QStringList() << QLatin1String("horizontalHeader")

   839                                << QLatin1String("verticalHeader"));

   840 

   841         foreach (const QString &headerPrefix, headerPrefixes) {

   842             DomPropertyList headerProperties;

   843             foreach (const QString &realPropertyName, realPropertyNames) {

   844                 const QString upperPropertyName = realPropertyName.at(0).toUpper()

   845                                                   + realPropertyName.mid(1);

   846                 const QString fakePropertyName = headerPrefix + upperPropertyName;

   847                 if (DomProperty *fakeProperty = attributes.value(fakePropertyName)) {

   848                     fakeProperty->setAttributeName(realPropertyName);

   849                     headerProperties << fakeProperty;

   850                 }

   851             }

   852             writeProperties(varName + QLatin1String("->") + headerPrefix + QLatin1String("()"),

   853                             QLatin1String("QHeaderView"),

   854                             headerProperties, WritePropertyIgnoreObjectName);

   855         }

   856     }

   857 

   858     if (node->elementLayout().isEmpty())

   859         m_layoutChain.pop();

   860 

   861     const QStringList zOrder = node->elementZOrder();

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

   863         const QString name = zOrder.at(i);

   864 

   865         if (!m_registeredWidgets.contains(name)) {

   866             fprintf(stderr, "'%s' isn't a valid widget\n", name.toLatin1().data());

   867             continue;

   868         }

   869 

   870         if (name.isEmpty()) {

   871             continue;

   872         }

   873 

   874         m_output << m_indent << name << "->raise();\n";

   875     }

   876 }

   877 

   878 void WriteInitialization::addButtonGroup(const DomWidget *buttonNode, const QString &varName)

   879 {

   880     const DomPropertyMap attributes = propertyMap(buttonNode->elementAttribute());

   881     // Look up the button group name as specified in the attribute and find the uniquified name

   882     const DomProperty *prop = attributes.value(QLatin1String("buttonGroup"));

   883     if (!prop)

   884         return;

   885     const QString attributeName = toString(prop->elementString());

   886     const DomButtonGroup *group = m_driver->findButtonGroup(attributeName);

   887     // Legacy feature: Create missing groups on the fly as the UIC button group feature

   888     // was present before the actual Designer support (4.5)

   889     const bool createGroupOnTheFly = group == 0;

   890     if (createGroupOnTheFly) {

   891         DomButtonGroup *newGroup = new DomButtonGroup;

   892         newGroup->setAttributeName(attributeName);

   893         group = newGroup;

   894         fprintf(stderr, "Warning: Creating button group `%s'\n", attributeName.toLatin1().data());

   895     }

   896     const QString groupName = m_driver->findOrInsertButtonGroup(group);

   897     // Create on demand

   898     if (!m_buttonGroups.contains(groupName)) {

   899         const QString className = QLatin1String("QButtonGroup");

   900         m_output << m_indent;

   901         if (createGroupOnTheFly)

   902             m_output << className << " *";

   903         m_output << groupName << " = new " << className << '(' << m_mainFormVarName << ");\n";

   904         m_buttonGroups.insert(groupName);

   905         writeProperties(groupName, className, group->elementProperty());

   906     }

   907     m_output << m_indent << groupName << "->addButton(" << varName << ");\n";

   908 }

   909 

   910 void WriteInitialization::acceptLayout(DomLayout *node)

   911 {

   912     const QString className = node->attributeClass();

   913     const QString varName = m_driver->findOrInsertLayout(node);

   914 

   915     const DomPropertyMap properties = propertyMap(node->elementProperty());

   916     const bool oldLayoutProperties = properties.constFind(QLatin1String("margin")) != properties.constEnd();

   917 

   918     bool isGroupBox = false;

   919 

   920     if (m_widgetChain.top()) {

   921         const QString parentWidget = m_widgetChain.top()->attributeClass();

   922 

   923         if (!m_layoutChain.top() && (m_uic->customWidgetsInfo()->extends(parentWidget, QLatin1String("Q3GroupBox"))

   924                         || m_uic->customWidgetsInfo()->extends(parentWidget, QLatin1String("Q3ButtonGroup")))) {

   925             const QString parent = m_driver->findOrInsertWidget(m_widgetChain.top());

   926 

   927             isGroupBox = true;

   928             // special case for group box

   929 

   930             m_output << m_indent << parent << "->setColumnLayout(0, Qt::Vertical);\n";

   931             QString objectName = parent;

   932             objectName += QLatin1String("->layout()");

   933             int marginType = Use43UiFile;

   934             if (oldLayoutProperties)

   935                 marginType = m_layoutMarginType;

   936 

   937             m_LayoutDefaultHandler.writeProperties(m_indent,

   938                                     objectName, properties, marginType, false, m_output);

   939         }

   940     }

   941 

   942     m_output << m_indent << varName << " = new " << className << '(';

   943 

   944     if (!m_layoutChain.top() && !isGroupBox)

   945         m_output << m_driver->findOrInsertWidget(m_widgetChain.top());

   946 

   947     m_output << ");\n";

   948 

   949     if (isGroupBox) {

   950         const QString tempName = m_driver->unique(QLatin1String("boxlayout"));

   951         m_output << m_indent << "QBoxLayout *" << tempName << " = qobject_cast<QBoxLayout *>(" <<

   952                     m_driver->findOrInsertWidget(m_widgetChain.top()) << "->layout());\n";

   953         m_output << m_indent << "if (" << tempName << ")\n";

   954         m_output << m_dindent << tempName << "->addLayout(" << varName << ");\n";

   955     }

   956 

   957     if (isGroupBox) {

   958         m_output << m_indent << varName << "->setAlignment(Qt::AlignTop);\n";

   959     }  else {

   960         // Suppress margin on a read child layout

   961         const bool suppressMarginDefault = m_layoutChain.top();

   962         int marginType = Use43UiFile;

   963         if (oldLayoutProperties)

   964             marginType = m_layoutMarginType;

   965         m_LayoutDefaultHandler.writeProperties(m_indent, varName, properties, marginType, suppressMarginDefault, m_output);

   966     }

   967 

   968     m_layoutMarginType = SubLayoutMargin;

   969 

   970     DomPropertyList propList = node->elementProperty();

   971     if (m_layoutWidget) {

   972         bool left, top, right, bottom;

   973         left = top = right = bottom = false;

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

   975             const DomProperty *p = propList.at(i);

   976             const QString propertyName = p->attributeName();

   977             if (propertyName == QLatin1String("leftMargin") && p->kind() == DomProperty::Number)

   978                 left = true;

   979             else if (propertyName == QLatin1String("topMargin") && p->kind() == DomProperty::Number)

   980                 top = true;

   981             else if (propertyName == QLatin1String("rightMargin") && p->kind() == DomProperty::Number)

   982                 right = true;

   983             else if (propertyName == QLatin1String("bottomMargin") && p->kind() == DomProperty::Number)

   984                 bottom = true;

   985         }

   986         if (!left) {

   987             DomProperty *p = new DomProperty();

   988             p->setAttributeName(QLatin1String("leftMargin"));

   989             p->setElementNumber(0);

   990             propList.append(p);

   991         }

   992         if (!top) {

   993             DomProperty *p = new DomProperty();

   994             p->setAttributeName(QLatin1String("topMargin"));

   995             p->setElementNumber(0);

   996             propList.append(p);

   997         }

   998         if (!right) {

   999             DomProperty *p = new DomProperty();

  1000             p->setAttributeName(QLatin1String("rightMargin"));

  1001             p->setElementNumber(0);

  1002             propList.append(p);

  1003         }

  1004         if (!bottom) {

  1005             DomProperty *p = new DomProperty();

  1006             p->setAttributeName(QLatin1String("bottomMargin"));

  1007             p->setElementNumber(0);

  1008             propList.append(p);

  1009         }

  1010         m_layoutWidget = false;

  1011     }

  1012 

  1013     writeProperties(varName, className, propList, WritePropertyIgnoreMargin|WritePropertyIgnoreSpacing);

  1014 

  1015     m_layoutChain.push(node);

  1016     TreeWalker::acceptLayout(node);

  1017     m_layoutChain.pop();

  1018 

  1019     // Stretch? (Unless we are compiling for UIC3)

  1020     const QString numberNull = QString(QLatin1Char('0'));

  1021     writePropertyList(varName, QLatin1String("setStretch"), node->attributeStretch(), numberNull);

  1022     writePropertyList(varName, QLatin1String("setRowStretch"), node->attributeRowStretch(), numberNull);

  1023     writePropertyList(varName, QLatin1String("setColumnStretch"), node->attributeColumnStretch(), numberNull);

  1024     writePropertyList(varName, QLatin1String("setColumnMinimumWidth"), node->attributeColumnMinimumWidth(), numberNull);

  1025     writePropertyList(varName, QLatin1String("setRowMinimumHeight"), node->attributeRowMinimumHeight(), numberNull);

  1026 }

  1027 

  1028 // Apply a comma-separated list of values using a function "setSomething(int idx, value)"

  1029 void WriteInitialization::writePropertyList(const QString &varName,

  1030                                             const QString &setFunction,

  1031                                             const QString &value,

  1032                                             const QString &defaultValue)

  1033 {

  1034     if (value.isEmpty())

  1035         return;

  1036     const QStringList list = value.split(QLatin1Char(','));

  1037     const int count =  list.count();

  1038     for (int i = 0; i < count; i++)

  1039         if (list.at(i) != defaultValue)

  1040             m_output << m_indent << varName << "->" << setFunction << '(' << i << ", " << list.at(i) << ");\n";

  1041 }

  1042 

  1043 void WriteInitialization::acceptSpacer(DomSpacer *node)

  1044 {

  1045     m_output << m_indent << m_driver->findOrInsertSpacer(node) << " = ";

  1046     writeSpacerItem(node, m_output);

  1047     m_output << ";\n";

  1048 }

  1049 

  1050 static inline QString formLayoutRole(int column, int colspan)

  1051 {

  1052     if (colspan > 1)

  1053         return QLatin1String("QFormLayout::SpanningRole");

  1054     return column == 0 ? QLatin1String("QFormLayout::LabelRole") : QLatin1String("QFormLayout::FieldRole");

  1055 }

  1056 

  1057 void WriteInitialization::acceptLayoutItem(DomLayoutItem *node)

  1058 {

  1059     TreeWalker::acceptLayoutItem(node);

  1060 

  1061     DomLayout *layout = m_layoutChain.top();

  1062 

  1063     if (!layout)

  1064         return;

  1065 

  1066     const QString layoutName = m_driver->findOrInsertLayout(layout);

  1067     const QString itemName = m_driver->findOrInsertLayoutItem(node);

  1068 

  1069     QString addArgs;

  1070     QString methodPrefix = QLatin1String("add"); //Consistent API-design galore!

  1071     if (layout->attributeClass() == QLatin1String("QGridLayout")) {

  1072         const int row = node->attributeRow();

  1073         const int col = node->attributeColumn();

  1074 

  1075         const int rowSpan = node->hasAttributeRowSpan() ? node->attributeRowSpan() : 1;

  1076         const int colSpan = node->hasAttributeColSpan() ? node->attributeColSpan() : 1;

  1077 

  1078         addArgs = QString::fromLatin1("%1, %2, %3, %4, %5").arg(itemName).arg(row).arg(col).arg(rowSpan).arg(colSpan);

  1079     } else {

  1080         if (layout->attributeClass() == QLatin1String("QFormLayout")) {

  1081             methodPrefix = QLatin1String("set");

  1082             const int row = node->attributeRow();

  1083             const int colSpan = node->hasAttributeColSpan() ? node->attributeColSpan() : 1;

  1084             const QString role = formLayoutRole(node->attributeColumn(), colSpan);

  1085             addArgs = QString::fromLatin1("%1, %2, %3").arg(row).arg(role).arg(itemName);

  1086         } else {

  1087             addArgs = itemName;

  1088         }

  1089     }

  1090 

  1091     // figure out "add" method

  1092     m_output << "\n" << m_indent << layoutName << "->";

  1093     switch (node->kind()) {

  1094     case DomLayoutItem::Widget:

  1095         m_output << methodPrefix << "Widget(" <<  addArgs;

  1096         break;

  1097     case DomLayoutItem::Layout:

  1098         m_output <<  methodPrefix << "Layout(" << addArgs;

  1099         break;

  1100     case DomLayoutItem::Spacer:

  1101         m_output << methodPrefix << "Item(" << addArgs;

  1102         break;

  1103     case DomLayoutItem::Unknown:

  1104         Q_ASSERT( 0 );

  1105         break;

  1106     }

  1107     m_output << ");\n\n";

  1108 }

  1109 

  1110 void WriteInitialization::acceptActionGroup(DomActionGroup *node)

  1111 {

  1112     const QString actionName = m_driver->findOrInsertActionGroup(node);

  1113     QString varName = m_driver->findOrInsertWidget(m_widgetChain.top());

  1114 

  1115     if (m_actionGroupChain.top())

  1116         varName = m_driver->findOrInsertActionGroup(m_actionGroupChain.top());

  1117 

  1118     m_output << m_indent << actionName << " = new QActionGroup(" << varName << ");\n";

  1119     writeProperties(actionName, QLatin1String("QActionGroup"), node->elementProperty());

  1120 

  1121     m_actionGroupChain.push(node);

  1122     TreeWalker::acceptActionGroup(node);

  1123     m_actionGroupChain.pop();

  1124 }

  1125 

  1126 void WriteInitialization::acceptAction(DomAction *node)

  1127 {

  1128     if (node->hasAttributeMenu())

  1129         return;

  1130 

  1131     const QString actionName = m_driver->findOrInsertAction(node);

  1132     m_registeredActions.insert(actionName, node);

  1133     QString varName = m_driver->findOrInsertWidget(m_widgetChain.top());

  1134