QmlDesigner: Add Navigator tracing

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

src/plugins/qmldesigner/CMakeLists.txt

@@ -40,7 +40,9 @@ env_with_default("QTC_ENABLE_FORM_EDITOR_TRACING" ENV_QTC_ENABLE_FORM_EDITOR_TRA
 option(ENABLE_FORM_EDITOR_TRACING "Enable form editor tracing" ${ENV_QTC_ENABLE_FORM_EDITOR_TRACING})
 add_feature_info("Form editor tracing" ${ENABLE_FORM_EDITOR_TRACING} "")
 
-
+env_with_default("QTC_ENABLE_NAVIGATOR_TRACING" ENV_QTC_ENABLE_NAVIGATOR_TRACING OFF)
+option(ENABLE_NAVIGATOR_TRACING "Enable navigator tracing" ${ENV_QTC_ENABLE_NAVIGATOR_TRACING})
+add_feature_info("Navigator tracing" ${ENABLE_NAVIGATOR_TRACING} "")
 
 if(QDS_DESIGNVIEWER_USE_STAGING)
   add_definitions(-DQDS_DESIGNVIEWER_USE_STAGING)
@@ -396,12 +398,15 @@ extend_qtc_plugin(QmlDesigner
 
 extend_qtc_plugin(QmlDesigner
   SOURCES_PREFIX components/navigator
+  PUBLIC_DEFINES
+    $<$<BOOL:${ENABLE_NAVIGATOR_TRACING}>:ENABLE_NAVIGATOR_TRACING>
   SOURCES
     iconcheckboxitemdelegate.cpp iconcheckboxitemdelegate.h
     nameitemdelegate.cpp nameitemdelegate.h
     navigator.qrc
     navigatormodelinterface.h
     navigatorsearchwidget.cpp navigatorsearchwidget.h
+    navigatortracing.cpp navigatortracing.h
     navigatortreemodel.cpp navigatortreemodel.h
     navigatortreeview.cpp navigatortreeview.h
     navigatorview.cpp navigatorview.h

src/plugins/qmldesigner/components/navigator/choosefrompropertylistdialog.cpp

@@ -2,18 +2,24 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "choosefrompropertylistdialog.h"
-#include "nodemetainfo.h"
+
+#include "navigatortracing.h"
 #include "ui_choosefrompropertylistdialog.h"
 
+#include <nodemetainfo.h>
 #include <qmldesignerplugin.h>
 
 namespace QmlDesigner {
 
+static auto category = NavigatorTracing::category;
+
 // This will filter and return possible properties that the given type can be bound to
 ChooseFromPropertyListFilter::ChooseFromPropertyListFilter(const NodeMetaInfo &insertInfo,
                                                            const NodeMetaInfo &parentInfo,
                                                            bool breakOnFirst)
 {
+    NanotraceHR::Tracer tracer{"choose from property list filter constructor", category()};
+
     // TODO: Metainfo based matching system (QDS-6240)
 
     // Fall back to a hardcoded list of supported cases:
@@ -136,11 +142,15 @@ ChooseFromPropertyListDialog::ChooseFromPropertyListDialog(const QStringList &pr
 
 ChooseFromPropertyListDialog::~ChooseFromPropertyListDialog()
 {
+    NanotraceHR::Tracer tracer{"choose from property list filter destructor", category()};
+
     delete m_ui;
 }
 
 TypeName ChooseFromPropertyListDialog::selectedProperty() const
 {
+    NanotraceHR::Tracer tracer{"choose from property list filter selected property", category()};
+
     return m_selectedProperty;
 }
 
@@ -149,6 +159,8 @@ TypeName ChooseFromPropertyListDialog::selectedProperty() const
 ChooseFromPropertyListDialog *ChooseFromPropertyListDialog::createIfNeeded(
         const ModelNode &targetNode, const ModelNode &newNode, QWidget *parent)
 {
+    NanotraceHR::Tracer tracer{"choose from property list filter create if needed", category()};
+
     const NodeMetaInfo info = newNode.metaInfo();
     const NodeMetaInfo targetInfo = targetNode.metaInfo();
     ChooseFromPropertyListFilter *filter = new ChooseFromPropertyListFilter(info, targetInfo);
@@ -163,6 +175,9 @@ ChooseFromPropertyListDialog *ChooseFromPropertyListDialog::createIfNeeded(
 ChooseFromPropertyListDialog *ChooseFromPropertyListDialog::createIfNeeded(
     const ModelNode &targetNode, const NodeMetaInfo &propertyType, QWidget *parent)
 {
+    NanotraceHR::Tracer tracer{"choose from property list filter create if needed for type",
+                               category()};
+
     const NodeMetaInfo metaInfo = targetNode.metaInfo();
     QStringList matchingNames;
     for (const auto &property : metaInfo.properties()) {
@@ -178,6 +193,8 @@ ChooseFromPropertyListDialog *ChooseFromPropertyListDialog::createIfNeeded(
 
 void ChooseFromPropertyListDialog::fillList(const QStringList &propNames)
 {
+    NanotraceHR::Tracer tracer{"choose from property list filter fill list", category()};
+
     if (propNames.isEmpty())
         return;
 

src/plugins/qmldesigner/components/navigator/iconcheckboxitemdelegate.cpp

@@ -5,31 +5,38 @@
 
 #include <qmath.h>
 
-#include "navigatorview.h"
+#include "navigatortracing.h"
-#include "navigatortreeview.h"
 #include "navigatortreemodel.h"
-#include "qproxystyle.h"
+#include "navigatortreeview.h"
+#include "navigatorview.h"
 
 #include <theme.h>
 
 #include <utils/qtcassert.h>
 
+#include <qproxystyle.h>
 #include <QLineEdit>
-#include <QPen>
-#include <QPixmapCache>
 #include <QMouseEvent>
 #include <QPainter>
+#include <QPen>
+#include <QPixmapCache>
 
 namespace QmlDesigner {
 
+static auto category = NavigatorTracing::category;
+
 IconCheckboxItemDelegate::IconCheckboxItemDelegate(QObject *parent, const QIcon &icon)
     : QStyledItemDelegate(parent),
       m_icon(icon)
-{}
+{
+    NanotraceHR::Tracer tracer{"icon checkbox item delegate constructor", category()};
+}
 
 QSize IconCheckboxItemDelegate::sizeHint(const QStyleOptionViewItem & /*option*/,
                                          const QModelIndex & /*modelIndex*/) const
 {
+    NanotraceHR::Tracer tracer{"icon checkbox item delegate size hint", category()};
+
     return {15, 20};
 }
 
@@ -63,6 +70,8 @@ void IconCheckboxItemDelegate::paint(QPainter *painter,
                                      const QStyleOptionViewItem &styleOption,
                                      const QModelIndex &modelIndex) const
 {
+    NanotraceHR::Tracer tracer{"icon checkbox item delegate paint", category()};
+
     if (isReference(modelIndex))
         return; // Do not paint hover selection and icons for reference nodes
 
@@ -109,12 +118,13 @@ void IconCheckboxItemDelegate::paint(QPainter *painter,
     painter->restore();
 }
 
-
 bool IconCheckboxItemDelegate::editorEvent(QEvent *event,
                                            QAbstractItemModel *model,
                                            const QStyleOptionViewItem &option,
                                            const QModelIndex &index)
 {
+    NanotraceHR::Tracer tracer{"icon checkbox item delegate editor event", category()};
+
     Q_ASSERT(event);
     Q_ASSERT(model);
 
@@ -130,10 +140,9 @@ bool IconCheckboxItemDelegate::editorEvent(QEvent *event,
         return false;
 
     // make sure that we have the right event type
-    if ((event->type() == QEvent::MouseButtonRelease)
+    if ((event->type() == QEvent::MouseButtonRelease) || (event->type() == QEvent::MouseButtonDblClick)
-        || (event->type() == QEvent::MouseButtonDblClick)
         || (event->type() == QEvent::MouseButtonPress)) {
-        QMouseEvent *me = static_cast<QMouseEvent*>(event);
+        QMouseEvent *me = static_cast<QMouseEvent *>(event);
         if (me->button() != Qt::LeftButton || !option.rect.contains(me->pos()))
             return false;
 
@@ -142,8 +151,8 @@ bool IconCheckboxItemDelegate::editorEvent(QEvent *event,
             return true;
 
     } else if (event->type() == QEvent::KeyPress) {
-        if (static_cast<QKeyEvent*>(event)->key() != Qt::Key_Space
+        if (static_cast<QKeyEvent *>(event)->key() != Qt::Key_Space
-         && static_cast<QKeyEvent*>(event)->key() != Qt::Key_Select)
+            && static_cast<QKeyEvent *>(event)->key() != Qt::Key_Select)
             return false;
     } else {
         return false;
@@ -151,7 +160,7 @@ bool IconCheckboxItemDelegate::editorEvent(QEvent *event,
 
     Qt::CheckState state = static_cast<Qt::CheckState>(value.toInt());
     if (flags & Qt::ItemIsUserTristate)
-        state = ((Qt::CheckState)((state + 1) % 3));
+        state = ((Qt::CheckState) ((state + 1) % 3));
     else
         state = (state == Qt::Checked) ? Qt::Unchecked : Qt::Checked;
     return model->setData(index, state, Qt::CheckStateRole);

src/plugins/qmldesigner/components/navigator/nameitemdelegate.cpp

@@ -3,12 +3,13 @@
 
 #include "nameitemdelegate.h"
 
-#include <qmath.h>
 
 #include "choosefrompropertylistdialog.h"
+#include "navigatortracing.h"
 #include "navigatortreeview.h"
 #include "navigatorview.h"
 #include "navigatorwidget.h"
+
 #include <dialogutils.h>
 #include <modelnodecontextmenu.h>
 #include <modelutils.h>
@@ -20,15 +21,18 @@
 #include <coreplugin/messagebox.h>
 #include <utils/qtcassert.h>
 
+#include <qmath.h>
 #include <QLineEdit>
-#include <QPen>
-#include <QPixmapCache>
 #include <QMouseEvent>
 #include <QPainter>
 #include <QPainterPath>
+#include <QPen>
+#include <QPixmapCache>
 
 namespace QmlDesigner {
 
+static auto category = NavigatorTracing::category;
+
 int NameItemDelegate::iconOffset = 0;
 
 static QPixmap generateWavyPixmap(qreal maxRadius, const QPen &pen)
@@ -91,6 +95,7 @@ static QPixmap getWavyPixmap(qreal maxRadius, const QPen &pen)
 NameItemDelegate::NameItemDelegate(QObject *parent)
     : QStyledItemDelegate(parent)
 {
+    NanotraceHR::Tracer tracer{"name item delegate constructor", category()};
 }
 
 static int drawIcon(QPainter *painter, const QStyleOptionViewItem &styleOption, const QModelIndex &modelIndex)
@@ -194,6 +199,8 @@ static void openContextMenu(const QModelIndex &index, const QPoint &pos)
 QSize NameItemDelegate::sizeHint(const QStyleOptionViewItem & /*option*/,
                                  const QModelIndex & /*modelIndex*/) const
 {
+    NanotraceHR::Tracer tracer{"name item delegate size hint", category()};
+
     return {15, 20 + (2 * delegateMargin)};
 }
 
@@ -201,6 +208,8 @@ void NameItemDelegate::paint(QPainter *painter,
                              const QStyleOptionViewItem &styleOption,
                              const QModelIndex &modelIndex) const
 {
+    NanotraceHR::Tracer tracer{"name item delegate paint", category()};
+
     painter->save();
 
     painter->setPen(Theme::getColor(Theme::Color::DSnavigatorText));
@@ -283,6 +292,8 @@ QWidget *NameItemDelegate::createEditor(QWidget *parent,
                                         const QStyleOptionViewItem &/*option*/,
                                         const QModelIndex &index) const
 {
+    NanotraceHR::Tracer tracer{"name item delegate create editor", category()};
+
     if (!getModelNode(index).isValid())
         return nullptr;
 
@@ -291,6 +302,8 @@ QWidget *NameItemDelegate::createEditor(QWidget *parent,
 
 void NameItemDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
 {
+    NanotraceHR::Tracer tracer{"name item delegate set editor data", category()};
+
     const ModelNode node = getModelNode(index);
     const QString value = node.id();
 
@@ -302,6 +315,8 @@ void NameItemDelegate::setModelData(QWidget *editor,
                                     [[maybe_unused]] QAbstractItemModel *model,
                                     const QModelIndex &index) const
 {
+    NanotraceHR::Tracer tracer{"name item delegate set model data", category()};
+
     auto lineEdit = static_cast<QLineEdit*>(editor);
     setId(index, lineEdit->text());
     lineEdit->clearFocus();
@@ -309,6 +324,8 @@ void NameItemDelegate::setModelData(QWidget *editor,
 
 bool NameItemDelegate::editorEvent(QEvent *event, QAbstractItemModel *, const QStyleOptionViewItem &, const QModelIndex &index)
 {
+    NanotraceHR::Tracer tracer{"name item delegate editor event", category()};
+
     if (event->type() == QEvent::MouseButtonRelease) {
         auto mouseEvent = static_cast<QMouseEvent *>(event);
         if (mouseEvent->button() == Qt::RightButton) {
@@ -324,6 +341,8 @@ void NameItemDelegate::updateEditorGeometry(QWidget *editor,
                                             const QStyleOptionViewItem &option,
                                             const QModelIndex &/*index*/) const
 {
+    NanotraceHR::Tracer tracer{"name item delegate update editor geometry", category()};
+
     auto lineEdit = static_cast<QLineEdit*>(editor);
     lineEdit->setTextMargins(0, 0, 0, 2);
     // + 2 is shifting the QLineEdit to the left so it will align with the text when activated

src/plugins/qmldesigner/components/navigator/navigatorsearchwidget.cpp

@@ -3,6 +3,8 @@
 
 #include "navigatorsearchwidget.h"
 
+#include "navigatortracing.h"
+
 #include <utils/stylehelper.h>
 #include <theme.h>
 
@@ -15,9 +17,13 @@
 
 namespace QmlDesigner {
 
+static auto category = NavigatorTracing::category;
+
 LineEdit::LineEdit(QWidget *parent)
     : QLineEdit(parent)
 {
+    NanotraceHR::Tracer tracer{"line edit constructor", category()};
+
     clearButton = new QToolButton(this);
 
     const QString fontName = "qtds_propertyIconFont.ttf";
@@ -74,6 +80,8 @@ LineEdit::LineEdit(QWidget *parent)
 
 void LineEdit::resizeEvent([[maybe_unused]] QResizeEvent *event)
 {
+    NanotraceHR::Tracer tracer{"line edit resize event", category()};
+
     QSize hint = clearButton->sizeHint();
     int frameWidth = style()->pixelMetric(QStyle::PM_DefaultFrameWidth);
 
@@ -83,6 +91,8 @@ void LineEdit::resizeEvent([[maybe_unused]] QResizeEvent *event)
 
 void LineEdit::keyPressEvent(QKeyEvent *event)
 {
+    NanotraceHR::Tracer tracer{"line edit key press event", category()};
+
     if (event->key() == Qt::Key_Escape && event->modifiers() == Qt::NoModifier) {
         clear();
         event->accept();
@@ -93,6 +103,8 @@ void LineEdit::keyPressEvent(QKeyEvent *event)
 
 void LineEdit::paintEvent(QPaintEvent *event)
 {
+    NanotraceHR::Tracer tracer{"line edit paint event", category()};
+
     if (text().isEmpty()) {
         QPalette p(palette());
         p.setColor(QPalette::Active,
@@ -108,12 +120,16 @@ void LineEdit::paintEvent(QPaintEvent *event)
 
 void LineEdit::updateClearButton(const QString& text)
 {
+    NanotraceHR::Tracer tracer{"line edit update clear button", category()};
+
     clearButton->setVisible(!text.isEmpty());
 }
 
 NavigatorSearchWidget::NavigatorSearchWidget(QWidget *parent)
     : QWidget(parent)
 {
+    NanotraceHR::Tracer tracer{"line edit constructor", category()};
+
     auto layout = new QBoxLayout(QBoxLayout::LeftToRight);
     layout->setSpacing(0);
     layout->setContentsMargins(10, 6, 10, 6);
@@ -136,6 +152,8 @@ NavigatorSearchWidget::NavigatorSearchWidget(QWidget *parent)
 
 void NavigatorSearchWidget::clear()
 {
+    NanotraceHR::Tracer tracer{"line edit clear", category()};
+
     m_textField->clear();
 }
 

src/plugins/qmldesigner/components/navigator/navigatortracing.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 "navigatortracing.h"
+
+#include <tracing/qmldesignertracing.h>
+
+#include <sqlitebasestatement.h>
+
+namespace QmlDesigner::NavigatorTracing {
+using namespace NanotraceHR::Literals;
+namespace {
+
+thread_local Category category_{"model",
+                                Tracing::eventQueueWithStringArguments(),
+                                Tracing::eventQueueWithoutArguments(),
+                                category};
+
+} // namespace
+
+Category &category()
+{
+    return category_;
+}
+
+} // namespace QmlDesigner::NavigatorTracing

src/plugins/qmldesigner/components/navigator/navigatortracing.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::NavigatorTracing {
+
+constexpr NanotraceHR::Tracing tracingStatus()
+{
+#ifdef ENABLE_NAVIGATOR_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::NavigatorTracing

src/plugins/qmldesigner/components/navigator/navigatortreemodel.cpp

@@ -3,13 +3,15 @@
 
 #include "navigatortreemodel.h"
 
-#include "assetslibrarywidget.h"
 #include "choosefrompropertylistdialog.h"
-#include "createtexture.h"
+#include "navigatortracing.h"
 #include "navigatorview.h"
 #include "navigatorwidget.h"
-#include "qmldesignerconstants.h"
+
-#include "qmldesignerplugin.h"
+#include <assetslibrarywidget.h>
+#include <createtexture.h>
+#include <qmldesignerconstants.h>
+#include <qmldesignerplugin.h>
 #include <qmldesignertr.h>
 
 #include <abstractview.h>
@@ -55,6 +57,8 @@
 
 namespace QmlDesigner {
 
+static auto category = NavigatorTracing::category;
+
 static QList<ModelNode> modelNodesFromMimeData(const QMimeData *mimeData, AbstractView *view)
 {
     QByteArray encodedModelNodeData = mimeData->data(Constants::MIME_TYPE_MODELNODE_LIST);
@@ -223,13 +227,20 @@ static QColor nodeColor(const ModelNode &node)
 NavigatorTreeModel::NavigatorTreeModel(QObject *parent)
     : QAbstractItemModel(parent)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model constructor", category()};
+
     m_actionManager = &QmlDesignerPlugin::instance()->viewManager().designerActionManager();
 }
 
-NavigatorTreeModel::~NavigatorTreeModel() = default;
+NavigatorTreeModel::~NavigatorTreeModel()
+{
+    NanotraceHR::Tracer tracer{"navigator tree model destructor", category()};
+}
 
 QVariant NavigatorTreeModel::data(const QModelIndex &index, int role) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model data", category()};
+
     if (!index.isValid())
         return QVariant();
 
@@ -309,6 +320,8 @@ QVariant NavigatorTreeModel::data(const QModelIndex &index, int role) const
 
 Qt::ItemFlags NavigatorTreeModel::flags(const QModelIndex &index) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model flags", category()};
+
     if (modelNodeForIndex(index).isRootNode()) {
         Qt::ItemFlags flags = Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDropEnabled;
         if (index.column() == ColumnType::Name)
@@ -353,6 +366,8 @@ static void appendForcedNodes(const NodeListProperty &property, QList<ModelNode>
 
 QList<ModelNode> NavigatorTreeModel::filteredList(const NodeListProperty &property, bool filter, bool reverseOrder) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model filtered list", category()};
+
     auto it = m_rowCache.find(property.parentModelNode());
 
     if (it != m_rowCache.end())
@@ -395,6 +410,8 @@ QList<ModelNode> NavigatorTreeModel::filteredList(const NodeListProperty &proper
 
 QModelIndex NavigatorTreeModel::index(int row, int column, const QModelIndex &parent) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model index", category()};
+
     if (!m_view->model())
         return {};
 
@@ -432,11 +449,15 @@ QModelIndex NavigatorTreeModel::index(int row, int column, const QModelIndex &pa
 
 QVariant NavigatorTreeModel::headerData(int, Qt::Orientation, int) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model header data", category()};
+
     return QVariant();
 }
 
 QModelIndex NavigatorTreeModel::parent(const QModelIndex &index) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model parent", category()};
+
     if (!index.isValid())
         return {};
 
@@ -467,6 +488,8 @@ QModelIndex NavigatorTreeModel::parent(const QModelIndex &index) const
 
 int NavigatorTreeModel::rowCount(const QModelIndex &parent) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model row count", category()};
+
     if (!m_view->isAttached() || parent.column() > 0 || isReference(parent))
         return 0;
 
@@ -491,6 +514,8 @@ int NavigatorTreeModel::rowCount(const QModelIndex &parent) const
 
 int NavigatorTreeModel::columnCount(const QModelIndex &parent) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model column count", category()};
+
     if (parent.column() > 0)
         return 0;
 
@@ -499,6 +524,8 @@ int NavigatorTreeModel::columnCount(const QModelIndex &parent) const
 
 ModelNode NavigatorTreeModel::modelNodeForIndex(const QModelIndex &index) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model model node for index", category()};
+
     if (!index.isValid())
         return ModelNode();
 
@@ -513,6 +540,8 @@ ModelNode NavigatorTreeModel::modelNodeForIndex(const QModelIndex &index) const
 
 bool NavigatorTreeModel::hasModelNodeForIndex(const QModelIndex &index) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model has model node for index", category()};
+
     if (!index.isValid())
         return false;
 
@@ -521,11 +550,15 @@ bool NavigatorTreeModel::hasModelNodeForIndex(const QModelIndex &index) const
 
 void NavigatorTreeModel::setView(NavigatorView *view)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model set view", category()};
+
     m_view = view;
 }
 
 QStringList NavigatorTreeModel::mimeTypes() const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model mime types", category()};
+
     static const QStringList types({Constants::MIME_TYPE_MODELNODE_LIST,
                                     Constants::MIME_TYPE_ITEM_LIBRARY_INFO,
                                     Constants::MIME_TYPE_TEXTURE,
@@ -540,6 +573,8 @@ QStringList NavigatorTreeModel::mimeTypes() const
 
 QMimeData *NavigatorTreeModel::mimeData(const QModelIndexList &modelIndexList) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model mime data", category()};
+
     auto mimeData = new QMimeData();
 
     QByteArray encodedModelNodeData;
@@ -563,11 +598,15 @@ QMimeData *NavigatorTreeModel::mimeData(const QModelIndexList &modelIndexList) c
 
 QModelIndex NavigatorTreeModel::indexForModelNode(const ModelNode &node) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model index for model node", category()};
+
     return m_nodeIndexHash.value(node);
 }
 
 QModelIndex NavigatorTreeModel::createIndexFromModelNode(int row, int column, const ModelNode &modelNode) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model create index from model node", category()};
+
     QModelIndex index = createIndex(row, column, modelNode.internalId());
     if (column == 0)
         m_nodeIndexHash.insert(modelNode, index);
@@ -615,6 +654,8 @@ bool NavigatorTreeModel::dropMimeData(const QMimeData *mimeData,
                                       int /*columnNumber*/,
                                       const QModelIndex &dropModelIndex)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model drop mime data", category()};
+
     if (action == Qt::IgnoreAction)
         return true;
 
@@ -777,6 +818,8 @@ void NavigatorTreeModel::handleInternalDrop(const QMimeData *mimeData,
                                             int rowNumber,
                                             const QModelIndex &dropModelIndex)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model handle internal drop", category()};
+
     QTC_ASSERT(m_view, return);
     const QModelIndex rowModelIndex = dropModelIndex.sibling(dropModelIndex.row(), 0);
     int targetRowNumber = rowNumber;
@@ -804,6 +847,8 @@ static ItemLibraryEntry createItemLibraryEntryFromMimeData(const QByteArray &dat
 
 void NavigatorTreeModel::handleItemLibraryItemDrop(const QMimeData *mimeData, int rowNumber, const QModelIndex &dropModelIndex)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model handle item library item drop", category()};
+
     QTC_ASSERT(m_view, return);
 
     const QModelIndex rowModelIndex = dropModelIndex.sibling(dropModelIndex.row(), 0);
@@ -915,6 +960,8 @@ void NavigatorTreeModel::handleItemLibraryItemDrop(const QMimeData *mimeData, in
 
 void NavigatorTreeModel::addImport(const QString &importName)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model add import", category()};
+
 #ifdef QDS_USE_PROJECTSTORAGE
     Import import = Import::createLibraryImport(importName);
     m_view->model()->changeImports({import}, {});
@@ -927,6 +974,8 @@ void NavigatorTreeModel::addImport(const QString &importName)
 bool QmlDesigner::NavigatorTreeModel::moveNodeToParent(const NodeAbstractProperty &targetProperty,
                                                        const ModelNode &node)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model move node to parent", category()};
+
     NodeAbstractProperty parentProp = targetProperty.parentProperty();
     if (parentProp.isValid()) {
         ModelNode targetModel = parentProp.parentModelNode();
@@ -938,6 +987,8 @@ bool QmlDesigner::NavigatorTreeModel::moveNodeToParent(const NodeAbstractPropert
 
 QIcon NavigatorTreeModel::colorizeIcon(const QIcon &icon, const QColor &color) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model colorize icon", category()};
+
     if (!color.isValid())
         return icon;
 
@@ -966,6 +1017,8 @@ void NavigatorTreeModel::moveNodesInteractive(NodeAbstractProperty &parentProper
                                               int targetIndex,
                                               bool executeInTransaction)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model move nodes interactive", category()};
+
     QTC_ASSERT(m_view, return);
 
     auto doMoveNodesInteractive = [&parentProperty, modelNodes, targetIndex]() {
@@ -1024,16 +1077,22 @@ void NavigatorTreeModel::moveNodesInteractive(NodeAbstractProperty &parentProper
 
 Qt::DropActions NavigatorTreeModel::supportedDropActions() const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model supported drop actions", category()};
+
     return Qt::LinkAction | Qt::MoveAction;
 }
 
 Qt::DropActions NavigatorTreeModel::supportedDragActions() const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model supported drag actions", category()};
+
     return Qt::LinkAction;
 }
 
 bool NavigatorTreeModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model set data", category()};
+
     QTC_ASSERT(m_view, return false);
     ModelNode modelNode = modelNodeForIndex(index);
     if (index.column() == ColumnType::Alias && role == Qt::CheckStateRole) {
@@ -1053,6 +1112,8 @@ bool NavigatorTreeModel::setData(const QModelIndex &index, const QVariant &value
 
 void NavigatorTreeModel::notifyDataChanged(const ModelNode &modelNode)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model notify data changed", category()};
+
     const auto emitDataChanged = [this](const QModelIndex &index) {
         const QAbstractItemModel *model = index.model();
         const QModelIndex sibling = model ? model->sibling(index.row(), ColumnType::Count - 1, index)
@@ -1081,12 +1142,16 @@ static QList<ModelNode> collectParents(const QList<ModelNode> &modelNodes)
 
 QList<QPersistentModelIndex> NavigatorTreeModel::nodesToPersistentIndex(const QList<ModelNode> &modelNodes)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model nodes to persistent index", category()};
+
     return ::Utils::transform<QList<QPersistentModelIndex>>(
         modelNodes, std::bind_front(&NavigatorTreeModel::indexForModelNode, this));
 }
 
 void NavigatorTreeModel::notifyModelNodesRemoved(const QList<ModelNode> &modelNodes)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model notify model nodes removed", category()};
+
     for (const ModelNode &modelNode : modelNodes)
         m_referenceIndexHash.remove(modelNode);
 
@@ -1099,6 +1164,8 @@ void NavigatorTreeModel::notifyModelNodesRemoved(const QList<ModelNode> &modelNo
 
 void NavigatorTreeModel::notifyModelNodesInserted(const QList<ModelNode> &modelNodes)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model notify model nodes inserted", category()};
+
     m_rowReferenceCache.clear();
     m_rowCache.clear();
     QList<QPersistentModelIndex> indexes = nodesToPersistentIndex(collectParents(modelNodes));
@@ -1108,6 +1175,8 @@ void NavigatorTreeModel::notifyModelNodesInserted(const QList<ModelNode> &modelN
 
 void NavigatorTreeModel::notifyModelNodesMoved(const QList<ModelNode> &modelNodes)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model notify model nodes moved", category()};
+
     m_rowReferenceCache.clear();
     m_rowCache.clear();
     QList<QPersistentModelIndex> indexes = nodesToPersistentIndex(collectParents(modelNodes));
@@ -1117,6 +1186,9 @@ void NavigatorTreeModel::notifyModelNodesMoved(const QList<ModelNode> &modelNode
 
 void NavigatorTreeModel::notifyModelReferenceNodesUpdated(const QList<ModelNode> &modelNodes)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model notify model reference nodes updated",
+                               category()};
+
     for (const ModelNode &modelNode : modelNodes)
         m_rowReferenceCache.remove(modelNode);
 
@@ -1127,11 +1199,15 @@ void NavigatorTreeModel::notifyModelReferenceNodesUpdated(const QList<ModelNode>
 
 void NavigatorTreeModel::notifyIconsChanged()
 {
+    NanotraceHR::Tracer tracer{"navigator tree model notify icons changed", category()};
+
     emit dataChanged(index(0, 0), index(rowCount(), 0), {Qt::DecorationRole});
 }
 
 void NavigatorTreeModel::showReferences(bool show)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model show references", category()};
+
     m_showReferenceItems = show;
     m_rowCache.clear();
     resetModel();
@@ -1139,6 +1215,8 @@ void NavigatorTreeModel::showReferences(bool show)
 
 void NavigatorTreeModel::setFilter(bool showOnlyVisibleItems)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model set filter", category()};
+
     m_showOnlyVisibleItems = showOnlyVisibleItems;
     m_rowCache.clear();
     resetModel();
@@ -1146,6 +1224,8 @@ void NavigatorTreeModel::setFilter(bool showOnlyVisibleItems)
 
 void NavigatorTreeModel::setNameFilter(const QString &filter)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model set name filter", category()};
+
     m_nameFilter = filter;
     m_rowCache.clear();
 
@@ -1175,6 +1255,8 @@ void NavigatorTreeModel::setNameFilter(const QString &filter)
 
 void NavigatorTreeModel::setOrder(bool reverseItemOrder)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model set order", category()};
+
     m_reverseItemOrder = reverseItemOrder;
     m_rowCache.clear();
     resetModel();
@@ -1182,6 +1264,8 @@ void NavigatorTreeModel::setOrder(bool reverseItemOrder)
 
 void NavigatorTreeModel::resetModel()
 {
+    NanotraceHR::Tracer tracer{"navigator tree model reset model", category()};
+
     beginResetModel();
     m_rowCache.clear();
     m_nodeIndexHash.clear();
@@ -1192,16 +1276,22 @@ void NavigatorTreeModel::resetModel()
 
 void NavigatorTreeModel::updateToolTipPixmap(const ModelNode &node, const QPixmap &pixmap)
 {
+    NanotraceHR::Tracer tracer{"navigator tree model update tool tip pixmap", category()};
+
     emit toolTipPixmapUpdated(node.id(), pixmap);
 }
 
 bool NavigatorTreeModel::isReferenceNodesVisible() const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model is reference nodes visible", category()};
+
     return m_showReferenceItems;
 }
 
 bool NavigatorTreeModel::canBeReference(const ModelNode &modelNode) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model can be reference", category()};
+
     return modelNode.hasMetaInfo();
 }
 
@@ -1209,6 +1299,8 @@ QModelIndex NavigatorTreeModel::createReferenceIndex(int row,
                                                      int column,
                                                      const ReferenceData &referenceData) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model create reference index", category()};
+
     const QString uniqueId = QString("%1-%2-%3")
                                  .arg(referenceData.owner.internalId())
                                  .arg(referenceData.current.internalId())
@@ -1226,6 +1318,8 @@ QModelIndex NavigatorTreeModel::createReferenceIndex(int row,
 
 void NavigatorTreeModel::resetReferences()
 {
+    NanotraceHR::Tracer tracer{"navigator tree model reset references", category()};
+
     m_rowReferenceCache.clear();
     m_referenceIndexHash.clear();
     m_referenceUnique.clear();
@@ -1235,6 +1329,8 @@ void NavigatorTreeModel::resetReferences()
 
 QList<ModelNode> NavigatorTreeModel::referenceList(const QList<BindingProperty> &bindingProperties, const QList<ModelNode> &unwanted) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model reference list", category()};
+
     if (bindingProperties.isEmpty())
         return {};
 
@@ -1261,17 +1357,23 @@ QList<ModelNode> NavigatorTreeModel::referenceList(const QList<BindingProperty>
 
 bool NavigatorTreeModel::isReference(const QModelIndex &index) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model is reference", category()};
+
     return m_references.contains(index.internalId());
 }
 
 ModelNode NavigatorTreeModel::referenceExtractCurrent(const QModelIndex &index) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model reference extract current", category()};
+
     Q_ASSERT(isReference(index));
     return m_references[index.internalId()].current;
 }
 
 ModelNode NavigatorTreeModel::referenceExtractOwner(const QModelIndex &index) const
 {
+    NanotraceHR::Tracer tracer{"navigator tree model reference extract owner", category()};
+
     Q_ASSERT(isReference(index));
     return m_references[index.internalId()].owner;
 }

src/plugins/qmldesigner/components/navigator/navigatortreeview.cpp

@@ -3,13 +3,14 @@
 
 #include "navigatortreeview.h"
 
+#include "navigatortracing.h"
+#include "navigatortreemodel.h"
+#include "navigatorview.h"
+#include "previewtooltip.h"
+
 #include <qmath.h>
 
-#include "modelnode.h"
+#include <modelnode.h>
-#include "navigatorview.h"
-#include "navigatortreemodel.h"
-#include "qproxystyle.h"
-#include "previewtooltip.h"
 
 #include <qmldesignerbase/studio/studiostyle.h>
 
@@ -18,19 +19,22 @@
 #include <utils/icon.h>
 #include <utils/utilsicons.h>
 
-#include <QLineEdit>
+#include <qproxystyle.h>
-#include <QPen>
-#include <QPixmapCache>
-#include <QMouseEvent>
-#include <QPainter>
-#include <QStyleFactory>
 #include <QEvent>
 #include <QImage>
+#include <QLineEdit>
+#include <QMouseEvent>
+#include <QPainter>
+#include <QPen>
+#include <QPixmapCache>
+#include <QStyleFactory>
 
 namespace QmlDesigner {
 
 namespace {
 
+auto category = NavigatorTracing::category;
+
 // This style basically allows us to span the entire row
 // including the arrow indicators which would otherwise not be
 // drawn by the delegate
@@ -40,6 +44,8 @@ public:
     TableViewStyle(QObject *parent)
         : QProxyStyle(new StudioStyle("fusion"))
     {
+        NanotraceHR::Tracer tracer{"table view style constructor", category()};
+
         setParent(parent);
         baseStyle()->setParent(parent);
     }
@@ -49,6 +55,8 @@ public:
                        QPainter *painter,
                        const QWidget *widget = nullptr) const override
     {
+        NanotraceHR::Tracer tracer{"table view style draw primitive", category()};
+
         static QRect mouseOverStateSavedFrameRectangle;
         if (element == QStyle::PE_PanelItemViewRow) {
             if (option->state & QStyle::State_MouseOver)
@@ -136,6 +144,8 @@ public:
                   const QWidget *widget = nullptr,
                   QStyleHintReturn *returnData = nullptr) const override
     {
+        NanotraceHR::Tracer tracer{"table view style style hint", category()};
+
         if (hint == SH_ItemView_ShowDecorationSelected)
             return 0;
         else
@@ -145,12 +155,16 @@ public:
 private: // functions
     QColor highlightBrushColor() const
     {
+        NanotraceHR::Tracer tracer{"table view style highlight brush color", category()};
+
         QColor color = Theme::getColor(Theme::Color::DSnavigatorDropIndicatorBackground);
         color.setAlphaF(0.7f);
         return color;
     }
     QColor highlightLineColor() const
     {
+        NanotraceHR::Tracer tracer{"table view style highlight line color", category()};
+
         QColor color = Theme::getColor(Theme::Color::DSnavigatorDropIndicatorOutline);
         color.setAlphaF(0.7f);
         return color;
@@ -158,6 +172,8 @@ private: // functions
 
     void drawHighlightFrame(const QRect &frameRectangle, QPainter *painter) const
     {
+        NanotraceHR::Tracer tracer{"table view style draw highlight frame", category()};
+
         painter->setPen(QPen(highlightLineColor(), 2));
         painter->setBrush(highlightBrushColor());
         painter->drawRect(frameRectangle);
@@ -165,12 +181,16 @@ private: // functions
 
     void drawIndicatorLine(const QPoint &leftPoint, const QPoint &rightPoint, QPainter *painter) const
     {
+        NanotraceHR::Tracer tracer{"table view style draw indicator line", category()};
+
         painter->setPen(QPen(highlightLineColor(), 3));
         painter->drawLine(leftPoint, rightPoint);
     }
 
     QRect adjustedRectangleToWidgetWidth(const QRect &originalRectangle, const QWidget *widget) const
     {
+        NanotraceHR::Tracer tracer{"table view style adjusted rectangle to widget width", category()};
+
         QRect adjustesRectangle = originalRectangle;
         adjustesRectangle.setLeft(0);
         adjustesRectangle.setWidth(widget->rect().width());
@@ -185,6 +205,8 @@ private: // variables
 NavigatorTreeView::NavigatorTreeView(QWidget *parent)
     : QTreeView(parent)
 {
+    NanotraceHR::Tracer tracer{"navigator tree view constructor", category()};
+
     setStyle(new TableViewStyle(this));
     setMinimumWidth(240);
     setRootIsDecorated(false);
@@ -194,6 +216,8 @@ NavigatorTreeView::NavigatorTreeView(QWidget *parent)
 
 void NavigatorTreeView::drawSelectionBackground(QPainter *painter, const QStyleOption &option)
 {
+    NanotraceHR::Tracer tracer{"navigator tree view draw selection background", category()};
+
     painter->save();
     painter->fillRect(option.rect.adjusted(0, delegateMargin, 0, -delegateMargin),
                       Theme::getColor(Theme::Color::DSnavigatorItemBackgroundSelected));
@@ -202,6 +226,8 @@ void NavigatorTreeView::drawSelectionBackground(QPainter *painter, const QStyleO
 
 bool NavigatorTreeView::viewportEvent(QEvent *event)
 {
+    NanotraceHR::Tracer tracer{"navigator tree view viewport event", category()};
+
     const QPoint offset(10, 5);
 
     if (event->type() == QEvent::ToolTip) {
@@ -260,6 +286,8 @@ bool NavigatorTreeView::viewportEvent(QEvent *event)
 
 void NavigatorTreeView::mousePressEvent(QMouseEvent *event)
 {
+    NanotraceHR::Tracer tracer{"navigator tree view mouse press event", category()};
+
     m_clickedIndex = indexAt(event->pos());
     if (auto navModel = qobject_cast<NavigatorTreeModel *>(model())) {
         if (navModel->isReference(m_clickedIndex)) {
@@ -279,6 +307,8 @@ void NavigatorTreeView::mousePressEvent(QMouseEvent *event)
 
 void NavigatorTreeView::mouseReleaseEvent(QMouseEvent *event)
 {
+    NanotraceHR::Tracer tracer{"navigator tree view mouse release event", category()};
+
     const QModelIndex modelIndex = indexAt(event->pos());
     if (m_clickedIndex == modelIndex) {
         if (auto navModel = qobject_cast<NavigatorTreeModel *>(model())) {
@@ -299,6 +329,8 @@ void NavigatorTreeView::mouseReleaseEvent(QMouseEvent *event)
 
 void NavigatorTreeView::startDrag(Qt::DropActions supportedActions)
 {
+    NanotraceHR::Tracer tracer{"navigator tree view start drag", category()};
+
     if (m_dragAllowed) {
         if (m_previewToolTip) {
             // Workaround to ensure tooltip doesn't linger during drag, as drag grabs all mouse

src/plugins/qmldesigner/components/navigator/navigatorview.cpp

@@ -5,6 +5,7 @@
 
 #include "iconcheckboxitemdelegate.h"
 #include "nameitemdelegate.h"
+#include "navigatortracing.h"
 #include "navigatortreemodel.h"
 #include "navigatorwidget.h"
 
@@ -17,13 +18,13 @@
 #include <nodeinstanceview.h>
 #include <nodelistproperty.h>
 #include <nodeproperty.h>
-#include <rewritingexception.h>
-#include <theme.h>
-#include <variantproperty.h>
 #include <qmldesignerconstants.h>
 #include <qmldesignericons.h>
 #include <qmldesignerplugin.h>
 #include <qmlitemnode.h>
+#include <rewritingexception.h>
+#include <theme.h>
+#include <variantproperty.h>
 
 #include <coreplugin/editormanager/editormanager.h>
 #include <coreplugin/icore.h>
@@ -42,6 +43,8 @@
 #include <QPixmap>
 #include <QTimer>
 
+static auto category = QmlDesigner::NavigatorTracing::category;
+
 inline static void setScenePos(const QmlDesigner::ModelNode &modelNode, const QPointF &pos)
 {
     if (modelNode.hasParentProperty() && QmlDesigner::QmlItemNode::isValidQmlItemNode(modelNode.parentProperty().parentModelNode())) {
@@ -94,22 +97,28 @@ NavigatorView::NavigatorView(ExternalDependenciesInterface &externalDependencies
     : AbstractView{externalDependencies}
     , m_blockSelectionChangedSignal(false)
 {
-
+    NanotraceHR::Tracer tracer{"navigator view constructor", category()};
 }
 
 NavigatorView::~NavigatorView()
 {
+    NanotraceHR::Tracer tracer{"navigator view destructor", category()};
+
     if (m_widget && !m_widget->parent())
         delete m_widget.data();
 }
 
 bool NavigatorView::hasWidget() const
 {
+    NanotraceHR::Tracer tracer{"navigator view has widget", category()};
+
     return true;
 }
 
 WidgetInfo NavigatorView::widgetInfo()
 {
+    NanotraceHR::Tracer tracer{"navigator view widget info", category()};
+
     if (!m_widget)
         setupWidget();
 
@@ -122,6 +131,8 @@ WidgetInfo NavigatorView::widgetInfo()
 
 void NavigatorView::modelAttached(Model *model)
 {
+    NanotraceHR::Tracer tracer{"navigator view model attached", category()};
+
     AbstractView::modelAttached(model);
 
     QTreeView *treeView = treeWidget();
@@ -185,6 +196,8 @@ void NavigatorView::modelAttached(Model *model)
 
 void NavigatorView::clearExplorerWarnings()
 {
+    NanotraceHR::Tracer tracer{"navigator view clear explorer warnings", category()};
+
     QList<ModelNode> allNodes;
     allNodes.append(rootModelNode());
     allNodes.append(rootModelNode().allSubModelNodes());
@@ -199,6 +212,8 @@ void NavigatorView::clearExplorerWarnings()
 
 void NavigatorView::modelAboutToBeDetached(Model *model)
 {
+    NanotraceHR::Tracer tracer{"navigator view model about to be detached", category()};
+
     QHash<QString, bool> &localExpandMap = m_expandMap[model->fileUrl()];
 
     // If detaching full document model, recreate expand map from scratch to remove stale entries.
@@ -241,12 +256,16 @@ void NavigatorView::modelAboutToBeDetached(Model *model)
 
 void NavigatorView::importsChanged(const Imports &/*addedImports*/, const Imports &/*removedImports*/)
 {
+    NanotraceHR::Tracer tracer{"navigator view imports changed", category()};
+
     treeWidget()->update();
 }
 
 void NavigatorView::bindingPropertiesChanged(const QList<BindingProperty> &propertyList,
                                              PropertyChangeFlags /*propertyChange*/)
 {
+    NanotraceHR::Tracer tracer{"navigator view binding properties changed", category()};
+
     QSet<ModelNode> owners;
 
     for (const BindingProperty &bindingProperty : propertyList) {
@@ -274,6 +293,8 @@ void NavigatorView::bindingPropertiesChanged(const QList<BindingProperty> &prope
 
 void NavigatorView::dragStarted(QMimeData *mimeData)
 {
+    NanotraceHR::Tracer tracer{"navigator view drag started", category()};
+
     if (mimeData->hasFormat(Constants::MIME_TYPE_ITEM_LIBRARY_INFO)) {
         QByteArray data = mimeData->data(Constants::MIME_TYPE_ITEM_LIBRARY_INFO);
         QDataStream stream(data);
@@ -345,6 +366,8 @@ void NavigatorView::dragStarted(QMimeData *mimeData)
 
 void NavigatorView::dragEnded()
 {
+    NanotraceHR::Tracer tracer{"navigator view drag ended", category()};
+
     m_widget->setDragType("");
     m_widget->update();
 }
@@ -354,12 +377,16 @@ void NavigatorView::customNotification([[maybe_unused]] const AbstractView *view
                                        [[maybe_unused]] const QList<ModelNode> &nodeList,
                                        [[maybe_unused]] const QList<QVariant> &data)
 {
+    NanotraceHR::Tracer tracer{"navigator view custom notification", category()};
+
     if (identifier == "asset_import_update")
         m_currentModelInterface->notifyIconsChanged();
 }
 
 void NavigatorView::handleChangedExport(const ModelNode &modelNode, bool exported)
 {
+    NanotraceHR::Tracer tracer{"navigator view handle changed export", category()};
+
     const ModelNode rootNode = rootModelNode();
     Q_ASSERT(rootNode.isValid());
     const PropertyName modelNodeId = modelNode.id().toUtf8();
@@ -375,17 +402,23 @@ void NavigatorView::handleChangedExport(const ModelNode &modelNode, bool exporte
 
 bool NavigatorView::isNodeInvisible(const ModelNode &modelNode) const
 {
+    NanotraceHR::Tracer tracer{"navigator view is node invisible", category()};
+
     return QmlVisualNode(modelNode).visibilityOverride();
 }
 
 void NavigatorView::disableWidget()
 {
+    NanotraceHR::Tracer tracer{"navigator view disable widget", category()};
+
     if (m_widget)
         m_widget->disableNavigator();
 }
 
 void NavigatorView::enableWidget()
 {
+    NanotraceHR::Tracer tracer{"navigator view enable widget", category()};
+
     if (m_widget)
         m_widget->enableNavigator();
 }
@@ -394,6 +427,8 @@ void NavigatorView::modelNodePreviewPixmapChanged(const ModelNode &node,
                                                   const QPixmap &pixmap,
                                                   const QByteArray &requestId)
 {
+    NanotraceHR::Tracer tracer{"navigator view model node preview pixmap changed", category()};
+
     // There might be multiple requests for different preview pixmap sizes.
     // Here only the one with the default size is picked.
     if (requestId.isEmpty())
@@ -402,6 +437,8 @@ void NavigatorView::modelNodePreviewPixmapChanged(const ModelNode &node,
 
 ModelNode NavigatorView::modelNodeForIndex(const QModelIndex &modelIndex) const
 {
+    NanotraceHR::Tracer tracer{"navigator view model node for index", category()};
+
     return modelIndex.model()->data(modelIndex, ModelNodeRole).value<ModelNode>();
 }
 
@@ -413,6 +450,8 @@ void NavigatorView::nodeRemoved(const ModelNode &removedNode,
                                 const NodeAbstractProperty & /*parentProperty*/,
                                 AbstractView::PropertyChangeFlags /*propertyChange*/)
 {
+    NanotraceHR::Tracer tracer{"navigator view node removed", category()};
+
     m_currentModelInterface->notifyModelNodesRemoved({removedNode});
 }
 
@@ -421,6 +460,8 @@ void NavigatorView::nodeReparented(const ModelNode &modelNode,
                                    const NodeAbstractProperty & oldPropertyParent,
                                    AbstractView::PropertyChangeFlags /*propertyChange*/)
 {
+    NanotraceHR::Tracer tracer{"navigator view node reparented", category()};
+
     if (!oldPropertyParent.isValid())
         m_currentModelInterface->notifyModelNodesInserted({modelNode});
     else
@@ -433,6 +474,8 @@ void NavigatorView::nodeReparented(const ModelNode &modelNode,
 
 void NavigatorView::nodeIdChanged(const ModelNode& modelNode, const QString & /*newId*/, const QString & /*oldId*/)
 {
+    NanotraceHR::Tracer tracer{"navigator view node id changed", category()};
+
     m_currentModelInterface->notifyDataChanged(modelNode);
 }
 
@@ -442,6 +485,8 @@ void NavigatorView::propertiesAboutToBeRemoved(const QList<AbstractProperty> &/*
 
 void NavigatorView::propertiesRemoved(const QList<AbstractProperty> &propertyList)
 {
+    NanotraceHR::Tracer tracer{"navigator view properties removed", category()};
+
     QList<ModelNode> modelNodes;
     for (const AbstractProperty &property : propertyList) {
         if (property.isNodeAbstractProperty()) {
@@ -455,11 +500,15 @@ void NavigatorView::propertiesRemoved(const QList<AbstractProperty> &propertyLis
 
 void NavigatorView::rootNodeTypeChanged(const QString &/*type*/, int /*majorVersion*/, int /*minorVersion*/)
 {
+    NanotraceHR::Tracer tracer{"navigator view root node type changed", category()};
+
     m_currentModelInterface->notifyDataChanged(rootModelNode());
 }
 
 void NavigatorView::nodeTypeChanged(const ModelNode &modelNode, const TypeName &, int , int)
 {
+    NanotraceHR::Tracer tracer{"navigator view node type changed", category()};
+
     m_currentModelInterface->notifyDataChanged(modelNode);
 }
 
@@ -467,6 +516,8 @@ void NavigatorView::auxiliaryDataChanged(const ModelNode &modelNode,
                                          [[maybe_unused]] AuxiliaryDataKeyView key,
                                          [[maybe_unused]] const QVariant &data)
 {
+    NanotraceHR::Tracer tracer{"navigator view auxiliary data changed", category()};
+
     m_currentModelInterface->notifyDataChanged(modelNode);
 
     if (key == lockedProperty) {
@@ -479,6 +530,8 @@ void NavigatorView::auxiliaryDataChanged(const ModelNode &modelNode,
 
 void NavigatorView::instanceErrorChanged(const QVector<ModelNode> &errorNodeList)
 {
+    NanotraceHR::Tracer tracer{"navigator view instance error changed", category()};
+
     for (const ModelNode &modelNode : errorNodeList) {
         m_currentModelInterface->notifyDataChanged(modelNode);
         propagateInstanceErrorToExplorer(modelNode);
@@ -487,6 +540,8 @@ void NavigatorView::instanceErrorChanged(const QVector<ModelNode> &errorNodeList
 
 void NavigatorView::nodeOrderChanged(const NodeListProperty &listProperty)
 {
+    NanotraceHR::Tracer tracer{"navigator view node order changed", category()};
+
     m_currentModelInterface->notifyModelNodesMoved(listProperty.directSubNodes());
 
     // make sure selection is in sync again
@@ -495,6 +550,8 @@ void NavigatorView::nodeOrderChanged(const NodeListProperty &listProperty)
 
 void NavigatorView::changeToComponent(const QModelIndex &index)
 {
+    NanotraceHR::Tracer tracer{"navigator view change to component", category()};
+
     if (index.isValid() && currentModel()->data(index, Qt::UserRole).isValid()) {
         const ModelNode doubleClickNode = modelNodeForIndex(index);
         if (doubleClickNode.metaInfo().isFileComponent())
@@ -507,16 +564,22 @@ void NavigatorView::changeToComponent(const QModelIndex &index)
 
 QModelIndex NavigatorView::indexForModelNode(const ModelNode &modelNode) const
 {
+    NanotraceHR::Tracer tracer{"navigator view index for model node", category()};
+
     return m_currentModelInterface->indexForModelNode(modelNode);
 }
 
 QAbstractItemModel *NavigatorView::currentModel() const
 {
+    NanotraceHR::Tracer tracer{"navigator view current model", category()};
+
     return treeWidget()->model();
 }
 
 const ProjectExplorer::FileNode *NavigatorView::fileNodeForModelNode(const ModelNode &node) const
 {
+    NanotraceHR::Tracer tracer{"navigator view file node for model node", category()};
+
     QString filename = ModelUtils::componentFilePath(node);
     Utils::FilePath filePath = Utils::FilePath::fromString(filename);
     ProjectExplorer::Project *currentProject = ProjectExplorer::ProjectManager::projectForFile(
@@ -539,6 +602,8 @@ const ProjectExplorer::FileNode *NavigatorView::fileNodeForModelNode(const Model
 
 const ProjectExplorer::FileNode *NavigatorView::fileNodeForIndex(const QModelIndex &index) const
 {
+    NanotraceHR::Tracer tracer{"navigator view file node for index", category()};
+
     if (index.isValid() && currentModel()->data(index, Qt::UserRole).isValid()) {
         ModelNode node = modelNodeForIndex(index);
         if (node.metaInfo().isFileComponent()) {
@@ -549,8 +614,11 @@ const ProjectExplorer::FileNode *NavigatorView::fileNodeForIndex(const QModelInd
     return nullptr;
 }
 
-void NavigatorView::propagateInstanceErrorToExplorer(const ModelNode &modelNode) {
+void NavigatorView::propagateInstanceErrorToExplorer(const ModelNode &modelNode)
-    QModelIndex index = indexForModelNode(modelNode);;
+{
+    NanotraceHR::Tracer tracer{"navigator view propagate instance error to explorer", category()};
+
+    QModelIndex index = indexForModelNode(modelNode);
 
     do {
         const ProjectExplorer::FileNode *fnode = fileNodeForIndex(index);
@@ -566,6 +634,8 @@ void NavigatorView::propagateInstanceErrorToExplorer(const ModelNode &modelNode)
 
 void NavigatorView::leftButtonClicked()
 {
+    NanotraceHR::Tracer tracer{"navigator view left button clicked", category()};
+
     if (selectedModelNodes().size() > 1)
         return; //Semantics are unclear for multi selection.
 
@@ -590,6 +660,8 @@ void NavigatorView::leftButtonClicked()
 
 void NavigatorView::rightButtonClicked()
 {
+    NanotraceHR::Tracer tracer{"navigator view right button clicked", category()};
+
     if (selectedModelNodes().size() > 1)
         return; //Semantics are unclear for multi selection.
 
@@ -634,6 +706,8 @@ void NavigatorView::rightButtonClicked()
 
 void NavigatorView::upButtonClicked()
 {
+    NanotraceHR::Tracer tracer{"navigator view up button clicked", category()};
+
     bool blocked = blockSelectionChangedSignal(true);
     bool reverse = QmlDesignerPlugin::settings().value(DesignerSettingsKey::NAVIGATOR_REVERSE_ITEM_ORDER).toBool();
 
@@ -648,6 +722,8 @@ void NavigatorView::upButtonClicked()
 
 void NavigatorView::downButtonClicked()
 {
+    NanotraceHR::Tracer tracer{"navigator view down button clicked", category()};
+
     bool blocked = blockSelectionChangedSignal(true);
     bool reverse = QmlDesignerPlugin::settings().value(DesignerSettingsKey::NAVIGATOR_REVERSE_ITEM_ORDER).toBool();
 
@@ -662,12 +738,16 @@ void NavigatorView::downButtonClicked()
 
 void NavigatorView::colorizeToggled(bool flag)
 {
+    NanotraceHR::Tracer tracer{"navigator view colorize toggled", category()};
+
     QmlDesignerPlugin::settings().insert(DesignerSettingsKey::NAVIGATOR_COLORIZE_ICONS, flag);
     m_currentModelInterface->notifyIconsChanged();
 }
 
 void NavigatorView::referenceToggled(bool flag)
 {
+    NanotraceHR::Tracer tracer{"navigator view reference toggled", category()};
+
     m_currentModelInterface->showReferences(flag);
     treeWidget()->expandAll();
     QmlDesignerPlugin::settings().insert(DesignerSettingsKey::NAVIGATOR_SHOW_REFERENCE_NODES, flag);
@@ -675,6 +755,8 @@ void NavigatorView::referenceToggled(bool flag)
 
 void NavigatorView::filterToggled(bool flag)
 {
+    NanotraceHR::Tracer tracer{"navigator view filter toggled", category()};
+
     m_currentModelInterface->setFilter(flag);
     treeWidget()->expandAll();
     QmlDesignerPlugin::settings().insert(DesignerSettingsKey::NAVIGATOR_SHOW_ONLY_VISIBLE_ITEMS, flag);
@@ -682,6 +764,8 @@ void NavigatorView::filterToggled(bool flag)
 
 void NavigatorView::reverseOrderToggled(bool flag)
 {
+    NanotraceHR::Tracer tracer{"navigator view reverse order toggled", category()};
+
     m_currentModelInterface->setOrder(flag);
     treeWidget()->expandAll();
     QmlDesignerPlugin::settings().insert(DesignerSettingsKey::NAVIGATOR_REVERSE_ITEM_ORDER, flag);
@@ -689,12 +773,16 @@ void NavigatorView::reverseOrderToggled(bool flag)
 
 void NavigatorView::textFilterChanged(const QString &text)
 {
+    NanotraceHR::Tracer tracer{"navigator view text filter changed", category()};
+
     m_treeModel->setNameFilter(text);
     treeWidget()->expandAll();
 }
 
 void NavigatorView::changeSelection(const QItemSelection & /*newSelection*/, const QItemSelection &/*deselected*/)
 {
+    NanotraceHR::Tracer tracer{"navigator view change selection", category()};
+
     if (m_blockSelectionChangedSignal)
         return;
 
@@ -713,12 +801,16 @@ void NavigatorView::changeSelection(const QItemSelection & /*newSelection*/, con
 
 void NavigatorView::selectedNodesChanged(const QList<ModelNode> &/*selectedNodeList*/, const QList<ModelNode> &/*lastSelectedNodeList*/)
 {
+    NanotraceHR::Tracer tracer{"navigator view selected nodes changed", category()};
+
     // Update selection asynchronously to ensure NavigatorTreeModel's index cache is up to date
     QTimer::singleShot(0, this, &NavigatorView::updateItemSelection);
 }
 
 void NavigatorView::updateItemSelection()
 {
+    NanotraceHR::Tracer tracer{"navigator view update item selection", category()};
+
     if (!isAttached())
         return;
 
@@ -761,6 +853,7 @@ void NavigatorView::updateItemSelection()
 
 QTreeView *NavigatorView::treeWidget() const
 {
+    NanotraceHR::Tracer tracer{"navigator view tree widget", category()};
     if (m_widget)
         return m_widget->treeView();
     return nullptr;
@@ -768,12 +861,16 @@ QTreeView *NavigatorView::treeWidget() const
 
 NavigatorTreeModel *NavigatorView::treeModel()
 {
+    NanotraceHR::Tracer tracer{"navigator view tree model", category()};
+
     return m_treeModel.data();
 }
 
 // along the lines of QObject::blockSignals
 bool NavigatorView::blockSelectionChangedSignal(bool block)
 {
+    NanotraceHR::Tracer tracer{"navigator view block selection changed signal", category()};
+
     bool oldValue = m_blockSelectionChangedSignal;
     m_blockSelectionChangedSignal = block;
     return oldValue;
@@ -781,6 +878,8 @@ bool NavigatorView::blockSelectionChangedSignal(bool block)
 
 void NavigatorView::expandAncestors(const QModelIndex &index)
 {
+    NanotraceHR::Tracer tracer{"navigator view expand ancestors", category()};
+
     QModelIndex currentIndex = index.parent();
     while (currentIndex.isValid()) {
         if (!treeWidget()->isExpanded(currentIndex))
@@ -791,6 +890,8 @@ void NavigatorView::expandAncestors(const QModelIndex &index)
 
 void NavigatorView::reparentAndCatch(NodeAbstractProperty property, const ModelNode &modelNode)
 {
+    NanotraceHR::Tracer tracer{"navigator view reparent and catch", category()};
+
     try {
         property.reparentHere(modelNode);
     } catch (Exception &exception) {
@@ -800,6 +901,8 @@ void NavigatorView::reparentAndCatch(NodeAbstractProperty property, const ModelN
 
 void NavigatorView::setupWidget()
 {
+    NanotraceHR::Tracer tracer{"navigator view setup widget", category()};
+
     m_widget = new NavigatorWidget(this);
     m_treeModel = new NavigatorTreeModel(this);
     m_treeModel->setView(this);

src/plugins/qmldesigner/components/navigator/navigatorwidget.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 "navigatorsearchwidget.h"
 #include "navigatorwidget.h"
+#include "navigatorsearchwidget.h"
+#include "navigatortracing.h"
 #include "navigatorview.h"
 
 #include <designeractionmanager.h>
@@ -29,10 +30,14 @@ using namespace Core;
 
 namespace QmlDesigner {
 
+static auto category = NavigatorTracing::category;
+
 NavigatorWidget::NavigatorWidget(NavigatorView *view)
     : m_treeView(new NavigatorTreeView)
     , m_navigatorView(view)
 {
+    NanotraceHR::Tracer tracer{"navigator widget constructor", category()};
+
     setAcceptDrops(true);
 
     m_treeView->setDragEnabled(true);
@@ -77,16 +82,22 @@ NavigatorWidget::NavigatorWidget(NavigatorView *view)
 
 void NavigatorWidget::setTreeModel(QAbstractItemModel *model)
 {
+    NanotraceHR::Tracer tracer{"navigator widget set tree model", category()};
+
     m_treeView->setModel(model);
 }
 
 QTreeView *NavigatorWidget::treeView() const
 {
+    NanotraceHR::Tracer tracer{"navigator widget tree view", category()};
+
     return m_treeView;
 }
 
 QList<QWidget *> NavigatorWidget::createToolBarWidgets()
 {
+    NanotraceHR::Tracer tracer{"navigator widget create toolbar widgets", category()};
+
     QList<QWidget *> buttons;
 
     auto empty = new QWidget();
@@ -212,6 +223,8 @@ QList<QWidget *> NavigatorWidget::createToolBarWidgets()
 
 QToolBar *NavigatorWidget::createToolBar()
 {
+    NanotraceHR::Tracer tracer{"navigator widget create toolbar", category()};
+
     const QList<QWidget *> buttons = createToolBarWidgets();
 
     auto toolBar = new QToolBar();
@@ -224,6 +237,8 @@ QToolBar *NavigatorWidget::createToolBar()
 
 void NavigatorWidget::contextHelp(const Core::IContext::HelpCallback &callback) const
 {
+    NanotraceHR::Tracer tracer{"navigator widget context help", category()};
+
     if (auto view = navigatorView()) {
         QmlDesignerPlugin::contextHelp(callback, view->contextHelpId());
     } else {
@@ -233,29 +248,40 @@ void NavigatorWidget::contextHelp(const Core::IContext::HelpCallback &callback)
 
 void NavigatorWidget::disableNavigator()
 {
+    NanotraceHR::Tracer tracer{"navigator widget disable navigator", category()};
+
     m_treeView->setEnabled(false);
 }
 
 void NavigatorWidget::enableNavigator()
 {
+    NanotraceHR::Tracer tracer{"navigator widget enable navigator", category()};
+
     m_treeView->setEnabled(true);
 }
 
 NavigatorView *NavigatorWidget::navigatorView() const
 {
+    NanotraceHR::Tracer tracer{"navigator widget navigator view", category()};
+
     return m_navigatorView.data();
 }
 
 void NavigatorWidget::dragEnterEvent(QDragEnterEvent *dragEnterEvent)
 {
+    NanotraceHR::Tracer tracer{"navigator widget drag enter event", category()};
+
     const DesignerActionManager &actionManager = QmlDesignerPlugin::instance()
-                                                     ->viewManager().designerActionManager();
+                                                     ->viewManager()
+                                                     .designerActionManager();
     if (actionManager.externalDragHasSupportedAssets(dragEnterEvent->mimeData()))
         dragEnterEvent->acceptProposedAction();
 }
 
 void NavigatorWidget::dropEvent(QDropEvent *dropEvent)
 {
+    NanotraceHR::Tracer tracer{"navigator widget drop event", category()};
+
     dropEvent->accept();
     const DesignerActionManager &actionManager = QmlDesignerPlugin::instance()
                                                      ->viewManager().designerActionManager();
@@ -264,16 +290,22 @@ void NavigatorWidget::dropEvent(QDropEvent *dropEvent)
 
 void NavigatorWidget::setDragType(const QByteArray &type)
 {
+    NanotraceHR::Tracer tracer{"navigator widget set drag type", category()};
+
     m_dragType = type;
 }
 
 QByteArray NavigatorWidget::dragType() const
 {
+    NanotraceHR::Tracer tracer{"navigator widget drag type", category()};
+
     return m_dragType;
 }
 
 void NavigatorWidget::clearSearch()
 {
+    NanotraceHR::Tracer tracer{"navigator widget clear search", category()};
+
     m_searchWidget->clear();
 }
 

src/plugins/qmldesigner/components/navigator/previewtooltip.cpp

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "previewtooltip.h"
+#include "navigatortracing.h"
 #include "ui_previewtooltip.h"
 
 #include <utils/theme/theme.h>
@@ -11,10 +12,14 @@
 
 namespace QmlDesigner {
 
+static auto category = NavigatorTracing::category;
+
 PreviewToolTip::PreviewToolTip(QWidget *parent)
     : QWidget(parent)
     , m_ui(new Ui::PreviewToolTip)
 {
+    NanotraceHR::Tracer tracer{"preview tooltip constructor", category()};
+
     setWindowFlags(Qt::FramelessWindowHint | Qt::Tool | Qt::WindowTransparentForInput
                    | Qt::WindowStaysOnTopHint | Qt::WindowDoesNotAcceptFocus);
     m_ui->setupUi(this);
@@ -38,26 +43,36 @@ PreviewToolTip::PreviewToolTip(QWidget *parent)
 
 PreviewToolTip::~PreviewToolTip()
 {
+    NanotraceHR::Tracer tracer{"preview tooltip destructor", category()};
+
     delete m_ui;
 }
 
 void PreviewToolTip::setId(const QString &id)
 {
+    NanotraceHR::Tracer tracer{"preview tooltip set id", category()};
+
     m_ui->idLabel->setText(id);
 }
 
 void PreviewToolTip::setType(const QString &type)
 {
+    NanotraceHR::Tracer tracer{"preview tooltip set type", category()};
+
     m_ui->typeLabel->setText(type);
 }
 
 void PreviewToolTip::setInfo(const QString &info)
 {
+    NanotraceHR::Tracer tracer{"preview tooltip set info", category()};
+
     m_ui->infoLabel->setText(info);
 }
 
 void PreviewToolTip::setPixmap(const QPixmap &pixmap)
 {
+    NanotraceHR::Tracer tracer{"preview tooltip set pixmap", category()};
+
     QPixmap scaled = pixmap.scaled(m_ui->labelBackground->size(), Qt::KeepAspectRatio);
     scaled.setDevicePixelRatio(1.);
     m_ui->imageLabel->setPixmap(scaled);
@@ -65,6 +80,8 @@ void PreviewToolTip::setPixmap(const QPixmap &pixmap)
 
 QString PreviewToolTip::id() const
 {
+    NanotraceHR::Tracer tracer{"preview tooltip get id", category()};
+
     return m_ui->idLabel->text();
 }
 

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 OR ENABLE_PROPERTY_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 OR ENABLE_NAVIGATOR_TRACING
   PUBLIC_DEPENDS Nanotrace
   PUBLIC_DEFINES
     ENABLE_QMLDESIGNER_TRACING