#include <QThread>
ApiTrace::ApiTrace()
- : m_frameMarker(ApiTrace::FrameMarker_SwapBuffers),
- m_needsSaving(false)
+ : m_needsSaving(false)
{
m_loader = new TraceLoader();
SIGNAL(frameContentsLoaded(ApiTraceFrame*,QVector<ApiTraceCall*>,quint64)),
this,
SLOT(loaderFrameLoaded(ApiTraceFrame*,QVector<ApiTraceCall*>,quint64)));
+ connect(m_loader, SIGNAL(guessedApi(int)),
+ this, SLOT(guessedApi(int)));
connect(m_loader, SIGNAL(finishedParsing()),
this, SLOT(finishedParsing()));
- connect(this, SIGNAL(loaderSearchNext(int,QString,Qt::CaseSensitivity)),
- m_loader, SLOT(searchNext(int,QString,Qt::CaseSensitivity)));
- connect(this, SIGNAL(loaderSearchPrev(int,QString,Qt::CaseSensitivity)),
- m_loader, SLOT(searchPrev(int,QString,Qt::CaseSensitivity)));
+ connect(this, SIGNAL(loaderSearch(ApiTrace::SearchRequest)),
+ m_loader, SLOT(search(ApiTrace::SearchRequest)));
connect(m_loader,
- SIGNAL(searchResult(ApiTrace::SearchResult,ApiTraceCall*)),
+ SIGNAL(searchResult(ApiTrace::SearchRequest,ApiTrace::SearchResult,ApiTraceCall*)),
this,
- SLOT(loaderSearchResult(ApiTrace::SearchResult,ApiTraceCall*)));
+ SLOT(loaderSearchResult(ApiTrace::SearchRequest,ApiTrace::SearchResult,ApiTraceCall*)));
connect(this, SIGNAL(loaderFindFrameStart(ApiTraceFrame*)),
m_loader, SLOT(findFrameStart(ApiTraceFrame*)));
connect(this, SIGNAL(loaderFindFrameEnd(ApiTraceFrame*)),
delete m_saver;
}
-bool ApiTrace::isCallAFrameMarker(const ApiTraceCall *call,
- ApiTrace::FrameMarker marker)
-{
- if (!call) {
- return false;
- }
-
- switch (marker) {
- case FrameMarker_SwapBuffers:
- return call->name().contains(QLatin1String("SwapBuffers")) ||
- call->name() == QLatin1String("CGLFlushDrawable") ||
- call->name() == QLatin1String("glFrameTerminatorGREMEDY");
- case FrameMarker_Flush:
- return call->name() == QLatin1String("glFlush");
- case FrameMarker_Finish:
- return call->name() == QLatin1String("glFinish");
- case FrameMarker_Clear:
- return call->name() == QLatin1String("glClear");
- }
-
- Q_ASSERT(!"unknown frame marker");
-
- return false;
-}
-
bool ApiTrace::isEmpty() const
{
return m_frames.isEmpty();
return m_fileName;
}
-ApiTrace::FrameMarker ApiTrace::frameMarker() const
-{
- return m_frameMarker;
-}
-
-QList<ApiTraceFrame*> ApiTrace::frames() const
+const QList<ApiTraceFrame*> & ApiTrace::frames() const
{
return m_frames;
}
{
if (m_fileName != name) {
m_fileName = name;
+ m_tempFileName = QString();
m_frames.clear();
m_errors.clear();
m_editedCalls.clear();
+ m_queuedErrors.clear();
m_needsSaving = false;
emit invalidated();
bool ApiTrace::hasErrors() const
{
- return !m_errors.isEmpty();
+ return !m_errors.isEmpty() || !m_queuedErrors.isEmpty();
}
void ApiTrace::loadFrame(ApiTraceFrame *frame)
{
- Q_ASSERT(!frame->isLoaded());
- emit requestFrame(frame);
+ if (!isFrameLoading(frame)) {
+ Q_ASSERT(!frame->isLoaded());
+ m_loadingFrames.insert(frame);
+ emit requestFrame(frame);
+ }
+}
+
+void ApiTrace::guessedApi(int api)
+{
+ m_api = static_cast<trace::API>(api);
+}
+
+trace::API ApiTrace::api() const
+{
+ return m_api;
}
void ApiTrace::finishedParsing()
{
- ApiTraceFrame *firstFrame = m_frames[0];
- if (firstFrame && !firstFrame->isLoaded()) {
- loadFrame(firstFrame);
+ if (!m_frames.isEmpty()) {
+ ApiTraceFrame *firstFrame = m_frames[0];
+ if (firstFrame && !firstFrame->isLoaded()) {
+ loadFrame(firstFrame);
+ }
}
}
quint64 binaryDataSize)
{
Q_ASSERT(frame->numChildrenToLoad() == calls.size());
- emit beginLoadingFrame(frame, calls.size());
- frame->setCalls(calls, binaryDataSize);
- emit endLoadingFrame(frame);
+
+ if (!frame->isLoaded()) {
+ emit beginLoadingFrame(frame, calls.size());
+ frame->setCalls(calls, binaryDataSize);
+ emit endLoadingFrame(frame);
+ m_loadingFrames.remove(frame);
+ }
if (!m_queuedErrors.isEmpty()) {
QList< QPair<ApiTraceFrame*, ApiTraceError> >::iterator itr;
{
ApiTraceCall *foundCall = 0;
int frameIdx = m_frames.indexOf(frame);
+ SearchRequest request(SearchRequest::Next,
+ frame, from, str, sensitivity);
if (frame->isLoaded()) {
foundCall = frame->findNextCall(from, str, sensitivity);
if (foundCall) {
- emit findResult(SearchResult_Found, foundCall);
+ emit findResult(request, SearchResult_Found, foundCall);
return;
}
frameIdx += 1;
}
+ //for the rest of the frames we search from beginning
+ request.from = 0;
for (int i = frameIdx; i < m_frames.count(); ++i) {
ApiTraceFrame *frame = m_frames[i];
+ request.frame = frame;
if (!frame->isLoaded()) {
- emit loaderSearchNext(i, str, sensitivity);
+ emit loaderSearch(request);
return;
} else {
ApiTraceCall *call = frame->findNextCall(0, str, sensitivity);
if (call) {
- emit findResult(SearchResult_Found, call);
+ emit findResult(request, SearchResult_Found, call);
return;
}
}
}
- emit findResult(SearchResult_Wrapped, 0);
+ emit findResult(request, SearchResult_Wrapped, 0);
}
void ApiTrace::findPrev(ApiTraceFrame *frame,
{
ApiTraceCall *foundCall = 0;
int frameIdx = m_frames.indexOf(frame);
+ SearchRequest request(SearchRequest::Prev,
+ frame, from, str, sensitivity);
if (frame->isLoaded()) {
foundCall = frame->findPrevCall(from, str, sensitivity);
if (foundCall) {
- emit findResult(SearchResult_Found, foundCall);
+ emit findResult(request, SearchResult_Found, foundCall);
return;
}
frameIdx -= 1;
}
+ request.from = 0;
for (int i = frameIdx; i >= 0; --i) {
ApiTraceFrame *frame = m_frames[i];
+ request.frame = frame;
if (!frame->isLoaded()) {
- emit loaderSearchPrev(i, str, sensitivity);
+ emit loaderSearch(request);
return;
} else {
ApiTraceCall *call = frame->findPrevCall(0, str, sensitivity);
if (call) {
- emit findResult(SearchResult_Found, call);
+ emit findResult(request, SearchResult_Found, call);
return;
}
}
}
- emit findResult(SearchResult_Wrapped, 0);
+ emit findResult(request, SearchResult_Wrapped, 0);
}
-void ApiTrace::loaderSearchResult(ApiTrace::SearchResult result,
+void ApiTrace::loaderSearchResult(const ApiTrace::SearchRequest &request,
+ ApiTrace::SearchResult result,
ApiTraceCall *call)
{
//qDebug()<<"Search result = "<<result
// <<", call is = "<<call;
- emit findResult(result, call);
+ emit findResult(request, result, call);
}
void ApiTrace::findFrameStart(ApiTraceFrame *frame)
{
+ if (!frame)
+ return;
+
if (frame->isLoaded()) {
emit foundFrameStart(frame);
} else {
void ApiTrace::findFrameEnd(ApiTraceFrame *frame)
{
+ if (!frame)
+ return;
+
if (frame->isLoaded()) {
emit foundFrameEnd(frame);
} else {
{
unsigned numCalls = 0;
- for (int frameIdx = 0; frameIdx <= m_frames.size(); ++frameIdx) {
+ for (int frameIdx = 0; frameIdx < m_frames.size(); ++frameIdx) {
const ApiTraceFrame *frame = m_frames[frameIdx];
unsigned numCallsInFrame = frame->isLoaded()
? frame->numChildren()
}
emit changed(call);
} else {
- emit requestFrame(frame);
+ loadFrame(frame);
m_queuedErrors.append(qMakePair(frame, error));
}
}
+bool ApiTrace::isFrameLoading(ApiTraceFrame *frame) const
+{
+ return m_loadingFrames.contains(frame);
+}
+
+void ApiTrace::bindThumbnailsToFrames(const QList<QImage> &thumbnails)
+{
+ QList<ApiTraceFrame *> frames = m_frames;
+
+ QList<QImage>::const_iterator thumbnail = thumbnails.begin();
+
+ foreach (ApiTraceFrame *frame, frames) {
+ if (thumbnail != thumbnails.end()) {
+ frame->setThumbnail(*thumbnail);
+
+ ++thumbnail;
+
+ emit changed(frame);
+ }
+ }
+}
+
#include "apitrace.moc"