KD Chart 2  [rev.2.8]
kdganttgraphicsitem.cpp
Go to the documentation of this file.
1 /****************************************************************************
2 ** Copyright (C) 2001-2021 Klaralvdalens Datakonsult AB. All rights reserved.
3 **
4 ** This file is part of the KD Chart library.
5 **
6 ** Licensees holding valid commercial KD Chart licenses may use this file in
7 ** accordance with the KD Chart Commercial License Agreement provided with
8 ** the Software.
9 **
10 **
11 ** This file may be distributed and/or modified under the terms of the
12 ** GNU General Public License version 2 and version 3 as published by the
13 ** Free Software Foundation and appearing in the file LICENSE.GPL.txt included.
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 ** Contact info@kdab.com if any conditions of this licensing are not
19 ** clear to you.
20 **
21 **********************************************************************/
22 
23 #include "kdganttgraphicsitem.h"
24 #include "kdganttgraphicsscene.h"
25 #include "kdganttgraphicsview.h"
26 #include "kdganttitemdelegate.h"
28 #include "kdganttconstraintmodel.h"
29 #include "kdganttconstraint.h"
30 #include "kdganttabstractgrid.h"
32 
33 #include <cassert>
34 #include <cmath>
35 #include <algorithm>
36 #include <iterator>
37 
38 #include <QPainter>
39 #include <QAbstractItemModel>
40 #include <QAbstractProxyModel>
41 #include <QItemSelectionModel>
42 #include <QGraphicsSceneMouseEvent>
43 #include <QGraphicsLineItem>
44 
45 #include <QDebug>
46 
51 using namespace KDGantt;
52 
54 
55 namespace {
56  class Updater {
57  bool *u_ptr;
58  bool oldval;
59  public:
60  Updater( bool* u ) : u_ptr( u ), oldval( *u ) {
61  *u=true;
62  }
63  ~Updater() {
64  *u_ptr = oldval;
65  }
66  };
67 }
69  : BASE( parent ), m_isupdating( false )
70 {
71  if ( scene )
72  scene->addItem( this );
73  init();
74 }
75 
76 GraphicsItem::GraphicsItem( const QModelIndex& idx, QGraphicsItem* parent,
77  GraphicsScene* scene )
78  : BASE( parent ), m_index( idx ), m_isupdating( false )
79 {
80  init();
81  if ( scene )
82  scene->addItem( this );
83 }
84 
86 {
87 }
88 
89 void GraphicsItem::init()
90 {
91  setCacheMode( QGraphicsItem::DeviceCoordinateCache );
92  setFlags( ItemIsMovable|ItemIsSelectable|ItemIsFocusable );
93  setAcceptHoverEvents( true );
94  setHandlesChildEvents( true );
95  setZValue( 100. );
96  m_dragline = 0;
97 }
98 
99 int GraphicsItem::type() const
100 {
101  return Type;
102 }
103 
104 StyleOptionGanttItem GraphicsItem::getStyleOption() const
105 {
107  opt.itemRect = rect();
108  opt.boundingRect = boundingRect();
109  QVariant tp = m_index.model()->data( m_index, TextPositionRole );
110  if (tp.isValid()) {
111  opt.displayPosition = static_cast<StyleOptionGanttItem::Position>(tp.toInt());
112  } else {
113 #if 0
114  qDebug() << "Item" << m_index.model()->data( m_index, Qt::DisplayRole ).toString()
115  << ", ends="<<m_endConstraints.size() << ", starts="<<m_startConstraints.size();
116 #endif
117  opt.displayPosition = m_endConstraints.size()<m_startConstraints.size()?StyleOptionGanttItem::Left:StyleOptionGanttItem::Right;
118 #if 0
119  qDebug() << "choosing" << opt.displayPosition;
120 #endif
121  }
122  QVariant da = m_index.model()->data( m_index, Qt::TextAlignmentRole );
123  if ( da.isValid() ) {
124  opt.displayAlignment = static_cast< Qt::Alignment >( da.toInt() );
125  } else {
126  switch ( opt.displayPosition ) {
127  case StyleOptionGanttItem::Left: opt.displayAlignment = Qt::AlignLeft|Qt::AlignVCenter; break;
128  case StyleOptionGanttItem::Right: opt.displayAlignment = Qt::AlignRight|Qt::AlignVCenter; break;
129  case StyleOptionGanttItem::Hidden: // fall through
130  case StyleOptionGanttItem::Center: opt.displayAlignment = Qt::AlignCenter; break;
131  }
132  }
133  opt.grid = scene()->grid();
134  opt.text = m_index.model()->data( m_index, Qt::DisplayRole ).toString();
135  if ( isEnabled() ) opt.state |= QStyle::State_Enabled;
136  if ( isSelected() ) opt.state |= QStyle::State_Selected;
137  if ( hasFocus() ) opt.state |= QStyle::State_HasFocus;
138  return opt;
139 }
140 
142 {
143  return qobject_cast<GraphicsScene*>( QGraphicsItem::scene() );
144 }
145 
146 void GraphicsItem::setRect( const QRectF& r )
147 {
148 #if 0
149  qDebug() << "GraphicsItem::setRect("<<r<<"), txt="<<m_index.model()->data( m_index, Qt::DisplayRole ).toString();
150  if ( m_index.model()->data( m_index, Qt::DisplayRole ).toString() == QLatin1String("Code Freeze" ) ) {
151  qDebug() << "gotcha";
152  }
153 #endif
154 
155  prepareGeometryChange();
156  m_rect = r;
157  updateConstraintItems();
158  update();
159 }
160 
161 void GraphicsItem::setBoundingRect( const QRectF& r )
162 {
163  prepareGeometryChange();
164  m_boundingrect = r;
165  update();
166 }
167 
169 {
170  return !scene()->isReadOnly() && m_index.model()->flags( m_index ) & Qt::ItemIsEditable;
171 }
172 
173 void GraphicsItem::paint( QPainter* painter, const QStyleOptionGraphicsItem* option,
174  QWidget* widget )
175 {
176  Q_UNUSED( widget );
177  if ( boundingRect().isValid() && scene() ) {
178  StyleOptionGanttItem opt = getStyleOption();
179  *static_cast<QStyleOption*>(&opt) = *static_cast<const QStyleOption*>( option );
180  //opt.fontMetrics = painter->fontMetrics();
181  scene()->itemDelegate()->paintGanttItem( painter, opt, index() );
182  }
183 }
184 
185 void GraphicsItem::setIndex( const QPersistentModelIndex& idx )
186 {
187  m_index=idx;
188  update();
189 }
190 
192 {
193  return scene()->itemDelegate()->toolTip( index() );
194 }
195 
197 {
198  return m_boundingrect;
199 }
200 
201 QPointF GraphicsItem::startConnector( int relationType ) const
202 {
203  switch ( relationType ) {
206  return mapToScene( m_rect.left(), m_rect.top()+m_rect.height()/2. );
207  default:
208  break;
209  }
210  return mapToScene( m_rect.right(), m_rect.top()+m_rect.height()/2. );
211 }
212 
213 QPointF GraphicsItem::endConnector( int relationType ) const
214 {
215  switch ( relationType ) {
218  return mapToScene( m_rect.right(), m_rect.top()+m_rect.height()/2. );
219  default:
220  break;
221  }
222  return mapToScene( m_rect.left(), m_rect.top()+m_rect.height()/2. );
223 }
224 
225 
226 void GraphicsItem::constraintsChanged()
227 {
228  if ( !scene() || !scene()->itemDelegate() ) return;
229  const Span bs = scene()->itemDelegate()->itemBoundingSpan( getStyleOption(), index() );
230  const QRectF br = boundingRect();
231  setBoundingRect( QRectF( bs.start(), 0., bs.length(), br.height() ) );
232 }
233 
235 {
236  assert( item );
237  m_startConstraints << item;
238  item->setStart( startConnector( item->constraint().relationType() ) );
239  constraintsChanged();
240 }
241 
243 {
244  assert( item );
245  m_endConstraints << item;
246  item->setEnd( endConnector( item->constraint().relationType() ) );
247  constraintsChanged();
248 }
249 
251 {
252  assert( item );
253  m_startConstraints.removeAll( item );
254  constraintsChanged();
255 }
256 
258 {
259  assert( item );
260  m_endConstraints.removeAll( item );
261  constraintsChanged();
262 }
263 
264 void GraphicsItem::updateConstraintItems()
265 {
266  { // Workaround for multiple definition error with MSVC6
267  Q_FOREACH( ConstraintGraphicsItem* item, m_startConstraints ) {
268  QPointF s = startConnector( item->constraint().relationType() );
269  item->setStart( s );
270  }}
271  {// Workaround for multiple definition error with MSVC6
272  Q_FOREACH( ConstraintGraphicsItem* item, m_endConstraints ) {
273  QPointF e = endConnector( item->constraint().relationType() );
274  item->setEnd( e );
275  }}
276 }
277 
278 void GraphicsItem::updateItem( const Span& rowGeometry, const QPersistentModelIndex& idx )
279 {
280  //qDebug() << "GraphicsItem::updateItem("<<rowGeometry<<idx<<")";
281  Updater updater( &m_isupdating );
282  if ( !idx.isValid() || idx.data( ItemTypeRole )==TypeMulti ) {
283  setRect( QRectF() );
284  hide();
285  return;
286  }
287 
288  /* Use explicit type cast to avoid ambiguity */
289  const Span s = scene()->grid()->mapToChart( static_cast<const QModelIndex&>( idx ) );
290  setPos( QPointF( s.start(), rowGeometry.start() ) );
291  setRect( QRectF( 0., 0., s.length(), rowGeometry.length() ) );
292  setIndex( idx );
293  const Span bs = scene()->itemDelegate()->itemBoundingSpan( getStyleOption(), index() );
294  //qDebug() << "boundingSpan for" << getStyleOption().text << rect() << "is" << bs;
295  setBoundingRect( QRectF( bs.start(), 0., bs.length(), rowGeometry.length() ) );
296  const int maxh = scene()->rowController()->maximumItemHeight();
297  if ( maxh < rowGeometry.length() ) {
298  QRectF r = rect();
299  const Qt::Alignment align = getStyleOption().displayAlignment;
300  if ( align & Qt::AlignTop ) {
301  // Do nothing
302  } else if ( align & Qt::AlignBottom ) {
303  r.setY( rowGeometry.length()-maxh );
304  } else {
305  // Center
306  r.setY( ( rowGeometry.length()-maxh ) / 2. );
307  }
308  r.setHeight( maxh );
309  setRect( r );
310  }
311 
312  //scene()->setSceneRect( scene()->sceneRect().united( mapToScene( boundingRect() ).boundingRect() ) );
313  //updateConstraintItems();
314 }
315 
316 QVariant GraphicsItem::itemChange( GraphicsItemChange change, const QVariant& value )
317 {
318  if ( !isUpdating() && change==ItemPositionChange && scene() ) {
319  QPointF newPos=value.toPointF();
320  if ( isEditable() ) {
321  newPos.setY( pos().y() );
322  return newPos;
323  } else {
324  return pos();
325  }
326  } else if ( change==QGraphicsItem::ItemSelectedChange ) {
327  if ( index().isValid() && !( index().model()->flags( index() ) & Qt::ItemIsSelectable ) ) {
328  // Reject selection attempt
329  return qVariantFromValue( false );
330  }
331 
332  if ( value.toBool() ) {
333  scene()->selectionModel()->select( index(), QItemSelectionModel::Select );
334  } else {
335  scene()->selectionModel()->select( index(), QItemSelectionModel::Deselect );
336  }
337  }
338 
339  return QGraphicsItem::itemChange( change, value );
340 }
341 
342 void GraphicsItem::focusInEvent( QFocusEvent* event )
343 {
344  Q_UNUSED( event );
345  scene()->selectionModel()->select( index(), QItemSelectionModel::SelectCurrent );
346 }
347 
348 void GraphicsItem::updateModel()
349 {
350  //qDebug() << "GraphicsItem::updateModel()";
351  if ( isEditable() ) {
352  QAbstractItemModel* model = const_cast<QAbstractItemModel*>( index().model() );
353 #if !defined(NDEBUG)
354  ConstraintModel* cmodel = scene()->constraintModel();
355 #endif
356  assert( model );
357  assert( cmodel );
358  if ( model ) {
359  //ItemType typ = static_cast<ItemType>( model->data( index(),
360  // ItemTypeRole ).toInt() );
361  QList<Constraint> constraints;
362  for ( QList<ConstraintGraphicsItem*>::iterator it1 = m_startConstraints.begin() ;
363  it1 != m_startConstraints.end() ;
364  ++it1 )
365  constraints.push_back((*it1)->proxyConstraint());
366  for ( QList<ConstraintGraphicsItem*>::iterator it2 = m_endConstraints.begin() ;
367  it2 != m_endConstraints.end() ;
368  ++it2 )
369  constraints.push_back((*it2)->proxyConstraint());
370  if ( scene()->grid()->mapFromChart( Span( scenePos().x(), rect().width() ),
371  index(),
372  constraints ) ) {
373  scene()->updateRow( index().parent() );
374  }
375  }
376  }
377 }
378 
379 void GraphicsItem::hoverMoveEvent( QGraphicsSceneHoverEvent* event )
380 {
381  if ( !isEditable() ) return;
382  StyleOptionGanttItem opt = getStyleOption();
383  ItemDelegate::InteractionState istate = scene()->itemDelegate()->interactionStateFor( event->pos(), opt, index() );
384  switch ( istate ) {
386 #ifndef QT_NO_CURSOR
387  setCursor( Qt::SizeHorCursor );
388 #endif
389  scene()->itemEntered( index() );
390  break;
392 #ifndef QT_NO_CURSOR
393  setCursor( Qt::SizeHorCursor );
394 #endif
395  scene()->itemEntered( index() );
396  break;
398 #ifndef QT_NO_CURSOR
399  setCursor( Qt::SplitHCursor );
400 #endif
401  scene()->itemEntered( index() );
402  break;
403  default:
404 #ifndef QT_NO_CURSOR
405  unsetCursor();
406 #endif
407  break;
408  };
409 }
410 
411 void GraphicsItem::hoverLeaveEvent( QGraphicsSceneHoverEvent* )
412 {
413 #ifndef QT_NO_CURSOR
414  unsetCursor();
415 #endif
416 }
417 
418 void GraphicsItem::mousePressEvent( QGraphicsSceneMouseEvent* event )
419 {
420  //qDebug() << "GraphicsItem::mousePressEvent("<<event<<")";
421  StyleOptionGanttItem opt = getStyleOption();
422  int istate = scene()->itemDelegate()->interactionStateFor( event->pos(), opt, index() );
423  // If State_None is returned by interactionStateFor(), we ignore this event so that
424  // it can get forwarded to another item that's below this one. Needed, for example,
425  // to allow items to be moved that are placed below the label of another item.
426  if ( istate != ItemDelegate::State_None ) {
427  m_istate = istate;
428  m_presspos = event->pos();
429  m_pressscenepos = event->scenePos();
430  scene()->itemPressed( index() );
431 
432  switch ( m_istate ) {
435  default: /* State_Move */
436  BASE::mousePressEvent( event );
437  break;
438  }
439  } else {
440  event->ignore();
441  }
442 }
443 
444 void GraphicsItem::mouseReleaseEvent( QGraphicsSceneMouseEvent* event )
445 {
446  //qDebug() << "GraphicsItem::mouseReleaseEvent("<<event << ")";
447  if ( !m_presspos.isNull() ) {
448  scene()->itemClicked( index() );
449  }
450  delete m_dragline; m_dragline = 0;
451  if ( scene()->dragSource() ) {
452  // Create a new constraint
453  GraphicsItem* other = qgraphicsitem_cast<GraphicsItem*>( scene()->itemAt( event->scenePos(), QTransform() ) );
454  if ( other && scene()->dragSource()!=other &&
456  {
457  // The code below fixes bug KDCH-696.
458  // Modified the code to add constraint even if the user drags and drops
459  // constraint on left part of the TypeEvent symbol(i.e diamond symbol)
460  QRectF itemRect = other->rect().adjusted(-other->rect().height()/2.0, 0, 0, 0 );
461  if ( other->mapToScene( itemRect ).boundingRect().contains( event->scenePos() ))
462  {
463  GraphicsView* view = qobject_cast<GraphicsView*>( event->widget()->parentWidget() );
464  if ( view ) {
465  view->addConstraint( scene()->summaryHandlingModel()->mapToSource( scene()->dragSource()->index() ),
466  scene()->summaryHandlingModel()->mapToSource( other->index() ), event->modifiers() );
467  }
468  }
469  }
470  else
471  {
472  if ( other && scene()->dragSource()!=other &&
473  other->mapToScene( other->rect() ).boundingRect().contains( event->scenePos() )) {
474  GraphicsView* view = qobject_cast<GraphicsView*>( event->widget()->parentWidget() );
475  if ( view ) {
476  view->addConstraint( scene()->summaryHandlingModel()->mapToSource( scene()->dragSource()->index() ),
477  scene()->summaryHandlingModel()->mapToSource( other->index() ), event->modifiers() );
478  }
479  }
480  }
481 
482  scene()->setDragSource( 0 );
483  //scene()->update();
484  } else {
485  if ( isEditable() ) {
486  updateItemFromMouse(event->scenePos());
487 
488  // It is important to set m_presspos to null here because
489  // when the sceneRect updates because we move the item
490  // a MouseMoveEvent will be delivered, and we have to
491  // protect against that
492  m_presspos = QPointF();
493  updateModel();
494  // without this command we sometimes get a white area at the left side of a task item
495  // after we moved that item right-ways into a grey weekend section of the scene:
496  scene()->update();
497  }
498  }
499 
500  m_presspos = QPointF();
501  BASE::mouseReleaseEvent( event );
502 }
503 
504 void GraphicsItem::mouseDoubleClickEvent( QGraphicsSceneMouseEvent* event )
505 {
506  const int typ = static_cast<ItemType>( index().model()->data( index(), ItemTypeRole ).toInt() );
507  StyleOptionGanttItem opt = getStyleOption();
508  ItemDelegate::InteractionState istate = scene()->itemDelegate()->interactionStateFor( event->pos(), opt, index() );
509  if ( (istate != ItemDelegate::State_None) || (typ == TypeSummary)) {
510  scene()->itemDoubleClicked( index() );
511  }
512  BASE::mouseDoubleClickEvent( event );
513 }
514 
515 void GraphicsItem::updateItemFromMouse( const QPointF& scenepos )
516 {
517  //qDebug() << "GraphicsItem::updateItemFromMouse("<<scenepos<<")";
518  const QPointF p = scenepos - m_presspos;
519  QRectF r = rect();
520  QRectF br = boundingRect();
521  switch ( m_istate ) {
523  setPos( p.x(), pos().y() );
524  break;
526  const qreal brr = br.right();
527  const qreal rr = r.right();
528  const qreal delta = pos().x()-p.x();
529  setPos( p.x(), QGraphicsItem::pos().y() );
530  br.setRight( brr+delta );
531  r.setRight( rr+delta );
532  break;
533  }
535  const qreal rr = r.right();
536  r.setRight( scenepos.x()-pos().x() );
537  br.setWidth( br.width() + r.right()-rr );
538  break;
539  }
540  default: return;
541  }
542  setRect( r );
543  setBoundingRect( br );
544 }
545 
546 void GraphicsItem::mouseMoveEvent( QGraphicsSceneMouseEvent* event )
547 {
548  if ( !isEditable() ) return;
549  if ( m_presspos.isNull() ) return;
550 
551  //qDebug() << "GraphicsItem::mouseMoveEvent("<<event<<"), m_istate="<< static_cast<ItemDelegate::InteractionState>( m_istate );
552  switch ( m_istate ) {
556  // Check for constraint drag
557  if ( qAbs( m_pressscenepos.x()-event->scenePos().x() ) < 10.
558  && qAbs( m_pressscenepos.y()-event->scenePos().y() ) > 5. ) {
560  m_dragline = new QGraphicsLineItem( this );
561  m_dragline->setPen( QPen( Qt::DashLine ) );
562  m_dragline->setLine(QLineF( rect().center(), event->pos() ));
563  scene()->setDragSource( this );
564  break;
565  }
566 
567  scene()->selectionModel()->setCurrentIndex( index(), QItemSelectionModel::Current );
568  updateItemFromMouse(event->scenePos());
569  //BASE::mouseMoveEvent(event);
570  break;
572  QLineF line = m_dragline->line();
573  m_dragline->setLine( QLineF( line.p1(), event->pos() ) );
574  //QGraphicsItem* item = scene()->itemAt( event->scenePos() );
575  break;
576  }
577  }
578 }
KDGantt::GraphicsScene::grid
AbstractGrid * grid() const
Definition: kdganttgraphicsscene.cpp:284
KDGantt::StyleOptionGanttItem::Position
Position
Definition: kdganttstyleoptionganttitem.h:36
KDGantt::StyleOptionGanttItem::Hidden
@ Hidden
Definition: kdganttstyleoptionganttitem.h:36
KDGantt::GraphicsScene::selectionModel
QItemSelectionModel * selectionModel() const
Definition: kdganttgraphicsscene.cpp:255
BASE
QGraphicsItem BASE
Definition: kdganttgraphicsitem.cpp:53
KDGantt::ItemDelegate::State_DragConstraint
@ State_DragConstraint
Definition: kdganttitemdelegate.h:45
KDGantt::ItemDelegate::paintGanttItem
virtual void paintGanttItem(QPainter *p, const StyleOptionGanttItem &opt, const QModelIndex &idx)
Definition: kdganttitemdelegate.cpp:273
QWidget
Class only listed here to document inheritance of some KDChart classes.
KDGantt::Span::start
qreal start() const
Definition: kdganttglobal.h:245
KDGantt::TypeSummary
@ TypeSummary
Definition: kdganttglobal.h:229
KDGantt::GraphicsItem::hoverMoveEvent
void hoverMoveEvent(QGraphicsSceneHoverEvent *) override
Definition: kdganttgraphicsitem.cpp:379
KDGantt::GraphicsItem::focusInEvent
void focusInEvent(QFocusEvent *event) override
Definition: kdganttgraphicsitem.cpp:342
KDGantt::GraphicsItem::setBoundingRect
void setBoundingRect(const QRectF &r)
Definition: kdganttgraphicsitem.cpp:161
KDGantt::StyleOptionGanttItem::grid
AbstractGrid * grid
Definition: kdganttstyleoptionganttitem.h:45
kdganttgraphicsscene.h
KDGantt::ItemDelegate::toolTip
virtual QString toolTip(const QModelIndex &idx) const
Definition: kdganttitemdelegate.cpp:178
KDGantt::ItemDelegate::State_ExtendLeft
@ State_ExtendLeft
Definition: kdganttitemdelegate.h:43
KDGantt::GraphicsScene::itemClicked
void itemClicked(const QModelIndex &)
Definition: kdganttgraphicsscene.cpp:621
KDGantt::GraphicsScene::constraintModel
ConstraintModel * constraintModel() const
Definition: kdganttgraphicsscene.cpp:230
QList
Definition: KDChartPosition.h:36
KDGantt::GraphicsItem
Definition: kdganttgraphicsitem.h:42
KDGantt::GraphicsItem::removeStartConstraint
void removeStartConstraint(ConstraintGraphicsItem *)
Definition: kdganttgraphicsitem.cpp:250
kdganttconstraint.h
KDGantt::GraphicsItem::mouseDoubleClickEvent
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *) override
Definition: kdganttgraphicsitem.cpp:504
KDGantt::GraphicsItem::paint
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget=0) override
Definition: kdganttgraphicsitem.cpp:173
KDGantt::ItemDelegate::State_Move
@ State_Move
Definition: kdganttitemdelegate.h:42
KDGantt::GraphicsScene
Definition: kdganttgraphicsscene.h:48
KDGantt::ConstraintGraphicsItem
Definition: kdganttconstraintgraphicsitem.h:33
KDGantt::GraphicsScene::itemDelegate
ItemDelegate * itemDelegate() const
Definition: kdganttgraphicsscene.cpp:190
kdganttgraphicsview.h
KDGantt::ItemDelegate::InteractionState
InteractionState
Definition: kdganttitemdelegate.h:41
KDGantt::GraphicsScene::rowController
AbstractRowController * rowController() const
Definition: kdganttgraphicsscene.cpp:265
KDGantt::ItemDelegate::interactionStateFor
virtual InteractionState interactionStateFor(const QPointF &pos, const StyleOptionGanttItem &opt, const QModelIndex &idx) const
Definition: kdganttitemdelegate.cpp:238
KDGantt::GraphicsItem::type
int type() const override
Definition: kdganttgraphicsitem.cpp:99
KDGantt::GraphicsView
The GraphicsView class provides a model/view implementation of a gantt chart.
Definition: kdganttgraphicsview.h:45
KDGantt::GraphicsItem::addEndConstraint
void addEndConstraint(ConstraintGraphicsItem *)
Definition: kdganttgraphicsitem.cpp:242
KDGantt::StyleOptionGanttItem
QStyleOption subclass for gantt items.
Definition: kdganttstyleoptionganttitem.h:34
KDGantt
Definition: kdganttabstractrowcontroller.h:33
KDGantt::GraphicsItem::setIndex
void setIndex(const QPersistentModelIndex &idx)
Definition: kdganttgraphicsitem.cpp:185
kdganttitemdelegate.h
KDGantt::ConstraintGraphicsItem::constraint
const Constraint & constraint() const
Definition: kdganttconstraintgraphicsitem.h:50
KDGantt::ConstraintGraphicsItem::setEnd
void setEnd(const QPointF &end)
Definition: kdganttconstraintgraphicsitem.cpp:94
KDGantt::StyleOptionGanttItem::Right
@ Right
Definition: kdganttstyleoptionganttitem.h:36
KDGantt::GraphicsScene::itemDoubleClicked
void itemDoubleClicked(const QModelIndex &)
Definition: kdganttgraphicsscene.cpp:626
KDGantt::GraphicsItem::mouseMoveEvent
void mouseMoveEvent(QGraphicsSceneMouseEvent *) override
Definition: kdganttgraphicsitem.cpp:546
KDGantt::StyleOptionGanttItem::displayPosition
Position displayPosition
Definition: kdganttstyleoptionganttitem.h:44
KDGantt::Span::length
qreal length() const
Definition: kdganttglobal.h:250
KDGantt::ItemDelegate::State_ExtendRight
@ State_ExtendRight
Definition: kdganttitemdelegate.h:44
KDGantt::GraphicsItem::isUpdating
bool isUpdating() const
Definition: kdganttgraphicsitem.h:70
KDGantt::ItemDelegate::State_None
@ State_None
Definition: kdganttitemdelegate.h:41
KDGantt::GraphicsItem::mouseReleaseEvent
void mouseReleaseEvent(QGraphicsSceneMouseEvent *) override
Definition: kdganttgraphicsitem.cpp:444
KDGantt::TypeMulti
@ TypeMulti
Definition: kdganttglobal.h:230
KDGantt::GraphicsItem::index
const QPersistentModelIndex & index() const
Definition: kdganttgraphicsitem.h:66
kdganttabstractrowcontroller.h
KDGantt::ItemTypeRole
@ ItemTypeRole
Definition: kdganttglobal.h:221
KDGantt::TextPositionRole
@ TextPositionRole
Definition: kdganttglobal.h:223
KDGantt::GraphicsItem::removeEndConstraint
void removeEndConstraint(ConstraintGraphicsItem *)
Definition: kdganttgraphicsitem.cpp:257
QAbstractProxyModel
KDGantt::Span
A class representing a start point and a length.
Definition: kdganttglobal.h:234
KDGantt::GraphicsItem::rect
QRectF rect() const
Definition: kdganttgraphicsitem.h:60
KDGantt::GraphicsItem::isEditable
bool isEditable() const
Definition: kdganttgraphicsitem.cpp:168
KDGantt::ConstraintModel
Definition: kdganttconstraintmodel.h:33
KDGantt::GraphicsItem::updateItem
void updateItem(const Span &rowgeometry, const QPersistentModelIndex &idx)
Definition: kdganttgraphicsitem.cpp:278
KDGantt::GraphicsItem::scene
GraphicsScene * scene() const
Definition: kdganttgraphicsitem.cpp:141
KDGantt::GraphicsScene::itemEntered
void itemEntered(const QModelIndex &)
Definition: kdganttgraphicsscene.cpp:611
KDGantt::StyleOptionGanttItem::Center
@ Center
Definition: kdganttstyleoptionganttitem.h:36
KDGantt::GraphicsItem::setRect
void setRect(const QRectF &r)
Definition: kdganttgraphicsitem.cpp:146
KDGantt::TypeEvent
@ TypeEvent
Definition: kdganttglobal.h:227
KDGantt::GraphicsItem::mousePressEvent
void mousePressEvent(QGraphicsSceneMouseEvent *) override
Definition: kdganttgraphicsitem.cpp:418
KDGantt::GraphicsItem::GraphicsItem
GraphicsItem(QGraphicsItem *parent=0, GraphicsScene *scene=0)
Definition: kdganttgraphicsitem.cpp:68
KDGantt::GraphicsItem::Type
@ Type
Definition: kdganttgraphicsitem.h:44
KDGantt::StyleOptionGanttItem::text
QString text
Definition: kdganttstyleoptionganttitem.h:46
KDGantt::Constraint::relationType
RelationType relationType() const
Definition: kdganttconstraint.cpp:123
KDGantt::GraphicsItem::addStartConstraint
void addStartConstraint(ConstraintGraphicsItem *)
Definition: kdganttgraphicsitem.cpp:234
KDGantt::GraphicsItem::boundingRect
QRectF boundingRect() const override
Definition: kdganttgraphicsitem.cpp:196
KDGantt::GraphicsView::addConstraint
virtual void addConstraint(const QModelIndex &from, const QModelIndex &to, Qt::KeyboardModifiers modifiers)
Definition: kdganttgraphicsview.cpp:586
KDGantt::StyleOptionGanttItem::boundingRect
QRectF boundingRect
Definition: kdganttstyleoptionganttitem.h:42
KDGantt::StyleOptionGanttItem::itemRect
QRectF itemRect
Definition: kdganttstyleoptionganttitem.h:43
KDGantt::StyleOptionGanttItem::Left
@ Left
Definition: kdganttstyleoptionganttitem.h:36
KDGantt::Constraint::StartFinish
@ StartFinish
Definition: kdganttconstraint.h:51
KDGantt::GraphicsItem::~GraphicsItem
~GraphicsItem() override
Definition: kdganttgraphicsitem.cpp:85
KDGantt::Constraint::StartStart
@ StartStart
Definition: kdganttconstraint.h:50
kdganttgraphicsitem.h
KDGantt::GraphicsItem::itemChange
QVariant itemChange(GraphicsItemChange, const QVariant &value) override
Definition: kdganttgraphicsitem.cpp:316
KDGantt::ItemType
ItemType
Definition: kdganttglobal.h:225
KDGantt::GraphicsScene::itemPressed
void itemPressed(const QModelIndex &)
Definition: kdganttgraphicsscene.cpp:616
KDGantt::AbstractRowController::maximumItemHeight
virtual int maximumItemHeight() const =0
KDGantt::GraphicsScene::updateRow
void updateRow(const QModelIndex &idx)
Definition: kdganttgraphicsscene.cpp:373
KDGantt::GraphicsScene::setDragSource
void setDragSource(GraphicsItem *item)
Definition: kdganttgraphicsscene.cpp:631
kdganttconstraintgraphicsitem.h
KDGantt::ItemDelegate::itemBoundingSpan
virtual Span itemBoundingSpan(const StyleOptionGanttItem &opt, const QModelIndex &idx) const
Definition: kdganttitemdelegate.cpp:200
KDGantt::Constraint::FinishFinish
@ FinishFinish
Definition: kdganttconstraint.h:49
QGraphicsItem
KDGantt::ConstraintGraphicsItem::setStart
void setStart(const QPointF &start)
Definition: kdganttconstraintgraphicsitem.cpp:87
KDGantt::GraphicsItem::hoverLeaveEvent
void hoverLeaveEvent(QGraphicsSceneHoverEvent *) override
Definition: kdganttgraphicsitem.cpp:411
kdganttconstraintmodel.h
KDGantt::GraphicsScene::isReadOnly
bool isReadOnly() const
Definition: kdganttgraphicsscene.cpp:294
KDGantt::GraphicsItem::ganttToolTip
virtual QString ganttToolTip() const
Definition: kdganttgraphicsitem.cpp:191

Klarälvdalens Datakonsult AB (KDAB)
"The Qt, C++ and OpenGL Experts"
https://www.kdab.com/

https://www.kdab.com/development-resources/qt-tools/kd-chart/