QmlDesigner: Add property editor tracing

Change-Id: I80dd04d1721c0ae3ab84c061f92e0646beb1ccf2
Reviewed-by: Thomas Hartmann <thomas.hartmann@qt.io>

src/plugins/qmldesigner/CMakeLists.txt

@@ -32,10 +32,15 @@ env_with_default("QDS_DESIGNVIEWER_USE_STAGING" ENV_QDS_DESIGNVIEWER_USE_STAGING
 option(QDS_DESIGNVIEWER_USE_STAGING "Use staging API URL for Design Viewer" ${ENV_QDS_DESIGNVIEWER_USE_STAGING})
 add_feature_info("Use staging API URL for Design Viewer" ${QDS_DESIGNVIEWER_USE_STAGING} "")
 
+env_with_default("QTC_ENABLE_PROPERTY_EDITOR_TRACING" ENV_QTC_ENABLE_PROPERTY_EDITOR_TRACING OFF)
+option(ENABLE_PROPERTY_EDITOR_TRACING "Enable property editor tracing" ${ENV_QTC_ENABLE_PROPERTY_EDITOR_TRACING})
+add_feature_info("Property editor tracing" ${ENABLE_PROPERTY_EDITOR_TRACING} "")
 
 env_with_default("QTC_ENABLE_FORM_EDITOR_TRACING" ENV_QTC_ENABLE_FORM_EDITOR_TRACING OFF)
 option(ENABLE_FORM_EDITOR_TRACING "Enable form editor tracing" ${ENV_QTC_ENABLE_FORM_EDITOR_TRACING})
-add_feature_info("Model tracing" ${ENABLE_FORM_EDITOR_TRACING} "")
+add_feature_info("Form editor tracing" ${ENABLE_FORM_EDITOR_TRACING} "")
+
+
 
 if(QDS_DESIGNVIEWER_USE_STAGING)
   add_definitions(-DQDS_DESIGNVIEWER_USE_STAGING)
@@ -410,6 +415,8 @@ extend_qtc_plugin(QmlDesigner
 extend_qtc_plugin(QmlDesigner
   SOURCES_PREFIX components/propertyeditor
   PUBLIC_INCLUDES components/propertyeditor  
+  PUBLIC_DEFINES
+    $<$<BOOL:${ENABLE_PROPERTY_EDITOR_TRACING}>:ENABLE_PROPERTY_EDITOR_TRACING>
   SOURCES
     aligndistribute.cpp aligndistribute.h
     assetimageprovider.cpp assetimageprovider.h
@@ -430,6 +437,7 @@ extend_qtc_plugin(QmlDesigner
     propertyeditorcontextobject.cpp propertyeditorcontextobject.h
     propertyeditordynamicpropertiesproxymodel.cpp propertyeditordynamicpropertiesproxymodel.h
     propertyeditorqmlbackend.cpp propertyeditorqmlbackend.h
+    propertyeditortracing.cpp propertyeditortracing.h
     propertyeditortransaction.cpp propertyeditortransaction.h
     propertyeditorvalue.cpp propertyeditorvalue.h
     propertyeditorview.cpp propertyeditorview.h

src/plugins/qmldesigner/components/propertyeditor/aligndistribute.cpp

@@ -3,6 +3,8 @@
 
 #include "aligndistribute.h"
 
+#include "propertyeditortracing.h"
+
 #include <nodeabstractproperty.h>
 #include <qmldesignerplugin.h>
 #include <qmlmodelnodeproxy.h>
@@ -23,12 +25,18 @@ using namespace Utils;
 
 namespace QmlDesigner {
 
+static auto category = PropertyEditorTracing::category;
+
 AlignDistribute::AlignDistribute(QObject *parent)
     : QObject(parent)
-{}
+{
+    NanotraceHR::Tracer tracer{"align distribute constructor", category()};
+}
 
 bool AlignDistribute::multiSelection() const
 {
+    NanotraceHR::Tracer tracer{"align distribute multiSelection", category()};
+
     if (!m_qmlObjectNode.isValid())
         return false;
 
@@ -37,6 +45,8 @@ bool AlignDistribute::multiSelection() const
 
 bool AlignDistribute::selectionHasAnchors() const
 {
+    NanotraceHR::Tracer tracer{"align distribute selection has anchors", category()};
+
     if (!m_qmlObjectNode.isValid())
         return true;
 
@@ -51,6 +61,8 @@ bool AlignDistribute::selectionHasAnchors() const
 
 bool AlignDistribute::selectionExclusivlyItems() const
 {
+    NanotraceHR::Tracer tracer{"align distribute selection exclusivly items", category()};
+
     if (!m_qmlObjectNode.isValid())
         return false;
 
@@ -64,6 +76,8 @@ bool AlignDistribute::selectionExclusivlyItems() const
 
 bool AlignDistribute::selectionContainsRootItem() const
 {
+    NanotraceHR::Tracer tracer{"align distribute selection contains root item", category()};
+
     if (!m_qmlObjectNode.isValid())
         return true;
 
@@ -78,6 +92,8 @@ bool AlignDistribute::selectionContainsRootItem() const
 
 void AlignDistribute::setModelNodeBackend(const QVariant &modelNodeBackend)
 {
+    NanotraceHR::Tracer tracer{"align distribute set model node backend", category()};
+
     auto modelNodeBackendObject = modelNodeBackend.value<QObject *>();
     const auto backendObjectCasted = qobject_cast<const QmlModelNodeProxy *>(modelNodeBackendObject);
 
@@ -92,11 +108,15 @@ void AlignDistribute::setModelNodeBackend(const QVariant &modelNodeBackend)
 // function or associated MEMBER variable. The property will be invalid.
 QVariant AlignDistribute::modelNodeBackend() const
 {
+    NanotraceHR::Tracer tracer{"align distribute model node backend", category()};
+
     return {};
 }
 
 void AlignDistribute::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"align distribute register declarative type", category()};
+
     qmlRegisterType<AlignDistribute>("HelperWidgets", 2, 0, "AlignDistribute");
 }
 
@@ -256,7 +276,9 @@ inline static qreal getInstanceSceneY(const QmlItemNode &qmlItemNode)
 
 void AlignDistribute::alignObjects(Target target, AlignTo alignTo, const QString &keyObject)
 {
-    QTC_ASSERT(m_qmlObjectNode.isValid(), return );
+    NanotraceHR::Tracer tracer{"align distribute align objects", category()};
+
+    QTC_ASSERT(m_qmlObjectNode.isValid(), return);
 
     const auto selectionContext = SelectionContext(m_qmlObjectNode.view());
     if (selectionContext.selectedModelNodes().empty())
@@ -347,6 +369,8 @@ void AlignDistribute::alignObjects(Target target, AlignTo alignTo, const QString
 
 void AlignDistribute::distributeObjects(Target target, AlignTo alignTo, const QString &keyObject)
 {
+    NanotraceHR::Tracer tracer{"align distribute distribute objects", category()};
+
     QTC_ASSERT(m_qmlObjectNode.isValid(), return );
 
     const auto selectionContext = SelectionContext(m_qmlObjectNode.view());
@@ -508,6 +532,8 @@ void AlignDistribute::distributeSpacing(Dimension dimension,
                                         const qreal &distance,
                                         DistributeOrigin distributeOrigin)
 {
+    NanotraceHR::Tracer tracer{"align distribute distribute spacing", category()};
+
     QTC_ASSERT(m_qmlObjectNode.isValid(), return );
 
     const auto selectionContext = SelectionContext(m_qmlObjectNode.view());
@@ -637,6 +663,8 @@ void AlignDistribute::distributeSpacing(Dimension dimension,
 
 AlignDistribute::CompareFunction AlignDistribute::getCompareFunction(Target target) const
 {
+    NanotraceHR::Tracer tracer{"align distribute get compare function", category()};
+
     static const std::map<Target, CompareFunction> cmpMap = {{Target::Left, compareByLeft},
                                                              {Target::CenterH, compareByCenterH},
                                                              {Target::Right, compareByRight},
@@ -648,6 +676,8 @@ AlignDistribute::CompareFunction AlignDistribute::getCompareFunction(Target targ
 
 AlignDistribute::Dimension AlignDistribute::getDimension(Target target) const
 {
+    NanotraceHR::Tracer tracer{"align distribute get dimension", category()};
+
     switch (target) {
     case Target::Left:
     case Target::CenterH:
@@ -665,6 +695,8 @@ AlignDistribute::Dimension AlignDistribute::getDimension(Target target) const
 
 bool AlignDistribute::executePixelPerfectDialog() const
 {
+    NanotraceHR::Tracer tracer{"align distribute execute pixel perfect dialog", category()};
+
     Utils::CheckableDecider decider(Key("WarnAboutPixelPerfectDistribution"));
 
     QMessageBox::StandardButton pressed = Utils::CheckableMessageBox::question(

src/plugins/qmldesigner/components/propertyeditor/assetimageprovider.cpp

@@ -3,6 +3,8 @@
 
 #include "assetimageprovider.h"
 
+#include "propertyeditortracing.h"
+
 #include <asset.h>
 #include <imagecache/imagecacheimageresponse.h>
 
@@ -18,6 +20,9 @@ namespace QmlDesigner {
 QQuickImageResponse *AssetImageProvider::requestImageResponse(const QString &id,
                                                               const QSize &requestedSize)
 {
+    NanotraceHR::Tracer tracer{"asset image provider request image response",
+                               PropertyEditorTracing::category()};
+
     if (id.endsWith(".mesh"))
         return m_imageCacheProvider.requestImageResponse(id, {});
 

src/plugins/qmldesigner/components/propertyeditor/colorpalettebackend.cpp

@@ -3,6 +3,8 @@
 
 #include "colorpalettebackend.h"
 
+#include "propertyeditortracing.h"
+
 #include <coreplugin/icore.h>
 
 #include <QApplication>
@@ -21,6 +23,8 @@ namespace QmlDesigner {
 
 QPointer<ColorPaletteBackend> ColorPaletteBackend::m_instance = nullptr;
 
+static auto category = PropertyEditorTracing::category;
+
 ColorPaletteBackend::ColorPaletteBackend()
     : m_currentPalette()
     , m_data()
@@ -29,6 +33,8 @@ ColorPaletteBackend::ColorPaletteBackend()
     , updateTimer(0)
 #endif
 {
+    NanotraceHR::Tracer tracer{"color palette backend constructor", category()};
+
     m_data.insert(g_recent, Palette(QmlDesigner::DesignerSettingsKey::COLOR_PALETTE_RECENT));
     m_data.insert(g_favorite, Palette(QmlDesigner::DesignerSettingsKey::COLOR_PALETTE_FAVORITE));
 
@@ -47,6 +53,8 @@ ColorPaletteBackend::ColorPaletteBackend()
 
 ColorPaletteBackend::~ColorPaletteBackend()
 {
+    NanotraceHR::Tracer tracer{"color palette backend destructor", category()};
+
     //writePalettes(); // TODO crash on QtDS close
     if (m_eyeDropperActive)
         eyeDropperLeave(QCursor::pos(), EyeDropperEventFilter::LeaveReason::Default);
@@ -54,19 +62,26 @@ ColorPaletteBackend::~ColorPaletteBackend()
 
 void ColorPaletteBackend::readPalettes()
 {
+    NanotraceHR::Tracer tracer{"color palette backend read palettes", category()};
+
     for (auto &palette : m_data)
         palette.read();
 }
 
 void ColorPaletteBackend::writePalettes()
 {
+    NanotraceHR::Tracer tracer{"color palette backend write palettes", category()};
+
     for (auto &palette : m_data)
         palette.write();
 }
 
 void ColorPaletteBackend::addColor(const QString &color, const QString &paletteName)
 {
+    NanotraceHR::Tracer tracer{"color palette backend add color", category()};
+
     auto found = m_data.find(paletteName);
+
     if (found == m_data.end()) {
         qWarning() << Q_FUNC_INFO << "Unknown palette: " << paletteName;
         return;
@@ -92,6 +107,8 @@ void ColorPaletteBackend::addColor(const QString &color, const QString &paletteN
 
 void ColorPaletteBackend::removeColor(int id, const QString &paletteName)
 {
+    NanotraceHR::Tracer tracer{"color palette backend remove color", category()};
+
     auto found = m_data.find(paletteName);
 
     if (found == m_data.end()) {
@@ -122,6 +139,8 @@ void ColorPaletteBackend::removeColor(int id, const QString &paletteName)
 
 void ColorPaletteBackend::addRecentColor(const QString &item)
 {
+    NanotraceHR::Tracer tracer{"color palette backend add recent color", category()};
+
     if (m_data[g_recent].m_colors.isEmpty()) {
         addColor(item, g_recent);
         return;
@@ -134,26 +153,36 @@ void ColorPaletteBackend::addRecentColor(const QString &item)
 
 void ColorPaletteBackend::addFavoriteColor(const QString &item)
 {
+    NanotraceHR::Tracer tracer{"color palette backend add favorite color", category()};
+
     addColor(item, g_favorite);
 }
 
 void ColorPaletteBackend::removeFavoriteColor(int id)
 {
+    NanotraceHR::Tracer tracer{"color palette backend  remove favorite color", category()};
+
     removeColor(id, g_favorite);
 }
 
 QStringList ColorPaletteBackend::palettes() const
 {
+    NanotraceHR::Tracer tracer{"color palette backend get palettes", category()};
+
     return m_data.keys();
 }
 
 const QString &ColorPaletteBackend::currentPalette() const
 {
+    NanotraceHR::Tracer tracer{"color palette backend get current palette", category()};
+
     return m_currentPalette;
 }
 
 void ColorPaletteBackend::setCurrentPalette(const QString &palette)
 {
+    NanotraceHR::Tracer tracer{"color palette backend set current palette", category()};
+
     if (!m_data.contains(palette)) {
         qWarning() << Q_FUNC_INFO << "Unknown palette: " << palette;
         return;
@@ -186,11 +215,15 @@ void ColorPaletteBackend::setCurrentPalette(const QString &palette)
 
 const QStringList &ColorPaletteBackend::currentPaletteColors() const
 {
+    NanotraceHR::Tracer tracer{"color palette backend get current palette colors", category()};
+
     return m_currentPaletteColors;
 }
 
 void ColorPaletteBackend::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"color palette backend register declarative type", category()};
+
     [[maybe_unused]] static const int typeIndex = qmlRegisterSingletonType<ColorPaletteBackend>(
         "QtQuickDesignerColorPalette", 1, 0, "ColorPaletteBackend", [](QQmlEngine *, QJSEngine *) {
             return new ColorPaletteBackend();
@@ -199,6 +232,8 @@ void ColorPaletteBackend::registerDeclarativeType()
 
 void ColorPaletteBackend::showDialog(QColor color)
 {
+    NanotraceHR::Tracer tracer{"color palette backend show dialog", category()};
+
     auto colorDialog = new QColorDialog(Core::ICore::dialogParent());
     colorDialog->setCurrentColor(color);
     colorDialog->setAttribute(Qt::WA_DeleteOnClose);
@@ -213,11 +248,15 @@ void ColorPaletteBackend::showDialog(QColor color)
 
 void ColorPaletteBackend::invokeEyeDropper()
 {
+    NanotraceHR::Tracer tracer{"color palette backend invoke eye dropper", category()};
+
     eyeDropperEnter();
 }
 
 void ColorPaletteBackend::eyeDropperEnter()
 {
+    NanotraceHR::Tracer tracer{"color palette backend eye dropper enter", category()};
+
     if (m_eyeDropperActive)
         return;
 
@@ -278,6 +317,8 @@ void ColorPaletteBackend::eyeDropperEnter()
 void ColorPaletteBackend::eyeDropperLeave(const QPoint &pos,
                                           EyeDropperEventFilter::LeaveReason actionOnLeave)
 {
+    NanotraceHR::Tracer tracer{"color palette backend eye dropper leave", category()};
+
     if (!m_eyeDropperActive)
         return;
 
@@ -306,6 +347,8 @@ void ColorPaletteBackend::eyeDropperLeave(const QPoint &pos,
 
 void ColorPaletteBackend::eyeDropperPointerMoved(const QPoint &pos)
 {
+    NanotraceHR::Tracer tracer{"color palette backend eye dropper pointer moved", category()};
+
     m_eyeDropperCurrentColor = grabScreenColor(pos);
     updateEyeDropperPosition(pos);
 }
@@ -318,11 +361,15 @@ const QSize g_halfPreviewSize = g_previewSize / 2;
 
 QColor ColorPaletteBackend::grabScreenColor(const QPoint &p)
 {
+    NanotraceHR::Tracer tracer{"color palette backend grab screen color", category()};
+
     return grabScreenRect(QRect(p, QSize(1, 1))).pixel(0, 0);
 }
 
 QImage ColorPaletteBackend::grabScreenRect(const QRect &r)
 {
+    NanotraceHR::Tracer tracer{"color palette backend grab screen rect", category()};
+
     QScreen *screen = QGuiApplication::screenAt(r.topLeft());
     if (!screen)
         screen = QGuiApplication::primaryScreen();
@@ -339,6 +386,8 @@ QImage ColorPaletteBackend::grabScreenRect(const QRect &r)
 
 void ColorPaletteBackend::updateEyeDropper()
 {
+    NanotraceHR::Tracer tracer{"color palette backend update eye dropper", category()};
+
 #ifndef QT_NO_CURSOR
     static QPoint lastGlobalPos;
     const QPoint newGlobalPos = QCursor::pos();
@@ -356,6 +405,8 @@ void ColorPaletteBackend::updateEyeDropper()
 
 void ColorPaletteBackend::updateEyeDropperPosition(const QPoint &globalPos)
 {
+    NanotraceHR::Tracer tracer{"color palette backend update eye dropper position", category()};
+
 #if QT_CONFIG(cursor)
     QPoint topLeft = globalPos - QPoint(g_halfCursorSize.width(), g_halfCursorSize.height());
     updateCursor(grabScreenRect(QRect(topLeft, g_cursorSize)));
@@ -364,6 +415,8 @@ void ColorPaletteBackend::updateEyeDropperPosition(const QPoint &globalPos)
 
 void ColorPaletteBackend::updateCursor(const QImage &image)
 {
+    NanotraceHR::Tracer tracer{"color palette backend update cursor", category()};
+
     QWindow *window = Core::ICore::mainWindow()->windowHandle();
     if (!window)
         return;
@@ -422,6 +475,7 @@ void ColorPaletteBackend::updateCursor(const QImage &image)
 
 bool ColorPaletteBackend::eyeDropperActive() const
 {
+    NanotraceHR::Tracer tracer{"color palette backend eye dropper active", category()};
     return m_eyeDropperActive;
 }
 

src/plugins/qmldesigner/components/propertyeditor/compatibleproperties.cpp

@@ -3,6 +3,8 @@
 
 #include "compatibleproperties.h"
 
+#include "propertyeditortracing.h"
+
 #include <bindingproperty.h>
 #include <qmlobjectnode.h>
 #include <qmltimelinekeyframegroup.h>
@@ -10,6 +12,8 @@
 
 namespace QmlDesigner {
 
+static auto category = PropertyEditorTracing::category;
+
 /*!
  * \internal
  * \brief Extracts and removes compatible properties from \param properties.
@@ -17,6 +21,8 @@ namespace QmlDesigner {
  */
 void CompatibleProperties::createCompatibilityMap(QList<PropertyName> &properties)
 {
+    NanotraceHR::Tracer tracer{"compatible properties compatibility map", category()};
+
     m_compatibilityMap.clear();
     if (m_oldInfo == m_newInfo || !m_oldInfo.isQtQuick3DMaterial() || !m_newInfo.isQtQuick3DMaterial())
         return;
@@ -63,6 +69,8 @@ void CompatibleProperties::createCompatibilityMap(QList<PropertyName> &propertie
 
 void CompatibleProperties::copyMappedProperties(const ModelNode &node)
 {
+    NanotraceHR::Tracer tracer{"compatible properties copy mapped properties", category()};
+
     if (m_compatibilityMap.isEmpty())
         return;
     // Copy mapped properties to new name. Note that this will only copy the base
@@ -95,6 +103,8 @@ void CompatibleProperties::copyMappedProperties(const ModelNode &node)
 
 void CompatibleProperties::applyCompatibleProperties(const ModelNode &node)
 {
+    NanotraceHR::Tracer tracer{"compatible properties apply compatible properties", category()};
+
     for (const auto &pair : m_compatibilityMap.asKeyValueRange()) {
         const CopyData &copyData = pair.second;
         if (copyData.isBinding) {

src/plugins/qmldesigner/components/propertyeditor/designerpropertymap.cpp

@@ -3,14 +3,21 @@
 
 #include "designerpropertymap.h"
 
+#include "propertyeditortracing.h"
+
 namespace QmlDesigner {
 
+static auto category = PropertyEditorTracing::category;
+
 DesignerPropertyMap::DesignerPropertyMap(QObject *parent) : QQmlPropertyMap(parent)
 {
+    NanotraceHR::Tracer tracer{"designer property map", category()};
 }
 
 QVariant DesignerPropertyMap::value(const QString &key) const
 {
+    NanotraceHR::Tracer tracer{"designer property map value", QmlDesigner::category()};
+
     if (contains(key))
         return QQmlPropertyMap::value(key);
     return QVariant();
@@ -18,7 +25,10 @@ QVariant DesignerPropertyMap::value(const QString &key) const
 
 void DesignerPropertyMap::registerDeclarativeType(const QString &name)
 {
-    qmlRegisterType<DesignerPropertyMap>("Bauhaus",1,0,name.toUtf8());
+    NanotraceHR::Tracer tracer{"designer property map register declarative type",
+                               QmlDesigner::category()};
+
+    qmlRegisterType<DesignerPropertyMap>("Bauhaus", 1, 0, name.toUtf8());
 }
 
 } //QmlDesigner

src/plugins/qmldesigner/components/propertyeditor/dynamicpropertiesproxymodel.cpp

@@ -26,9 +26,10 @@
 #include "dynamicpropertiesproxymodel.h"
 
 #include "bindingproperty.h"
+#include "propertyeditortracing.h"
 #include "propertyeditorvalue.h"
-#include <scripteditorutils.h>
 
+#include <scripteditorutils.h>
 #include <dynamicpropertiesmodel.h>
 
 #include <abstractproperty.h>
@@ -45,6 +46,8 @@
 
 namespace QmlDesigner {
 
+static auto category = PropertyEditorTracing::category;
+
 static const int propertyNameRole = Qt::UserRole + 1;
 static const int propertyTypeRole = Qt::UserRole + 2;
 static const int propertyValueRole = Qt::UserRole + 3;
@@ -53,10 +56,13 @@ static const int propertyBindingRole = Qt::UserRole + 4;
 DynamicPropertiesProxyModel::DynamicPropertiesProxyModel(QObject *parent)
     : QAbstractListModel(parent)
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model constructor", category()};
 }
 
 void DynamicPropertiesProxyModel::initModel(DynamicPropertiesModel *model)
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model init model", category()};
+
     m_model = model;
 
     connect(m_model, &QAbstractItemModel::modelAboutToBeReset,
@@ -84,11 +90,15 @@ void DynamicPropertiesProxyModel::initModel(DynamicPropertiesModel *model)
 
 int DynamicPropertiesProxyModel::rowCount(const QModelIndex &) const
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model row count", category()};
+
     return m_model ? m_model->rowCount() : 0;
 }
 
 QHash<int, QByteArray> DynamicPropertiesProxyModel::roleNames() const
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model role names", category()};
+
     static QHash<int, QByteArray> roleNames{{propertyNameRole, "propertyName"},
                                             {propertyTypeRole, "propertyType"},
                                             {propertyValueRole, "propertyValue"},
@@ -99,6 +109,8 @@ QHash<int, QByteArray> DynamicPropertiesProxyModel::roleNames() const
 
 QVariant DynamicPropertiesProxyModel::data(const QModelIndex &index, int role) const
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model data", category()};
+
     if (index.isValid() && index.row() < rowCount()) {
         AbstractProperty property = m_model->propertyForRow(index.row());
 
@@ -132,6 +144,8 @@ QVariant DynamicPropertiesProxyModel::data(const QModelIndex &index, int role) c
 
 void DynamicPropertiesProxyModel::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model register declarative type", category()};
+
     static bool registered = false;
     if (!registered)
         qmlRegisterType<DynamicPropertiesProxyModel>("HelperWidgets", 2, 0, "DynamicPropertiesModel");
@@ -139,11 +153,14 @@ void DynamicPropertiesProxyModel::registerDeclarativeType()
 
 DynamicPropertiesModel *DynamicPropertiesProxyModel::dynamicPropertiesModel() const
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model dynamic properties model", category()};
     return m_model;
 }
 
 QString DynamicPropertiesProxyModel::newPropertyName() const
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model new property name", category()};
+
     DynamicPropertiesModel *propsModel = dynamicPropertiesModel();
 
     return QString::fromUtf8(uniquePropertyName("newName", propsModel->singleSelectedNode()));
@@ -151,6 +168,8 @@ QString DynamicPropertiesProxyModel::newPropertyName() const
 
 void DynamicPropertiesProxyModel::createProperty(const QString &name, const QString &type)
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model create property", category()};
+
     QmlDesignerPlugin::emitUsageStatistics(Constants::EVENT_PROPERTY_ADDED);
 
     TypeName typeName = type.toUtf8();
@@ -191,6 +210,8 @@ void DynamicPropertiesProxyModel::createProperty(const QString &name, const QStr
 
 DynamicPropertyRow::DynamicPropertyRow()
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model constructor", category()};
+
     m_backendValue = new PropertyEditorValue(this);
 
     QObject::connect(m_backendValue,
@@ -211,16 +232,22 @@ DynamicPropertyRow::DynamicPropertyRow()
 
 DynamicPropertyRow::~DynamicPropertyRow()
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model destructor", category()};
+
     clearProxyBackendValues();
 }
 
 void DynamicPropertyRow::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model register declarative type", category()};
+
     qmlRegisterType<DynamicPropertyRow>("HelperWidgets", 2, 0, "DynamicPropertyRow");
 }
 
 void DynamicPropertyRow::setRow(int r)
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model set row", category()};
+
     if (m_row == r)
         return;
 
@@ -231,11 +258,15 @@ void DynamicPropertyRow::setRow(int r)
 
 int DynamicPropertyRow::row() const
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model get row", category()};
+
     return m_row;
 }
 
 void DynamicPropertyRow::setModel(DynamicPropertiesProxyModel *model)
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model set model", category()};
+
     if (model == m_model)
         return;
 
@@ -259,21 +290,30 @@ void DynamicPropertyRow::setModel(DynamicPropertiesProxyModel *model)
 
 DynamicPropertiesProxyModel *DynamicPropertyRow::model() const
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model get model", category()};
+
     return m_model;
 }
 
 PropertyEditorValue *DynamicPropertyRow::backendValue() const
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model get backend value", category()};
+
     return m_backendValue;
 }
 
 void DynamicPropertyRow::remove()
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model remove", category()};
+
     m_model->dynamicPropertiesModel()->remove(m_row);
 }
 
 PropertyEditorValue *DynamicPropertyRow::createProxyBackendValue()
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model create proxy backend value",
+                               category()};
+
     auto *newValue = new PropertyEditorValue(this);
     m_proxyBackendValues.append(newValue);
 
@@ -284,12 +324,17 @@ PropertyEditorValue *DynamicPropertyRow::createProxyBackendValue()
 
 void DynamicPropertyRow::clearProxyBackendValues()
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model clear proxy backend values",
+                               category()};
+
     qDeleteAll(m_proxyBackendValues);
     m_proxyBackendValues.clear();
 }
 
 void DynamicPropertyRow::setupBackendValue()
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model setup backend value", category()};
+
     if (!m_model)
         return;
 
@@ -333,6 +378,8 @@ void DynamicPropertyRow::setupBackendValue()
 
 void DynamicPropertyRow::commitValue(const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model commit value", category()};
+
     if (m_lock)
         return;
 
@@ -381,6 +428,8 @@ void DynamicPropertyRow::commitValue(const QVariant &value)
 
 void DynamicPropertyRow::commitExpression(const QString &expression)
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model commit expression", category()};
+
     if (m_lock || m_row < 0)
         return;
 
@@ -428,6 +477,8 @@ void DynamicPropertyRow::commitExpression(const QString &expression)
 
 void DynamicPropertyRow::handleDataChanged(const QModelIndex &topLeft, const QModelIndex &, const QList<int> &)
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model handle data changed", category()};
+
     if (m_model->dynamicPropertiesModel()->isCallbackToModelBlocked())
         return;
 
@@ -437,6 +488,8 @@ void DynamicPropertyRow::handleDataChanged(const QModelIndex &topLeft, const QMo
 
 void DynamicPropertyRow::resetValue()
 {
+    NanotraceHR::Tracer tracer{"dynamic properties proxy model reset value", category()};
+
     if (m_lock || m_row < 0)
         return;
 

src/plugins/qmldesigner/components/propertyeditor/fileresourcesmodel.cpp

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "fileresourcesmodel.h"
+#include "propertyeditortracing.h"
 
 #include <coreplugin/icore.h>
 
@@ -19,10 +20,14 @@
 
 static QString s_lastBrowserPath;
 
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 FileResourcesModel::FileResourcesModel(QObject *parent)
     : QObject(parent)
     , m_filter(QLatin1String("(*.*)"))
 {
+    NanotraceHR::Tracer tracer{"file resources model consstructor", category()};
+
     ProjectExplorer::Project *project = ProjectExplorer::ProjectManager::projectForFile(
         QmlDesigner::DocumentManager::currentFilePath());
 
@@ -36,6 +41,8 @@ FileResourcesModel::FileResourcesModel(QObject *parent)
 
 void FileResourcesModel::setModelNodeBackend(const QVariant &modelNodeBackend)
 {
+    NanotraceHR::Tracer tracer{"file resources model set model node backend", category()};
+
     auto modelNodeBackendObject = modelNodeBackend.value<QObject *>();
 
     const auto backendObjectCasted = qobject_cast<const QmlDesigner::QmlModelNodeProxy *>(
@@ -57,11 +64,15 @@ void FileResourcesModel::setModelNodeBackend(const QVariant &modelNodeBackend)
 
 QString FileResourcesModel::fileName() const
 {
+    NanotraceHR::Tracer tracer{"file resources model file name", category()};
+
     return m_fileName.toString();
 }
 
 void FileResourcesModel::setFileNameStr(const QString &fileName)
 {
+    NanotraceHR::Tracer tracer{"file resources model set file name", category()};
+
     setFileName(QUrl(fileName));
 }
 
@@ -77,6 +88,8 @@ void FileResourcesModel::setFileName(const QUrl &fileName)
 
 void FileResourcesModel::setPath(const QUrl &url)
 {
+    NanotraceHR::Tracer tracer{"file resources model set path", category()};
+
     m_path = url;
     refreshModel();
 
@@ -85,16 +98,22 @@ void FileResourcesModel::setPath(const QUrl &url)
 
 QUrl FileResourcesModel::path() const
 {
+    NanotraceHR::Tracer tracer{"file resources model path", category()};
+
     return m_path;
 }
 
 QUrl FileResourcesModel::docPath() const
 {
+    NanotraceHR::Tracer tracer{"file resources model doc path", category()};
+
     return QUrl::fromLocalFile(m_docPath.path());
 }
 
 void FileResourcesModel::setFilter(const QString &filter)
 {
+    NanotraceHR::Tracer tracer{"file resources model set filter", category()};
+
     if (m_filter == filter)
         return;
 
@@ -106,16 +125,22 @@ void FileResourcesModel::setFilter(const QString &filter)
 
 QString FileResourcesModel::filter() const
 {
+    NanotraceHR::Tracer tracer{"file resources model filter", category()};
+
     return m_filter;
 }
 
 QList<FileResourcesItem> FileResourcesModel::model() const
 {
+    NanotraceHR::Tracer tracer{"file resources model model", category()};
+
     return m_model;
 }
 
 void FileResourcesModel::openFileDialog(const QString &customPath)
 {
+    NanotraceHR::Tracer tracer{"file resources model open file dialog", category()};
+
     QString resourcePath = customPath.isEmpty() ? m_path.toLocalFile() : customPath;
     bool resourcePathChanged = m_lastResourcePath != resourcePath;
     m_lastResourcePath = resourcePath;
@@ -149,6 +174,8 @@ void FileResourcesModel::openFileDialog(const QString &customPath)
 
 QString FileResourcesModel::resolve(const QString &relative) const
 {
+    NanotraceHR::Tracer tracer{"file resources model resolve", category()};
+
     if (relative.startsWith('#'))
         return relative;
 
@@ -170,20 +197,26 @@ QString FileResourcesModel::resolve(const QString &relative) const
 
 bool FileResourcesModel::isLocal(const QString &path) const
 {
+    NanotraceHR::Tracer tracer{"file resources model is local", category()};
+
     return QUrl::fromUserInput(path, m_docPath.path()).isLocalFile();
 }
 
 void FileResourcesModel::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"file resources model register declarative type", category()};
+
     qmlRegisterType<FileResourcesModel>("HelperWidgets", 2, 0, "FileResourcesModel");
 }
 
 QVariant FileResourcesModel::modelNodeBackend() const
 {
+    NanotraceHR::Tracer tracer{"file resources model model node backend", category()};
+
     return QVariant();
 }
 
-bool filterMetaIcons(const QString &fileName)
+static bool filterMetaIcons(const QString &fileName)
 {
     QFileInfo info(fileName);
 
@@ -210,6 +243,8 @@ bool filterMetaIcons(const QString &fileName)
 
 void FileResourcesModel::refreshModel()
 {
+    NanotraceHR::Tracer tracer{"file resources model refresh model", category()};
+
     m_model.clear();
 
     if (m_path.isValid()) {

src/plugins/qmldesigner/components/propertyeditor/fontresourcesmodel.cpp

@@ -3,6 +3,7 @@
 
 #include "fontresourcesmodel.h"
 #include "fileresourcesmodel.h"
+#include "propertyeditortracing.h"
 
 #include <cmakeprojectmanager/cmakekitaspect.h>
 #include <designermcumanager.h>
@@ -32,6 +33,8 @@ using namespace Qt::Literals::StringLiterals;
 
 namespace {
 
+auto category = QmlDesigner::PropertyEditorTracing::category;
+
 QStringList makeFontFilesFilterList()
 {
     QStringList filterList;
@@ -100,11 +103,15 @@ QSet<QString> systemFonts()
 
 void FontResourcesModel::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"font resources model register declarative type", category()};
+
     qmlRegisterType<FontResourcesModel>("HelperWidgets", 2, 0, "FontResourcesModel");
 }
 
 QVariant FontResourcesModel::modelNodeBackend()
 {
+    NanotraceHR::Tracer tracer{"font resources model model node backend", category()};
+
     return {};
 }
 
@@ -112,16 +119,22 @@ FontResourcesModel::FontResourcesModel(QObject *parent)
     : QObject{parent}
     , m_resourceModel{std::make_unique<FileResourcesModel>()}
 {
+    NanotraceHR::Tracer tracer{"font resources model constructor", category()};
+
     m_resourceModel->setFilter(fontFilesFilterList().join(' '));
 }
 
 void FontResourcesModel::setModelNodeBackend(const QVariant &modelNodeBackend)
 {
+    NanotraceHR::Tracer tracer{"file resources model set model node backend", category()};
+
     m_resourceModel->setModelNodeBackend(modelNodeBackend);
 }
 
 QStringList FontResourcesModel::model() const
 {
+    NanotraceHR::Tracer tracer{"file resources model model", category()};
+
     QSet<QString> fonts;
     for (const auto &item : m_resourceModel->model()) {
         fonts.insert(fontFamily(item.absoluteFilePath()));
@@ -137,20 +150,28 @@ QStringList FontResourcesModel::model() const
 
 void FontResourcesModel::refreshModel()
 {
+    NanotraceHR::Tracer tracer{"file resources model refresh model", category()};
+
     m_resourceModel->refreshModel();
 }
 
 void FontResourcesModel::openFileDialog(const QString &customPath)
 {
+    NanotraceHR::Tracer tracer{"file resources model open file dialog", category()};
+
     m_resourceModel->openFileDialog(customPath);
 }
 
 QString FontResourcesModel::resolve(const QString &relative) const
 {
+    NanotraceHR::Tracer tracer{"file resources model resolve", category()};
+
     return m_resourceModel->resolve(relative);
 }
 
 bool FontResourcesModel::isLocal(const QString &path) const
 {
+    NanotraceHR::Tracer tracer{"file resources model is local", category()};
+
     return m_resourceModel->isLocal(path);
 }

src/plugins/qmldesigner/components/propertyeditor/fontresourcesmodel.h

@@ -30,8 +30,8 @@ public:
     void refreshModel();
 
     Q_INVOKABLE void openFileDialog(const QString &customPath = {});
-    Q_INVOKABLE [[nodiscard]] QString resolve(const QString &relative) const;
+    [[nodiscard]] Q_INVOKABLE QString resolve(const QString &relative) const;
-    Q_INVOKABLE [[nodiscard]] bool isLocal(const QString &path) const;
+    [[nodiscard]] Q_INVOKABLE bool isLocal(const QString &path) const;
 
 signals:
     void fileNameChanged(const QUrl &fileName);

src/plugins/qmldesigner/components/propertyeditor/gradientmodel.cpp

@@ -5,6 +5,7 @@
 
 #include "gradientpresetcustomlistmodel.h"
 #include "gradientpresetitem.h"
+#include "propertyeditortracing.h"
 #include "propertyeditorview.h"
 #include "qmlanchorbindingproxy.h"
 
@@ -22,6 +23,9 @@
 #include <QTimer>
 
 namespace {
+
+auto category = QmlDesigner::PropertyEditorTracing::category;
+
 constexpr auto widthBinding = [](const QStringView nodeName) -> QString {
     return QString("%1.width").arg(nodeName);
 };
@@ -257,10 +261,13 @@ void prepareGradient(const T &array,
 GradientModel::GradientModel(QObject *parent) :
     QAbstractListModel(parent)
 {
+    NanotraceHR::Tracer tracer{"gradient model constructor", category()};
 }
 
 int GradientModel::rowCount(const QModelIndex & /*parent*/) const
 {
+    NanotraceHR::Tracer tracer{"gradient model row count", category()};
+
     if (m_itemNode.modelNode().hasNodeProperty(gradientPropertyName().toUtf8())) {
         QmlDesigner::ModelNode gradientNode = m_itemNode.modelNode()
                                                   .nodeProperty(gradientPropertyName().toUtf8())
@@ -275,20 +282,21 @@ int GradientModel::rowCount(const QModelIndex & /*parent*/) const
 
 QHash<int, QByteArray> GradientModel::roleNames() const
 {
-    static QHash<int, QByteArray> roleNames{
+    NanotraceHR::Tracer tracer{"gradient model role names", category()};
-        {Qt::UserRole + 1, "position"},
+
+    static QHash<int, QByteArray> roleNames{{Qt::UserRole + 1, "position"},
                                             {Qt::UserRole + 2, "color"},
                                             {Qt::UserRole + 3, "readOnly"},
-        {Qt::UserRole + 4, "index"}
+                                            {Qt::UserRole + 4, "index"}};
-    };
 
     return roleNames;
 }
 
 QVariant GradientModel::data(const QModelIndex &index, int role) const
 {
-    if (index.isValid() && index.row() < rowCount()) {
+    NanotraceHR::Tracer tracer{"gradient model data", category()};
 
+    if (index.isValid() && index.row() < rowCount()) {
         if (role == Qt::UserRole + 3) {
             if (index.row() == 0 || index.row() == (rowCount() - 1))
                 return true;
@@ -312,6 +320,8 @@ QVariant GradientModel::data(const QModelIndex &index, int role) const
 
 int GradientModel::addStop(qreal position, const QColor &color)
 {
+    NanotraceHR::Tracer tracer{"gradient model add stop", category()};
+
     if (m_locked)
         return -1;
 
@@ -354,6 +364,8 @@ int GradientModel::addStop(qreal position, const QColor &color)
 
 void GradientModel::addGradient()
 {
+    NanotraceHR::Tracer tracer{"gradient model add gradient", category()};
+
     if (m_locked)
         return;
 
@@ -397,6 +409,8 @@ void GradientModel::addGradient()
 
 void GradientModel::setColor(int index, const QColor &color)
 {
+    NanotraceHR::Tracer tracer{"gradient model set color", category()};
+
     if (locked())
         return;
 
@@ -417,6 +431,8 @@ void GradientModel::setColor(int index, const QColor &color)
 
 void GradientModel::setPosition(int index, qreal positition)
 {
+    NanotraceHR::Tracer tracer{"gradient model set position", category()};
+
     if (locked())
         return;
 
@@ -431,6 +447,8 @@ void GradientModel::setPosition(int index, qreal positition)
 
 QColor GradientModel::getColor(int index) const
 {
+    NanotraceHR::Tracer tracer{"gradient model get color", category()};
+
     if (index < rowCount()) {
         QmlDesigner::ModelNode gradientNode =  m_itemNode.modelNode().nodeProperty(gradientPropertyName().toUtf8()).modelNode();
         QmlDesigner::QmlObjectNode stop = gradientNode.nodeListProperty("stops").at(index);
@@ -443,6 +461,8 @@ QColor GradientModel::getColor(int index) const
 
 qreal GradientModel::getPosition(int index) const
 {
+    NanotraceHR::Tracer tracer{"gradient model get position", category()};
+
     if (index < rowCount()) {
         QmlDesigner::ModelNode gradientNode =  m_itemNode.modelNode().nodeProperty(gradientPropertyName().toUtf8()).modelNode();
         QmlDesigner::QmlObjectNode stop = gradientNode.nodeListProperty("stops").at(index);
@@ -455,6 +475,8 @@ qreal GradientModel::getPosition(int index) const
 
 void GradientModel::removeStop(int index)
 {
+    NanotraceHR::Tracer tracer{"gradient model remove stop", category()};
+
     if (index < rowCount() - 1 && index != 0) {
         view()->executeInTransaction("GradientModel::removeStop", [this, index](){
             QmlDesigner::ModelNode gradientNode =  m_itemNode.modelNode().nodeProperty(gradientPropertyName().toUtf8()).modelNode();
@@ -476,6 +498,8 @@ void GradientModel::removeStop(int index)
 
 void GradientModel::deleteGradient()
 {
+    NanotraceHR::Tracer tracer{"gradient model delete gradient", category()};
+
     if (!m_itemNode.isValid())
         return;
 
@@ -490,21 +514,29 @@ void GradientModel::deleteGradient()
 
 void GradientModel::lock()
 {
+    NanotraceHR::Tracer tracer{"gradient model lock", category()};
+
     m_locked = true;
 }
 
 void GradientModel::unlock()
 {
+    NanotraceHR::Tracer tracer{"gradient model unlock", category()};
+
     m_locked = false;
 }
 
 void GradientModel::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"gradient model register declarative type", category()};
+
     qmlRegisterType<GradientModel>("HelperWidgets", 2, 0, "GradientModel");
 }
 
 qreal GradientModel::readGradientProperty(const QString &propertyName) const
 {
+    NanotraceHR::Tracer tracer{"gradient model read gradient property", category()};
+
     if (!m_itemNode.isValid())
         return 0;
 
@@ -520,11 +552,15 @@ qreal GradientModel::readGradientProperty(const QString &propertyName) const
 
 qreal GradientModel::readGradientPropertyPercentage(const QString &propertyName) const
 {
+    NanotraceHR::Tracer tracer{"gradient model read gradient property percentage", category()};
+
     return getPercentageGradientProperty(propertyName.toUtf8());
 }
 
 QString GradientModel::readGradientOrientation() const
 {
+    NanotraceHR::Tracer tracer{"gradient model read gradient orientation", category()};
+
     if (!m_itemNode.isValid())
         return QString();
 
@@ -541,6 +577,8 @@ QString GradientModel::readGradientOrientation() const
 GradientModel::GradientPropertyUnits GradientModel::readGradientPropertyUnits(
     const QString &propertyName) const
 {
+    NanotraceHR::Tracer tracer{"gradient model read gradient property units", category()};
+
     if (hasPercentageGradientProperty(propertyName))
         return GradientPropertyUnits::Percentage;
 
@@ -559,6 +597,8 @@ bool GradientModel::isPercentageSupportedByProperty(const QString &propertyName,
 
 void GradientModel::setupModel()
 {
+    NanotraceHR::Tracer tracer{"gradient model setup model", category()};
+
     m_locked = true;
     const QScopeGuard cleanup([&] { m_locked = false; });
 
@@ -568,7 +608,9 @@ void GradientModel::setupModel()
 
 void GradientModel::setAnchorBackend(const QVariant &anchorBackend)
 {
-    auto anchorBackendObject = anchorBackend.value<QObject*>();
+    NanotraceHR::Tracer tracer{"gradient model set anchor backend", category()};
+
+    auto anchorBackendObject = anchorBackend.value<QObject *>();
 
     const auto backendCasted =
             qobject_cast<const QmlDesigner::QmlAnchorBindingProxy *>(anchorBackendObject);
@@ -592,32 +634,44 @@ void GradientModel::setAnchorBackend(const QVariant &anchorBackend)
 
 QString GradientModel::gradientPropertyName() const
 {
+    NanotraceHR::Tracer tracer{"gradient model gradient property name", category()};
+
     return m_gradientPropertyName;
 }
 
 void GradientModel::setGradientPropertyName(const QString &name)
 {
+    NanotraceHR::Tracer tracer{"gradient model set gradient property name", category()};
+
     m_gradientPropertyName = name;
 }
 
 QString GradientModel::gradientTypeName() const
 {
+    NanotraceHR::Tracer tracer{"gradient model gradient type name", category()};
+
     return m_gradientTypeName;
 }
 
 void GradientModel::setGradientTypeName(const QString &name)
 {
+    NanotraceHR::Tracer tracer{"gradient model set gradient type name", category()};
+
     m_gradientTypeName = name;
 }
 
 bool GradientModel::hasGradient() const
 {
+    NanotraceHR::Tracer tracer{"gradient model has gradient", category()};
+
     return m_itemNode.isValid()
            && m_itemNode.modelNode().hasProperty(gradientPropertyName().toUtf8());
 }
 
 bool GradientModel::locked() const
 {
+    NanotraceHR::Tracer tracer{"gradient model locked", category()};
+
     if (m_locked)
         return true;
 
@@ -628,6 +682,8 @@ bool GradientModel::locked() const
 
 bool GradientModel::hasShapesImport() const
 {
+    NanotraceHR::Tracer tracer{"gradient model has shapes import", category()};
+
     if (m_itemNode.isValid()) {
         QmlDesigner::Import import = QmlDesigner::Import::createLibraryImport("QtQuick.Shapes", "1.0");
         return model()->hasImport(import, true, true);
@@ -638,6 +694,8 @@ bool GradientModel::hasShapesImport() const
 
 void GradientModel::ensureShapesImport()
 {
+    NanotraceHR::Tracer tracer{"gradient model ensure shapes import", category()};
+
     if (!hasShapesImport()) {
         QmlDesigner::Import timelineImport = QmlDesigner::Import::createLibraryImport("QtQuick.Shapes", "1.0");
         try {
@@ -650,6 +708,8 @@ void GradientModel::ensureShapesImport()
 
 void GradientModel::setupGradientProperties(const QmlDesigner::ModelNode &gradient)
 {
+    NanotraceHR::Tracer tracer{"gradient model setup gradient properties", category()};
+
     QTC_ASSERT(m_itemNode.isValid(), return);
 
     QTC_ASSERT(gradient.isValid(), return);
@@ -676,23 +736,31 @@ void GradientModel::setupGradientProperties(const QmlDesigner::ModelNode &gradie
 
 QmlDesigner::Model *GradientModel::model() const
 {
+    NanotraceHR::Tracer tracer{"gradient model model", category()};
+
     QTC_ASSERT(m_itemNode.isValid(), return nullptr);
     return m_itemNode.view()->model();
 }
 
 QmlDesigner::AbstractView *GradientModel::view() const
 {
+    NanotraceHR::Tracer tracer{"gradient model view", category()};
+
     QTC_ASSERT(m_itemNode.isValid(), return nullptr);
     return m_itemNode.view();
 }
 
 void GradientModel::resetPuppet()
 {
+    NanotraceHR::Tracer tracer{"gradient model reset puppet", category()};
+
     QTimer::singleShot(1000, view(), &QmlDesigner::AbstractView::resetPuppet);
 }
 
 QmlDesigner::ModelNode GradientModel::createGradientNode()
 {
+    NanotraceHR::Tracer tracer{"gradient model create gradient node", category()};
+
 #ifdef QDS_USE_PROJECTSTORAGE
     QmlDesigner::TypeName typeName = m_gradientTypeName.toUtf8();
     auto gradientNode = view()->createModelNode(typeName);
@@ -719,6 +787,8 @@ QmlDesigner::ModelNode GradientModel::createGradientNode()
 
 QmlDesigner::ModelNode GradientModel::createGradientStopNode()
 {
+    NanotraceHR::Tracer tracer{"gradient model create gradient stop node", category()};
+
 #ifdef QDS_USE_PROJECTSTORAGE
     return view()->createModelNode("GradientStop");
 #else
@@ -734,6 +804,8 @@ QmlDesigner::ModelNode GradientModel::createGradientStopNode()
 
 void GradientModel::deleteGradientNode(bool saveTransaction)
 {
+    NanotraceHR::Tracer tracer{"gradient model delete gradient node", category()};
+
     QmlDesigner::ModelNode modelNode = m_itemNode.modelNode();
 
     if (m_itemNode.isInBaseState()) {
@@ -754,6 +826,8 @@ void GradientModel::deleteGradientNode(bool saveTransaction)
 
 bool GradientModel::hasPercentageGradientProperty(const QString &propertyName) const
 {
+    NanotraceHR::Tracer tracer{"gradient model has percentage gradient property", category()};
+
     bool result = false;
     getPercentageGradientProperty(propertyName.toUtf8(), &result);
     return result;
@@ -762,6 +836,8 @@ bool GradientModel::hasPercentageGradientProperty(const QString &propertyName) c
 qreal GradientModel::getPercentageGradientProperty(const QmlDesigner::PropertyNameView propertyName,
                                                    bool *ok) const
 {
+    NanotraceHR::Tracer tracer{"gradient model get percentage gradient property", category()};
+
     if (ok != nullptr)
         *ok = false;
 
@@ -809,6 +885,8 @@ qreal GradientModel::getPercentageGradientProperty(const QmlDesigner::PropertyNa
 
 QVariant GradientModel::getGradientPropertyVariant(const QString &propertyName) const
 {
+    NanotraceHR::Tracer tracer{"gradient model get gradient property variant", category()};
+
     if (!m_itemNode.isValid())
         return {};
 
@@ -825,6 +903,8 @@ QVariant GradientModel::getGradientPropertyVariant(const QString &propertyName)
 ShapeGradientPropertyData GradientModel::getDefaultGradientPropertyData(
     const QmlDesigner::PropertyNameView propertyName, const QStringView &gradientType) const
 {
+    NanotraceHR::Tracer tracer{"gradient model get default gradient property data", category()};
+
     const auto *gradData = getDefaultGradientData(propertyName, gradientType);
     if (gradData != nullptr)
         return *gradData;
@@ -834,6 +914,8 @@ ShapeGradientPropertyData GradientModel::getDefaultGradientPropertyData(
 
 void GradientModel::setGradientProperty(const QString &propertyName, qreal value)
 {
+    NanotraceHR::Tracer tracer{"gradient model set gradient property", category()};
+
     QTC_ASSERT(m_itemNode.isValid(), return);
 
     QmlDesigner::QmlObjectNode gradient = m_itemNode.modelNode()
@@ -851,6 +933,8 @@ void GradientModel::setGradientProperty(const QString &propertyName, qreal value
 
 void GradientModel::setGradientPropertyPercentage(const QString &propertyName, qreal value)
 {
+    NanotraceHR::Tracer tracer{"gradient model set gradient property percentage", category()};
+
     QTC_ASSERT(m_itemNode.isValid(), return);
 
     QmlDesigner::QmlObjectNode gradient = m_itemNode.modelNode()
@@ -883,6 +967,8 @@ void GradientModel::setGradientPropertyPercentage(const QString &propertyName, q
 
 void GradientModel::setGradientOrientation(Qt::Orientation value)
 {
+    NanotraceHR::Tracer tracer{"gradient model set gradient orientation", category()};
+
     QTC_ASSERT(m_itemNode.isValid(), return);
 
     QmlDesigner::QmlObjectNode gradient = m_itemNode.modelNode()
@@ -903,6 +989,8 @@ void GradientModel::setGradientOrientation(Qt::Orientation value)
 void GradientModel::setGradientPropertyUnits(const QString &propertyName,
                                              GradientModel::GradientPropertyUnits value)
 {
+    NanotraceHR::Tracer tracer{"gradient model set gradient property units", category()};
+
     //translate from previous units to the new unit system
     const bool toPixels = (value == GradientPropertyUnits::Pixels);
     const bool toPercentage = (value == GradientPropertyUnits::Percentage);
@@ -952,6 +1040,8 @@ void GradientModel::setGradientPropertyUnits(const QString &propertyName,
 
 void GradientModel::setPresetByID(int presetID)
 {
+    NanotraceHR::Tracer tracer{"gradient model set preset by ID", category()};
+
     const QGradient gradient(GradientPresetItem::createGradientFromPreset(
         static_cast<GradientPresetItem::Preset>(presetID)));
     const QList<QGradientStop> gradientStops = gradient.stops().toList();
@@ -971,6 +1061,8 @@ void GradientModel::setPresetByStops(const QList<qreal> &stopsPositions,
                                      int stopsCount,
                                      bool saveTransaction)
 {
+    NanotraceHR::Tracer tracer{"gradient model set preset by stops", category()};
+
     if (m_locked)
         return;
 
@@ -1017,6 +1109,8 @@ void GradientModel::setPresetByStops(const QList<qreal> &stopsPositions,
 
 void GradientModel::savePreset()
 {
+    NanotraceHR::Tracer tracer{"gradient model save preset", category()};
+
     //preparing qgradient:
     QGradient currentGradient;
     QGradientStops currentStops;
@@ -1040,6 +1134,8 @@ void GradientModel::savePreset()
 
 void GradientModel::updateGradient()
 {
+    NanotraceHR::Tracer tracer{"gradient model update gradient", category()};
+
     beginResetModel();
 
     QList<qreal> stops;

src/plugins/qmldesigner/components/propertyeditor/gradientpresetcustomlistmodel.cpp

@@ -3,6 +3,7 @@
 
 #include "gradientpresetcustomlistmodel.h"
 #include "gradientpresetitem.h"
+#include "propertyeditortracing.h"
 
 #include <coreplugin/icore.h>
 #include <utils/qtcassert.h>
@@ -14,7 +15,9 @@
 #include <QSettings>
 #include <QFile>
 
-namespace Internal {
+namespace {
+
+auto category = QmlDesigner::PropertyEditorTracing::category;
 
 const char settingsKey[] = "GradientPresetCustomList";
 const char settingsFileName[] = "GradientPresets.ini";
@@ -27,45 +30,56 @@ QString settingsFullFilePath(const QSettings::Scope &scope)
     return Core::ICore::userResourcePath(settingsFileName).toUrlishString();
 }
 
-} // namespace Internal
+} // namespace
 
 GradientPresetCustomListModel::GradientPresetCustomListModel(QObject *parent)
     : GradientPresetListModel(parent)
     , m_filename(getFilename())
 {
+    NanotraceHR::Tracer tracer{"gradient preset custom list model constructor", category()};
+
     readPresets();
 }
 
-GradientPresetCustomListModel::~GradientPresetCustomListModel() {}
+GradientPresetCustomListModel::~GradientPresetCustomListModel()
+{
+    NanotraceHR::Tracer tracer{"gradient preset custom list model destructor", category()};
+}
 
 void GradientPresetCustomListModel::registerDeclarativeType()
 {
-    qmlRegisterType<GradientPresetCustomListModel>("HelperWidgets",
+    NanotraceHR::Tracer tracer{"gradient preset custom list model register declarative type",
-                                                   2,
+                               category()};
-                                                   0,
+
-                                                   "GradientPresetCustomListModel");
+    qmlRegisterType<GradientPresetCustomListModel>("HelperWidgets", 2, 0, "GradientPresetCustomListModel");
 }
 
 QString GradientPresetCustomListModel::getFilename()
 {
-    return Internal::settingsFullFilePath(QSettings::UserScope);
+    NanotraceHR::Tracer tracer{"gradient preset custom list model get filename", category()};
+
+    return settingsFullFilePath(QSettings::UserScope);
 }
 
 void GradientPresetCustomListModel::storePresets(const QString &filename,
                                                  const QList<GradientPresetItem> &items)
 {
+    NanotraceHR::Tracer tracer{"gradient preset custom list model store presets", category()};
+
     const QList<QVariant> presets = Utils::transform<QList<QVariant>>(
         items, [](const GradientPresetItem &item) { return QVariant::fromValue(item); });
 
     QSettings settings(filename, QSettings::IniFormat);
     settings.clear();
-    settings.setValue(Internal::settingsKey, QVariant::fromValue(presets));
+    settings.setValue(settingsKey, QVariant::fromValue(presets));
 }
 
 QList<GradientPresetItem> GradientPresetCustomListModel::storedPresets(const QString &filename)
 {
+    NanotraceHR::Tracer tracer{"gradient preset custom list model stored presets", category()};
+
     const QSettings settings(filename, QSettings::IniFormat);
-    const QVariant presetSettings = settings.value(Internal::settingsKey);
+    const QVariant presetSettings = settings.value(settingsKey);
 
     if (!presetSettings.isValid())
         return {};
@@ -86,6 +100,8 @@ void GradientPresetCustomListModel::addGradient(const QList<qreal> &stopsPositio
                                                 const QList<QString> &stopsColors,
                                                 int stopsCount)
 {
+    NanotraceHR::Tracer tracer{"gradient preset custom list model add gradient", category()};
+
     QGradient tempGradient;
     QGradientStops gradientStops;
     QGradientStop gradientStop;
@@ -102,6 +118,8 @@ void GradientPresetCustomListModel::addGradient(const QList<qreal> &stopsPositio
 
 void GradientPresetCustomListModel::changePresetName(int id, const QString &newName)
 {
+    NanotraceHR::Tracer tracer{"gradient preset custom list model change preset name", category()};
+
     QTC_ASSERT(id >= 0, return);
     QTC_ASSERT(id < m_items.size(), return);
     m_items[id].setPresetName(newName);
@@ -110,6 +128,8 @@ void GradientPresetCustomListModel::changePresetName(int id, const QString &newN
 
 void GradientPresetCustomListModel::deletePreset(int id)
 {
+    NanotraceHR::Tracer tracer{"gradient preset custom list model delete preset", category()};
+
     QTC_ASSERT(id >= 0, return);
     QTC_ASSERT(id < m_items.size(), return);
     beginResetModel();
@@ -120,11 +140,15 @@ void GradientPresetCustomListModel::deletePreset(int id)
 
 void GradientPresetCustomListModel::writePresets()
 {
+    NanotraceHR::Tracer tracer{"gradient preset custom list model write presets", category()};
+
     storePresets(m_filename, m_items);
 }
 
 void GradientPresetCustomListModel::readPresets()
 {
+    NanotraceHR::Tracer tracer{"gradient preset custom list model read presets", category()};
+
     const QList<GradientPresetItem> presets = storedPresets(m_filename);
     beginResetModel();
     m_items.clear();

src/plugins/qmldesigner/components/propertyeditor/gradientpresetdefaultlistmodel.cpp

@@ -3,22 +3,33 @@
 
 #include "gradientpresetdefaultlistmodel.h"
 #include "gradientpresetitem.h"
+#include "propertyeditortracing.h"
 
 #include <QHash>
 #include <QByteArray>
 #include <QDebug>
 #include <QFile>
 
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 GradientPresetDefaultListModel::GradientPresetDefaultListModel(QObject *parent)
     : GradientPresetListModel(parent)
 {
+    NanotraceHR::Tracer tracer{"gradient preset default list model constructor", category()};
+
     addAllPresets();
 }
 
-GradientPresetDefaultListModel::~GradientPresetDefaultListModel() {}
+GradientPresetDefaultListModel::~GradientPresetDefaultListModel()
+{
+    NanotraceHR::Tracer tracer{"gradient preset default list model destructor", category()};
+}
 
 void GradientPresetDefaultListModel::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"gradient preset default list model register declarative type",
+                               category()};
+
     qmlRegisterType<GradientPresetDefaultListModel>("HelperWidgets",
                                                     2,
                                                     0,
@@ -27,6 +38,8 @@ void GradientPresetDefaultListModel::registerDeclarativeType()
 
 void GradientPresetDefaultListModel::addAllPresets()
 {
+    NanotraceHR::Tracer tracer{"gradient preset default list model add all presets", category()};
+
     const QMetaObject &metaObj = QGradient::staticMetaObject;
     const QMetaEnum metaEnum = metaObj.enumerator(metaObj.indexOfEnumerator("Preset"));
 

src/plugins/qmldesigner/components/propertyeditor/gradientpresetitem.cpp

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "gradientpresetitem.h"
+#include "propertyeditortracing.h"
 
 #include <utils/qtcassert.h>
 #include <utils/algorithm.h>
@@ -14,26 +15,36 @@
 
 #include <algorithm>
 
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 GradientPresetItem::GradientPresetItem()
     : m_gradientVal(QGradient())
     , m_gradientID(Preset(0))
     , m_presetName(QString())
-{}
+{
+    NanotraceHR::Tracer tracer{"gradient preset item default constructor", category()};
+}
 
 GradientPresetItem::GradientPresetItem(const QGradient &value, const QString &name)
     : m_gradientVal(value)
     , m_gradientID(Preset(0))
     , m_presetName(name)
-{}
+{
+    NanotraceHR::Tracer tracer{"gradient preset item constructor with gradient and name", category()};
+}
 
 GradientPresetItem::GradientPresetItem(const Preset value)
     : m_gradientVal(createGradientFromPreset(value))
     , m_gradientID(value)
     , m_presetName(getNameByPreset(value))
-{}
+{
+    NanotraceHR::Tracer tracer{"gradient preset item constructor with preset", category()};
+}
 
 QVariant GradientPresetItem::getProperty(GradientPresetItem::Property id) const
 {
+    NanotraceHR::Tracer tracer{"gradient preset item get property", category()};
+
     QVariant out;
 
     switch (id) {
@@ -65,11 +76,15 @@ QVariant GradientPresetItem::getProperty(GradientPresetItem::Property id) const
 
 QGradient GradientPresetItem::gradientVal() const
 {
+    NanotraceHR::Tracer tracer{"gradient preset item gradient value", category()};
+
     return m_gradientVal;
 }
 
 void GradientPresetItem::setGradient(const QGradient &value)
 {
+    NanotraceHR::Tracer tracer{"gradient preset item set gradient", category()};
+
     m_gradientVal = value;
     m_gradientID = Preset(0);
     m_presetName = QString();
@@ -77,6 +92,8 @@ void GradientPresetItem::setGradient(const QGradient &value)
 
 void GradientPresetItem::setGradient(const Preset value)
 {
+    NanotraceHR::Tracer tracer{"gradient preset item set gradient by preset", category()};
+
     m_gradientID = value;
     m_gradientVal = createGradientFromPreset(value);
     m_presetName = getNameByPreset(value);
@@ -84,6 +101,8 @@ void GradientPresetItem::setGradient(const Preset value)
 
 QList<qreal> GradientPresetItem::stopsPosList() const
 {
+    NanotraceHR::Tracer tracer{"gradient preset item stops position list", category()};
+
     const QList<QPair<qreal, QColor>> subres = m_gradientVal.stops().toList();
     const QList<qreal> result = Utils::transform<QList<qreal>>(subres,
                                                                [](const QPair<qreal, QColor> &item) {
@@ -94,6 +113,8 @@ QList<qreal> GradientPresetItem::stopsPosList() const
 
 QList<QString> GradientPresetItem::stopsColorList() const
 {
+    NanotraceHR::Tracer tracer{"gradient preset item stops color list", category()};
+
     const QList<QPair<qreal, QColor>> subres = m_gradientVal.stops().toList();
     const QList<QString> result
         = Utils::transform<QList<QString>>(subres, [](const QPair<qreal, QColor> &item) {
@@ -104,26 +125,36 @@ QList<QString> GradientPresetItem::stopsColorList() const
 
 int GradientPresetItem::stopListSize() const
 {
+    NanotraceHR::Tracer tracer{"gradient preset item stop list size", category()};
+
     return m_gradientVal.stops().size();
 }
 
 void GradientPresetItem::setPresetName(const QString &value)
 {
+    NanotraceHR::Tracer tracer{"gradient preset item set preset name", category()};
+
     m_presetName = value;
 }
 
 QString GradientPresetItem::presetName() const
 {
+    NanotraceHR::Tracer tracer{"gradient preset item preset name", category()};
+
     return m_presetName;
 }
 
 int GradientPresetItem::presetID() const
 {
+    NanotraceHR::Tracer tracer{"gradient preset item preset ID", category()};
+
     return static_cast<int>(m_gradientID);
 }
 
 QString GradientPresetItem::getNameByPreset(Preset value)
 {
+    NanotraceHR::Tracer tracer{"gradient preset item get name by preset", category()};
+
     const QMetaObject &metaObj = QGradient::staticMetaObject;
     const QMetaEnum metaEnum = metaObj.enumerator(metaObj.indexOfEnumerator("Preset"));
 
@@ -143,6 +174,8 @@ QString GradientPresetItem::getNameByPreset(Preset value)
 
 QGradient GradientPresetItem::createGradientFromPreset(Preset value)
 {
+    NanotraceHR::Tracer tracer{"gradient preset item create gradient from preset", category()};
+
     return QGradient(value);
 }
 
@@ -156,6 +189,7 @@ QDebug &operator<<(QDebug &stream, const GradientPresetItem &gradient)
 
 QDataStream &operator<<(QDataStream &stream, const GradientPresetItem &gradient)
 {
+    NanotraceHR::Tracer tracer{"gradient preset item operator <<", category()};
     stream << gradient.m_gradientVal.stops();
 
     stream << static_cast<int>(gradient.m_gradientID);
@@ -165,6 +199,8 @@ QDataStream &operator<<(QDataStream &stream, const GradientPresetItem &gradient)
 
 QDataStream &operator>>(QDataStream &stream, GradientPresetItem &gradient)
 {
+    NanotraceHR::Tracer tracer{"gradient preset item operator >>", category()};
+
     QGradientStops stops;
     stream >> stops;
     gradient.m_gradientVal.setStops(stops);

src/plugins/qmldesigner/components/propertyeditor/gradientpresetlistmodel.cpp

@@ -3,18 +3,23 @@
 
 #include "gradientpresetlistmodel.h"
 #include "gradientpresetitem.h"
+#include "propertyeditortracing.h"
 
 #include <QHash>
 #include <QByteArray>
 #include <QDebug>
 
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 GradientPresetListModel::GradientPresetListModel(QObject *parent)
     : QAbstractListModel(parent)
 {
-    m_roleNames
+    NanotraceHR::Tracer tracer{"gradient preset list model constructor", category()};
-        = {{static_cast<int>(GradientPresetItem::Property::objectNameRole), "objectName"},
+
+    m_roleNames = {{static_cast<int>(GradientPresetItem::Property::objectNameRole), "objectName"},
                    {static_cast<int>(GradientPresetItem::Property::stopsPosListRole), "stopsPosList"},
-           {static_cast<int>(GradientPresetItem::Property::stopsColorListRole), "stopsColorList"},
+                   {static_cast<int>(GradientPresetItem::Property::stopsColorListRole),
+                    "stopsColorList"},
                    {static_cast<int>(GradientPresetItem::Property::stopListSizeRole), "stopListSize"},
                    {static_cast<int>(GradientPresetItem::Property::presetNameRole), "presetName"},
                    {static_cast<int>(GradientPresetItem::Property::presetIDRole), "presetID"}};
@@ -22,16 +27,22 @@ GradientPresetListModel::GradientPresetListModel(QObject *parent)
 
 GradientPresetListModel::~GradientPresetListModel()
 {
+    NanotraceHR::Tracer tracer{"gradient preset list model destructor", category()};
+
     clearItems();
 }
 
 int GradientPresetListModel::rowCount(const QModelIndex & /*parent*/) const
 {
+    NanotraceHR::Tracer tracer{"gradient preset list model row count", category()};
+
     return m_items.size();
 }
 
 QVariant GradientPresetListModel::data(const QModelIndex &index, int role) const
 {
+    NanotraceHR::Tracer tracer{"gradient preset list model data", category()};
+
     if (index.isValid() && (index.row() >= 0) && (index.row() < m_items.size())) {
         if (m_roleNames.contains(role)) {
             QVariant value = m_items.at(index.row())
@@ -53,11 +64,15 @@ QVariant GradientPresetListModel::data(const QModelIndex &index, int role) const
 
 QHash<int, QByteArray> GradientPresetListModel::roleNames() const
 {
+    NanotraceHR::Tracer tracer{"gradient preset list model role names", category()};
+
     return m_roleNames;
 }
 
 void GradientPresetListModel::clearItems()
 {
+    NanotraceHR::Tracer tracer{"gradient preset list model clear items", category()};
+
     beginResetModel();
     m_items.clear();
     endResetModel();
@@ -65,6 +80,8 @@ void GradientPresetListModel::clearItems()
 
 void GradientPresetListModel::addItem(const GradientPresetItem &element)
 {
+    NanotraceHR::Tracer tracer{"gradient preset list model add item", category()};
+
     beginResetModel();
     m_items.append(element);
     endResetModel();
@@ -72,16 +89,21 @@ void GradientPresetListModel::addItem(const GradientPresetItem &element)
 
 const QList<GradientPresetItem> &GradientPresetListModel::items() const
 {
+    NanotraceHR::Tracer tracer{"gradient preset list model items", category()};
+
     return m_items;
 }
 
 void GradientPresetListModel::sortItems()
 {
+    NanotraceHR::Tracer tracer{"gradient preset list model sort items", category()};
 
     std::ranges::sort(m_items, {}, &GradientPresetItem::presetID);
 }
 
 void GradientPresetListModel::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"gradient preset list model register declarative type", category()};
+
     qmlRegisterType<GradientPresetListModel>("HelperWidgets", 2, 0, "GradientPresetListModel");
 }

src/plugins/qmldesigner/components/propertyeditor/instanceimageprovider.cpp

@@ -2,18 +2,23 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "instanceimageprovider.h"
+#include "propertyeditortracing.h"
 
 #include <abstractview.h>
 #include <QTimer>
 
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 static const char INSTANCE_IMAGE_REQUEST_ID[] = "PropertyEditor.InstanceImage";
 
 namespace QmlDesigner {
 
 InstanceImageProvider::InstanceImageProvider()
     : QQuickImageProvider(Pixmap)
-    , m_delayTimer(new QTimer(this))
+    , m_delayTimer(std::make_unique<QTimer>())
 {
+    NanotraceHR::Tracer tracer{"instance image provider constructor", category()};
+
     m_delayTimer->setInterval(500);
     m_delayTimer->setSingleShot(true);
     m_delayTimer->callOnTimeout([this] { requestOne(); });
@@ -30,6 +35,8 @@ InstanceImageProvider::InstanceImageProvider()
  */
 QPixmap InstanceImageProvider::requestPixmap(const QString &id, QSize *size, const QSize &requestedSize)
 {
+    NanotraceHR::Tracer tracer{"instance image provider request pixmap", category()};
+
     using namespace Qt::StringLiterals;
     static const QPixmap defaultImage = QPixmap::fromImage(
         QImage(":/propertyeditor/images/defaultmaterialpreview.png"));
@@ -69,6 +76,8 @@ bool InstanceImageProvider::feedImage(const ModelNode &node,
                                       const QPixmap &pixmap,
                                       const QByteArray &requestId)
 {
+    NanotraceHR::Tracer tracer{"instance image provider feed image", category()};
+
     if (!requestId.startsWith(INSTANCE_IMAGE_REQUEST_ID))
         return false;
 
@@ -83,16 +92,22 @@ bool InstanceImageProvider::feedImage(const ModelNode &node,
 
 void InstanceImageProvider::setModelNode(const ModelNode &node)
 {
+    NanotraceHR::Tracer tracer{"instance image provider set model node", category()};
+
     m_requestedNode = node;
 }
 
 bool InstanceImageProvider::hasPendingRequest() const
 {
+    NanotraceHR::Tracer tracer{"instance image provider has pending request", category()};
+
     return !m_pendingRequest.isEmpty();
 }
 
 void InstanceImageProvider::requestOne()
 {
+    NanotraceHR::Tracer tracer{"instance image provider request one", category()};
+
     if (!m_requestedNode)
         return;
 
@@ -109,18 +124,24 @@ void InstanceImageProvider::requestOne()
 
 void InstanceImageProvider::requestOne(QSize size)
 {
+    NanotraceHR::Tracer tracer{"instance image provider request one with size", category()};
+
     prepareRequest(size);
     requestOne();
 }
 
 void InstanceImageProvider::postponeRequest(QSize size)
 {
+    NanotraceHR::Tracer tracer{"instance image provider postpone request", category()};
+
     prepareRequest(size);
-    QMetaObject::invokeMethod(m_delayTimer, static_cast<void (QTimer::*)()>(&QTimer::start));
+    QMetaObject::invokeMethod(m_delayTimer.get(), static_cast<void (QTimer::*)()>(&QTimer::start));
 }
 
 void InstanceImageProvider::prepareRequest(QSize size)
 {
+    NanotraceHR::Tracer tracer{"instance image provider prepare request", category()};
+
     m_requestedSize = size;
 }
 
@@ -131,16 +152,22 @@ void InstanceImageProvider::prepareRequest(QSize size)
  */
 bool InstanceImageProvider::dataAvailable(const ModelNode &node, QSize size)
 {
+    NanotraceHR::Tracer tracer{"instance image provider data available", category()};
+
     return !m_resetRequest && node == m_receivedNode && size == m_receivedImage.size();
 }
 
 void InstanceImageProvider::invalidate()
 {
+    NanotraceHR::Tracer tracer{"instance image provider invalidate", category()};
+
     m_resetRequest = true;
 }
 
 QPixmap InstanceImageProvider::getScaledImage(QSize size)
 {
+    NanotraceHR::Tracer tracer{"instance image provider get scaled image", category()};
+
     if (size == m_receivedImage.size())
         return m_receivedImage;
     else

src/plugins/qmldesigner/components/propertyeditor/instanceimageprovider.h

@@ -47,7 +47,7 @@ private:
 
     QPixmap m_receivedImage;
 
-    QTimer *m_delayTimer = nullptr;
+    std::unique_ptr<QTimer> m_delayTimer;
 };
 
 } // namespace QmlDesigner

src/plugins/qmldesigner/components/propertyeditor/itemfiltermodel.cpp

@@ -3,6 +3,8 @@
 
 #include "itemfiltermodel.h"
 
+#include "propertyeditortracing.h"
+
 #include <abstractview.h>
 #include <model.h>
 #include <nodemetainfo.h>
@@ -15,6 +17,8 @@
 
 using namespace QmlDesigner;
 
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 ItemFilterModel::ItemFilterModel(QObject *parent)
     : QAbstractListModel(parent)
     , m_typeFilter("QtQuick.Item")
@@ -23,7 +27,9 @@ ItemFilterModel::ItemFilterModel(QObject *parent)
 
 void ItemFilterModel::setModelNodeBackend(const QVariant &modelNodeBackend)
 {
-    auto modelNodeBackendObject = modelNodeBackend.value<QObject*>();
+    NanotraceHR::Tracer tracer{"item filter model set model node backend", category()};
+
+    auto modelNodeBackendObject = modelNodeBackend.value<QObject *>();
 
     const auto backendObjectCasted =
             qobject_cast<const QmlModelNodeProxy *>(modelNodeBackendObject);
@@ -44,6 +50,8 @@ void ItemFilterModel::setModelNodeBackend(const QVariant &modelNodeBackend)
 
 void ItemFilterModel::setTypeFilter(const QString &filter)
 {
+    NanotraceHR::Tracer tracer{"item filter model set type filter", category()};
+
     if (m_typeFilter == filter)
         return;
 
@@ -54,6 +62,8 @@ void ItemFilterModel::setTypeFilter(const QString &filter)
 
 void ItemFilterModel::setSelectionOnly(bool value)
 {
+    NanotraceHR::Tracer tracer{"item filter model set selection only", category()};
+
     if (m_selectionOnly == value)
         return;
 
@@ -64,12 +74,16 @@ void ItemFilterModel::setSelectionOnly(bool value)
 
 void ItemFilterModel::setSelectedItems(const QStringList &selectedItems)
 {
+    NanotraceHR::Tracer tracer{"item filter model set selected items", category()};
+
     m_selectedItems = selectedItems;
     emit selectedItemsChanged();
 }
 
 void ItemFilterModel::setValidationRoles(const QStringList &validationRoles)
 {
+    NanotraceHR::Tracer tracer{"item filter model set validation roles", category()};
+
     auto tmp = validationRoles;
     tmp.removeDuplicates();
 
@@ -83,21 +97,29 @@ void ItemFilterModel::setValidationRoles(const QStringList &validationRoles)
 
 QString ItemFilterModel::typeFilter() const
 {
+    NanotraceHR::Tracer tracer{"item filter model type filter", category()};
+
     return m_typeFilter;
 }
 
 bool ItemFilterModel::selectionOnly() const
 {
+    NanotraceHR::Tracer tracer{"item filter model selection only", category()};
+
     return m_selectionOnly;
 }
 
 QStringList ItemFilterModel::selectedItems() const
 {
+    NanotraceHR::Tracer tracer{"item filter model selected items", category()};
+
     return m_selectedItems;
 }
 
 QStringList ItemFilterModel::itemModel() const
 {
+    NanotraceHR::Tracer tracer{"item filter model item model", category()};
+
     AbstractView *view = m_modelNode.view();
     if (!view || !view->model())
         return {};
@@ -111,16 +133,22 @@ QStringList ItemFilterModel::itemModel() const
 
 QStringList ItemFilterModel::validationRoles() const
 {
+    NanotraceHR::Tracer tracer{"item filter model validation roles", category()};
+
     return m_validationRoles;
 }
 
 QStringList ItemFilterModel::validationItems() const
 {
+    NanotraceHR::Tracer tracer{"item filter model validation items", category()};
+
     return m_validationItems;
 }
 
 QVariant ItemFilterModel::modelItemData(int row) const
 {
+    NanotraceHR::Tracer tracer{"item filter model model item data", category()};
+
     QModelIndex idx = index(row, 0, {});
     if (!idx.isValid())
         return {};
@@ -141,6 +169,8 @@ QVariant ItemFilterModel::modelItemData(int row) const
 
 int ItemFilterModel::indexFromId(const QString &id) const
 {
+    NanotraceHR::Tracer tracer{"item filter model index from id", category()};
+
     AbstractView *view = m_modelNode.view();
     if (!view || !view->model())
         return -1;
@@ -156,16 +186,22 @@ int ItemFilterModel::indexFromId(const QString &id) const
 
 void ItemFilterModel::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"item filter model register declarative type", category()};
+
     qmlRegisterType<ItemFilterModel>("HelperWidgets", 2, 0, "ItemFilterModel");
 }
 
 int ItemFilterModel::rowCount(const QModelIndex &) const
 {
+    NanotraceHR::Tracer tracer{"item filter model row count", category()};
+
     return m_modelInternalIds.size();
 }
 
 QVariant ItemFilterModel::data(const QModelIndex &index, int role) const
 {
+    NanotraceHR::Tracer tracer{"item filter model data", category()};
+
     if (!index.isValid() || index.row() >= rowCount())
         return {};
 
@@ -188,6 +224,8 @@ QVariant ItemFilterModel::data(const QModelIndex &index, int role) const
 
 QHash<int, QByteArray> ItemFilterModel::roleNames() const
 {
+    NanotraceHR::Tracer tracer{"item filter model role names", category()};
+
     static QHash<int, QByteArray> roleNames{{IdRole, "id"},
                                             {NameRole, "name"},
                                             {IdAndNameRole, "idAndName"},
@@ -198,11 +236,15 @@ QHash<int, QByteArray> ItemFilterModel::roleNames() const
 
 QVariant ItemFilterModel::modelNodeBackend() const
 {
+    NanotraceHR::Tracer tracer{"item filter model model node backend", category()};
+
     return {};
 }
 
 ModelNode ItemFilterModel::modelNodeForRow(const int &row) const
 {
+    NanotraceHR::Tracer tracer{"item filter model model node for row", category()};
+
     if (row < 0 || row >= m_modelInternalIds.size())
         return {};
 
@@ -215,6 +257,8 @@ ModelNode ItemFilterModel::modelNodeForRow(const int &row) const
 
 void ItemFilterModel::setupModel()
 {
+    NanotraceHR::Tracer tracer{"item filter model setup model", category()};
+
     if (!m_modelNode.isValid() || !m_modelNode.view()->isAttached())
         return;
 
@@ -238,6 +282,8 @@ void ItemFilterModel::setupModel()
 
 void ItemFilterModel::setupValidationItems()
 {
+    NanotraceHR::Tracer tracer{"item filter model setup validation items", category()};
+
     QStringList validationItems;
 
     for (const QString &role : m_validationRoles) {

src/plugins/qmldesigner/components/propertyeditor/listvalidator.cpp

@@ -3,12 +3,20 @@
 
 #include "listvalidator.h"
 
+#include "propertyeditortracing.h"
+
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 ListValidator::ListValidator(QObject *parent)
     : QValidator{parent}
-{}
+{
+    NanotraceHR::Tracer tracer{"list validator constructor", category()};
+}
 
 QValidator::State ListValidator::validate(QString &input, int &) const
 {
+    NanotraceHR::Tracer tracer{"list validator validate", category()};
+
     if (input.isEmpty())
         return QValidator::Intermediate;
 
@@ -30,6 +38,8 @@ QValidator::State ListValidator::validate(QString &input, int &) const
 
 void ListValidator::fixup(QString &input) const
 {
+    NanotraceHR::Tracer tracer{"list validator fixup", category()};
+
     for (const QString &item : m_filterList) {
         if (item.compare(input, Qt::CaseInsensitive) == 0) {
             input = item;
@@ -40,6 +50,8 @@ void ListValidator::fixup(QString &input) const
 
 void ListValidator::setFilterList(const QStringList &filterList)
 {
+    NanotraceHR::Tracer tracer{"list validator set filter list", category()};
+
     if (m_filterList == filterList)
         return;
 
@@ -49,10 +61,14 @@ void ListValidator::setFilterList(const QStringList &filterList)
 
 QStringList ListValidator::filterList() const
 {
+    NanotraceHR::Tracer tracer{"list validator filter list", category()};
+
     return m_filterList;
 }
 
 void ListValidator::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"list validator register declarative type", category()};
+
     qmlRegisterType<ListValidator>("HelperWidgets", 2, 0, "ListValidator");
 }

src/plugins/qmldesigner/components/propertyeditor/propertyeditorcontextobject.cpp

@@ -3,17 +3,19 @@
 
 #include "propertyeditorcontextobject.h"
 
-#include "abstractview.h"
 #include "compatibleproperties.h"
-#include "easingcurvedialog.h"
+#include "propertyeditortracing.h"
-#include "nodemetainfo.h"
 #include "propertyeditorutils.h"
-#include "qml3dnode.h"
+
-#include "qmldesignerconstants.h"
+#include <abstractview.h>
-#include "qmldesignerplugin.h"
+#include <easingcurvedialog.h>
-#include "qmlmodelnodeproxy.h"
+#include <nodemetainfo.h>
-#include "qmlobjectnode.h"
+#include <qml3dnode.h>
-#include "qmltimeline.h"
+#include <qmldesignerconstants.h>
+#include <qmldesignerplugin.h>
+#include <qmlmodelnodeproxy.h>
+#include <qmlobjectnode.h>
+#include <qmltimeline.h>
 
 #include <qmldesignerbase/settings/designersettings.h>
 
@@ -34,6 +36,8 @@
 
 namespace QmlDesigner {
 
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 static Q_LOGGING_CATEGORY(urlSpecifics, "qtc.propertyeditor.specifics", QtWarningMsg)
 
 PropertyEditorContextObject::PropertyEditorContextObject(QObject *parent)
@@ -43,10 +47,14 @@ PropertyEditorContextObject::PropertyEditorContextObject(QObject *parent)
     , m_backendValues(nullptr)
     , m_qmlComponent(nullptr)
     , m_qmlContext(nullptr)
-{}
+{
+    NanotraceHR::Tracer tracer{"property editor context object constructor", category()};
+}
 
 QString PropertyEditorContextObject::convertColorToString(const QVariant &color)
 {
+    NanotraceHR::Tracer tracer{"property editor context object convert color to string", category()};
+
     QString colorString;
     QColor theColor;
     if (color.canConvert(QMetaType(QMetaType::QColor))) {
@@ -69,13 +77,16 @@ QString PropertyEditorContextObject::convertColorToString(const QVariant &color)
 
 QColor PropertyEditorContextObject::colorFromString(const QString &colorString)
 {
+    NanotraceHR::Tracer tracer{"property editor context object color from string", category()};
+
     return QColor::fromString(colorString);
 }
 
 QString PropertyEditorContextObject::translateFunction()
 {
-    if (QmlDesignerPlugin::instance()->settings().value(
+    NanotraceHR::Tracer tracer{"property editor context object translate function", category()};
-            DesignerSettingsKey::TYPE_OF_QSTR_FUNCTION).toInt())
+
+    if (QmlDesignerPlugin::instance()->settings().value(DesignerSettingsKey::TYPE_OF_QSTR_FUNCTION).toInt())
 
         switch (QmlDesignerPlugin::instance()->settings().value(
                     DesignerSettingsKey::TYPE_OF_QSTR_FUNCTION).toInt()) {
@@ -90,6 +101,8 @@ QString PropertyEditorContextObject::translateFunction()
 
 QStringList PropertyEditorContextObject::autoComplete(const QString &text, int pos, bool explicitComplete, bool filter)
 {
+    NanotraceHR::Tracer tracer{"property editor context object auto complete", category()};
+
     if (m_model && m_model->rewriterView())
         return  Utils::filtered(m_model->rewriterView()->autoComplete(text, pos, explicitComplete), [filter](const QString &string) {
             return !filter || (!string.isEmpty() && string.at(0).isUpper()); });
@@ -99,6 +112,8 @@ QStringList PropertyEditorContextObject::autoComplete(const QString &text, int p
 
 void PropertyEditorContextObject::toggleExportAlias()
 {
+    NanotraceHR::Tracer tracer{"property editor context object toggle export alias", category()};
+
     QTC_ASSERT(m_model && m_model->rewriterView(), return);
 
     /* Ideally we should not missuse the rewriterView
@@ -127,6 +142,8 @@ void PropertyEditorContextObject::toggleExportAlias()
 
 void PropertyEditorContextObject::goIntoComponent()
 {
+    NanotraceHR::Tracer tracer{"property editor context object go into component", category()};
+
     QTC_ASSERT(m_model && m_model->rewriterView(), return);
 
     /* Ideally we should not missuse the rewriterView
@@ -142,6 +159,8 @@ void PropertyEditorContextObject::goIntoComponent()
 
 void PropertyEditorContextObject::changeTypeName(const QString &typeName)
 {
+    NanotraceHR::Tracer tracer{"property editor context object change type name", category()};
+
     QTC_ASSERT(m_model && m_model->rewriterView(), return);
 
     /* Ideally we should not missuse the rewriterView
@@ -295,11 +314,15 @@ void PropertyEditorContextObject::insertKeyframe(const QString &propertyName)
 
 QString PropertyEditorContextObject::activeDragSuffix() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object active drag suffix", category()};
+
     return m_activeDragSuffix;
 }
 
 void PropertyEditorContextObject::setActiveDragSuffix(const QString &suffix)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set active drag suffix", category()};
+
     if (m_activeDragSuffix != suffix) {
         m_activeDragSuffix = suffix;
         emit activeDragSuffixChanged();
@@ -308,22 +331,29 @@ void PropertyEditorContextObject::setActiveDragSuffix(const QString &suffix)
 
 int PropertyEditorContextObject::majorVersion() const
 {
-    return m_majorVersion;
+    NanotraceHR::Tracer tracer{"property editor context object major version", category()};
 
+    return m_majorVersion;
 }
 
 int PropertyEditorContextObject::majorQtQuickVersion() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object major Qt Quick version", category()};
+
     return m_majorQtQuickVersion;
 }
 
 int PropertyEditorContextObject::minorQtQuickVersion() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object minor Qt Quick version", category()};
+
     return m_minorQtQuickVersion;
 }
 
 void PropertyEditorContextObject::setMajorVersion(int majorVersion)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set major version", category()};
+
     if (m_majorVersion == majorVersion)
         return;
 
@@ -334,6 +364,9 @@ void PropertyEditorContextObject::setMajorVersion(int majorVersion)
 
 void PropertyEditorContextObject::setMajorQtQuickVersion(int majorVersion)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set major Qt Quick version",
+                               category()};
+
     if (m_majorQtQuickVersion == majorVersion)
         return;
 
@@ -345,6 +378,9 @@ void PropertyEditorContextObject::setMajorQtQuickVersion(int majorVersion)
 
 void PropertyEditorContextObject::setMinorQtQuickVersion(int minorVersion)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set minor Qt Quick version",
+                               category()};
+
     if (m_minorQtQuickVersion == minorVersion)
         return;
 
@@ -355,6 +391,8 @@ void PropertyEditorContextObject::setMinorQtQuickVersion(int minorVersion)
 
 int PropertyEditorContextObject::minorVersion() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object minor version", category()};
+
     return m_minorVersion;
 }
 
@@ -370,11 +408,14 @@ void PropertyEditorContextObject::setMinorVersion(int minorVersion)
 
 bool PropertyEditorContextObject::hasActiveTimeline() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object has active timeline", category()};
     return m_setHasActiveTimeline;
 }
 
 void PropertyEditorContextObject::setHasActiveTimeline(bool b)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set has active timeline", category()};
+
     if (b == m_setHasActiveTimeline)
         return;
 
@@ -384,12 +425,16 @@ void PropertyEditorContextObject::setHasActiveTimeline(bool b)
 
 void PropertyEditorContextObject::insertInQmlContext(QQmlContext *context)
 {
+    NanotraceHR::Tracer tracer{"property editor context object insert in QML context", category()};
+
     m_qmlContext = context;
     m_qmlContext->setContextObject(this);
 }
 
 QQmlComponent *PropertyEditorContextObject::specificQmlComponent()
 {
+    NanotraceHR::Tracer tracer{"property editor context object specific QML component", category()};
+
     if (m_qmlComponent)
         return m_qmlComponent;
 
@@ -408,11 +453,14 @@ QQmlComponent *PropertyEditorContextObject::specificQmlComponent()
 
 bool PropertyEditorContextObject::hasMultiSelection() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object has multi selection", category()};
+
     return m_hasMultiSelection;
 }
 
 void PropertyEditorContextObject::setHasMultiSelection(bool b)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set has multi selection", category()};
     if (b == m_hasMultiSelection)
         return;
 
@@ -422,11 +470,15 @@ void PropertyEditorContextObject::setHasMultiSelection(bool b)
 
 bool PropertyEditorContextObject::isSelectionLocked() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object is selection locked", category()};
+
     return m_isSelectionLocked;
 }
 
 void PropertyEditorContextObject::setIsSelectionLocked(bool lock)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set is selection locked", category()};
+
     if (lock == m_isSelectionLocked)
         return;
 
@@ -436,6 +488,8 @@ void PropertyEditorContextObject::setIsSelectionLocked(bool lock)
 
 void PropertyEditorContextObject::setInsightEnabled(bool value)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set insight enabled", category()};
+
     if (value != m_insightEnabled) {
         m_insightEnabled = value;
         emit insightEnabledChanged();
@@ -444,12 +498,16 @@ void PropertyEditorContextObject::setInsightEnabled(bool value)
 
 void PropertyEditorContextObject::setInsightCategories(const QStringList &categories)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set insight categories", category()};
+
     m_insightCategories = categories;
     emit insightCategoriesChanged();
 }
 
 bool PropertyEditorContextObject::hasQuick3DImport() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object has quick 3D import", category()};
+
     return m_hasQuick3DImport;
 }
 
@@ -460,6 +518,8 @@ void PropertyEditorContextObject::setEditorNodes(const ModelNodes &nodes)
 
 void PropertyEditorContextObject::setHasQuick3DImport(bool value)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set has quick 3D import", category()};
+
     if (value == m_hasQuick3DImport)
         return;
 
@@ -469,11 +529,15 @@ void PropertyEditorContextObject::setHasQuick3DImport(bool value)
 
 bool PropertyEditorContextObject::hasMaterialLibrary() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object has material library", category()};
+
     return m_hasMaterialLibrary;
 }
 
 void PropertyEditorContextObject::setHasMaterialLibrary(bool value)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set has material library", category()};
+
     if (value == m_hasMaterialLibrary)
         return;
 
@@ -483,11 +547,15 @@ void PropertyEditorContextObject::setHasMaterialLibrary(bool value)
 
 bool PropertyEditorContextObject::isQt6Project() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object is Qt6 project", category()};
+
     return m_isQt6Project;
 }
 
 void PropertyEditorContextObject::setIsQt6Project(bool value)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set is Qt6 project", category()};
+
     if (m_isQt6Project == value)
         return;
 
@@ -497,11 +565,15 @@ void PropertyEditorContextObject::setIsQt6Project(bool value)
 
 bool PropertyEditorContextObject::has3DModelSelected() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object has 3D model selected", category()};
+
     return m_has3DModelSelected;
 }
 
 void PropertyEditorContextObject::setHas3DModelSelected(bool value)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set has 3D model selected", category()};
+
     if (value == m_has3DModelSelected)
         return;
 
@@ -511,6 +583,8 @@ void PropertyEditorContextObject::setHas3DModelSelected(bool value)
 
 void PropertyEditorContextObject::setSpecificsUrl(const QUrl &newSpecificsUrl)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set specifics URL", category()};
+
     if (newSpecificsUrl == m_specificsUrl)
         return;
 
@@ -522,6 +596,8 @@ void PropertyEditorContextObject::setSpecificsUrl(const QUrl &newSpecificsUrl)
 
 void PropertyEditorContextObject::setSpecificQmlData(const QString &newSpecificQmlData)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set specific QML data", category()};
+
     if (m_specificQmlData == newSpecificQmlData)
         return;
 
@@ -536,6 +612,8 @@ void PropertyEditorContextObject::setSpecificQmlData(const QString &newSpecificQ
 
 void PropertyEditorContextObject::setStateName(const QString &newStateName)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set state name", category()};
+
     if (newStateName == m_stateName)
         return;
 
@@ -545,6 +623,8 @@ void PropertyEditorContextObject::setStateName(const QString &newStateName)
 
 void PropertyEditorContextObject::setAllStateNames(const QStringList &allStates)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set all state names", category()};
+
     if (allStates == m_allStateNames)
         return;
 
@@ -554,6 +634,8 @@ void PropertyEditorContextObject::setAllStateNames(const QStringList &allStates)
 
 void PropertyEditorContextObject::setIsBaseState(bool newIsBaseState)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set is base state", category()};
+
     if (newIsBaseState == m_isBaseState)
         return;
 
@@ -563,6 +645,8 @@ void PropertyEditorContextObject::setIsBaseState(bool newIsBaseState)
 
 void PropertyEditorContextObject::setSelectionChanged(bool newSelectionChanged)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set selection changed", category()};
+
     if (newSelectionChanged == m_selectionChanged)
         return;
 
@@ -572,6 +656,8 @@ void PropertyEditorContextObject::setSelectionChanged(bool newSelectionChanged)
 
 void PropertyEditorContextObject::setBackendValues(QQmlPropertyMap *newBackendValues)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set backend values", category()};
+
     if (newBackendValues == m_backendValues)
         return;
 
@@ -581,16 +667,22 @@ void PropertyEditorContextObject::setBackendValues(QQmlPropertyMap *newBackendVa
 
 void PropertyEditorContextObject::setModel(Model *model)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set model", category()};
+
     m_model = model;
 }
 
 void PropertyEditorContextObject::triggerSelectionChanged()
 {
+    NanotraceHR::Tracer tracer{"property editor context object trigger selection changed", category()};
+
     setSelectionChanged(!m_selectionChanged);
 }
 
 void PropertyEditorContextObject::setHasAliasExport(bool hasAliasExport)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set has alias export", category()};
+
     if (m_aliasExport == hasAliasExport)
         return;
 
@@ -600,6 +692,8 @@ void PropertyEditorContextObject::setHasAliasExport(bool hasAliasExport)
 
 void PropertyEditorContextObject::setQuickWidget(QQuickWidget *newQuickWidget)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set quick widget", category()};
+
     m_quickWidget = newQuickWidget;
 }
 
@@ -616,6 +710,8 @@ void PropertyEditorContextObject::hideCursor()
 
 void PropertyEditorContextObject::restoreCursor()
 {
+    NanotraceHR::Tracer tracer{"property editor context object restore cursor", category()};
+
     if (!QApplication::overrideCursor())
         return;
 
@@ -627,6 +723,8 @@ void PropertyEditorContextObject::restoreCursor()
 
 void PropertyEditorContextObject::holdCursorInPlace()
 {
+    NanotraceHR::Tracer tracer{"property editor context object hold cursor in place", category()};
+
     if (!QApplication::overrideCursor())
         return;
 
@@ -636,6 +734,8 @@ void PropertyEditorContextObject::holdCursorInPlace()
 
 int PropertyEditorContextObject::devicePixelRatio()
 {
+    NanotraceHR::Tracer tracer{"property editor context object device pixel ratio", category()};
+
     if (QWidget *w = QApplication::activeWindow())
         return w->devicePixelRatio();
 
@@ -644,11 +744,15 @@ int PropertyEditorContextObject::devicePixelRatio()
 
 QStringList PropertyEditorContextObject::styleNamesForFamily(const QString &family)
 {
+    NanotraceHR::Tracer tracer{"property editor context object style names for family", category()};
+
     return QFontDatabase::styles(family);
 }
 
 QStringList PropertyEditorContextObject::allStatesForId(const QString &id)
 {
+    NanotraceHR::Tracer tracer{"property editor context object all states for id", category()};
+
     if (m_model && m_model->rewriterView()) {
         const QmlObjectNode node = m_model->rewriterView()->modelNodeForId(id);
         if (node.isValid())
@@ -660,6 +764,8 @@ QStringList PropertyEditorContextObject::allStatesForId(const QString &id)
 
 bool PropertyEditorContextObject::isBlocked(const QString &propName) const
 {
+    NanotraceHR::Tracer tracer{"property editor context object is blocked", category()};
+
     if (m_model && m_model->rewriterView()) {
         const QList<ModelNode> nodes = m_model->rewriterView()->selectedModelNodes();
         for (const auto &node : nodes) {
@@ -672,6 +778,8 @@ bool PropertyEditorContextObject::isBlocked(const QString &propName) const
 
 void PropertyEditorContextObject::verifyInsightImport()
 {
+    NanotraceHR::Tracer tracer{"property editor context object verify insight import", category()};
+
     Import import = Import::createLibraryImport("QtInsightTracker", "1.0");
 
     if (!m_model->hasImport(import))
@@ -680,6 +788,8 @@ void PropertyEditorContextObject::verifyInsightImport()
 
 QRect PropertyEditorContextObject::screenRect() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object screen rect", category()};
+
     if (m_quickWidget && m_quickWidget->screen())
         return m_quickWidget->screen()->availableGeometry();
     return  {};
@@ -687,6 +797,8 @@ QRect PropertyEditorContextObject::screenRect() const
 
 QPoint PropertyEditorContextObject::globalPos(const QPoint &point) const
 {
+    NanotraceHR::Tracer tracer{"property editor context object global pos", category()};
+
     if (m_quickWidget)
         return m_quickWidget->mapToGlobal(point);
     return point;
@@ -694,32 +806,44 @@ QPoint PropertyEditorContextObject::globalPos(const QPoint &point) const
 
 void PropertyEditorContextObject::handleToolBarAction(int action)
 {
+    NanotraceHR::Tracer tracer{"property editor context object handle toolbar action", category()};
+
     emit toolBarAction(action);
 }
 
 void PropertyEditorContextObject::saveExpandedState(const QString &sectionName, bool expanded)
 {
+    NanotraceHR::Tracer tracer{"property editor context object save expanded state", category()};
+
     s_expandedStateHash.insert(sectionName, expanded);
 }
 
 bool PropertyEditorContextObject::loadExpandedState(const QString &sectionName, bool defaultValue) const
 {
+    NanotraceHR::Tracer tracer{"property editor context object load expanded state", category()};
+
     return s_expandedStateHash.value(sectionName, defaultValue);
 }
 
 void EasingCurveEditor::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"property editor context object register declarative type", category()};
+
     qmlRegisterType<EasingCurveEditor>("HelperWidgets", 2, 0, "EasingCurveEditor");
 }
 
 void EasingCurveEditor::runDialog()
 {
+    NanotraceHR::Tracer tracer{"property editor context object run dialog", category()};
+
     if (m_modelNode.isValid())
         EasingCurveDialog::runDialog({ m_modelNode }, Core::ICore::dialogParent());
 }
 
 void EasingCurveEditor::setModelNodeBackend(const QVariant &modelNodeBackend)
 {
+    NanotraceHR::Tracer tracer{"property editor context object set model node backend", category()};
+
     if (!modelNodeBackend.isNull() && modelNodeBackend.isValid()) {
         m_modelNodeBackend = modelNodeBackend;
 
@@ -738,6 +862,8 @@ void EasingCurveEditor::setModelNodeBackend(const QVariant &modelNodeBackend)
 
 QVariant EasingCurveEditor::modelNodeBackend() const
 {
+    NanotraceHR::Tracer tracer{"property editor context object model node backend", category()};
+
     return m_modelNodeBackend;
 }
 

src/plugins/qmldesigner/components/propertyeditor/propertyeditordynamicpropertiesproxymodel.cpp

@@ -25,21 +25,31 @@
 
 #include "propertyeditordynamicpropertiesproxymodel.h"
 
+#include "propertyeditortracing.h"
+
 #include <dynamicpropertiesmodel.h>
 
 #include <propertyeditorview.h>
 
 namespace QmlDesigner {
 
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 PropertyEditorDynamicPropertiesProxyModel::PropertyEditorDynamicPropertiesProxyModel(QObject *parent)
     : DynamicPropertiesProxyModel(parent)
 {
+    NanotraceHR::Tracer tracer{"property editor dynamic properties proxy model constructor",
+                               category()};
+
     if (PropertyEditorView::instance())
         initModel(PropertyEditorView::instance()->dynamicPropertiesModel());
 }
 
 void PropertyEditorDynamicPropertiesProxyModel::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{
+        "property editor dynamic properties proxy model register declarative type", category()};
+
     DynamicPropertiesProxyModel::registerDeclarativeType();
     qmlRegisterType<PropertyEditorDynamicPropertiesProxyModel>("HelperWidgets", 2, 0, "PropertyEditorDynamicPropertiesModel");
 }

src/plugins/qmldesigner/components/propertyeditor/propertyeditorqmlbackend.cpp

@@ -4,6 +4,7 @@
 #include "propertyeditorqmlbackend.h"
 
 #include "instanceimageprovider.h"
+#include "propertyeditortracing.h"
 #include "propertyeditortransaction.h"
 #include "propertyeditorutils.h"
 #include "propertyeditorvalue.h"
@@ -51,6 +52,8 @@
 
 #include <tuple>
 
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 static Q_LOGGING_CATEGORY(propertyEditorBenchmark, "qtc.propertyeditor.load", QtWarningMsg)
 
 static QmlJS::SimpleReaderNode::Ptr s_templateConfiguration = QmlJS::SimpleReaderNode::Ptr();
@@ -115,6 +118,8 @@ PropertyEditorQmlBackend::PropertyEditorQmlBackend(PropertyEditorView *propertyE
     , m_propertyEditorTransaction(std::make_unique<PropertyEditorTransaction>(propertyEditor))
     , m_dummyPropertyEditorValue(std::make_unique<PropertyEditorValue>())
 {
+    NanotraceHR::Tracer tracer{"property editor backend constructor", category()};
+
     m_contextObject->setQuickWidget(m_view.get());
     m_view->engine()->setOutputWarningsToStandardError(QmlDesignerPlugin::instance()
         ->settings().value(DesignerSettingsKey::SHOW_PROPERTYEDITOR_WARNINGS).toBool());
@@ -133,12 +138,17 @@ PropertyEditorQmlBackend::PropertyEditorQmlBackend(PropertyEditorView *propertyE
                      propertyEditor, &PropertyEditorView::changeValue);
 }
 
-PropertyEditorQmlBackend::~PropertyEditorQmlBackend() = default;
+PropertyEditorQmlBackend::~PropertyEditorQmlBackend()
+{
+    NanotraceHR::Tracer tracer{"property editor backend destructor", category()};
+}
 
 void PropertyEditorQmlBackend::setupPropertyEditorValue(PropertyNameView name,
                                                         PropertyEditorView *propertyEditor,
                                                         const NodeMetaInfo &type)
 {
+    NanotraceHR::Tracer tracer{"property editor backend setup property editor value", category()};
+
     QmlDesigner::PropertyName propertyName(name.toByteArray());
     propertyName.replace('.', '_');
     auto valueObject = qobject_cast<PropertyEditorValue*>(variantToQObject(backendValuesPropertyMap().value(QString::fromUtf8(propertyName))));
@@ -174,6 +184,8 @@ QVariant properDefaultAuxiliaryProperties(const QmlObjectNode &qmlObjectNode,
 QVariant properDefaultLayoutAttachedProperties(const QmlObjectNode &qmlObjectNode,
                                                PropertyNameView propertyName)
 {
+    NanotraceHR::Tracer tracer{"property editor backend proper default layout attached properties",
+                               category()};
     const QVariant value = qmlObjectNode.modelValue("Layout."_sv + propertyName);
     QVariant marginsValue = qmlObjectNode.modelValue("Layout.margins");
 
@@ -220,6 +232,8 @@ QVariant properDefaultInsightAttachedProperties(const QmlObjectNode &qmlObjectNo
 
 void PropertyEditorQmlBackend::setupLayoutAttachedProperties(const QmlObjectNode &qmlObjectNode, PropertyEditorView *propertyEditor)
 {
+    NanotraceHR::Tracer tracer{"property editor backend setup layout attached properties", category()};
+
     if (QmlItemNode(qmlObjectNode).isInLayout()) {
         static constexpr PropertyNameView propertyNames[] = {"alignment",
                                                              "column",
@@ -253,6 +267,9 @@ void PropertyEditorQmlBackend::setupLayoutAttachedProperties(const QmlObjectNode
 void PropertyEditorQmlBackend::setupInsightAttachedProperties(const QmlObjectNode &qmlObjectNode,
                                                               PropertyEditorView *propertyEditor)
 {
+    NanotraceHR::Tracer tracer{"property editor backend setup insight attached properties",
+                               category()};
+
     const PropertyName propertyName = "category";
     createPropertyEditorValue(qmlObjectNode,
                               "InsightCategory."_sv + propertyName,
@@ -263,6 +280,8 @@ void PropertyEditorQmlBackend::setupInsightAttachedProperties(const QmlObjectNod
 void PropertyEditorQmlBackend::setupAuxiliaryProperties(const QmlObjectNode &qmlObjectNode,
                                                         PropertyEditorView *propertyEditor)
 {
+    NanotraceHR::Tracer tracer{"property editor backend setup auxiliary properties", category()};
+
     const QmlItemNode itemNode(qmlObjectNode);
 
     auto createProperty = [&](auto &&...properties) {
@@ -336,12 +355,16 @@ void PropertyEditorQmlBackend::setupAuxiliaryProperties(const QmlObjectNode &qml
 void PropertyEditorQmlBackend::handleInstancePropertyChangedInModelNodeProxy(
     const ModelNode &modelNode, PropertyNameView propertyName)
 {
+    NanotraceHR::Tracer tracer{"property editor backend handle instance property changed", category()};
+
     m_backendModelNode.handleInstancePropertyChanged(modelNode, propertyName);
 }
 
 void PropertyEditorQmlBackend::handleAuxiliaryDataChanges(const QmlObjectNode &qmlObjectNode,
                                                           AuxiliaryDataKeyView key)
 {
+    NanotraceHR::Tracer tracer{"property editor backend handle auxiliary data changes", category()};
+
     if (qmlObjectNode.isRootModelNode() && isMaterialAuxiliaryKey(key)) {
         m_backendMaterialNode.handleAuxiliaryPropertyChanges();
         m_view->instanceImageProvider()->invalidate();
@@ -350,12 +373,16 @@ void PropertyEditorQmlBackend::handleAuxiliaryDataChanges(const QmlObjectNode &q
 
 void PropertyEditorQmlBackend::handleVariantPropertyChangedInModelNodeProxy(const VariantProperty &property)
 {
+    NanotraceHR::Tracer tracer{"property editor backend handle variant property changed", category()};
+
     m_backendModelNode.handleVariantPropertyChanged(property);
     updateInstanceImage();
 }
 
 void PropertyEditorQmlBackend::handleBindingPropertyChangedInModelNodeProxy(const BindingProperty &property)
 {
+    NanotraceHR::Tracer tracer{"property editor backend handle binding property changed", category()};
+
     m_backendModelNode.handleBindingPropertyChanged(property);
     m_backendTextureNode.handleBindingPropertyChanged(property);
     updateInstanceImage();
@@ -364,6 +391,9 @@ void PropertyEditorQmlBackend::handleBindingPropertyChangedInModelNodeProxy(cons
 void PropertyEditorQmlBackend::handleBindingPropertyInModelNodeProxyAboutToChange(
     const BindingProperty &property)
 {
+    NanotraceHR::Tracer tracer{"property editor backend handle binding property about to change",
+                               category()};
+
     if (m_backendMaterialNode.materialNode()) {
         ModelNode expressionNode = property.resolveToModelNode();
         if (expressionNode.metaInfo().isQtQuick3DTexture())
@@ -374,6 +404,8 @@ void PropertyEditorQmlBackend::handleBindingPropertyInModelNodeProxyAboutToChang
 
 void PropertyEditorQmlBackend::handlePropertiesRemovedInModelNodeProxy(const AbstractProperty &property)
 {
+    NanotraceHR::Tracer tracer{"property editor backend handle properties removed", category()};
+
     m_backendModelNode.handlePropertiesRemoved(property);
     m_backendTextureNode.handlePropertiesRemoved(property);
     updateInstanceImage();
@@ -395,6 +427,9 @@ void PropertyEditorQmlBackend::handleModelNodePreviewPixmapChanged(const ModelNo
 
 void PropertyEditorQmlBackend::handleModelSelectedNodesChanged(PropertyEditorView *propertyEditor)
 {
+    NanotraceHR::Tracer tracer{"property editor backend handle model selected nodes changed",
+                               category()};
+
     contextObject()->setHas3DModelSelected(!Utils3D::getSelectedModels(propertyEditor).isEmpty());
     m_backendTextureNode.updateSelectionDetails();
 }
@@ -404,6 +439,8 @@ void PropertyEditorQmlBackend::createPropertyEditorValue(const QmlObjectNode &qm
                                                          const QVariant &value,
                                                          PropertyEditorView *propertyEditor)
 {
+    NanotraceHR::Tracer tracer{"property editor backend create property editor value", category()};
+
     PropertyName propertyName(name.toByteArray());
     propertyName.replace('.', '_');
     auto valueObject = qobject_cast<PropertyEditorValue*>(variantToQObject(backendValuesPropertyMap().value(QString::fromUtf8(propertyName))));
@@ -441,6 +478,8 @@ void PropertyEditorQmlBackend::setValue(const QmlObjectNode &,
                                         PropertyNameView name,
                                         const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{"property editor backend set value", category()};
+
     // Vector*D values need to be split into their subcomponents
     if (value.typeId() == QMetaType::QVector2D) {
         const char *suffix[2] = {"_x", "_y"};
@@ -487,6 +526,8 @@ void PropertyEditorQmlBackend::setValue(const QmlObjectNode &,
 
 void PropertyEditorQmlBackend::setExpression(PropertyNameView propName, const QString &exp)
 {
+    NanotraceHR::Tracer tracer{"property editor backend set expression", category()};
+
     PropertyEditorValue *propertyValue = propertyValueForName(QString::fromUtf8(propName));
     if (propertyValue)
         propertyValue->setExpression(exp);
@@ -494,21 +535,29 @@ void PropertyEditorQmlBackend::setExpression(PropertyNameView propName, const QS
 
 QQmlContext *PropertyEditorQmlBackend::context()
 {
+    NanotraceHR::Tracer tracer{"property editor backend context", category()};
+
     return m_view->rootContext();
 }
 
 PropertyEditorContextObject *PropertyEditorQmlBackend::contextObject()
 {
+    NanotraceHR::Tracer tracer{"property editor backend context object", category()};
+
     return m_contextObject.get();
 }
 
 QQuickWidget *PropertyEditorQmlBackend::widget()
 {
+    NanotraceHR::Tracer tracer{"property editor backend widget", category()};
+
     return m_view.get();
 }
 
 void PropertyEditorQmlBackend::setSource(const QUrl &url)
 {
+    NanotraceHR::Tracer tracer{"property editor backend set source", category()};
+
     m_view->setSource(url);
 
     const bool showError = qEnvironmentVariableIsSet(Constants::ENVIRONMENT_SHOW_QML_ERRORS);
@@ -521,24 +570,37 @@ void PropertyEditorQmlBackend::setSource(const QUrl &url)
 
 QmlAnchorBindingProxy &PropertyEditorQmlBackend::backendAnchorBinding()
 {
+    NanotraceHR::Tracer tracer{"property editor backend backend anchor binding", category()};
+
     return m_backendAnchorBinding;
 }
 
-DesignerPropertyMap &PropertyEditorQmlBackend::backendValuesPropertyMap() {
+DesignerPropertyMap &PropertyEditorQmlBackend::backendValuesPropertyMap()
+{
+    NanotraceHR::Tracer tracer{"property editor backend backend values property map", category()};
+
     return m_backendValuesPropertyMap;
 }
 
-PropertyEditorTransaction *PropertyEditorQmlBackend::propertyEditorTransaction() {
+PropertyEditorTransaction *PropertyEditorQmlBackend::propertyEditorTransaction()
+{
+    NanotraceHR::Tracer tracer{"property editor backend property editor transaction", category()};
+
     return m_propertyEditorTransaction.get();
 }
 
 PropertyEditorValue *PropertyEditorQmlBackend::propertyValueForName(const QString &propertyName)
 {
-     return qobject_cast<PropertyEditorValue*>(variantToQObject(backendValuesPropertyMap().value(propertyName)));
+    NanotraceHR::Tracer tracer{"property editor backend property value for name", category()};
+
+    return qobject_cast<PropertyEditorValue *>(
+        variantToQObject(backendValuesPropertyMap().value(propertyName)));
 }
 
 void QmlDesigner::PropertyEditorQmlBackend::createPropertyEditorValues(const QmlObjectNode &qmlObjectNode, PropertyEditorView *propertyEditor)
 {
+    NanotraceHR::Tracer tracer{"property editor backend create property editor values", category()};
+
 #ifndef QDS_USE_PROJECTSTORAGE
     for (const auto &property : PropertyEditorUtils::filteredProperties(qmlObjectNode.metaInfo())) {
         auto propertyName = property.name();
@@ -563,6 +625,8 @@ PropertyEditorValue *PropertyEditorQmlBackend::insertValue(const QString &name,
                                                            const QVariant &value,
                                                            const ModelNode &modelNode)
 {
+    NanotraceHR::Tracer tracer{"property editor backend insert value", category()};
+
     auto valueObject = qobject_cast<PropertyEditorValue *>(
         variantToQObject(m_backendValuesPropertyMap.value(name)));
     if (!valueObject)
@@ -586,6 +650,8 @@ PropertyEditorValue *PropertyEditorQmlBackend::insertValue(const QString &name,
 
 void PropertyEditorQmlBackend::updateInstanceImage()
 {
+    NanotraceHR::Tracer tracer{"property editor backend update instance image", category()};
+
     m_view->instanceImageProvider()->invalidate();
     refreshPreview();
 }
@@ -595,6 +661,8 @@ void PropertyEditorQmlBackend::setup(const ModelNodes &editorNodes,
                                      const QUrl &qmlSpecificsFile,
                                      PropertyEditorView *propertyEditor)
 {
+    NanotraceHR::Tracer tracer{"property editor backend setup", category()};
+
     QmlObjectNode qmlObjectNode(editorNodes.isEmpty() ? ModelNode{} : editorNodes.first());
     if (!qmlObjectNode.isValid()) {
         qWarning() << "PropertyEditor: invalid node for setup";
@@ -694,11 +762,15 @@ void PropertyEditorQmlBackend::setup(const ModelNodes &editorNodes,
 
 QString PropertyEditorQmlBackend::propertyEditorResourcesPath()
 {
+    NanotraceHR::Tracer tracer{"property editor backend property editor resources path", category()};
+
     return resourcesPath("propertyEditorQmlSources");
 }
 
 QString PropertyEditorQmlBackend::scriptsEditorResourcesPath()
 {
+    NanotraceHR::Tracer tracer{"property editor backend scripts editor resources path", category()};
+
     return resourcesPath("scriptseditor");
 }
 
@@ -968,6 +1040,8 @@ QUrl PropertyEditorQmlBackend::getQmlFileUrl(const TypeName &relativeTypeName, c
 
 TypeName PropertyEditorQmlBackend::fixTypeNameForPanes(const TypeName &typeName)
 {
+    NanotraceHR::Tracer tracer{"property editor backend fix type name for panes", category()};
+
     TypeName fixedTypeName = typeName;
     fixedTypeName.replace('.', '/');
     return fixedTypeName;
@@ -975,6 +1049,8 @@ TypeName PropertyEditorQmlBackend::fixTypeNameForPanes(const TypeName &typeName)
 
 QString PropertyEditorQmlBackend::resourcesPath(const QString &dir)
 {
+    NanotraceHR::Tracer tracer{"property editor backend resources path", category()};
+
 #ifdef SHARE_QML_PATH
     if (Utils::qtcEnvironmentVariableIsSet("LOAD_QML_FROM_SOURCE"))
         return QLatin1String(SHARE_QML_PATH) + "/" + dir;
@@ -984,11 +1060,15 @@ QString PropertyEditorQmlBackend::resourcesPath(const QString &dir)
 
 void PropertyEditorQmlBackend::refreshBackendModel()
 {
+    NanotraceHR::Tracer tracer{"property editor backend refresh backend model", category()};
+
     m_backendModelNode.refresh();
 }
 
 void PropertyEditorQmlBackend::refreshPreview()
 {
+    NanotraceHR::Tracer tracer{"property editor backend refresh preview", category()};
+
     auto qmlPreview = widget()->rootObject();
 
     if (qmlPreview && qmlPreview->metaObject()->indexOfMethod("refreshPreview()") > -1)
@@ -997,6 +1077,8 @@ void PropertyEditorQmlBackend::refreshPreview()
 
 void PropertyEditorQmlBackend::setupContextProperties()
 {
+    NanotraceHR::Tracer tracer{"property editor backend setup context properties", category()};
+
     context()->setContextProperties({
         {"modelNodeBackend", QVariant::fromValue(&m_backendModelNode)},
         {"materialNodeBackend", QVariant::fromValue(&m_backendMaterialNode)},
@@ -1015,7 +1097,10 @@ TypeName PropertyEditorQmlBackend::qmlFileName(const NodeMetaInfo &nodeInfo)
 }
 #endif
 
-QUrl PropertyEditorQmlBackend::fileToUrl(const QString &filePath)  {
+QUrl PropertyEditorQmlBackend::fileToUrl(const QString &filePath)
+{
+    NanotraceHR::Tracer tracer{"property editor backend file to url", category()};
+
     QUrl fileUrl;
 
     if (filePath.isEmpty())
@@ -1035,11 +1120,15 @@ QUrl PropertyEditorQmlBackend::fileToUrl(const QString &filePath)  {
 
 QUrl PropertyEditorQmlBackend::emptyPaneUrl()
 {
+    NanotraceHR::Tracer tracer{"property editor backend empty pane url", category()};
+
     return fileToUrl(QDir(propertyEditorResourcesPath()).filePath("QtQuick/emptyPane.qml"_L1));
 }
 
 QString PropertyEditorQmlBackend::fileFromUrl(const QUrl &url)
 {
+    NanotraceHR::Tracer tracer{"property editor backend file from url", category()};
+
     if (url.scheme() == QStringLiteral("qrc")) {
         const QString &path = url.path();
         return QStringLiteral(":") + path;
@@ -1050,23 +1139,32 @@ QString PropertyEditorQmlBackend::fileFromUrl(const QUrl &url)
 
 bool PropertyEditorQmlBackend::checkIfUrlExists(const QUrl &url)
 {
+    NanotraceHR::Tracer tracer{"property editor backend check if url exists", category()};
+
     const QString &file = fileFromUrl(url);
     return !file.isEmpty() && QFileInfo::exists(file);
 }
 
 void PropertyEditorQmlBackend::emitSelectionToBeChanged()
 {
+    NanotraceHR::Tracer tracer{"property editor backend emit selection to be changed", category()};
+
     m_backendModelNode.emitSelectionToBeChanged();
 }
 
 void PropertyEditorQmlBackend::emitSelectionChanged()
 {
+    NanotraceHR::Tracer tracer{"property editor backend emit selection changed", category()};
+
     m_backendModelNode.emitSelectionChanged();
 }
 
 void PropertyEditorQmlBackend::setValueforLayoutAttachedProperties(const QmlObjectNode &qmlObjectNode,
                                                                    PropertyNameView name)
 {
+    NanotraceHR::Tracer tracer{"property editor backend set value for layout attached properties",
+                               category()};
+
     PropertyName propertyName = name.toByteArray();
     propertyName.replace("Layout.", "");
     setValue(qmlObjectNode, name, properDefaultLayoutAttachedProperties(qmlObjectNode, propertyName));
@@ -1083,6 +1181,9 @@ void PropertyEditorQmlBackend::setValueforLayoutAttachedProperties(const QmlObje
 void PropertyEditorQmlBackend::setValueforInsightAttachedProperties(const QmlObjectNode &qmlObjectNode,
                                                                     PropertyNameView name)
 {
+    NanotraceHR::Tracer tracer{"property editor backend set value for insight attached properties",
+                               category()};
+
     PropertyName propertyName = name.toByteArray();
     propertyName.replace("InsightCategory.", "");
     setValue(qmlObjectNode, name, properDefaultInsightAttachedProperties(qmlObjectNode, propertyName));
@@ -1091,6 +1192,9 @@ void PropertyEditorQmlBackend::setValueforInsightAttachedProperties(const QmlObj
 void PropertyEditorQmlBackend::setValueforAuxiliaryProperties(const QmlObjectNode &qmlObjectNode,
                                                               AuxiliaryDataKeyView key)
 {
+    NanotraceHR::Tracer tracer{"property editor backend set value for auxiliary properties",
+                               category()};
+
     const PropertyName propertyName = auxNamePostFix(key.name);
     setValue(qmlObjectNode, propertyName, qmlObjectNode.modelNode().auxiliaryDataWithDefault(key));
 }

src/plugins/qmldesigner/components/propertyeditor/propertyeditortracing.cpp

@@ -0,0 +1,26 @@
+// Copyright (C) 2025 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "propertyeditortracing.h"
+
+#include <tracing/qmldesignertracing.h>
+
+#include <sqlitebasestatement.h>
+
+namespace QmlDesigner::PropertyEditorTracing {
+using namespace NanotraceHR::Literals;
+namespace {
+
+thread_local Category category_{"model",
+                                Tracing::eventQueueWithStringArguments(),
+                                Tracing::eventQueueWithoutArguments(),
+                                category};
+
+} // namespace
+
+Category &category()
+{
+    return category_;
+}
+
+} // namespace QmlDesigner::PropertyEditorTracing

src/plugins/qmldesigner/components/propertyeditor/propertyeditortracing.h

@@ -0,0 +1,26 @@
+// Copyright (C) 2025 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include <qmldesignercomponents_global.h>
+
+#include <nanotrace/nanotracehr.h>
+
+#pragma once
+
+namespace QmlDesigner::PropertyEditorTracing {
+
+constexpr NanotraceHR::Tracing tracingStatus()
+{
+#ifdef ENABLE_PROPERTY_EDITOR_TRACING
+    return NanotraceHR::Tracing::IsEnabled;
+#else
+    return NanotraceHR::Tracing::IsDisabled;
+#endif
+}
+
+using Category = NanotraceHR::StringViewWithStringArgumentsCategory<tracingStatus()>;
+using SourceLocation = Category::SourceLocation;
+
+[[gnu::pure]] QMLDESIGNERCOMPONENTS_EXPORT Category &category();
+
+} // namespace QmlDesigner::PropertyEditorTracing

src/plugins/qmldesigner/components/propertyeditor/propertyeditortransaction.cpp

@@ -2,18 +2,26 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "propertyeditortransaction.h"
+
+#include "propertyeditortracing.h"
+
 #include <QTimerEvent>
 
 #include <QDebug>
 
 namespace QmlDesigner {
 
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 PropertyEditorTransaction::PropertyEditorTransaction(QmlDesigner::PropertyEditorView *propertyEditor) : QObject(propertyEditor), m_propertyEditor(propertyEditor), m_timerId(-1)
 {
+    NanotraceHR::Tracer tracer{"property editor transaction constructor", category()};
 }
 
 void PropertyEditorTransaction::start()
 {
+    NanotraceHR::Tracer tracer{"property editor transaction start", category()};
+
     if (!m_propertyEditor->model())
         return;
     if (m_rewriterTransaction.isValid())
@@ -24,6 +32,8 @@ void PropertyEditorTransaction::start()
 
 void PropertyEditorTransaction::end()
 {
+    NanotraceHR::Tracer tracer{"property editor transaction end", category()};
+
     if (m_rewriterTransaction.isValid() && m_propertyEditor->model()) {
         killTimer(m_timerId);
         m_rewriterTransaction.commit();
@@ -32,6 +42,8 @@ void PropertyEditorTransaction::end()
 
 bool PropertyEditorTransaction::active() const
 {
+    NanotraceHR::Tracer tracer{"property editor transaction active", category()};
+
     return m_rewriterTransaction.isValid();
 }
 
@@ -39,6 +51,9 @@ void PropertyEditorTransaction::timerEvent(QTimerEvent *timerEvent)
 {
     if (timerEvent->timerId() != m_timerId)
         return;
+
+    NanotraceHR::Tracer tracer{"property editor transaction timer event", category()};
+
     killTimer(timerEvent->timerId());
     if (m_rewriterTransaction.isValid())
         m_rewriterTransaction.commit();

src/plugins/qmldesigner/components/propertyeditor/propertyeditorutils.cpp

@@ -3,10 +3,14 @@
 
 #include "propertyeditorutils.h"
 
+#include "propertyeditortracing.h"
+
 namespace QmlDesigner {
 
 namespace PropertyEditorUtils {
 
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 #ifndef QDS_USE_PROJECTSTORAGE
 
 static bool checkIfUnkownTypeProperty(const std::vector<PropertyName> &propertyNames,
@@ -31,6 +35,8 @@ static bool checkIfUnkownTypeProperty(const std::vector<PropertyName> &propertyN
 
 PropertyMetaInfos filteredProperties(const NodeMetaInfo &metaInfo)
 {
+    NanotraceHR::Tracer tracer{"property editor utils filtered properties", category()};
+
     auto properties = metaInfo.properties();
 
 #ifndef QDS_USE_PROJECTSTORAGE

src/plugins/qmldesigner/components/propertyeditor/propertyeditorvalue.cpp

@@ -3,20 +3,22 @@
 
 #include "propertyeditorvalue.h"
 
-#include "abstractview.h"
+#include "propertyeditortracing.h"
-#include "bindingproperty.h"
-#include "createtexture.h"
-#include "designermcumanager.h"
-#include "designmodewidget.h"
-#include "nodemetainfo.h"
-#include "nodeproperty.h"
 #include "propertyeditorutils.h"
 #include "propertyeditorview.h"
-#include "qmldesignerplugin.h"
+
-#include "qmlitemnode.h"
+#include <abstractview.h>
-#include "qmlobjectnode.h"
+#include <bindingproperty.h>
-#include "rewritertransaction.h"
+#include <createtexture.h>
-#include "rewritingexception.h"
+#include <designermcumanager.h>
+#include <designmodewidget.h>
+#include <nodemetainfo.h>
+#include <nodeproperty.h>
+#include <qmldesignerplugin.h>
+#include <qmlitemnode.h>
+#include <qmlobjectnode.h>
+#include <rewritertransaction.h>
+#include <rewritingexception.h>
 
 #include <enumeration.h>
 #include <utils3d.h>
@@ -28,14 +30,19 @@
 
 namespace QmlDesigner {
 
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 PropertyEditorValue::PropertyEditorValue(QObject *parent)
     : QObject(parent),
       m_complexNode(new PropertyEditorNodeWrapper(this))
 {
+    NanotraceHR::Tracer tracer{"property editor value constructor", category()};
 }
 
 QVariant PropertyEditorValue::value() const
 {
+    NanotraceHR::Tracer tracer{"property editor value value", category()};
+
     QVariant returnValue = m_value;
     if (auto metaInfo = modelNode().metaInfo(); metaInfo.property(name()).propertyType().isUrl())
         returnValue = returnValue.toUrl().toString();
@@ -107,6 +114,8 @@ static bool compareVariants(const QVariant &value1, const QVariant &value2)
 
 void PropertyEditorValue::setValueWithEmit(const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{"property editor value set value with emit", category()};
+
     if (!compareVariants(value, m_value) || isBound()) {
         QVariant newValue = value;
         if (auto metaInfo = modelNode().metaInfo(); metaInfo.property(name()).propertyType().isUrl())
@@ -127,6 +136,8 @@ void PropertyEditorValue::setValueWithEmit(const QVariant &value)
 
 void PropertyEditorValue::setValue(const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{"property editor value set value", category()};
+
     const bool colorsEqual = cleverColorCompare(value, m_value);
 
     if (!compareVariants(m_value, value) && !cleverDoubleCompare(value, m_value) && !colorsEqual)
@@ -145,16 +156,22 @@ void PropertyEditorValue::setValue(const QVariant &value)
 
 QString PropertyEditorValue::enumeration() const
 {
+    NanotraceHR::Tracer tracer{"property editor value enumeration", category()};
+
     return m_value.value<Enumeration>().nameToString();
 }
 
 QString PropertyEditorValue::expression() const
 {
+    NanotraceHR::Tracer tracer{"property editor value expression", category()};
+
     return m_expression;
 }
 
 void PropertyEditorValue::setExpressionWithEmit(const QString &expression)
 {
+    NanotraceHR::Tracer tracer{"property editor value set expression with emit", category()};
+
     if (m_expression != expression) {
         setExpression(expression);
         m_value.clear();
@@ -166,7 +183,9 @@ void PropertyEditorValue::setExpressionWithEmit(const QString &expression)
 
 void PropertyEditorValue::setExpression(const QString &expression)
 {
-    if ( m_expression != expression) {
+    NanotraceHR::Tracer tracer{"property editor value set expression", category()};
+
+    if (m_expression != expression) {
         m_expression = expression;
         emit expressionChanged(QString());
     }
@@ -174,11 +193,15 @@ void PropertyEditorValue::setExpression(const QString &expression)
 
 QString PropertyEditorValue::valueToString() const
 {
+    NanotraceHR::Tracer tracer{"property editor value value to string", category()};
+
     return value().toString();
 }
 
 bool PropertyEditorValue::isInSubState() const
 {
+    NanotraceHR::Tracer tracer{"property editor value is in sub state", category()};
+
     const QmlObjectNode objectNode(modelNode());
     return objectNode.isValid() && objectNode.currentState().isValid()
            && objectNode.propertyAffectedByCurrentState(name());
@@ -186,42 +209,58 @@ bool PropertyEditorValue::isInSubState() const
 
 bool PropertyEditorValue::isBound() const
 {
+    NanotraceHR::Tracer tracer{"property editor value is bound", category()};
+
     const QmlObjectNode objectNode(modelNode());
     return m_forceBound || (objectNode.isValid() && objectNode.hasBindingProperty(name()));
 }
 
 bool PropertyEditorValue::isInModel() const
 {
+    NanotraceHR::Tracer tracer{"property editor value is in model", category()};
+
     return modelNode().hasProperty(name());
 }
 
 PropertyNameView PropertyEditorValue::name() const
 {
+    NanotraceHR::Tracer tracer{"property editor value name", category()};
+
     return m_name;
 }
 
 QString PropertyEditorValue::nameAsQString() const
 {
+    NanotraceHR::Tracer tracer{"property editor value name as QString", category()};
+
     return QString::fromUtf8(m_name);
 }
 
 void PropertyEditorValue::setName(PropertyNameView name)
 {
+    NanotraceHR::Tracer tracer{"property editor value set name", category()};
+
     m_name = name;
 }
 
 bool PropertyEditorValue::isValid() const
 {
+    NanotraceHR::Tracer tracer{"property editor value is valid", category()};
+
     return m_isValid;
 }
 
 void PropertyEditorValue::setIsValid(bool valid)
 {
+    NanotraceHR::Tracer tracer{"property editor value set is valid", category()};
+
     m_isValid = valid;
 }
 
 bool PropertyEditorValue::isTranslated() const
 {
+    NanotraceHR::Tracer tracer{"property editor value is translated", category()};
+
     if (modelNode().isValid()) {
         auto metaInfo = modelNode().metaInfo();
         auto isString = metaInfo.isValid() && metaInfo.hasProperty(name())
@@ -249,11 +288,15 @@ bool PropertyEditorValue::isTranslated() const
 
 bool PropertyEditorValue::hasActiveDrag() const
 {
+    NanotraceHR::Tracer tracer{"property editor value has active drag", category()};
+
     return m_hasActiveDrag;
 }
 
 void PropertyEditorValue::setHasActiveDrag(bool val)
 {
+    NanotraceHR::Tracer tracer{"property editor value set has active drag", category()};
+
     if (m_hasActiveDrag != val) {
         m_hasActiveDrag = val;
         emit hasActiveDragChanged();
@@ -272,6 +315,8 @@ static bool isAllowedSubclassType(const QString &type, const NodeMetaInfo &metaI
 
 bool PropertyEditorValue::isAvailable() const
 {
+    NanotraceHR::Tracer tracer{"property editor value is available", category()};
+
     if (!m_modelNode.isValid())
         return true;
 
@@ -322,11 +367,15 @@ bool PropertyEditorValue::isAvailable() const
 
 ModelNode PropertyEditorValue::modelNode() const
 {
+    NanotraceHR::Tracer tracer{"property editor value model node", category()};
+
     return m_modelNode;
 }
 
 void PropertyEditorValue::setModelNode(const ModelNode &modelNode)
 {
+    NanotraceHR::Tracer tracer{"property editor value set model node", category()};
+
     if (modelNode != m_modelNode) {
         m_modelNode = modelNode;
         m_complexNode->update();
@@ -336,11 +385,15 @@ void PropertyEditorValue::setModelNode(const ModelNode &modelNode)
 
 PropertyEditorNodeWrapper *PropertyEditorValue::complexNode()
 {
+    NanotraceHR::Tracer tracer{"property editor value complex node", category()};
+
     return m_complexNode;
 }
 
 void PropertyEditorValue::resetValue()
 {
+    NanotraceHR::Tracer tracer{"property editor value reset value", category()};
+
     if (m_value.isValid() || !m_expression.isEmpty() || isBound()) {
         m_value = QVariant();
         m_isBound = false;
@@ -353,6 +406,8 @@ void PropertyEditorValue::resetValue()
 
 void PropertyEditorValue::setEnumeration(const QString &scope, const QString &name)
 {
+    NanotraceHR::Tracer tracer{"property editor value set enumeration", category()};
+
     Enumeration newEnumeration(scope.toUtf8(), name.toUtf8());
 
     setValueWithEmit(QVariant::fromValue(newEnumeration));
@@ -360,11 +415,15 @@ void PropertyEditorValue::setEnumeration(const QString &scope, const QString &na
 
 void PropertyEditorValue::exportPropertyAsAlias()
 {
+    NanotraceHR::Tracer tracer{"property editor value export property as alias", category()};
+
     emit exportPropertyAsAliasRequested(nameAsQString());
 }
 
 bool PropertyEditorValue::hasPropertyAlias() const
 {
+    NanotraceHR::Tracer tracer{"property editor value has property alias", category()};
+
     if (!modelNode().isValid())
         return false;
 
@@ -387,16 +446,22 @@ bool PropertyEditorValue::hasPropertyAlias() const
 
 bool PropertyEditorValue::isAttachedProperty() const
 {
+    NanotraceHR::Tracer tracer{"property editor value is attached property", category()};
+
     return !nameAsQString().isEmpty() && nameAsQString().at(0).isUpper();
 }
 
 void PropertyEditorValue::removeAliasExport()
 {
+    NanotraceHR::Tracer tracer{"property editor value remove alias export", category()};
+
     emit removeAliasExportRequested(nameAsQString());
 }
 
 QString PropertyEditorValue::getTranslationContext() const
 {
+    NanotraceHR::Tracer tracer{"property editor value get translation context", category()};
+
     if (modelNode().isValid()) {
         if (auto metaInfo = modelNode().metaInfo();
             metaInfo.isValid() && metaInfo.hasProperty(name())
@@ -416,7 +481,10 @@ QString PropertyEditorValue::getTranslationContext() const
 
 bool PropertyEditorValue::isIdList() const
 {
-    if (modelNode().isValid() && modelNode().metaInfo().isValid() && modelNode().metaInfo().hasProperty(name())) {
+    NanotraceHR::Tracer tracer{"property editor value is id list", category()};
+
+    if (modelNode().isValid() && modelNode().metaInfo().isValid()
+        && modelNode().metaInfo().hasProperty(name())) {
         const QmlObjectNode objectNode(modelNode());
         if (objectNode.hasBindingProperty(name())) {
             static const QRegularExpression rx(QRegularExpression::anchoredPattern(
@@ -436,11 +504,15 @@ bool PropertyEditorValue::isIdList() const
 
 QStringList PropertyEditorValue::getExpressionAsList() const
 {
+    NanotraceHR::Tracer tracer{"property editor value get expression as list", category()};
+
     return generateStringList(expression());
 }
 
 QVector<double> PropertyEditorValue::getExpressionAsVector() const
 {
+    NanotraceHR::Tracer tracer{"property editor value get expression as vector", category()};
+
     const QRegularExpression rx(
         QRegularExpression::anchoredPattern("Qt.vector(2|3|4)d\\((.*?)\\)"));
     const QRegularExpressionMatch match = rx.match(expression());
@@ -469,6 +541,8 @@ QVector<double> PropertyEditorValue::getExpressionAsVector() const
 
 bool PropertyEditorValue::idListAdd(const QString &value)
 {
+    NanotraceHR::Tracer tracer{"property editor value id list add", category()};
+
     const QmlObjectNode objectNode(modelNode());
     if (!isIdList() && objectNode.isValid() && objectNode.hasProperty(name()))
         return false;
@@ -487,6 +561,8 @@ bool PropertyEditorValue::idListAdd(const QString &value)
 
 bool PropertyEditorValue::idListRemove(int idx)
 {
+    NanotraceHR::Tracer tracer{"property editor value id list remove", category()};
+
     QTC_ASSERT(isIdList(), return false);
 
     auto stringList = generateStringList(expression());
@@ -505,6 +581,8 @@ bool PropertyEditorValue::idListRemove(int idx)
 
 bool PropertyEditorValue::idListReplace(int idx, const QString &value)
 {
+    NanotraceHR::Tracer tracer{"property editor value id list replace", category()};
+
     QTC_ASSERT(isIdList(), return false);
 
     static const QRegularExpression rx(QRegularExpression::anchoredPattern(
@@ -525,6 +603,8 @@ bool PropertyEditorValue::idListReplace(int idx, const QString &value)
 
 void PropertyEditorValue::commitDrop(const QString &dropData)
 {
+    NanotraceHR::Tracer tracer{"property editor value commit drop", category()};
+
     if (m_modelNode.metaInfo().property(m_name).propertyType().isQtQuick3DTexture()) {
         m_modelNode.view()->executeInTransaction(__FUNCTION__, [&] {
             ModelNode texture = m_modelNode.view()->modelNodeForInternalId(dropData.toInt());
@@ -548,6 +628,8 @@ void PropertyEditorValue::commitDrop(const QString &dropData)
 
 void PropertyEditorValue::editMaterial(int idx)
 {
+    NanotraceHR::Tracer tracer{"property editor value edit material", category()};
+
     if (ModelNode material = Utils3D::getMaterialOfModel(m_modelNode, idx)) {
         QmlDesignerPlugin::instance()->mainWidget()->showDockWidget("Properties", true);
         material.selectNode();
@@ -556,6 +638,8 @@ void PropertyEditorValue::editMaterial(int idx)
 
 void PropertyEditorValue::setForceBound(bool b)
 {
+    NanotraceHR::Tracer tracer{"property editor value set force bound", category()};
+
     if (m_forceBound == b)
         return;
     m_forceBound = b;
@@ -565,6 +649,8 @@ void PropertyEditorValue::setForceBound(bool b)
 
 void PropertyEditorValue::insertKeyframe()
 {
+    NanotraceHR::Tracer tracer{"property editor value insert keyframe", category()};
+
     if (!m_modelNode.isValid())
         return;
 
@@ -582,6 +668,8 @@ void PropertyEditorValue::insertKeyframe()
 
 QStringList PropertyEditorValue::generateStringList(const QString &string) const
 {
+    NanotraceHR::Tracer tracer{"property editor value generate string list", category()};
+
     QString copy = string;
     copy = copy.remove("[").remove("]");
 
@@ -594,6 +682,8 @@ QStringList PropertyEditorValue::generateStringList(const QString &string) const
 
 QString PropertyEditorValue::generateString(const QStringList &stringList) const
 {
+    NanotraceHR::Tracer tracer{"property editor value generate string", category()};
+
     if (stringList.size() > 1)
         return "[" + stringList.join(",") + "]";
     else if (stringList.isEmpty())
@@ -604,6 +694,8 @@ QString PropertyEditorValue::generateString(const QStringList &stringList) const
 
 void PropertyEditorValue::registerDeclarativeTypes()
 {
+    NanotraceHR::Tracer tracer{"property editor value register declarative types", category()};
+
     qmlRegisterType<PropertyEditorValue>("HelperWidgets", 2, 0, "PropertyEditorValue");
     qmlRegisterType<PropertyEditorNodeWrapper>("HelperWidgets", 2, 0, "PropertyEditorNodeWrapper");
     qmlRegisterType<QQmlPropertyMap>("HelperWidgets", 2, 0, "QQmlPropertyMap");
@@ -613,6 +705,8 @@ PropertyEditorNodeWrapper::PropertyEditorNodeWrapper(PropertyEditorValue *parent
     : QObject(parent),
       m_valuesPropertyMap(this)
 {
+    NanotraceHR::Tracer tracer{"property editor value node wrapper constructor", category()};
+
     m_editorValue = parent;
     connect(m_editorValue, &PropertyEditorValue::modelNodeChanged, this, &PropertyEditorNodeWrapper::update);
 }
@@ -620,35 +714,48 @@ PropertyEditorNodeWrapper::PropertyEditorNodeWrapper(PropertyEditorValue *parent
 PropertyEditorNodeWrapper::PropertyEditorNodeWrapper(QObject *parent)
     : QObject(parent)
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper constructor", category()};
 }
 
 bool PropertyEditorNodeWrapper::exists() const
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper exists", category()};
+
     return m_editorValue && m_editorValue->modelNode().isValid() && m_modelNode.isValid();
 }
 
 QString PropertyEditorNodeWrapper::type() const
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper type", category()};
+
     return m_modelNode.simplifiedTypeName();
 }
 
 ModelNode PropertyEditorNodeWrapper::parentModelNode() const
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper parent model node", category()};
+
     return m_editorValue->modelNode();
 }
 
 PropertyNameView PropertyEditorNodeWrapper::propertyName() const
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper property name", category()};
+
     return m_editorValue->name();
 }
 
 QQmlPropertyMap *PropertyEditorNodeWrapper::properties()
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper properties", category()};
+
     return &m_valuesPropertyMap;
 }
 
 void PropertyEditorNodeWrapper::add(const QString &type)
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper add", category()};
+
     TypeName propertyType = type.toUtf8();
 
     if ((m_editorValue && m_editorValue->modelNode().isValid())) {
@@ -683,6 +790,8 @@ void PropertyEditorNodeWrapper::add(const QString &type)
 
 void PropertyEditorNodeWrapper::remove()
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper remove", category()};
+
     if ((m_editorValue && m_editorValue->modelNode().isValid())) {
         QmlObjectNode(m_modelNode).destroy();
         m_editorValue->modelNode().removeProperty(m_editorValue->name());
@@ -701,6 +810,8 @@ void PropertyEditorNodeWrapper::remove()
 
 void PropertyEditorNodeWrapper::changeValue(const QString &propertyName)
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper change value", category()};
+
     const PropertyName name = propertyName.toUtf8();
 
     if (name.isNull())
@@ -718,6 +829,8 @@ void PropertyEditorNodeWrapper::changeValue(const QString &propertyName)
 
 void PropertyEditorNodeWrapper::setup()
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper setup", category()};
+
     Q_ASSERT(m_editorValue);
     Q_ASSERT(m_editorValue->modelNode().isValid());
 
@@ -748,6 +861,8 @@ void PropertyEditorNodeWrapper::setup()
 
 void PropertyEditorNodeWrapper::update()
 {
+    NanotraceHR::Tracer tracer{"property editor node wrapper update", category()};
+
     if (!m_editorValue || !m_editorValue->modelNode().isValid())
         return;
 
@@ -763,6 +878,8 @@ void PropertyEditorNodeWrapper::update()
 
 QQmlPropertyMap *PropertyEditorSubSelectionWrapper::properties()
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper properties", category()};
+
     return &m_valuesPropertyMap;
 }
 
@@ -778,6 +895,9 @@ void PropertyEditorSubSelectionWrapper::createPropertyEditorValue(const QmlObjec
                                                                   PropertyNameView name,
                                                                   const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper create property editor value",
+                               category()};
+
     Utils::SmallString propertyName = name.toByteArray();
     propertyName.replace('.', '_');
 
@@ -816,6 +936,9 @@ void PropertyEditorSubSelectionWrapper::createPropertyEditorValue(const QmlObjec
 
 void PropertyEditorSubSelectionWrapper::exportPropertyAsAlias(const QString &name)
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper export property as alias",
+                               category()};
+
     if (name.isNull())
         return;
 
@@ -831,6 +954,9 @@ void PropertyEditorSubSelectionWrapper::exportPropertyAsAlias(const QString &nam
 
 void PropertyEditorSubSelectionWrapper::removeAliasExport(const QString &name)
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper remove alias export",
+                               category()};
+
     if (name.isNull())
         return;
 
@@ -846,12 +972,16 @@ void PropertyEditorSubSelectionWrapper::removeAliasExport(const QString &name)
 
 bool PropertyEditorSubSelectionWrapper::locked() const
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper locked", category()};
+
     return m_locked;
 }
 
 PropertyEditorSubSelectionWrapper::PropertyEditorSubSelectionWrapper(const ModelNode &modelNode)
     : m_modelNode(modelNode)
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper constructor", category()};
+
     QmlObjectNode qmlObjectNode(modelNode);
 
     QTC_ASSERT(qmlObjectNode.isValid(), return );
@@ -867,11 +997,15 @@ PropertyEditorSubSelectionWrapper::PropertyEditorSubSelectionWrapper(const Model
 
 ModelNode PropertyEditorSubSelectionWrapper::modelNode() const
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper model node", category()};
+
     return m_modelNode;
 }
 
 void PropertyEditorSubSelectionWrapper::deleteModelNode()
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper delete model node", category()};
+
     QmlObjectNode objectNode(m_modelNode);
 
     view()->executeInTransaction("PropertyEditorView::changeExpression", [&] {
@@ -882,7 +1016,9 @@ void PropertyEditorSubSelectionWrapper::deleteModelNode()
 
 void PropertyEditorSubSelectionWrapper::changeValue(const QString &name)
 {
-    QTC_ASSERT(m_modelNode.isValid(), return );
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper change value", category()};
+
+    QTC_ASSERT(m_modelNode.isValid(), return);
 
     if (name.isNull())
         return;
@@ -919,6 +1055,9 @@ void PropertyEditorSubSelectionWrapper::changeValue(const QString &name)
 
 void PropertyEditorSubSelectionWrapper::setValueFromModel(PropertyNameView name, const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper set value from model",
+                               category()};
+
     m_locked = true;
 
     QmlObjectNode qmlObjectNode(m_modelNode);
@@ -934,6 +1073,8 @@ void PropertyEditorSubSelectionWrapper::setValueFromModel(PropertyNameView name,
 
 void PropertyEditorSubSelectionWrapper::resetValue(PropertyNameView name)
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper reset value", category()};
+
     auto propertyValue = qobject_cast<PropertyEditorValue *>(
         variantToQObject(m_valuesPropertyMap.value(QString::fromUtf8(name))));
     if (propertyValue)
@@ -942,12 +1083,17 @@ void PropertyEditorSubSelectionWrapper::resetValue(PropertyNameView name)
 
 bool PropertyEditorSubSelectionWrapper::isRelevantModelNode(const ModelNode &modelNode) const
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper is relevant model node",
+                               category()};
+
     QmlObjectNode objectNode(m_modelNode);
     return modelNode == m_modelNode || objectNode.propertyChangeForCurrentState() == modelNode;
 }
 
 void PropertyEditorSubSelectionWrapper::changeExpression(const QString &propertyName)
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper change expression", category()};
+
     PropertyName name = propertyName.toUtf8();
 
     QTC_ASSERT(m_modelNode.isValid(), return );
@@ -981,6 +1127,9 @@ void PropertyEditorSubSelectionWrapper::changeExpression(const QString &property
 
 void PropertyEditorSubSelectionWrapper::removePropertyFromModel(PropertyNameView propertyName)
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper remove property from model",
+                               category()};
+
     QTC_ASSERT(m_modelNode.isValid(), return );
 
     m_locked = true;
@@ -1000,6 +1149,9 @@ void PropertyEditorSubSelectionWrapper::removePropertyFromModel(PropertyNameView
 void PropertyEditorSubSelectionWrapper::commitVariantValueToModel(PropertyNameView propertyName,
                                                                   const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{
+        "property editor sub selection wrapper commit variant value to model", category()};
+
     QTC_ASSERT(m_modelNode.isValid(), return );
 
     try {
@@ -1016,6 +1168,7 @@ void PropertyEditorSubSelectionWrapper::commitVariantValueToModel(PropertyNameVi
 
 AbstractView *PropertyEditorSubSelectionWrapper::view() const
 {
+    NanotraceHR::Tracer tracer{"property editor sub selection wrapper view", category()};
     QTC_CHECK(m_modelNode.isValid());
 
     return m_modelNode.view();

src/plugins/qmldesigner/components/propertyeditor/propertyeditorview.cpp

@@ -4,6 +4,7 @@
 #include "propertyeditorview.h"
 
 #include "propertyeditorqmlbackend.h"
+#include "propertyeditortracing.h"
 #include "propertyeditortransaction.h"
 #include "propertyeditorvalue.h"
 #include "propertyeditorwidget.h"
@@ -50,6 +51,8 @@ enum {
 
 namespace QmlDesigner {
 
+static auto category = PropertyEditorTracing::category;
+
 constexpr QStringView quick3dImport{u"QtQuick3D"};
 
 static bool propertyIsAttachedLayoutProperty(PropertyNameView propertyName)
@@ -80,6 +83,8 @@ PropertyEditorView::PropertyEditorView(AsynchronousImageCache &imageCache,
     , m_propertyComponentGenerator{PropertyEditorQmlBackend::propertyEditorResourcesPath(), model()}
     , m_locked(false)
 {
+    NanotraceHR::Tracer tracer{"property editor view constructor", category()};
+
     m_qmlDir = PropertyEditorQmlBackend::propertyEditorResourcesPath();
 
     if (Utils::HostOsInfo::isMacHost())
@@ -101,11 +106,15 @@ PropertyEditorView::PropertyEditorView(AsynchronousImageCache &imageCache,
 
 PropertyEditorView::~PropertyEditorView()
 {
+    NanotraceHR::Tracer tracer{"property editor view destructor", category()};
+
     qDeleteAll(m_qmlBackendHash);
 }
 
 void PropertyEditorView::changeValue(const QString &name)
 {
+    NanotraceHR::Tracer tracer{"property editor view change value", category()};
+
     PropertyName propertyName = name.toUtf8();
 
     if (propertyName.isNull())
@@ -231,6 +240,8 @@ static bool isTrueFalseLiteral(const QString &expression)
 
 void PropertyEditorView::changeExpression(const QString &propertyName)
 {
+    NanotraceHR::Tracer tracer{"property editor view change expression", category()};
+
     PropertyName name = propertyName.toUtf8();
 
     if (name.isNull())
@@ -268,6 +279,8 @@ void PropertyEditorView::changeExpression(const QString &propertyName)
 
 void PropertyEditorView::exportPropertyAsAlias(const QString &name)
 {
+    NanotraceHR::Tracer tracer{"property editor view export property as alias", category()};
+
     if (name.isNull())
         return;
 
@@ -283,6 +296,8 @@ void PropertyEditorView::exportPropertyAsAlias(const QString &name)
 
 void PropertyEditorView::removeAliasExport(const QString &name)
 {
+    NanotraceHR::Tracer tracer{"property editor view remove alias export", category()};
+
     if (name.isNull())
         return;
 
@@ -298,21 +313,30 @@ void PropertyEditorView::removeAliasExport(const QString &name)
 
 bool PropertyEditorView::locked() const
 {
+    NanotraceHR::Tracer tracer{"property editor view locked", category()};
+
     return m_locked;
 }
 
 void PropertyEditorView::currentTimelineChanged(const ModelNode &)
 {
-    m_qmlBackEndForCurrentType->contextObject()->setHasActiveTimeline(QmlTimeline::hasActiveTimeline(this));
+    NanotraceHR::Tracer tracer{"property editor view current timeline changed", category()};
+
+    m_qmlBackEndForCurrentType->contextObject()->setHasActiveTimeline(
+        QmlTimeline::hasActiveTimeline(this));
 }
 
 void PropertyEditorView::refreshMetaInfos(const TypeIds &deletedTypeIds)
 {
+    NanotraceHR::Tracer tracer{"property editor view refresh meta infos", category()};
+
     m_propertyComponentGenerator.refreshMetaInfos(deletedTypeIds);
 }
 
 DynamicPropertiesModel *PropertyEditorView::dynamicPropertiesModel() const
 {
+    NanotraceHR::Tracer tracer{"property editor view dynamic properties model", category()};
+
     return m_dynamicPropertiesModel.get();
 }
 
@@ -320,6 +344,8 @@ void PropertyEditorView::setExpressionOnObjectNode(const QmlObjectNode &constObj
                                                    PropertyNameView name,
                                                    const QString &newExpression)
 {
+    NanotraceHR::Tracer tracer{"property editor view set expression on object node", category()};
+
     auto qmlObjectNode = constObjectNode;
     auto expression = newExpression;
     if (auto property = qmlObjectNode.modelNode().metaInfo().property(name)) {
@@ -374,7 +400,9 @@ void PropertyEditorView::setExpressionOnObjectNode(const QmlObjectNode &constObj
 
 void PropertyEditorView::generateAliasForProperty(const ModelNode &modelNode, const QString &name)
 {
-    QTC_ASSERT(modelNode.isValid(), return );
+    NanotraceHR::Tracer tracer{"property editor view generate alias for property", category()};
+
+    QTC_ASSERT(modelNode.isValid(), return);
 
     auto view = modelNode.view();
 
@@ -400,7 +428,9 @@ void PropertyEditorView::generateAliasForProperty(const ModelNode &modelNode, co
 
 void PropertyEditorView::removeAliasForProperty(const ModelNode &modelNode, const QString &propertyName)
 {
-    QTC_ASSERT(modelNode.isValid(), return );
+    NanotraceHR::Tracer tracer{"property editor view remove alias for property", category()};
+
+    QTC_ASSERT(modelNode.isValid(), return);
 
     auto view = modelNode.view();
 
@@ -420,6 +450,8 @@ void PropertyEditorView::removeAliasForProperty(const ModelNode &modelNode, cons
 
 PropertyEditorView *PropertyEditorView::instance()
 {
+    NanotraceHR::Tracer tracer{"property editor view instance", category()};
+
     static PropertyEditorView *s_instance = nullptr;
 
     if (s_instance)
@@ -438,6 +470,8 @@ PropertyEditorView *PropertyEditorView::instance()
 
 NodeMetaInfo PropertyEditorView::findCommonAncestor(const ModelNode &node)
 {
+    NanotraceHR::Tracer tracer{"property editor view find common ancestor", category()};
+
     if (!node.isValid())
         return node.metaInfo();
 
@@ -458,6 +492,8 @@ NodeMetaInfo PropertyEditorView::findCommonAncestor(const ModelNode &node)
 
 void PropertyEditorView::updateSize()
 {
+    NanotraceHR::Tracer tracer{"property editor view update size", category()};
+
     if (!m_qmlBackEndForCurrentType)
         return;
     auto frame = m_qmlBackEndForCurrentType->widget()->findChild<QWidget *>("propertyEditorFrame");
@@ -467,6 +503,8 @@ void PropertyEditorView::updateSize()
 
 void PropertyEditorView::resetView()
 {
+    NanotraceHR::Tracer tracer{"property editor view reset view", category()};
+
     if (model() == nullptr)
         return;
 
@@ -498,6 +536,8 @@ void PropertyEditorView::resetView()
 
 void PropertyEditorView::setIsSelectionLocked(bool locked)
 {
+    NanotraceHR::Tracer tracer{"property editor view set is selection locked", category()};
+
     if (m_isSelectionLocked != locked) {
         m_isSelectionLocked = locked;
         for (PropertyEditorQmlBackend *qmlBackend : std::as_const(m_qmlBackendHash))
@@ -555,6 +595,8 @@ PropertyEditorQmlBackend *getQmlBackend(QHash<QString, PropertyEditorQmlBackend
                                         PropertyEditorWidget *stackedWidget,
                                         PropertyEditorView *propertyEditorView)
 {
+    NanotraceHR::Tracer tracer{"property editor view get Qml Backend", category()};
+
     auto qmlFileName = qmlFileUrl.toString();
     PropertyEditorQmlBackend *currentQmlBackend = qmlBackendHash.value(qmlFileName);
 
@@ -649,6 +691,8 @@ void setupWidget(PropertyEditorQmlBackend *currentQmlBackend,
 
 void PropertyEditorView::handleToolBarAction(int action)
 {
+    NanotraceHR::Tracer tracer{"property editor view handle toolbar action", category()};
+
     switch (action) {
     case PropertyEditorContextObject::SelectionLock: {
         setIsSelectionLocked(true);
@@ -663,6 +707,8 @@ void PropertyEditorView::handleToolBarAction(int action)
 
 void PropertyEditorView::setupQmlBackend()
 {
+    NanotraceHR::Tracer tracer{"property editor view setup Qml Backend", category()};
+
 #ifdef QDS_USE_PROJECTSTORAGE
     const NodeMetaInfo commonAncestor = findCommonAncestor(activeNode());
     auto selfAndPrototypes = commonAncestor.selfAndPrototypes();
@@ -740,6 +786,8 @@ void PropertyEditorView::setupQmlBackend()
 
 void PropertyEditorView::commitVariantValueToModel(PropertyNameView propertyName, const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{"property editor view commit variant value to model", category()};
+
     m_locked = true;
     try {
         RewriterTransaction transaction = beginRewriterTransaction("PropertyEditorView::commitVariantValueToMode");
@@ -759,6 +807,8 @@ void PropertyEditorView::commitVariantValueToModel(PropertyNameView propertyName
 
 void PropertyEditorView::commitAuxValueToModel(PropertyNameView propertyName, const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{"property editor view commit aux value to model", category()};
+
     m_locked = true;
 
     PropertyNameView name = propertyName;
@@ -782,6 +832,8 @@ void PropertyEditorView::commitAuxValueToModel(PropertyNameView propertyName, co
 
 void PropertyEditorView::removePropertyFromModel(PropertyNameView propertyName)
 {
+    NanotraceHR::Tracer tracer{"property editor view remove property from model", category()};
+
     m_locked = true;
     try {
         RewriterTransaction transaction = beginRewriterTransaction("PropertyEditorView::removePropertyFromModel");
@@ -802,22 +854,30 @@ void PropertyEditorView::removePropertyFromModel(PropertyNameView propertyName)
 
 bool PropertyEditorView::noValidSelection() const
 {
+    NanotraceHR::Tracer tracer{"property editor view no valid selection", category()};
+
     QTC_ASSERT(m_qmlBackEndForCurrentType, return true);
     return !QmlObjectNode::isValidQmlObjectNode(activeNode());
 }
 
 ModelNode PropertyEditorView::activeNode() const
 {
+    NanotraceHR::Tracer tracer{"property editor view active node", category()};
+
     return m_activeNode;
 }
 
 void PropertyEditorView::setActiveNode(const ModelNode &node)
 {
+    NanotraceHR::Tracer tracer{"property editor view set active node", category()};
+
     m_activeNode = node;
 }
 
 QList<ModelNode> PropertyEditorView::currentNodes() const
 {
+    NanotraceHR::Tracer tracer{"property editor view current nodes", category()};
+
     if (m_isSelectionLocked)
         return {m_activeNode};
 
@@ -827,6 +887,8 @@ QList<ModelNode> PropertyEditorView::currentNodes() const
 void PropertyEditorView::selectedNodesChanged(const QList<ModelNode> &,
                                           const QList<ModelNode> &)
 {
+    NanotraceHR::Tracer tracer{"property editor view selected nodes changed", category()};
+
     if (!m_isSelectionLocked)
         select();
 
@@ -837,6 +899,8 @@ void PropertyEditorView::selectedNodesChanged(const QList<ModelNode> &,
 
 bool PropertyEditorView::isNodeOrChildSelected(const ModelNode &node) const
 {
+    NanotraceHR::Tracer tracer{"property editor view is node or child selected", category()};
+
     if (activeNode().isValid() && node.isValid()) {
         const ModelNodes &nodeList = node.allSubModelNodesAndThisNode();
         return nodeList.contains(activeNode());
@@ -846,12 +910,16 @@ bool PropertyEditorView::isNodeOrChildSelected(const ModelNode &node) const
 
 void PropertyEditorView::resetSelectionLocked()
 {
+    NanotraceHR::Tracer tracer{"property editor view reset selection locked", category()};
+
     if (m_isSelectionLocked)
         setIsSelectionLocked(false);
 }
 
 void PropertyEditorView::resetIfNodeIsRemoved(const ModelNode &removedNode)
 {
+    NanotraceHR::Tracer tracer{"property editor view reset if node is removed", category()};
+
     if (isNodeOrChildSelected(removedNode)) {
         resetSelectionLocked();
         select();
@@ -860,6 +928,8 @@ void PropertyEditorView::resetIfNodeIsRemoved(const ModelNode &removedNode)
 
 void PropertyEditorView::nodeAboutToBeRemoved(const ModelNode &removedNode)
 {
+    NanotraceHR::Tracer tracer{"property editor view node about to be removed", category()};
+
     resetIfNodeIsRemoved(removedNode);
 
     const ModelNodes &allRemovedNodes = removedNode.allSubModelNodesAndThisNode();
@@ -880,6 +950,8 @@ void PropertyEditorView::nodeAboutToBeRemoved(const ModelNode &removedNode)
 
 void PropertyEditorView::nodeRemoved(const ModelNode &, const NodeAbstractProperty &, PropertyChangeFlags)
 {
+    NanotraceHR::Tracer tracer{"property editor view node removed", category()};
+
     if (m_qmlBackEndForCurrentType && m_textureAboutToBeRemoved)
         m_qmlBackEndForCurrentType->refreshBackendModel();
 
@@ -888,6 +960,8 @@ void PropertyEditorView::nodeRemoved(const ModelNode &, const NodeAbstractProper
 
 void PropertyEditorView::modelAttached(Model *model)
 {
+    NanotraceHR::Tracer tracer{"property editor view model attached", category()};
+
     AbstractView::modelAttached(model);
 
     if constexpr (useProjectStorage())
@@ -902,6 +976,8 @@ void PropertyEditorView::modelAttached(Model *model)
 
 void PropertyEditorView::modelAboutToBeDetached(Model *model)
 {
+    NanotraceHR::Tracer tracer{"property editor view model about to be detached", category()};
+
     AbstractView::modelAboutToBeDetached(model);
     m_qmlBackEndForCurrentType->propertyEditorTransaction()->end();
 
@@ -911,6 +987,8 @@ void PropertyEditorView::modelAboutToBeDetached(Model *model)
 
 void PropertyEditorView::propertiesRemoved(const QList<AbstractProperty> &propertyList)
 {
+    NanotraceHR::Tracer tracer{"property editor view properties removed", category()};
+
     if (noValidSelection())
         return;
 
@@ -985,12 +1063,16 @@ void PropertyEditorView::propertiesRemoved(const QList<AbstractProperty> &proper
 
 void PropertyEditorView::propertiesAboutToBeRemoved(const QList<AbstractProperty> &propertyList)
 {
+    NanotraceHR::Tracer tracer{"property editor view properties about to be removed", category()};
+
     for (const auto &property : propertyList)
         m_dynamicPropertiesModel->removeItem(property);
 }
 
 void PropertyEditorView::variantPropertiesChanged(const QList<VariantProperty>& propertyList, PropertyChangeFlags /*propertyChange*/)
 {
+    NanotraceHR::Tracer tracer{"property editor view variant properties changed", category()};
+
     if (noValidSelection())
         return;
 
@@ -1042,6 +1124,8 @@ void PropertyEditorView::variantPropertiesChanged(const QList<VariantProperty>&
 void PropertyEditorView::bindingPropertiesChanged(const QList<BindingProperty> &propertyList,
                                                   PropertyChangeFlags /*propertyChange*/)
 {
+    NanotraceHR::Tracer tracer{"property editor view binding properties changed", category()};
+
     if (noValidSelection())
         return;
 
@@ -1085,6 +1169,8 @@ void PropertyEditorView::auxiliaryDataChanged(const ModelNode &node,
                                               [[maybe_unused]] AuxiliaryDataKeyView key,
                                               const QVariant &data)
 {
+    NanotraceHR::Tracer tracer{"property editor view auxiliary data changed", category()};
+
     if (noValidSelection())
         return;
 
@@ -1114,12 +1200,17 @@ void PropertyEditorView::auxiliaryDataChanged(const ModelNode &node,
 void PropertyEditorView::signalDeclarationPropertiesChanged(
     const QVector<SignalDeclarationProperty> &propertyList, PropertyChangeFlags /* propertyChange */)
 {
+    NanotraceHR::Tracer tracer{"property editor view signal declaration properties changed",
+                               category()};
+
     for (const SignalDeclarationProperty &property : propertyList)
         m_dynamicPropertiesModel->updateItem(property);
 }
 
 void PropertyEditorView::instanceInformationsChanged(const QMultiHash<ModelNode, InformationName> &informationChangedHash)
 {
+    NanotraceHR::Tracer tracer{"property editor view instance informations changed", category()};
+
     if (noValidSelection())
         return;
 
@@ -1133,6 +1224,8 @@ void PropertyEditorView::instanceInformationsChanged(const QMultiHash<ModelNode,
 
 void PropertyEditorView::nodeIdChanged(const ModelNode &node, const QString &newId, const QString &oldId)
 {
+    NanotraceHR::Tracer tracer{"property editor view node id changed", category()};
+
     if (noValidSelection())
         return;
 
@@ -1156,6 +1249,8 @@ void PropertyEditorView::nodeIdChanged(const ModelNode &node, const QString &new
 
 void PropertyEditorView::select()
 {
+    NanotraceHR::Tracer tracer{"property editor view select", category()};
+
     if (m_qmlBackEndForCurrentType)
         m_qmlBackEndForCurrentType->emitSelectionToBeChanged();
 
@@ -1164,6 +1259,8 @@ void PropertyEditorView::select()
 
 void PropertyEditorView::setActiveNodeToSelection()
 {
+    NanotraceHR::Tracer tracer{"property editor view set active node to selection", category()};
+
     const auto selectedNodeList = currentNodes();
 
     setActiveNode(ModelNode());
@@ -1179,6 +1276,8 @@ void PropertyEditorView::setActiveNodeToSelection()
 
 void PropertyEditorView::forceSelection(const ModelNode &node)
 {
+    NanotraceHR::Tracer tracer{"property editor view force selection", category()};
+
     if (node == activeNode())
         return;
 
@@ -1191,11 +1290,15 @@ void PropertyEditorView::forceSelection(const ModelNode &node)
 
 bool PropertyEditorView::hasWidget() const
 {
+    NanotraceHR::Tracer tracer{"property editor view has widget", category()};
+
     return true;
 }
 
 WidgetInfo PropertyEditorView::widgetInfo()
 {
+    NanotraceHR::Tracer tracer{"property editor view widget info", category()};
+
     return createWidgetInfo(m_stackedWidget,
                             QStringLiteral("Properties"),
                             WidgetInfo::RightPane,
@@ -1205,6 +1308,8 @@ WidgetInfo PropertyEditorView::widgetInfo()
 
 void PropertyEditorView::currentStateChanged(const ModelNode &node)
 {
+    NanotraceHR::Tracer tracer{"property editor view current state changed", category()};
+
     QmlModelState newQmlModelState(node);
     Q_ASSERT(newQmlModelState.isValid());
     if (debug)
@@ -1214,6 +1319,8 @@ void PropertyEditorView::currentStateChanged(const ModelNode &node)
 
 void PropertyEditorView::instancePropertyChanged(const QList<QPair<ModelNode, PropertyName> > &propertyList)
 {
+    NanotraceHR::Tracer tracer{"property editor view instance property changed", category()};
+
     if (!activeNode().isValid())
         return;
 
@@ -1251,11 +1358,15 @@ void PropertyEditorView::instancePropertyChanged(const QList<QPair<ModelNode, Pr
 
 void PropertyEditorView::rootNodeTypeChanged(const QString &/*type*/, int /*majorVersion*/, int /*minorVersion*/)
 {
+    NanotraceHR::Tracer tracer{"property editor view root node type changed", category()};
+
     resetView();
 }
 
 void PropertyEditorView::nodeTypeChanged(const ModelNode &node, const TypeName &, int, int)
 {
+    NanotraceHR::Tracer tracer{"property editor view node type changed", category()};
+
     if (node == activeNode())
         resetView();
 }
@@ -1265,6 +1376,8 @@ void PropertyEditorView::nodeReparented(const ModelNode &node,
                                         const NodeAbstractProperty & /*oldPropertyParent*/,
                                         AbstractView::PropertyChangeFlags /*propertyChange*/)
 {
+    NanotraceHR::Tracer tracer{"property editor view node reparented", category()};
+
     if (node == activeNode())
         m_qmlBackEndForCurrentType->backendAnchorBinding().setup(QmlItemNode(activeNode()));
 
@@ -1285,6 +1398,8 @@ void PropertyEditorView::nodeReparented(const ModelNode &node,
 
 void PropertyEditorView::importsChanged(const Imports &addedImports, const Imports &removedImports)
 {
+    NanotraceHR::Tracer tracer{"property editor view imports changed", category()};
+
     if (!m_qmlBackEndForCurrentType)
         return;
 
@@ -1299,6 +1414,8 @@ void PropertyEditorView::customNotification([[maybe_unused]] const AbstractView
                                             const QList<ModelNode> &nodeList,
                                             [[maybe_unused]] const QList<QVariant> &data)
 {
+    NanotraceHR::Tracer tracer{"property editor view custom notification", category()};
+
     if (identifier == "force_editing_node") {
         if (!nodeList.isEmpty())
             forceSelection(nodeList.first());
@@ -1309,6 +1426,8 @@ void PropertyEditorView::modelNodePreviewPixmapChanged(const ModelNode &node,
                                                        const QPixmap &pixmap,
                                                        const QByteArray &requestId)
 {
+    NanotraceHR::Tracer tracer{"property editor view model node preview pixmap changed", category()};
+
     if (node != activeNode())
         return;
 
@@ -1318,6 +1437,8 @@ void PropertyEditorView::modelNodePreviewPixmapChanged(const ModelNode &node,
 
 void PropertyEditorView::highlightTextureProperties(bool highlight)
 {
+    NanotraceHR::Tracer tracer{"property editor view highlight texture properties", category()};
+
     NodeMetaInfo metaInfo = activeNode().metaInfo();
     QTC_ASSERT(metaInfo.isValid(), return);
 
@@ -1334,6 +1455,8 @@ void PropertyEditorView::highlightTextureProperties(bool highlight)
 
 void PropertyEditorView::dragStarted(QMimeData *mimeData)
 {
+    NanotraceHR::Tracer tracer{"property editor view drag started", category()};
+
     if (mimeData->hasFormat(Constants::MIME_TYPE_ASSETS)) {
         const QString assetPath = QString::fromUtf8(mimeData->data(Constants::MIME_TYPE_ASSETS))
                                       .split(',')[0];
@@ -1354,6 +1477,8 @@ void PropertyEditorView::dragStarted(QMimeData *mimeData)
 
 void PropertyEditorView::dragEnded()
 {
+    NanotraceHR::Tracer tracer{"property editor view drag ended", category()};
+
     m_qmlBackEndForCurrentType->contextObject()->setActiveDragSuffix("");
     highlightTextureProperties(false);
 }
@@ -1362,6 +1487,8 @@ void PropertyEditorView::setValue(const QmlObjectNode &qmlObjectNode,
                                   PropertyNameView name,
                                   const QVariant &value)
 {
+    NanotraceHR::Tracer tracer{"property editor view set value", category()};
+
     m_locked = true;
     m_qmlBackEndForCurrentType->setValue(qmlObjectNode, name, value);
     m_locked = false;
@@ -1369,6 +1496,8 @@ void PropertyEditorView::setValue(const QmlObjectNode &qmlObjectNode,
 
 bool PropertyEditorView::eventFilter(QObject *obj, QEvent *event)
 {
+    NanotraceHR::Tracer tracer{"property editor view event filter", category()};
+
     if (event->type() == QEvent::FocusOut) {
         if (m_qmlBackEndForCurrentType && m_qmlBackEndForCurrentType->widget() == obj)
             QMetaObject::invokeMethod(m_qmlBackEndForCurrentType->widget()->rootObject(), "closeContextMenu");
@@ -1378,6 +1507,8 @@ bool PropertyEditorView::eventFilter(QObject *obj, QEvent *event)
 
 void PropertyEditorView::reloadQml()
 {
+    NanotraceHR::Tracer tracer{"property editor view reload Qml", category()};
+
     m_qmlBackendHash.clear();
     while (QWidget *widget = m_stackedWidget->widget(0)) {
         m_stackedWidget->removeWidget(widget);

src/plugins/qmldesigner/components/propertyeditor/propertyeditorwidget.cpp

@@ -3,18 +3,26 @@
 
 #include "propertyeditorwidget.h"
 
+#include "propertyeditortracing.h"
+
 #include <qmldesignerconstants.h>
 #include <qmldesignerplugin.h>
 
 namespace QmlDesigner {
 
+static auto category = PropertyEditorTracing::category;
+
 PropertyEditorWidget::PropertyEditorWidget(QWidget *parent) : QStackedWidget(parent)
 {
+    NanotraceHR::Tracer tracer{"property editor widget constructor", category()};
+
     QmlDesignerPlugin::trackWidgetFocusTime(this, Constants::EVENT_PROPERTYEDITOR_TIME);
 }
 
 void PropertyEditorWidget::resizeEvent(QResizeEvent * event)
 {
+    NanotraceHR::Tracer tracer{"property editor widget resize event", category()};
+
     QStackedWidget::resizeEvent(event);
     emit resized();
 }

src/plugins/qmldesigner/components/propertyeditor/propertynamevalidator.cpp

@@ -3,16 +3,24 @@
 
 #include "propertynamevalidator.h"
 
-#include "modelutils.h"
+#include "propertyeditortracing.h"
+
+#include <modelutils.h>
 
 #include <QRegularExpression>
 
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 PropertyNameValidator::PropertyNameValidator(QObject *parent)
     : QValidator(parent)
-{}
+{
+    NanotraceHR::Tracer tracer{"property name validator constructor", category()};
+}
 
 QValidator::State PropertyNameValidator::validate(QString &input, int &) const
 {
+    NanotraceHR::Tracer tracer{"property name validator validate", category()};
+
     if (input.isEmpty())
         return QValidator::Intermediate;
 
@@ -32,5 +40,7 @@ QValidator::State PropertyNameValidator::validate(QString &input, int &) const
 
 void PropertyNameValidator::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"property name validator register declarative type", category()};
+
     qmlRegisterType<PropertyNameValidator>("HelperWidgets", 2, 0, "PropertyNameValidator");
 }

src/plugins/qmldesigner/components/propertyeditor/qmlanchorbindingproxy.cpp

@@ -3,6 +3,8 @@
 
 #include "qmlanchorbindingproxy.h"
 
+#include "propertyeditortracing.h"
+
 #include <abstractview.h>
 #include <exception.h>
 #include <modelnodeoperations.h>
@@ -22,6 +24,9 @@ class ModelNode;
 class NodeState;
 
 namespace {
+
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 const Utils::SmallString auxDataString("anchors_");
 
 Utils::SmallString auxPropertyString(Utils::SmallStringView name)
@@ -47,12 +52,18 @@ QmlAnchorBindingProxy::QmlAnchorBindingProxy(QObject *parent) :
     m_relativeVerticalTarget(Center), m_relativeHorizontalTarget(Center),
     m_locked(false), m_ignoreQml(false)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy constructor", category()};
 }
 
-QmlAnchorBindingProxy::~QmlAnchorBindingProxy() = default;
+QmlAnchorBindingProxy::~QmlAnchorBindingProxy()
+{
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy destructor", category()};
+}
 
 void QmlAnchorBindingProxy::setup(const QmlItemNode &fxItemNode)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy setup", category()};
+
     m_qmlItemNode = fxItemNode;
 
     m_ignoreQml = true;
@@ -80,6 +91,8 @@ void QmlAnchorBindingProxy::setup(const QmlItemNode &fxItemNode)
 
 void QmlAnchorBindingProxy::invalidate(const QmlItemNode &fxItemNode)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy invalidate", category()};
+
     if (m_locked)
         return;
 
@@ -92,13 +105,8 @@ void QmlAnchorBindingProxy::invalidate(const QmlItemNode &fxItemNode)
         return node.modelNode().parentProperty().parentModelNode();
     };
 
-    m_verticalTarget =
+    m_verticalTarget = m_horizontalTarget = m_topTarget = m_bottomTarget = m_leftTarget = m_rightTarget = parentModelNode(
-            m_horizontalTarget =
+        m_qmlItemNode);
-            m_topTarget =
-            m_bottomTarget =
-            m_leftTarget =
-            m_rightTarget =
-            parentModelNode(m_qmlItemNode);
 
     setupAnchorTargets();
 
@@ -121,6 +129,8 @@ void QmlAnchorBindingProxy::invalidate(const QmlItemNode &fxItemNode)
 
 void QmlAnchorBindingProxy::setupAnchorTargets()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy setup anchor targets", category()};
+
     if (m_qmlItemNode.modelNode().hasParentProperty())
         setDefaultAnchorTarget(m_qmlItemNode.modelNode().parentProperty().parentModelNode());
     else
@@ -209,7 +219,9 @@ void QmlAnchorBindingProxy::setupAnchorTargets()
     }
 
     if (horizontalCentered()) {
-        ModelNode targetNode = m_qmlItemNode.anchors().instanceAnchor(AnchorLineHorizontalCenter).qmlItemNode();
+        ModelNode targetNode = m_qmlItemNode.anchors()
+                                   .instanceAnchor(AnchorLineHorizontalCenter)
+                                   .qmlItemNode();
         if (targetNode.isValid())
             m_horizontalTarget = targetNode;
     }
@@ -217,6 +229,8 @@ void QmlAnchorBindingProxy::setupAnchorTargets()
 
 void QmlAnchorBindingProxy::emitAnchorSignals()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy emit anchor signals", category()};
+
     emit topAnchorChanged();
     emit bottomAnchorChanged();
     emit leftAnchorChanged();
@@ -233,6 +247,8 @@ void QmlAnchorBindingProxy::emitAnchorSignals()
 
 void QmlAnchorBindingProxy::setDefaultRelativeTopTarget()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set default relative top target", category()};
+
     if (m_topTarget.modelNode() == m_qmlItemNode.modelNode().parentProperty().parentModelNode()) {
         m_relativeTopTarget = SameEdge;
     } else {
@@ -242,6 +258,9 @@ void QmlAnchorBindingProxy::setDefaultRelativeTopTarget()
 
 void QmlAnchorBindingProxy::setDefaultRelativeBottomTarget()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set default relative bottom target",
+                               category()};
+
     if (m_bottomTarget.modelNode() == m_qmlItemNode.modelNode().parentProperty().parentModelNode()) {
         m_relativeBottomTarget = SameEdge;
     } else {
@@ -251,6 +270,9 @@ void QmlAnchorBindingProxy::setDefaultRelativeBottomTarget()
 
 void QmlAnchorBindingProxy::setDefaultRelativeLeftTarget()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set default relative left target",
+                               category()};
+
     if (m_leftTarget.modelNode() == m_qmlItemNode.modelNode().parentProperty().parentModelNode()) {
         m_relativeLeftTarget = SameEdge;
     } else {
@@ -260,6 +282,9 @@ void QmlAnchorBindingProxy::setDefaultRelativeLeftTarget()
 
 void QmlAnchorBindingProxy::setDefaultRelativeRightTarget()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set default relative right target",
+                               category()};
+
     if (m_rightTarget.modelNode() == m_qmlItemNode.modelNode().parentProperty().parentModelNode()) {
         m_relativeRightTarget = SameEdge;
     } else {
@@ -267,23 +292,32 @@ void QmlAnchorBindingProxy::setDefaultRelativeRightTarget()
     }
 }
 
-bool QmlAnchorBindingProxy::executeInTransaction(const QByteArray &identifier, const AbstractView::OperationBlock &lambda)
+bool QmlAnchorBindingProxy::executeInTransaction(const QByteArray &identifier,
+                                                 const AbstractView::OperationBlock &lambda)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy execute in transaction", category()};
+
     return m_qmlItemNode.modelNode().view()->executeInTransaction(identifier, lambda);
 }
 
 bool QmlAnchorBindingProxy::hasParent() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy has parent", category()};
+
     return m_qmlItemNode.hasNodeParent();
 }
 
 bool QmlAnchorBindingProxy::isInLayout() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy is in layout", category()};
+
     return m_qmlItemNode.isInLayout();
 }
 
 bool QmlAnchorBindingProxy::isFilled() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy is filled", category()};
+
     return hasAnchors() && topAnchored() && bottomAnchored() && leftAnchored() && rightAnchored()
            && (m_qmlItemNode.instanceValue("anchors.topMargin").toInt() == 0)
            && (m_qmlItemNode.instanceValue("anchors.bottomMargin").toInt() == 0)
@@ -293,32 +327,42 @@ bool QmlAnchorBindingProxy::isFilled() const
 
 bool QmlAnchorBindingProxy::topAnchored() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy top anchored", category()};
+
     return m_qmlItemNode.anchors().instanceHasAnchor(AnchorLineTop);
 }
 
 bool QmlAnchorBindingProxy::bottomAnchored() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy bottom anchored", category()};
+
     return m_qmlItemNode.anchors().instanceHasAnchor(AnchorLineBottom);
 }
 
 bool QmlAnchorBindingProxy::leftAnchored() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy left anchored", category()};
+
     return m_qmlItemNode.anchors().instanceHasAnchor(AnchorLineLeft);
 }
 
 bool QmlAnchorBindingProxy::rightAnchored() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy right anchored", category()};
+
     return m_qmlItemNode.anchors().instanceHasAnchor(AnchorLineRight);
 }
 
 bool QmlAnchorBindingProxy::hasAnchors() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy has anchors", category()};
+
     return m_qmlItemNode.anchors().instanceHasAnchors();
 }
 
-
 void QmlAnchorBindingProxy::setTopTarget(const QString &target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set top target", category()};
 
     if (m_ignoreQml)
         return;
@@ -331,7 +375,7 @@ void QmlAnchorBindingProxy::setTopTarget(const QString &target)
     if (!newTarget.isValid())
         return;
 
-    executeInTransaction("QmlAnchorBindingProxy::setTopTarget", [this, newTarget](){
+    executeInTransaction("QmlAnchorBindingProxy::setTopTarget", [this, newTarget]() {
         m_topTarget = newTarget;
         setDefaultRelativeTopTarget();
         anchorTop();
@@ -340,9 +384,10 @@ void QmlAnchorBindingProxy::setTopTarget(const QString &target)
     emit topTargetChanged();
 }
 
-
 void QmlAnchorBindingProxy::setBottomTarget(const QString &target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set bottom target", category()};
+
     if (m_ignoreQml)
         return;
 
@@ -354,11 +399,10 @@ void QmlAnchorBindingProxy::setBottomTarget(const QString &target)
     if (!newTarget.isValid())
         return;
 
-    executeInTransaction("QmlAnchorBindingProxy::setBottomTarget", [this, newTarget](){
+    executeInTransaction("QmlAnchorBindingProxy::setBottomTarget", [this, newTarget]() {
         m_bottomTarget = newTarget;
         setDefaultRelativeBottomTarget();
         anchorBottom();
-
     });
 
     emit bottomTargetChanged();
@@ -366,6 +410,8 @@ void QmlAnchorBindingProxy::setBottomTarget(const QString &target)
 
 void QmlAnchorBindingProxy::setLeftTarget(const QString &target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set left target", category()};
+
     if (m_ignoreQml)
         return;
 
@@ -377,7 +423,7 @@ void QmlAnchorBindingProxy::setLeftTarget(const QString &target)
     if (!newTarget.isValid())
         return;
 
-    executeInTransaction("QmlAnchorBindingProxy::setLeftTarget", [this, newTarget](){
+    executeInTransaction("QmlAnchorBindingProxy::setLeftTarget", [this, newTarget]() {
         m_leftTarget = newTarget;
         setDefaultRelativeLeftTarget();
         anchorLeft();
@@ -388,6 +434,8 @@ void QmlAnchorBindingProxy::setLeftTarget(const QString &target)
 
 void QmlAnchorBindingProxy::setRightTarget(const QString &target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set right target", category()};
+
     if (m_ignoreQml)
         return;
 
@@ -399,7 +447,7 @@ void QmlAnchorBindingProxy::setRightTarget(const QString &target)
     if (!newTarget.isValid())
         return;
 
-    executeInTransaction("QmlAnchorBindingProxy::setRightTarget", [this, newTarget](){
+    executeInTransaction("QmlAnchorBindingProxy::setRightTarget", [this, newTarget]() {
         m_rightTarget = newTarget;
         setDefaultRelativeRightTarget();
         anchorRight();
@@ -410,6 +458,8 @@ void QmlAnchorBindingProxy::setRightTarget(const QString &target)
 
 void QmlAnchorBindingProxy::setVerticalTarget(const QString &target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set vertical target", category()};
+
     if (m_ignoreQml)
         return;
 
@@ -421,7 +471,7 @@ void QmlAnchorBindingProxy::setVerticalTarget(const QString &target)
     if (!newTarget.isValid())
         return;
 
-    executeInTransaction("QmlAnchorBindingProxy::setVerticalTarget", [this, newTarget](){
+    executeInTransaction("QmlAnchorBindingProxy::setVerticalTarget", [this, newTarget]() {
         m_verticalTarget = newTarget;
         anchorVertical();
     });
@@ -431,6 +481,8 @@ void QmlAnchorBindingProxy::setVerticalTarget(const QString &target)
 
 void QmlAnchorBindingProxy::setHorizontalTarget(const QString &target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set horizontal target", category()};
+
     if (m_ignoreQml)
         return;
 
@@ -442,7 +494,7 @@ void QmlAnchorBindingProxy::setHorizontalTarget(const QString &target)
     if (!newTarget.isValid())
         return;
 
-    executeInTransaction("QmlAnchorBindingProxy::setHorizontalTarget", [this, newTarget](){
+    executeInTransaction("QmlAnchorBindingProxy::setHorizontalTarget", [this, newTarget]() {
         m_horizontalTarget = newTarget;
         anchorHorizontal();
     });
@@ -452,13 +504,15 @@ void QmlAnchorBindingProxy::setHorizontalTarget(const QString &target)
 
 void QmlAnchorBindingProxy::setRelativeAnchorTargetTop(QmlAnchorBindingProxy::RelativeAnchorTarget target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set relative anchor target top", category()};
+
     if (m_ignoreQml)
         return;
 
     if (target == m_relativeTopTarget)
         return;
 
-    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetTop", [this, target](){
+    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetTop", [this, target]() {
         m_relativeTopTarget = target;
         anchorTop();
     });
@@ -468,13 +522,16 @@ void QmlAnchorBindingProxy::setRelativeAnchorTargetTop(QmlAnchorBindingProxy::Re
 
 void QmlAnchorBindingProxy::setRelativeAnchorTargetBottom(QmlAnchorBindingProxy::RelativeAnchorTarget target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set relative anchor target bottom",
+                               category()};
+
     if (m_ignoreQml)
         return;
 
     if (target == m_relativeBottomTarget)
         return;
 
-    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetBottom", [this, target](){
+    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetBottom", [this, target]() {
         m_relativeBottomTarget = target;
         anchorBottom();
     });
@@ -484,16 +541,17 @@ void QmlAnchorBindingProxy::setRelativeAnchorTargetBottom(QmlAnchorBindingProxy:
 
 void QmlAnchorBindingProxy::setRelativeAnchorTargetLeft(QmlAnchorBindingProxy::RelativeAnchorTarget target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set relative anchor target left", category()};
+
     if (m_ignoreQml)
         return;
 
     if (target == m_relativeLeftTarget)
         return;
 
-    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetLeft", [this, target](){
+    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetLeft", [this, target]() {
         m_relativeLeftTarget = target;
         anchorLeft();
-
     });
 
     emit relativeAnchorTargetLeftChanged();
@@ -501,31 +559,36 @@ void QmlAnchorBindingProxy::setRelativeAnchorTargetLeft(QmlAnchorBindingProxy::R
 
 void QmlAnchorBindingProxy::setRelativeAnchorTargetRight(QmlAnchorBindingProxy::RelativeAnchorTarget target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set relative anchor target right",
+                               category()};
+
     if (m_ignoreQml)
         return;
 
     if (target == m_relativeRightTarget)
         return;
 
-    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetRight", [this, target](){
+    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetRight", [this, target]() {
         m_relativeRightTarget = target;
         anchorRight();
     });
 
     emit relativeAnchorTargetRightChanged();
-
 }
 
-void QmlAnchorBindingProxy::setRelativeAnchorTargetVertical(QmlAnchorBindingProxy::RelativeAnchorTarget target)
+void QmlAnchorBindingProxy::setRelativeAnchorTargetVertical(
+    QmlAnchorBindingProxy::RelativeAnchorTarget target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set relative anchor target vertical",
+                               category()};
+
     if (m_ignoreQml)
         return;
 
     if (target == m_relativeVerticalTarget)
         return;
 
-
+    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetVertical", [this, target]() {
-    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetVertical", [this, target](){
         m_relativeVerticalTarget = target;
         anchorVertical();
     });
@@ -533,15 +596,19 @@ void QmlAnchorBindingProxy::setRelativeAnchorTargetVertical(QmlAnchorBindingProx
     emit relativeAnchorTargetVerticalChanged();
 }
 
-void QmlAnchorBindingProxy::setRelativeAnchorTargetHorizontal(QmlAnchorBindingProxy::RelativeAnchorTarget target)
+void QmlAnchorBindingProxy::setRelativeAnchorTargetHorizontal(
+    QmlAnchorBindingProxy::RelativeAnchorTarget target)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set relative anchor target horizontal",
+                               category()};
+
     if (m_ignoreQml)
         return;
 
     if (target == m_relativeHorizontalTarget)
         return;
 
-    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetHorizontal", [this, target](){
+    executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetHorizontal", [this, target]() {
         m_relativeHorizontalTarget = target;
         anchorHorizontal();
     });
@@ -551,6 +618,8 @@ void QmlAnchorBindingProxy::setRelativeAnchorTargetHorizontal(QmlAnchorBindingPr
 
 QStringList QmlAnchorBindingProxy::possibleTargetItems() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy possible target items", category()};
+
     QStringList stringList;
     if (!m_qmlItemNode.isValid())
         return stringList;
@@ -563,7 +632,8 @@ QStringList QmlAnchorBindingProxy::possibleTargetItems() const
     //We currently have no instanceChildren().
     //So we double check here if the instanceParents are equal.
     for (const QmlItemNode &node : std::as_const(itemList))
-        if (node.isValid() && (node.instanceParent().modelNode() != m_qmlItemNode.instanceParent().modelNode()))
+        if (node.isValid()
+            && (node.instanceParent().modelNode() != m_qmlItemNode.instanceParent().modelNode()))
             itemList.removeAll(node);
 
     for (const QmlItemNode &itemNode : std::as_const(itemList)) {
@@ -581,7 +651,9 @@ QStringList QmlAnchorBindingProxy::possibleTargetItems() const
 
 void QmlAnchorBindingProxy::registerDeclarativeType()
 {
-    qmlRegisterType<QmlAnchorBindingProxy>("HelperWidgets",2,0,"AnchorBindingProxy");
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy register declarative type", category()};
+
+    qmlRegisterType<QmlAnchorBindingProxy>("HelperWidgets", 2, 0, "AnchorBindingProxy");
 }
 
 int QmlAnchorBindingProxy::indexOfPossibleTargetItem(const QString &targetName) const
@@ -591,8 +663,9 @@ int QmlAnchorBindingProxy::indexOfPossibleTargetItem(const QString &targetName)
 
 void QmlAnchorBindingProxy::resetLayout()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy reset layout", category()};
 
-    executeInTransaction("QmlAnchorBindingProxy::resetLayout", [this](){
+    executeInTransaction("QmlAnchorBindingProxy::resetLayout", [this]() {
         m_qmlItemNode.anchors().removeAnchors();
         m_qmlItemNode.anchors().removeMargins();
 
@@ -607,10 +680,12 @@ void QmlAnchorBindingProxy::resetLayout()
     emit leftAnchorChanged();
     emit rightAnchorChanged();
     emit anchorsChanged();
-    }
+}
 
 void QmlAnchorBindingProxy::setBottomAnchor(bool anchor)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set bottom anchor", category()};
+
     if (!m_qmlItemNode.hasNodeParent())
         return;
 
@@ -639,6 +714,8 @@ void QmlAnchorBindingProxy::setBottomAnchor(bool anchor)
 
 void QmlAnchorBindingProxy::setLeftAnchor(bool anchor)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set left anchor", category()};
+
     if (!m_qmlItemNode.hasNodeParent())
         return;
 
@@ -668,6 +745,8 @@ void QmlAnchorBindingProxy::setLeftAnchor(bool anchor)
 
 void QmlAnchorBindingProxy::setRightAnchor(bool anchor)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set right anchor", category()};
+
     if (!m_qmlItemNode.hasNodeParent())
         return;
 
@@ -696,6 +775,8 @@ void QmlAnchorBindingProxy::setRightAnchor(bool anchor)
 }
  QRectF QmlAnchorBindingProxy::parentBoundingBox()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy parent bounding box", category()};
+
     if (m_qmlItemNode.hasInstanceParent()) {
         if (m_qmlItemNode.instanceParentItem().instanceContentItemBoundingRect().isValid())
             return m_qmlItemNode.instanceParentItem().instanceContentItemBoundingRect();
@@ -707,6 +788,8 @@ void QmlAnchorBindingProxy::setRightAnchor(bool anchor)
 
 QRectF QmlAnchorBindingProxy::boundingBox(const QmlItemNode &node)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy bounding box", category()};
+
     if (node.isValid())
         return node.instanceTransformWithContentTransform().mapRect(node.instanceBoundingRect());
 
@@ -715,11 +798,16 @@ QRectF QmlAnchorBindingProxy::boundingBox(const QmlItemNode &node)
 
 QRectF QmlAnchorBindingProxy::transformedBoundingBox()
 {
-    return m_qmlItemNode.instanceTransformWithContentTransform().mapRect(m_qmlItemNode.instanceBoundingRect());
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy transformed bounding box", category()};
+
+    return m_qmlItemNode.instanceTransformWithContentTransform().mapRect(
+        m_qmlItemNode.instanceBoundingRect());
 }
 
 void QmlAnchorBindingProxy::anchorTop()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy anchor top", category()};
+
     m_locked = true;
 
     bool topTargetIsParent = m_topTarget == m_qmlItemNode.instanceParentItem();
@@ -746,6 +834,8 @@ void QmlAnchorBindingProxy::anchorTop()
 
 void QmlAnchorBindingProxy::anchorBottom()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy anchor bottom", category()};
+
     m_locked = true;
 
     bool bottomTargetIsParent = m_bottomTarget == m_qmlItemNode.instanceParentItem();
@@ -772,6 +862,8 @@ void QmlAnchorBindingProxy::anchorBottom()
 
 void QmlAnchorBindingProxy::anchorLeft()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy anchor left", category()};
+
     m_locked = true;
 
     bool leftTargetIsParent = m_leftTarget == m_qmlItemNode.instanceParentItem();
@@ -798,6 +890,8 @@ void QmlAnchorBindingProxy::anchorLeft()
 
 void QmlAnchorBindingProxy::anchorRight()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy anchor right", category()};
+
     m_locked = true;
 
     bool rightTargetIsParent = m_rightTarget == m_qmlItemNode.instanceParentItem();
@@ -824,6 +918,8 @@ void QmlAnchorBindingProxy::anchorRight()
 
 void QmlAnchorBindingProxy::anchorVertical()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy anchor vertical", category()};
+
     m_locked = true;
     if (m_relativeVerticalTarget == SameEdge) {
         m_qmlItemNode.anchors().setAnchor(AnchorLineVerticalCenter, m_verticalTarget, AnchorLineRight);
@@ -839,6 +935,8 @@ void QmlAnchorBindingProxy::anchorVertical()
 
 void QmlAnchorBindingProxy::anchorHorizontal()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy anchor horizontal", category()};
+
     m_locked = true;
     if (m_relativeHorizontalTarget == SameEdge) {
         m_qmlItemNode.anchors().setAnchor(AnchorLineHorizontalCenter, m_horizontalTarget, AnchorLineRight);
@@ -853,6 +951,8 @@ void QmlAnchorBindingProxy::anchorHorizontal()
 
 QmlItemNode QmlAnchorBindingProxy::targetIdToNode(const QString &id) const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy target id to node", category()};
+
     QmlItemNode itemNode;
 
     if (m_qmlItemNode.isValid() && m_qmlItemNode.view()) {
@@ -868,6 +968,8 @@ QmlItemNode QmlAnchorBindingProxy::targetIdToNode(const QString &id) const
 
 QString QmlAnchorBindingProxy::idForNode(const QmlItemNode &qmlItemNode) const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy id for node", category()};
+
     if (!qmlItemNode.modelNode().isValid())
         return {};
 
@@ -882,11 +984,15 @@ QString QmlAnchorBindingProxy::idForNode(const QmlItemNode &qmlItemNode) const
 
 ModelNode QmlAnchorBindingProxy::modelNode() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy model node", category()};
+
     return m_qmlItemNode.modelNode();
 }
 
 void QmlAnchorBindingProxy::setTopAnchor(bool anchor)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set top anchor", category()};
+
     if (!m_qmlItemNode.hasNodeParent())
         return ;
 
@@ -913,7 +1019,9 @@ void QmlAnchorBindingProxy::setTopAnchor(bool anchor)
 }
 
 void QmlAnchorBindingProxy::removeTopAnchor() {
-    executeInTransaction("QmlAnchorBindingProxy::removeTopAnchor", [this](){
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy remove top anchor", category()};
+
+    executeInTransaction("QmlAnchorBindingProxy::removeTopAnchor", [this]() {
         m_qmlItemNode.anchors().removeAnchor(AnchorLineTop);
         m_qmlItemNode.anchors().removeMargin(AnchorLineTop);
 
@@ -925,7 +1033,9 @@ void QmlAnchorBindingProxy::removeTopAnchor() {
 
 void QmlAnchorBindingProxy::removeBottomAnchor()
 {
-    executeInTransaction("QmlAnchorBindingProxy::removeBottomAnchor", [this](){
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy remove bottom anchor", category()};
+
+    executeInTransaction("QmlAnchorBindingProxy::removeBottomAnchor", [this]() {
         m_qmlItemNode.anchors().removeAnchor(AnchorLineBottom);
         m_qmlItemNode.anchors().removeMargin(AnchorLineBottom);
 
@@ -937,7 +1047,9 @@ void QmlAnchorBindingProxy::removeBottomAnchor()
 
 void QmlAnchorBindingProxy::removeLeftAnchor()
 {
-    executeInTransaction("QmlAnchorBindingProxy::removeLeftAnchor", [this](){
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy remove left anchor", category()};
+
+    executeInTransaction("QmlAnchorBindingProxy::removeLeftAnchor", [this]() {
         m_qmlItemNode.anchors().removeAnchor(AnchorLineLeft);
         m_qmlItemNode.anchors().removeMargin(AnchorLineLeft);
 
@@ -949,7 +1061,9 @@ void QmlAnchorBindingProxy::removeLeftAnchor()
 
 void QmlAnchorBindingProxy::removeRightAnchor()
 {
-    executeInTransaction("QmlAnchorBindingProxy::removeRightAnchor", [this](){
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy remove right anchor", category()};
+
+    executeInTransaction("QmlAnchorBindingProxy::removeRightAnchor", [this]() {
         m_qmlItemNode.anchors().removeAnchor(AnchorLineRight);
         m_qmlItemNode.anchors().removeMargin(AnchorLineRight);
 
@@ -961,6 +1075,8 @@ void QmlAnchorBindingProxy::removeRightAnchor()
 
 void QmlAnchorBindingProxy::setVerticalCentered(bool centered)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set vertical centered", category()};
+
     if (!m_qmlItemNode.hasNodeParent())
         return ;
 
@@ -995,6 +1111,8 @@ void QmlAnchorBindingProxy::setVerticalCentered(bool centered)
 
 void QmlAnchorBindingProxy::setHorizontalCentered(bool centered)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set horizontal centered", category()};
+
     if (!m_qmlItemNode.hasNodeParent())
         return ;
 
@@ -1028,46 +1146,65 @@ void QmlAnchorBindingProxy::setHorizontalCentered(bool centered)
 
 bool QmlAnchorBindingProxy::verticalCentered()
 {
-    return m_qmlItemNode.isValid() && m_qmlItemNode.anchors().instanceHasAnchor(AnchorLineVerticalCenter);
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy vertical centered", category()};
+
+    return m_qmlItemNode.isValid()
+           && m_qmlItemNode.anchors().instanceHasAnchor(AnchorLineVerticalCenter);
 }
 
 QString QmlAnchorBindingProxy::topTarget() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy top target", category()};
+
     return idForNode(m_topTarget);
 }
 
 QString QmlAnchorBindingProxy::bottomTarget() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy bottom target", category()};
+
     return idForNode(m_bottomTarget);
 }
 
 QString QmlAnchorBindingProxy::leftTarget() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy left target", category()};
+
     return idForNode(m_leftTarget);
 }
 
 QString QmlAnchorBindingProxy::rightTarget() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy right target", category()};
+
     return idForNode(m_rightTarget);
 }
 
 QmlAnchorBindingProxy::RelativeAnchorTarget QmlAnchorBindingProxy::relativeAnchorTargetTop() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy relative anchor target top", category()};
+
     return m_relativeTopTarget;
 }
 
 QmlAnchorBindingProxy::RelativeAnchorTarget QmlAnchorBindingProxy::relativeAnchorTargetBottom() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy relative anchor target bottom", category()};
+
     return m_relativeBottomTarget;
 }
 
 QmlAnchorBindingProxy::RelativeAnchorTarget QmlAnchorBindingProxy::relativeAnchorTargetLeft() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy relative anchor target left", category()};
+
     return m_relativeLeftTarget;
 }
 
 QmlAnchorBindingProxy::RelativeAnchorTarget QmlAnchorBindingProxy::relativeAnchorTargetRight() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy relative anchor target right", category()};
+
     return m_relativeRightTarget;
 }
 
@@ -1078,16 +1215,23 @@ QmlAnchorBindingProxy::RelativeAnchorTarget QmlAnchorBindingProxy::relativeAncho
 
 QmlAnchorBindingProxy::RelativeAnchorTarget QmlAnchorBindingProxy::relativeAnchorTargetHorizontal() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy relative anchor target horizontal",
+                               category()};
+
     return m_relativeHorizontalTarget;
 }
 
 QString QmlAnchorBindingProxy::verticalTarget() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy vertical target", category()};
+
     return idForNode(m_verticalTarget);
 }
 
 QString QmlAnchorBindingProxy::horizontalTarget() const
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy horizontal target", category()};
+
     return idForNode(m_horizontalTarget);
 }
 
@@ -1098,6 +1242,8 @@ bool QmlAnchorBindingProxy::horizontalCentered()
 
 void QmlAnchorBindingProxy::fill()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy fill", category()};
+
     executeInTransaction("QmlAnchorBindingProxy::fill", [this](){
         backupPropertyAndRemove(modelNode(), "x");
         backupPropertyAndRemove(modelNode(), "y");
@@ -1122,6 +1268,8 @@ void QmlAnchorBindingProxy::fill()
 
 void QmlAnchorBindingProxy::centerIn()
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy center in", category()};
+
     executeInTransaction("QmlAnchorBindingProxy::centerIn", [this]() {
         backupPropertyAndRemove(modelNode(), "x");
         backupPropertyAndRemove(modelNode(), "y");
@@ -1139,6 +1287,8 @@ void QmlAnchorBindingProxy::centerIn()
 
 void QmlAnchorBindingProxy::setDefaultAnchorTarget(const ModelNode &modelNode)
 {
+    NanotraceHR::Tracer tracer{"qml anchor binding proxy set default anchor target", category()};
+
     m_verticalTarget = modelNode;
     m_horizontalTarget = modelNode;
     m_topTarget = modelNode;

src/plugins/qmldesigner/components/propertyeditor/qmlmaterialnodeproxy.cpp

@@ -3,6 +3,8 @@
 
 #include "qmlmaterialnodeproxy.h"
 
+#include "propertyeditortracing.h"
+
 #include <auxiliarydataproperties.h>
 #include <designmodewidget.h>
 #include <nodeinstanceview.h>
@@ -14,6 +16,8 @@
 
 namespace QmlDesigner {
 
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 using namespace Qt::StringLiterals;
 
 static bool allMaterialTypesAre(const ModelNodes &materials, const QString &materialType)
@@ -33,6 +37,8 @@ QmlMaterialNodeProxy::QmlMaterialNodeProxy()
     : QObject()
     , m_previewUpdateTimer(this)
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy constructor", category()};
+
     m_previewUpdateTimer.setInterval(200);
     m_previewUpdateTimer.setSingleShot(true);
     m_previewUpdateTimer.callOnTimeout(
@@ -43,6 +49,8 @@ QmlMaterialNodeProxy::~QmlMaterialNodeProxy() = default;
 
 void QmlMaterialNodeProxy::setup(const ModelNodes &editorNodes)
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy setup", category()};
+
     QmlObjectNode objectNode = editorNodes.isEmpty() ? ModelNode{} : editorNodes.first();
     const QmlObjectNode material = objectNode.metaInfo().isQtQuick3DMaterial() ? objectNode
                                                                                : QmlObjectNode{};
@@ -54,16 +62,22 @@ void QmlMaterialNodeProxy::setup(const ModelNodes &editorNodes)
 
 ModelNode QmlMaterialNodeProxy::materialNode() const
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy material node", category()};
+
     return m_materialNode;
 }
 
 ModelNodes QmlMaterialNodeProxy::editorNodes() const
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy editor nodes", category()};
+
     return m_editorNodes;
 }
 
 void QmlMaterialNodeProxy::setPossibleTypes(const QStringList &types)
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy set possible types", category()};
+
     if (types == m_possibleTypes)
         return;
 
@@ -75,6 +89,8 @@ void QmlMaterialNodeProxy::setPossibleTypes(const QStringList &types)
 
 void QmlMaterialNodeProxy::updatePossibleTypes()
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy update possible types", category()};
+
     static const QStringList basicTypes{
         "CustomMaterial",
         "DefaultMaterial",
@@ -107,12 +123,16 @@ void QmlMaterialNodeProxy::updatePossibleTypes()
 
 void QmlMaterialNodeProxy::setCurrentType(const QString &type)
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy set current type", category()};
+
     m_currentType = type.split('.').last();
     updatePossibleTypeIndex();
 }
 
 void QmlMaterialNodeProxy::toolBarAction(int action)
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy tool bar action", category()};
+
     QTC_ASSERT(hasQuick3DImport(), return);
 
     switch (ToolBarAction(action)) {
@@ -151,6 +171,8 @@ void QmlMaterialNodeProxy::toolBarAction(int action)
 
 void QmlMaterialNodeProxy::setPreviewEnv(const QString &envAndValue)
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy set preview env", category()};
+
     if (envAndValue.isEmpty())
         return;
 
@@ -188,6 +210,8 @@ void QmlMaterialNodeProxy::setPreviewEnv(const QString &envAndValue)
 
 void QmlMaterialNodeProxy::setPreviewModel(const QString &modelStr)
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy set preview model", category()};
+
     if (modelStr.isEmpty())
         return;
 
@@ -212,6 +236,9 @@ void QmlMaterialNodeProxy::setPreviewModel(const QString &modelStr)
 
 void QmlMaterialNodeProxy::handleAuxiliaryPropertyChanges()
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy handle auxiliary property changes",
+                               category()};
+
     if (!hasQuick3DImport())
         return;
 
@@ -220,11 +247,15 @@ void QmlMaterialNodeProxy::handleAuxiliaryPropertyChanges()
 
 void QmlMaterialNodeProxy::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy register declarative type", category()};
+
     qmlRegisterType<QmlMaterialNodeProxy>("HelperWidgets", 2, 0, "QmlMaterialNodeProxy");
 }
 
 void QmlMaterialNodeProxy::updatePossibleTypeIndex()
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy update possible type index", category()};
+
     int newIndex = -1;
     if (!m_currentType.isEmpty())
         newIndex = m_possibleTypes.indexOf(m_currentType);
@@ -239,6 +270,8 @@ void QmlMaterialNodeProxy::updatePossibleTypeIndex()
 
 void QmlMaterialNodeProxy::updatePreviewModel()
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy update preview model", category()};
+
     if (!hasQuick3DImport())
         return;
 
@@ -275,6 +308,8 @@ void QmlMaterialNodeProxy::updatePreviewModel()
 
 void QmlMaterialNodeProxy::setMaterialNode(const QmlObjectNode &material)
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy set material node", category()};
+
     if (material == m_materialNode)
         return;
 
@@ -284,16 +319,22 @@ void QmlMaterialNodeProxy::setMaterialNode(const QmlObjectNode &material)
 
 void QmlMaterialNodeProxy::setEditorNodes(const ModelNodes &editorNodes)
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy set editor nodes", category()};
+
     m_editorNodes = editorNodes;
 }
 
 bool QmlMaterialNodeProxy::hasQuick3DImport() const
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy has quick3d import", category()};
+
     return materialNode().isValid() && materialNode().model()->hasImport("QtQuick3D"_L1);
 }
 
 AbstractView *QmlMaterialNodeProxy::materialView() const
 {
+    NanotraceHR::Tracer tracer{"qml material node proxy material view", category()};
+
     return materialNode().view();
 }
 

src/plugins/qmldesigner/components/propertyeditor/qmlmodelnodeproxy.cpp

@@ -1,8 +1,9 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-#include "abstractview.h"
 #include "qmlmodelnodeproxy.h"
+#include "abstractview.h"
+#include "propertyeditortracing.h"
 
 #include <nodemetainfo.h>
 
@@ -17,18 +18,25 @@
 
 namespace QmlDesigner {
 
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 QmlModelNodeProxy::QmlModelNodeProxy(QObject *parent) :
     QObject(parent)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy constructor", category()};
 }
 
 void QmlModelNodeProxy::setup(const ModelNode &node)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy setup", category()};
+
     setup(ModelNodes{node});
 }
 
 void QmlModelNodeProxy::setup(const ModelNodes &editorNodes)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy setup with editor nodes", category()};
+
     m_qmlObjectNode = editorNodes.isEmpty() ? ModelNode{} : editorNodes.first();
     m_editorNodes = editorNodes;
 
@@ -39,11 +47,15 @@ void QmlModelNodeProxy::setup(const ModelNodes &editorNodes)
 
 void QmlModelNodeProxy::registerDeclarativeType()
 {
-    qmlRegisterType<QmlModelNodeProxy>("HelperWidgets",2,0,"ModelNodeProxy");
+    NanotraceHR::Tracer tracer{"qml model node proxy register declarative type", category()};
+
+    qmlRegisterType<QmlModelNodeProxy>("HelperWidgets", 2, 0, "ModelNodeProxy");
 }
 
 void QmlModelNodeProxy::emitSelectionToBeChanged()
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy emit selection to be changed", category()};
+
     emit selectionToBeChanged();
 }
 
@@ -54,16 +66,22 @@ void QmlModelNodeProxy::emitSelectionChanged()
 
 void QmlModelNodeProxy::refresh()
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy refresh", category()};
+
     emit refreshRequired();
 }
 
 QmlObjectNode QmlModelNodeProxy::qmlObjectNode() const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy qml object node", category()};
+
     return m_qmlObjectNode;
 }
 
 ModelNode QmlModelNodeProxy::modelNode() const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy model node", category()};
+
     return m_qmlObjectNode.modelNode();
 }
 
@@ -74,11 +92,15 @@ ModelNodes QmlModelNodeProxy::editorNodes() const
 
 ModelNode QmlModelNodeProxy::singleSelectedNode() const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy single selected node", category()};
+
     return multiSelection() ? ModelNode{} : modelNode();
 }
 
 bool QmlModelNodeProxy::multiSelection() const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy multi selection", category()};
+
     if (!m_qmlObjectNode.isValid())
         return false;
 
@@ -87,6 +109,8 @@ bool QmlModelNodeProxy::multiSelection() const
 
 QString QmlModelNodeProxy::nodeId() const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy node id", category()};
+
     if (!m_qmlObjectNode.isValid())
         return {};
 
@@ -98,6 +122,8 @@ QString QmlModelNodeProxy::nodeId() const
 
 QString QmlModelNodeProxy::nodeObjectName() const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy node object name", category()};
+
     if (!m_qmlObjectNode.isValid())
         return {};
 
@@ -109,6 +135,8 @@ QString QmlModelNodeProxy::nodeObjectName() const
 
 QString QmlModelNodeProxy::simplifiedTypeName() const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy simplified type name", category()};
+
     if (!m_qmlObjectNode.isValid())
         return {};
 
@@ -125,6 +153,8 @@ static QList<int> toInternalIdList(const QList<ModelNode> &nodes)
 
 QList<int> QmlModelNodeProxy::allChildren(int internalId) const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy all children", category()};
+
     ModelNode modelNode = m_qmlObjectNode.modelNode();
 
     QTC_ASSERT(modelNode.isValid(), return {});
@@ -137,6 +167,8 @@ QList<int> QmlModelNodeProxy::allChildren(int internalId) const
 
 QList<int> QmlModelNodeProxy::allChildrenOfType(const QString &typeName, int internalId) const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy all children of type", category()};
+
     ModelNode modelNode = m_qmlObjectNode.modelNode();
 
     QTC_ASSERT(modelNode.isValid(), return {});
@@ -149,6 +181,8 @@ QList<int> QmlModelNodeProxy::allChildrenOfType(const QString &typeName, int int
 
 QString QmlModelNodeProxy::simplifiedTypeName(int internalId) const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy simplified type name", category()};
+
     ModelNode modelNode = m_qmlObjectNode.modelNode();
 
     QTC_ASSERT(modelNode.isValid(), return {});
@@ -158,6 +192,8 @@ QString QmlModelNodeProxy::simplifiedTypeName(int internalId) const
 
 PropertyEditorSubSelectionWrapper *QmlModelNodeProxy::findWrapper(int internalId) const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy find wrapper", category()};
+
     for (const auto &item : qAsConst(m_subselection)) {
         if (item->modelNode().internalId() == internalId)
             return item.data();
@@ -168,6 +204,8 @@ PropertyEditorSubSelectionWrapper *QmlModelNodeProxy::findWrapper(int internalId
 
 PropertyEditorSubSelectionWrapper *QmlModelNodeProxy::registerSubSelectionWrapper(int internalId)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy register sub selection wrapper", category()};
+
     auto result = findWrapper(internalId);
 
     if (result)
@@ -193,6 +231,8 @@ void QmlModelNodeProxy::createModelNode(int internalIdParent,
                                         const QString &typeName,
                                         const QString &requiredImport)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy create model node", category()};
+
     auto parentModelNode = m_qmlObjectNode.modelNode();
 
     QTC_ASSERT(parentModelNode.isValid(), return );
@@ -231,6 +271,8 @@ void QmlModelNodeProxy::moveNode(int internalIdParent,
                                  int fromIndex,
                                  int toIndex)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy move node", category()};
+
     ModelNode modelNode = m_qmlObjectNode.modelNode();
 
     QTC_ASSERT(modelNode.isValid(), return );
@@ -247,6 +289,8 @@ void QmlModelNodeProxy::moveNode(int internalIdParent,
 
 bool QmlModelNodeProxy::isInstanceOf(const QString &typeName, int internalId) const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy is instance of", category()};
+
     ModelNode modelNode = m_qmlObjectNode.modelNode();
 
     QTC_ASSERT(modelNode.isValid(), return {});
@@ -261,6 +305,8 @@ bool QmlModelNodeProxy::isInstanceOf(const QString &typeName, int internalId) co
 
 void QmlModelNodeProxy::changeType(int internalId, const QString &typeName)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy change type", category()};
+
     QTC_ASSERT(m_qmlObjectNode.isValid(), return );
 
     ModelNode node = m_qmlObjectNode.view()->modelNodeForInternalId(internalId);
@@ -279,6 +325,8 @@ void QmlModelNodeProxy::changeType(int internalId, const QString &typeName)
 void QmlModelNodeProxy::handleInstancePropertyChanged(const ModelNode &modelNode,
                                                       PropertyNameView propertyName)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy handle instance property changed", category()};
+
     const QmlObjectNode qmlObjectNode(modelNode);
 
     for (const auto &item : qAsConst(m_subselection)) {
@@ -295,6 +343,8 @@ void QmlModelNodeProxy::handleInstancePropertyChanged(const ModelNode &modelNode
 
 void QmlModelNodeProxy::handleBindingPropertyChanged(const BindingProperty &property)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy handle binding property changed", category()};
+
     for (const auto &item : qAsConst(m_subselection)) {
         if (item && item->isRelevantModelNode(property.parentModelNode())) {
             QmlObjectNode objectNode(item->modelNode());
@@ -308,6 +358,8 @@ void QmlModelNodeProxy::handleBindingPropertyChanged(const BindingProperty &prop
 
 void QmlModelNodeProxy::handleVariantPropertyChanged(const VariantProperty &property)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy handle variant property changed", category()};
+
     for (const auto &item : qAsConst(m_subselection)) {
         if (item && item->isRelevantModelNode(property.parentModelNode())) {
             QmlObjectNode objectNode(item->modelNode());
@@ -321,6 +373,8 @@ void QmlModelNodeProxy::handleVariantPropertyChanged(const VariantProperty &prop
 
 void QmlModelNodeProxy::handlePropertiesRemoved(const AbstractProperty &property)
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy handle properties removed", category()};
+
     for (const auto &item : qAsConst(m_subselection)) {
         if (item && item->isRelevantModelNode(property.parentModelNode())) {
             QmlObjectNode objectNode(item->modelNode());
@@ -332,11 +386,15 @@ void QmlModelNodeProxy::handlePropertiesRemoved(const AbstractProperty &property
 
 QList<int> QmlModelNodeProxy::allChildren(const ModelNode &modelNode) const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy all children", category()};
+
     return toInternalIdList(modelNode.directSubModelNodes());
 }
 
 QList<int> QmlModelNodeProxy::allChildrenOfType(const ModelNode &modelNode, const QString &typeName) const
 {
+    NanotraceHR::Tracer tracer{"qml model node proxy all children of type", category()};
+
     QTC_ASSERT(modelNode.isValid(), return {});
 
     NodeMetaInfo metaInfo = modelNode.model()->metaInfo(typeName.toUtf8());

src/plugins/qmldesigner/components/propertyeditor/qmltexturenodeproxy.cpp

@@ -3,6 +3,8 @@
 
 #include "qmltexturenodeproxy.h"
 
+#include "propertyeditortracing.h"
+
 #include <abstractview.h>
 #include <createtexture.h>
 #include <designmodewidget.h>
@@ -13,14 +15,24 @@
 
 namespace QmlDesigner {
 
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 using namespace Qt::StringLiterals;
 
-QmlTextureNodeProxy::QmlTextureNodeProxy() = default;
+QmlTextureNodeProxy::QmlTextureNodeProxy()
+{
+    NanotraceHR::Tracer tracer{"qml texture node proxy constructor", category()};
+}
 
-QmlTextureNodeProxy::~QmlTextureNodeProxy() = default;
+QmlTextureNodeProxy::~QmlTextureNodeProxy()
+{
+    NanotraceHR::Tracer tracer{"qml texture node proxy destructor", category()};
+}
 
 void QmlTextureNodeProxy::setup(const QmlObjectNode &objectNode)
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy setup", category()};
+
     const QmlObjectNode texture = objectNode.metaInfo().isQtQuick3DTexture() ? objectNode
                                                                              : QmlObjectNode{};
 
@@ -30,6 +42,8 @@ void QmlTextureNodeProxy::setup(const QmlObjectNode &objectNode)
 
 void QmlTextureNodeProxy::updateSelectionDetails()
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy update selection details", category()};
+
     QScopeGuard falseSetter{
         std::bind_front(&QmlTextureNodeProxy::setSelectedNodeAcceptsMaterial, this, false)};
 
@@ -46,6 +60,8 @@ void QmlTextureNodeProxy::updateSelectionDetails()
 
 void QmlTextureNodeProxy::handlePropertyChanged(const AbstractProperty &property)
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy handle property changed", category()};
+
     if (!textureNode())
         return;
 
@@ -65,31 +81,43 @@ void QmlTextureNodeProxy::handlePropertyChanged(const AbstractProperty &property
 
 void QmlTextureNodeProxy::handleBindingPropertyChanged(const BindingProperty &property)
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy handle binding property changed", category()};
+
     handlePropertyChanged(property);
 }
 
 void QmlTextureNodeProxy::handlePropertiesRemoved(const AbstractProperty &property)
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy handle properties removed", category()};
+
     handlePropertyChanged(property);
 }
 
 QmlObjectNode QmlTextureNodeProxy::textureNode() const
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy texture node", category()};
+
     return m_textureNode;
 }
 
 bool QmlTextureNodeProxy::hasTexture() const
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy has texture", category()};
+
     return textureNode().isValid();
 }
 
 bool QmlTextureNodeProxy::selectedNodeAcceptsMaterial() const
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy selected node accepts material", category()};
+
     return m_selectedNodeAcceptsMaterial;
 }
 
 QString QmlTextureNodeProxy::resolveResourcePath(const QString &path) const
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy resolve resource path", category()};
+
     if (path.isEmpty())
         return ":/propertyeditor/images/texture_default.png";
 
@@ -108,6 +136,8 @@ QString QmlTextureNodeProxy::resolveResourcePath(const QString &path) const
 
 void QmlTextureNodeProxy::toolbarAction(int action)
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy toolbar action", category()};
+
     if (!hasQuick3DImport())
         return;
 
@@ -146,11 +176,15 @@ void QmlTextureNodeProxy::toolbarAction(int action)
 
 void QmlTextureNodeProxy::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy register declarative type", category()};
+
     qmlRegisterType<QmlTextureNodeProxy>("HelperWidgets", 2, 0, "QmlTextureNodeProxy");
 }
 
 void QmlTextureNodeProxy::setTextureNode(const QmlObjectNode &node)
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy set texture node", category()};
+
     if (m_textureNode == node)
         return;
     m_textureNode = node;
@@ -159,6 +193,9 @@ void QmlTextureNodeProxy::setTextureNode(const QmlObjectNode &node)
 
 void QmlTextureNodeProxy::setSelectedNodeAcceptsMaterial(bool value)
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy set selected node accepts material",
+                               category()};
+
     if (m_selectedNodeAcceptsMaterial == value)
         return;
     m_selectedNodeAcceptsMaterial = value;
@@ -167,6 +204,8 @@ void QmlTextureNodeProxy::setSelectedNodeAcceptsMaterial(bool value)
 
 bool QmlTextureNodeProxy::hasQuick3DImport() const
 {
+    NanotraceHR::Tracer tracer{"qml texture node proxy has quick3d import", category()};
+
     return textureNode().isValid() && textureNode().model()->hasImport("QtQuick3D"_L1);
 }
 

src/plugins/qmldesigner/components/propertyeditor/quick2propertyeditorview.cpp

@@ -3,14 +3,7 @@
 
 #include "quick2propertyeditorview.h"
 
-#include <qmldesignerconstants.h>
-#include <scripteditorbackend.h>
-
 #include "aligndistribute.h"
-#include "annotationeditor/annotationeditor.h"
-#include "assetimageprovider.h"
-#include "bindingeditor/actioneditor.h"
-#include "bindingeditor/bindingeditor.h"
 #include "colorpalettebackend.h"
 #include "fileresourcesmodel.h"
 #include "fontresourcesmodel.h"
@@ -22,23 +15,37 @@
 #include "listvalidator.h"
 #include "propertychangesmodel.h"
 #include "propertyeditorcontextobject.h"
+#include "propertyeditordynamicpropertiesproxymodel.h"
 #include "propertyeditorqmlbackend.h"
+#include "propertyeditortracing.h"
 #include "propertyeditorvalue.h"
 #include "propertymodel.h"
 #include "propertynamevalidator.h"
 #include "qmlanchorbindingproxy.h"
 #include "qmlmaterialnodeproxy.h"
 #include "qmltexturenodeproxy.h"
-#include "richtexteditor/richtexteditorproxy.h"
-#include "propertyeditordynamicpropertiesproxymodel.h"
-#include "theme.h"
 #include "tooltip.h"
 
+#include <qmldesignerconstants.h>
+#include <scripteditorbackend.h>
+
+#include <annotationeditor/annotationeditor.h>
+#include <assetimageprovider.h>
+#include <bindingeditor/actioneditor.h>
+#include <bindingeditor/bindingeditor.h>
+
+#include <richtexteditor/richtexteditorproxy.h>
+#include <theme.h>
+
 namespace QmlDesigner {
 
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 Quick2PropertyEditorView::Quick2PropertyEditorView(AsynchronousImageCache &imageCache)
     : QQuickWidget()
 {
+    NanotraceHR::Tracer tracer{"quick2 property editor view constructor", category()};
+
     setObjectName(Constants::OBJECT_NAME_PROPERTY_EDITOR);
     setResizeMode(QQuickWidget::SizeRootObjectToView);
     Theme::setupTheme(engine());

src/plugins/qmldesigner/components/propertyeditor/tooltip.cpp

@@ -2,18 +2,27 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "tooltip.h"
+
+#include "propertyeditortracing.h"
+
 #include <qquickwindow.h>
 #include <qquickitem.h>
 #include <QtQuick/QQuickRenderControl>
 #include <QtWidgets/qtwidgetsglobal.h>
 #include <qtooltip.h>
 
+static auto category = QmlDesigner::PropertyEditorTracing::category;
+
 Tooltip::Tooltip(QObject *parent)
     : QObject(parent)
-{}
+{
+    NanotraceHR::Tracer tracer{"tooltip constructor", category()};
+}
 
 void Tooltip::showText(QQuickItem *item, const QPointF &pos, const QString &str)
 {
+    NanotraceHR::Tracer tracer{"tooltip show text", category()};
+
     if (!item || !item->window())
         return;
 
@@ -29,11 +38,15 @@ void Tooltip::showText(QQuickItem *item, const QPointF &pos, const QString &str)
 
 void Tooltip::hideText()
 {
+    NanotraceHR::Tracer tracer{"tooltip hide text", category()};
+
     QToolTip::hideText();
 }
 
 void Tooltip::registerDeclarativeType()
 {
+    NanotraceHR::Tracer tracer{"tooltip register declarative type", category()};
+
     qmlRegisterType<Tooltip>("StudioControls", 1, 0, "ToolTipExt");
     qmlRegisterType<Tooltip>("HelperWidgets", 2, 0, "Tooltip");
 }

src/plugins/qmldesigner/libs/designercore/CMakeLists.txt

@@ -49,7 +49,7 @@ extend_qtc_library(QmlDesignerCore
 )
 
 extend_qtc_library(QmlDesignerCore
-  CONDITION ENABLE_PROJECT_STORAGE_TRACING OR ENABLE_SOURCE_PATH_STORAGE_TRACING OR ENABLE_IMAGE_CACHE_TRACING OR ENABLE_MODEL_TRACING OR ENABLE_FORM_EDITOR_TRACING
+  CONDITION ENABLE_PROJECT_STORAGE_TRACING OR ENABLE_SOURCE_PATH_STORAGE_TRACING OR ENABLE_IMAGE_CACHE_TRACING OR ENABLE_MODEL_TRACING OR ENABLE_FORM_EDITOR_TRACING OR ENABLE_PROPERTY_EDITOR_TRACING
   PUBLIC_DEPENDS Nanotrace
   PUBLIC_DEFINES
     ENABLE_QMLDESIGNER_TRACING