{
m_loaderThread->quit();
m_loaderThread->deleteLater();
- qDeleteAll(m_calls);
qDeleteAll(m_frames);
delete m_loader;
delete m_saver;
bool ApiTrace::isEmpty() const
{
- return m_calls.isEmpty();
+ return m_frames.isEmpty();
}
QString ApiTrace::fileName() const
return m_frameMarker;
}
-QVector<ApiTraceCall*> ApiTrace::calls() const
-{
- return m_calls;
-}
-
-int ApiTrace::numCalls() const
-{
- return m_calls.count();
-}
-
QList<ApiTraceFrame*> ApiTrace::frames() const
{
return m_frames;
m_fileName = name;
m_frames.clear();
- m_calls.clear();
m_errors.clear();
m_editedCalls.clear();
m_needsSaving = false;
emit invalidated();
-// m_loader->loadTrace(m_fileName);
emit loadTrace(m_fileName);
}
}
-void ApiTrace::setFrameMarker(FrameMarker marker)
-{
- if (m_frameMarker != marker) {
- emit framesInvalidated();
-
- qDeleteAll(m_frames);
- m_frames.clear();
- detectFrames();
- }
-}
-
void ApiTrace::addFrames(const QList<ApiTraceFrame*> &frames)
{
QVector<ApiTraceCall*> calls;
m_frames += frames;
- int currentCalls = m_calls.count();
int numNewCalls = 0;
foreach(ApiTraceFrame *frame, frames) {
frame->setParentTrace(this);
numNewCalls += frame->numChildren();
calls += frame->calls();
}
- m_calls.reserve(m_calls.count() + calls.count() + 1);
- m_calls += calls;
-
- emit endAddingFrames();
- emit callsAdded(currentCalls, numNewCalls);
-}
-void ApiTrace::detectFrames()
-{
- if (m_calls.isEmpty())
- return;
-
- emit beginAddingFrames(0, m_frames.count());
-
- ApiTraceFrame *currentFrame = 0;
- foreach(ApiTraceCall *apiCall, m_calls) {
- if (!currentFrame) {
- currentFrame = new ApiTraceFrame(this);
- currentFrame->number = m_frames.count();
- currentFrame->setLoaded(true);
- }
- apiCall->setParentFrame(currentFrame);
- currentFrame->addCall(apiCall);
- if (ApiTrace::isCallAFrameMarker(apiCall,
- m_frameMarker)) {
- m_frames.append(currentFrame);
- currentFrame = 0;
- }
- }
- //last frames won't have markers
- // it's just a bunch of Delete calls for every object
- // after the last SwapBuffers
- if (currentFrame) {
- m_frames.append(currentFrame);
- currentFrame = 0;
- }
emit endAddingFrames();
}
ApiTraceCall * ApiTrace::callWithIndex(int idx) const
{
- for (int i = 0; i < m_calls.count(); ++i) {
- ApiTraceCall *call = m_calls[i];
- if (call->index() == idx)
+ for (int i = 0; i < m_frames.count(); ++i) {
+ ApiTraceCall *call = m_frames[i]->callWithIndex(idx);
+ if (call)
return call;
}
return NULL;
ApiTraceState ApiTrace::defaultState() const
{
ApiTraceFrame *frame = frameAt(0);
- if (!frame || !frame->hasState())
+ if (!frame || !frame->isLoaded() || frame->isEmpty())
return ApiTraceState();
- return *frame->state();
+ ApiTraceCall *firstCall = frame->calls().first();
+ if (!firstCall->hasState()) {
+ return ApiTraceState();
+ }
+
+ return *firstCall->state();
}
void ApiTrace::callEdited(ApiTraceCall *call)
QDir dir;
emit startedSaving();
dir.mkpath(fi.absolutePath());
- m_saver->saveFile(m_tempFileName, m_calls);
+ m_saver->saveFile(m_tempFileName,
+ m_fileName,
+ m_editedCalls);
}
void ApiTrace::slotSaved()
return m_saver->isRunning();
}
-void ApiTrace::callError(ApiTraceCall *call)
-{
- Q_ASSERT(call);
-
- if (call->hasError())
- m_errors.insert(call);
- else
- m_errors.remove(call);
-
- emit changed(call);
-}
-
bool ApiTrace::hasErrors() const
{
return !m_errors.isEmpty();
void ApiTrace::loadFrame(ApiTraceFrame *frame)
{
- Q_ASSERT(!frame->loaded());
+ Q_ASSERT(!frame->isLoaded());
emit requestFrame(frame);
}
void ApiTrace::finishedParsing()
{
ApiTraceFrame *firstFrame = m_frames[0];
- if (firstFrame && !firstFrame->loaded()) {
+ if (firstFrame && !firstFrame->isLoaded()) {
loadFrame(firstFrame);
}
}
emit beginLoadingFrame(frame, calls.size());
frame->setCalls(calls, binaryDataSize);
emit endLoadingFrame(frame);
+
+ if (!m_queuedErrors.isEmpty()) {
+ QList< QPair<ApiTraceFrame*, ApiTraceError> >::iterator itr;
+ for (itr = m_queuedErrors.begin(); itr != m_queuedErrors.end();
+ ++itr) {
+ const ApiTraceError &error = (*itr).second;
+ if ((*itr).first == frame) {
+ ApiTraceCall *call = frame->callWithIndex(error.callIndex);
+
+ if (!call) {
+ continue;
+ }
+
+ call->setError(error.message);
+ m_queuedErrors.erase(itr);
+
+ if (call->hasError()) {
+ m_errors.insert(call);
+ } else {
+ m_errors.remove(call);
+ }
+ emit changed(call);
+ }
+ }
+ }
}
void ApiTrace::findNext(ApiTraceFrame *frame,
ApiTraceCall *foundCall = 0;
int frameIdx = m_frames.indexOf(frame);
- if (frame->loaded()) {
+ if (frame->isLoaded()) {
foundCall = frame->findNextCall(from, str, sensitivity);
if (foundCall) {
- emit findResult(SearchFound, foundCall);
+ emit findResult(SearchResult_Found, foundCall);
return;
}
for (int i = frameIdx; i < m_frames.count(); ++i) {
ApiTraceFrame *frame = m_frames[i];
- if (!frame->loaded()) {
+ if (!frame->isLoaded()) {
emit loaderSearchNext(i, str, sensitivity);
return;
} else {
ApiTraceCall *call = frame->findNextCall(0, str, sensitivity);
if (call) {
- emit findResult(SearchFound, call);
+ emit findResult(SearchResult_Found, call);
return;
}
}
}
- emit findResult(SearchWrapped, 0);
+ emit findResult(SearchResult_Wrapped, 0);
}
void ApiTrace::findPrev(ApiTraceFrame *frame,
ApiTraceCall *foundCall = 0;
int frameIdx = m_frames.indexOf(frame);
- if (frame->loaded()) {
+ if (frame->isLoaded()) {
foundCall = frame->findPrevCall(from, str, sensitivity);
if (foundCall) {
- emit findResult(SearchFound, foundCall);
+ emit findResult(SearchResult_Found, foundCall);
return;
}
for (int i = frameIdx; i >= 0; --i) {
ApiTraceFrame *frame = m_frames[i];
- if (!frame->loaded()) {
+ if (!frame->isLoaded()) {
emit loaderSearchPrev(i, str, sensitivity);
return;
} else {
ApiTraceCall *call = frame->findPrevCall(0, str, sensitivity);
if (call) {
- emit findResult(SearchFound, call);
+ emit findResult(SearchResult_Found, call);
return;
}
}
}
- emit findResult(SearchWrapped, 0);
+ emit findResult(SearchResult_Wrapped, 0);
}
void ApiTrace::loaderSearchResult(ApiTrace::SearchResult result,
void ApiTrace::findFrameStart(ApiTraceFrame *frame)
{
- if (frame->loaded()) {
+ if (frame->isLoaded()) {
emit foundFrameStart(frame);
} else {
emit loaderFindFrameStart(frame);
void ApiTrace::findFrameEnd(ApiTraceFrame *frame)
{
- if (frame->loaded()) {
+ if (frame->isLoaded()) {
emit foundFrameEnd(frame);
} else {
emit loaderFindFrameEnd(frame);
frame = m_frames[frameIdx];
if (frame) {
- if (frame->loaded()) {
+ if (frame->isLoaded()) {
ApiTraceCall *call = frame->callWithIndex(index);
emit foundCallIndex(call);
} else {
for (int frameIdx = 0; frameIdx <= m_frames.size(); ++frameIdx) {
const ApiTraceFrame *frame = m_frames[frameIdx];
- unsigned numCallsInFrame = frame->loaded()
+ unsigned numCallsInFrame = frame->isLoaded()
? frame->numChildren()
: frame->numChildrenToLoad();
unsigned firstCall = numCalls;
return -1;
}
+void ApiTrace::setCallError(const ApiTraceError &error)
+{
+ int frameIdx = callInFrame(error.callIndex);
+ ApiTraceFrame *frame = 0;
+
+ if (frameIdx < 0) {
+ return;
+ }
+ frame = m_frames[frameIdx];
+
+ if (frame->isLoaded()) {
+ ApiTraceCall *call = frame->callWithIndex(error.callIndex);
+ call->setError(error.message);
+ if (call->hasError()) {
+ m_errors.insert(call);
+ } else {
+ m_errors.remove(call);
+ }
+ emit changed(call);
+ } else {
+ emit requestFrame(frame);
+ m_queuedErrors.append(qMakePair(frame, error));
+ }
+}
+
#include "apitrace.moc"
projects / apitrace / blobdiff