QmlDesigner: Add qml timeline tracing

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

src/plugins/qmldesigner/qmltools/qmltimeline.cpp

@@ -17,32 +17,46 @@
 
 namespace QmlDesigner {
 
-QmlTimeline::QmlTimeline() = default;
+static auto category = ModelTracing::category;
 
-QmlTimeline::QmlTimeline(const ModelNode &modelNode) : QmlModelNodeFacade(modelNode)
+bool QmlTimeline::isValid(SL sl) const
 {
-
+    return isValidQmlTimeline(modelNode(), sl);
 }
 
-bool QmlTimeline::isValid() const
+bool QmlTimeline::isValidQmlTimeline(const ModelNode &modelNode, SL sl)
 {
-    return isValidQmlTimeline(modelNode());
+    using NanotraceHR::keyValue;
-}
+    NanotraceHR::Tracer tracer{"qml timeline is valid",
+                               category(),
+                               keyValue("model node", modelNode),
+                               keyValue("caller location", sl)};
 
-bool QmlTimeline::isValidQmlTimeline(const ModelNode &modelNode)
-{
     return isValidQmlModelNodeFacade(modelNode) && modelNode.metaInfo().isQtQuickTimelineTimeline();
 }
 
-void QmlTimeline::destroy()
+void QmlTimeline::destroy(SL sl)
 {
-    Q_ASSERT(isValid());
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline destroy",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("caller location", sl)};
     modelNode().destroy();
 }
 
 QmlTimelineKeyframeGroup QmlTimeline::keyframeGroup(const ModelNode &node,
-                                                    PropertyNameView propertyName)
+                                                    PropertyNameView propertyName,
+                                                    SL sl)
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline keyframe group",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("target node", node),
+                               keyValue("property name", propertyName),
+                               keyValue("caller location", sl)};
+
     if (isValid()) {
         addKeyframeGroupIfNotExists(node, propertyName);
         for (const ModelNode &childNode : modelNode().defaultNodeListProperty().toModelNodeList()) {
@@ -60,8 +74,16 @@ QmlTimelineKeyframeGroup QmlTimeline::keyframeGroup(const ModelNode &node,
     return QmlTimelineKeyframeGroup(); //not found
 }
 
-bool QmlTimeline::hasTimeline(const ModelNode &node, PropertyNameView propertyName)
+bool QmlTimeline::hasTimeline(const ModelNode &node, PropertyNameView propertyName, SL sl)
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline has timeline",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("target node", node),
+                               keyValue("property name", propertyName),
+                               keyValue("caller location", sl)};
+
     if (isValid()) {
         for (const ModelNode &childNode : modelNode().defaultNodeListProperty().toModelNodeList()) {
             if (QmlTimelineKeyframeGroup::isValidQmlTimelineKeyframeGroup(childNode)) {
@@ -78,39 +100,76 @@ bool QmlTimeline::hasTimeline(const ModelNode &node, PropertyNameView propertyNa
     return false;
 }
 
-qreal QmlTimeline::startKeyframe() const
+qreal QmlTimeline::startKeyframe(SL sl) const
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline start keyframe",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("caller location", sl)};
+
     if (isValid())
         return QmlObjectNode(modelNode()).modelValue("startFrame").toReal();
     return 0;
 }
 
-qreal QmlTimeline::endKeyframe() const
+qreal QmlTimeline::endKeyframe(SL sl) const
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline end keyframe",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("caller location", sl)};
+
     if (isValid())
         return QmlObjectNode(modelNode()).modelValue("endFrame").toReal();
     return 0;
 }
 
-qreal QmlTimeline::currentKeyframe() const
+qreal QmlTimeline::currentKeyframe(SL sl) const
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline current keyframe",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("caller location", sl)};
+
     if (isValid())
         return QmlObjectNode(modelNode()).instanceValue("currentFrame").toReal();
     return 0;
 }
 
-qreal QmlTimeline::duration() const
+qreal QmlTimeline::duration(SL sl) const
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline duration",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("caller location", sl)};
+
     return endKeyframe() - startKeyframe();
 }
 
-bool QmlTimeline::isEnabled() const
+bool QmlTimeline::isEnabled(SL sl) const
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline is enabled",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("caller location", sl)};
+
     return QmlObjectNode(modelNode()).modelValue("enabled").toBool();
 }
 
-qreal QmlTimeline::minActualKeyframe(const ModelNode &target) const
+qreal QmlTimeline::minActualKeyframe(const ModelNode &target, SL sl) const
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline min actual keyframe",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("target node", target),
+                               keyValue("caller location", sl)};
+
     qreal min = std::numeric_limits<double>::max();
 
     for (const QmlTimelineKeyframeGroup &frames : keyframeGroupsForTarget(target)) {
@@ -122,8 +181,15 @@ qreal QmlTimeline::minActualKeyframe(const ModelNode &target) const
     return min;
 }
 
-qreal QmlTimeline::maxActualKeyframe(const ModelNode &target) const
+qreal QmlTimeline::maxActualKeyframe(const ModelNode &target, SL sl) const
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline max actual keyframe",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("target node", target),
+                               keyValue("caller location", sl)};
+
     qreal max = std::numeric_limits<double>::min();
 
     for (const QmlTimelineKeyframeGroup &frames : keyframeGroupsForTarget(target)) {
@@ -135,21 +201,42 @@ qreal QmlTimeline::maxActualKeyframe(const ModelNode &target) const
     return max;
 }
 
-void QmlTimeline::moveAllKeyframes(const ModelNode &target, qreal offset)
+void QmlTimeline::moveAllKeyframes(const ModelNode &target, qreal offset, SL sl)
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline move all keyframes",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("target node", target),
+                               keyValue("offset", offset),
+                               keyValue("caller location", sl)};
+
     for (QmlTimelineKeyframeGroup &frames : keyframeGroupsForTarget(target))
         frames.moveAllKeyframes(offset);
 
 }
 
-void QmlTimeline::scaleAllKeyframes(const ModelNode &target, qreal factor)
+void QmlTimeline::scaleAllKeyframes(const ModelNode &target, qreal factor, SL sl)
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline scale all keyframes",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("target node", target),
+                               keyValue("factor", factor),
+                               keyValue("caller location", sl)};
+
     for (QmlTimelineKeyframeGroup &frames : keyframeGroupsForTarget(target))
         frames.scaleAllKeyframes(factor);
 }
 
-QList<ModelNode> QmlTimeline::allTargets() const
+QList<ModelNode> QmlTimeline::allTargets(SL sl) const
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline all targets",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("caller location", sl)};
     QList<ModelNode> result;
     if (isValid()) {
         for (const ModelNode &childNode : modelNode().defaultNodeListProperty().toModelNodeList()) {
@@ -163,38 +250,67 @@ QList<ModelNode> QmlTimeline::allTargets() const
     return result;
 }
 
-QList<QmlTimelineKeyframeGroup> QmlTimeline::keyframeGroupsForTarget(const ModelNode &target) const
+QList<QmlTimelineKeyframeGroup> QmlTimeline::keyframeGroupsForTarget(const ModelNode &target, SL sl) const
 {
-     QList<QmlTimelineKeyframeGroup> result;
+    using NanotraceHR::keyValue;
-     if (isValid()) {
+    NanotraceHR::Tracer tracer{"qml timeline keyframe groups for target",
-         for (const ModelNode &childNode : modelNode().defaultNodeListProperty().toModelNodeList()) {
+                               category(),
-             if (QmlTimelineKeyframeGroup::isValidQmlTimelineKeyframeGroup(childNode)) {
+                               keyValue("model node", *this),
-                 const QmlTimelineKeyframeGroup frames(childNode);
+                               keyValue("target node", target),
-                 if (frames.target() == target)
+                               keyValue("caller location", sl)};
-                     result.append(frames);
+
-             }
+    QList<QmlTimelineKeyframeGroup> result;
-         }
+    if (isValid()) {
-     }
+        for (const ModelNode &childNode : modelNode().defaultNodeListProperty().toModelNodeList()) {
+            if (QmlTimelineKeyframeGroup::isValidQmlTimelineKeyframeGroup(childNode)) {
+                const QmlTimelineKeyframeGroup frames(childNode);
+                if (frames.target() == target)
+                    result.append(frames);
+            }
+        }
+    }
      return result;
 }
 
-void QmlTimeline::destroyKeyframesForTarget(const ModelNode &target)
+void QmlTimeline::destroyKeyframesForTarget(const ModelNode &target, SL sl)
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline destroy keyframes for target",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("target node", target),
+                               keyValue("caller location", sl)};
+
     for (QmlTimelineKeyframeGroup frames : keyframeGroupsForTarget(target))
         frames.destroy();
 }
 
 void QmlTimeline::removeKeyframesForTargetAndProperty(const ModelNode &target,
-                                                      PropertyNameView propertyName)
+                                                      PropertyNameView propertyName,
+                                                      SL sl)
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline remove keyframes for target and property",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("target node", target),
+                               keyValue("property name", propertyName),
+                               keyValue("caller location", sl)};
+
     for (QmlTimelineKeyframeGroup frames : keyframeGroupsForTarget(target)) {
         if (frames.propertyName() == propertyName)
             frames.destroy();
     }
 }
 
-bool QmlTimeline::hasActiveTimeline(AbstractView *view)
+bool QmlTimeline::hasActiveTimeline(AbstractView *view, SL sl)
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline has active timeline",
+                               category(),
+                               keyValue("view", view),
+                               keyValue("caller location", sl)};
+
     if (view && view->isAttached()) {
         if (!view->model()->hasImport(Import::createLibraryImport("QtQuick.Timeline", "1.0"), true, true))
             return false;
@@ -205,16 +321,30 @@ bool QmlTimeline::hasActiveTimeline(AbstractView *view)
     return false;
 }
 
-bool QmlTimeline::isRecording() const
+bool QmlTimeline::isRecording(SL sl) const
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline is recording",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("caller location", sl)};
+
     QTC_ASSERT(isValid(), return false);
 
     return modelNode().hasAuxiliaryData(recordProperty);
 }
 
-void QmlTimeline::toogleRecording(bool record) const
+void QmlTimeline::toogleRecording(bool record, SL sl) const
 {
-    QTC_ASSERT(isValid(), return);
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline toggle recording",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("recording", record),
+                               keyValue("caller location", sl)};
+
+    if (!isValid())
+        return;
 
     if (!record) {
         if (isRecording())
@@ -224,9 +354,16 @@ void QmlTimeline::toogleRecording(bool record) const
     }
 }
 
-void QmlTimeline::resetGroupRecording() const
+void QmlTimeline::resetGroupRecording(SL sl) const
 {
-    QTC_ASSERT(isValid(), return);
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline reset group recording",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("caller location", sl)};
+
+    if (!isValid())
+        return;
 
     for (const ModelNode &childNode : modelNode().defaultNodeListProperty().toModelNodeList()) {
         if (QmlTimelineKeyframeGroup::isValidQmlTimelineKeyframeGroup(childNode)) {
@@ -253,8 +390,16 @@ void QmlTimeline::addKeyframeGroupIfNotExists(const ModelNode &node, PropertyNam
     }
 }
 
-bool QmlTimeline::hasKeyframeGroup(const ModelNode &node, PropertyNameView propertyName) const
+bool QmlTimeline::hasKeyframeGroup(const ModelNode &node, PropertyNameView propertyName, SL sl) const
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline has keyframe group",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("target node", node),
+                               keyValue("property name", propertyName),
+                               keyValue("caller location", sl)};
+
     for (const QmlTimelineKeyframeGroup &frames : allKeyframeGroups()) {
         if (frames.target().isValid()
                 && frames.target() == node
@@ -265,8 +410,15 @@ bool QmlTimeline::hasKeyframeGroup(const ModelNode &node, PropertyNameView prope
     return false;
 }
 
-bool QmlTimeline::hasKeyframeGroupForTarget(const ModelNode &node) const
+bool QmlTimeline::hasKeyframeGroupForTarget(const ModelNode &node, SL sl) const
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline has keyframe group for target",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("target node", node),
+                               keyValue("caller location", sl)};
+
     if (!isValid())
         return false;
 
@@ -278,8 +430,16 @@ bool QmlTimeline::hasKeyframeGroupForTarget(const ModelNode &node) const
     return false;
 }
 
-void QmlTimeline::insertKeyframe(const ModelNode &target, PropertyNameView propertyName)
+void QmlTimeline::insertKeyframe(const ModelNode &target, PropertyNameView propertyName, SL sl)
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml timeline insert keyframe",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("target node", target),
+                               keyValue("property name", propertyName),
+                               keyValue("caller location", sl)};
+
     ModelNode targetNode = target;
     QmlTimelineKeyframeGroup timelineFrames(keyframeGroup(targetNode, propertyName));
 

src/plugins/qmldesigner/qmltools/qmltimeline.h

@@ -16,46 +16,54 @@ class QMLDESIGNER_EXPORT QmlTimeline final : public QmlModelNodeFacade
 {
 
 public:
-    QmlTimeline();
+    QmlTimeline() = default;
-    QmlTimeline(const ModelNode &modelNode);
 
-    bool isValid() const;
+    QmlTimeline(const ModelNode &modelNode)
+        : QmlModelNodeFacade(modelNode)
+    {}
+
+    bool isValid(SL sl = {}) const;
     explicit operator bool() const { return isValid(); }
-    static bool isValidQmlTimeline(const ModelNode &modelNode);
-    void destroy();
 
-    QmlTimelineKeyframeGroup keyframeGroup(const ModelNode &modelNode, PropertyNameView propertyName);
+    static bool isValidQmlTimeline(const ModelNode &modelNode, SL sl = {});
-    bool hasTimeline(const ModelNode &modelNode, PropertyNameView propertyName);
+    void destroy(SL sl = {});
 
-    qreal startKeyframe() const;
+    QmlTimelineKeyframeGroup keyframeGroup(const ModelNode &modelNode,
-    qreal endKeyframe() const;
+                                           PropertyNameView propertyName,
-    qreal currentKeyframe() const;
+                                           SL sl = {});
-    qreal duration() const;
+    bool hasTimeline(const ModelNode &modelNode, PropertyNameView propertyName, SL sl = {});
 
-    bool isEnabled() const;
+    qreal startKeyframe(SL sl = {}) const;
+    qreal endKeyframe(SL sl = {}) const;
+    qreal currentKeyframe(SL sl = {}) const;
+    qreal duration(SL sl = {}) const;
 
-    qreal minActualKeyframe(const ModelNode &target) const;
+    bool isEnabled(SL sl = {}) const;
-    qreal maxActualKeyframe(const ModelNode &target) const;
 
-    void moveAllKeyframes(const ModelNode &target, qreal offset);
+    qreal minActualKeyframe(const ModelNode &target, SL sl = {}) const;
-    void scaleAllKeyframes(const ModelNode &target, qreal factor);
+    qreal maxActualKeyframe(const ModelNode &target, SL sl = {}) const;
 
-    QList<ModelNode> allTargets() const;
+    void moveAllKeyframes(const ModelNode &target, qreal offset, SL sl = {});
-    QList<QmlTimelineKeyframeGroup> keyframeGroupsForTarget(const ModelNode &target) const;
+    void scaleAllKeyframes(const ModelNode &target, qreal factor, SL sl = {});
-    void destroyKeyframesForTarget(const ModelNode &target);
 
-    void removeKeyframesForTargetAndProperty(const ModelNode &target, PropertyNameView propertyName);
+    QList<ModelNode> allTargets(SL sl = {}) const;
+    QList<QmlTimelineKeyframeGroup> keyframeGroupsForTarget(const ModelNode &target, SL sl = {}) const;
+    void destroyKeyframesForTarget(const ModelNode &target, SL sl = {});
 
-    static bool hasActiveTimeline(AbstractView *view);
+    void removeKeyframesForTargetAndProperty(const ModelNode &target,
+                                             PropertyNameView propertyName,
+                                             SL sl = {});
 
-    bool isRecording() const;
+    static bool hasActiveTimeline(AbstractView *view, SL sl = {});
-    void toogleRecording(bool b) const;
 
-    void resetGroupRecording() const;
+    bool isRecording(SL sl = {}) const;
-    bool hasKeyframeGroup(const ModelNode &node, PropertyNameView propertyName) const;
+    void toogleRecording(bool b, SL sl = {}) const;
-    bool hasKeyframeGroupForTarget(const ModelNode &node) const;
 
-    void insertKeyframe(const ModelNode &target, PropertyNameView propertyName);
+    void resetGroupRecording(SL sl = {}) const;
+    bool hasKeyframeGroup(const ModelNode &node, PropertyNameView propertyName, SL sl = {}) const;
+    bool hasKeyframeGroupForTarget(const ModelNode &node, SL sl = {}) const;
+
+    void insertKeyframe(const ModelNode &target, PropertyNameView propertyName, SL sl = {});
 
 private:
     void addKeyframeGroupIfNotExists(const ModelNode &node, PropertyNameView propertyName);