diff --git a/src/plugins/qmldesigner/CMakeLists.txt b/src/plugins/qmldesigner/CMakeLists.txt index bc01127ccb1..21c9b7aff74 100644 --- a/src/plugins/qmldesigner/CMakeLists.txt +++ b/src/plugins/qmldesigner/CMakeLists.txt @@ -32,10 +32,15 @@ env_with_default("QDS_DESIGNVIEWER_USE_STAGING" ENV_QDS_DESIGNVIEWER_USE_STAGING option(QDS_DESIGNVIEWER_USE_STAGING "Use staging API URL for Design Viewer" ${ENV_QDS_DESIGNVIEWER_USE_STAGING}) add_feature_info("Use staging API URL for Design Viewer" ${QDS_DESIGNVIEWER_USE_STAGING} "") +env_with_default("QTC_ENABLE_PROPERTY_EDITOR_TRACING" ENV_QTC_ENABLE_PROPERTY_EDITOR_TRACING OFF) +option(ENABLE_PROPERTY_EDITOR_TRACING "Enable property editor tracing" ${ENV_QTC_ENABLE_PROPERTY_EDITOR_TRACING}) +add_feature_info("Property editor tracing" ${ENABLE_PROPERTY_EDITOR_TRACING} "") env_with_default("QTC_ENABLE_FORM_EDITOR_TRACING" ENV_QTC_ENABLE_FORM_EDITOR_TRACING OFF) option(ENABLE_FORM_EDITOR_TRACING "Enable form editor tracing" ${ENV_QTC_ENABLE_FORM_EDITOR_TRACING}) -add_feature_info("Model tracing" ${ENABLE_FORM_EDITOR_TRACING} "") +add_feature_info("Form editor tracing" ${ENABLE_FORM_EDITOR_TRACING} "") + + if(QDS_DESIGNVIEWER_USE_STAGING) add_definitions(-DQDS_DESIGNVIEWER_USE_STAGING) @@ -409,7 +414,9 @@ extend_qtc_plugin(QmlDesigner extend_qtc_plugin(QmlDesigner SOURCES_PREFIX components/propertyeditor - PUBLIC_INCLUDES components/propertyeditor + PUBLIC_INCLUDES components/propertyeditor + PUBLIC_DEFINES + $<$:ENABLE_PROPERTY_EDITOR_TRACING> SOURCES aligndistribute.cpp aligndistribute.h assetimageprovider.cpp assetimageprovider.h @@ -430,6 +437,7 @@ extend_qtc_plugin(QmlDesigner propertyeditorcontextobject.cpp propertyeditorcontextobject.h propertyeditordynamicpropertiesproxymodel.cpp propertyeditordynamicpropertiesproxymodel.h propertyeditorqmlbackend.cpp propertyeditorqmlbackend.h + propertyeditortracing.cpp propertyeditortracing.h propertyeditortransaction.cpp propertyeditortransaction.h propertyeditorvalue.cpp propertyeditorvalue.h propertyeditorview.cpp propertyeditorview.h diff --git a/src/plugins/qmldesigner/components/propertyeditor/aligndistribute.cpp b/src/plugins/qmldesigner/components/propertyeditor/aligndistribute.cpp index 4f993d7380b..75727ac5bae 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/aligndistribute.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/aligndistribute.cpp @@ -3,6 +3,8 @@ #include "aligndistribute.h" +#include "propertyeditortracing.h" + #include #include #include @@ -23,12 +25,18 @@ using namespace Utils; namespace QmlDesigner { +static auto category = PropertyEditorTracing::category; + AlignDistribute::AlignDistribute(QObject *parent) : QObject(parent) -{} +{ + NanotraceHR::Tracer tracer{"align distribute constructor", category()}; +} bool AlignDistribute::multiSelection() const { + NanotraceHR::Tracer tracer{"align distribute multiSelection", category()}; + if (!m_qmlObjectNode.isValid()) return false; @@ -37,6 +45,8 @@ bool AlignDistribute::multiSelection() const bool AlignDistribute::selectionHasAnchors() const { + NanotraceHR::Tracer tracer{"align distribute selection has anchors", category()}; + if (!m_qmlObjectNode.isValid()) return true; @@ -51,6 +61,8 @@ bool AlignDistribute::selectionHasAnchors() const bool AlignDistribute::selectionExclusivlyItems() const { + NanotraceHR::Tracer tracer{"align distribute selection exclusivly items", category()}; + if (!m_qmlObjectNode.isValid()) return false; @@ -64,6 +76,8 @@ bool AlignDistribute::selectionExclusivlyItems() const bool AlignDistribute::selectionContainsRootItem() const { + NanotraceHR::Tracer tracer{"align distribute selection contains root item", category()}; + if (!m_qmlObjectNode.isValid()) return true; @@ -78,6 +92,8 @@ bool AlignDistribute::selectionContainsRootItem() const void AlignDistribute::setModelNodeBackend(const QVariant &modelNodeBackend) { + NanotraceHR::Tracer tracer{"align distribute set model node backend", category()}; + auto modelNodeBackendObject = modelNodeBackend.value(); const auto backendObjectCasted = qobject_cast(modelNodeBackendObject); @@ -92,11 +108,15 @@ void AlignDistribute::setModelNodeBackend(const QVariant &modelNodeBackend) // function or associated MEMBER variable. The property will be invalid. QVariant AlignDistribute::modelNodeBackend() const { + NanotraceHR::Tracer tracer{"align distribute model node backend", category()}; + return {}; } void AlignDistribute::registerDeclarativeType() { + NanotraceHR::Tracer tracer{"align distribute register declarative type", category()}; + qmlRegisterType("HelperWidgets", 2, 0, "AlignDistribute"); } @@ -256,7 +276,9 @@ inline static qreal getInstanceSceneY(const QmlItemNode &qmlItemNode) void AlignDistribute::alignObjects(Target target, AlignTo alignTo, const QString &keyObject) { - QTC_ASSERT(m_qmlObjectNode.isValid(), return ); + NanotraceHR::Tracer tracer{"align distribute align objects", category()}; + + QTC_ASSERT(m_qmlObjectNode.isValid(), return); const auto selectionContext = SelectionContext(m_qmlObjectNode.view()); if (selectionContext.selectedModelNodes().empty()) @@ -347,6 +369,8 @@ void AlignDistribute::alignObjects(Target target, AlignTo alignTo, const QString void AlignDistribute::distributeObjects(Target target, AlignTo alignTo, const QString &keyObject) { + NanotraceHR::Tracer tracer{"align distribute distribute objects", category()}; + QTC_ASSERT(m_qmlObjectNode.isValid(), return ); const auto selectionContext = SelectionContext(m_qmlObjectNode.view()); @@ -508,6 +532,8 @@ void AlignDistribute::distributeSpacing(Dimension dimension, const qreal &distance, DistributeOrigin distributeOrigin) { + NanotraceHR::Tracer tracer{"align distribute distribute spacing", category()}; + QTC_ASSERT(m_qmlObjectNode.isValid(), return ); const auto selectionContext = SelectionContext(m_qmlObjectNode.view()); @@ -637,6 +663,8 @@ void AlignDistribute::distributeSpacing(Dimension dimension, AlignDistribute::CompareFunction AlignDistribute::getCompareFunction(Target target) const { + NanotraceHR::Tracer tracer{"align distribute get compare function", category()}; + static const std::map cmpMap = {{Target::Left, compareByLeft}, {Target::CenterH, compareByCenterH}, {Target::Right, compareByRight}, @@ -648,6 +676,8 @@ AlignDistribute::CompareFunction AlignDistribute::getCompareFunction(Target targ AlignDistribute::Dimension AlignDistribute::getDimension(Target target) const { + NanotraceHR::Tracer tracer{"align distribute get dimension", category()}; + switch (target) { case Target::Left: case Target::CenterH: @@ -665,6 +695,8 @@ AlignDistribute::Dimension AlignDistribute::getDimension(Target target) const bool AlignDistribute::executePixelPerfectDialog() const { + NanotraceHR::Tracer tracer{"align distribute execute pixel perfect dialog", category()}; + Utils::CheckableDecider decider(Key("WarnAboutPixelPerfectDistribution")); QMessageBox::StandardButton pressed = Utils::CheckableMessageBox::question( diff --git a/src/plugins/qmldesigner/components/propertyeditor/assetimageprovider.cpp b/src/plugins/qmldesigner/components/propertyeditor/assetimageprovider.cpp index 6b871dbca2b..97a2a93c418 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/assetimageprovider.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/assetimageprovider.cpp @@ -3,6 +3,8 @@ #include "assetimageprovider.h" +#include "propertyeditortracing.h" + #include #include @@ -18,6 +20,9 @@ namespace QmlDesigner { QQuickImageResponse *AssetImageProvider::requestImageResponse(const QString &id, const QSize &requestedSize) { + NanotraceHR::Tracer tracer{"asset image provider request image response", + PropertyEditorTracing::category()}; + if (id.endsWith(".mesh")) return m_imageCacheProvider.requestImageResponse(id, {}); diff --git a/src/plugins/qmldesigner/components/propertyeditor/colorpalettebackend.cpp b/src/plugins/qmldesigner/components/propertyeditor/colorpalettebackend.cpp index 203390e24c8..5e23d3e4dd3 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/colorpalettebackend.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/colorpalettebackend.cpp @@ -3,6 +3,8 @@ #include "colorpalettebackend.h" +#include "propertyeditortracing.h" + #include #include @@ -21,6 +23,8 @@ namespace QmlDesigner { QPointer ColorPaletteBackend::m_instance = nullptr; +static auto category = PropertyEditorTracing::category; + ColorPaletteBackend::ColorPaletteBackend() : m_currentPalette() , m_data() @@ -29,6 +33,8 @@ ColorPaletteBackend::ColorPaletteBackend() , updateTimer(0) #endif { + NanotraceHR::Tracer tracer{"color palette backend constructor", category()}; + m_data.insert(g_recent, Palette(QmlDesigner::DesignerSettingsKey::COLOR_PALETTE_RECENT)); m_data.insert(g_favorite, Palette(QmlDesigner::DesignerSettingsKey::COLOR_PALETTE_FAVORITE)); @@ -47,6 +53,8 @@ ColorPaletteBackend::ColorPaletteBackend() ColorPaletteBackend::~ColorPaletteBackend() { + NanotraceHR::Tracer tracer{"color palette backend destructor", category()}; + //writePalettes(); // TODO crash on QtDS close if (m_eyeDropperActive) eyeDropperLeave(QCursor::pos(), EyeDropperEventFilter::LeaveReason::Default); @@ -54,19 +62,26 @@ ColorPaletteBackend::~ColorPaletteBackend() void ColorPaletteBackend::readPalettes() { + NanotraceHR::Tracer tracer{"color palette backend read palettes", category()}; + for (auto &palette : m_data) palette.read(); } void ColorPaletteBackend::writePalettes() { + NanotraceHR::Tracer tracer{"color palette backend write palettes", category()}; + for (auto &palette : m_data) palette.write(); } void ColorPaletteBackend::addColor(const QString &color, const QString &paletteName) { + NanotraceHR::Tracer tracer{"color palette backend add color", category()}; + auto found = m_data.find(paletteName); + if (found == m_data.end()) { qWarning() << Q_FUNC_INFO << "Unknown palette: " << paletteName; return; @@ -92,6 +107,8 @@ void ColorPaletteBackend::addColor(const QString &color, const QString &paletteN void ColorPaletteBackend::removeColor(int id, const QString &paletteName) { + NanotraceHR::Tracer tracer{"color palette backend remove color", category()}; + auto found = m_data.find(paletteName); if (found == m_data.end()) { @@ -122,6 +139,8 @@ void ColorPaletteBackend::removeColor(int id, const QString &paletteName) void ColorPaletteBackend::addRecentColor(const QString &item) { + NanotraceHR::Tracer tracer{"color palette backend add recent color", category()}; + if (m_data[g_recent].m_colors.isEmpty()) { addColor(item, g_recent); return; @@ -134,26 +153,36 @@ void ColorPaletteBackend::addRecentColor(const QString &item) void ColorPaletteBackend::addFavoriteColor(const QString &item) { + NanotraceHR::Tracer tracer{"color palette backend add favorite color", category()}; + addColor(item, g_favorite); } void ColorPaletteBackend::removeFavoriteColor(int id) { + NanotraceHR::Tracer tracer{"color palette backend remove favorite color", category()}; + removeColor(id, g_favorite); } QStringList ColorPaletteBackend::palettes() const { + NanotraceHR::Tracer tracer{"color palette backend get palettes", category()}; + return m_data.keys(); } const QString &ColorPaletteBackend::currentPalette() const { + NanotraceHR::Tracer tracer{"color palette backend get current palette", category()}; + return m_currentPalette; } void ColorPaletteBackend::setCurrentPalette(const QString &palette) { + NanotraceHR::Tracer tracer{"color palette backend set current palette", category()}; + if (!m_data.contains(palette)) { qWarning() << Q_FUNC_INFO << "Unknown palette: " << palette; return; @@ -186,11 +215,15 @@ void ColorPaletteBackend::setCurrentPalette(const QString &palette) const QStringList &ColorPaletteBackend::currentPaletteColors() const { + NanotraceHR::Tracer tracer{"color palette backend get current palette colors", category()}; + return m_currentPaletteColors; } void ColorPaletteBackend::registerDeclarativeType() { + NanotraceHR::Tracer tracer{"color palette backend register declarative type", category()}; + [[maybe_unused]] static const int typeIndex = qmlRegisterSingletonType( "QtQuickDesignerColorPalette", 1, 0, "ColorPaletteBackend", [](QQmlEngine *, QJSEngine *) { return new ColorPaletteBackend(); @@ -199,6 +232,8 @@ void ColorPaletteBackend::registerDeclarativeType() void ColorPaletteBackend::showDialog(QColor color) { + NanotraceHR::Tracer tracer{"color palette backend show dialog", category()}; + auto colorDialog = new QColorDialog(Core::ICore::dialogParent()); colorDialog->setCurrentColor(color); colorDialog->setAttribute(Qt::WA_DeleteOnClose); @@ -213,11 +248,15 @@ void ColorPaletteBackend::showDialog(QColor color) void ColorPaletteBackend::invokeEyeDropper() { + NanotraceHR::Tracer tracer{"color palette backend invoke eye dropper", category()}; + eyeDropperEnter(); } void ColorPaletteBackend::eyeDropperEnter() { + NanotraceHR::Tracer tracer{"color palette backend eye dropper enter", category()}; + if (m_eyeDropperActive) return; @@ -278,6 +317,8 @@ void ColorPaletteBackend::eyeDropperEnter() void ColorPaletteBackend::eyeDropperLeave(const QPoint &pos, EyeDropperEventFilter::LeaveReason actionOnLeave) { + NanotraceHR::Tracer tracer{"color palette backend eye dropper leave", category()}; + if (!m_eyeDropperActive) return; @@ -306,6 +347,8 @@ void ColorPaletteBackend::eyeDropperLeave(const QPoint &pos, void ColorPaletteBackend::eyeDropperPointerMoved(const QPoint &pos) { + NanotraceHR::Tracer tracer{"color palette backend eye dropper pointer moved", category()}; + m_eyeDropperCurrentColor = grabScreenColor(pos); updateEyeDropperPosition(pos); } @@ -318,11 +361,15 @@ const QSize g_halfPreviewSize = g_previewSize / 2; QColor ColorPaletteBackend::grabScreenColor(const QPoint &p) { + NanotraceHR::Tracer tracer{"color palette backend grab screen color", category()}; + return grabScreenRect(QRect(p, QSize(1, 1))).pixel(0, 0); } QImage ColorPaletteBackend::grabScreenRect(const QRect &r) { + NanotraceHR::Tracer tracer{"color palette backend grab screen rect", category()}; + QScreen *screen = QGuiApplication::screenAt(r.topLeft()); if (!screen) screen = QGuiApplication::primaryScreen(); @@ -339,6 +386,8 @@ QImage ColorPaletteBackend::grabScreenRect(const QRect &r) void ColorPaletteBackend::updateEyeDropper() { + NanotraceHR::Tracer tracer{"color palette backend update eye dropper", category()}; + #ifndef QT_NO_CURSOR static QPoint lastGlobalPos; const QPoint newGlobalPos = QCursor::pos(); @@ -356,6 +405,8 @@ void ColorPaletteBackend::updateEyeDropper() void ColorPaletteBackend::updateEyeDropperPosition(const QPoint &globalPos) { + NanotraceHR::Tracer tracer{"color palette backend update eye dropper position", category()}; + #if QT_CONFIG(cursor) QPoint topLeft = globalPos - QPoint(g_halfCursorSize.width(), g_halfCursorSize.height()); updateCursor(grabScreenRect(QRect(topLeft, g_cursorSize))); @@ -364,6 +415,8 @@ void ColorPaletteBackend::updateEyeDropperPosition(const QPoint &globalPos) void ColorPaletteBackend::updateCursor(const QImage &image) { + NanotraceHR::Tracer tracer{"color palette backend update cursor", category()}; + QWindow *window = Core::ICore::mainWindow()->windowHandle(); if (!window) return; @@ -422,6 +475,7 @@ void ColorPaletteBackend::updateCursor(const QImage &image) bool ColorPaletteBackend::eyeDropperActive() const { + NanotraceHR::Tracer tracer{"color palette backend eye dropper active", category()}; return m_eyeDropperActive; } diff --git a/src/plugins/qmldesigner/components/propertyeditor/compatibleproperties.cpp b/src/plugins/qmldesigner/components/propertyeditor/compatibleproperties.cpp index 5b1bdbe4cab..996f262d9ea 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/compatibleproperties.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/compatibleproperties.cpp @@ -3,6 +3,8 @@ #include "compatibleproperties.h" +#include "propertyeditortracing.h" + #include #include #include @@ -10,6 +12,8 @@ namespace QmlDesigner { +static auto category = PropertyEditorTracing::category; + /*! * \internal * \brief Extracts and removes compatible properties from \param properties. @@ -17,6 +21,8 @@ namespace QmlDesigner { */ void CompatibleProperties::createCompatibilityMap(QList &properties) { + NanotraceHR::Tracer tracer{"compatible properties compatibility map", category()}; + m_compatibilityMap.clear(); if (m_oldInfo == m_newInfo || !m_oldInfo.isQtQuick3DMaterial() || !m_newInfo.isQtQuick3DMaterial()) return; @@ -63,6 +69,8 @@ void CompatibleProperties::createCompatibilityMap(QList &propertie void CompatibleProperties::copyMappedProperties(const ModelNode &node) { + NanotraceHR::Tracer tracer{"compatible properties copy mapped properties", category()}; + if (m_compatibilityMap.isEmpty()) return; // Copy mapped properties to new name. Note that this will only copy the base @@ -95,6 +103,8 @@ void CompatibleProperties::copyMappedProperties(const ModelNode &node) void CompatibleProperties::applyCompatibleProperties(const ModelNode &node) { + NanotraceHR::Tracer tracer{"compatible properties apply compatible properties", category()}; + for (const auto &pair : m_compatibilityMap.asKeyValueRange()) { const CopyData ©Data = pair.second; if (copyData.isBinding) { diff --git a/src/plugins/qmldesigner/components/propertyeditor/designerpropertymap.cpp b/src/plugins/qmldesigner/components/propertyeditor/designerpropertymap.cpp index e52de245b80..1b229a54230 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/designerpropertymap.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/designerpropertymap.cpp @@ -3,14 +3,21 @@ #include "designerpropertymap.h" +#include "propertyeditortracing.h" + namespace QmlDesigner { +static auto category = PropertyEditorTracing::category; + DesignerPropertyMap::DesignerPropertyMap(QObject *parent) : QQmlPropertyMap(parent) { + NanotraceHR::Tracer tracer{"designer property map", category()}; } QVariant DesignerPropertyMap::value(const QString &key) const { + NanotraceHR::Tracer tracer{"designer property map value", QmlDesigner::category()}; + if (contains(key)) return QQmlPropertyMap::value(key); return QVariant(); @@ -18,7 +25,10 @@ QVariant DesignerPropertyMap::value(const QString &key) const void DesignerPropertyMap::registerDeclarativeType(const QString &name) { - qmlRegisterType("Bauhaus",1,0,name.toUtf8()); + NanotraceHR::Tracer tracer{"designer property map register declarative type", + QmlDesigner::category()}; + + qmlRegisterType("Bauhaus", 1, 0, name.toUtf8()); } } //QmlDesigner diff --git a/src/plugins/qmldesigner/components/propertyeditor/dynamicpropertiesproxymodel.cpp b/src/plugins/qmldesigner/components/propertyeditor/dynamicpropertiesproxymodel.cpp index c3ecf025b90..3510aca764f 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/dynamicpropertiesproxymodel.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/dynamicpropertiesproxymodel.cpp @@ -26,9 +26,10 @@ #include "dynamicpropertiesproxymodel.h" #include "bindingproperty.h" +#include "propertyeditortracing.h" #include "propertyeditorvalue.h" -#include +#include #include #include @@ -45,6 +46,8 @@ namespace QmlDesigner { +static auto category = PropertyEditorTracing::category; + static const int propertyNameRole = Qt::UserRole + 1; static const int propertyTypeRole = Qt::UserRole + 2; static const int propertyValueRole = Qt::UserRole + 3; @@ -53,10 +56,13 @@ static const int propertyBindingRole = Qt::UserRole + 4; DynamicPropertiesProxyModel::DynamicPropertiesProxyModel(QObject *parent) : QAbstractListModel(parent) { + NanotraceHR::Tracer tracer{"dynamic properties proxy model constructor", category()}; } void DynamicPropertiesProxyModel::initModel(DynamicPropertiesModel *model) { + NanotraceHR::Tracer tracer{"dynamic properties proxy model init model", category()}; + m_model = model; connect(m_model, &QAbstractItemModel::modelAboutToBeReset, @@ -84,14 +90,18 @@ void DynamicPropertiesProxyModel::initModel(DynamicPropertiesModel *model) int DynamicPropertiesProxyModel::rowCount(const QModelIndex &) const { + NanotraceHR::Tracer tracer{"dynamic properties proxy model row count", category()}; + return m_model ? m_model->rowCount() : 0; } QHash DynamicPropertiesProxyModel::roleNames() const { - static QHash roleNames{{propertyNameRole, "propertyName"}, - {propertyTypeRole, "propertyType"}, - {propertyValueRole, "propertyValue"}, + NanotraceHR::Tracer tracer{"dynamic properties proxy model role names", category()}; + + static QHash roleNames{{propertyNameRole, "propertyName"}, + {propertyTypeRole, "propertyType"}, + {propertyValueRole, "propertyValue"}, {propertyBindingRole, "propertyBinding"}}; return roleNames; @@ -99,6 +109,8 @@ QHash DynamicPropertiesProxyModel::roleNames() const QVariant DynamicPropertiesProxyModel::data(const QModelIndex &index, int role) const { + NanotraceHR::Tracer tracer{"dynamic properties proxy model data", category()}; + if (index.isValid() && index.row() < rowCount()) { AbstractProperty property = m_model->propertyForRow(index.row()); @@ -132,6 +144,8 @@ QVariant DynamicPropertiesProxyModel::data(const QModelIndex &index, int role) c void DynamicPropertiesProxyModel::registerDeclarativeType() { + NanotraceHR::Tracer tracer{"dynamic properties proxy model register declarative type", category()}; + static bool registered = false; if (!registered) qmlRegisterType("HelperWidgets", 2, 0, "DynamicPropertiesModel"); @@ -139,11 +153,14 @@ void DynamicPropertiesProxyModel::registerDeclarativeType() DynamicPropertiesModel *DynamicPropertiesProxyModel::dynamicPropertiesModel() const { + NanotraceHR::Tracer tracer{"dynamic properties proxy model dynamic properties model", category()}; return m_model; } QString DynamicPropertiesProxyModel::newPropertyName() const { + NanotraceHR::Tracer tracer{"dynamic properties proxy model new property name", category()}; + DynamicPropertiesModel *propsModel = dynamicPropertiesModel(); return QString::fromUtf8(uniquePropertyName("newName", propsModel->singleSelectedNode())); @@ -151,6 +168,8 @@ QString DynamicPropertiesProxyModel::newPropertyName() const void DynamicPropertiesProxyModel::createProperty(const QString &name, const QString &type) { + NanotraceHR::Tracer tracer{"dynamic properties proxy model create property", category()}; + QmlDesignerPlugin::emitUsageStatistics(Constants::EVENT_PROPERTY_ADDED); TypeName typeName = type.toUtf8(); @@ -191,6 +210,8 @@ void DynamicPropertiesProxyModel::createProperty(const QString &name, const QStr DynamicPropertyRow::DynamicPropertyRow() { + NanotraceHR::Tracer tracer{"dynamic properties proxy model constructor", category()}; + m_backendValue = new PropertyEditorValue(this); QObject::connect(m_backendValue, @@ -211,16 +232,22 @@ DynamicPropertyRow::DynamicPropertyRow() DynamicPropertyRow::~DynamicPropertyRow() { + NanotraceHR::Tracer tracer{"dynamic properties proxy model destructor", category()}; + clearProxyBackendValues(); } void DynamicPropertyRow::registerDeclarativeType() { + NanotraceHR::Tracer tracer{"dynamic properties proxy model register declarative type", category()}; + qmlRegisterType("HelperWidgets", 2, 0, "DynamicPropertyRow"); } void DynamicPropertyRow::setRow(int r) { + NanotraceHR::Tracer tracer{"dynamic properties proxy model set row", category()}; + if (m_row == r) return; @@ -231,11 +258,15 @@ void DynamicPropertyRow::setRow(int r) int DynamicPropertyRow::row() const { + NanotraceHR::Tracer tracer{"dynamic properties proxy model get row", category()}; + return m_row; } void DynamicPropertyRow::setModel(DynamicPropertiesProxyModel *model) { + NanotraceHR::Tracer tracer{"dynamic properties proxy model set model", category()}; + if (model == m_model) return; @@ -259,21 +290,30 @@ void DynamicPropertyRow::setModel(DynamicPropertiesProxyModel *model) DynamicPropertiesProxyModel *DynamicPropertyRow::model() const { + NanotraceHR::Tracer tracer{"dynamic properties proxy model get model", category()}; + return m_model; } PropertyEditorValue *DynamicPropertyRow::backendValue() const { + NanotraceHR::Tracer tracer{"dynamic properties proxy model get backend value", category()}; + return m_backendValue; } void DynamicPropertyRow::remove() { + NanotraceHR::Tracer tracer{"dynamic properties proxy model remove", category()}; + m_model->dynamicPropertiesModel()->remove(m_row); } PropertyEditorValue *DynamicPropertyRow::createProxyBackendValue() { + NanotraceHR::Tracer tracer{"dynamic properties proxy model create proxy backend value", + category()}; + auto *newValue = new PropertyEditorValue(this); m_proxyBackendValues.append(newValue); @@ -284,12 +324,17 @@ PropertyEditorValue *DynamicPropertyRow::createProxyBackendValue() void DynamicPropertyRow::clearProxyBackendValues() { + NanotraceHR::Tracer tracer{"dynamic properties proxy model clear proxy backend values", + category()}; + qDeleteAll(m_proxyBackendValues); m_proxyBackendValues.clear(); } void DynamicPropertyRow::setupBackendValue() { + NanotraceHR::Tracer tracer{"dynamic properties proxy model setup backend value", category()}; + if (!m_model) return; @@ -333,6 +378,8 @@ void DynamicPropertyRow::setupBackendValue() void DynamicPropertyRow::commitValue(const QVariant &value) { + NanotraceHR::Tracer tracer{"dynamic properties proxy model commit value", category()}; + if (m_lock) return; @@ -381,6 +428,8 @@ void DynamicPropertyRow::commitValue(const QVariant &value) void DynamicPropertyRow::commitExpression(const QString &expression) { + NanotraceHR::Tracer tracer{"dynamic properties proxy model commit expression", category()}; + if (m_lock || m_row < 0) return; @@ -428,6 +477,8 @@ void DynamicPropertyRow::commitExpression(const QString &expression) void DynamicPropertyRow::handleDataChanged(const QModelIndex &topLeft, const QModelIndex &, const QList &) { + NanotraceHR::Tracer tracer{"dynamic properties proxy model handle data changed", category()}; + if (m_model->dynamicPropertiesModel()->isCallbackToModelBlocked()) return; @@ -437,6 +488,8 @@ void DynamicPropertyRow::handleDataChanged(const QModelIndex &topLeft, const QMo void DynamicPropertyRow::resetValue() { + NanotraceHR::Tracer tracer{"dynamic properties proxy model reset value", category()}; + if (m_lock || m_row < 0) return; diff --git a/src/plugins/qmldesigner/components/propertyeditor/fileresourcesmodel.cpp b/src/plugins/qmldesigner/components/propertyeditor/fileresourcesmodel.cpp index 2942ca86c76..d45560fe9ec 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/fileresourcesmodel.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/fileresourcesmodel.cpp @@ -2,6 +2,7 @@ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 #include "fileresourcesmodel.h" +#include "propertyeditortracing.h" #include @@ -19,10 +20,14 @@ static QString s_lastBrowserPath; +static auto category = QmlDesigner::PropertyEditorTracing::category; + FileResourcesModel::FileResourcesModel(QObject *parent) : QObject(parent) , m_filter(QLatin1String("(*.*)")) { + NanotraceHR::Tracer tracer{"file resources model consstructor", category()}; + ProjectExplorer::Project *project = ProjectExplorer::ProjectManager::projectForFile( QmlDesigner::DocumentManager::currentFilePath()); @@ -36,6 +41,8 @@ FileResourcesModel::FileResourcesModel(QObject *parent) void FileResourcesModel::setModelNodeBackend(const QVariant &modelNodeBackend) { + NanotraceHR::Tracer tracer{"file resources model set model node backend", category()}; + auto modelNodeBackendObject = modelNodeBackend.value(); const auto backendObjectCasted = qobject_cast( @@ -57,11 +64,15 @@ void FileResourcesModel::setModelNodeBackend(const QVariant &modelNodeBackend) QString FileResourcesModel::fileName() const { + NanotraceHR::Tracer tracer{"file resources model file name", category()}; + return m_fileName.toString(); } void FileResourcesModel::setFileNameStr(const QString &fileName) { + NanotraceHR::Tracer tracer{"file resources model set file name", category()}; + setFileName(QUrl(fileName)); } @@ -77,6 +88,8 @@ void FileResourcesModel::setFileName(const QUrl &fileName) void FileResourcesModel::setPath(const QUrl &url) { + NanotraceHR::Tracer tracer{"file resources model set path", category()}; + m_path = url; refreshModel(); @@ -85,16 +98,22 @@ void FileResourcesModel::setPath(const QUrl &url) QUrl FileResourcesModel::path() const { + NanotraceHR::Tracer tracer{"file resources model path", category()}; + return m_path; } QUrl FileResourcesModel::docPath() const { + NanotraceHR::Tracer tracer{"file resources model doc path", category()}; + return QUrl::fromLocalFile(m_docPath.path()); } void FileResourcesModel::setFilter(const QString &filter) { + NanotraceHR::Tracer tracer{"file resources model set filter", category()}; + if (m_filter == filter) return; @@ -106,16 +125,22 @@ void FileResourcesModel::setFilter(const QString &filter) QString FileResourcesModel::filter() const { + NanotraceHR::Tracer tracer{"file resources model filter", category()}; + return m_filter; } QList FileResourcesModel::model() const { + NanotraceHR::Tracer tracer{"file resources model model", category()}; + return m_model; } void FileResourcesModel::openFileDialog(const QString &customPath) { + NanotraceHR::Tracer tracer{"file resources model open file dialog", category()}; + QString resourcePath = customPath.isEmpty() ? m_path.toLocalFile() : customPath; bool resourcePathChanged = m_lastResourcePath != resourcePath; m_lastResourcePath = resourcePath; @@ -149,6 +174,8 @@ void FileResourcesModel::openFileDialog(const QString &customPath) QString FileResourcesModel::resolve(const QString &relative) const { + NanotraceHR::Tracer tracer{"file resources model resolve", category()}; + if (relative.startsWith('#')) return relative; @@ -170,20 +197,26 @@ QString FileResourcesModel::resolve(const QString &relative) const bool FileResourcesModel::isLocal(const QString &path) const { + NanotraceHR::Tracer tracer{"file resources model is local", category()}; + return QUrl::fromUserInput(path, m_docPath.path()).isLocalFile(); } void FileResourcesModel::registerDeclarativeType() { + NanotraceHR::Tracer tracer{"file resources model register declarative type", category()}; + qmlRegisterType("HelperWidgets", 2, 0, "FileResourcesModel"); } QVariant FileResourcesModel::modelNodeBackend() const { + NanotraceHR::Tracer tracer{"file resources model model node backend", category()}; + return QVariant(); } -bool filterMetaIcons(const QString &fileName) +static bool filterMetaIcons(const QString &fileName) { QFileInfo info(fileName); @@ -210,6 +243,8 @@ bool filterMetaIcons(const QString &fileName) void FileResourcesModel::refreshModel() { + NanotraceHR::Tracer tracer{"file resources model refresh model", category()}; + m_model.clear(); if (m_path.isValid()) { diff --git a/src/plugins/qmldesigner/components/propertyeditor/fontresourcesmodel.cpp b/src/plugins/qmldesigner/components/propertyeditor/fontresourcesmodel.cpp index e2a31cf5812..efed448d74d 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/fontresourcesmodel.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/fontresourcesmodel.cpp @@ -3,6 +3,7 @@ #include "fontresourcesmodel.h" #include "fileresourcesmodel.h" +#include "propertyeditortracing.h" #include #include @@ -32,6 +33,8 @@ using namespace Qt::Literals::StringLiterals; namespace { +auto category = QmlDesigner::PropertyEditorTracing::category; + QStringList makeFontFilesFilterList() { QStringList filterList; @@ -100,11 +103,15 @@ QSet systemFonts() void FontResourcesModel::registerDeclarativeType() { + NanotraceHR::Tracer tracer{"font resources model register declarative type", category()}; + qmlRegisterType("HelperWidgets", 2, 0, "FontResourcesModel"); } QVariant FontResourcesModel::modelNodeBackend() { + NanotraceHR::Tracer tracer{"font resources model model node backend", category()}; + return {}; } @@ -112,16 +119,22 @@ FontResourcesModel::FontResourcesModel(QObject *parent) : QObject{parent} , m_resourceModel{std::make_unique()} { + NanotraceHR::Tracer tracer{"font resources model constructor", category()}; + m_resourceModel->setFilter(fontFilesFilterList().join(' ')); } void FontResourcesModel::setModelNodeBackend(const QVariant &modelNodeBackend) { + NanotraceHR::Tracer tracer{"file resources model set model node backend", category()}; + m_resourceModel->setModelNodeBackend(modelNodeBackend); } QStringList FontResourcesModel::model() const { + NanotraceHR::Tracer tracer{"file resources model model", category()}; + QSet fonts; for (const auto &item : m_resourceModel->model()) { fonts.insert(fontFamily(item.absoluteFilePath())); @@ -137,20 +150,28 @@ QStringList FontResourcesModel::model() const void FontResourcesModel::refreshModel() { + NanotraceHR::Tracer tracer{"file resources model refresh model", category()}; + m_resourceModel->refreshModel(); } void FontResourcesModel::openFileDialog(const QString &customPath) { + NanotraceHR::Tracer tracer{"file resources model open file dialog", category()}; + m_resourceModel->openFileDialog(customPath); } QString FontResourcesModel::resolve(const QString &relative) const { + NanotraceHR::Tracer tracer{"file resources model resolve", category()}; + return m_resourceModel->resolve(relative); } bool FontResourcesModel::isLocal(const QString &path) const { + NanotraceHR::Tracer tracer{"file resources model is local", category()}; + return m_resourceModel->isLocal(path); } diff --git a/src/plugins/qmldesigner/components/propertyeditor/fontresourcesmodel.h b/src/plugins/qmldesigner/components/propertyeditor/fontresourcesmodel.h index 3870cdef41f..07dcffa1268 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/fontresourcesmodel.h +++ b/src/plugins/qmldesigner/components/propertyeditor/fontresourcesmodel.h @@ -30,8 +30,8 @@ public: void refreshModel(); Q_INVOKABLE void openFileDialog(const QString &customPath = {}); - Q_INVOKABLE [[nodiscard]] QString resolve(const QString &relative) const; - Q_INVOKABLE [[nodiscard]] bool isLocal(const QString &path) const; + [[nodiscard]] Q_INVOKABLE QString resolve(const QString &relative) const; + [[nodiscard]] Q_INVOKABLE bool isLocal(const QString &path) const; signals: void fileNameChanged(const QUrl &fileName); diff --git a/src/plugins/qmldesigner/components/propertyeditor/gradientmodel.cpp b/src/plugins/qmldesigner/components/propertyeditor/gradientmodel.cpp index 715d71db85b..a9b496efa68 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/gradientmodel.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/gradientmodel.cpp @@ -5,6 +5,7 @@ #include "gradientpresetcustomlistmodel.h" #include "gradientpresetitem.h" +#include "propertyeditortracing.h" #include "propertyeditorview.h" #include "qmlanchorbindingproxy.h" @@ -22,6 +23,9 @@ #include namespace { + +auto category = QmlDesigner::PropertyEditorTracing::category; + constexpr auto widthBinding = [](const QStringView nodeName) -> QString { return QString("%1.width").arg(nodeName); }; @@ -257,10 +261,13 @@ void prepareGradient(const T &array, GradientModel::GradientModel(QObject *parent) : QAbstractListModel(parent) { + NanotraceHR::Tracer tracer{"gradient model constructor", category()}; } int GradientModel::rowCount(const QModelIndex & /*parent*/) const { + NanotraceHR::Tracer tracer{"gradient model row count", category()}; + if (m_itemNode.modelNode().hasNodeProperty(gradientPropertyName().toUtf8())) { QmlDesigner::ModelNode gradientNode = m_itemNode.modelNode() .nodeProperty(gradientPropertyName().toUtf8()) @@ -275,20 +282,21 @@ int GradientModel::rowCount(const QModelIndex & /*parent*/) const QHash GradientModel::roleNames() const { - static QHash roleNames{ - {Qt::UserRole + 1, "position"}, - {Qt::UserRole + 2, "color"}, - {Qt::UserRole + 3, "readOnly"}, - {Qt::UserRole + 4, "index"} - }; + NanotraceHR::Tracer tracer{"gradient model role names", category()}; + + static QHash roleNames{{Qt::UserRole + 1, "position"}, + {Qt::UserRole + 2, "color"}, + {Qt::UserRole + 3, "readOnly"}, + {Qt::UserRole + 4, "index"}}; return roleNames; } QVariant GradientModel::data(const QModelIndex &index, int role) const { - if (index.isValid() && index.row() < rowCount()) { + NanotraceHR::Tracer tracer{"gradient model data", category()}; + if (index.isValid() && index.row() < rowCount()) { if (role == Qt::UserRole + 3) { if (index.row() == 0 || index.row() == (rowCount() - 1)) return true; @@ -312,6 +320,8 @@ QVariant GradientModel::data(const QModelIndex &index, int role) const int GradientModel::addStop(qreal position, const QColor &color) { + NanotraceHR::Tracer tracer{"gradient model add stop", category()}; + if (m_locked) return -1; @@ -354,6 +364,8 @@ int GradientModel::addStop(qreal position, const QColor &color) void GradientModel::addGradient() { + NanotraceHR::Tracer tracer{"gradient model add gradient", category()}; + if (m_locked) return; @@ -397,6 +409,8 @@ void GradientModel::addGradient() void GradientModel::setColor(int index, const QColor &color) { + NanotraceHR::Tracer tracer{"gradient model set color", category()}; + if (locked()) return; @@ -417,6 +431,8 @@ void GradientModel::setColor(int index, const QColor &color) void GradientModel::setPosition(int index, qreal positition) { + NanotraceHR::Tracer tracer{"gradient model set position", category()}; + if (locked()) return; @@ -431,6 +447,8 @@ void GradientModel::setPosition(int index, qreal positition) QColor GradientModel::getColor(int index) const { + NanotraceHR::Tracer tracer{"gradient model get color", category()}; + if (index < rowCount()) { QmlDesigner::ModelNode gradientNode = m_itemNode.modelNode().nodeProperty(gradientPropertyName().toUtf8()).modelNode(); QmlDesigner::QmlObjectNode stop = gradientNode.nodeListProperty("stops").at(index); @@ -443,6 +461,8 @@ QColor GradientModel::getColor(int index) const qreal GradientModel::getPosition(int index) const { + NanotraceHR::Tracer tracer{"gradient model get position", category()}; + if (index < rowCount()) { QmlDesigner::ModelNode gradientNode = m_itemNode.modelNode().nodeProperty(gradientPropertyName().toUtf8()).modelNode(); QmlDesigner::QmlObjectNode stop = gradientNode.nodeListProperty("stops").at(index); @@ -455,6 +475,8 @@ qreal GradientModel::getPosition(int index) const void GradientModel::removeStop(int index) { + NanotraceHR::Tracer tracer{"gradient model remove stop", category()}; + if (index < rowCount() - 1 && index != 0) { view()->executeInTransaction("GradientModel::removeStop", [this, index](){ QmlDesigner::ModelNode gradientNode = m_itemNode.modelNode().nodeProperty(gradientPropertyName().toUtf8()).modelNode(); @@ -476,6 +498,8 @@ void GradientModel::removeStop(int index) void GradientModel::deleteGradient() { + NanotraceHR::Tracer tracer{"gradient model delete gradient", category()}; + if (!m_itemNode.isValid()) return; @@ -490,21 +514,29 @@ void GradientModel::deleteGradient() void GradientModel::lock() { + NanotraceHR::Tracer tracer{"gradient model lock", category()}; + m_locked = true; } void GradientModel::unlock() { + NanotraceHR::Tracer tracer{"gradient model unlock", category()}; + m_locked = false; } void GradientModel::registerDeclarativeType() { + NanotraceHR::Tracer tracer{"gradient model register declarative type", category()}; + qmlRegisterType("HelperWidgets", 2, 0, "GradientModel"); } qreal GradientModel::readGradientProperty(const QString &propertyName) const { + NanotraceHR::Tracer tracer{"gradient model read gradient property", category()}; + if (!m_itemNode.isValid()) return 0; @@ -520,11 +552,15 @@ qreal GradientModel::readGradientProperty(const QString &propertyName) const qreal GradientModel::readGradientPropertyPercentage(const QString &propertyName) const { + NanotraceHR::Tracer tracer{"gradient model read gradient property percentage", category()}; + return getPercentageGradientProperty(propertyName.toUtf8()); } QString GradientModel::readGradientOrientation() const { + NanotraceHR::Tracer tracer{"gradient model read gradient orientation", category()}; + if (!m_itemNode.isValid()) return QString(); @@ -541,6 +577,8 @@ QString GradientModel::readGradientOrientation() const GradientModel::GradientPropertyUnits GradientModel::readGradientPropertyUnits( const QString &propertyName) const { + NanotraceHR::Tracer tracer{"gradient model read gradient property units", category()}; + if (hasPercentageGradientProperty(propertyName)) return GradientPropertyUnits::Percentage; @@ -559,6 +597,8 @@ bool GradientModel::isPercentageSupportedByProperty(const QString &propertyName, void GradientModel::setupModel() { + NanotraceHR::Tracer tracer{"gradient model setup model", category()}; + m_locked = true; const QScopeGuard cleanup([&] { m_locked = false; }); @@ -568,7 +608,9 @@ void GradientModel::setupModel() void GradientModel::setAnchorBackend(const QVariant &anchorBackend) { - auto anchorBackendObject = anchorBackend.value(); + NanotraceHR::Tracer tracer{"gradient model set anchor backend", category()}; + + auto anchorBackendObject = anchorBackend.value(); const auto backendCasted = qobject_cast(anchorBackendObject); @@ -592,32 +634,44 @@ void GradientModel::setAnchorBackend(const QVariant &anchorBackend) QString GradientModel::gradientPropertyName() const { + NanotraceHR::Tracer tracer{"gradient model gradient property name", category()}; + return m_gradientPropertyName; } void GradientModel::setGradientPropertyName(const QString &name) { + NanotraceHR::Tracer tracer{"gradient model set gradient property name", category()}; + m_gradientPropertyName = name; } QString GradientModel::gradientTypeName() const { + NanotraceHR::Tracer tracer{"gradient model gradient type name", category()}; + return m_gradientTypeName; } void GradientModel::setGradientTypeName(const QString &name) { + NanotraceHR::Tracer tracer{"gradient model set gradient type name", category()}; + m_gradientTypeName = name; } bool GradientModel::hasGradient() const { + NanotraceHR::Tracer tracer{"gradient model has gradient", category()}; + return m_itemNode.isValid() - && m_itemNode.modelNode().hasProperty(gradientPropertyName().toUtf8()); + && m_itemNode.modelNode().hasProperty(gradientPropertyName().toUtf8()); } bool GradientModel::locked() const { + NanotraceHR::Tracer tracer{"gradient model locked", category()}; + if (m_locked) return true; @@ -628,6 +682,8 @@ bool GradientModel::locked() const bool GradientModel::hasShapesImport() const { + NanotraceHR::Tracer tracer{"gradient model has shapes import", category()}; + if (m_itemNode.isValid()) { QmlDesigner::Import import = QmlDesigner::Import::createLibraryImport("QtQuick.Shapes", "1.0"); return model()->hasImport(import, true, true); @@ -638,6 +694,8 @@ bool GradientModel::hasShapesImport() const void GradientModel::ensureShapesImport() { + NanotraceHR::Tracer tracer{"gradient model ensure shapes import", category()}; + if (!hasShapesImport()) { QmlDesigner::Import timelineImport = QmlDesigner::Import::createLibraryImport("QtQuick.Shapes", "1.0"); try { @@ -650,6 +708,8 @@ void GradientModel::ensureShapesImport() void GradientModel::setupGradientProperties(const QmlDesigner::ModelNode &gradient) { + NanotraceHR::Tracer tracer{"gradient model setup gradient properties", category()}; + QTC_ASSERT(m_itemNode.isValid(), return); QTC_ASSERT(gradient.isValid(), return); @@ -676,23 +736,31 @@ void GradientModel::setupGradientProperties(const QmlDesigner::ModelNode &gradie QmlDesigner::Model *GradientModel::model() const { + NanotraceHR::Tracer tracer{"gradient model model", category()}; + QTC_ASSERT(m_itemNode.isValid(), return nullptr); return m_itemNode.view()->model(); } QmlDesigner::AbstractView *GradientModel::view() const { + NanotraceHR::Tracer tracer{"gradient model view", category()}; + QTC_ASSERT(m_itemNode.isValid(), return nullptr); return m_itemNode.view(); } void GradientModel::resetPuppet() { + NanotraceHR::Tracer tracer{"gradient model reset puppet", category()}; + QTimer::singleShot(1000, view(), &QmlDesigner::AbstractView::resetPuppet); } QmlDesigner::ModelNode GradientModel::createGradientNode() { + NanotraceHR::Tracer tracer{"gradient model create gradient node", category()}; + #ifdef QDS_USE_PROJECTSTORAGE QmlDesigner::TypeName typeName = m_gradientTypeName.toUtf8(); auto gradientNode = view()->createModelNode(typeName); @@ -719,6 +787,8 @@ QmlDesigner::ModelNode GradientModel::createGradientNode() QmlDesigner::ModelNode GradientModel::createGradientStopNode() { + NanotraceHR::Tracer tracer{"gradient model create gradient stop node", category()}; + #ifdef QDS_USE_PROJECTSTORAGE return view()->createModelNode("GradientStop"); #else @@ -734,6 +804,8 @@ QmlDesigner::ModelNode GradientModel::createGradientStopNode() void GradientModel::deleteGradientNode(bool saveTransaction) { + NanotraceHR::Tracer tracer{"gradient model delete gradient node", category()}; + QmlDesigner::ModelNode modelNode = m_itemNode.modelNode(); if (m_itemNode.isInBaseState()) { @@ -754,6 +826,8 @@ void GradientModel::deleteGradientNode(bool saveTransaction) bool GradientModel::hasPercentageGradientProperty(const QString &propertyName) const { + NanotraceHR::Tracer tracer{"gradient model has percentage gradient property", category()}; + bool result = false; getPercentageGradientProperty(propertyName.toUtf8(), &result); return result; @@ -762,6 +836,8 @@ bool GradientModel::hasPercentageGradientProperty(const QString &propertyName) c qreal GradientModel::getPercentageGradientProperty(const QmlDesigner::PropertyNameView propertyName, bool *ok) const { + NanotraceHR::Tracer tracer{"gradient model get percentage gradient property", category()}; + if (ok != nullptr) *ok = false; @@ -809,6 +885,8 @@ qreal GradientModel::getPercentageGradientProperty(const QmlDesigner::PropertyNa QVariant GradientModel::getGradientPropertyVariant(const QString &propertyName) const { + NanotraceHR::Tracer tracer{"gradient model get gradient property variant", category()}; + if (!m_itemNode.isValid()) return {}; @@ -825,6 +903,8 @@ QVariant GradientModel::getGradientPropertyVariant(const QString &propertyName) ShapeGradientPropertyData GradientModel::getDefaultGradientPropertyData( const QmlDesigner::PropertyNameView propertyName, const QStringView &gradientType) const { + NanotraceHR::Tracer tracer{"gradient model get default gradient property data", category()}; + const auto *gradData = getDefaultGradientData(propertyName, gradientType); if (gradData != nullptr) return *gradData; @@ -834,6 +914,8 @@ ShapeGradientPropertyData GradientModel::getDefaultGradientPropertyData( void GradientModel::setGradientProperty(const QString &propertyName, qreal value) { + NanotraceHR::Tracer tracer{"gradient model set gradient property", category()}; + QTC_ASSERT(m_itemNode.isValid(), return); QmlDesigner::QmlObjectNode gradient = m_itemNode.modelNode() @@ -851,6 +933,8 @@ void GradientModel::setGradientProperty(const QString &propertyName, qreal value void GradientModel::setGradientPropertyPercentage(const QString &propertyName, qreal value) { + NanotraceHR::Tracer tracer{"gradient model set gradient property percentage", category()}; + QTC_ASSERT(m_itemNode.isValid(), return); QmlDesigner::QmlObjectNode gradient = m_itemNode.modelNode() @@ -883,6 +967,8 @@ void GradientModel::setGradientPropertyPercentage(const QString &propertyName, q void GradientModel::setGradientOrientation(Qt::Orientation value) { + NanotraceHR::Tracer tracer{"gradient model set gradient orientation", category()}; + QTC_ASSERT(m_itemNode.isValid(), return); QmlDesigner::QmlObjectNode gradient = m_itemNode.modelNode() @@ -903,6 +989,8 @@ void GradientModel::setGradientOrientation(Qt::Orientation value) void GradientModel::setGradientPropertyUnits(const QString &propertyName, GradientModel::GradientPropertyUnits value) { + NanotraceHR::Tracer tracer{"gradient model set gradient property units", category()}; + //translate from previous units to the new unit system const bool toPixels = (value == GradientPropertyUnits::Pixels); const bool toPercentage = (value == GradientPropertyUnits::Percentage); @@ -952,6 +1040,8 @@ void GradientModel::setGradientPropertyUnits(const QString &propertyName, void GradientModel::setPresetByID(int presetID) { + NanotraceHR::Tracer tracer{"gradient model set preset by ID", category()}; + const QGradient gradient(GradientPresetItem::createGradientFromPreset( static_cast(presetID))); const QList gradientStops = gradient.stops().toList(); @@ -971,6 +1061,8 @@ void GradientModel::setPresetByStops(const QList &stopsPositions, int stopsCount, bool saveTransaction) { + NanotraceHR::Tracer tracer{"gradient model set preset by stops", category()}; + if (m_locked) return; @@ -1017,6 +1109,8 @@ void GradientModel::setPresetByStops(const QList &stopsPositions, void GradientModel::savePreset() { + NanotraceHR::Tracer tracer{"gradient model save preset", category()}; + //preparing qgradient: QGradient currentGradient; QGradientStops currentStops; @@ -1040,6 +1134,8 @@ void GradientModel::savePreset() void GradientModel::updateGradient() { + NanotraceHR::Tracer tracer{"gradient model update gradient", category()}; + beginResetModel(); QList stops; diff --git a/src/plugins/qmldesigner/components/propertyeditor/gradientpresetcustomlistmodel.cpp b/src/plugins/qmldesigner/components/propertyeditor/gradientpresetcustomlistmodel.cpp index 1b87ba0e753..446713db439 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/gradientpresetcustomlistmodel.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/gradientpresetcustomlistmodel.cpp @@ -3,6 +3,7 @@ #include "gradientpresetcustomlistmodel.h" #include "gradientpresetitem.h" +#include "propertyeditortracing.h" #include #include @@ -14,7 +15,9 @@ #include #include -namespace Internal { +namespace { + +auto category = QmlDesigner::PropertyEditorTracing::category; const char settingsKey[] = "GradientPresetCustomList"; const char settingsFileName[] = "GradientPresets.ini"; @@ -27,45 +30,56 @@ QString settingsFullFilePath(const QSettings::Scope &scope) return Core::ICore::userResourcePath(settingsFileName).toUrlishString(); } -} // namespace Internal +} // namespace GradientPresetCustomListModel::GradientPresetCustomListModel(QObject *parent) : GradientPresetListModel(parent) , m_filename(getFilename()) { + NanotraceHR::Tracer tracer{"gradient preset custom list model constructor", category()}; + readPresets(); } -GradientPresetCustomListModel::~GradientPresetCustomListModel() {} +GradientPresetCustomListModel::~GradientPresetCustomListModel() +{ + NanotraceHR::Tracer tracer{"gradient preset custom list model destructor", category()}; +} void GradientPresetCustomListModel::registerDeclarativeType() { - qmlRegisterType("HelperWidgets", - 2, - 0, - "GradientPresetCustomListModel"); + NanotraceHR::Tracer tracer{"gradient preset custom list model register declarative type", + category()}; + + qmlRegisterType("HelperWidgets", 2, 0, "GradientPresetCustomListModel"); } QString GradientPresetCustomListModel::getFilename() { - return Internal::settingsFullFilePath(QSettings::UserScope); + NanotraceHR::Tracer tracer{"gradient preset custom list model get filename", category()}; + + return settingsFullFilePath(QSettings::UserScope); } void GradientPresetCustomListModel::storePresets(const QString &filename, const QList &items) { + NanotraceHR::Tracer tracer{"gradient preset custom list model store presets", category()}; + const QList presets = Utils::transform>( items, [](const GradientPresetItem &item) { return QVariant::fromValue(item); }); QSettings settings(filename, QSettings::IniFormat); settings.clear(); - settings.setValue(Internal::settingsKey, QVariant::fromValue(presets)); + settings.setValue(settingsKey, QVariant::fromValue(presets)); } QList GradientPresetCustomListModel::storedPresets(const QString &filename) { + NanotraceHR::Tracer tracer{"gradient preset custom list model stored presets", category()}; + const QSettings settings(filename, QSettings::IniFormat); - const QVariant presetSettings = settings.value(Internal::settingsKey); + const QVariant presetSettings = settings.value(settingsKey); if (!presetSettings.isValid()) return {}; @@ -86,6 +100,8 @@ void GradientPresetCustomListModel::addGradient(const QList &stopsPositio const QList &stopsColors, int stopsCount) { + NanotraceHR::Tracer tracer{"gradient preset custom list model add gradient", category()}; + QGradient tempGradient; QGradientStops gradientStops; QGradientStop gradientStop; @@ -102,6 +118,8 @@ void GradientPresetCustomListModel::addGradient(const QList &stopsPositio void GradientPresetCustomListModel::changePresetName(int id, const QString &newName) { + NanotraceHR::Tracer tracer{"gradient preset custom list model change preset name", category()}; + QTC_ASSERT(id >= 0, return); QTC_ASSERT(id < m_items.size(), return); m_items[id].setPresetName(newName); @@ -110,6 +128,8 @@ void GradientPresetCustomListModel::changePresetName(int id, const QString &newN void GradientPresetCustomListModel::deletePreset(int id) { + NanotraceHR::Tracer tracer{"gradient preset custom list model delete preset", category()}; + QTC_ASSERT(id >= 0, return); QTC_ASSERT(id < m_items.size(), return); beginResetModel(); @@ -120,11 +140,15 @@ void GradientPresetCustomListModel::deletePreset(int id) void GradientPresetCustomListModel::writePresets() { + NanotraceHR::Tracer tracer{"gradient preset custom list model write presets", category()}; + storePresets(m_filename, m_items); } void GradientPresetCustomListModel::readPresets() { + NanotraceHR::Tracer tracer{"gradient preset custom list model read presets", category()}; + const QList presets = storedPresets(m_filename); beginResetModel(); m_items.clear(); diff --git a/src/plugins/qmldesigner/components/propertyeditor/gradientpresetdefaultlistmodel.cpp b/src/plugins/qmldesigner/components/propertyeditor/gradientpresetdefaultlistmodel.cpp index 11f927e9413..b99c8ff62d7 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/gradientpresetdefaultlistmodel.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/gradientpresetdefaultlistmodel.cpp @@ -3,22 +3,33 @@ #include "gradientpresetdefaultlistmodel.h" #include "gradientpresetitem.h" +#include "propertyeditortracing.h" #include #include #include #include +static auto category = QmlDesigner::PropertyEditorTracing::category; + GradientPresetDefaultListModel::GradientPresetDefaultListModel(QObject *parent) : GradientPresetListModel(parent) { + NanotraceHR::Tracer tracer{"gradient preset default list model constructor", category()}; + addAllPresets(); } -GradientPresetDefaultListModel::~GradientPresetDefaultListModel() {} +GradientPresetDefaultListModel::~GradientPresetDefaultListModel() +{ + NanotraceHR::Tracer tracer{"gradient preset default list model destructor", category()}; +} void GradientPresetDefaultListModel::registerDeclarativeType() { + NanotraceHR::Tracer tracer{"gradient preset default list model register declarative type", + category()}; + qmlRegisterType("HelperWidgets", 2, 0, @@ -27,6 +38,8 @@ void GradientPresetDefaultListModel::registerDeclarativeType() void GradientPresetDefaultListModel::addAllPresets() { + NanotraceHR::Tracer tracer{"gradient preset default list model add all presets", category()}; + const QMetaObject &metaObj = QGradient::staticMetaObject; const QMetaEnum metaEnum = metaObj.enumerator(metaObj.indexOfEnumerator("Preset")); diff --git a/src/plugins/qmldesigner/components/propertyeditor/gradientpresetitem.cpp b/src/plugins/qmldesigner/components/propertyeditor/gradientpresetitem.cpp index 700b13ca209..98620535215 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/gradientpresetitem.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/gradientpresetitem.cpp @@ -2,6 +2,7 @@ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 #include "gradientpresetitem.h" +#include "propertyeditortracing.h" #include #include @@ -14,26 +15,36 @@ #include +static auto category = QmlDesigner::PropertyEditorTracing::category; + GradientPresetItem::GradientPresetItem() : m_gradientVal(QGradient()) , m_gradientID(Preset(0)) , m_presetName(QString()) -{} +{ + NanotraceHR::Tracer tracer{"gradient preset item default constructor", category()}; +} GradientPresetItem::GradientPresetItem(const QGradient &value, const QString &name) : m_gradientVal(value) , m_gradientID(Preset(0)) , m_presetName(name) -{} +{ + NanotraceHR::Tracer tracer{"gradient preset item constructor with gradient and name", category()}; +} GradientPresetItem::GradientPresetItem(const Preset value) : m_gradientVal(createGradientFromPreset(value)) , m_gradientID(value) , m_presetName(getNameByPreset(value)) -{} +{ + NanotraceHR::Tracer tracer{"gradient preset item constructor with preset", category()}; +} QVariant GradientPresetItem::getProperty(GradientPresetItem::Property id) const { + NanotraceHR::Tracer tracer{"gradient preset item get property", category()}; + QVariant out; switch (id) { @@ -65,11 +76,15 @@ QVariant GradientPresetItem::getProperty(GradientPresetItem::Property id) const QGradient GradientPresetItem::gradientVal() const { + NanotraceHR::Tracer tracer{"gradient preset item gradient value", category()}; + return m_gradientVal; } void GradientPresetItem::setGradient(const QGradient &value) { + NanotraceHR::Tracer tracer{"gradient preset item set gradient", category()}; + m_gradientVal = value; m_gradientID = Preset(0); m_presetName = QString(); @@ -77,6 +92,8 @@ void GradientPresetItem::setGradient(const QGradient &value) void GradientPresetItem::setGradient(const Preset value) { + NanotraceHR::Tracer tracer{"gradient preset item set gradient by preset", category()}; + m_gradientID = value; m_gradientVal = createGradientFromPreset(value); m_presetName = getNameByPreset(value); @@ -84,6 +101,8 @@ void GradientPresetItem::setGradient(const Preset value) QList GradientPresetItem::stopsPosList() const { + NanotraceHR::Tracer tracer{"gradient preset item stops position list", category()}; + const QList> subres = m_gradientVal.stops().toList(); const QList result = Utils::transform>(subres, [](const QPair &item) { @@ -94,6 +113,8 @@ QList GradientPresetItem::stopsPosList() const QList GradientPresetItem::stopsColorList() const { + NanotraceHR::Tracer tracer{"gradient preset item stops color list", category()}; + const QList> subres = m_gradientVal.stops().toList(); const QList result = Utils::transform>(subres, [](const QPair &item) { @@ -104,26 +125,36 @@ QList GradientPresetItem::stopsColorList() const int GradientPresetItem::stopListSize() const { + NanotraceHR::Tracer tracer{"gradient preset item stop list size", category()}; + return m_gradientVal.stops().size(); } void GradientPresetItem::setPresetName(const QString &value) { + NanotraceHR::Tracer tracer{"gradient preset item set preset name", category()}; + m_presetName = value; } QString GradientPresetItem::presetName() const { + NanotraceHR::Tracer tracer{"gradient preset item preset name", category()}; + return m_presetName; } int GradientPresetItem::presetID() const { + NanotraceHR::Tracer tracer{"gradient preset item preset ID", category()}; + return static_cast(m_gradientID); } QString GradientPresetItem::getNameByPreset(Preset value) { + NanotraceHR::Tracer tracer{"gradient preset item get name by preset", category()}; + const QMetaObject &metaObj = QGradient::staticMetaObject; const QMetaEnum metaEnum = metaObj.enumerator(metaObj.indexOfEnumerator("Preset")); @@ -143,6 +174,8 @@ QString GradientPresetItem::getNameByPreset(Preset value) QGradient GradientPresetItem::createGradientFromPreset(Preset value) { + NanotraceHR::Tracer tracer{"gradient preset item create gradient from preset", category()}; + return QGradient(value); } @@ -156,6 +189,7 @@ QDebug &operator<<(QDebug &stream, const GradientPresetItem &gradient) QDataStream &operator<<(QDataStream &stream, const GradientPresetItem &gradient) { + NanotraceHR::Tracer tracer{"gradient preset item operator <<", category()}; stream << gradient.m_gradientVal.stops(); stream << static_cast(gradient.m_gradientID); @@ -165,6 +199,8 @@ QDataStream &operator<<(QDataStream &stream, const GradientPresetItem &gradient) QDataStream &operator>>(QDataStream &stream, GradientPresetItem &gradient) { + NanotraceHR::Tracer tracer{"gradient preset item operator >>", category()}; + QGradientStops stops; stream >> stops; gradient.m_gradientVal.setStops(stops); diff --git a/src/plugins/qmldesigner/components/propertyeditor/gradientpresetlistmodel.cpp b/src/plugins/qmldesigner/components/propertyeditor/gradientpresetlistmodel.cpp index 676bdd28dfb..f4359b41203 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/gradientpresetlistmodel.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/gradientpresetlistmodel.cpp @@ -3,35 +3,46 @@ #include "gradientpresetlistmodel.h" #include "gradientpresetitem.h" +#include "propertyeditortracing.h" #include #include #include +static auto category = QmlDesigner::PropertyEditorTracing::category; + GradientPresetListModel::GradientPresetListModel(QObject *parent) : QAbstractListModel(parent) { - m_roleNames - = {{static_cast(GradientPresetItem::Property::objectNameRole), "objectName"}, - {static_cast(GradientPresetItem::Property::stopsPosListRole), "stopsPosList"}, - {static_cast(GradientPresetItem::Property::stopsColorListRole), "stopsColorList"}, - {static_cast(GradientPresetItem::Property::stopListSizeRole), "stopListSize"}, - {static_cast(GradientPresetItem::Property::presetNameRole), "presetName"}, - {static_cast(GradientPresetItem::Property::presetIDRole), "presetID"}}; + NanotraceHR::Tracer tracer{"gradient preset list model constructor", category()}; + + m_roleNames = {{static_cast(GradientPresetItem::Property::objectNameRole), "objectName"}, + {static_cast(GradientPresetItem::Property::stopsPosListRole), "stopsPosList"}, + {static_cast(GradientPresetItem::Property::stopsColorListRole), + "stopsColorList"}, + {static_cast(GradientPresetItem::Property::stopListSizeRole), "stopListSize"}, + {static_cast(GradientPresetItem::Property::presetNameRole), "presetName"}, + {static_cast(GradientPresetItem::Property::presetIDRole), "presetID"}}; } GradientPresetListModel::~GradientPresetListModel() { + NanotraceHR::Tracer tracer{"gradient preset list model destructor", category()}; + clearItems(); } int GradientPresetListModel::rowCount(const QModelIndex & /*parent*/) const { + NanotraceHR::Tracer tracer{"gradient preset list model row count", category()}; + return m_items.size(); } QVariant GradientPresetListModel::data(const QModelIndex &index, int role) const { + NanotraceHR::Tracer tracer{"gradient preset list model data", category()}; + if (index.isValid() && (index.row() >= 0) && (index.row() < m_items.size())) { if (m_roleNames.contains(role)) { QVariant value = m_items.at(index.row()) @@ -53,11 +64,15 @@ QVariant GradientPresetListModel::data(const QModelIndex &index, int role) const QHash GradientPresetListModel::roleNames() const { + NanotraceHR::Tracer tracer{"gradient preset list model role names", category()}; + return m_roleNames; } void GradientPresetListModel::clearItems() { + NanotraceHR::Tracer tracer{"gradient preset list model clear items", category()}; + beginResetModel(); m_items.clear(); endResetModel(); @@ -65,6 +80,8 @@ void GradientPresetListModel::clearItems() void GradientPresetListModel::addItem(const GradientPresetItem &element) { + NanotraceHR::Tracer tracer{"gradient preset list model add item", category()}; + beginResetModel(); m_items.append(element); endResetModel(); @@ -72,16 +89,21 @@ void GradientPresetListModel::addItem(const GradientPresetItem &element) const QList &GradientPresetListModel::items() const { + NanotraceHR::Tracer tracer{"gradient preset list model items", category()}; + return m_items; } void GradientPresetListModel::sortItems() { + NanotraceHR::Tracer tracer{"gradient preset list model sort items", category()}; std::ranges::sort(m_items, {}, &GradientPresetItem::presetID); } void GradientPresetListModel::registerDeclarativeType() { + NanotraceHR::Tracer tracer{"gradient preset list model register declarative type", category()}; + qmlRegisterType("HelperWidgets", 2, 0, "GradientPresetListModel"); } diff --git a/src/plugins/qmldesigner/components/propertyeditor/instanceimageprovider.cpp b/src/plugins/qmldesigner/components/propertyeditor/instanceimageprovider.cpp index 6b7cc4084ec..b6e663987f3 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/instanceimageprovider.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/instanceimageprovider.cpp @@ -2,18 +2,23 @@ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 #include "instanceimageprovider.h" +#include "propertyeditortracing.h" #include #include +static auto category = QmlDesigner::PropertyEditorTracing::category; + static const char INSTANCE_IMAGE_REQUEST_ID[] = "PropertyEditor.InstanceImage"; namespace QmlDesigner { InstanceImageProvider::InstanceImageProvider() : QQuickImageProvider(Pixmap) - , m_delayTimer(new QTimer(this)) + , m_delayTimer(std::make_unique()) { + NanotraceHR::Tracer tracer{"instance image provider constructor", category()}; + m_delayTimer->setInterval(500); m_delayTimer->setSingleShot(true); m_delayTimer->callOnTimeout([this] { requestOne(); }); @@ -30,6 +35,8 @@ InstanceImageProvider::InstanceImageProvider() */ QPixmap InstanceImageProvider::requestPixmap(const QString &id, QSize *size, const QSize &requestedSize) { + NanotraceHR::Tracer tracer{"instance image provider request pixmap", category()}; + using namespace Qt::StringLiterals; static const QPixmap defaultImage = QPixmap::fromImage( QImage(":/propertyeditor/images/defaultmaterialpreview.png")); @@ -69,6 +76,8 @@ bool InstanceImageProvider::feedImage(const ModelNode &node, const QPixmap &pixmap, const QByteArray &requestId) { + NanotraceHR::Tracer tracer{"instance image provider feed image", category()}; + if (!requestId.startsWith(INSTANCE_IMAGE_REQUEST_ID)) return false; @@ -83,16 +92,22 @@ bool InstanceImageProvider::feedImage(const ModelNode &node, void InstanceImageProvider::setModelNode(const ModelNode &node) { + NanotraceHR::Tracer tracer{"instance image provider set model node", category()}; + m_requestedNode = node; } bool InstanceImageProvider::hasPendingRequest() const { + NanotraceHR::Tracer tracer{"instance image provider has pending request", category()}; + return !m_pendingRequest.isEmpty(); } void InstanceImageProvider::requestOne() { + NanotraceHR::Tracer tracer{"instance image provider request one", category()}; + if (!m_requestedNode) return; @@ -109,18 +124,24 @@ void InstanceImageProvider::requestOne() void InstanceImageProvider::requestOne(QSize size) { + NanotraceHR::Tracer tracer{"instance image provider request one with size", category()}; + prepareRequest(size); requestOne(); } void InstanceImageProvider::postponeRequest(QSize size) { + NanotraceHR::Tracer tracer{"instance image provider postpone request", category()}; + prepareRequest(size); - QMetaObject::invokeMethod(m_delayTimer, static_cast(&QTimer::start)); + QMetaObject::invokeMethod(m_delayTimer.get(), static_cast(&QTimer::start)); } void InstanceImageProvider::prepareRequest(QSize size) { + NanotraceHR::Tracer tracer{"instance image provider prepare request", category()}; + m_requestedSize = size; } @@ -131,16 +152,22 @@ void InstanceImageProvider::prepareRequest(QSize size) */ bool InstanceImageProvider::dataAvailable(const ModelNode &node, QSize size) { + NanotraceHR::Tracer tracer{"instance image provider data available", category()}; + return !m_resetRequest && node == m_receivedNode && size == m_receivedImage.size(); } void InstanceImageProvider::invalidate() { + NanotraceHR::Tracer tracer{"instance image provider invalidate", category()}; + m_resetRequest = true; } QPixmap InstanceImageProvider::getScaledImage(QSize size) { + NanotraceHR::Tracer tracer{"instance image provider get scaled image", category()}; + if (size == m_receivedImage.size()) return m_receivedImage; else diff --git a/src/plugins/qmldesigner/components/propertyeditor/instanceimageprovider.h b/src/plugins/qmldesigner/components/propertyeditor/instanceimageprovider.h index c25b0b383fd..746d6c82ce4 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/instanceimageprovider.h +++ b/src/plugins/qmldesigner/components/propertyeditor/instanceimageprovider.h @@ -47,7 +47,7 @@ private: QPixmap m_receivedImage; - QTimer *m_delayTimer = nullptr; + std::unique_ptr m_delayTimer; }; } // namespace QmlDesigner diff --git a/src/plugins/qmldesigner/components/propertyeditor/itemfiltermodel.cpp b/src/plugins/qmldesigner/components/propertyeditor/itemfiltermodel.cpp index dd6b4e92691..ecddd07f5cc 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/itemfiltermodel.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/itemfiltermodel.cpp @@ -3,6 +3,8 @@ #include "itemfiltermodel.h" +#include "propertyeditortracing.h" + #include #include #include @@ -15,6 +17,8 @@ using namespace QmlDesigner; +static auto category = QmlDesigner::PropertyEditorTracing::category; + ItemFilterModel::ItemFilterModel(QObject *parent) : QAbstractListModel(parent) , m_typeFilter("QtQuick.Item") @@ -23,7 +27,9 @@ ItemFilterModel::ItemFilterModel(QObject *parent) void ItemFilterModel::setModelNodeBackend(const QVariant &modelNodeBackend) { - auto modelNodeBackendObject = modelNodeBackend.value(); + NanotraceHR::Tracer tracer{"item filter model set model node backend", category()}; + + auto modelNodeBackendObject = modelNodeBackend.value(); const auto backendObjectCasted = qobject_cast(modelNodeBackendObject); @@ -44,6 +50,8 @@ void ItemFilterModel::setModelNodeBackend(const QVariant &modelNodeBackend) void ItemFilterModel::setTypeFilter(const QString &filter) { + NanotraceHR::Tracer tracer{"item filter model set type filter", category()}; + if (m_typeFilter == filter) return; @@ -54,6 +62,8 @@ void ItemFilterModel::setTypeFilter(const QString &filter) void ItemFilterModel::setSelectionOnly(bool value) { + NanotraceHR::Tracer tracer{"item filter model set selection only", category()}; + if (m_selectionOnly == value) return; @@ -64,12 +74,16 @@ void ItemFilterModel::setSelectionOnly(bool value) void ItemFilterModel::setSelectedItems(const QStringList &selectedItems) { + NanotraceHR::Tracer tracer{"item filter model set selected items", category()}; + m_selectedItems = selectedItems; emit selectedItemsChanged(); } void ItemFilterModel::setValidationRoles(const QStringList &validationRoles) { + NanotraceHR::Tracer tracer{"item filter model set validation roles", category()}; + auto tmp = validationRoles; tmp.removeDuplicates(); @@ -83,21 +97,29 @@ void ItemFilterModel::setValidationRoles(const QStringList &validationRoles) QString ItemFilterModel::typeFilter() const { + NanotraceHR::Tracer tracer{"item filter model type filter", category()}; + return m_typeFilter; } bool ItemFilterModel::selectionOnly() const { + NanotraceHR::Tracer tracer{"item filter model selection only", category()}; + return m_selectionOnly; } QStringList ItemFilterModel::selectedItems() const { + NanotraceHR::Tracer tracer{"item filter model selected items", category()}; + return m_selectedItems; } QStringList ItemFilterModel::itemModel() const { + NanotraceHR::Tracer tracer{"item filter model item model", category()}; + AbstractView *view = m_modelNode.view(); if (!view || !view->model()) return {}; @@ -111,16 +133,22 @@ QStringList ItemFilterModel::itemModel() const QStringList ItemFilterModel::validationRoles() const { + NanotraceHR::Tracer tracer{"item filter model validation roles", category()}; + return m_validationRoles; } QStringList ItemFilterModel::validationItems() const { + NanotraceHR::Tracer tracer{"item filter model validation items", category()}; + return m_validationItems; } QVariant ItemFilterModel::modelItemData(int row) const { + NanotraceHR::Tracer tracer{"item filter model model item data", category()}; + QModelIndex idx = index(row, 0, {}); if (!idx.isValid()) return {}; @@ -141,6 +169,8 @@ QVariant ItemFilterModel::modelItemData(int row) const int ItemFilterModel::indexFromId(const QString &id) const { + NanotraceHR::Tracer tracer{"item filter model index from id", category()}; + AbstractView *view = m_modelNode.view(); if (!view || !view->model()) return -1; @@ -156,16 +186,22 @@ int ItemFilterModel::indexFromId(const QString &id) const void ItemFilterModel::registerDeclarativeType() { + NanotraceHR::Tracer tracer{"item filter model register declarative type", category()}; + qmlRegisterType("HelperWidgets", 2, 0, "ItemFilterModel"); } int ItemFilterModel::rowCount(const QModelIndex &) const { + NanotraceHR::Tracer tracer{"item filter model row count", category()}; + return m_modelInternalIds.size(); } QVariant ItemFilterModel::data(const QModelIndex &index, int role) const { + NanotraceHR::Tracer tracer{"item filter model data", category()}; + if (!index.isValid() || index.row() >= rowCount()) return {}; @@ -188,6 +224,8 @@ QVariant ItemFilterModel::data(const QModelIndex &index, int role) const QHash ItemFilterModel::roleNames() const { + NanotraceHR::Tracer tracer{"item filter model role names", category()}; + static QHash roleNames{{IdRole, "id"}, {NameRole, "name"}, {IdAndNameRole, "idAndName"}, @@ -198,11 +236,15 @@ QHash ItemFilterModel::roleNames() const QVariant ItemFilterModel::modelNodeBackend() const { + NanotraceHR::Tracer tracer{"item filter model model node backend", category()}; + return {}; } ModelNode ItemFilterModel::modelNodeForRow(const int &row) const { + NanotraceHR::Tracer tracer{"item filter model model node for row", category()}; + if (row < 0 || row >= m_modelInternalIds.size()) return {}; @@ -215,6 +257,8 @@ ModelNode ItemFilterModel::modelNodeForRow(const int &row) const void ItemFilterModel::setupModel() { + NanotraceHR::Tracer tracer{"item filter model setup model", category()}; + if (!m_modelNode.isValid() || !m_modelNode.view()->isAttached()) return; @@ -238,6 +282,8 @@ void ItemFilterModel::setupModel() void ItemFilterModel::setupValidationItems() { + NanotraceHR::Tracer tracer{"item filter model setup validation items", category()}; + QStringList validationItems; for (const QString &role : m_validationRoles) { diff --git a/src/plugins/qmldesigner/components/propertyeditor/listvalidator.cpp b/src/plugins/qmldesigner/components/propertyeditor/listvalidator.cpp index c1eaa48c3fe..14742d36622 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/listvalidator.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/listvalidator.cpp @@ -3,12 +3,20 @@ #include "listvalidator.h" +#include "propertyeditortracing.h" + +static auto category = QmlDesigner::PropertyEditorTracing::category; + ListValidator::ListValidator(QObject *parent) : QValidator{parent} -{} +{ + NanotraceHR::Tracer tracer{"list validator constructor", category()}; +} QValidator::State ListValidator::validate(QString &input, int &) const { + NanotraceHR::Tracer tracer{"list validator validate", category()}; + if (input.isEmpty()) return QValidator::Intermediate; @@ -30,6 +38,8 @@ QValidator::State ListValidator::validate(QString &input, int &) const void ListValidator::fixup(QString &input) const { + NanotraceHR::Tracer tracer{"list validator fixup", category()}; + for (const QString &item : m_filterList) { if (item.compare(input, Qt::CaseInsensitive) == 0) { input = item; @@ -40,6 +50,8 @@ void ListValidator::fixup(QString &input) const void ListValidator::setFilterList(const QStringList &filterList) { + NanotraceHR::Tracer tracer{"list validator set filter list", category()}; + if (m_filterList == filterList) return; @@ -49,10 +61,14 @@ void ListValidator::setFilterList(const QStringList &filterList) QStringList ListValidator::filterList() const { + NanotraceHR::Tracer tracer{"list validator filter list", category()}; + return m_filterList; } void ListValidator::registerDeclarativeType() { + NanotraceHR::Tracer tracer{"list validator register declarative type", category()}; + qmlRegisterType("HelperWidgets", 2, 0, "ListValidator"); } diff --git a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorcontextobject.cpp b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorcontextobject.cpp index bbf36cffab7..eeba449dc53 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorcontextobject.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorcontextobject.cpp @@ -3,17 +3,19 @@ #include "propertyeditorcontextobject.h" -#include "abstractview.h" #include "compatibleproperties.h" -#include "easingcurvedialog.h" -#include "nodemetainfo.h" +#include "propertyeditortracing.h" #include "propertyeditorutils.h" -#include "qml3dnode.h" -#include "qmldesignerconstants.h" -#include "qmldesignerplugin.h" -#include "qmlmodelnodeproxy.h" -#include "qmlobjectnode.h" -#include "qmltimeline.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include #include @@ -34,6 +36,8 @@ namespace QmlDesigner { +static auto category = QmlDesigner::PropertyEditorTracing::category; + static Q_LOGGING_CATEGORY(urlSpecifics, "qtc.propertyeditor.specifics", QtWarningMsg) PropertyEditorContextObject::PropertyEditorContextObject(QObject *parent) @@ -43,10 +47,14 @@ PropertyEditorContextObject::PropertyEditorContextObject(QObject *parent) , m_backendValues(nullptr) , m_qmlComponent(nullptr) , m_qmlContext(nullptr) -{} +{ + NanotraceHR::Tracer tracer{"property editor context object constructor", category()}; +} QString PropertyEditorContextObject::convertColorToString(const QVariant &color) { + NanotraceHR::Tracer tracer{"property editor context object convert color to string", category()}; + QString colorString; QColor theColor; if (color.canConvert(QMetaType(QMetaType::QColor))) { @@ -69,13 +77,16 @@ QString PropertyEditorContextObject::convertColorToString(const QVariant &color) QColor PropertyEditorContextObject::colorFromString(const QString &colorString) { + NanotraceHR::Tracer tracer{"property editor context object color from string", category()}; + return QColor::fromString(colorString); } QString PropertyEditorContextObject::translateFunction() { - if (QmlDesignerPlugin::instance()->settings().value( - DesignerSettingsKey::TYPE_OF_QSTR_FUNCTION).toInt()) + NanotraceHR::Tracer tracer{"property editor context object translate function", category()}; + + if (QmlDesignerPlugin::instance()->settings().value(DesignerSettingsKey::TYPE_OF_QSTR_FUNCTION).toInt()) switch (QmlDesignerPlugin::instance()->settings().value( DesignerSettingsKey::TYPE_OF_QSTR_FUNCTION).toInt()) { @@ -90,6 +101,8 @@ QString PropertyEditorContextObject::translateFunction() QStringList PropertyEditorContextObject::autoComplete(const QString &text, int pos, bool explicitComplete, bool filter) { + NanotraceHR::Tracer tracer{"property editor context object auto complete", category()}; + if (m_model && m_model->rewriterView()) return Utils::filtered(m_model->rewriterView()->autoComplete(text, pos, explicitComplete), [filter](const QString &string) { return !filter || (!string.isEmpty() && string.at(0).isUpper()); }); @@ -99,6 +112,8 @@ QStringList PropertyEditorContextObject::autoComplete(const QString &text, int p void PropertyEditorContextObject::toggleExportAlias() { + NanotraceHR::Tracer tracer{"property editor context object toggle export alias", category()}; + QTC_ASSERT(m_model && m_model->rewriterView(), return); /* Ideally we should not missuse the rewriterView @@ -127,6 +142,8 @@ void PropertyEditorContextObject::toggleExportAlias() void PropertyEditorContextObject::goIntoComponent() { + NanotraceHR::Tracer tracer{"property editor context object go into component", category()}; + QTC_ASSERT(m_model && m_model->rewriterView(), return); /* Ideally we should not missuse the rewriterView @@ -142,6 +159,8 @@ void PropertyEditorContextObject::goIntoComponent() void PropertyEditorContextObject::changeTypeName(const QString &typeName) { + NanotraceHR::Tracer tracer{"property editor context object change type name", category()}; + QTC_ASSERT(m_model && m_model->rewriterView(), return); /* Ideally we should not missuse the rewriterView @@ -295,11 +314,15 @@ void PropertyEditorContextObject::insertKeyframe(const QString &propertyName) QString PropertyEditorContextObject::activeDragSuffix() const { + NanotraceHR::Tracer tracer{"property editor context object active drag suffix", category()}; + return m_activeDragSuffix; } void PropertyEditorContextObject::setActiveDragSuffix(const QString &suffix) { + NanotraceHR::Tracer tracer{"property editor context object set active drag suffix", category()}; + if (m_activeDragSuffix != suffix) { m_activeDragSuffix = suffix; emit activeDragSuffixChanged(); @@ -308,22 +331,29 @@ void PropertyEditorContextObject::setActiveDragSuffix(const QString &suffix) int PropertyEditorContextObject::majorVersion() const { - return m_majorVersion; + NanotraceHR::Tracer tracer{"property editor context object major version", category()}; + return m_majorVersion; } int PropertyEditorContextObject::majorQtQuickVersion() const { + NanotraceHR::Tracer tracer{"property editor context object major Qt Quick version", category()}; + return m_majorQtQuickVersion; } int PropertyEditorContextObject::minorQtQuickVersion() const { + NanotraceHR::Tracer tracer{"property editor context object minor Qt Quick version", category()}; + return m_minorQtQuickVersion; } void PropertyEditorContextObject::setMajorVersion(int majorVersion) { + NanotraceHR::Tracer tracer{"property editor context object set major version", category()}; + if (m_majorVersion == majorVersion) return; @@ -334,6 +364,9 @@ void PropertyEditorContextObject::setMajorVersion(int majorVersion) void PropertyEditorContextObject::setMajorQtQuickVersion(int majorVersion) { + NanotraceHR::Tracer tracer{"property editor context object set major Qt Quick version", + category()}; + if (m_majorQtQuickVersion == majorVersion) return; @@ -345,6 +378,9 @@ void PropertyEditorContextObject::setMajorQtQuickVersion(int majorVersion) void PropertyEditorContextObject::setMinorQtQuickVersion(int minorVersion) { + NanotraceHR::Tracer tracer{"property editor context object set minor Qt Quick version", + category()}; + if (m_minorQtQuickVersion == minorVersion) return; @@ -355,6 +391,8 @@ void PropertyEditorContextObject::setMinorQtQuickVersion(int minorVersion) int PropertyEditorContextObject::minorVersion() const { + NanotraceHR::Tracer tracer{"property editor context object minor version", category()}; + return m_minorVersion; } @@ -370,11 +408,14 @@ void PropertyEditorContextObject::setMinorVersion(int minorVersion) bool PropertyEditorContextObject::hasActiveTimeline() const { + NanotraceHR::Tracer tracer{"property editor context object has active timeline", category()}; return m_setHasActiveTimeline; } void PropertyEditorContextObject::setHasActiveTimeline(bool b) { + NanotraceHR::Tracer tracer{"property editor context object set has active timeline", category()}; + if (b == m_setHasActiveTimeline) return; @@ -384,12 +425,16 @@ void PropertyEditorContextObject::setHasActiveTimeline(bool b) void PropertyEditorContextObject::insertInQmlContext(QQmlContext *context) { + NanotraceHR::Tracer tracer{"property editor context object insert in QML context", category()}; + m_qmlContext = context; m_qmlContext->setContextObject(this); } QQmlComponent *PropertyEditorContextObject::specificQmlComponent() { + NanotraceHR::Tracer tracer{"property editor context object specific QML component", category()}; + if (m_qmlComponent) return m_qmlComponent; @@ -408,11 +453,14 @@ QQmlComponent *PropertyEditorContextObject::specificQmlComponent() bool PropertyEditorContextObject::hasMultiSelection() const { + NanotraceHR::Tracer tracer{"property editor context object has multi selection", category()}; + return m_hasMultiSelection; } void PropertyEditorContextObject::setHasMultiSelection(bool b) { + NanotraceHR::Tracer tracer{"property editor context object set has multi selection", category()}; if (b == m_hasMultiSelection) return; @@ -422,11 +470,15 @@ void PropertyEditorContextObject::setHasMultiSelection(bool b) bool PropertyEditorContextObject::isSelectionLocked() const { + NanotraceHR::Tracer tracer{"property editor context object is selection locked", category()}; + return m_isSelectionLocked; } void PropertyEditorContextObject::setIsSelectionLocked(bool lock) { + NanotraceHR::Tracer tracer{"property editor context object set is selection locked", category()}; + if (lock == m_isSelectionLocked) return; @@ -436,6 +488,8 @@ void PropertyEditorContextObject::setIsSelectionLocked(bool lock) void PropertyEditorContextObject::setInsightEnabled(bool value) { + NanotraceHR::Tracer tracer{"property editor context object set insight enabled", category()}; + if (value != m_insightEnabled) { m_insightEnabled = value; emit insightEnabledChanged(); @@ -444,12 +498,16 @@ void PropertyEditorContextObject::setInsightEnabled(bool value) void PropertyEditorContextObject::setInsightCategories(const QStringList &categories) { + NanotraceHR::Tracer tracer{"property editor context object set insight categories", category()}; + m_insightCategories = categories; emit insightCategoriesChanged(); } bool PropertyEditorContextObject::hasQuick3DImport() const { + NanotraceHR::Tracer tracer{"property editor context object has quick 3D import", category()}; + return m_hasQuick3DImport; } @@ -460,6 +518,8 @@ void PropertyEditorContextObject::setEditorNodes(const ModelNodes &nodes) void PropertyEditorContextObject::setHasQuick3DImport(bool value) { + NanotraceHR::Tracer tracer{"property editor context object set has quick 3D import", category()}; + if (value == m_hasQuick3DImport) return; @@ -469,11 +529,15 @@ void PropertyEditorContextObject::setHasQuick3DImport(bool value) bool PropertyEditorContextObject::hasMaterialLibrary() const { + NanotraceHR::Tracer tracer{"property editor context object has material library", category()}; + return m_hasMaterialLibrary; } void PropertyEditorContextObject::setHasMaterialLibrary(bool value) { + NanotraceHR::Tracer tracer{"property editor context object set has material library", category()}; + if (value == m_hasMaterialLibrary) return; @@ -483,11 +547,15 @@ void PropertyEditorContextObject::setHasMaterialLibrary(bool value) bool PropertyEditorContextObject::isQt6Project() const { + NanotraceHR::Tracer tracer{"property editor context object is Qt6 project", category()}; + return m_isQt6Project; } void PropertyEditorContextObject::setIsQt6Project(bool value) { + NanotraceHR::Tracer tracer{"property editor context object set is Qt6 project", category()}; + if (m_isQt6Project == value) return; @@ -497,11 +565,15 @@ void PropertyEditorContextObject::setIsQt6Project(bool value) bool PropertyEditorContextObject::has3DModelSelected() const { + NanotraceHR::Tracer tracer{"property editor context object has 3D model selected", category()}; + return m_has3DModelSelected; } void PropertyEditorContextObject::setHas3DModelSelected(bool value) { + NanotraceHR::Tracer tracer{"property editor context object set has 3D model selected", category()}; + if (value == m_has3DModelSelected) return; @@ -511,6 +583,8 @@ void PropertyEditorContextObject::setHas3DModelSelected(bool value) void PropertyEditorContextObject::setSpecificsUrl(const QUrl &newSpecificsUrl) { + NanotraceHR::Tracer tracer{"property editor context object set specifics URL", category()}; + if (newSpecificsUrl == m_specificsUrl) return; @@ -522,6 +596,8 @@ void PropertyEditorContextObject::setSpecificsUrl(const QUrl &newSpecificsUrl) void PropertyEditorContextObject::setSpecificQmlData(const QString &newSpecificQmlData) { + NanotraceHR::Tracer tracer{"property editor context object set specific QML data", category()}; + if (m_specificQmlData == newSpecificQmlData) return; @@ -536,6 +612,8 @@ void PropertyEditorContextObject::setSpecificQmlData(const QString &newSpecificQ void PropertyEditorContextObject::setStateName(const QString &newStateName) { + NanotraceHR::Tracer tracer{"property editor context object set state name", category()}; + if (newStateName == m_stateName) return; @@ -545,8 +623,10 @@ void PropertyEditorContextObject::setStateName(const QString &newStateName) void PropertyEditorContextObject::setAllStateNames(const QStringList &allStates) { + NanotraceHR::Tracer tracer{"property editor context object set all state names", category()}; + if (allStates == m_allStateNames) - return; + return; m_allStateNames = allStates; emit allStateNamesChanged(); @@ -554,7 +634,9 @@ void PropertyEditorContextObject::setAllStateNames(const QStringList &allStates) void PropertyEditorContextObject::setIsBaseState(bool newIsBaseState) { - if (newIsBaseState == m_isBaseState) + NanotraceHR::Tracer tracer{"property editor context object set is base state", category()}; + + if (newIsBaseState == m_isBaseState) return; m_isBaseState = newIsBaseState; @@ -563,6 +645,8 @@ void PropertyEditorContextObject::setIsBaseState(bool newIsBaseState) void PropertyEditorContextObject::setSelectionChanged(bool newSelectionChanged) { + NanotraceHR::Tracer tracer{"property editor context object set selection changed", category()}; + if (newSelectionChanged == m_selectionChanged) return; @@ -572,6 +656,8 @@ void PropertyEditorContextObject::setSelectionChanged(bool newSelectionChanged) void PropertyEditorContextObject::setBackendValues(QQmlPropertyMap *newBackendValues) { + NanotraceHR::Tracer tracer{"property editor context object set backend values", category()}; + if (newBackendValues == m_backendValues) return; @@ -581,16 +667,22 @@ void PropertyEditorContextObject::setBackendValues(QQmlPropertyMap *newBackendVa void PropertyEditorContextObject::setModel(Model *model) { + NanotraceHR::Tracer tracer{"property editor context object set model", category()}; + m_model = model; } void PropertyEditorContextObject::triggerSelectionChanged() { + NanotraceHR::Tracer tracer{"property editor context object trigger selection changed", category()}; + setSelectionChanged(!m_selectionChanged); } void PropertyEditorContextObject::setHasAliasExport(bool hasAliasExport) { + NanotraceHR::Tracer tracer{"property editor context object set has alias export", category()}; + if (m_aliasExport == hasAliasExport) return; @@ -600,6 +692,8 @@ void PropertyEditorContextObject::setHasAliasExport(bool hasAliasExport) void PropertyEditorContextObject::setQuickWidget(QQuickWidget *newQuickWidget) { + NanotraceHR::Tracer tracer{"property editor context object set quick widget", category()}; + m_quickWidget = newQuickWidget; } @@ -616,6 +710,8 @@ void PropertyEditorContextObject::hideCursor() void PropertyEditorContextObject::restoreCursor() { + NanotraceHR::Tracer tracer{"property editor context object restore cursor", category()}; + if (!QApplication::overrideCursor()) return; @@ -627,6 +723,8 @@ void PropertyEditorContextObject::restoreCursor() void PropertyEditorContextObject::holdCursorInPlace() { + NanotraceHR::Tracer tracer{"property editor context object hold cursor in place", category()}; + if (!QApplication::overrideCursor()) return; @@ -636,6 +734,8 @@ void PropertyEditorContextObject::holdCursorInPlace() int PropertyEditorContextObject::devicePixelRatio() { + NanotraceHR::Tracer tracer{"property editor context object device pixel ratio", category()}; + if (QWidget *w = QApplication::activeWindow()) return w->devicePixelRatio(); @@ -644,22 +744,28 @@ int PropertyEditorContextObject::devicePixelRatio() QStringList PropertyEditorContextObject::styleNamesForFamily(const QString &family) { + NanotraceHR::Tracer tracer{"property editor context object style names for family", category()}; + return QFontDatabase::styles(family); } QStringList PropertyEditorContextObject::allStatesForId(const QString &id) { - if (m_model && m_model->rewriterView()) { - const QmlObjectNode node = m_model->rewriterView()->modelNodeForId(id); - if (node.isValid()) - return node.allStateNames(); - } + NanotraceHR::Tracer tracer{"property editor context object all states for id", category()}; + + if (m_model && m_model->rewriterView()) { + const QmlObjectNode node = m_model->rewriterView()->modelNodeForId(id); + if (node.isValid()) + return node.allStateNames(); + } return {}; } bool PropertyEditorContextObject::isBlocked(const QString &propName) const { + NanotraceHR::Tracer tracer{"property editor context object is blocked", category()}; + if (m_model && m_model->rewriterView()) { const QList nodes = m_model->rewriterView()->selectedModelNodes(); for (const auto &node : nodes) { @@ -672,6 +778,8 @@ bool PropertyEditorContextObject::isBlocked(const QString &propName) const void PropertyEditorContextObject::verifyInsightImport() { + NanotraceHR::Tracer tracer{"property editor context object verify insight import", category()}; + Import import = Import::createLibraryImport("QtInsightTracker", "1.0"); if (!m_model->hasImport(import)) @@ -680,6 +788,8 @@ void PropertyEditorContextObject::verifyInsightImport() QRect PropertyEditorContextObject::screenRect() const { + NanotraceHR::Tracer tracer{"property editor context object screen rect", category()}; + if (m_quickWidget && m_quickWidget->screen()) return m_quickWidget->screen()->availableGeometry(); return {}; @@ -687,6 +797,8 @@ QRect PropertyEditorContextObject::screenRect() const QPoint PropertyEditorContextObject::globalPos(const QPoint &point) const { + NanotraceHR::Tracer tracer{"property editor context object global pos", category()}; + if (m_quickWidget) return m_quickWidget->mapToGlobal(point); return point; @@ -694,32 +806,44 @@ QPoint PropertyEditorContextObject::globalPos(const QPoint &point) const void PropertyEditorContextObject::handleToolBarAction(int action) { + NanotraceHR::Tracer tracer{"property editor context object handle toolbar action", category()}; + emit toolBarAction(action); } void PropertyEditorContextObject::saveExpandedState(const QString §ionName, bool expanded) { + NanotraceHR::Tracer tracer{"property editor context object save expanded state", category()}; + s_expandedStateHash.insert(sectionName, expanded); } bool PropertyEditorContextObject::loadExpandedState(const QString §ionName, bool defaultValue) const { + NanotraceHR::Tracer tracer{"property editor context object load expanded state", category()}; + return s_expandedStateHash.value(sectionName, defaultValue); } void EasingCurveEditor::registerDeclarativeType() { - qmlRegisterType("HelperWidgets", 2, 0, "EasingCurveEditor"); + NanotraceHR::Tracer tracer{"property editor context object register declarative type", category()}; + + qmlRegisterType("HelperWidgets", 2, 0, "EasingCurveEditor"); } void EasingCurveEditor::runDialog() { + NanotraceHR::Tracer tracer{"property editor context object run dialog", category()}; + if (m_modelNode.isValid()) EasingCurveDialog::runDialog({ m_modelNode }, Core::ICore::dialogParent()); } void EasingCurveEditor::setModelNodeBackend(const QVariant &modelNodeBackend) { + NanotraceHR::Tracer tracer{"property editor context object set model node backend", category()}; + if (!modelNodeBackend.isNull() && modelNodeBackend.isValid()) { m_modelNodeBackend = modelNodeBackend; @@ -738,6 +862,8 @@ void EasingCurveEditor::setModelNodeBackend(const QVariant &modelNodeBackend) QVariant EasingCurveEditor::modelNodeBackend() const { + NanotraceHR::Tracer tracer{"property editor context object model node backend", category()}; + return m_modelNodeBackend; } diff --git a/src/plugins/qmldesigner/components/propertyeditor/propertyeditordynamicpropertiesproxymodel.cpp b/src/plugins/qmldesigner/components/propertyeditor/propertyeditordynamicpropertiesproxymodel.cpp index 29fb649143e..7d8387d6196 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditordynamicpropertiesproxymodel.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditordynamicpropertiesproxymodel.cpp @@ -25,21 +25,31 @@ #include "propertyeditordynamicpropertiesproxymodel.h" +#include "propertyeditortracing.h" + #include #include namespace QmlDesigner { +static auto category = QmlDesigner::PropertyEditorTracing::category; + PropertyEditorDynamicPropertiesProxyModel::PropertyEditorDynamicPropertiesProxyModel(QObject *parent) : DynamicPropertiesProxyModel(parent) { + NanotraceHR::Tracer tracer{"property editor dynamic properties proxy model constructor", + category()}; + if (PropertyEditorView::instance()) initModel(PropertyEditorView::instance()->dynamicPropertiesModel()); } void PropertyEditorDynamicPropertiesProxyModel::registerDeclarativeType() { + NanotraceHR::Tracer tracer{ + "property editor dynamic properties proxy model register declarative type", category()}; + DynamicPropertiesProxyModel::registerDeclarativeType(); qmlRegisterType("HelperWidgets", 2, 0, "PropertyEditorDynamicPropertiesModel"); } diff --git a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorqmlbackend.cpp b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorqmlbackend.cpp index 11f3fe5b76a..19e80b43d57 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorqmlbackend.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorqmlbackend.cpp @@ -4,6 +4,7 @@ #include "propertyeditorqmlbackend.h" #include "instanceimageprovider.h" +#include "propertyeditortracing.h" #include "propertyeditortransaction.h" #include "propertyeditorutils.h" #include "propertyeditorvalue.h" @@ -51,6 +52,8 @@ #include +static auto category = QmlDesigner::PropertyEditorTracing::category; + static Q_LOGGING_CATEGORY(propertyEditorBenchmark, "qtc.propertyeditor.load", QtWarningMsg) static QmlJS::SimpleReaderNode::Ptr s_templateConfiguration = QmlJS::SimpleReaderNode::Ptr(); @@ -115,6 +118,8 @@ PropertyEditorQmlBackend::PropertyEditorQmlBackend(PropertyEditorView *propertyE , m_propertyEditorTransaction(std::make_unique(propertyEditor)) , m_dummyPropertyEditorValue(std::make_unique()) { + NanotraceHR::Tracer tracer{"property editor backend constructor", category()}; + m_contextObject->setQuickWidget(m_view.get()); m_view->engine()->setOutputWarningsToStandardError(QmlDesignerPlugin::instance() ->settings().value(DesignerSettingsKey::SHOW_PROPERTYEDITOR_WARNINGS).toBool()); @@ -133,12 +138,17 @@ PropertyEditorQmlBackend::PropertyEditorQmlBackend(PropertyEditorView *propertyE propertyEditor, &PropertyEditorView::changeValue); } -PropertyEditorQmlBackend::~PropertyEditorQmlBackend() = default; +PropertyEditorQmlBackend::~PropertyEditorQmlBackend() +{ + NanotraceHR::Tracer tracer{"property editor backend destructor", category()}; +} void PropertyEditorQmlBackend::setupPropertyEditorValue(PropertyNameView name, PropertyEditorView *propertyEditor, const NodeMetaInfo &type) { + NanotraceHR::Tracer tracer{"property editor backend setup property editor value", category()}; + QmlDesigner::PropertyName propertyName(name.toByteArray()); propertyName.replace('.', '_'); auto valueObject = qobject_cast(variantToQObject(backendValuesPropertyMap().value(QString::fromUtf8(propertyName)))); @@ -174,6 +184,8 @@ QVariant properDefaultAuxiliaryProperties(const QmlObjectNode &qmlObjectNode, QVariant properDefaultLayoutAttachedProperties(const QmlObjectNode &qmlObjectNode, PropertyNameView propertyName) { + NanotraceHR::Tracer tracer{"property editor backend proper default layout attached properties", + category()}; const QVariant value = qmlObjectNode.modelValue("Layout."_sv + propertyName); QVariant marginsValue = qmlObjectNode.modelValue("Layout.margins"); @@ -220,6 +232,8 @@ QVariant properDefaultInsightAttachedProperties(const QmlObjectNode &qmlObjectNo void PropertyEditorQmlBackend::setupLayoutAttachedProperties(const QmlObjectNode &qmlObjectNode, PropertyEditorView *propertyEditor) { + NanotraceHR::Tracer tracer{"property editor backend setup layout attached properties", category()}; + if (QmlItemNode(qmlObjectNode).isInLayout()) { static constexpr PropertyNameView propertyNames[] = {"alignment", "column", @@ -253,6 +267,9 @@ void PropertyEditorQmlBackend::setupLayoutAttachedProperties(const QmlObjectNode void PropertyEditorQmlBackend::setupInsightAttachedProperties(const QmlObjectNode &qmlObjectNode, PropertyEditorView *propertyEditor) { + NanotraceHR::Tracer tracer{"property editor backend setup insight attached properties", + category()}; + const PropertyName propertyName = "category"; createPropertyEditorValue(qmlObjectNode, "InsightCategory."_sv + propertyName, @@ -263,6 +280,8 @@ void PropertyEditorQmlBackend::setupInsightAttachedProperties(const QmlObjectNod void PropertyEditorQmlBackend::setupAuxiliaryProperties(const QmlObjectNode &qmlObjectNode, PropertyEditorView *propertyEditor) { + NanotraceHR::Tracer tracer{"property editor backend setup auxiliary properties", category()}; + const QmlItemNode itemNode(qmlObjectNode); auto createProperty = [&](auto &&...properties) { @@ -336,12 +355,16 @@ void PropertyEditorQmlBackend::setupAuxiliaryProperties(const QmlObjectNode &qml void PropertyEditorQmlBackend::handleInstancePropertyChangedInModelNodeProxy( const ModelNode &modelNode, PropertyNameView propertyName) { + NanotraceHR::Tracer tracer{"property editor backend handle instance property changed", category()}; + m_backendModelNode.handleInstancePropertyChanged(modelNode, propertyName); } void PropertyEditorQmlBackend::handleAuxiliaryDataChanges(const QmlObjectNode &qmlObjectNode, AuxiliaryDataKeyView key) { + NanotraceHR::Tracer tracer{"property editor backend handle auxiliary data changes", category()}; + if (qmlObjectNode.isRootModelNode() && isMaterialAuxiliaryKey(key)) { m_backendMaterialNode.handleAuxiliaryPropertyChanges(); m_view->instanceImageProvider()->invalidate(); @@ -350,12 +373,16 @@ void PropertyEditorQmlBackend::handleAuxiliaryDataChanges(const QmlObjectNode &q void PropertyEditorQmlBackend::handleVariantPropertyChangedInModelNodeProxy(const VariantProperty &property) { + NanotraceHR::Tracer tracer{"property editor backend handle variant property changed", category()}; + m_backendModelNode.handleVariantPropertyChanged(property); updateInstanceImage(); } void PropertyEditorQmlBackend::handleBindingPropertyChangedInModelNodeProxy(const BindingProperty &property) { + NanotraceHR::Tracer tracer{"property editor backend handle binding property changed", category()}; + m_backendModelNode.handleBindingPropertyChanged(property); m_backendTextureNode.handleBindingPropertyChanged(property); updateInstanceImage(); @@ -364,6 +391,9 @@ void PropertyEditorQmlBackend::handleBindingPropertyChangedInModelNodeProxy(cons void PropertyEditorQmlBackend::handleBindingPropertyInModelNodeProxyAboutToChange( const BindingProperty &property) { + NanotraceHR::Tracer tracer{"property editor backend handle binding property about to change", + category()}; + if (m_backendMaterialNode.materialNode()) { ModelNode expressionNode = property.resolveToModelNode(); if (expressionNode.metaInfo().isQtQuick3DTexture()) @@ -374,6 +404,8 @@ void PropertyEditorQmlBackend::handleBindingPropertyInModelNodeProxyAboutToChang void PropertyEditorQmlBackend::handlePropertiesRemovedInModelNodeProxy(const AbstractProperty &property) { + NanotraceHR::Tracer tracer{"property editor backend handle properties removed", category()}; + m_backendModelNode.handlePropertiesRemoved(property); m_backendTextureNode.handlePropertiesRemoved(property); updateInstanceImage(); @@ -395,6 +427,9 @@ void PropertyEditorQmlBackend::handleModelNodePreviewPixmapChanged(const ModelNo void PropertyEditorQmlBackend::handleModelSelectedNodesChanged(PropertyEditorView *propertyEditor) { + NanotraceHR::Tracer tracer{"property editor backend handle model selected nodes changed", + category()}; + contextObject()->setHas3DModelSelected(!Utils3D::getSelectedModels(propertyEditor).isEmpty()); m_backendTextureNode.updateSelectionDetails(); } @@ -404,6 +439,8 @@ void PropertyEditorQmlBackend::createPropertyEditorValue(const QmlObjectNode &qm const QVariant &value, PropertyEditorView *propertyEditor) { + NanotraceHR::Tracer tracer{"property editor backend create property editor value", category()}; + PropertyName propertyName(name.toByteArray()); propertyName.replace('.', '_'); auto valueObject = qobject_cast(variantToQObject(backendValuesPropertyMap().value(QString::fromUtf8(propertyName)))); @@ -441,6 +478,8 @@ void PropertyEditorQmlBackend::setValue(const QmlObjectNode &, PropertyNameView name, const QVariant &value) { + NanotraceHR::Tracer tracer{"property editor backend set value", category()}; + // Vector*D values need to be split into their subcomponents if (value.typeId() == QMetaType::QVector2D) { const char *suffix[2] = {"_x", "_y"}; @@ -487,6 +526,8 @@ void PropertyEditorQmlBackend::setValue(const QmlObjectNode &, void PropertyEditorQmlBackend::setExpression(PropertyNameView propName, const QString &exp) { + NanotraceHR::Tracer tracer{"property editor backend set expression", category()}; + PropertyEditorValue *propertyValue = propertyValueForName(QString::fromUtf8(propName)); if (propertyValue) propertyValue->setExpression(exp); @@ -494,21 +535,29 @@ void PropertyEditorQmlBackend::setExpression(PropertyNameView propName, const QS QQmlContext *PropertyEditorQmlBackend::context() { + NanotraceHR::Tracer tracer{"property editor backend context", category()}; + return m_view->rootContext(); } PropertyEditorContextObject *PropertyEditorQmlBackend::contextObject() { + NanotraceHR::Tracer tracer{"property editor backend context object", category()}; + return m_contextObject.get(); } QQuickWidget *PropertyEditorQmlBackend::widget() { + NanotraceHR::Tracer tracer{"property editor backend widget", category()}; + return m_view.get(); } void PropertyEditorQmlBackend::setSource(const QUrl &url) { + NanotraceHR::Tracer tracer{"property editor backend set source", category()}; + m_view->setSource(url); const bool showError = qEnvironmentVariableIsSet(Constants::ENVIRONMENT_SHOW_QML_ERRORS); @@ -521,24 +570,37 @@ void PropertyEditorQmlBackend::setSource(const QUrl &url) QmlAnchorBindingProxy &PropertyEditorQmlBackend::backendAnchorBinding() { + NanotraceHR::Tracer tracer{"property editor backend backend anchor binding", category()}; + return m_backendAnchorBinding; } -DesignerPropertyMap &PropertyEditorQmlBackend::backendValuesPropertyMap() { +DesignerPropertyMap &PropertyEditorQmlBackend::backendValuesPropertyMap() +{ + NanotraceHR::Tracer tracer{"property editor backend backend values property map", category()}; + return m_backendValuesPropertyMap; } -PropertyEditorTransaction *PropertyEditorQmlBackend::propertyEditorTransaction() { +PropertyEditorTransaction *PropertyEditorQmlBackend::propertyEditorTransaction() +{ + NanotraceHR::Tracer tracer{"property editor backend property editor transaction", category()}; + return m_propertyEditorTransaction.get(); } PropertyEditorValue *PropertyEditorQmlBackend::propertyValueForName(const QString &propertyName) { - return qobject_cast(variantToQObject(backendValuesPropertyMap().value(propertyName))); + NanotraceHR::Tracer tracer{"property editor backend property value for name", category()}; + + return qobject_cast( + variantToQObject(backendValuesPropertyMap().value(propertyName))); } void QmlDesigner::PropertyEditorQmlBackend::createPropertyEditorValues(const QmlObjectNode &qmlObjectNode, PropertyEditorView *propertyEditor) { + NanotraceHR::Tracer tracer{"property editor backend create property editor values", category()}; + #ifndef QDS_USE_PROJECTSTORAGE for (const auto &property : PropertyEditorUtils::filteredProperties(qmlObjectNode.metaInfo())) { auto propertyName = property.name(); @@ -563,6 +625,8 @@ PropertyEditorValue *PropertyEditorQmlBackend::insertValue(const QString &name, const QVariant &value, const ModelNode &modelNode) { + NanotraceHR::Tracer tracer{"property editor backend insert value", category()}; + auto valueObject = qobject_cast( variantToQObject(m_backendValuesPropertyMap.value(name))); if (!valueObject) @@ -586,6 +650,8 @@ PropertyEditorValue *PropertyEditorQmlBackend::insertValue(const QString &name, void PropertyEditorQmlBackend::updateInstanceImage() { + NanotraceHR::Tracer tracer{"property editor backend update instance image", category()}; + m_view->instanceImageProvider()->invalidate(); refreshPreview(); } @@ -595,6 +661,8 @@ void PropertyEditorQmlBackend::setup(const ModelNodes &editorNodes, const QUrl &qmlSpecificsFile, PropertyEditorView *propertyEditor) { + NanotraceHR::Tracer tracer{"property editor backend setup", category()}; + QmlObjectNode qmlObjectNode(editorNodes.isEmpty() ? ModelNode{} : editorNodes.first()); if (!qmlObjectNode.isValid()) { qWarning() << "PropertyEditor: invalid node for setup"; @@ -694,11 +762,15 @@ void PropertyEditorQmlBackend::setup(const ModelNodes &editorNodes, QString PropertyEditorQmlBackend::propertyEditorResourcesPath() { + NanotraceHR::Tracer tracer{"property editor backend property editor resources path", category()}; + return resourcesPath("propertyEditorQmlSources"); } QString PropertyEditorQmlBackend::scriptsEditorResourcesPath() { + NanotraceHR::Tracer tracer{"property editor backend scripts editor resources path", category()}; + return resourcesPath("scriptseditor"); } @@ -968,6 +1040,8 @@ QUrl PropertyEditorQmlBackend::getQmlFileUrl(const TypeName &relativeTypeName, c TypeName PropertyEditorQmlBackend::fixTypeNameForPanes(const TypeName &typeName) { + NanotraceHR::Tracer tracer{"property editor backend fix type name for panes", category()}; + TypeName fixedTypeName = typeName; fixedTypeName.replace('.', '/'); return fixedTypeName; @@ -975,6 +1049,8 @@ TypeName PropertyEditorQmlBackend::fixTypeNameForPanes(const TypeName &typeName) QString PropertyEditorQmlBackend::resourcesPath(const QString &dir) { + NanotraceHR::Tracer tracer{"property editor backend resources path", category()}; + #ifdef SHARE_QML_PATH if (Utils::qtcEnvironmentVariableIsSet("LOAD_QML_FROM_SOURCE")) return QLatin1String(SHARE_QML_PATH) + "/" + dir; @@ -984,11 +1060,15 @@ QString PropertyEditorQmlBackend::resourcesPath(const QString &dir) void PropertyEditorQmlBackend::refreshBackendModel() { + NanotraceHR::Tracer tracer{"property editor backend refresh backend model", category()}; + m_backendModelNode.refresh(); } void PropertyEditorQmlBackend::refreshPreview() { + NanotraceHR::Tracer tracer{"property editor backend refresh preview", category()}; + auto qmlPreview = widget()->rootObject(); if (qmlPreview && qmlPreview->metaObject()->indexOfMethod("refreshPreview()") > -1) @@ -997,6 +1077,8 @@ void PropertyEditorQmlBackend::refreshPreview() void PropertyEditorQmlBackend::setupContextProperties() { + NanotraceHR::Tracer tracer{"property editor backend setup context properties", category()}; + context()->setContextProperties({ {"modelNodeBackend", QVariant::fromValue(&m_backendModelNode)}, {"materialNodeBackend", QVariant::fromValue(&m_backendMaterialNode)}, @@ -1015,7 +1097,10 @@ TypeName PropertyEditorQmlBackend::qmlFileName(const NodeMetaInfo &nodeInfo) } #endif -QUrl PropertyEditorQmlBackend::fileToUrl(const QString &filePath) { +QUrl PropertyEditorQmlBackend::fileToUrl(const QString &filePath) +{ + NanotraceHR::Tracer tracer{"property editor backend file to url", category()}; + QUrl fileUrl; if (filePath.isEmpty()) @@ -1035,11 +1120,15 @@ QUrl PropertyEditorQmlBackend::fileToUrl(const QString &filePath) { QUrl PropertyEditorQmlBackend::emptyPaneUrl() { + NanotraceHR::Tracer tracer{"property editor backend empty pane url", category()}; + return fileToUrl(QDir(propertyEditorResourcesPath()).filePath("QtQuick/emptyPane.qml"_L1)); } QString PropertyEditorQmlBackend::fileFromUrl(const QUrl &url) { + NanotraceHR::Tracer tracer{"property editor backend file from url", category()}; + if (url.scheme() == QStringLiteral("qrc")) { const QString &path = url.path(); return QStringLiteral(":") + path; @@ -1050,23 +1139,32 @@ QString PropertyEditorQmlBackend::fileFromUrl(const QUrl &url) bool PropertyEditorQmlBackend::checkIfUrlExists(const QUrl &url) { + NanotraceHR::Tracer tracer{"property editor backend check if url exists", category()}; + const QString &file = fileFromUrl(url); return !file.isEmpty() && QFileInfo::exists(file); } void PropertyEditorQmlBackend::emitSelectionToBeChanged() { + NanotraceHR::Tracer tracer{"property editor backend emit selection to be changed", category()}; + m_backendModelNode.emitSelectionToBeChanged(); } void PropertyEditorQmlBackend::emitSelectionChanged() { + NanotraceHR::Tracer tracer{"property editor backend emit selection changed", category()}; + m_backendModelNode.emitSelectionChanged(); } void PropertyEditorQmlBackend::setValueforLayoutAttachedProperties(const QmlObjectNode &qmlObjectNode, PropertyNameView name) { + NanotraceHR::Tracer tracer{"property editor backend set value for layout attached properties", + category()}; + PropertyName propertyName = name.toByteArray(); propertyName.replace("Layout.", ""); setValue(qmlObjectNode, name, properDefaultLayoutAttachedProperties(qmlObjectNode, propertyName)); @@ -1083,6 +1181,9 @@ void PropertyEditorQmlBackend::setValueforLayoutAttachedProperties(const QmlObje void PropertyEditorQmlBackend::setValueforInsightAttachedProperties(const QmlObjectNode &qmlObjectNode, PropertyNameView name) { + NanotraceHR::Tracer tracer{"property editor backend set value for insight attached properties", + category()}; + PropertyName propertyName = name.toByteArray(); propertyName.replace("InsightCategory.", ""); setValue(qmlObjectNode, name, properDefaultInsightAttachedProperties(qmlObjectNode, propertyName)); @@ -1091,6 +1192,9 @@ void PropertyEditorQmlBackend::setValueforInsightAttachedProperties(const QmlObj void PropertyEditorQmlBackend::setValueforAuxiliaryProperties(const QmlObjectNode &qmlObjectNode, AuxiliaryDataKeyView key) { + NanotraceHR::Tracer tracer{"property editor backend set value for auxiliary properties", + category()}; + const PropertyName propertyName = auxNamePostFix(key.name); setValue(qmlObjectNode, propertyName, qmlObjectNode.modelNode().auxiliaryDataWithDefault(key)); } diff --git a/src/plugins/qmldesigner/components/propertyeditor/propertyeditortracing.cpp b/src/plugins/qmldesigner/components/propertyeditor/propertyeditortracing.cpp new file mode 100644 index 00000000000..d641aca07df --- /dev/null +++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditortracing.cpp @@ -0,0 +1,26 @@ +// Copyright (C) 2025 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include "propertyeditortracing.h" + +#include + +#include + +namespace QmlDesigner::PropertyEditorTracing { +using namespace NanotraceHR::Literals; +namespace { + +thread_local Category category_{"model", + Tracing::eventQueueWithStringArguments(), + Tracing::eventQueueWithoutArguments(), + category}; + +} // namespace + +Category &category() +{ + return category_; +} + +} // namespace QmlDesigner::PropertyEditorTracing diff --git a/src/plugins/qmldesigner/components/propertyeditor/propertyeditortracing.h b/src/plugins/qmldesigner/components/propertyeditor/propertyeditortracing.h new file mode 100644 index 00000000000..db6aed68f05 --- /dev/null +++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditortracing.h @@ -0,0 +1,26 @@ +// Copyright (C) 2025 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +#include + +#include + +#pragma once + +namespace QmlDesigner::PropertyEditorTracing { + +constexpr NanotraceHR::Tracing tracingStatus() +{ +#ifdef ENABLE_PROPERTY_EDITOR_TRACING + return NanotraceHR::Tracing::IsEnabled; +#else + return NanotraceHR::Tracing::IsDisabled; +#endif +} + +using Category = NanotraceHR::StringViewWithStringArgumentsCategory; +using SourceLocation = Category::SourceLocation; + +[[gnu::pure]] QMLDESIGNERCOMPONENTS_EXPORT Category &category(); + +} // namespace QmlDesigner::PropertyEditorTracing diff --git a/src/plugins/qmldesigner/components/propertyeditor/propertyeditortransaction.cpp b/src/plugins/qmldesigner/components/propertyeditor/propertyeditortransaction.cpp index 25618709d97..b09b5ad401e 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditortransaction.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditortransaction.cpp @@ -2,18 +2,26 @@ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 #include "propertyeditortransaction.h" + +#include "propertyeditortracing.h" + #include #include namespace QmlDesigner { +static auto category = QmlDesigner::PropertyEditorTracing::category; + PropertyEditorTransaction::PropertyEditorTransaction(QmlDesigner::PropertyEditorView *propertyEditor) : QObject(propertyEditor), m_propertyEditor(propertyEditor), m_timerId(-1) { + NanotraceHR::Tracer tracer{"property editor transaction constructor", category()}; } void PropertyEditorTransaction::start() { + NanotraceHR::Tracer tracer{"property editor transaction start", category()}; + if (!m_propertyEditor->model()) return; if (m_rewriterTransaction.isValid()) @@ -24,7 +32,9 @@ void PropertyEditorTransaction::start() void PropertyEditorTransaction::end() { - if (m_rewriterTransaction.isValid() && m_propertyEditor->model()) { + NanotraceHR::Tracer tracer{"property editor transaction end", category()}; + + if (m_rewriterTransaction.isValid() && m_propertyEditor->model()) { killTimer(m_timerId); m_rewriterTransaction.commit(); } @@ -32,6 +42,8 @@ void PropertyEditorTransaction::end() bool PropertyEditorTransaction::active() const { + NanotraceHR::Tracer tracer{"property editor transaction active", category()}; + return m_rewriterTransaction.isValid(); } @@ -39,6 +51,9 @@ void PropertyEditorTransaction::timerEvent(QTimerEvent *timerEvent) { if (timerEvent->timerId() != m_timerId) return; + + NanotraceHR::Tracer tracer{"property editor transaction timer event", category()}; + killTimer(timerEvent->timerId()); if (m_rewriterTransaction.isValid()) m_rewriterTransaction.commit(); diff --git a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorutils.cpp b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorutils.cpp index b26e98da13d..912f756af37 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorutils.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorutils.cpp @@ -3,10 +3,14 @@ #include "propertyeditorutils.h" +#include "propertyeditortracing.h" + namespace QmlDesigner { namespace PropertyEditorUtils { +static auto category = QmlDesigner::PropertyEditorTracing::category; + #ifndef QDS_USE_PROJECTSTORAGE static bool checkIfUnkownTypeProperty(const std::vector &propertyNames, @@ -31,6 +35,8 @@ static bool checkIfUnkownTypeProperty(const std::vector &propertyN PropertyMetaInfos filteredProperties(const NodeMetaInfo &metaInfo) { + NanotraceHR::Tracer tracer{"property editor utils filtered properties", category()}; + auto properties = metaInfo.properties(); #ifndef QDS_USE_PROJECTSTORAGE diff --git a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorvalue.cpp b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorvalue.cpp index 8b9b2fe6e71..6d0d0e88e27 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorvalue.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorvalue.cpp @@ -3,20 +3,22 @@ #include "propertyeditorvalue.h" -#include "abstractview.h" -#include "bindingproperty.h" -#include "createtexture.h" -#include "designermcumanager.h" -#include "designmodewidget.h" -#include "nodemetainfo.h" -#include "nodeproperty.h" +#include "propertyeditortracing.h" #include "propertyeditorutils.h" #include "propertyeditorview.h" -#include "qmldesignerplugin.h" -#include "qmlitemnode.h" -#include "qmlobjectnode.h" -#include "rewritertransaction.h" -#include "rewritingexception.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include #include @@ -28,14 +30,19 @@ namespace QmlDesigner { +static auto category = QmlDesigner::PropertyEditorTracing::category; + PropertyEditorValue::PropertyEditorValue(QObject *parent) : QObject(parent), m_complexNode(new PropertyEditorNodeWrapper(this)) { + NanotraceHR::Tracer tracer{"property editor value constructor", category()}; } QVariant PropertyEditorValue::value() const { + NanotraceHR::Tracer tracer{"property editor value value", category()}; + QVariant returnValue = m_value; if (auto metaInfo = modelNode().metaInfo(); metaInfo.property(name()).propertyType().isUrl()) returnValue = returnValue.toUrl().toString(); @@ -107,6 +114,8 @@ static bool compareVariants(const QVariant &value1, const QVariant &value2) void PropertyEditorValue::setValueWithEmit(const QVariant &value) { + NanotraceHR::Tracer tracer{"property editor value set value with emit", category()}; + if (!compareVariants(value, m_value) || isBound()) { QVariant newValue = value; if (auto metaInfo = modelNode().metaInfo(); metaInfo.property(name()).propertyType().isUrl()) @@ -127,6 +136,8 @@ void PropertyEditorValue::setValueWithEmit(const QVariant &value) void PropertyEditorValue::setValue(const QVariant &value) { + NanotraceHR::Tracer tracer{"property editor value set value", category()}; + const bool colorsEqual = cleverColorCompare(value, m_value); if (!compareVariants(m_value, value) && !cleverDoubleCompare(value, m_value) && !colorsEqual) @@ -145,16 +156,22 @@ void PropertyEditorValue::setValue(const QVariant &value) QString PropertyEditorValue::enumeration() const { + NanotraceHR::Tracer tracer{"property editor value enumeration", category()}; + return m_value.value().nameToString(); } QString PropertyEditorValue::expression() const { + NanotraceHR::Tracer tracer{"property editor value expression", category()}; + return m_expression; } void PropertyEditorValue::setExpressionWithEmit(const QString &expression) { + NanotraceHR::Tracer tracer{"property editor value set expression with emit", category()}; + if (m_expression != expression) { setExpression(expression); m_value.clear(); @@ -166,7 +183,9 @@ void PropertyEditorValue::setExpressionWithEmit(const QString &expression) void PropertyEditorValue::setExpression(const QString &expression) { - if ( m_expression != expression) { + NanotraceHR::Tracer tracer{"property editor value set expression", category()}; + + if (m_expression != expression) { m_expression = expression; emit expressionChanged(QString()); } @@ -174,11 +193,15 @@ void PropertyEditorValue::setExpression(const QString &expression) QString PropertyEditorValue::valueToString() const { + NanotraceHR::Tracer tracer{"property editor value value to string", category()}; + return value().toString(); } bool PropertyEditorValue::isInSubState() const { + NanotraceHR::Tracer tracer{"property editor value is in sub state", category()}; + const QmlObjectNode objectNode(modelNode()); return objectNode.isValid() && objectNode.currentState().isValid() && objectNode.propertyAffectedByCurrentState(name()); @@ -186,42 +209,58 @@ bool PropertyEditorValue::isInSubState() const bool PropertyEditorValue::isBound() const { + NanotraceHR::Tracer tracer{"property editor value is bound", category()}; + const QmlObjectNode objectNode(modelNode()); return m_forceBound || (objectNode.isValid() && objectNode.hasBindingProperty(name())); } bool PropertyEditorValue::isInModel() const { + NanotraceHR::Tracer tracer{"property editor value is in model", category()}; + return modelNode().hasProperty(name()); } PropertyNameView PropertyEditorValue::name() const { + NanotraceHR::Tracer tracer{"property editor value name", category()}; + return m_name; } QString PropertyEditorValue::nameAsQString() const { + NanotraceHR::Tracer tracer{"property editor value name as QString", category()}; + return QString::fromUtf8(m_name); } void PropertyEditorValue::setName(PropertyNameView name) { + NanotraceHR::Tracer tracer{"property editor value set name", category()}; + m_name = name; } bool PropertyEditorValue::isValid() const { + NanotraceHR::Tracer tracer{"property editor value is valid", category()}; + return m_isValid; } void PropertyEditorValue::setIsValid(bool valid) { + NanotraceHR::Tracer tracer{"property editor value set is valid", category()}; + m_isValid = valid; } bool PropertyEditorValue::isTranslated() const { + NanotraceHR::Tracer tracer{"property editor value is translated", category()}; + if (modelNode().isValid()) { auto metaInfo = modelNode().metaInfo(); auto isString = metaInfo.isValid() && metaInfo.hasProperty(name()) @@ -249,11 +288,15 @@ bool PropertyEditorValue::isTranslated() const bool PropertyEditorValue::hasActiveDrag() const { + NanotraceHR::Tracer tracer{"property editor value has active drag", category()}; + return m_hasActiveDrag; } void PropertyEditorValue::setHasActiveDrag(bool val) { + NanotraceHR::Tracer tracer{"property editor value set has active drag", category()}; + if (m_hasActiveDrag != val) { m_hasActiveDrag = val; emit hasActiveDragChanged(); @@ -272,6 +315,8 @@ static bool isAllowedSubclassType(const QString &type, const NodeMetaInfo &metaI bool PropertyEditorValue::isAvailable() const { + NanotraceHR::Tracer tracer{"property editor value is available", category()}; + if (!m_modelNode.isValid()) return true; @@ -322,11 +367,15 @@ bool PropertyEditorValue::isAvailable() const ModelNode PropertyEditorValue::modelNode() const { + NanotraceHR::Tracer tracer{"property editor value model node", category()}; + return m_modelNode; } void PropertyEditorValue::setModelNode(const ModelNode &modelNode) { + NanotraceHR::Tracer tracer{"property editor value set model node", category()}; + if (modelNode != m_modelNode) { m_modelNode = modelNode; m_complexNode->update(); @@ -336,11 +385,15 @@ void PropertyEditorValue::setModelNode(const ModelNode &modelNode) PropertyEditorNodeWrapper *PropertyEditorValue::complexNode() { + NanotraceHR::Tracer tracer{"property editor value complex node", category()}; + return m_complexNode; } void PropertyEditorValue::resetValue() { + NanotraceHR::Tracer tracer{"property editor value reset value", category()}; + if (m_value.isValid() || !m_expression.isEmpty() || isBound()) { m_value = QVariant(); m_isBound = false; @@ -353,6 +406,8 @@ void PropertyEditorValue::resetValue() void PropertyEditorValue::setEnumeration(const QString &scope, const QString &name) { + NanotraceHR::Tracer tracer{"property editor value set enumeration", category()}; + Enumeration newEnumeration(scope.toUtf8(), name.toUtf8()); setValueWithEmit(QVariant::fromValue(newEnumeration)); @@ -360,11 +415,15 @@ void PropertyEditorValue::setEnumeration(const QString &scope, const QString &na void PropertyEditorValue::exportPropertyAsAlias() { + NanotraceHR::Tracer tracer{"property editor value export property as alias", category()}; + emit exportPropertyAsAliasRequested(nameAsQString()); } bool PropertyEditorValue::hasPropertyAlias() const { + NanotraceHR::Tracer tracer{"property editor value has property alias", category()}; + if (!modelNode().isValid()) return false; @@ -387,16 +446,22 @@ bool PropertyEditorValue::hasPropertyAlias() const bool PropertyEditorValue::isAttachedProperty() const { + NanotraceHR::Tracer tracer{"property editor value is attached property", category()}; + return !nameAsQString().isEmpty() && nameAsQString().at(0).isUpper(); } void PropertyEditorValue::removeAliasExport() { + NanotraceHR::Tracer tracer{"property editor value remove alias export", category()}; + emit removeAliasExportRequested(nameAsQString()); } QString PropertyEditorValue::getTranslationContext() const { + NanotraceHR::Tracer tracer{"property editor value get translation context", category()}; + if (modelNode().isValid()) { if (auto metaInfo = modelNode().metaInfo(); metaInfo.isValid() && metaInfo.hasProperty(name()) @@ -416,7 +481,10 @@ QString PropertyEditorValue::getTranslationContext() const bool PropertyEditorValue::isIdList() const { - if (modelNode().isValid() && modelNode().metaInfo().isValid() && modelNode().metaInfo().hasProperty(name())) { + NanotraceHR::Tracer tracer{"property editor value is id list", category()}; + + if (modelNode().isValid() && modelNode().metaInfo().isValid() + && modelNode().metaInfo().hasProperty(name())) { const QmlObjectNode objectNode(modelNode()); if (objectNode.hasBindingProperty(name())) { static const QRegularExpression rx(QRegularExpression::anchoredPattern( @@ -436,11 +504,15 @@ bool PropertyEditorValue::isIdList() const QStringList PropertyEditorValue::getExpressionAsList() const { + NanotraceHR::Tracer tracer{"property editor value get expression as list", category()}; + return generateStringList(expression()); } QVector PropertyEditorValue::getExpressionAsVector() const { + NanotraceHR::Tracer tracer{"property editor value get expression as vector", category()}; + const QRegularExpression rx( QRegularExpression::anchoredPattern("Qt.vector(2|3|4)d\\((.*?)\\)")); const QRegularExpressionMatch match = rx.match(expression()); @@ -469,6 +541,8 @@ QVector PropertyEditorValue::getExpressionAsVector() const bool PropertyEditorValue::idListAdd(const QString &value) { + NanotraceHR::Tracer tracer{"property editor value id list add", category()}; + const QmlObjectNode objectNode(modelNode()); if (!isIdList() && objectNode.isValid() && objectNode.hasProperty(name())) return false; @@ -487,6 +561,8 @@ bool PropertyEditorValue::idListAdd(const QString &value) bool PropertyEditorValue::idListRemove(int idx) { + NanotraceHR::Tracer tracer{"property editor value id list remove", category()}; + QTC_ASSERT(isIdList(), return false); auto stringList = generateStringList(expression()); @@ -505,6 +581,8 @@ bool PropertyEditorValue::idListRemove(int idx) bool PropertyEditorValue::idListReplace(int idx, const QString &value) { + NanotraceHR::Tracer tracer{"property editor value id list replace", category()}; + QTC_ASSERT(isIdList(), return false); static const QRegularExpression rx(QRegularExpression::anchoredPattern( @@ -525,6 +603,8 @@ bool PropertyEditorValue::idListReplace(int idx, const QString &value) void PropertyEditorValue::commitDrop(const QString &dropData) { + NanotraceHR::Tracer tracer{"property editor value commit drop", category()}; + if (m_modelNode.metaInfo().property(m_name).propertyType().isQtQuick3DTexture()) { m_modelNode.view()->executeInTransaction(__FUNCTION__, [&] { ModelNode texture = m_modelNode.view()->modelNodeForInternalId(dropData.toInt()); @@ -548,6 +628,8 @@ void PropertyEditorValue::commitDrop(const QString &dropData) void PropertyEditorValue::editMaterial(int idx) { + NanotraceHR::Tracer tracer{"property editor value edit material", category()}; + if (ModelNode material = Utils3D::getMaterialOfModel(m_modelNode, idx)) { QmlDesignerPlugin::instance()->mainWidget()->showDockWidget("Properties", true); material.selectNode(); @@ -556,6 +638,8 @@ void PropertyEditorValue::editMaterial(int idx) void PropertyEditorValue::setForceBound(bool b) { + NanotraceHR::Tracer tracer{"property editor value set force bound", category()}; + if (m_forceBound == b) return; m_forceBound = b; @@ -565,6 +649,8 @@ void PropertyEditorValue::setForceBound(bool b) void PropertyEditorValue::insertKeyframe() { + NanotraceHR::Tracer tracer{"property editor value insert keyframe", category()}; + if (!m_modelNode.isValid()) return; @@ -582,6 +668,8 @@ void PropertyEditorValue::insertKeyframe() QStringList PropertyEditorValue::generateStringList(const QString &string) const { + NanotraceHR::Tracer tracer{"property editor value generate string list", category()}; + QString copy = string; copy = copy.remove("[").remove("]"); @@ -594,6 +682,8 @@ QStringList PropertyEditorValue::generateStringList(const QString &string) const QString PropertyEditorValue::generateString(const QStringList &stringList) const { + NanotraceHR::Tracer tracer{"property editor value generate string", category()}; + if (stringList.size() > 1) return "[" + stringList.join(",") + "]"; else if (stringList.isEmpty()) @@ -604,6 +694,8 @@ QString PropertyEditorValue::generateString(const QStringList &stringList) const void PropertyEditorValue::registerDeclarativeTypes() { + NanotraceHR::Tracer tracer{"property editor value register declarative types", category()}; + qmlRegisterType("HelperWidgets", 2, 0, "PropertyEditorValue"); qmlRegisterType("HelperWidgets", 2, 0, "PropertyEditorNodeWrapper"); qmlRegisterType("HelperWidgets", 2, 0, "QQmlPropertyMap"); @@ -613,6 +705,8 @@ PropertyEditorNodeWrapper::PropertyEditorNodeWrapper(PropertyEditorValue *parent : QObject(parent), m_valuesPropertyMap(this) { + NanotraceHR::Tracer tracer{"property editor value node wrapper constructor", category()}; + m_editorValue = parent; connect(m_editorValue, &PropertyEditorValue::modelNodeChanged, this, &PropertyEditorNodeWrapper::update); } @@ -620,35 +714,48 @@ PropertyEditorNodeWrapper::PropertyEditorNodeWrapper(PropertyEditorValue *parent PropertyEditorNodeWrapper::PropertyEditorNodeWrapper(QObject *parent) : QObject(parent) { + NanotraceHR::Tracer tracer{"property editor node wrapper constructor", category()}; } bool PropertyEditorNodeWrapper::exists() const { + NanotraceHR::Tracer tracer{"property editor node wrapper exists", category()}; + return m_editorValue && m_editorValue->modelNode().isValid() && m_modelNode.isValid(); } QString PropertyEditorNodeWrapper::type() const { + NanotraceHR::Tracer tracer{"property editor node wrapper type", category()}; + return m_modelNode.simplifiedTypeName(); } ModelNode PropertyEditorNodeWrapper::parentModelNode() const { - return m_editorValue->modelNode(); + NanotraceHR::Tracer tracer{"property editor node wrapper parent model node", category()}; + + return m_editorValue->modelNode(); } PropertyNameView PropertyEditorNodeWrapper::propertyName() const { + NanotraceHR::Tracer tracer{"property editor node wrapper property name", category()}; + return m_editorValue->name(); } QQmlPropertyMap *PropertyEditorNodeWrapper::properties() { + NanotraceHR::Tracer tracer{"property editor node wrapper properties", category()}; + return &m_valuesPropertyMap; } void PropertyEditorNodeWrapper::add(const QString &type) { + NanotraceHR::Tracer tracer{"property editor node wrapper add", category()}; + TypeName propertyType = type.toUtf8(); if ((m_editorValue && m_editorValue->modelNode().isValid())) { @@ -683,6 +790,8 @@ void PropertyEditorNodeWrapper::add(const QString &type) void PropertyEditorNodeWrapper::remove() { + NanotraceHR::Tracer tracer{"property editor node wrapper remove", category()}; + if ((m_editorValue && m_editorValue->modelNode().isValid())) { QmlObjectNode(m_modelNode).destroy(); m_editorValue->modelNode().removeProperty(m_editorValue->name()); @@ -701,6 +810,8 @@ void PropertyEditorNodeWrapper::remove() void PropertyEditorNodeWrapper::changeValue(const QString &propertyName) { + NanotraceHR::Tracer tracer{"property editor node wrapper change value", category()}; + const PropertyName name = propertyName.toUtf8(); if (name.isNull()) @@ -718,6 +829,8 @@ void PropertyEditorNodeWrapper::changeValue(const QString &propertyName) void PropertyEditorNodeWrapper::setup() { + NanotraceHR::Tracer tracer{"property editor node wrapper setup", category()}; + Q_ASSERT(m_editorValue); Q_ASSERT(m_editorValue->modelNode().isValid()); @@ -748,6 +861,8 @@ void PropertyEditorNodeWrapper::setup() void PropertyEditorNodeWrapper::update() { + NanotraceHR::Tracer tracer{"property editor node wrapper update", category()}; + if (!m_editorValue || !m_editorValue->modelNode().isValid()) return; @@ -763,6 +878,8 @@ void PropertyEditorNodeWrapper::update() QQmlPropertyMap *PropertyEditorSubSelectionWrapper::properties() { + NanotraceHR::Tracer tracer{"property editor sub selection wrapper properties", category()}; + return &m_valuesPropertyMap; } @@ -778,6 +895,9 @@ void PropertyEditorSubSelectionWrapper::createPropertyEditorValue(const QmlObjec PropertyNameView name, const QVariant &value) { + NanotraceHR::Tracer tracer{"property editor sub selection wrapper create property editor value", + category()}; + Utils::SmallString propertyName = name.toByteArray(); propertyName.replace('.', '_'); @@ -816,6 +936,9 @@ void PropertyEditorSubSelectionWrapper::createPropertyEditorValue(const QmlObjec void PropertyEditorSubSelectionWrapper::exportPropertyAsAlias(const QString &name) { + NanotraceHR::Tracer tracer{"property editor sub selection wrapper export property as alias", + category()}; + if (name.isNull()) return; @@ -831,6 +954,9 @@ void PropertyEditorSubSelectionWrapper::exportPropertyAsAlias(const QString &nam void PropertyEditorSubSelectionWrapper::removeAliasExport(const QString &name) { + NanotraceHR::Tracer tracer{"property editor sub selection wrapper remove alias export", + category()}; + if (name.isNull()) return; @@ -846,12 +972,16 @@ void PropertyEditorSubSelectionWrapper::removeAliasExport(const QString &name) bool PropertyEditorSubSelectionWrapper::locked() const { + NanotraceHR::Tracer tracer{"property editor sub selection wrapper locked", category()}; + return m_locked; } PropertyEditorSubSelectionWrapper::PropertyEditorSubSelectionWrapper(const ModelNode &modelNode) : m_modelNode(modelNode) { + NanotraceHR::Tracer tracer{"property editor sub selection wrapper constructor", category()}; + QmlObjectNode qmlObjectNode(modelNode); QTC_ASSERT(qmlObjectNode.isValid(), return ); @@ -867,11 +997,15 @@ PropertyEditorSubSelectionWrapper::PropertyEditorSubSelectionWrapper(const Model ModelNode PropertyEditorSubSelectionWrapper::modelNode() const { + NanotraceHR::Tracer tracer{"property editor sub selection wrapper model node", category()}; + return m_modelNode; } void PropertyEditorSubSelectionWrapper::deleteModelNode() { + NanotraceHR::Tracer tracer{"property editor sub selection wrapper delete model node", category()}; + QmlObjectNode objectNode(m_modelNode); view()->executeInTransaction("PropertyEditorView::changeExpression", [&] { @@ -882,7 +1016,9 @@ void PropertyEditorSubSelectionWrapper::deleteModelNode() void PropertyEditorSubSelectionWrapper::changeValue(const QString &name) { - QTC_ASSERT(m_modelNode.isValid(), return ); + NanotraceHR::Tracer tracer{"property editor sub selection wrapper change value", category()}; + + QTC_ASSERT(m_modelNode.isValid(), return); if (name.isNull()) return; @@ -919,6 +1055,9 @@ void PropertyEditorSubSelectionWrapper::changeValue(const QString &name) void PropertyEditorSubSelectionWrapper::setValueFromModel(PropertyNameView name, const QVariant &value) { + NanotraceHR::Tracer tracer{"property editor sub selection wrapper set value from model", + category()}; + m_locked = true; QmlObjectNode qmlObjectNode(m_modelNode); @@ -934,6 +1073,8 @@ void PropertyEditorSubSelectionWrapper::setValueFromModel(PropertyNameView name, void PropertyEditorSubSelectionWrapper::resetValue(PropertyNameView name) { + NanotraceHR::Tracer tracer{"property editor sub selection wrapper reset value", category()}; + auto propertyValue = qobject_cast( variantToQObject(m_valuesPropertyMap.value(QString::fromUtf8(name)))); if (propertyValue) @@ -942,12 +1083,17 @@ void PropertyEditorSubSelectionWrapper::resetValue(PropertyNameView name) bool PropertyEditorSubSelectionWrapper::isRelevantModelNode(const ModelNode &modelNode) const { + NanotraceHR::Tracer tracer{"property editor sub selection wrapper is relevant model node", + category()}; + QmlObjectNode objectNode(m_modelNode); return modelNode == m_modelNode || objectNode.propertyChangeForCurrentState() == modelNode; } void PropertyEditorSubSelectionWrapper::changeExpression(const QString &propertyName) { + NanotraceHR::Tracer tracer{"property editor sub selection wrapper change expression", category()}; + PropertyName name = propertyName.toUtf8(); QTC_ASSERT(m_modelNode.isValid(), return ); @@ -981,6 +1127,9 @@ void PropertyEditorSubSelectionWrapper::changeExpression(const QString &property void PropertyEditorSubSelectionWrapper::removePropertyFromModel(PropertyNameView propertyName) { + NanotraceHR::Tracer tracer{"property editor sub selection wrapper remove property from model", + category()}; + QTC_ASSERT(m_modelNode.isValid(), return ); m_locked = true; @@ -1000,6 +1149,9 @@ void PropertyEditorSubSelectionWrapper::removePropertyFromModel(PropertyNameView void PropertyEditorSubSelectionWrapper::commitVariantValueToModel(PropertyNameView propertyName, const QVariant &value) { + NanotraceHR::Tracer tracer{ + "property editor sub selection wrapper commit variant value to model", category()}; + QTC_ASSERT(m_modelNode.isValid(), return ); try { @@ -1016,6 +1168,7 @@ void PropertyEditorSubSelectionWrapper::commitVariantValueToModel(PropertyNameVi AbstractView *PropertyEditorSubSelectionWrapper::view() const { + NanotraceHR::Tracer tracer{"property editor sub selection wrapper view", category()}; QTC_CHECK(m_modelNode.isValid()); return m_modelNode.view(); diff --git a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorview.cpp b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorview.cpp index 82e99bb7e16..26c5e7b785f 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorview.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorview.cpp @@ -4,6 +4,7 @@ #include "propertyeditorview.h" #include "propertyeditorqmlbackend.h" +#include "propertyeditortracing.h" #include "propertyeditortransaction.h" #include "propertyeditorvalue.h" #include "propertyeditorwidget.h" @@ -50,6 +51,8 @@ enum { namespace QmlDesigner { +static auto category = PropertyEditorTracing::category; + constexpr QStringView quick3dImport{u"QtQuick3D"}; static bool propertyIsAttachedLayoutProperty(PropertyNameView propertyName) @@ -80,6 +83,8 @@ PropertyEditorView::PropertyEditorView(AsynchronousImageCache &imageCache, , m_propertyComponentGenerator{PropertyEditorQmlBackend::propertyEditorResourcesPath(), model()} , m_locked(false) { + NanotraceHR::Tracer tracer{"property editor view constructor", category()}; + m_qmlDir = PropertyEditorQmlBackend::propertyEditorResourcesPath(); if (Utils::HostOsInfo::isMacHost()) @@ -101,11 +106,15 @@ PropertyEditorView::PropertyEditorView(AsynchronousImageCache &imageCache, PropertyEditorView::~PropertyEditorView() { + NanotraceHR::Tracer tracer{"property editor view destructor", category()}; + qDeleteAll(m_qmlBackendHash); } void PropertyEditorView::changeValue(const QString &name) { + NanotraceHR::Tracer tracer{"property editor view change value", category()}; + PropertyName propertyName = name.toUtf8(); if (propertyName.isNull()) @@ -231,6 +240,8 @@ static bool isTrueFalseLiteral(const QString &expression) void PropertyEditorView::changeExpression(const QString &propertyName) { + NanotraceHR::Tracer tracer{"property editor view change expression", category()}; + PropertyName name = propertyName.toUtf8(); if (name.isNull()) @@ -268,6 +279,8 @@ void PropertyEditorView::changeExpression(const QString &propertyName) void PropertyEditorView::exportPropertyAsAlias(const QString &name) { + NanotraceHR::Tracer tracer{"property editor view export property as alias", category()}; + if (name.isNull()) return; @@ -283,6 +296,8 @@ void PropertyEditorView::exportPropertyAsAlias(const QString &name) void PropertyEditorView::removeAliasExport(const QString &name) { + NanotraceHR::Tracer tracer{"property editor view remove alias export", category()}; + if (name.isNull()) return; @@ -298,21 +313,30 @@ void PropertyEditorView::removeAliasExport(const QString &name) bool PropertyEditorView::locked() const { + NanotraceHR::Tracer tracer{"property editor view locked", category()}; + return m_locked; } void PropertyEditorView::currentTimelineChanged(const ModelNode &) { - m_qmlBackEndForCurrentType->contextObject()->setHasActiveTimeline(QmlTimeline::hasActiveTimeline(this)); + NanotraceHR::Tracer tracer{"property editor view current timeline changed", category()}; + + m_qmlBackEndForCurrentType->contextObject()->setHasActiveTimeline( + QmlTimeline::hasActiveTimeline(this)); } void PropertyEditorView::refreshMetaInfos(const TypeIds &deletedTypeIds) { + NanotraceHR::Tracer tracer{"property editor view refresh meta infos", category()}; + m_propertyComponentGenerator.refreshMetaInfos(deletedTypeIds); } DynamicPropertiesModel *PropertyEditorView::dynamicPropertiesModel() const { + NanotraceHR::Tracer tracer{"property editor view dynamic properties model", category()}; + return m_dynamicPropertiesModel.get(); } @@ -320,6 +344,8 @@ void PropertyEditorView::setExpressionOnObjectNode(const QmlObjectNode &constObj PropertyNameView name, const QString &newExpression) { + NanotraceHR::Tracer tracer{"property editor view set expression on object node", category()}; + auto qmlObjectNode = constObjectNode; auto expression = newExpression; if (auto property = qmlObjectNode.modelNode().metaInfo().property(name)) { @@ -374,7 +400,9 @@ void PropertyEditorView::setExpressionOnObjectNode(const QmlObjectNode &constObj void PropertyEditorView::generateAliasForProperty(const ModelNode &modelNode, const QString &name) { - QTC_ASSERT(modelNode.isValid(), return ); + NanotraceHR::Tracer tracer{"property editor view generate alias for property", category()}; + + QTC_ASSERT(modelNode.isValid(), return); auto view = modelNode.view(); @@ -400,7 +428,9 @@ void PropertyEditorView::generateAliasForProperty(const ModelNode &modelNode, co void PropertyEditorView::removeAliasForProperty(const ModelNode &modelNode, const QString &propertyName) { - QTC_ASSERT(modelNode.isValid(), return ); + NanotraceHR::Tracer tracer{"property editor view remove alias for property", category()}; + + QTC_ASSERT(modelNode.isValid(), return); auto view = modelNode.view(); @@ -420,6 +450,8 @@ void PropertyEditorView::removeAliasForProperty(const ModelNode &modelNode, cons PropertyEditorView *PropertyEditorView::instance() { + NanotraceHR::Tracer tracer{"property editor view instance", category()}; + static PropertyEditorView *s_instance = nullptr; if (s_instance) @@ -438,6 +470,8 @@ PropertyEditorView *PropertyEditorView::instance() NodeMetaInfo PropertyEditorView::findCommonAncestor(const ModelNode &node) { + NanotraceHR::Tracer tracer{"property editor view find common ancestor", category()}; + if (!node.isValid()) return node.metaInfo(); @@ -458,6 +492,8 @@ NodeMetaInfo PropertyEditorView::findCommonAncestor(const ModelNode &node) void PropertyEditorView::updateSize() { + NanotraceHR::Tracer tracer{"property editor view update size", category()}; + if (!m_qmlBackEndForCurrentType) return; auto frame = m_qmlBackEndForCurrentType->widget()->findChild("propertyEditorFrame"); @@ -467,6 +503,8 @@ void PropertyEditorView::updateSize() void PropertyEditorView::resetView() { + NanotraceHR::Tracer tracer{"property editor view reset view", category()}; + if (model() == nullptr) return; @@ -498,6 +536,8 @@ void PropertyEditorView::resetView() void PropertyEditorView::setIsSelectionLocked(bool locked) { + NanotraceHR::Tracer tracer{"property editor view set is selection locked", category()}; + if (m_isSelectionLocked != locked) { m_isSelectionLocked = locked; for (PropertyEditorQmlBackend *qmlBackend : std::as_const(m_qmlBackendHash)) @@ -555,6 +595,8 @@ PropertyEditorQmlBackend *getQmlBackend(QHash PropertyEditorView::currentNodes() const { + NanotraceHR::Tracer tracer{"property editor view current nodes", category()}; + if (m_isSelectionLocked) return {m_activeNode}; @@ -827,6 +887,8 @@ QList PropertyEditorView::currentNodes() const void PropertyEditorView::selectedNodesChanged(const QList &, const QList &) { + NanotraceHR::Tracer tracer{"property editor view selected nodes changed", category()}; + if (!m_isSelectionLocked) select(); @@ -837,6 +899,8 @@ void PropertyEditorView::selectedNodesChanged(const QList &, bool PropertyEditorView::isNodeOrChildSelected(const ModelNode &node) const { + NanotraceHR::Tracer tracer{"property editor view is node or child selected", category()}; + if (activeNode().isValid() && node.isValid()) { const ModelNodes &nodeList = node.allSubModelNodesAndThisNode(); return nodeList.contains(activeNode()); @@ -846,12 +910,16 @@ bool PropertyEditorView::isNodeOrChildSelected(const ModelNode &node) const void PropertyEditorView::resetSelectionLocked() { + NanotraceHR::Tracer tracer{"property editor view reset selection locked", category()}; + if (m_isSelectionLocked) setIsSelectionLocked(false); } void PropertyEditorView::resetIfNodeIsRemoved(const ModelNode &removedNode) { + NanotraceHR::Tracer tracer{"property editor view reset if node is removed", category()}; + if (isNodeOrChildSelected(removedNode)) { resetSelectionLocked(); select(); @@ -860,6 +928,8 @@ void PropertyEditorView::resetIfNodeIsRemoved(const ModelNode &removedNode) void PropertyEditorView::nodeAboutToBeRemoved(const ModelNode &removedNode) { + NanotraceHR::Tracer tracer{"property editor view node about to be removed", category()}; + resetIfNodeIsRemoved(removedNode); const ModelNodes &allRemovedNodes = removedNode.allSubModelNodesAndThisNode(); @@ -880,6 +950,8 @@ void PropertyEditorView::nodeAboutToBeRemoved(const ModelNode &removedNode) void PropertyEditorView::nodeRemoved(const ModelNode &, const NodeAbstractProperty &, PropertyChangeFlags) { + NanotraceHR::Tracer tracer{"property editor view node removed", category()}; + if (m_qmlBackEndForCurrentType && m_textureAboutToBeRemoved) m_qmlBackEndForCurrentType->refreshBackendModel(); @@ -888,6 +960,8 @@ void PropertyEditorView::nodeRemoved(const ModelNode &, const NodeAbstractProper void PropertyEditorView::modelAttached(Model *model) { + NanotraceHR::Tracer tracer{"property editor view model attached", category()}; + AbstractView::modelAttached(model); if constexpr (useProjectStorage()) @@ -902,6 +976,8 @@ void PropertyEditorView::modelAttached(Model *model) void PropertyEditorView::modelAboutToBeDetached(Model *model) { + NanotraceHR::Tracer tracer{"property editor view model about to be detached", category()}; + AbstractView::modelAboutToBeDetached(model); m_qmlBackEndForCurrentType->propertyEditorTransaction()->end(); @@ -911,6 +987,8 @@ void PropertyEditorView::modelAboutToBeDetached(Model *model) void PropertyEditorView::propertiesRemoved(const QList &propertyList) { + NanotraceHR::Tracer tracer{"property editor view properties removed", category()}; + if (noValidSelection()) return; @@ -985,12 +1063,16 @@ void PropertyEditorView::propertiesRemoved(const QList &proper void PropertyEditorView::propertiesAboutToBeRemoved(const QList &propertyList) { + NanotraceHR::Tracer tracer{"property editor view properties about to be removed", category()}; + for (const auto &property : propertyList) m_dynamicPropertiesModel->removeItem(property); } void PropertyEditorView::variantPropertiesChanged(const QList& propertyList, PropertyChangeFlags /*propertyChange*/) { + NanotraceHR::Tracer tracer{"property editor view variant properties changed", category()}; + if (noValidSelection()) return; @@ -1042,6 +1124,8 @@ void PropertyEditorView::variantPropertiesChanged(const QList& void PropertyEditorView::bindingPropertiesChanged(const QList &propertyList, PropertyChangeFlags /*propertyChange*/) { + NanotraceHR::Tracer tracer{"property editor view binding properties changed", category()}; + if (noValidSelection()) return; @@ -1085,6 +1169,8 @@ void PropertyEditorView::auxiliaryDataChanged(const ModelNode &node, [[maybe_unused]] AuxiliaryDataKeyView key, const QVariant &data) { + NanotraceHR::Tracer tracer{"property editor view auxiliary data changed", category()}; + if (noValidSelection()) return; @@ -1114,12 +1200,17 @@ void PropertyEditorView::auxiliaryDataChanged(const ModelNode &node, void PropertyEditorView::signalDeclarationPropertiesChanged( const QVector &propertyList, PropertyChangeFlags /* propertyChange */) { + NanotraceHR::Tracer tracer{"property editor view signal declaration properties changed", + category()}; + for (const SignalDeclarationProperty &property : propertyList) m_dynamicPropertiesModel->updateItem(property); } void PropertyEditorView::instanceInformationsChanged(const QMultiHash &informationChangedHash) { + NanotraceHR::Tracer tracer{"property editor view instance informations changed", category()}; + if (noValidSelection()) return; @@ -1133,6 +1224,8 @@ void PropertyEditorView::instanceInformationsChanged(const QMultiHashemitSelectionToBeChanged(); @@ -1164,6 +1259,8 @@ void PropertyEditorView::select() void PropertyEditorView::setActiveNodeToSelection() { + NanotraceHR::Tracer tracer{"property editor view set active node to selection", category()}; + const auto selectedNodeList = currentNodes(); setActiveNode(ModelNode()); @@ -1179,6 +1276,8 @@ void PropertyEditorView::setActiveNodeToSelection() void PropertyEditorView::forceSelection(const ModelNode &node) { + NanotraceHR::Tracer tracer{"property editor view force selection", category()}; + if (node == activeNode()) return; @@ -1191,11 +1290,15 @@ void PropertyEditorView::forceSelection(const ModelNode &node) bool PropertyEditorView::hasWidget() const { + NanotraceHR::Tracer tracer{"property editor view has widget", category()}; + return true; } WidgetInfo PropertyEditorView::widgetInfo() { + NanotraceHR::Tracer tracer{"property editor view widget info", category()}; + return createWidgetInfo(m_stackedWidget, QStringLiteral("Properties"), WidgetInfo::RightPane, @@ -1205,6 +1308,8 @@ WidgetInfo PropertyEditorView::widgetInfo() void PropertyEditorView::currentStateChanged(const ModelNode &node) { + NanotraceHR::Tracer tracer{"property editor view current state changed", category()}; + QmlModelState newQmlModelState(node); Q_ASSERT(newQmlModelState.isValid()); if (debug) @@ -1214,6 +1319,8 @@ void PropertyEditorView::currentStateChanged(const ModelNode &node) void PropertyEditorView::instancePropertyChanged(const QList > &propertyList) { + NanotraceHR::Tracer tracer{"property editor view instance property changed", category()}; + if (!activeNode().isValid()) return; @@ -1251,13 +1358,17 @@ void PropertyEditorView::instancePropertyChanged(const QListbackendAnchorBinding().setup(QmlItemNode(activeNode())); @@ -1285,6 +1398,8 @@ void PropertyEditorView::nodeReparented(const ModelNode &node, void PropertyEditorView::importsChanged(const Imports &addedImports, const Imports &removedImports) { + NanotraceHR::Tracer tracer{"property editor view imports changed", category()}; + if (!m_qmlBackEndForCurrentType) return; @@ -1299,6 +1414,8 @@ void PropertyEditorView::customNotification([[maybe_unused]] const AbstractView const QList &nodeList, [[maybe_unused]] const QList &data) { + NanotraceHR::Tracer tracer{"property editor view custom notification", category()}; + if (identifier == "force_editing_node") { if (!nodeList.isEmpty()) forceSelection(nodeList.first()); @@ -1309,6 +1426,8 @@ void PropertyEditorView::modelNodePreviewPixmapChanged(const ModelNode &node, const QPixmap &pixmap, const QByteArray &requestId) { + NanotraceHR::Tracer tracer{"property editor view model node preview pixmap changed", category()}; + if (node != activeNode()) return; @@ -1318,6 +1437,8 @@ void PropertyEditorView::modelNodePreviewPixmapChanged(const ModelNode &node, void PropertyEditorView::highlightTextureProperties(bool highlight) { + NanotraceHR::Tracer tracer{"property editor view highlight texture properties", category()}; + NodeMetaInfo metaInfo = activeNode().metaInfo(); QTC_ASSERT(metaInfo.isValid(), return); @@ -1334,6 +1455,8 @@ void PropertyEditorView::highlightTextureProperties(bool highlight) void PropertyEditorView::dragStarted(QMimeData *mimeData) { + NanotraceHR::Tracer tracer{"property editor view drag started", category()}; + if (mimeData->hasFormat(Constants::MIME_TYPE_ASSETS)) { const QString assetPath = QString::fromUtf8(mimeData->data(Constants::MIME_TYPE_ASSETS)) .split(',')[0]; @@ -1354,6 +1477,8 @@ void PropertyEditorView::dragStarted(QMimeData *mimeData) void PropertyEditorView::dragEnded() { + NanotraceHR::Tracer tracer{"property editor view drag ended", category()}; + m_qmlBackEndForCurrentType->contextObject()->setActiveDragSuffix(""); highlightTextureProperties(false); } @@ -1362,6 +1487,8 @@ void PropertyEditorView::setValue(const QmlObjectNode &qmlObjectNode, PropertyNameView name, const QVariant &value) { + NanotraceHR::Tracer tracer{"property editor view set value", category()}; + m_locked = true; m_qmlBackEndForCurrentType->setValue(qmlObjectNode, name, value); m_locked = false; @@ -1369,6 +1496,8 @@ void PropertyEditorView::setValue(const QmlObjectNode &qmlObjectNode, bool PropertyEditorView::eventFilter(QObject *obj, QEvent *event) { + NanotraceHR::Tracer tracer{"property editor view event filter", category()}; + if (event->type() == QEvent::FocusOut) { if (m_qmlBackEndForCurrentType && m_qmlBackEndForCurrentType->widget() == obj) QMetaObject::invokeMethod(m_qmlBackEndForCurrentType->widget()->rootObject(), "closeContextMenu"); @@ -1378,6 +1507,8 @@ bool PropertyEditorView::eventFilter(QObject *obj, QEvent *event) void PropertyEditorView::reloadQml() { + NanotraceHR::Tracer tracer{"property editor view reload Qml", category()}; + m_qmlBackendHash.clear(); while (QWidget *widget = m_stackedWidget->widget(0)) { m_stackedWidget->removeWidget(widget); diff --git a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorwidget.cpp b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorwidget.cpp index 36c04e69f11..32c79e7d1c7 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/propertyeditorwidget.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/propertyeditorwidget.cpp @@ -3,18 +3,26 @@ #include "propertyeditorwidget.h" +#include "propertyeditortracing.h" + #include #include namespace QmlDesigner { +static auto category = PropertyEditorTracing::category; + PropertyEditorWidget::PropertyEditorWidget(QWidget *parent) : QStackedWidget(parent) { + NanotraceHR::Tracer tracer{"property editor widget constructor", category()}; + QmlDesignerPlugin::trackWidgetFocusTime(this, Constants::EVENT_PROPERTYEDITOR_TIME); } void PropertyEditorWidget::resizeEvent(QResizeEvent * event) { + NanotraceHR::Tracer tracer{"property editor widget resize event", category()}; + QStackedWidget::resizeEvent(event); emit resized(); } diff --git a/src/plugins/qmldesigner/components/propertyeditor/propertynamevalidator.cpp b/src/plugins/qmldesigner/components/propertyeditor/propertynamevalidator.cpp index 2af3d1bf9aa..3a36c4917d8 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/propertynamevalidator.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/propertynamevalidator.cpp @@ -3,16 +3,24 @@ #include "propertynamevalidator.h" -#include "modelutils.h" +#include "propertyeditortracing.h" + +#include #include +static auto category = QmlDesigner::PropertyEditorTracing::category; + PropertyNameValidator::PropertyNameValidator(QObject *parent) : QValidator(parent) -{} +{ + NanotraceHR::Tracer tracer{"property name validator constructor", category()}; +} QValidator::State PropertyNameValidator::validate(QString &input, int &) const { + NanotraceHR::Tracer tracer{"property name validator validate", category()}; + if (input.isEmpty()) return QValidator::Intermediate; @@ -32,5 +40,7 @@ QValidator::State PropertyNameValidator::validate(QString &input, int &) const void PropertyNameValidator::registerDeclarativeType() { + NanotraceHR::Tracer tracer{"property name validator register declarative type", category()}; + qmlRegisterType("HelperWidgets", 2, 0, "PropertyNameValidator"); } diff --git a/src/plugins/qmldesigner/components/propertyeditor/qmlanchorbindingproxy.cpp b/src/plugins/qmldesigner/components/propertyeditor/qmlanchorbindingproxy.cpp index 87d0b9864d5..f83dc1b7680 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/qmlanchorbindingproxy.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/qmlanchorbindingproxy.cpp @@ -3,6 +3,8 @@ #include "qmlanchorbindingproxy.h" +#include "propertyeditortracing.h" + #include #include #include @@ -22,6 +24,9 @@ class ModelNode; class NodeState; namespace { + +static auto category = QmlDesigner::PropertyEditorTracing::category; + const Utils::SmallString auxDataString("anchors_"); Utils::SmallString auxPropertyString(Utils::SmallStringView name) @@ -47,12 +52,18 @@ QmlAnchorBindingProxy::QmlAnchorBindingProxy(QObject *parent) : m_relativeVerticalTarget(Center), m_relativeHorizontalTarget(Center), m_locked(false), m_ignoreQml(false) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy constructor", category()}; } -QmlAnchorBindingProxy::~QmlAnchorBindingProxy() = default; +QmlAnchorBindingProxy::~QmlAnchorBindingProxy() +{ + NanotraceHR::Tracer tracer{"qml anchor binding proxy destructor", category()}; +} void QmlAnchorBindingProxy::setup(const QmlItemNode &fxItemNode) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy setup", category()}; + m_qmlItemNode = fxItemNode; m_ignoreQml = true; @@ -80,6 +91,8 @@ void QmlAnchorBindingProxy::setup(const QmlItemNode &fxItemNode) void QmlAnchorBindingProxy::invalidate(const QmlItemNode &fxItemNode) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy invalidate", category()}; + if (m_locked) return; @@ -92,13 +105,8 @@ void QmlAnchorBindingProxy::invalidate(const QmlItemNode &fxItemNode) return node.modelNode().parentProperty().parentModelNode(); }; - m_verticalTarget = - m_horizontalTarget = - m_topTarget = - m_bottomTarget = - m_leftTarget = - m_rightTarget = - parentModelNode(m_qmlItemNode); + m_verticalTarget = m_horizontalTarget = m_topTarget = m_bottomTarget = m_leftTarget = m_rightTarget = parentModelNode( + m_qmlItemNode); setupAnchorTargets(); @@ -121,6 +129,8 @@ void QmlAnchorBindingProxy::invalidate(const QmlItemNode &fxItemNode) void QmlAnchorBindingProxy::setupAnchorTargets() { + NanotraceHR::Tracer tracer{"qml anchor binding proxy setup anchor targets", category()}; + if (m_qmlItemNode.modelNode().hasParentProperty()) setDefaultAnchorTarget(m_qmlItemNode.modelNode().parentProperty().parentModelNode()); else @@ -209,7 +219,9 @@ void QmlAnchorBindingProxy::setupAnchorTargets() } if (horizontalCentered()) { - ModelNode targetNode = m_qmlItemNode.anchors().instanceAnchor(AnchorLineHorizontalCenter).qmlItemNode(); + ModelNode targetNode = m_qmlItemNode.anchors() + .instanceAnchor(AnchorLineHorizontalCenter) + .qmlItemNode(); if (targetNode.isValid()) m_horizontalTarget = targetNode; } @@ -217,6 +229,8 @@ void QmlAnchorBindingProxy::setupAnchorTargets() void QmlAnchorBindingProxy::emitAnchorSignals() { + NanotraceHR::Tracer tracer{"qml anchor binding proxy emit anchor signals", category()}; + emit topAnchorChanged(); emit bottomAnchorChanged(); emit leftAnchorChanged(); @@ -233,6 +247,8 @@ void QmlAnchorBindingProxy::emitAnchorSignals() void QmlAnchorBindingProxy::setDefaultRelativeTopTarget() { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set default relative top target", category()}; + if (m_topTarget.modelNode() == m_qmlItemNode.modelNode().parentProperty().parentModelNode()) { m_relativeTopTarget = SameEdge; } else { @@ -242,6 +258,9 @@ void QmlAnchorBindingProxy::setDefaultRelativeTopTarget() void QmlAnchorBindingProxy::setDefaultRelativeBottomTarget() { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set default relative bottom target", + category()}; + if (m_bottomTarget.modelNode() == m_qmlItemNode.modelNode().parentProperty().parentModelNode()) { m_relativeBottomTarget = SameEdge; } else { @@ -251,6 +270,9 @@ void QmlAnchorBindingProxy::setDefaultRelativeBottomTarget() void QmlAnchorBindingProxy::setDefaultRelativeLeftTarget() { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set default relative left target", + category()}; + if (m_leftTarget.modelNode() == m_qmlItemNode.modelNode().parentProperty().parentModelNode()) { m_relativeLeftTarget = SameEdge; } else { @@ -260,6 +282,9 @@ void QmlAnchorBindingProxy::setDefaultRelativeLeftTarget() void QmlAnchorBindingProxy::setDefaultRelativeRightTarget() { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set default relative right target", + category()}; + if (m_rightTarget.modelNode() == m_qmlItemNode.modelNode().parentProperty().parentModelNode()) { m_relativeRightTarget = SameEdge; } else { @@ -267,23 +292,32 @@ void QmlAnchorBindingProxy::setDefaultRelativeRightTarget() } } -bool QmlAnchorBindingProxy::executeInTransaction(const QByteArray &identifier, const AbstractView::OperationBlock &lambda) +bool QmlAnchorBindingProxy::executeInTransaction(const QByteArray &identifier, + const AbstractView::OperationBlock &lambda) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy execute in transaction", category()}; + return m_qmlItemNode.modelNode().view()->executeInTransaction(identifier, lambda); } bool QmlAnchorBindingProxy::hasParent() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy has parent", category()}; + return m_qmlItemNode.hasNodeParent(); } bool QmlAnchorBindingProxy::isInLayout() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy is in layout", category()}; + return m_qmlItemNode.isInLayout(); } bool QmlAnchorBindingProxy::isFilled() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy is filled", category()}; + return hasAnchors() && topAnchored() && bottomAnchored() && leftAnchored() && rightAnchored() && (m_qmlItemNode.instanceValue("anchors.topMargin").toInt() == 0) && (m_qmlItemNode.instanceValue("anchors.bottomMargin").toInt() == 0) @@ -293,32 +327,42 @@ bool QmlAnchorBindingProxy::isFilled() const bool QmlAnchorBindingProxy::topAnchored() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy top anchored", category()}; + return m_qmlItemNode.anchors().instanceHasAnchor(AnchorLineTop); } bool QmlAnchorBindingProxy::bottomAnchored() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy bottom anchored", category()}; + return m_qmlItemNode.anchors().instanceHasAnchor(AnchorLineBottom); } bool QmlAnchorBindingProxy::leftAnchored() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy left anchored", category()}; + return m_qmlItemNode.anchors().instanceHasAnchor(AnchorLineLeft); } bool QmlAnchorBindingProxy::rightAnchored() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy right anchored", category()}; + return m_qmlItemNode.anchors().instanceHasAnchor(AnchorLineRight); } bool QmlAnchorBindingProxy::hasAnchors() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy has anchors", category()}; + return m_qmlItemNode.anchors().instanceHasAnchors(); } - void QmlAnchorBindingProxy::setTopTarget(const QString &target) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set top target", category()}; if (m_ignoreQml) return; @@ -331,7 +375,7 @@ void QmlAnchorBindingProxy::setTopTarget(const QString &target) if (!newTarget.isValid()) return; - executeInTransaction("QmlAnchorBindingProxy::setTopTarget", [this, newTarget](){ + executeInTransaction("QmlAnchorBindingProxy::setTopTarget", [this, newTarget]() { m_topTarget = newTarget; setDefaultRelativeTopTarget(); anchorTop(); @@ -340,9 +384,10 @@ void QmlAnchorBindingProxy::setTopTarget(const QString &target) emit topTargetChanged(); } - void QmlAnchorBindingProxy::setBottomTarget(const QString &target) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set bottom target", category()}; + if (m_ignoreQml) return; @@ -354,11 +399,10 @@ void QmlAnchorBindingProxy::setBottomTarget(const QString &target) if (!newTarget.isValid()) return; - executeInTransaction("QmlAnchorBindingProxy::setBottomTarget", [this, newTarget](){ + executeInTransaction("QmlAnchorBindingProxy::setBottomTarget", [this, newTarget]() { m_bottomTarget = newTarget; setDefaultRelativeBottomTarget(); anchorBottom(); - }); emit bottomTargetChanged(); @@ -366,6 +410,8 @@ void QmlAnchorBindingProxy::setBottomTarget(const QString &target) void QmlAnchorBindingProxy::setLeftTarget(const QString &target) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set left target", category()}; + if (m_ignoreQml) return; @@ -377,7 +423,7 @@ void QmlAnchorBindingProxy::setLeftTarget(const QString &target) if (!newTarget.isValid()) return; - executeInTransaction("QmlAnchorBindingProxy::setLeftTarget", [this, newTarget](){ + executeInTransaction("QmlAnchorBindingProxy::setLeftTarget", [this, newTarget]() { m_leftTarget = newTarget; setDefaultRelativeLeftTarget(); anchorLeft(); @@ -388,6 +434,8 @@ void QmlAnchorBindingProxy::setLeftTarget(const QString &target) void QmlAnchorBindingProxy::setRightTarget(const QString &target) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set right target", category()}; + if (m_ignoreQml) return; @@ -399,7 +447,7 @@ void QmlAnchorBindingProxy::setRightTarget(const QString &target) if (!newTarget.isValid()) return; - executeInTransaction("QmlAnchorBindingProxy::setRightTarget", [this, newTarget](){ + executeInTransaction("QmlAnchorBindingProxy::setRightTarget", [this, newTarget]() { m_rightTarget = newTarget; setDefaultRelativeRightTarget(); anchorRight(); @@ -410,6 +458,8 @@ void QmlAnchorBindingProxy::setRightTarget(const QString &target) void QmlAnchorBindingProxy::setVerticalTarget(const QString &target) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set vertical target", category()}; + if (m_ignoreQml) return; @@ -421,7 +471,7 @@ void QmlAnchorBindingProxy::setVerticalTarget(const QString &target) if (!newTarget.isValid()) return; - executeInTransaction("QmlAnchorBindingProxy::setVerticalTarget", [this, newTarget](){ + executeInTransaction("QmlAnchorBindingProxy::setVerticalTarget", [this, newTarget]() { m_verticalTarget = newTarget; anchorVertical(); }); @@ -431,6 +481,8 @@ void QmlAnchorBindingProxy::setVerticalTarget(const QString &target) void QmlAnchorBindingProxy::setHorizontalTarget(const QString &target) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set horizontal target", category()}; + if (m_ignoreQml) return; @@ -442,7 +494,7 @@ void QmlAnchorBindingProxy::setHorizontalTarget(const QString &target) if (!newTarget.isValid()) return; - executeInTransaction("QmlAnchorBindingProxy::setHorizontalTarget", [this, newTarget](){ + executeInTransaction("QmlAnchorBindingProxy::setHorizontalTarget", [this, newTarget]() { m_horizontalTarget = newTarget; anchorHorizontal(); }); @@ -452,13 +504,15 @@ void QmlAnchorBindingProxy::setHorizontalTarget(const QString &target) void QmlAnchorBindingProxy::setRelativeAnchorTargetTop(QmlAnchorBindingProxy::RelativeAnchorTarget target) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set relative anchor target top", category()}; + if (m_ignoreQml) return; if (target == m_relativeTopTarget) return; - executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetTop", [this, target](){ + executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetTop", [this, target]() { m_relativeTopTarget = target; anchorTop(); }); @@ -468,13 +522,16 @@ void QmlAnchorBindingProxy::setRelativeAnchorTargetTop(QmlAnchorBindingProxy::Re void QmlAnchorBindingProxy::setRelativeAnchorTargetBottom(QmlAnchorBindingProxy::RelativeAnchorTarget target) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set relative anchor target bottom", + category()}; + if (m_ignoreQml) return; if (target == m_relativeBottomTarget) return; - executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetBottom", [this, target](){ + executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetBottom", [this, target]() { m_relativeBottomTarget = target; anchorBottom(); }); @@ -484,16 +541,17 @@ void QmlAnchorBindingProxy::setRelativeAnchorTargetBottom(QmlAnchorBindingProxy: void QmlAnchorBindingProxy::setRelativeAnchorTargetLeft(QmlAnchorBindingProxy::RelativeAnchorTarget target) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set relative anchor target left", category()}; + if (m_ignoreQml) return; if (target == m_relativeLeftTarget) return; - executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetLeft", [this, target](){ + executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetLeft", [this, target]() { m_relativeLeftTarget = target; anchorLeft(); - }); emit relativeAnchorTargetLeftChanged(); @@ -501,31 +559,36 @@ void QmlAnchorBindingProxy::setRelativeAnchorTargetLeft(QmlAnchorBindingProxy::R void QmlAnchorBindingProxy::setRelativeAnchorTargetRight(QmlAnchorBindingProxy::RelativeAnchorTarget target) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set relative anchor target right", + category()}; + if (m_ignoreQml) return; if (target == m_relativeRightTarget) return; - executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetRight", [this, target](){ + executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetRight", [this, target]() { m_relativeRightTarget = target; anchorRight(); }); emit relativeAnchorTargetRightChanged(); - } -void QmlAnchorBindingProxy::setRelativeAnchorTargetVertical(QmlAnchorBindingProxy::RelativeAnchorTarget target) +void QmlAnchorBindingProxy::setRelativeAnchorTargetVertical( + QmlAnchorBindingProxy::RelativeAnchorTarget target) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set relative anchor target vertical", + category()}; + if (m_ignoreQml) return; if (target == m_relativeVerticalTarget) return; - - executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetVertical", [this, target](){ + executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetVertical", [this, target]() { m_relativeVerticalTarget = target; anchorVertical(); }); @@ -533,15 +596,19 @@ void QmlAnchorBindingProxy::setRelativeAnchorTargetVertical(QmlAnchorBindingProx emit relativeAnchorTargetVerticalChanged(); } -void QmlAnchorBindingProxy::setRelativeAnchorTargetHorizontal(QmlAnchorBindingProxy::RelativeAnchorTarget target) +void QmlAnchorBindingProxy::setRelativeAnchorTargetHorizontal( + QmlAnchorBindingProxy::RelativeAnchorTarget target) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set relative anchor target horizontal", + category()}; + if (m_ignoreQml) return; if (target == m_relativeHorizontalTarget) return; - executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetHorizontal", [this, target](){ + executeInTransaction("QmlAnchorBindingProxy::setRelativeAnchorTargetHorizontal", [this, target]() { m_relativeHorizontalTarget = target; anchorHorizontal(); }); @@ -551,6 +618,8 @@ void QmlAnchorBindingProxy::setRelativeAnchorTargetHorizontal(QmlAnchorBindingPr QStringList QmlAnchorBindingProxy::possibleTargetItems() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy possible target items", category()}; + QStringList stringList; if (!m_qmlItemNode.isValid()) return stringList; @@ -563,7 +632,8 @@ QStringList QmlAnchorBindingProxy::possibleTargetItems() const //We currently have no instanceChildren(). //So we double check here if the instanceParents are equal. for (const QmlItemNode &node : std::as_const(itemList)) - if (node.isValid() && (node.instanceParent().modelNode() != m_qmlItemNode.instanceParent().modelNode())) + if (node.isValid() + && (node.instanceParent().modelNode() != m_qmlItemNode.instanceParent().modelNode())) itemList.removeAll(node); for (const QmlItemNode &itemNode : std::as_const(itemList)) { @@ -581,7 +651,9 @@ QStringList QmlAnchorBindingProxy::possibleTargetItems() const void QmlAnchorBindingProxy::registerDeclarativeType() { - qmlRegisterType("HelperWidgets",2,0,"AnchorBindingProxy"); + NanotraceHR::Tracer tracer{"qml anchor binding proxy register declarative type", category()}; + + qmlRegisterType("HelperWidgets", 2, 0, "AnchorBindingProxy"); } int QmlAnchorBindingProxy::indexOfPossibleTargetItem(const QString &targetName) const @@ -591,8 +663,9 @@ int QmlAnchorBindingProxy::indexOfPossibleTargetItem(const QString &targetName) void QmlAnchorBindingProxy::resetLayout() { + NanotraceHR::Tracer tracer{"qml anchor binding proxy reset layout", category()}; - executeInTransaction("QmlAnchorBindingProxy::resetLayout", [this](){ + executeInTransaction("QmlAnchorBindingProxy::resetLayout", [this]() { m_qmlItemNode.anchors().removeAnchors(); m_qmlItemNode.anchors().removeMargins(); @@ -602,15 +675,17 @@ void QmlAnchorBindingProxy::resetLayout() restoreProperty(modelNode(), "height"); }); - emit topAnchorChanged(); - emit bottomAnchorChanged(); - emit leftAnchorChanged(); - emit rightAnchorChanged(); - emit anchorsChanged(); - } + emit topAnchorChanged(); + emit bottomAnchorChanged(); + emit leftAnchorChanged(); + emit rightAnchorChanged(); + emit anchorsChanged(); +} void QmlAnchorBindingProxy::setBottomAnchor(bool anchor) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set bottom anchor", category()}; + if (!m_qmlItemNode.hasNodeParent()) return; @@ -639,6 +714,8 @@ void QmlAnchorBindingProxy::setBottomAnchor(bool anchor) void QmlAnchorBindingProxy::setLeftAnchor(bool anchor) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set left anchor", category()}; + if (!m_qmlItemNode.hasNodeParent()) return; @@ -668,6 +745,8 @@ void QmlAnchorBindingProxy::setLeftAnchor(bool anchor) void QmlAnchorBindingProxy::setRightAnchor(bool anchor) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set right anchor", category()}; + if (!m_qmlItemNode.hasNodeParent()) return; @@ -696,6 +775,8 @@ void QmlAnchorBindingProxy::setRightAnchor(bool anchor) } QRectF QmlAnchorBindingProxy::parentBoundingBox() { + NanotraceHR::Tracer tracer{"qml anchor binding proxy parent bounding box", category()}; + if (m_qmlItemNode.hasInstanceParent()) { if (m_qmlItemNode.instanceParentItem().instanceContentItemBoundingRect().isValid()) return m_qmlItemNode.instanceParentItem().instanceContentItemBoundingRect(); @@ -707,6 +788,8 @@ void QmlAnchorBindingProxy::setRightAnchor(bool anchor) QRectF QmlAnchorBindingProxy::boundingBox(const QmlItemNode &node) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy bounding box", category()}; + if (node.isValid()) return node.instanceTransformWithContentTransform().mapRect(node.instanceBoundingRect()); @@ -715,11 +798,16 @@ QRectF QmlAnchorBindingProxy::boundingBox(const QmlItemNode &node) QRectF QmlAnchorBindingProxy::transformedBoundingBox() { - return m_qmlItemNode.instanceTransformWithContentTransform().mapRect(m_qmlItemNode.instanceBoundingRect()); + NanotraceHR::Tracer tracer{"qml anchor binding proxy transformed bounding box", category()}; + + return m_qmlItemNode.instanceTransformWithContentTransform().mapRect( + m_qmlItemNode.instanceBoundingRect()); } void QmlAnchorBindingProxy::anchorTop() { + NanotraceHR::Tracer tracer{"qml anchor binding proxy anchor top", category()}; + m_locked = true; bool topTargetIsParent = m_topTarget == m_qmlItemNode.instanceParentItem(); @@ -746,6 +834,8 @@ void QmlAnchorBindingProxy::anchorTop() void QmlAnchorBindingProxy::anchorBottom() { + NanotraceHR::Tracer tracer{"qml anchor binding proxy anchor bottom", category()}; + m_locked = true; bool bottomTargetIsParent = m_bottomTarget == m_qmlItemNode.instanceParentItem(); @@ -772,6 +862,8 @@ void QmlAnchorBindingProxy::anchorBottom() void QmlAnchorBindingProxy::anchorLeft() { + NanotraceHR::Tracer tracer{"qml anchor binding proxy anchor left", category()}; + m_locked = true; bool leftTargetIsParent = m_leftTarget == m_qmlItemNode.instanceParentItem(); @@ -798,6 +890,8 @@ void QmlAnchorBindingProxy::anchorLeft() void QmlAnchorBindingProxy::anchorRight() { + NanotraceHR::Tracer tracer{"qml anchor binding proxy anchor right", category()}; + m_locked = true; bool rightTargetIsParent = m_rightTarget == m_qmlItemNode.instanceParentItem(); @@ -824,6 +918,8 @@ void QmlAnchorBindingProxy::anchorRight() void QmlAnchorBindingProxy::anchorVertical() { + NanotraceHR::Tracer tracer{"qml anchor binding proxy anchor vertical", category()}; + m_locked = true; if (m_relativeVerticalTarget == SameEdge) { m_qmlItemNode.anchors().setAnchor(AnchorLineVerticalCenter, m_verticalTarget, AnchorLineRight); @@ -839,6 +935,8 @@ void QmlAnchorBindingProxy::anchorVertical() void QmlAnchorBindingProxy::anchorHorizontal() { + NanotraceHR::Tracer tracer{"qml anchor binding proxy anchor horizontal", category()}; + m_locked = true; if (m_relativeHorizontalTarget == SameEdge) { m_qmlItemNode.anchors().setAnchor(AnchorLineHorizontalCenter, m_horizontalTarget, AnchorLineRight); @@ -853,6 +951,8 @@ void QmlAnchorBindingProxy::anchorHorizontal() QmlItemNode QmlAnchorBindingProxy::targetIdToNode(const QString &id) const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy target id to node", category()}; + QmlItemNode itemNode; if (m_qmlItemNode.isValid() && m_qmlItemNode.view()) { @@ -868,6 +968,8 @@ QmlItemNode QmlAnchorBindingProxy::targetIdToNode(const QString &id) const QString QmlAnchorBindingProxy::idForNode(const QmlItemNode &qmlItemNode) const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy id for node", category()}; + if (!qmlItemNode.modelNode().isValid()) return {}; @@ -882,11 +984,15 @@ QString QmlAnchorBindingProxy::idForNode(const QmlItemNode &qmlItemNode) const ModelNode QmlAnchorBindingProxy::modelNode() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy model node", category()}; + return m_qmlItemNode.modelNode(); } void QmlAnchorBindingProxy::setTopAnchor(bool anchor) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set top anchor", category()}; + if (!m_qmlItemNode.hasNodeParent()) return ; @@ -913,7 +1019,9 @@ void QmlAnchorBindingProxy::setTopAnchor(bool anchor) } void QmlAnchorBindingProxy::removeTopAnchor() { - executeInTransaction("QmlAnchorBindingProxy::removeTopAnchor", [this](){ + NanotraceHR::Tracer tracer{"qml anchor binding proxy remove top anchor", category()}; + + executeInTransaction("QmlAnchorBindingProxy::removeTopAnchor", [this]() { m_qmlItemNode.anchors().removeAnchor(AnchorLineTop); m_qmlItemNode.anchors().removeMargin(AnchorLineTop); @@ -925,7 +1033,9 @@ void QmlAnchorBindingProxy::removeTopAnchor() { void QmlAnchorBindingProxy::removeBottomAnchor() { - executeInTransaction("QmlAnchorBindingProxy::removeBottomAnchor", [this](){ + NanotraceHR::Tracer tracer{"qml anchor binding proxy remove bottom anchor", category()}; + + executeInTransaction("QmlAnchorBindingProxy::removeBottomAnchor", [this]() { m_qmlItemNode.anchors().removeAnchor(AnchorLineBottom); m_qmlItemNode.anchors().removeMargin(AnchorLineBottom); @@ -937,7 +1047,9 @@ void QmlAnchorBindingProxy::removeBottomAnchor() void QmlAnchorBindingProxy::removeLeftAnchor() { - executeInTransaction("QmlAnchorBindingProxy::removeLeftAnchor", [this](){ + NanotraceHR::Tracer tracer{"qml anchor binding proxy remove left anchor", category()}; + + executeInTransaction("QmlAnchorBindingProxy::removeLeftAnchor", [this]() { m_qmlItemNode.anchors().removeAnchor(AnchorLineLeft); m_qmlItemNode.anchors().removeMargin(AnchorLineLeft); @@ -949,7 +1061,9 @@ void QmlAnchorBindingProxy::removeLeftAnchor() void QmlAnchorBindingProxy::removeRightAnchor() { - executeInTransaction("QmlAnchorBindingProxy::removeRightAnchor", [this](){ + NanotraceHR::Tracer tracer{"qml anchor binding proxy remove right anchor", category()}; + + executeInTransaction("QmlAnchorBindingProxy::removeRightAnchor", [this]() { m_qmlItemNode.anchors().removeAnchor(AnchorLineRight); m_qmlItemNode.anchors().removeMargin(AnchorLineRight); @@ -961,6 +1075,8 @@ void QmlAnchorBindingProxy::removeRightAnchor() void QmlAnchorBindingProxy::setVerticalCentered(bool centered) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set vertical centered", category()}; + if (!m_qmlItemNode.hasNodeParent()) return ; @@ -995,6 +1111,8 @@ void QmlAnchorBindingProxy::setVerticalCentered(bool centered) void QmlAnchorBindingProxy::setHorizontalCentered(bool centered) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set horizontal centered", category()}; + if (!m_qmlItemNode.hasNodeParent()) return ; @@ -1028,46 +1146,65 @@ void QmlAnchorBindingProxy::setHorizontalCentered(bool centered) bool QmlAnchorBindingProxy::verticalCentered() { - return m_qmlItemNode.isValid() && m_qmlItemNode.anchors().instanceHasAnchor(AnchorLineVerticalCenter); + NanotraceHR::Tracer tracer{"qml anchor binding proxy vertical centered", category()}; + + return m_qmlItemNode.isValid() + && m_qmlItemNode.anchors().instanceHasAnchor(AnchorLineVerticalCenter); } QString QmlAnchorBindingProxy::topTarget() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy top target", category()}; + return idForNode(m_topTarget); } QString QmlAnchorBindingProxy::bottomTarget() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy bottom target", category()}; + return idForNode(m_bottomTarget); } QString QmlAnchorBindingProxy::leftTarget() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy left target", category()}; + return idForNode(m_leftTarget); } QString QmlAnchorBindingProxy::rightTarget() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy right target", category()}; + return idForNode(m_rightTarget); } QmlAnchorBindingProxy::RelativeAnchorTarget QmlAnchorBindingProxy::relativeAnchorTargetTop() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy relative anchor target top", category()}; + return m_relativeTopTarget; } QmlAnchorBindingProxy::RelativeAnchorTarget QmlAnchorBindingProxy::relativeAnchorTargetBottom() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy relative anchor target bottom", category()}; + return m_relativeBottomTarget; } QmlAnchorBindingProxy::RelativeAnchorTarget QmlAnchorBindingProxy::relativeAnchorTargetLeft() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy relative anchor target left", category()}; + return m_relativeLeftTarget; } QmlAnchorBindingProxy::RelativeAnchorTarget QmlAnchorBindingProxy::relativeAnchorTargetRight() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy relative anchor target right", category()}; + return m_relativeRightTarget; } @@ -1078,16 +1215,23 @@ QmlAnchorBindingProxy::RelativeAnchorTarget QmlAnchorBindingProxy::relativeAncho QmlAnchorBindingProxy::RelativeAnchorTarget QmlAnchorBindingProxy::relativeAnchorTargetHorizontal() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy relative anchor target horizontal", + category()}; + return m_relativeHorizontalTarget; } QString QmlAnchorBindingProxy::verticalTarget() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy vertical target", category()}; + return idForNode(m_verticalTarget); } QString QmlAnchorBindingProxy::horizontalTarget() const { + NanotraceHR::Tracer tracer{"qml anchor binding proxy horizontal target", category()}; + return idForNode(m_horizontalTarget); } @@ -1098,6 +1242,8 @@ bool QmlAnchorBindingProxy::horizontalCentered() void QmlAnchorBindingProxy::fill() { + NanotraceHR::Tracer tracer{"qml anchor binding proxy fill", category()}; + executeInTransaction("QmlAnchorBindingProxy::fill", [this](){ backupPropertyAndRemove(modelNode(), "x"); backupPropertyAndRemove(modelNode(), "y"); @@ -1122,6 +1268,8 @@ void QmlAnchorBindingProxy::fill() void QmlAnchorBindingProxy::centerIn() { + NanotraceHR::Tracer tracer{"qml anchor binding proxy center in", category()}; + executeInTransaction("QmlAnchorBindingProxy::centerIn", [this]() { backupPropertyAndRemove(modelNode(), "x"); backupPropertyAndRemove(modelNode(), "y"); @@ -1139,6 +1287,8 @@ void QmlAnchorBindingProxy::centerIn() void QmlAnchorBindingProxy::setDefaultAnchorTarget(const ModelNode &modelNode) { + NanotraceHR::Tracer tracer{"qml anchor binding proxy set default anchor target", category()}; + m_verticalTarget = modelNode; m_horizontalTarget = modelNode; m_topTarget = modelNode; diff --git a/src/plugins/qmldesigner/components/propertyeditor/qmlmaterialnodeproxy.cpp b/src/plugins/qmldesigner/components/propertyeditor/qmlmaterialnodeproxy.cpp index 16ef8604969..3249301fd41 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/qmlmaterialnodeproxy.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/qmlmaterialnodeproxy.cpp @@ -3,6 +3,8 @@ #include "qmlmaterialnodeproxy.h" +#include "propertyeditortracing.h" + #include #include #include @@ -14,6 +16,8 @@ namespace QmlDesigner { +static auto category = QmlDesigner::PropertyEditorTracing::category; + using namespace Qt::StringLiterals; static bool allMaterialTypesAre(const ModelNodes &materials, const QString &materialType) @@ -33,6 +37,8 @@ QmlMaterialNodeProxy::QmlMaterialNodeProxy() : QObject() , m_previewUpdateTimer(this) { + NanotraceHR::Tracer tracer{"qml material node proxy constructor", category()}; + m_previewUpdateTimer.setInterval(200); m_previewUpdateTimer.setSingleShot(true); m_previewUpdateTimer.callOnTimeout( @@ -43,6 +49,8 @@ QmlMaterialNodeProxy::~QmlMaterialNodeProxy() = default; void QmlMaterialNodeProxy::setup(const ModelNodes &editorNodes) { + NanotraceHR::Tracer tracer{"qml material node proxy setup", category()}; + QmlObjectNode objectNode = editorNodes.isEmpty() ? ModelNode{} : editorNodes.first(); const QmlObjectNode material = objectNode.metaInfo().isQtQuick3DMaterial() ? objectNode : QmlObjectNode{}; @@ -54,16 +62,22 @@ void QmlMaterialNodeProxy::setup(const ModelNodes &editorNodes) ModelNode QmlMaterialNodeProxy::materialNode() const { + NanotraceHR::Tracer tracer{"qml material node proxy material node", category()}; + return m_materialNode; } ModelNodes QmlMaterialNodeProxy::editorNodes() const { + NanotraceHR::Tracer tracer{"qml material node proxy editor nodes", category()}; + return m_editorNodes; } void QmlMaterialNodeProxy::setPossibleTypes(const QStringList &types) { + NanotraceHR::Tracer tracer{"qml material node proxy set possible types", category()}; + if (types == m_possibleTypes) return; @@ -75,6 +89,8 @@ void QmlMaterialNodeProxy::setPossibleTypes(const QStringList &types) void QmlMaterialNodeProxy::updatePossibleTypes() { + NanotraceHR::Tracer tracer{"qml material node proxy update possible types", category()}; + static const QStringList basicTypes{ "CustomMaterial", "DefaultMaterial", @@ -107,12 +123,16 @@ void QmlMaterialNodeProxy::updatePossibleTypes() void QmlMaterialNodeProxy::setCurrentType(const QString &type) { + NanotraceHR::Tracer tracer{"qml material node proxy set current type", category()}; + m_currentType = type.split('.').last(); updatePossibleTypeIndex(); } void QmlMaterialNodeProxy::toolBarAction(int action) { + NanotraceHR::Tracer tracer{"qml material node proxy tool bar action", category()}; + QTC_ASSERT(hasQuick3DImport(), return); switch (ToolBarAction(action)) { @@ -151,6 +171,8 @@ void QmlMaterialNodeProxy::toolBarAction(int action) void QmlMaterialNodeProxy::setPreviewEnv(const QString &envAndValue) { + NanotraceHR::Tracer tracer{"qml material node proxy set preview env", category()}; + if (envAndValue.isEmpty()) return; @@ -188,6 +210,8 @@ void QmlMaterialNodeProxy::setPreviewEnv(const QString &envAndValue) void QmlMaterialNodeProxy::setPreviewModel(const QString &modelStr) { + NanotraceHR::Tracer tracer{"qml material node proxy set preview model", category()}; + if (modelStr.isEmpty()) return; @@ -212,6 +236,9 @@ void QmlMaterialNodeProxy::setPreviewModel(const QString &modelStr) void QmlMaterialNodeProxy::handleAuxiliaryPropertyChanges() { + NanotraceHR::Tracer tracer{"qml material node proxy handle auxiliary property changes", + category()}; + if (!hasQuick3DImport()) return; @@ -220,11 +247,15 @@ void QmlMaterialNodeProxy::handleAuxiliaryPropertyChanges() void QmlMaterialNodeProxy::registerDeclarativeType() { + NanotraceHR::Tracer tracer{"qml material node proxy register declarative type", category()}; + qmlRegisterType("HelperWidgets", 2, 0, "QmlMaterialNodeProxy"); } void QmlMaterialNodeProxy::updatePossibleTypeIndex() { + NanotraceHR::Tracer tracer{"qml material node proxy update possible type index", category()}; + int newIndex = -1; if (!m_currentType.isEmpty()) newIndex = m_possibleTypes.indexOf(m_currentType); @@ -239,6 +270,8 @@ void QmlMaterialNodeProxy::updatePossibleTypeIndex() void QmlMaterialNodeProxy::updatePreviewModel() { + NanotraceHR::Tracer tracer{"qml material node proxy update preview model", category()}; + if (!hasQuick3DImport()) return; @@ -275,6 +308,8 @@ void QmlMaterialNodeProxy::updatePreviewModel() void QmlMaterialNodeProxy::setMaterialNode(const QmlObjectNode &material) { + NanotraceHR::Tracer tracer{"qml material node proxy set material node", category()}; + if (material == m_materialNode) return; @@ -284,16 +319,22 @@ void QmlMaterialNodeProxy::setMaterialNode(const QmlObjectNode &material) void QmlMaterialNodeProxy::setEditorNodes(const ModelNodes &editorNodes) { + NanotraceHR::Tracer tracer{"qml material node proxy set editor nodes", category()}; + m_editorNodes = editorNodes; } bool QmlMaterialNodeProxy::hasQuick3DImport() const { + NanotraceHR::Tracer tracer{"qml material node proxy has quick3d import", category()}; + return materialNode().isValid() && materialNode().model()->hasImport("QtQuick3D"_L1); } AbstractView *QmlMaterialNodeProxy::materialView() const { + NanotraceHR::Tracer tracer{"qml material node proxy material view", category()}; + return materialNode().view(); } diff --git a/src/plugins/qmldesigner/components/propertyeditor/qmlmodelnodeproxy.cpp b/src/plugins/qmldesigner/components/propertyeditor/qmlmodelnodeproxy.cpp index 1f51e37ec7e..f8a3a33c82a 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/qmlmodelnodeproxy.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/qmlmodelnodeproxy.cpp @@ -1,8 +1,9 @@ // Copyright (C) 2016 The Qt Company Ltd. // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 -#include "abstractview.h" #include "qmlmodelnodeproxy.h" +#include "abstractview.h" +#include "propertyeditortracing.h" #include @@ -17,18 +18,25 @@ namespace QmlDesigner { +static auto category = QmlDesigner::PropertyEditorTracing::category; + QmlModelNodeProxy::QmlModelNodeProxy(QObject *parent) : QObject(parent) { + NanotraceHR::Tracer tracer{"qml model node proxy constructor", category()}; } void QmlModelNodeProxy::setup(const ModelNode &node) { + NanotraceHR::Tracer tracer{"qml model node proxy setup", category()}; + setup(ModelNodes{node}); } void QmlModelNodeProxy::setup(const ModelNodes &editorNodes) { + NanotraceHR::Tracer tracer{"qml model node proxy setup with editor nodes", category()}; + m_qmlObjectNode = editorNodes.isEmpty() ? ModelNode{} : editorNodes.first(); m_editorNodes = editorNodes; @@ -39,11 +47,15 @@ void QmlModelNodeProxy::setup(const ModelNodes &editorNodes) void QmlModelNodeProxy::registerDeclarativeType() { - qmlRegisterType("HelperWidgets",2,0,"ModelNodeProxy"); + NanotraceHR::Tracer tracer{"qml model node proxy register declarative type", category()}; + + qmlRegisterType("HelperWidgets", 2, 0, "ModelNodeProxy"); } void QmlModelNodeProxy::emitSelectionToBeChanged() { + NanotraceHR::Tracer tracer{"qml model node proxy emit selection to be changed", category()}; + emit selectionToBeChanged(); } @@ -54,16 +66,22 @@ void QmlModelNodeProxy::emitSelectionChanged() void QmlModelNodeProxy::refresh() { + NanotraceHR::Tracer tracer{"qml model node proxy refresh", category()}; + emit refreshRequired(); } QmlObjectNode QmlModelNodeProxy::qmlObjectNode() const { + NanotraceHR::Tracer tracer{"qml model node proxy qml object node", category()}; + return m_qmlObjectNode; } ModelNode QmlModelNodeProxy::modelNode() const { + NanotraceHR::Tracer tracer{"qml model node proxy model node", category()}; + return m_qmlObjectNode.modelNode(); } @@ -74,11 +92,15 @@ ModelNodes QmlModelNodeProxy::editorNodes() const ModelNode QmlModelNodeProxy::singleSelectedNode() const { + NanotraceHR::Tracer tracer{"qml model node proxy single selected node", category()}; + return multiSelection() ? ModelNode{} : modelNode(); } bool QmlModelNodeProxy::multiSelection() const { + NanotraceHR::Tracer tracer{"qml model node proxy multi selection", category()}; + if (!m_qmlObjectNode.isValid()) return false; @@ -87,6 +109,8 @@ bool QmlModelNodeProxy::multiSelection() const QString QmlModelNodeProxy::nodeId() const { + NanotraceHR::Tracer tracer{"qml model node proxy node id", category()}; + if (!m_qmlObjectNode.isValid()) return {}; @@ -98,6 +122,8 @@ QString QmlModelNodeProxy::nodeId() const QString QmlModelNodeProxy::nodeObjectName() const { + NanotraceHR::Tracer tracer{"qml model node proxy node object name", category()}; + if (!m_qmlObjectNode.isValid()) return {}; @@ -109,6 +135,8 @@ QString QmlModelNodeProxy::nodeObjectName() const QString QmlModelNodeProxy::simplifiedTypeName() const { + NanotraceHR::Tracer tracer{"qml model node proxy simplified type name", category()}; + if (!m_qmlObjectNode.isValid()) return {}; @@ -125,6 +153,8 @@ static QList toInternalIdList(const QList &nodes) QList QmlModelNodeProxy::allChildren(int internalId) const { + NanotraceHR::Tracer tracer{"qml model node proxy all children", category()}; + ModelNode modelNode = m_qmlObjectNode.modelNode(); QTC_ASSERT(modelNode.isValid(), return {}); @@ -137,6 +167,8 @@ QList QmlModelNodeProxy::allChildren(int internalId) const QList QmlModelNodeProxy::allChildrenOfType(const QString &typeName, int internalId) const { + NanotraceHR::Tracer tracer{"qml model node proxy all children of type", category()}; + ModelNode modelNode = m_qmlObjectNode.modelNode(); QTC_ASSERT(modelNode.isValid(), return {}); @@ -149,6 +181,8 @@ QList QmlModelNodeProxy::allChildrenOfType(const QString &typeName, int int QString QmlModelNodeProxy::simplifiedTypeName(int internalId) const { + NanotraceHR::Tracer tracer{"qml model node proxy simplified type name", category()}; + ModelNode modelNode = m_qmlObjectNode.modelNode(); QTC_ASSERT(modelNode.isValid(), return {}); @@ -158,6 +192,8 @@ QString QmlModelNodeProxy::simplifiedTypeName(int internalId) const PropertyEditorSubSelectionWrapper *QmlModelNodeProxy::findWrapper(int internalId) const { + NanotraceHR::Tracer tracer{"qml model node proxy find wrapper", category()}; + for (const auto &item : qAsConst(m_subselection)) { if (item->modelNode().internalId() == internalId) return item.data(); @@ -168,6 +204,8 @@ PropertyEditorSubSelectionWrapper *QmlModelNodeProxy::findWrapper(int internalId PropertyEditorSubSelectionWrapper *QmlModelNodeProxy::registerSubSelectionWrapper(int internalId) { + NanotraceHR::Tracer tracer{"qml model node proxy register sub selection wrapper", category()}; + auto result = findWrapper(internalId); if (result) @@ -193,6 +231,8 @@ void QmlModelNodeProxy::createModelNode(int internalIdParent, const QString &typeName, const QString &requiredImport) { + NanotraceHR::Tracer tracer{"qml model node proxy create model node", category()}; + auto parentModelNode = m_qmlObjectNode.modelNode(); QTC_ASSERT(parentModelNode.isValid(), return ); @@ -231,6 +271,8 @@ void QmlModelNodeProxy::moveNode(int internalIdParent, int fromIndex, int toIndex) { + NanotraceHR::Tracer tracer{"qml model node proxy move node", category()}; + ModelNode modelNode = m_qmlObjectNode.modelNode(); QTC_ASSERT(modelNode.isValid(), return ); @@ -247,6 +289,8 @@ void QmlModelNodeProxy::moveNode(int internalIdParent, bool QmlModelNodeProxy::isInstanceOf(const QString &typeName, int internalId) const { + NanotraceHR::Tracer tracer{"qml model node proxy is instance of", category()}; + ModelNode modelNode = m_qmlObjectNode.modelNode(); QTC_ASSERT(modelNode.isValid(), return {}); @@ -261,6 +305,8 @@ bool QmlModelNodeProxy::isInstanceOf(const QString &typeName, int internalId) co void QmlModelNodeProxy::changeType(int internalId, const QString &typeName) { + NanotraceHR::Tracer tracer{"qml model node proxy change type", category()}; + QTC_ASSERT(m_qmlObjectNode.isValid(), return ); ModelNode node = m_qmlObjectNode.view()->modelNodeForInternalId(internalId); @@ -279,6 +325,8 @@ void QmlModelNodeProxy::changeType(int internalId, const QString &typeName) void QmlModelNodeProxy::handleInstancePropertyChanged(const ModelNode &modelNode, PropertyNameView propertyName) { + NanotraceHR::Tracer tracer{"qml model node proxy handle instance property changed", category()}; + const QmlObjectNode qmlObjectNode(modelNode); for (const auto &item : qAsConst(m_subselection)) { @@ -295,6 +343,8 @@ void QmlModelNodeProxy::handleInstancePropertyChanged(const ModelNode &modelNode void QmlModelNodeProxy::handleBindingPropertyChanged(const BindingProperty &property) { + NanotraceHR::Tracer tracer{"qml model node proxy handle binding property changed", category()}; + for (const auto &item : qAsConst(m_subselection)) { if (item && item->isRelevantModelNode(property.parentModelNode())) { QmlObjectNode objectNode(item->modelNode()); @@ -308,6 +358,8 @@ void QmlModelNodeProxy::handleBindingPropertyChanged(const BindingProperty &prop void QmlModelNodeProxy::handleVariantPropertyChanged(const VariantProperty &property) { + NanotraceHR::Tracer tracer{"qml model node proxy handle variant property changed", category()}; + for (const auto &item : qAsConst(m_subselection)) { if (item && item->isRelevantModelNode(property.parentModelNode())) { QmlObjectNode objectNode(item->modelNode()); @@ -321,6 +373,8 @@ void QmlModelNodeProxy::handleVariantPropertyChanged(const VariantProperty &prop void QmlModelNodeProxy::handlePropertiesRemoved(const AbstractProperty &property) { + NanotraceHR::Tracer tracer{"qml model node proxy handle properties removed", category()}; + for (const auto &item : qAsConst(m_subselection)) { if (item && item->isRelevantModelNode(property.parentModelNode())) { QmlObjectNode objectNode(item->modelNode()); @@ -332,11 +386,15 @@ void QmlModelNodeProxy::handlePropertiesRemoved(const AbstractProperty &property QList QmlModelNodeProxy::allChildren(const ModelNode &modelNode) const { + NanotraceHR::Tracer tracer{"qml model node proxy all children", category()}; + return toInternalIdList(modelNode.directSubModelNodes()); } QList QmlModelNodeProxy::allChildrenOfType(const ModelNode &modelNode, const QString &typeName) const { + NanotraceHR::Tracer tracer{"qml model node proxy all children of type", category()}; + QTC_ASSERT(modelNode.isValid(), return {}); NodeMetaInfo metaInfo = modelNode.model()->metaInfo(typeName.toUtf8()); diff --git a/src/plugins/qmldesigner/components/propertyeditor/qmltexturenodeproxy.cpp b/src/plugins/qmldesigner/components/propertyeditor/qmltexturenodeproxy.cpp index ee8dbad7617..c0d9fb2b621 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/qmltexturenodeproxy.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/qmltexturenodeproxy.cpp @@ -3,6 +3,8 @@ #include "qmltexturenodeproxy.h" +#include "propertyeditortracing.h" + #include #include #include @@ -13,14 +15,24 @@ namespace QmlDesigner { +static auto category = QmlDesigner::PropertyEditorTracing::category; + using namespace Qt::StringLiterals; -QmlTextureNodeProxy::QmlTextureNodeProxy() = default; +QmlTextureNodeProxy::QmlTextureNodeProxy() +{ + NanotraceHR::Tracer tracer{"qml texture node proxy constructor", category()}; +} -QmlTextureNodeProxy::~QmlTextureNodeProxy() = default; +QmlTextureNodeProxy::~QmlTextureNodeProxy() +{ + NanotraceHR::Tracer tracer{"qml texture node proxy destructor", category()}; +} void QmlTextureNodeProxy::setup(const QmlObjectNode &objectNode) { + NanotraceHR::Tracer tracer{"qml texture node proxy setup", category()}; + const QmlObjectNode texture = objectNode.metaInfo().isQtQuick3DTexture() ? objectNode : QmlObjectNode{}; @@ -30,6 +42,8 @@ void QmlTextureNodeProxy::setup(const QmlObjectNode &objectNode) void QmlTextureNodeProxy::updateSelectionDetails() { + NanotraceHR::Tracer tracer{"qml texture node proxy update selection details", category()}; + QScopeGuard falseSetter{ std::bind_front(&QmlTextureNodeProxy::setSelectedNodeAcceptsMaterial, this, false)}; @@ -46,6 +60,8 @@ void QmlTextureNodeProxy::updateSelectionDetails() void QmlTextureNodeProxy::handlePropertyChanged(const AbstractProperty &property) { + NanotraceHR::Tracer tracer{"qml texture node proxy handle property changed", category()}; + if (!textureNode()) return; @@ -65,31 +81,43 @@ void QmlTextureNodeProxy::handlePropertyChanged(const AbstractProperty &property void QmlTextureNodeProxy::handleBindingPropertyChanged(const BindingProperty &property) { + NanotraceHR::Tracer tracer{"qml texture node proxy handle binding property changed", category()}; + handlePropertyChanged(property); } void QmlTextureNodeProxy::handlePropertiesRemoved(const AbstractProperty &property) { + NanotraceHR::Tracer tracer{"qml texture node proxy handle properties removed", category()}; + handlePropertyChanged(property); } QmlObjectNode QmlTextureNodeProxy::textureNode() const { + NanotraceHR::Tracer tracer{"qml texture node proxy texture node", category()}; + return m_textureNode; } bool QmlTextureNodeProxy::hasTexture() const { + NanotraceHR::Tracer tracer{"qml texture node proxy has texture", category()}; + return textureNode().isValid(); } bool QmlTextureNodeProxy::selectedNodeAcceptsMaterial() const { + NanotraceHR::Tracer tracer{"qml texture node proxy selected node accepts material", category()}; + return m_selectedNodeAcceptsMaterial; } QString QmlTextureNodeProxy::resolveResourcePath(const QString &path) const { + NanotraceHR::Tracer tracer{"qml texture node proxy resolve resource path", category()}; + if (path.isEmpty()) return ":/propertyeditor/images/texture_default.png"; @@ -108,6 +136,8 @@ QString QmlTextureNodeProxy::resolveResourcePath(const QString &path) const void QmlTextureNodeProxy::toolbarAction(int action) { + NanotraceHR::Tracer tracer{"qml texture node proxy toolbar action", category()}; + if (!hasQuick3DImport()) return; @@ -146,11 +176,15 @@ void QmlTextureNodeProxy::toolbarAction(int action) void QmlTextureNodeProxy::registerDeclarativeType() { + NanotraceHR::Tracer tracer{"qml texture node proxy register declarative type", category()}; + qmlRegisterType("HelperWidgets", 2, 0, "QmlTextureNodeProxy"); } void QmlTextureNodeProxy::setTextureNode(const QmlObjectNode &node) { + NanotraceHR::Tracer tracer{"qml texture node proxy set texture node", category()}; + if (m_textureNode == node) return; m_textureNode = node; @@ -159,6 +193,9 @@ void QmlTextureNodeProxy::setTextureNode(const QmlObjectNode &node) void QmlTextureNodeProxy::setSelectedNodeAcceptsMaterial(bool value) { + NanotraceHR::Tracer tracer{"qml texture node proxy set selected node accepts material", + category()}; + if (m_selectedNodeAcceptsMaterial == value) return; m_selectedNodeAcceptsMaterial = value; @@ -167,6 +204,8 @@ void QmlTextureNodeProxy::setSelectedNodeAcceptsMaterial(bool value) bool QmlTextureNodeProxy::hasQuick3DImport() const { + NanotraceHR::Tracer tracer{"qml texture node proxy has quick3d import", category()}; + return textureNode().isValid() && textureNode().model()->hasImport("QtQuick3D"_L1); } diff --git a/src/plugins/qmldesigner/components/propertyeditor/quick2propertyeditorview.cpp b/src/plugins/qmldesigner/components/propertyeditor/quick2propertyeditorview.cpp index 87e92578520..f49cb23c566 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/quick2propertyeditorview.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/quick2propertyeditorview.cpp @@ -3,14 +3,7 @@ #include "quick2propertyeditorview.h" -#include -#include - #include "aligndistribute.h" -#include "annotationeditor/annotationeditor.h" -#include "assetimageprovider.h" -#include "bindingeditor/actioneditor.h" -#include "bindingeditor/bindingeditor.h" #include "colorpalettebackend.h" #include "fileresourcesmodel.h" #include "fontresourcesmodel.h" @@ -22,23 +15,37 @@ #include "listvalidator.h" #include "propertychangesmodel.h" #include "propertyeditorcontextobject.h" +#include "propertyeditordynamicpropertiesproxymodel.h" #include "propertyeditorqmlbackend.h" +#include "propertyeditortracing.h" #include "propertyeditorvalue.h" #include "propertymodel.h" #include "propertynamevalidator.h" #include "qmlanchorbindingproxy.h" #include "qmlmaterialnodeproxy.h" #include "qmltexturenodeproxy.h" -#include "richtexteditor/richtexteditorproxy.h" -#include "propertyeditordynamicpropertiesproxymodel.h" -#include "theme.h" #include "tooltip.h" +#include +#include + +#include +#include +#include +#include + +#include +#include + namespace QmlDesigner { +static auto category = QmlDesigner::PropertyEditorTracing::category; + Quick2PropertyEditorView::Quick2PropertyEditorView(AsynchronousImageCache &imageCache) : QQuickWidget() { + NanotraceHR::Tracer tracer{"quick2 property editor view constructor", category()}; + setObjectName(Constants::OBJECT_NAME_PROPERTY_EDITOR); setResizeMode(QQuickWidget::SizeRootObjectToView); Theme::setupTheme(engine()); diff --git a/src/plugins/qmldesigner/components/propertyeditor/tooltip.cpp b/src/plugins/qmldesigner/components/propertyeditor/tooltip.cpp index dd50e1ff171..3d3a5e25a0c 100644 --- a/src/plugins/qmldesigner/components/propertyeditor/tooltip.cpp +++ b/src/plugins/qmldesigner/components/propertyeditor/tooltip.cpp @@ -2,18 +2,27 @@ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 #include "tooltip.h" + +#include "propertyeditortracing.h" + #include #include #include #include #include +static auto category = QmlDesigner::PropertyEditorTracing::category; + Tooltip::Tooltip(QObject *parent) : QObject(parent) -{} +{ + NanotraceHR::Tracer tracer{"tooltip constructor", category()}; +} void Tooltip::showText(QQuickItem *item, const QPointF &pos, const QString &str) { + NanotraceHR::Tracer tracer{"tooltip show text", category()}; + if (!item || !item->window()) return; @@ -29,11 +38,15 @@ void Tooltip::showText(QQuickItem *item, const QPointF &pos, const QString &str) void Tooltip::hideText() { + NanotraceHR::Tracer tracer{"tooltip hide text", category()}; + QToolTip::hideText(); } void Tooltip::registerDeclarativeType() { + NanotraceHR::Tracer tracer{"tooltip register declarative type", category()}; + qmlRegisterType("StudioControls", 1, 0, "ToolTipExt"); qmlRegisterType("HelperWidgets", 2, 0, "Tooltip"); } diff --git a/src/plugins/qmldesigner/libs/designercore/CMakeLists.txt b/src/plugins/qmldesigner/libs/designercore/CMakeLists.txt index 531c923fb78..87913eccde6 100644 --- 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 + CONDITION ENABLE_PROJECT_STORAGE_TRACING OR ENABLE_SOURCE_PATH_STORAGE_TRACING OR ENABLE_IMAGE_CACHE_TRACING OR ENABLE_MODEL_TRACING OR ENABLE_FORM_EDITOR_TRACING OR ENABLE_PROPERTY_EDITOR_TRACING PUBLIC_DEPENDS Nanotrace PUBLIC_DEFINES ENABLE_QMLDESIGNER_TRACING