" font-weight:bold;\n"
// text shadow looks great but doesn't work well in qtwebkit 4.7
" /*text-shadow: 0px 2px 3px #555;*/\n"
- " font-size: 1.2em;\n"
+ " font-size: 1.1em;\n"
"}\n"
".arg-name {\n"
" border: 1px solid rgb(238,206,0);\n"
QString
apiVariantToString(const QVariant &variant, bool multiLine)
{
- if (variant.userType() == QVariant::Double) {
+ if (variant.isNull()) {
+ return QLatin1String("?");
+ }
+
+ if (variant.userType() == QMetaType::Float) {
return QString::number(variant.toFloat());
}
+ if (variant.userType() == QVariant::Double) {
+ return QString::number(variant.toDouble());
+ }
if (variant.userType() == QVariant::ByteArray) {
if (variant.toByteArray().size() < 1024) {
int bytes = variant.toByteArray().size();
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)
{
m_variant = QVariant(node->value);
}
-void VariantVisitor::visit(Trace::SInt *node)
+void VariantVisitor::visit(trace::UInt *node)
{
m_variant = QVariant(node->value);
}
-void VariantVisitor::visit(Trace::UInt *node)
+void VariantVisitor::visit(trace::Float *node)
{
m_variant = QVariant(node->value);
}
-void VariantVisitor::visit(Trace::Float *node)
+void VariantVisitor::visit(trace::Double *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;
sig = m_loader->enumSignature(e->sig->id);
}
if (!sig) {
- sig = new ApiTraceEnumSignature(
- QString::fromStdString(e->sig->name),
- QVariant(e->sig->value));
+ sig = new ApiTraceEnumSignature(e->sig);
if (m_loader) {
m_loader->addEnumSignature(e->sig->id, sig);
}
}
- m_variant = QVariant::fromValue(ApiEnum(sig));
+ m_variant = QVariant::fromValue(ApiEnum(sig, e->value));
}
-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));
}
+ApiTraceEnumSignature::ApiTraceEnumSignature(const trace::EnumSig *sig)
+{
+ for (const trace::EnumValue *it = sig->values;
+ it != sig->values + sig->num_values; ++it) {
+ QPair<QString, signed long long> pair;
+
+ pair.first = QString::fromStdString(it->name);
+ pair.second = it->value;
+
+ m_names.append(pair);
+ }
+}
+
+QString ApiTraceEnumSignature::name(signed long long value) const
+{
+ for (ValueList::const_iterator it = m_names.begin();
+ it != m_names.end(); ++it) {
+ if (value == it->second) {
+ return it->first;
+ }
+ }
+ return QString::fromLatin1("%1").arg(value);
+}
-ApiEnum::ApiEnum(ApiTraceEnumSignature *sig)
- : m_sig(sig)
+ApiEnum::ApiEnum(ApiTraceEnumSignature *sig, signed long long value)
+ : m_sig(sig), m_value(value)
{
}
QString ApiEnum::toString() const
{
if (m_sig) {
- return m_sig->name();
+ return m_sig->name(m_value);
}
Q_ASSERT(!"should never happen");
return QString();
QVariant ApiEnum::value() const
{
if (m_sig) {
- return m_sig->value();
+ return QVariant::fromValue(m_value);
}
Q_ASSERT(!"should never happen");
return QVariant();
QString ApiEnum::name() const
{
if (m_sig) {
- return m_sig->name();
+ return m_sig->name(m_value);
}
Q_ASSERT(!"should never happen");
return QString();
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();
+ QString formatName =
+ image[QLatin1String("__format__")].toString();
Q_ASSERT(type == QLatin1String("uint8"));
Q_ASSERT(normalized == true);
ApiTexture tex;
tex.setSize(size);
+ tex.setDepth(depth);
+ tex.setFormatName(formatName);
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();
+ QString formatName = buffer[QLatin1String("__format__")].toString();
Q_ASSERT(type == QLatin1String("uint8"));
Q_ASSERT(normalized == true);
ApiFramebuffer fbo;
fbo.setSize(size);
+ fbo.setDepth(depth);
+ fbo.setFormatName(formatName);
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].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;
}
ApiTraceCall::~ApiTraceCall()
return m_returnValue;
}
+trace::CallFlags ApiTraceCall::flags() const
+{
+ return m_flags;
+}
+
QUrl ApiTraceCall::helpUrl() const
{
return m_signature->helpUrl();
if (!m_richText.isEmpty())
return m_richText;
- m_richText = QLatin1String("<div class=\"call\">");
+ m_richText += QLatin1String("<div class=\"call\">");
+
+ m_richText +=
+ QString::fromLatin1("%1) ")
+ .arg(m_index);
+ QString parentTip;
+ if (m_parentFrame) {
+ parentTip =
+ QString::fromLatin1("Frame %1")
+ .arg(m_parentFrame->number);
+ }
QUrl helpUrl = m_signature->helpUrl();
if (helpUrl.isEmpty()) {
m_richText += QString::fromLatin1(
- "%1) <span class=\"callName\">%2</span>(")
- .arg(m_index)
+ "<span class=\"callName\" title=\"%1\">%2</span>(")
+ .arg(parentTip)
.arg(m_signature->name());
} else {
m_richText += QString::fromLatin1(
- "%1) <span class=\"callName\"><a href=\"%2\">%3</a></span>(")
- .arg(m_index)
+ "<span class=\"callName\" title=\"%1\"><a href=\"%2\">%3</a></span>(")
+ .arg(parentTip)
.arg(helpUrl.toString())
.arg(m_signature->name());
}