X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=gui%2Fapitracecall.cpp;h=aa60781aa9e9103bcd82ac1a99dad996a66f64f5;hb=f736a6252b691d8f10403a25a686360868b32e50;hp=180dab47d86da72dec5557ca8982e82a9b257951;hpb=df95ce0021270675feb2eed73d920f0d51b29e24;p=apitrace

diff --git a/gui/apitracecall.cpp b/gui/apitracecall.cpp
index 180dab4..aa60781 100644
--- a/gui/apitracecall.cpp
+++ b/gui/apitracecall.cpp
@@ -173,10 +173,21 @@ void VariantVisitor::visit(Trace::String *node)
 
 void VariantVisitor::visit(Trace::Enum *e)
 {
-    QVariant val = QVariant(e->sig->value);
+    ApiTraceEnumSignature *sig = 0;
 
-    m_variant = QVariant::fromValue(
-        ApiEnum(QString::fromStdString(e->sig->name), val));
+    if (m_trace) {
+        sig = m_trace->enumSignature(e->sig->id);
+    }
+    if (!sig) {
+        sig = new ApiTraceEnumSignature(
+            QString::fromStdString(e->sig->name),
+            QVariant(e->sig->value));
+        if (m_trace) {
+            m_trace->addEnumSignature(e->sig->id, sig);
+        }
+    }
+
+    m_variant = QVariant::fromValue(ApiEnum(sig));
 }
 
 void VariantVisitor::visit(Trace::Bitmask *bitmask)
@@ -214,25 +225,36 @@ void VariantVisitor::visit(Trace::Pointer *ptr)
 }
 
 
-ApiEnum::ApiEnum(const QString &name, const QVariant &val)
-    : m_name(name),
-      m_value(val)
+ApiEnum::ApiEnum(ApiTraceEnumSignature *sig)
+    : m_sig(sig)
 {
 }
 
 QString ApiEnum::toString() const
 {
-    return m_name;
+    if (m_sig) {
+        return m_sig->name();
+    }
+    Q_ASSERT(!"should never happen");
+    return QString();
 }
 
 QVariant ApiEnum::value() const
 {
-    return m_value;
+    if (m_sig) {
+        return m_sig->value();
+    }
+    Q_ASSERT(!"should never happen");
+    return QVariant();
 }
 
 QString ApiEnum::name() const
 {
-    return m_name;
+    if (m_sig) {
+        return m_sig->name();
+    }
+    Q_ASSERT(!"should never happen");
+    return QString();
 }
 
 unsigned long long ApiBitmask::value() const
@@ -353,7 +375,7 @@ void ApiStruct::init(const Trace::Struct *s)
 
     m_sig.name = QString::fromStdString(s->sig->name);
     for (unsigned i = 0; i < s->sig->num_members; ++i) {
-        VariantVisitor vis;
+        VariantVisitor vis(0);
         m_sig.memberNames.append(
             QString::fromStdString(s->sig->member_names[i]));
         s->members[i]->visit(vis);
@@ -396,8 +418,9 @@ void ApiArray::init(const Trace::Array *arr)
     if (!arr)
         return;
 
+    m_array.reserve(arr->values.size());
     for (int i = 0; i < arr->values.size(); ++i) {
-        VariantVisitor vis;
+        VariantVisitor vis(0);
         arr->values[i]->visit(vis);
 
         m_array.append(vis.variant());
@@ -511,74 +534,108 @@ const QList<ApiFramebuffer> & ApiTraceState::framebuffers() const
     return m_framebuffers;
 }
 
+ApiTraceCallSignature::ApiTraceCallSignature(const QString &name,
+                                             const QStringList &argNames)
+    : m_name(name),
+      m_argNames(argNames)
+{
+}
+
+ApiTraceCallSignature::~ApiTraceCallSignature()
+{
+}
+
+QUrl ApiTraceCallSignature::helpUrl() const
+{
+    return m_helpUrl;
+}
+
+void ApiTraceCallSignature::setHelpUrl(const QUrl &url)
+{
+    m_helpUrl = url;
+}
+
 ApiTraceEvent::ApiTraceEvent()
     : m_type(ApiTraceEvent::None),
+      m_hasBinaryData(false),
+      m_binaryDataIndex(0),
+      m_state(0),
       m_staticText(0)
 {
 }
 
 ApiTraceEvent::ApiTraceEvent(Type t)
     : m_type(t),
+      m_hasBinaryData(false),
+      m_binaryDataIndex(0),
+      m_state(0),
       m_staticText(0)
 {
 }
 
 ApiTraceEvent::~ApiTraceEvent()
 {
+    delete m_state;
     delete m_staticText;
 }
 
 QVariantMap ApiTraceEvent::stateParameters() const
 {
-    return m_state.parameters();
+    if (m_state) {
+        return m_state->parameters();
+    } else {
+        return QVariantMap();
+    }
 }
 
-ApiTraceState ApiTraceEvent::state() const
+ApiTraceState *ApiTraceEvent::state() const
 {
     return m_state;
 }
 
-void ApiTraceEvent::setState(const ApiTraceState &state)
+void ApiTraceEvent::setState(ApiTraceState *state)
 {
     m_state = state;
 }
 
-
-ApiTraceCall::ApiTraceCall()
+ApiTraceCall::ApiTraceCall(ApiTraceFrame *parentFrame, const Trace::Call *call)
     : ApiTraceEvent(ApiTraceEvent::Call),
-      m_hasBinaryData(false),
-      m_binaryDataIndex(0)
+      m_parentFrame(parentFrame)
 {
-}
+    ApiTrace *trace = parentTrace();
 
+    Q_ASSERT(trace);
 
-ApiTraceCall::ApiTraceCall(const Trace::Call *call)
-    : ApiTraceEvent(ApiTraceEvent::Call),
-      m_hasBinaryData(false),
-      m_binaryDataIndex(0)
-{
-    m_name = QString::fromStdString(call->sig->name);
     m_index = call->no;
 
-    QString argumentsText;
-    for (int i = 0; i < call->sig->num_args; ++i) {
-        m_argNames +=
-            QString::fromStdString(call->sig->arg_names[i]);
+    m_signature = trace->signature(call->sig->id);
+
+    if (!m_signature) {
+        QString name = QString::fromStdString(call->sig->name);
+        QStringList argNames;
+        argNames.reserve(call->sig->num_args);
+        for (int i = 0; i < call->sig->num_args; ++i) {
+            argNames += QString::fromStdString(call->sig->arg_names[i]);
+        }
+        m_signature = new ApiTraceCallSignature(name, argNames);
+        trace->addSignature(call->sig->id, m_signature);
     }
     if (call->ret) {
-        VariantVisitor retVisitor;
+        VariantVisitor retVisitor(trace);
         call->ret->visit(retVisitor);
         m_returnValue = retVisitor.variant();
     }
+    m_argValues.reserve(call->args.size());
     for (int i = 0; i < call->args.size(); ++i) {
-        VariantVisitor argVisitor;
+        VariantVisitor argVisitor(trace);
         call->args[i]->visit(argVisitor);
-        m_argValues += argVisitor.variant();
+        m_argValues.append(argVisitor.variant());
         if (m_argValues[i].type() == QVariant::ByteArray) {
             m_hasBinaryData = true;
             m_binaryDataIndex = i;
         }
     }
+    m_argValues.squeeze();
 }
 
 ApiTraceCall::~ApiTraceCall()
@@ -614,19 +671,19 @@ ApiTrace * ApiTraceCall::parentTrace() const
     return NULL;
 }
 
-QVariantList ApiTraceCall::originalValues() const
+QVector<QVariant> ApiTraceCall::originalValues() const
 {
     return m_argValues;
 }
 
-void ApiTraceCall::setEditedValues(const QVariantList &lst)
+void ApiTraceCall::setEditedValues(const QVector<QVariant> &lst)
 {
     ApiTrace *trace = parentTrace();
 
     m_editedValues = lst;
     //lets regenerate data
     m_richText = QString();
-    m_filterText = QString();
+    m_searchText = QString();
     delete m_staticText;
     m_staticText = 0;
 
@@ -639,7 +696,7 @@ void ApiTraceCall::setEditedValues(const QVariantList &lst)
     }
 }
 
-QVariantList ApiTraceCall::editedValues() const
+QVector<QVariant> ApiTraceCall::editedValues() const
 {
     return m_editedValues;
 }
@@ -651,12 +708,12 @@ bool ApiTraceCall::edited() const
 
 void ApiTraceCall::revert()
 {
-    setEditedValues(QVariantList());
+    setEditedValues(QVector<QVariant>());
 }
 
 void ApiTraceCall::setHelpUrl(const QUrl &url)
 {
-    m_helpUrl = url;
+    m_signature->setHelpUrl(url);
 }
 
 void ApiTraceCall::setParentFrame(ApiTraceFrame *frame)
@@ -676,15 +733,15 @@ int ApiTraceCall::index() const
 
 QString ApiTraceCall::name() const
 {
-    return m_name;
+    return m_signature->name();
 }
 
 QStringList ApiTraceCall::argNames() const
 {
-    return m_argNames;
+    return m_signature->argNames();
 }
 
-QVariantList ApiTraceCall::arguments() const
+QVector<QVariant> ApiTraceCall::arguments() const
 {
     if (m_editedValues.isEmpty())
         return m_argValues;
@@ -699,7 +756,7 @@ QVariant ApiTraceCall::returnValue() const
 
 QUrl ApiTraceCall::helpUrl() const
 {
-    return m_helpUrl;
+    return m_signature->helpUrl();
 }
 
 bool ApiTraceCall::hasBinaryData() const
@@ -717,11 +774,13 @@ QStaticText ApiTraceCall::staticText() const
     if (m_staticText && !m_staticText->text().isEmpty())
         return *m_staticText;
 
-    QVariantList argValues = arguments();
+    QVector<QVariant> argValues = arguments();
 
     QString richText = QString::fromLatin1(
-        "<span style=\"font-weight:bold\">%1</span>(").arg(m_name);
-    for (int i = 0; i < m_argNames.count(); ++i) {
+        "<span style=\"font-weight:bold\">%1</span>(").arg(
+            m_signature->name());
+    QStringList argNames = m_signature->argNames();
+    for (int i = 0; i < argNames.count(); ++i) {
         richText += QLatin1String("<span style=\"color:#0000ff\">");
         QString argText = apiVariantToString(argValues[i]);
 
@@ -739,7 +798,7 @@ QStaticText ApiTraceCall::staticText() const
             richText += argText;
         }
         richText += QLatin1String("</span>");
-        if (i < m_argNames.count() - 1)
+        if (i < argNames.count() - 1)
             richText += QLatin1String(", ");
     }
     richText += QLatin1String(")");
@@ -770,30 +829,32 @@ QString ApiTraceCall::toHtml() const
 
     m_richText = QLatin1String("<div class=\"call\">");
 
-    if (m_helpUrl.isEmpty()) {
+    QUrl helpUrl = m_signature->helpUrl();
+    if (helpUrl.isEmpty()) {
         m_richText += QString::fromLatin1(
             "%1) <span class=\"callName\">%2</span>(")
                       .arg(m_index)
-                      .arg(m_name);
+                      .arg(m_signature->name());
     } else {
         m_richText += QString::fromLatin1(
             "%1) <span class=\"callName\"><a href=\"%2\">%3</a></span>(")
                       .arg(m_index)
-                      .arg(m_helpUrl.toString())
-                      .arg(m_name);
+                      .arg(helpUrl.toString())
+                      .arg(m_signature->name());
     }
 
-    QVariantList argValues = arguments();
-    for (int i = 0; i < m_argNames.count(); ++i) {
+    QVector<QVariant> argValues = arguments();
+    QStringList argNames = m_signature->argNames();
+    for (int i = 0; i < argNames.count(); ++i) {
         m_richText +=
             QLatin1String("<span class=\"arg-name\">") +
-            m_argNames[i] +
+            argNames[i] +
             QLatin1String("</span>") +
             QLatin1Literal(" = ") +
             QLatin1Literal("<span class=\"arg-value\">") +
             apiVariantToString(argValues[i], true) +
             QLatin1Literal("</span>");
-        if (i < m_argNames.count() - 1)
+        if (i < argNames.count() - 1)
             m_richText += QLatin1String(", ");
     }
     m_richText += QLatin1String(")");
@@ -827,28 +888,29 @@ QString ApiTraceCall::toHtml() const
     return m_richText;
 }
 
-QString ApiTraceCall::filterText() const
+QString ApiTraceCall::searchText() const
 {
-    if (!m_filterText.isEmpty())
-        return m_filterText;
+    if (!m_searchText.isEmpty())
+        return m_searchText;
 
-    QVariantList argValues = arguments();
-    m_filterText = m_name + QLatin1Literal("(");
-    for (int i = 0; i < m_argNames.count(); ++i) {
-        m_filterText += m_argNames[i] +
+    QVector<QVariant> argValues = arguments();
+    m_searchText = m_signature->name() + QLatin1Literal("(");
+    QStringList argNames = m_signature->argNames();
+    for (int i = 0; i < argNames.count(); ++i) {
+        m_searchText += argNames[i] +
                         QLatin1Literal(" = ") +
                         apiVariantToString(argValues[i]);
-        if (i < m_argNames.count() - 1)
-            m_filterText += QLatin1String(", ");
+        if (i < argNames.count() - 1)
+            m_searchText += QLatin1String(", ");
     }
-    m_filterText += QLatin1String(")");
+    m_searchText += QLatin1String(")");
 
     if (m_returnValue.isValid()) {
-        m_filterText += QLatin1Literal(" = ") +
+        m_searchText += QLatin1Literal(" = ") +
                         apiVariantToString(m_returnValue);
     }
-    m_filterText.squeeze();
-    return m_filterText;
+    m_searchText.squeeze();
+    return m_searchText;
 }
 
 int ApiTraceCall::numChildren() const
@@ -856,9 +918,9 @@ int ApiTraceCall::numChildren() const
     return 0;
 }
 
-ApiTraceFrame::ApiTraceFrame()
+ApiTraceFrame::ApiTraceFrame(ApiTrace *parentTrace)
     : ApiTraceEvent(ApiTraceEvent::Frame),
-      m_parentTrace(0),
+      m_parentTrace(parentTrace),
       m_binaryDataSize(0)
 {
 }
@@ -908,11 +970,6 @@ ApiTrace * ApiTraceFrame::parentTrace() const
     return m_parentTrace;
 }
 
-void ApiTraceFrame::setParentTrace(ApiTrace *trace)
-{
-    m_parentTrace = trace;
-}
-
 void ApiTraceFrame::addCall(ApiTraceCall *call)
 {
     m_calls.append(call);
@@ -923,7 +980,7 @@ void ApiTraceFrame::addCall(ApiTraceCall *call)
     }
 }
 
-QList<ApiTraceCall*> ApiTraceFrame::calls() const
+QVector<ApiTraceCall*> ApiTraceFrame::calls() const
 {
     return m_calls;
 }
@@ -947,3 +1004,10 @@ int ApiTraceFrame::binaryDataSize() const
 {
     return m_binaryDataSize;
 }
+
+void ApiTraceFrame::setCalls(const QVector<ApiTraceCall*> &calls,
+                             quint64 binaryDataSize)
+{
+    m_calls = calls;
+    m_binaryDataSize = binaryDataSize;
+}