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     const QList<ApiFramebuffer> &fbos =
 325         state.framebuffers();
 326
 327     m_ui.surfacesTreeWidget->clear();
 328     if (textures.isEmpty() && fbos.isEmpty()) {
 329         m_ui.surfacesTab->setDisabled(false);
 330     } else {
 331         m_ui.surfacesTreeWidget->setIconSize(QSize(64, 64));
 332         if (!textures.isEmpty()) {
 333             QTreeWidgetItem *textureItem =
 334                 new QTreeWidgetItem(m_ui.surfacesTreeWidget);
 335             textureItem->setText(0, tr("Textures"));
 336             for (int i = 0; i < textures.count(); ++i) {
 337                 const ApiTexture &texture =
 338                     textures[i];
 339                 QIcon icon(QPixmap::fromImage(texture.thumb()));
 340                 QTreeWidgetItem *item = new QTreeWidgetItem(textureItem);
 341                 item->setIcon(0, icon);
 342                 int width = texture.size().width();
 343                 int height = texture.size().height();
 344                 QString descr =
 345                     QString::fromLatin1("%1, %2 x %3")
 346                     .arg(texture.target())
 347                     .arg(width)
 348                     .arg(height);
 349                 item->setText(1, descr);
 350
 351                 item->setData(0, Qt::UserRole,
 352                               texture.image());
 353             }
 354         }
 355         if (!fbos.isEmpty()) {
 356             QTreeWidgetItem *fboItem =
 357                 new QTreeWidgetItem(m_ui.surfacesTreeWidget);
 358             fboItem->setText(0, tr("Framebuffers"));
 359             for (int i = 0; i < fbos.count(); ++i) {
 360                 const ApiFramebuffer &fbo =
 361                     fbos[i];
 362                 QIcon icon(QPixmap::fromImage(fbo.thumb()));
 363                 QTreeWidgetItem *item = new QTreeWidgetItem(fboItem);
 364                 item->setIcon(0, icon);
 365                 int width = fbo.size().width();
 366                 int height = fbo.size().height();
 367                 QString descr =
 368                     QString::fromLatin1("%1, %2 x %3")
 369                     .arg(fbo.type())
 370                     .arg(width)
 371                     .arg(height);
 372                 item->setText(1, descr);
 373
 374                 item->setData(0, Qt::UserRole,
 375                               fbo.image());
 376             }
 377         }
 378         m_ui.surfacesTab->setEnabled(true);
 379     }
 380     m_ui.stateDock->show();
 381 }
 382
 383 void MainWindow::showSettings()
 384 {
 385     SettingsDialog dialog;
 386     dialog.setFilterOptions(m_proxyModel->filterOptions());
 387
 388     if (dialog.exec() == QDialog::Accepted) {
 389         m_proxyModel->setFilterOptions(dialog.filterOptions());
 390     }
 391 }
 392
 393 void MainWindow::openHelp(const QUrl &url)
 394 {
 395     QDesktopServices::openUrl(url);
 396 }
 397
 398 void MainWindow::showSurfacesMenu(const QPoint &pos)
 399 {
 400     QTreeWidget *tree = m_ui.surfacesTreeWidget;
 401     QTreeWidgetItem *item = tree->itemAt(pos);
 402     if (!item)
 403         return;
 404
 405     QMenu menu(tr("Surfaces"), this);
 406     //add needed actions
 407     QAction *act = menu.addAction(tr("View Image"));
 408     act->setStatusTip(tr("View the currently selected surface"));
 409     connect(act, SIGNAL(triggered()),
 410             SLOT(showSelectedSurface()));
 411
 412     menu.exec(tree->viewport()->mapToGlobal(pos));
 413 }
 414
 415 void MainWindow::showSelectedSurface()
 416 {
 417     QTreeWidgetItem *item =
 418         m_ui.surfacesTreeWidget->currentItem();
 419
 420     if (!item)
 421         return;
 422
 423     QVariant var = item->data(0, Qt::UserRole);
 424     m_imageViewer->setImage(var.value<QImage>());
 425     m_imageViewer->show();
 426     m_imageViewer->raise();
 427     m_imageViewer->activateWindow();
 428 }
 429
 430 void MainWindow::initObjects()
 431 {
 432     m_ui.stateTreeWidget->sortByColumn(0, Qt::AscendingOrder);
 433
 434     m_sourcesWidget = new ShadersSourceWidget(m_ui.shadersTab);
 435     QVBoxLayout *layout = new QVBoxLayout;
 436     layout->addWidget(m_sourcesWidget);
 437     m_ui.shadersTab->setLayout(layout);
 438
 439     m_trace = new ApiTrace();
 440     m_retracer = new Retracer(this);
 441
 442     m_vdataInterpreter = new VertexDataInterpreter(this);
 443     m_vdataInterpreter->setListWidget(m_ui.vertexDataListWidget);
 444     m_vdataInterpreter->setStride(
 445         m_ui.vertexStrideSB->value());
 446     m_vdataInterpreter->setComponents(
 447         m_ui.vertexComponentsSB->value());
 448     m_vdataInterpreter->setStartingOffset(
 449         m_ui.startingOffsetSB->value());
 450     m_vdataInterpreter->setTypeFromString(
 451         m_ui.vertexTypeCB->currentText());
 452
 453     m_imageViewer = new ImageViewer(this);
 454
 455     m_model = new ApiTraceModel();
 456     m_model->setApiTrace(m_trace);
 457     m_proxyModel = new ApiTraceFilter();
 458     m_proxyModel->setSourceModel(m_model);
 459     m_ui.callView->setModel(m_proxyModel);
 460     m_ui.callView->setItemDelegate(new ApiCallDelegate);
 461     m_ui.callView->resizeColumnToContents(0);
 462     m_ui.callView->header()->swapSections(0, 1);
 463     m_ui.callView->setColumnWidth(1, 42);
 464
 465     QToolBar *toolBar = addToolBar(tr("Navigation"));
 466     m_filterEdit = new QLineEdit(toolBar);
 467     toolBar->addWidget(m_filterEdit);
 468
 469     m_progressBar = new QProgressBar();
 470     m_progressBar->setRange(0, 0);
 471     statusBar()->addPermanentWidget(m_progressBar);
 472     m_progressBar->hide();
 473
 474     m_ui.detailsDock->hide();
 475     m_ui.vertexDataDock->hide();
 476     m_ui.stateDock->hide();
 477     setDockOptions(dockOptions() | QMainWindow::ForceTabbedDocks);
 478
 479     tabifyDockWidget(m_ui.stateDock, m_ui.vertexDataDock);
 480
 481     m_ui.surfacesTreeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
 482
 483     m_ui.detailsWebView->page()->setLinkDelegationPolicy(
 484         QWebPage::DelegateExternalLinks);
 485 }
 486
 487 void MainWindow::initConnections()
 488 {
 489     connect(m_trace, SIGNAL(startedLoadingTrace()),
 490             this, SLOT(startedLoadingTrace()));
 491     connect(m_trace, SIGNAL(finishedLoadingTrace()),
 492             this, SLOT(finishedLoadingTrace()));
 493
 494     connect(m_retracer, SIGNAL(finished(const QString&)),
 495             this, SLOT(replayFinished(const QString&)));
 496     connect(m_retracer, SIGNAL(error(const QString&)),
 497             this, SLOT(replayError(const QString&)));
 498     connect(m_retracer, SIGNAL(foundState(const ApiTraceState&)),
 499             this, SLOT(replayStateFound(const ApiTraceState&)));
 500
 501     connect(m_ui.vertexInterpretButton, SIGNAL(clicked()),
 502             m_vdataInterpreter, SLOT(interpretData()));
 503     connect(m_ui.vertexTypeCB, SIGNAL(currentIndexChanged(const QString&)),
 504             m_vdataInterpreter, SLOT(setTypeFromString(const QString&)));
 505     connect(m_ui.vertexStrideSB, SIGNAL(valueChanged(int)),
 506             m_vdataInterpreter, SLOT(setStride(int)));
 507     connect(m_ui.vertexComponentsSB, SIGNAL(valueChanged(int)),
 508             m_vdataInterpreter, SLOT(setComponents(int)));
 509     connect(m_ui.startingOffsetSB, SIGNAL(valueChanged(int)),
 510             m_vdataInterpreter, SLOT(setStartingOffset(int)));
 511
 512
 513     connect(m_ui.actionOpen, SIGNAL(triggered()),
 514             this, SLOT(openTrace()));
 515     connect(m_ui.actionQuit, SIGNAL(triggered()),
 516             this, SLOT(close()));
 517
 518     connect(m_ui.actionReplay, SIGNAL(triggered()),
 519             this, SLOT(replayStart()));
 520     connect(m_ui.actionStop, SIGNAL(triggered()),
 521             this, SLOT(replayStop()));
 522     connect(m_ui.actionLookupState, SIGNAL(triggered()),
 523             this, SLOT(lookupState()));
 524     connect(m_ui.actionOptions, SIGNAL(triggered()),
 525             this, SLOT(showSettings()));
 526
 527     connect(m_ui.callView, SIGNAL(activated(const QModelIndex &)),
 528             this, SLOT(callItemSelected(const QModelIndex &)));
 529     connect(m_filterEdit, SIGNAL(returnPressed()),
 530             this, SLOT(filterTrace()));
 531
 532     connect(m_ui.surfacesTreeWidget,
 533             SIGNAL(customContextMenuRequested(const QPoint &)),
 534             SLOT(showSurfacesMenu(const QPoint &)));
 535     connect(m_ui.surfacesTreeWidget,
 536             SIGNAL(itemDoubleClicked(QTreeWidgetItem *, int)),
 537             SLOT(showSelectedSurface()));
 538
 539     connect(m_ui.detailsWebView, SIGNAL(linkClicked(const QUrl&)),
 540             this, SLOT(openHelp(const QUrl&)));
 541 }
 542
 543 void MainWindow::replayStateFound(const ApiTraceState &state)
 544 {
 545     m_stateEvent->setState(state);
 546     m_model->stateSetOnEvent(m_stateEvent);
 547     if (m_selectedEvent == m_stateEvent) {
 548         fillStateForFrame();
 549     } else {
 550         m_ui.stateDock->hide();
 551     }
 552 }
 553
 554 #include "mainwindow.moc"