kdgantt2/kdganttgraphicsview.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 "kdganttgraphicsview.h"
  26 #include "kdganttgraphicsview_p.h"
  27 #include "kdganttabstractrowcontroller.h"
  28 #include "kdganttgraphicsitem.h"
  29 #include "kdganttconstraintmodel.h"
  30
  31 #include <QMenu>
  32 #include <QPainter>
  33 #include <QPaintEvent>
  34 #include <QResizeEvent>
  35 #include <QScrollBar>
  36 #include <QAbstractProxyModel>
  37
  38 #include <cassert>
  39
  40 #if defined KDAB_EVAL
  41 #include "../evaldialog/evaldialog.h"
  42 #endif
  43
  44 /*!\class KDGantt::HeaderWidget
  45  * \internal
  46  */
  47
  48 using namespace KDGantt;
  49
  50 HeaderWidget::HeaderWidget( GraphicsView* parent )
  51     : QWidget( parent ), m_offset( 0. )
  52 {
  53     assert( parent ); // Parent must be set
  54 }
  55
  56 HeaderWidget::~HeaderWidget()
  57 {
  58 }
  59
  60 void HeaderWidget::scrollTo( int v )
  61 {
  62     m_offset = v;
  63     // QWidget::scroll() wont work properly for me on Mac
  64     //scroll( static_cast<int>( old-v ), 0 );
  65     update();
  66 }
  67
  68 void HeaderWidget::paintEvent( QPaintEvent* ev )
  69 {
  70     QPainter p( this );
  71     view()->grid()->paintHeader( &p, rect(), ev->rect(), m_offset, this );
  72 }
  73
  74 #ifndef QT_NO_CONTEXTMENU
  75 void HeaderWidget::contextMenuEvent( QContextMenuEvent* event )
  76 {
  77     QMenu contextMenu;
  78
  79     DateTimeGrid* const grid = qobject_cast< DateTimeGrid* >( view()->grid() );
  80     QAction* actionScaleAuto = 0;
  81     QAction* actionScaleDay = 0;
  82     QAction* actionScaleHour = 0;
  83     QAction* actionZoomIn = 0;
  84     QAction* actionZoomOut = 0;
  85     if( grid != 0 )
  86     {
  87         QMenu* menuScale = new QMenu( tr( "Scale" ), &contextMenu );
  88         QActionGroup* scaleGroup = new QActionGroup( &contextMenu );
  89         scaleGroup->setExclusive( true );
  90
  91         actionScaleAuto = new QAction( tr( "Auto" ), menuScale );
  92         actionScaleAuto->setCheckable( true );
  93         actionScaleAuto->setChecked( grid->scale() == DateTimeGrid::ScaleAuto );
  94         actionScaleDay = new QAction( tr( "Day" ), menuScale );
  95         actionScaleDay->setCheckable( true );
  96         actionScaleDay->setChecked( grid->scale() == DateTimeGrid::ScaleDay );
  97         actionScaleHour = new QAction( tr( "Hour" ), menuScale );
  98         actionScaleHour->setCheckable( true );
  99         actionScaleHour->setChecked( grid->scale() == DateTimeGrid::ScaleHour );
 100
 101         scaleGroup->addAction( actionScaleAuto );
 102         menuScale->addAction( actionScaleAuto );
 103
 104         scaleGroup->addAction( actionScaleDay );
 105         menuScale->addAction( actionScaleDay );
 106
 107         scaleGroup->addAction( actionScaleHour );
 108         menuScale->addAction( actionScaleHour );
 109
 110         contextMenu.addMenu( menuScale );
 111
 112         contextMenu.addSeparator();
 113
 114         actionZoomIn = new QAction( tr( "Zoom In" ), &contextMenu );
 115         contextMenu.addAction( actionZoomIn );
 116         actionZoomOut = new QAction( tr( "Zoom Out" ), &contextMenu );
 117         contextMenu.addAction( actionZoomOut );
 118     }
 119
 120     if( contextMenu.isEmpty() )
 121     {
 122         event->ignore();
 123         return;
 124     }
 125
 126     const QAction* const action = contextMenu.exec( event->globalPos() );
 127     if( action == 0 ) {}
 128     else if( action == actionScaleAuto )
 129     {
 130         assert( grid != 0 );
 131         grid->setScale( DateTimeGrid::ScaleAuto );
 132     }
 133     else if( action == actionScaleDay )
 134     {
 135         assert( grid != 0 );
 136         grid->setScale( DateTimeGrid::ScaleDay );
 137     }
 138     else if( action == actionScaleHour )
 139     {
 140         assert( grid != 0 );
 141         grid->setScale( DateTimeGrid::ScaleHour );
 142     }
 143     else if( action == actionZoomIn )
 144     {
 145         assert( grid != 0 );
 146         grid->setDayWidth( grid->dayWidth() + 10.0 );
 147     }
 148     else if( action == actionZoomOut )
 149     {
 150         assert( grid != 0 );
 151         grid->setDayWidth( grid->dayWidth() - 10.0 );
 152     }
 153
 154     event->accept();
 155 }
 156 #endif
 157
 158 GraphicsView::Private::Private( GraphicsView* _q )
 159   : q( _q ), rowcontroller(0), headerwidget( _q )
 160 {
 161 }
 162
 163 void GraphicsView::Private::updateHeaderGeometry()
 164 {
 165     q->setViewportMargins(0,rowcontroller->headerHeight(),0,0);
 166     headerwidget.setGeometry( q->viewport()->x(),
 167                               q->viewport()->y() - rowcontroller->headerHeight(),
 168                               q->viewport()->width(),
 169                               rowcontroller->headerHeight() );
 170 }
 171
 172 void GraphicsView::Private::slotGridChanged()
 173 {
 174     updateHeaderGeometry();
 175     headerwidget.update();
 176     q->updateSceneRect();
 177     q->update();
 178 }
 179
 180 void GraphicsView::Private::slotHorizontalScrollValueChanged( int val )
 181 {
 182 #if QT_VERSION >= 0x040300
 183     const QRectF viewRect = q->transform().mapRect( q->sceneRect() );
 184 #else
 185     const QRectF viewRect = q->sceneRect();
 186 #endif
 187     headerwidget.scrollTo( val-q->horizontalScrollBar()->minimum()+static_cast<int>( viewRect.left() ) );
 188 }
 189
 190 void GraphicsView::Private::slotColumnsInserted( const QModelIndex& parent,  int start, int end )
 191 {
 192     Q_UNUSED( start );
 193     Q_UNUSED( end );
 194     QModelIndex idx = scene.model()->index( 0, 0, scene.summaryHandlingModel()->mapToSource( parent ) );
 195     do {
 196         scene.updateRow( scene.summaryHandlingModel()->mapFromSource( idx ) );
 197     } while ( ( idx = rowcontroller->indexBelow( idx ) ) != QModelIndex() && rowcontroller->isRowVisible( idx ) );
 198         //} while ( ( idx = d->treeview.indexBelow( idx ) ) != QModelIndex() && d->treeview.visualRect(idx).isValid() );
 199      q->updateSceneRect();
 200 }
 201
 202 void GraphicsView::Private::slotColumnsRemoved( const QModelIndex& parent,  int start, int end )
 203 {
 204     // TODO
 205     Q_UNUSED( start );
 206     Q_UNUSED( end );
 207     Q_UNUSED( parent );
 208     q->updateScene();
 209 }
 210
 211 void GraphicsView::Private::slotDataChanged( const QModelIndex& topLeft, const QModelIndex& bottomRight )
 212 {
 213     //qDebug() << "GraphicsView::slotDataChanged("<<topLeft<<bottomRight<<")";
 214     const QModelIndex parent = topLeft.parent();
 215     for ( int row = topLeft.row(); row <= bottomRight.row(); ++row ) {
 216         scene.updateRow( scene.summaryHandlingModel()->index( row, 0, parent ) );
 217     }
 218 }
 219
 220 void GraphicsView::Private::slotLayoutChanged()
 221 {
 222     //qDebug() << "slotLayoutChanged()";
 223     q->updateScene();
 224 }
 225
 226 void GraphicsView::Private::slotModelReset()
 227 {
 228     //qDebug() << "slotModelReset()";
 229     q->updateScene();
 230 }
 231
 232 void GraphicsView::Private::slotRowsInserted( const QModelIndex& parent,  int start, int end )
 233 {
 234     Q_UNUSED( parent );
 235     Q_UNUSED( start );
 236     Q_UNUSED( end );
 237     q->updateScene(); // TODO: This might be optimised
 238 }
 239
 240 void GraphicsView::Private::slotRowsAboutToBeRemoved( const QModelIndex& parent,  int start, int end )
 241 {
 242     //qDebug() << "GraphicsView::Private::slotRowsAboutToBeRemoved("<<parent<<start<<end<<")";
 243     for ( int row = start; row <= end; ++row ) {
 244         for ( int col = 0; col < scene.summaryHandlingModel()->columnCount( parent ); ++col ) {
 245             //qDebug() << "removing "<<scene.summaryHandlingModel()->index( row, col, parent );
 246             scene.removeItem( scene.summaryHandlingModel()->index( row, col, parent ) );
 247         }
 248     }
 249 }
 250
 251 void GraphicsView::Private::slotRowsRemoved( const QModelIndex& parent,  int start, int end )
 252 {
 253     //qDebug() << "GraphicsView::Private::slotRowsRemoved("<<parent<<start<<end<<")";
 254     // TODO
 255     Q_UNUSED( parent );
 256     Q_UNUSED( start );
 257     Q_UNUSED( end );
 258
 259     q->updateScene();
 260 }
 261
 262 void GraphicsView::Private::slotItemClicked( const QModelIndex& idx )
 263 {
 264     QModelIndex sidx = idx;//scene.summaryHandlingModel()->mapToSource( idx );
 265     emit q->clicked( sidx );
 266     if (q->style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick, 0, q))
 267         emit q->activated( sidx );
 268 }
 269
 270 void GraphicsView::Private::slotItemDoubleClicked( const QModelIndex& idx )
 271 {
 272     QModelIndex sidx = idx;//scene.summaryHandlingModel()->mapToSource( idx );
 273     emit q->doubleClicked( sidx );
 274     if (!q->style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick, 0, q))
 275         emit q->activated( sidx );
 276 }
 277
 278 void GraphicsView::Private::slotHeaderContextMenuRequested( const QPoint& pt )
 279 {
 280     emit q->headerContextMenuRequested( headerwidget.mapToGlobal( pt ) );
 281 }
 282
 283 /*!\class KDGantt::GraphicsView kdganttgraphicsview.h KDGanttGraphicsView
 284  * \ingroup KDGantt
 285  * \brief The GraphicsView class provides a model/view implementation of a gantt chart.
 286  *
 287  *
 288  */
 289
 290 /*! \signal void GraphicsView::activated( const QModelIndex & index ) */
 291 /*! \signal void GraphicsView::clicked( const QModelIndex & index ); */
 292 /*! \signal void GraphicsView::doubleClicked( const QModelIndex & index ); */
 293 /*! \signal void GraphicsView::entered( const QModelIndex & index ); */
 294 /*! \signal void GraphicsView::pressed( const QModelIndex & index ); */
 295 /*! \signal void GraphicsView::headerContextMenuRequested( const QPoint& pt )
 296  * This signal is emitted when the header has contextMenuPolicy Qt::CustomContextMenu
 297  * and the widget wants to show a contextmenu for the header. Unlike in
 298  * QWidget::customContextMenuRequested() signal, \a pt is here in global coordinates.
 299  */
 300
 301 /*! Constructor. Creates a new KDGantt::GraphicsView with parent
 302  * \a parent.
 303  */
 304 GraphicsView::GraphicsView( QWidget* parent )
 305     : QGraphicsView( parent ), _d( new Private( this ) )
 306 {
 307
 308 #if defined KDAB_EVAL
 309   EvalDialog::checkEvalLicense( "KD Gantt" );
 310 #endif
 311     connect( horizontalScrollBar(), SIGNAL(valueChanged(int)),
 312              this, SLOT(slotHorizontalScrollValueChanged(int)) );
 313     connect( &_d->scene, SIGNAL(gridChanged()),
 314              this, SLOT(slotGridChanged()) );
 315     connect( &_d->scene, SIGNAL(entered(QModelIndex)),
 316              this, SIGNAL(entered(QModelIndex)) );
 317     connect( &_d->scene, SIGNAL(pressed(QModelIndex)),
 318              this, SIGNAL(pressed(QModelIndex)) );
 319     connect( &_d->scene, SIGNAL(clicked(QModelIndex)),
 320              this, SLOT(slotItemClicked(QModelIndex)) );
 321     connect( &_d->scene, SIGNAL(doubleClicked(QModelIndex)),
 322              this, SLOT(slotItemDoubleClicked(QModelIndex)) );
 323     connect( &_d->scene, SIGNAL(sceneRectChanged(QRectF)),
 324              this, SLOT(updateSceneRect()) );
 325     connect( &_d->headerwidget, SIGNAL(customContextMenuRequested(QPoint)),
 326              this, SLOT(slotHeaderContextMenuRequested(QPoint)) );
 327     setScene( &_d->scene );
 328
 329     // HACK!
 330     setSummaryHandlingModel( _d->scene.summaryHandlingModel() );
 331
 332     //setCacheMode( CacheBackground );
 333 }
 334
 335 /*! Destroys this view. */
 336 GraphicsView::~GraphicsView()
 337 {
 338     delete _d;
 339 }
 340
 341 #define d d_func()
 342
 343 /*! Sets the model to be displayed in this view to
 344  * \a model. The view does not take ownership of the model.
 345  *
 346  * To make a model work well with GraphicsView it must
 347  * have a certain layout. Whether the model is flat or has a
 348  * treestrucure is not important, as long as an
 349  * AbstractRowController is provided that can navigate the
 350  * model.
 351  *
 352  * GraphicsView operates per row in the model. The data is always
 353  * taken from the _last_ item in the row. The ItemRoles used are
 354  * Qt::DisplayRole and the roles defined in KDGantt::ItemDataRole.
 355  */
 356 void GraphicsView::setModel( QAbstractItemModel* model )
 357 {
 358     if ( d->scene.model() ) {
 359         disconnect( d->scene.model() );
 360     }
 361
 362     d->scene.setModel( model );
 363     connect( model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
 364              this, SLOT(updateSceneRect()) );
 365     updateScene();
 366 }
 367
 368 /*! \returns the current model displayed by this view
 369  */
 370 QAbstractItemModel* GraphicsView::model() const
 371 {
 372     return d->scene.model();
 373 }
 374
 375 void GraphicsView::setSummaryHandlingModel( QAbstractProxyModel* proxyModel )
 376 {
 377     disconnect( d->scene.summaryHandlingModel() );
 378     d->scene.setSummaryHandlingModel( proxyModel );
 379
 380     /* Connections. We have to rely on the treeview
 381      * to receive the signals before we do(!)
 382      */
 383     connect( proxyModel, SIGNAL(columnsInserted(QModelIndex,int,int)),
 384              this,  SLOT(slotColumnsInserted(QModelIndex,int,int)) );
 385     connect( proxyModel, SIGNAL(columnsRemoved(QModelIndex,int,int)),
 386              this,  SLOT(slotColumnsRemoved(QModelIndex,int,int)) );
 387     connect( proxyModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
 388              this,  SLOT(slotDataChanged(QModelIndex,QModelIndex)) );
 389     connect( proxyModel, SIGNAL(layoutChanged()),
 390              this,  SLOT(slotLayoutChanged()) );
 391     connect( proxyModel, SIGNAL(modelReset()),
 392              this,  SLOT(slotModelReset()) );
 393     connect( proxyModel, SIGNAL(rowsInserted(QModelIndex,int,int)),
 394              this,  SLOT(slotRowsInserted(QModelIndex,int,int)) );
 395     connect( proxyModel, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
 396              this,  SLOT(slotRowsAboutToBeRemoved(QModelIndex,int,int)) );
 397     connect( proxyModel, SIGNAL(rowsRemoved(QModelIndex,int,int)),
 398              this,  SLOT(slotRowsRemoved(QModelIndex,int,int)) );
 399
 400     updateScene();
 401 }
 402
 403 /*! Sets the constraintmodel displayed by this view.
 404  * \see KDGantt::ConstraintModel.
 405  */
 406 void GraphicsView::setConstraintModel( ConstraintModel* cmodel )
 407 {
 408     d->scene.setConstraintModel( cmodel );
 409 }
 410
 411 /*! \returns the KDGantt::ConstraintModel displayed by this view.
 412  */
 413 ConstraintModel* GraphicsView::constraintModel() const
 414 {
 415     return d->scene.constraintModel();
 416 }
 417
 418 /*! \returns the KDGantt::SummaryHandlingProxyModel used by this view.
 419  */
 420 QAbstractProxyModel* GraphicsView::summaryHandlingModel() const
 421 {
 422     return d->scene.summaryHandlingModel();
 423 }
 424
 425 /*! Sets the root index of the model displayed by this view.
 426  * Similar to QAbstractItemView::setRootIndex, default is QModelIndex().
 427  */
 428 void GraphicsView::setRootIndex( const QModelIndex& idx )
 429 {
 430     d->scene.setRootIndex( idx );
 431 }
 432
 433 /*! \returns the rootindex for this view.
 434  */
 435 QModelIndex GraphicsView::rootIndex() const
 436 {
 437     return d->scene.rootIndex();
 438 }
 439
 440 /*! Sets the QItemSelectionModel used by this view to manage
 441  * selections. Similar to QAbstractItemView::setSelectionModel
 442  */
 443 void GraphicsView::setSelectionModel( QItemSelectionModel* model )
 444 {
 445     d->scene.setSelectionModel( model );
 446 }
 447
 448 /*! \returns the QItemSelectionModel used by this view
 449  */
 450 QItemSelectionModel* GraphicsView::selectionModel() const
 451 {
 452     return d->scene.selectionModel();
 453 }
 454
 455 /*! Sets the KDGantt::ItemDelegate used for rendering items on this
 456  * view. \see ItemDelegate and QAbstractItemDelegate.
 457  */
 458 void GraphicsView::setItemDelegate( ItemDelegate* delegate )
 459 {
 460     d->scene.setItemDelegate( delegate );
 461 }
 462
 463 /*! \returns the ItemDelegate used by this view to render items
 464 */
 465 ItemDelegate* GraphicsView::itemDelegate() const
 466 {
 467     return d->scene.itemDelegate();
 468 }
 469
 470 /*! Sets the AbstractRowController used by this view. The
 471  * AbstractRowController deals with the height and position
 472  * of each row and with which parts of the model are
 473  * displayed. \see AbstractRowController
 474  */
 475 void GraphicsView::setRowController( AbstractRowController* rowcontroller )
 476 {
 477     d->rowcontroller = rowcontroller;
 478     d->scene.setRowController( rowcontroller );
 479     updateScene();
 480 }
 481
 482 /*! \returns the AbstractRowController
 483  * for this view. \see setRowController
 484  */
 485 AbstractRowController* GraphicsView::rowController() const
 486 {
 487     return d->rowcontroller;
 488 }
 489
 490 /*! Sets the AbstractGrid for this view. The grid is an
 491  * object that controls how QModelIndexes are mapped
 492  * to and from the view and how the background and header
 493  * is rendered. \see AbstractGrid and DateTimeGrid.
 494  */
 495 void GraphicsView::setGrid( AbstractGrid* grid )
 496 {
 497     d->scene.setGrid( grid );
 498     d->slotGridChanged();
 499 }
 500
 501 /*! \returns the AbstractGrid used by this view.
 502  */
 503 AbstractGrid* GraphicsView::grid() const
 504 {
 505     return d->scene.grid();
 506 }
 507
 508 /*! Sets the view to read-only mode if \a to is true. The default is
 509  * read/write if the model permits it.
 510  */
 511 void GraphicsView::setReadOnly( bool ro )
 512 {
 513     d->scene.setReadOnly( ro );
 514 }
 515
 516 /*!\returns true iff the view is in read-only mode
 517  */
 518 bool GraphicsView::isReadOnly() const
 519 {
 520     return d->scene.isReadOnly();
 521 }
 522
 523 /*! Sets the context menu policy for the header. The default value
 524  * Qt::DefaultContextMenu results in a standard context menu on the header
 525  * that allows the user to set the scale and zoom.
 526  *
 527  * Setting this to Qt::CustomContextMenu will cause the signal
 528  * headerContextMenuRequested(const QPoint& pt) to be emitted instead.
 529  *
 530  * \see QWidget::setContextMenuPolicy( Qt::ContextMenuPolicy )
 531  */
 532 void GraphicsView::setHeaderContextMenuPolicy( Qt::ContextMenuPolicy p )
 533 {
 534     d->headerwidget.setContextMenuPolicy( p );
 535 }
 536
 537 /*! \returns the context menu policy for the header
 538  */
 539 Qt::ContextMenuPolicy GraphicsView::headerContextMenuPolicy() const
 540 {
 541     return d->headerwidget.contextMenuPolicy();
 542 }
 543
 544 /*! Adds a constraint from \a from to \a to. \a modifiers are the
 545  * keyboard modifiers pressed by the user when the action is invoked.
 546  *
 547  * Override this to control how contraints are added. The default
 548  * implementation adds a soft constraint unless the Shift key is pressed,
 549  * in that case it adds a hard constraint. If a constraint is already
 550  * present, it is removed and nothing is added.
 551  */
 552 void GraphicsView::addConstraint( const QModelIndex& from,
 553                                   const QModelIndex& to,
 554                                   Qt::KeyboardModifiers modifiers )
 555 {
 556     if ( isReadOnly() ) return;
 557     ConstraintModel* cmodel = constraintModel();
 558     assert( cmodel );
 559     Constraint c( from, to, ( modifiers&Qt::ShiftModifier )?Constraint::TypeHard:Constraint::TypeSoft );
 560     if ( cmodel->hasConstraint( c ) ) cmodel->removeConstraint( c );
 561     else cmodel->addConstraint( c );
 562 }
 563
 564 void GraphicsView::resizeEvent( QResizeEvent* ev )
 565 {
 566     d->updateHeaderGeometry();
 567     QRectF r = scene()->itemsBoundingRect();
 568     // To scroll more to the left than the actual item start, bug #4516
 569     r.setLeft( qMin<qreal>( 0.0, r.left() ) );
 570     // TODO: take scrollbars into account (if not always on)
 571     // The scene should be at least the size of the viewport
 572     QSizeF size = viewport()->size();
 573     //TODO: why -2 below? size should be ex. frames etc?
 574     if ( size.width() > r.width() ) {
 575         r.setWidth( size.width() - 2 );
 576     }
 577     if ( size.height() > r.height() ) {
 578         r.setHeight( size.height() - 2 );
 579     }
 580     const int totalh = rowController()->totalHeight();
 581     if ( r.height() < totalh ) {
 582         r.setHeight( totalh );
 583     }
 584
 585     scene()->setSceneRect( r );
 586
 587     QGraphicsView::resizeEvent( ev );
 588 }
 589
 590 /*!\returns The QModelIndex for the item located at
 591  * position \a pos in the view or an invalid index
 592  * if no item was present at that position.
 593  *
 594  * This is useful for for example contextmenus.
 595  */
 596 QModelIndex GraphicsView::indexAt( const QPoint& pos ) const
 597 {
 598     QGraphicsItem* item = itemAt( pos );
 599     if ( GraphicsItem* gitem = qgraphicsitem_cast<GraphicsItem*>( item ) ) {
 600         return d->scene.summaryHandlingModel()->mapToSource( gitem->index() );
 601     } else {
 602         return QModelIndex();
 603     }
 604 }
 605
 606 /*! \internal */
 607 void GraphicsView::clearItems()
 608 {
 609     d->scene.clearItems();
 610 }
 611
 612 /*! \internal */
 613 void GraphicsView::updateRow( const QModelIndex& idx )
 614 {
 615     d->scene.updateRow( d->scene.summaryHandlingModel()->mapFromSource( idx ) );
 616 }
 617
 618 /*! \internal
 619  * Adjusts the bounding rectangle of the scene.
 620  */
 621 void GraphicsView::updateSceneRect()
 622 {
 623     /* What to do with this? We need to shrink the view to
 624      * make collapsing items work
 625      */
 626     qreal range = horizontalScrollBar()->maximum()-horizontalScrollBar()->minimum();
 627     const qreal hscroll = horizontalScrollBar()->value()/( range>0?range:1 );
 628     QRectF r = d->scene.itemsBoundingRect();
 629     // To scroll more to the left than the actual item start, bug #4516
 630     r.setTop( 0. );
 631     r.setLeft( qMin<qreal>( 0.0, r.left() ) );
 632     r.setSize( r.size().expandedTo( viewport()->size() ) );
 633     const int totalh = rowController()->totalHeight();
 634     if ( r.height() < totalh ) r.setHeight( totalh );
 635     d->scene.setSceneRect( r );
 636
 637     /* set scrollbar to keep the same time in view */
 638     range = horizontalScrollBar()->maximum()-horizontalScrollBar()->minimum();
 639     if ( range>0 ) horizontalScrollBar()->setValue( qRound( hscroll*range ) );
 640
 641     /* We have to update here to adjust for any rows with no
 642      * information because they are painted with a different
 643      * background brush
 644      */
 645     d->scene.invalidate( QRectF(), QGraphicsScene::BackgroundLayer );
 646 }
 647
 648 /*! \internal
 649  * Resets the state of the view.
 650  */
 651 void GraphicsView::updateScene()
 652 {
 653     clearItems();
 654     if( !model()) return;
 655     if( !rowController()) return;
 656     QModelIndex idx = model()->index( 0, 0, rootIndex() );
 657     do {
 658         updateRow( idx );
 659     } while ( ( idx = rowController()->indexBelow( idx ) ) != QModelIndex() && rowController()->isRowVisible(idx) );
 660     //constraintModel()->cleanup();
 661     //qDebug() << constraintModel();
 662     updateSceneRect();
 663     if ( scene() ) scene()->invalidate( QRectF(), QGraphicsScene::BackgroundLayer );
 664 }
 665
 666 /*! \internal */
 667 GraphicsItem* GraphicsView::createItem( ItemType type ) const
 668 {
 669     return d->scene.createItem( type );
 670 }
 671
 672 /*! \internal */
 673 void GraphicsView::deleteSubtree( const QModelIndex& idx )
 674 {
 675     d->scene.deleteSubtree( d->scene.summaryHandlingModel()->mapFromSource( idx ) );
 676 }
 677
 678 /*! Print the Gantt chart using \a printer. If \a drawRowLabels
 679  * is true (the default), each row will have it's label printed
 680  * on the left side.
 681  *
 682  * This version of print() will print multiple pages.
 683  */
 684 void GraphicsView::print( QPrinter* printer, bool drawRowLabels )
 685 {
 686     d->scene.print( printer, drawRowLabels );
 687 }
 688
 689 /*! Print part of the Gantt chart from \a start to \a end using \a printer.
 690  * If \a drawRowLabels is true (the default), each row will have it's
 691  * label printed on the left side.
 692  *
 693  * This version of print() will print multiple pages.
 694  *
 695  * To print a certain range of a chart with a DateTimeGrid, use
 696  * qreal DateTimeGrid::mapFromDateTime( const QDateTime& dt) const
 697  * to figure out the values for \a start and \a end.
 698  */
 699 void GraphicsView::print( QPrinter* printer,  qreal start, qreal end, bool drawRowLabels )
 700 {
 701     d->scene.print( printer, start, end, drawRowLabels );
 702 }
 703
 704 /*! Render the GanttView inside the rectangle \a target using the painter \a painter.
 705  * If \a drawRowLabels is true (the default), each row will have it's
 706  * label printed on the left side.
 707  */
 708 void GraphicsView::print( QPainter* painter, const QRectF& targetRect, bool drawRowLabels )
 709 {
 710   d->scene.print(painter,targetRect,drawRowLabels);
 711 }
 712
 713 /*! Render the GanttView inside the rectangle \a target using the painter \a painter.
 714  * If \a drawRowLabels is true (the default), each row will have it's
 715  * label printed on the left side.
 716  *
 717  * To print a certain range of a chart with a DateTimeGrid, use
 718  * qreal DateTimeGrid::mapFromDateTime( const QDateTime& dt) const
 719  * to figure out the values for \a start and \a end.
 720  */
 721 void GraphicsView::print( QPainter* painter, qreal start, qreal end,
 722                           const QRectF& targetRect, bool drawRowLabels )
 723 {
 724   d->scene.print(painter, start, end, targetRect, drawRowLabels);
 725 }
 726
 727
 728 #include "moc_kdganttgraphicsview.cpp"
 729 #include "moc_kdganttgraphicsview_p.cpp"