Merge commit 'dev' into 'wip/cmake-merge'

Change-Id: I176c40d031be26a1dd1cf08843e448a660598783

27 files changed, 1794 insertions, 883 deletions

diff --git a/src/tools/uic/CMakeLists.txt b/src/tools/uic/CMakeLists.txt
index 15ef92a2b4..05de0a71ba 100644
--- a/src/tools/uic/CMakeLists.txt
+++ b/src/tools/uic/CMakeLists.txt
@@ -12,9 +12,11 @@ add_qt_tool(uic
         customwidgetsinfo.cpp customwidgetsinfo.h
         databaseinfo.cpp databaseinfo.h
         driver.cpp driver.h
-        globaldefs.h
         main.cpp
         option.h
+        python/pythonwritedeclaration.cpp python/pythonwritedeclaration.h
+        python/pythonwriteimports.cpp python/pythonwriteimports.h
+        shared/language.cpp shared/language.h
         treewalker.cpp treewalker.h
         ui4.cpp ui4.h
         uic.cpp uic.h
@@ -24,19 +26,24 @@ add_qt_tool(uic
         QT_UIC
         QT_NO_CAST_FROM_ASCII
         QT_NO_FOREACH
-        QT_UIC_CPP_GENERATOR
+        QT_UIC_CPP_GENERATOR # special case
     INCLUDE_DIRECTORIES
+        # . # special case: remove
+        shared
         cpp
+        # ${CMAKE_CURRENT_BINARY_DIR} # special case: remove
+        python
     DISABLE_AUTOGEN_TOOLS # special case:
         uic rcc
-    # QMAKE_TARGET_DESCRIPTION = "Qt User Interface Compiler"
-    # _LOADED = "qt_tool"
-    # _OPTION = "host_build"
 )
 
+#### Keys ignored in scope 1:.:.:uic.pro:<TRUE>:
+# QMAKE_TARGET_DESCRIPTION = "Qt User Interface Compiler"
+# _LOADED = "qt_tool"
+# _OPTION = "host_build"
+
 ## Scopes:
 #####################################################################
-#
-#extend_target(uic CONDITION NOT force_bootstrap AND NOT qtConfig(commandlineparser OR NOT QT_FEATURE_textcodec OR NOT QT_FEATURE_xmlstreamreader OR NOT QT_FEATURE_xmlstreamwriter
-#    # CONFIG = "force_bootstrap"
-#)
+
+#### Keys ignored in scope 2:.:.:uic.pro:NOT force_bootstrap AND NOT qtConfig(commandlineparser OR NOT QT_FEATURE_textcodec OR NOT QT_FEATURE_xmlstreamreader OR NOT QT_FEATURE_xmlstreamwriter:
+# CONFIG = "force_bootstrap"
diff --git a/src/tools/uic/cpp/cpp.pri b/src/tools/uic/cpp/cpp.pri
index a6b6188117..786b0e97a5 100644
--- a/src/tools/uic/cpp/cpp.pri
+++ b/src/tools/uic/cpp/cpp.pri
@@ -1,7 +1,5 @@
 INCLUDEPATH += $$PWD $$QT_BUILD_TREE/src/tools/uic
 
-DEFINES += QT_UIC_CPP_GENERATOR
-
 # Input
 HEADERS += $$PWD/cppwritedeclaration.h \
            $$PWD/cppwriteincludes.h \
diff --git a/src/tools/uic/cpp/cppwriteincludes.cpp b/src/tools/uic/cpp/cppwriteincludes.cpp
index d51fddffea..0ba49627c0 100644
--- a/src/tools/uic/cpp/cppwriteincludes.cpp
+++ b/src/tools/uic/cpp/cppwriteincludes.cpp
@@ -119,7 +119,7 @@ void WriteIncludes::acceptUI(DomUI *node)
     writeHeaders(m_globalIncludes, true);
     writeHeaders(m_localIncludes, false);
 
-    m_output << QLatin1Char('\n');
+    m_output << '\n';
 }
 
 void WriteIncludes::acceptWidget(DomWidget *node)
@@ -214,14 +214,14 @@ void WriteIncludes::add(const QString &className, bool determineHeader, const QS
     m_knownClasses.insert(className);
 
     const CustomWidgetsInfo *cwi = m_uic->customWidgetsInfo();
-    if (cwi->extends(className, QLatin1String("QTreeView"))
-               || cwi->extends(className, QLatin1String("QTreeWidget"))
-               || cwi->extends(className, QLatin1String("QTableView"))
-               || cwi->extends(className, QLatin1String("QTableWidget"))) {
+    static const QStringList treeViewsWithHeaders = {
+        QLatin1String("QTreeView"), QLatin1String("QTreeWidget"),
+        QLatin1String("QTableView"), QLatin1String("QTableWidget")
+    };
+    if (cwi->extendsOneOf(className, treeViewsWithHeaders))
         add(QLatin1String("QHeaderView"));
-    }
 
-    if (!m_laidOut && m_uic->customWidgetsInfo()->extends(className, QLatin1String("QToolBox")))
+    if (!m_laidOut && cwi->extends(className, QLatin1String("QToolBox")))
         add(QLatin1String("QLayout")); // spacing property of QToolBox)
 
     if (className == QLatin1String("Line")) { // ### hmm, deprecate me!
@@ -314,7 +314,7 @@ void WriteIncludes::writeHeaders(const OrderedSet &headers, bool global)
         const QString value = m_oldHeaderToNewHeader.value(header, header);
         const auto trimmed = QStringRef(&value).trimmed();
         if (!trimmed.isEmpty())
-            m_output << "#include " << openingQuote << trimmed << closingQuote << QLatin1Char('\n');
+            m_output << "#include " << openingQuote << trimmed << closingQuote << '\n';
     }
 }
 
diff --git a/src/tools/uic/cpp/cppwriteincludes.h b/src/tools/uic/cpp/cppwriteincludes.h
index 7f03849798..79cbd41014 100644
--- a/src/tools/uic/cpp/cppwriteincludes.h
+++ b/src/tools/uic/cpp/cppwriteincludes.h
@@ -40,6 +40,7 @@
 QT_BEGIN_NAMESPACE
 
 class QTextStream;
+class CustomWidgetsInfo;
 class Driver;
 class Uic;
 
@@ -58,9 +59,9 @@ struct WriteIncludes : public TreeWalker
 //
 // actions
 //
-    void acceptActionGroup(DomActionGroup *node) Q_DECL_OVERRIDE;
-    void acceptAction(DomAction *node) Q_DECL_OVERRIDE;
-    void acceptActionRef(DomActionRef *node) Q_DECL_OVERRIDE;
+    void acceptActionGroup(DomActionGroup *node) override;
+    void acceptAction(DomAction *node) override;
+    void acceptActionRef(DomActionRef *node) override;
 
 //
 // custom widgets
@@ -74,6 +75,9 @@ struct WriteIncludes : public TreeWalker
     void acceptIncludes(DomIncludes *node) override;
     void acceptInclude(DomInclude *node) override;
 
+protected:
+     QTextStream &output() const { return m_output; }
+
 private:
     void add(const QString &className, bool determineHeader = true, const QString &header = QString(), bool global = false);
 
diff --git a/src/tools/uic/cpp/cppwriteinitialization.cpp b/src/tools/uic/cpp/cppwriteinitialization.cpp
index 4f6ac1eb97..6ff7323b3d 100644
--- a/src/tools/uic/cpp/cppwriteinitialization.cpp
+++ b/src/tools/uic/cpp/cppwriteinitialization.cpp
@@ -32,9 +32,11 @@
 #include "utils.h"
 #include "uic.h"
 #include "databaseinfo.h"
-#include "globaldefs.h"
+
+#include <language.h>
 
 #include <qtextstream.h>
+#include <qversionnumber.h>
 #include <qdebug.h>
 
 #include <algorithm>
@@ -44,41 +46,32 @@
 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.
-    QLatin1String qtEnumerationPrefix(const QString &name) {
-        static const QLatin1String prefix("Qt::");
-        if (name.indexOf(prefix) != 0)
-            return prefix;
-        return QLatin1String();
-    }
     // 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"));
+        QString result;
         if (!pstyle)
-            return QString();
-
+            return result;
         switch (pstyle->kind()) {
-        case DomProperty::Number: {
-            return QLatin1String("static_cast<Qt::ToolBarArea>(")
-                   + QString::number(pstyle->elementNumber()) + QLatin1String("), ");
-        }
-        case DomProperty::Enum: {
-            const QString area = pstyle->elementEnum();
-            return qtEnumerationPrefix(area) + area + QLatin1String(", ");
-        }
+        case DomProperty::Number:
+            result = QLatin1String(language::toolbarArea(pstyle->elementNumber()));
+            break;
+        case DomProperty::Enum:
+            result = pstyle->elementEnum();
+            break;
         default:
             break;
         }
-        return QString();
+        if (!result.startsWith(QLatin1String("Qt::")))
+            result.prepend(QLatin1String("Qt::"));
+        return result + QLatin1String(", ");
     }
 
     // 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(";
+                output << language::operatorNew << "QSpacerItem(";
 
         int w = 0;
         int h = 0;
@@ -109,11 +102,9 @@ namespace {
             if (orientation == QLatin1String("Qt::Vertical") || orientation == QLatin1String("Vertical"))
                 isVspacer = true;
         }
-
-        if (isVspacer)
-            output << "QSizePolicy::Minimum, " << sizeType << ')';
-        else
-            output << sizeType << ", QSizePolicy::Minimum)";
+        const QString horizType = isVspacer ? QLatin1String("QSizePolicy::Minimum") : sizeType;
+        const QString vertType = isVspacer ? sizeType : QLatin1String("QSizePolicy::Minimum");
+        output << language::enumValue(horizType) << ", " << language::enumValue(vertType) << ')';
     }
 
 
@@ -127,7 +118,8 @@ namespace {
     // 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";
+            str << indent << varName << language::derefPointer
+                << setter << '(' << v << ')' << language::eol;
         }
 
     static inline bool iconHasStatePixmaps(const DomResourceIcon *i) {
@@ -172,17 +164,16 @@ namespace {
         }
         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";
 }
 
+// QtGui
+static inline QString accessibilityConfigKey() { return QStringLiteral("accessibility"); }
+static inline QString shortcutConfigKey()      { return QStringLiteral("shortcut"); }
+static inline QString whatsThisConfigKey()     { return QStringLiteral("whatsthis"); }
+// QtWidgets
+static inline QString statusTipConfigKey()     { return QStringLiteral("statustip"); }
+static inline QString toolTipConfigKey()       { return QStringLiteral("tooltip"); }
+
 namespace CPP {
 
 FontHandle::FontHandle(const DomFont *domFont) :
@@ -503,8 +494,9 @@ void WriteInitialization::acceptUI(DomUI *node)
 
     const QString widgetClassName = node->elementWidget()->attributeClass();
 
-    m_output << m_option.indent << "void " << "setupUi(" << widgetClassName << " *" << varName << ")\n"
-           << m_option.indent << "{\n";
+    const QString parameterType = widgetClassName + QLatin1String(" *");
+    m_output << m_option.indent
+             << language::startFunctionDefinition1("setupUi", parameterType, varName, m_option.indent);
 
     const QStringList connections = m_uic->databaseInfo()->connections();
     for (int i=0; i<connections.size(); ++i) {
@@ -514,38 +506,42 @@ void WriteInitialization::acceptUI(DomUI *node)
             continue;
 
         const QString varConn = connection + QLatin1String("Connection");
-        m_output << m_indent << varConn << " = QSqlDatabase::database(" << fixString(connection, m_dindent) << ");\n";
+        m_output << m_indent << varConn << " = QSqlDatabase::database("
+            << language::charliteral(connection, m_dindent) << ");\n";
     }
 
     acceptWidget(node->elementWidget());
 
     if (!m_buddies.empty())
-        openIfndef(m_output, QLatin1String(shortcutDefineC));
+        m_output << language::openQtConfig(shortcutConfigKey());
     for (const Buddy &b : qAsConst(m_buddies)) {
         if (!m_registeredWidgets.contains(b.objName)) {
             fprintf(stderr, "%s: Warning: Buddy assignment: '%s' is not a valid widget.\n",
                     qPrintable(m_option.messagePrefix()),
                     b.objName.toLatin1().data());
             continue;
-        } else if (!m_registeredWidgets.contains(b.buddy)) {
+        }
+        if (!m_registeredWidgets.contains(b.buddy)) {
             fprintf(stderr, "%s: Warning: Buddy assignment: '%s' is not a valid widget.\n",
                     qPrintable(m_option.messagePrefix()),
                     b.buddy.toLatin1().data());
             continue;
         }
 
-        m_output << m_indent << b.objName << "->setBuddy(" << b.buddy << ");\n";
+        m_output << m_indent << b.objName << language::derefPointer
+            << "setBuddy(" << b.buddy << ')' << language::eol;
     }
     if (!m_buddies.empty())
-        closeIfndef(m_output, QLatin1String(shortcutDefineC));
+        m_output << language::closeQtConfig(shortcutConfigKey());
 
     if (node->elementTabStops())
         acceptTabStops(node->elementTabStops());
 
-    if (m_delayedActionInitialization.size())
+    if (!m_delayedActionInitialization.isEmpty())
         m_output << "\n" << m_delayedActionInitialization;
 
-    m_output << "\n" << m_indent << "retranslateUi(" << varName << ");\n";
+    m_output << "\n" << m_indent << language::self
+        << "retranslateUi(" << varName << ')' << language::eol;
 
     if (node->elementConnections())
         acceptConnections(node->elementConnections());
@@ -553,10 +549,12 @@ void WriteInitialization::acceptUI(DomUI *node)
     if (!m_delayedInitialization.isEmpty())
         m_output << "\n" << m_delayedInitialization << "\n";
 
-    if (m_option.autoConnection)
-        m_output << "\n" << m_indent << "QMetaObject::connectSlotsByName(" << varName << ");\n";
+    if (m_option.autoConnection) {
+        m_output << "\n" << m_indent << "QMetaObject" << language::qualifier
+            << "connectSlotsByName(" << varName << ')' << language::eol;
+    }
 
-    m_output << m_option.indent << "} // setupUi\n\n";
+    m_output << m_option.indent << language::endFunctionDefinition("setupUi");
 
     if (!m_mainFormUsedInRetranslateUi) {
         m_refreshInitialization += m_indent;
@@ -565,10 +563,10 @@ void WriteInitialization::acceptUI(DomUI *node)
         m_refreshInitialization += QLatin1String(");\n");
     }
 
-    m_output << m_option.indent << "void " << "retranslateUi(" << widgetClassName << " *" << varName << ")\n"
-           << m_option.indent << "{\n"
+    m_output << m_option.indent
+           << language::startFunctionDefinition1("retranslateUi", parameterType, varName, m_option.indent)
            << m_refreshInitialization
-           << m_option.indent << "} // retranslateUi\n\n";
+           << m_option.indent << language::endFunctionDefinition("retranslateUi");
 
     m_layoutChain.pop();
     m_widgetChain.pop();
@@ -591,9 +589,11 @@ void WriteInitialization::addWizardPage(const QString &pageVarName, const DomWid
         }
     }
     if (id.isEmpty()) {
-        m_output << m_indent << parentWidget << "->addPage(" << pageVarName << ");\n";
+        m_output << m_indent << parentWidget << language::derefPointer
+            << "addPage(" << pageVarName << ')' << language::eol;
     } else {
-        m_output << m_indent << parentWidget << "->setPage(" << id << ", " << pageVarName << ");\n";
+        m_output << m_indent << parentWidget << language::derefPointer
+            << "setPage(" << id << ", " << pageVarName << ')' << language::eol;
     }
 }
 
@@ -615,18 +615,24 @@ void WriteInitialization::acceptWidget(DomWidget *node)
     if (m_uic->isContainer(parentClass))
         parentWidget.clear();
 
-    if (m_widgetChain.size() != 1)
-        m_output << m_indent << varName << " = new " << m_uic->customWidgetsInfo()->realClassName(className) << '(' << parentWidget << ");\n";
+    const auto *cwi = m_uic->customWidgetsInfo();
+
+    if (m_widgetChain.size() != 1) {
+        m_output << m_indent << varName << " = " << language::operatorNew
+            << language::fixClassName(cwi->realClassName(className))
+            << '(' << parentWidget << ')' << language::eol;
+    }
 
     parentWidget = savedParentWidget;
 
-    if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QComboBox"))) {
+
+    if (cwi->extends(className, QLatin1String("QComboBox"))) {
         initializeComboBox(node);
-    } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QListWidget"))) {
+    } else if (cwi->extends(className, QLatin1String("QListWidget"))) {
         initializeListWidget(node);
-    } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QTreeWidget"))) {
+    } else if (cwi->extends(className, QLatin1String("QTreeWidget"))) {
         initializeTreeWidget(node);
-    } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QTableWidget"))) {
+    } else if (cwi->extends(className, QLatin1String("QTableWidget"))) {
         initializeTableWidget(node);
     }
 
@@ -635,7 +641,8 @@ void WriteInitialization::acceptWidget(DomWidget *node)
 
     writeProperties(varName, className, node->elementProperty());
 
-    if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QMenu")) && parentWidget.size()) {
+    if (!parentWidget.isEmpty()
+        && cwi->extends(className, QLatin1String("QMenu"))) {
         initializeMenu(node, parentWidget);
     }
 
@@ -647,7 +654,7 @@ void WriteInitialization::acceptWidget(DomWidget *node)
         if (const DomWidget* parentWidget = m_widgetChain.top()) {
             const QString parentClass = parentWidget->attributeClass();
             if (parentClass != QLatin1String("QMainWindow")
-                && !m_uic->isCustomWidgetContainer(parentClass)
+                && !m_uic->customWidgetsInfo()->isCustomWidgetContainer(parentClass)
                 && !m_uic->isContainer(parentClass))
             m_layoutWidget = true;
         }
@@ -663,101 +670,100 @@ void WriteInitialization::acceptWidget(DomWidget *node)
 
     const QString pageDefaultString = QLatin1String("Page");
 
-    if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QMainWindow"))) {
-        if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QMenuBar"))) {
-            m_output << m_indent << parentWidget << "->setMenuBar(" << varName <<");\n";
-        } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QToolBar"))) {
-            m_output << m_indent << parentWidget << "->addToolBar("
-                     << toolBarAreaStringFromDOMAttributes(attributes) << varName << ");\n";
+    if (cwi->extends(parentClass, QLatin1String("QMainWindow"))) {
+        if (cwi->extends(className, QLatin1String("QMenuBar"))) {
+            m_output << m_indent << parentWidget << language::derefPointer
+                << "setMenuBar(" << varName << ')' << language::eol;
+        } else if (cwi->extends(className, QLatin1String("QToolBar"))) {
+            m_output << m_indent << parentWidget << language::derefPointer << "addToolBar("
+                << language::enumValue(toolBarAreaStringFromDOMAttributes(attributes)) << varName
+                << ')' << language::eol;
 
             if (const DomProperty *pbreak = attributes.value(QLatin1String("toolBarBreak"))) {
                 if (pbreak->elementBool() == QLatin1String("true")) {
-                    m_output << m_indent << parentWidget << "->insertToolBarBreak(" <<  varName << ");\n";
+                    m_output << m_indent << parentWidget << language::derefPointer
+                        << "insertToolBarBreak(" <<  varName << ')' << language::eol;
                 }
             }
 
-        } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QDockWidget"))) {
-            QString area;
+        } else if (cwi->extends(className, QLatin1String("QDockWidget"))) {
+            m_output << m_indent << parentWidget << language::derefPointer << "addDockWidget(";
             if (DomProperty *pstyle = attributes.value(QLatin1String("dockWidgetArea"))) {
-                area += QLatin1String("static_cast<Qt::DockWidgetArea>(");
-                area += QString::number(pstyle->elementNumber());
-                area += QLatin1String("), ");
+                m_output << "Qt" << language::qualifier
+                    << language::dockWidgetArea(pstyle->elementNumber()) << ", ";
             }
-
-            m_output << m_indent << parentWidget << "->addDockWidget(" << area << varName << ");\n";
+            m_output << varName << ");\n";
         } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QStatusBar"))) {
-            m_output << m_indent << parentWidget << "->setStatusBar(" << varName << ");\n";
+            m_output << m_indent << parentWidget << language::derefPointer
+                << "setStatusBar(" << varName << ')' << language::eol;
         } else {
-                m_output << m_indent << parentWidget << "->setCentralWidget(" << varName << ");\n";
+                m_output << m_indent << parentWidget << language::derefPointer
+                    << "setCentralWidget(" << varName << ')' << language::eol;
         }
     }
 
     // Check for addPageMethod of a custom plugin first
-    const QString addPageMethod = m_uic->customWidgetsInfo()->customWidgetAddPageMethod(parentClass);
+    QString addPageMethod = cwi->customWidgetAddPageMethod(parentClass);
+    if (addPageMethod.isEmpty())
+        addPageMethod = cwi->simpleContainerAddPageMethod(parentClass);
     if (!addPageMethod.isEmpty()) {
-        m_output << m_indent << parentWidget << "->" << addPageMethod << '(' << varName << ");\n";
-    } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QStackedWidget"))) {
-        m_output << m_indent << parentWidget << "->addWidget(" << varName << ");\n";
-    } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QToolBar"))) {
-        m_output << m_indent << parentWidget << "->addWidget(" << varName << ");\n";
-    } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QDockWidget"))) {
-        m_output << m_indent << parentWidget << "->setWidget(" << varName << ");\n";
-    } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QScrollArea"))) {
-        m_output << m_indent << parentWidget << "->setWidget(" << varName << ");\n";
-    } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QSplitter"))) {
-        m_output << m_indent << parentWidget << "->addWidget(" << varName << ");\n";
-    } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QMdiArea"))) {
-        m_output << m_indent << parentWidget << "->addSubWindow(" << varName << ");\n";
+        m_output << m_indent << parentWidget << language::derefPointer
+            << addPageMethod << '(' << varName << ')' << language::eol;
     } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QWizard"))) {
         addWizardPage(varName, node, parentWidget);
     } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QToolBox"))) {
-        QString icon;
-        if (const DomProperty *picon = attributes.value(QLatin1String("icon"))) {
-            icon += QLatin1String(", ") ;
-            icon += iconCall(picon);
-        }
-
         const DomProperty *plabel = attributes.value(QLatin1String("label"));
         DomString *plabelString = plabel ? plabel->elementString() : 0;
+        QString icon;
+        if (const DomProperty *picon = attributes.value(QLatin1String("icon")))
+            icon = QLatin1String(", ") + iconCall(picon); // Side effect: Writes icon definition
+        m_output << m_indent << parentWidget << language::derefPointer << "addItem("
+            << varName << icon << ", " << noTrCall(plabelString, pageDefaultString)
+            << ')' << language::eol;
 
-        m_output << m_indent << parentWidget << "->addItem(" << varName << icon << ", " << noTrCall(plabelString, pageDefaultString) << ");\n";
-
-        autoTrOutput(plabelString, pageDefaultString) << m_indent << parentWidget << "->setItemText("
-                   << parentWidget << "->indexOf(" << varName << "), " << autoTrCall(plabelString, pageDefaultString) << ");\n";
+        autoTrOutput(plabelString, pageDefaultString) << m_indent << parentWidget
+            << language::derefPointer << "setItemText(" << parentWidget
+            << language::derefPointer << "indexOf("  << varName << "), "
+            << autoTrCall(plabelString, pageDefaultString) << ')' << language::eol;
 
-#ifndef QT_NO_TOOLTIP
         if (DomProperty *ptoolTip = attributes.value(QLatin1String("toolTip"))) {
-            autoTrOutput(ptoolTip->elementString()) << m_indent << parentWidget << "->setItemToolTip("
-                       << parentWidget << "->indexOf(" << varName << "), " << autoTrCall(ptoolTip->elementString()) << ");\n";
+            autoTrOutput(ptoolTip->elementString())
+                << language::openQtConfig(toolTipConfigKey())
+                << m_indent << parentWidget << language::derefPointer << "setItemToolTip(" << parentWidget
+                << language::derefPointer << "indexOf(" << varName << "), "
+                << autoTrCall(ptoolTip->elementString()) << ')' << language::eol
+                << language::closeQtConfig(toolTipConfigKey());
         }
-#endif // QT_NO_TOOLTIP
     } else if (m_uic->customWidgetsInfo()->extends(parentClass, QLatin1String("QTabWidget"))) {
-        QString icon;
-        if (const DomProperty *picon = attributes.value(QLatin1String("icon"))) {
-            icon += QLatin1String(", ");
-            icon += iconCall(picon);
-        }
-
         const DomProperty *ptitle = attributes.value(QLatin1String("title"));
         DomString *ptitleString = ptitle ? ptitle->elementString() : 0;
+        QString icon;
+        if (const DomProperty *picon = attributes.value(QLatin1String("icon")))
+            icon = QLatin1String(", ") + iconCall(picon); // Side effect: Writes icon definition
+        m_output << m_indent << parentWidget << language::derefPointer << "addTab("
+            << varName << icon << ", " << "QString())" << language::eol;
 
-        m_output << m_indent << parentWidget << "->addTab(" << varName << icon << ", " << "QString());\n";
-
-        autoTrOutput(ptitleString, pageDefaultString) << m_indent << parentWidget << "->setTabText("
-                   << parentWidget << "->indexOf(" << varName << "), " << autoTrCall(ptitleString, pageDefaultString) << ");\n";
+        autoTrOutput(ptitleString, pageDefaultString) << m_indent << parentWidget
+            << language::derefPointer << "setTabText(" << parentWidget
+            << language::derefPointer << "indexOf(" << varName << "), "
+            << autoTrCall(ptitleString, pageDefaultString) << ')' << language::eol;
 
-#ifndef QT_NO_TOOLTIP
         if (const DomProperty *ptoolTip = attributes.value(QLatin1String("toolTip"))) {
-            autoTrOutput(ptoolTip->elementString()) << m_indent << parentWidget << "->setTabToolTip("
-                       << parentWidget << "->indexOf(" << varName << "), " << autoTrCall(ptoolTip->elementString()) << ");\n";
+            autoTrOutput(ptoolTip->elementString())
+                << language::openQtConfig(toolTipConfigKey())
+                << m_indent << parentWidget << language::derefPointer << "setTabToolTip("
+                << parentWidget << language::derefPointer << "indexOf(" << varName
+                << "), " << autoTrCall(ptoolTip->elementString()) << ')' << language::eol
+                << language::closeQtConfig(toolTipConfigKey());
         }
-#endif // QT_NO_TOOLTIP
-#ifndef QT_NO_WHATSTHIS
         if (const DomProperty *pwhatsThis = attributes.value(QLatin1String("whatsThis"))) {
-            autoTrOutput(pwhatsThis->elementString()) << m_indent << parentWidget << "->setTabWhatsThis("
-                       << parentWidget << "->indexOf(" << varName << "), " << autoTrCall(pwhatsThis->elementString()) << ");\n";
+            autoTrOutput(pwhatsThis->elementString())
+                << language::openQtConfig(whatsThisConfigKey())
+                << m_indent << parentWidget << language::derefPointer << "setTabWhatsThis("
+                << parentWidget << language::derefPointer << "indexOf(" << varName
+                << "), " << autoTrCall(pwhatsThis->elementString()) << ')' << language::eol
+                << language::closeQtConfig(whatsThisConfigKey());
         }
-#endif // QT_NO_WHATSTHIS
     }
 
     //
@@ -766,15 +772,21 @@ void WriteInitialization::acceptWidget(DomWidget *node)
     static const QLatin1String realPropertyNames[] = {
         QLatin1String("visible"),
         QLatin1String("cascadingSectionResizes"),
+        QLatin1String("minimumSectionSize"),    // before defaultSectionSize
         QLatin1String("defaultSectionSize"),
         QLatin1String("highlightSections"),
-        QLatin1String("minimumSectionSize"),
         QLatin1String("showSortIndicator"),
         QLatin1String("stretchLastSection"),
     };
 
-    if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QTreeView"))
-               || m_uic->customWidgetsInfo()->extends(className, QLatin1String("QTreeWidget"))) {
+    static const QStringList trees = {
+        QLatin1String("QTreeView"), QLatin1String("QTreeWidget")
+    };
+    static const QStringList tables = {
+        QLatin1String("QTableView"), QLatin1String("QTableWidget")
+    };
+
+    if (cwi->extendsOneOf(className, trees)) {
         DomPropertyList headerProperties;
         for (auto realPropertyName : realPropertyNames) {
             const QString fakePropertyName = QLatin1String("header")
@@ -784,12 +796,11 @@ void WriteInitialization::acceptWidget(DomWidget *node)
                 headerProperties << fakeProperty;
             }
         }
-        writeProperties(varName + QLatin1String("->header()"), QLatin1String("QHeaderView"),
-                        headerProperties, WritePropertyIgnoreObjectName);
-
-    } else if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QTableView"))
-               || m_uic->customWidgetsInfo()->extends(className, QLatin1String("QTableWidget"))) {
+        writeProperties(varName + language::derefPointer + QLatin1String("header()"),
+                        QLatin1String("QHeaderView"), headerProperties,
+                        WritePropertyIgnoreObjectName);
 
+    } else if (cwi->extendsOneOf(className, tables)) {
         static const QLatin1String headerPrefixes[] = {
             QLatin1String("horizontalHeader"),
             QLatin1String("verticalHeader"),
@@ -805,8 +816,9 @@ void WriteInitialization::acceptWidget(DomWidget *node)
                     headerProperties << fakeProperty;
                 }
             }
-            writeProperties(varName + QLatin1String("->") + headerPrefix + QLatin1String("()"),
-                            QLatin1String("QHeaderView"),
+            const QString headerVar = varName + language::derefPointer
+                + headerPrefix + QLatin1String("()");
+            writeProperties(headerVar, QLatin1String("QHeaderView"),
                             headerProperties, WritePropertyIgnoreObjectName);
         }
     }
@@ -823,8 +835,10 @@ void WriteInitialization::acceptWidget(DomWidget *node)
             continue;
         }
 
-        if (!name.isEmpty())
-            m_output << m_indent << name << "->raise();\n";
+        if (!name.isEmpty()) {
+            m_output << m_indent << name << language::derefPointer << "raise()"
+                << language::eol;
+        }
     }
 }
 
@@ -855,11 +869,13 @@ void WriteInitialization::addButtonGroup(const DomWidget *buttonNode, const QStr
         m_output << m_indent;
         if (createGroupOnTheFly)
             m_output << className << " *";
-        m_output << groupName << " = new " << className << '(' << m_mainFormVarName << ");\n";
+        m_output << groupName << " = " << language::operatorNew
+            << className << '(' << m_mainFormVarName << ')' << language::eol;
         m_buttonGroups.insert(groupName);
         writeProperties(groupName, className, group->elementProperty());
     }
-    m_output << m_indent << groupName << "->addButton(" << varName << ");\n";
+    m_output << m_indent << groupName << language::derefPointer << "addButton("
+        << varName << ')' << language::eol;
 }
 
 void WriteInitialization::acceptLayout(DomLayout *node)
@@ -872,7 +888,7 @@ void WriteInitialization::acceptLayout(DomLayout *node)
 
     bool isGroupBox = false;
 
-    m_output << m_indent << varName << " = new " << className << '(';
+    m_output << m_indent << varName << " = " << language::operatorNew << className << '(';
 
     if (!m_layoutChain.top() && !isGroupBox)
         m_output << m_driver->findOrInsertWidget(m_widgetChain.top());
@@ -964,9 +980,12 @@ void WriteInitialization::writePropertyList(const QString &varName,
         return;
     const QStringList list = value.split(QLatin1Char(','));
     const int count =  list.count();
-    for (int i = 0; i < count; i++)
-        if (list.at(i) != defaultValue)
-            m_output << m_indent << varName << "->" << setFunction << '(' << i << ", " << list.at(i) << ");\n";
+    for (int i = 0; i < count; i++) {
+        if (list.at(i) != defaultValue) {
+            m_output << m_indent << varName << language::derefPointer << setFunction
+                << '(' << i << ", " << list.at(i) << ')' << language::eol;
+        }
+    }
 }
 
 void WriteInitialization::acceptSpacer(DomSpacer *node)
@@ -983,6 +1002,24 @@ static inline QString formLayoutRole(int column, int colspan)
     return column == 0 ? QLatin1String("QFormLayout::LabelRole") : QLatin1String("QFormLayout::FieldRole");
 }
 
+static QString layoutAddMethod(DomLayoutItem::Kind kind, const QString &layoutClass)
+{
+    const QString methodPrefix = layoutClass == QLatin1String("QFormLayout")
+        ? QLatin1String("set") : QLatin1String("add");
+    switch (kind) {
+    case DomLayoutItem::Widget:
+        return methodPrefix + QLatin1String("Widget");
+    case DomLayoutItem::Layout:
+        return methodPrefix + QLatin1String("Layout");
+    case DomLayoutItem::Spacer:
+        return methodPrefix + QLatin1String("Item");
+    case DomLayoutItem::Unknown:
+        Q_ASSERT( false );
+        break;
+    }
+    Q_UNREACHABLE();
+}
+
 void WriteInitialization::acceptLayoutItem(DomLayoutItem *node)
 {
     TreeWalker::acceptLayoutItem(node);
@@ -995,47 +1032,27 @@ void WriteInitialization::acceptLayoutItem(DomLayoutItem *node)
     const QString layoutName = m_driver->findOrInsertLayout(layout);
     const QString itemName = m_driver->findOrInsertLayoutItem(node);
 
-    QString addArgs;
-    QString methodPrefix = QLatin1String("add"); //Consistent API-design galore!
+    m_output << "\n" << m_indent << layoutName << language::derefPointer << ""
+        << layoutAddMethod(node->kind(), layout->attributeClass()) << '(';
+
     if (layout->attributeClass() == QLatin1String("QGridLayout")) {
         const int row = node->attributeRow();
         const int col = node->attributeColumn();
 
         const int rowSpan = node->hasAttributeRowSpan() ? node->attributeRowSpan() : 1;
         const int colSpan = node->hasAttributeColSpan() ? node->attributeColSpan() : 1;
-
-        addArgs = QString::fromLatin1("%1, %2, %3, %4, %5").arg(itemName).arg(row).arg(col).arg(rowSpan).arg(colSpan);
+        m_output << itemName << ", " << row << ", " << col << ", " << rowSpan << ", " << colSpan;
         if (!node->attributeAlignment().isEmpty())
-            addArgs += QLatin1String(", ") + node->attributeAlignment();
+            m_output << ", " << language::enumValue(node->attributeAlignment());
+    } else if (layout->attributeClass() == QLatin1String("QFormLayout")) {
+        const int row = node->attributeRow();
+        const int colSpan = node->hasAttributeColSpan() ? node->attributeColSpan() : 1;
+        const QString role = formLayoutRole(node->attributeColumn(), colSpan);
+        m_output << row << ", " << language::enumValue(role) << ", " << itemName;
     } else {
-        if (layout->attributeClass() == QLatin1String("QFormLayout")) {
-            methodPrefix = QLatin1String("set");
-            const int row = node->attributeRow();
-            const int colSpan = node->hasAttributeColSpan() ? node->attributeColSpan() : 1;
-            const QString role = formLayoutRole(node->attributeColumn(), colSpan);
-            addArgs = QString::fromLatin1("%1, %2, %3").arg(row).arg(role, itemName);
-        } else {
-            addArgs = itemName;
-            if (layout->attributeClass().contains(QLatin1String("Box")) && !node->attributeAlignment().isEmpty())
-                addArgs += QLatin1String(", 0, ") + node->attributeAlignment();
-        }
-    }
-
-    // figure out "add" method
-    m_output << "\n" << m_indent << layoutName << "->";
-    switch (node->kind()) {
-    case DomLayoutItem::Widget:
-        m_output << methodPrefix << "Widget(" <<  addArgs;
-        break;
-    case DomLayoutItem::Layout:
-        m_output <<  methodPrefix << "Layout(" << addArgs;
-        break;
-    case DomLayoutItem::Spacer:
-        m_output << methodPrefix << "Item(" << addArgs;
-        break;
-    case DomLayoutItem::Unknown:
-        Q_ASSERT( 0 );
-        break;
+        m_output << itemName;
+        if (layout->attributeClass().contains(QLatin1String("Box")) && !node->attributeAlignment().isEmpty())
+            m_output << ", 0, " << language::enumValue(node->attributeAlignment());
     }
     m_output << ");\n\n";
 }
@@ -1048,7 +1065,8 @@ void WriteInitialization::acceptActionGroup(DomActionGroup *node)
     if (m_actionGroupChain.top())
         varName = m_driver->findOrInsertActionGroup(m_actionGroupChain.top());
 
-    m_output << m_indent << actionName << " = new QActionGroup(" << varName << ");\n";
+    m_output << m_indent << actionName << " = " << language::operatorNew
+        << "QActionGroup(" << varName << ");\n";
     writeProperties(actionName, QLatin1String("QActionGroup"), node->elementProperty());
 
     m_actionGroupChain.push(node);
@@ -1068,41 +1086,46 @@ void WriteInitialization::acceptAction(DomAction *node)
     if (m_actionGroupChain.top())
         varName = m_driver->findOrInsertActionGroup(m_actionGroupChain.top());
 
-    m_output << m_indent << actionName << " = new QAction(" << varName << ");\n";
+    m_output << m_indent << actionName << " = " << language::operatorNew
+        << "QAction(" << varName << ')' << language::eol;
     writeProperties(actionName, QLatin1String("QAction"), node->elementProperty());
 }
 
 void WriteInitialization::acceptActionRef(DomActionRef *node)
 {
     QString actionName = node->attributeName();
-    const bool isSeparator = actionName == QLatin1String("separator");
-    bool isMenu = false;
+    if (actionName.isEmpty() || !m_widgetChain.top()
+        || m_driver->actionGroupByName(actionName)) {
+        return;
+    }
 
-    QString varName = m_driver->findOrInsertWidget(m_widgetChain.top());
+    const QString varName = m_driver->findOrInsertWidget(m_widgetChain.top());
 
-    if (actionName.isEmpty() || !m_widgetChain.top()) {
-        return;
-    } else if (m_driver->actionGroupByName(actionName)) {
-        return;
-    } else if (const DomWidget *w = m_driver->widgetByName(actionName)) {
-        isMenu = m_uic->isMenu(w->attributeClass());
-    } else if (!(m_driver->actionByName(actionName) || isSeparator)) {
-        fprintf(stderr, "%s: Warning: action `%s' not declared\n",
-                qPrintable(m_option.messagePrefix()),
-                actionName.toLatin1().data());
+    if (m_widgetChain.top() && actionName == QLatin1String("separator")) {
+        // separator is always reserved!
+        m_actionOut << m_indent << varName << language::derefPointer
+            << "addSeparator()" << language::eol;
         return;
     }
 
-    if (m_widgetChain.top() && isSeparator) {
-        // separator is always reserved!
-        m_actionOut << m_indent << varName << "->addSeparator();\n";
+    const DomWidget *domWidget = m_driver->widgetByName(actionName);
+    if (domWidget && m_uic->isMenu(domWidget->attributeClass())) {
+        m_actionOut << m_indent << varName << language::derefPointer
+            << "addAction(" << m_driver->findOrInsertWidget(domWidget)
+            << language::derefPointer << "menuAction())" << language::eol;
         return;
     }
 
-    if (isMenu)
-        actionName += QLatin1String("->menuAction()");
+    const DomAction *domAction = m_driver->actionByName(actionName);
+    if (!domAction) {
+        fprintf(stderr, "%s: Warning: action `%s' not declared\n",
+                qPrintable(m_option.messagePrefix()), qPrintable(actionName));
+        return;
+    }
 
-    m_actionOut << m_indent << varName << "->addAction(" << actionName << ");\n";
+    m_actionOut << m_indent << varName << language::derefPointer
+        << "addAction(" << m_driver->findOrInsertAction(domAction)
+        << ')' << language::eol;
 }
 
 QString WriteInitialization::writeStringListProperty(const DomStringList *list) const
@@ -1119,11 +1142,28 @@ QString WriteInitialization::writeStringListProperty(const DomStringList *list)
             str << '\n' << m_indent << "    << " << trCall(values.at(i), comment);
     } else {
         for (int i = 0; i < values.size(); ++i)
-            str << " << QString::fromUtf8(" << fixString(values.at(i), m_dindent) << ')';
+            str << " << " << language::qstring(values.at(i), m_dindent);
     }
     return propertyValue;
 }
 
+static QString configKeyForProperty(const QString &propertyName)
+{
+    if (propertyName == QLatin1String("toolTip"))
+        return toolTipConfigKey();
+    if (propertyName == QLatin1String("whatsThis"))
+        return whatsThisConfigKey();
+    if (propertyName == QLatin1String("statusTip"))
+        return statusTipConfigKey();
+    if (propertyName == QLatin1String("shortcut"))
+        return shortcutConfigKey();
+    if (propertyName == QLatin1String("accessibleName")
+        || propertyName == QLatin1String("accessibleDescription")) {
+        return accessibilityConfigKey();
+    }
+    return QString();
+}
+
 void WriteInitialization::writeProperties(const QString &varName,
                                           const QString &className,
                                           const DomPropertyList &lst,
@@ -1134,19 +1174,32 @@ void WriteInitialization::writeProperties(const QString &varName,
     if (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QAxWidget"))) {
         DomPropertyMap properties = propertyMap(lst);
         if (DomProperty *p = properties.value(QLatin1String("control"))) {
-            m_output << m_indent << varName << "->setControl(QString::fromUtf8("
-                     << fixString(toString(p->elementString()), m_dindent) << "));\n";
+            m_output << m_indent << varName << language::derefPointer << "setControl("
+                << language::qstring(toString(p->elementString()), m_dindent)
+                << ')' << language::eol;
         }
     }
 
     QString indent;
     if (!m_widgetChain.top()) {
         indent = m_option.indent;
-        m_output << m_indent << "if (" << varName << "->objectName().isEmpty())\n";
+        switch (language::language()) {
+         case Language::Cpp:
+            m_output << m_indent << "if (" << varName << "->objectName().isEmpty())\n";
+            break;
+        case Language::Python:
+           m_output << m_indent << "if " << varName << ".objectName():\n";
+           break;
+        }
+    }
+    if (!(flags & WritePropertyIgnoreObjectName)) {
+        QString objectName = varName;
+        if (!language::self.isEmpty() && objectName.startsWith(language::self))
+            objectName.remove(0, language::self.size());
+        m_output << m_indent << indent
+            << varName << language::derefPointer << "setObjectName("
+            << language::qstring(objectName, m_dindent) << ')' << language::eol;
     }
-    if (!(flags & WritePropertyIgnoreObjectName))
-        m_output << m_indent << indent << varName
-                 << "->setObjectName(QString::fromUtf8(" << fixString(varName, m_dindent) << "));\n";
 
     int leftMargin, topMargin, rightMargin, bottomMargin;
     leftMargin = topMargin = rightMargin = bottomMargin = -1;
@@ -1162,28 +1215,31 @@ void WriteInitialization::writeProperties(const QString &varName,
         // special case for the property `geometry': Do not use position
         if (isTopLevel && propertyName == QLatin1String("geometry") && p->elementRect()) {
             const DomRect *r = p->elementRect();
-            m_output << m_indent << varName << "->resize(" << r->elementWidth() << ", " << r->elementHeight() << ");\n";
+            m_output << m_indent << varName << language::derefPointer << "resize("
+                << r->elementWidth() << ", " << r->elementHeight() << ')' << language::eol;
             continue;
         }
         if (propertyName == QLatin1String("currentRow") // QListWidget::currentRow
                 && m_uic->customWidgetsInfo()->extends(className, QLatin1String("QListWidget"))) {
-            m_delayedOut << m_indent << varName << "->setCurrentRow("
-                       << p->elementNumber() << ");\n";
+            m_delayedOut << m_indent << varName << language::derefPointer
+                << "setCurrentRow(" << p->elementNumber() << ')' << language::eol;
             continue;
         }
+        static const QStringList currentIndexWidgets = {
+            QLatin1String("QComboBox"), QLatin1String("QStackedWidget"),
+            QLatin1String("QTabWidget"), QLatin1String("QToolBox")
+        };
         if (propertyName == QLatin1String("currentIndex") // set currentIndex later
-            && (m_uic->customWidgetsInfo()->extends(className, QLatin1String("QComboBox"))
-                || m_uic->customWidgetsInfo()->extends(className, QLatin1String("QStackedWidget"))
-                || m_uic->customWidgetsInfo()->extends(className, QLatin1String("QTabWidget"))
-                || m_uic->customWidgetsInfo()->extends(className, QLatin1String("QToolBox")))) {
-            m_delayedOut << m_indent << varName << "->setCurrentIndex("
-                       << p->elementNumber() << ");\n";
+            && (m_uic->customWidgetsInfo()->extendsOneOf(className, currentIndexWidgets))) {
+            m_delayedOut << m_indent << varName << language::derefPointer
+                << "setCurrentIndex(" << p->elementNumber() << ')' << language::eol;
             continue;
         }
         if (propertyName == QLatin1String("tabSpacing")
             && m_uic->customWidgetsInfo()->extends(className, QLatin1String("QToolBox"))) {
-            m_delayedOut << m_indent << varName << "->layout()->setSpacing("
-                       << p->elementNumber() << ");\n";
+            m_delayedOut << m_indent << varName << language::derefPointer
+                << "layout()" << language::derefPointer << "setSpacing("
+                << p->elementNumber() << ')' << language::eol;
             continue;
         }
         if (propertyName == QLatin1String("control") // ActiveQt support
@@ -1210,10 +1266,15 @@ void WriteInitialization::writeProperties(const QString &varName,
             if (p->elementEnum() == QLatin1String("Qt::Vertical"))
                 shape = QLatin1String("QFrame::VLine");
 
-            m_output << m_indent << varName << "->setFrameShape(" << shape << ");\n";
+            m_output << m_indent << varName << language::derefPointer << "setFrameShape("
+                << language::enumValue(shape) << ')' << language::eol;
             // QFrame Default is 'Plain'. Make the line 'Sunken' unless otherwise specified
-            if (!frameShadowEncountered)
-                m_output << m_indent << varName << "->setFrameShadow(QFrame::Sunken);\n";
+            if (!frameShadowEncountered) {
+                m_output << m_indent << varName << language::derefPointer
+                    << "setFrameShadow("
+                    << language::enumValue(QLatin1String("QFrame::Sunken"))
+                    << ')' << language::eol;
+            }
             continue;
         } else if ((flags & WritePropertyIgnoreMargin)  && propertyName == QLatin1String("margin")) {
             continue;
@@ -1245,25 +1306,28 @@ void WriteInitialization::writeProperties(const QString &varName,
 
         QString setFunction;
 
-        if (stdset) {
-            setFunction = QLatin1String("->set")
-                        + propertyName.at(0).toUpper()
-                        + propertyName.midRef(1)
-                        + QLatin1Char('(');
-        } else {
-            setFunction += QLatin1String("->setProperty(\"")
-                         + propertyName
-                         + QLatin1String("\", QVariant");
-            if (p->kind() == DomProperty::Enum)
-                setFunction += QLatin1String("::fromValue");
-            setFunction += QLatin1Char('(');
-        }
+        {
+            QTextStream str(&setFunction);
+            if (stdset) {
+                str << language::derefPointer <<"set" << propertyName.at(0).toUpper()
+                    << propertyName.midRef(1) << '(';
+            } else {
+                str << language::derefPointer << QLatin1String("setProperty(\"")
+                    << propertyName << "\", ";
+                if (language::language() == Language::Cpp) {
+                    str << "QVariant";
+                    if (p->kind() == DomProperty::Enum)
+                        str << "::fromValue";
+                    str << '(';
+                }
+            }
+        } // QTextStream
 
         QString varNewName = varName;
 
         switch (p->kind()) {
         case DomProperty::Bool: {
-            propertyValue = p->elementBool();
+            propertyValue = language::boolValue(p->elementBool() == language::cppTrue);
             break;
         }
         case DomProperty::Color:
@@ -1274,13 +1338,12 @@ void WriteInitialization::writeProperties(const QString &varName,
                 Buddy buddy = { varName, p->elementCstring() };
                 m_buddies.append(std::move(buddy));
             } else {
-                if (stdset)
-                    propertyValue = fixString(p->elementCstring(), m_dindent);
-                else {
-                    propertyValue = QLatin1String("QByteArray(")
-                                  + fixString(p->elementCstring(), m_dindent)
-                                  + QLatin1Char(')');
-                }
+                QTextStream str(&propertyValue);
+                if (!stdset)
+                    str << "QByteArray(";
+                str << language::charliteral(p->elementCstring(), m_dindent);
+                if (!stdset)
+                    str << ')';
             }
             break;
         case DomProperty::Cursor:
@@ -1289,17 +1352,19 @@ void WriteInitialization::writeProperties(const QString &varName,
             break;
         case DomProperty::CursorShape:
             if (p->hasAttributeStdset() && !p->attributeStdset())
-                varNewName += QLatin1String("->viewport()");
-            propertyValue = QString::fromLatin1("QCursor(Qt::%1)")
-                            .arg(p->elementCursorShape());
+                varNewName += language::derefPointer + QLatin1String("viewport()");
+            propertyValue = QLatin1String("QCursor(Qt") + language::qualifier
+                + p->elementCursorShape() + QLatin1Char(')');
             break;
         case DomProperty::Enum:
             propertyValue = p->elementEnum();
-            if (!propertyValue.contains(QLatin1String("::")))
-                propertyValue = className + QLatin1String("::") + propertyValue;
+            if (propertyValue.contains(language::cppQualifier))
+                propertyValue = language::enumValue(propertyValue);
+            else
+                propertyValue.prepend(className + language::qualifier);
             break;
         case DomProperty::Set:
-            propertyValue = p->elementSet();
+            propertyValue = language::enumValue(p->elementSet());
             break;
         case DomProperty::Font:
             propertyValue = writeFontProperties(p->elementFont());
@@ -1313,8 +1378,8 @@ void WriteInitialization::writeProperties(const QString &varName,
         case DomProperty::Palette: {
             const DomPalette *pal = p->elementPalette();
             const QString paletteName = m_driver->unique(QLatin1String("palette"));
-            m_output << m_indent << "QPalette " << paletteName << ";\n";
-
+            m_output << m_indent << language::stackVariable("QPalette", paletteName)
+                << language::eol;
             writeColorGroup(pal->elementActive(), QLatin1String("QPalette::Active"), paletteName);
             writeColorGroup(pal->elementInactive(), QLatin1String("QPalette::Inactive"), paletteName);
             writeColorGroup(pal->elementDisabled(), QLatin1String("QPalette::Disabled"), paletteName);
@@ -1350,15 +1415,16 @@ void WriteInitialization::writeProperties(const QString &varName,
         }
         case DomProperty::Locale: {
              const DomLocale *locale = p->elementLocale();
-             propertyValue = QString::fromLatin1("QLocale(QLocale::%1, QLocale::%2)")
-                             .arg(locale->attributeLanguage(), locale->attributeCountry());
+             QTextStream(&propertyValue) << "QLocale(QLocale" << language::qualifier
+                 << locale->attributeLanguage() << ", QLocale" << language::qualifier
+                 << locale->attributeCountry() << ')';
             break;
         }
         case DomProperty::SizePolicy: {
             const QString spName = writeSizePolicy( p->elementSizePolicy());
-            m_output << m_indent << spName << QString::fromLatin1(
-                ".setHeightForWidth(%1->sizePolicy().hasHeightForWidth());\n")
-                .arg(varName);
+            m_output << m_indent << spName << ".setHeightForWidth("
+                << varName << language::derefPointer << "sizePolicy().hasHeightForWidth())"
+                << language::eol;
 
             propertyValue = spName;
             break;
@@ -1449,8 +1515,8 @@ void WriteInitialization::writeProperties(const QString &varName,
 
         case DomProperty::Url: {
             const DomUrl* u = p->elementUrl();
-            propertyValue = QString::fromLatin1("QUrl(QString::fromUtf8(%1))")
-                            .arg(fixString(u->elementString()->text(), m_dindent));
+            QTextStream(&propertyValue) << "QUrl("
+                << language::qstring(u->elementString()->text(), m_dindent) << ")";
             break;
         }
         case DomProperty::Brush:
@@ -1460,29 +1526,19 @@ void WriteInitialization::writeProperties(const QString &varName,
             break;
         }
 
-        if (propertyValue.size()) {
-            const char* defineC = 0;
-            if (propertyName == QLatin1String("toolTip"))
-                defineC = toolTipDefineC;
-            else if (propertyName == QLatin1String("whatsThis"))
-                defineC = whatsThisDefineC;
-            else if (propertyName == QLatin1String("statusTip"))
-                defineC = statusTipDefineC;
-            else if (propertyName == QLatin1String("shortcut"))
-                defineC = shortcutDefineC;
-            else if (propertyName == QLatin1String("accessibleName") || propertyName == QLatin1String("accessibleDescription"))
-                defineC = accessibilityDefineC;
+        if (!propertyValue.isEmpty()) {
+            const QString configKey = configKeyForProperty(propertyName);
 
             QTextStream &o = delayProperty ? m_delayedOut : autoTrOutput(p);
 
-            if (defineC)
-                openIfndef(o, QLatin1String(defineC));
+            if (!configKey.isEmpty())
+                o << language::openQtConfig(configKey);
             o << m_indent << varNewName << setFunction << propertyValue;
-            if (!stdset)
+            if (!stdset && language::language() == Language::Cpp)
                 o << ')';
-            o << ");\n";
-            if (defineC)
-                closeIfndef(o, QLatin1String(defineC));
+            o << ')' << language::eol;
+            if (!configKey.isEmpty())
+               o << language::closeQtConfig(configKey);
 
             if (varName == m_mainFormVarName && &o == &m_refreshOut) {
                 // this is the only place (currently) where we output mainForm name to the retranslateUi().
@@ -1492,11 +1548,9 @@ void WriteInitialization::writeProperties(const QString &varName,
         }
     }
     if (leftMargin != -1 || topMargin != -1 || rightMargin != -1 || bottomMargin != -1) {
-        m_output << m_indent << varName << QLatin1String("->setContentsMargins(")
-                 << leftMargin << QLatin1String(", ")
-                 << topMargin << QLatin1String(", ")
-                 << rightMargin << QLatin1String(", ")
-                 << bottomMargin << QLatin1String(");\n");
+        m_output << m_indent << varName << language::derefPointer << "setContentsMargins("
+            << leftMargin << ", " << topMargin << ", "
+            << rightMargin << ", " << bottomMargin << ");\n";
     }
 }
 
@@ -1515,20 +1569,15 @@ QString  WriteInitialization::writeSizePolicy(const DomSizePolicy *sp)
     const QString spName = m_driver->unique(QLatin1String("sizePolicy"));
     m_sizePolicyNameMap.insert(sizePolicyHandle, spName);
 
-    m_output << m_indent << "QSizePolicy " << spName;
-    do {
-        if (sp->hasElementHSizeType() && sp->hasElementVSizeType()) {
-            m_output << "(static_cast<QSizePolicy::Policy>(" << sp->elementHSizeType()
-                << "), static_cast<QSizePolicy::Policy>(" << sp->elementVSizeType() << "));\n";
-            break;
-        }
-        if (sp->hasAttributeHSizeType() && sp->hasAttributeVSizeType()) {
-                m_output << "(QSizePolicy::" << sp->attributeHSizeType() << ", QSizePolicy::"
-                << sp->attributeVSizeType() << ");\n";
-            break;
-        }
-        m_output << ";\n";
-    } while (false);
+    m_output << m_indent << language::stackVariableWithInitParameters("QSizePolicy", spName);
+    if (sp->hasElementHSizeType() && sp->hasElementVSizeType()) {
+        m_output << "QSizePolicy" << language::qualifier << language::sizePolicy(sp->elementHSizeType())
+            << ", QSizePolicy" << language::qualifier << language::sizePolicy(sp->elementVSizeType());
+    } else if (sp->hasAttributeHSizeType() && sp->hasAttributeVSizeType()) {
+        m_output << "QSizePolicy" << language::qualifier << sp->attributeHSizeType()
+            << ", QSizePolicy" << language::qualifier << sp->attributeVSizeType();
+    }
+    m_output << ')' << language::eol;
 
     m_output << m_indent << spName << ".setHorizontalStretch("
         << sp->elementHorStretch() << ");\n";
@@ -1552,10 +1601,11 @@ QString WriteInitialization::writeFontProperties(const DomFont *f)
     const QString fontName = m_driver->unique(QLatin1String("font"));
     m_fontPropertiesNameMap.insert(FontHandle(f), fontName);
 
-    m_output << m_indent << "QFont " << fontName << ";\n";
+    m_output << m_indent << language::stackVariable("QFont", fontName)
+        << language::eol;
     if (f->hasElementFamily() && !f->elementFamily().isEmpty()) {
-        m_output << m_indent << fontName << ".setFamily(QString::fromUtf8("
-                 << fixString(f->elementFamily(), m_dindent) << "));\n";
+        m_output << m_indent << fontName << ".setFamily("
+            << language::qstring(f->elementFamily(), m_dindent) << ");\n";
     }
     if (f->hasElementPointSize() && f->elementPointSize() > 0) {
          m_output << m_indent << fontName << ".setPointSize(" << f->elementPointSize()
@@ -1564,15 +1614,15 @@ QString WriteInitialization::writeFontProperties(const DomFont *f)
 
     if (f->hasElementBold()) {
         m_output << m_indent << fontName << ".setBold("
-            << (f->elementBold() ? "true" : "false") << ");\n";
+            << language::boolValue(f->elementBold()) << ')' << language::eol;
     }
     if (f->hasElementItalic()) {
         m_output << m_indent << fontName << ".setItalic("
-            <<  (f->elementItalic() ? "true" : "false") << ");\n";
+            << language::boolValue(f->elementItalic()) << ')' << language::eol;
     }
     if (f->hasElementUnderline()) {
         m_output << m_indent << fontName << ".setUnderline("
-            << (f->elementUnderline() ? "true" : "false") << ");\n";
+            << language::boolValue(f->elementUnderline()) << ')' << language::eol;
     }
     if (f->hasElementWeight() && f->elementWeight() > 0) {
         m_output << m_indent << fontName << ".setWeight("
@@ -1580,23 +1630,35 @@ QString WriteInitialization::writeFontProperties(const DomFont *f)
     }
     if (f->hasElementStrikeOut()) {
          m_output << m_indent << fontName << ".setStrikeOut("
-            << (f->elementStrikeOut() ? "true" : "false") << ");\n";
+            << language::boolValue(f->elementStrikeOut()) << ')' << language::eol;
     }
     if (f->hasElementKerning()) {
         m_output << m_indent << fontName << ".setKerning("
-            << (f->elementKerning() ? "true" : "false") << ");\n";
+            << language::boolValue(f->elementKerning()) << ')' << language::eol;
     }
     if (f->hasElementAntialiasing()) {
-        m_output << m_indent << fontName << ".setStyleStrategy("
-            << (f->elementAntialiasing() ? "QFont::PreferDefault" : "QFont::NoAntialias") << ");\n";
+        m_output << m_indent << fontName << ".setStyleStrategy(QFont"
+            << language::qualifier
+            << (f->elementAntialiasing() ? "PreferDefault" : "NoAntialias")
+            << ')' << language::eol;
     }
     if (f->hasElementStyleStrategy()) {
-         m_output << m_indent << fontName << ".setStyleStrategy(QFont::"
-            << f->elementStyleStrategy() << ");\n";
+         m_output << m_indent << fontName << ".setStyleStrategy(QFont"
+            << language::qualifier << f->elementStyleStrategy() << ')' << language::eol;
     }
     return  fontName;
 }
 
+static void writeIconAddFile(QTextStream &output, const QString &indent,
+                             const QString &iconName, const QString &fileName,
+                             const char *mode, const char *state)
+{
+    output << indent << iconName << ".addFile("
+        << language::qstring(fileName, indent) << ", QSize(), QIcon"
+        << language::qualifier << mode << ", QIcon" << language::qualifier
+        << state << ')' << language::eol;
+}
+
 // Post 4.4 write resource icon
 static void writeResourceIcon(QTextStream &output,
                               const QString &iconName,
@@ -1604,91 +1666,92 @@ static void writeResourceIcon(QTextStream &output,
                               const DomResourceIcon *i)
 {
     if (i->hasElementNormalOff()) {
-        output << indent << iconName << ".addFile(QString::fromUtf8("
-               << fixString(i->elementNormalOff()->text(), indent)
-               << "), QSize(), QIcon::Normal, QIcon::Off);\n";
+        writeIconAddFile(output, indent, iconName, i->elementNormalOff()->text(),
+                         "Normal", "Off");
     }
     if (i->hasElementNormalOn()) {
-        output << indent << iconName << ".addFile(QString::fromUtf8("
-               << fixString(i->elementNormalOn()->text(), indent)
-               << "), QSize(), QIcon::Normal, QIcon::On);\n";
+        writeIconAddFile(output, indent, iconName, i->elementNormalOn()->text(),
+                         "Normal", "On");
     }
     if (i->hasElementDisabledOff()) {
-        output << indent << iconName << ".addFile(QString::fromUtf8("
-               << fixString(i->elementDisabledOff()->text(), indent)
-               << "), QSize(), QIcon::Disabled, QIcon::Off);\n";
+        writeIconAddFile(output, indent, iconName, i->elementDisabledOff()->text(),
+                         "Disabled", "Off");
     }
     if (i->hasElementDisabledOn()) {
-        output << indent << iconName << ".addFile(QString::fromUtf8("
-               << fixString(i->elementDisabledOn()->text(), indent)
-               << "), QSize(), QIcon::Disabled, QIcon::On);\n";
+        writeIconAddFile(output, indent, iconName, i->elementDisabledOn()->text(),
+                         "Disabled", "On");
     }
     if (i->hasElementActiveOff()) {
-        output << indent << iconName << ".addFile(QString::fromUtf8("
-               << fixString(i->elementActiveOff()->text(), indent)
-               << "), QSize(), QIcon::Active, QIcon::Off);\n";
+        writeIconAddFile(output, indent, iconName, i->elementActiveOff()->text(),
+                         "Active", "Off");
     }
     if (i->hasElementActiveOn()) {
-        output << indent << iconName << ".addFile(QString::fromUtf8("
-               << fixString(i->elementActiveOn()->text(), indent)
-               << "), QSize(), QIcon::Active, QIcon::On);\n";
+        writeIconAddFile(output, indent, iconName, i->elementActiveOn()->text(),
+                         "Active", "On");
     }
     if (i->hasElementSelectedOff()) {
-        output << indent << iconName << ".addFile(QString::fromUtf8("
-               << fixString(i->elementSelectedOff()->text(), indent)
-               << "), QSize(), QIcon::Selected, QIcon::Off);\n";
+        writeIconAddFile(output, indent, iconName, i->elementSelectedOff()->text(),
+                         "Selected", "Off");
     }
     if (i->hasElementSelectedOn()) {
-        output << indent << iconName << ".addFile(QString::fromUtf8("
-               << fixString(i->elementSelectedOn()->text(), indent)
-               << "), QSize(), QIcon::Selected, QIcon::On);\n";
+        writeIconAddFile(output, indent, iconName, i->elementSelectedOff()->text(),
+                         "Selected", "On");
     }
 }
 
+static void writeIconAddPixmap(QTextStream &output, const QString &indent,
+                               const QString &iconName, const QString &call,
+                               const char *mode, const char *state)
+{
+    output << indent << iconName << ".addPixmap(" << call << ", QIcon"
+        << language::qualifier << mode << ", QIcon" << language::qualifier
+        << state << ')' << language::eol;
+}
+
 void WriteInitialization::writePixmapFunctionIcon(QTextStream &output,
                                                   const QString &iconName,
                                                   const QString &indent,
                                                   const DomResourceIcon *i) const
 {
     if (i->hasElementNormalOff()) {
-        output << indent << iconName << ".addPixmap("
-               << pixCall(QLatin1String("QPixmap"), i->elementNormalOff()->text())
-               << ", QIcon::Normal, QIcon::Off);\n";
+        writeIconAddPixmap(output, indent,  iconName,
+                           pixCall(QLatin1String("QPixmap"), i->elementNormalOff()->text()),
+                           "Normal", "Off");
     }
     if (i->hasElementNormalOn()) {
-        output << indent << iconName << ".addPixmap("
-               << pixCall(QLatin1String("QPixmap"), i->elementNormalOn()->text())
-               << ", QIcon::Normal, QIcon::On);\n";
+        writeIconAddPixmap(output, indent,  iconName,
+                           pixCall(QLatin1String("QPixmap"), i->elementNormalOn()->text()),
+                           "Normal", "On");
     }
     if (i->hasElementDisabledOff()) {
-        output << indent << iconName << ".addPixmap("
-               << pixCall(QLatin1String("QPixmap"), i->elementDisabledOff()->text())
-               << ", QIcon::Disabled, QIcon::Off);\n";
+        writeIconAddPixmap(output, indent,  iconName,
+                           pixCall(QLatin1String("QPixmap"), i->elementDisabledOff()->text()),
+                           "Disabled", "Off");
     }
     if (i->hasElementDisabledOn()) {
-        output << indent << iconName << ".addPixmap("
-               << pixCall(QLatin1String("QPixmap"), i->elementDisabledOn()->text())
-               << ", QIcon::Disabled, QIcon::On);\n";
+        writeIconAddPixmap(output, indent,  iconName,
+                           pixCall(QLatin1String("QPixmap"), i->elementDisabledOn()->text()),
+                           "Disabled", "On");
     }
     if (i->hasElementActiveOff()) {
-        output << indent << iconName << ".addPixmap("
-               << pixCall(QLatin1String("QPixmap"), i->elementActiveOff()->text())
-               << ", QIcon::Active, QIcon::Off);\n";
+        writeIconAddPixmap(output, indent,  iconName,
+                           pixCall(QLatin1String("QPixmap"), i->elementActiveOff()->text()),
+                           "Active", "Off");
     }
     if (i->hasElementActiveOn()) {
-        output << indent << iconName << ".addPixmap("
-               << pixCall(QLatin1String("QPixmap"), i->elementActiveOn()->text())
-               << ", QIcon::Active, QIcon::On);\n";
+        writeIconAddPixmap(output, indent,  iconName,
+                           pixCall(QLatin1String("QPixmap"), i->elementActiveOn()->text()),
+                           "Active", "On");
     }
     if (i->hasElementSelectedOff()) {
-        output << indent << iconName << ".addPixmap("
-               << pixCall(QLatin1String("QPixmap"), i->elementSelectedOff()->text())
-               << ", QIcon::Selected, QIcon::Off);\n";
+        writeIconAddPixmap(output, indent,  iconName,
+                           pixCall(QLatin1String("QPixmap"), i->elementSelectedOff()->text()),
+                           "Selected", "Off");
     }
     if (i->hasElementSelectedOn()) {
-        output << indent << iconName << ".addPixmap("
-               << pixCall(QLatin1String("QPixmap"), i->elementSelectedOn()->text())
-               << ", QIcon::Selected, QIcon::On);\n";
+        writeIconAddPixmap(output, indent,  iconName,
+                           pixCall(QLatin1String("QPixmap"), i->elementSelectedOn()->text()),
+                           "Selected", "On");
     }
 }
 
@@ -1714,7 +1777,6 @@ QString WriteInitialization::writeIconProperties(const DomResourceIcon *i)
                 writePixmapFunctionIcon(m_output, iconName, m_indent, i);
         } else {
             // Theme: Generate code to check the theme and default to resource
-            const QString themeIconName = fixString(i->attributeTheme(), QString());
             if (iconHasStatePixmaps(i)) {
                 // Theme + default state pixmaps:
                 // Generate code to check the theme and default to state pixmaps
@@ -1726,8 +1788,8 @@ QString WriteInitialization::writeIconProperties(const DomResourceIcon *i)
                     m_output << "QString ";
                     m_firstThemeIcon = false;
                 }
-                m_output << themeNameStringVariableC << " = QString::fromUtf8("
-                         << themeIconName << ");\n";
+                m_output << themeNameStringVariableC << " = "
+                    << language::qstring(i->attributeTheme()) << ";\n";
                 m_output << m_indent << "if (QIcon::hasThemeIcon("
                          << themeNameStringVariableC
                          << ")) {\n"
@@ -1740,9 +1802,8 @@ QString WriteInitialization::writeIconProperties(const DomResourceIcon *i)
                 m_output << m_indent << "}\n";
             } else {
                 // Theme, but no state pixmaps: Construct from theme directly.
-                m_output << m_indent << "QIcon " << iconName
-                         << "(QIcon::fromTheme(QString::fromUtf8("
-                         << themeIconName << ")));\n";
+                m_output << m_indent << "QIcon " << iconName << "(QIcon::fromTheme("
+                    << language::qstring(i->attributeTheme()) << "));\n";
             } // Theme, but not state
         }     // >= 4.4
     } else {  // pre-4.4 legacy
@@ -1765,6 +1826,13 @@ QString WriteInitialization::domColor2QString(const DomColor *c)
         .arg(c->elementBlue());
 }
 
+static inline QVersionNumber colorRoleVersionAdded(const QString &roleName)
+{
+    if (roleName == QLatin1String("PlaceholderText"))
+        return QVersionNumber(5, 12, 0);
+    return QVersionNumber();
+}
+
 void WriteInitialization::writeColorGroup(DomColorGroup *colorGroup, const QString &group, const QString &paletteName)
 {
     if (!colorGroup)
@@ -1776,7 +1844,7 @@ void WriteInitialization::writeColorGroup(DomColorGroup *colorGroup, const QStri
         const DomColor *color = colors.at(i);
 
         m_output << m_indent << paletteName << ".setColor(" << group
-            << ", " << "static_cast<QPalette::ColorRole>(" << QString::number(i) << ')'
+            << ", QPalette" << language::qualifier << language::paletteColorRole(i)
             << ", " << domColor2QString(color)
             << ");\n";
     }
@@ -1785,10 +1853,20 @@ void WriteInitialization::writeColorGroup(DomColorGroup *colorGroup, const QStri
     const auto &colorRoles = colorGroup->elementColorRole();
     for (const DomColorRole *colorRole : colorRoles) {
         if (colorRole->hasAttributeRole()) {
+            const QString roleName = colorRole->attributeRole();
+            const QVersionNumber versionAdded = colorRoleVersionAdded(roleName);
             const QString brushName = writeBrushInitialization(colorRole->elementBrush());
-            m_output << m_indent << paletteName << ".setBrush(" << group
-                << ", " << "QPalette::" << colorRole->attributeRole()
+            if (!versionAdded.isNull()) {
+                m_output << "#if QT_VERSION >= QT_VERSION_CHECK("
+                    << versionAdded.majorVersion() << ", " << versionAdded.minorVersion()
+                    << ", " << versionAdded.microVersion() << ")\n";
+            }
+            m_output << m_indent << paletteName << ".setBrush("
+                << language::enumValue(group) << ", "
+                << "QPalette" << language::qualifier << roleName
                 << ", " << brushName << ");\n";
+            if (!versionAdded.isNull())
+                m_output << "#endif\n";
         }
     }
 }
@@ -1877,10 +1955,10 @@ void WriteInitialization::writeBrush(const DomBrush *brush, const QString &brush
     } else {
         const DomColor *color = brush->elementColor();
         m_output << m_indent << "QBrush " << brushName << '('
-            << domColor2QString(color) << ");\n";
+            << domColor2QString(color) << ')' << language::eol;
 
         m_output << m_indent << brushName << ".setStyle("
-            << "Qt::" << style << ");\n";
+            << language::qtQualifier << style << ')' << language::eol;
     }
 }
 
@@ -1958,15 +2036,14 @@ QString WriteInitialization::pixCall(const QString &t, const QString &text) cons
         return type;
     }
 
+    QTextStream str(&type);
+    str << '(';
     QString pixFunc = m_uic->pixmapFunction();
     if (pixFunc.isEmpty())
-        pixFunc = QLatin1String("QString::fromUtf8");
-
-    type += QLatin1Char('(')
-          + pixFunc
-          + QLatin1Char('(')
-          + fixString(text, m_dindent)
-          + QLatin1String("))");
+        str << language::qstring(text, m_dindent);
+    else
+        str << pixFunc << '(' << language::charliteral(text, m_dindent) << ')';
+    str << ')';
     return type;
 }
 
@@ -1989,13 +2066,15 @@ void WriteInitialization::initializeComboBox(DomWidget *w)
         if (icon)
             iconValue = iconCall(icon);
 
-        m_output << m_indent << varName << "->addItem(";
+        m_output << m_indent << varName << language::derefPointer << "addItem(";
         if (icon)
             m_output << iconValue << ", ";
 
         if (needsTranslation(text->elementString())) {
             m_output << "QString());\n";
-            m_refreshOut << m_indent << varName << "->setItemText(" << i << ", " << trCall(text->elementString()) << ");\n";
+            m_refreshOut << m_indent << varName << language::derefPointer
+                << "setItemText(" << i << ", " << trCall(text->elementString())
+                << ')' << language::eol;
         } else {
             m_output << noTrCall(text->elementString()) << ");\n";
         }
@@ -2010,9 +2089,13 @@ QString WriteInitialization::disableSorting(DomWidget *w, const QString &varName
     if (!w->elementItem().isEmpty()) {
         tempName = m_driver->unique(QLatin1String("__sortingEnabled"));
         m_refreshOut << "\n";
-        m_refreshOut << m_indent << "const bool " << tempName
-            << " = " << varName << "->isSortingEnabled();\n";
-        m_refreshOut << m_indent << varName << "->setSortingEnabled(false);\n";
+        m_refreshOut << m_indent;
+        if (language::language() == Language::Cpp)
+            m_refreshOut << "const bool ";
+        m_refreshOut << tempName << " = " << varName << language::derefPointer
+            << "isSortingEnabled()" << language::eol
+            << m_indent << varName << language::derefPointer
+            << "setSortingEnabled(" << language::boolValue(false) << ')' << language::eol;
     }
     return tempName;
 }
@@ -2020,7 +2103,8 @@ QString WriteInitialization::disableSorting(DomWidget *w, const QString &varName
 void WriteInitialization::enableSorting(DomWidget *w, const QString &varName, const QString &tempName)
 {
     if (!w->elementItem().isEmpty()) {
-        m_refreshOut << m_indent << varName << "->setSortingEnabled(" << tempName << ");\n\n";
+        m_refreshOut << m_indent << varName << language::derefPointer
+            << "setSortingEnabled(" << tempName << ')' << language::eol << '\n';
     }
 }
 
@@ -2042,10 +2126,15 @@ void WriteInitialization::enableSorting(DomWidget *w, const QString &varName, co
 void WriteInitialization::addInitializer(Item *item,
         const QString &name, int column, const QString &value, const QString &directive, bool translatable) const
 {
-    if (!value.isEmpty())
-        item->addSetter(QLatin1String("->set") + name.at(0).toUpper() + name.midRef(1) +
-                    QLatin1Char('(') + (column < 0 ? QString() : QString::number(column) +
-                    QLatin1String(", ")) + value + QLatin1String(");"), directive, translatable);
+    if (!value.isEmpty()) {
+        QString setter;
+        QTextStream str(&setter);
+        str << language::derefPointer << "set" << name.at(0).toUpper() << name.midRef(1) << '(';
+        if (column >= 0)
+            str << column << ", ";
+        str << value << ");";
+        item->addSetter(setter, directive, translatable);
+    }
 }
 
 /*!
@@ -2090,10 +2179,11 @@ void WriteInitialization::addQtFlagsInitializer(Item *item,
         const DomPropertyMap &properties, const QString &name, int column) const
 {
     if (const DomProperty *p = properties.value(name)) {
+        const QString orOperator = QLatin1Char('|') + language::qtQualifier;
         QString v = p->elementSet();
         if (!v.isEmpty()) {
-            v.replace(QLatin1Char('|'), QLatin1String("|Qt::"));
-            addInitializer(item, name, column, QLatin1String("Qt::") + v);
+            v.replace(QLatin1Char('|'), orOperator);
+            addInitializer(item, name, column, language::qtQualifier + v);
         }
     }
 }
@@ -2108,7 +2198,7 @@ void WriteInitialization::addQtEnumInitializer(Item *item,
     if (const DomProperty *p = properties.value(name)) {
         QString v = p->elementEnum();
         if (!v.isEmpty())
-            addInitializer(item, name, column, QLatin1String("Qt::") + v);
+            addInitializer(item, name, column, language::qtQualifier + v);
     }
 }
 
@@ -2127,9 +2217,12 @@ void WriteInitialization::addCommonInitializers(Item *item,
     addQtFlagsInitializer(item, properties, QLatin1String("textAlignment"), column);
     addQtEnumInitializer(item, properties, QLatin1String("checkState"), column);
     addStringInitializer(item, properties, QLatin1String("text"), column);
-    addStringInitializer(item, properties, QLatin1String("toolTip"), column, QLatin1String(toolTipDefineC));
-    addStringInitializer(item, properties, QLatin1String("whatsThis"), column, QLatin1String(whatsThisDefineC));
-    addStringInitializer(item, properties, QLatin1String("statusTip"), column, QLatin1String(statusTipDefineC));
+    addStringInitializer(item, properties, QLatin1String("toolTip"), column,
+                         toolTipConfigKey());
+    addStringInitializer(item, properties, QLatin1String("whatsThis"), column,
+                         whatsThisConfigKey());
+    addStringInitializer(item, properties, QLatin1String("statusTip"), column,
+                         statusTipConfigKey());
 }
 
 void WriteInitialization::initializeListWidget(DomWidget *w)
@@ -2154,7 +2247,9 @@ void WriteInitialization::initializeListWidget(DomWidget *w)
         addCommonInitializers(&item, properties);
 
         item.writeSetupUi(varName);
-        item.writeRetranslateUi(varName + QLatin1String("->item(") + QString::number(i) + QLatin1Char(')'));
+        QString parentPath;
+        QTextStream(&parentPath) << varName << language::derefPointer << "item(" << i << ')';
+        item.writeRetranslateUi(parentPath);
     }
     enableSorting(w, varName, tempName);
 }
@@ -2175,14 +2270,19 @@ void WriteInitialization::initializeTreeWidget(DomWidget *w)
 
         if (const DomProperty *p = properties.value(QLatin1String("text"))) {
             DomString *str = p->elementString();
-            if (str && str->text().isEmpty())
-                m_output << m_indent << varName << "->headerItem()->setText(" << i << ", QString());\n";
+            if (str && str->text().isEmpty()) {
+                m_output << m_indent << varName << language::derefPointer
+                    << "headerItem()" << language::derefPointer << "setText("
+                    << i << ", QString())" << language::eol;
+            }
         }
     }
     const QString itemName = item.writeSetupUi(QString(), Item::DontConstruct);
-    item.writeRetranslateUi(varName + QLatin1String("->headerItem()"));
-    if (!itemName.isNull())
-        m_output << m_indent << varName << "->setHeaderItem(" << itemName << ");\n";
+    item.writeRetranslateUi(varName + language::derefPointer + QLatin1String("headerItem()"));
+    if (!itemName.isNull()) {
+        m_output << m_indent << varName << language::derefPointer
+            << "setHeaderItem(" << itemName << ')' << language::eol;
+    }
 
     if (w->elementItem().empty())
         return;
@@ -2193,7 +2293,9 @@ void WriteInitialization::initializeTreeWidget(DomWidget *w)
     for (int i = 0; i < items.count(); i++) {
         Item *itm = items[i];
         itm->writeSetupUi(varName);
-        itm->writeRetranslateUi(varName + QLatin1String("->topLevelItem(") + QString::number(i) + QLatin1Char(')'));
+        QString parentPath;
+        QTextStream(&parentPath) << varName << language::derefPointer << "topLevelItem(" << i << ')';
+        itm->writeRetranslateUi(parentPath);
         delete itm;
     }
 
@@ -2255,8 +2357,10 @@ void WriteInitialization::initializeTableWidget(DomWidget *w)
     const auto &columns = w->elementColumn();
 
     if (!columns.empty()) {
-        m_output << m_indent << "if (" << varName << "->columnCount() < " << columns.size() << ")\n"
-            << m_dindent << varName << "->setColumnCount(" << columns.size() << ");\n";
+        m_output << m_indent << "if (" << varName << language::derefPointer << "columnCount() < "
+            << columns.size() << ")\n"
+            << m_dindent << varName << language::derefPointer << "setColumnCount("
+            << columns.size() << ')' << language::eol;
     }
 
     for (int i = 0; i < columns.size(); ++i) {
@@ -2268,8 +2372,12 @@ void WriteInitialization::initializeTableWidget(DomWidget *w)
             addCommonInitializers(&item, properties);
 
             QString itemName = item.writeSetupUi(QString(), Item::ConstructItemAndVariable);
-            item.writeRetranslateUi(varName + QLatin1String("->horizontalHeaderItem(") + QString::number(i) + QLatin1Char(')'));
-            m_output << m_indent << varName << "->setHorizontalHeaderItem(" << QString::number(i) << ", " << itemName << ");\n";
+            QString parentPath;
+            QTextStream(&parentPath) << varName << language::derefPointer
+                << "horizontalHeaderItem(" << i << ')';
+            item.writeRetranslateUi(parentPath);
+            m_output << m_indent << varName << language::derefPointer << "setHorizontalHeaderItem("
+                << i << ", " << itemName << ')' << language::eol;
         }
     }
 
@@ -2277,8 +2385,9 @@ void WriteInitialization::initializeTableWidget(DomWidget *w)
     const auto &rows = w->elementRow();
 
     if (!rows.isEmpty()) {
-        m_output << m_indent << "if (" << varName << "->rowCount() < " << rows.size() << ")\n"
-            << m_dindent << varName << "->setRowCount(" << rows.size() << ");\n";
+        m_output << m_indent << "if (" << varName << language::derefPointer << "rowCount() < " << rows.size() << ")\n"
+            << m_dindent << varName << language::derefPointer << "setRowCount("
+            << rows.size() << ')' << language::eol;
     }
 
     for (int i = 0; i < rows.size(); ++i) {
@@ -2290,8 +2399,11 @@ void WriteInitialization::initializeTableWidget(DomWidget *w)
             addCommonInitializers(&item, properties);
 
             QString itemName = item.writeSetupUi(QString(), Item::ConstructItemAndVariable);
-            item.writeRetranslateUi(varName + QLatin1String("->verticalHeaderItem(") + QString::number(i) + QLatin1Char(')'));
-            m_output << m_indent << varName << "->setVerticalHeaderItem(" << QString::number(i) << ", " << itemName << ");\n";
+            QString parentPath;
+            QTextStream(&parentPath) << varName << language::derefPointer << "verticalHeaderItem(" << i << ')';
+            item.writeRetranslateUi(parentPath);
+            m_output << m_indent << varName << language::derefPointer << "setVerticalHeaderItem("
+                << i << ", " << itemName << ')' << language::eol;
         }
     }
 
@@ -2311,8 +2423,12 @@ void WriteInitialization::initializeTableWidget(DomWidget *w)
             addCommonInitializers(&item, properties);
 
             QString itemName = item.writeSetupUi(QString(), Item::ConstructItemAndVariable);
-            item.writeRetranslateUi(varName + QLatin1String("->item(") + QString::number(r) + QLatin1String(", ") + QString::number(c) + QLatin1Char(')'));
-            m_output << m_indent << varName << "->setItem(" << QString::number(r) << ", " << QString::number(c) << ", " << itemName << ");\n";
+            QString parentPath;
+            QTextStream(&parentPath) << varName << language::derefPointer << "item(" << r
+                << ", " << c << ')';
+            item.writeRetranslateUi(parentPath);
+            m_output << m_indent << varName << language::derefPointer << "setItem("
+                << r << ", " << c << ", " << itemName << ')' << language::eol;
         }
     }
     enableSorting(w, varName, tempName);
@@ -2324,28 +2440,31 @@ QString WriteInitialization::trCall(const QString &str, const QString &commentHi
         return QLatin1String("QString()");
 
     QString result;
-    const QString comment = commentHint.isEmpty() ? QString(QLatin1String("nullptr")) : fixString(commentHint, m_dindent);
+    QTextStream ts(&result);
 
     const bool idBasedTranslations = m_driver->useIdBasedTranslations();
     if (m_option.translateFunction.isEmpty()) {
         if (idBasedTranslations || m_option.idBased) {
-            result += QLatin1String("qtTrId(");
+            ts << "qtTrId(";
         } else {
-            result += QLatin1String("QApplication::translate(\"")
-                    + m_generatedClass
-                    + QLatin1String("\", ");
+            ts << "QCoreApplication" << language::qualifier << "translate("
+                << '"' << m_generatedClass << "\", ";
         }
     } else {
-        result += m_option.translateFunction + QLatin1Char('(');
+        ts << m_option.translateFunction << '(';
     }
 
-    result += fixString(idBasedTranslations ? id : str, m_dindent);
+    ts << language::charliteral(idBasedTranslations ? id : str, m_dindent);
 
     if (!idBasedTranslations && !m_option.idBased) {
-        result += QLatin1String(", ") + comment;
+        ts << ", ";
+        if (commentHint.isEmpty())
+            ts << language::nullPtr;
+        else
+            ts << language::charliteral(commentHint, m_dindent);
     }
 
-    result += QLatin1Char(')');
+    ts << ')';
     return result;
 }
 
@@ -2356,7 +2475,8 @@ void WriteInitialization::initializeMenu(DomWidget *w, const QString &/*parentWi
 
     const DomAction *action = m_driver->actionByName(menuAction);
     if (action && action->hasAttributeMenu()) {
-        m_output << m_indent << menuAction << " = " << menuName << "->menuAction();\n";
+        m_output << m_indent << menuAction << " = " << menuName
+            << language::derefPointer << "menuAction()" << language::eol;
     }
 }
 
@@ -2380,9 +2500,9 @@ QString WriteInitialization::noTrCall(DomString *str, const QString &defaultStri
         return QString();
     if (str)
         value = str->text();
-    QString ret = QLatin1String("QString::fromUtf8(");
-    ret += fixString(value, m_dindent);
-    ret += QLatin1Char(')');
+    QString ret;
+    QTextStream ts(&ret);
+    ts << language::qstring(value, m_dindent);
     return ret;
 }
 
@@ -2410,54 +2530,42 @@ QTextStream &WriteInitialization::autoTrOutput(const DomString *str, const QStri
     return m_output;
 }
 
-bool WriteInitialization::isValidObject(const QString &name) const
-{
-    return m_registeredWidgets.contains(name)
-        || m_registeredActions.contains(name);
-}
-
-QString WriteInitialization::findDeclaration(const QString &name)
+WriteInitialization::Declaration WriteInitialization::findDeclaration(const QString &name)
 {
-    const QString normalized = Driver::normalizedName(name);
-
-    if (DomWidget *widget = m_driver->widgetByName(normalized))
-        return m_driver->findOrInsertWidget(widget);
-    if (DomAction *action = m_driver->actionByName(normalized))
-        return m_driver->findOrInsertAction(action);
-    if (const DomButtonGroup *group = m_driver->findButtonGroup(normalized))
-        return m_driver->findOrInsertButtonGroup(group);
-    return QString();
+    if (const DomWidget *widget = m_driver->widgetByName(name))
+        return {m_driver->findOrInsertWidget(widget), widget->attributeClass()};
+    if (const DomAction *action = m_driver->actionByName(name))
+        return {m_driver->findOrInsertAction(action), QStringLiteral("QAction")};
+    if (const DomButtonGroup *group = m_driver->findButtonGroup(name))
+         return {m_driver->findOrInsertButtonGroup(group), QStringLiteral("QButtonGroup")};
+    return {};
 }
 
 void WriteInitialization::acceptConnection(DomConnection *connection)
 {
-    const QString sender = findDeclaration(connection->elementSender());
-    const QString receiver = findDeclaration(connection->elementReceiver());
-
-    if (sender.isEmpty() || receiver.isEmpty())
-        return;
+    const QString senderName = connection->elementSender();
+    const QString receiverName = connection->elementReceiver();
 
-    m_output << m_indent << "QObject::connect("
-        << sender
-        << ", "
-        << "SIGNAL("<<connection->elementSignal()<<')'
-        << ", "
-        << receiver
-        << ", "
-        << "SLOT("<<connection->elementSlot()<<')'
-        << ");\n";
-}
-
-DomWidget *WriteInitialization::findWidget(QLatin1String widgetClass)
-{
-    for (int i = m_widgetChain.count() - 1; i >= 0; --i) {
-        DomWidget *widget = m_widgetChain.at(i);
+    const auto senderDecl = findDeclaration(senderName);
+    const auto receiverDecl = findDeclaration(receiverName);
 
-        if (widget && m_uic->customWidgetsInfo()->extends(widget->attributeClass(), widgetClass))
-            return widget;
+    if (senderDecl.name.isEmpty() || receiverDecl.name.isEmpty()) {
+        QString message;
+        QTextStream(&message) << m_option.messagePrefix()
+            << ": Warning: Invalid signal/slot connection: \""
+            << senderName << "\" -> \"" << receiverName << "\".";
+        fprintf(stderr, "%s\n", qPrintable(message));
+        return;
     }
 
-    return 0;
+    language::SignalSlot theSignal{senderDecl.name, connection->elementSignal(),
+                                   senderDecl.className};
+    language::SignalSlot theSlot{receiverDecl.name, connection->elementSlot(),
+                                 receiverDecl.className};
+
+    m_output << m_indent;
+    language::formatConnection(m_output, theSignal, theSlot);
+    m_output << ";\n";
 }
 
 static void generateMultiDirectiveBegin(QTextStream &outputStream, const QSet<QString> &directives)
@@ -2466,7 +2574,7 @@ static void generateMultiDirectiveBegin(QTextStream &outputStream, const QSet<QS
         return;
 
     if (directives.size() == 1) {
-        outputStream << "#ifndef " << *directives.cbegin() << endl;
+        outputStream << language::openQtConfig(*directives.cbegin());
         return;
     }
 
@@ -2474,7 +2582,10 @@ static void generateMultiDirectiveBegin(QTextStream &outputStream, const QSet<QS
     // sort (always generate in the same order):
     std::sort(list.begin(), list.end());
 
-    outputStream << "#if !defined(" << list.join(QLatin1String(") || !defined(")) << ')' << endl;
+    outputStream << "#if " << language::qtConfig(list.constFirst());
+    for (int i = 1, size = list.size(); i < size; ++i)
+        outputStream << " || " << language::qtConfig(list.at(i));
+    outputStream << endl;
 }
 
 static void generateMultiDirectiveEnd(QTextStream &outputStream, const QSet<QString> &directives)
@@ -2510,7 +2621,8 @@ QString WriteInitialization::Item::writeSetupUi(const QString &parent, Item::Emp
     bool generateMultiDirective = false;
     if (emptyItemPolicy == Item::ConstructItemOnly && m_children.isEmpty()) {
         if (m_setupUiData.policy == ItemData::DontGenerate) {
-            m_setupUiStream << m_indent << "new " << m_itemClassName << '(' << parent << ");\n";
+            m_setupUiStream << m_indent << language::operatorNew << m_itemClassName
+                << '(' << parent << ')' << language::eol;
             return QString();
         }
         if (m_setupUiData.policy == ItemData::GenerateWithMultiDirective)
@@ -2521,19 +2633,27 @@ QString WriteInitialization::Item::writeSetupUi(const QString &parent, Item::Emp
         generateMultiDirectiveBegin(m_setupUiStream, m_setupUiData.directives);
 
     const QString uniqueName = m_driver->unique(QLatin1String("__") + m_itemClassName.toLower());
-    m_setupUiStream << m_indent << m_itemClassName << " *" << uniqueName << " = new " << m_itemClassName << '(' << parent << ");\n";
+    m_setupUiStream << m_indent;
+    if (language::language() == Language::Cpp)
+        m_setupUiStream << m_itemClassName << " *";
+    m_setupUiStream << uniqueName
+        << " = " << language::operatorNew << m_itemClassName << '(' << parent
+        << ')' << language::eol;
 
     if (generateMultiDirective) {
         m_setupUiStream << "#else\n";
-        m_setupUiStream << m_indent << "new " << m_itemClassName << '(' << parent << ");\n";
+        m_setupUiStream << m_indent << language::operatorNew << m_itemClassName
+            << '(' << parent << ')' << language::eol;
         generateMultiDirectiveEnd(m_setupUiStream, m_setupUiData.directives);
     }
 
     QMultiMap<QString, QString>::ConstIterator it = m_setupUiData.setters.constBegin();
     while (it != m_setupUiData.setters.constEnd()) {
-        openIfndef(m_setupUiStream, it.key());
+        if (!it.key().isEmpty())
+            m_setupUiStream << language::openQtConfig(it.key());
         m_setupUiStream << m_indent << uniqueName << it.value() << endl;
-        closeIfndef(m_setupUiStream, it.key());
+        if (!it.key().isEmpty())
+            m_setupUiStream << language::closeQtConfig(it.key());
         ++it;
     }
     for (Item *child : qAsConst(m_children))
@@ -2550,7 +2670,10 @@ void WriteInitialization::Item::writeRetranslateUi(const QString &parentPath)
         generateMultiDirectiveBegin(m_retranslateUiStream, m_retranslateUiData.directives);
 
     const QString uniqueName = m_driver->unique(QLatin1String("___") + m_itemClassName.toLower());
-    m_retranslateUiStream << m_indent << m_itemClassName << " *" << uniqueName << " = " << parentPath << ";\n";
+    m_retranslateUiStream << m_indent;
+    if (language::language() == Language::Cpp)
+        m_retranslateUiStream << m_itemClassName << " *";
+    m_retranslateUiStream << uniqueName << " = " << parentPath << language::eol;
 
     if (m_retranslateUiData.policy == ItemData::GenerateWithMultiDirective)
         generateMultiDirectiveEnd(m_retranslateUiStream, m_retranslateUiData.directives);
@@ -2560,17 +2683,23 @@ void WriteInitialization::Item::writeRetranslateUi(const QString &parentPath)
     while (it != m_retranslateUiData.setters.constEnd()) {
         const QString newDirective = it.key();
         if (oldDirective != newDirective) {
-            closeIfndef(m_retranslateUiStream, oldDirective);
-            openIfndef(m_retranslateUiStream, newDirective);
+            if (!oldDirective.isEmpty())
+                m_retranslateUiStream << language::closeQtConfig(oldDirective);
+            if (!newDirective.isEmpty())
+                m_retranslateUiStream << language::openQtConfig(newDirective);
             oldDirective = newDirective;
         }
         m_retranslateUiStream << m_indent << uniqueName << it.value() << endl;
         ++it;
     }
-    closeIfndef(m_retranslateUiStream, oldDirective);
+    if (!oldDirective.isEmpty())
+        m_retranslateUiStream << language::closeQtConfig(oldDirective);
 
-    for (int i = 0; i < m_children.size(); i++)
-        m_children[i]->writeRetranslateUi(uniqueName + QLatin1String("->child(") + QString::number(i) + QLatin1Char(')'));
+    for (int i = 0; i < m_children.size(); i++) {
+        QString method;
+        QTextStream(&method) << uniqueName << language::derefPointer << "child(" << i << ')';
+        m_children[i]->writeRetranslateUi(method);
+    }
 }
 
 void WriteInitialization::Item::addSetter(const QString &setter, const QString &directive, bool translatable)
diff --git a/src/tools/uic/cpp/cppwriteinitialization.h b/src/tools/uic/cpp/cppwriteinitialization.h
index cce83bd677..b90ffe00a7 100644
--- a/src/tools/uic/cpp/cppwriteinitialization.h
+++ b/src/tools/uic/cpp/cppwriteinitialization.h
@@ -174,8 +174,6 @@ private:
         void writeRetranslateUi(const QString &parentPath);
         void addSetter(const QString &setter, const QString &directive = QString(), bool translatable = false); // don't call it if you already added *this as a child of another Item
         void addChild(Item *child); // all setters should already been added
-        int setupUiCount() const { return m_setupUiData.setters.count(); }
-        int retranslateUiCount() const { return m_retranslateUiData.setters.count(); }
     private:
         struct ItemData
         {
@@ -222,10 +220,13 @@ private:
     QString disableSorting(DomWidget *w, const QString &varName);
     void enableSorting(DomWidget *w, const QString &varName, const QString &tempName);
 
-    QString findDeclaration(const QString &name);
-    DomWidget *findWidget(QLatin1String widgetClass);
+    struct Declaration
+    {
+        QString name;
+        QString className;
+    };
 
-    bool isValidObject(const QString &name) const;
+    Declaration findDeclaration(const QString &name);
 
 private:
     QString writeFontProperties(const DomFont *f);
diff --git a/src/tools/uic/customwidgetsinfo.cpp b/src/tools/uic/customwidgetsinfo.cpp
index 0ac0c2b6a3..d6a409152b 100644
--- a/src/tools/uic/customwidgetsinfo.cpp
+++ b/src/tools/uic/customwidgetsinfo.cpp
@@ -31,6 +31,8 @@
 #include "ui4.h"
 #include "utils.h"
 
+#include <utility>
+
 QT_BEGIN_NAMESPACE
 
 CustomWidgetsInfo::CustomWidgetsInfo() = default;
@@ -73,6 +75,24 @@ bool CustomWidgetsInfo::extends(const QString &classNameIn, QLatin1String baseCl
     return false;
 }
 
+bool CustomWidgetsInfo::extendsOneOf(const QString &classNameIn,
+                                     const QStringList &baseClassNames) const
+{
+    if (baseClassNames.contains(classNameIn))
+        return true;
+
+    QString className = classNameIn;
+    while (const DomCustomWidget *c = customWidget(className)) {
+        const QString extends = c->elementExtends();
+        if (className == extends) // Faulty legacy custom widget entries exist.
+            return false;
+        if (baseClassNames.contains(extends))
+            return true;
+        className = extends;
+    }
+    return false;
+}
+
 bool CustomWidgetsInfo::isCustomWidgetContainer(const QString &className) const
 {
     if (const DomCustomWidget *dcw = m_customWidgets.value(className, 0))
@@ -96,5 +116,24 @@ QString CustomWidgetsInfo::customWidgetAddPageMethod(const QString &name) const
     return QString();
 }
 
+// add page methods for simple containers taking only the widget parameter
+QString CustomWidgetsInfo::simpleContainerAddPageMethod(const QString &name) const
+{
+    using AddPageMethod = std::pair<const char *, const char *>;
+
+    static AddPageMethod addPageMethods[] = {
+        {"QStackedWidget", "addWidget"},
+        {"QToolBar", "addWidget"},
+        {"QDockWidget", "setWidget"},
+        {"QScrollArea", "setWidget"},
+        {"QSplitter", "addWidget"},
+        {"QMdiArea", "addSubWindow"}
+    };
+    for (const auto &m : addPageMethods) {
+        if (extends(name, QLatin1String(m.first)))
+            return QLatin1String(m.second);
+    }
+    return QString();
+}
 
 QT_END_NAMESPACE
diff --git a/src/tools/uic/customwidgetsinfo.h b/src/tools/uic/customwidgetsinfo.h
index 944ed59215..8a10999027 100644
--- a/src/tools/uic/customwidgetsinfo.h
+++ b/src/tools/uic/customwidgetsinfo.h
@@ -48,20 +48,16 @@ public:
     void acceptCustomWidgets(DomCustomWidgets *node) override;
     void acceptCustomWidget(DomCustomWidget *node) override;
 
-    inline QStringList customWidgets() const
-    { return m_customWidgets.keys(); }
-
-    inline bool hasCustomWidget(const QString &name) const
-    { return m_customWidgets.contains(name); }
-
     inline DomCustomWidget *customWidget(const QString &name) const
     { return m_customWidgets.value(name); }
 
     QString customWidgetAddPageMethod(const QString &name) const;
+    QString simpleContainerAddPageMethod(const QString &name) const;
 
     QString realClassName(const QString &className) const;
 
     bool extends(const QString &className, QLatin1String baseClassName) const;
+    bool extendsOneOf(const QString &className, const QStringList &baseClassNames) const;
 
     bool isCustomWidgetContainer(const QString &className) const;
 
diff --git a/src/tools/uic/databaseinfo.h b/src/tools/uic/databaseinfo.h
index bebf139c5a..4015e39dbc 100644
--- a/src/tools/uic/databaseinfo.h
+++ b/src/tools/uic/databaseinfo.h
@@ -48,12 +48,6 @@ public:
     inline QStringList connections() const
     { return m_connections; }
 
-    inline QStringList cursors(const QString &connection) const
-    { return m_cursors.value(connection); }
-
-    inline QStringList fields(const QString &connection) const
-    { return m_fields.value(connection); }
-
 private:
     QStringList m_connections;
     QMap<QString, QStringList> m_cursors;
diff --git a/src/tools/uic/driver.cpp b/src/tools/uic/driver.cpp
index 6b3a6f8f69..a0812932ce 100644
--- a/src/tools/uic/driver.cpp
+++ b/src/tools/uic/driver.cpp
@@ -30,9 +30,13 @@
 #include "uic.h"
 #include "ui4.h"
 
+#include <language.h>
+
 #include <qfileinfo.h>
 #include <qdebug.h>
 
+#include <algorithm>
+
 QT_BEGIN_NAMESPACE
 
 Driver::Driver()
@@ -43,39 +47,52 @@ Driver::Driver()
 
 Driver::~Driver() = default;
 
-QString Driver::findOrInsertWidget(DomWidget *ui_widget)
-{
-    if (!m_widgets.contains(ui_widget))
-        m_widgets.insert(ui_widget, unique(ui_widget->attributeName(), ui_widget->attributeClass()));
+static inline QString spacerItemClass()  { return QStringLiteral("QSpacerItem"); }
+static inline QString actionGroupClass() { return QStringLiteral("QActionGroup"); }
+static inline QString actionClass()      { return QStringLiteral("QAction"); }
+static inline QString buttonGroupClass() { return QStringLiteral("QButtonGroup"); }
 
-    return m_widgets.value(ui_widget);
+template <class DomClass>
+const DomClass *Driver::findByAttributeName(const DomObjectHash<DomClass> &domHash,
+                                            const QString &name) const
+{
+    for (auto it = domHash.cbegin(), end = domHash.cend(); it != end; ++it) {
+        if (it.key()->attributeName() == name)
+            return it.key();
+   }
+    return nullptr;
 }
 
-QString Driver::findOrInsertSpacer(DomSpacer *ui_spacer)
+template <class DomClass>
+QString Driver::findOrInsert(DomObjectHash<DomClass> *domHash, const DomClass *dom,
+                             const QString &className, bool isMember)
 {
-    if (!m_spacers.contains(ui_spacer)) {
-        QString name;
-        if (ui_spacer->hasAttributeName())
-            name = ui_spacer->attributeName();
-        m_spacers.insert(ui_spacer, unique(name, QLatin1String("QSpacerItem")));
+    auto it = domHash->find(dom);
+    if (it == domHash->end()) {
+        const QString name = this->unique(dom->attributeName(), className);
+        it = domHash->insert(dom, isMember ? language::self + name : name);
     }
+    return it.value();
+}
 
-    return m_spacers.value(ui_spacer);
+QString Driver::findOrInsertWidget(const DomWidget *ui_widget)
+{
+    // Top level is passed into setupUI(), everything else is a member variable
+    const bool isMember = !m_widgets.isEmpty();
+    return findOrInsert(&m_widgets, ui_widget, ui_widget->attributeClass(), isMember);
 }
 
-QString Driver::findOrInsertLayout(DomLayout *ui_layout)
+QString Driver::findOrInsertSpacer(const DomSpacer *ui_spacer)
 {
-    if (!m_layouts.contains(ui_layout)) {
-        QString name;
-        if (ui_layout->hasAttributeName())
-            name = ui_layout->attributeName();
-        m_layouts.insert(ui_layout, unique(name, ui_layout->attributeClass()));
-    }
+    return findOrInsert(&m_spacers, ui_spacer, spacerItemClass());
+}
 
-    return m_layouts.value(ui_layout);
+QString Driver::findOrInsertLayout(const DomLayout *ui_layout)
+{
+    return findOrInsert(&m_layouts, ui_layout, ui_layout->attributeClass());
 }
 
-QString Driver::findOrInsertLayoutItem(DomLayoutItem *ui_layoutItem)
+QString Driver::findOrInsertLayoutItem(const DomLayoutItem *ui_layoutItem)
 {
     switch (ui_layoutItem->kind()) {
         case DomLayoutItem::Widget:
@@ -93,38 +110,25 @@ QString Driver::findOrInsertLayoutItem(DomLayoutItem *ui_layoutItem)
     return QString();
 }
 
-QString Driver::findOrInsertActionGroup(DomActionGroup *ui_group)
+QString Driver::findOrInsertActionGroup(const DomActionGroup *ui_group)
 {
-    if (!m_actionGroups.contains(ui_group))
-        m_actionGroups.insert(ui_group, unique(ui_group->attributeName(), QLatin1String("QActionGroup")));
-
-    return m_actionGroups.value(ui_group);
+    return findOrInsert(&m_actionGroups, ui_group, actionGroupClass());
 }
 
-QString Driver::findOrInsertAction(DomAction *ui_action)
+QString Driver::findOrInsertAction(const DomAction *ui_action)
 {
-    if (!m_actions.contains(ui_action))
-        m_actions.insert(ui_action, unique(ui_action->attributeName(), QLatin1String("QAction")));
-
-    return m_actions.value(ui_action);
+    return findOrInsert(&m_actions, ui_action, actionClass());
 }
 
 QString Driver::findOrInsertButtonGroup(const DomButtonGroup *ui_group)
 {
-    ButtonGroupNameHash::iterator it = m_buttonGroups.find(ui_group);
-    if (it == m_buttonGroups.end())
-        it = m_buttonGroups.insert(ui_group, unique(ui_group->attributeName(), QLatin1String("QButtonGroup")));
-    return it.value();
+    return findOrInsert(&m_buttonGroups, ui_group, buttonGroupClass());
 }
 
 // Find a group by its non-uniqified name
 const DomButtonGroup *Driver::findButtonGroup(const QString &attributeName) const
 {
-    const ButtonGroupNameHash::const_iterator cend = m_buttonGroups.constEnd();
-    for (ButtonGroupNameHash::const_iterator it = m_buttonGroups.constBegin(); it != cend; ++it)
-        if (it.key()->attributeName() == attributeName)
-            return it.key();
-    return 0;
+    return findByAttributeName(m_buttonGroups, attributeName);
 }
 
 
@@ -136,11 +140,9 @@ QString Driver::findOrInsertName(const QString &name)
 QString Driver::normalizedName(const QString &name)
 {
     QString result = name;
-    QChar *data = result.data();
-    for (int i = name.size(); --i >= 0; ++data) {
-        if (!data->isLetterOrNumber())
-            *data = QLatin1Char('_');
-    }
+    std::replace_if(result.begin(), result.end(),
+                    [] (QChar c) { return !c.isLetterOrNumber(); },
+                    QLatin1Char('_'));
     return result;
 }
 
@@ -149,23 +151,21 @@ QString Driver::unique(const QString &instanceName, const QString &className)
     QString name;
     bool alreadyUsed = false;
 
-    if (instanceName.size()) {
-        int id = 1;
-        name = instanceName;
-        name = normalizedName(name);
+    if (!instanceName.isEmpty()) {
+        name = normalizedName(instanceName);
         QString base = name;
 
-        while (m_nameRepository.contains(name)) {
+        for (int id = 1; m_nameRepository.contains(name); ++id) {
             alreadyUsed = true;
-            name = base + QString::number(id++);
+            name = base + QString::number(id);
         }
-    } else if (className.size()) {
+    } else if (!className.isEmpty()) {
         name = unique(qtify(className));
     } else {
         name = unique(QLatin1String("var"));
     }
 
-    if (alreadyUsed && className.size()) {
+    if (alreadyUsed && !className.isEmpty()) {
         fprintf(stderr, "%s: Warning: The name '%s' (%s) is already in use, defaulting to '%s'.\n",
                 qPrintable(m_option.messagePrefix()),
                 qPrintable(instanceName), qPrintable(className),
@@ -181,17 +181,10 @@ QString Driver::qtify(const QString &name)
     QString qname = name;
 
     if (qname.at(0) == QLatin1Char('Q') || qname.at(0) == QLatin1Char('K'))
-        qname = qname.mid(1);
+        qname.remove(0, 1);
 
-    int i=0;
-    while (i < qname.length()) {
-        if (qname.at(i).toLower() != qname.at(i))
-            qname[i] = qname.at(i).toLower();
-        else
-            break;
-
-        ++i;
-    }
+    for (int i = 0, size = qname.size(); i < size && qname.at(i).isUpper(); ++i)
+        qname[i] = qname.at(i).toLower();
 
     return qname;
 }
@@ -256,18 +249,11 @@ bool Driver::uic(const QString &fileName, DomUI *ui, QTextStream *out)
     m_output = out != 0 ? out : &m_stdout;
 
     Uic tool(this);
-    bool rtn = false;
-#ifdef QT_UIC_CPP_GENERATOR
-    rtn = tool.write(ui);
-#else
-    Q_UNUSED(ui);
-    fprintf(stderr, "uic: option to generate cpp code not compiled in [%s:%d]\n",
-            __FILE__, __LINE__);
-#endif
+    const bool result = tool.write(ui);
 
     m_output = oldOutput;
 
-    return rtn;
+    return result;
 }
 
 bool Driver::uic(const QString &fileName, QTextStream *out)
@@ -313,58 +299,19 @@ bool Driver::uic(const QString &fileName, QTextStream *out)
     return rtn;
 }
 
-void Driver::reset()
-{
-    Q_ASSERT( m_output == 0 );
-
-    m_option = Option();
-    m_output = 0;
-    m_problems.clear();
-
-    QStringList m_problems;
-
-    m_widgets.clear();
-    m_spacers.clear();
-    m_layouts.clear();
-    m_actionGroups.clear();
-    m_actions.clear();
-    m_nameRepository.clear();
-    m_pixmaps.clear();
-}
-
-void Driver::insertPixmap(const QString &pixmap)
-{
-    m_pixmaps.insert(pixmap, true);
-}
-
-bool Driver::containsPixmap(const QString &pixmap) const
-{
-    return m_pixmaps.contains(pixmap);
-}
-
-DomWidget *Driver::widgetByName(const QString &name) const
-{
-    return m_widgets.key(name);
-}
-
-DomSpacer *Driver::spacerByName(const QString &name) const
-{
-    return m_spacers.key(name);
-}
-
-DomLayout *Driver::layoutByName(const QString &name) const
+const DomWidget *Driver::widgetByName(const QString &name) const
 {
-    return m_layouts.key(name);
+    return findByAttributeName(m_widgets, name);
 }
 
-DomActionGroup *Driver::actionGroupByName(const QString &name) const
+const DomActionGroup *Driver::actionGroupByName(const QString &name) const
 {
-    return m_actionGroups.key(name);
+    return findByAttributeName(m_actionGroups, name);
 }
 
-DomAction *Driver::actionByName(const QString &name) const
+const DomAction *Driver::actionByName(const QString &name) const
 {
-    return m_actions.key(name);
+    return findByAttributeName(m_actions, name);
 }
 
 QT_END_NAMESPACE
diff --git a/src/tools/uic/driver.h b/src/tools/uic/driver.h
index 1563bdbd83..36336007b2 100644
--- a/src/tools/uic/driver.h
+++ b/src/tools/uic/driver.h
@@ -49,27 +49,20 @@ class DomButtonGroup;
 
 class Driver
 {
-    Q_DISABLE_COPY(Driver)
+    Q_DISABLE_COPY_MOVE(Driver)
 public:
     Driver();
     virtual ~Driver();
 
     // tools
     bool printDependencies(const QString &fileName);
-    bool uic(const QString &fileName, QTextStream *output = 0);
-    bool uic(const QString &fileName, DomUI *ui, QTextStream *output = 0);
+    bool uic(const QString &fileName, QTextStream *output = nullptr);
+    bool uic(const QString &fileName, DomUI *ui, QTextStream *output = nullptr);
 
     // configuration
     inline QTextStream &output() const { return *m_output; }
     inline Option &option() { return m_option; }
 
-    // initialization
-    void reset();
-
-    // error
-    inline QStringList problems() { return m_problems; }
-    inline void addProblem(const QString &problem) { m_problems.append(problem); }
-
     // utils
     static QString headerFileName(const QString &fileName);
     QString headerFileName() const;
@@ -80,50 +73,46 @@ public:
                    const QString &className=QString());
 
     // symbol table
-    QString findOrInsertWidget(DomWidget *ui_widget);
-    QString findOrInsertSpacer(DomSpacer *ui_spacer);
-    QString findOrInsertLayout(DomLayout *ui_layout);
-    QString findOrInsertLayoutItem(DomLayoutItem *ui_layoutItem);
+    QString findOrInsertWidget(const DomWidget *ui_widget);
+    QString findOrInsertSpacer(const DomSpacer *ui_spacer);
+    QString findOrInsertLayout(const DomLayout *ui_layout);
+    QString findOrInsertLayoutItem(const DomLayoutItem *ui_layoutItem);
     QString findOrInsertName(const QString &name);
-    QString findOrInsertActionGroup(DomActionGroup *ui_group);
-    QString findOrInsertAction(DomAction *ui_action);
+    QString findOrInsertActionGroup(const DomActionGroup *ui_group);
+    QString findOrInsertAction(const DomAction *ui_action);
     QString findOrInsertButtonGroup(const DomButtonGroup *ui_group);
     // Find a group by its non-uniqified name
     const DomButtonGroup *findButtonGroup(const QString &attributeName) const;
 
-    inline bool hasName(const QString &name) const
-    { return m_nameRepository.contains(name); }
-
-    DomWidget *widgetByName(const QString &name) const;
-    DomSpacer *spacerByName(const QString &name) const;
-    DomLayout *layoutByName(const QString &name) const;
-    DomActionGroup *actionGroupByName(const QString &name) const;
-    DomAction *actionByName(const QString &name) const;
-
-    // pixmap
-    void insertPixmap(const QString &pixmap);
-    bool containsPixmap(const QString &pixmap) const;
+    const DomWidget *widgetByName(const QString &name) const;
+    const DomActionGroup *actionGroupByName(const QString &name) const;
+    const DomAction *actionByName(const QString &name) const;
 
     bool useIdBasedTranslations() const { return m_idBasedTranslations; }
     void setUseIdBasedTranslations(bool u) { m_idBasedTranslations = u; }
 
 private:
+    template <class DomClass> using DomObjectHash = QHash<const DomClass *, QString>;
+
+    template <class DomClass>
+    const DomClass *findByAttributeName(const DomObjectHash<DomClass> &domHash,
+                                        const QString &name) const;
+    template <class DomClass>
+    QString findOrInsert(DomObjectHash<DomClass> *domHash, const DomClass *dom, const QString &className,
+                         bool isMember = true);
+
     Option m_option;
     QTextStream m_stdout;
     QTextStream *m_output;
 
-    QStringList m_problems;
-
     // symbol tables
-    QHash<DomWidget*, QString> m_widgets;
-    QHash<DomSpacer*, QString> m_spacers;
-    QHash<DomLayout*, QString> m_layouts;
-    QHash<DomActionGroup*, QString> m_actionGroups;
-    typedef QHash<const DomButtonGroup*, QString> ButtonGroupNameHash;
-    ButtonGroupNameHash m_buttonGroups;
-    QHash<DomAction*, QString> m_actions;
+    DomObjectHash<DomWidget> m_widgets;
+    DomObjectHash<DomSpacer> m_spacers;
+    DomObjectHash<DomLayout> m_layouts;
+    DomObjectHash<DomActionGroup> m_actionGroups;
+    DomObjectHash<DomButtonGroup> m_buttonGroups;
+    DomObjectHash<DomAction> m_actions;
     QHash<QString, bool> m_nameRepository;
-    QHash<QString, bool> m_pixmaps;
     bool m_idBasedTranslations = false;
 };
 
diff --git a/src/tools/uic/main.cpp b/src/tools/uic/main.cpp
index 0e30bac28e..166fe78ff7 100644
--- a/src/tools/uic/main.cpp
+++ b/src/tools/uic/main.cpp
@@ -29,6 +29,7 @@
 #include "uic.h"
 #include "option.h"
 #include "driver.h"
+#include <language.h>
 
 #include <qfile.h>
 #include <qdir.h>
@@ -96,7 +97,7 @@ int runUic(int argc, char *argv[])
 
     QCommandLineOption generatorOption(QStringList() << QStringLiteral("g") << QStringLiteral("generator"));
     generatorOption.setDescription(QStringLiteral("Select generator."));
-    generatorOption.setValueName(QStringLiteral("java|cpp"));
+    generatorOption.setValueName(QStringLiteral("python|cpp"));
     parser.addOption(generatorOption);
 
     QCommandLineOption idBasedOption(QStringLiteral("idbased"));
@@ -115,7 +116,13 @@ int runUic(int argc, char *argv[])
     driver.option().postfix = parser.value(postfixOption);
     driver.option().translateFunction = parser.value(translateOption);
     driver.option().includeFile = parser.value(includeOption);
-    driver.option().generator = (parser.value(generatorOption).toLower() == QLatin1String("java")) ? Option::JavaGenerator : Option::CppGenerator;
+
+    Language language = Language::Cpp;
+    if (parser.isSet(generatorOption)) {
+        if (parser.value(generatorOption).compare(QLatin1String("python")) == 0)
+            language = Language::Python;
+    }
+    language::setLanguage(language);
 
     if (parser.isSet(noStringLiteralOption))
         fprintf(stderr, "The -s, --no-stringliteral option is deprecated and it won't take any effect.\n");
@@ -132,14 +139,14 @@ int runUic(int argc, char *argv[])
 
     QTextStream *out = 0;
     QFile f;
-    if (driver.option().outputFile.size()) {
+    if (!driver.option().outputFile.isEmpty()) {
         f.setFileName(driver.option().outputFile);
         if (!f.open(QIODevice::WriteOnly | QFile::Text)) {
             fprintf(stderr, "Could not create output file\n");
             return 1;
         }
         out = new QTextStream(&f);
-#ifndef QT_NO_TEXTCODEC
+#if QT_CONFIG(textcodec)
         out->setCodec(QTextCodec::codecForName("UTF-8"));
 #endif
     }
diff --git a/src/tools/uic/option.h b/src/tools/uic/option.h
index a5b14abc5f..4fc442e94a 100644
--- a/src/tools/uic/option.h
+++ b/src/tools/uic/option.h
@@ -36,12 +36,6 @@ QT_BEGIN_NAMESPACE
 
 struct Option
 {
-    enum Generator
-    {
-        CppGenerator,
-        JavaGenerator
-    };
-
     unsigned int headerProtection : 1;
     unsigned int copyrightHeader : 1;
     unsigned int generateImplemetation : 1;
@@ -51,7 +45,6 @@ struct Option
     unsigned int limitXPM_LineLength : 1;
     unsigned int implicitIncludes: 1;
     unsigned int idBased: 1;
-    Generator generator;
 
     QString inputFile;
     QString outputFile;
@@ -61,10 +54,6 @@ struct Option
     QString postfix;
     QString translateFunction;
     QString includeFile;
-#ifdef QT_UIC_JAVA_GENERATOR
-    QString javaPackage;
-    QString javaOutputDirectory;
-#endif
 
     Option()
         : headerProtection(1),
@@ -76,7 +65,6 @@ struct Option
           limitXPM_LineLength(0),
           implicitIncludes(1),
           idBased(0),
-          generator(CppGenerator),
           prefix(QLatin1String("Ui_"))
     { indent.fill(QLatin1Char(' '), 4); }
 
diff --git a/src/tools/uic/python/python.pri b/src/tools/uic/python/python.pri
new file mode 100644
index 0000000000..4dd31160a1
--- /dev/null
+++ b/src/tools/uic/python/python.pri
@@ -0,0 +1,8 @@
+INCLUDEPATH += $$PWD
+
+# Input
+HEADERS += $$PWD/pythonwritedeclaration.h \
+           $$PWD/pythonwriteimports.h
+
+SOURCES += $$PWD/pythonwritedeclaration.cpp \
+           $$PWD/pythonwriteimports.cpp
diff --git a/src/tools/uic/python/pythonwritedeclaration.cpp b/src/tools/uic/python/pythonwritedeclaration.cpp
new file mode 100644
index 0000000000..5122b18e23
--- /dev/null
+++ b/src/tools/uic/python/pythonwritedeclaration.cpp
@@ -0,0 +1,73 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "pythonwritedeclaration.h"
+#include <cppwriteinitialization.h>
+#include <language.h>
+#include <driver.h>
+#include <ui4.h>
+#include <uic.h>
+
+#include <QtCore/qtextstream.h>
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace Python {
+
+WriteDeclaration::WriteDeclaration(Uic *uic)  :
+    m_uic(uic),
+    m_driver(uic->driver()),
+    m_output(uic->output()),
+    m_option(uic->option())
+{
+}
+
+void WriteDeclaration::acceptUI(DomUI *node)
+{
+    // remove any left-over C++ namespaces
+    const QString qualifiedClassName = QLatin1String("Ui_") + node->elementClass()
+        + m_option.postfix;
+    m_output << "class " << language::fixClassName(qualifiedClassName) << "(object):\n";
+
+    TreeWalker::acceptWidget(node->elementWidget());
+    if (const DomButtonGroups *domButtonGroups = node->elementButtonGroups())
+        acceptButtonGroups(domButtonGroups);
+    CPP::WriteInitialization(m_uic).acceptUI(node);
+}
+
+// Register button groups to prevent the on-the-fly creation legacy
+// feature from triggering
+void WriteDeclaration::acceptButtonGroup(const DomButtonGroup *buttonGroup)
+{
+    m_driver->findOrInsertButtonGroup(buttonGroup);
+}
+
+} // namespace Python
+
+QT_END_NAMESPACE
diff --git a/src/tools/uic/python/pythonwritedeclaration.h b/src/tools/uic/python/pythonwritedeclaration.h
new file mode 100644
index 0000000000..a8d50b6fbf
--- /dev/null
+++ b/src/tools/uic/python/pythonwritedeclaration.h
@@ -0,0 +1,62 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef PYTHONWRITEDECLARATION_H
+#define PYTHONWRITEDECLARATION_H
+
+#include <treewalker.h>
+
+QT_BEGIN_NAMESPACE
+
+class QTextStream;
+class Driver;
+class Uic;
+
+struct Option;
+
+namespace Python {
+
+struct WriteDeclaration : public TreeWalker
+{
+    WriteDeclaration(Uic *uic);
+
+    void acceptUI(DomUI *node) override;
+    void acceptButtonGroup(const DomButtonGroup *buttonGroup) override;
+
+private:
+    Uic *m_uic;
+    Driver *m_driver;
+    QTextStream &m_output;
+    const Option &m_option;
+};
+
+} // namespace Python
+
+QT_END_NAMESPACE
+
+#endif // PYTHONWRITEDECLARATION_H
diff --git a/src/tools/uic/python/pythonwriteimports.cpp b/src/tools/uic/python/pythonwriteimports.cpp
new file mode 100644
index 0000000000..8e11981f37
--- /dev/null
+++ b/src/tools/uic/python/pythonwriteimports.cpp
@@ -0,0 +1,92 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "pythonwriteimports.h"
+
+#include <customwidgetsinfo.h>
+#include <uic.h>
+
+#include <ui4.h>
+
+#include <QtCore/qtextstream.h>
+
+QT_BEGIN_NAMESPACE
+
+static const char *standardImports =
+R"I(from PySide2.QtCore import (QCoreApplication, QMetaObject, QObject, QPoint,
+    QRect, QSize, QUrl, Qt)
+from PySide2.QtGui import (QColor, QFont, QIcon, QPixmap)
+from PySide2.QtWidgets import *
+)I";
+
+namespace Python {
+
+WriteImports::WriteImports(Uic *uic) : m_uic(uic)
+{
+}
+
+void WriteImports::acceptUI(DomUI *node)
+{
+    auto &output = m_uic->output();
+    output << standardImports << '\n';
+    if (auto customWidgets = node->elementCustomWidgets()) {
+        TreeWalker::acceptCustomWidgets(customWidgets);
+        output << '\n';
+    }
+}
+
+QString WriteImports::qtModuleOf(const DomCustomWidget *node) const
+{
+    if (m_uic->customWidgetsInfo()->extends(node->elementClass(), QLatin1String("QAxWidget")))
+        return QStringLiteral("QtAxContainer");
+    if (const auto headerElement = node->elementHeader()) {
+        const auto &header = headerElement->text();
+        if (header.startsWith(QLatin1String("Qt"))) {
+            const int slash = header.indexOf(QLatin1Char('/'));
+            if (slash != -1)
+                return header.left(slash);
+        }
+    }
+    return QString();
+}
+
+void WriteImports::acceptCustomWidget(DomCustomWidget *node)
+{
+    const auto &className = node->elementClass();
+    if (className.contains(QLatin1String("::")))
+        return; // Exclude namespaced names (just to make tests pass).
+    const QString &qtModule = qtModuleOf(node);
+    auto &output = m_uic->output();
+    if (!qtModule.isEmpty())
+        output << "from PySide2." << qtModule << ' ';
+    output << "import " << className << '\n';
+}
+
+} // namespace Python
+
+QT_END_NAMESPACE
diff --git a/src/tools/uic/globaldefs.h b/src/tools/uic/python/pythonwriteimports.h
index 5ad193c29a..427cbb48b1 100644
--- a/src/tools/uic/globaldefs.h
+++ b/src/tools/uic/python/pythonwriteimports.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2018 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the tools applications of the Qt Toolkit.
@@ -26,16 +26,33 @@
 **
 ****************************************************************************/
 
-#ifndef GLOBALDEFS_H
-#define GLOBALDEFS_H
+#ifndef PYTHONWRITEIMPORTS_H
+#define PYTHONWRITEIMPORTS_H
 
-#include <qglobal.h>
+#include <treewalker.h>
 
 QT_BEGIN_NAMESPACE
 
-enum { BOXLAYOUT_DEFAULT_MARGIN = 11 };
-enum { BOXLAYOUT_DEFAULT_SPACING = 6 };
+class Uic;
+
+namespace Python {
+
+struct WriteImports : public TreeWalker
+{
+public:
+    explicit WriteImports(Uic *uic);
+
+    void acceptUI(DomUI *node) override;
+    void acceptCustomWidget(DomCustomWidget *node) override;
+
+private:
+    QString qtModuleOf(const DomCustomWidget *node) const;
+
+    Uic *const m_uic;
+};
+
+} // namespace Python
 
 QT_END_NAMESPACE
 
-#endif // GLOBALDEFS_H
+#endif // PYTHONWRITEIMPORTS_H
diff --git a/src/tools/uic/shared/language.cpp b/src/tools/uic/shared/language.cpp
new file mode 100644
index 0000000000..235a8ed2fc
--- /dev/null
+++ b/src/tools/uic/shared/language.cpp
@@ -0,0 +1,426 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "language.h"
+
+#include <QtCore/qtextstream.h>
+
+namespace language {
+
+static Encoding encoding = Encoding::Utf8;
+static Language _language = Language::Cpp;
+
+Language language() { return _language; }
+
+void setLanguage(Language l)
+{
+    _language = l;
+    switch (_language) {
+    case Language::Cpp:
+        derefPointer = QLatin1String("->");
+        nullPtr = QLatin1String("nullptr");
+        operatorNew = QLatin1String("new ");
+        qtQualifier = QLatin1String("Qt::");
+        qualifier = QLatin1String("::");
+        self = QLatin1String("");  // for testing: change to "this->";
+        eol = QLatin1String(";\n");
+        encoding = Encoding::Utf8;
+        break;
+    case Language::Python:
+        derefPointer = QLatin1String(".");
+        nullPtr = QLatin1String("None");
+        operatorNew = QLatin1String("");
+        qtQualifier = QLatin1String("Qt.");
+        qualifier = QLatin1String(".");
+        self = QLatin1String("self.");
+        eol = QLatin1String("\n");
+        encoding = Encoding::Unicode;
+        break;
+    }
+}
+
+QString derefPointer;
+QString nullPtr;
+QString operatorNew;
+QString qtQualifier;
+QString qualifier;
+QString self;
+QString eol;
+
+QString cppQualifier = QLatin1String("::");
+QString cppTrue = QLatin1String("true");
+QString cppFalse = QLatin1String("false");
+
+QTextStream &operator<<(QTextStream &str, const qtConfig &c)
+{
+    str << "QT_CONFIG(" << c.parameter() << ')';
+    return str;
+}
+
+QTextStream &operator<<(QTextStream &str, const openQtConfig &c)
+{
+    str << "#if " << qtConfig(c.parameter())  << '\n';
+    return str;
+}
+
+QTextStream &operator<<(QTextStream &str, const closeQtConfig &c)
+{
+    str << "#endif // " << qtConfig(c.parameter()) << '\n';
+    return str;
+}
+
+struct EnumLookup
+{
+    int value;
+    const char *valueString;
+};
+
+template <int N>
+const char *lookupEnum(const EnumLookup(&array)[N], int value, int defaultIndex = 0)
+{
+    for (int i = 0; i < N; ++i) {
+        if (value == array[i].value)
+            return array[i].valueString;
+    }
+    const char *defaultValue = array[defaultIndex].valueString;
+    qWarning("uic: Warning: Invalid enumeration value %d, defaulting to %s",
+             value, defaultValue);
+    return defaultValue;
+}
+
+QString fixClassName(QString className)
+{
+    if (language() == Language::Python)
+        className.replace(cppQualifier, QLatin1String("_"));
+    return className;
+}
+
+const char *toolbarArea(int v)
+{
+    static const EnumLookup toolBarAreas[] =
+    {
+        {0,   "NoToolBarArea"},
+        {0x1, "LeftToolBarArea"},
+        {0x2, "RightToolBarArea"},
+        {0x4, "TopToolBarArea"},
+        {0x8, "BottomToolBarArea"},
+        {0xf, "AllToolBarAreas"}
+    };
+    return lookupEnum(toolBarAreas, v);
+}
+
+const char *sizePolicy(int v)
+{
+    static const EnumLookup sizePolicies[] =
+    {
+        {0,   "Fixed"},
+        {0x1, "Minimum"},
+        {0x4, "Maximum"},
+        {0x5, "Preferred"},
+        {0x3, "MinimumExpanding"},
+        {0x7, "Expanding"},
+        {0xD, "Ignored"}
+    };
+    return lookupEnum(sizePolicies, v, 3);
+}
+
+const char *dockWidgetArea(int v)
+{
+    static const EnumLookup dockWidgetAreas[] =
+    {
+        {0,   "NoDockWidgetArea"},
+        {0x1, "LeftDockWidgetArea"},
+        {0x2, "RightDockWidgetArea"},
+        {0x4, "TopDockWidgetArea"},
+        {0x8, "BottomDockWidgetArea"},
+        {0xf, "AllDockWidgetAreas"}
+    };
+    return lookupEnum(dockWidgetAreas, v);
+}
+
+const char *paletteColorRole(int v)
+{
+    static const EnumLookup colorRoles[] =
+    {
+        {0, "WindowText"},
+        {1, "Button"},
+        {2, "Light"},
+        {3, "Midlight"},
+        {4, "Dark"},
+        {5, "Mid"},
+        {6, "Text"},
+        {7, "BrightText"},
+        {8, "ButtonText"},
+        {9, "Base"},
+        {10, "Window"},
+        {11, "Shadow"},
+        {12, "Highlight"},
+        {13, "HighlightedText"},
+        {14, "Link"},
+        {15, "LinkVisited"},
+        {16, "AlternateBase"},
+        {17, "NoRole"},
+        {18, "ToolTipBase"},
+        {19, "ToolTipText"},
+        {20, "PlaceholderText"},
+    };
+    return lookupEnum(colorRoles, v);
+}
+
+// Helpers for formatting a character sequences
+
+// Format a special character like '\x0a'
+static int formatEscapedNumber(QTextStream &str, ushort value, int base, int width,
+                               char prefix = 0)
+{
+    int length = 1 + width;
+    str << '\\';
+    if (prefix) {
+        str << prefix;
+        ++length;
+    }
+    const auto oldPadChar = str.padChar();
+    const auto oldFieldWidth = str.fieldWidth();
+    const auto oldFieldAlignment = str.fieldAlignment();
+    const auto oldIntegerBase = str.integerBase();
+    str.setPadChar(QLatin1Char('0'));
+    str.setFieldWidth(width);
+    str.setFieldAlignment(QTextStream::AlignRight);
+    str.setIntegerBase(base);
+    str << value;
+    str.setIntegerBase(oldIntegerBase);
+    str.setFieldAlignment(oldFieldAlignment);
+    str.setFieldWidth(oldFieldWidth);
+    str.setPadChar(oldPadChar);
+    return length;
+}
+
+static int formatSpecialCharacter(QTextStream &str, ushort value)
+{
+    int length = 0;
+    switch (value) {
+    case '\\':
+        str << "\\\\";
+        length += 2;
+        break;
+    case '\"':
+        str << "\\\"";
+        length += 2;
+        break;
+    case '\n':
+        str << "\\n\"\n\"";
+        length += 5;
+        break;
+    default:
+        break;
+    }
+    return length;
+}
+
+// Format a sequence of characters for C++ with special characters numerically
+// escaped (non-raw string literals), wrappped at maxSegmentSize. FormattingTraits
+// are used to transform characters into (unsigned) codes, which can be used
+// for either normal escapes or Unicode code points as used in Unicode literals.
+
+enum : int { maxSegmentSize = 1024 };
+
+template <Encoding e>
+struct FormattingTraits
+{
+};
+
+template <>
+struct FormattingTraits<Encoding::Utf8>
+{
+    static ushort code(char c) { return uchar(c); }
+};
+
+template <>
+struct FormattingTraits<Encoding::Unicode>
+{
+    static ushort code(QChar c) { return c.unicode(); }
+};
+
+template <Encoding e, class Iterator>
+static void formatStringSequence(QTextStream &str, Iterator it, Iterator end,
+                                 const QString &indent,
+                                 int escapeIntegerBase, int escapeWidth,
+                                 char escapePrefix = 0)
+{
+    str << '"';
+    int length = 0;
+    while (it != end) {
+        const auto code = FormattingTraits<e>::code(*it);
+        if (code >= 0x80) {
+            length += formatEscapedNumber(str, code, escapeIntegerBase, escapeWidth, escapePrefix);
+        } else if (const int l = formatSpecialCharacter(str, code)) {
+            length += l;
+        } else if (code != '\r') {
+            str << *it;
+            ++length;
+        }
+        ++it;
+        if (it != end && length > maxSegmentSize) {
+            str << "\"\n" << indent << indent << '"';
+            length = 0;
+        }
+    }
+    str << '"';
+}
+
+void _formatString(QTextStream &str, const QString &value, const QString &indent,
+                   bool qString)
+{
+    switch (encoding) {
+    // Special characters as 3 digit octal escapes (u8"\303\234mlaut")
+    case Encoding::Utf8: {
+        if (qString && _language == Language::Cpp)
+            str << "QString::fromUtf8(";
+        const QByteArray utf8 = value.toUtf8();
+        formatStringSequence<Encoding::Utf8>(str, utf8.cbegin(), utf8.cend(), indent,
+                                             8, 3);
+        if (qString && _language == Language::Cpp)
+            str << ')';
+    }
+        break;
+    // Special characters as 4 digit hex Unicode points (u8"\u00dcmlaut")
+    case Encoding::Unicode:
+        str << 'u'; // Python Unicode literal (would be UTF-16 in C++)
+        formatStringSequence<Encoding::Unicode>(str, value.cbegin(), value.cend(), indent,
+                                                16, 4, 'u');
+        break;
+    }
+}
+
+QTextStream &operator<<(QTextStream &str, const repeat &r)
+{
+    for (int i = 0; i < r.m_count; ++i)
+        str << r.m_char;
+    return str;
+}
+
+startFunctionDefinition1::startFunctionDefinition1(const char *name, const QString &parameterType,
+                                                   const QString &parameterName,
+                                                   const QString &indent,
+                                                   const char *returnType) :
+    m_name(name), m_parameterType(parameterType), m_parameterName(parameterName),
+    m_indent(indent), m_return(returnType)
+{
+}
+
+QTextStream &operator<<(QTextStream &str, const startFunctionDefinition1 &f)
+{
+    switch (language()) {
+    case Language::Cpp:
+        str << (f.m_return ? f.m_return : "void") << ' ' << f.m_name << '('
+            << f.m_parameterType;
+        if (f.m_parameterType.cend()->isLetter())
+            str << ' ';
+        str << f.m_parameterName << ')' << '\n' << f.m_indent << "{\n";
+        break;
+    case Language::Python:
+        str << "def " << f.m_name << "(self, " << f.m_parameterName << "):\n";
+        break;
+    }
+    return str;
+}
+
+endFunctionDefinition::endFunctionDefinition(const char *name) : m_name(name)
+{
+}
+
+QTextStream &operator<<(QTextStream &str, const endFunctionDefinition &f)
+{
+    switch (language()) {
+    case Language::Cpp:
+        str << "} // " << f.m_name << "\n\n";
+        break;
+    case Language::Python:
+        str << "# " << f.m_name << "\n\n";
+        break;
+    }
+    return str;
+}
+
+void _formatStackVariable(QTextStream &str, const char *className, QStringView varName,
+                          bool withInitParameters)
+{
+    switch (language()) {
+    case Language::Cpp:
+        str << className << ' ' << varName;
+        if (withInitParameters)
+            str << '(';
+        break;
+    case Language::Python:
+        str << varName << " = " << className << '(';
+        if (!withInitParameters)
+            str << ')';
+        break;
+    }
+}
+
+void formatConnection(QTextStream &str, const SignalSlot &sender, const SignalSlot &receiver)
+{
+    switch (language()) {
+    case Language::Cpp:
+        str << "QObject::connect(" << sender.name << ", SIGNAL("<< sender.signature
+            << "), " << receiver.name << ", SLOT("<< receiver.signature << "))";
+        break;
+    case Language::Python:
+        str << sender.name << '.'
+            << sender.signature.leftRef(sender.signature.indexOf(QLatin1Char('(')))
+            << ".connect(" << receiver.name << '.'
+            << receiver.signature.leftRef(receiver.signature.indexOf(QLatin1Char('(')))
+            << ')';
+        break;
+    }
+}
+
+QString boolValue(bool v)
+{
+    switch (language()) {
+    case Language::Cpp:
+        return v ? cppTrue : cppFalse;
+    case Language::Python:
+        return v ? QStringLiteral("True") : QStringLiteral("False");
+    }
+    Q_UNREACHABLE();
+}
+
+static inline QString dot() { return QStringLiteral("."); }
+
+QString enumValue(const QString &value)
+{
+    if (language() == Language::Cpp || !value.contains(cppQualifier))
+        return value;
+    QString fixed = value;
+    fixed.replace(cppQualifier, dot());
+    return fixed;
+}
+
+} // namespace language
diff --git a/src/tools/uic/shared/language.h b/src/tools/uic/shared/language.h
new file mode 100644
index 0000000000..fc8af9715b
--- /dev/null
+++ b/src/tools/uic/shared/language.h
@@ -0,0 +1,208 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef LANGUAGE_H
+#define LANGUAGE_H
+
+#include <QtCore/qstring.h>
+#include <QtCore/qstringview.h>
+#include <QtCore/qstring.h>
+
+QT_FORWARD_DECLARE_CLASS(QTextStream)
+
+enum class Language { Cpp, Python };
+
+namespace language {
+
+Language language();
+void setLanguage(Language);
+
+extern QString derefPointer;
+extern QString nullPtr;
+extern QString operatorNew;
+extern QString qtQualifier;
+extern QString qualifier;
+extern QString self;
+extern QString eol;
+
+extern QString cppQualifier;
+extern QString cppTrue;
+extern QString cppFalse;
+
+// Base class for streamable objects with one QStringView parameter
+class StringViewStreamable
+{
+public:
+    StringViewStreamable(QStringView parameter) : m_parameter(parameter) {}
+
+    QStringView parameter() const { return m_parameter; }
+
+private:
+    QStringView m_parameter;
+};
+
+class qtConfig : public StringViewStreamable
+{
+public:
+    qtConfig(QStringView name) : StringViewStreamable(name) {}
+};
+
+QTextStream &operator<<(QTextStream &str, const qtConfig &c);
+
+class openQtConfig : public StringViewStreamable
+{
+public:
+    openQtConfig(QStringView name) : StringViewStreamable(name) {}
+};
+
+QTextStream &operator<<(QTextStream &str, const openQtConfig &c);
+
+class closeQtConfig : public StringViewStreamable
+{
+public:
+    closeQtConfig(QStringView name) : StringViewStreamable(name) {}
+};
+
+QTextStream &operator<<(QTextStream &, const closeQtConfig &c);
+
+QString fixClassName(QString className);
+
+const char *toolbarArea(int v);
+const char *sizePolicy(int v);
+const char *dockWidgetArea(int v);
+const char *paletteColorRole(int v);
+
+enum class Encoding { Utf8, Unicode };
+
+void _formatString(QTextStream &str, const QString &value, const QString &indent,
+                   bool qString);
+
+template <bool AsQString>
+class _string
+{
+public:
+    explicit _string(const QString &value, const QString &indent = QString())
+        : m_value(value), m_indent(indent) {}
+
+    void format(QTextStream &str) const
+    { _formatString(str, m_value, m_indent, AsQString); }
+
+private:
+    const QString &m_value;
+    const QString &m_indent;
+};
+
+template <bool AsQString>
+inline QTextStream &operator<<(QTextStream &str, const language::_string<AsQString> &s)
+{
+    s.format(str);
+    return str;
+}
+
+using charliteral = _string<false>;
+using qstring = _string<true>;
+
+class repeat {
+public:
+    explicit repeat(int count, char c) : m_count(count), m_char(c) {}
+
+    friend QTextStream &operator<<(QTextStream &str, const repeat &r);
+
+private:
+    const int m_count;
+    const char m_char;
+};
+
+class startFunctionDefinition1 {
+public:
+    explicit startFunctionDefinition1(const char *name, const QString &parameterType,
+                                      const QString &parameterName,
+                                      const QString &indent,
+                                      const char *returnType = nullptr);
+
+    friend QTextStream &operator<<(QTextStream &str, const startFunctionDefinition1 &f);
+private:
+    const char *m_name;
+    const QString &m_parameterType;
+    const QString &m_parameterName;
+    const QString &m_indent;
+    const char *m_return;
+};
+
+class endFunctionDefinition {
+public:
+    explicit endFunctionDefinition(const char *name);
+
+    friend QTextStream &operator<<(QTextStream &str, const endFunctionDefinition &f);
+private:
+    const char *m_name;
+};
+
+void _formatStackVariable(QTextStream &str, const char *className, QStringView varName, bool withInitParameters);
+
+template <bool withInitParameters>
+class _stackVariable {
+public:
+    explicit _stackVariable(const char *className, QStringView varName) :
+        m_className(className), m_varName(varName) {}
+
+    void format(QTextStream &str) const
+    { _formatStackVariable(str, m_className, m_varName, withInitParameters); }
+
+private:
+    const char *m_className;
+    QStringView m_varName;
+    QStringView m_parameters;
+};
+
+template <bool withInitParameters>
+inline QTextStream &operator<<(QTextStream &str, const _stackVariable<withInitParameters> &s)
+{
+    s.format(str);
+    return str;
+}
+
+using stackVariable = _stackVariable<false>;
+using stackVariableWithInitParameters = _stackVariable<true>;
+
+struct SignalSlot
+{
+    QString name;
+    QString signature;
+    QString className;
+};
+
+void formatConnection(QTextStream &str, const SignalSlot &sender, const SignalSlot &receiver);
+
+QString boolValue(bool v);
+
+QString enumValue(const QString &value);
+
+} // namespace language
+
+#endif // LANGUAGE_H
diff --git a/src/tools/uic/shared/shared.pri b/src/tools/uic/shared/shared.pri
new file mode 100644
index 0000000000..dce2af8bf1
--- /dev/null
+++ b/src/tools/uic/shared/shared.pri
@@ -0,0 +1,5 @@
+INCLUDEPATH += $$PWD
+
+HEADERS += $$PWD/language.h
+
+SOURCES += $$PWD/language.cpp
diff --git a/src/tools/uic/treewalker.h b/src/tools/uic/treewalker.h
index 43d4633d83..7e8eda57d9 100644
--- a/src/tools/uic/treewalker.h
+++ b/src/tools/uic/treewalker.h
@@ -101,7 +101,6 @@ struct TreeWalker
     virtual void acceptTime(DomTime *time);
     virtual void acceptDateTime(DomDateTime *dateTime);
     virtual void acceptProperty(DomProperty *property);
-    typedef QVector<DomScript *> DomScripts;
     typedef QVector<DomWidget *> DomWidgets;
     virtual void acceptIncludes(DomIncludes *includes);
     virtual void acceptInclude(DomInclude *incl);
diff --git a/src/tools/uic/uic.cpp b/src/tools/uic/uic.cpp
index 957a50b1d5..b95f1a784b 100644
--- a/src/tools/uic/uic.cpp
+++ b/src/tools/uic/uic.cpp
@@ -33,18 +33,16 @@
 #include "treewalker.h"
 #include "validator.h"
 
-#ifdef QT_UIC_CPP_GENERATOR
 #include "cppwriteincludes.h"
 #include "cppwritedeclaration.h"
-#endif
+#include <pythonwritedeclaration.h>
+#include <pythonwriteimports.h>
 
-#ifdef QT_UIC_JAVA_GENERATOR
-#include "javawriteincludes.h"
-#include "javawritedeclaration.h"
-#endif
+#include <language.h>
 
 #include <qxmlstream.h>
 #include <qfileinfo.h>
+#include <qscopedpointer.h>
 #include <qtextstream.h>
 
 QT_BEGIN_NAMESPACE
@@ -109,21 +107,63 @@ bool Uic::printDependencies()
     return true;
 }
 
-void Uic::writeCopyrightHeader(DomUI *ui)
+void Uic::writeCopyrightHeaderCpp(const DomUI *ui) const
 {
     QString comment = ui->elementComment();
-    if (comment.size())
+    if (!comment.isEmpty())
         out << "/*\n" << comment << "\n*/\n\n";
 
     out << "/********************************************************************************\n";
     out << "** Form generated from reading UI file '" << QFileInfo(opt.inputFile).fileName() << "'\n";
     out << "**\n";
-    out << "** Created by: Qt User Interface Compiler version " << QLatin1String(QT_VERSION_STR) << "\n";
+    out << "** Created by: Qt User Interface Compiler version " << QT_VERSION_STR << "\n";
     out << "**\n";
     out << "** WARNING! All changes made in this file will be lost when recompiling UI file!\n";
     out << "********************************************************************************/\n\n";
 }
 
+// Format existing UI file comments for Python with some smartness : Replace all
+// leading C++ comment characters by '#' or prepend '#' if needed.
+
+static inline bool isCppCommentChar(QChar c)
+{
+    return  c == QLatin1Char('/') || c == QLatin1Char('*');
+}
+
+static int leadingCppCommentCharCount(const QStringRef &s)
+{
+    int i = 0;
+    for (const int size = s.size(); i < size && isCppCommentChar(s.at(i)); ++i) {
+    }
+    return i;
+}
+
+void Uic::writeCopyrightHeaderPython(const DomUI *ui) const
+{
+    QString comment = ui->elementComment();
+    if (!comment.isEmpty()) {
+        const auto lines = comment.splitRef(QLatin1Char('\n'));
+        for (const auto &line : lines) {
+            if (const int leadingCommentChars = leadingCppCommentCharCount(line)) {
+                 out << language::repeat(leadingCommentChars, '#')
+                     << line.right(line.size() - leadingCommentChars);
+            } else {
+                if (!line.startsWith(QLatin1Char('#')))
+                    out << "# ";
+                out << line;
+            }
+            out << '\n';
+        }
+        out << '\n';
+    }
+
+    out << language::repeat(80, '#') << "\n## Form generated from reading UI file '"
+        << QFileInfo(opt.inputFile).fileName()
+        << "'\n##\n## Created by: Qt User Interface Compiler version " << QT_VERSION_STR
+        << "\n##\n## WARNING! All changes made in this file will be lost when recompiling UI file!\n"
+        << language::repeat(80, '#') << "\n\n";
+}
+
 // Check the version with a stream reader at the <ui> element.
 
 static double versionFromUiAttribute(QXmlStreamReader &reader)
@@ -172,128 +212,92 @@ DomUI *Uic::parseUiFile(QXmlStreamReader &reader)
 
 bool Uic::write(QIODevice *in)
 {
-    if (option().generator == Option::JavaGenerator) {
-         // the Java generator ignores header protection
-        opt.headerProtection = false;
-    }
-
-    DomUI *ui = 0;
+    QScopedPointer<DomUI> ui;
     {
         QXmlStreamReader reader;
         reader.setDevice(in);
-        ui = parseUiFile(reader);
-
-        if (!ui)
-            return false;
+        ui.reset(parseUiFile(reader));
     }
 
+    if (ui.isNull())
+        return false;
+
     double version = ui->attributeVersion().toDouble();
     if (version < 4.0) {
-        delete ui;
-
         fprintf(stderr, "uic: File generated with too old version of Qt Designer\n");
         return false;
     }
 
-    QString language = ui->attributeLanguage();
+    const QString &language = ui->attributeLanguage();
     driver()->setUseIdBasedTranslations(ui->attributeIdbasedtr());
 
-    bool rtn = false;
-
-    if (option().generator == Option::JavaGenerator) {
-#ifdef QT_UIC_JAVA_GENERATOR
-        if (language.toLower() != QLatin1String("jambi")) {
-            fprintf(stderr, "uic: File is not a 'jambi' form\n");
-            delete ui;
-            return false;
-        }
-        rtn = jwrite (ui);
-#else
-        fprintf(stderr, "uic: option to generate java code not compiled in\n");
-#endif
-    } else {
-#ifdef QT_UIC_CPP_GENERATOR
-        if (!language.isEmpty() && language.toLower() != QLatin1String("c++")) {
-            fprintf(stderr, "uic: File is not a 'c++' ui file, language=%s\n", qPrintable(language));
-            delete ui;
-            return false;
-        }
-
-        rtn = write (ui);
-#else
-        fprintf(stderr, "uic: option to generate cpp code not compiled in\n");
-#endif
+    if (!language.isEmpty() && language.compare(QLatin1String("c++"), Qt::CaseInsensitive) != 0) {
+        fprintf(stderr, "uic: File is not a \"c++\" ui file, language=%s\n", qPrintable(language));
+        return false;
     }
 
-    delete ui;
-
-    return rtn;
+    return write(ui.data());
 }
 
-#ifdef QT_UIC_CPP_GENERATOR
 bool Uic::write(DomUI *ui)
 {
-    using namespace CPP;
-
     if (!ui || !ui->elementWidget())
         return false;
 
-    if (opt.copyrightHeader)
-        writeCopyrightHeader(ui);
+    const auto lang = language::language();
+
+    if (lang == Language::Python)
+       out << "# -*- coding: utf-8 -*-\n\n";
 
-    if (opt.headerProtection) {
+    if (opt.copyrightHeader) {
+        switch (language::language()) {
+        case Language::Cpp:
+            writeCopyrightHeaderCpp(ui);
+            break;
+        case Language::Python:
+            writeCopyrightHeaderPython(ui);
+            break;
+        }
+    }
+
+    if (opt.headerProtection && lang == Language::Cpp) {
         writeHeaderProtectionStart();
         out << "\n";
     }
 
     pixFunction = ui->elementPixmapFunction();
-    if (pixFunction == QLatin1String("QPixmap::fromMimeSource"))
-        pixFunction = QLatin1String("qPixmapFromMimeSource");
+    if (pixFunction == QLatin1String("QPixmap::fromMimeSource")
+        || pixFunction == QLatin1String("qPixmapFromMimeSource")) {
+        fprintf(stderr, "%s: Warning: Obsolete pixmap function '%s' specified in the UI file.\n",
+                qPrintable(opt.messagePrefix()), qPrintable(pixFunction));
+        pixFunction.clear();
+    }
 
     info.acceptUI(ui);
     cWidgetsInfo.acceptUI(ui);
-    WriteIncludes writeIncludes(this);
-    writeIncludes.acceptUI(ui);
 
-    Validator(this).acceptUI(ui);
-    WriteDeclaration(this).acceptUI(ui);
+    switch (language::language()) {
+    case Language::Cpp: {
+        CPP::WriteIncludes writeIncludes(this);
+        writeIncludes.acceptUI(ui);
+        Validator(this).acceptUI(ui);
+        CPP::WriteDeclaration(this).acceptUI(ui);
+    }
+        break;
+    case Language::Python: {
+        Python::WriteImports writeImports(this);
+        writeImports.acceptUI(ui);
+        Validator(this).acceptUI(ui);
+        Python::WriteDeclaration(this).acceptUI(ui);
+    }
+        break;
+    }
 
-    if (opt.headerProtection)
+    if (opt.headerProtection && lang == Language::Cpp)
         writeHeaderProtectionEnd();
 
     return true;
 }
-#endif
-
-#ifdef QT_UIC_JAVA_GENERATOR
-bool Uic::jwrite(DomUI *ui)
-{
-    using namespace Java;
-
-    if (!ui || !ui->elementWidget())
-        return false;
-
-    if (opt.copyrightHeader)
-        writeCopyrightHeader(ui);
-
-    pixFunction = ui->elementPixmapFunction();
-    if (pixFunction == QLatin1String("QPixmap::fromMimeSource"))
-        pixFunction = QLatin1String("qPixmapFromMimeSource");
-
-    externalPix = ui->elementImages() == 0;
-
-    info.acceptUI(ui);
-    cWidgetsInfo.acceptUI(ui);
-    WriteIncludes(this).acceptUI(ui);
-
-    Validator(this).acceptUI(ui);
-    WriteDeclaration(this).acceptUI(ui);
-
-    return true;
-}
-#endif
-
-#ifdef QT_UIC_CPP_GENERATOR
 
 void Uic::writeHeaderProtectionStart()
 {
@@ -307,57 +311,35 @@ void Uic::writeHeaderProtectionEnd()
     QString h = drv->headerFileName();
     out << "#endif // " << h << "\n";
 }
-#endif
-
-bool Uic::isMainWindow(const QString &className) const
-{
-    return customWidgetsInfo()->extends(className, QLatin1String("QMainWindow"));
-}
-
-bool Uic::isToolBar(const QString &className) const
-{
-    return customWidgetsInfo()->extends(className, QLatin1String("QToolBar"));
-}
 
 bool Uic::isButton(const QString &className) const
 {
-    return customWidgetsInfo()->extends(className, QLatin1String("QRadioButton"))
-        || customWidgetsInfo()->extends(className, QLatin1String("QToolButton"))
-        || customWidgetsInfo()->extends(className, QLatin1String("QCheckBox"))
-        || customWidgetsInfo()->extends(className, QLatin1String("QPushButton"))
-        || customWidgetsInfo()->extends(className, QLatin1String("QCommandLinkButton"));
+    static const QStringList buttons = {
+        QLatin1String("QRadioButton"), QLatin1String("QToolButton"),
+        QLatin1String("QCheckBox"), QLatin1String("QPushButton"),
+        QLatin1String("QCommandLinkButton")
+    };
+    return customWidgetsInfo()->extendsOneOf(className, buttons);
 }
 
 bool Uic::isContainer(const QString &className) const
 {
-    return customWidgetsInfo()->extends(className, QLatin1String("QStackedWidget"))
-        || customWidgetsInfo()->extends(className, QLatin1String("QToolBox"))
-        || customWidgetsInfo()->extends(className, QLatin1String("QTabWidget"))
-        || customWidgetsInfo()->extends(className, QLatin1String("QScrollArea"))
-        || customWidgetsInfo()->extends(className, QLatin1String("QMdiArea"))
-        || customWidgetsInfo()->extends(className, QLatin1String("QWizard"))
-        || customWidgetsInfo()->extends(className, QLatin1String("QDockWidget"));
-}
-
-bool Uic::isCustomWidgetContainer(const QString &className) const
-{
-    return customWidgetsInfo()->isCustomWidgetContainer(className);
-}
-
-bool Uic::isStatusBar(const QString &className) const
-{
-    return customWidgetsInfo()->extends(className, QLatin1String("QStatusBar"));
-}
-
-bool Uic::isMenuBar(const QString &className) const
-{
-    return customWidgetsInfo()->extends(className, QLatin1String("QMenuBar"));
+    static const QStringList containers = {
+        QLatin1String("QStackedWidget"), QLatin1String("QToolBox"),
+        QLatin1String("QTabWidget"), QLatin1String("QScrollArea"),
+        QLatin1String("QMdiArea"), QLatin1String("QWizard"),
+        QLatin1String("QDockWidget")
+    };
+
+    return customWidgetsInfo()->extendsOneOf(className, containers);
 }
 
 bool Uic::isMenu(const QString &className) const
 {
-    return customWidgetsInfo()->extends(className, QLatin1String("QMenu"))
-        || customWidgetsInfo()->extends(className, QLatin1String("QPopupMenu"));
+    static const QStringList menus = {
+        QLatin1String("QMenu"), QLatin1String("QPopupMenu")
+    };
+    return customWidgetsInfo()->extendsOneOf(className, menus);
 }
 
 QT_END_NAMESPACE
diff --git a/src/tools/uic/uic.h b/src/tools/uic/uic.h
index 1c229bc516..f3dfd49149 100644
--- a/src/tools/uic/uic.h
+++ b/src/tools/uic/uic.h
@@ -53,7 +53,7 @@ struct Option;
 
 class Uic
 {
-    Q_DISABLE_COPY(Uic)
+    Q_DISABLE_COPY_MOVE(Uic)
 public:
     Uic(Driver *driver);
     ~Uic();
@@ -83,33 +83,21 @@ public:
 
     bool write(QIODevice *in);
 
-#ifdef QT_UIC_JAVA_GENERATOR
-    bool jwrite(DomUI *ui);
-#endif
-
-#ifdef QT_UIC_CPP_GENERATOR
     bool write(DomUI *ui);
-#endif
 
-    bool isMainWindow(const QString &className) const;
-    bool isToolBar(const QString &className) const;
-    bool isStatusBar(const QString &className) const;
     bool isButton(const QString &className) const;
     bool isContainer(const QString &className) const;
-    bool isCustomWidgetContainer(const QString &className) const;
-    bool isMenuBar(const QString &className) const;
     bool isMenu(const QString &className) const;
 
 private:
     // copyright header
-    void writeCopyrightHeader(DomUI *ui);
+    void writeCopyrightHeaderCpp(const DomUI *ui) const;
+    void writeCopyrightHeaderPython(const DomUI *ui) const;
     DomUI *parseUiFile(QXmlStreamReader &reader);
 
-#ifdef QT_UIC_CPP_GENERATOR
     // header protection
     void writeHeaderProtectionStart();
     void writeHeaderProtectionEnd();
-#endif
 
 private:
     Driver *drv;
diff --git a/src/tools/uic/uic.pri b/src/tools/uic/uic.pri
index 3f0bab05dd..1c9098dcf9 100644
--- a/src/tools/uic/uic.pri
+++ b/src/tools/uic/uic.pri
@@ -5,7 +5,6 @@ HEADERS += \
            $$PWD/customwidgetsinfo.h \
            $$PWD/databaseinfo.h \
            $$PWD/driver.h \
-           $$PWD/globaldefs.h \
            $$PWD/option.h \
            $$PWD/treewalker.h \
            $$PWD/utils.h \
diff --git a/src/tools/uic/uic.pro b/src/tools/uic/uic.pro
index 18511395d9..1bf8ef8ad3 100644
--- a/src/tools/uic/uic.pro
+++ b/src/tools/uic/uic.pro
@@ -5,7 +5,9 @@ option(host_build)
 DEFINES += QT_UIC QT_NO_CAST_FROM_ASCII QT_NO_FOREACH
 
 include(uic.pri)
+include(shared/shared.pri)
 include(cpp/cpp.pri)
+include(python/python.pri)
 
 HEADERS += uic.h
 
diff --git a/src/tools/uic/utils.h b/src/tools/uic/utils.h
index 3f32a532ca..34c4ab23d4 100644
--- a/src/tools/uic/utils.h
+++ b/src/tools/uic/utils.h
@@ -42,55 +42,6 @@ inline bool toBool(const QString &str)
 inline QString toString(const DomString *str)
 { return str ? str->text() : QString(); }
 
-inline QString fixString(const QString &str, const QString &indent)
-{
-    QString cursegment;
-    QStringList result;
-    const QByteArray utf8 = str.toUtf8();
-    const int utf8Length = utf8.length();
-
-    for (int i = 0; i < utf8Length; ++i) {
-        const uchar cbyte = utf8.at(i);
-        if (cbyte >= 0x80) {
-            cursegment += QLatin1Char('\\');
-            cursegment += QString::number(cbyte, 8);
-        } else {
-            switch(cbyte) {
-            case '\\':
-                cursegment += QLatin1String("\\\\"); break;
-            case '\"':
-                cursegment += QLatin1String("\\\""); break;
-            case '\r':
-                break;
-            case '\n':
-                cursegment += QLatin1String("\\n\"\n\""); break;
-            default:
-                cursegment += QLatin1Char(cbyte);
-            }
-        }
-
-        if (cursegment.length() > 1024) {
-            result << cursegment;
-            cursegment.clear();
-        }
-    }
-
-    if (!cursegment.isEmpty())
-        result << cursegment;
-
-
-    QString joinstr = QLatin1String("\"\n");
-    joinstr += indent;
-    joinstr += indent;
-    joinstr += QLatin1Char('"');
-
-    QString rc(QLatin1Char('"'));
-    rc += result.join(joinstr);
-    rc += QLatin1Char('"');
-
-    return rc;
-}
-
 inline QHash<QString, DomProperty *> propertyMap(const QList<DomProperty *> &properties)
 {
     QHash<QString, DomProperty *> map;