kdgantt2/kdganttview.cpp

   1 /****************************************************************************
   2  ** Copyright (C) 2001-2006 Klarälvdalens Datakonsult AB.  All rights reserved.
   3  **
   4  ** This file is part of the KD Gantt library.
   5  **
   6  ** This file may be distributed and/or modified under the terms of the
   7  ** GNU General Public License version 2 as published by the Free Software
   8  ** Foundation and appearing in the file LICENSE.GPL included in the
   9  ** packaging of this file.
  10  **
  11  ** Licensees holding valid commercial KD Gantt licenses may use this file in
  12  ** accordance with the KD Gantt Commercial License Agreement provided with
  13  ** the Software.
  14  **
  15  ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  17  **
  18  ** See http://www.kdab.net/kdgantt for
  19  **   information about KD Gantt Commercial License Agreements.
  20  **
  21  ** Contact info@kdab.net if any conditions of this
  22  ** licensing are not clear to you.
  23  **
  24  **********************************************************************/
  25 #include "kdganttview.h"
  26 #include "kdganttview_p.h"
  27
  28 #include "kdganttitemdelegate.h"
  29 #include "kdganttgraphicsitem.h"
  30
  31 #include <QAbstractItemModel>
  32 #include <QHeaderView>
  33 #include <QVBoxLayout>
  34 #include <QGraphicsItem>
  35 #include <QGraphicsRectItem>
  36 #include <QScrollBar>
  37 #include <QPaintEvent>
  38
  39 #include "kdgantt_debug.h"
  40
  41 #include <cassert>
  42
  43 #if defined KDAB_EVAL
  44 #include "../evaldialog/evaldialog.h"
  45 #endif
  46
  47 using namespace KDGantt;
  48
  49 namespace
  50 {
  51 class HeaderView : public QHeaderView
  52 {
  53 public:
  54     explicit HeaderView(QWidget *parent = Q_NULLPTR) : QHeaderView(Qt::Horizontal, parent)
  55     {
  56     }
  57
  58     QSize sizeHint() const Q_DECL_OVERRIDE
  59     {
  60         QSize s = QHeaderView::sizeHint();
  61         s.rheight() *= 2;
  62         return s;
  63     }
  64 };
  65 }
  66
  67 KDGanttTreeView::KDGanttTreeView(QAbstractProxyModel *proxy, QWidget *parent)
  68     : QTreeView(parent),
  69       m_controller(this, proxy)
  70 {
  71     setHeader(new HeaderView);
  72 }
  73
  74 KDGanttTreeView::~KDGanttTreeView()
  75 {
  76 }
  77
  78 View::Private::Private(View *v)
  79     : q(v),
  80       splitter(v),
  81       rowController(0),
  82       gfxview(&splitter),
  83       model(0)
  84 {
  85     //init();
  86 }
  87
  88 View::Private::~Private()
  89 {
  90 }
  91
  92 void View::Private::init()
  93 {
  94     KDGanttTreeView *tw = new KDGanttTreeView(&ganttProxyModel, &splitter);
  95     tw->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
  96     tw->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
  97
  98     q->setLeftView(tw);
  99     q->setRowController(tw->rowController());
 100
 101     gfxview.setAlignment(Qt::AlignTop | Qt::AlignLeft);
 102     //gfxview.setRenderHints( QPainter::Antialiasing );
 103
 104     tw->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
 105     gfxview.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
 106
 107     QVBoxLayout *layout = new QVBoxLayout(q);
 108     layout->setMargin(0);
 109     layout->addWidget(&splitter);
 110     q->setLayout(layout);
 111
 112     constraintProxy.setProxyModel(&ganttProxyModel);
 113     constraintProxy.setDestinationModel(&mappedConstraintModel);
 114     gfxview.setSelectionModel(leftWidget->selectionModel());
 115     gfxview.setConstraintModel(&mappedConstraintModel);
 116 }
 117
 118 void View::Private::updateScene()
 119 {
 120     gfxview.clearItems();
 121     if (!model) {
 122         return;
 123     }
 124
 125     if (QTreeView *tw = qobject_cast<QTreeView *>(leftWidget)) {
 126         QModelIndex idx = ganttProxyModel.mapFromSource(model->index(0, 0, leftWidget->rootIndex()));
 127         do {
 128             gfxview.updateRow(idx);
 129         } while ((idx = tw->indexBelow(idx)) != QModelIndex() &&
 130                  gfxview.rowController()->isRowVisible(idx));
 131         gfxview.updateSceneRect();
 132     } else {
 133         const QModelIndex rootidx = ganttProxyModel.mapFromSource(leftWidget->rootIndex());
 134         for (int r = 0; r < ganttProxyModel.rowCount(rootidx); ++r) {
 135             gfxview.updateRow(ganttProxyModel.index(r, 0, rootidx));
 136         }
 137     }
 138 }
 139
 140 void View::Private::slotCollapsed(const QModelIndex &_idx)
 141 {
 142     QTreeView *tw = qobject_cast<QTreeView *>(leftWidget);
 143     if (!tw) {
 144         return;
 145     }
 146
 147     bool blocked = gfxview.blockSignals(true);
 148
 149     QModelIndex idx(_idx);
 150     const QAbstractItemModel *model = leftWidget->model();
 151     const QModelIndex pidx = ganttProxyModel.mapFromSource(idx);
 152     bool isMulti = false;
 153     for (QModelIndex treewalkidx = pidx; treewalkidx.isValid(); treewalkidx = treewalkidx.parent()) {
 154         if (treewalkidx.data(ItemTypeRole).toInt() == TypeMulti
 155                 && !gfxview.rowController()->isRowExpanded(treewalkidx)) {
 156             isMulti = true;
 157             break;
 158         }
 159     }
 160
 161     if (!isMulti) {
 162         for (int i = 0; i < model->rowCount(idx); ++i) {
 163             gfxview.deleteSubtree(ganttProxyModel.index(i, 0, pidx));
 164         }
 165     } else {
 166         gfxview.updateRow(pidx);
 167     }
 168     //qCDebug(KDGANTT_LOG) << "Looking to update from " << idx;
 169     while ((idx = tw->indexBelow(idx)) != QModelIndex() &&
 170             gfxview.rowController()->isRowVisible(ganttProxyModel.mapFromSource(idx))) {
 171         const QModelIndex proxyidx(ganttProxyModel.mapFromSource(idx));
 172         gfxview.updateRow(proxyidx);
 173     }
 174     gfxview.blockSignals(blocked);
 175     gfxview.updateSceneRect();
 176 }
 177
 178 void View::Private::slotExpanded(const QModelIndex &_idx)
 179 {
 180     QModelIndex idx(ganttProxyModel.mapFromSource(_idx));
 181     do {
 182         //qCDebug(KDGANTT_LOG) << "Updating row" << idx << idx.data( Qt::DisplayRole ).toString();
 183         gfxview.updateRow(idx);
 184     } while ((idx = gfxview.rowController()->indexBelow(idx)) != QModelIndex()
 185              && gfxview.rowController()->isRowVisible(idx));
 186     gfxview.updateSceneRect();
 187 }
 188
 189 void View::Private::slotVerticalScrollValueChanged(int val)
 190 {
 191 #if 0
 192     qCDebug(KDGANTT_LOG) << "View::Private::slotVerticalScrollValueChanged(" << val << ")="
 193                          << val / gfxview.verticalScrollBar()->singleStep();
 194 #endif
 195     leftWidget->verticalScrollBar()->setValue(val / gfxview.verticalScrollBar()->singleStep());
 196 }
 197
 198 void View::Private::slotLeftWidgetVerticalRangeChanged(int min, int max)
 199 {
 200     //qCDebug(KDGANTT_LOG) << "View::Private::slotLeftWidgetVerticalRangeChanged("<<min<<max<<")";
 201     gfxview.verticalScrollBar()->setRange(min, max);
 202     gfxview.updateSceneRect();
 203 }
 204
 205 void View::Private::slotGfxViewVerticalRangeChanged(int min, int max)
 206 {
 207     //qCDebug(KDGANTT_LOG) << "View::Private::slotGfxViewVerticalRangeChanged("<<min<<max<<")";
 208     int leftMin = leftWidget->verticalScrollBar()->minimum();
 209     int leftMax = leftWidget->verticalScrollBar()->maximum();
 210     bool blocked = gfxview.verticalScrollBar()->blockSignals(true);
 211     gfxview.verticalScrollBar()->setRange(qMax(min, leftMin), qMax(max, leftMax));
 212     gfxview.verticalScrollBar()->blockSignals(blocked);
 213 }
 214
 215 /*!\class KDGantt::View kdganttview.h KDGanttView
 216  * \ingroup KDGantt
 217  * \brief This widget that consists of a QTreeView and a GraphicsView
 218  *
 219  * This is the easy to use, complete gantt chart widget. It
 220  * consists of a QTreeView on the left and a KDGantt::GraphicsView
 221  * on the right separated by a QSplitter. The two views share the same
 222  * model.
 223  */
 224
 225 /*! Constructor. Creates a View with parent \a parent,
 226  * a DateTimeGrid as default grid implementaion and no model etc.
 227  */
 228 View::View(QWidget *parent)
 229     : QWidget(parent),
 230       _d(new Private(this))
 231 {
 232 #if defined KDAB_EVAL
 233     EvalDialog::checkEvalLicense("KD Gantt");
 234 #endif
 235     _d->init();
 236 }
 237
 238 View::~View()
 239 {
 240     delete _d;
 241 }
 242
 243 #define d d_func()
 244
 245 /*! Replaces the left widget with a custom QAbstractItemView.
 246  *
 247  * \param aiv The view to be used to the left, instead of the default tree view
 248  * \sa setRowController()
 249  */
 250 void View::setLeftView(QAbstractItemView *aiv)
 251 {
 252     assert(aiv);
 253     if (aiv == d->leftWidget) {
 254         return;
 255     }
 256     if (!d->leftWidget.isNull()) {
 257         d->leftWidget->disconnect(this);
 258         d->leftWidget->hide();
 259         d->leftWidget->verticalScrollBar()->disconnect(d->gfxview.verticalScrollBar());
 260         d->gfxview.verticalScrollBar()->disconnect(d->leftWidget->verticalScrollBar());
 261     }
 262
 263     d->leftWidget = aiv;
 264     d->splitter.insertWidget(0, d->leftWidget);
 265
 266     if (qobject_cast<QTreeView *>(d->leftWidget)) {
 267         connect(d->leftWidget,  SIGNAL(collapsed(QModelIndex)),
 268                 this, SLOT(slotCollapsed(QModelIndex)));
 269         connect(d->leftWidget,  SIGNAL(expanded(QModelIndex)),
 270                 this, SLOT(slotExpanded(QModelIndex)));
 271     }
 272
 273     connect(d->gfxview.verticalScrollBar(), SIGNAL(valueChanged(int)),
 274             d->leftWidget->verticalScrollBar(), SLOT(setValue(int)));
 275     connect(d->leftWidget->verticalScrollBar(), SIGNAL(valueChanged(int)),
 276             d->gfxview.verticalScrollBar(), SLOT(setValue(int)));
 277     connect(d->leftWidget->verticalScrollBar(), SIGNAL(rangeChanged(int,int)),
 278             this, SLOT(slotLeftWidgetVerticalRangeChanged(int,int)));
 279     connect(d->gfxview.verticalScrollBar(), SIGNAL(rangeChanged(int,int)),
 280             this, SLOT(slotGfxViewVerticalRangeChanged(int,int)));
 281 }
 282
 283 /*! Sets \a ctrl to be the rowcontroller used by this View.
 284  * The default rowcontroller is owned by KDGantt::View and is
 285  * suitable for the default treeview in the left part of the view.
 286  * You probably only want to change this if you replace the treeview.
 287  */
 288 void View::setRowController(AbstractRowController *ctrl)
 289 {
 290     if (ctrl == d->rowController) {
 291         return;
 292     }
 293     d->rowController = ctrl;
 294     d->gfxview.setRowController(d->rowController);
 295 }
 296
 297 /*! \returns a pointer to the current rowcontroller.
 298  * \see AbstractRowController
 299  */
 300 AbstractRowController *View::rowController()
 301 {
 302     return d->rowController;
 303 }
 304
 305 /*! \overload AbstractRowController* KDGantt::View::rowController()
 306  */
 307 const AbstractRowController *View::rowController() const
 308 {
 309     return d->rowController;
 310 }
 311
 312 /*!
 313  * \returns a pointer to the QAbstractItemView in the left
 314  * part of the widget.
 315  * */
 316 const QAbstractItemView *View::leftView() const
 317 {
 318     return d->leftWidget;
 319 }
 320
 321 /*!
 322  * \overload const QAbstractItemView* KDGantt::View::leftView() const
 323  */
 324 QAbstractItemView *View::leftView()
 325 {
 326     return d->leftWidget;
 327 }
 328
 329 /*!
 330  * \returns a pointer to the GraphicsView
 331  */
 332 const GraphicsView *View::graphicsView() const
 333 {
 334     return &d->gfxview;
 335 }
 336
 337 /*!
 338  * \overload const GraphicsView* KDGantt::View::graphicsView() const
 339  */
 340 GraphicsView *View::graphicsView()
 341 {
 342     return &d->gfxview;
 343 }
 344
 345 /*!
 346  * \returns a pointer to the QSplitter that manages the left view and graphicsView
 347  */
 348 const QSplitter *View::splitter() const
 349 {
 350     return &d->splitter;
 351 }
 352
 353 /*!
 354  * \overload const QSplitter* KDGantt::View::splitter() const
 355  */
 356 QSplitter *View::splitter()
 357 {
 358     return &d->splitter;
 359 }
 360
 361 /*! \returns the current model displayed by this view
 362  */
 363 QAbstractItemModel *View::model() const
 364 {
 365     return leftView()->model();
 366 }
 367
 368 /*! Sets the QAbstractItemModel to be displayed in this view
 369  * to \a model.
 370  *
 371  * \see GraphicsView::setModel
 372  */
 373 void View::setModel(QAbstractItemModel *model)
 374 {
 375     leftView()->setModel(model);
 376     d->ganttProxyModel.setSourceModel(model);
 377     d->gfxview.setModel(&d->ganttProxyModel);
 378 }
 379
 380 /*! \returns the QItemSelectionModel used by this view
 381  */
 382 QItemSelectionModel *View::selectionModel() const
 383 {
 384     return leftView()->selectionModel();
 385 }
 386
 387 /*! Sets the QItemSelectionModel used by this view to manage
 388  * selections. Similar to QAbstractItemView::setSelectionModel
 389  */
 390 void View::setSelectionModel(QItemSelectionModel *smodel)
 391 {
 392     leftView()->setSelectionModel(smodel);
 393     d->gfxview.setSelectionModel(new QItemSelectionModel(&(d->ganttProxyModel), this));
 394 }
 395
 396 /*! Sets the AbstractGrid for this view. The grid is an
 397  * object that controls how QModelIndexes are mapped
 398  * to and from the view and how the background and header
 399  * is rendered. \see AbstractGrid and DateTimeGrid.
 400  */
 401 void View::setGrid(AbstractGrid *grid)
 402 {
 403     d->gfxview.setGrid(grid);
 404 }
 405
 406 /*! \returns the AbstractGrid used by this view.
 407  */
 408 AbstractGrid *View::grid() const
 409 {
 410     return d->gfxview.grid();
 411 }
 412
 413 /*! \returns the rootindex for this view.
 414  */
 415 QModelIndex View::rootIndex() const
 416 {
 417     return leftView()->rootIndex();
 418 }
 419
 420 /*! Sets the root index of the model displayed by this view.
 421  * Similar to QAbstractItemView::setRootIndex, default is QModelIndex().
 422  */
 423 void View::setRootIndex(const QModelIndex &idx)
 424 {
 425     leftView()->setRootIndex(idx);
 426     d->gfxview.setRootIndex(idx);
 427 }
 428
 429 /*! \returns the ItemDelegate used by this view to render items
 430 */
 431 ItemDelegate *View::itemDelegate() const
 432 {
 433     return d->gfxview.itemDelegate();
 434 }
 435
 436 /*! Sets the KDGantt::ItemDelegate used for rendering items on this
 437  * view. \see ItemDelegate and QAbstractItemDelegate.
 438  */
 439 void View::setItemDelegate(ItemDelegate *delegate)
 440 {
 441     leftView()->setItemDelegate(delegate);
 442     d->gfxview.setItemDelegate(delegate);
 443 }
 444
 445 /*! Sets the constraintmodel displayed by this view.
 446  * \see KDGantt::ConstraintModel.
 447  */
 448 void View::setConstraintModel(ConstraintModel *cm)
 449 {
 450     d->constraintProxy.setSourceModel(cm);
 451     d->gfxview.setConstraintModel(&d->mappedConstraintModel);
 452 }
 453
 454 /*! \returns the KDGantt::ConstraintModel displayed by this view.
 455  */
 456 ConstraintModel *View::constraintModel() const
 457 {
 458     return d->constraintProxy.sourceModel();
 459 }
 460
 461 const QAbstractProxyModel *View::ganttProxyModel() const
 462 {
 463     return &(d->ganttProxyModel);
 464 }
 465
 466 QAbstractProxyModel *View::ganttProxyModel()
 467 {
 468     return &(d->ganttProxyModel);
 469 }
 470
 471 void View::resizeEvent(QResizeEvent *ev)
 472 {
 473     QWidget::resizeEvent(ev);
 474 }
 475
 476 /*!\returns The QModelIndex for the item located at
 477  * position \a pos in the view or an invalid index
 478  * if no item was present at that position.
 479  *
 480  * \see GraphicsView::indexAt
 481  */
 482 QModelIndex View::indexAt(const QPoint &pos) const
 483 {
 484     return d->gfxview.indexAt(pos);
 485 }
 486
 487 /*! Print the Gantt chart using \a printer. If \a drawRowLabels
 488  * is true (the default), each row will have it's label printed
 489  * on the left side.
 490  *
 491  * This version of print() will print multiple pages.
 492  */
 493 void View::print(QPrinter *printer, bool drawRowLabels)
 494 {
 495     graphicsView()->print(printer, drawRowLabels);
 496 }
 497
 498 /*! Print part of the Gantt chart from \a start to \a end using \a printer.
 499  * If \a drawRowLabels is true (the default), each row will have it's
 500  * label printed on the left side.
 501  *
 502  * This version of print() will print multiple pages.
 503  *
 504  * To print a certain range of a chart with a DateTimeGrid, use
 505  * qreal DateTimeGrid::mapFromDateTime( const QDateTime& dt) const
 506  * to figure out the values for \a start and \a end.
 507  */
 508 void View::print(QPrinter *printer, qreal start, qreal end, bool drawRowLabels)
 509 {
 510     graphicsView()->print(printer, start, end, drawRowLabels);
 511 }
 512
 513 /*! Render the GanttView inside the rectangle \a target using the painter \a painter.
 514  * If \a drawRowLabels is true (the default), each row will have it's
 515  * label printed on the left side.
 516  */
 517 void View::print(QPainter *painter, const QRectF &target, bool drawRowLabels)
 518 {
 519     d->gfxview.print(painter,
 520                      target,
 521                      drawRowLabels);
 522 }
 523
 524 /*! Render the GanttView inside the rectangle \a target using the painter \a painter.
 525  * If \a drawRowLabels is true (the default), each row will have it's
 526  * label printed on the left side.
 527  *
 528  * To print a certain range of a chart with a DateTimeGrid, use
 529  * qreal DateTimeGrid::mapFromDateTime( const QDateTime& dt) const
 530  * to figure out the values for \a start and \a end.
 531  */
 532 void View::print(QPainter *painter, qreal start, qreal end, const QRectF &target, bool drawRowLabels)
 533 {
 534     d->gfxview.print(painter,
 535                      start, end,
 536                      target,
 537                      drawRowLabels);
 538 }
 539
 540 #include "moc_kdganttview.cpp"
 541
 542 #ifndef KDAB_NO_UNIT_TESTS
 543 #include "unittest/test.h"
 544
 545 #include "kdganttlistviewrowcontroller.h"
 546 #include <QApplication>
 547 #include <QTimer>
 548 #include <QPixmap>
 549 #include <QListView>
 550
 551 namespace
 552 {
 553 std::ostream &operator<<(std::ostream &os, const QImage &img)
 554 {
 555     os << "QImage[ size=(" << img.width() << ", " << img.height() << ")]";
 556     return os;
 557 }
 558 }
 559
 560 KDAB_SCOPED_UNITTEST_SIMPLE(KDGantt, View, "test")
 561 {
 562     View view(0);
 563 #if 0 // GUI tests do not work well on the server
 564     QTimer::singleShot(1000, qApp, SLOT(quit()));
 565     view.show();
 566
 567     qApp->exec();
 568     QPixmap screenshot1 = QPixmap::grabWidget(&view);
 569
 570     QTreeView *tv = new QTreeView;
 571     view.setLeftView(tv);
 572     view.setRowController(new TreeViewRowController(tv, view.ganttProxyModel()));
 573
 574     QTimer::singleShot(1000, qApp, SLOT(quit()));
 575
 576     qApp->exec();
 577     QPixmap screenshot2 = QPixmap::grabWidget(&view);
 578
 579     assertEqual(screenshot1.toImage(),  screenshot2.toImage());
 580
 581     QListView *lv = new QListView;
 582     view.setLeftView(lv);
 583     view.setRowController(new ListViewRowController(lv, view.ganttProxyModel()));
 584     view.show();
 585     QTimer::singleShot(1000, qApp, SLOT(quit()));
 586     qApp->exec();
 587 #endif
 588 }
 589 #endif /* KDAB_NO_UNIT_TESTS */