int currentCalls = m_calls.count();
int numNewCalls = 0;
foreach(ApiTraceFrame *frame, frames) {
- frame->setParentTrace(this);
+ Q_ASSERT(this == frame->parentTrace());
numNewCalls += frame->numChildren();
m_calls += frame->calls();
}
ApiTraceFrame *currentFrame = 0;
foreach(ApiTraceCall *apiCall, m_calls) {
if (!currentFrame) {
- currentFrame = new ApiTraceFrame();
- currentFrame->setParentTrace(this);
+ currentFrame = new ApiTraceFrame(this);
currentFrame->number = m_frames.count();
}
apiCall->setParentFrame(currentFrame);
return !m_errors.isEmpty();
}
+ApiTraceCallSignature * ApiTrace::signature(const QString &callName)
+{
+ return m_signatures[callName];
+}
+
+void ApiTrace::addSignature(ApiTraceCallSignature *signature)
+{
+ m_signatures.insert(signature->name(), signature);
+}
+
#include "apitrace.moc"
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_staticText(0)
m_state = state;
}
-
-ApiTraceCall::ApiTraceCall()
+ApiTraceCall::ApiTraceCall(ApiTraceFrame *parentFrame, const Trace::Call *call)
: ApiTraceEvent(ApiTraceEvent::Call),
+ m_parentFrame(parentFrame),
m_hasBinaryData(false),
m_binaryDataIndex(0)
{
-}
+ 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]);
+ QString name = QString::fromStdString(call->sig->name);
+ m_signature = trace->signature(name);
+
+ if (!m_signature) {
+ QStringList argNames;
+ 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(m_signature);
}
if (call->ret) {
VariantVisitor retVisitor;
void ApiTraceCall::setHelpUrl(const QUrl &url)
{
- m_helpUrl = url;
+ m_signature->setHelpUrl(url);
}
void ApiTraceCall::setParentFrame(ApiTraceFrame *frame)
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
QUrl ApiTraceCall::helpUrl() const
{
- return m_helpUrl;
+ return m_signature->helpUrl();
}
bool ApiTraceCall::hasBinaryData() const
QVariantList 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]);
richText += argText;
}
richText += QLatin1String("</span>");
- if (i < m_argNames.count() - 1)
+ if (i < argNames.count() - 1)
richText += QLatin1String(", ");
}
richText += QLatin1String(")");
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) {
+ 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(")");
return m_searchText;
QVariantList argValues = arguments();
- m_searchText = m_name + QLatin1Literal("(");
- for (int i = 0; i < m_argNames.count(); ++i) {
- m_searchText += m_argNames[i] +
+ 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)
+ if (i < argNames.count() - 1)
m_searchText += QLatin1String(", ");
}
m_searchText += QLatin1String(")");
return 0;
}
-ApiTraceFrame::ApiTraceFrame()
+ApiTraceFrame::ApiTraceFrame(ApiTrace *parentTrace)
: ApiTraceEvent(ApiTraceEvent::Frame),
- m_parentTrace(0),
+ m_parentTrace(parentTrace),
m_binaryDataSize(0)
{
}
return m_parentTrace;
}
-void ApiTraceFrame::setParentTrace(ApiTrace *trace)
-{
- m_parentTrace = trace;
-}
-
void ApiTraceFrame::addCall(ApiTraceCall *call)
{
m_calls.append(call);
};
Q_DECLARE_METATYPE(ApiTraceState);
+class ApiTraceCallSignature
+{
+public:
+ ApiTraceCallSignature(const QString &name,
+ const QStringList &argNames);
+ ~ApiTraceCallSignature();
+
+ QString name() const
+ {
+ return m_name;
+ }
+ QStringList argNames() const
+ {
+ return m_argNames;
+ }
+
+ QUrl helpUrl() const;
+ void setHelpUrl(const QUrl &url);
+
+private:
+ QString m_name;
+ QStringList m_argNames;
+ QUrl m_helpUrl;
+};
+
class ApiTraceEvent
{
public:
class ApiTraceCall : public ApiTraceEvent
{
public:
- ApiTraceCall();
- ApiTraceCall(const Trace::Call *tcall);
+ ApiTraceCall(ApiTraceFrame *parentFrame, const Trace::Call *tcall);
~ApiTraceCall();
int index() const;
int binaryDataIndex() const;
private:
int m_index;
- QString m_name;
- QStringList m_argNames;
+ ApiTraceCallSignature *m_signature;
QVariantList m_argValues;
QVariant m_returnValue;
ApiTraceFrame *m_parentFrame;
- QUrl m_helpUrl;
QVariantList m_editedValues;
class ApiTraceFrame : public ApiTraceEvent
{
public:
- ApiTraceFrame();
+ ApiTraceFrame(ApiTrace *parent);
int number;
bool isEmpty() const;
ApiTrace *parentTrace() const;
- void setParentTrace(ApiTrace *trace);
int numChildren() const;
QStaticText staticText() const;
static ApiTraceCall *
apiCallFromTraceCall(const Trace::Call *call,
- const QHash<QString, QUrl> &helpHash)
+ const QHash<QString, QUrl> &helpHash,
+ ApiTraceFrame *frame)
{
- ApiTraceCall *apiCall = new ApiTraceCall(call);
+ ApiTraceCall *apiCall = new ApiTraceCall(frame, call);
apiCall->setHelpUrl(helpHash.value(apiCall->name()));
return apiCall;
}
-LoaderThread::LoaderThread(QObject *parent)
+LoaderThread::LoaderThread(ApiTrace *parent)
: QThread(parent),
- m_frameMarker(ApiTrace::FrameMarker_SwapBuffers)
+ m_frameMarker(ApiTrace::FrameMarker_SwapBuffers),
+ m_trace(parent)
{
}
while (call) {
//std::cout << *call;
if (!currentFrame) {
- currentFrame = new ApiTraceFrame();
+ currentFrame = new ApiTraceFrame(m_trace);
currentFrame->number = frameCount;
++frameCount;
}
ApiTraceCall *apiCall =
- apiCallFromTraceCall(call, helpHash);
- apiCall->setParentFrame(currentFrame);
+ apiCallFromTraceCall(call, helpHash, currentFrame);
currentFrame->addCall(apiCall);
if (ApiTrace::isCallAFrameMarker(apiCall,
m_frameMarker)) {