feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

QmlProfiler: Allow string data in events

Browse Source 
The restriction to put all strings in the type data is becoming a
burden to further enhancements. Also, introduce proper ctors for all
event structs.

Change-Id: I42d3bac96155ac1ac183a2b82785ce0396c5a932
Reviewed-by: Joerg Bornemann <joerg.bornemann@theqtcompany.com>
This commit is contained in:
Ulf Hermann
2015-11-13 15:31:32 +01:00
parent 8d936b8aa6
commit 35cedb2aee
6 changed files with 250 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
src/plugins/qmlprofiler/qmlprofileranimationsmodel.cpp
View File

@@ -81,20 +81,21 @@ void QmlProfilerAnimationsModel::loadData()
qint64 minNextStartTimes[] = {0, 0};
foreach (const QmlProfilerDataModel::QmlEventData &event, referenceList) {
const QmlProfilerDataModel::QmlEventTypeData &type = typeList[event.typeIndex];
const QmlProfilerDataModel::QmlEventTypeData &type = typeList[event.typeIndex()];
if (!accepted(type))
continue;
lastThread = (QmlDebug::AnimationThread)event.numericData3;
lastThread = (QmlDebug::AnimationThread)event.numericData(2);
// initial estimation of the event duration: 1/framerate
qint64 estimatedDuration = event.numericData1 > 0 ? 1e9/event.numericData1 : 1;
qint64 estimatedDuration = event.numericData(0) > 0 ? 1e9/event.numericData(0) : 1;
// the profiler registers the animation events at the end of them
qint64 realEndTime = event.startTime;
qint64 realEndTime = event.startTime();
// ranges should not overlap. If they do, our estimate wasn't accurate enough
qint64 realStartTime = qMax(event.startTime - estimatedDuration, minNextStartTimes[lastThread]);
qint64 realStartTime = qMax(event.startTime() - estimatedDuration,
minNextStartTimes[lastThread]);
// Sometimes our estimate is far off or the server has miscalculated the frame rate
if (realStartTime >= realEndTime)
@@ -102,9 +103,9 @@ void QmlProfilerAnimationsModel::loadData()
// Don't "fix" the framerate even if we've fixed the duration.
// The server should know better after all and if it doesn't we want to see that.
lastEvent.typeId = event.typeIndex;
lastEvent.framerate = (int)event.numericData1;
lastEvent.animationcount = (int)event.numericData2;
lastEvent.typeId = event.typeIndex();
lastEvent.framerate = (int)event.numericData(0);
lastEvent.animationcount = (int)event.numericData(1);
QTC_ASSERT(lastEvent.animationcount > 0, continue);
m_data.insert(insert(realStartTime, realEndTime - realStartTime, lastThread), lastEvent);
@@ -112,9 +113,10 @@ void QmlProfilerAnimationsModel::loadData()
if (lastThread == QmlDebug::GuiThread)
m_maxGuiThreadAnimations = qMax(lastEvent.animationcount, m_maxGuiThreadAnimations);
else
m_maxRenderThreadAnimations = qMax(lastEvent.animationcount, m_maxRenderThreadAnimations);
m_maxRenderThreadAnimations = qMax(lastEvent.animationcount,
m_maxRenderThreadAnimations);
minNextStartTimes[lastThread] = event.startTime + 1;
minNextStartTimes[lastThread] = event.startTime() + 1;
updateProgress(count(), referenceList.count());
}

14
src/plugins/qmlprofiler/qmlprofilerdatamodel.cpp
View File

@@ -194,7 +194,7 @@ bool QmlProfilerDataModel::isEmpty() const
inline static bool operator<(const QmlProfilerDataModel::QmlEventData &t1,
const QmlProfilerDataModel::QmlEventData &t2)
{
return t1.startTime < t2.startTime;
return t1.startTime() < t2.startTime();
}
inline static uint qHash(const QmlProfilerDataModel::QmlEventTypeData &type)
@@ -266,15 +266,15 @@ void QmlProfilerDataModel::addQmlEvent(QmlDebug::Message message, QmlDebug::Rang
Q_D(QmlProfilerDataModel);
QString displayName;
QmlEventTypeData typeData = {displayName, location, message, rangeType, detailType, data};
QmlEventData eventData = {-1, startTime, duration, ndata1, ndata2, ndata3, ndata4, ndata5};
QmlEventTypeData typeData(displayName, location, message, rangeType, detailType, data);
QmlEventData eventData(startTime, duration, -1, ndata1, ndata2, ndata3, ndata4, ndata5);
QHash<QmlEventTypeData, int>::Iterator it = d->eventTypeIds.find(typeData);
if (it != d->eventTypeIds.end()) {
eventData.typeIndex = it.value();
eventData.setTypeIndex(it.value());
} else {
eventData.typeIndex = d->eventTypes.size();
d->eventTypeIds[typeData] = eventData.typeIndex;
eventData.setTypeIndex(d->eventTypes.size());
d->eventTypeIds[typeData] = eventData.typeIndex();
d->eventTypes.append(typeData);
}
@@ -290,7 +290,7 @@ qint64 QmlProfilerDataModel::lastTimeMark() const
if (d->eventList.isEmpty())
return 0;
return d->eventList.last().startTime + d->eventList.last().duration;
return d->eventList.last().startTime() + d->eventList.last().duration();
}
void QmlProfilerDataModel::detailsChanged(int requestId, const QString &newString)

151
src/plugins/qmlprofiler/qmlprofilerdatamodel.h
View File

@@ -43,6 +43,15 @@ class QMLPROFILER_EXPORT QmlProfilerDataModel : public QObject
Q_OBJECT
public:
struct QmlEventTypeData {
QmlEventTypeData(const QString &displayName = QString(),
const QmlDebug::QmlEventLocation &location = QmlDebug::QmlEventLocation(),
QmlDebug::Message message = QmlDebug::MaximumMessage,
QmlDebug::RangeType rangeType = QmlDebug::MaximumRangeType,
int detailType = -1, const QString &data = QString()) :
displayName(displayName), location(location), message(message), rangeType(rangeType),
detailType(detailType), data(data)
{}
QString displayName;
QmlDebug::QmlEventLocation location;
QmlDebug::Message message;
@@ -52,17 +61,143 @@ public:
};
struct QmlEventData {
int typeIndex;
qint64 startTime;
qint64 duration;
qint64 numericData1;
qint64 numericData2;
qint64 numericData3;
qint64 numericData4;
qint64 numericData5;
QmlEventData(qint64 startTime = -1, qint64 duration = -1, int typeIndex = -1,
qint64 num0 = 0, qint64 num1 = 0, qint64 num2 = 0, qint64 num3 = 0,
qint64 num4 = 0) :
m_startTime(startTime), m_duration(duration), m_dataType(NumericData),
m_typeIndex(typeIndex)
{
m_numericData[0] = num0;
m_numericData[1] = num1;
m_numericData[2] = num2;
m_numericData[3] = num3;
m_numericData[4] = num4;
}
QmlEventData(qint64 startTime, qint64 duration, int typeIndex, const QString &data)
: m_startTime(startTime), m_duration(duration), m_typeIndex(typeIndex)
{
assignStringData(data);
}
QmlEventData(const QmlEventData &other) :
m_startTime(other.m_startTime), m_duration(other.m_duration),
m_dataType(other.m_dataType), m_typeIndex(other.m_typeIndex)
{
assignData(other);
}
QmlEventData &operator=(const QmlEventData &other)
{
if (this != &other) {
if (m_dataType == StringData)
m_stringData.~QString();
m_startTime = other.m_startTime;
m_duration = other.m_duration;
m_typeIndex = other.m_typeIndex;
m_dataType = other.m_dataType;
assignData(other);
}
return *this;
}
~QmlEventData()
{
if (m_dataType == StringData)
m_stringData.~QString();
}
qint64 startTime() const { return m_startTime; }
void setStartTime(qint64 startTime) { m_startTime = startTime; }
qint64 duration() const { return m_duration; }
void setDuration(qint64 duration) { m_duration = duration; }
int typeIndex() const { return m_typeIndex; }
void setTypeIndex(int typeIndex) { m_typeIndex = typeIndex; }
qint64 numericData(int i) const { return m_dataType == NumericData ? m_numericData[i] : 0; }
void setNumericData(int i, qint64 data)
{
if (m_dataType == StringData)
m_stringData.~QString();
m_dataType = NumericData;
m_numericData[i] = data;
}
QString stringData() const
{
switch (m_dataType) {
case NumericData: return QString();
case StringData: return m_stringData;
default: return QString::fromUtf8(m_characterData, m_characterDataLength);
}
}
void setStringData(const QString &data)
{
if (m_dataType == StringData)
m_stringData.~QString();
assignStringData(data);
}
private:
static const quint8 StringData = 254;
static const quint8 NumericData = 255;
qint64 m_startTime;
qint64 m_duration;
union {
qint64 m_numericData[5];
QString m_stringData;
char m_characterData[5 * sizeof(qint64) + 3];
};
union {
quint8 m_dataType;
quint8 m_characterDataLength;
};
qint32 m_typeIndex;
void assignData(const QmlEventData &other)
{
switch (m_dataType) {
case StringData:
new (&m_stringData) QString(other.m_stringData);
break;
case NumericData:
for (int i = 0; i < 5; ++i)
m_numericData[i] = other.m_numericData[i];
break;
default:
memcpy(m_characterData, other.m_characterData, m_characterDataLength);
break;
}
}
void assignStringData(const QString &data)
{
QByteArray cdata = data.toUtf8();
if (cdata.length() <= (int)sizeof(m_characterData)) {
m_characterDataLength = cdata.length();
memcpy(m_characterData, cdata.constData(), m_characterDataLength);
} else {
m_dataType = StringData;
new (&m_stringData) QString(data);
}
}
};
struct QmlEventNoteData {
QmlEventNoteData(int typeIndex = -1, qint64 startTime = -1, qint64 duration = -1,
const QString &text = QString()) :
typeIndex(typeIndex), startTime(startTime), duration(duration), text(text)
{}
int typeIndex;
qint64 startTime;
qint64 duration;

70
src/plugins/qmlprofiler/qmlprofilereventsmodelproxy.cpp
View File

@@ -196,34 +196,34 @@ void QmlProfilerEventsModelProxy::loadData(qint64 rangeStart, qint64 rangeEnd)
for (int i = 0; i < eventList.size(); ++i) {
const QmlProfilerDataModel::QmlEventData *event = &eventList[i];
const QmlProfilerDataModel::QmlEventTypeData *type = &typesList[event->typeIndex];
const QmlProfilerDataModel::QmlEventTypeData *type = &typesList[event->typeIndex()];
if (!d->acceptedTypes.contains(type->rangeType))
continue;
if (checkRanges) {
if ((event->startTime + event->duration < rangeStart)
|| (event->startTime > rangeEnd))
if ((event->startTime() + event->duration() < rangeStart)
|| (event->startTime() > rangeEnd))
continue;
}
// update stats
QmlEventStats *stats = &d->data[event->typeIndex];
QmlEventStats *stats = &d->data[event->typeIndex()];
stats->duration += event->duration;
if (event->duration < stats->minTime)
stats->minTime = event->duration;
if (event->duration > stats->maxTime)
stats->maxTime = event->duration;
stats->duration += event->duration();
if (event->duration() < stats->minTime)
stats->minTime = event->duration();
if (event->duration() > stats->maxTime)
stats->maxTime = event->duration();
stats->calls++;
// for median computing
durations[event->typeIndex].append(event->duration);
durations[event->typeIndex()].append(event->duration());
// qml time computation
if (event->startTime > lastEndTime) { // assume parent event if starts before last end
qmlTime += event->duration;
lastEndTime = event->startTime + event->duration;
if (event->startTime() > lastEndTime) { // assume parent event if starts before last end
qmlTime += event->duration();
lastEndTime = event->startTime() + event->duration();
}
@@ -231,16 +231,16 @@ void QmlProfilerEventsModelProxy::loadData(qint64 rangeStart, qint64 rangeEnd)
// binding loop detection
//
const QmlProfilerDataModel::QmlEventData *potentialParent = callStack.top();
while (potentialParent
&& !(potentialParent->startTime + potentialParent->duration > event->startTime)) {
while (potentialParent && !(potentialParent->startTime() + potentialParent->duration() >
event->startTime())) {
callStack.pop();
potentialParent = callStack.top();
}
// check whether event is already in stack
for (int ii = 1; ii < callStack.size(); ++ii) {
if (callStack.at(ii)->typeIndex == event->typeIndex) {
d->eventsInBindingLoop.insert(event->typeIndex);
if (callStack.at(ii)->typeIndex() == event->typeIndex()) {
d->eventsInBindingLoop.insert(event->typeIndex());
break;
}
}
@@ -374,30 +374,31 @@ void QmlProfilerEventParentsModelProxy::loadData()
const QVector<QmlProfilerDataModel::QmlEventTypeData> typesList = simpleModel->getEventTypes();
foreach (const QmlProfilerDataModel::QmlEventData &event, eventList) {
// whitelist
if (!m_eventsModel->eventTypeAccepted(typesList[event.typeIndex].rangeType))
if (!m_eventsModel->eventTypeAccepted(typesList[event.typeIndex()].rangeType))
continue;
// level computation
if (endtimesPerLevel[level] > event.startTime) {
if (endtimesPerLevel[level] > event.startTime()) {
level++;
} else {
while (level > QmlDebug::Constants::QML_MIN_LEVEL && endtimesPerLevel[level-1] <= event.startTime)
while (level > QmlDebug::Constants::QML_MIN_LEVEL &&
endtimesPerLevel[level-1] <= event.startTime())
level--;
}
endtimesPerLevel[level] = event.startTime + event.duration;
endtimesPerLevel[level] = event.startTime() + event.duration();
int parentTypeIndex = -1;
if (level > QmlDebug::Constants::QML_MIN_LEVEL && lastParent.contains(level-1))
parentTypeIndex = lastParent[level-1];
QmlEventRelativesMap &relativesMap = m_data[event.typeIndex];
QmlEventRelativesMap &relativesMap = m_data[event.typeIndex()];
QmlEventRelativesMap::Iterator it = relativesMap.find(parentTypeIndex);
if (it != relativesMap.end()) {
it.value().calls++;
it.value().duration += event.duration;
it.value().duration += event.duration();
} else {
QmlEventRelativesData parent = {
event.duration,
event.duration(),
1,
eventsInBindingLoop.contains(parentTypeIndex)
};
@@ -405,7 +406,7 @@ void QmlProfilerEventParentsModelProxy::loadData()
}
// now lastparent is the new type
lastParent[level] = event.typeIndex;
lastParent[level] = event.typeIndex();
}
}
@@ -438,17 +439,18 @@ void QmlProfilerEventChildrenModelProxy::loadData()
const QVector<QmlProfilerDataModel::QmlEventTypeData> &typesList = simpleModel->getEventTypes();
foreach (const QmlProfilerDataModel::QmlEventData &event, eventList) {
// whitelist
if (!m_eventsModel->eventTypeAccepted(typesList[event.typeIndex].rangeType))
if (!m_eventsModel->eventTypeAccepted(typesList[event.typeIndex()].rangeType))
continue;
// level computation
if (endtimesPerLevel[level] > event.startTime) {
if (endtimesPerLevel[level] > event.startTime()) {
level++;
} else {
while (level > QmlDebug::Constants::QML_MIN_LEVEL && endtimesPerLevel[level-1] <= event.startTime)
while (level > QmlDebug::Constants::QML_MIN_LEVEL &&
endtimesPerLevel[level-1] <= event.startTime())
level--;
}
endtimesPerLevel[level] = event.startTime + event.duration;
endtimesPerLevel[level] = event.startTime() + event.duration();
int parentId = -1;
@@ -456,21 +458,21 @@ void QmlProfilerEventChildrenModelProxy::loadData()
parentId = lastParent[level-1];
QmlEventRelativesMap &relativesMap = m_data[parentId];
QmlEventRelativesMap::Iterator it = relativesMap.find(event.typeIndex);
QmlEventRelativesMap::Iterator it = relativesMap.find(event.typeIndex());
if (it != relativesMap.end()) {
it.value().calls++;
it.value().duration += event.duration;
it.value().duration += event.duration();
} else {
QmlEventRelativesData child = {
event.duration,
event.duration(),
1,
eventsInBindingLoop.contains(parentId)
};
relativesMap.insert(event.typeIndex, child);
relativesMap.insert(event.typeIndex(), child);
}
// now lastparent is the new type
lastParent[level] = event.typeIndex;
lastParent[level] = event.typeIndex();
}
}

4
src/plugins/qmlprofiler/qmlprofilerrangemodel.cpp
View File

@@ -80,12 +80,12 @@ void QmlProfilerRangeModel::loadData()
const QVector<QmlProfilerDataModel::QmlEventData> &eventList = simpleModel->getEvents();
const QVector<QmlProfilerDataModel::QmlEventTypeData> &typesList = simpleModel->getEventTypes();
foreach (const QmlProfilerDataModel::QmlEventData &event, eventList) {
const QmlProfilerDataModel::QmlEventTypeData &type = typesList[event.typeIndex];
const QmlProfilerDataModel::QmlEventTypeData &type = typesList[event.typeIndex()];
if (!accepted(type))
continue;
// store starttime-based instance
m_data.insert(insert(event.startTime, event.duration, event.typeIndex),
m_data.insert(insert(event.startTime(), event.duration(), event.typeIndex()),
QmlRangeEventStartInstance());
updateProgress(count(), eventList.count() * 5);
}

100
src/plugins/qmlprofiler/qmlprofilertracefile.cpp
View File

@@ -164,9 +164,9 @@ bool QmlProfilerFileReader::load(QIODevice *device)
else
validVersion = false;
if (attributes.hasAttribute(_("traceStart")))
traceStart = attributes.value(_("traceStart")).toString().toLongLong();
traceStart = attributes.value(_("traceStart")).toLongLong();
if (attributes.hasAttribute(_("traceEnd")))
traceEnd = attributes.value(_("traceEnd")).toString().toLongLong();
traceEnd = attributes.value(_("traceEnd")).toLongLong();
}
if (elementName == _("eventData")) {
@@ -263,7 +263,7 @@ void QmlProfilerFileReader::loadEventData(QXmlStreamReader &stream)
const QXmlStreamAttributes attributes = stream.attributes();
if (attributes.hasAttribute(_("index"))) {
eventIndex = attributes.value(_("index")).toString().toInt();
eventIndex = attributes.value(_("index")).toInt();
} else {
// ignore event
eventIndex = -1;
@@ -373,7 +373,7 @@ void QmlProfilerFileReader::loadProfilerDataModel(QXmlStreamReader &stream)
case QXmlStreamReader::StartElement: {
if (elementName == _("range")) {
progress(stream.device());
QmlProfilerDataModel::QmlEventData range = { -1, 0, 0, 0, 0, 0, 0, 0 };
QmlProfilerDataModel::QmlEventData range(0, 0, -1, 0, 0, 0, 0, 0);
const QXmlStreamAttributes attributes = stream.attributes();
if (!attributes.hasAttribute(_("startTime"))
@@ -382,43 +382,43 @@ void QmlProfilerFileReader::loadProfilerDataModel(QXmlStreamReader &stream)
continue;
}
range.startTime = attributes.value(_("startTime")).toString().toLongLong();
range.setStartTime(attributes.value(_("startTime")).toLongLong());
if (attributes.hasAttribute(_("duration")))
range.duration = attributes.value(_("duration")).toString().toLongLong();
range.setDuration(attributes.value(_("duration")).toLongLong());
// attributes for special events
if (attributes.hasAttribute(_("framerate")))
range.numericData1 = attributes.value(_("framerate")).toString().toLongLong();
range.setNumericData(0, attributes.value(_("framerate")).toLongLong());
if (attributes.hasAttribute(_("animationcount")))
range.numericData2 = attributes.value(_("animationcount")).toString().toLongLong();
range.setNumericData(1, attributes.value(_("animationcount")).toLongLong());
if (attributes.hasAttribute(_("thread")))
range.numericData3 = attributes.value(_("thread")).toString().toLongLong();
range.setNumericData(2, attributes.value(_("thread")).toLongLong());
if (attributes.hasAttribute(_("width")))
range.numericData1 = attributes.value(_("width")).toString().toLongLong();
range.setNumericData(0, attributes.value(_("width")).toLongLong());
if (attributes.hasAttribute(_("height")))
range.numericData2 = attributes.value(_("height")).toString().toLongLong();
range.setNumericData(1, attributes.value(_("height")).toLongLong());
if (attributes.hasAttribute(_("refCount")))
range.numericData3 = attributes.value(_("refCount")).toString().toLongLong();
range.setNumericData(2, attributes.value(_("refCount")).toLongLong());
if (attributes.hasAttribute(_("amount")))
range.numericData1 = attributes.value(_("amount")).toString().toLongLong();
range.setNumericData(0, attributes.value(_("amount")).toLongLong());
if (attributes.hasAttribute(_("timing1")))
range.numericData1 = attributes.value(_("timing1")).toString().toLongLong();
range.setNumericData(0, attributes.value(_("timing1")).toLongLong());
if (attributes.hasAttribute(_("timing2")))
range.numericData2 = attributes.value(_("timing2")).toString().toLongLong();
range.setNumericData(1, attributes.value(_("timing2")).toLongLong());
if (attributes.hasAttribute(_("timing3")))
range.numericData3 = attributes.value(_("timing3")).toString().toLongLong();
range.setNumericData(2, attributes.value(_("timing3")).toLongLong());
if (attributes.hasAttribute(_("timing4")))
range.numericData4 = attributes.value(_("timing4")).toString().toLongLong();
range.setNumericData(3, attributes.value(_("timing4")).toLongLong());
if (attributes.hasAttribute(_("timing5")))
range.numericData5 = attributes.value(_("timing5")).toString().toLongLong();
range.setNumericData(4, attributes.value(_("timing5")).toLongLong());
if (attributes.hasAttribute(_("type")))
range.numericData1 = attributes.value(_("type")).toString().toLongLong();
range.setNumericData(0, attributes.value(_("type")).toLongLong());
if (attributes.hasAttribute(_("data1")))
range.numericData2 = attributes.value(_("data1")).toString().toLongLong();
range.setNumericData(1, attributes.value(_("data1")).toLongLong());
if (attributes.hasAttribute(_("data2")))
range.numericData3 = attributes.value(_("data2")).toString().toLongLong();
range.setNumericData(2, attributes.value(_("data2")).toLongLong());
range.typeIndex = attributes.value(_("eventIndex")).toString().toInt();
range.setTypeIndex(attributes.value(_("eventIndex")).toInt());
m_ranges.append(range);
}
@@ -451,9 +451,9 @@ void QmlProfilerFileReader::loadNoteData(QXmlStreamReader &stream)
if (elementName == _("note")) {
progress(stream.device());
QXmlStreamAttributes attrs = stream.attributes();
currentNote.startTime = attrs.value(_("startTime")).toString().toLongLong();
currentNote.duration = attrs.value(_("duration")).toString().toLongLong();
currentNote.typeIndex = attrs.value(_("eventIndex")).toString().toInt();
currentNote.startTime = attrs.value(_("startTime")).toLongLong();
currentNote.duration = attrs.value(_("duration")).toLongLong();
currentNote.typeIndex = attrs.value(_("eventIndex")).toInt();
}
break;
}
@@ -600,57 +600,57 @@ void QmlProfilerFileWriter::save(QIODevice *device)
const QmlProfilerDataModel::QmlEventData &range = m_ranges[rangeIndex];
stream.writeStartElement(_("range"));
stream.writeAttribute(_("startTime"), QString::number(range.startTime));
if (range.duration > 0) // no need to store duration of instantaneous events
stream.writeAttribute(_("duration"), QString::number(range.duration));
stream.writeAttribute(_("eventIndex"), QString::number(range.typeIndex));
stream.writeAttribute(_("startTime"), QString::number(range.startTime()));
if (range.duration() > 0) // no need to store duration of instantaneous events
stream.writeAttribute(_("duration"), QString::number(range.duration()));
stream.writeAttribute(_("eventIndex"), QString::number(range.typeIndex()));
const QmlProfilerDataModel::QmlEventTypeData &event = m_qmlEvents[range.typeIndex];
const QmlProfilerDataModel::QmlEventTypeData &event = m_qmlEvents[range.typeIndex()];
if (event.message == Event) {
if (event.detailType == AnimationFrame) {
// special: animation event
stream.writeAttribute(_("framerate"), QString::number(range.numericData1));
stream.writeAttribute(_("animationcount"), QString::number(range.numericData2));
stream.writeAttribute(_("thread"), QString::number(range.numericData3));
stream.writeAttribute(_("framerate"), QString::number(range.numericData(0)));
stream.writeAttribute(_("animationcount"), QString::number(range.numericData(1)));
stream.writeAttribute(_("thread"), QString::number(range.numericData(2)));
} else if (event.detailType == Key || event.detailType == Mouse) {
// special: input event
stream.writeAttribute(_("type"), QString::number(range.numericData1));
stream.writeAttribute(_("data1"), QString::number(range.numericData2));
stream.writeAttribute(_("data2"), QString::number(range.numericData3));
stream.writeAttribute(_("type"), QString::number(range.numericData(0)));
stream.writeAttribute(_("data1"), QString::number(range.numericData(1)));
stream.writeAttribute(_("data2"), QString::number(range.numericData(2)));
}
}
// special: pixmap cache event
if (event.message == PixmapCacheEvent) {
if (event.detailType == PixmapSizeKnown) {
stream.writeAttribute(_("width"), QString::number(range.numericData1));
stream.writeAttribute(_("height"), QString::number(range.numericData2));
stream.writeAttribute(_("width"), QString::number(range.numericData(0)));
stream.writeAttribute(_("height"), QString::number(range.numericData(1)));
}
if (event.detailType == PixmapReferenceCountChanged ||
event.detailType == PixmapCacheCountChanged)
stream.writeAttribute(_("refCount"), QString::number(range.numericData3));
stream.writeAttribute(_("refCount"), QString::number(range.numericData(2)));
}
if (event.message == SceneGraphFrame) {
// special: scenegraph frame events
if (range.numericData1 > 0)
stream.writeAttribute(_("timing1"), QString::number(range.numericData1));
if (range.numericData2 > 0)
stream.writeAttribute(_("timing2"), QString::number(range.numericData2));
if (range.numericData3 > 0)
stream.writeAttribute(_("timing3"), QString::number(range.numericData3));
if (range.numericData4 > 0)
stream.writeAttribute(_("timing4"), QString::number(range.numericData4));
if (range.numericData5 > 0)
stream.writeAttribute(_("timing5"), QString::number(range.numericData5));
if (range.numericData(0) > 0)
stream.writeAttribute(_("timing1"), QString::number(range.numericData(0)));
if (range.numericData(1) > 0)
stream.writeAttribute(_("timing2"), QString::number(range.numericData(1)));
if (range.numericData(2) > 0)
stream.writeAttribute(_("timing3"), QString::number(range.numericData(2)));
if (range.numericData(3) > 0)
stream.writeAttribute(_("timing4"), QString::number(range.numericData(3)));
if (range.numericData(4) > 0)
stream.writeAttribute(_("timing5"), QString::number(range.numericData(4)));
}
// special: memory allocation event
if (event.message == MemoryAllocation)
stream.writeAttribute(_("amount"), QString::number(range.numericData1));
stream.writeAttribute(_("amount"), QString::number(range.numericData(0)));
stream.writeEndElement();
incrementProgress();