git.cworth.org Git - apitrace/blob - gui/mainwindow.cpp

   1 #include "mainwindow.h"
   2
   3 #include "apitrace.h"
   4 #include "apitracecall.h"
   5 #include "apicalldelegate.h"
   6 #include "apitracemodel.h"
   7 #include "apitracefilter.h"
   8 #include "imageviewer.h"
   9 #include "retracer.h"
  10 #include "settingsdialog.h"
  11 #include "shaderssourcewidget.h"
  12 #include "ui_retracerdialog.h"
  13 #include "vertexdatainterpreter.h"
  14
  15 #include <QAction>
  16 #include <QDebug>
  17 #include <QDesktopServices>
  18 #include <QDir>
  19 #include <QFileDialog>
  20 #include <QLineEdit>
  21 #include <QMessageBox>
  22 #include <QProgressBar>
  23 #include <QToolBar>
  24 #include <QUrl>
  25 #include <QVBoxLayout>
  26 #include <QWebPage>
  27 #include <QWebView>
  28
  29
  30 MainWindow::MainWindow()
  31     : QMainWindow(),
  32       m_selectedEvent(0),
  33       m_stateEvent(0)
  34 {
  35     m_ui.setupUi(this);
  36     initObjects();
  37     initConnections();
  38 }
  39
  40 void MainWindow::openTrace()
  41 {
  42     QString fileName =
  43         QFileDialog::getOpenFileName(
  44             this,
  45             tr("Open Trace"),
  46             QDir::homePath(),
  47             tr("Trace Files (*.trace)"));
  48
  49     qDebug()<< "File name : " <<fileName;
  50
  51     newTraceFile(fileName);
  52 }
  53
  54 void MainWindow::loadTrace(const QString &fileName)
  55 {
  56     if (!QFile::exists(fileName)) {
  57         QMessageBox::warning(this, tr("File Missing"),
  58                              tr("File '%1' doesn't exist.").arg(fileName));
  59         return;
  60     }
  61     qDebug()<< "Loading  : " <<fileName;
  62
  63     m_progressBar->setValue(0);
  64     newTraceFile(fileName);
  65 }
  66
  67 void MainWindow::callItemSelected(const QModelIndex &index)
  68 {
  69     ApiTraceEvent *event =
  70         index.data(ApiTraceModel::EventRole).value<ApiTraceEvent*>();
  71
  72     if (event && event->type() == ApiTraceEvent::Call) {
  73         ApiTraceCall *call = static_cast<ApiTraceCall*>(event);
  74         m_ui.detailsWebView->setHtml(call->toHtml());
  75         m_ui.detailsDock->show();
  76         if (call->hasBinaryData()) {
  77             QByteArray data =
  78                 call->argValues[call->binaryDataIndex()].toByteArray();
  79             m_vdataInterpreter->setData(data);
  80
  81             for (int i = 0; i < call->argNames.count(); ++i) {
  82                 QString name = call->argNames[i];
  83                 if (name == QLatin1String("stride")) {
  84                     int stride = call->argValues[i].toInt();
  85                     m_ui.vertexStrideSB->setValue(stride);
  86                 } else if (name == QLatin1String("size")) {
  87                     int components = call->argValues[i].toInt();
  88                     m_ui.vertexComponentsSB->setValue(components);
  89                 } else if (name == QLatin1String("type")) {
  90                     QString val = call->argValues[i].toString();
  91                     int textIndex = m_ui.vertexTypeCB->findText(val);
  92                     if (textIndex >= 0)
  93                         m_ui.vertexTypeCB->setCurrentIndex(textIndex);
  94                 }
  95             }
  96         }
  97         m_ui.vertexDataDock->setVisible(call->hasBinaryData());
  98         m_selectedEvent = call;
  99     } else {
 100         if (event && event->type() == ApiTraceEvent::Frame) {
 101             m_selectedEvent = static_cast<ApiTraceFrame*>(event);
 102         } else
 103             m_selectedEvent = 0;
 104         m_ui.detailsDock->hide();
 105         m_ui.vertexDataDock->hide();
 106     }
 107     if (m_selectedEvent && !m_selectedEvent->state().isEmpty()) {
 108         fillStateForFrame();
 109     } else
 110         m_ui.stateDock->hide();
 111 }
 112
 113 void MainWindow::filterTrace()
 114 {
 115     m_proxyModel->setFilterString(m_filterEdit->text());
 116 }
 117
 118 void MainWindow::replayStart()
 119 {
 120     QDialog dlg;
 121     Ui_RetracerDialog dlgUi;
 122     dlgUi.setupUi(&dlg);
 123
 124     dlgUi.doubleBufferingCB->setChecked(
 125         m_retracer->isDoubleBuffered());
 126     dlgUi.benchmarkCB->setChecked(
 127         m_retracer->isBenchmarking());
 128
 129     if (dlg.exec() == QDialog::Accepted) {
 130         m_retracer->setDoubleBuffered(
 131             dlgUi.doubleBufferingCB->isChecked());
 132         m_retracer->setBenchmarking(
 133             dlgUi.benchmarkCB->isChecked());
 134         replayTrace(false);
 135     }
 136 }
 137
 138 void MainWindow::replayStop()
 139 {
 140     m_retracer->quit();
 141     m_ui.actionStop->setEnabled(false);
 142     m_ui.actionReplay->setEnabled(true);
 143     m_ui.actionLookupState->setEnabled(true);
 144 }
 145
 146 void MainWindow::newTraceFile(const QString &fileName)
 147 {
 148     m_traceFileName = fileName;
 149     m_trace->setFileName(fileName);
 150
 151     if (m_traceFileName.isEmpty()) {
 152         m_ui.actionReplay->setEnabled(false);
 153         m_ui.actionLookupState->setEnabled(false);
 154         setWindowTitle(tr("QApiTrace"));
 155     } else {
 156         QFileInfo info(fileName);
 157         m_ui.actionReplay->setEnabled(true);
 158         m_ui.actionLookupState->setEnabled(true);
 159         setWindowTitle(
 160             tr("QApiTrace - %1").arg(info.fileName()));
 161     }
 162 }
 163
 164 void MainWindow::replayFinished(const QString &output)
 165 {
 166     m_ui.actionStop->setEnabled(false);
 167     m_ui.actionReplay->setEnabled(true);
 168     m_ui.actionLookupState->setEnabled(true);
 169
 170     m_progressBar->hide();
 171     if (output.length() < 80) {
 172         statusBar()->showMessage(output);
 173     }
 174     m_stateEvent = 0;
 175     statusBar()->showMessage(
 176         tr("Replaying finished!"), 2000);
 177 }
 178
 179 void MainWindow::replayError(const QString &message)
 180 {
 181     m_ui.actionStop->setEnabled(false);
 182     m_ui.actionReplay->setEnabled(true);
 183     m_ui.actionLookupState->setEnabled(true);
 184     m_stateEvent = 0;
 185
 186     m_progressBar->hide();
 187     statusBar()->showMessage(
 188         tr("Replaying unsuccessful."), 2000);
 189     QMessageBox::warning(
 190         this, tr("Replay Failed"), message);
 191 }
 192
 193 void MainWindow::startedLoadingTrace()
 194 {
 195     Q_ASSERT(m_trace);
 196     m_progressBar->show();
 197     QFileInfo info(m_trace->fileName());
 198     statusBar()->showMessage(
 199         tr("Loading %1...").arg(info.fileName()));
 200 }
 201
 202 void MainWindow::finishedLoadingTrace()
 203 {
 204     m_progressBar->hide();
 205     if (!m_trace) {
 206         return;
 207     }
 208     QFileInfo info(m_trace->fileName());
 209     statusBar()->showMessage(
 210         tr("Loaded %1").arg(info.fileName()), 3000);
 211 }
 212
 213 void MainWindow::replayTrace(bool dumpState)
 214 {
 215     if (m_traceFileName.isEmpty())
 216         return;
 217
 218     m_retracer->setFileName(m_traceFileName);
 219     m_retracer->setCaptureState(dumpState);
 220     if (m_retracer->captureState() && m_selectedEvent) {
 221         int index = 0;
 222         if (m_selectedEvent->type() == ApiTraceEvent::Call) {
 223             index = static_cast<ApiTraceCall*>(m_selectedEvent)->index;
 224         } else if (m_selectedEvent->type() == ApiTraceEvent::Frame) {
 225             ApiTraceFrame *frame =
 226                 static_cast<ApiTraceFrame*>(m_selectedEvent);
 227             if (frame->calls.isEmpty()) {
 228                 //XXX i guess we could still get the current state
 229                 qDebug()<<"tried to get a state for an empty frame";
 230                 return;
 231             }
 232             index = frame->calls.first()->index;
 233         } else {
 234             qDebug()<<"Unknown event type";
 235             return;
 236         }
 237         m_retracer->setCaptureAtCallNumber(index);
 238     }
 239     m_retracer->start();
 240
 241     m_ui.actionStop->setEnabled(true);
 242     m_progressBar->show();
 243     if (dumpState)
 244         statusBar()->showMessage(
 245             tr("Looking up the state..."));
 246     else
 247         statusBar()->showMessage(
 248             tr("Replaying the trace file..."));
 249 }
 250
 251 void MainWindow::lookupState()
 252 {
 253     if (!m_selectedEvent) {
 254         QMessageBox::warning(
 255             this, tr("Unknown Event"),
 256             tr("To inspect the state select an event in the event list."));
 257         return;
 258     }
 259     m_stateEvent = m_selectedEvent;
 260     replayTrace(true);
 261 }
 262
 263 MainWindow::~MainWindow()
 264 {
 265 }
 266
 267 static void
 268 variantToString(const QVariant &var, QString &str)
 269 {
 270     if (var.type() == QVariant::List) {
 271         QVariantList lst = var.toList();
 272         str += QLatin1String("[");
 273         for (int i = 0; i < lst.count(); ++i) {
 274             QVariant val = lst[i];
 275             variantToString(val, str);
 276             if (i < lst.count() - 1)
 277                 str += QLatin1String(", ");
 278         }
 279         str += QLatin1String("]");
 280     } else if (var.type() == QVariant::Map) {
 281         Q_ASSERT(!"unsupported state type");
 282     } else if (var.type() == QVariant::Hash) {
 283         Q_ASSERT(!"unsupported state type");
 284     } else {
 285         str += var.toString();
 286     }
 287 }
 288
 289 void MainWindow::fillStateForFrame()
 290 {
 291     QVariantMap::const_iterator itr;
 292     QVariantMap params;
 293
 294     if (!m_selectedEvent || m_selectedEvent->state().isEmpty())
 295         return;
 296
 297     const ApiTraceState &state = m_selectedEvent->state();
 298     m_ui.stateTreeWidget->clear();
 299     params = state.parameters();
 300     QList<QTreeWidgetItem *> items;
 301     for (itr = params.constBegin(); itr != params.constEnd(); ++itr) {
 302         QString key = itr.key();
 303         QString val;
 304
 305         variantToString(itr.value(), val);
 306         //qDebug()<<"key = "<<key;
 307         //qDebug()<<"val = "<<val;
 308         QStringList lst;
 309         lst += key;
 310         lst += val;
 311         items.append(new QTreeWidgetItem((QTreeWidget*)0, lst));
 312     }
 313     m_ui.stateTreeWidget->insertTopLevelItems(0, items);
 314
 315     QStringList shaderSources = state.shaderSources();
 316     if (shaderSources.isEmpty()) {
 317         m_sourcesWidget->setShaders(shaderSources);
 318     } else {
 319         m_sourcesWidget->setShaders(shaderSources);
 320     }
 321
 322     const QList<ApiTexture> &textures =
 323         state.textures();
 324
 325     m_ui.surfacesTreeWidget->clear();
 326     if (textures.isEmpty()) {
 327         m_ui.surfacesTab->setDisabled(false);
 328     } else {
 329         QTreeWidgetItem *textureItem =
 330             new QTreeWidgetItem(m_ui.surfacesTreeWidget);
 331         m_ui.surfacesTreeWidget->setIconSize(QSize(64, 64));
 332         textureItem->setText(0, tr("Textures"));
 333         for (int i = 0; i < textures.count(); ++i) {
 334             const ApiTexture &texture =
 335                 textures[i];
 336             QIcon icon(QPixmap::fromImage(texture.thumb()));
 337             QTreeWidgetItem *item = new QTreeWidgetItem(textureItem);
 338             item->setIcon(0, icon);
 339             int width = texture.size().width();
 340             int height = texture.size().height();
 341             QString descr =
 342                 QString::fromLatin1("%1, %2 x %3")
 343                 .arg(texture.target())
 344                 .arg(width)
 345                 .arg(height);
 346             item->setText(1, descr);
 347
 348             item->setData(0, Qt::UserRole,
 349                           texture.image());
 350         }
 351         m_ui.surfacesTab->setEnabled(true);
 352     }
 353     m_ui.stateDock->show();
 354 }
 355
 356 void MainWindow::showSettings()
 357 {
 358     SettingsDialog dialog;
 359     dialog.setFilterOptions(m_proxyModel->filterOptions());
 360
 361     if (dialog.exec() == QDialog::Accepted) {
 362         m_proxyModel->setFilterOptions(dialog.filterOptions());
 363     }
 364 }
 365
 366 void MainWindow::openHelp(const QUrl &url)
 367 {
 368     QDesktopServices::openUrl(url);
 369 }
 370
 371 void MainWindow::showSurfacesMenu(const QPoint &pos)
 372 {
 373     QTreeWidget *tree = m_ui.surfacesTreeWidget;
 374     QTreeWidgetItem *item = tree->itemAt(pos);
 375     if (!item)
 376         return;
 377
 378     QMenu menu(tr("Surfaces"), this);
 379     //add needed actions
 380     QAction *act = menu.addAction(tr("View Image"));
 381     act->setStatusTip(tr("View the currently selected surface"));
 382     connect(act, SIGNAL(triggered()),
 383             SLOT(showSelectedSurface()));
 384
 385     menu.exec(tree->viewport()->mapToGlobal(pos));
 386 }
 387
 388 void MainWindow::showSelectedSurface()
 389 {
 390     QTreeWidgetItem *item =
 391         m_ui.surfacesTreeWidget->currentItem();
 392
 393     if (!item)
 394         return;
 395
 396     QVariant var = item->data(0, Qt::UserRole);
 397     m_imageViewer->setImage(var.value<QImage>());
 398     m_imageViewer->show();
 399     m_imageViewer->raise();
 400     m_imageViewer->activateWindow();
 401 }
 402
 403 void MainWindow::initObjects()
 404 {
 405     m_ui.stateTreeWidget->sortByColumn(0, Qt::AscendingOrder);
 406
 407     m_sourcesWidget = new ShadersSourceWidget(m_ui.shadersTab);
 408     QVBoxLayout *layout = new QVBoxLayout;
 409     layout->addWidget(m_sourcesWidget);
 410     m_ui.shadersTab->setLayout(layout);
 411
 412     m_trace = new ApiTrace();
 413     m_retracer = new Retracer(this);
 414
 415     m_vdataInterpreter = new VertexDataInterpreter(this);
 416     m_vdataInterpreter->setListWidget(m_ui.vertexDataListWidget);
 417     m_vdataInterpreter->setStride(
 418         m_ui.vertexStrideSB->value());
 419     m_vdataInterpreter->setComponents(
 420         m_ui.vertexComponentsSB->value());
 421     m_vdataInterpreter->setStartingOffset(
 422         m_ui.startingOffsetSB->value());
 423     m_vdataInterpreter->setTypeFromString(
 424         m_ui.vertexTypeCB->currentText());
 425
 426     m_imageViewer = new ImageViewer(this);
 427
 428     m_model = new ApiTraceModel();
 429     m_model->setApiTrace(m_trace);
 430     m_proxyModel = new ApiTraceFilter();
 431     m_proxyModel->setSourceModel(m_model);
 432     m_ui.callView->setModel(m_proxyModel);
 433     m_ui.callView->setItemDelegate(new ApiCallDelegate);
 434     m_ui.callView->resizeColumnToContents(0);
 435     m_ui.callView->header()->swapSections(0, 1);
 436     m_ui.callView->setColumnWidth(1, 42);
 437
 438     QToolBar *toolBar = addToolBar(tr("Navigation"));
 439     m_filterEdit = new QLineEdit(toolBar);
 440     toolBar->addWidget(m_filterEdit);
 441
 442     m_progressBar = new QProgressBar();
 443     m_progressBar->setRange(0, 0);
 444     statusBar()->addPermanentWidget(m_progressBar);
 445     m_progressBar->hide();
 446
 447     m_ui.detailsDock->hide();
 448     m_ui.vertexDataDock->hide();
 449     m_ui.stateDock->hide();
 450     setDockOptions(dockOptions() | QMainWindow::ForceTabbedDocks);
 451
 452     tabifyDockWidget(m_ui.stateDock, m_ui.vertexDataDock);
 453
 454     m_ui.surfacesTreeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
 455
 456     m_ui.detailsWebView->page()->setLinkDelegationPolicy(
 457         QWebPage::DelegateExternalLinks);
 458 }
 459
 460 void MainWindow::initConnections()
 461 {
 462     connect(m_trace, SIGNAL(startedLoadingTrace()),
 463             this, SLOT(startedLoadingTrace()));
 464     connect(m_trace, SIGNAL(finishedLoadingTrace()),
 465             this, SLOT(finishedLoadingTrace()));
 466
 467     connect(m_retracer, SIGNAL(finished(const QString&)),
 468             this, SLOT(replayFinished(const QString&)));
 469     connect(m_retracer, SIGNAL(error(const QString&)),
 470             this, SLOT(replayError(const QString&)));
 471     connect(m_retracer, SIGNAL(foundState(const ApiTraceState&)),
 472             this, SLOT(replayStateFound(const ApiTraceState&)));
 473
 474     connect(m_ui.vertexInterpretButton, SIGNAL(clicked()),
 475             m_vdataInterpreter, SLOT(interpretData()));
 476     connect(m_ui.vertexTypeCB, SIGNAL(currentIndexChanged(const QString&)),
 477             m_vdataInterpreter, SLOT(setTypeFromString(const QString&)));
 478     connect(m_ui.vertexStrideSB, SIGNAL(valueChanged(int)),
 479             m_vdataInterpreter, SLOT(setStride(int)));
 480     connect(m_ui.vertexComponentsSB, SIGNAL(valueChanged(int)),
 481             m_vdataInterpreter, SLOT(setComponents(int)));
 482     connect(m_ui.startingOffsetSB, SIGNAL(valueChanged(int)),
 483             m_vdataInterpreter, SLOT(setStartingOffset(int)));
 484
 485
 486     connect(m_ui.actionOpen, SIGNAL(triggered()),
 487             this, SLOT(openTrace()));
 488     connect(m_ui.actionQuit, SIGNAL(triggered()),
 489             this, SLOT(close()));
 490
 491     connect(m_ui.actionReplay, SIGNAL(triggered()),
 492             this, SLOT(replayStart()));
 493     connect(m_ui.actionStop, SIGNAL(triggered()),
 494             this, SLOT(replayStop()));
 495     connect(m_ui.actionLookupState, SIGNAL(triggered()),
 496             this, SLOT(lookupState()));
 497     connect(m_ui.actionOptions, SIGNAL(triggered()),
 498             this, SLOT(showSettings()));
 499
 500     connect(m_ui.callView, SIGNAL(activated(const QModelIndex &)),
 501             this, SLOT(callItemSelected(const QModelIndex &)));
 502     connect(m_filterEdit, SIGNAL(returnPressed()),
 503             this, SLOT(filterTrace()));
 504
 505     connect(m_ui.surfacesTreeWidget,
 506             SIGNAL(customContextMenuRequested(const QPoint &)),
 507             SLOT(showSurfacesMenu(const QPoint &)));
 508     connect(m_ui.surfacesTreeWidget,
 509             SIGNAL(itemDoubleClicked(QTreeWidgetItem *, int)),
 510             SLOT(showSelectedSurface()));
 511
 512     connect(m_ui.detailsWebView, SIGNAL(linkClicked(const QUrl&)),
 513             this, SLOT(openHelp(const QUrl&)));
 514 }
 515
 516 void MainWindow::replayStateFound(const ApiTraceState &state)
 517 {
 518     m_stateEvent->setState(state);
 519     m_model->stateSetOnEvent(m_stateEvent);
 520     if (m_selectedEvent == m_stateEvent) {
 521         fillStateForFrame();
 522     } else {
 523         m_ui.stateDock->hide();
 524     }
 525 }
 526
 527 #include "mainwindow.moc"