allows us to split calls into frames and do other postprocessing.
set(qapitrace_SRCS
+ apitrace.cpp
apicalldelegate.cpp
apitracecall.cpp
apitracefilter.cpp
{
}
-void ApiCallDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option,
+void ApiCallDelegate::paint(QPainter *painter,
+ const QStyleOptionViewItem &option,
const QModelIndex &index) const
{
ApiTraceCall *call = index.data().value<ApiTraceCall*>();
//text.setTextWidth(option.rect.width());
QStyledItemDelegate::paint(painter, option, index);
painter->drawStaticText(option.rect.topLeft(), text);
- } else{
- QStyledItemDelegate::paint(painter, option, index);
+ } else {
+ ApiTraceFrame *frame = index.data().value<ApiTraceFrame*>();
+ if (frame) {
+ QStaticText text = frame->staticText();
+ //text.setTextWidth(option.rect.width());
+ QStyledItemDelegate::paint(painter, option, index);
+ painter->drawStaticText(option.rect.topLeft(), text);
+ } else {
+ QStyledItemDelegate::paint(painter, option, index);
+ }
}
}
QStaticText text = call->staticText();
//text.setTextWidth(option.rect.width());
return text.size().toSize();
+ } else {
+ ApiTraceFrame *frame = index.data().value<ApiTraceFrame*>();
+ if (frame) {
+ QStaticText text = frame->staticText();
+ //text.setTextWidth(option.rect.width());
+ return text.size().toSize();
+ }
}
return QStyledItemDelegate::sizeHint(option, index);
}
#ifndef APICALLDELEGATE_H
#define APICALLDELEGATE_H
-
-
#include <QStyledItemDelegate>
class ApiCallDelegate : public QStyledItemDelegate
--- /dev/null
+#include "apitrace.h"
+
+#include "loaderthread.h"
+
+ApiTrace::ApiTrace()
+ : m_frameMarker(ApiTrace::FrameMarker_SwapBuffers)
+{
+ m_loader = new LoaderThread(this);
+ connect(m_loader, SIGNAL(parsedFrames(const QList<ApiTraceFrame*>)),
+ this, SLOT(addFrames(const QList<ApiTraceFrame*>)));
+}
+
+ApiTrace::~ApiTrace()
+{
+ qDeleteAll(m_calls);
+ qDeleteAll(m_frames);
+ delete m_loader;
+}
+
+bool ApiTrace::isCallAFrameMarker(const ApiTraceCall *call,
+ ApiTrace::FrameMarker marker)
+{
+ if (!call)
+ return false;
+
+ switch (marker) {
+ case FrameMarker_SwapBuffers:
+ return call->name.contains(QLatin1String("SwapBuffers"));
+ 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_calls.isEmpty();
+}
+
+QString ApiTrace::fileName() const
+{
+ return m_fileName;
+}
+
+ApiTrace::FrameMarker ApiTrace::frameMarker() const
+{
+ return m_frameMarker;
+}
+
+QList<ApiTraceCall*> ApiTrace::calls() const
+{
+ return m_calls;
+}
+
+ApiTraceCall * ApiTrace::callAt(int idx) const
+{
+ return m_calls.value(idx);
+}
+
+int ApiTrace::numCalls() const
+{
+ return m_calls.count();
+}
+
+QList<ApiTraceFrame*> ApiTrace::frames() const
+{
+ return m_frames;
+}
+
+ApiTraceFrame * ApiTrace::frameAt(int idx) const
+{
+ return m_frames.value(idx);
+}
+
+int ApiTrace::numFrames() const
+{
+ return m_frames.count();
+}
+
+int ApiTrace::numCallsInFrame(int idx) const
+{
+ const ApiTraceFrame *frame = frameAt(idx);
+ if (frame)
+ return frame->calls.count();
+ else
+ return 0;
+}
+
+void ApiTrace::setFileName(const QString &name)
+{
+ if (m_fileName != name) {
+ m_fileName = name;
+
+ if (m_loader->isRunning()) {
+ m_loader->terminate();
+ m_loader->wait();
+ }
+ emit invalidated();
+
+ m_loader->loadFile(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)
+{
+ int currentFrames = m_frames.count();
+ int numNewFrames = frames.count();
+ m_frames += frames;
+
+ int currentCalls = m_calls.count();
+ int numNewCalls = 0;
+ foreach(ApiTraceFrame *frame, frames) {
+ numNewCalls += frame->calls.count();
+ m_calls += frame->calls;
+ }
+
+ emit framesAdded(currentFrames, numNewFrames);
+ emit callsAdded(currentCalls, numNewCalls);
+}
+
+void ApiTrace::detectFrames()
+{
+ if (m_calls.isEmpty())
+ return;
+
+ ApiTraceFrame *currentFrame = 0;
+ foreach(ApiTraceCall *apiCall, m_calls) {
+ if (!currentFrame) {
+ currentFrame = new ApiTraceFrame();
+ currentFrame->number = m_frames.count();
+ }
+ apiCall->parentFrame = currentFrame;
+ apiCall->index = currentFrame->calls.count();
+ currentFrame->calls.append(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 framesAdded(0, m_frames.count());
+}
+
+#include "apitrace.moc"
--- /dev/null
+#ifndef APITRACE_H
+#define APITRACE_H
+
+#include "apitracecall.h"
+
+#include <QObject>
+
+class LoaderThread;
+
+class ApiTrace : public QObject
+{
+ Q_OBJECT
+public:
+ enum FrameMarker {
+ FrameMarker_SwapBuffers,
+ FrameMarker_Flush,
+ FrameMarker_Finish,
+ FrameMarker_Clear
+ };
+ static bool isCallAFrameMarker(const ApiTraceCall *call,
+ FrameMarker marker);
+public:
+ ApiTrace();
+ ~ApiTrace();
+
+ bool isEmpty() const;
+
+ QString fileName() const;
+
+ FrameMarker frameMarker() const;
+
+ QList<ApiTraceCall*> calls() const;
+ ApiTraceCall *callAt(int idx) const;
+ int numCalls() const;
+
+ QList<ApiTraceFrame*> frames() const;
+ ApiTraceFrame *frameAt(int idx) const;
+ int numFrames() const;
+ int numCallsInFrame(int idx) const;
+
+public slots:
+ void setFileName(const QString &name);
+ void setFrameMarker(FrameMarker marker);
+
+signals:
+ void invalidated();
+ void framesInvalidated();
+
+ void framesAdded(int oldCount, int numAdded);
+ void callsAdded(int oldCount, int numAdded);
+
+private slots:
+ void addFrames(const QList<ApiTraceFrame*> &frames);
+private:
+ void detectFrames();
+private:
+ QString m_fileName;
+
+ QList<ApiTraceFrame*> m_frames;
+ QList<ApiTraceCall*> m_calls;
+
+ FrameMarker m_frameMarker;
+
+ LoaderThread *m_loader;
+};
+
+#endif
}
return m_filterText;
}
+
+QStaticText ApiTraceFrame::staticText() const
+{
+ if (!m_staticText.text().isEmpty())
+ return m_staticText;
+
+ QString richText =
+ QString::fromLatin1("<span style=\"font-weight:bold\">Frame %1</span>").arg(number);
+
+ m_staticText.setText(richText);
+ QTextOption opt;
+ opt.setWrapMode(QTextOption::NoWrap);
+ m_staticText.setTextOption(opt);
+ m_staticText.prepare();
+
+ return m_staticText;
+}
+
+int ApiTraceCall::numChildren() const
+{
+ return 0;
+}
+
+int ApiTraceFrame::numChildren() const
+{
+ return calls.count();
+}
+
+ApiTraceFrame::ApiTraceFrame()
+ : ApiTraceEvent(ApiTraceEvent::Frame)
+{
+}
+
+ApiTraceCall::ApiTraceCall()
+ : ApiTraceEvent(ApiTraceEvent::Call)
+{
+}
+
+ApiTraceEvent::ApiTraceEvent()
+ : m_type(ApiTraceEvent::None)
+{
+}
+
+ApiTraceEvent::ApiTraceEvent(Type t)
+ : m_type(t)
+{
+}
+
+ApiTraceCall::~ApiTraceCall()
+{
+}
QString apiVariantToString(const QVariant &variant);
-class ApiTraceCall
+class ApiTraceFrame;
+
+class ApiTraceEvent
{
public:
+ enum Type {
+ None,
+ Call,
+ Frame
+ };
+public:
+ ApiTraceEvent();
+ ApiTraceEvent(Type t);
+
+ Type type() const { return m_type; }
+
+ virtual QStaticText staticText() const = 0;
+ virtual int numChildren() const = 0;
+
+protected:
+ Type m_type;
+};
+Q_DECLARE_METATYPE(ApiTraceEvent*);
+
+class ApiTraceCall : public ApiTraceEvent
+{
+public:
+ ApiTraceCall();
+ ~ApiTraceCall();
+
+ int index;
QString name;
QStringList argNames;
QVariantList argValues;
QVariant returnValue;
+ ApiTraceFrame *parentFrame;
QString toHtml() const;
QString filterText() const;
QStaticText staticText() const;
+ int numChildren() const;
private:
mutable QString m_richText;
mutable QString m_filterText;
mutable QStaticText m_staticText;
};
-Q_DECLARE_METATYPE(ApiTraceCall);
Q_DECLARE_METATYPE(ApiTraceCall*);
+class ApiTraceFrame : public ApiTraceEvent
+{
+public:
+ ApiTraceFrame();
+ int number;
+ QList<ApiTraceCall*> calls;
+
+
+ int numChildren() const;
+ QStaticText staticText() const;
+private:
+ mutable QStaticText m_staticText;
+};
+Q_DECLARE_METATYPE(ApiTraceFrame*);
+
+
#endif
#include <QDebug>
-ApiTraceFilter::ApiTraceFilter(QObject *parent )
+ApiTraceFilter::ApiTraceFilter(QObject *parent)
: QSortFilterProxyModel()
{
}
QVariant varientData = sourceModel()->data(index0);
ApiTraceCall *call = varientData.value<ApiTraceCall*>();
- if (!call)
- return false;
+ if (!call) {
+ ApiTraceFrame *frame = varientData.value<ApiTraceFrame*>();
+ return frame != 0;
+ }
QString function = call->name;
ApiTraceModel::ApiTraceModel(QObject *parent)
- : QAbstractItemModel(parent)
+ : QAbstractItemModel(parent),
+ m_trace(0)
{
- m_loader = new LoaderThread();
-
- connect(m_loader, SIGNAL(parsedCalls(const QList<Trace::Call*>&)),
- SLOT(appendCalls(const QList<Trace::Call*>&)));
}
ApiTraceModel::~ApiTraceModel()
{
- qDeleteAll(m_calls);
- delete m_loader;
+ m_trace = 0;
}
QVariant ApiTraceModel::data(const QModelIndex &index, int role) const
if (role != Qt::DisplayRole)
return QVariant();
- ApiTraceCall *item = m_calls.value(index.row());
-
- if (!item)
+ //data only in the first column
+ if (index.column() != 0)
return QVariant();
- switch (index.column()) {
- case 0: {
- return QVariant::fromValue(item);
- }
- default:
- return QVariant();
+ ApiTraceEvent *itm = item(index);
+ if (itm) {
+ if (itm->type() == ApiTraceEvent::Frame) {
+ ApiTraceFrame *frame =
+ static_cast<ApiTraceFrame *>(itm);
+ return QVariant::fromValue(frame);
+ } else if (itm->type() == ApiTraceEvent::Call) {
+ ApiTraceCall *call =
+ static_cast<ApiTraceCall *>(itm);
+ return QVariant::fromValue(call);
+ }
}
+
+ return QVariant();
}
Qt::ItemFlags ApiTraceModel::flags(const QModelIndex &index) const
if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
switch (section) {
case 0:
- return tr("Function");
+ return tr("Event");
default:
//fall through
break;
if (parent.isValid() && parent.column() != 0)
return QModelIndex();
- ApiTraceCall *call = m_calls.value(row);
-
- if (call)
- return createIndex(row, column, call);
- else
- return QModelIndex();
+ if (parent.isValid()) {
+ QVariant data = parent.data();
+ ApiTraceFrame *frame = data.value<ApiTraceFrame*>();
+ if (!frame) {
+ qDebug()<<"got a valid parent but it's not a frame "<<data;
+ return QModelIndex();
+ }
+ ApiTraceCall *call = frame->calls.value(row);
+ if (call)
+ return createIndex(row, column, call);
+ else
+ return QModelIndex();
+ } else {
+ ApiTraceFrame *frame = m_trace->frameAt(row);
+ if (frame)
+ return createIndex(row, column, frame);
+ else
+ return QModelIndex();
+ }
+ return QModelIndex();
}
bool ApiTraceModel::hasChildren(const QModelIndex &parent) const
{
- return parent.isValid() ? false : (rowCount() > 0);
+ if (parent.isValid()) {
+ ApiTraceFrame *frame = parent.data().value<ApiTraceFrame*>();
+ if (frame)
+ return !frame->calls.isEmpty();
+ else
+ return false;
+ } else {
+ return (rowCount() > 0);
+ }
}
QModelIndex ApiTraceModel::parent(const QModelIndex &index) const
if (!index.isValid())
return QModelIndex();
- //list for now
+ ApiTraceCall *call = index.data().value<ApiTraceCall*>();
+ if (call) {
+ Q_ASSERT(call->parentFrame);
+ return createIndex(call->parentFrame->number,
+ 0, call->parentFrame);
+ }
return QModelIndex();
}
int ApiTraceModel::rowCount(const QModelIndex &parent) const
{
- return m_calls.count();
+ if (!parent.isValid())
+ return m_trace->numFrames();
+
+ ApiTraceCall *call = parent.data().value<ApiTraceCall*>();
+ if (call)
+ return 0;
+
+ ApiTraceFrame *frame = parent.data().value<ApiTraceFrame*>();
+ if (frame)
+ return frame->calls.count();
+
+ return 0;
}
int ApiTraceModel::columnCount(const QModelIndex &parent) const
{
- return parent.isValid() ? 0 : 1;
+ return 1;
}
Q_UNUSED(parent);
- if (m_calls.count() <= position)
- return false;
-
beginRemoveRows(parent, position, position + rows - 1);
- for (int i = 0; i < rows; ++i) {
- ApiTraceCall *call = m_calls.value(i);
- m_calls.removeAt(i);
- delete call;
- }
+ //XXX remove it from ApiTrace
endRemoveRows();
return success;
}
-void ApiTraceModel::loadTraceFile(const QString &fileName)
+void ApiTraceModel::setApiTrace(ApiTrace *trace)
{
- if (m_loader->isRunning()) {
- m_loader->terminate();
- m_loader->wait();
- }
- removeRows(0, m_calls.count(), QModelIndex());
-
- m_loader->loadFile(fileName);
+ if (m_trace == trace)
+ return;
+ if (m_trace)
+ disconnect(m_trace);
+ m_trace = trace;
+ connect(m_trace, SIGNAL(framesInvalidated()),
+ this, SLOT(invalidateFrames()));
+ connect(m_trace, SIGNAL(framesAdded(int, int)),
+ this, SLOT(appendFrames(int, int)));
}
-void ApiTraceModel::appendCalls(const QList<Trace::Call*> traceCalls)
+const ApiTrace * ApiTraceModel::apiTrace() const
{
- beginInsertRows(QModelIndex(), m_calls.count(),
- m_calls.count() + traceCalls.count());
- foreach(Trace::Call *call, traceCalls) {
- ApiTraceCall *apiCall = new ApiTraceCall;
- apiCall->name = QString::fromStdString(call->sig->name);
+ return m_trace;
+}
- QString argumentsText;
- for (int i = 0; i < call->sig->arg_names.size(); ++i) {
- apiCall->argNames +=
- QString::fromStdString(call->sig->arg_names[i]);
- }
- if (call->ret) {
- VariantVisitor retVisitor;
- call->ret->visit(retVisitor);
- apiCall->returnValue = retVisitor.variant();
- }
- for (int i = 0; i < call->args.size(); ++i) {
- VariantVisitor argVisitor;
- call->args[i]->visit(argVisitor);
- apiCall->argValues += argVisitor.variant();
- }
+void ApiTraceModel::invalidateFrames()
+{
+ beginResetModel();
+ endResetModel();
+}
- m_calls.append(apiCall);
- }
+void ApiTraceModel::appendFrames(int oldCount, int numAdded)
+{
+ beginInsertRows(QModelIndex(), oldCount,
+ oldCount + numAdded);
endInsertRows();
+}
- qDeleteAll(traceCalls);
+ApiTraceEvent * ApiTraceModel::item(const QModelIndex &index) const
+{
+ if (!index.isValid())
+ return 0;
+ return static_cast<ApiTraceEvent*>(index.internalPointer());
}
#include "apitracemodel.moc"
#include <QModelIndex>
#include <QVariant>
+class ApiTrace;
class ApiTraceCall;
-class LoaderThread;
-namespace Trace {
- class Call;
-}
+class ApiTraceEvent;
class ApiTraceModel : public QAbstractItemModel
{
Q_OBJECT
-
public:
ApiTraceModel(QObject *parent = 0);
~ApiTraceModel();
+ void setApiTrace(ApiTrace *trace);
+ const ApiTrace *apiTrace() const;
+
+public:
+ /* QAbstractItemModel { */
QVariant data(const QModelIndex &index, int role) const;
Qt::ItemFlags flags(const QModelIndex &index) const;
QVariant headerData(int section, Qt::Orientation orientation,
const QModelIndex &parent = QModelIndex());
bool removeRows(int position, int rows,
const QModelIndex &parent = QModelIndex());
+ /* } QAbstractItemModel; */
-public slots:
- void loadTraceFile(const QString &fileName);
- void appendCalls(const QList<Trace::Call*> traceCalls);
+private slots:
+ void invalidateFrames();
+ void appendFrames(int oldCount, int numAdded);
+
+private:
+ ApiTraceEvent *item(const QModelIndex &index) const;
private:
- QList<ApiTraceCall*> m_calls;
- LoaderThread *m_loader;
+ ApiTrace *m_trace;
};
#endif
#include "trace_parser.hpp"
+#define FRAMES_TO_CACHE 100
+
+static ApiTraceCall *
+apiCallFromTraceCall(const Trace::Call *call)
+{
+ ApiTraceCall *apiCall = new ApiTraceCall();
+ apiCall->name = QString::fromStdString(call->sig->name);
+
+ QString argumentsText;
+ for (int i = 0; i < call->sig->arg_names.size(); ++i) {
+ apiCall->argNames +=
+ QString::fromStdString(call->sig->arg_names[i]);
+ }
+ if (call->ret) {
+ VariantVisitor retVisitor;
+ call->ret->visit(retVisitor);
+ apiCall->returnValue = retVisitor.variant();
+ }
+ for (int i = 0; i < call->args.size(); ++i) {
+ VariantVisitor argVisitor;
+ call->args[i]->visit(argVisitor);
+ apiCall->argValues += argVisitor.variant();
+ }
+
+ return apiCall;
+}
+
LoaderThread::LoaderThread(QObject *parent)
- : QThread(parent)
+ : QThread(parent),
+ m_frameMarker(ApiTrace::FrameMarker_SwapBuffers)
{
}
void LoaderThread::run()
{
- QList<Trace::Call*> traceCalls;
+ QList<ApiTraceFrame*> frames;
+ ApiTraceFrame *currentFrame = 0;
+ int frameCount = 0;
Trace::Parser p;
if (p.open(m_fileName.toLatin1().constData())) {
Trace::Call *call;
call = p.parse_call();
while (call) {
//std::cout << *call;
- traceCalls.append(call);
- if (traceCalls.count() >= 1000) {
- emit parsedCalls(traceCalls);
- traceCalls.clear();
+ if (!currentFrame) {
+ currentFrame = new ApiTraceFrame();
+ currentFrame->number = frameCount;
+ ++frameCount;
+ }
+ ApiTraceCall *apiCall =
+ apiCallFromTraceCall(call);
+ apiCall->parentFrame = currentFrame;
+ apiCall->index = currentFrame->calls.count();
+ currentFrame->calls.append(apiCall);
+ if (ApiTrace::isCallAFrameMarker(apiCall,
+ m_frameMarker)) {
+ frames.append(currentFrame);
+ currentFrame = 0;
+ if (frames.count() >= FRAMES_TO_CACHE) {
+ emit parsedFrames(frames);
+ frames.clear();
+ }
}
call = p.parse_call();
}
}
- if (traceCalls.count()) {
- emit parsedCalls(traceCalls);
- traceCalls.clear();
+ //last frames won't have markers
+ // it's just a bunch of Delete calls for every object
+ // after the last SwapBuffers
+ if (currentFrame) {
+ frames.append(currentFrame);
+ currentFrame = 0;
+ }
+ if (frames.count()) {
+ emit parsedFrames(frames);
}
}
start();
}
+ApiTrace::FrameMarker LoaderThread::frameMarker() const
+{
+ return m_frameMarker;
+}
+
+void LoaderThread::setFrameMarker(ApiTrace::FrameMarker marker)
+{
+ Q_ASSERT(!isRunning());
+ m_frameMarker = marker;
+}
+
#include "loaderthread.moc"
#ifndef LOADERTHREAD_H
#define LOADERTHREAD_H
+#include "apitrace.h"
#include <QThread>
#include <QList>
class ApiTraceCall;
-namespace Trace {
- class Call;
-}
+class ApiTraceFrame;
class LoaderThread : public QThread
{
public:
LoaderThread(QObject *parent=0);
+ ApiTrace::FrameMarker frameMarker() const;
+ void setFrameMarker(ApiTrace::FrameMarker marker);
public slots:
void loadFile(const QString &fileName);
signals:
- void parsedCalls(const QList<Trace::Call*> &calls);
+ void parsedFrames(const QList<ApiTraceFrame*> &frames);
protected:
virtual void run();
private:
QString m_fileName;
+ ApiTrace::FrameMarker m_frameMarker;
};
#endif
#include "mainwindow.h"
-#include "trace_model.hpp"
+#include "apitracecall.h"
#include <QApplication>
#include <QMetaType>
#include <QVariant>
-Q_DECLARE_METATYPE(QList<Trace::Call*>);
+Q_DECLARE_METATYPE(QList<ApiTraceFrame*>);
int main(int argc, char **argv)
{
QApplication app(argc, argv);
- qRegisterMetaType<QList<Trace::Call*> >();
+ qRegisterMetaType<QList<ApiTraceFrame*> >();
MainWindow window;
window.show();
#include "mainwindow.h"
+#include "apitrace.h"
#include "apitracecall.h"
#include "apicalldelegate.h"
#include "apitracemodel.h"
{
m_ui.setupUi(this);
+ m_trace = new ApiTrace();
+
m_model = new ApiTraceModel();
+ m_model->setApiTrace(m_trace);
m_proxyModel = new ApiTraceFilter();
m_proxyModel->setSourceModel(m_model);
m_ui.callView->setModel(m_proxyModel);
qDebug()<< "File name : " <<fileName;
newTraceFile(fileName);
- m_model->loadTraceFile(fileName);
}
void MainWindow::loadTrace(const QString &fileName)
}
qDebug()<< "Loading : " <<fileName;
- m_model->loadTraceFile(fileName);
newTraceFile(fileName);
}
void MainWindow::newTraceFile(const QString &fileName)
{
m_traceFileName = fileName;
+ m_trace->setFileName(fileName);
if (m_traceFileName.isEmpty()) {
m_ui.actionReplay->setEnabled(false);
#include <QMainWindow>
#include <QProcess>
-
+class ApiTrace;
class ApiTraceModel;
class ApiTraceFilter;
class QLineEdit;
private:
Ui_MainWindow m_ui;
+ ApiTrace *m_trace;
ApiTraceModel *m_model;
ApiTraceFilter *m_proxyModel;
QLineEdit *m_filterEdit;
<verstretch>0</verstretch>
</sizepolicy>
</property>
+ <property name="minimumSize">
+ <size>
+ <width>77</width>
+ <height>100</height>
+ </size>
+ </property>
<property name="floating">
<bool>false</bool>
</property>
<widget class="QWidget" name="dockWidgetContents">
<layout class="QHBoxLayout" name="horizontalLayout_2">
<item>
- <widget class="QWebView" name="detailsWebView">
+ <widget class="QWebView" name="detailsWebView" native="true">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Ignored">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
- <property name="url">
+ <property name="url" stdset="0">
<url>
<string>about:blank</string>
</url>
</action>
<action name="actionOpen">
<property name="icon">
- <iconset theme="document-open">
+ <iconset>
<normaloff/>
</iconset>
</property>
</action>
<action name="actionQuit">
<property name="icon">
- <iconset theme="application-exit">
+ <iconset>
<normaloff/>
</iconset>
</property>
<bool>false</bool>
</property>
<property name="icon">
- <iconset theme="media-playback-start">
+ <iconset>
<normaloff/>
</iconset>
</property>
<bool>false</bool>
</property>
<property name="icon">
- <iconset theme="media-playback-stop">
+ <iconset>
<normaloff/>
</iconset>
</property>
projects / apitrace / commitdiff