QGraphicsItem

Header: #include
qmake: QT += widgets Since: Qt 4.2 Inherited By: QAbstractGraphicsShapeItem, QGraphicsItemGroup, QGraphicsLineItem, QGraphicsObject, and QGraphicsPixmapItem

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
#ifndef QGRAPHICSITEM_H
#define QGRAPHICSITEM_H

#include <QtWidgets/qtwidgetsglobal.h>
#include <QtCore/qobject.h>
#include <QtCore/qvariant.h>
#include <QtCore/qrect.h>
#include <QtCore/qscopedpointer.h>
#include <QtGui/qpainterpath.h>
#include <QtGui/qpixmap.h>

class tst_QGraphicsItem;

QT_REQUIRE_CONFIG(graphicsview);

QT_BEGIN_NAMESPACE

class QBrush;
class QCursor;
class QFocusEvent;
class QGraphicsEffect;
class QGraphicsItemGroup;
class QGraphicsObject;
class QGraphicsSceneContextMenuEvent;
class QGraphicsSceneDragDropEvent;
class QGraphicsSceneEvent;
class QGraphicsSceneHoverEvent;
class QGraphicsSceneMouseEvent;
class QGraphicsSceneWheelEvent;
class QGraphicsScene;
class QGraphicsTransform;
class QGraphicsWidget;
class QInputMethodEvent;
class QKeyEvent;
class QMatrix;
class QMenu;
class QPainter;
class QPen;
class QPointF;
class QRectF;
class QStyleOptionGraphicsItem;

class QGraphicsItemPrivate;
class Q_WIDGETS_EXPORT QGraphicsItem
{
public:
enum GraphicsItemFlag {
ItemIsMovable = 0x1,
ItemIsSelectable = 0x2,
ItemIsFocusable = 0x4,
ItemClipsToShape = 0x8,
ItemClipsChildrenToShape = 0x10,
ItemIgnoresTransformations = 0x20,
ItemIgnoresParentOpacity = 0x40,
ItemDoesntPropagateOpacityToChildren = 0x80,
ItemStacksBehindParent = 0x100,
ItemUsesExtendedStyleOption = 0x200,
ItemHasNoContents = 0x400,
ItemSendsGeometryChanges = 0x800,
ItemAcceptsInputMethod = 0x1000,
ItemNegativeZStacksBehindParent = 0x2000,
ItemIsPanel = 0x4000,
ItemIsFocusScope = 0x8000, // internal
ItemSendsScenePositionChanges = 0x10000,
ItemStopsClickFocusPropagation = 0x20000,
ItemStopsFocusHandling = 0x40000,
ItemContainsChildrenInShape = 0x80000
// NB! Don't forget to increase the d_ptr->flags bit field by 1 when adding a new flag.
};
Q_DECLARE_FLAGS(GraphicsItemFlags, GraphicsItemFlag)

enum GraphicsItemChange {
ItemPositionChange,
#if QT_DEPRECATED_SINCE(5, 14)
ItemMatrixChange Q_DECL_ENUMERATOR_DEPRECATED_X("Use ItemTransformChange instead"),
#endif
ItemVisibleChange = 2,
ItemEnabledChange,
ItemSelectedChange,
ItemParentChange,
ItemChildAddedChange,
ItemChildRemovedChange,
ItemTransformChange,
ItemPositionHasChanged,
ItemTransformHasChanged,
ItemSceneChange,
ItemVisibleHasChanged,
ItemEnabledHasChanged,
ItemSelectedHasChanged,
ItemParentHasChanged,
ItemSceneHasChanged,
ItemCursorChange,
ItemCursorHasChanged,
ItemToolTipChange,
ItemToolTipHasChanged,
ItemFlagsChange,
ItemFlagsHaveChanged,
ItemZValueChange,
ItemZValueHasChanged,
ItemOpacityChange,
ItemOpacityHasChanged,
ItemScenePositionHasChanged,
ItemRotationChange,
ItemRotationHasChanged,
ItemScaleChange,
ItemScaleHasChanged,
ItemTransformOriginPointChange,
ItemTransformOriginPointHasChanged
};

enum CacheMode {
NoCache,
ItemCoordinateCache,
DeviceCoordinateCache
};

enum PanelModality
{
NonModal,
PanelModal,
SceneModal
};

explicit QGraphicsItem(QGraphicsItem *parent = nullptr);
virtual ~QGraphicsItem();

QGraphicsScene *scene() const;

QGraphicsItem *parentItem() const;
QGraphicsItem *topLevelItem() const;
QGraphicsObject *parentObject() const;
QGraphicsWidget *parentWidget() const;
QGraphicsWidget *topLevelWidget() const;
QGraphicsWidget *window() const;
QGraphicsItem *panel() const;
void setParentItem(QGraphicsItem *parent);
#if QT_DEPRECATED_SINCE(5, 0)
QT_DEPRECATED inline QList<QGraphicsItem *> children() const { return childItems(); }
#endif
QList<QGraphicsItem *> childItems() const;
bool isWidget() const;
bool isWindow() const;
bool isPanel() const;

QGraphicsObject *toGraphicsObject();
const QGraphicsObject *toGraphicsObject() const;

QGraphicsItemGroup *group() const;
void setGroup(QGraphicsItemGroup *group);

GraphicsItemFlags flags() const;
void setFlag(GraphicsItemFlag flag, bool enabled = true);
void setFlags(GraphicsItemFlags flags);

CacheMode cacheMode() const;
void setCacheMode(CacheMode mode, const QSize &cacheSize = QSize());

PanelModality panelModality() const;
void setPanelModality(PanelModality panelModality);
bool isBlockedByModalPanel(QGraphicsItem **blockingPanel = nullptr) const;

#ifndef QT_NO_TOOLTIP
QString toolTip() const;
void setToolTip(const QString &toolTip);
#endif

#ifndef QT_NO_CURSOR
QCursor cursor() const;
void setCursor(const QCursor &cursor);
bool hasCursor() const;
void unsetCursor();
#endif

bool isVisible() const;
bool isVisibleTo(const QGraphicsItem *parent) const;
void setVisible(bool visible);
inline void hide() { setVisible(false); }
inline void show() { setVisible(true); }

bool isEnabled() const;
void setEnabled(bool enabled);

bool isSelected() const;
void setSelected(bool selected);

bool acceptDrops() const;
void setAcceptDrops(bool on);

qreal opacity() const;
qreal effectiveOpacity() const;
void setOpacity(qreal opacity);

#if QT_CONFIG(graphicseffect)
// Effect
QGraphicsEffect *graphicsEffect() const;
void setGraphicsEffect(QGraphicsEffect *effect);
#endif // QT_CONFIG(graphicseffect)

Qt::MouseButtons acceptedMouseButtons() const;
void setAcceptedMouseButtons(Qt::MouseButtons buttons);
#if QT_DEPRECATED_SINCE(5, 0)
QT_DEPRECATED inline bool acceptsHoverEvents() const { return acceptHoverEvents(); }
QT_DEPRECATED inline void setAcceptsHoverEvents(bool enabled) { setAcceptHoverEvents(enabled); }
#endif
bool acceptHoverEvents() const;
void setAcceptHoverEvents(bool enabled);
bool acceptTouchEvents() const;
void setAcceptTouchEvents(bool enabled);

bool filtersChildEvents() const;
void setFiltersChildEvents(bool enabled);

bool handlesChildEvents() const;
void setHandlesChildEvents(bool enabled);

bool isActive() const;
void setActive(bool active);

bool hasFocus() const;
void setFocus(Qt::FocusReason focusReason = Qt::OtherFocusReason);
void clearFocus();

QGraphicsItem *focusProxy() const;
void setFocusProxy(QGraphicsItem *item);

QGraphicsItem *focusItem() const;
QGraphicsItem *focusScopeItem() const;

void grabMouse();
void ungrabMouse();
void grabKeyboard();
void ungrabKeyboard();

// Positioning in scene coordinates
QPointF pos() const;
inline qreal x() const { return pos().x(); }
void setX(qreal x);
inline qreal y() const { return pos().y(); }
void setY(qreal y);
QPointF scenePos() const;
void setPos(const QPointF &pos);
inline void setPos(qreal x, qreal y);
inline void moveBy(qreal dx, qreal dy) { setPos(pos().x() + dx, pos().y() + dy); }

void ensureVisible(const QRectF &rect = QRectF(), int xmargin = 50, int ymargin = 50);
inline void ensureVisible(qreal x, qreal y, qreal w, qreal h, int xmargin = 50, int ymargin = 50);

// Local transformation
#if QT_DEPRECATED_SINCE(5, 13)
QT_DEPRECATED_X("Use transform() instead")
QMatrix matrix() const;
QT_DEPRECATED_X("Use sceneTransform() instead")
QMatrix sceneMatrix() const;
QT_DEPRECATED_X("Use setTransform() instead")
void setMatrix(const QMatrix &matrix, bool combine = false);
QT_DEPRECATED_X("Use resetTransform() instead")
void resetMatrix();
#endif
QTransform transform() const;
QTransform sceneTransform() const;
QTransform deviceTransform(const QTransform &viewportTransform) const;
QTransform itemTransform(const QGraphicsItem *other, bool *ok = nullptr) const;
void setTransform(const QTransform &matrix, bool combine = false);
void resetTransform();
#if QT_DEPRECATED_SINCE(5, 0)
QT_DEPRECATED inline void rotate(qreal angle) { setTransform(QTransform().rotate(angle), true); }
QT_DEPRECATED inline void scale(qreal sx, qreal sy) { setTransform(QTransform::fromScale(sx, sy), true); }
QT_DEPRECATED inline void shear(qreal sh, qreal sv) { setTransform(QTransform().shear(sh, sv), true); }
QT_DEPRECATED inline void translate(qreal dx, qreal dy) { setTransform(QTransform::fromTranslate(dx, dy), true); }
#endif
void setRotation(qreal angle);
qreal rotation() const;

void setScale(qreal scale);
qreal scale() const;

QList<QGraphicsTransform *> transformations() const;
void setTransformations(const QList<QGraphicsTransform *> &transformations);

QPointF transformOriginPoint() const;
void setTransformOriginPoint(const QPointF &origin);
inline void setTransformOriginPoint(qreal ax, qreal ay)
{ setTransformOriginPoint(QPointF(ax,ay)); }

virtual void advance(int phase);

// Stacking order
qreal zValue() const;
void setZValue(qreal z);
void stackBefore(const QGraphicsItem *sibling);

// Hit test
virtual QRectF boundingRect() const = 0;
QRectF childrenBoundingRect() const;
QRectF sceneBoundingRect() const;
virtual QPainterPath shape() const;
bool isClipped() const;
QPainterPath clipPath() const;
virtual bool contains(const QPointF &point) const;
virtual bool collidesWithItem(const QGraphicsItem *other, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
virtual bool collidesWithPath(const QPainterPath &path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
QList<QGraphicsItem *> collidingItems(Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
bool isObscured(const QRectF &rect = QRectF()) const;
inline bool isObscured(qreal x, qreal y, qreal w, qreal h) const;
virtual bool isObscuredBy(const QGraphicsItem *item) const;
virtual QPainterPath opaqueArea() const;

QRegion boundingRegion(const QTransform &itemToDeviceTransform) const;
qreal boundingRegionGranularity() const;
void setBoundingRegionGranularity(qreal granularity);

// Drawing
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr) = 0;
void update(const QRectF &rect = QRectF());
inline void update(qreal x, qreal y, qreal width, qreal height);
void scroll(qreal dx, qreal dy, const QRectF &rect = QRectF());

// Coordinate mapping
QPointF mapToItem(const QGraphicsItem *item, const QPointF &point) const;
QPointF mapToParent(const QPointF &point) const;
QPointF mapToScene(const QPointF &point) const;
QPolygonF mapToItem(const QGraphicsItem *item, const QRectF &rect) const;
QPolygonF mapToParent(const QRectF &rect) const;
QPolygonF mapToScene(const QRectF &rect) const;
QRectF mapRectToItem(const QGraphicsItem *item, const QRectF &rect) const;
QRectF mapRectToParent(const QRectF &rect) const;
QRectF mapRectToScene(const QRectF &rect) const;
QPolygonF mapToItem(const QGraphicsItem *item, const QPolygonF &polygon) const;
QPolygonF mapToParent(const QPolygonF &polygon) const;
QPolygonF mapToScene(const QPolygonF &polygon) const;
QPainterPath mapToItem(const QGraphicsItem *item, const QPainterPath &path) const;
QPainterPath mapToParent(const QPainterPath &path) const;
QPainterPath mapToScene(const QPainterPath &path) const;
QPointF mapFromItem(const QGraphicsItem *item, const QPointF &point) const;
QPointF mapFromParent(const QPointF &point) const;
QPointF mapFromScene(const QPointF &point) const;
QPolygonF mapFromItem(const QGraphicsItem *item, const QRectF &rect) const;
QPolygonF mapFromParent(const QRectF &rect) const;
QPolygonF mapFromScene(const QRectF &rect) const;
QRectF mapRectFromItem(const QGraphicsItem *item, const QRectF &rect) const;
QRectF mapRectFromParent(const QRectF &rect) const;
QRectF mapRectFromScene(const QRectF &rect) const;
QPolygonF mapFromItem(const QGraphicsItem *item, const QPolygonF &polygon) const;
QPolygonF mapFromParent(const QPolygonF &polygon) const;
QPolygonF mapFromScene(const QPolygonF &polygon) const;
QPainterPath mapFromItem(const QGraphicsItem *item, const QPainterPath &path) const;
QPainterPath mapFromParent(const QPainterPath &path) const;
QPainterPath mapFromScene(const QPainterPath &path) const;

inline QPointF mapToItem(const QGraphicsItem *item, qreal x, qreal y) const;
inline QPointF mapToParent(qreal x, qreal y) const;
inline QPointF mapToScene(qreal x, qreal y) const;
inline QPolygonF mapToItem(const QGraphicsItem *item, qreal x, qreal y, qreal w, qreal h) const;
inline QPolygonF mapToParent(qreal x, qreal y, qreal w, qreal h) const;
inline QPolygonF mapToScene(qreal x, qreal y, qreal w, qreal h) const;
inline QRectF mapRectToItem(const QGraphicsItem *item, qreal x, qreal y, qreal w, qreal h) const;
inline QRectF mapRectToParent(qreal x, qreal y, qreal w, qreal h) const;
inline QRectF mapRectToScene(qreal x, qreal y, qreal w, qreal h) const;
inline QPointF mapFromItem(const QGraphicsItem *item, qreal x, qreal y) const;
inline QPointF mapFromParent(qreal x, qreal y) const;
inline QPointF mapFromScene(qreal x, qreal y) const;
inline QPolygonF mapFromItem(const QGraphicsItem *item, qreal x, qreal y, qreal w, qreal h) const;
inline QPolygonF mapFromParent(qreal x, qreal y, qreal w, qreal h) const;
inline QPolygonF mapFromScene(qreal x, qreal y, qreal w, qreal h) const;
inline QRectF mapRectFromItem(const QGraphicsItem *item, qreal x, qreal y, qreal w, qreal h) const;
inline QRectF mapRectFromParent(qreal x, qreal y, qreal w, qreal h) const;
inline QRectF mapRectFromScene(qreal x, qreal y, qreal w, qreal h) const;

bool isAncestorOf(const QGraphicsItem *child) const;
QGraphicsItem *commonAncestorItem(const QGraphicsItem *other) const;
bool isUnderMouse() const;

// Custom data
QVariant data(int key) const;
void setData(int key, const QVariant &value);

Qt::InputMethodHints inputMethodHints() const;
void setInputMethodHints(Qt::InputMethodHints hints);

enum {
Type = 1,
UserType = 65536
};
virtual int type() const;

void installSceneEventFilter(QGraphicsItem *filterItem);
void removeSceneEventFilter(QGraphicsItem *filterItem);

protected:
void updateMicroFocus();
virtual bool sceneEventFilter(QGraphicsItem *watched, QEvent *event);
virtual bool sceneEvent(QEvent *event);
virtual void contextMenuEvent(QGraphicsSceneContextMenuEvent *event);
virtual void dragEnterEvent(QGraphicsSceneDragDropEvent *event);
virtual void dragLeaveEvent(QGraphicsSceneDragDropEvent *event);
virtual void dragMoveEvent(QGraphicsSceneDragDropEvent *event);
virtual void dropEvent(QGraphicsSceneDragDropEvent *event);
virtual void focusInEvent(QFocusEvent *event);
virtual void focusOutEvent(QFocusEvent *event);
virtual void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
virtual void hoverMoveEvent(QGraphicsSceneHoverEvent *event);
virtual void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
virtual void keyPressEvent(QKeyEvent *event);
virtual void keyReleaseEvent(QKeyEvent *event);
virtual void mousePressEvent(QGraphicsSceneMouseEvent *event);
virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
virtual void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
virtual void wheelEvent(QGraphicsSceneWheelEvent *event);
virtual void inputMethodEvent(QInputMethodEvent *event);
virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const;

virtual QVariant itemChange(GraphicsItemChange change, const QVariant &value);

enum Extension {
UserExtension = 0x80000000
};
virtual bool supportsExtension(Extension extension) const;
virtual void setExtension(Extension extension, const QVariant &variant);
virtual QVariant extension(const QVariant &variant) const;

protected:
QGraphicsItem(QGraphicsItemPrivate &dd, QGraphicsItem *parent);
QScopedPointer<QGraphicsItemPrivate> d_ptr;

void addToIndex();
void removeFromIndex();
void prepareGeometryChange();

private:
Q_DISABLE_COPY(QGraphicsItem)
Q_DECLARE_PRIVATE(QGraphicsItem)
friend class QGraphicsItemGroup;
friend class QGraphicsScene;
friend class QGraphicsScenePrivate;
friend class QGraphicsSceneFindItemBspTreeVisitor;
friend class QGraphicsSceneBspTree;
friend class QGraphicsView;
friend class QGraphicsViewPrivate;
friend class QGraphicsObject;
friend class QGraphicsWidget;
friend class QGraphicsWidgetPrivate;
friend class QGraphicsProxyWidgetPrivate;
friend class QGraphicsSceneIndex;
friend class QGraphicsSceneIndexPrivate;
friend class QGraphicsSceneBspTreeIndex;
friend class QGraphicsSceneBspTreeIndexPrivate;
friend class QGraphicsItemEffectSourcePrivate;
friend class QGraphicsTransformPrivate;
#ifndef QT_NO_GESTURES
friend class QGestureManager;
#endif
friend class ::tst_QGraphicsItem;
friend bool qt_closestLeaf(const QGraphicsItem *, const QGraphicsItem *);
friend bool qt_closestItemFirst(const QGraphicsItem *, const QGraphicsItem *);
};

Q_DECLARE_OPERATORS_FOR_FLAGS(QGraphicsItem::GraphicsItemFlags)
#ifndef Q_CLANG_QDOC
Q_DECLARE_INTERFACE(QGraphicsItem, "org.qt-project.Qt.QGraphicsItem")
#endif

inline void QGraphicsItem::setPos(qreal ax, qreal ay)
{ setPos(QPointF(ax, ay)); }
inline void QGraphicsItem::ensureVisible(qreal ax, qreal ay, qreal w, qreal h, int xmargin, int ymargin)
{ ensureVisible(QRectF(ax, ay, w, h), xmargin, ymargin); }
inline void QGraphicsItem::update(qreal ax, qreal ay, qreal width, qreal height)
{ update(QRectF(ax, ay, width, height)); }
inline bool QGraphicsItem::isObscured(qreal ax, qreal ay, qreal w, qreal h) const
{ return isObscured(QRectF(ax, ay, w, h)); }
inline QPointF QGraphicsItem::mapToItem(const QGraphicsItem *item, qreal ax, qreal ay) const
{ return mapToItem(item, QPointF(ax, ay)); }
inline QPointF QGraphicsItem::mapToParent(qreal ax, qreal ay) const
{ return mapToParent(QPointF(ax, ay)); }
inline QPointF QGraphicsItem::mapToScene(qreal ax, qreal ay) const
{ return mapToScene(QPointF(ax, ay)); }
inline QPointF QGraphicsItem::mapFromItem(const QGraphicsItem *item, qreal ax, qreal ay) const
{ return mapFromItem(item, QPointF(ax, ay)); }
inline QPointF QGraphicsItem::mapFromParent(qreal ax, qreal ay) const
{ return mapFromParent(QPointF(ax, ay)); }
inline QPointF QGraphicsItem::mapFromScene(qreal ax, qreal ay) const
{ return mapFromScene(QPointF(ax, ay)); }
inline QPolygonF QGraphicsItem::mapToItem(const QGraphicsItem *item, qreal ax, qreal ay, qreal w, qreal h) const
{ return mapToItem(item, QRectF(ax, ay, w, h)); }
inline QPolygonF QGraphicsItem::mapToParent(qreal ax, qreal ay, qreal w, qreal h) const
{ return mapToParent(QRectF(ax, ay, w, h)); }
inline QPolygonF QGraphicsItem::mapToScene(qreal ax, qreal ay, qreal w, qreal h) const
{ return mapToScene(QRectF(ax, ay, w, h)); }
inline QRectF QGraphicsItem::mapRectToItem(const QGraphicsItem *item, qreal ax, qreal ay, qreal w, qreal h) const
{ return mapRectToItem(item, QRectF(ax, ay, w, h)); }
inline QRectF QGraphicsItem::mapRectToParent(qreal ax, qreal ay, qreal w, qreal h) const
{ return mapRectToParent(QRectF(ax, ay, w, h)); }
inline QRectF QGraphicsItem::mapRectToScene(qreal ax, qreal ay, qreal w, qreal h) const
{ return mapRectToScene(QRectF(ax, ay, w, h)); }
inline QPolygonF QGraphicsItem::mapFromItem(const QGraphicsItem *item, qreal ax, qreal ay, qreal w, qreal h) const
{ return mapFromItem(item, QRectF(ax, ay, w, h)); }
inline QPolygonF QGraphicsItem::mapFromParent(qreal ax, qreal ay, qreal w, qreal h) const
{ return mapFromParent(QRectF(ax, ay, w, h)); }
inline QPolygonF QGraphicsItem::mapFromScene(qreal ax, qreal ay, qreal w, qreal h) const
{ return mapFromScene(QRectF(ax, ay, w, h)); }
inline QRectF QGraphicsItem::mapRectFromItem(const QGraphicsItem *item, qreal ax, qreal ay, qreal w, qreal h) const
{ return mapRectFromItem(item, QRectF(ax, ay, w, h)); }
inline QRectF QGraphicsItem::mapRectFromParent(qreal ax, qreal ay, qreal w, qreal h) const
{ return mapRectFromParent(QRectF(ax, ay, w, h)); }
inline QRectF QGraphicsItem::mapRectFromScene(qreal ax, qreal ay, qreal w, qreal h) const
{ return mapRectFromScene(QRectF(ax, ay, w, h)); }


class Q_WIDGETS_EXPORT QGraphicsObject : public QObject, public QGraphicsItem
{
Q_OBJECT
Q_PROPERTY(QGraphicsObject* parent READ parentObject WRITE setParentItem NOTIFY parentChanged DESIGNABLE false)
Q_PROPERTY(qreal opacity READ opacity WRITE setOpacity NOTIFY opacityChanged FINAL)
Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged)
Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged FINAL)
Q_PROPERTY(QPointF pos READ pos WRITE setPos FINAL)
Q_PROPERTY(qreal x READ x WRITE setX NOTIFY xChanged FINAL)
Q_PROPERTY(qreal y READ y WRITE setY NOTIFY yChanged FINAL)
Q_PROPERTY(qreal z READ zValue WRITE setZValue NOTIFY zChanged FINAL)
Q_PROPERTY(qreal rotation READ rotation WRITE setRotation NOTIFY rotationChanged)
Q_PROPERTY(qreal scale READ scale WRITE setScale NOTIFY scaleChanged)
Q_PROPERTY(QPointF transformOriginPoint READ transformOriginPoint WRITE setTransformOriginPoint)
#if QT_CONFIG(graphicseffect)
Q_PROPERTY(QGraphicsEffect *effect READ graphicsEffect WRITE setGraphicsEffect)
#endif
Q_PRIVATE_PROPERTY(QGraphicsItem::d_func(), QDeclarativeListProperty<QGraphicsObject> children READ childrenList DESIGNABLE false NOTIFY childrenChanged)
Q_PRIVATE_PROPERTY(QGraphicsItem::d_func(), qreal width READ width WRITE setWidth NOTIFY widthChanged RESET resetWidth FINAL)
Q_PRIVATE_PROPERTY(QGraphicsItem::d_func(), qreal height READ height WRITE setHeight NOTIFY heightChanged RESET resetHeight FINAL)
Q_CLASSINFO("DefaultProperty", "children")
Q_INTERFACES(QGraphicsItem)
public:
explicit QGraphicsObject(QGraphicsItem *parent = nullptr);
~QGraphicsObject();

using QObject::children;

#ifndef QT_NO_GESTURES
void grabGesture(Qt::GestureType type, Qt::GestureFlags flags = Qt::GestureFlags());
void ungrabGesture(Qt::GestureType type);
#endif

protected Q_SLOTS:
void updateMicroFocus();

Q_SIGNALS:
void parentChanged();
void opacityChanged();
void visibleChanged();
void enabledChanged();
void xChanged();
void yChanged();
void zChanged();
void rotationChanged();
void scaleChanged();
void childrenChanged();
void widthChanged();
void heightChanged();

protected:
QGraphicsObject(QGraphicsItemPrivate &dd, QGraphicsItem *parent);

bool event(QEvent *ev) override;

private:
friend class QGraphicsItem;
friend class QGraphicsItemPrivate;
};


class QAbstractGraphicsShapeItemPrivate;
class Q_WIDGETS_EXPORT QAbstractGraphicsShapeItem : public QGraphicsItem
{
public:
explicit QAbstractGraphicsShapeItem(QGraphicsItem *parent = nullptr);
~QAbstractGraphicsShapeItem();

QPen pen() const;
void setPen(const QPen &pen);

QBrush brush() const;
void setBrush(const QBrush &brush);

bool isObscuredBy(const QGraphicsItem *item) const override;
QPainterPath opaqueArea() const override;

protected:
QAbstractGraphicsShapeItem(QAbstractGraphicsShapeItemPrivate &dd,
QGraphicsItem *parent);

private:
Q_DISABLE_COPY(QAbstractGraphicsShapeItem)
Q_DECLARE_PRIVATE(QAbstractGraphicsShapeItem)
};

class QGraphicsPathItemPrivate;
class Q_WIDGETS_EXPORT QGraphicsPathItem : public QAbstractGraphicsShapeItem
{
public:
explicit QGraphicsPathItem(QGraphicsItem *parent = nullptr);
explicit QGraphicsPathItem(const QPainterPath &path, QGraphicsItem *parent = nullptr);
~QGraphicsPathItem();

QPainterPath path() const;
void setPath(const QPainterPath &path);

QRectF boundingRect() const override;
QPainterPath shape() const override;
bool contains(const QPointF &point) const override;

void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr) override;

bool isObscuredBy(const QGraphicsItem *item) const override;
QPainterPath opaqueArea() const override;

enum { Type = 2 };
int type() const override;

protected:
bool supportsExtension(Extension extension) const override;
void setExtension(Extension extension, const QVariant &variant) override;
QVariant extension(const QVariant &variant) const override;

private:
Q_DISABLE_COPY(QGraphicsPathItem)
Q_DECLARE_PRIVATE(QGraphicsPathItem)
};

class QGraphicsRectItemPrivate;
class Q_WIDGETS_EXPORT QGraphicsRectItem : public QAbstractGraphicsShapeItem
{
public:
explicit QGraphicsRectItem(QGraphicsItem *parent = nullptr);
explicit QGraphicsRectItem(const QRectF &rect, QGraphicsItem *parent = nullptr);
explicit QGraphicsRectItem(qreal x, qreal y, qreal w, qreal h, QGraphicsItem *parent = nullptr);
~QGraphicsRectItem();

QRectF rect() const;
void setRect(const QRectF &rect);
inline void setRect(qreal x, qreal y, qreal w, qreal h);

QRectF boundingRect() const override;
QPainterPath shape() const override;
bool contains(const QPointF &point) const override;

void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr) override;

bool isObscuredBy(const QGraphicsItem *item) const override;
QPainterPath opaqueArea() const override;

enum { Type = 3 };
int type() const override;

protected:
bool supportsExtension(Extension extension) const override;
void setExtension(Extension extension, const QVariant &variant) override;
QVariant extension(const QVariant &variant) const override;

private:
Q_DISABLE_COPY(QGraphicsRectItem)
Q_DECLARE_PRIVATE(QGraphicsRectItem)
};

inline void QGraphicsRectItem::setRect(qreal ax, qreal ay, qreal w, qreal h)
{ setRect(QRectF(ax, ay, w, h)); }

class QGraphicsEllipseItemPrivate;
class Q_WIDGETS_EXPORT QGraphicsEllipseItem : public QAbstractGraphicsShapeItem
{
public:
explicit QGraphicsEllipseItem(QGraphicsItem *parent = nullptr);
explicit QGraphicsEllipseItem(const QRectF &rect, QGraphicsItem *parent = nullptr);
explicit QGraphicsEllipseItem(qreal x, qreal y, qreal w, qreal h, QGraphicsItem *parent = nullptr);
~QGraphicsEllipseItem();

QRectF rect() const;
void setRect(const QRectF &rect);
inline void setRect(qreal x, qreal y, qreal w, qreal h);

int startAngle() const;
void setStartAngle(int angle);

int spanAngle() const;
void setSpanAngle(int angle);

QRectF boundingRect() const override;
QPainterPath shape() const override;
bool contains(const QPointF &point) const override;

void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr) override;

bool isObscuredBy(const QGraphicsItem *item) const override;
QPainterPath opaqueArea() const override;

enum { Type = 4 };
int type() const override;

protected:
bool supportsExtension(Extension extension) const override;
void setExtension(Extension extension, const QVariant &variant) override;
QVariant extension(const QVariant &variant) const override;

private:
Q_DISABLE_COPY(QGraphicsEllipseItem)
Q_DECLARE_PRIVATE(QGraphicsEllipseItem)
};

inline void QGraphicsEllipseItem::setRect(qreal ax, qreal ay, qreal w, qreal h)
{ setRect(QRectF(ax, ay, w, h)); }

class QGraphicsPolygonItemPrivate;
class Q_WIDGETS_EXPORT QGraphicsPolygonItem : public QAbstractGraphicsShapeItem
{
public:
explicit QGraphicsPolygonItem(QGraphicsItem *parent = nullptr);
explicit QGraphicsPolygonItem(const QPolygonF &polygon,
QGraphicsItem *parent = nullptr);
~QGraphicsPolygonItem();

QPolygonF polygon() const;
void setPolygon(const QPolygonF &polygon);

Qt::FillRule fillRule() const;
void setFillRule(Qt::FillRule rule);

QRectF boundingRect() const override;
QPainterPath shape() const override;
bool contains(const QPointF &point) const override;

void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr) override;

bool isObscuredBy(const QGraphicsItem *item) const override;
QPainterPath opaqueArea() const override;

enum { Type = 5 };
int type() const override;

protected:
bool supportsExtension(Extension extension) const override;
void setExtension(Extension extension, const QVariant &variant) override;
QVariant extension(const QVariant &variant) const override;

private:
Q_DISABLE_COPY(QGraphicsPolygonItem)
Q_DECLARE_PRIVATE(QGraphicsPolygonItem)
};

class QGraphicsLineItemPrivate;
class Q_WIDGETS_EXPORT QGraphicsLineItem : public QGraphicsItem
{
public:
explicit QGraphicsLineItem(QGraphicsItem *parent = nullptr);
explicit QGraphicsLineItem(const QLineF &line, QGraphicsItem *parent = nullptr);
explicit QGraphicsLineItem(qreal x1, qreal y1, qreal x2, qreal y2, QGraphicsItem *parent = nullptr);
~QGraphicsLineItem();

QPen pen() const;
void setPen(const QPen &pen);

QLineF line() const;
void setLine(const QLineF &line);
inline void setLine(qreal x1, qreal y1, qreal x2, qreal y2)
{ setLine(QLineF(x1, y1, x2, y2)); }

QRectF boundingRect() const override;
QPainterPath shape() const override;
bool contains(const QPointF &point) const override;

void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr) override;

bool isObscuredBy(const QGraphicsItem *item) const override;
QPainterPath opaqueArea() const override;

enum { Type = 6 };
int type() const override;

protected:
bool supportsExtension(Extension extension) const override;
void setExtension(Extension extension, const QVariant &variant) override;
QVariant extension(const QVariant &variant) const override;

private:
Q_DISABLE_COPY(QGraphicsLineItem)
Q_DECLARE_PRIVATE(QGraphicsLineItem)
};

class QGraphicsPixmapItemPrivate;
class Q_WIDGETS_EXPORT QGraphicsPixmapItem : public QGraphicsItem
{
public:
enum ShapeMode {
MaskShape,
BoundingRectShape,
HeuristicMaskShape
};

explicit QGraphicsPixmapItem(QGraphicsItem *parent = nullptr);
explicit QGraphicsPixmapItem(const QPixmap &pixmap, QGraphicsItem *parent = nullptr);
~QGraphicsPixmapItem();

QPixmap pixmap() const;
void setPixmap(const QPixmap &pixmap);

Qt::TransformationMode transformationMode() const;
void setTransformationMode(Qt::TransformationMode mode);

QPointF offset() const;
void setOffset(const QPointF &offset);
inline void setOffset(qreal x, qreal y);

QRectF boundingRect() const override;
QPainterPath shape() const override;
bool contains(const QPointF &point) const override;

void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;

bool isObscuredBy(const QGraphicsItem *item) const override;
QPainterPath opaqueArea() const override;

enum { Type = 7 };
int type() const override;

ShapeMode shapeMode() const;
void setShapeMode(ShapeMode mode);

protected:
bool supportsExtension(Extension extension) const override;
void setExtension(Extension extension, const QVariant &variant) override;
QVariant extension(const QVariant &variant) const override;

private:
Q_DISABLE_COPY(QGraphicsPixmapItem)
Q_DECLARE_PRIVATE(QGraphicsPixmapItem)
};

inline void QGraphicsPixmapItem::setOffset(qreal ax, qreal ay)
{ setOffset(QPointF(ax, ay)); }

class QGraphicsTextItemPrivate;
class QTextDocument;
class QTextCursor;
class Q_WIDGETS_EXPORT QGraphicsTextItem : public QGraphicsObject
{
Q_OBJECT
QDOC_PROPERTY(bool openExternalLinks READ openExternalLinks WRITE setOpenExternalLinks)
QDOC_PROPERTY(QTextCursor textCursor READ textCursor WRITE setTextCursor)

public:
explicit QGraphicsTextItem(QGraphicsItem *parent = nullptr);
explicit QGraphicsTextItem(const QString &text, QGraphicsItem *parent = nullptr);
~QGraphicsTextItem();

QString toHtml() const;
void setHtml(const QString &html);

QString toPlainText() const;
void setPlainText(const QString &text);

QFont font() const;
void setFont(const QFont &font);

void setDefaultTextColor(const QColor &c);
QColor defaultTextColor() const;

QRectF boundingRect() const override;
QPainterPath shape() const override;
bool contains(const QPointF &point) const override;

void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;

bool isObscuredBy(const QGraphicsItem *item) const override;
QPainterPath opaqueArea() const override;

enum { Type = 8 };
int type() const override;

void setTextWidth(qreal width);
qreal textWidth() const;

void adjustSize();

void setDocument(QTextDocument *document);
QTextDocument *document() const;

void setTextInteractionFlags(Qt::TextInteractionFlags flags);
Qt::TextInteractionFlags textInteractionFlags() const;

void setTabChangesFocus(bool b);
bool tabChangesFocus() const;

void setOpenExternalLinks(bool open);
bool openExternalLinks() const;

void setTextCursor(const QTextCursor &cursor);
QTextCursor textCursor() const;

Q_SIGNALS:
void linkActivated(const QString &);
void linkHovered(const QString &);

protected:
bool sceneEvent(QEvent *event) override;
void mousePressEvent(QGraphicsSceneMouseEvent *event) override;
void mouseMoveEvent(QGraphicsSceneMouseEvent *event) override;
void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) override;
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) override;
void contextMenuEvent(QGraphicsSceneContextMenuEvent *event) override;
void keyPressEvent(QKeyEvent *event) override;
void keyReleaseEvent(QKeyEvent *event) override;
void focusInEvent(QFocusEvent *event) override;
void focusOutEvent(QFocusEvent *event) override;
void dragEnterEvent(QGraphicsSceneDragDropEvent *event) override;
void dragLeaveEvent(QGraphicsSceneDragDropEvent *event) override;
void dragMoveEvent(QGraphicsSceneDragDropEvent *event) override;
void dropEvent(QGraphicsSceneDragDropEvent *event) override;
void inputMethodEvent(QInputMethodEvent *event) override;
void hoverEnterEvent(QGraphicsSceneHoverEvent *event) override;
void hoverMoveEvent(QGraphicsSceneHoverEvent *event) override;
void hoverLeaveEvent(QGraphicsSceneHoverEvent *event) override;

QVariant inputMethodQuery(Qt::InputMethodQuery query) const override;

bool supportsExtension(Extension extension) const override;
void setExtension(Extension extension, const QVariant &variant) override;
QVariant extension(const QVariant &variant) const override;

private:
Q_DISABLE_COPY(QGraphicsTextItem)
Q_PRIVATE_SLOT(dd, void _q_updateBoundingRect(const QSizeF &))
Q_PRIVATE_SLOT(dd, void _q_update(QRectF))
Q_PRIVATE_SLOT(dd, void _q_ensureVisible(QRectF))
QGraphicsTextItemPrivate *dd;
friend class QGraphicsTextItemPrivate;
};

class QGraphicsSimpleTextItemPrivate;
class Q_WIDGETS_EXPORT QGraphicsSimpleTextItem : public QAbstractGraphicsShapeItem
{
public:
explicit QGraphicsSimpleTextItem(QGraphicsItem *parent = nullptr);
explicit QGraphicsSimpleTextItem(const QString &text, QGraphicsItem *parent = nullptr);
~QGraphicsSimpleTextItem();

void setText(const QString &text);
QString text() const;

void setFont(const QFont &font);
QFont font() const;

QRectF boundingRect() const override;
QPainterPath shape() const override;
bool contains(const QPointF &point) const override;

void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;

bool isObscuredBy(const QGraphicsItem *item) const override;
QPainterPath opaqueArea() const override;

enum { Type = 9 };
int type() const override;

protected:
bool supportsExtension(Extension extension) const override;
void setExtension(Extension extension, const QVariant &variant) override;
QVariant extension(const QVariant &variant) const override;

private:
Q_DISABLE_COPY(QGraphicsSimpleTextItem)
Q_DECLARE_PRIVATE(QGraphicsSimpleTextItem)
};

class QGraphicsItemGroupPrivate;
class Q_WIDGETS_EXPORT QGraphicsItemGroup : public QGraphicsItem
{
public:
explicit QGraphicsItemGroup(QGraphicsItem *parent = nullptr);
~QGraphicsItemGroup();

void addToGroup(QGraphicsItem *item);
void removeFromGroup(QGraphicsItem *item);

QRectF boundingRect() const override;
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr) override;

bool isObscuredBy(const QGraphicsItem *item) const override;
QPainterPath opaqueArea() const override;

enum { Type = 10 };
int type() const override;

private:
Q_DISABLE_COPY(QGraphicsItemGroup)
Q_DECLARE_PRIVATE(QGraphicsItemGroup)
};

template <class T> inline T qgraphicsitem_cast(QGraphicsItem *item)
{
typedef typename std::remove_cv<typename std::remove_pointer<T>::type>::type Item;
return int(Item::Type) == int(QGraphicsItem::Type)
|| (item && int(Item::Type) == item->type()) ? static_cast<T>(item) : 0;
}

template <class T> inline T qgraphicsitem_cast(const QGraphicsItem *item)
{
typedef typename std::remove_cv<typename std::remove_pointer<T>::type>::type Item;
return int(Item::Type) == int(QGraphicsItem::Type)
|| (item && int(Item::Type) == item->type()) ? static_cast<T>(item) : 0;
}

#ifndef QT_NO_DEBUG_STREAM
Q_WIDGETS_EXPORT QDebug operator<<(QDebug debug, QGraphicsItem *item);
Q_WIDGETS_EXPORT QDebug operator<<(QDebug debug, QGraphicsObject *item);
Q_WIDGETS_EXPORT QDebug operator<<(QDebug debug, QGraphicsItem::GraphicsItemChange change);
Q_WIDGETS_EXPORT QDebug operator<<(QDebug debug, QGraphicsItem::GraphicsItemFlag flag);
Q_WIDGETS_EXPORT QDebug operator<<(QDebug debug, QGraphicsItem::GraphicsItemFlags flags);
#endif

QT_END_NAMESPACE

Q_DECLARE_METATYPE(QGraphicsItem *)

QT_BEGIN_NAMESPACE

QT_END_NAMESPACE

#endif // QGRAPHICSITEM_H