Implement grouping of calls.

[apitrace] / gui / apitracecall.cpp

diff --git a/gui/apitracecall.cpp b/gui/apitracecall.cpp
index c3a1deebed5bc01e4ef2cb13956ef06c0cc0a387..79876351a12807039e76bd5aba16c9a3dfb1d591 100644 (file)
--- a/gui/apitracecall.cpp
+++ b/gui/apitracecall.cpp
@@ -648,7 +648,31 @@ ApiTraceCall::ApiTraceCall(ApiTraceFrame *parentFrame,
                            TraceLoader *loader,
                            const trace::Call *call)
     : ApiTraceEvent(ApiTraceEvent::Call),
-      m_parentFrame(parentFrame)
+      m_parentFrame(parentFrame),
+      m_parentCall(0)
+{
+    loadData(loader, call);
+}
+
+ApiTraceCall::ApiTraceCall(ApiTraceCall *parentCall,
+                           TraceLoader *loader,
+                           const trace::Call *call)
+    : ApiTraceEvent(ApiTraceEvent::Call),
+      m_parentFrame(parentCall->parentFrame()),
+      m_parentCall(parentCall)
+{
+    loadData(loader, call);
+}
+
+
+ApiTraceCall::~ApiTraceCall()
+{
+}
+
+
+void
+ApiTraceCall::loadData(TraceLoader *loader,
+                       const trace::Call *call)
 {
     m_index = call->no;
 
@@ -687,29 +711,23 @@ ApiTraceCall::ApiTraceCall(ApiTraceFrame *parentFrame,
     m_flags = call->flags;
     if (call->backtrace != NULL) {
         QString qbacktrace;
-        for (int i = 0; i < call->backtrace->frames.size(); i++) {
-            trace::StackFrame* frame = call->backtrace->frames[i];
-            trace::String* tmp;
-            tmp = frame->module;
-            if (tmp != NULL) {
-                qbacktrace += QString("%1 ").arg(tmp->toString());
+        for (int i = 0; i < call->backtrace->size(); i++) {
+            const trace::StackFrame * frame = (*call->backtrace)[i];
+            if (frame->module != NULL) {
+                qbacktrace += QString("%1 ").arg(frame->module);
             }
-            tmp = frame->function;
-            if (tmp != NULL) {
-                qbacktrace += QString("at %1() ").arg(tmp->toString());
+            if (frame->function != NULL) {
+                qbacktrace += QString("at %1() ").arg(frame->function);
             }
-            tmp = frame->filename;
-            if (tmp != NULL) {
-                qbacktrace += QString("at %1").arg(tmp->toString());
-                tmp = frame->linenumber;
-                if (tmp != NULL) {
-                    qbacktrace += QString(":%1 ").arg(tmp->toString());
+            if (frame->filename != NULL) {
+                qbacktrace += QString("at %1").arg(frame->filename);
+                if (frame->linenumber >= 0) {
+                    qbacktrace += QString(":%1 ").arg(frame->linenumber);
                 }
             }
             else {
-                tmp = frame->offset;
-                if (tmp != NULL) {
-                    qbacktrace += QString("[%1]").arg(tmp->toString());
+                if (frame->offset >= 0) {
+                    qbacktrace += QString("[0x%1]").arg(frame->offset, 0, 16);
                 }
             }
             qbacktrace += "\n";
@@ -718,10 +736,46 @@ ApiTraceCall::ApiTraceCall(ApiTraceFrame *parentFrame,
     }
 }
 
-ApiTraceCall::~ApiTraceCall()
+ApiTraceCall *
+ApiTraceCall::parentCall() const
+{
+    return m_parentCall;
+}
+
+
+ApiTraceEvent *
+ApiTraceCall::parentEvent() const
+{
+    if (m_parentCall)
+        return m_parentCall;
+    else
+        return m_parentFrame;
+}
+
+QVector<ApiTraceCall*>
+ApiTraceCall::children() const
 {
+    return m_children;
 }
 
+void
+ApiTraceCall::addChild(ApiTraceCall *call)
+{
+    m_children.append(call);
+}
+
+
+int
+ApiTraceCall::callIndex(ApiTraceCall *call) const
+{
+    return m_children.indexOf(call);
+}
+
+void
+ApiTraceCall::finishedAddingChildren()
+{
+    m_children.squeeze();
+}
 
 bool ApiTraceCall::hasError() const
 {
@@ -826,6 +880,15 @@ QVector<QVariant> ApiTraceCall::arguments() const
         return m_editedValues;
 }
 
+ApiTraceEvent *
+ApiTraceCall::eventAtRow(int row) const
+{
+    if (row < m_children.count())
+        return m_children.value(row);
+    else
+        return NULL;
+}
+
 QVariant ApiTraceCall::returnValue() const
 {
     return m_returnValue;
@@ -1017,7 +1080,7 @@ QString ApiTraceCall::searchText() const
 
 int ApiTraceCall::numChildren() const
 {
-    return 0;
+    return m_children.count();
 }
 
 bool ApiTraceCall::contains(const QString &str,
@@ -1080,22 +1143,17 @@ QStaticText ApiTraceFrame::staticText() const
 
 int ApiTraceFrame::numChildren() const
 {
-    return m_calls.count();
+    return m_children.count();
 }
 
-ApiTrace * ApiTraceFrame::parentTrace() const
+int ApiTraceFrame::numTotalCalls() const
 {
-    return m_parentTrace;
+    return m_calls.count();
 }
 
-void ApiTraceFrame::addCall(ApiTraceCall *call)
+ApiTrace * ApiTraceFrame::parentTrace() const
 {
-    m_calls.append(call);
-    if (call->hasBinaryData()) {
-        QByteArray data =
-            call->arguments()[call->binaryDataIndex()].toByteArray();
-        m_binaryDataSize += data.size();
-    }
+    return m_parentTrace;
 }
 
 QVector<ApiTraceCall*> ApiTraceFrame::calls() const
@@ -1103,9 +1161,12 @@ QVector<ApiTraceCall*> ApiTraceFrame::calls() const
     return m_calls;
 }
 
-ApiTraceCall * ApiTraceFrame::call(int idx) const
+ApiTraceEvent * ApiTraceFrame::eventAtRow(int row) const
 {
-    return m_calls.value(idx);
+    if (row < m_children.count())
+        return m_children.value(row);
+    else
+        return NULL;
 }
 
 
@@ -1122,7 +1183,7 @@ ApiTraceCall * ApiTraceFrame::callWithIndex(int index) const
 
 int ApiTraceFrame::callIndex(ApiTraceCall *call) const
 {
-    return m_calls.indexOf(call);
+    return m_children.indexOf(call);
 }
 
 bool ApiTraceFrame::isEmpty() const
@@ -1139,9 +1200,11 @@ int ApiTraceFrame::binaryDataSize() const
     return m_binaryDataSize;
 }
 
-void ApiTraceFrame::setCalls(const QVector<ApiTraceCall*> &calls,
+void ApiTraceFrame::setCalls(const QVector<ApiTraceCall*> &children,
+                             const QVector<ApiTraceCall*> &calls,
                              quint64 binaryDataSize)
 {
+    m_children = children;
     m_calls = calls;
     m_binaryDataSize = binaryDataSize;
     m_loaded = true;
@@ -1154,11 +1217,6 @@ bool ApiTraceFrame::isLoaded() const
     return m_loaded;
 }
 
-void ApiTraceFrame::setLoaded(bool l)
-{
-    m_loaded = l;
-}
-
 void ApiTraceFrame::setNumChildren(int num)
 {
     m_callsToLoad = num;