qquickitem.h - mozsearch

qt/qtdeclarative/src/quick/items/qquickitem.h (file symbol)

Enable keyboard shortcuts

Source code

Go to source file

Revision control

Copy as Markdown

// Copyright (C) 2020 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

// Qt-Security score:significant reason:default

#ifndef QQUICKITEM_H

#define QQUICKITEM_H

#include <QtQuick/qtquickglobal.h>

#include <QtQml/qqml.h>

#include <QtQml/qqmlcomponent.h>

#include <QtCore/QObject>

#include <QtCore/QList>

#include <QtCore/qproperty.h>

#include <QtGui/qevent.h>

#include <QtGui/qfont.h>

#include <QtGui/qaccessible.h>

QT_BEGIN_NAMESPACE

class QQuickItem;

class QQuickTransformPrivate;

class Q_QUICK_EXPORT QQuickTransform : public QObject

    Q_OBJECT

    QML_ANONYMOUS

    QML_ADDED_IN_VERSION(2, 0)

public:

    explicit QQuickTransform(QObject *parent = nullptr);

    ~QQuickTransform() override;

    void appendToItem(QQuickItem *);

    void prependToItem(QQuickItem *);

    virtual void applyTo(QMatrix4x4 *matrix) const = 0;

protected Q_SLOTS:

    void update();

protected:

    QQuickTransform(QQuickTransformPrivate &dd, QObject *parent);

private:

    Q_DECLARE_PRIVATE(QQuickTransform)

};

class QCursor;

class QQuickItemLayer;

class QQuickState;

class QQuickAnchorLine;

class QQuickTransition;

class QQuickKeyEvent;

class QQuickAnchors;

class QQuickItemPrivate;

class QQuickWindow;

class QTouchEvent;

class QSGNode;

class QSGTransformNode;

class QSGTextureProvider;

class QQuickItemGrabResult;

class QQuickPalette;

class Q_QUICK_EXPORT QQuickItem : public QObject, public QQmlParserStatus

    Q_OBJECT

    Q_INTERFACES(QQmlParserStatus)

    Q_PROPERTY(QQuickItem *parent READ parentItem WRITE setParentItem NOTIFY parentChanged DESIGNABLE false FINAL)

    Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQmlListProperty<QObject> data READ data DESIGNABLE false VIRTUAL)

    Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQmlListProperty<QObject> resources READ resources DESIGNABLE false)

    Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQmlListProperty<QQuickItem> children READ children NOTIFY childrenChanged DESIGNABLE false)

    Q_PROPERTY(qreal x READ x WRITE setX NOTIFY xChanged BINDABLE bindableX FINAL)

    Q_PROPERTY(qreal y READ y WRITE setY NOTIFY yChanged BINDABLE bindableY FINAL)

    Q_PROPERTY(qreal z READ z WRITE setZ NOTIFY zChanged FINAL)

    Q_PROPERTY(qreal width READ width WRITE setWidth NOTIFY widthChanged RESET resetWidth BINDABLE bindableWidth FINAL)

    Q_PROPERTY(qreal height READ height WRITE setHeight NOTIFY heightChanged RESET resetHeight BINDABLE bindableHeight FINAL)

    Q_PROPERTY(qreal opacity READ opacity WRITE setOpacity NOTIFY opacityChanged FINAL)

    Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged VIRTUAL)

    Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged FINAL)

    Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQuickPalette *palette READ palette WRITE setPalette RESET resetPalette NOTIFY paletteChanged VIRTUAL REVISION(6, 0))

    Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQmlListProperty<QQuickItem> visibleChildren READ visibleChildren NOTIFY visibleChildrenChanged DESIGNABLE false)

    Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQmlListProperty<QQuickState> states READ states DESIGNABLE false)

    Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQmlListProperty<QQuickTransition> transitions READ transitions DESIGNABLE false)

    Q_PROPERTY(QString state READ state WRITE setState NOTIFY stateChanged)

    Q_PROPERTY(QRectF childrenRect READ childrenRect NOTIFY childrenRectChanged DESIGNABLE false FINAL)

    Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQuickAnchors * anchors READ anchors DESIGNABLE false CONSTANT FINAL)

    Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQuickAnchorLine left READ left CONSTANT FINAL)

    Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQuickAnchorLine right READ right CONSTANT FINAL)

    Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQuickAnchorLine horizontalCenter READ horizontalCenter CONSTANT FINAL)

    Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQuickAnchorLine top READ top CONSTANT FINAL)

    Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQuickAnchorLine bottom READ bottom CONSTANT FINAL)

    Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQuickAnchorLine verticalCenter READ verticalCenter CONSTANT FINAL)

    Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQuickAnchorLine baseline READ baseline CONSTANT FINAL)

    Q_PROPERTY(qreal baselineOffset READ baselineOffset WRITE setBaselineOffset NOTIFY baselineOffsetChanged VIRTUAL)

    Q_PROPERTY(bool clip READ clip WRITE setClip NOTIFY clipChanged)

    Q_PROPERTY(bool focus READ hasFocus WRITE setFocus NOTIFY focusChanged FINAL)

    Q_PROPERTY(bool activeFocus READ hasActiveFocus NOTIFY activeFocusChanged FINAL)

    Q_PROPERTY(bool activeFocusOnTab READ activeFocusOnTab WRITE setActiveFocusOnTab NOTIFY activeFocusOnTabChanged FINAL REVISION(2, 1))

    Q_PROPERTY(Qt::FocusPolicy focusPolicy READ focusPolicy WRITE setFocusPolicy NOTIFY focusPolicyChanged VIRTUAL REVISION(6, 7))

    Q_PROPERTY(qreal rotation READ rotation WRITE setRotation NOTIFY rotationChanged VIRTUAL)

    Q_PROPERTY(qreal scale READ scale WRITE setScale NOTIFY scaleChanged)

    Q_PROPERTY(TransformOrigin transformOrigin READ transformOrigin WRITE setTransformOrigin NOTIFY transformOriginChanged)

    Q_PROPERTY(QPointF transformOriginPoint READ transformOriginPoint)  // deprecated - see QTBUG-26423

    Q_PROPERTY(QQmlListProperty<QQuickTransform> transform READ transform DESIGNABLE false FINAL)

    Q_PROPERTY(bool smooth READ smooth WRITE setSmooth NOTIFY smoothChanged)

    Q_PROPERTY(bool antialiasing READ antialiasing WRITE setAntialiasing NOTIFY antialiasingChanged RESET resetAntialiasing)

    Q_PROPERTY(qreal implicitWidth READ implicitWidth WRITE setImplicitWidth NOTIFY implicitWidthChanged VIRTUAL)

    Q_PROPERTY(qreal implicitHeight READ implicitHeight WRITE setImplicitHeight NOTIFY implicitHeightChanged VIRTUAL)

    Q_PROPERTY(QObject *containmentMask READ containmentMask WRITE setContainmentMask NOTIFY containmentMaskChanged REVISION(2, 11))

    // Value clamped to 4 bit range (see MutabilityGroup enum)

    Q_PROPERTY(int mutabilityGroup READ mutabilityGroup WRITE setMutabilityGroup NOTIFY mutabilityGroupChanged REVISION(6, 12))

#if QT_CONFIG(quick_shadereffect)

    Q_PRIVATE_PROPERTY(QQuickItem::d_func(), QQuickItemLayer *layer READ layer DESIGNABLE false CONSTANT FINAL)

#endif

    Q_CLASSINFO("DefaultProperty", "data")

    Q_CLASSINFO("ParentProperty", "parent")

    Q_CLASSINFO("qt_QmlJSWrapperFactoryMethod", "_q_createJSWrapper(QQmlV4ExecutionEnginePtr)")

    QML_NAMED_ELEMENT(Item)

    QML_ADDED_IN_VERSION(2, 0)

public:

    enum Flag {

        ItemClipsChildrenToShape  = 0x01,

#if QT_CONFIG(im)

        ItemAcceptsInputMethod    = 0x02,

#endif

        ItemIsFocusScope          = 0x04,

        ItemHasContents           = 0x08,

        ItemAcceptsDrops          = 0x10,

        ItemIsViewport            = 0x20,

        ItemObservesViewport      = 0x40,

        // Remember to increment the size of QQuickItemPrivate::flags

};

    Q_DECLARE_FLAGS(Flags, Flag)

    Q_FLAG(Flags)

    enum ItemChange {

        ItemChildAddedChange,      // value.item

        ItemChildRemovedChange,    // value.item

        ItemSceneChange,           // value.window

        ItemVisibleHasChanged,     // value.boolValue

        ItemParentHasChanged,      // value.item

        ItemOpacityHasChanged,     // value.realValue

        ItemActiveFocusHasChanged, // value.boolValue

        ItemRotationHasChanged,    // value.realValue

        ItemAntialiasingHasChanged, // value.boolValue

        ItemDevicePixelRatioHasChanged, // value.realValue

        ItemEnabledHasChanged,     // value.boolValue

        ItemScaleHasChanged,       // value.realValue

        ItemTransformHasChanged,   // value.item

};

    Q_ENUM(ItemChange)

    enum MutabilityGroup : int {

        AutoMutabilityGroup     = 0x0,

        StaticMutabilityGroup   = 0x1,

        ModerateMutabilityGroup = 0x8,

        DynamicMutabilityGroup  = 0xf,

        // Maximum 4 bits

};

    Q_ENUM(MutabilityGroup)

    union ItemChangeData {

        ItemChangeData(QQuickItem *v) : item(v) {}

        ItemChangeData(QQuickWindow *v) : window(v) {}

        ItemChangeData(qreal v) : realValue(v) {}

        ItemChangeData(bool v) : boolValue(v) {}

        QQuickItem *item;

        QQuickWindow *window;

        qreal realValue;

        bool boolValue;

};

    enum TransformOrigin {

        TopLeft, Top, TopRight,

        Left, Center, Right,

        BottomLeft, Bottom, BottomRight

};

    Q_ENUM(TransformOrigin)

    explicit QQuickItem(QQuickItem *parent = nullptr);

    ~QQuickItem() override;

    QQuickWindow *window() const;

    QQuickItem *parentItem() const;

    void setParentItem(QQuickItem *parent);

    void stackBefore(const QQuickItem *);

    void stackAfter(const QQuickItem *);

    QRectF childrenRect();

    QList<QQuickItem *> childItems() const;

    bool clip() const;

    void setClip(bool);

    QString state() const;

    void setState(const QString &);

    qreal baselineOffset() const;

    void setBaselineOffset(qreal);

    QQmlListProperty<QQuickTransform> transform();

    qreal x() const;

    qreal y() const;

    QPointF position() const;

    void setX(qreal);

    void setY(qreal);

    void setPosition(const QPointF &);

    QBindable<qreal> bindableX();

    QBindable<qreal> bindableY();

    qreal width() const;

    void setWidth(qreal);

    void resetWidth();

    void setImplicitWidth(qreal);

    qreal implicitWidth() const;

    QBindable<qreal> bindableWidth();

    qreal height() const;

    void setHeight(qreal);

    void resetHeight();

    void setImplicitHeight(qreal);

    qreal implicitHeight() const;

    QBindable<qreal> bindableHeight();

    QSizeF size() const;

    void setSize(const QSizeF &size);

    TransformOrigin transformOrigin() const;

    void setTransformOrigin(TransformOrigin);

    QPointF transformOriginPoint() const;

    void setTransformOriginPoint(const QPointF &);

    qreal z() const;

    void setZ(qreal);

    qreal rotation() const;

    void setRotation(qreal);

    qreal scale() const;

    void setScale(qreal);

    qreal opacity() const;

    void setOpacity(qreal);

    bool isVisible() const;

    void setVisible(bool);

    bool isEnabled() const;

    void setEnabled(bool);

    bool smooth() const;

    void setSmooth(bool);

    bool activeFocusOnTab() const;

    void setActiveFocusOnTab(bool);

    bool antialiasing() const;

    void setAntialiasing(bool);

    void resetAntialiasing();

    Flags flags() const;

    void setFlag(Flag flag, bool enabled = true);

    void setFlags(Flags flags);

    virtual QRectF boundingRect() const;

    virtual QRectF clipRect() const;

    QQuickItem *viewportItem() const;

    bool hasActiveFocus() const;

    bool hasFocus() const;

    void setFocus(bool);

    void setFocus(bool focus, Qt::FocusReason reason);

    bool isFocusScope() const;

    QQuickItem *scopedFocusItem() const;

    Qt::FocusPolicy focusPolicy() const;

    void setFocusPolicy(Qt::FocusPolicy policy);

    bool isAncestorOf(const QQuickItem *child) const;

    Qt::MouseButtons acceptedMouseButtons() const;

    void setAcceptedMouseButtons(Qt::MouseButtons buttons);

    bool acceptHoverEvents() const;

    void setAcceptHoverEvents(bool enabled);

    bool acceptTouchEvents() const;

    void setAcceptTouchEvents(bool accept);

#if QT_CONFIG(cursor)

    QCursor cursor() const;

    void setCursor(const QCursor &cursor);

    void unsetCursor();

#endif

    bool isUnderMouse() const;

    void grabMouse();

    void ungrabMouse();

    bool keepMouseGrab() const;

    void setKeepMouseGrab(bool);

    bool filtersChildMouseEvents() const;

    void setFiltersChildMouseEvents(bool filter);

    void grabTouchPoints(const QList<int> &ids);

    void ungrabTouchPoints();

    bool keepTouchGrab() const;

    void setKeepTouchGrab(bool);

    // implemented in qquickitemgrabresult.cpp

    Q_REVISION(2, 4) Q_INVOKABLE bool grabToImage(const QJSValue &callback, const QSize &targetSize = QSize());

    QSharedPointer<QQuickItemGrabResult> grabToImage(const QSize &targetSize = QSize());

    Q_INVOKABLE virtual bool contains(const QPointF &point) const;

    QObject *containmentMask() const;

    void setContainmentMask(QObject *mask);

    QTransform itemTransform(QQuickItem *, bool *) const;

    QPointF mapToScene(const QPointF &point) const;

    QRectF mapRectToItem(const QQuickItem *item, const QRectF &rect) const;

    QRectF mapRectToScene(const QRectF &rect) const;

    QPointF mapFromScene(const QPointF &point) const;

    QRectF mapRectFromItem(const QQuickItem *item, const QRectF &rect) const;

    QRectF mapRectFromScene(const QRectF &rect) const;

    void polish();

#if QT_DEPRECATED_SINCE(6, 5)

    QT_DEPRECATED_VERSION_X_6_5("Use typed overload or mapRectFromItem")

    void mapFromItem(QQmlV4FunctionPtr) const;

#endif

    Q_INVOKABLE QPointF mapFromItem(const QQuickItem *item, const QPointF &point) const;

    // overloads mainly exist for QML

    Q_INVOKABLE QPointF mapFromItem(const QQuickItem *item, qreal x, qreal y);

    Q_INVOKABLE QRectF mapFromItem(const QQuickItem *item, const QRectF &rect) const;

    Q_INVOKABLE QRectF mapFromItem(const QQuickItem *item, qreal x, qreal y, qreal width, qreal height) const;

#if QT_DEPRECATED_SINCE(6, 5)

    QT_DEPRECATED_VERSION_X_6_5("Use typed overload or mapRectToItem")

    void mapToItem(QQmlV4FunctionPtr) const;

#endif

    Q_INVOKABLE QPointF mapToItem(const QQuickItem *item, const QPointF &point) const;

    // overloads mainly exist for QML

    Q_INVOKABLE QPointF mapToItem(const QQuickItem *item, qreal x, qreal y);

    Q_INVOKABLE QRectF mapToItem(const QQuickItem *item, const QRectF &rect) const;

    Q_INVOKABLE QRectF mapToItem(const QQuickItem *item, qreal x, qreal y, qreal width, qreal height) const;

#if QT_DEPRECATED_SINCE(6, 5)

    QT_DEPRECATED_VERSION_X_6_5("Use the typed overload")

    Q_REVISION(2, 7) void mapFromGlobal(QQmlV4FunctionPtr) const;

#endif

    Q_REVISION(2, 7) Q_INVOKABLE QPointF mapFromGlobal(qreal x, qreal y) const;

    // overload mainly exists for QML

    Q_REVISION(2, 7) Q_INVOKABLE QPointF mapFromGlobal(const QPointF &point) const;

#if QT_DEPRECATED_SINCE(6, 5)

    QT_DEPRECATED_VERSION_X_6_5("Use the typed overload")

    Q_REVISION(2, 7) void mapToGlobal(QQmlV4FunctionPtr) const;

#endif

    Q_REVISION(2, 7) Q_INVOKABLE  QPointF mapToGlobal(qreal x, qreal y) const;

    // overload only exist for QML

    Q_REVISION(2, 7) Q_INVOKABLE  QPointF mapToGlobal(const QPointF &point) const;

    Q_INVOKABLE void forceActiveFocus();

    Q_INVOKABLE void forceActiveFocus(Qt::FocusReason reason);

    Q_REVISION(2, 1) Q_INVOKABLE QQuickItem *nextItemInFocusChain(bool forward = true);

    Q_INVOKABLE QQuickItem *childAt(qreal x, qreal y) const;

    Q_REVISION(6, 3) Q_INVOKABLE void ensurePolished();

    Q_REVISION(6, 3) Q_INVOKABLE void dumpItemTree() const;

#if QT_CONFIG(im)

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

#endif

    struct UpdatePaintNodeData {

       QSGTransformNode *transformNode;

    private:

       friend class QQuickWindowPrivate;

       UpdatePaintNodeData();

};

    virtual bool isTextureProvider() const;

    virtual QSGTextureProvider *textureProvider() const;

    // Value clamped to 4 bit range (see MutabilityGroup enum)

    void setMutabilityGroup(int mutabilityGroup);

    int mutabilityGroup() const;

public Q_SLOTS:

    void update();

Q_SIGNALS:

    void childrenRectChanged(const QRectF &);

    void baselineOffsetChanged(qreal);

    void stateChanged(const QString &);

    void focusChanged(bool);

    void activeFocusChanged(bool);

    Q_REVISION(6, 7) void focusPolicyChanged(Qt::FocusPolicy);

    Q_REVISION(2, 1) void activeFocusOnTabChanged(bool);

    void parentChanged(QQuickItem *);

    void transformOriginChanged(TransformOrigin);

    void smoothChanged(bool);

    void antialiasingChanged(bool);

    void clipChanged(bool);

    Q_REVISION(2, 1) void windowChanged(QQuickWindow* window);

    void childrenChanged();

    void opacityChanged();

    void enabledChanged();

    void visibleChanged();

    void visibleChildrenChanged();

    void rotationChanged();

    void scaleChanged();

    void xChanged();

    void yChanged();

    void widthChanged();

    void heightChanged();

    void zChanged();

    void implicitWidthChanged();

    void implicitHeightChanged();

    Q_REVISION(2, 11) void containmentMaskChanged();

    Q_REVISION(6, 0) void paletteChanged();

    Q_REVISION(6, 0) void paletteCreated();

    Q_REVISION(6, 12) void mutabilityGroupChanged(int group);

protected:

    bool event(QEvent *) override;

    bool isComponentComplete() const;

    virtual void itemChange(ItemChange, const ItemChangeData &);

    virtual void geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry);

#if QT_CONFIG(im)

    void updateInputMethod(Qt::InputMethodQueries queries = Qt::ImQueryInput);

#endif

    bool widthValid() const; // ### better name?

    bool heightValid() const; // ### better name?

    void setImplicitSize(qreal, qreal);

    void classBegin() override;

    void componentComplete() override;

    virtual void keyPressEvent(QKeyEvent *event);

    virtual void keyReleaseEvent(QKeyEvent *event);

#if QT_CONFIG(im)

    virtual void inputMethodEvent(QInputMethodEvent *);

#endif

    virtual void focusInEvent(QFocusEvent *);

    virtual void focusOutEvent(QFocusEvent *);

    virtual void mousePressEvent(QMouseEvent *event);

    virtual void mouseMoveEvent(QMouseEvent *event);

    virtual void mouseReleaseEvent(QMouseEvent *event);

    virtual void mouseDoubleClickEvent(QMouseEvent *event);

    virtual void mouseUngrabEvent(); // XXX todo - params?

    virtual void touchUngrabEvent();

#if QT_CONFIG(wheelevent)

    virtual void wheelEvent(QWheelEvent *event);

#endif

    virtual void touchEvent(QTouchEvent *event);

    virtual void hoverEnterEvent(QHoverEvent *event);

    virtual void hoverMoveEvent(QHoverEvent *event);

    virtual void hoverLeaveEvent(QHoverEvent *event);

#if QT_CONFIG(quick_draganddrop)

    virtual void dragEnterEvent(QDragEnterEvent *);

    virtual void dragMoveEvent(QDragMoveEvent *);

    virtual void dragLeaveEvent(QDragLeaveEvent *);

    virtual void dropEvent(QDropEvent *);

#endif

    virtual bool childMouseEventFilter(QQuickItem *, QEvent *);

#if QT_VERSION >= QT_VERSION_CHECK(7, 0, 0)

    virtual bool contextMenuEvent(QContextMenuEvent *event);

#endif

    virtual QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *);

    virtual void releaseResources();

    virtual void updatePolish();

    QQuickItem(QQuickItemPrivate &dd, QQuickItem *parent = nullptr);

private:

    Q_PRIVATE_SLOT(d_func(), void _q_resourceObjectDeleted(QObject *))

    Q_PRIVATE_SLOT(d_func(), quint64 _q_createJSWrapper(QQmlV4ExecutionEnginePtr))

    friend class QQuickWindowPrivate;

    friend class QQuickDeliveryAgentPrivate;

    friend class QSGRenderer;

    friend class QAccessibleQuickItem;

    friend class QQuickAccessibleAttached;

    friend class QQuickAnchorChanges;

#ifndef QT_NO_DEBUG_STREAM

    friend Q_QUICK_EXPORT QDebug operator<<(QDebug debug, QQuickItem *item);

#endif

    Q_DISABLE_COPY(QQuickItem)

    Q_DECLARE_PRIVATE(QQuickItem)

};

Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickItem::Flags)

#ifndef Q_QDOC

template <> inline QQuickItem *qobject_cast<QQuickItem *>(QObject *o)

    if (!o || !o->isQuickItemType())

        return nullptr;

    return static_cast<QQuickItem *>(o);

template <> inline const QQuickItem *qobject_cast<const QQuickItem *>(const QObject *o)

    if (!o || !o->isQuickItemType())

        return nullptr;

    return static_cast<const QQuickItem *>(o);

#endif // !Q_QDOC

#ifndef QT_NO_DEBUG_STREAM

QDebug Q_QUICK_EXPORT operator<<(QDebug debug,

#if QT_VERSION >= QT_VERSION_CHECK(7, 0, 0)

                                 const

#endif

                                 QQuickItem *item);

#endif // QT_NO_DEBUG_STREAM

QT_END_NAMESPACE

#endif // QQUICKITEM_H