+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
+{
+ if (m_state) {
+ return m_state->parameters();
+ } else {
+ return QVariantMap();
+ }
+}
+
+ApiTraceState *ApiTraceEvent::state() const
+{
+ return m_state;
+}
+
+void ApiTraceEvent::setState(ApiTraceState *state)
+{
+ m_state = state;
+}
+
+ApiTraceCall::ApiTraceCall(ApiTraceFrame *parentFrame,
+ TraceLoader *loader,
+ const trace::Call *call)
+ : ApiTraceEvent(ApiTraceEvent::Call),
+ 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;
+
+ m_signature = loader->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);
+ loader->addSignature(call->sig->id, m_signature);
+ }
+ if (call->ret) {
+ VariantVisitor retVisitor(loader);
+ call->ret->visit(retVisitor);
+ m_returnValue = retVisitor.variant();
+ }
+ m_argValues.reserve(call->args.size());
+ for (int i = 0; i < call->args.size(); ++i) {
+ if (call->args[i].value) {
+ VariantVisitor argVisitor(loader);
+ call->args[i].value->visit(argVisitor);
+ m_argValues.append(argVisitor.variant());
+ if (m_argValues[i].type() == QVariant::ByteArray) {
+ m_hasBinaryData = true;
+ m_binaryDataIndex = i;
+ }
+ } else {
+ m_argValues.append(QVariant());
+ }
+ }
+ m_argValues.squeeze();
+ m_flags = call->flags;
+ if (call->backtrace != NULL) {
+ QString qbacktrace;
+ 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);
+ }
+ if (frame->function != NULL) {
+ qbacktrace += QString("at %1() ").arg(frame->function);
+ }
+ if (frame->filename != NULL) {
+ qbacktrace += QString("at %1").arg(frame->filename);
+ if (frame->linenumber >= 0) {
+ qbacktrace += QString(":%1 ").arg(frame->linenumber);
+ }
+ }
+ else {
+ if (frame->offset >= 0) {
+ qbacktrace += QString("[0x%1]").arg(frame->offset, 0, 16);
+ }
+ }
+ qbacktrace += "\n";
+ }
+ this->setBacktrace(qbacktrace);
+ }
+}
+
+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
+{
+ return !m_error.isEmpty();
+}
+
+QString ApiTraceCall::error() const
+{
+ return m_error;
+}
+
+void ApiTraceCall::setError(const QString &msg)
+{
+ if (m_error != msg) {
+ m_error = msg;
+ m_richText = QString();
+ }
+}
+
+ApiTrace * ApiTraceCall::parentTrace() const
+{
+ if (m_parentFrame)
+ return m_parentFrame->parentTrace();
+ return NULL;
+}
+
+QVector<QVariant> ApiTraceCall::originalValues() const
+{
+ return m_argValues;
+}
+
+void ApiTraceCall::setEditedValues(const QVector<QVariant> &lst)
+{
+ ApiTrace *trace = parentTrace();
+
+ m_editedValues = lst;
+ //lets regenerate data
+ m_richText = QString();
+ m_searchText = QString();
+ delete m_staticText;
+ m_staticText = 0;
+
+ if (trace) {
+ if (!lst.isEmpty()) {
+ trace->callEdited(this);
+ } else {
+ trace->callReverted(this);
+ }