Merge remote branch 'qt/master' into lighthouse-master

59 files changed, 615 insertions, 463 deletions

diff --git a/tools/designer/src/components/buddyeditor/buddyeditor.cpp b/tools/designer/src/components/buddyeditor/buddyeditor.cpp
index e367f9a..4127d7c 100644
--- a/tools/designer/src/components/buddyeditor/buddyeditor.cpp
+++ b/tools/designer/src/components/buddyeditor/buddyeditor.cpp
@@ -153,13 +153,13 @@ void BuddyEditor::updateBackground()
 
     m_updating = true;
     QList<Connection *> newList;
-    const LabelList label_list = qFindChildren<QLabel*>(background());
+    const LabelList label_list = background()->findChildren<QLabel*>();
     foreach (QLabel *label, label_list) {
         const QString buddy_name = buddy(label, m_formWindow->core());
         if (buddy_name.isEmpty())
             continue;
 
-        const QList<QWidget *> targets = qFindChildren<QWidget*>(background(), buddy_name);
+        const QList<QWidget *> targets = background()->findChildren<QWidget*>(buddy_name);
         if (targets.isEmpty())
             continue;
 
@@ -238,12 +238,12 @@ void BuddyEditor::setBackground(QWidget *background)
     clear();
     ConnectionEdit::setBackground(background);
 
-    const LabelList label_list = qFindChildren<QLabel*>(background);
+    const LabelList label_list = background->findChildren<QLabel*>();
     foreach (QLabel *label, label_list) {
         const QString buddy_name = buddy(label, m_formWindow->core());
         if (buddy_name.isEmpty())
             continue;
-        QWidget *target = qFindChild<QWidget*>(background, buddy_name);
+        QWidget *target = background->findChild<QWidget*>(buddy_name);
         if (target == 0)
             continue;
 
@@ -297,7 +297,7 @@ void BuddyEditor::endConnection(QWidget *target, const QPoint &pos)
 
 void BuddyEditor::widgetRemoved(QWidget *widget)
 {
-    QList<QWidget*> child_list = qFindChildren<QWidget*>(widget);
+    QList<QWidget*> child_list = widget->findChildren<QWidget*>();
     child_list.prepend(widget);
 
     ConnectionSet remove_set;
@@ -354,7 +354,7 @@ void BuddyEditor::deleteSelected()
 void BuddyEditor::autoBuddy()
 {
     // Any labels?
-    LabelList labelList = qFindChildren<QLabel*>(background());
+    LabelList labelList = background()->findChildren<QLabel*>();
     if (labelList.empty())
         return;
     // Find already used buddies
diff --git a/tools/designer/src/components/formeditor/dpi_chooser.cpp b/tools/designer/src/components/formeditor/dpi_chooser.cpp
index e79c757..1eadfa5 100644
--- a/tools/designer/src/components/formeditor/dpi_chooser.cpp
+++ b/tools/designer/src/components/formeditor/dpi_chooser.cpp
@@ -97,13 +97,13 @@ DPI_Chooser::DPI_Chooser(QWidget *parent) :
     m_systemEntry->description = 0;
     const struct DPI_Entry *systemEntry = m_systemEntry;
     //: System resolution
-    m_predefinedCombo->addItem(tr("System (%1 x %2)").arg(m_systemEntry->dpiX).arg(m_systemEntry->dpiY), qVariantFromValue(systemEntry));
+    m_predefinedCombo->addItem(tr("System (%1 x %2)").arg(m_systemEntry->dpiX).arg(m_systemEntry->dpiY), QVariant::fromValue(systemEntry));
     // Devices. Exclude the system values as not to duplicate the entries
     const int predefinedCount = sizeof(dpiEntries)/sizeof(DPI_Entry);
     const struct DPI_Entry *ecend = dpiEntries + predefinedCount;
     for (const struct DPI_Entry *it = dpiEntries; it < ecend; ++it)
         if (it->dpiX != m_systemEntry->dpiX || it->dpiY != m_systemEntry->dpiY)
-            m_predefinedCombo->addItem(tr(it->description), qVariantFromValue(it));
+            m_predefinedCombo->addItem(tr(it->description), QVariant::fromValue(it));
     m_predefinedCombo->addItem(tr("User defined"));
 
     setFocusProxy(m_predefinedCombo);
diff --git a/tools/designer/src/components/formeditor/formeditor.qrc b/tools/designer/src/components/formeditor/formeditor.qrc
index 6510814..ed7e40e 100644
--- a/tools/designer/src/components/formeditor/formeditor.qrc
+++ b/tools/designer/src/components/formeditor/formeditor.qrc
@@ -153,6 +153,7 @@
     <file>images/win/textjustify.png</file>
     <file>images/win/textsuperscript.png</file>
     <file>images/win/textsubscript.png</file>
+    <file>images/win/simplifyrichtext.png</file>
     <file>images/win/back.png</file>
     <file>images/win/forward.png</file>
     <file>images/win/down.png</file>
@@ -167,6 +168,7 @@
     <file>images/mac/textjustify.png</file>
     <file>images/mac/textsuperscript.png</file>
     <file>images/mac/textsubscript.png</file>
+    <file>images/mac/simplifyrichtext.png</file>
   </qresource>
   <qresource prefix="/trolltech/brushes">
     <file>defaultbrushes.xml</file>
diff --git a/tools/designer/src/components/formeditor/formwindow.cpp b/tools/designer/src/components/formeditor/formwindow.cpp
index 15775f6..ebf00f9 100644
--- a/tools/designer/src/components/formeditor/formwindow.cpp
+++ b/tools/designer/src/components/formeditor/formwindow.cpp
@@ -387,7 +387,7 @@ void FormWindow::setCursorToAll(const QCursor &c, QWidget *start)
 {
 #ifndef QT_NO_CURSOR
     start->setCursor(c);
-    const QWidgetList widgets = qFindChildren<QWidget*>(start);
+    const QWidgetList widgets = start->findChildren<QWidget*>();
     foreach (QWidget *widget, widgets) {
         if (!qobject_cast<WidgetHandle*>(widget)) {
             widget->setCursor(c);
@@ -945,7 +945,7 @@ bool FormWindow::isMainContainer(const QWidget *w) const
 
 void FormWindow::updateChildSelections(QWidget *w)
 {
-    const QWidgetList l = qFindChildren<QWidget*>(w);
+    const QWidgetList l = w->findChildren<QWidget*>();
     if (!l.empty()) {
         const QWidgetList::const_iterator lcend = l.constEnd();
         for (QWidgetList::const_iterator it = l.constBegin(); it != lcend; ++it) {
@@ -1155,19 +1155,19 @@ bool FormWindow::unify(QObject *w, QString &s, bool changeIt)
         existingNames.insert(main->objectName());
 
     const QDesignerMetaDataBaseInterface *metaDataBase = core()->metaDataBase();
-    const QWidgetList widgetChildren = qFindChildren<QWidget*>(main);
+    const QWidgetList widgetChildren = main->findChildren<QWidget*>();
     if (!widgetChildren.empty())
         insertNames(metaDataBase, widgetChildren.constBegin(), widgetChildren.constEnd(), w, existingNames);
 
-    const QList<QLayout *> layoutChildren = qFindChildren<QLayout*>(main);
+    const QList<QLayout *> layoutChildren = main->findChildren<QLayout*>();
     if (!layoutChildren.empty())
         insertNames(metaDataBase, layoutChildren.constBegin(), layoutChildren.constEnd(), w, existingNames);
 
-    const QList<QAction *> actionChildren = qFindChildren<QAction*>(main);
+    const QList<QAction *> actionChildren = main->findChildren<QAction*>();
     if (!actionChildren.empty())
         insertNames(metaDataBase, actionChildren.constBegin(), actionChildren.constEnd(), w, existingNames);
 
-    const QList<QButtonGroup *> buttonGroupChildren = qFindChildren<QButtonGroup*>(main);
+    const QList<QButtonGroup *> buttonGroupChildren = main->findChildren<QButtonGroup*>();
     if (!buttonGroupChildren.empty())
         insertNames(metaDataBase, buttonGroupChildren.constBegin(), buttonGroupChildren.constEnd(), w, existingNames);
 
@@ -1283,7 +1283,7 @@ void FormWindow::resizeWidget(QWidget *widget, const QRect &geometry)
 
 void FormWindow::raiseChildSelections(QWidget *w)
 {
-    const QWidgetList l = qFindChildren<QWidget*>(w);
+    const QWidgetList l = w->findChildren<QWidget*>();
     if (l.isEmpty())
         return;
     m_selection->raiseList(l);
@@ -1344,7 +1344,7 @@ QWidgetList FormWindow::selectedWidgets() const
 void FormWindow::selectWidgets()
 {
     bool selectionChanged = false;
-    const QWidgetList l = qFindChildren<QWidget*>(mainContainer());
+    const QWidgetList l = mainContainer()->findChildren<QWidget*>();
     QListIterator <QWidget*> it(l);
     const QRect selRect(mapToGlobal(m_currRect.topLeft()), m_currRect.size());
     while (it.hasNext()) {
@@ -1523,7 +1523,7 @@ void ArrowKeyPropertyCommand::init(QWidgetList &l, const ArrowKeyOperation &op)
     QObjectList ol;
     foreach(QWidget *w, l)
         ol.push_back(w);
-    SetPropertyCommand::init(ol, QLatin1String("geometry"), qVariantFromValue(op));
+    SetPropertyCommand::init(ol, QLatin1String("geometry"), QVariant::fromValue(op));
 
     setText(op.resize ? FormWindow::tr("Key Resize") : FormWindow::tr("Key Move"));
 }
@@ -1531,14 +1531,14 @@ void ArrowKeyPropertyCommand::init(QWidgetList &l, const ArrowKeyOperation &op)
 QVariant ArrowKeyPropertyCommand::mergeValue(const QVariant &newMergeValue)
 {
     // Merge move operations of the same arrow key
-    if (!qVariantCanConvert<ArrowKeyOperation>(newMergeValue))
+    if (!newMergeValue.canConvert<ArrowKeyOperation>())
         return QVariant();
     ArrowKeyOperation mergedOperation = qvariant_cast<ArrowKeyOperation>(newValue());
     const ArrowKeyOperation newMergeOperation = qvariant_cast<ArrowKeyOperation>(newMergeValue);
     if (mergedOperation.resize != newMergeOperation.resize || mergedOperation.arrowKey != newMergeOperation.arrowKey)
         return QVariant();
     mergedOperation.distance += newMergeOperation.distance;
-    return qVariantFromValue(mergedOperation);
+    return QVariant::fromValue(mergedOperation);
 }
 
 void FormWindow::handleArrowKeyEvent(int key, Qt::KeyboardModifiers modifiers)
@@ -2241,7 +2241,7 @@ QAction *FormWindow::createSelectAncestorSubMenu(QWidget *w)
     for (int i = 0; i < size; i++) {
         QWidget *w = parents.at(i);
         QAction *a = ag->addAction(objectNameOf(w));
-        a->setData(qVariantFromValue(w));
+        a->setData(QVariant::fromValue(w));
         menu->addAction(a);
     }
     QAction *ma = new QAction(tr("Select Ancestor"), 0);
@@ -2796,7 +2796,7 @@ bool FormWindow::dropDockWidget(QDesignerDnDItemInterface *item, const QPoint &g
         PropertySheetEnumValue e = qvariant_cast<PropertySheetEnumValue>(propertySheet->property(propertySheet->indexOf(dockWidgetAreaName)));
         e.value = area;
         QVariant v;
-        qVariantSetValue(v, e);
+        v.setValue(e);
         SetPropertyCommand *cmd = new SetPropertyCommand(this);
         cmd->init(widget, dockWidgetAreaName, v);
         m_undoStack.push(cmd);
diff --git a/tools/designer/src/components/formeditor/images/mac/simplifyrichtext.png b/tools/designer/src/components/formeditor/images/mac/simplifyrichtext.png
new file mode 100644
index 0000000..a48e974
--- /dev/null
+++ b/tools/designer/src/components/formeditor/images/mac/simplifyrichtext.png
diff --git a/tools/designer/src/components/formeditor/images/win/simplifyrichtext.png b/tools/designer/src/components/formeditor/images/win/simplifyrichtext.png
new file mode 100644
index 0000000..e251cf7
--- /dev/null
+++ b/tools/designer/src/components/formeditor/images/win/simplifyrichtext.png
diff --git a/tools/designer/src/components/formeditor/qdesigner_resource.cpp b/tools/designer/src/components/formeditor/qdesigner_resource.cpp
index 1d78695..6c458f3 100644
--- a/tools/designer/src/components/formeditor/qdesigner_resource.cpp
+++ b/tools/designer/src/components/formeditor/qdesigner_resource.cpp
@@ -197,7 +197,7 @@ QVariant QDesignerResourceBuilder::loadResource(const QDir &workingDirectory, co
                     m_loadedQrcFiles.insert(QFileInfo(workingDirectory, dp->attributeResource()).absoluteFilePath(), false);
 #endif
             }
-            return qVariantFromValue(pixmap);
+            return QVariant::fromValue(pixmap);
         }
 
         case DomProperty::IconSet: {
@@ -227,7 +227,7 @@ QVariant QDesignerResourceBuilder::loadResource(const QDir &workingDirectory, co
                     m_loadedQrcFiles.insert(QFileInfo(workingDirectory, di->attributeResource()).absoluteFilePath(), false);
 #endif
             }
-            return qVariantFromValue(icon);
+            return QVariant::fromValue(icon);
         }
         default:
             break;
@@ -237,12 +237,12 @@ QVariant QDesignerResourceBuilder::loadResource(const QDir &workingDirectory, co
 
 QVariant QDesignerResourceBuilder::toNativeValue(const QVariant &value) const
 {
-    if (qVariantCanConvert<PropertySheetPixmapValue>(value)) {
+    if (value.canConvert<PropertySheetPixmapValue>()) {
         if (m_pixmapCache)
-            return m_pixmapCache->pixmap(qVariantValue<PropertySheetPixmapValue>(value));
-    } else if (qVariantCanConvert<PropertySheetIconValue>(value)) {
+            return m_pixmapCache->pixmap(qvariant_cast<PropertySheetPixmapValue>(value));
+    } else if (value.canConvert<PropertySheetIconValue>()) {
         if (m_iconCache)
-            return m_iconCache->icon(qVariantValue<PropertySheetIconValue>(value));
+            return m_iconCache->icon(qvariant_cast<PropertySheetIconValue>(value));
     }
     return value;
 }
@@ -250,7 +250,7 @@ QVariant QDesignerResourceBuilder::toNativeValue(const QVariant &value) const
 DomProperty *QDesignerResourceBuilder::saveResource(const QDir &workingDirectory, const QVariant &value) const
 {
     DomProperty *p = new DomProperty;
-    if (qVariantCanConvert<PropertySheetPixmapValue>(value)) {
+    if (value.canConvert<PropertySheetPixmapValue>()) {
         const PropertySheetPixmapValue pix = qvariant_cast<PropertySheetPixmapValue>(value);
         DomResourcePixmap *rp = new DomResourcePixmap;
         const QString pixPath = pix.path();
@@ -275,7 +275,7 @@ DomProperty *QDesignerResourceBuilder::saveResource(const QDir &workingDirectory
         }
         p->setElementPixmap(rp);
         return p;
-    } else if (qVariantCanConvert<PropertySheetIconValue>(value)) {
+    } else if (value.canConvert<PropertySheetIconValue>()) {
         const PropertySheetIconValue icon = qvariant_cast<PropertySheetIconValue>(value);
         const QMap<QPair<QIcon::Mode, QIcon::State>, PropertySheetPixmapValue> pixmaps = icon.paths();
         if (!pixmaps.isEmpty()) {
@@ -331,7 +331,7 @@ DomProperty *QDesignerResourceBuilder::saveResource(const QDir &workingDirectory
 
 bool QDesignerResourceBuilder::isResourceType(const QVariant &value) const
 {
-    if (qVariantCanConvert<PropertySheetPixmapValue>(value) || qVariantCanConvert<PropertySheetIconValue>(value))
+    if (value.canConvert<PropertySheetPixmapValue>() || value.canConvert<PropertySheetIconValue>())
         return true;
     return false;
 }
@@ -364,26 +364,26 @@ QVariant QDesignerTextBuilder::loadText(const DomProperty *text) const
         if (!translatable)
             strVal.setTranslatable(translatable);
     }
-    return qVariantFromValue(strVal);
+    return QVariant::fromValue(strVal);
 }
 
 QVariant QDesignerTextBuilder::toNativeValue(const QVariant &value) const
 {
-    if (qVariantCanConvert<PropertySheetStringValue>(value))
-        return qVariantFromValue(qVariantValue<PropertySheetStringValue>(value).value());
+    if (value.canConvert<PropertySheetStringValue>())
+        return QVariant::fromValue(qvariant_cast<PropertySheetStringValue>(value).value());
     return value;
 }
 
 DomProperty *QDesignerTextBuilder::saveText(const QVariant &value) const
 {
-    if (!qVariantCanConvert<PropertySheetStringValue>(value) && !qVariantCanConvert<QString>(value))
+    if (!value.canConvert<PropertySheetStringValue>() && !value.canConvert<QString>())
         return 0;
 
     DomProperty *property = new DomProperty();
     DomString *domStr = new DomString();
 
-    if (qVariantCanConvert<PropertySheetStringValue>(value)) {
-        PropertySheetStringValue str = qVariantValue<PropertySheetStringValue>(value);
+    if (value.canConvert<PropertySheetStringValue>()) {
+        PropertySheetStringValue str = qvariant_cast<PropertySheetStringValue>(value);
 
         domStr->setText(str.value());
 
@@ -475,7 +475,7 @@ void QDesignerResource::saveDom(DomUI *ui, QWidget *widget)
     if (classVar.canConvert(QVariant::String))
         classStr = classVar.toString();
     else
-        classStr = qVariantValue<PropertySheetStringValue>(classVar).value();
+        classStr = qvariant_cast<PropertySheetStringValue>(classVar).value();
     ui->setElementClass(classStr);
 
     for (int index = 0; index < m_formWindow->toolCount(); ++index) {
@@ -946,7 +946,7 @@ QWidget *QDesignerResource::create(DomWidget *ui_widget, QWidget *parentWidget)
             w->addAction(a);
         } else if (QActionGroup *g = m_actionGroups.value(name)) {
             w->addActions(g->actions());
-        } else if (QMenu *menu = qFindChild<QMenu*>(w, name)) {
+        } else if (QMenu *menu = w->findChild<QMenu*>(name)) {
             w->addAction(menu->menuAction());
             addMenuAction(menu->menuAction());
         }
@@ -1045,7 +1045,7 @@ static bool readDomEnumerationValue(const DomProperty *p,
     switch (p->kind()) {
     case DomProperty::Set: {
         const QVariant sheetValue = sheet->property(index);
-        if (qVariantCanConvert<PropertySheetFlagValue>(sheetValue)) {
+        if (sheetValue.canConvert<PropertySheetFlagValue>()) {
             const PropertySheetFlagValue f = qvariant_cast<PropertySheetFlagValue>(sheetValue);
             bool ok = false;
             v = f.metaFlags.parseFlags(p->elementSet(), &ok);
@@ -1057,7 +1057,7 @@ static bool readDomEnumerationValue(const DomProperty *p,
         break;
     case DomProperty::Enum: {
         const QVariant sheetValue = sheet->property(index);
-        if (qVariantCanConvert<PropertySheetEnumValue>(sheetValue)) {
+        if (sheetValue.canConvert<PropertySheetEnumValue>()) {
             const PropertySheetEnumValue e = qvariant_cast<PropertySheetEnumValue>(sheetValue);
             bool ok = false;
             v = e.metaEnum.parseEnum(p->elementEnum(), &ok);
@@ -1110,7 +1110,7 @@ void QDesignerResource::applyProperties(QObject *o, const QList<DomProperty*> &p
                     if (!translatable)
                         keyVal.setTranslatable(translatable);
                 }
-                v = qVariantFromValue(keyVal);
+                v = QVariant::fromValue(keyVal);
             } else {
                 const DomString *str = p->elementString();
                 PropertySheetStringValue strVal(v.toString());
@@ -1124,7 +1124,7 @@ void QDesignerResource::applyProperties(QObject *o, const QList<DomProperty*> &p
                     if (!translatable)
                         strVal.setTranslatable(translatable);
                 }
-                v = qVariantFromValue(strVal);
+                v = QVariant::fromValue(strVal);
             }
         }
 
@@ -1135,18 +1135,18 @@ void QDesignerResource::applyProperties(QObject *o, const QList<DomProperty*> &p
         } else if (dynamicPropertiesAllowed) {
             QVariant defaultValue = QVariant(v.type());
             bool isDefault = (v == defaultValue);
-            if (qVariantCanConvert<PropertySheetIconValue>(v)) {
+            if (v.canConvert<PropertySheetIconValue>()) {
                 defaultValue = QVariant(QVariant::Icon);
-                isDefault = (qVariantValue<PropertySheetIconValue>(v) == PropertySheetIconValue());
-            } else if (qVariantCanConvert<PropertySheetPixmapValue>(v)) {
+                isDefault = (qvariant_cast<PropertySheetIconValue>(v) == PropertySheetIconValue());
+            } else if (v.canConvert<PropertySheetPixmapValue>()) {
                 defaultValue = QVariant(QVariant::Pixmap);
-                isDefault = (qVariantValue<PropertySheetPixmapValue>(v) == PropertySheetPixmapValue());
-            } else if (qVariantCanConvert<PropertySheetStringValue>(v)) {
+                isDefault = (qvariant_cast<PropertySheetPixmapValue>(v) == PropertySheetPixmapValue());
+            } else if (v.canConvert<PropertySheetStringValue>()) {
                 defaultValue = QVariant(QVariant::String);
-                isDefault = (qVariantValue<PropertySheetStringValue>(v) == PropertySheetStringValue());
-            } else if (qVariantCanConvert<PropertySheetKeySequenceValue>(v)) {
+                isDefault = (qvariant_cast<PropertySheetStringValue>(v) == PropertySheetStringValue());
+            } else if (v.canConvert<PropertySheetKeySequenceValue>()) {
                 defaultValue = QVariant(QVariant::KeySequence);
-                isDefault = (qVariantValue<PropertySheetKeySequenceValue>(v) == PropertySheetKeySequenceValue());
+                isDefault = (qvariant_cast<PropertySheetKeySequenceValue>(v) == PropertySheetKeySequenceValue());
             }
             if (defaultValue.type() != QVariant::UserType) {
                 const int idx = dynamicSheet->addDynamicProperty(p->attributeName(), defaultValue);
@@ -1185,12 +1185,12 @@ QWidget *QDesignerResource::createWidget(const QString &widgetName, QWidget *par
     if (!qobject_cast<QMenu*>(w) && (!parentWidget || !container)) {
         m_formWindow->manageWidget(w);
         if (parentWidget) {
-            QList<QWidget *> list = qVariantValue<QWidgetList>(parentWidget->property("_q_widgetOrder"));
+            QList<QWidget *> list = qvariant_cast<QWidgetList>(parentWidget->property("_q_widgetOrder"));
             list.append(w);
-            parentWidget->setProperty("_q_widgetOrder", qVariantFromValue(list));
-            QList<QWidget *> zOrder = qVariantValue<QWidgetList>(parentWidget->property("_q_zOrder"));
+            parentWidget->setProperty("_q_widgetOrder", QVariant::fromValue(list));
+            QList<QWidget *> zOrder = qvariant_cast<QWidgetList>(parentWidget->property("_q_zOrder"));
             zOrder.append(w);
-            parentWidget->setProperty("_q_zOrder", qVariantFromValue(list));
+            parentWidget->setProperty("_q_zOrder", QVariant::fromValue(list));
         }
     } else {
         core()->metaDataBase()->add(w);
@@ -1320,7 +1320,7 @@ DomLayout *QDesignerResource::createDom(QLayout *layout, DomLayout *ui_parentLay
     QDesignerMetaDataBaseItemInterface *item = core()->metaDataBase()->item(layout);
 
     if (item == 0) {
-        layout = qFindChild<QLayout*>(layout);
+        layout = layout->findChild<QLayout*>();
         // refresh the meta database item
         item = core()->metaDataBase()->item(layout);
     }
@@ -1440,7 +1440,7 @@ void QDesignerResource::applyTabStops(QWidget *widget, DomTabStops *tabStops)
 
     QList<QWidget*> tabOrder;
     foreach (const QString &widgetName, tabStops->elementTabStop()) {
-        if (QWidget *w = qFindChild<QWidget*>(widget, widgetName)) {
+        if (QWidget *w = widget->findChild<QWidget*>(widgetName)) {
             tabOrder.append(w);
         }
     }
@@ -1605,8 +1605,8 @@ DomWidget *QDesignerResource::saveWidget(QTabWidget *widget, DomWidget *ui_paren
             // attribute `icon'
             widget->setCurrentIndex(i);
             QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(core()->extensionManager(), widget);
-            PropertySheetIconValue icon = qVariantValue<PropertySheetIconValue>(sheet->property(sheet->indexOf(QLatin1String("currentTabIcon"))));
-            DomProperty *p = resourceBuilder()->saveResource(workingDirectory(), qVariantFromValue(icon));
+            PropertySheetIconValue icon = qvariant_cast<PropertySheetIconValue>(sheet->property(sheet->indexOf(QLatin1String("currentTabIcon"))));
+            DomProperty *p = resourceBuilder()->saveResource(workingDirectory(), QVariant::fromValue(icon));
             if (p) {
                 p->setAttributeName(strings.iconAttribute);
                 ui_attribute_list.append(p);
@@ -1620,7 +1620,7 @@ DomWidget *QDesignerResource::saveWidget(QTabWidget *widget, DomWidget *ui_paren
 
             // attribute `toolTip'
             QVariant v = sheet->property(sheet->indexOf(QLatin1String("currentTabToolTip")));
-            if (!qVariantValue<PropertySheetStringValue>(v).value().isEmpty()) {
+            if (!qvariant_cast<PropertySheetStringValue>(v).value().isEmpty()) {
                 p = textBuilder()->saveText(v);
                 if (p) {
                     p->setAttributeName(strings.toolTipAttribute);
@@ -1630,7 +1630,7 @@ DomWidget *QDesignerResource::saveWidget(QTabWidget *widget, DomWidget *ui_paren
 
             // attribute `whatsThis'
             v = sheet->property(sheet->indexOf(QLatin1String("currentTabWhatsThis")));
-            if (!qVariantValue<PropertySheetStringValue>(v).value().isEmpty()) {
+            if (!qvariant_cast<PropertySheetStringValue>(v).value().isEmpty()) {
                 p = textBuilder()->saveText(v);
                 if (p) {
                     p->setAttributeName(strings.whatsThisAttribute);
@@ -1676,8 +1676,8 @@ DomWidget *QDesignerResource::saveWidget(QToolBox *widget, DomWidget *ui_parentW
             // attribute `icon'
             widget->setCurrentIndex(i);
             QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(core()->extensionManager(), widget);
-            PropertySheetIconValue icon = qVariantValue<PropertySheetIconValue>(sheet->property(sheet->indexOf(QLatin1String("currentItemIcon"))));
-            DomProperty *p = resourceBuilder()->saveResource(workingDirectory(), qVariantFromValue(icon));
+            PropertySheetIconValue icon = qvariant_cast<PropertySheetIconValue>(sheet->property(sheet->indexOf(QLatin1String("currentItemIcon"))));
+            DomProperty *p = resourceBuilder()->saveResource(workingDirectory(), QVariant::fromValue(icon));
             if (p) {
                 p->setAttributeName(strings.iconAttribute);
                 ui_attribute_list.append(p);
@@ -1690,7 +1690,7 @@ DomWidget *QDesignerResource::saveWidget(QToolBox *widget, DomWidget *ui_parentW
 
             // attribute `toolTip'
             QVariant v = sheet->property(sheet->indexOf(QLatin1String("currentItemToolTip")));
-            if (!qVariantValue<PropertySheetStringValue>(v).value().isEmpty()) {
+            if (!qvariant_cast<PropertySheetStringValue>(v).value().isEmpty()) {
                 p = textBuilder()->saveText(v);
                 if (p) {
                     p->setAttributeName(strings.toolTipAttribute);
@@ -2209,8 +2209,8 @@ DomProperty *QDesignerResource::createProperty(QObject *object, const QString &p
         return 0;
     }
 
-    if (qVariantCanConvert<PropertySheetFlagValue>(value)) {
-        const PropertySheetFlagValue f = qVariantValue<PropertySheetFlagValue>(value);
+    if (value.canConvert<PropertySheetFlagValue>()) {
+        const PropertySheetFlagValue f = qvariant_cast<PropertySheetFlagValue>(value);
         const QString flagString = f.metaFlags.toString(f.value, DesignerMetaFlags::FullyQualified);
         if (flagString.isEmpty())
             return 0;
@@ -2222,8 +2222,8 @@ DomProperty *QDesignerResource::createProperty(QObject *object, const QString &p
         p->setAttributeName(propertyName);
         p->setElementSet(flagString);
         return applyProperStdSetAttribute(object, propertyName, p);
-    } else if (qVariantCanConvert<PropertySheetEnumValue>(value)) {
-        const PropertySheetEnumValue e = qVariantValue<PropertySheetEnumValue>(value);
+    } else if (value.canConvert<PropertySheetEnumValue>()) {
+        const PropertySheetEnumValue e = qvariant_cast<PropertySheetEnumValue>(value);
         bool ok;
         const QString id = e.metaEnum.toString(e.value, DesignerMetaEnum::FullyQualified, &ok);
         if (!ok)
@@ -2238,8 +2238,8 @@ DomProperty *QDesignerResource::createProperty(QObject *object, const QString &p
         p->setAttributeName(propertyName);
         p->setElementEnum(id);
         return applyProperStdSetAttribute(object, propertyName, p);
-    } else if (qVariantCanConvert<PropertySheetStringValue>(value)) {
-        const PropertySheetStringValue strVal = qVariantValue<PropertySheetStringValue>(value);
+    } else if (value.canConvert<PropertySheetStringValue>()) {
+        const PropertySheetStringValue strVal = qvariant_cast<PropertySheetStringValue>(value);
         DomProperty *p = new DomProperty;
         if (!hasSetter(core(), object, propertyName))
             p->setAttributeStdset(0);
@@ -2249,8 +2249,8 @@ DomProperty *QDesignerResource::createProperty(QObject *object, const QString &p
         saveStringProperty(p, strVal);
 
         return applyProperStdSetAttribute(object, propertyName, p);
-    } else if (qVariantCanConvert<PropertySheetKeySequenceValue>(value)) {
-        const PropertySheetKeySequenceValue keyVal = qVariantValue<PropertySheetKeySequenceValue>(value);
+    } else if (value.canConvert<PropertySheetKeySequenceValue>()) {
+        const PropertySheetKeySequenceValue keyVal = qvariant_cast<PropertySheetKeySequenceValue>(value);
         DomProperty *p = new DomProperty;
         if (!hasSetter(core(), object, propertyName))
             p->setAttributeStdset(0);
diff --git a/tools/designer/src/components/formeditor/qmainwindow_container.cpp b/tools/designer/src/components/formeditor/qmainwindow_container.cpp
index 9b5326a..ef4ce85 100644
--- a/tools/designer/src/components/formeditor/qmainwindow_container.cpp
+++ b/tools/designer/src/components/formeditor/qmainwindow_container.cpp
@@ -104,7 +104,7 @@ Qt::DockWidgetArea dockWidgetArea(QDockWidget *me)
         QList<QLayout*> candidates;
         if (mw->layout()) {
             candidates.append(mw->layout());
-            candidates += qFindChildren<QLayout*>(mw->layout());
+            candidates += mw->layout()->findChildren<QLayout*>();
         }
         foreach (QLayout *l, candidates) {
             if (l->indexOf(me) != -1) {
diff --git a/tools/designer/src/components/objectinspector/objectinspectormodel.cpp b/tools/designer/src/components/objectinspector/objectinspectormodel.cpp
index 93e1df1..4bbacdb 100644
--- a/tools/designer/src/components/objectinspector/objectinspectormodel.cpp
+++ b/tools/designer/src/components/objectinspector/objectinspectormodel.cpp
@@ -273,7 +273,7 @@ namespace qdesigner_internal {
 
     void ObjectData::setItems(const StandardItemList &row, const ObjectInspectorIcons &icons) const
     {
-        const QVariant object = qVariantFromValue(m_object);
+        const QVariant object = QVariant::fromValue(m_object);
         row[ObjectInspectorModel::ObjectNameColumn]->setData(object, DataRole);
         row[ObjectInspectorModel::ClassNameColumn]->setData(object, DataRole);
         setItemsDisplayData(row, icons, ClassNameChanged|ObjectNameChanged|ClassIconChanged|TypeChanged|LayoutTypeChanged);
diff --git a/tools/designer/src/components/propertyeditor/brushpropertymanager.cpp b/tools/designer/src/components/propertyeditor/brushpropertymanager.cpp
index 2300b47..fffdc29 100644
--- a/tools/designer/src/components/propertyeditor/brushpropertymanager.cpp
+++ b/tools/designer/src/components/propertyeditor/brushpropertymanager.cpp
@@ -163,7 +163,7 @@ void BrushPropertyManager::initializeProperty(QtVariantPropertyManager *vm, QtPr
     for (int i = 0; i < brushStyleCount; i++)
         styles.push_back(QCoreApplication::translate("BrushPropertyManager", brushStyles[i]));
     styleSubProperty->setAttribute(QLatin1String("enumNames"), styles);
-    styleSubProperty->setAttribute(QLatin1String("enumIcons"), qVariantFromValue(brushStyleIcons()));
+    styleSubProperty->setAttribute(QLatin1String("enumIcons"), QVariant::fromValue(brushStyleIcons()));
     m_brushPropertyToStyleSubProperty.insert(property, styleSubProperty);
     m_brushStyleSubPropertyToProperty.insert(styleSubProperty, property);
     // color
diff --git a/tools/designer/src/components/propertyeditor/designerpropertymanager.cpp b/tools/designer/src/components/propertyeditor/designerpropertymanager.cpp
index 9ab2940..e251511 100644
--- a/tools/designer/src/components/propertyeditor/designerpropertymanager.cpp
+++ b/tools/designer/src/components/propertyeditor/designerpropertymanager.cpp
@@ -740,7 +740,7 @@ void DesignerPropertyManager::slotValueChanged(QtProperty *property, const QVari
         m_changingSubValue = false;
         data.val = newValue;
         QVariant v;
-        qVariantSetValue(v, data.val);
+        v.setValue(data.val);
         variantProperty(flagProperty)->setValue(v);
     } else if (QtProperty *alignProperty = m_alignHToProperty.value(property, 0)) {
         const uint v = m_alignValues.value(alignProperty);
@@ -763,7 +763,7 @@ void DesignerPropertyManager::slotValueChanged(QtProperty *property, const QVari
         if (v == newValue)
             return;
 
-        variantProperty(stringProperty)->setValue(qVariantFromValue(newValue));
+        variantProperty(stringProperty)->setValue(QVariant::fromValue(newValue));
     } else if (QtProperty *stringProperty = m_translatableToString.value(property, 0)) {
         const PropertySheetStringValue v = m_stringValues.value(stringProperty);
         PropertySheetStringValue newValue = v;
@@ -771,7 +771,7 @@ void DesignerPropertyManager::slotValueChanged(QtProperty *property, const QVari
         if (v == newValue)
             return;
 
-        variantProperty(stringProperty)->setValue(qVariantFromValue(newValue));
+        variantProperty(stringProperty)->setValue(QVariant::fromValue(newValue));
     } else if (QtProperty *stringProperty = m_disambiguationToString.value(property, 0)) {
         const PropertySheetStringValue v = m_stringValues.value(stringProperty);
         PropertySheetStringValue newValue = v;
@@ -779,7 +779,7 @@ void DesignerPropertyManager::slotValueChanged(QtProperty *property, const QVari
         if (v == newValue)
             return;
 
-        variantProperty(stringProperty)->setValue(qVariantFromValue(newValue));
+        variantProperty(stringProperty)->setValue(QVariant::fromValue(newValue));
     } else if (QtProperty *keySequenceProperty = m_commentToKeySequence.value(property, 0)) {
         const PropertySheetKeySequenceValue v = m_keySequenceValues.value(keySequenceProperty);
         PropertySheetKeySequenceValue newValue = v;
@@ -787,7 +787,7 @@ void DesignerPropertyManager::slotValueChanged(QtProperty *property, const QVari
         if (v == newValue)
             return;
 
-        variantProperty(keySequenceProperty)->setValue(qVariantFromValue(newValue));
+        variantProperty(keySequenceProperty)->setValue(QVariant::fromValue(newValue));
     } else if (QtProperty *keySequenceProperty = m_translatableToKeySequence.value(property, 0)) {
         const PropertySheetKeySequenceValue v = m_keySequenceValues.value(keySequenceProperty);
         PropertySheetKeySequenceValue newValue = v;
@@ -795,7 +795,7 @@ void DesignerPropertyManager::slotValueChanged(QtProperty *property, const QVari
         if (v == newValue)
             return;
 
-        variantProperty(keySequenceProperty)->setValue(qVariantFromValue(newValue));
+        variantProperty(keySequenceProperty)->setValue(QVariant::fromValue(newValue));
     } else if (QtProperty *keySequenceProperty = m_disambiguationToKeySequence.value(property, 0)) {
         const PropertySheetKeySequenceValue v = m_keySequenceValues.value(keySequenceProperty);
         PropertySheetKeySequenceValue newValue = v;
@@ -803,16 +803,16 @@ void DesignerPropertyManager::slotValueChanged(QtProperty *property, const QVari
         if (v == newValue)
             return;
 
-        variantProperty(keySequenceProperty)->setValue(qVariantFromValue(newValue));
+        variantProperty(keySequenceProperty)->setValue(QVariant::fromValue(newValue));
     } else if (QtProperty *iProperty = m_iconSubPropertyToProperty.value(property, 0)) {
         QtVariantProperty *iconProperty = variantProperty(iProperty);
-        PropertySheetIconValue icon = qVariantValue<PropertySheetIconValue>(iconProperty->value());
+        PropertySheetIconValue icon = qvariant_cast<PropertySheetIconValue>(iconProperty->value());
         QPair<QIcon::Mode, QIcon::State> pair = m_iconSubPropertyToState.value(property);
-        icon.setPixmap(pair.first, pair.second, qVariantValue<PropertySheetPixmapValue>(value));
+        icon.setPixmap(pair.first, pair.second, qvariant_cast<PropertySheetPixmapValue>(value));
         QtProperty *origSourceOfChange = m_sourceOfChange;
         if (!origSourceOfChange)
             m_sourceOfChange = property;
-        iconProperty->setValue(qVariantFromValue(icon));
+        iconProperty->setValue(QVariant::fromValue(icon));
         if (!origSourceOfChange)
             m_sourceOfChange = origSourceOfChange;
     } else if (m_iconValues.contains(property)) {
@@ -933,7 +933,7 @@ QVariant DesignerPropertyManager::attributeValue(const QtProperty *property, con
         PropertyFlagDataMap::const_iterator it = m_flagValues.constFind(prop);
         if (it != m_flagValues.constEnd()) {
             QVariant v;
-            qVariantSetValue(v, it.value().flags);
+            v.setValue(it.value().flags);
             return v;
         }
     }
@@ -985,7 +985,7 @@ void DesignerPropertyManager::setAttribute(QtProperty *property,
         if (value.userType() != designerFlagListTypeId())
             return;
 
-        const DesignerFlagList flags = qVariantValue<DesignerFlagList>(value);
+        const DesignerFlagList flags = qvariant_cast<DesignerFlagList>(value);
         PropertyFlagDataMap::iterator fit = m_flagValues.find(property);
         FlagData data = fit.value();
         if (data.flags == flags)
@@ -1022,7 +1022,7 @@ void DesignerPropertyManager::setAttribute(QtProperty *property,
         fit.value() = data;
 
         QVariant v;
-        qVariantSetValue(v, flags);
+        v.setValue(flags);
         emit attributeChanged(property, attribute, v);
 
         emit propertyChanged(property);
@@ -1061,7 +1061,7 @@ void DesignerPropertyManager::setAttribute(QtProperty *property,
         if (value.userType() != QVariant::Palette)
             return;
 
-        QPalette superPalette = qVariantValue<QPalette>(value);
+        QPalette superPalette = qvariant_cast<QPalette>(value);
 
         const PropertyPaletteDataMap::iterator it = m_paletteValues.find(property);
         PaletteData data = it.value();
@@ -1077,7 +1077,7 @@ void DesignerPropertyManager::setAttribute(QtProperty *property,
         it.value() = data;
 
         QVariant v;
-        qVariantSetValue(v, superPalette);
+        v.setValue(superPalette);
         emit attributeChanged(property, attribute, v);
 
         emit propertyChanged(property);
@@ -1086,7 +1086,7 @@ void DesignerPropertyManager::setAttribute(QtProperty *property,
         if (value.userType() != QVariant::Pixmap)
             return;
 
-        QPixmap defaultPixmap = qVariantValue<QPixmap>(value);
+        QPixmap defaultPixmap = qvariant_cast<QPixmap>(value);
 
         const QMap<QtProperty *, QPixmap>::iterator it = m_defaultPixmaps.find(property);
         QPixmap oldDefaultPixmap = it.value();
@@ -1095,7 +1095,7 @@ void DesignerPropertyManager::setAttribute(QtProperty *property,
 
         it.value() = defaultPixmap;
 
-        QVariant v = qVariantFromValue(defaultPixmap);
+        QVariant v = QVariant::fromValue(defaultPixmap);
         emit attributeChanged(property, attribute, v);
 
         emit propertyChanged(property);
@@ -1103,7 +1103,7 @@ void DesignerPropertyManager::setAttribute(QtProperty *property,
         if (value.userType() != QVariant::Icon)
             return;
 
-        QIcon defaultIcon = qVariantValue<QIcon>(value);
+        QIcon defaultIcon = qvariant_cast<QIcon>(value);
 
         const QMap<QtProperty *, QIcon>::iterator it = m_defaultIcons.find(property);
         QIcon oldDefaultIcon = it.value();
@@ -1124,7 +1124,7 @@ void DesignerPropertyManager::setAttribute(QtProperty *property,
             }
         }
 
-        QVariant v = qVariantFromValue(defaultIcon);
+        QVariant v = QVariant::fromValue(defaultIcon);
         emit attributeChanged(property, attribute, v);
 
         emit propertyChanged(property);
@@ -1265,12 +1265,12 @@ QString DesignerPropertyManager::valueText(const QtProperty *property) const
         return m_stringListValues.value(const_cast<QtProperty *>(property)).join(QLatin1String("; "));
     }
     if (QtVariantPropertyManager::valueType(property) == QVariant::String || QtVariantPropertyManager::valueType(property) == designerStringTypeId()) {
-        const QString str = (QtVariantPropertyManager::valueType(property) == QVariant::String) ? value(property).toString() : qVariantValue<PropertySheetStringValue>(value(property)).value();
+        const QString str = (QtVariantPropertyManager::valueType(property) == QVariant::String) ? value(property).toString() : qvariant_cast<PropertySheetStringValue>(value(property)).value();
         const int validationMode = attributeValue(property, QLatin1String(validationModesAttributeC)).toInt();
         return TextPropertyEditor::stringToEditorString(str, static_cast<TextPropertyValidationMode>(validationMode));
     }
     if (QtVariantPropertyManager::valueType(property) == designerKeySequenceTypeId()) {
-        return qVariantValue<PropertySheetKeySequenceValue>(value(property)).value();
+        return qvariant_cast<PropertySheetKeySequenceValue>(value(property)).value();
     }
     if (QtVariantPropertyManager::valueType(property) == QVariant::Bool) {
         return QString();
@@ -1313,13 +1313,13 @@ void DesignerPropertyManager::reloadResourceProperties()
         }
 
         emit propertyChanged(property);
-        emit QtVariantPropertyManager::valueChanged(property, qVariantFromValue(itIcon.value()));
+        emit QtVariantPropertyManager::valueChanged(property, QVariant::fromValue(itIcon.value()));
     }
     QMapIterator<QtProperty *, qdesigner_internal::PropertySheetPixmapValue> itPix(m_pixmapValues);
     while (itPix.hasNext()) {
         QtProperty *property = itPix.next().key();
         emit propertyChanged(property);
-        emit QtVariantPropertyManager::valueChanged(property, qVariantFromValue(itPix.value()));
+        emit QtVariantPropertyManager::valueChanged(property, QVariant::fromValue(itPix.value()));
     }
 }
 
@@ -1357,13 +1357,13 @@ QVariant DesignerPropertyManager::value(const QtProperty *property) const
     if (m_paletteValues.contains(const_cast<QtProperty *>(property)))
         return m_paletteValues.value(const_cast<QtProperty *>(property)).val;
     if (m_iconValues.contains(const_cast<QtProperty *>(property)))
-        return qVariantFromValue(m_iconValues.value(const_cast<QtProperty *>(property)));
+        return QVariant::fromValue(m_iconValues.value(const_cast<QtProperty *>(property)));
     if (m_pixmapValues.contains(const_cast<QtProperty *>(property)))
-        return qVariantFromValue(m_pixmapValues.value(const_cast<QtProperty *>(property)));
+        return QVariant::fromValue(m_pixmapValues.value(const_cast<QtProperty *>(property)));
     if (m_stringValues.contains(const_cast<QtProperty *>(property)))
-        return qVariantFromValue(m_stringValues.value(const_cast<QtProperty *>(property)));
+        return QVariant::fromValue(m_stringValues.value(const_cast<QtProperty *>(property)));
     if (m_keySequenceValues.contains(const_cast<QtProperty *>(property)))
-        return qVariantFromValue(m_keySequenceValues.value(const_cast<QtProperty *>(property)));
+        return QVariant::fromValue(m_keySequenceValues.value(const_cast<QtProperty *>(property)));
     if (m_uintValues.contains(const_cast<QtProperty *>(property)))
         return m_uintValues.value(const_cast<QtProperty *>(property));
     if (m_longLongValues.contains(const_cast<QtProperty *>(property)))
@@ -1497,7 +1497,7 @@ void DesignerPropertyManager::setValue(QtProperty *property, const QVariant &val
         if (value.userType() != designerStringTypeId())
             return;
 
-        const PropertySheetStringValue v = qVariantValue<PropertySheetStringValue>(value);
+        const PropertySheetStringValue v = qvariant_cast<PropertySheetStringValue>(value);
 
         const PropertySheetStringValue val = m_stringValues.value(property);
 
@@ -1517,7 +1517,7 @@ void DesignerPropertyManager::setValue(QtProperty *property, const QVariant &val
 
         m_stringValues[property] = v;
 
-        emit QtVariantPropertyManager::valueChanged(property, qVariantFromValue(v));
+        emit QtVariantPropertyManager::valueChanged(property, QVariant::fromValue(v));
         emit propertyChanged(property);
 
         return;
@@ -1525,7 +1525,7 @@ void DesignerPropertyManager::setValue(QtProperty *property, const QVariant &val
         if (value.userType() != designerKeySequenceTypeId())
             return;
 
-        const PropertySheetKeySequenceValue v = qVariantValue<PropertySheetKeySequenceValue>(value);
+        const PropertySheetKeySequenceValue v = qvariant_cast<PropertySheetKeySequenceValue>(value);
 
         const PropertySheetKeySequenceValue val = m_keySequenceValues.value(property);
 
@@ -1545,7 +1545,7 @@ void DesignerPropertyManager::setValue(QtProperty *property, const QVariant &val
 
         m_keySequenceValues[property] = v;
 
-        emit QtVariantPropertyManager::valueChanged(property, qVariantFromValue(v));
+        emit QtVariantPropertyManager::valueChanged(property, QVariant::fromValue(v));
         emit propertyChanged(property);
 
         return;
@@ -1553,7 +1553,7 @@ void DesignerPropertyManager::setValue(QtProperty *property, const QVariant &val
         if (value.type() != QVariant::Palette && !value.canConvert(QVariant::Palette))
             return;
 
-        QPalette p = qVariantValue<QPalette>(value);
+        QPalette p = qvariant_cast<QPalette>(value);
 
         PaletteData data = m_paletteValues.value(property);
 
@@ -1575,7 +1575,7 @@ void DesignerPropertyManager::setValue(QtProperty *property, const QVariant &val
         if (value.userType() != designerIconTypeId())
             return;
 
-        const PropertySheetIconValue icon = qVariantValue<PropertySheetIconValue>(value);
+        const PropertySheetIconValue icon = qvariant_cast<PropertySheetIconValue>(value);
 
         const PropertySheetIconValue oldIcon = m_iconValues.value(property);
         if (icon == oldIcon)
@@ -1600,12 +1600,12 @@ void DesignerPropertyManager::setValue(QtProperty *property, const QVariant &val
             QtVariantProperty *subProperty = variantProperty(itSub.value());
             bool hasPath = iconPaths.contains(pair);
             subProperty->setModified(hasPath);
-            subProperty->setValue(qVariantFromValue(iconPaths.value(pair)));
+            subProperty->setValue(QVariant::fromValue(iconPaths.value(pair)));
             subProperty->setAttribute(QLatin1String(defaultResourceAttributeC),
                                       defaultIcon.pixmap(16, 16, pair.first, pair.second));
         }
 
-        emit QtVariantPropertyManager::valueChanged(property, qVariantFromValue(icon));
+        emit QtVariantPropertyManager::valueChanged(property, QVariant::fromValue(icon));
         emit propertyChanged(property);
 
         QString toolTip;
@@ -1620,7 +1620,7 @@ void DesignerPropertyManager::setValue(QtProperty *property, const QVariant &val
         if (value.userType() != designerPixmapTypeId())
             return;
 
-        const PropertySheetPixmapValue pixmap = qVariantValue<PropertySheetPixmapValue>(value);
+        const PropertySheetPixmapValue pixmap = qvariant_cast<PropertySheetPixmapValue>(value);
 
         const PropertySheetPixmapValue oldPixmap = m_pixmapValues.value(property);
         if (pixmap == oldPixmap)
@@ -1628,7 +1628,7 @@ void DesignerPropertyManager::setValue(QtProperty *property, const QVariant &val
 
         m_pixmapValues[property] = pixmap;
 
-        emit QtVariantPropertyManager::valueChanged(property, qVariantFromValue(pixmap));
+        emit QtVariantPropertyManager::valueChanged(property, QVariant::fromValue(pixmap));
         emit propertyChanged(property);
 
         property->setToolTip(pixmap.path());
@@ -1746,9 +1746,9 @@ void DesignerPropertyManager::setValue(QtProperty *property, const QVariant &val
     if (QtVariantPropertyManager::valueType(property) == QVariant::String)
         property->setToolTip(DesignerPropertyManager::value(property).toString());
     else if (QtVariantPropertyManager::valueType(property) == designerStringTypeId())
-        property->setToolTip(qVariantValue<PropertySheetStringValue>(DesignerPropertyManager::value(property)).value());
+        property->setToolTip(qvariant_cast<PropertySheetStringValue>(DesignerPropertyManager::value(property)).value());
     else if (QtVariantPropertyManager::valueType(property) == designerKeySequenceTypeId())
-        property->setToolTip(qVariantValue<PropertySheetKeySequenceValue>(DesignerPropertyManager::value(property)).value());
+        property->setToolTip(qvariant_cast<PropertySheetKeySequenceValue>(DesignerPropertyManager::value(property)).value());
     else if (QtVariantPropertyManager::valueType(property) == QVariant::Bool)
         property->setToolTip(QtVariantPropertyManager::valueText(property));
 }
@@ -2017,7 +2017,7 @@ bool DesignerPropertyManager::resetIconSubProperty(QtProperty *property)
         return false;
 
     QtVariantProperty *pixmapProperty = variantProperty(property);
-    pixmapProperty->setValue(qVariantFromValue(PropertySheetPixmapValue()));
+    pixmapProperty->setValue(QVariant::fromValue(PropertySheetPixmapValue()));
     return true;
 }
 
@@ -2131,7 +2131,7 @@ void DesignerEditorFactory::slotPropertyChanged(QtProperty *property)
         if (!property->isModified())
             defaultPixmap = qvariant_cast<QIcon>(manager->attributeValue(property, QLatin1String(defaultResourceAttributeC))).pixmap(16, 16);
         else if (m_fwb)
-            defaultPixmap = m_fwb->iconCache()->icon(qVariantValue<PropertySheetIconValue>(manager->value(property))).pixmap(16, 16);
+            defaultPixmap = m_fwb->iconCache()->icon(qvariant_cast<PropertySheetIconValue>(manager->value(property))).pixmap(16, 16);
         QList<PixmapEditor *> editors = m_iconPropertyToEditors.value(property);
         QListIterator<PixmapEditor *> it(editors);
         while (it.hasNext()) {
@@ -2175,13 +2175,13 @@ void DesignerEditorFactory::slotValueChanged(QtProperty *property, const QVarian
         break;
     default:
         if (type == DesignerPropertyManager::designerIconTypeId())
-            applyToEditors(m_iconPropertyToEditors.value(property), &PixmapEditor::setPath, qVariantValue<PropertySheetIconValue>(value).pixmap(QIcon::Normal, QIcon::Off).path());
+            applyToEditors(m_iconPropertyToEditors.value(property), &PixmapEditor::setPath, qvariant_cast<PropertySheetIconValue>(value).pixmap(QIcon::Normal, QIcon::Off).path());
         else if (type == DesignerPropertyManager::designerPixmapTypeId())
-            applyToEditors(m_pixmapPropertyToEditors.value(property), &PixmapEditor::setPath, qVariantValue<PropertySheetPixmapValue>(value).path());
+            applyToEditors(m_pixmapPropertyToEditors.value(property), &PixmapEditor::setPath, qvariant_cast<PropertySheetPixmapValue>(value).path());
         else if (type == DesignerPropertyManager::designerStringTypeId())
-            applyToEditors(m_stringPropertyToEditors.value(property), &TextEditor::setText, qVariantValue<PropertySheetStringValue>(value).value());
+            applyToEditors(m_stringPropertyToEditors.value(property), &TextEditor::setText, qvariant_cast<PropertySheetStringValue>(value).value());
         else if (type == DesignerPropertyManager::designerKeySequenceTypeId())
-            applyToEditors(m_keySequencePropertyToEditors.value(property), &QtKeySequenceEdit::setKeySequence, qVariantValue<PropertySheetKeySequenceValue>(value).value());
+            applyToEditors(m_keySequencePropertyToEditors.value(property), &QtKeySequenceEdit::setKeySequence, qvariant_cast<PropertySheetKeySequenceValue>(value).value());
         break;
     }
 }
@@ -2324,7 +2324,7 @@ QWidget *DesignerEditorFactory::createEditor(QtVariantPropertyManager *manager,
             editor = ed;
         } else if (type == DesignerPropertyManager::designerStringTypeId()) {
             const TextPropertyValidationMode tvm = static_cast<TextPropertyValidationMode>(manager->attributeValue(property, QLatin1String(validationModesAttributeC)).toInt());
-            TextEditor *ed = createTextEditor(parent, tvm, qVariantValue<PropertySheetStringValue>(manager->value(property)).value());
+            TextEditor *ed = createTextEditor(parent, tvm, qvariant_cast<PropertySheetStringValue>(manager->value(property)).value());
             const QVariant richTextDefaultFont = manager->attributeValue(property, QLatin1String(fontAttributeC));
             if (richTextDefaultFont.type() == QVariant::Font)
                 ed->setRichTextDefaultFont(qvariant_cast<QFont>(richTextDefaultFont));
@@ -2335,7 +2335,7 @@ QWidget *DesignerEditorFactory::createEditor(QtVariantPropertyManager *manager,
             editor = ed;
         } else if (type == DesignerPropertyManager::designerKeySequenceTypeId()) {
             QtKeySequenceEdit *ed = new QtKeySequenceEdit(parent);
-            ed->setKeySequence(qVariantValue<PropertySheetKeySequenceValue>(manager->value(property)).value());
+            ed->setKeySequence(qvariant_cast<PropertySheetKeySequenceValue>(manager->value(property)).value());
             m_keySequencePropertyToEditors[property].append(ed);
             m_editorToKeySequenceProperty[ed] = property;
             connect(ed, SIGNAL(destroyed(QObject*)), this, SLOT(slotEditorDestroyed(QObject*)));
@@ -2456,12 +2456,12 @@ void DesignerEditorFactory::slotStringTextChanged(const QString &value)
             QtVariantProperty *varProp = manager->variantProperty(prop);
             QVariant val = varProp->value();
             if (val.userType() == DesignerPropertyManager::designerStringTypeId()) {
-                PropertySheetStringValue strVal = qVariantValue<PropertySheetStringValue>(val);
+                PropertySheetStringValue strVal = qvariant_cast<PropertySheetStringValue>(val);
                 strVal.setValue(value);
                 // Disable translation if no translation subproperties exist.
                 if (varProp->subProperties().empty())
                     strVal.setTranslatable(false);
-                val = qVariantFromValue(strVal);
+                val = QVariant::fromValue(strVal);
             } else {
                 val = QVariant(value);
             }
@@ -2482,11 +2482,11 @@ void DesignerEditorFactory::slotKeySequenceChanged(const QKeySequence &value)
             QtVariantProperty *varProp = manager->variantProperty(prop);
             QVariant val = varProp->value();
             if (val.userType() == DesignerPropertyManager::designerKeySequenceTypeId()) {
-                PropertySheetKeySequenceValue keyVal = qVariantValue<PropertySheetKeySequenceValue>(val);
+                PropertySheetKeySequenceValue keyVal = qvariant_cast<PropertySheetKeySequenceValue>(val);
                 keyVal.setValue(value);
-                val = qVariantFromValue(keyVal);
+                val = QVariant::fromValue(keyVal);
             } else {
-                val = qVariantFromValue(value);
+                val = QVariant::fromValue(value);
             }
             m_changingPropertyValue = true;
             manager->variantProperty(prop)->setValue(val);
@@ -2497,24 +2497,24 @@ void DesignerEditorFactory::slotKeySequenceChanged(const QKeySequence &value)
 
 void DesignerEditorFactory::slotPaletteChanged(const QPalette &value)
 {
-    updateManager(this, &m_changingPropertyValue, m_editorToPaletteProperty, qobject_cast<QWidget *>(sender()), qVariantFromValue(value));
+    updateManager(this, &m_changingPropertyValue, m_editorToPaletteProperty, qobject_cast<QWidget *>(sender()), QVariant::fromValue(value));
 }
 
 void DesignerEditorFactory::slotPixmapChanged(const QString &value)
 {
     updateManager(this, &m_changingPropertyValue, m_editorToPixmapProperty, qobject_cast<QWidget *>(sender()),
-                    qVariantFromValue(PropertySheetPixmapValue(value)));
+                    QVariant::fromValue(PropertySheetPixmapValue(value)));
 }
 
 void DesignerEditorFactory::slotIconChanged(const QString &value)
 {
     updateManager(this, &m_changingPropertyValue, m_editorToIconProperty, qobject_cast<QWidget *>(sender()),
-                    qVariantFromValue(PropertySheetIconValue(PropertySheetPixmapValue(value))));
+                    QVariant::fromValue(PropertySheetIconValue(PropertySheetPixmapValue(value))));
 }
 
 void DesignerEditorFactory::slotStringListChanged(const QStringList &value)
 {
-    updateManager(this, &m_changingPropertyValue, m_editorToStringListProperty, qobject_cast<QWidget *>(sender()), qVariantFromValue(value));
+    updateManager(this, &m_changingPropertyValue, m_editorToStringListProperty, qobject_cast<QWidget *>(sender()), QVariant::fromValue(value));
 }
 
 ResetDecorator::~ResetDecorator()
diff --git a/tools/designer/src/components/propertyeditor/fontpropertymanager.cpp b/tools/designer/src/components/propertyeditor/fontpropertymanager.cpp
index 9442b01..419834e 100644
--- a/tools/designer/src/components/propertyeditor/fontpropertymanager.cpp
+++ b/tools/designer/src/components/propertyeditor/fontpropertymanager.cpp
@@ -123,7 +123,7 @@ namespace qdesigner_internal {
 
         // This will cause a recursion
         QtVariantProperty *antialiasing = vm->addProperty(enumTypeId, QCoreApplication::translate("FontPropertyManager", "Antialiasing"));
-        const QFont font = qVariantValue<QFont>(vm->variantProperty(property)->value());
+        const QFont font = qvariant_cast<QFont>(vm->variantProperty(property)->value());
 
         antialiasing->setAttribute(QLatin1String("enumNames"), m_aliasingEnumNames);
         antialiasing->setValue(antialiasingToIndex(font.styleStrategy()));
@@ -196,7 +196,7 @@ namespace qdesigner_internal {
 
         mask &= ~flag;
         font.resolve(mask);
-        qVariantSetValue(v, font);
+        v.setValue(font);
         fontProperty->setValue(v);
         return true;
     }
@@ -250,13 +250,13 @@ namespace qdesigner_internal {
         QtVariantProperty *fontProperty = vm->variantProperty(antialiasingProperty);
         const QFont::StyleStrategy newValue = indexToAntialiasing(value.toInt());
 
-        QFont font = qVariantValue<QFont>(fontProperty->value());
+        QFont font = qvariant_cast<QFont>(fontProperty->value());
         const QFont::StyleStrategy oldValue = font.styleStrategy();
         if (newValue == oldValue)
             return Unchanged;
 
         font.setStyleStrategy(newValue);
-        fontProperty->setValue(qVariantFromValue(font));
+        fontProperty->setValue(QVariant::fromValue(font));
         return Changed;
     }
 
@@ -268,7 +268,7 @@ namespace qdesigner_internal {
 
         const PropertyList &subProperties = it.value();
 
-        QFont font = qVariantValue<QFont>(value);
+        QFont font = qvariant_cast<QFont>(value);
         const unsigned mask = font.resolve();
 
         const int count = subProperties.size();
@@ -285,7 +285,7 @@ namespace qdesigner_internal {
         if (QtProperty *antialiasingProperty = m_propertyToAntialiasing.value(property, 0)) {
             QtVariantProperty *antialiasing = vm->variantProperty(antialiasingProperty);
             if (antialiasing) {
-                QFont font = qVariantValue<QFont>(value);
+                QFont font = qvariant_cast<QFont>(value);
                 antialiasing->setValue(antialiasingToIndex(font.styleStrategy()));
             }
         }
diff --git a/tools/designer/src/components/propertyeditor/paletteeditor.cpp b/tools/designer/src/components/propertyeditor/paletteeditor.cpp
index 067946b..5c4cbcc 100644
--- a/tools/designer/src/components/propertyeditor/paletteeditor.cpp
+++ b/tools/designer/src/components/propertyeditor/paletteeditor.cpp
@@ -294,7 +294,7 @@ bool PaletteModel::setData(const QModelIndex &index, const QVariant &value, int
         return false;
 
     if (index.column() != 0 && role == BrushRole) {
-        const QBrush br = qVariantValue<QBrush>(value);
+        const QBrush br = qvariant_cast<QBrush>(value);
         const QPalette::ColorRole r = static_cast<QPalette::ColorRole>(index.row());
         const QPalette::ColorGroup g = columnToGroup(index.column());
         m_palette.setBrush(g, r, br);
@@ -336,7 +336,7 @@ bool PaletteModel::setData(const QModelIndex &index, const QVariant &value, int
     }
     if (index.column() == 0 && role == Qt::EditRole) {
         uint mask = m_palette.resolve();
-        const bool isMask = qVariantValue<bool>(value);
+        const bool isMask = qvariant_cast<bool>(value);
         const int r = index.row();
         if (isMask)
             mask |= (1 << r);
@@ -532,13 +532,13 @@ QWidget *ColorDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem
 void ColorDelegate::setEditorData(QWidget *ed, const QModelIndex &index) const
 {
     if (index.column() == 0) {
-        const bool mask = qVariantValue<bool>(index.model()->data(index, Qt::EditRole));
+        const bool mask = qvariant_cast<bool>(index.model()->data(index, Qt::EditRole));
         RoleEditor *editor = static_cast<RoleEditor *>(ed);
         editor->setEdited(mask);
-        const QString colorName = qVariantValue<QString>(index.model()->data(index, Qt::DisplayRole));
+        const QString colorName = qvariant_cast<QString>(index.model()->data(index, Qt::DisplayRole));
         editor->setLabel(colorName);
     } else {
-        const QBrush br = qVariantValue<QBrush>(index.model()->data(index, BrushRole));
+        const QBrush br = qvariant_cast<QBrush>(index.model()->data(index, BrushRole));
         BrushEditor *editor = static_cast<BrushEditor *>(ed);
         editor->setBrush(br);
     }
@@ -571,11 +571,11 @@ void ColorDelegate::paint(QPainter *painter, const QStyleOptionViewItem &opt,
             const QModelIndex &index) const
 {
     QStyleOptionViewItem option = opt;
-    const bool mask = qVariantValue<bool>(index.model()->data(index, Qt::EditRole));
+    const bool mask = qvariant_cast<bool>(index.model()->data(index, Qt::EditRole));
     if (index.column() == 0 && mask) {
         option.font.setBold(true);
     }
-    QBrush br = qVariantValue<QBrush>(index.model()->data(index, BrushRole));
+    QBrush br = qvariant_cast<QBrush>(index.model()->data(index, BrushRole));
     if (br.style() == Qt::LinearGradientPattern ||
             br.style() == Qt::RadialGradientPattern ||
             br.style() == Qt::ConicalGradientPattern) {
diff --git a/tools/designer/src/components/propertyeditor/propertyeditor.cpp b/tools/designer/src/components/propertyeditor/propertyeditor.cpp
index a8ca8ad..7296636 100644
--- a/tools/designer/src/components/propertyeditor/propertyeditor.cpp
+++ b/tools/designer/src/components/propertyeditor/propertyeditor.cpp
@@ -872,12 +872,12 @@ void PropertyEditor::updateBrowserValue(QtVariantProperty *property, const QVari
 
 int PropertyEditor::toBrowserType(const QVariant &value, const QString &propertyName) const
 {
-    if (qVariantCanConvert<PropertySheetFlagValue>(value)) {
+    if (value.canConvert<PropertySheetFlagValue>()) {
         if (m_strings.m_alignmentProperties.contains(propertyName))
             return DesignerPropertyManager::designerAlignmentTypeId();
         return DesignerPropertyManager::designerFlagTypeId();
     }
-    if (qVariantCanConvert<PropertySheetEnumValue>(value))
+    if (value.canConvert<PropertySheetEnumValue>())
         return DesignerPropertyManager::enumTypeId();
 
     return value.userType();
@@ -1034,7 +1034,7 @@ void PropertyEditor::setObject(QObject *object)
                         }
                         m_updatingBrowser = true;
                         QVariant v;
-                        qVariantSetValue(v, flags);
+                        v.setValue(flags);
                         property->setAttribute(m_strings.m_flagsAttribute, v);
                         m_updatingBrowser = false;
                     }
@@ -1223,7 +1223,7 @@ void PropertyEditor::slotValueChanged(QtProperty *property, const QVariant &valu
         e.value = e.metaEnum.parseEnum(valName, &ok);
         Q_ASSERT(ok);
         QVariant v;
-        qVariantSetValue(v, e);
+        v.setValue(e);
         emitPropertyValueChanged(property->propertyName(), v, true);
         return;
     }
diff --git a/tools/designer/src/components/signalsloteditor/connectdialog.cpp b/tools/designer/src/components/signalsloteditor/connectdialog.cpp
index ff6be16..abd2e83 100644
--- a/tools/designer/src/components/signalsloteditor/connectdialog.cpp
+++ b/tools/designer/src/components/signalsloteditor/connectdialog.cpp
@@ -231,7 +231,7 @@ void ConnectDialog::populateSlotList(const QString &signal)
 
     QFont font = QApplication::font();
     font.setItalic(true);
-    QVariant variantFont = qVariantFromValue(font);
+    QVariant variantFont = QVariant::fromValue(font);
 
     QListWidgetItem *curr = 0;
     QMap<QString, QString>::ConstIterator itMember = memberToClassName.constBegin();
@@ -271,7 +271,7 @@ void ConnectDialog::populateSignalList()
 
     QFont font = QApplication::font();
     font.setItalic(true);
-    QVariant variantFont = qVariantFromValue(font);
+    QVariant variantFont = QVariant::fromValue(font);
 
     QListWidgetItem *curr = 0;
     QMap<QString, QString>::ConstIterator itMember = memberToClassName.constBegin();
diff --git a/tools/designer/src/components/signalsloteditor/signalslot_utils.cpp b/tools/designer/src/components/signalsloteditor/signalslot_utils.cpp
index 8674ac1..09c2233 100644
--- a/tools/designer/src/components/signalsloteditor/signalslot_utils.cpp
+++ b/tools/designer/src/components/signalsloteditor/signalslot_utils.cpp
@@ -245,7 +245,7 @@ namespace qdesigner_internal {
     ClassesMemberFunctions reverseClassesMemberFunctions(const QString &obj_name, MemberType member_type,
                                                          const QString &peer, QDesignerFormWindowInterface *form)
     {
-        QObject *object = qFindChild<QObject*>(form, obj_name);
+        QObject *object = form->findChild<QObject*>(obj_name);
         if (!object)
             return ClassesMemberFunctions();
 
diff --git a/tools/designer/src/components/signalsloteditor/signalsloteditor.cpp b/tools/designer/src/components/signalsloteditor/signalsloteditor.cpp
index b801c5e..1d45ef5 100644
--- a/tools/designer/src/components/signalsloteditor/signalsloteditor.cpp
+++ b/tools/designer/src/components/signalsloteditor/signalsloteditor.cpp
@@ -372,7 +372,7 @@ QObject *SignalSlotEditor::objectByName(QWidget *topLevel, const QString &name)
     if (topLevel->objectName() == name)
         object = topLevel;
     else
-        object = qFindChild<QObject*>(topLevel, name);
+        object = topLevel->findChild<QObject*>(name);
     const QDesignerMetaDataBaseInterface *mdb = formWindow()->core()->metaDataBase();
     if (mdb->item(object))
         return object;
diff --git a/tools/designer/src/components/signalsloteditor/signalsloteditorwindow.cpp b/tools/designer/src/components/signalsloteditor/signalsloteditorwindow.cpp
index 5547761..6cfc286 100644
--- a/tools/designer/src/components/signalsloteditor/signalsloteditorwindow.cpp
+++ b/tools/designer/src/components/signalsloteditor/signalsloteditorwindow.cpp
@@ -117,7 +117,7 @@ static QStringList objectNameList(QDesignerFormWindowInterface *form)
     const QDesignerMetaDataBaseInterface *mdb = form->core()->metaDataBase();
 
     // Add managed actions and actions with managed menus
-    const ActionList actions = qFindChildren<QAction*>(mainContainer);
+    const ActionList actions = mainContainer->findChildren<QAction*>();
     if (!actions.empty()) {
         const ActionList::const_iterator cend = actions.constEnd();
         for (ActionList::const_iterator it = actions.constBegin(); it != cend; ++it) {
@@ -135,7 +135,7 @@ static QStringList objectNameList(QDesignerFormWindowInterface *form)
     }
 
     // Add  managed buttons groups
-    const ButtonGroupList buttonGroups = qFindChildren<QButtonGroup *>(mainContainer);
+    const ButtonGroupList buttonGroups = mainContainer->findChildren<QButtonGroup *>();
     if (!buttonGroups.empty()) {
         const ButtonGroupList::const_iterator cend = buttonGroups.constEnd();
         for (ButtonGroupList::const_iterator it = buttonGroups.constBegin(); it != cend; ++it)
@@ -473,7 +473,7 @@ void InlineEditorModel::addTextList(const QMap<QString, bool> &text_list)
     insertRows(cnt, text_list.size());
     QFont font = QApplication::font();
     font.setItalic(true);
-    QVariant fontVariant = qVariantFromValue(font);
+    QVariant fontVariant = QVariant::fromValue(font);
     QMap<QString, bool>::ConstIterator it = text_list.constBegin();
     const QMap<QString, bool>::ConstIterator itEnd = text_list.constEnd();
     while (it != itEnd) {
@@ -658,7 +658,7 @@ QWidget *ConnectionDelegate::createEditor(QWidget *parent,
 
         const qdesigner_internal::ClassesMemberFunctions class_list = qdesigner_internal::reverseClassesMemberFunctions(obj_name, type, peer, m_form);
 
-        QObject *object = qFindChild<QObject*>(m_form, obj_name);
+        QObject *object = m_form->findChild<QObject*>(obj_name);
 
         inline_editor->addText(type == qdesigner_internal::SignalMember ? tr("<signal>") : tr("<slot>"));
         foreach (const qdesigner_internal::ClassMemberFunctions &class_info, class_list) {
@@ -767,7 +767,7 @@ void SignalSlotEditorWindow::setActiveFormWindow(QDesignerFormWindowInterface *f
         }
     }
 
-    m_editor = qFindChild<SignalSlotEditor*>(form);
+    m_editor = form->findChild<SignalSlotEditor*>();
     m_model->setEditor(m_editor);
     if (!m_editor.isNull()) {
         ConnectionDelegate *delegate
diff --git a/tools/designer/src/components/tabordereditor/tabordereditor.cpp b/tools/designer/src/components/tabordereditor/tabordereditor.cpp
index 37acabc..f877654 100644
--- a/tools/designer/src/components/tabordereditor/tabordereditor.cpp
+++ b/tools/designer/src/components/tabordereditor/tabordereditor.cpp
@@ -239,7 +239,7 @@ void TabOrderEditor::initTabOrder()
     childQueue.append(formWindow()->mainContainer());
     while (!childQueue.isEmpty()) {
         QWidget *child = childQueue.takeFirst();
-        childQueue += qVariantValue<QWidgetList>(child->property("_q_widgetOrder"));
+        childQueue += qvariant_cast<QWidgetList>(child->property("_q_widgetOrder"));
 
         if (skipWidget(child))
             continue;
diff --git a/tools/designer/src/components/taskmenu/button_taskmenu.cpp b/tools/designer/src/components/taskmenu/button_taskmenu.cpp
index 6b91c60..e178ebc 100644
--- a/tools/designer/src/components/taskmenu/button_taskmenu.cpp
+++ b/tools/designer/src/components/taskmenu/button_taskmenu.cpp
@@ -508,7 +508,7 @@ bool ButtonTaskMenu::refreshAssignMenu(const QDesignerFormWindowInterface *fw, i
             QButtonGroup *bg = *it;
             if (*it != currentGroup) {
                 QAction *a = new QAction(bg->objectName(), m_assignGroupSubMenu);
-                a->setData(qVariantFromValue(bg));
+                a->setData(QVariant::fromValue(bg));
                 m_assignActionGroup->addAction(a);
                 m_assignGroupSubMenu->addAction(a);
             }
diff --git a/tools/designer/src/components/taskmenu/inplace_editor.cpp b/tools/designer/src/components/taskmenu/inplace_editor.cpp
index 5732500..810df23 100644
--- a/tools/designer/src/components/taskmenu/inplace_editor.cpp
+++ b/tools/designer/src/components/taskmenu/inplace_editor.cpp
@@ -106,7 +106,7 @@ void TaskMenuInlineEditor::editText()
     const int index = sheet->indexOf(m_property);
     if (index == -1)
         return;
-    m_value = qVariantValue<PropertySheetStringValue>(sheet->property(index));
+    m_value = qvariant_cast<PropertySheetStringValue>(sheet->property(index));
     const QString oldValue = m_value.value();
 
     m_editor = new InPlaceEditor(m_widget, m_vm, m_formWindow, oldValue, editRectangle());
@@ -119,9 +119,9 @@ void TaskMenuInlineEditor::updateText(const QString &text)
     // do not use the cursor selection
     m_value.setValue(text);
     if (m_managed) {
-        m_formWindow->cursor()->setProperty(m_property, qVariantFromValue(m_value));
+        m_formWindow->cursor()->setProperty(m_property, QVariant::fromValue(m_value));
     } else {
-        m_formWindow->cursor()->setWidgetProperty(m_widget, m_property, qVariantFromValue(m_value));
+        m_formWindow->cursor()->setWidgetProperty(m_widget, m_property, QVariant::fromValue(m_value));
     }
 }
 
diff --git a/tools/designer/src/components/taskmenu/itemlisteditor.cpp b/tools/designer/src/components/taskmenu/itemlisteditor.cpp
index 94959fd..29fe0c9 100644
--- a/tools/designer/src/components/taskmenu/itemlisteditor.cpp
+++ b/tools/designer/src/components/taskmenu/itemlisteditor.cpp
@@ -191,8 +191,8 @@ void AbstractItemEditor::propertyChanged(QtProperty *property)
         return;
 
     if ((role == ItemFlagsShadowRole && prop->value().toInt() == (int)QListWidgetItem().flags())
-        || (role == Qt::DecorationPropertyRole && !qVariantValue<PropertySheetIconValue>(prop->value()).mask())
-        || (role == Qt::FontRole && !qVariantValue<QFont>(prop->value()).resolve())) {
+        || (role == Qt::DecorationPropertyRole && !qvariant_cast<PropertySheetIconValue>(prop->value()).mask())
+        || (role == Qt::FontRole && !qvariant_cast<QFont>(prop->value()).resolve())) {
         prop->setModified(false);
         setItemData(role, QVariant());
     } else {
@@ -202,19 +202,19 @@ void AbstractItemEditor::propertyChanged(QtProperty *property)
 
     switch (role) {
     case Qt::DecorationPropertyRole:
-        setItemData(Qt::DecorationRole, qVariantFromValue(iconCache()->icon(qVariantValue<PropertySheetIconValue>(prop->value()))));
+        setItemData(Qt::DecorationRole, QVariant::fromValue(iconCache()->icon(qvariant_cast<PropertySheetIconValue>(prop->value()))));
         break;
     case Qt::DisplayPropertyRole:
-        setItemData(Qt::EditRole, qVariantFromValue(qVariantValue<PropertySheetStringValue>(prop->value()).value()));
+        setItemData(Qt::EditRole, QVariant::fromValue(qvariant_cast<PropertySheetStringValue>(prop->value()).value()));
         break;
     case Qt::ToolTipPropertyRole:
-        setItemData(Qt::ToolTipRole, qVariantFromValue(qVariantValue<PropertySheetStringValue>(prop->value()).value()));
+        setItemData(Qt::ToolTipRole, QVariant::fromValue(qvariant_cast<PropertySheetStringValue>(prop->value()).value()));
         break;
     case Qt::StatusTipPropertyRole:
-        setItemData(Qt::StatusTipRole, qVariantFromValue(qVariantValue<PropertySheetStringValue>(prop->value()).value()));
+        setItemData(Qt::StatusTipRole, QVariant::fromValue(qvariant_cast<PropertySheetStringValue>(prop->value()).value()));
         break;
     case Qt::WhatsThisPropertyRole:
-        setItemData(Qt::WhatsThisRole, qVariantFromValue(qVariantValue<PropertySheetStringValue>(prop->value()).value()));
+        setItemData(Qt::WhatsThisRole, QVariant::fromValue(qvariant_cast<PropertySheetStringValue>(prop->value()).value()));
         break;
     default:
         break;
@@ -236,22 +236,22 @@ void AbstractItemEditor::resetProperty(QtProperty *property)
     QtVariantProperty *prop = m_propertyManager->variantProperty(property);
     int role = m_propertyToRole.value(prop);
     if (role == ItemFlagsShadowRole)
-        prop->setValue(qVariantFromValue((int)QListWidgetItem().flags()));
+        prop->setValue(QVariant::fromValue((int)QListWidgetItem().flags()));
     else
         prop->setValue(QVariant(prop->valueType(), (void *)0));
     prop->setModified(false);
 
     setItemData(role, QVariant());
     if (role == Qt::DecorationPropertyRole)
-        setItemData(Qt::DecorationRole, qVariantFromValue(QIcon()));
+        setItemData(Qt::DecorationRole, QVariant::fromValue(QIcon()));
     if (role == Qt::DisplayPropertyRole)
-        setItemData(Qt::EditRole, qVariantFromValue(QString()));
+        setItemData(Qt::EditRole, QVariant::fromValue(QString()));
     if (role == Qt::ToolTipPropertyRole)
-        setItemData(Qt::ToolTipRole, qVariantFromValue(QString()));
+        setItemData(Qt::ToolTipRole, QVariant::fromValue(QString()));
     if (role == Qt::StatusTipPropertyRole)
-        setItemData(Qt::StatusTipRole, qVariantFromValue(QString()));
+        setItemData(Qt::StatusTipRole, QVariant::fromValue(QString()));
     if (role == Qt::WhatsThisPropertyRole)
-        setItemData(Qt::WhatsThisRole, qVariantFromValue(QString()));
+        setItemData(Qt::WhatsThisRole, QVariant::fromValue(QString()));
 }
 
 void AbstractItemEditor::cacheReloaded()
@@ -268,7 +268,7 @@ void AbstractItemEditor::updateBrowser()
         QVariant val = getItemData(role);
         if (!val.isValid()) {
             if (role == ItemFlagsShadowRole)
-                val = qVariantFromValue((int)QListWidgetItem().flags());
+                val = QVariant::fromValue((int)QListWidgetItem().flags());
             else
                 val = QVariant((int)prop->value().userType(), (void *)0);
             prop->setModified(false);
@@ -340,7 +340,7 @@ void ItemListEditor::on_newListItemButton_clicked()
     int row = ui.listWidget->currentRow() + 1;
 
     QListWidgetItem *item = new QListWidgetItem(m_newItemText);
-    item->setData(Qt::DisplayPropertyRole, qVariantFromValue(PropertySheetStringValue(m_newItemText)));
+    item->setData(Qt::DisplayPropertyRole, QVariant::fromValue(PropertySheetStringValue(m_newItemText)));
     item->setFlags(item->flags() | Qt::ItemIsEditable);
     if (row < ui.listWidget->count())
         ui.listWidget->insertItem(row, item);
@@ -403,15 +403,15 @@ void ItemListEditor::on_listWidget_itemChanged(QListWidgetItem *item)
     if (m_updatingBrowser)
         return;
 
-    PropertySheetStringValue val = qVariantValue<PropertySheetStringValue>(item->data(Qt::DisplayPropertyRole));
+    PropertySheetStringValue val = qvariant_cast<PropertySheetStringValue>(item->data(Qt::DisplayPropertyRole));
     val.setValue(item->text());
     BoolBlocker block(m_updatingBrowser);
-    item->setData(Qt::DisplayPropertyRole, qVariantFromValue(val));
+    item->setData(Qt::DisplayPropertyRole, QVariant::fromValue(val));
 
     // The checkState could change, too, but if this signal is connected,
     // checkState is not in the list anyway, as we are editing a header item.
     emit itemChanged(ui.listWidget->currentRow(), Qt::DisplayPropertyRole,
-                     qVariantFromValue(val));
+                     QVariant::fromValue(val));
     updateBrowser();
 }
 
@@ -438,8 +438,8 @@ void ItemListEditor::setItemData(int role, const QVariant &v)
     QVariant newValue = v;
     if (role == Qt::FontRole && newValue.type() == QVariant::Font) {
         QFont oldFont = ui.listWidget->font();
-        QFont newFont = qVariantValue<QFont>(newValue).resolve(oldFont);
-        newValue = qVariantFromValue(newFont);
+        QFont newFont = qvariant_cast<QFont>(newValue).resolve(oldFont);
+        newValue = QVariant::fromValue(newFont);
         item->setData(role, QVariant()); // force the right font with the current resolve mask is set (item view bug)
     }
     item->setData(role, newValue);
diff --git a/tools/designer/src/components/taskmenu/tablewidgeteditor.cpp b/tools/designer/src/components/taskmenu/tablewidgeteditor.cpp
index 7dd5442..cd8b188 100644
--- a/tools/designer/src/components/taskmenu/tablewidgeteditor.cpp
+++ b/tools/designer/src/components/taskmenu/tablewidgeteditor.cpp
@@ -152,8 +152,8 @@ void TableWidgetEditor::setItemData(int role, const QVariant &v)
     QVariant newValue = v;
     if (role == Qt::FontRole && newValue.type() == QVariant::Font) {
         QFont oldFont = ui.tableWidget->font();
-        QFont newFont = qVariantValue<QFont>(newValue).resolve(oldFont);
-        newValue = qVariantFromValue(newFont);
+        QFont newFont = qvariant_cast<QFont>(newValue).resolve(oldFont);
+        newValue = QVariant::fromValue(newFont);
         item->setData(role, QVariant()); // force the right font with the current resolve mask is set (item view bug)
     }
     item->setData(role, newValue);
@@ -179,10 +179,10 @@ void TableWidgetEditor::on_tableWidget_itemChanged(QTableWidgetItem *item)
     if (m_updatingBrowser)
         return;
 
-    PropertySheetStringValue val = qVariantValue<PropertySheetStringValue>(item->data(Qt::DisplayPropertyRole));
+    PropertySheetStringValue val = qvariant_cast<PropertySheetStringValue>(item->data(Qt::DisplayPropertyRole));
     val.setValue(item->text());
     BoolBlocker block(m_updatingBrowser);
-    item->setData(Qt::DisplayPropertyRole, qVariantFromValue(val));
+    item->setData(Qt::DisplayPropertyRole, QVariant::fromValue(val));
 
     updateBrowser();
 }
@@ -317,7 +317,7 @@ void TableWidgetEditor::on_columnEditor_itemInserted(int idx)
     ui.tableWidget->setColumnCount(columnCount + 1);
 
     QTableWidgetItem *newItem = new QTableWidgetItem(m_columnEditor->newItemText());
-    newItem->setData(Qt::DisplayPropertyRole, qVariantFromValue(PropertySheetStringValue(m_columnEditor->newItemText())));
+    newItem->setData(Qt::DisplayPropertyRole, QVariant::fromValue(PropertySheetStringValue(m_columnEditor->newItemText())));
     ui.tableWidget->setHorizontalHeaderItem(columnCount, newItem);
 
     moveColumnsLeft(idx, columnCount);
@@ -359,7 +359,7 @@ void TableWidgetEditor::on_rowEditor_itemInserted(int idx)
     ui.tableWidget->setRowCount(rowCount + 1);
 
     QTableWidgetItem *newItem = new QTableWidgetItem(m_rowEditor->newItemText());
-    newItem->setData(Qt::DisplayPropertyRole, qVariantFromValue(PropertySheetStringValue(m_rowEditor->newItemText())));
+    newItem->setData(Qt::DisplayPropertyRole, QVariant::fromValue(PropertySheetStringValue(m_rowEditor->newItemText())));
     ui.tableWidget->setVerticalHeaderItem(rowCount, newItem);
 
     moveRowsDown(idx, rowCount);
diff --git a/tools/designer/src/components/taskmenu/treewidgeteditor.cpp b/tools/designer/src/components/taskmenu/treewidgeteditor.cpp
index c4063d1..8fab2ad 100644
--- a/tools/designer/src/components/taskmenu/treewidgeteditor.cpp
+++ b/tools/designer/src/components/taskmenu/treewidgeteditor.cpp
@@ -171,8 +171,8 @@ void TreeWidgetEditor::setItemData(int role, const QVariant &v)
     BoolBlocker block(m_updatingBrowser);
     if (role == Qt::FontRole && newValue.type() == QVariant::Font) {
         QFont oldFont = ui.treeWidget->font();
-        QFont newFont = qVariantValue<QFont>(newValue).resolve(oldFont);
-        newValue = qVariantFromValue(newFont);
+        QFont newFont = qvariant_cast<QFont>(newValue).resolve(oldFont);
+        newValue = QVariant::fromValue(newFont);
         ui.treeWidget->currentItem()->setData(col, role, QVariant()); // force the right font with the current resolve mask is set (item view bug)
     }
     ui.treeWidget->currentItem()->setData(col, role, newValue);
@@ -198,7 +198,7 @@ void TreeWidgetEditor::on_newItemButton_clicked()
         newItem = new QTreeWidgetItem(ui.treeWidget);
     const QString newItemText = tr("New Item");
     newItem->setText(0, newItemText);
-    newItem->setData(0, Qt::DisplayPropertyRole, qVariantFromValue(PropertySheetStringValue(newItemText)));
+    newItem->setData(0, Qt::DisplayPropertyRole, QVariant::fromValue(PropertySheetStringValue(newItemText)));
     newItem->setFlags(newItem->flags() | Qt::ItemIsEditable);
     ui.treeWidget->blockSignals(false);
 
@@ -217,7 +217,7 @@ void TreeWidgetEditor::on_newSubItemButton_clicked()
     QTreeWidgetItem *newItem = new QTreeWidgetItem(curItem);
     const QString newItemText = tr("New Subitem");
     newItem->setText(0, newItemText);
-    newItem->setData(0, Qt::DisplayPropertyRole, qVariantFromValue(PropertySheetStringValue(newItemText)));
+    newItem->setData(0, Qt::DisplayPropertyRole, QVariant::fromValue(PropertySheetStringValue(newItemText)));
     newItem->setFlags(newItem->flags() | Qt::ItemIsEditable);
     ui.treeWidget->blockSignals(false);
 
@@ -408,10 +408,10 @@ void TreeWidgetEditor::on_treeWidget_itemChanged(QTreeWidgetItem *item, int colu
     if (m_updatingBrowser)
         return;
 
-    PropertySheetStringValue val = qVariantValue<PropertySheetStringValue>(item->data(column, Qt::DisplayPropertyRole));
+    PropertySheetStringValue val = qvariant_cast<PropertySheetStringValue>(item->data(column, Qt::DisplayPropertyRole));
     val.setValue(item->text(column));
     BoolBlocker block(m_updatingBrowser);
-    item->setData(column, Qt::DisplayPropertyRole, qVariantFromValue(val));
+    item->setData(column, Qt::DisplayPropertyRole, QVariant::fromValue(val));
 
     updateBrowser();
 }
@@ -425,7 +425,7 @@ void TreeWidgetEditor::on_columnEditor_indexChanged(int idx)
 void TreeWidgetEditor::on_columnEditor_itemChanged(int idx, int role, const QVariant &v)
 {
     if (role == Qt::DisplayPropertyRole)
-        ui.treeWidget->headerItem()->setData(idx, Qt::EditRole, qVariantValue<PropertySheetStringValue>(v).value());
+        ui.treeWidget->headerItem()->setData(idx, Qt::EditRole, qvariant_cast<PropertySheetStringValue>(v).value());
     ui.treeWidget->headerItem()->setData(idx, role, v);
 }
 
diff --git a/tools/designer/src/components/widgetbox/widgetbox_dnditem.cpp b/tools/designer/src/components/widgetbox/widgetbox_dnditem.cpp
index 25798d3..ac32795 100644
--- a/tools/designer/src/components/widgetbox/widgetbox_dnditem.cpp
+++ b/tools/designer/src/components/widgetbox/widgetbox_dnditem.cpp
@@ -185,7 +185,7 @@ static QWidget *decorationFromDomWidget(DomUI *dom_ui, QDesignerFormEditorInterf
     fakeTopLevel->setParent(0, Qt::ToolTip); // Container
     // Actual widget
     const DomWidget *domW = dom_ui->elementWidget()->elementWidget().front();
-    QWidget *w = qFindChildren<QWidget*>(fakeTopLevel).front();
+    QWidget *w = fakeTopLevel->findChildren<QWidget*>().front();
     Q_ASSERT(w);
     // hack begin;
     // We set _q_dockDrag dynamic property which will be detected in drag enter event of form window.
diff --git a/tools/designer/src/designer/assistantclient.cpp b/tools/designer/src/designer/assistantclient.cpp
index e47817f..bddaf63 100644
--- a/tools/designer/src/designer/assistantclient.cpp
+++ b/tools/designer/src/designer/assistantclient.cpp
@@ -101,7 +101,7 @@ bool AssistantClient::sendCommand(const QString &cmd, QString *errorMessage)
         return false;
     }
     QTextStream str(m_process);
-    str << cmd << QLatin1Char('\0') << endl;
+    str << cmd << QLatin1Char('\n') << endl;
     return true;
 }
 
diff --git a/tools/designer/src/designer/qdesigner_settings.cpp b/tools/designer/src/designer/qdesigner_settings.cpp
index cc6cec5..9404e50 100644
--- a/tools/designer/src/designer/qdesigner_settings.cpp
+++ b/tools/designer/src/designer/qdesigner_settings.cpp
@@ -241,7 +241,7 @@ ToolWindowFontSettings QDesignerSettings::toolWindowFont() const
     fontSettings.m_writingSystem =
             static_cast<QFontDatabase::WritingSystem>(value(QLatin1String("UI/writingSystem"),
                                                             QFontDatabase::Any).toInt());
-    fontSettings.m_font = qVariantValue<QFont>(value(QLatin1String("UI/font")));
+    fontSettings.m_font = qvariant_cast<QFont>(value(QLatin1String("UI/font")));
     fontSettings.m_useFont =
             settings()->value(QLatin1String("UI/useFont"), QVariant(false)).toBool();
     return fontSettings;
diff --git a/tools/designer/src/lib/shared/actioneditor.cpp b/tools/designer/src/lib/shared/actioneditor.cpp
index 26ac8a8..d3716ca 100644
--- a/tools/designer/src/lib/shared/actioneditor.cpp
+++ b/tools/designer/src/lib/shared/actioneditor.cpp
@@ -288,7 +288,7 @@ void ActionEditor::setFormWindow(QDesignerFormWindowInterface *formWindow)
         return;
 
     if (m_formWindow != 0) {
-        const ActionList actionList = qFindChildren<QAction*>(m_formWindow->mainContainer());
+        const ActionList actionList = m_formWindow->mainContainer()->findChildren<QAction*>();
         foreach (QAction *action, actionList)
             disconnect(action, SIGNAL(changed()), this, SLOT(slotActionChanged()));
     }
@@ -311,7 +311,7 @@ void ActionEditor::setFormWindow(QDesignerFormWindowInterface *formWindow)
     m_actionNew->setEnabled(true);
     m_filterWidget->setEnabled(true);
 
-    const ActionList actionList = qFindChildren<QAction*>(formWindow->mainContainer());
+    const ActionList actionList = formWindow->mainContainer()->findChildren<QAction*>();
     foreach (QAction *action, actionList)
         if (!action->isSeparator() && core()->metaDataBase()->item(action) != 0) {
             // Show unless it has a menu. However, listen for change on menu actions also as it might be removed
@@ -459,9 +459,9 @@ void ActionEditor::slotNewAction()
             setInitialProperty(sheet, QLatin1String(checkablePropertyC), QVariant(true));
 
         if (!actionData.keysequence.value().isEmpty())
-            setInitialProperty(sheet, QLatin1String(shortcutPropertyC), qVariantFromValue(actionData.keysequence));
+            setInitialProperty(sheet, QLatin1String(shortcutPropertyC), QVariant::fromValue(actionData.keysequence));
 
-        sheet->setProperty(sheet->indexOf(QLatin1String(iconPropertyC)), qVariantFromValue(actionData.icon));
+        sheet->setProperty(sheet->indexOf(QLatin1String(iconPropertyC)), QVariant::fromValue(actionData.icon));
 
         AddActionCommand *cmd = new AddActionCommand(formWindow());
         cmd->init(action);
@@ -486,7 +486,7 @@ static QDesignerFormWindowCommand *setIconPropertyCommand(const PropertySheetIco
         return cmd;
     }
     SetPropertyCommand *cmd = new SetPropertyCommand(fw);
-    cmd->init(action, iconProperty, qVariantFromValue(newIcon));
+    cmd->init(action, iconProperty, QVariant::fromValue(newIcon));
     return cmd;
 }
 
@@ -502,7 +502,7 @@ static QDesignerFormWindowCommand *setKeySequencePropertyCommand(const PropertyS
         return cmd;
     }
     SetPropertyCommand *cmd = new SetPropertyCommand(fw);
-    cmd->init(action, shortcutProperty, qVariantFromValue(ks));
+    cmd->init(action, shortcutProperty, QVariant::fromValue(ks));
     return cmd;
 }
 
@@ -528,7 +528,7 @@ static inline QString textPropertyValue(const QDesignerPropertySheetExtension *s
 {
     const int index = sheet->indexOf(name);
     Q_ASSERT(index != -1);
-    const PropertySheetStringValue ps = qVariantValue<PropertySheetStringValue>(sheet->property(index));
+    const PropertySheetStringValue ps = qvariant_cast<PropertySheetStringValue>(sheet->property(index));
     return ps.value();
 }
 
@@ -545,7 +545,7 @@ void ActionEditor::editAction(QAction *action)
     oldActionData.name = action->objectName();
     oldActionData.text = action->text();
     oldActionData.toolTip = textPropertyValue(sheet, QLatin1String(toolTipPropertyC));
-    oldActionData.icon = qVariantValue<PropertySheetIconValue>(sheet->property(sheet->indexOf(QLatin1String(iconPropertyC))));
+    oldActionData.icon = qvariant_cast<PropertySheetIconValue>(sheet->property(sheet->indexOf(QLatin1String(iconPropertyC))));
     oldActionData.keysequence = ActionModel::actionShortCut(sheet);
     oldActionData.checkable =  action->isCheckable();
     dlg.setActionData(oldActionData);
@@ -677,7 +677,7 @@ void  ActionEditor::resourceImageDropped(const QString &path, QAction *action)
 
     QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(core()->extensionManager(), action);
     const PropertySheetIconValue oldIcon =
-            qVariantValue<PropertySheetIconValue>(sheet->property(sheet->indexOf(QLatin1String(iconPropertyC))));
+            qvariant_cast<PropertySheetIconValue>(sheet->property(sheet->indexOf(QLatin1String(iconPropertyC))));
     PropertySheetIconValue newIcon;
     newIcon.setPixmap(QIcon::Normal, QIcon::Off, PropertySheetPixmapValue(path));
     if (newIcon.paths().isEmpty() || newIcon.paths() == oldIcon.paths())
diff --git a/tools/designer/src/lib/shared/actionrepository.cpp b/tools/designer/src/lib/shared/actionrepository.cpp
index 1076ff4..8df6f83 100644
--- a/tools/designer/src/lib/shared/actionrepository.cpp
+++ b/tools/designer/src/lib/shared/actionrepository.cpp
@@ -136,7 +136,7 @@ QModelIndex ActionModel::addAction(QAction *action)
     const  Qt::ItemFlags flags = Qt::ItemIsSelectable|Qt::ItemIsDropEnabled|Qt::ItemIsDragEnabled|Qt::ItemIsEnabled;
 
     QVariant itemData;
-    qVariantSetValue(itemData, action);
+    itemData.setValue(action);
 
     for (int i = 0; i < NumColumns; i++) {
         QStandardItem *item = new QStandardItem;
diff --git a/tools/designer/src/lib/shared/connectionedit.cpp b/tools/designer/src/lib/shared/connectionedit.cpp
index 0bebe47..fb6cf60 100644
--- a/tools/designer/src/lib/shared/connectionedit.cpp
+++ b/tools/designer/src/lib/shared/connectionedit.cpp
@@ -1395,7 +1395,7 @@ void ConnectionEdit::widgetRemoved(QWidget *widget)
     if (m_con_list.empty())
         return;
 
-    QWidgetList child_list = qFindChildren<QWidget*>(widget);
+    QWidgetList child_list = widget->findChildren<QWidget*>();
     child_list.prepend(widget);
 
     const ConnectionSet remove_set = findConnectionsOf(m_con_list, child_list.constBegin(),  child_list.constEnd());
@@ -1545,7 +1545,7 @@ void ConnectionEdit::setSource(Connection *con, const QString &obj_name)
 {
     QObject *object = 0;
     if (!obj_name.isEmpty()) {
-        object = qFindChild<QObject*>(m_bg_widget, obj_name);
+        object = m_bg_widget->findChild<QObject*>(obj_name);
         if (object == 0 && m_bg_widget->objectName() == obj_name)
             object = m_bg_widget;
 
@@ -1559,7 +1559,7 @@ void ConnectionEdit::setTarget(Connection *con, const QString &obj_name)
 {
     QObject *object = 0;
     if (!obj_name.isEmpty()) {
-        object = qFindChild<QObject*>(m_bg_widget, obj_name);
+        object = m_bg_widget->findChild<QObject*>(obj_name);
         if (object == 0 && m_bg_widget->objectName() == obj_name)
             object = m_bg_widget;
 
diff --git a/tools/designer/src/lib/shared/formlayoutmenu.cpp b/tools/designer/src/lib/shared/formlayoutmenu.cpp
index 8d9f9a6..ff909a7 100644
--- a/tools/designer/src/lib/shared/formlayoutmenu.cpp
+++ b/tools/designer/src/lib/shared/formlayoutmenu.cpp
@@ -432,16 +432,16 @@ static QPair<QWidget *,QWidget *>
     const QString objectNameProperty = QLatin1String("objectName");
     QDesignerPropertySheetExtension *labelSheet = qt_extension<QDesignerPropertySheetExtension*>(core->extensionManager(), rc.first);
     int nameIndex = labelSheet->indexOf(objectNameProperty);
-    labelSheet->setProperty(nameIndex, qVariantFromValue(PropertySheetStringValue(row.labelName)));
+    labelSheet->setProperty(nameIndex, QVariant::fromValue(PropertySheetStringValue(row.labelName)));
     labelSheet->setChanged(nameIndex, true);
     formWindow->ensureUniqueObjectName(rc.first);
     const int textIndex = labelSheet->indexOf(QLatin1String("text"));
-    labelSheet->setProperty(textIndex, qVariantFromValue(PropertySheetStringValue(row.labelText)));
+    labelSheet->setProperty(textIndex, QVariant::fromValue(PropertySheetStringValue(row.labelText)));
     labelSheet->setChanged(textIndex, true);
     // Set up properties of the control
     QDesignerPropertySheetExtension *controlSheet = qt_extension<QDesignerPropertySheetExtension*>(core->extensionManager(), rc.second);
     nameIndex = controlSheet->indexOf(objectNameProperty);
-    controlSheet->setProperty(nameIndex, qVariantFromValue(PropertySheetStringValue(row.fieldName)));
+    controlSheet->setProperty(nameIndex, QVariant::fromValue(PropertySheetStringValue(row.fieldName)));
     controlSheet->setChanged(nameIndex, true);
     formWindow->ensureUniqueObjectName(rc.second);
     return rc;
diff --git a/tools/designer/src/lib/shared/formwindowbase.cpp b/tools/designer/src/lib/shared/formwindowbase.cpp
index 5292f5f..7e65d6b 100644
--- a/tools/designer/src/lib/shared/formwindowbase.cpp
+++ b/tools/designer/src/lib/shared/formwindowbase.cpp
@@ -184,11 +184,11 @@ void FormWindowBase::reloadProperties()
             const int index = itIndex.next().key();
             const QVariant newValue = sheet->property(index);
             if (qobject_cast<QLabel *>(sheet->object()) && sheet->propertyName(index) == QLatin1String("text")) {
-                const PropertySheetStringValue newString = qVariantValue<PropertySheetStringValue>(newValue);
+                const PropertySheetStringValue newString = qvariant_cast<PropertySheetStringValue>(newValue);
                 // optimize a bit, reset only if the text value might contain a reference to qt resources
                 // (however reloading of icons other than taken from resources might not work here)
                 if (newString.value().contains(QLatin1String(":/"))) {
-                    const QVariant resetValue = qVariantFromValue(PropertySheetStringValue());
+                    const QVariant resetValue = QVariant::fromValue(PropertySheetStringValue());
                     sheet->setProperty(index, resetValue);
                 }
             }
diff --git a/tools/designer/src/lib/shared/grid.cpp b/tools/designer/src/lib/shared/grid.cpp
index 42296e1..67b8d5c 100644
--- a/tools/designer/src/lib/shared/grid.cpp
+++ b/tools/designer/src/lib/shared/grid.cpp
@@ -71,7 +71,7 @@ template <class T>
         const QVariantMap::const_iterator it = v.constFind(key);
         const bool found = it != v.constEnd();
         if (found)
-            value = qVariantValue<T>(it.value());
+            value = qvariant_cast<T>(it.value());
         return found;
     }
 
diff --git a/tools/designer/src/lib/shared/layoutinfo.cpp b/tools/designer/src/lib/shared/layoutinfo.cpp
index ad2dda4..309aa37 100644
--- a/tools/designer/src/lib/shared/layoutinfo.cpp
+++ b/tools/designer/src/lib/shared/layoutinfo.cpp
@@ -190,7 +190,7 @@ LayoutInfo::Type LayoutInfo::laidoutWidgetType(const QDesignerFormEditorInterfac
     }
 
     // 3) Some child layout (see below comment about Q3GroupBox)
-    const QList<QLayout*> childLayouts = qFindChildren<QLayout*>(parentLayout);
+    const QList<QLayout*> childLayouts = parentLayout->findChildren<QLayout*>();
     if (childLayouts.empty())
         return NoLayout;
     const QList<QLayout*>::const_iterator lcend = childLayouts.constEnd();
@@ -244,7 +244,7 @@ QLayout *LayoutInfo::managedLayout(const QDesignerFormEditorInterface *core, QLa
      * widget->layout() returns an internal VBoxLayout. */
     const QDesignerMetaDataBaseItemInterface *item = metaDataBase->item(layout);
     if (item == 0) {
-        layout = qFindChild<QLayout*>(layout);
+        layout = layout->findChild<QLayout*>();
         item = metaDataBase->item(layout);
     }
     if (!item)
diff --git a/tools/designer/src/lib/shared/morphmenu.cpp b/tools/designer/src/lib/shared/morphmenu.cpp
index de85d37..80eac0c 100644
--- a/tools/designer/src/lib/shared/morphmenu.cpp
+++ b/tools/designer/src/lib/shared/morphmenu.cpp
@@ -240,7 +240,7 @@ static QString suggestObjectName(const QString &oldClassName, const QString &new
 QLabel *buddyLabelOf(QDesignerFormWindowInterface *fw, QWidget *w)
 {
     typedef QList<QLabel*> LabelList;
-    const LabelList labelList = qFindChildren<QLabel*>(fw);
+    const LabelList labelList = fw->findChildren<QLabel*>();
     if (labelList.empty())
         return 0;
     const LabelList::const_iterator cend = labelList.constEnd();
@@ -256,11 +256,11 @@ static void replaceWidgetListDynamicProperty(QWidget *parentWidget,
                                              QWidget *oldWidget, QWidget *newWidget,
                                              const char *name)
 {
-    QWidgetList list = qVariantValue<QWidgetList>(parentWidget->property(name));
+    QWidgetList list = qvariant_cast<QWidgetList>(parentWidget->property(name));
     const int index = list.indexOf(oldWidget);
     if (index != -1) {
         list.replace(index, newWidget);
-         parentWidget->setProperty(name, qVariantFromValue(list));
+         parentWidget->setProperty(name, QVariant::fromValue(list));
     }
 }
 
diff --git a/tools/designer/src/lib/shared/qdesigner_command.cpp b/tools/designer/src/lib/shared/qdesigner_command.cpp
index 69206df..8c01000 100644
--- a/tools/designer/src/lib/shared/qdesigner_command.cpp
+++ b/tools/designer/src/lib/shared/qdesigner_command.cpp
@@ -107,23 +107,23 @@ static const char *zOrderPropertyC = "_q_zOrder";
 
 static void addToWidgetListDynamicProperty(QWidget *parentWidget, QWidget *widget, const char *name, int index = -1)
 {
-    QWidgetList list = qVariantValue<QWidgetList>(parentWidget->property(name));
+    QWidgetList list = qvariant_cast<QWidgetList>(parentWidget->property(name));
     list.removeAll(widget);
     if (index >= 0 && index < list.size()) {
         list.insert(index, widget);
     } else {
         list.append(widget);
     }
-    parentWidget->setProperty(name, qVariantFromValue(list));
+    parentWidget->setProperty(name, QVariant::fromValue(list));
 }
 
 static int removeFromWidgetListDynamicProperty(QWidget *parentWidget, QWidget *widget, const char *name)
 {
-    QWidgetList list = qVariantValue<QWidgetList>(parentWidget->property(name));
+    QWidgetList list = qvariant_cast<QWidgetList>(parentWidget->property(name));
     const int firstIndex = list.indexOf(widget);
     if (firstIndex != -1) {
         list.removeAll(widget);
-        parentWidget->setProperty(name, qVariantFromValue(list));
+        parentWidget->setProperty(name, QVariant::fromValue(list));
     }
     return firstIndex;
 }
@@ -247,7 +247,7 @@ void InsertWidgetCommand::refreshBuddyLabels()
 {
     typedef QList<QLabel*> LabelList;
 
-    const LabelList label_list = qFindChildren<QLabel*>(formWindow());
+    const LabelList label_list = formWindow()->findChildren<QLabel*>();
     if (label_list.empty())
         return;
 
@@ -281,7 +281,7 @@ void ChangeZOrderCommand::init(QWidget *widget)
 
     setText(QApplication::translate("Command", "Change Z-order of '%1'").arg(widget->objectName()));
 
-    m_oldParentZOrder = qVariantValue<QWidgetList>(widget->parentWidget()->property("_q_zOrder"));
+    m_oldParentZOrder = qvariant_cast<QWidgetList>(widget->parentWidget()->property("_q_zOrder"));
     const int index = m_oldParentZOrder.indexOf(m_widget);
     if (index != -1 && index + 1 < m_oldParentZOrder.count())
         m_oldPreceding = m_oldParentZOrder.at(index + 1);
@@ -289,14 +289,14 @@ void ChangeZOrderCommand::init(QWidget *widget)
 
 void ChangeZOrderCommand::redo()
 {
-    m_widget->parentWidget()->setProperty("_q_zOrder", qVariantFromValue(reorderWidget(m_oldParentZOrder, m_widget)));
+    m_widget->parentWidget()->setProperty("_q_zOrder", QVariant::fromValue(reorderWidget(m_oldParentZOrder, m_widget)));
 
     reorder(m_widget);
 }
 
 void ChangeZOrderCommand::undo()
 {
-    m_widget->parentWidget()->setProperty("_q_zOrder", qVariantFromValue(m_oldParentZOrder));
+    m_widget->parentWidget()->setProperty("_q_zOrder", QVariant::fromValue(m_oldParentZOrder));
 
     if (m_oldPreceding)
         m_widget->stackUnder(m_oldPreceding);
@@ -365,7 +365,7 @@ void ManageWidgetCommandHelper::init(const QDesignerFormWindowInterface *fw, QWi
     m_widget = widget;
     m_managedChildren.clear();
 
-    const QWidgetList children = qFindChildren<QWidget *>(m_widget);
+    const QWidgetList children = m_widget->findChildren<QWidget *>();
     if (children.empty())
         return;
 
@@ -580,8 +580,8 @@ void ReparentWidgetCommand::init(QWidget *widget, QWidget *parentWidget)
 
     setText(QApplication::translate("Command", "Reparent '%1'").arg(widget->objectName()));
 
-    m_oldParentList = qVariantValue<QWidgetList>(m_oldParentWidget->property("_q_widgetOrder"));
-    m_oldParentZOrder = qVariantValue<QWidgetList>(m_oldParentWidget->property("_q_zOrder"));
+    m_oldParentList = qvariant_cast<QWidgetList>(m_oldParentWidget->property("_q_widgetOrder"));
+    m_oldParentZOrder = qvariant_cast<QWidgetList>(m_oldParentWidget->property("_q_zOrder"));
 }
 
 void ReparentWidgetCommand::redo()
@@ -591,19 +591,19 @@ void ReparentWidgetCommand::redo()
 
     QWidgetList oldList = m_oldParentList;
     oldList.removeAll(m_widget);
-    m_oldParentWidget->setProperty("_q_widgetOrder", qVariantFromValue(oldList));
+    m_oldParentWidget->setProperty("_q_widgetOrder", QVariant::fromValue(oldList));
 
-    QWidgetList newList = qVariantValue<QWidgetList>(m_newParentWidget->property("_q_widgetOrder"));
+    QWidgetList newList = qvariant_cast<QWidgetList>(m_newParentWidget->property("_q_widgetOrder"));
     newList.append(m_widget);
-    m_newParentWidget->setProperty("_q_widgetOrder", qVariantFromValue(newList));
+    m_newParentWidget->setProperty("_q_widgetOrder", QVariant::fromValue(newList));
 
     QWidgetList oldZOrder = m_oldParentZOrder;
     oldZOrder.removeAll(m_widget);
-    m_oldParentWidget->setProperty("_q_zOrder", qVariantFromValue(oldZOrder));
+    m_oldParentWidget->setProperty("_q_zOrder", QVariant::fromValue(oldZOrder));
 
-    QWidgetList newZOrder = qVariantValue<QWidgetList>(m_newParentWidget->property("_q_zOrder"));
+    QWidgetList newZOrder = qvariant_cast<QWidgetList>(m_newParentWidget->property("_q_zOrder"));
     newZOrder.append(m_widget);
-    m_newParentWidget->setProperty("_q_zOrder", qVariantFromValue(newZOrder));
+    m_newParentWidget->setProperty("_q_zOrder", QVariant::fromValue(newZOrder));
 
     m_widget->show();
     core()->objectInspector()->setFormWindow(formWindow());
@@ -614,16 +614,16 @@ void ReparentWidgetCommand::undo()
     m_widget->setParent(m_oldParentWidget);
     m_widget->move(m_oldPos);
 
-    m_oldParentWidget->setProperty("_q_widgetOrder", qVariantFromValue(m_oldParentList));
+    m_oldParentWidget->setProperty("_q_widgetOrder", QVariant::fromValue(m_oldParentList));
 
-    QWidgetList newList = qVariantValue<QWidgetList>(m_newParentWidget->property("_q_widgetOrder"));
+    QWidgetList newList = qvariant_cast<QWidgetList>(m_newParentWidget->property("_q_widgetOrder"));
     newList.removeAll(m_widget);
-    m_newParentWidget->setProperty("_q_widgetOrder", qVariantFromValue(newList));
+    m_newParentWidget->setProperty("_q_widgetOrder", QVariant::fromValue(newList));
 
-    m_oldParentWidget->setProperty("_q_zOrder", qVariantFromValue(m_oldParentZOrder));
+    m_oldParentWidget->setProperty("_q_zOrder", QVariant::fromValue(m_oldParentZOrder));
 
-    QWidgetList newZOrder = qVariantValue<QWidgetList>(m_newParentWidget->property("_q_zOrder"));
-    m_newParentWidget->setProperty("_q_zOrder", qVariantFromValue(newZOrder));
+    QWidgetList newZOrder = qvariant_cast<QWidgetList>(m_newParentWidget->property("_q_zOrder"));
+    m_newParentWidget->setProperty("_q_zOrder", QVariant::fromValue(newZOrder));
 
     m_widget->show();
     core()->objectInspector()->setFormWindow(formWindow());
@@ -1016,7 +1016,7 @@ void ToolBoxCommand::addPage()
     QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(formWindow()->core()->extensionManager(), m_toolBox);
     if (sheet) {
         qdesigner_internal::PropertySheetStringValue itemText(m_itemText);
-        sheet->setProperty(sheet->indexOf(QLatin1String("currentItemText")), qVariantFromValue(itemText));
+        sheet->setProperty(sheet->indexOf(QLatin1String("currentItemText")), QVariant::fromValue(itemText));
     }
 
     m_widget->show();
@@ -1176,7 +1176,7 @@ void TabWidgetCommand::addPage()
     QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(formWindow()->core()->extensionManager(), m_tabWidget);
     if (sheet) {
         qdesigner_internal::PropertySheetStringValue itemText(m_itemText);
-        sheet->setProperty(sheet->indexOf(QLatin1String("currentTabText")), qVariantFromValue(itemText));
+        sheet->setProperty(sheet->indexOf(QLatin1String("currentTabText")), QVariant::fromValue(itemText));
     }
 
     formWindow()->clearSelection();
@@ -2193,7 +2193,7 @@ static void copyRolesFromItem(ItemData *id, const T *item, bool editor)
     if (editor)
         copyRoleFromItem<T>(id, ItemFlagsShadowRole, item);
     else if (item->flags() != defaultFlags)
-        id->m_properties.insert(ItemFlagsShadowRole, qVariantFromValue((int)item->flags()));
+        id->m_properties.insert(ItemFlagsShadowRole, QVariant::fromValue((int)item->flags()));
 }
 
 template<class T>
@@ -2210,19 +2210,19 @@ static void copyRolesToItem(const ItemData *id, T *item, DesignerIconCache *icon
                 switch (it.key()) {
                 case Qt::DecorationPropertyRole:
                     if (iconCache)
-                        item->setIcon(iconCache->icon(qVariantValue<PropertySheetIconValue>(it.value())));
+                        item->setIcon(iconCache->icon(qvariant_cast<PropertySheetIconValue>(it.value())));
                     break;
                 case Qt::DisplayPropertyRole:
-                    item->setText(qVariantValue<PropertySheetStringValue>(it.value()).value());
+                    item->setText(qvariant_cast<PropertySheetStringValue>(it.value()).value());
                     break;
                 case Qt::ToolTipPropertyRole:
-                    item->setToolTip(qVariantValue<PropertySheetStringValue>(it.value()).value());
+                    item->setToolTip(qvariant_cast<PropertySheetStringValue>(it.value()).value());
                     break;
                 case Qt::StatusTipPropertyRole:
-                    item->setStatusTip(qVariantValue<PropertySheetStringValue>(it.value()).value());
+                    item->setStatusTip(qvariant_cast<PropertySheetStringValue>(it.value()).value());
                     break;
                 case Qt::WhatsThisPropertyRole:
-                    item->setWhatsThis(qVariantValue<PropertySheetStringValue>(it.value()).value());
+                    item->setWhatsThis(qvariant_cast<PropertySheetStringValue>(it.value()).value());
                     break;
                 }
             }
@@ -2267,7 +2267,7 @@ ItemData::ItemData(const QTreeWidgetItem *item, int column)
 {
     copyRoleFromItem(this, Qt::EditRole, item, column);
     PropertySheetStringValue str(item->text(column));
-    m_properties.insert(Qt::DisplayPropertyRole, qVariantFromValue(str));
+    m_properties.insert(Qt::DisplayPropertyRole, QVariant::fromValue(str));
 
     for (int i = 0; itemRoles[i] != -1; i++)
         copyRoleFromItem(this, itemRoles[i], item, column);
@@ -2282,19 +2282,19 @@ void ItemData::fillTreeItemColumn(QTreeWidgetItem *item, int column, DesignerIco
             switch (it.key()) {
             case Qt::DecorationPropertyRole:
                 if (iconCache)
-                    item->setIcon(column, iconCache->icon(qVariantValue<PropertySheetIconValue>(it.value())));
+                    item->setIcon(column, iconCache->icon(qvariant_cast<PropertySheetIconValue>(it.value())));
                 break;
             case Qt::DisplayPropertyRole:
-                item->setText(column, qVariantValue<PropertySheetStringValue>(it.value()).value());
+                item->setText(column, qvariant_cast<PropertySheetStringValue>(it.value()).value());
                 break;
             case Qt::ToolTipPropertyRole:
-                item->setToolTip(column, qVariantValue<PropertySheetStringValue>(it.value()).value());
+                item->setToolTip(column, qvariant_cast<PropertySheetStringValue>(it.value()).value());
                 break;
             case Qt::StatusTipPropertyRole:
-                item->setStatusTip(column, qVariantValue<PropertySheetStringValue>(it.value()).value());
+                item->setStatusTip(column, qvariant_cast<PropertySheetStringValue>(it.value()).value());
                 break;
             case Qt::WhatsThisPropertyRole:
-                item->setWhatsThis(column, qVariantValue<PropertySheetStringValue>(it.value()).value());
+                item->setWhatsThis(column, qvariant_cast<PropertySheetStringValue>(it.value()).value());
                 break;
             }
         }
@@ -2364,10 +2364,10 @@ void ListContents::applyToComboBox(QComboBox *comboBox, DesignerIconCache *iconC
     foreach (const ItemData &hash, m_items) {
         QIcon icon;
         if (iconCache)
-            icon = iconCache->icon(qVariantValue<PropertySheetIconValue>(
+            icon = iconCache->icon(qvariant_cast<PropertySheetIconValue>(
                     hash.m_properties[Qt::DecorationPropertyRole]));
         QVariant var = hash.m_properties[Qt::DisplayPropertyRole];
-        PropertySheetStringValue str = qVariantValue<PropertySheetStringValue>(var);
+        PropertySheetStringValue str = qvariant_cast<PropertySheetStringValue>(var);
         comboBox->addItem(icon, str.value());
         comboBox->setItemData(comboBox->count() - 1,
                               var,
@@ -2407,7 +2407,7 @@ bool TableWidgetContents::nonEmpty(const QTableWidgetItem *item, int headerColum
     if (item->flags() != defaultFlags)
         return true;
 
-    QString text = qVariantValue<PropertySheetStringValue>(item->data(Qt::DisplayPropertyRole)).value();
+    QString text = qvariant_cast<PropertySheetStringValue>(item->data(Qt::DisplayPropertyRole)).value();
     if (!text.isEmpty()) {
         if (headerColumn < 0 || text != defaultHeaderText(headerColumn))
             return true;
@@ -2545,7 +2545,7 @@ QTreeWidgetItem *TreeWidgetContents::ItemContents::createTreeItem(DesignerIconCa
 
     if (m_itemFlags != -1) {
         if (editor)
-            item->setData(0, ItemFlagsShadowRole, qVariantFromValue(m_itemFlags));
+            item->setData(0, ItemFlagsShadowRole, QVariant::fromValue(m_itemFlags));
         else
             item->setFlags((Qt::ItemFlags)m_itemFlags);
     }
diff --git a/tools/designer/src/lib/shared/qdesigner_formbuilder.cpp b/tools/designer/src/lib/shared/qdesigner_formbuilder.cpp
index 14e0d81..b881589 100644
--- a/tools/designer/src/lib/shared/qdesigner_formbuilder.cpp
+++ b/tools/designer/src/lib/shared/qdesigner_formbuilder.cpp
@@ -243,7 +243,7 @@ static bool readDomEnumerationValue(const DomProperty *p,
         if (index == -1)
             return false;
         const QVariant sheetValue = sheet->property(index);
-        if (qVariantCanConvert<PropertySheetFlagValue>(sheetValue)) {
+        if (sheetValue.canConvert<PropertySheetFlagValue>()) {
             const PropertySheetFlagValue f = qvariant_cast<PropertySheetFlagValue>(sheetValue);
             bool ok = false;
             v = f.metaFlags.parseFlags(p->elementSet(), &ok);
@@ -258,7 +258,7 @@ static bool readDomEnumerationValue(const DomProperty *p,
         if (index == -1)
             return false;
         const QVariant sheetValue = sheet->property(index);
-        if (qVariantCanConvert<PropertySheetEnumValue>(sheetValue)) {
+        if (sheetValue.canConvert<PropertySheetEnumValue>()) {
             const PropertySheetEnumValue e = qvariant_cast<PropertySheetEnumValue>(sheetValue);
             bool ok = false;
             v = e.metaEnum.parseEnum(p->elementEnum(), &ok);
diff --git a/tools/designer/src/lib/shared/qdesigner_formwindowcommand.cpp b/tools/designer/src/lib/shared/qdesigner_formwindowcommand.cpp
index 490373e..675752e 100644
--- a/tools/designer/src/lib/shared/qdesigner_formwindowcommand.cpp
+++ b/tools/designer/src/lib/shared/qdesigner_formwindowcommand.cpp
@@ -115,7 +115,7 @@ void QDesignerFormWindowCommand::updateBuddies(QDesignerFormWindowInterface *for
 
     typedef QList<QLabel*> LabelList;
 
-    const LabelList label_list = qFindChildren<QLabel*>(form);
+    const LabelList label_list = form->findChildren<QLabel*>();
     if (label_list.empty())
         return;
 
diff --git a/tools/designer/src/lib/shared/qdesigner_menu.cpp b/tools/designer/src/lib/shared/qdesigner_menu.cpp
index 31a226a..3d9fdf1 100644
--- a/tools/designer/src/lib/shared/qdesigner_menu.cpp
+++ b/tools/designer/src/lib/shared/qdesigner_menu.cpp
@@ -477,7 +477,7 @@ bool QDesignerMenu::handleContextMenuEvent(QWidget *, QContextMenuEvent *event)
 
     QMenu menu;
     QVariant itemData;
-    qVariantSetValue(itemData, action);
+    itemData.setValue(action);
 
     QAction *addSeparatorAction = menu.addAction(tr("Insert separator"));
     addSeparatorAction->setData(itemData);
@@ -630,7 +630,7 @@ QDesignerMenu *QDesignerMenu::findActivatedMenu() const
 {
     QList<QDesignerMenu*> candidates;
     candidates.append(const_cast<QDesignerMenu*>(this));
-    candidates += qFindChildren<QDesignerMenu*>(this);
+    candidates += findChildren<QDesignerMenu*>();
 
     foreach (QDesignerMenu *m, candidates) {
         if (m == qApp->activeWindow())
@@ -867,7 +867,7 @@ void QDesignerMenu::closeMenuChain()
         w = w->parentWidget();
 
     if (w) {
-        foreach (QMenu *subMenu, qFindChildren<QMenu*>(w)) {
+        foreach (QMenu *subMenu, w->findChildren<QMenu*>()) {
             subMenu->hide();
         }
     }
@@ -1323,7 +1323,7 @@ QAction *QDesignerMenu::safeActionAt(int index) const
 void QDesignerMenu::hideSubMenu()
 {
     m_lastSubMenuIndex = -1;
-    foreach (QMenu *subMenu, qFindChildren<QMenu*>(this)) {
+    foreach (QMenu *subMenu, findChildren<QMenu*>()) {
         subMenu->hide();
     }
 }
diff --git a/tools/designer/src/lib/shared/qdesigner_menubar.cpp b/tools/designer/src/lib/shared/qdesigner_menubar.cpp
index 8d53037..b017264 100644
--- a/tools/designer/src/lib/shared/qdesigner_menubar.cpp
+++ b/tools/designer/src/lib/shared/qdesigner_menubar.cpp
@@ -403,7 +403,7 @@ ActionList QDesignerMenuBar::contextMenuActions()
     if (QAction *action = safeActionAt(m_currentIndex)) {
         if (!qobject_cast<SpecialMenuAction*>(action)) {
             QVariant itemData;
-            qVariantSetValue(itemData, action);
+            itemData.setValue(action);
 
             QAction *remove_action = new QAction(tr("Remove Menu '%1'").arg(action->menu()->objectName()), 0);
             remove_action->setData(itemData);
diff --git a/tools/designer/src/lib/shared/qdesigner_propertycommand.cpp b/tools/designer/src/lib/shared/qdesigner_propertycommand.cpp
index 6cc054c..08385b5 100644
--- a/tools/designer/src/lib/shared/qdesigner_propertycommand.cpp
+++ b/tools/designer/src/lib/shared/qdesigner_propertycommand.cpp
@@ -505,7 +505,7 @@ PropertyHelper::Value applySubProperty(const QVariant &oldValue, const QVariant
     case QVariant::Size:
         return PropertyHelper::Value(applySizeSubProperty(oldValue.toSize(), newValue.toSize(), mask), changed);
     case QVariant::SizePolicy:
-        return PropertyHelper::Value(qVariantFromValue(applySizePolicySubProperty(qvariant_cast<QSizePolicy>(oldValue), qvariant_cast<QSizePolicy>(newValue), mask)), changed);
+        return PropertyHelper::Value(QVariant::fromValue(applySizePolicySubProperty(qvariant_cast<QSizePolicy>(oldValue), qvariant_cast<QSizePolicy>(newValue), mask)), changed);
     case QVariant::Font: {
         // Changed flag in case of font and palette depends on resolve mask only, not on the passed "changed" value.
 
@@ -524,27 +524,27 @@ PropertyHelper::Value applySubProperty(const QVariant &oldValue, const QVariant
         // He press reset button for the whole font property. In result whole font properties for both
         // widgets should be marked as unchanged.
         QFont font = applyFontSubProperty(qvariant_cast<QFont>(oldValue), qvariant_cast<QFont>(newValue), mask);
-        return PropertyHelper::Value(qVariantFromValue(font), font.resolve());
+        return PropertyHelper::Value(QVariant::fromValue(font), font.resolve());
         }
     case QVariant::Palette: {
         QPalette palette = applyPaletteSubProperty(qvariant_cast<QPalette>(oldValue), qvariant_cast<QPalette>(newValue), mask);
-        return PropertyHelper::Value(qVariantFromValue(palette), palette.resolve());
+        return PropertyHelper::Value(QVariant::fromValue(palette), palette.resolve());
         }
     default:
         if (oldValue.userType() == qMetaTypeId<qdesigner_internal::PropertySheetIconValue>()) {
             PropertySheetIconValue icon = qvariant_cast<qdesigner_internal::PropertySheetIconValue>(oldValue);
             icon.assign(qvariant_cast<qdesigner_internal::PropertySheetIconValue>(newValue), mask);
-            return PropertyHelper::Value(qVariantFromValue(icon), icon.mask());
+            return PropertyHelper::Value(QVariant::fromValue(icon), icon.mask());
         } else if (oldValue.userType() == qMetaTypeId<qdesigner_internal::PropertySheetStringValue>()) {
             qdesigner_internal::PropertySheetStringValue str = applyStringSubProperty(
                         qvariant_cast<qdesigner_internal::PropertySheetStringValue>(oldValue),
                         qvariant_cast<qdesigner_internal::PropertySheetStringValue>(newValue), mask);
-            return PropertyHelper::Value(qVariantFromValue(str), changed);
+            return PropertyHelper::Value(QVariant::fromValue(str), changed);
         } else if (oldValue.userType() == qMetaTypeId<qdesigner_internal::PropertySheetKeySequenceValue>()) {
             qdesigner_internal::PropertySheetKeySequenceValue key = applyKeySequenceSubProperty(
                         qvariant_cast<qdesigner_internal::PropertySheetKeySequenceValue>(oldValue),
                         qvariant_cast<qdesigner_internal::PropertySheetKeySequenceValue>(newValue), mask);
-            return PropertyHelper::Value(qVariantFromValue(key), changed);
+            return PropertyHelper::Value(QVariant::fromValue(key), changed);
         }
         // Enumerations, flags
         switch (specialProperty) {
@@ -552,7 +552,7 @@ PropertyHelper::Value applySubProperty(const QVariant &oldValue, const QVariant
             qdesigner_internal::PropertySheetFlagValue f = qvariant_cast<qdesigner_internal::PropertySheetFlagValue>(oldValue);
             f.value = applyAlignmentSubProperty(variantToAlignment(oldValue), variantToAlignment(newValue), mask);
             QVariant v;
-            qVariantSetValue(v, f);
+            v.setValue(f);
             return PropertyHelper::Value(v, changed);
                                                }
         default:
@@ -651,7 +651,7 @@ void PropertyHelper::checkApplyWidgetValue(QDesignerFormWindowInterface *fw, QWi
     switch (specialProperty) {
     case SP_MinimumSize: {
         const QSize size = checkSize(value.toSize());
-        qVariantSetValue(value, size);
+        value.setValue(size);
     }
 
         break;
@@ -660,7 +660,7 @@ void PropertyHelper::checkApplyWidgetValue(QDesignerFormWindowInterface *fw, QWi
         checkSizes(fw, value.toSize(), &fs, &cs);
         container->setMaximumSize(cs);
         fw->mainContainer()->setMaximumSize(fs);
-        qVariantSetValue(value, fs);
+        value.setValue(fs);
 
     }
         break;
@@ -670,7 +670,7 @@ void PropertyHelper::checkApplyWidgetValue(QDesignerFormWindowInterface *fw, QWi
         checkSizes(fw, r.size(), &fs, &cs);
         container->resize(cs);
         r.setSize(fs);
-        qVariantSetValue(value, r);
+        value.setValue(r);
     }
         break;
     default:
@@ -727,8 +727,8 @@ void PropertyHelper::updateObject(QDesignerFormWindowInterface *fw, const QVaria
     case OT_Widget: {
         switch (m_specialProperty) {
         case SP_ObjectName: {
-            const QString oldName = qVariantValue<PropertySheetStringValue>(oldValue).value();
-            const QString newName = qVariantValue<PropertySheetStringValue>(newValue).value();
+            const QString oldName = qvariant_cast<PropertySheetStringValue>(oldValue).value();
+            const QString newName = qvariant_cast<PropertySheetStringValue>(newValue).value();
             QDesignerFormWindowCommand::updateBuddies(fw, oldName, newName);
         }
             break;
@@ -751,8 +751,8 @@ void PropertyHelper::updateObject(QDesignerFormWindowInterface *fw, const QVaria
     case SP_LayoutName:
     case SP_SpacerName:
         if (QDesignerIntegration *integr = integration(fw)) {
-            const QString oldName = qVariantValue<PropertySheetStringValue>(oldValue).value();
-            const QString newName = qVariantValue<PropertySheetStringValue>(newValue).value();
+            const QString oldName = qvariant_cast<PropertySheetStringValue>(oldValue).value();
+            const QString newName = qvariant_cast<PropertySheetStringValue>(newValue).value();
             integr->emitObjectNameChanged(fw, m_object, newName, oldName);
         }
         break;
diff --git a/tools/designer/src/lib/shared/qdesigner_propertysheet.cpp b/tools/designer/src/lib/shared/qdesigner_propertysheet.cpp
index 086f46d..72ecb8f 100644
--- a/tools/designer/src/lib/shared/qdesigner_propertysheet.cpp
+++ b/tools/designer/src/lib/shared/qdesigner_propertysheet.cpp
@@ -290,18 +290,18 @@ bool QDesignerPropertySheetPrivate::isResourceProperty(int index) const
 void QDesignerPropertySheetPrivate::addResourceProperty(int index, QVariant::Type type)
 {
     if (type == QVariant::Pixmap)
-        m_resourceProperties.insert(index, qVariantFromValue(qdesigner_internal::PropertySheetPixmapValue()));
+        m_resourceProperties.insert(index, QVariant::fromValue(qdesigner_internal::PropertySheetPixmapValue()));
     else if (type == QVariant::Icon)
-        m_resourceProperties.insert(index, qVariantFromValue(qdesigner_internal::PropertySheetIconValue()));
+        m_resourceProperties.insert(index, QVariant::fromValue(qdesigner_internal::PropertySheetIconValue()));
 }
 
 QVariant QDesignerPropertySheetPrivate::emptyResourceProperty(int index) const
 {
     QVariant v = m_resourceProperties.value(index);
-    if (qVariantCanConvert<qdesigner_internal::PropertySheetPixmapValue>(v))
-        return qVariantFromValue(qdesigner_internal::PropertySheetPixmapValue());
-    if (qVariantCanConvert<qdesigner_internal::PropertySheetIconValue>(v))
-        return qVariantFromValue(qdesigner_internal::PropertySheetIconValue());
+    if (v.canConvert<qdesigner_internal::PropertySheetPixmapValue>())
+        return QVariant::fromValue(qdesigner_internal::PropertySheetPixmapValue());
+    if (v.canConvert<qdesigner_internal::PropertySheetIconValue>())
+        return QVariant::fromValue(qdesigner_internal::PropertySheetIconValue());
     return v;
 }
 
@@ -320,8 +320,8 @@ void QDesignerPropertySheetPrivate::setResourceProperty(int index, const QVarian
     Q_ASSERT(isResourceProperty(index));
 
     QVariant &v = m_resourceProperties[index];
-    if ((qVariantCanConvert<qdesigner_internal::PropertySheetPixmapValue>(value) && qVariantCanConvert<qdesigner_internal::PropertySheetPixmapValue>(v))
-        || (qVariantCanConvert<qdesigner_internal::PropertySheetIconValue>(value) && qVariantCanConvert<qdesigner_internal::PropertySheetIconValue>(v)))
+    if ((value.canConvert<qdesigner_internal::PropertySheetPixmapValue>() && v.canConvert<qdesigner_internal::PropertySheetPixmapValue>())
+        || (value.canConvert<qdesigner_internal::PropertySheetIconValue>() && v.canConvert<qdesigner_internal::PropertySheetIconValue>()))
         v = value;
 }
 
@@ -722,14 +722,14 @@ int QDesignerPropertySheet::addDynamicProperty(const QString &propName, const QV
 
     QVariant v = value;
     if (value.type() == QVariant::Icon)
-        v = qVariantFromValue(qdesigner_internal::PropertySheetIconValue());
+        v = QVariant::fromValue(qdesigner_internal::PropertySheetIconValue());
     else if (value.type() == QVariant::Pixmap)
-        v = qVariantFromValue(qdesigner_internal::PropertySheetPixmapValue());
+        v = QVariant::fromValue(qdesigner_internal::PropertySheetPixmapValue());
     else if (value.type() == QVariant::String)
-        v = qVariantFromValue(qdesigner_internal::PropertySheetStringValue(value.toString()));
+        v = QVariant::fromValue(qdesigner_internal::PropertySheetStringValue(value.toString()));
     else if (value.type() == QVariant::KeySequence) {
-        const QKeySequence keySequence = qVariantValue<QKeySequence>(value);
-        v = qVariantFromValue(qdesigner_internal::PropertySheetKeySequenceValue(keySequence));
+        const QKeySequence keySequence = qvariant_cast<QKeySequence>(value);
+        v = QVariant::fromValue(qdesigner_internal::PropertySheetKeySequenceValue(keySequence));
     }
 
     if (d->m_addIndex.contains(propName)) {
@@ -873,9 +873,9 @@ int QDesignerPropertySheet::createFakeProperty(const QString &propertyName, cons
         info.kind = QDesignerPropertySheetPrivate::FakeProperty;
         QVariant v = value.isValid() ? value : metaProperty(index);
         if (v.type() == QVariant::String)
-            v = qVariantFromValue(qdesigner_internal::PropertySheetStringValue());
+            v = QVariant::fromValue(qdesigner_internal::PropertySheetStringValue());
         if (v.type() == QVariant::KeySequence)
-            v = qVariantFromValue(qdesigner_internal::PropertySheetKeySequenceValue());
+            v = QVariant::fromValue(qdesigner_internal::PropertySheetKeySequenceValue());
         d->m_fakeProperties.insert(index, v);
         return index;
     }
@@ -1002,17 +1002,17 @@ QVariant QDesignerPropertySheet::property(int index) const
             value.setValue(strValue);
             d->setStringProperty(index, value); // cache it
         }
-        return qVariantFromValue(value);
+        return QVariant::fromValue(value);
     }
 
     if (d->isKeySequenceProperty(index)) {
-        QKeySequence keyValue = qVariantValue<QKeySequence>(metaProperty(index));
+        QKeySequence keyValue = qvariant_cast<QKeySequence>(metaProperty(index));
         qdesigner_internal::PropertySheetKeySequenceValue value = d->keySequenceProperty(index);
         if (keyValue != value.value()) {
             value.setValue(keyValue);
             d->setKeySequenceProperty(index, value); // cache it
         }
-        return qVariantFromValue(value);
+        return QVariant::fromValue(value);
     }
 
     return metaProperty(index);
@@ -1027,12 +1027,12 @@ QVariant QDesignerPropertySheet::metaProperty(int index) const
     switch (p->kind()) {
     case QDesignerMetaPropertyInterface::FlagKind: {
         qdesigner_internal::PropertySheetFlagValue psflags = qdesigner_internal::PropertySheetFlagValue(v.toInt(), designerMetaFlagsFor(p->enumerator()));
-        qVariantSetValue(v, psflags);
+        v.setValue(psflags);
     }
         break;
     case QDesignerMetaPropertyInterface::EnumKind: {
         qdesigner_internal::PropertySheetEnumValue pse = qdesigner_internal::PropertySheetEnumValue(v.toInt(), designerMetaEnumFor(p->enumerator()));
-        qVariantSetValue(v, pse);
+        v.setValue(pse);
     }
         break;
     case QDesignerMetaPropertyInterface::OtherKind:
@@ -1043,20 +1043,20 @@ QVariant QDesignerPropertySheet::metaProperty(int index) const
 
 QVariant QDesignerPropertySheet::resolvePropertyValue(int index, const QVariant &value) const
 {
-    if (qVariantCanConvert<qdesigner_internal::PropertySheetEnumValue>(value))
+    if (value.canConvert<qdesigner_internal::PropertySheetEnumValue>())
         return qvariant_cast<qdesigner_internal::PropertySheetEnumValue>(value).value;
 
-    if (qVariantCanConvert<qdesigner_internal::PropertySheetFlagValue>(value))
+    if (value.canConvert<qdesigner_internal::PropertySheetFlagValue>())
         return qvariant_cast<qdesigner_internal::PropertySheetFlagValue>(value).value;
 
-    if (qVariantCanConvert<qdesigner_internal::PropertySheetStringValue>(value))
-        return qVariantValue<qdesigner_internal::PropertySheetStringValue>(value).value();
+    if (value.canConvert<qdesigner_internal::PropertySheetStringValue>())
+        return qvariant_cast<qdesigner_internal::PropertySheetStringValue>(value).value();
 
-    if (qVariantCanConvert<qdesigner_internal::PropertySheetKeySequenceValue>(value))
-        return qVariantValue<qdesigner_internal::PropertySheetKeySequenceValue>(value).value();
+    if (value.canConvert<qdesigner_internal::PropertySheetKeySequenceValue>())
+        return qvariant_cast<qdesigner_internal::PropertySheetKeySequenceValue>(value).value();
 
-    if (qVariantCanConvert<qdesigner_internal::PropertySheetPixmapValue>(value)) {
-        const QString path = qVariantValue<qdesigner_internal::PropertySheetPixmapValue>(value).path();
+    if (value.canConvert<qdesigner_internal::PropertySheetPixmapValue>()) {
+        const QString path = qvariant_cast<qdesigner_internal::PropertySheetPixmapValue>(value).path();
         if (path.isEmpty())
             return defaultResourceProperty(index);
         if (d->m_pixmapCache) {
@@ -1064,8 +1064,8 @@ QVariant QDesignerPropertySheet::resolvePropertyValue(int index, const QVariant
         }
     }
 
-    if (qVariantCanConvert<qdesigner_internal::PropertySheetIconValue>(value)) {
-        const int pathCount = qVariantValue<qdesigner_internal::PropertySheetIconValue>(value).paths().count();
+    if (value.canConvert<qdesigner_internal::PropertySheetIconValue>()) {
+        const int pathCount = qvariant_cast<qdesigner_internal::PropertySheetIconValue>(value).paths().count();
         if (pathCount == 0)
             return defaultResourceProperty(index);
         if (d->m_iconCache)
@@ -1082,17 +1082,17 @@ void QDesignerPropertySheet::setFakeProperty(int index, const QVariant &value)
     QVariant &v = d->m_fakeProperties[index];
 
     // set resource properties also (if we are going to have fake resource properties)
-    if (qVariantCanConvert<qdesigner_internal::PropertySheetFlagValue>(value) || qVariantCanConvert<qdesigner_internal::PropertySheetEnumValue>(value)) {
+    if (value.canConvert<qdesigner_internal::PropertySheetFlagValue>() || value.canConvert<qdesigner_internal::PropertySheetEnumValue>()) {
         v = value;
-    } else if (qVariantCanConvert<qdesigner_internal::PropertySheetFlagValue>(v)) {
+    } else if (v.canConvert<qdesigner_internal::PropertySheetFlagValue>()) {
         qdesigner_internal::PropertySheetFlagValue f = qvariant_cast<qdesigner_internal::PropertySheetFlagValue>(v);
         f.value = value.toInt();
-        qVariantSetValue(v, f);
+        v.setValue(f);
         Q_ASSERT(value.type() == QVariant::Int);
-    } else if (qVariantCanConvert<qdesigner_internal::PropertySheetEnumValue>(v)) {
+    } else if (v.canConvert<qdesigner_internal::PropertySheetEnumValue>()) {
         qdesigner_internal::PropertySheetEnumValue e = qvariant_cast<qdesigner_internal::PropertySheetEnumValue>(v);
         e.value = value.toInt();
-        qVariantSetValue(v, e);
+        v.setValue(e);
         Q_ASSERT(value.type() == QVariant::Int);
     } else {
         v = value;
@@ -1139,9 +1139,9 @@ void QDesignerPropertySheet::setProperty(int index, const QVariant &value)
             if (d->isResourceProperty(index))
                 d->setResourceProperty(index, value);
             if (d->isStringProperty(index))
-                d->setStringProperty(index, qVariantValue<qdesigner_internal::PropertySheetStringValue>(value));
+                d->setStringProperty(index, qvariant_cast<qdesigner_internal::PropertySheetStringValue>(value));
             if (d->isKeySequenceProperty(index))
-                d->setKeySequenceProperty(index, qVariantValue<qdesigner_internal::PropertySheetKeySequenceValue>(value));
+                d->setKeySequenceProperty(index, qvariant_cast<qdesigner_internal::PropertySheetKeySequenceValue>(value));
             d->m_object->setProperty(propertyName(index).toUtf8(), resolvePropertyValue(index, value));
             if (d->m_object->isWidgetType()) {
                 QWidget *w = qobject_cast<QWidget *>(d->m_object);
@@ -1155,26 +1155,26 @@ void QDesignerPropertySheet::setProperty(int index, const QVariant &value)
         if (d->isResourceProperty(index))
             d->setResourceProperty(index, value);
         if (d->isStringProperty(index))
-            d->setStringProperty(index, qVariantValue<qdesigner_internal::PropertySheetStringValue>(value));
+            d->setStringProperty(index, qvariant_cast<qdesigner_internal::PropertySheetStringValue>(value));
         if (d->isKeySequenceProperty(index))
-            d->setKeySequenceProperty(index, qVariantValue<qdesigner_internal::PropertySheetKeySequenceValue>(value));
+            d->setKeySequenceProperty(index, qvariant_cast<qdesigner_internal::PropertySheetKeySequenceValue>(value));
         const QDesignerMetaPropertyInterface *p = d->m_meta->property(index);
         p->write(d->m_object, resolvePropertyValue(index, value));
         if (qobject_cast<QGroupBox *>(d->m_object) && propertyType(index) == PropertyCheckable) {
             const int idx = indexOf(QLatin1String("focusPolicy"));
             if (!isChanged(idx)) {
-                qdesigner_internal::PropertySheetEnumValue e = qVariantValue<qdesigner_internal::PropertySheetEnumValue>(property(idx));
+                qdesigner_internal::PropertySheetEnumValue e = qvariant_cast<qdesigner_internal::PropertySheetEnumValue>(property(idx));
                 if (value.toBool()) {
                     const QDesignerMetaPropertyInterface *p = d->m_meta->property(idx);
                     p->write(d->m_object, Qt::NoFocus);
                     e.value = Qt::StrongFocus;
                     QVariant v;
-                    qVariantSetValue(v, e);
+                    v.setValue(e);
                     setFakeProperty(idx, v);
                 } else {
                     e.value = Qt::NoFocus;
                     QVariant v;
-                    qVariantSetValue(v, e);
+                    v.setValue(e);
                     setFakeProperty(idx, v);
                 }
             }
@@ -1196,9 +1196,9 @@ bool QDesignerPropertySheet::reset(int index)
     if (d->invalidIndex(Q_FUNC_INFO, index))
         return false;
     if (d->isStringProperty(index))
-        setProperty(index, qVariantFromValue(qdesigner_internal::PropertySheetStringValue()));
+        setProperty(index, QVariant::fromValue(qdesigner_internal::PropertySheetStringValue()));
     if (d->isKeySequenceProperty(index))
-        setProperty(index, qVariantFromValue(qdesigner_internal::PropertySheetKeySequenceValue()));
+        setProperty(index, QVariant::fromValue(qdesigner_internal::PropertySheetKeySequenceValue()));
     if (d->isResourceProperty(index)) {
         setProperty(index, d->emptyResourceProperty(index));
         return true;
@@ -1208,10 +1208,10 @@ bool QDesignerPropertySheet::reset(int index)
         const QVariant defaultValue = d->m_info.value(index).defaultValue;
         QVariant newValue = defaultValue;
         if (d->isStringProperty(index)) {
-            newValue = qVariantFromValue(qdesigner_internal::PropertySheetStringValue(newValue.toString()));
+            newValue = QVariant::fromValue(qdesigner_internal::PropertySheetStringValue(newValue.toString()));
         } else if (d->isKeySequenceProperty(index)) {
-            const QKeySequence keySequence = qVariantValue<QKeySequence>(newValue);
-            newValue = qVariantFromValue(qdesigner_internal::PropertySheetKeySequenceValue(keySequence));
+            const QKeySequence keySequence = qvariant_cast<QKeySequence>(newValue);
+            newValue = QVariant::fromValue(qdesigner_internal::PropertySheetKeySequenceValue(keySequence));
         }
         if (oldValue == newValue)
             return true;
diff --git a/tools/designer/src/lib/shared/qdesigner_tabwidget.cpp b/tools/designer/src/lib/shared/qdesigner_tabwidget.cpp
index ecd97fa..461212c 100644
--- a/tools/designer/src/lib/shared/qdesigner_tabwidget.cpp
+++ b/tools/designer/src/lib/shared/qdesigner_tabwidget.cpp
@@ -134,7 +134,7 @@ QTabBar *QTabWidgetEventFilter::tabBar() const
 {
     // QTabWidget::tabBar() accessor is protected, grmbl...
     if (!m_cachedTabBar) {
-        const QList<QTabBar *> tabBars = qFindChildren<QTabBar *>(m_tabWidget);
+        const QList<QTabBar *> tabBars = m_tabWidget->findChildren<QTabBar *>();
         Q_ASSERT(tabBars.size() == 1);
         m_cachedTabBar = tabBars.front();
     }
@@ -405,13 +405,13 @@ QTabWidgetPropertySheet::QTabWidgetPropertySheet(QTabWidget *object, QObject *pa
     QDesignerPropertySheet(object, parent),
     m_tabWidget(object)
 {
-    createFakeProperty(QLatin1String(currentTabTextKey), qVariantFromValue(qdesigner_internal::PropertySheetStringValue()));
+    createFakeProperty(QLatin1String(currentTabTextKey), QVariant::fromValue(qdesigner_internal::PropertySheetStringValue()));
     createFakeProperty(QLatin1String(currentTabNameKey), QString());
-    createFakeProperty(QLatin1String(currentTabIconKey), qVariantFromValue(qdesigner_internal::PropertySheetIconValue()));
+    createFakeProperty(QLatin1String(currentTabIconKey), QVariant::fromValue(qdesigner_internal::PropertySheetIconValue()));
     if (formWindowBase())
         formWindowBase()->addReloadableProperty(this, indexOf(QLatin1String(currentTabIconKey)));
-    createFakeProperty(QLatin1String(currentTabToolTipKey), qVariantFromValue(qdesigner_internal::PropertySheetStringValue()));
-    createFakeProperty(QLatin1String(currentTabWhatsThisKey), qVariantFromValue(qdesigner_internal::PropertySheetStringValue()));
+    createFakeProperty(QLatin1String(currentTabToolTipKey), QVariant::fromValue(qdesigner_internal::PropertySheetStringValue()));
+    createFakeProperty(QLatin1String(currentTabWhatsThisKey), QVariant::fromValue(qdesigner_internal::PropertySheetStringValue()));
     // Prevent the tab widget's drag and drop handling from interfering with Designer's
     createFakeProperty(QLatin1String(tabMovableKey), QVariant(false));
 }
@@ -447,22 +447,22 @@ void QTabWidgetPropertySheet::setProperty(int index, const QVariant &value)
     switch (tabWidgetProperty) {
     case PropertyCurrentTabText:
         m_tabWidget->setTabText(currentIndex, qvariant_cast<QString>(resolvePropertyValue(index, value)));
-        m_pageToData[currentWidget].text = qVariantValue<qdesigner_internal::PropertySheetStringValue>(value);
+        m_pageToData[currentWidget].text = qvariant_cast<qdesigner_internal::PropertySheetStringValue>(value);
         break;
     case PropertyCurrentTabName:
         currentWidget->setObjectName(value.toString());
         break;
     case PropertyCurrentTabIcon:
         m_tabWidget->setTabIcon(currentIndex, qvariant_cast<QIcon>(resolvePropertyValue(index, value)));
-        m_pageToData[currentWidget].icon = qVariantValue<qdesigner_internal::PropertySheetIconValue>(value);
+        m_pageToData[currentWidget].icon = qvariant_cast<qdesigner_internal::PropertySheetIconValue>(value);
         break;
     case PropertyCurrentTabToolTip:
         m_tabWidget->setTabToolTip(currentIndex, qvariant_cast<QString>(resolvePropertyValue(index, value)));
-        m_pageToData[currentWidget].tooltip = qVariantValue<qdesigner_internal::PropertySheetStringValue>(value);
+        m_pageToData[currentWidget].tooltip = qvariant_cast<qdesigner_internal::PropertySheetStringValue>(value);
         break;
     case PropertyCurrentTabWhatsThis:
         m_tabWidget->setTabWhatsThis(currentIndex, qvariant_cast<QString>(resolvePropertyValue(index, value)));
-        m_pageToData[currentWidget].whatsthis = qVariantValue<qdesigner_internal::PropertySheetStringValue>(value);
+        m_pageToData[currentWidget].whatsthis = qvariant_cast<qdesigner_internal::PropertySheetStringValue>(value);
         break;
     case PropertyTabWidgetNone:
         break;
@@ -486,28 +486,28 @@ QVariant QTabWidgetPropertySheet::property(int index) const
     QWidget *currentWidget = m_tabWidget->currentWidget();
     if (!currentWidget) {
         if (tabWidgetProperty == PropertyCurrentTabIcon)
-            return qVariantFromValue(qdesigner_internal::PropertySheetIconValue());
+            return QVariant::fromValue(qdesigner_internal::PropertySheetIconValue());
         if (tabWidgetProperty == PropertyCurrentTabText)
-            return qVariantFromValue(qdesigner_internal::PropertySheetStringValue());
+            return QVariant::fromValue(qdesigner_internal::PropertySheetStringValue());
         if (tabWidgetProperty == PropertyCurrentTabToolTip)
-            return qVariantFromValue(qdesigner_internal::PropertySheetStringValue());
+            return QVariant::fromValue(qdesigner_internal::PropertySheetStringValue());
         if (tabWidgetProperty == PropertyCurrentTabWhatsThis)
-            return qVariantFromValue(qdesigner_internal::PropertySheetStringValue());
+            return QVariant::fromValue(qdesigner_internal::PropertySheetStringValue());
         return QVariant(QString());
     }
 
     // index-dependent
     switch (tabWidgetProperty) {
     case PropertyCurrentTabText:
-        return qVariantFromValue(m_pageToData.value(currentWidget).text);
+        return QVariant::fromValue(m_pageToData.value(currentWidget).text);
     case PropertyCurrentTabName:
         return currentWidget->objectName();
     case PropertyCurrentTabIcon:
-        return qVariantFromValue(m_pageToData.value(currentWidget).icon);
+        return QVariant::fromValue(m_pageToData.value(currentWidget).icon);
     case PropertyCurrentTabToolTip:
-        return qVariantFromValue(m_pageToData.value(currentWidget).tooltip);
+        return QVariant::fromValue(m_pageToData.value(currentWidget).tooltip);
     case PropertyCurrentTabWhatsThis:
-        return qVariantFromValue(m_pageToData.value(currentWidget).whatsthis);
+        return QVariant::fromValue(m_pageToData.value(currentWidget).whatsthis);
     case PropertyTabWidgetNone:
         break;
     }
diff --git a/tools/designer/src/lib/shared/qdesigner_taskmenu.cpp b/tools/designer/src/lib/shared/qdesigner_taskmenu.cpp
index cd95f5b..a607f35 100644
--- a/tools/designer/src/lib/shared/qdesigner_taskmenu.cpp
+++ b/tools/designer/src/lib/shared/qdesigner_taskmenu.cpp
@@ -132,7 +132,7 @@ static QString objName(const QDesignerFormEditorInterface *core, QObject *object
     const QString objectNameProperty = QLatin1String("objectName");
     const int index = sheet->indexOf(objectNameProperty);
     const qdesigner_internal::PropertySheetStringValue objectNameValue
-            = qVariantValue<qdesigner_internal::PropertySheetStringValue>(sheet->property(index));
+            = qvariant_cast<qdesigner_internal::PropertySheetStringValue>(sheet->property(index));
     return objectNameValue.value();
 }
 
@@ -447,7 +447,7 @@ void QDesignerTaskMenu::changeObjectName()
             const QString objectNameProperty = QLatin1String("objectName");
             PropertySheetStringValue objectNameValue;
             objectNameValue.setValue(newObjectName);
-            setProperty(fw, CurrentWidgetMode, objectNameProperty, qVariantFromValue(objectNameValue));
+            setProperty(fw, CurrentWidgetMode, objectNameProperty, QVariant::fromValue(objectNameValue));
         }
     }
 }
@@ -465,7 +465,7 @@ void QDesignerTaskMenu::changeTextProperty(const QString &propertyName, const QS
         qDebug() << "** WARNING Invalid property" << propertyName << " passed to changeTextProperty!";
         return;
     }
-    PropertySheetStringValue textValue = qVariantValue<PropertySheetStringValue>(sheet->property(index));
+    PropertySheetStringValue textValue = qvariant_cast<PropertySheetStringValue>(sheet->property(index));
     const QString oldText = textValue.value();
     // Pop up respective dialog
     bool accepted = false;
@@ -498,7 +498,7 @@ void QDesignerTaskMenu::changeTextProperty(const QString &propertyName, const QS
 
 
     textValue.setValue(newText);
-    setProperty(fw, pm, propertyName, qVariantFromValue(textValue));
+    setProperty(fw, pm, propertyName, QVariant::fromValue(textValue));
 }
 
 void QDesignerTaskMenu::changeToolTip()
@@ -673,7 +673,7 @@ void QDesignerTaskMenu::navigateToSlot(QDesignerFormEditorInterface *core,
     if (selectSignalDialog.exec() == QDialog::Accepted) {
         QTreeWidgetItem *selectedItem = dialogUi.signalList->selectedItems().first();
         const QString signalSignature = selectedItem->text(0);
-        const QStringList parameterNames = qVariantValue<QStringList>(selectedItem->data(0, Qt::UserRole));
+        const QStringList parameterNames = qvariant_cast<QStringList>(selectedItem->data(0, Qt::UserRole));
 
         // TODO: Check whether signal is connected to slot
         integr->emitNavigateToSlot(objectName, signalSignature, parameterNames);
diff --git a/tools/designer/src/lib/shared/qdesigner_toolbar.cpp b/tools/designer/src/lib/shared/qdesigner_toolbar.cpp
index e3bc64c..629c810 100644
--- a/tools/designer/src/lib/shared/qdesigner_toolbar.cpp
+++ b/tools/designer/src/lib/shared/qdesigner_toolbar.cpp
@@ -146,7 +146,7 @@ ActionList ToolBarEventFilter::contextMenuActions(const QPoint &globalPos)
     // Insert before
     if (action && index != 0 && !action->isSeparator()) {
         QAction *newSeperatorAct = new QAction(tr("Insert Separator before '%1'").arg(action->objectName()), 0);
-        qVariantSetValue(itemData, action);
+        itemData.setValue(action);
         newSeperatorAct->setData(itemData);
         connect(newSeperatorAct, SIGNAL(triggered()), this, SLOT(slotInsertSeparator()));
         rc.push_back(newSeperatorAct);
@@ -155,7 +155,7 @@ ActionList ToolBarEventFilter::contextMenuActions(const QPoint &globalPos)
     // Append separator
     if (actions.empty() || !actions.back()->isSeparator()) {
         QAction *newSeperatorAct = new QAction(tr("Append Separator"), 0);
-        qVariantSetValue(itemData, static_cast<QAction*>(0));
+        itemData.setValue(static_cast<QAction*>(0));
         newSeperatorAct->setData(itemData);
         connect(newSeperatorAct, SIGNAL(triggered()), this, SLOT(slotInsertSeparator()));
         rc.push_back(newSeperatorAct);
@@ -167,7 +167,7 @@ ActionList ToolBarEventFilter::contextMenuActions(const QPoint &globalPos)
     // Remove
     if (action) {
         QAction *a = new QAction(tr("Remove action '%1'").arg(action->objectName()), 0);
-        qVariantSetValue(itemData, action);
+        itemData.setValue(action);
         a->setData(itemData);
         connect(a, SIGNAL(triggered()), this, SLOT(slotRemoveSelectedAction()));
         rc.push_back(a);
diff --git a/tools/designer/src/lib/shared/qdesigner_toolbox.cpp b/tools/designer/src/lib/shared/qdesigner_toolbox.cpp
index 986bfbe..c0f7c20 100644
--- a/tools/designer/src/lib/shared/qdesigner_toolbox.cpp
+++ b/tools/designer/src/lib/shared/qdesigner_toolbox.cpp
@@ -260,12 +260,12 @@ QToolBoxWidgetPropertySheet::QToolBoxWidgetPropertySheet(QToolBox *object, QObje
     QDesignerPropertySheet(object, parent),
     m_toolBox(object)
 {
-    createFakeProperty(QLatin1String(currentItemTextKey), qVariantFromValue(qdesigner_internal::PropertySheetStringValue()));
+    createFakeProperty(QLatin1String(currentItemTextKey), QVariant::fromValue(qdesigner_internal::PropertySheetStringValue()));
     createFakeProperty(QLatin1String(currentItemNameKey), QString());
-    createFakeProperty(QLatin1String(currentItemIconKey), qVariantFromValue(qdesigner_internal::PropertySheetIconValue()));
+    createFakeProperty(QLatin1String(currentItemIconKey), QVariant::fromValue(qdesigner_internal::PropertySheetIconValue()));
     if (formWindowBase())
         formWindowBase()->addReloadableProperty(this, indexOf(QLatin1String(currentItemIconKey)));
-    createFakeProperty(QLatin1String(currentItemToolTipKey), qVariantFromValue(qdesigner_internal::PropertySheetStringValue()));
+    createFakeProperty(QLatin1String(currentItemToolTipKey), QVariant::fromValue(qdesigner_internal::PropertySheetStringValue()));
     createFakeProperty(QLatin1String(tabSpacingKey), QVariant(tabSpacingDefault));
 }
 
@@ -306,18 +306,18 @@ void QToolBoxWidgetPropertySheet::setProperty(int index, const QVariant &value)
     switch (toolBoxProperty) {
     case PropertyCurrentItemText:
         m_toolBox->setItemText(currentIndex, qvariant_cast<QString>(resolvePropertyValue(index, value)));
-        m_pageToData[currentWidget].text = qVariantValue<qdesigner_internal::PropertySheetStringValue>(value);
+        m_pageToData[currentWidget].text = qvariant_cast<qdesigner_internal::PropertySheetStringValue>(value);
         break;
     case PropertyCurrentItemName:
         currentWidget->setObjectName(value.toString());
         break;
     case PropertyCurrentItemIcon:
         m_toolBox->setItemIcon(currentIndex, qvariant_cast<QIcon>(resolvePropertyValue(index, value)));
-        m_pageToData[currentWidget].icon = qVariantValue<qdesigner_internal::PropertySheetIconValue>(value);
+        m_pageToData[currentWidget].icon = qvariant_cast<qdesigner_internal::PropertySheetIconValue>(value);
         break;
     case PropertyCurrentItemToolTip:
         m_toolBox->setItemToolTip(currentIndex, qvariant_cast<QString>(resolvePropertyValue(index, value)));
-        m_pageToData[currentWidget].tooltip = qVariantValue<qdesigner_internal::PropertySheetStringValue>(value);
+        m_pageToData[currentWidget].tooltip = qvariant_cast<qdesigner_internal::PropertySheetStringValue>(value);
         break;
     case PropertyTabSpacing:
     case PropertyToolBoxNone:
@@ -353,24 +353,24 @@ QVariant QToolBoxWidgetPropertySheet::property(int index) const
     QWidget *currentWidget = m_toolBox->currentWidget();
     if (!currentWidget) {
         if (toolBoxProperty == PropertyCurrentItemIcon)
-            return  qVariantFromValue(qdesigner_internal::PropertySheetIconValue());
+            return  QVariant::fromValue(qdesigner_internal::PropertySheetIconValue());
         if (toolBoxProperty == PropertyCurrentItemText)
-            return  qVariantFromValue(qdesigner_internal::PropertySheetStringValue());
+            return  QVariant::fromValue(qdesigner_internal::PropertySheetStringValue());
         if (toolBoxProperty == PropertyCurrentItemToolTip)
-            return  qVariantFromValue(qdesigner_internal::PropertySheetStringValue());
+            return  QVariant::fromValue(qdesigner_internal::PropertySheetStringValue());
         return QVariant(QString());
     }
 
     // index-dependent
     switch (toolBoxProperty) {
     case PropertyCurrentItemText:
-        return qVariantFromValue(m_pageToData.value(currentWidget).text);
+        return QVariant::fromValue(m_pageToData.value(currentWidget).text);
     case PropertyCurrentItemName:
         return currentWidget->objectName();
     case PropertyCurrentItemIcon:
-        return qVariantFromValue(m_pageToData.value(currentWidget).icon);
+        return QVariant::fromValue(m_pageToData.value(currentWidget).icon);
     case PropertyCurrentItemToolTip:
-        return qVariantFromValue(m_pageToData.value(currentWidget).tooltip);
+        return QVariant::fromValue(m_pageToData.value(currentWidget).tooltip);
     case PropertyTabSpacing:
     case PropertyToolBoxNone:
         break;
diff --git a/tools/designer/src/lib/shared/qdesigner_utils.cpp b/tools/designer/src/lib/shared/qdesigner_utils.cpp
index 3bd0704..de3e387 100644
--- a/tools/designer/src/lib/shared/qdesigner_utils.cpp
+++ b/tools/designer/src/lib/shared/qdesigner_utils.cpp
@@ -82,8 +82,8 @@ namespace qdesigner_internal
 
         for (int c = 0; c < item->columnCount(); c++) {
             const QVariant v = item->data(c, Qt::DecorationPropertyRole);
-            if (qVariantCanConvert<PropertySheetIconValue>(v))
-                item->setIcon(c, iconCache->icon(qVariantValue<PropertySheetIconValue>(v)));
+            if (v.canConvert<PropertySheetIconValue>())
+                item->setIcon(c, iconCache->icon(qvariant_cast<PropertySheetIconValue>(v)));
         }
     }
 
@@ -93,8 +93,8 @@ namespace qdesigner_internal
             return;
 
         const QVariant v = item->data(Qt::DecorationPropertyRole);
-        if (qVariantCanConvert<PropertySheetIconValue>(v))
-            item->setIcon(iconCache->icon(qVariantValue<PropertySheetIconValue>(v)));
+        if (v.canConvert<PropertySheetIconValue>())
+            item->setIcon(iconCache->icon(qvariant_cast<PropertySheetIconValue>(v)));
     }
 
     void reloadTableItem(DesignerIconCache *iconCache, QTableWidgetItem *item)
@@ -103,8 +103,8 @@ namespace qdesigner_internal
             return;
 
         const QVariant v = item->data(Qt::DecorationPropertyRole);
-        if (qVariantCanConvert<PropertySheetIconValue>(v))
-            item->setIcon(iconCache->icon(qVariantValue<PropertySheetIconValue>(v)));
+        if (v.canConvert<PropertySheetIconValue>())
+            item->setIcon(iconCache->icon(qvariant_cast<PropertySheetIconValue>(v)));
     }
 
     void reloadIconResources(DesignerIconCache *iconCache, QObject *object)
@@ -115,8 +115,8 @@ namespace qdesigner_internal
         } else if (QComboBox *comboBox = qobject_cast<QComboBox *>(object)) {
             for (int i = 0; i < comboBox->count(); i++) {
                 const QVariant v = comboBox->itemData(i, Qt::DecorationPropertyRole);
-                if (qVariantCanConvert<PropertySheetIconValue>(v)) {
-                    QIcon icon = iconCache->icon(qVariantValue<PropertySheetIconValue>(v));
+                if (v.canConvert<PropertySheetIconValue>()) {
+                    QIcon icon = iconCache->icon(qvariant_cast<PropertySheetIconValue>(v));
                     comboBox->setItemIcon(i, icon);
                     comboBox->setItemData(i, icon);
                 }
diff --git a/tools/designer/src/lib/shared/qdesigner_utils_p.h b/tools/designer/src/lib/shared/qdesigner_utils_p.h
index fac0697..bed1d05 100644
--- a/tools/designer/src/lib/shared/qdesigner_utils_p.h
+++ b/tools/designer/src/lib/shared/qdesigner_utils_p.h
@@ -432,15 +432,15 @@ namespace Utils {
 
 inline int valueOf(const QVariant &value, bool *ok = 0)
 {
-    if (qVariantCanConvert<PropertySheetEnumValue>(value)) {
+    if (value.canConvert<PropertySheetEnumValue>()) {
         if (ok)
             *ok = true;
-        return qVariantValue<PropertySheetEnumValue>(value).value;
+        return qvariant_cast<PropertySheetEnumValue>(value).value;
     }
-    else if (qVariantCanConvert<PropertySheetFlagValue>(value)) {
+    else if (value.canConvert<PropertySheetFlagValue>()) {
         if (ok)
             *ok = true;
-        return qVariantValue<PropertySheetFlagValue>(value).value;
+        return qvariant_cast<PropertySheetFlagValue>(value).value;
     }
     return value.toInt(ok);
 }
diff --git a/tools/designer/src/lib/shared/richtexteditor.cpp b/tools/designer/src/lib/shared/richtexteditor.cpp
index ec7c2e5..b5a2618 100644
--- a/tools/designer/src/lib/shared/richtexteditor.cpp
+++ b/tools/designer/src/lib/shared/richtexteditor.cpp
@@ -52,6 +52,9 @@
 #include <QtCore/QList>
 #include <QtCore/QMap>
 #include <QtCore/QPointer>
+#include <QtCore/QXmlStreamReader>
+#include <QtCore/QXmlStreamWriter>
+#include <QtCore/QXmlStreamAttributes>
 
 #include <QtGui/QAction>
 #include <QtGui/QColorDialog>
@@ -74,28 +77,129 @@
 
 QT_BEGIN_NAMESPACE
 
-static const char *RichTextDialogC = "RichTextDialog";
-static const char *Geometry = "Geometry";
+static const char RichTextDialogGroupC[] = "RichTextDialog";
+static const char GeometryKeyC[] = "Geometry";
+static const char TabKeyC[] = "Tab";
+
+const bool simplifyRichTextDefault = true;
 
 namespace qdesigner_internal {
 
+// Richtext simplification filter helpers: Elements to be discarded
+static inline bool filterElement(const QStringRef &name)
+{
+    return name != QLatin1String("meta") && name != QLatin1String("style");
+}
+
+// Richtext simplification filter helpers: Filter attributes of elements
+static inline void filterAttributes(const QStringRef &name,
+                                    QXmlStreamAttributes *atts,
+                                    bool *paragraphAlignmentFound)
+{
+    typedef QXmlStreamAttributes::iterator AttributeIt;
+
+    if (atts->isEmpty())
+        return;
+
+     // No style attributes for <body>
+    if (name == QLatin1String("body")) {
+        atts->clear();
+        return;
+    }
+
+    // Clean out everything except 'align' for 'p'
+    if (name == QLatin1String("p")) {
+        for (AttributeIt it = atts->begin(); it != atts->end(); ) {
+            if (it->name() == QLatin1String("align")) {
+                ++it;
+                *paragraphAlignmentFound = true;
+            } else {
+                it = atts->erase(it);
+            }
+        }
+        return;
+    }
+}
+
+// Richtext simplification filter helpers: Check for blank QStringRef.
+static inline bool isWhiteSpace(const QStringRef &in)
+{
+    const int count = in.size();
+    for (int i = 0; i < count; i++)
+        if (!in.at(i).isSpace())
+            return false;
+    return true;
+}
+
+// Richtext simplification filter: Remove hard-coded font settings,
+// <style> elements, <p> attributes other than 'align' and
+// and unnecessary meta-information.
+QString simplifyRichTextFilter(const QString &in, bool *isPlainTextPtr = 0)
+{
+    unsigned elementCount = 0;
+    bool paragraphAlignmentFound = false;
+    QString out;
+    QXmlStreamReader reader(in);
+    QXmlStreamWriter writer(&out);
+    writer.setAutoFormatting(false);
+    writer.setAutoFormattingIndent(0);
+
+    while (!reader.atEnd()) {
+        switch (reader.readNext()) {
+        case QXmlStreamReader::StartElement:
+            elementCount++;
+            if (filterElement(reader.name())) {
+                const QStringRef name = reader.name();
+                QXmlStreamAttributes attributes = reader.attributes();
+                filterAttributes(name, &attributes, &paragraphAlignmentFound);
+                writer.writeStartElement(name.toString());
+                if (!attributes.isEmpty())
+                    writer.writeAttributes(attributes);
+            } else {
+                reader.readElementText(); // Skip away all nested elements and characters.
+            }
+            break;
+        case QXmlStreamReader::Characters:
+            if (!isWhiteSpace(reader.text()))
+                writer.writeCharacters(reader.text().toString());
+            break;
+        case QXmlStreamReader::EndElement:
+            writer.writeEndElement();
+            break;
+        default:
+            break;
+        }
+    }
+    // Check for plain text (no spans, just <html><head><body><p>)
+    if (isPlainTextPtr)
+        *isPlainTextPtr = !paragraphAlignmentFound && elementCount == 4u; //
+    return out;
+}
+
 class RichTextEditor : public QTextEdit
 {
     Q_OBJECT
 public:
-    RichTextEditor(QWidget *parent = 0);
-    void setDefaultFont(const QFont &font);
+    explicit RichTextEditor(QWidget *parent = 0);
+    void setDefaultFont(QFont font);
 
     QToolBar *createToolBar(QDesignerFormEditorInterface *core, QWidget *parent = 0);
 
+    bool simplifyRichText() const      { return m_simplifyRichText; }
+
 public slots:
     void setFontBold(bool b);
     void setFontPointSize(double);
     void setText(const QString &text);
+    void setSimplifyRichText(bool v);
     QString text(Qt::TextFormat format) const;
 
 signals:
     void stateChanged();
+    void simplifyRichTextChanged(bool);
+
+private:
+    bool m_simplifyRichText;
 };
 
 class AddLinkDialog : public QDialog
@@ -303,6 +407,7 @@ private:
     QAction *m_align_justify_action;
     QAction *m_link_action;
     QAction *m_image_action;
+    QAction *m_simplify_richtext_action;
     ColorAction *m_color_action;
     QComboBox *m_font_size_input;
 
@@ -432,6 +537,17 @@ RichTextEditorToolBar::RichTextEditorToolBar(QDesignerFormEditorInterface *core,
             this, SLOT(colorChanged(QColor)));
     addAction(m_color_action);
 
+    addSeparator();
+
+    // Simplify rich text
+    m_simplify_richtext_action
+        = createCheckableAction(createIconSet(QLatin1String("simplifyrichtext.png")),
+                                tr("Simplify Rich Text"), m_editor, SLOT(setSimplifyRichText(bool)));
+    m_simplify_richtext_action->setChecked(m_editor->simplifyRichText());
+    connect(m_editor, SIGNAL(simplifyRichTextChanged(bool)),
+            m_simplify_richtext_action, SLOT(setChecked(bool)));
+    addAction(m_simplify_richtext_action);
+
     connect(editor, SIGNAL(textChanged()), this, SLOT(updateActions()));
     connect(editor, SIGNAL(stateChanged()), this, SLOT(updateActions()));
 
@@ -551,7 +667,7 @@ void RichTextEditorToolBar::updateActions()
 }
 
 RichTextEditor::RichTextEditor(QWidget *parent)
-    : QTextEdit(parent)
+    : QTextEdit(parent), m_simplifyRichText(simplifyRichTextDefault)
 {
     connect(this, SIGNAL(currentCharFormatChanged(QTextCharFormat)),
             this, SIGNAL(stateChanged()));
@@ -579,14 +695,31 @@ void RichTextEditor::setFontPointSize(double d)
 
 void RichTextEditor::setText(const QString &text)
 {
+
     if (Qt::mightBeRichText(text))
         setHtml(text);
     else
         setPlainText(text);
 }
 
-void RichTextEditor::setDefaultFont(const QFont &font)
+void RichTextEditor::setSimplifyRichText(bool v)
 {
+    if (v != m_simplifyRichText) {
+        m_simplifyRichText = v;
+        emit simplifyRichTextChanged(v);
+    }
+}
+
+void RichTextEditor::setDefaultFont(QFont font)
+{
+    // Some default fonts on Windows have a default size of 7.8,
+    // which results in complicated rich text generated by toHtml().
+    // Use an integer value.
+    const int pointSize = qRound(font.pointSizeF());
+    if (pointSize > 0 && !qFuzzyCompare(qreal(pointSize), font.pointSizeF())) {
+        font.setPointSize(pointSize);
+    }
+
     document()->setDefaultFont(font);
     if (font.pointSize() > 0)
         setFontPointSize(font.pointSize());
@@ -602,15 +735,16 @@ QString RichTextEditor::text(Qt::TextFormat format) const
     case Qt::PlainText:
         return toPlainText();
     case Qt::RichText:
-        return toHtml();
+        return m_simplifyRichText ? simplifyRichTextFilter(toHtml()) : toHtml();
     case Qt::AutoText:
         break;
     }
     const QString html = toHtml();
-    const QString plain = toPlainText();
-    QTextEdit tester;
-    tester.setPlainText(plain);
-    return tester.toHtml() == html ? plain : html;
+    bool isPlainText;
+    const QString simplifiedHtml = simplifyRichTextFilter(html, &isPlainText);
+    if (isPlainText)
+        return toPlainText();
+    return m_simplifyRichText ? simplifiedHtml : html;
 }
 
 RichTextEditorDialog::RichTextEditorDialog(QDesignerFormEditorInterface *core, QWidget *parent)  :
@@ -619,15 +753,25 @@ RichTextEditorDialog::RichTextEditorDialog(QDesignerFormEditorInterface *core, Q
     m_text_edit(new HtmlTextEdit),
     m_tab_widget(new QTabWidget),
     m_state(Clean),
-    m_core(core)
+    m_core(core),
+    m_initialTab(RichTextIndex)
 {
     setWindowTitle(tr("Edit text"));
     setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
 
+    // Read settings
+    const QDesignerSettingsInterface *settings = core->settingsManager();
+    const QString rootKey = QLatin1String(RichTextDialogGroupC) + QLatin1Char('/');
+    const QByteArray lastGeometry = settings->value(rootKey + QLatin1String(GeometryKeyC)).toByteArray();
+    const int initialTab = settings->value(rootKey + QLatin1String(TabKeyC), QVariant(m_initialTab)).toInt();
+    if (initialTab == RichTextIndex || initialTab == SourceIndex)
+        m_initialTab = initialTab;
+
     m_text_edit->setAcceptRichText(false);
     new HtmlHighlighter(m_text_edit);
 
     connect(m_editor, SIGNAL(textChanged()), this, SLOT(richTextChanged()));
+    connect(m_editor, SIGNAL(simplifyRichTextChanged(bool)), this, SLOT(richTextChanged()));
     connect(m_text_edit, SIGNAL(textChanged()), this, SLOT(sourceChanged()));
 
     // The toolbar needs to be created after the RichTextEditor
@@ -661,32 +805,33 @@ RichTextEditorDialog::RichTextEditorDialog(QDesignerFormEditorInterface *core, Q
     layout->addWidget(m_tab_widget);
     layout->addWidget(buttonBox);
 
-    m_editor->setFocus();
-
-    QDesignerSettingsInterface *settings = core->settingsManager();
-    settings->beginGroup(QLatin1String(RichTextDialogC));
-
-    if (settings->contains(QLatin1String(Geometry)))
-        restoreGeometry(settings->value(QLatin1String(Geometry)).toByteArray());
-
-    settings->endGroup();
+    if (!lastGeometry.isEmpty())
+        restoreGeometry(lastGeometry);
 }
 
 RichTextEditorDialog::~RichTextEditorDialog()
 {
     QDesignerSettingsInterface *settings = m_core->settingsManager();
-    settings->beginGroup(QLatin1String(RichTextDialogC));
+    settings->beginGroup(QLatin1String(RichTextDialogGroupC));
 
-    settings->setValue(QLatin1String(Geometry), saveGeometry());
+    settings->setValue(QLatin1String(GeometryKeyC), saveGeometry());
+    settings->setValue(QLatin1String(TabKeyC), m_tab_widget->currentIndex());
     settings->endGroup();
 }
 
 int RichTextEditorDialog::showDialog()
 {
-    m_tab_widget->setCurrentIndex(0);
-    m_editor->selectAll();
-    m_editor->setFocus();
-
+    m_tab_widget->setCurrentIndex(m_initialTab);
+    switch (m_initialTab) {
+    case RichTextIndex:
+        m_editor->selectAll();
+        m_editor->setFocus();
+        break;
+    case SourceIndex:
+        m_text_edit->selectAll();
+        m_text_edit->setFocus();
+        break;
+    }
     return exec();
 }
 
@@ -697,6 +842,9 @@ void RichTextEditorDialog::setDefaultFont(const QFont &font)
 
 void RichTextEditorDialog::setText(const QString &text)
 {
+    // Generally simplify rich text unless verbose text is found.
+    const bool isSimplifiedRichText = !text.startsWith("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">");
+    m_editor->setSimplifyRichText(isSimplifiedRichText);
     m_editor->setText(text);
     m_text_edit->setPlainText(text);
     m_state = Clean;
diff --git a/tools/designer/src/lib/shared/richtexteditor_p.h b/tools/designer/src/lib/shared/richtexteditor_p.h
index 44023ef..116ecb4 100644
--- a/tools/designer/src/lib/shared/richtexteditor_p.h
+++ b/tools/designer/src/lib/shared/richtexteditor_p.h
@@ -93,6 +93,7 @@ private:
     QTabWidget     *m_tab_widget;
     State m_state;
     QDesignerFormEditorInterface *m_core;
+    int m_initialTab;
 };
 
 } // namespace qdesigner_internal
diff --git a/tools/designer/src/lib/shared/stylesheeteditor.cpp b/tools/designer/src/lib/shared/stylesheeteditor.cpp
index b76d700..bee5210 100644
--- a/tools/designer/src/lib/shared/stylesheeteditor.cpp
+++ b/tools/designer/src/lib/shared/stylesheeteditor.cpp
@@ -79,6 +79,7 @@ StyleSheetEditor::StyleSheetEditor(QWidget *parent)
     : QTextEdit(parent)
 {
     setTabStopWidth(fontMetrics().width(QLatin1Char(' '))*4);
+    setAcceptRichText(false);
     new CssHighlighter(document());
 }
 
@@ -393,14 +394,14 @@ StyleSheetPropertyEditorDialog::StyleSheetPropertyEditorDialog(QWidget *parent,
             qt_extension<QDesignerPropertySheetExtension*>(m_fw->core()->extensionManager(), m_widget);
     Q_ASSERT(sheet != 0);
     const int index = sheet->indexOf(QLatin1String(styleSheetProperty));
-    const PropertySheetStringValue value = qVariantValue<PropertySheetStringValue>(sheet->property(index));
+    const PropertySheetStringValue value = qvariant_cast<PropertySheetStringValue>(sheet->property(index));
     setText(value.value());
 }
 
 void StyleSheetPropertyEditorDialog::applyStyleSheet()
 {
     const PropertySheetStringValue value(text(), false);
-    m_fw->cursor()->setWidgetProperty(m_widget, QLatin1String(styleSheetProperty), qVariantFromValue(value));
+    m_fw->cursor()->setWidgetProperty(m_widget, QLatin1String(styleSheetProperty), QVariant::fromValue(value));
 }
 
 } // namespace qdesigner_internal
diff --git a/tools/designer/src/lib/shared/widgetfactory.cpp b/tools/designer/src/lib/shared/widgetfactory.cpp
index c7b13a1..d686052 100644
--- a/tools/designer/src/lib/shared/widgetfactory.cpp
+++ b/tools/designer/src/lib/shared/widgetfactory.cpp
@@ -782,7 +782,7 @@ void WidgetFactory::applyStyleToTopLevel(QStyle *style, QWidget *widget)
 
     widget->setStyle(style);
     widget->setPalette(standardPalette);
-    const QWidgetList lst = qFindChildren<QWidget*>(widget);
+    const QWidgetList lst = widget->findChildren<QWidget*>();
     const QWidgetList::const_iterator cend = lst.constEnd();
     for (QWidgetList::const_iterator it = lst.constBegin(); it != cend; ++it)
         (*it)->setStyle(style);
diff --git a/tools/designer/src/lib/shared/zoomwidget.cpp b/tools/designer/src/lib/shared/zoomwidget.cpp
index f5d7434..5cf4ea2 100644
--- a/tools/designer/src/lib/shared/zoomwidget.cpp
+++ b/tools/designer/src/lib/shared/zoomwidget.cpp
@@ -328,7 +328,7 @@ void ZoomWidget::setWidget(QWidget *w, Qt::WindowFlags wFlags)
         scene().removeItem(m_proxy);
         if (QWidget *w = m_proxy->widget()) {
             // remove the event filter
-            if (QObject *evf =  qFindChild<QObject*>(w, QLatin1String(zoomedEventFilterRedirectorNameC)))
+            if (QObject *evf =  w->findChild<QObject*>(QLatin1String(zoomedEventFilterRedirectorNameC)))
                 w->removeEventFilter(evf);
         }
         m_proxy->deleteLater();
diff --git a/tools/designer/src/lib/uilib/abstractformbuilder.cpp b/tools/designer/src/lib/uilib/abstractformbuilder.cpp
index 6f009e3..ad2aa05 100644
--- a/tools/designer/src/lib/uilib/abstractformbuilder.cpp
+++ b/tools/designer/src/lib/uilib/abstractformbuilder.cpp
@@ -341,7 +341,7 @@ QWidget *QAbstractFormBuilder::create(DomWidget *ui_widget, QWidget *parentWidge
                 w->addAction(a);
             } else if (QActionGroup *g = m_actionGroups.value(name)) {
                 w->addActions(g->actions());
-            } else if (QMenu *menu = qFindChild<QMenu*>(w, name)) {
+            } else if (QMenu *menu = w->findChild<QMenu*>(name)) {
                 w->addAction(menu->menuAction());
                 addMenuAction(menu->menuAction());
             }
@@ -363,9 +363,9 @@ QWidget *QAbstractFormBuilder::create(DomWidget *ui_widget, QWidget *parentWidge
 
     const QStringList zOrderNames = ui_widget->elementZOrder();
     if (!zOrderNames.isEmpty()) {
-        QList<QWidget *> zOrder = qVariantValue<QWidgetList>(w->property("_q_zOrder"));
+        QList<QWidget *> zOrder = qvariant_cast<QWidgetList>(w->property("_q_zOrder"));
         foreach (const QString &widgetName, zOrderNames) {
-            if (QWidget *child = qFindChild<QWidget*>(w, widgetName)) {
+            if (QWidget *child = w->findChild<QWidget*>(widgetName)) {
                 if (child->parentWidget() == w) {
                     zOrder.removeAll(child);
                     zOrder.append(child);
@@ -373,7 +373,7 @@ QWidget *QAbstractFormBuilder::create(DomWidget *ui_widget, QWidget *parentWidge
                 }
             }
         }
-        w->setProperty("_q_zOrder", qVariantFromValue(zOrder));
+        w->setProperty("_q_zOrder", QVariant::fromValue(zOrder));
     }
 
     return w;
@@ -1287,7 +1287,7 @@ DomWidget *QAbstractFormBuilder::createDom(QWidget *widget, DomWidget *ui_parent
     {
         QList<QObject *> childObjects = widget->children();
 
-        const QList<QWidget *> list = qVariantValue<QWidgetList>(widget->property("_q_widgetOrder"));
+        const QList<QWidget *> list = qvariant_cast<QWidgetList>(widget->property("_q_widgetOrder"));
         foreach (QWidget *w, list) {
             if (childObjects.contains(w)) {
                 children.append(w);
@@ -1296,7 +1296,7 @@ DomWidget *QAbstractFormBuilder::createDom(QWidget *widget, DomWidget *ui_parent
         }
         children += childObjects;
 
-        const QList<QWidget *> zOrder = qVariantValue<QWidgetList>(widget->property("_q_zOrder"));
+        const QList<QWidget *> zOrder = qvariant_cast<QWidgetList>(widget->property("_q_zOrder"));
         if (list != zOrder) {
             QStringList zOrderList;
             QListIterator<QWidget* > itZOrder(zOrder);
@@ -1603,14 +1603,14 @@ void QAbstractFormBuilder::applyTabStops(QWidget *widget, DomTabStops *tabStops)
     for (int i=0; i<l.size(); ++i) {
         const QString name = l.at(i);
 
-        QWidget *child = qFindChild<QWidget*>(widget, name);
+        QWidget *child = widget->findChild<QWidget*>(name);
         if (!child) {
             uiLibWarning(QCoreApplication::translate("QAbstractFormBuilder", "While applying tab stops: The widget '%1' could not be found.").arg(name));
             continue;
         }
 
         if (i == 0) {
-            lastWidget = qFindChild<QWidget*>(widget, name);
+            lastWidget = widget->findChild<QWidget*>(name);
             continue;
         } else if (!child || !lastWidget) {
             continue;
@@ -1618,7 +1618,7 @@ void QAbstractFormBuilder::applyTabStops(QWidget *widget, DomTabStops *tabStops)
 
         QWidget::setTabOrder(lastWidget, child);
 
-        lastWidget = qFindChild<QWidget*>(widget, name);
+        lastWidget = widget->findChild<QWidget*>(name);
     }
 }
 
@@ -1747,7 +1747,7 @@ static void loadItemProps(QAbstractFormBuilder *abstractFormBuilder, T *item,
         if ((p = properties.value(it.second))) {
             v = formBuilder->textBuilder()->loadText(p);
             QVariant nativeValue = formBuilder->textBuilder()->toNativeValue(v);
-            item->setData(it.first.first, qVariantValue<QString>(nativeValue));
+            item->setData(it.first.first, qvariant_cast<QString>(nativeValue));
             item->setData(it.first.second, v);
         }
 
@@ -1759,7 +1759,7 @@ static void loadItemProps(QAbstractFormBuilder *abstractFormBuilder, T *item,
     if ((p = properties.value(strings.iconAttribute))) {
         v = formBuilder->resourceBuilder()->loadResource(formBuilder->workingDirectory(), p);
         QVariant nativeValue = formBuilder->resourceBuilder()->toNativeValue(v);
-        item->setIcon(qVariantValue<QIcon>(nativeValue));
+        item->setIcon(qvariant_cast<QIcon>(nativeValue));
         item->setData(Qt::DecorationPropertyRole, v);
     }
 }
@@ -1855,7 +1855,7 @@ static void loadItemProps(QAbstractFormBuilder *abstractFormBuilder, QTableWidge
         if ((p = properties.value(it.second))) {
             v = formBuilder->textBuilder()->loadText(p);
             QVariant nativeValue = formBuilder->textBuilder()->toNativeValue(v);
-            item->setData(it.first.first, qVariantValue<QString>(nativeValue));
+            item->setData(it.first.first, qvariant_cast<QString>(nativeValue));
             item->setData(it.first.second, v);
         }
 
@@ -1867,7 +1867,7 @@ static void loadItemProps(QAbstractFormBuilder *abstractFormBuilder, QTableWidge
     if ((p = properties.value(strings.iconAttribute))) {
         v = formBuilder->resourceBuilder()->loadResource(formBuilder->workingDirectory(), p);
         QVariant nativeValue = formBuilder->resourceBuilder()->toNativeValue(v);
-        item->setIcon(qVariantValue<QIcon>(nativeValue));
+        item->setIcon(qvariant_cast<QIcon>(nativeValue));
         item->setData(Qt::DecorationPropertyRole, v);
     }
 }
@@ -1885,7 +1885,7 @@ static void loadItemProps(QAbstractFormBuilder *abstractFormBuilder, QListWidget
         if ((p = properties.value(it.second))) {
             v = formBuilder->textBuilder()->loadText(p);
             QVariant nativeValue = formBuilder->textBuilder()->toNativeValue(v);
-            item->setData(it.first.first, qVariantValue<QString>(nativeValue));
+            item->setData(it.first.first, qvariant_cast<QString>(nativeValue));
             item->setData(it.first.second, v);
         }
 
@@ -1897,7 +1897,7 @@ static void loadItemProps(QAbstractFormBuilder *abstractFormBuilder, QListWidget
     if ((p = properties.value(strings.iconAttribute))) {
         v = formBuilder->resourceBuilder()->loadResource(formBuilder->workingDirectory(), p);
         QVariant nativeValue = formBuilder->resourceBuilder()->toNativeValue(v);
-        item->setIcon(qVariantValue<QIcon>(nativeValue));
+        item->setIcon(qvariant_cast<QIcon>(nativeValue));
         item->setData(Qt::DecorationPropertyRole, v);
     }
 }
@@ -2337,14 +2337,14 @@ void QAbstractFormBuilder::loadTreeWidgetExtraInfo(DomWidget *ui_widget, QTreeWi
             if ((p = properties.value(it.second))) {
                 v = textBuilder()->loadText(p);
                 QVariant nativeValue = textBuilder()->toNativeValue(v);
-                treeWidget->headerItem()->setData(i, it.first.first, qVariantValue<QString>(nativeValue));
+                treeWidget->headerItem()->setData(i, it.first.first, qvariant_cast<QString>(nativeValue));
                 treeWidget->headerItem()->setData(i, it.first.second, v);
             }
 
         if ((p = properties.value(strings.iconAttribute))) {
             v = resourceBuilder()->loadResource(workingDirectory(), p);
             QVariant nativeValue = resourceBuilder()->toNativeValue(v);
-            treeWidget->headerItem()->setIcon(i, qVariantValue<QIcon>(nativeValue));
+            treeWidget->headerItem()->setIcon(i, qvariant_cast<QIcon>(nativeValue));
             treeWidget->headerItem()->setData(i, Qt::DecorationPropertyRole, v);
         }
     }
@@ -2374,14 +2374,14 @@ void QAbstractFormBuilder::loadTreeWidgetExtraInfo(DomWidget *ui_widget, QTreeWi
                 col++;
                 QVariant textV = textBuilder()->loadText(property);
                 QVariant nativeValue = textBuilder()->toNativeValue(textV);
-                currentItem->setText(col, qVariantValue<QString>(nativeValue));
+                currentItem->setText(col, qvariant_cast<QString>(nativeValue));
                 currentItem->setData(col, Qt::DisplayPropertyRole, textV);
             } else if (col >= 0) {
                 if (property->attributeName() == strings.iconAttribute) {
                     QVariant v = resourceBuilder()->loadResource(workingDirectory(), property);
                     if (v.isValid()) {
                         QVariant nativeValue = resourceBuilder()->toNativeValue(v);
-                        currentItem->setIcon(col, qVariantValue<QIcon>(nativeValue));
+                        currentItem->setIcon(col, qvariant_cast<QIcon>(nativeValue));
                         currentItem->setData(col, Qt::DecorationPropertyRole, v);
                     }
                 } else {
@@ -2397,7 +2397,7 @@ void QAbstractFormBuilder::loadTreeWidgetExtraInfo(DomWidget *ui_widget, QTreeWi
                         if (rolePair.first >= 0) {
                             QVariant textV = textBuilder()->loadText(property);
                             QVariant nativeValue = textBuilder()->toNativeValue(textV);
-                            currentItem->setData(col, rolePair.first, qVariantValue<QString>(nativeValue));
+                            currentItem->setData(col, rolePair.first, qvariant_cast<QString>(nativeValue));
                             currentItem->setData(col, rolePair.second, textV);
                         }
                     }
@@ -2475,13 +2475,13 @@ void QAbstractFormBuilder::loadComboBoxExtraInfo(DomWidget *ui_widget, QComboBox
         p = properties.value(strings.textAttribute);
         if (p && p->elementString()) {
              textData = textBuilder()->loadText(p);
-             text = qVariantValue<QString>(textBuilder()->toNativeValue(textData));
+             text = qvariant_cast<QString>(textBuilder()->toNativeValue(textData));
         }
 
         p = properties.value(strings.iconAttribute);
         if (p) {
              iconData = resourceBuilder()->loadResource(workingDirectory(), p);
-             icon = qVariantValue<QIcon>(resourceBuilder()->toNativeValue(iconData));
+             icon = qvariant_cast<QIcon>(resourceBuilder()->toNativeValue(iconData));
         }
 
         comboBox->addItem(icon, text);
diff --git a/tools/designer/src/lib/uilib/formbuilder.cpp b/tools/designer/src/lib/uilib/formbuilder.cpp
index c97daac..c7d4e90 100644
--- a/tools/designer/src/lib/uilib/formbuilder.cpp
+++ b/tools/designer/src/lib/uilib/formbuilder.cpp
@@ -319,7 +319,7 @@ QWidget *QFormBuilder::widgetByName(QWidget *topLevel, const QString &name)
     if (topLevel->objectName() == name)
         return topLevel;
 
-    return qFindChild<QWidget*>(topLevel, name);
+    return topLevel->findChild<QWidget*>(name);
 }
 
 static QObject *objectByName(QWidget *topLevel, const QString &name)
@@ -328,7 +328,7 @@ static QObject *objectByName(QWidget *topLevel, const QString &name)
     if (topLevel->objectName() == name)
         return topLevel;
 
-    return qFindChild<QObject*>(topLevel, name);
+    return topLevel->findChild<QObject*>(name);
 }
 
 /*!
diff --git a/tools/designer/src/lib/uilib/formbuilderextra.cpp b/tools/designer/src/lib/uilib/formbuilderextra.cpp
index 6c3357f..0747974 100644
--- a/tools/designer/src/lib/uilib/formbuilderextra.cpp
+++ b/tools/designer/src/lib/uilib/formbuilderextra.cpp
@@ -136,7 +136,7 @@ bool QFormBuilderExtra::applyBuddy(const QString &buddyName, BuddyMode applyMode
         return false;
     }
 
-    const QWidgetList widgets = qFindChildren<QWidget*>(label->topLevelWidget(), buddyName);
+    const QWidgetList widgets = label->topLevelWidget()->findChildren<QWidget*>(buddyName);
     if (widgets.empty()) {
         label->setBuddy(0);
         return false;
diff --git a/tools/designer/src/lib/uilib/properties.cpp b/tools/designer/src/lib/uilib/properties.cpp
index 615aa8a..b660dc4 100644
--- a/tools/designer/src/lib/uilib/properties.cpp
+++ b/tools/designer/src/lib/uilib/properties.cpp
@@ -78,7 +78,7 @@ QVariant domPropertyToVariant(QAbstractFormBuilder *afb,const QMetaObject *meta,
     case DomProperty::String: {
         const int index = meta->indexOfProperty(p->attributeName().toUtf8());
         if (index != -1 && meta->property(index).type() == QVariant::KeySequence)
-            return qVariantFromValue(QKeySequence(p->elementString()->text()));
+            return QVariant::fromValue(QKeySequence(p->elementString()->text()));
     }
         break;
 
@@ -96,7 +96,7 @@ QVariant domPropertyToVariant(QAbstractFormBuilder *afb,const QMetaObject *meta,
             afb->setupColorGroup(palette, QPalette::Disabled, dom->elementDisabled());
 
         palette.setCurrentColorGroup(QPalette::Active);
-        return qVariantFromValue(palette);
+        return QVariant::fromValue(palette);
     }
 
     case DomProperty::Set: {
@@ -135,7 +135,7 @@ QVariant domPropertyToVariant(QAbstractFormBuilder *afb,const QMetaObject *meta,
         return QVariant(e.keyToValue(enumValue.toUtf8()));
     }
     case DomProperty::Brush:
-        return qVariantFromValue(afb->setupBrush(p->elementBrush()));
+        return QVariant::fromValue(afb->setupBrush(p->elementBrush()));
     default:
         if (afb->resourceBuilder()->isResourceProperty(p)) {
             return afb->resourceBuilder()->loadResource(afb->workingDirectory(), p);
@@ -212,7 +212,7 @@ QVariant domPropertyToVariant(const DomProperty *p)
     case DomProperty::Char: {
         const DomChar *character = p->elementChar();
         const QChar c(character->elementUnicode());
-        return qVariantFromValue(c);
+        return QVariant::fromValue(c);
     }
 
     case DomProperty::Color: {
@@ -220,7 +220,7 @@ QVariant domPropertyToVariant(const DomProperty *p)
         QColor c(color->elementRed(), color->elementGreen(), color->elementBlue());
         if (color->hasAttributeAlpha())
             c.setAlpha(color->attributeAlpha());
-        return qVariantFromValue(c);
+        return QVariant::fromValue(c);
     }
 
     case DomProperty::Font: {
@@ -248,7 +248,7 @@ QVariant domPropertyToVariant(const DomProperty *p)
         if (font->hasElementStyleStrategy()) {
             f.setStyleStrategy(enumKeyOfObjectToValue<QAbstractFormBuilderGadget, QFont::StyleStrategy>("styleStrategy", font->elementStyleStrategy().toLatin1()));
         }
-        return qVariantFromValue(f);
+        return QVariant::fromValue(f);
     }
 
     case DomProperty::Date: {
@@ -275,15 +275,15 @@ QVariant domPropertyToVariant(const DomProperty *p)
 
 #ifndef QT_NO_CURSOR
     case DomProperty::Cursor:
-        return qVariantFromValue(QCursor(static_cast<Qt::CursorShape>(p->elementCursor())));
+        return QVariant::fromValue(QCursor(static_cast<Qt::CursorShape>(p->elementCursor())));
 
     case DomProperty::CursorShape:
-        return qVariantFromValue(QCursor(enumKeyOfObjectToValue<QAbstractFormBuilderGadget, Qt::CursorShape>("cursorShape", p->elementCursorShape().toLatin1())));
+        return QVariant::fromValue(QCursor(enumKeyOfObjectToValue<QAbstractFormBuilderGadget, Qt::CursorShape>("cursorShape", p->elementCursorShape().toLatin1())));
 #endif
 
     case DomProperty::Locale: {
         const DomLocale *locale = p->elementLocale();
-        return qVariantFromValue(QLocale(enumKeyOfObjectToValue<QAbstractFormBuilderGadget, QLocale::Language>("language", locale->attributeLanguage().toLatin1()),
+        return QVariant::fromValue(QLocale(enumKeyOfObjectToValue<QAbstractFormBuilderGadget, QLocale::Language>("language", locale->attributeLanguage().toLatin1()),
                     enumKeyOfObjectToValue<QAbstractFormBuilderGadget, QLocale::Country>("country", locale->attributeCountry().toLatin1())));
     }
     case DomProperty::SizePolicy: {
@@ -309,7 +309,7 @@ QVariant domPropertyToVariant(const DomProperty *p)
             sizePolicy.setVerticalPolicy(sp);
         }
 
-        return qVariantFromValue(sizePolicy);
+        return QVariant::fromValue(sizePolicy);
     }
 
     case DomProperty::StringList:
diff --git a/tools/designer/src/lib/uilib/resourcebuilder.cpp b/tools/designer/src/lib/uilib/resourcebuilder.cpp
index 810bea0..d19a09a 100644
--- a/tools/designer/src/lib/uilib/resourcebuilder.cpp
+++ b/tools/designer/src/lib/uilib/resourcebuilder.cpp
@@ -91,7 +91,7 @@ QVariant QResourceBuilder::loadResource(const QDir &workingDirectory, const DomP
         case DomProperty::Pixmap: {
             const DomResourcePixmap *dpx = property->elementPixmap();
             QPixmap pixmap(QFileInfo(workingDirectory, dpx->text()).absoluteFilePath());
-            return qVariantFromValue(pixmap);
+            return QVariant::fromValue(pixmap);
         }
         case DomProperty::IconSet: {
             const DomResourceIcon *dpi = property->elementIconSet();
@@ -113,10 +113,10 @@ QVariant QResourceBuilder::loadResource(const QDir &workingDirectory, const DomP
                     icon.addFile(QFileInfo(workingDirectory, dpi->elementSelectedOff()->text()).absoluteFilePath(), QSize(), QIcon::Selected, QIcon::Off);
                 if (flags & SelectedOn)
                     icon.addFile(QFileInfo(workingDirectory, dpi->elementSelectedOn()->text()).absoluteFilePath(), QSize(), QIcon::Selected, QIcon::On);
-                return qVariantFromValue(icon);
+                return QVariant::fromValue(icon);
             } else { // 4.3 legacy
                 const QIcon icon(QFileInfo(workingDirectory, dpi->text()).absoluteFilePath());
-                return qVariantFromValue(icon);
+                return QVariant::fromValue(icon);
             }
         }
             break;
diff --git a/tools/designer/src/uitools/quiloader.cpp b/tools/designer/src/uitools/quiloader.cpp
index c7e7829..411059e 100644
--- a/tools/designer/src/uitools/quiloader.cpp
+++ b/tools/designer/src/uitools/quiloader.cpp
@@ -102,27 +102,27 @@ QVariant TranslatingTextBuilder::loadText(const DomProperty *text) const
     if (str->hasAttributeNotr()) {
         const QString notr = str->attributeNotr();
         if (notr == QLatin1String("true") || notr == QLatin1String("yes"))
-            return qVariantFromValue(str->text());
+            return QVariant::fromValue(str->text());
     }
     QUiTranslatableStringValue strVal;
     strVal.setValue(str->text().toUtf8());
     if (str->hasAttributeComment())
         strVal.setComment(str->attributeComment().toUtf8());
-    return qVariantFromValue(strVal);
+    return QVariant::fromValue(strVal);
 }
 
 QVariant TranslatingTextBuilder::toNativeValue(const QVariant &value) const
 {
-    if (qVariantCanConvert<QUiTranslatableStringValue>(value)) {
-        QUiTranslatableStringValue tsv = qVariantValue<QUiTranslatableStringValue>(value);
+    if (value.canConvert<QUiTranslatableStringValue>()) {
+        QUiTranslatableStringValue tsv = qvariant_cast<QUiTranslatableStringValue>(value);
         if (!m_trEnabled)
             return QString::fromUtf8(tsv.value().data());
-        return qVariantFromValue(
+        return QVariant::fromValue(
             QApplication::translate(m_className, tsv.value(), tsv.comment(),
                                     QCoreApplication::UnicodeUTF8));
     }
-    if (qVariantCanConvert<QString>(value))
-        return qVariantFromValue(qVariantValue<QString>(value));
+    if (value.canConvert<QString>())
+        return QVariant::fromValue(qvariant_cast<QString>(value));
     return value;
 }
 
@@ -150,7 +150,7 @@ static void recursiveReTranslate(QTreeWidgetItem *item, const QByteArray &class_
         for (unsigned j = 0; irs[j].shadowRole >= 0; j++) {
             QVariant v = item->data(i, irs[j].shadowRole);
             if (v.isValid()) {
-                QUiTranslatableStringValue tsv = qVariantValue<QUiTranslatableStringValue>(v);
+                QUiTranslatableStringValue tsv = qvariant_cast<QUiTranslatableStringValue>(v);
                 const QString text = QApplication::translate(class_name,
                                                              tsv.value(), tsv.comment(),
                                                              QCoreApplication::UnicodeUTF8);
@@ -172,7 +172,7 @@ static void reTranslateWidgetItem(T *item, const QByteArray &class_name)
     for (unsigned j = 0; irs[j].shadowRole >= 0; j++) {
         QVariant v = item->data(irs[j].shadowRole);
         if (v.isValid()) {
-            QUiTranslatableStringValue tsv = qVariantValue<QUiTranslatableStringValue>(v);
+            QUiTranslatableStringValue tsv = qvariant_cast<QUiTranslatableStringValue>(v);
             const QString text = QApplication::translate(class_name,
                                                          tsv.value(), tsv.comment(),
                                                          QCoreApplication::UnicodeUTF8);
@@ -191,7 +191,7 @@ static void reTranslateTableItem(QTableWidgetItem *item, const QByteArray &class
     do { \
         QVariant v = mainWidget->widget(i)->property(propName); \
         if (v.isValid()) { \
-            QUiTranslatableStringValue tsv = qVariantValue<QUiTranslatableStringValue>(v); \
+            QUiTranslatableStringValue tsv = qvariant_cast<QUiTranslatableStringValue>(v); \
             const QString text = QApplication::translate(m_className, \
                                                          tsv.value(), tsv.comment(), \
                                                          QCoreApplication::UnicodeUTF8); \
@@ -217,7 +217,7 @@ public:
                 if (prop.startsWith(PROP_GENERIC_PREFIX)) {
                     const QByteArray propName = prop.mid(sizeof(PROP_GENERIC_PREFIX) - 1);
                     const QUiTranslatableStringValue tsv =
-                                qVariantValue<QUiTranslatableStringValue>(o->property(prop));
+                                qvariant_cast<QUiTranslatableStringValue>(o->property(prop));
                     const QString text = QApplication::translate(m_className,
                                                                  tsv.value(), tsv.comment(),
                                                                  QCoreApplication::UnicodeUTF8);
@@ -273,7 +273,7 @@ public:
                     for (int i = 0; i < cnt; ++i) {
                         const QVariant v = combow->itemData(i, Qt::DisplayPropertyRole);
                         if (v.isValid()) {
-                            QUiTranslatableStringValue tsv = qVariantValue<QUiTranslatableStringValue>(v);
+                            QUiTranslatableStringValue tsv = qvariant_cast<QUiTranslatableStringValue>(v);
                             const QString text = QApplication::translate(m_className,
                                                                          tsv.value(), tsv.comment(),
                                                                          QCoreApplication::UnicodeUTF8);
@@ -430,7 +430,7 @@ void FormBuilderPrivate::applyProperties(QObject *o, const QList<DomProperty*> &
             continue;
         const QByteArray name = p->attributeName().toUtf8();
         if (dynamicTr) {
-            o->setProperty(PROP_GENERIC_PREFIX + name, qVariantFromValue(strVal));
+            o->setProperty(PROP_GENERIC_PREFIX + name, QVariant::fromValue(strVal));
             anyTrs = trEnabled;
         }
         o->setProperty(name, text);
@@ -489,7 +489,7 @@ QWidget *FormBuilderPrivate::create(DomWidget *ui_widget, QWidget *parentWidget)
             const QString text = convertTranslatable(p##attribute, m_class, &strVal); \
             if (!text.isEmpty()) { \
                 if (dynamicTr) \
-                    mainWidget->widget(i)->setProperty(propName, qVariantFromValue(strVal)); \
+                    mainWidget->widget(i)->setProperty(propName, QVariant::fromValue(strVal)); \
                 mainWidget->setter(i, text); \
             } \
         } \