" 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));
}
+void VariantVisitor::visit(trace::Repr *repr)
+{
+ /* TODO: Preserve both the human and machine value */
+ repr->humanValue->visit(*this);
+}
-ApiEnum::ApiEnum(ApiTraceEnumSignature *sig)
- : m_sig(sig)
+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, 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;
pair.first = QString::fromStdString(it->name);
QString str;
unsigned long long value = m_value;
bool first = true;
- for (Signature::const_iterator it = m_sig.begin();
- value != 0 && it != m_sig.end(); ++it) {
- Q_ASSERT(it->second);
- if ((value & it->second) == it->second) {
+ for (Signature::const_iterator it = m_sig.begin(); it != m_sig.end(); ++it) {
+ Q_ASSERT(it->second || first);
+ if ((it->second && (value & it->second) == it->second) ||
+ (!it->second && value == 0)) {
if (!first) {
str += QLatin1String(" | ");
}
value &= ~it->second;
first = false;
}
+ if (value == 0) {
+ break;
+ }
}
if (value || first) {
if (!first) {
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;
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();
-
- Q_ASSERT(type == QLatin1String("uint8"));
- Q_ASSERT(normalized == true);
- Q_UNUSED(normalized);
+ int depth =
+ image[QLatin1String("__depth__")].toInt();
+ QString formatName =
+ image[QLatin1String("__format__")].toString();
QByteArray dataArray =
image[QLatin1String("__data__")].toByteArray();
ApiTexture tex;
tex.setSize(size);
- tex.setNumChannels(numChannels);
+ tex.setDepth(depth);
+ tex.setFormatName(formatName);
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();
-
- Q_ASSERT(type == QLatin1String("uint8"));
- Q_ASSERT(normalized == true);
- Q_UNUSED(normalized);
+ int depth = buffer[QLatin1String("__depth__")].toInt();
+ QString formatName = buffer[QLatin1String("__format__")].toString();
QByteArray dataArray =
buffer[QLatin1String("__data__")].toByteArray();
ApiFramebuffer fbo;
fbo.setSize(size);
- fbo.setNumChannels(numChannels);
+ fbo.setDepth(depth);
+ fbo.setFormatName(formatName);
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
return m_framebuffers;
}
+ApiFramebuffer ApiTraceState::colorBuffer() const
+{
+ foreach (ApiFramebuffer fbo, m_framebuffers) {
+ if (fbo.type() == QLatin1String("GL_BACK")) {
+ return fbo;
+ }
+ }
+ foreach (ApiFramebuffer fbo, m_framebuffers) {
+ if (fbo.type() == QLatin1String("GL_FRONT")) {
+ return fbo;
+ }
+ }
+ return ApiFramebuffer();
+}
+
+
ApiTraceCallSignature::ApiTraceCallSignature(const QString &name,
const QStringList &argNames)
: m_name(name),
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()
void ApiTraceCall::setError(const QString &msg)
{
if (m_error != msg) {
- ApiTrace *trace = parentTrace();
m_error = msg;
m_richText = QString();
- if (trace)
- trace->callError(this);
}
}
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());
}
m_parentTrace(parentTrace),
m_binaryDataSize(0),
m_loaded(false),
- m_callsToLoad(0)
+ m_callsToLoad(0),
+ m_lastCallIndex(0)
{
}
+ApiTraceFrame::~ApiTraceFrame()
+{
+ qDeleteAll(m_calls);
+}
+
QStaticText ApiTraceFrame::staticText() const
{
if (m_staticText && !m_staticText->text().isEmpty())
return *m_staticText;
- QString richText;
+ QString richText = QObject::tr(
+ "<span style=\"font-weight:bold\">Frame %1</span>"
+ " "
+ "<span style=\"font-style:italic;font-size:small;font-weight:lighter;\"> "
+ "(%2 calls)</span>")
+ .arg(number)
+ .arg(m_loaded ? m_calls.count() : m_callsToLoad);
//mark the frame if it uploads more than a meg a frame
if (m_binaryDataSize > (1024*1024)) {
richText =
QObject::tr(
- "<span style=\"font-weight:bold;\">"
- "Frame %1</span>"
+ "%1"
"<span style=\"font-style:italic;\">"
" (%2MB)</span>")
- .arg(number)
+ .arg(richText)
.arg(double(m_binaryDataSize / (1024.*1024.)), 0, 'g', 2);
- } else {
- richText =
- QObject::tr(
- "<span style=\"font-weight:bold\">Frame %1</span>")
- .arg(number);
}
if (!m_staticText)
m_calls = calls;
m_binaryDataSize = binaryDataSize;
m_loaded = true;
+ delete m_staticText;
+ m_staticText = 0;
}
-bool ApiTraceFrame::loaded() const
+bool ApiTraceFrame::isLoaded() const
{
return m_loaded;
}
}
return 0;
}
+
+void ApiTraceFrame::setLastCallIndex(unsigned index)
+{
+ m_lastCallIndex = index;
+}
+
+unsigned ApiTraceFrame::lastCallIndex() const
+{
+ if (m_loaded && !m_calls.isEmpty()) {
+ return m_calls.last()->index();
+ } else {
+ return m_lastCallIndex;
+ }
+}
+
+void ApiTraceFrame::setThumbnail(const QImage & thumbnail)
+{
+ m_thumbnail = thumbnail;
+}
+
+const QImage & ApiTraceFrame::thumbnail() const
+{
+ return m_thumbnail;
+}
projects / apitrace / blobdiff