m_variant = QVariant::fromValue(ApiPointer(ptr->value));
}
+void VariantVisitor::visit(trace::Repr *repr)
+{
+ /* TODO: Preserve both the human and machine value */
+ repr->humanValue->visit(*this);
+}
+
ApiTraceEnumSignature::ApiTraceEnumSignature(const trace::EnumSig *sig)
{
for (const trace::EnumValue *it = sig->values;
QSize size(image[QLatin1String("__width__")].toInt(),
image[QLatin1String("__height__")].toInt());
QString cls = image[QLatin1String("__class__")].toString();
- QString type = image[QLatin1String("__type__")].toString();
- bool normalized =
- image[QLatin1String("__normalized__")].toBool();
- int numChannels =
- image[QLatin1String("__channels__")].toInt();
int depth =
image[QLatin1String("__depth__")].toInt();
QString formatName =
image[QLatin1String("__format__")].toString();
- Q_ASSERT(type == QLatin1String("uint8"));
- Q_ASSERT(normalized == true);
- Q_UNUSED(normalized);
-
QByteArray dataArray =
image[QLatin1String("__data__")].toByteArray();
tex.setSize(size);
tex.setDepth(depth);
tex.setFormatName(formatName);
- tex.setNumChannels(numChannels);
tex.setLabel(itr.key());
tex.contentsFromBase64(dataArray);
QSize size(buffer[QLatin1String("__width__")].toInt(),
buffer[QLatin1String("__height__")].toInt());
QString cls = buffer[QLatin1String("__class__")].toString();
- QString type = buffer[QLatin1String("__type__")].toString();
- bool normalized = buffer[QLatin1String("__normalized__")].toBool();
- int numChannels = buffer[QLatin1String("__channels__")].toInt();
int depth = buffer[QLatin1String("__depth__")].toInt();
QString formatName = buffer[QLatin1String("__format__")].toString();
- Q_ASSERT(type == QLatin1String("uint8"));
- Q_ASSERT(normalized == true);
- Q_UNUSED(normalized);
-
QByteArray dataArray =
buffer[QLatin1String("__data__")].toByteArray();
fbo.setSize(size);
fbo.setDepth(depth);
fbo.setFormatName(formatName);
- fbo.setNumChannels(numChannels);
fbo.setType(itr.key());
fbo.contentsFromBase64(dataArray);
m_framebuffers.append(fbo);
bool ApiTraceState::isEmpty() const
{
- return m_parameters.isEmpty();
+ return m_parameters.isEmpty() &&
+ m_shaderSources.isEmpty() &&
+ m_textures.isEmpty() &&
+ m_framebuffers.isEmpty();
}
const QList<ApiTexture> & ApiTraceState::textures() const
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;
}
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()
+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();
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;
return m_binaryDataIndex;
}
+QString ApiTraceCall::backtrace() const
+{
+ return m_backtrace;
+}
+
+void ApiTraceCall::setBacktrace(QString backtrace)
+{
+ m_backtrace = backtrace;
+}
+
QStaticText ApiTraceCall::staticText() const
{
if (m_staticText && !m_staticText->text().isEmpty())
int ApiTraceCall::numChildren() const
{
- return 0;
+ return m_children.count();
}
bool ApiTraceCall::contains(const QString &str,
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
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;
}
int ApiTraceFrame::callIndex(ApiTraceCall *call) const
{
- return m_calls.indexOf(call);
+ return m_children.indexOf(call);
}
bool ApiTraceFrame::isEmpty() 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;
return m_loaded;
}
-void ApiTraceFrame::setLoaded(bool l)
-{
- m_loaded = l;
-}
-
void ApiTraceFrame::setNumChildren(int num)
{
m_callsToLoad = num;