d2/d61/qgraphicsitem_8h_source.html

// Copyright (C) 2016 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only


#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 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,

        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);

    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;


#if QT_CONFIG(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);

    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

    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();

    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_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(), 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_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)

    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) : nullptr;

}


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) : nullptr;

}


#ifndef QT_NO_DEBUG_STREAM

Q_WIDGETS_EXPORT QDebug operator<<(QDebug debug, const QGraphicsItem *item);

Q_WIDGETS_EXPORT QDebug operator<<(QDebug debug, const 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


QT_DECL_METATYPE_EXTERN_TAGGED(QGraphicsItem*, QGraphicsItem_ptr, Q_WIDGETS_EXPORT)


#endif // QGRAPHICSITEM_H

isActive
bool isActive
Definition btsdpinquiry.mm:194

Item
Definition lalr.h:85

QAbstractGraphicsShapeItemPrivate
Definition qgraphicsitem.cpp:7950

QAbstractGraphicsShapeItem
The QAbstractGraphicsShapeItem class provides a common base for all path items.
Definition qgraphicsitem.h:549

QBrush
\inmodule QtGui
Definition qbrush.h:30

QColor
The QColor class provides colors based on RGB, HSV or CMYK values.
Definition qcolor.h:31

QCursor
The QCursor class provides a mouse cursor with an arbitrary shape.
Definition qcursor.h:45

QDebug
\inmodule QtCore

QEvent
\inmodule QtCore
Definition qcoreevent.h:45

QFocusEvent
The QFocusEvent class contains event parameters for widget focus events.
Definition qevent.h:469

QFont
\reentrant
Definition qfont.h:20

QGestureManager
Definition qgesturemanager_p.h:33

QGraphicsEffect
The QGraphicsEffect class is the base class for all graphics effects.
Definition qgraphicseffect.h:27

QGraphicsEllipseItemPrivate
Definition qgraphicsitem.cpp:8518

QGraphicsEllipseItem
The QGraphicsEllipseItem class provides an ellipse item that you can add to a QGraphicsScene.
Definition qgraphicsitem.h:645

QGraphicsEllipseItem::setRect
void setRect(const QRectF &rect)
Sets the item's ellipse geometry to rect.
Definition qgraphicsitem.cpp:8598

QGraphicsItemGroupPrivate
Definition qgraphicsitem.cpp:10814

QGraphicsItemGroup
The QGraphicsItemGroup class provides a container that treats a group of items as a single item.
Definition qgraphicsitem.h:947

QGraphicsItemPrivate
Definition qgraphicsitem_p.h:62

QGraphicsItem
The QGraphicsItem class is the base class for all graphical items in a QGraphicsScene.
Definition qgraphicsitem.h:47

QGraphicsItem::setTransformOriginPoint
void setTransformOriginPoint(qreal ax, qreal ay)
Definition qgraphicsitem.h:258

QGraphicsItem::mapRectToItem
QRectF mapRectToItem(const QGraphicsItem *item, const QRectF &rect) const
Definition qgraphicsitem.cpp:5930

QGraphicsItem::GraphicsItemChange
GraphicsItemChange
This enum describes the state changes that are notified by QGraphicsItem::itemChange().
Definition qgraphicsitem.h:74

QGraphicsItem::ItemChildRemovedChange
@ ItemChildRemovedChange
Definition qgraphicsitem.h:81

QGraphicsItem::ItemFlagsChange
@ ItemFlagsChange
Definition qgraphicsitem.h:95

QGraphicsItem::ItemScaleChange
@ ItemScaleChange
Definition qgraphicsitem.h:104

QGraphicsItem::ItemTransformOriginPointChange
@ ItemTransformOriginPointChange
Definition qgraphicsitem.h:106

QGraphicsItem::ItemPositionHasChanged
@ ItemPositionHasChanged
Definition qgraphicsitem.h:83

QGraphicsItem::ItemSceneHasChanged
@ ItemSceneHasChanged
Definition qgraphicsitem.h:90

QGraphicsItem::ItemOpacityHasChanged
@ ItemOpacityHasChanged
Definition qgraphicsitem.h:100

QGraphicsItem::ItemZValueHasChanged
@ ItemZValueHasChanged
Definition qgraphicsitem.h:98

QGraphicsItem::ItemToolTipChange
@ ItemToolTipChange
Definition qgraphicsitem.h:93

QGraphicsItem::ItemRotationChange
@ ItemRotationChange
Definition qgraphicsitem.h:102

QGraphicsItem::ItemRotationHasChanged
@ ItemRotationHasChanged
Definition qgraphicsitem.h:103

QGraphicsItem::ItemZValueChange
@ ItemZValueChange
Definition qgraphicsitem.h:97

QGraphicsItem::ItemSelectedHasChanged
@ ItemSelectedHasChanged
Definition qgraphicsitem.h:88

QGraphicsItem::ItemChildAddedChange
@ ItemChildAddedChange
Definition qgraphicsitem.h:80

QGraphicsItem::ItemFlagsHaveChanged
@ ItemFlagsHaveChanged
Definition qgraphicsitem.h:96

QGraphicsItem::ItemPositionChange
@ ItemPositionChange
Definition qgraphicsitem.h:75

QGraphicsItem::ItemParentChange
@ ItemParentChange
Definition qgraphicsitem.h:79

QGraphicsItem::ItemCursorHasChanged
@ ItemCursorHasChanged
Definition qgraphicsitem.h:92

QGraphicsItem::ItemTransformHasChanged
@ ItemTransformHasChanged
Definition qgraphicsitem.h:84

QGraphicsItem::ItemToolTipHasChanged
@ ItemToolTipHasChanged
Definition qgraphicsitem.h:94

QGraphicsItem::ItemCursorChange
@ ItemCursorChange
Definition qgraphicsitem.h:91

QGraphicsItem::ItemSelectedChange
@ ItemSelectedChange
Definition qgraphicsitem.h:78

QGraphicsItem::ItemTransformChange
@ ItemTransformChange
Definition qgraphicsitem.h:82

QGraphicsItem::ItemOpacityChange
@ ItemOpacityChange
Definition qgraphicsitem.h:99

QGraphicsItem::ItemVisibleHasChanged
@ ItemVisibleHasChanged
Definition qgraphicsitem.h:86

QGraphicsItem::ItemSceneChange
@ ItemSceneChange
Definition qgraphicsitem.h:85

QGraphicsItem::ItemScenePositionHasChanged
@ ItemScenePositionHasChanged
Definition qgraphicsitem.h:101

QGraphicsItem::ItemEnabledHasChanged
@ ItemEnabledHasChanged
Definition qgraphicsitem.h:87

QGraphicsItem::ItemScaleHasChanged
@ ItemScaleHasChanged
Definition qgraphicsitem.h:105

QGraphicsItem::ItemEnabledChange
@ ItemEnabledChange
Definition qgraphicsitem.h:77

QGraphicsItem::ItemParentHasChanged
@ ItemParentHasChanged
Definition qgraphicsitem.h:89

QGraphicsItem::mapToItem
QPointF mapToItem(const QGraphicsItem *item, const QPointF &point) const
Maps the point point, which is in this item's coordinate system, to item's coordinate system,...
Definition qgraphicsitem.cpp:5789

QGraphicsItem::d_ptr
QScopedPointer< QGraphicsItemPrivate > d_ptr
Definition qgraphicsitem.h:400

QGraphicsItem::ensureVisible
void ensureVisible(const QRectF &rect=QRectF(), int xmargin=50, int ymargin=50)
If this item is part of a scene that is viewed by a QGraphicsView, this convenience function will att...
Definition qgraphicsitem.cpp:3911

QGraphicsItem::update
void update(const QRectF &rect=QRectF())
Schedules a redraw of the area covered by rect in this item.
Definition qgraphicsitem.cpp:5642

QGraphicsItem::isObscured
bool isObscured(const QRectF &rect=QRectF()) const
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition qgraphicsitem.cpp:5068

QGraphicsItem::paint
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget=nullptr)=0
This function, which is usually called by QGraphicsView, paints the contents of an item in local coor...

QGraphicsItem::moveBy
void moveBy(qreal dx, qreal dy)
Moves the item by dx points horizontally, and dy point vertically.
Definition qgraphicsitem.h:235

QGraphicsItem::show
void show()
Shows the item (items are visible by default).
Definition qgraphicsitem.h:174

QGraphicsItem::y
qreal y() const
This convenience function is equivalent to calling pos().y().
Definition qgraphicsitem.h:230

QGraphicsItem::GraphicsItemFlag
GraphicsItemFlag
This enum describes different flags that you can set on an item to toggle different features in the i...
Definition qgraphicsitem.h:49

QGraphicsItem::Type
@ Type
Definition qgraphicsitem.h:357

QGraphicsItem::boundingRect
virtual QRectF boundingRect() const =0
This pure virtual function defines the outer bounds of the item as a rectangle; all painting must be ...

QGraphicsItem::mapFromItem
QPointF mapFromItem(const QGraphicsItem *item, const QPointF &point) const
Maps the point point, which is in item's coordinate system, to this item's coordinate system,...
Definition qgraphicsitem.cpp:6172

QGraphicsItem::setPos
void setPos(const QPointF &pos)
Sets the position of the item to pos, which is in parent coordinates.
Definition qgraphicsitem.cpp:3849

QGraphicsItem::mapRectToParent
QRectF mapRectToParent(const QRectF &rect) const
Definition qgraphicsitem.cpp:5954

QGraphicsItem::PanelModality
PanelModality
Definition qgraphicsitem.h:117

QGraphicsItem::PanelModal
@ PanelModal
Definition qgraphicsitem.h:119

QGraphicsItem::NonModal
@ NonModal
Definition qgraphicsitem.h:118

QGraphicsItem::CacheMode
CacheMode
Definition qgraphicsitem.h:110

QGraphicsItem::ItemCoordinateCache
@ ItemCoordinateCache
Definition qgraphicsitem.h:112

QGraphicsItem::NoCache
@ NoCache
Definition qgraphicsitem.h:111

QGraphicsItem::x
qreal x() const
This convenience function is equivalent to calling pos().x().
Definition qgraphicsitem.h:228

QGraphicsItem::mapToScene
QPointF mapToScene(const QPointF &point) const
Maps the point point, which is in this item's coordinate system, to the scene's coordinate system,...
Definition qgraphicsitem.cpp:5835

QGraphicsItem::mapRectToScene
QRectF mapRectToScene(const QRectF &rect) const
Definition qgraphicsitem.cpp:5979

QGraphicsItem::type
virtual int type() const
Returns the type of an item as an int.
Definition qgraphicsitem.cpp:6535

QGraphicsItem::mapToParent
QPointF mapToParent(const QPointF &point) const
Maps the point point, which is in this item's coordinate system, to its parent's coordinate system,...
Definition qgraphicsitem.cpp:5812

QGraphicsItem::mapRectFromItem
QRectF mapRectFromItem(const QGraphicsItem *item, const QRectF &rect) const
Definition qgraphicsitem.cpp:6005

QGraphicsItem::mapRectFromScene
QRectF mapRectFromScene(const QRectF &rect) const
Definition qgraphicsitem.cpp:6055

QGraphicsItem::mapFromParent
QPointF mapFromParent(const QPointF &point) const
Maps the point point, which is in this item's parent's coordinate system, to this item's coordinate s...
Definition qgraphicsitem.cpp:6195

QGraphicsItem::mapRectFromParent
QRectF mapRectFromParent(const QRectF &rect) const
Definition qgraphicsitem.cpp:6030

QGraphicsItem::hide
void hide()
Hides the item (items are visible by default).
Definition qgraphicsitem.h:173

QGraphicsItem::Extension
Extension
Definition qgraphicsitem.h:391

QGraphicsItem::mapFromScene
QPointF mapFromScene(const QPointF &point) const
Maps the point point, which is in this item's scene's coordinate system, to this item's coordinate sy...
Definition qgraphicsitem.cpp:6219

QGraphicsLineItemPrivate
Definition qgraphicsitem.cpp:9035

QGraphicsLineItem
The QGraphicsLineItem class provides a line item that you can add to a QGraphicsScene.
Definition qgraphicsitem.h:726

QGraphicsLineItem::setLine
void setLine(qreal x1, qreal y1, qreal x2, qreal y2)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition qgraphicsitem.h:738

QGraphicsObject
The QGraphicsObject class provides a base class for all graphics items that require signals,...
Definition qgraphicsitem.h:486

QGraphicsObject::heightChanged
void heightChanged()

QGraphicsObject::zChanged
void zChanged()
This signal gets emitted whenever the z value of the item changes.

QGraphicsObject::xChanged
void xChanged()
This signal gets emitted whenever the x position of the item changes.

QGraphicsObject::visibleChanged
void visibleChanged()
This signal gets emitted whenever the visibility of the item changes.

QGraphicsObject::childrenChanged
void childrenChanged()
This signal gets emitted whenever the children list changes.

QGraphicsObject::widthChanged
void widthChanged()

QGraphicsObject::rotationChanged
void rotationChanged()
This signal gets emitted whenever the rotation of the item changes.

QGraphicsObject::parentChanged
void parentChanged()
This signal gets emitted whenever the parent of the item changes.

QGraphicsObject::opacityChanged
void opacityChanged()
This signal gets emitted whenever the opacity of the item changes.

QGraphicsObject::yChanged
void yChanged()
This signal gets emitted whenever the y position of the item changes.

QGraphicsObject::scaleChanged
void scaleChanged()
This signal is emitted when the scale of the item changes.

QGraphicsObject::enabledChanged
void enabledChanged()
This signal gets emitted whenever the item gets enabled or disabled.

QGraphicsPathItemPrivate
Definition qgraphicsitem.cpp:8088

QGraphicsPathItem
[17]
Definition src_gui_graphicsview_qgraphicsitem.cpp:195

QGraphicsPathItem::type
int type() const override
Returns the type of an item as an int.

QGraphicsPixmapItemPrivate
Definition qgraphicsitem.cpp:9316

QGraphicsPixmapItem
The QGraphicsPixmapItem class provides a pixmap item that you can add to a QGraphicsScene.
Definition qgraphicsitem.h:765

QGraphicsPixmapItem::ShapeMode
ShapeMode
This enum describes how QGraphicsPixmapItem calculates its shape and opaque area.
Definition qgraphicsitem.h:767

QGraphicsPixmapItem::MaskShape
@ MaskShape
Definition qgraphicsitem.h:768

QGraphicsPixmapItem::BoundingRectShape
@ BoundingRectShape
Definition qgraphicsitem.h:769

QGraphicsPixmapItem::setOffset
void setOffset(const QPointF &offset)
Sets the pixmap item's offset to offset.
Definition qgraphicsitem.cpp:9465

QGraphicsPolygonItemPrivate
Definition qgraphicsitem.cpp:8813

QGraphicsPolygonItem
The QGraphicsPolygonItem class provides a polygon item that you can add to a QGraphicsScene.
Definition qgraphicsitem.h:689

QGraphicsProxyWidgetPrivate
Definition qgraphicsproxywidget_p.h:27

QGraphicsRectItemPrivate
Definition qgraphicsitem.cpp:8288

QGraphicsRectItem
The QGraphicsRectItem class provides a rectangle item that you can add to a QGraphicsScene.
Definition qgraphicsitem.h:607

QGraphicsRectItem::setRect
void setRect(const QRectF &rect)
Sets the item's rectangle to be the given rectangle.
Definition qgraphicsitem.cpp:8360

QGraphicsSceneBspTreeIndexPrivate
Definition qgraphicsscenebsptreeindex_p.h:75

QGraphicsSceneBspTreeIndex
The QGraphicsSceneBspTreeIndex class provides an implementation of a BSP indexing algorithm for disco...
Definition qgraphicsscenebsptreeindex_p.h:37

QGraphicsSceneBspTree
Definition qgraphicsscene_bsp_p.h:30

QGraphicsSceneContextMenuEvent
The QGraphicsSceneContextMenuEvent class provides context menu events in the graphics view framework.
Definition qgraphicssceneevent.h:143

QGraphicsSceneDragDropEvent
The QGraphicsSceneDragDropEvent class provides events for drag and drop in the graphics view framewor...
Definition qgraphicssceneevent.h:223

QGraphicsSceneEvent
The QGraphicsSceneEvent class provides a base class for all graphics view related events.
Definition qgraphicssceneevent.h:26

QGraphicsSceneHoverEvent
The QGraphicsSceneHoverEvent class provides hover events in the graphics view framework.
Definition qgraphicssceneevent.h:172

QGraphicsSceneIndexPrivate
Definition qgraphicssceneindex_p.h:86

QGraphicsSceneIndex
The QGraphicsSceneIndex class provides a base class to implement a custom indexing algorithm for disc...
Definition qgraphicssceneindex_p.h:39

QGraphicsSceneMouseEvent
The QGraphicsSceneMouseEvent class provides mouse events in the graphics view framework.
Definition qgraphicssceneevent.h:47

QGraphicsScenePrivate
Definition qgraphicsscene_p.h:48

QGraphicsSceneWheelEvent
The QGraphicsSceneWheelEvent class provides wheel events in the graphics view framework.
Definition qgraphicssceneevent.h:101

QGraphicsScene
The QGraphicsScene class provides a surface for managing a large number of 2D graphical items.
Definition qgraphicsscene.h:59

QGraphicsSimpleTextItemPrivate
Definition qgraphicsitem.cpp:10478

QGraphicsSimpleTextItem
The QGraphicsSimpleTextItem class provides a simple text path item that you can add to a QGraphicsSce...
Definition qgraphicsitem.h:911

QGraphicsTextItemPrivate
Definition qgraphicsitem.cpp:9654

QGraphicsTextItem
The QGraphicsTextItem class provides a text item that you can add to a QGraphicsScene to display form...
Definition qgraphicsitem.h:819

QGraphicsTextItem::linkHovered
void linkHovered(const QString &)
This signal is emitted when the user hovers over a link on a text item that enables Qt::LinksAccessib...

QGraphicsTextItem::linkActivated
void linkActivated(const QString &)
This signal is emitted when the user clicks on a link on a text item that enables Qt::LinksAccessible...

QGraphicsTransformPrivate
Definition qgraphicstransform_p.h:27

QGraphicsTransform
The QGraphicsTransform class is an abstract base class for building advanced transformations on QGrap...
Definition qgraphicstransform.h:21

QGraphicsViewPrivate
Definition qgraphicsview_p.h:33

QGraphicsView
The QGraphicsView class provides a widget for displaying the contents of a QGraphicsScene.
Definition qgraphicsview.h:24

QGraphicsWidgetPrivate
Definition qgraphicswidget_p.h:37

QGraphicsWidget
The QGraphicsWidget class is the base class for all widget items in a QGraphicsScene.
Definition qgraphicswidget.h:32

QInputMethodEvent
The QInputMethodEvent class provides parameters for input method events.
Definition qevent.h:624

QKeyEvent
The QKeyEvent class describes a key event.
Definition qevent.h:423

QLineF
\inmodule QtCore
Definition qline.h:182

QList
Definition qlist.h:74

QMenu
The QMenu class provides a menu widget for use in menu bars, context menus, and other popup menus.
Definition qmenu.h:26

QObject
\inmodule QtCore
Definition qobject.h:90

QObject::children
const QObjectList & children() const
Returns a list of child objects.
Definition qobject.h:171

QPainterPath
\inmodule QtGui
Definition qpainterpath.h:29

QPainter
The QPainter class performs low-level painting on widgets and other paint devices.
Definition qpainter.h:46

QPen
\inmodule QtGui
Definition qpen.h:25

QPixmap
Returns a copy of the pixmap that is transformed using the given transformation transform and transfo...
Definition qpixmap.h:27

QPointF
\inmodule QtCore\reentrant
Definition qpoint.h:214

QPolygonF
The QPolygonF class provides a list of points using floating point precision.
Definition qpolygon.h:96

QRectF
\inmodule QtCore\reentrant
Definition qrect.h:483

QRegion
The QRegion class specifies a clip region for a painter.
Definition qregion.h:27

QScopedPointer
\inmodule QtCore
Definition qscopedpointer.h:71

QSize
\inmodule QtCore
Definition qsize.h:25

QString
\macro QT_RESTRICTED_CAST_FROM_ASCII
Definition qstring.h:127

QStyleOptionGraphicsItem
The QStyleOptionGraphicsItem class is used to describe the parameters needed to draw a QGraphicsItem.
Definition qstyleoption.h:649

QTextCursor
\reentrant \inmodule QtGui
Definition qtextcursor.h:30

QTextDocument
\reentrant \inmodule QtGui
Definition qtextdocument.h:57

QTransform
The QTransform class specifies 2D transformations of a coordinate system.
Definition qtransform.h:20

QVariant
\inmodule QtCore
Definition qvariant.h:64

QWidget
The QWidget class is the base class of all user interface objects.
Definition qwidget.h:99

extension
void extension()
[6]
Definition dialogs.cpp:230

widget
QOpenGLWidget * widget
[1]
Definition doc_gui_widgets_qopenglwidget.cpp:53

paint
QPainter paint
Definition doc_src_groups.cpp:25

text
QString text
Definition doc_src_properties.cpp:102

cursor
QCursor cursor
Definition doc_src_properties.cpp:25

rect
rect
[4]
Definition doc_src_styles.cpp:43

QT_BEGIN_NAMESPACE
Combined button and popup list for selecting options.
Definition qstandardpaths_haiku.cpp:21

QT_END_NAMESPACE
Definition qsharedpointer.cpp:1545

Qt::InputMethodQuery
InputMethodQuery
Definition qnamespace.h:1354

Qt::TransformationMode
TransformationMode
Definition qnamespace.h:1323

Qt::ItemSelectionMode
ItemSelectionMode
Definition qnamespace.h:1311

Qt::IntersectsItemShape
@ IntersectsItemShape
Definition qnamespace.h:1313

Qt::GestureType
GestureType
Definition qnamespace.h:1620

Qt::FillRule
FillRule
Definition qnamespace.h:1294

Qt::FocusReason
FocusReason
Definition qnamespace.h:1334

Qt::OtherFocusReason
@ OtherFocusReason
Definition qnamespace.h:1342

brush
Definition brush.cpp:5

polygon
Definition polygon.cpp:4

toPlainText
static QString toPlainText(const QString &text)
Definition qcocoamessagedialog.mm:34

rule
DBusConnection const char * rule
Definition qdbus_symbols_p.h:156

value
EGLOutputLayerEXT EGLint EGLAttrib value
[5]
Definition qeglstreamconvenience_p.h:46

Q_DECLARE_FLAGS
#define Q_DECLARE_FLAGS(Flags, Enum)
Definition qflags.h:174

Q_DECLARE_OPERATORS_FOR_FLAGS
#define Q_DECLARE_OPERATORS_FOR_FLAGS(Flags)
Definition qflags.h:194

qgraphicsitem_cast
T qgraphicsitem_cast(QGraphicsItem *item)
Definition qgraphicsitem.h:969

operator<<
Q_WIDGETS_EXPORT QDebug operator<<(QDebug debug, const QGraphicsItem *item)
Definition qgraphicsitem.cpp:11160

qt_closestLeaf
bool qt_closestLeaf(const QGraphicsItem *item1, const QGraphicsItem *item2)
Definition qgraphicsitem_p.h:622

qt_closestItemFirst
bool qt_closestItemFirst(const QGraphicsItem *item1, const QGraphicsItem *item2)
Returns true if item1 is on top of item2.
Definition qgraphicsitem_p.h:560

unsetCursor
static void unsetCursor(QWindow *w)
Definition qguiapplication.cpp:4077

debug
@ debug
Definition qibusplatforminputcontext.cpp:48

QT_DECL_METATYPE_EXTERN_TAGGED
#define QT_DECL_METATYPE_EXTERN_TAGGED(TYPE, TAG, EXPORT)
Definition qmetatype.h:1355

Q_DECLARE_INTERFACE
#define Q_DECLARE_INTERFACE(IFace, IId)
Definition qobject.h:420

contains
static bool contains(const QJsonArray &haystack, unsigned needle)
Definition qopengl.cpp:116

b
GLboolean GLboolean GLboolean b
Definition qopengles2ext.h:337

z
GLuint GLfloat GLfloat GLfloat GLfloat GLfloat z
Definition qopengles2ext.h:2707

x
GLint GLint GLint GLint GLint x
[0]
Definition qopengles2ext.h:605

mode
GLenum mode
Definition qopengles2ext.h:333

key
GLuint64 key
Definition qopengles2ext.h:2268

w
GLfloat GLfloat GLfloat w
[0]
Definition qopengles2ext.h:789

height
GLint GLsizei GLsizei height
Definition qopengles2ext.h:206

y1
GLuint GLfloat GLfloat GLfloat GLfloat y1
Definition qopengles2ext.h:2707

x1
GLuint GLfloat GLfloat GLfloat x1
Definition qopengles2ext.h:2707

enabled
GLenum GLenum GLsizei const GLuint GLboolean enabled
Definition qopengles2ext.h:150

width
GLint GLsizei width
Definition qopengles2ext.h:206

type
GLenum type
Definition qopengles2ext.h:150

group
GLboolean GLuint group
Definition qopengles2ext.h:855

angle
GLfloat angle
Definition qopengles2ext.h:3231

flags
GLbitfield flags
Definition qopengles2ext.h:1026

data
GLint GLsizei GLsizei GLenum GLenum GLsizei void * data
Definition qopengles2ext.h:206

offset
GLenum GLuint GLintptr offset
Definition qopengles2ext.h:660

y
GLint y
Definition qopengles2ext.h:206

h
GLfloat GLfloat GLfloat GLfloat h
Definition qopengles2ext.h:789

event
struct _cl_event * event
Definition qopenglext.h:2998

transform
GLuint GLenum GLenum transform
Definition qopenglext.h:11564

query
GLenum query
Definition qopenglext.h:2738

c
const GLubyte * c
Definition qopenglext.h:12701

y2
GLfixed GLfixed GLfixed y2
Definition qopenglext.h:5231

matrix
GLuint GLenum matrix
Definition qopenglext.h:11564

x2
GLfixed GLfixed x2
Definition qopenglext.h:5231

path
GLsizei const GLchar *const  * path
Definition qopenglext.h:4283

option
GLuint GLenum option
Definition qopenglext.h:5929

scale
GLenum GLenum GLenum GLenum GLenum scale
Definition qopenglext.h:10817

cacheSize
static quint64 cacheSize()
Definition qopengltexturecache.cpp:64

boundingRect
static const QRectF boundingRect(const QPointF *points, int pointCount)
Definition qoutlinemapper.cpp:20

setToolTip
decorationRoleName setToolTip
Definition qqmltablemodelcolumn.cpp:97

isWindow
static bool isWindow(QObject *object)
Definition qquickdesignersupportitems.cpp:147

QT_REQUIRE_CONFIG
#define QT_REQUIRE_CONFIG(feature)
Definition qtconfigmacros.h:66

Q_PROPERTY
#define Q_PROPERTY(...)
Definition qtmetamacros.h:56

Q_OBJECT
#define Q_OBJECT
Definition qtmetamacros.h:117

Q_INTERFACES
#define Q_INTERFACES(x)
Definition qtmetamacros.h:55

Q_SLOTS
#define Q_SLOTS
Definition qtmetamacros.h:44

QDOC_PROPERTY
#define QDOC_PROPERTY(text)
Definition qtmetamacros.h:62

Q_SIGNALS
#define Q_SIGNALS
Definition qtmetamacros.h:45

Q_PRIVATE_PROPERTY
#define Q_PRIVATE_PROPERTY(d, text)
Definition qtmetamacros.h:57

qreal
double qreal
Definition qtypes.h:92

panel
QWidget * panel
Definition settings.cpp:7

open
file open(QIODevice::ReadOnly)

pos
pos
[7]
Definition src_corelib_io_qsettings.cpp:57

line
QString line
Definition src_corelib_io_qtextstream.cpp:16

setData
mimeData setData("text/csv", csvData)

variant
QVariant variant
[1]
Definition src_corelib_kernel_qvariant.cpp:30

ok
bool ok
[2]
Definition src_corelib_text_qbytearrayview.cpp:17

setX
p setX(p.x()+1)

other
QSharedPointer< T > other(t)
[5]

font
QFont font
Definition src_gui_dialogs_qfontdialog.cpp:6

effect
QGraphicsOpacityEffect * effect
the effect attached to this item
Definition src_gui_effects_qgraphicseffect.cpp:43

scene
QGraphicsScene scene
[0]
Definition src_gui_graphicsview_qgraphicsgridlayout.cpp:5

installSceneEventFilter
line installSceneEventFilter(ellipse)

sceneTransform
rect sceneTransform().map(QPointF(0

setCursor
item setCursor(Qt::IBeamCursor)
[1]

item
QGraphicsItem * item
Definition src_gui_graphicsview_qgraphicsitem.cpp:107

setPos
rect setPos(100, 100)

deviceTransform
rect deviceTransform(view->viewportTransform()).map(QPointF(0

isVisible
edit isVisible()

setCacheMode
view setCacheMode(QGraphicsView::CacheBackground)

child
QLayoutItem * child
[0]
Definition src_gui_kernel_qlayout.cpp:25

pixmap
widget render & pixmap
Definition src_gui_kernel_qwidget.cpp:32

painter
QPainter painter(this)
[7]

window
aWidget window() -> setWindowTitle("New Window Title")
[2]

setText
insertRed setText("insert red text")

textCursor
edit textCursor().insertText(text)
[0]

setPixmap
imageLabel setPixmap(QPixmap::fromImage(image))

Type
Definition moc.h:24

parent
IUIAutomationTreeWalker __RPC__deref_out_opt IUIAutomationElement ** parent
Definition uiaclientinterfaces_p.h:209