#include "trace_model.hpp"
#include <QDebug>
+#include <QObject>
ApiPointer::ApiPointer(int val)
: m_value(val)
if (variant.userType() == QVariant::Double) {
return QString::number(variant.toFloat());
}
+ if (variant.userType() == QVariant::ByteArray) {
+ if (variant.toByteArray().size() < 1024) {
+ int bytes = variant.toByteArray().size();
+ return QObject::tr("[binary data, size = %1 bytes]").arg(bytes);
+ } else {
+ float kb = variant.toByteArray().size()/1024.;
+ return QObject::tr("[binary data, size = %1 kb]").arg(kb);
+ }
+ }
if (variant.userType() < QVariant::UserType) {
return variant.toString();
m_array.append(vis.variant());
}
}
+
+QStaticText ApiTraceCall::staticText() const
+{
+ if (!m_staticText.text().isEmpty())
+ return m_staticText;
+
+ QString richText = QString::fromLatin1("<span style=\"font-weight:bold\">%1</span>(").arg(name);
+ for (int i = 0; i < argNames.count(); ++i) {
+ richText += QLatin1String("<span style=\"color:#0000ff\">");
+ QString argText = apiVariantToString(argValues[i]);
+
+ //if arguments are really long (e.g. shader text), cut them
+ // and elide it
+ if (argText.length() > 40) {
+ QString shortened = argText.mid(0, 40);
+ shortened[argText.length() - 5] = '.';
+ shortened[argText.length() - 4] = '.';
+ shortened[argText.length() - 3] = '.';
+ shortened[argText.length() - 2] = argText[argText.length() - 2];
+ shortened[argText.length() - 1] = argText[argText.length() - 1];
+ richText += shortened;
+ } else {
+ richText += argText;
+ }
+ richText += QLatin1String("</span>");
+ if (i < argNames.count() - 1)
+ richText += QString::fromLatin1(", ");
+ }
+ richText += QLatin1String(")");
+ if (returnValue.isValid()) {
+ richText += QLatin1String(" = ");
+ richText += QLatin1String("<span style=\"color:#0000ff\">");
+ richText += apiVariantToString(returnValue);
+ richText += QLatin1String("</span>");
+ }
+
+ m_staticText.setText(richText);
+ QTextOption opt;
+ opt.setWrapMode(QTextOption::NoWrap);
+ m_staticText.setTextOption(opt);
+ m_staticText.prepare();
+
+ return m_staticText;
+}
+
+QString ApiTraceCall::toHtml() const
+{
+ if (!m_richText.isEmpty())
+ return m_richText;
+
+ if (helpUrl.isEmpty()) {
+ m_richText = QString::fromLatin1(
+ "%1) <span style=\"font-weight:bold\">%2</span>(")
+ .arg(index)
+ .arg(name);
+ } else {
+ m_richText = QString::fromLatin1(
+ "%1) <span style=\"font-weight:bold\"><a href=\"%2\">%3</a></span>(")
+ .arg(index)
+ .arg(helpUrl.toString())
+ .arg(name);
+ }
+
+ for (int i = 0; i < argNames.count(); ++i) {
+ m_richText += argNames[i];
+ m_richText += QString::fromLatin1(" = ");
+ m_richText += QLatin1String("<span style=\"color:#0000ff\">");
+ m_richText += apiVariantToString(argValues[i]);
+ m_richText += QLatin1String("</span>");
+ if (i < argNames.count() - 1)
+ m_richText += QString::fromLatin1(", ");
+ }
+ m_richText += QLatin1String(")");
+
+ if (returnValue.isValid()) {
+ m_richText += QLatin1String(" = ");
+ m_richText += QLatin1String("<span style=\"color:#0000ff\">");
+ m_richText += apiVariantToString(returnValue);
+ m_richText += QLatin1String("</span>");
+ }
+ return m_richText;
+}
+
+QString ApiTraceCall::filterText() const
+{
+ if (!m_filterText.isEmpty())
+ return m_filterText;
+
+ m_filterText = name;
+ for (int i = 0; i < argNames.count(); ++i) {
+ m_filterText += argNames[i];
+ m_filterText += QString::fromLatin1(" = ");
+
+ if (argValues[i].type() == QVariant::ByteArray) {
+ m_hasBinaryData = true;
+ m_binaryDataIndex = i;
+ }
+ m_filterText += apiVariantToString(argValues[i]);
+ if (i < argNames.count() - 1)
+ m_filterText += QString::fromLatin1(", ");
+ }
+ m_filterText += QLatin1String(")");
+
+ if (returnValue.isValid()) {
+ m_filterText += QLatin1String(" = ");
+ m_filterText += apiVariantToString(returnValue);
+ }
+ return m_filterText;
+}
+
+QStaticText ApiTraceFrame::staticText() const
+{
+ if (!m_staticText.text().isEmpty())
+ return m_staticText;
+
+ QString richText =
+ QString::fromLatin1("<span style=\"font-weight:bold\">Frame %1</span>").arg(number);
+
+ m_staticText.setText(richText);
+ QTextOption opt;
+ opt.setWrapMode(QTextOption::NoWrap);
+ m_staticText.setTextOption(opt);
+ m_staticText.prepare();
+
+ return m_staticText;
+}
+
+int ApiTraceCall::numChildren() const
+{
+ return 0;
+}
+
+int ApiTraceFrame::numChildren() const
+{
+ return calls.count();
+}
+
+ApiTraceFrame::ApiTraceFrame()
+ : ApiTraceEvent(ApiTraceEvent::Frame)
+{
+}
+
+ApiTraceCall::ApiTraceCall()
+ : ApiTraceEvent(ApiTraceEvent::Call),
+ m_hasBinaryData(false),
+ m_binaryDataIndex(0)
+{
+}
+
+ApiTraceEvent::ApiTraceEvent()
+ : m_type(ApiTraceEvent::None)
+{
+}
+
+ApiTraceEvent::ApiTraceEvent(Type t)
+ : m_type(t)
+{
+}
+
+ApiTraceCall::~ApiTraceCall()
+{
+}
+
+QVariantMap ApiTraceEvent::stateParameters() const
+{
+ return m_state.parameters();
+}
+
+ApiTraceState ApiTraceEvent::state() const
+{
+ return m_state;
+}
+
+void ApiTraceEvent::setState(const ApiTraceState &state)
+{
+ m_state = state;
+}
+
+bool ApiTraceCall::hasBinaryData() const
+{
+ return m_hasBinaryData;
+}
+
+int ApiTraceCall::binaryDataIndex() const
+{
+ return m_binaryDataIndex;
+}
+
+ApiTraceState::ApiTraceState()
+{
+}
+
+ApiTraceState::ApiTraceState(const QVariantMap &parsedJson)
+{
+ m_parameters = parsedJson[QLatin1String("parameters")].toMap();
+ QVariantMap currentProgram =
+ parsedJson[QLatin1String("current_program")].toMap();
+ QVariantList attachedShaders =
+ currentProgram[QLatin1String("attached_shaders")].toList();
+
+
+ for (int i = 0; i < attachedShaders.count(); ++i) {
+ QVariantMap var = attachedShaders[i].toMap();
+ m_shaderSources.append(
+ var[QLatin1String("source")].toString());
+ }
+
+ QVariantList textureUnits =
+ parsedJson[QLatin1String("textures")].toList();
+ for (int i = 0; i < textureUnits.count(); ++i) {
+ QVariantMap unit = textureUnits[i].toMap();
+ QVariantMap::const_iterator itr;
+ for (itr = unit.constBegin(); itr != unit.constEnd(); ++itr) {
+ QVariantMap target = itr.value().toMap();
+ if (target.count()) {
+ QVariantList levels = target[QLatin1String("levels")].toList();
+ for (int j = 0; j < levels.count(); ++j) {
+ QVariantMap level = levels[j].toMap();
+ QVariantMap image = level[QLatin1String("image")].toMap();
+ QSize size(image[QLatin1String("__width__")].toInt(),
+ image[QLatin1String("__height__")].toInt());
+ QString cls = image[QLatin1String("__class__")].toString();
+ QString type = image[QLatin1String("__type__")].toString();
+ int numChannels =
+ image[QLatin1String("__channels__")].toInt();
+ QString encoding =
+ image[QLatin1String("__encoding__")].toString();
+
+ Q_ASSERT(numChannels == 4);
+ Q_ASSERT(encoding == QLatin1String("base64"));
+ Q_ASSERT(type == QLatin1String("float"));
+
+ QByteArray dataArray =
+ image[QLatin1String("__data__")].toByteArray();
+
+ ApiTexture tex;
+ tex.setSize(size);
+ tex.setLevel(j);
+ tex.setUnit(i);
+ tex.setTarget(itr.key());
+ tex.contentsFromBase64(dataArray);
+
+ m_textures.append(tex);
+ }
+ }
+ }
+ }
+}
+
+QVariantMap ApiTraceState::parameters() const
+{
+ return m_parameters;
+}
+
+QStringList ApiTraceState::shaderSources() const
+{
+ return m_shaderSources;
+}
+
+bool ApiTraceState::isEmpty() const
+{
+ return m_parameters.isEmpty();
+}
+
+QList<ApiTexture> ApiTraceState::textures() const
+{
+ return m_textures;
+}
+
+