git.cworth.org Git - apitrace/blob - gui/apitracecall.cpp

   1 #include "apitracecall.h"
   2
   3 #include "trace_model.hpp"
   4
   5 #include <QDebug>
   6
   7 ApiPointer::ApiPointer(int val)
   8     : m_value(val)
   9 {
  10 }
  11
  12 QString ApiPointer::toString() const
  13 {
  14     if (m_value)
  15         return QString("0x%1").arg(m_value, 0, 16);
  16     else
  17         return QLatin1String("NULL");
  18 }
  19
  20 QString apiVariantToString(const QVariant &variant)
  21 {
  22     if (variant.userType() == QVariant::Double) {
  23         return QString::number(variant.toFloat());
  24     }
  25
  26     if (variant.userType() < QVariant::UserType) {
  27         return variant.toString();
  28     }
  29
  30     if (variant.canConvert<ApiPointer>()) {
  31         return variant.value<ApiPointer>().toString();
  32     }
  33     if (variant.canConvert<ApiBitmask>()) {
  34         return variant.value<ApiBitmask>().toString();
  35     }
  36     if (variant.canConvert<ApiStruct>()) {
  37         return variant.value<ApiStruct>().toString();
  38     }
  39     if (variant.canConvert<ApiArray>()) {
  40         return variant.value<ApiArray>().toString();
  41     }
  42
  43     return QString();
  44 }
  45
  46 ApiBitmask::ApiBitmask(const Trace::Bitmask *bitmask)
  47     : m_value(0)
  48 {
  49     init(bitmask);
  50 }
  51
  52
  53 void ApiBitmask::init(const Trace::Bitmask *bitmask)
  54 {
  55     if (!bitmask)
  56         return;
  57
  58     m_value = bitmask->value;
  59     for (Trace::Bitmask::Signature::const_iterator it = bitmask->sig->begin();
  60          it != bitmask->sig->end(); ++it) {
  61         assert(it->second);
  62         QPair<QString, unsigned long long> pair;
  63
  64         pair.first = QString::fromStdString(it->first);
  65         pair.second = it->second;
  66
  67         m_sig.append(pair);
  68     }
  69 }
  70
  71 QString ApiBitmask::toString() const
  72 {
  73     QString str;
  74     unsigned long long value = m_value;
  75     bool first = true;
  76     for (Signature::const_iterator it = m_sig.begin();
  77          value != 0 && it != m_sig.end(); ++it) {
  78         Q_ASSERT(it->second);
  79         if ((value & it->second) == it->second) {
  80             if (!first) {
  81                 str += QLatin1String(" | ");
  82             }
  83             str += it->first;
  84             value &= ~it->second;
  85             first = false;
  86         }
  87     }
  88     if (value || first) {
  89         if (!first) {
  90             str += QLatin1String(" | ");
  91         }
  92         str += QString::fromLatin1("0x%1").arg(value, 0, 16);
  93     }
  94     return str;
  95 }
  96
  97 ApiStruct::ApiStruct(const Trace::Struct *s)
  98 {
  99     init(s);
 100 }
 101
 102 QString ApiStruct::toString() const
 103 {
 104     QString str;
 105
 106     str += QLatin1String("{");
 107     for (unsigned i = 0; i < m_members.count(); ++i) {
 108         str += m_sig.memberNames[i];
 109         str += QLatin1String(" = ");
 110         str += apiVariantToString(m_members[i]);
 111         if (i < m_members.count() - 1)
 112             str += QLatin1String(", ");
 113     }
 114     str += QLatin1String("}");
 115
 116     return str;
 117 }
 118
 119 void ApiStruct::init(const Trace::Struct *s)
 120 {
 121     if (!s)
 122         return;
 123
 124     m_sig.name = QString::fromStdString(s->sig->name);
 125     for (unsigned i = 0; i < s->members.size(); ++i) {
 126         VariantVisitor vis;
 127         m_sig.memberNames.append(
 128             QString::fromStdString(s->sig->member_names[i]));
 129         s->members[i]->visit(vis);
 130         m_members.append(vis.variant());
 131     }
 132 }
 133
 134 void VariantVisitor::visit(Trace::Null *)
 135 {
 136     m_variant = QVariant(QLatin1String("NULL"));
 137 }
 138
 139 void VariantVisitor::visit(Trace::Bool *node)
 140 {
 141     m_variant = QVariant(node->value);
 142 }
 143
 144 void VariantVisitor::visit(Trace::SInt *node)
 145 {
 146     m_variant = QVariant(node->value);
 147 }
 148
 149 void VariantVisitor::visit(Trace::UInt *node)
 150 {
 151     m_variant = QVariant(node->value);
 152 }
 153
 154 void VariantVisitor::visit(Trace::Float *node)
 155 {
 156     m_variant = QVariant(node->value);
 157 }
 158
 159 void VariantVisitor::visit(Trace::String *node)
 160 {
 161     m_variant = QVariant(QString::fromStdString(node->value));
 162 }
 163
 164 void VariantVisitor::visit(Trace::Enum *e)
 165 {
 166     m_variant = QVariant(QString::fromStdString(e->sig->first));
 167 }
 168
 169 void VariantVisitor::visit(Trace::Bitmask *bitmask)
 170 {
 171     m_variant = QVariant::fromValue(ApiBitmask(bitmask));
 172 }
 173
 174 void VariantVisitor::visit(Trace::Struct *str)
 175 {
 176     m_variant = QVariant::fromValue(ApiStruct(str));
 177 }
 178
 179 void VariantVisitor::visit(Trace::Array *array)
 180 {
 181     m_variant = QVariant::fromValue(ApiArray(array));
 182 }
 183
 184 void VariantVisitor::visit(Trace::Blob *blob)
 185 {
 186     QByteArray barray = QByteArray::fromRawData(blob->buf, blob->size);
 187     m_variant = QVariant(barray);
 188 }
 189
 190 void VariantVisitor::visit(Trace::Pointer *ptr)
 191 {
 192     m_variant = QVariant::fromValue(ApiPointer(ptr->value));
 193 }
 194
 195 ApiArray::ApiArray(const Trace::Array *arr)
 196 {
 197     init(arr);
 198 }
 199
 200 QString ApiArray::toString() const
 201 {
 202     QString str;
 203     str += QLatin1String("[");
 204     for(int i = 0; i < m_array.count(); ++i) {
 205         const QVariant &var = m_array[i];
 206         str += apiVariantToString(var);
 207         if (i < m_array.count() - 1)
 208             str += QLatin1String(", ");
 209     }
 210     str += QLatin1String("]");
 211
 212     return str;
 213 }
 214
 215 void ApiArray::init(const Trace::Array *arr)
 216 {
 217     if (!arr)
 218         return;
 219
 220     for (int i = 0; i < arr->values.size(); ++i) {
 221         VariantVisitor vis;
 222         arr->values[i]->visit(vis);
 223
 224         m_array.append(vis.variant());
 225     }
 226 }
 227
 228 QStaticText ApiTraceCall::staticText() const
 229 {
 230     if (!m_staticText.text().isEmpty())
 231         return m_staticText;
 232
 233     QString richText = QString::fromLatin1("<span style=\"font-weight:bold\">%1</span>(").arg(name);
 234     for (int i = 0; i < argNames.count(); ++i) {
 235         richText += QLatin1String("<span style=\"color:#0000ff\">");
 236         QString argText = apiVariantToString(argValues[i]);
 237
 238         //if arguments are really long (e.g. shader text), cut them
 239         // and elide it
 240         if (argText.length() > 40) {
 241             QString shortened = argText.mid(0, 40);
 242             shortened[argText.length() - 5] = '.';
 243             shortened[argText.length() - 4] = '.';
 244             shortened[argText.length() - 3] = '.';
 245             shortened[argText.length() - 2] = argText[argText.length() - 2];
 246             shortened[argText.length() - 1] = argText[argText.length() - 1];
 247             richText += shortened;
 248         } else {
 249             richText += argText;
 250         }
 251         richText += QLatin1String("</span>");
 252         if (i < argNames.count() - 1)
 253             richText += QString::fromLatin1(", ");
 254     }
 255     richText += QLatin1String(")");
 256     if (returnValue.isValid()) {
 257         richText += QLatin1String(" = ");
 258         richText += QLatin1String("<span style=\"color:#0000ff\">");
 259         richText += apiVariantToString(returnValue);
 260         richText += QLatin1String("</span>");
 261     }
 262
 263     m_staticText.setText(richText);
 264     QTextOption opt;
 265     opt.setWrapMode(QTextOption::NoWrap);
 266     m_staticText.setTextOption(opt);
 267     m_staticText.prepare();
 268
 269     return m_staticText;
 270 }
 271
 272 QString ApiTraceCall::toHtml() const
 273 {
 274     if (!m_richText.isEmpty())
 275         return m_richText;
 276
 277     m_richText = QString::fromLatin1("<span style=\"font-weight:bold\">%1</span>(").arg(name);
 278     for (int i = 0; i < argNames.count(); ++i) {
 279         m_richText += argNames[i];
 280         m_richText += QString::fromLatin1(" = ");
 281         m_richText += QLatin1String("<span style=\"color:#0000ff\">");
 282         m_richText += apiVariantToString(argValues[i]);
 283         m_richText += QLatin1String("</span>");
 284         if (i < argNames.count() - 1)
 285             m_richText += QString::fromLatin1(", ");
 286     }
 287     m_richText += QLatin1String(")");
 288
 289     if (returnValue.isValid()) {
 290         m_richText += QLatin1String(" = ");
 291         m_richText += QLatin1String("<span style=\"color:#0000ff\">");
 292         m_richText += apiVariantToString(returnValue);
 293         m_richText += QLatin1String("</span>");
 294     }
 295     return m_richText;
 296 }
 297
 298 QString ApiTraceCall::filterText() const
 299 {
 300     if (!m_filterText.isEmpty())
 301         return m_filterText;
 302
 303     m_filterText = name;
 304     for (int i = 0; i < argNames.count(); ++i) {
 305         m_filterText += argNames[i];
 306         m_filterText += QString::fromLatin1(" = ");
 307         m_filterText += apiVariantToString(argValues[i]);
 308         if (i < argNames.count() - 1)
 309             m_filterText += QString::fromLatin1(", ");
 310     }
 311     m_filterText += QLatin1String(")");
 312
 313     if (returnValue.isValid()) {
 314         m_filterText += QLatin1String(" = ");
 315         m_filterText += apiVariantToString(returnValue);
 316     }
 317     return m_filterText;
 318 }
 319
 320 QStaticText ApiTraceFrame::staticText() const
 321 {
 322     if (!m_staticText.text().isEmpty())
 323         return m_staticText;
 324
 325     QString richText =
 326         QString::fromLatin1("<span style=\"font-weight:bold\">Frame %1</span>").arg(number);
 327
 328     m_staticText.setText(richText);
 329     QTextOption opt;
 330     opt.setWrapMode(QTextOption::NoWrap);
 331     m_staticText.setTextOption(opt);
 332     m_staticText.prepare();
 333
 334     return m_staticText;
 335 }
 336
 337 int ApiTraceCall::numChildren() const
 338 {
 339     return 0;
 340 }
 341
 342 int ApiTraceFrame::numChildren() const
 343 {
 344     return calls.count();
 345 }
 346
 347 ApiTraceFrame::ApiTraceFrame()
 348     : ApiTraceEvent(ApiTraceEvent::Frame)
 349 {
 350 }
 351
 352 ApiTraceCall::ApiTraceCall()
 353     : ApiTraceEvent(ApiTraceEvent::Call)
 354 {
 355 }
 356
 357 ApiTraceEvent::ApiTraceEvent()
 358     : m_type(ApiTraceEvent::None)
 359 {
 360 }
 361
 362 ApiTraceEvent::ApiTraceEvent(Type t)
 363     : m_type(t)
 364 {
 365 }
 366
 367 ApiTraceCall::~ApiTraceCall()
 368 {
 369 }