QString
apiVariantToString(const QVariant &variant, bool multiLine)
{
+ if (variant.isNull()) {
+ return QLatin1String("?");
+ }
+
if (variant.userType() == QVariant::Double) {
return QString::number(variant.toFloat());
}
return variant.value<ApiBitmask>().toString();
}
if (variant.canConvert<ApiStruct>()) {
- return variant.value<ApiStruct>().toString();
+ return variant.value<ApiStruct>().toString(multiLine);
}
if (variant.canConvert<ApiArray>()) {
- return variant.value<ApiArray>().toString();
+ return variant.value<ApiArray>().toString(multiLine);
}
if (variant.canConvert<ApiEnum>()) {
return variant.value<ApiEnum>().toString();
}
-void VariantVisitor::visit(Trace::Null *)
+void VariantVisitor::visit(trace::Null *)
{
m_variant = QVariant::fromValue(ApiPointer(0));
}
-void VariantVisitor::visit(Trace::Bool *node)
+void VariantVisitor::visit(trace::Bool *node)
{
m_variant = QVariant(node->value);
}
-void VariantVisitor::visit(Trace::SInt *node)
+void VariantVisitor::visit(trace::SInt *node)
{
m_variant = QVariant(node->value);
}
-void VariantVisitor::visit(Trace::UInt *node)
+void VariantVisitor::visit(trace::UInt *node)
{
m_variant = QVariant(node->value);
}
-void VariantVisitor::visit(Trace::Float *node)
+void VariantVisitor::visit(trace::Float *node)
{
m_variant = QVariant(node->value);
}
-void VariantVisitor::visit(Trace::String *node)
+void VariantVisitor::visit(trace::String *node)
{
m_variant = QVariant(QString::fromStdString(node->value));
}
-void VariantVisitor::visit(Trace::Enum *e)
+void VariantVisitor::visit(trace::Enum *e)
{
ApiTraceEnumSignature *sig = 0;
m_variant = QVariant::fromValue(ApiEnum(sig));
}
-void VariantVisitor::visit(Trace::Bitmask *bitmask)
+void VariantVisitor::visit(trace::Bitmask *bitmask)
{
m_variant = QVariant::fromValue(ApiBitmask(bitmask));
}
-void VariantVisitor::visit(Trace::Struct *str)
+void VariantVisitor::visit(trace::Struct *str)
{
m_variant = QVariant::fromValue(ApiStruct(str));
}
-void VariantVisitor::visit(Trace::Array *array)
+void VariantVisitor::visit(trace::Array *array)
{
m_variant = QVariant::fromValue(ApiArray(array));
}
-void VariantVisitor::visit(Trace::Blob *blob)
+void VariantVisitor::visit(trace::Blob *blob)
{
- //XXX
- //FIXME: this is a nasty hack. Trace::Blob's can't
- // delete the contents in the destructor because
- // the data is being used by other calls. We piggy back
- // on that assumption and don't deep copy the data. If
- // Blob's will start deleting the data we will need to
- // start deep copying it or switch to using something like
- // Boost's shared_ptr or Qt's QSharedPointer to handle it
- blob->toPointer(true);
- QByteArray barray = QByteArray::fromRawData(blob->buf, blob->size);
+ QByteArray barray = QByteArray(blob->buf, blob->size);
m_variant = QVariant(barray);
}
-void VariantVisitor::visit(Trace::Pointer *ptr)
+void VariantVisitor::visit(trace::Pointer *ptr)
{
m_variant = QVariant::fromValue(ApiPointer(ptr->value));
}
return QLatin1String("NULL");
}
-ApiBitmask::ApiBitmask(const Trace::Bitmask *bitmask)
+ApiBitmask::ApiBitmask(const trace::Bitmask *bitmask)
: m_value(0)
{
init(bitmask);
}
-void ApiBitmask::init(const Trace::Bitmask *bitmask)
+void ApiBitmask::init(const trace::Bitmask *bitmask)
{
if (!bitmask)
return;
m_value = bitmask->value;
- for (const Trace::BitmaskFlag *it = bitmask->sig->flags;
+ for (const trace::BitmaskFlag *it = bitmask->sig->flags;
it != bitmask->sig->flags + bitmask->sig->num_flags; ++it) {
assert(it->value);
QPair<QString, unsigned long long> pair;
return str;
}
-ApiStruct::ApiStruct(const Trace::Struct *s)
+ApiStruct::ApiStruct(const trace::Struct *s)
{
init(s);
}
-QString ApiStruct::toString() const
+QString ApiStruct::toString(bool multiLine) const
{
QString str;
for (unsigned i = 0; i < m_members.count(); ++i) {
str += m_sig.memberNames[i] %
QLatin1Literal(" = ") %
- apiVariantToString(m_members[i]);
+ apiVariantToString(m_members[i], multiLine);
if (i < m_members.count() - 1)
str += QLatin1String(", ");
}
return str;
}
-void ApiStruct::init(const Trace::Struct *s)
+void ApiStruct::init(const trace::Struct *s)
{
if (!s)
return;
}
}
-ApiArray::ApiArray(const Trace::Array *arr)
+ApiArray::ApiArray(const trace::Array *arr)
{
init(arr);
}
return m_array;
}
-QString ApiArray::toString() const
+QString ApiArray::toString(bool multiLine) const
{
QString str;
str += QLatin1String("[");
for(int i = 0; i < m_array.count(); ++i) {
const QVariant &var = m_array[i];
- str += apiVariantToString(var);
+ str += apiVariantToString(var, multiLine);
if (i < m_array.count() - 1)
str += QLatin1String(", ");
}
return str;
}
-void ApiArray::init(const Trace::Array *arr)
+void ApiArray::init(const trace::Array *arr)
{
if (!arr)
return;
image[QLatin1String("__normalized__")].toBool();
int numChannels =
image[QLatin1String("__channels__")].toInt();
+ int depth =
+ image[QLatin1String("__depth__")].toInt();
Q_ASSERT(type == QLatin1String("uint8"));
Q_ASSERT(normalized == true);
ApiTexture tex;
tex.setSize(size);
+ tex.setDepth(depth);
tex.setNumChannels(numChannels);
tex.setLabel(itr.key());
tex.contentsFromBase64(dataArray);
QString type = buffer[QLatin1String("__type__")].toString();
bool normalized = buffer[QLatin1String("__normalized__")].toBool();
int numChannels = buffer[QLatin1String("__channels__")].toInt();
+ int depth = buffer[QLatin1String("__depth__")].toInt();
Q_ASSERT(type == QLatin1String("uint8"));
Q_ASSERT(normalized == true);
ApiFramebuffer fbo;
fbo.setSize(size);
+ fbo.setDepth(depth);
fbo.setNumChannels(numChannels);
fbo.setType(itr.key());
fbo.contentsFromBase64(dataArray);
ApiTraceCall::ApiTraceCall(ApiTraceFrame *parentFrame,
TraceLoader *loader,
- const Trace::Call *call)
+ const trace::Call *call)
: ApiTraceEvent(ApiTraceEvent::Call),
m_parentFrame(parentFrame)
{
}
m_argValues.reserve(call->args.size());
for (int i = 0; i < call->args.size(); ++i) {
- VariantVisitor argVisitor(loader);
- call->args[i]->visit(argVisitor);
- m_argValues.append(argVisitor.variant());
- if (m_argValues[i].type() == QVariant::ByteArray) {
- m_hasBinaryData = true;
- m_binaryDataIndex = i;
+ if (call->args[i]) {
+ VariantVisitor argVisitor(loader);
+ call->args[i]->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();