QmlDesigner: Add Navigator tracing

Change-Id: I970a75012b5451a12214389ba01dfdb5ca2b5f59 Reviewed-by: Thomas Hartmann <thomas.hartmann@qt.io>
2025-05-30 12:20:19 +02:00
parent 4a81749343
commit 13e00f1e2b
13 changed files with 449 additions and 43 deletions
--- a/src/plugins/qmldesigner/CMakeLists.txt
+++ b/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
--- a/src/plugins/qmldesigner/components/navigator/choosefrompropertylistdialog.cpp
+++ b/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;

--- a/src/plugins/qmldesigner/components/navigator/iconcheckboxitemdelegate.cpp
+++ b/src/plugins/qmldesigner/components/navigator/iconcheckboxitemdelegate.cpp
@@ -5,31 +5,38 @@

 #include <qmath.h>

-#include "navigatorview.h"
-#include "navigatortreeview.h"
+#include "navigatortracing.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,8 +140,7 @@ bool IconCheckboxItemDelegate::editorEvent(QEvent *event,
        return false;

    // make sure that we have the right event type
-    if ((event->type() == QEvent::MouseButtonRelease)
-        || (event->type() == QEvent::MouseButtonDblClick)
+    if ((event->type() == QEvent::MouseButtonRelease) || (event->type() == QEvent::MouseButtonDblClick)
        || (event->type() == QEvent::MouseButtonPress)) {
        QMouseEvent *me = static_cast<QMouseEvent *>(event);
        if (me->button() != Qt::LeftButton || !option.rect.contains(me->pos()))
--- a/src/plugins/qmldesigner/components/navigator/nameitemdelegate.cpp
+++ b/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
--- a/src/plugins/qmldesigner/components/navigator/navigatorsearchwidget.cpp
+++ b/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();
 }

--- a/src/plugins/qmldesigner/components/navigator/navigatortracing.cpp
+++ b/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
--- a/src/plugins/qmldesigner/components/navigator/navigatortracing.h
+++ b/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
--- a/src/plugins/qmldesigner/components/navigator/navigatortreemodel.cpp
+++ b/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;
 }
--- a/src/plugins/qmldesigner/components/navigator/navigatortreeview.cpp
+++ b/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 "navigatorview.h"
-#include "navigatortreemodel.h"
-#include "qproxystyle.h"
-#include "previewtooltip.h"
+#include <modelnode.h>

 #include <qmldesignerbase/studio/studiostyle.h>

@@ -18,19 +19,22 @@
 #include <utils/icon.h>
 #include <utils/utilsicons.h>

-#include <QLineEdit>
-#include <QPen>
-#include <QPixmapCache>
-#include <QMouseEvent>
-#include <QPainter>
-#include <QStyleFactory>
+#include <qproxystyle.h>
 #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
--- a/src/plugins/qmldesigner/components/navigator/navigatorview.cpp
+++ b/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) {
-    QModelIndex index = indexForModelNode(modelNode);;
+void NavigatorView::propagateInstanceErrorToExplorer(const ModelNode &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);
--- a/src/plugins/qmldesigner/components/navigator/navigatorwidget.cpp
+++ b/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();
 }

--- a/src/plugins/qmldesigner/components/navigator/previewtooltip.cpp
+++ b/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();
 }

--- a/src/plugins/qmldesigner/libs/designercore/CMakeLists.txt
+++ b/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