veritas/internal/runnerwindow.cpp

   1 /* KDevelop xUnit plugin
   2  *
   3  * Copyright 2006 Ernst Huber <qxrunner@systest.ch>
   4  * Copyright 2008 Manuel Breugelmans <mbr.nxi@gmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19  * 02110-1301, USA.
  20  */
  21
  22 #include "runnerwindow.h"
  23
  24 #include "ui_runnerwindow.h"
  25
  26 #include "interfaces/iproject.h"
  27
  28 #include "resultsmodel.h"
  29 #include "resultsproxymodel.h"
  30 #include "runnermodel.h"
  31 #include "runnerproxymodel.h"
  32 #include "selectionmanager.h"
  33 #include "verbosemanager.h"
  34 #include "verbosetoggle.h"
  35 #include "selectiontoggle.h"
  36 #include "testexecutor.h"
  37
  38 #include <ktexteditor/cursor.h>
  39 #include "interfaces/icore.h"
  40 #include "interfaces/idocumentcontroller.h"
  41
  42 #include "utils.h"
  43 #include "test_p.h"
  44 #include "resultswidget.h"
  45
  46 #include <QMessageBox>
  47 #include <QCloseEvent>
  48 #include <KLocale>
  49 #include <KAction>
  50 #include <KActionMenu>
  51 #include <KSelectAction>
  52 #include <KIcon>
  53 #include <KDebug>
  54 #include <KColorScheme>
  55 #include <QBrush>
  56 #include <QColor>
  57 #include <QHeaderView>
  58
  59 using KDevelop::IProject;
  60 Q_DECLARE_METATYPE(KDevelop::IProject*)
  61
  62 static void initVeritasResource()
  63 {
  64     Q_INIT_RESOURCE(qxrunner);
  65 }
  66
  67 using KDevelop::ICore;
  68 using KDevelop::IDocumentController;
  69
  70 using Veritas::RunnerWindow;
  71 using Veritas::RunnerModel;
  72 using Veritas::RunnerProxyModel;
  73 using Veritas::ResultsModel;
  74 using Veritas::ResultsProxyModel;
  75 using Veritas::VerboseManager;
  76 using Veritas::TestExecutor;
  77 using Veritas::Test;
  78
  79 const Ui::RunnerWindow* RunnerWindow::ui() const
  80 {
  81     return m_ui;
  82 }
  83
  84 RunnerWindow::RunnerWindow(ResultsModel* rmodel, QWidget* parent, Qt::WFlags flags)
  85         : QWidget(parent, flags), m_executor(0), m_isRunning(false)
  86 {
  87     initVeritasResource();
  88     m_ui = new Ui::RunnerWindow;
  89     m_ui->setupUi(this);
  90     m_results = new ResultsWidget();
  91     runnerView()->setRootIsDecorated(false);
  92     runnerView()->setUniformRowHeights(true);
  93
  94     connectFocusStuff();
  95     setGreenBar();
  96     ui()->progressRun->setTextVisible(false);
  97     ui()->progressRun->show();
  98     addProjectMenu();
  99
 100     // Disable user interaction while there is no data.
 101     enableItemActions(false);
 102
 103     initItemStatistics();
 104     connectActions();
 105     runnerView()->setMouseTracking(true);
 106
 107     ResultsProxyModel* rproxy = new ResultsProxyModel(this);
 108     rproxy->setSourceModel(rmodel);
 109     int filter = Veritas::RunError | Veritas::RunFatal | Veritas::RunInfo;
 110     rproxy->setFilter(filter); // also updates the view
 111     resultsView()->setModel(rproxy);
 112     m_results->setResizeMode();
 113
 114     m_selection = new SelectionManager(runnerView());
 115     SelectionToggle* selectionToggle = new SelectionToggle(runnerView()->viewport());
 116     m_selection->setButton(selectionToggle);
 117     m_verbose = new VerboseManager(runnerView());
 118     VerboseToggle* verboseToggle = new VerboseToggle(runnerView()->viewport());
 119     m_verbose->setButton(verboseToggle);
 120
 121     QPixmap refresh = KIconLoader::global()->loadIcon("view-refresh", KIconLoader::Small);
 122     m_ui->actionReload->setIcon(refresh);
 123     QPixmap run = KIconLoader::global()->loadIcon("arrow-right", KIconLoader::Small);
 124     m_ui->actionStart->setIcon(run);
 125     QPixmap stop = KIconLoader::global()->loadIcon("window-close", KIconLoader::Small);
 126     m_ui->actionStop->setIcon(stop);
 127     QPixmap select = KIconLoader::global()->loadIcon("list-add", KIconLoader::Small);
 128     m_ui->actionSelectAll->setIcon(select);
 129     QPixmap deselect = KIconLoader::global()->loadIcon("list-remove", KIconLoader::Small);
 130     m_ui->actionUnselectAll->setIcon(deselect);
 131
 132     runnerView()->setStyleSheet(
 133         "QTreeView::branch{"
 134         "image: none;"
 135         "border-image: none"
 136         "}");
 137
 138     connect(runnerView(),  SIGNAL(clicked(QModelIndex)),
 139             SLOT(expandOrCollapse(QModelIndex)));
 140
 141     const char* whatsthis = "xTest runner. First select a project from the rightmost dropdown box. Next, load the test tree by clicking on the green circular arrow icon. Run your tests with a click on the leftmost green arrow icon.";
 142     setWhatsThis( i18n(whatsthis) );
 143     resultsView()->setWhatsThis( i18n(whatsthis) );
 144
 145     runnerView()->setSelectionMode(QAbstractItemView::SingleSelection);
 146     runnerView()->setSelectionBehavior(QAbstractItemView::SelectRows);
 147 }
 148
 149 // helper for RunnerWindow(...)
 150 void RunnerWindow::addProjectMenu()
 151 {
 152     KSelectAction *m = new KSelectAction(i18n("Project"), this);
 153     m->setToolTip(i18n("Select project"));
 154     m->setToolBarMode(KSelectAction::MenuMode);
 155     m->setEditable(true);
 156     m_ui->runnerToolBar->addSeparator();
 157     m_ui->runnerToolBar->addAction(m);
 158     m_projectPopup = m;
 159 }
 160
 161 void RunnerWindow::addProjectToPopup(IProject* proj)
 162 {
 163     kDebug() << "Adding project to popup " << proj->name();
 164     QAction* p = new QAction(proj->name(), this);
 165     QVariant v;
 166     v.setValue(proj);
 167     p->setData(v);
 168     m_projectPopup->addAction(p);
 169     m_project2action[proj] = p;
 170 }
 171
 172 void RunnerWindow::rmProjectFromPopup(IProject* proj)
 173 {
 174     if (m_project2action.contains(proj)) {
 175         QAction* p = m_project2action[proj];
 176         m_projectPopup->removeAction(p);
 177         m_project2action.remove(proj);
 178     }
 179 }
 180
 181 namespace
 182 {
 183 /*! functor that counts the selected leaf tests */
 184 class SelectedLeafCount
 185 {
 186 public:
 187     SelectedLeafCount() : result(0) {}
 188     void operator()(Test* t) {
 189         if ((t->childCount() == 0) && t->internal()->isChecked()) {
 190             result++;
 191         }
 192     }
 193     int result;
 194 };
 195
 196 }
 197
 198 void RunnerWindow::resetProgressBar() const
 199 {
 200     ui()->progressRun->setValue(0);
 201     ui()->progressRun->update();
 202     if (runnerModel()) {
 203         SelectedLeafCount slf;
 204         traverseTree(runnerModel()->rootItem(), slf);
 205         if (slf.result == 0) slf.result++; // 0 results in an indeterminate progressbar, not good
 206         ui()->progressRun->setMaximum(slf.result);
 207     } else {
 208         ui()->progressRun->setMaximum(1);
 209     }
 210 }
 211
 212 // helper for RunnerWindow(...)
 213 void RunnerWindow::initItemStatistics()
 214 {
 215     displayNumErrors(0);
 216     displayNumFatals(0);
 217     displayNumExceptions(0);
 218 }
 219
 220 // helper for RunnerWindow(...)
 221 void RunnerWindow::connectFocusStuff()
 222 {
 223     // To keep the views synchronized when there are highlighted rows
 224     // which get clicked again..
 225     connect(runnerView(),  SIGNAL(pressed(const QModelIndex&)),
 226             SLOT(scrollToHighlightedRows()));
 227     connect(resultsView(), SIGNAL(pressed(const QModelIndex&)),
 228             SLOT(scrollToHighlightedRows()));
 229 }
 230
 231 KSelectAction* RunnerWindow::projectPopup() const
 232 {
 233     return m_projectPopup;
 234 }
 235
 236 // helper for RunnerWindow(...) ctor
 237 void RunnerWindow::connectActions()
 238 {
 239     // File commands.
 240     connect(m_ui->actionExit, SIGNAL(triggered(bool)), SLOT(close()));
 241     // Item commands.
 242     m_ui->actionStart->setShortcut(QKeySequence(tr("Ctrl+R")));
 243     connect(m_ui->actionStart, SIGNAL(triggered(bool)), SLOT(runItems()));
 244     m_ui->actionStop->setShortcut(QKeySequence(tr("Ctrl+K")));
 245     connect(m_ui->actionStop, SIGNAL(triggered(bool)), SLOT(stopItems()));
 246     // View commands
 247     m_ui->actionSelectAll->setShortcut(QKeySequence(tr("Ctrl+A")));
 248     connect(m_ui->actionSelectAll, SIGNAL(triggered(bool)),
 249             this, SLOT(selectAll()));
 250     m_ui->actionUnselectAll->setShortcut(QKeySequence(tr("Ctrl+U")));
 251     connect(m_ui->actionUnselectAll, SIGNAL(triggered(bool)),
 252             this, SLOT(unselectAll()));
 253     m_ui->actionExpandAll->setShortcut(QKeySequence(tr("Ctrl++")));
 254     connect(m_ui->actionExpandAll, SIGNAL(triggered(bool)),
 255             runnerView(), SLOT(expandAll()));
 256     m_ui->actionCollapseAll->setShortcut(QKeySequence(tr("Ctrl+-")));
 257     connect(m_ui->actionCollapseAll, SIGNAL(triggered(bool)),
 258             runnerView(), SLOT(collapseAll()));
 259 }
 260
 261 void RunnerWindow::unselectAll()
 262 {
 263     runnerModel()->uncheckAll();
 264     resetProgressBar();
 265     runnerView()->viewport()->update();
 266 }
 267
 268 void RunnerWindow::selectAll()
 269 {
 270     runnerModel()->checkAll();
 271     resetProgressBar();
 272     runnerView()->viewport()->update();
 273 }
 274
 275 RunnerWindow::~RunnerWindow()
 276 {
 277     // Deleting the model is left to the owner of the model instance.
 278     if (m_selection) delete m_selection;
 279     if (m_verbose) delete m_verbose;
 280     if (m_executor) {
 281         m_executor->stop();
 282         delete m_executor;
 283     }
 284     if (runnerModel()) delete runnerModel();
 285     delete m_ui;
 286 }
 287
 288 // helper for setModel(RunnerModel*)
 289 void RunnerWindow::stopPreviousModel()
 290 {
 291     RunnerModel* prevModel = runnerModel();
 292     if (prevModel) {
 293         if (m_executor) m_executor->stop();
 294
 295         RunnerProxyModel* m1 = runnerProxyModel();
 296         runnerView()->setModel(0);
 297         runnerView()->reset();
 298         delete m1;
 299
 300         resultsModel()->clear();
 301         m_results->setResizeMode();
 302         prevModel->disconnect();
 303         delete prevModel;
 304     }
 305 }
 306
 307 // helper for setModel(RunnerModel*)
 308 void RunnerWindow::initProxyModels(RunnerModel* model)
 309 {
 310     // Proxy models for the views with the source model as their parent
 311     // to have the proxies deleted when the model gets deleted.
 312     RunnerProxyModel* proxy = new RunnerProxyModel(model);
 313     proxy->setSourceModel(model);
 314     runnerView()->setModel(proxy);
 315     m_stopWatch = QTime();
 316 }
 317
 318 // helper for setModel(RunnerModel*)
 319 void RunnerWindow::connectItemStatistics(RunnerModel* model)
 320 {
 321     // Item statistics.
 322     connect(model, SIGNAL(numTotalChanged(int)),
 323             SLOT(displayNumTotal(int)));
 324     connect(model, SIGNAL(numSelectedChanged(int)),
 325             SLOT(displayNumSelected(int)));
 326     connect(model, SIGNAL(numErrorsChanged(int)),
 327             SLOT(displayNumErrors(int)));
 328     connect(model, SIGNAL(numFatalsChanged(int)),
 329             SLOT(displayNumFatals(int)));
 330     connect(model, SIGNAL(numExceptionsChanged(int)),
 331             SLOT(displayNumExceptions(int)));
 332
 333     model->countItems(); // this fires the signals connected above.
 334 }
 335
 336 // helper for setModel(RunnerModel*)
 337 void RunnerWindow::connectProgressIndicators(RunnerModel* model)
 338 {
 339     // Get notified of items run.
 340     connect(model, SIGNAL(numStartedChanged(int)),
 341             SLOT(displayProgress(int)));
 342     connect(model, SIGNAL(numCompletedChanged(int)),
 343             SLOT(displayNumCompleted(int)));
 344     connect(model, SIGNAL(allItemsCompleted()),
 345             SLOT(displayCompleted()));
 346     connect(model, SIGNAL(itemCompleted(QModelIndex)),
 347             resultsModel(), SLOT(addResult(QModelIndex)));
 348 }
 349
 350 void RunnerWindow::setModel(RunnerModel* model)
 351 {
 352     m_verbose->reset();
 353     m_selection->reset();
 354     stopPreviousModel();
 355     if (!model) {
 356         // No user interaction without a model or an empty one
 357         enableItemActions(false);
 358         return;
 359     }
 360     initProxyModels(model);
 361     if (model->rowCount() == 0) {
 362         enableItemActions(false);
 363         return;
 364     }
 365     connectItemStatistics(model);
 366
 367     connectProgressIndicators(model);
 368     enableItemActions(true);
 369     m_ui->actionStop->setDisabled(true);
 370
 371     connect(m_selection, SIGNAL(selectionChanged()),
 372             runnerModel(), SLOT(countItems()));
 373
 374     // set top row higlighted
 375     runnerView()->setCurrentIndex(runnerProxyModel()->index(0, 0));
 376     enableToSource();
 377     enableTestSync(true);
 378     m_verbose->makeConnections();
 379     m_selection->makeConnections();
 380     runnerView()->resizeColumnToContents(0);
 381 }
 382
 383
 384 void RunnerWindow::displayProgress(int numItems) const
 385 {
 386     // Display only when there are selected items
 387     if (ui()->progressRun->maximum() > 0) {
 388         ui()->progressRun->setValue(numItems);
 389     }
 390 }
 391
 392 void RunnerWindow::displayCompleted() const
 393 {
 394     if (!m_isRunning) return;
 395     ui()->progressRun->setValue(ui()->progressRun->maximum());
 396     enableControlsAfterRunning();
 397     displayElapsed();
 398     m_isRunning = false;
 399     emit runCompleted();
 400 }
 401
 402 void RunnerWindow::displayNumTotal(int numItems) const
 403 {
 404     Q_UNUSED(numItems);
 405 }
 406
 407 void RunnerWindow::displayNumSelected(int numItems) const
 408 {
 409     if (numItems == 0) numItems++;
 410     resetProgressBar();
 411 }
 412
 413 void RunnerWindow::displayNumCompleted(int numItems) const
 414 {
 415     ui()->labelNumRun->setText(QString().setNum(numItems));
 416     displayElapsed();
 417 }
 418
 419 void RunnerWindow::setGreenBar() const
 420 {
 421     QProgressBar* bar = ui()->progressRun;
 422     bar->setStyleSheet(
 423         QString("QProgressBar {"
 424             "border: 1px solid grey;"
 425             "border-radius: 2px;"
 426             "text-align: center;"
 427         "}"
 428         "QProgressBar::chunk {"
 429             "background-color: #009700;"
 430             "width: 5px;"
 431         "}"));
 432 }
 433
 434 void RunnerWindow::setRedBar() const
 435 {
 436     QProgressBar* bar = ui()->progressRun;
 437     bar->setStyleSheet(
 438         QString("QProgressBar {"
 439             "border: 1px solid grey;"
 440             "border-radius: 2px;"
 441             "text-align: center;"
 442         "}"
 443         "QProgressBar::chunk {"
 444             "background-color: #DF1313;"
 445             "width: 5px;"
 446         "}"));
 447 }
 448
 449 void RunnerWindow::displayNumErrors(int numItems) const
 450 {
 451     if (numItems > 0) setRedBar();
 452 }
 453
 454 void RunnerWindow::displayNumFatals(int numItems) const
 455 {
 456     if (numItems > 0) setRedBar();
 457 }
 458
 459 void RunnerWindow::displayNumExceptions(int numItems) const
 460 {
 461     if (numItems > 0) setRedBar();
 462 }
 463
 464 namespace
 465 {
 466 inline Test* testFromIndex(const QModelIndex& index)
 467 {
 468     return static_cast<Test*>(index.internalPointer());
 469 }
 470 }
 471
 472 void RunnerWindow::syncResultWithTest(const QItemSelection& selected,
 473                                       const QItemSelection& deselected) const
 474 {
 475     Q_UNUSED(deselected);
 476     QModelIndexList indexes = selected.indexes();
 477     if (indexes.count() < 1 || !runnerProxyModel()->index(0, 0).isValid()) {
 478         return; // Do nothing when there are no results or no runner item is selected.
 479     }
 480
 481     enableResultSync(false); // Prevent circular reaction
 482     QModelIndex testIndex = runnerProxyModel()->mapToSource(indexes.first());
 483     if (testIndex.isValid()) {
 484         Test* t = testFromIndex(testIndex);
 485         resultsProxyModel()->setTestFilter(t);
 486     }
 487     enableResultSync(true);
 488 }
 489
 490 void RunnerWindow::syncTestWithResult(const QItemSelection& selected,
 491                                       const QItemSelection& deselected) const
 492 {
 493     Q_UNUSED(deselected);
 494     QModelIndexList indexes = selected.indexes();
 495
 496     if (indexes.count() < 1) {
 497         return; // Do nothing when no result is selected.
 498     }
 499
 500     // Determine the results model index.
 501     QModelIndex resultIndex;
 502     resultIndex = Utils::modelIndexFromProxy(resultsProxyModel(), indexes.first());
 503
 504     if (resultIndex.parent().isValid()) {
 505         resultIndex = resultIndex.parent();
 506     }
 507
 508     // Get the corresponding runner item index contained in the results model.
 509     QModelIndex testItemIndex;
 510     testItemIndex = resultsModel()->mapToTestIndex(resultIndex);
 511
 512     enableTestSync(false); // prevent circular dependencies.
 513
 514     // Determine the proxy model index and highlight it.
 515     QModelIndex currentIndex;
 516     currentIndex = Utils::proxyIndexFromModel(runnerProxyModel(), testItemIndex);
 517     runnerView()->setCurrentIndex(currentIndex);
 518
 519     scrollToHighlightedRows(); // Make the row in every tree view visible
 520     // and expand corresponding parents.
 521     enableTestSync(true);      // Enable selection handler again.
 522 }
 523
 524 void RunnerWindow::displayElapsed() const
 525 {
 526     if (m_stopWatch.isValid()) {
 527         int mili = m_stopWatch.elapsed();
 528         QString elapsed = QString("%1.%2").arg(int(mili/1000)).arg(mili%1000);
 529         ui()->labelElapsed->setText(elapsed);
 530     } else {
 531         ui()->labelElapsed->setText("0.000");
 532     }
 533 }
 534
 535 void RunnerWindow::scrollToHighlightedRows() const
 536 {
 537
 538     if (runnerView()->selectionMode() == QAbstractItemView::NoSelection ||
 539             resultsView()->selectionMode() == QAbstractItemView::NoSelection) {
 540         return; // No relevance when selections not allowed.
 541     }
 542
 543     // Note: It's important not to use the current index but work with the
 544     // selection instead due to the fact that these indexes might not be the same.
 545
 546     QModelIndex index;
 547     QModelIndexList indexes;
 548     indexes = runnerView()->selectionModel()->selectedIndexes();
 549
 550     if (indexes.count() > 0) {
 551         index = indexes.first();
 552     }
 553     if (index.isValid()) {
 554         runnerView()->scrollTo(index);
 555     }
 556
 557     index = QModelIndex();
 558     indexes = resultsView()->selectionModel()->selectedIndexes();
 559
 560     if (indexes.count() > 0) {
 561         index = indexes.first();
 562     }
 563     if (index.isValid()) {
 564         resultsView()->scrollTo(index);
 565     } else {
 566         // Try to highlight a result.
 567         syncResultWithTest(runnerView()->selectionModel()->selection(),
 568                            runnerView()->selectionModel()->selection());
 569     }
 570 }
 571
 572 void RunnerWindow::runItems()
 573 {
 574     if (m_isRunning || !runnerModel()->rootItem()) {
 575         return;
 576     }
 577     m_isRunning = true;
 578
 579     m_stopWatch.start();
 580     setGreenBar();
 581     displayNumCompleted(0);
 582     ui()->labelElapsed->setText("0.000");
 583
 584     disableControlsBeforeRunning();
 585     resultsModel()->clear();
 586     runnerModel()->clearTree();
 587     runnerView()->viewport()->update(); // the icons have changed
 588     runnerModel()->initCounters();
 589
 590     if (m_executor) delete m_executor;
 591     m_executor = new TestExecutor;
 592     m_executor->setRoot(runnerModel()->rootItem());
 593     connect(m_executor, SIGNAL(allDone()), SLOT(displayCompleted()));
 594
 595     m_executor->go();
 596 }
 597
 598 void RunnerWindow::stopItems()
 599 {
 600     if (!runnerModel() || !m_isRunning) return;
 601     m_ui->actionStop->setDisabled(true);
 602     if (m_executor) m_executor->stop();
 603     displayCompleted();
 604     enableControlsAfterRunning();
 605     m_isRunning = false;
 606 }
 607
 608 void RunnerWindow::disableControlsBeforeRunning()
 609 {
 610     enableItemActions(false);
 611
 612     m_ui->actionStop->setEnabled(true);
 613     m_projectPopup->setEnabled(false);
 614     m_ui->actionReload->setEnabled(false);
 615     runnerView()->setCursor(QCursor(Qt::BusyCursor));
 616     runnerView()->setFocus();
 617     runnerView()->setSelectionMode(QAbstractItemView::NoSelection);
 618     resultsView()->setSelectionMode(QAbstractItemView::NoSelection);
 619     enableTestSync(false);
 620     enableResultSync(false);
 621 }
 622
 623 void RunnerWindow::enableControlsAfterRunning() const
 624 {
 625     enableItemActions(true);
 626
 627     m_ui->actionStop->setDisabled(true);
 628     m_ui->actionReload->setEnabled(true);
 629     m_projectPopup->setEnabled(true);
 630     runnerView()->setCursor(QCursor());
 631     runnerView()->setFocus();
 632     runnerView()->setSelectionMode(QAbstractItemView::SingleSelection);
 633     resultsView()->setSelectionMode(QAbstractItemView::SingleSelection);
 634     enableTestSync(true);
 635     enableResultSync(true);
 636
 637 }
 638
 639 void RunnerWindow::enableItemActions(bool enable) const
 640 {
 641     m_ui->actionStart->setEnabled(enable);
 642     m_ui->actionStop->setEnabled(enable);
 643     m_ui->actionSelectAll->setEnabled(enable);
 644     m_ui->actionUnselectAll->setEnabled(enable);
 645     m_ui->actionExpandAll->setEnabled(enable);
 646     m_ui->actionCollapseAll->setEnabled(enable);
 647 }
 648
 649 void RunnerWindow::enableTestSync(bool enable) const
 650 {
 651     if (enable) {
 652         connect(runnerView()->selectionModel(),
 653                 SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
 654                 SLOT(syncResultWithTest(QItemSelection,QItemSelection)));
 655     } else {
 656         disconnect(runnerView()->selectionModel(),
 657                 SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
 658                 this, SLOT(syncResultWithTest(QItemSelection,QItemSelection)));
 659     }
 660 }
 661
 662 void RunnerWindow::enableToSource() const
 663 {
 664     connect(resultsView()->selectionModel(),
 665             SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
 666             this, SLOT(jumpToSource(QItemSelection,QItemSelection)));
 667 }
 668
 669 void RunnerWindow::jumpToSource(const QItemSelection& selected, const QItemSelection& deselected)
 670 {
 671     Q_UNUSED(deselected);
 672     QModelIndexList indexes = selected.indexes();
 673
 674     if (indexes.count() < 1) {
 675         return; // Do nothing when no result is selected.
 676     }
 677
 678     // Determine the results model index.
 679     QModelIndex resultIndex;
 680     resultIndex = Utils::modelIndexFromProxy(resultsProxyModel(), indexes.first());
 681     Test* t = resultsModel()->testFromIndex(resultIndex);
 682     TestResult* r = t->result();
 683
 684     KTextEditor::Cursor range(r->line() - 1, 0);
 685     IDocumentController* dc = ICore::self()->documentController();
 686     dc->openDocument(KUrl(r->file().pathOrUrl()), range);
 687 }
 688
 689 void RunnerWindow::enableResultSync(bool enable) const
 690 {
 691     if (enable) {
 692         connect(resultsView()->selectionModel(),
 693                 SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
 694                 SLOT(syncTestWithResult(QItemSelection,QItemSelection)));
 695     } else {
 696         disconnect(resultsView()->selectionModel(),
 697                 SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
 698                 this, SLOT(syncTestWithResult(QItemSelection,QItemSelection)));
 699     }
 700 }
 701
 702 void RunnerWindow::displayStatusNum(QLabel* labelForText,
 703                                     QLabel* labelForPic, int numItems) const
 704 {
 705     labelForText->setText(": " + QString().setNum(numItems));
 706     bool visible = (numItems > 0);
 707     labelForText->setVisible(visible);
 708     labelForPic->setVisible(visible);
 709 }
 710
 711 void RunnerWindow::expandOrCollapse(const QModelIndex& index) const
 712 {
 713     runnerView()->isExpanded(index) ?
 714         runnerView()->collapse(index) :
 715         runnerView()->expand(index);
 716 }
 717
 718 ////////////////// GETTERS /////////////////////////////////////////////////////////////
 719
 720 QTreeView* RunnerWindow::runnerView() const
 721 {
 722     return m_ui->treeRunner;
 723 }
 724
 725 QTreeView* RunnerWindow::resultsView() const
 726 {
 727     return m_results->tree();
 728 }
 729
 730 QWidget* RunnerWindow::resultsWidget() const
 731 {
 732     return m_results;
 733 }
 734
 735 RunnerModel* RunnerWindow::runnerModel() const
 736 {
 737     RunnerProxyModel* proxy = runnerProxyModel();
 738     return proxy ?
 739         qobject_cast<RunnerModel*>(proxy->sourceModel()) :
 740         0;
 741 }
 742
 743 RunnerProxyModel* RunnerWindow::runnerProxyModel() const
 744 {
 745     return qobject_cast<RunnerProxyModel*>(runnerView()->model());
 746 }
 747
 748 ResultsModel* RunnerWindow::resultsModel() const
 749 {
 750     ResultsProxyModel* proxy = resultsProxyModel();
 751     return proxy ?
 752         qobject_cast<ResultsModel*>(proxy->sourceModel()) :
 753         0;
 754 }
 755
 756 ResultsProxyModel* RunnerWindow::resultsProxyModel() const
 757 {
 758     return qobject_cast<ResultsProxyModel*>(resultsView()->model());
 759 }
 760
 761 VerboseManager* RunnerWindow::verboseManager() const
 762 {
 763     return m_verbose;
 764 }