QGraphicsItem - QGraphicsScene - QGraphicsView

忘是亡心i 2022-06-09 10:00 354阅读 0赞

**1.QGraphicsItem -- 是个基类**

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,
            ItemMatrixChange,
            ItemVisibleChange,
            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 = Q_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 = Q_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);
    
    #ifndef QT_NO_GRAPHICSEFFECT
        // Effect
        QGraphicsEffect *graphicsEffect() const;
        void setGraphicsEffect(QGraphicsEffect *effect);
    #endif //QT_NO_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
        QMatrix matrix() const;
        QMatrix sceneMatrix() const;
        void setMatrix(const QMatrix &matrix, bool combine = false);
        void resetMatrix();
        QTransform transform() const;
        QTransform sceneTransform() const;
        QTransform deviceTransform(const QTransform &viewportTransform) const;
        QTransform itemTransform(const QGraphicsItem *other, bool *ok = Q_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 = Q_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 *);
    };

**2.QGraphicsScene**

class QGraphicsScene : public QObject

class Q_WIDGETS_EXPORT QGraphicsScene : public QObject
    {
        Q_OBJECT
        Q_PROPERTY(QBrush backgroundBrush READ backgroundBrush WRITE setBackgroundBrush)
        Q_PROPERTY(QBrush foregroundBrush READ foregroundBrush WRITE setForegroundBrush)
        Q_PROPERTY(ItemIndexMethod itemIndexMethod READ itemIndexMethod WRITE setItemIndexMethod)
        Q_PROPERTY(QRectF sceneRect READ sceneRect WRITE setSceneRect)
        Q_PROPERTY(int bspTreeDepth READ bspTreeDepth WRITE setBspTreeDepth)
        Q_PROPERTY(QPalette palette READ palette WRITE setPalette)
        Q_PROPERTY(QFont font READ font WRITE setFont)
        Q_PROPERTY(bool sortCacheEnabled READ isSortCacheEnabled WRITE setSortCacheEnabled)
        Q_PROPERTY(bool stickyFocus READ stickyFocus WRITE setStickyFocus)
        Q_PROPERTY(qreal minimumRenderSize READ minimumRenderSize WRITE setMinimumRenderSize)
    
    public:
        enum ItemIndexMethod {
            BspTreeIndex,
            NoIndex = -1
        };
    
        enum SceneLayer {
            ItemLayer = 0x1,
            BackgroundLayer = 0x2,
            ForegroundLayer = 0x4,
            AllLayers = 0xffff
        };
        Q_DECLARE_FLAGS(SceneLayers, SceneLayer)
    
        QGraphicsScene(QObject *parent = Q_NULLPTR);
        QGraphicsScene(const QRectF &sceneRect, QObject *parent = Q_NULLPTR);
        QGraphicsScene(qreal x, qreal y, qreal width, qreal height, QObject *parent = Q_NULLPTR);
        virtual ~QGraphicsScene();
    
        QRectF sceneRect() const;
        inline qreal width() const { return sceneRect().width(); }
        inline qreal height() const { return sceneRect().height(); }
        void setSceneRect(const QRectF &rect);
        inline void setSceneRect(qreal x, qreal y, qreal w, qreal h)
        { setSceneRect(QRectF(x, y, w, h)); }
    
        void render(QPainter *painter,
                    const QRectF &target = QRectF(), const QRectF &source = QRectF(),
                    Qt::AspectRatioMode aspectRatioMode = Qt::KeepAspectRatio);
    
        ItemIndexMethod itemIndexMethod() const;
        void setItemIndexMethod(ItemIndexMethod method);
    
        bool isSortCacheEnabled() const;
        void setSortCacheEnabled(bool enabled);
    
        int bspTreeDepth() const;
        void setBspTreeDepth(int depth);
    
        QRectF itemsBoundingRect() const;
    
        QList<QGraphicsItem *> items(Qt::SortOrder order = Qt::DescendingOrder) const;
    
        QList<QGraphicsItem *> items(const QPointF &pos, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, Qt::SortOrder order = Qt::DescendingOrder, const QTransform &deviceTransform = QTransform()) const;
        QList<QGraphicsItem *> items(const QRectF &rect, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, Qt::SortOrder order = Qt::DescendingOrder, const QTransform &deviceTransform = QTransform()) const;
        QList<QGraphicsItem *> items(const QPolygonF &polygon, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, Qt::SortOrder order = Qt::DescendingOrder, const QTransform &deviceTransform = QTransform()) const;
        QList<QGraphicsItem *> items(const QPainterPath &path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, Qt::SortOrder order = Qt::DescendingOrder, const QTransform &deviceTransform = QTransform()) const;
    
        QList<QGraphicsItem *> collidingItems(const QGraphicsItem *item, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
    #if QT_DEPRECATED_SINCE(5, 0)
        QT_DEPRECATED inline QGraphicsItem *itemAt(const QPointF &position) const {
            QList<QGraphicsItem *> itemsAtPoint = items(position);
            return itemsAtPoint.isEmpty() ? Q_NULLPTR : itemsAtPoint.first();
        }
    #endif
        QGraphicsItem *itemAt(const QPointF &pos, const QTransform &deviceTransform) const;
    #if QT_DEPRECATED_SINCE(5, 0)
        QT_DEPRECATED inline QList<QGraphicsItem *> items(qreal x, qreal y, qreal w, qreal h, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const
        { return items(QRectF(x, y, w, h), mode); }
    #endif
        inline QList<QGraphicsItem *> items(qreal x, qreal y, qreal w, qreal h, Qt::ItemSelectionMode mode, Qt::SortOrder order,
                                            const QTransform &deviceTransform = QTransform()) const
        { return items(QRectF(x, y, w, h), mode, order, deviceTransform); }
    #if QT_DEPRECATED_SINCE(5, 0)
        QT_DEPRECATED inline QGraphicsItem *itemAt(qreal x, qreal y) const {
            QList<QGraphicsItem *> itemsAtPoint = items(QPointF(x, y));
            return itemsAtPoint.isEmpty() ? Q_NULLPTR : itemsAtPoint.first();
        }
    #endif
        inline QGraphicsItem *itemAt(qreal x, qreal y, const QTransform &deviceTransform) const
        { return itemAt(QPointF(x, y), deviceTransform); }
    
        QList<QGraphicsItem *> selectedItems() const;
        QPainterPath selectionArea() const;
        void setSelectionArea(const QPainterPath &path, const QTransform &deviceTransform);
        void setSelectionArea(const QPainterPath &path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, const QTransform &deviceTransform = QTransform());
        void setSelectionArea(const QPainterPath &path, Qt::ItemSelectionOperation selectionOperation, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, const QTransform &deviceTransform = QTransform());
        // ### Qt6 merge the last 2 functions and add a default: Qt::ItemSelectionOperation selectionOperation = Qt::ReplaceSelection
    
        QGraphicsItemGroup *createItemGroup(const QList<QGraphicsItem *> &items);
        void destroyItemGroup(QGraphicsItemGroup *group);
    
        void addItem(QGraphicsItem *item);
        QGraphicsEllipseItem *addEllipse(const QRectF &rect, const QPen &pen = QPen(), const QBrush &brush = QBrush());
        QGraphicsLineItem *addLine(const QLineF &line, const QPen &pen = QPen());
        QGraphicsPathItem *addPath(const QPainterPath &path, const QPen &pen = QPen(), const QBrush &brush = QBrush());
        QGraphicsPixmapItem *addPixmap(const QPixmap &pixmap);
        QGraphicsPolygonItem *addPolygon(const QPolygonF &polygon, const QPen &pen = QPen(), const QBrush &brush = QBrush());
        QGraphicsRectItem *addRect(const QRectF &rect, const QPen &pen = QPen(), const QBrush &brush = QBrush());
        QGraphicsTextItem *addText(const QString &text, const QFont &font = QFont());
        QGraphicsSimpleTextItem *addSimpleText(const QString &text, const QFont &font = QFont());
        QGraphicsProxyWidget *addWidget(QWidget *widget, Qt::WindowFlags wFlags = Qt::WindowFlags());
        inline QGraphicsEllipseItem *addEllipse(qreal x, qreal y, qreal w, qreal h, const QPen &pen = QPen(), const QBrush &brush = QBrush())
        { return addEllipse(QRectF(x, y, w, h), pen, brush); }
        inline QGraphicsLineItem *addLine(qreal x1, qreal y1, qreal x2, qreal y2, const QPen &pen = QPen())
        { return addLine(QLineF(x1, y1, x2, y2), pen); }
        inline QGraphicsRectItem *addRect(qreal x, qreal y, qreal w, qreal h, const QPen &pen = QPen(), const QBrush &brush = QBrush())
        { return addRect(QRectF(x, y, w, h), pen, brush); }
        void removeItem(QGraphicsItem *item);
    
        QGraphicsItem *focusItem() const;
        void setFocusItem(QGraphicsItem *item, Qt::FocusReason focusReason = Qt::OtherFocusReason);
        bool hasFocus() const;
        void setFocus(Qt::FocusReason focusReason = Qt::OtherFocusReason);
        void clearFocus();
    
        void setStickyFocus(bool enabled);
        bool stickyFocus() const;
    
        QGraphicsItem *mouseGrabberItem() const;
    
        QBrush backgroundBrush() const;
        void setBackgroundBrush(const QBrush &brush);
    
        QBrush foregroundBrush() const;
        void setForegroundBrush(const QBrush &brush);
    
        virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const;
    
        QList <QGraphicsView *> views() const;
    
        inline void update(qreal x, qreal y, qreal w, qreal h)
        { update(QRectF(x, y, w, h)); }
        inline void invalidate(qreal x, qreal y, qreal w, qreal h, SceneLayers layers = AllLayers)
        { invalidate(QRectF(x, y, w, h), layers); }
    
        QStyle *style() const;
        void setStyle(QStyle *style);
    
        QFont font() const;
        void setFont(const QFont &font);
    
        QPalette palette() const;
        void setPalette(const QPalette &palette);
    
        bool isActive() const;
        QGraphicsItem *activePanel() const;
        void setActivePanel(QGraphicsItem *item);
        QGraphicsWidget *activeWindow() const;
        void setActiveWindow(QGraphicsWidget *widget);
    
        bool sendEvent(QGraphicsItem *item, QEvent *event);
    
        qreal minimumRenderSize() const;
        void setMinimumRenderSize(qreal minSize);
    
    public Q_SLOTS:
        void update(const QRectF &rect = QRectF());
        void invalidate(const QRectF &rect = QRectF(), SceneLayers layers = AllLayers);
        void advance();
        void clearSelection();
        void clear();
    
    protected:
        bool event(QEvent *event) Q_DECL_OVERRIDE;
        bool eventFilter(QObject *watched, QEvent *event) Q_DECL_OVERRIDE;
        virtual void contextMenuEvent(QGraphicsSceneContextMenuEvent *event);
        virtual void dragEnterEvent(QGraphicsSceneDragDropEvent *event);
        virtual void dragMoveEvent(QGraphicsSceneDragDropEvent *event);
        virtual void dragLeaveEvent(QGraphicsSceneDragDropEvent *event);
        virtual void dropEvent(QGraphicsSceneDragDropEvent *event);
        virtual void focusInEvent(QFocusEvent *event);
        virtual void focusOutEvent(QFocusEvent *event);
        virtual void helpEvent(QGraphicsSceneHelpEvent *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 void drawBackground(QPainter *painter, const QRectF &rect);
        virtual void drawForeground(QPainter *painter, const QRectF &rect);
        virtual void drawItems(QPainter *painter, int numItems,
                               QGraphicsItem *items[],
                               const QStyleOptionGraphicsItem options[],
                               QWidget *widget = Q_NULLPTR);
    
    protected Q_SLOTS:
        // ### Qt 6: make unconditional
    #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
        virtual
    #endif
        bool focusNextPrevChild(bool next);
    
    Q_SIGNALS:
        void changed(const QList<QRectF> &region);
        void sceneRectChanged(const QRectF &rect);
        void selectionChanged();
        void focusItemChanged(QGraphicsItem *newFocus, QGraphicsItem *oldFocus, Qt::FocusReason reason);
    
    private:
        Q_DECLARE_PRIVATE(QGraphicsScene)
        Q_DISABLE_COPY(QGraphicsScene)
        Q_PRIVATE_SLOT(d_func(), void _q_emitUpdated())
        Q_PRIVATE_SLOT(d_func(), void _q_polishItems())
        Q_PRIVATE_SLOT(d_func(), void _q_processDirtyItems())
        Q_PRIVATE_SLOT(d_func(), void _q_updateScenePosDescendants())
        friend class QGraphicsItem;
        friend class QGraphicsItemPrivate;
        friend class QGraphicsObject;
        friend class QGraphicsView;
        friend class QGraphicsViewPrivate;
        friend class QGraphicsWidget;
        friend class QGraphicsWidgetPrivate;
        friend class QGraphicsEffect;
        friend class QGraphicsSceneIndex;
        friend class QGraphicsSceneIndexPrivate;
        friend class QGraphicsSceneBspTreeIndex;
        friend class QGraphicsSceneBspTreeIndexPrivate;
        friend class QGraphicsItemEffectSourcePrivate;
    #ifndef QT_NO_GESTURES
        friend class QGesture;
    #endif
    };

**3.QGraphicsView **

class QGraphicsView : public QAbstractScrollArea  
class QAbstractScrollArea : public QFrame  
class QFrame : public QWidget  
class QWidget : public QObject, public QPaintDevice

class Q_WIDGETS_EXPORT QGraphicsView : public QAbstractScrollArea
    {
        Q_OBJECT
        Q_FLAGS(QPainter::RenderHints CacheMode OptimizationFlags)
        Q_PROPERTY(QBrush backgroundBrush READ backgroundBrush WRITE setBackgroundBrush)
        Q_PROPERTY(QBrush foregroundBrush READ foregroundBrush WRITE setForegroundBrush)
        Q_PROPERTY(bool interactive READ isInteractive WRITE setInteractive)
        Q_PROPERTY(QRectF sceneRect READ sceneRect WRITE setSceneRect)
        Q_PROPERTY(Qt::Alignment alignment READ alignment WRITE setAlignment)
        Q_PROPERTY(QPainter::RenderHints renderHints READ renderHints WRITE setRenderHints)
        Q_PROPERTY(DragMode dragMode READ dragMode WRITE setDragMode)
        Q_PROPERTY(CacheMode cacheMode READ cacheMode WRITE setCacheMode)
        Q_PROPERTY(ViewportAnchor transformationAnchor READ transformationAnchor WRITE setTransformationAnchor)
        Q_PROPERTY(ViewportAnchor resizeAnchor READ resizeAnchor WRITE setResizeAnchor)
        Q_PROPERTY(ViewportUpdateMode viewportUpdateMode READ viewportUpdateMode WRITE setViewportUpdateMode)
    #ifndef QT_NO_RUBBERBAND
        Q_PROPERTY(Qt::ItemSelectionMode rubberBandSelectionMode READ rubberBandSelectionMode WRITE setRubberBandSelectionMode)
    #endif
        Q_PROPERTY(OptimizationFlags optimizationFlags READ optimizationFlags WRITE setOptimizationFlags)
    
    public:
        enum ViewportAnchor {
            NoAnchor,
            AnchorViewCenter,
            AnchorUnderMouse
        };
        Q_ENUM(ViewportAnchor)
    
        enum CacheModeFlag {
            CacheNone = 0x0,
            CacheBackground = 0x1
        };
        Q_DECLARE_FLAGS(CacheMode, CacheModeFlag)
    
        enum DragMode {
            NoDrag,
            ScrollHandDrag,
            RubberBandDrag
        };
        Q_ENUM(DragMode)
    
        enum ViewportUpdateMode {
            FullViewportUpdate,
            MinimalViewportUpdate,
            SmartViewportUpdate,
            NoViewportUpdate,
            BoundingRectViewportUpdate
        };
        Q_ENUM(ViewportUpdateMode)
    
        enum OptimizationFlag {
            DontClipPainter = 0x1, // obsolete
            DontSavePainterState = 0x2,
            DontAdjustForAntialiasing = 0x4,
            IndirectPainting = 0x8
        };
        Q_DECLARE_FLAGS(OptimizationFlags, OptimizationFlag)
    
        QGraphicsView(QWidget *parent = Q_NULLPTR);
        QGraphicsView(QGraphicsScene *scene, QWidget *parent = Q_NULLPTR);
        ~QGraphicsView();
    
        QSize sizeHint() const Q_DECL_OVERRIDE;
    
        QPainter::RenderHints renderHints() const;
        void setRenderHint(QPainter::RenderHint hint, bool enabled = true);
        void setRenderHints(QPainter::RenderHints hints);
    
        Qt::Alignment alignment() const;
        void setAlignment(Qt::Alignment alignment);
    
        ViewportAnchor transformationAnchor() const;
        void setTransformationAnchor(ViewportAnchor anchor);
    
        ViewportAnchor resizeAnchor() const;
        void setResizeAnchor(ViewportAnchor anchor);
    
        ViewportUpdateMode viewportUpdateMode() const;
        void setViewportUpdateMode(ViewportUpdateMode mode);
    
        OptimizationFlags optimizationFlags() const;
        void setOptimizationFlag(OptimizationFlag flag, bool enabled = true);
        void setOptimizationFlags(OptimizationFlags flags);
    
        DragMode dragMode() const;
        void setDragMode(DragMode mode);
    
    #ifndef QT_NO_RUBBERBAND
        Qt::ItemSelectionMode rubberBandSelectionMode() const;
        void setRubberBandSelectionMode(Qt::ItemSelectionMode mode);
        QRect rubberBandRect() const;
    #endif
    
        CacheMode cacheMode() const;
        void setCacheMode(CacheMode mode);
        void resetCachedContent();
    
        bool isInteractive() const;
        void setInteractive(bool allowed);
    
        QGraphicsScene *scene() const;
        void setScene(QGraphicsScene *scene);
    
        QRectF sceneRect() const;
        void setSceneRect(const QRectF &rect);
        inline void setSceneRect(qreal x, qreal y, qreal w, qreal h);
    
        QMatrix matrix() const;
        void setMatrix(const QMatrix &matrix, bool combine = false);
        void resetMatrix();
        QTransform transform() const;
        QTransform viewportTransform() const;
        bool isTransformed() const;
        void setTransform(const QTransform &matrix, bool combine = false);
        void resetTransform();
        void rotate(qreal angle);
        void scale(qreal sx, qreal sy);
        void shear(qreal sh, qreal sv);
        void translate(qreal dx, qreal dy);
    
        void centerOn(const QPointF &pos);
        inline void centerOn(qreal x, qreal y);
        void centerOn(const QGraphicsItem *item);
        void ensureVisible(const QRectF &rect, int xmargin = 50, int ymargin = 50);
        inline void ensureVisible(qreal x, qreal y, qreal w, qreal h, int xmargin = 50, int ymargin = 50);
        void ensureVisible(const QGraphicsItem *item, int xmargin = 50, int ymargin = 50);
        void fitInView(const QRectF &rect, Qt::AspectRatioMode aspectRadioMode = Qt::IgnoreAspectRatio);
        inline void fitInView(qreal x, qreal y, qreal w, qreal h,
                              Qt::AspectRatioMode aspectRadioMode = Qt::IgnoreAspectRatio);
        void fitInView(const QGraphicsItem *item,
                       Qt::AspectRatioMode aspectRadioMode = Qt::IgnoreAspectRatio);
    
        void render(QPainter *painter, const QRectF &target = QRectF(), const QRect &source = QRect(),
                    Qt::AspectRatioMode aspectRatioMode = Qt::KeepAspectRatio);
    
        QList<QGraphicsItem *> items() const;
        QList<QGraphicsItem *> items(const QPoint &pos) const;
        inline QList<QGraphicsItem *> items(int x, int y) const;
        QList<QGraphicsItem *> items(const QRect &rect, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
        inline QList<QGraphicsItem *> items(int x, int y, int w, int h, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
        QList<QGraphicsItem *> items(const QPolygon &polygon, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
        QList<QGraphicsItem *> items(const QPainterPath &path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
        QGraphicsItem *itemAt(const QPoint &pos) const;
        inline QGraphicsItem *itemAt(int x, int y) const;
    
        QPointF mapToScene(const QPoint &point) const;
        QPolygonF mapToScene(const QRect &rect) const;
        QPolygonF mapToScene(const QPolygon &polygon) const;
        QPainterPath mapToScene(const QPainterPath &path) const;
        QPoint mapFromScene(const QPointF &point) const;
        QPolygon mapFromScene(const QRectF &rect) const;
        QPolygon mapFromScene(const QPolygonF &polygon) const;
        QPainterPath mapFromScene(const QPainterPath &path) const;
        inline QPointF mapToScene(int x, int y) const;
        inline QPolygonF mapToScene(int x, int y, int w, int h) const;
        inline QPoint mapFromScene(qreal x, qreal y) const;
        inline QPolygon mapFromScene(qreal x, qreal y, qreal w, qreal h) const;
    
        QVariant inputMethodQuery(Qt::InputMethodQuery query) const Q_DECL_OVERRIDE;
    
        QBrush backgroundBrush() const;
        void setBackgroundBrush(const QBrush &brush);
    
        QBrush foregroundBrush() const;
        void setForegroundBrush(const QBrush &brush);
    
    public Q_SLOTS:
        void updateScene(const QList<QRectF> &rects);
        void invalidateScene(const QRectF &rect = QRectF(), QGraphicsScene::SceneLayers layers = QGraphicsScene::AllLayers);
        void updateSceneRect(const QRectF &rect);
    
    #ifndef QT_NO_RUBBERBAND
    Q_SIGNALS:
        void rubberBandChanged(QRect viewportRect, QPointF fromScenePoint, QPointF toScenePoint);
    #endif
    
    protected Q_SLOTS:
        void setupViewport(QWidget *widget) Q_DECL_OVERRIDE;
    
    protected:
        QGraphicsView(QGraphicsViewPrivate &, QWidget *parent = Q_NULLPTR);
        bool event(QEvent *event) Q_DECL_OVERRIDE;
        bool viewportEvent(QEvent *event) Q_DECL_OVERRIDE;
    
    #ifndef QT_NO_CONTEXTMENU
        void contextMenuEvent(QContextMenuEvent *event) Q_DECL_OVERRIDE;
    #endif
    #if QT_CONFIG(draganddrop)
        void dragEnterEvent(QDragEnterEvent *event) Q_DECL_OVERRIDE;
        void dragLeaveEvent(QDragLeaveEvent *event) Q_DECL_OVERRIDE;
        void dragMoveEvent(QDragMoveEvent *event) Q_DECL_OVERRIDE;
        void dropEvent(QDropEvent *event) Q_DECL_OVERRIDE;
    #endif
        void focusInEvent(QFocusEvent *event) Q_DECL_OVERRIDE;
        bool focusNextPrevChild(bool next) Q_DECL_OVERRIDE;
        void focusOutEvent(QFocusEvent *event) Q_DECL_OVERRIDE;
        void keyPressEvent(QKeyEvent *event) Q_DECL_OVERRIDE;
        void keyReleaseEvent(QKeyEvent *event) Q_DECL_OVERRIDE;
        void mouseDoubleClickEvent(QMouseEvent *event) Q_DECL_OVERRIDE;
        void mousePressEvent(QMouseEvent *event) Q_DECL_OVERRIDE;
        void mouseMoveEvent(QMouseEvent *event) Q_DECL_OVERRIDE;
        void mouseReleaseEvent(QMouseEvent *event) Q_DECL_OVERRIDE;
    #ifndef QT_NO_WHEELEVENT
        void wheelEvent(QWheelEvent *event) Q_DECL_OVERRIDE;
    #endif
        void paintEvent(QPaintEvent *event) Q_DECL_OVERRIDE;
        void resizeEvent(QResizeEvent *event) Q_DECL_OVERRIDE;
        void scrollContentsBy(int dx, int dy) Q_DECL_OVERRIDE;
        void showEvent(QShowEvent *event) Q_DECL_OVERRIDE;
        void inputMethodEvent(QInputMethodEvent *event) Q_DECL_OVERRIDE;
    
        virtual void drawBackground(QPainter *painter, const QRectF &rect);
        virtual void drawForeground(QPainter *painter, const QRectF &rect);
        virtual void drawItems(QPainter *painter, int numItems,
                               QGraphicsItem *items[],
                               const QStyleOptionGraphicsItem options[]);
    
    private:
        Q_DECLARE_PRIVATE(QGraphicsView)
        Q_DISABLE_COPY(QGraphicsView)
    #ifndef QT_NO_CURSOR
        Q_PRIVATE_SLOT(d_func(), void _q_setViewportCursor(const QCursor &))
        Q_PRIVATE_SLOT(d_func(), void _q_unsetViewportCursor())
    #endif
        friend class QGraphicsSceneWidget;
        friend class QGraphicsScene;
        friend class QGraphicsScenePrivate;
        friend class QGraphicsItemPrivate;
    };