void FlameGraphModel::finalize()
{
foreach (FlameGraphData *child, m_stackBottom.children)
m_stackBottom.duration += child->duration;
loadNotes(-1, false);
endResetModel();
}
bool QmlProfilerFileReader::loadQtd(QIODevice *device)
{
QXmlStreamReader stream(device);
bool validVersion = true;
while (validVersion && !stream.atEnd() && !stream.hasError()) {
if (isCanceled())
return false;
QXmlStreamReader::TokenType token = stream.readNext();
const QStringRef elementName = stream.name();
switch (token) {
case QXmlStreamReader::StartDocument : continue;
case QXmlStreamReader::StartElement : {
if (elementName == _("trace")) {
QXmlStreamAttributes attributes = stream.attributes();
if (attributes.hasAttribute(_("version")))
validVersion = attributes.value(_("version")) == _(PROFILER_FILE_VERSION);
else
validVersion = false;
if (attributes.hasAttribute(_("traceStart")))
m_traceStart = attributes.value(_("traceStart")).toLongLong();
if (attributes.hasAttribute(_("traceEnd")))
m_traceEnd = attributes.value(_("traceEnd")).toLongLong();
}
if (elementName == _("eventData")) {
loadEventTypes(stream);
emit typesLoaded(m_eventTypes);
break;
}
if (elementName == _("profilerDataModel")) {
loadEvents(stream);
break;
}
if (elementName == _("noteData")) {
loadNotes(stream);
emit notesLoaded(m_notes);
break;
}
break;
}
default: break;
}
}
if (stream.hasError()) {
emit error(tr("Error while parsing trace data file: %1").arg(stream.errorString()));
return false;
} else {
emit success();
return true;
}
}
void NotesModel::refresh(const bool full) {
if (full) {
updateGitStatus();
QtConcurrent::run(this, &NotesModel::pullMergePush);
}
beginResetModel();
m_notes.clear();
loadNotes(notesFolder());
endResetModel();
}
int XmlNotes::loadNotes()
{
//DEBUG_FUNC_NAME
QFile file(m_fileName);
doc.clear();
if(!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
myWarning() << "cannot read the file " << file.fileName() << "error = " << file.errorString();
return 1;
}
if(!doc.setContent(&file)) {
myWarning() << "the file isn't valid";
file.close();
return 1;
}
if(doc.documentElement().isElement() && !doc.documentElement().isNull()) {
QDomElement e = doc.documentElement();
const QString oldVersion = e.attribute("version", "0.1");
if(oldVersion == "0.1") {
//errror to old version
myWarning() << "too old version " << e.attribute("version", "0.1") << " current is " << m_version;
file.close();
//make backup
QDir dir(m_fileName);
dir.rename(m_fileName, m_fileName + ".bak");
loadNotes();
return 2;
} else if(oldVersion == "0.2" && oldVersion != m_version) {
m_oldVersion = "0.2";
} else if(oldVersion == "0.3" && oldVersion != m_version) {
m_oldVersion = "0.3";
}
}
file.close();
m_isLoaded = true;
return 0;
}
void FlameGraphModel::loadData(qint64 rangeStart, qint64 rangeEnd)
{
const bool checkRanges = (rangeStart != -1) && (rangeEnd != -1);
if (m_modelManager->state() == QmlProfilerModelManager::ClearingData) {
beginResetModel();
clear();
endResetModel();
return;
} else if (m_modelManager->state() != QmlProfilerModelManager::ProcessingData &&
m_modelManager->state() != QmlProfilerModelManager::Done) {
return;
}
beginResetModel();
clear();
const QVector<QmlProfilerDataModel::QmlEventData> &eventList
= m_modelManager->qmlModel()->getEvents();
const QVector<QmlProfilerDataModel::QmlEventTypeData> &typesList
= m_modelManager->qmlModel()->getEventTypes();
// used by binding loop detection
QStack<const QmlProfilerDataModel::QmlEventData *> callStack;
callStack.append(0);
FlameGraphData *stackTop = &m_stackBottom;
for (int i = 0; i < eventList.size(); ++i) {
const QmlProfilerDataModel::QmlEventData *event = &eventList[i];
int typeIndex = event->typeIndex();
const QmlProfilerDataModel::QmlEventTypeData *type = &typesList[typeIndex];
if (!m_acceptedTypes.contains(type->rangeType))
continue;
if (checkRanges) {
if ((event->startTime() + event->duration() < rangeStart)
|| (event->startTime() > rangeEnd))
continue;
}
const QmlProfilerDataModel::QmlEventData *potentialParent = callStack.top();
while (potentialParent &&
potentialParent->startTime() + potentialParent->duration() <= event->startTime()) {
callStack.pop();
stackTop = stackTop->parent;
potentialParent = callStack.top();
}
callStack.push(event);
stackTop = pushChild(stackTop, event);
m_modelManager->modelProxyCountUpdated(m_modelId, i, eventList.count());
}
foreach (FlameGraphData *child, m_stackBottom.children)
m_stackBottom.duration += child->duration;
loadNotes(-1, false);
m_modelManager->modelProxyCountUpdated(m_modelId, 1, 1);
endResetModel();
}
