qquickflickable_p.h

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

Enable keyboard shortcuts

Revision control

Copy as Markdown

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

#define QQUICKFLICKABLE_P_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include "qquickitem.h"

#include <private/qtquickglobal_p.h>

#include <QtCore/qpoint.h>

QT_BEGIN_NAMESPACE

class QQuickFlickablePrivate;

class QQuickFlickableVisibleArea;

class QPointerEvent;

class Q_QUICK_EXPORT QQuickFlickable : public QQuickItem

    Q_OBJECT

    Q_PROPERTY(qreal contentWidth READ contentWidth WRITE setContentWidth NOTIFY contentWidthChanged VIRTUAL)

    Q_PROPERTY(qreal contentHeight READ contentHeight WRITE setContentHeight NOTIFY contentHeightChanged VIRTUAL)

    Q_PROPERTY(qreal contentX READ contentX WRITE setContentX NOTIFY contentXChanged)

    Q_PROPERTY(qreal contentY READ contentY WRITE setContentY NOTIFY contentYChanged)

    Q_PROPERTY(QQuickItem *contentItem READ contentItem CONSTANT)

    Q_PROPERTY(qreal topMargin READ topMargin WRITE setTopMargin NOTIFY topMarginChanged)

    Q_PROPERTY(qreal bottomMargin READ bottomMargin WRITE setBottomMargin NOTIFY bottomMarginChanged)

    Q_PROPERTY(qreal originY READ originY NOTIFY originYChanged)

    Q_PROPERTY(qreal leftMargin READ leftMargin WRITE setLeftMargin NOTIFY leftMarginChanged)

    Q_PROPERTY(qreal rightMargin READ rightMargin WRITE setRightMargin NOTIFY rightMarginChanged)

    Q_PROPERTY(qreal originX READ originX NOTIFY originXChanged)

    Q_PROPERTY(qreal horizontalVelocity READ horizontalVelocity NOTIFY horizontalVelocityChanged)

    Q_PROPERTY(qreal verticalVelocity READ verticalVelocity NOTIFY verticalVelocityChanged)

    Q_PROPERTY(BoundsBehavior boundsBehavior READ boundsBehavior WRITE setBoundsBehavior NOTIFY boundsBehaviorChanged)

    Q_PROPERTY(BoundsMovement boundsMovement READ boundsMovement WRITE setBoundsMovement NOTIFY boundsMovementChanged REVISION(2, 10))

    Q_PROPERTY(QQuickTransition *rebound READ rebound WRITE setRebound NOTIFY reboundChanged)

    Q_PROPERTY(qreal maximumFlickVelocity READ maximumFlickVelocity WRITE setMaximumFlickVelocity NOTIFY maximumFlickVelocityChanged)

    Q_PROPERTY(qreal flickDeceleration READ flickDeceleration WRITE setFlickDeceleration NOTIFY flickDecelerationChanged)

    Q_PROPERTY(bool moving READ isMoving NOTIFY movingChanged)

    Q_PROPERTY(bool movingHorizontally READ isMovingHorizontally NOTIFY movingHorizontallyChanged)

    Q_PROPERTY(bool movingVertically READ isMovingVertically NOTIFY movingVerticallyChanged)

    Q_PROPERTY(bool flicking READ isFlicking NOTIFY flickingChanged)

    Q_PROPERTY(bool flickingHorizontally READ isFlickingHorizontally NOTIFY flickingHorizontallyChanged)

    Q_PROPERTY(bool flickingVertically READ isFlickingVertically NOTIFY flickingVerticallyChanged)

    Q_PROPERTY(bool dragging READ isDragging NOTIFY draggingChanged)

    Q_PROPERTY(bool draggingHorizontally READ isDraggingHorizontally NOTIFY draggingHorizontallyChanged)

    Q_PROPERTY(bool draggingVertically READ isDraggingVertically NOTIFY draggingVerticallyChanged)

    Q_PROPERTY(FlickableDirection flickableDirection READ flickableDirection WRITE setFlickableDirection NOTIFY flickableDirectionChanged)

    Q_PROPERTY(bool interactive READ isInteractive WRITE setInteractive NOTIFY interactiveChanged)

    Q_PROPERTY(int pressDelay READ pressDelay WRITE setPressDelay NOTIFY pressDelayChanged)

    Q_PROPERTY(bool atXEnd READ isAtXEnd NOTIFY atXEndChanged)

    Q_PROPERTY(bool atYEnd READ isAtYEnd NOTIFY atYEndChanged)

    Q_PROPERTY(bool atXBeginning READ isAtXBeginning NOTIFY atXBeginningChanged)

    Q_PROPERTY(bool atYBeginning READ isAtYBeginning NOTIFY atYBeginningChanged)

    Q_PROPERTY(QQuickFlickableVisibleArea *visibleArea READ visibleArea CONSTANT)

    Q_PROPERTY(bool pixelAligned READ pixelAligned WRITE setPixelAligned NOTIFY pixelAlignedChanged)

    Q_PROPERTY(bool synchronousDrag READ synchronousDrag WRITE setSynchronousDrag NOTIFY synchronousDragChanged REVISION(2, 12))

    Q_PROPERTY(qreal horizontalOvershoot READ horizontalOvershoot NOTIFY horizontalOvershootChanged REVISION(2, 9))

    Q_PROPERTY(qreal verticalOvershoot READ verticalOvershoot NOTIFY verticalOvershootChanged REVISION(2, 9))

    Q_PROPERTY(Qt::MouseButtons acceptedButtons READ acceptedButtons WRITE setAcceptedButtons NOTIFY acceptedButtonsChanged REVISION(6, 9) FINAL)

    Q_PROPERTY(QQmlListProperty<QObject> flickableData READ flickableData)

    Q_PROPERTY(QQmlListProperty<QQuickItem> flickableChildren READ flickableChildren)

    Q_CLASSINFO("DefaultProperty", "flickableData")

    QML_NAMED_ELEMENT(Flickable)

    QML_ADDED_IN_VERSION(2, 0)

public:

    QQuickFlickable(QQuickItem *parent=nullptr);

    ~QQuickFlickable() override;

    QQmlListProperty<QObject> flickableData();

    QQmlListProperty<QQuickItem> flickableChildren();

    enum BoundsBehaviorFlag {

        StopAtBounds = 0x0,

        DragOverBounds = 0x1,

        OvershootBounds = 0x2,

        DragAndOvershootBounds = DragOverBounds | OvershootBounds

};

    Q_DECLARE_FLAGS(BoundsBehavior, BoundsBehaviorFlag)

    Q_FLAG(BoundsBehavior)

    BoundsBehavior boundsBehavior() const;

    void setBoundsBehavior(BoundsBehavior);

    enum BoundsMovement {

        // StopAtBounds = 0x0,

        FollowBoundsBehavior = 0x1

};

    Q_ENUM(BoundsMovement)

    BoundsMovement boundsMovement() const;

    void setBoundsMovement(BoundsMovement movement);

    QQuickTransition *rebound() const;

    void setRebound(QQuickTransition *transition);

    qreal contentWidth() const;

    void setContentWidth(qreal);

    qreal contentHeight() const;

    void setContentHeight(qreal);

    qreal contentX() const;

    virtual void setContentX(qreal pos);

    qreal contentY() const;

    virtual void setContentY(qreal pos);

    qreal topMargin() const;

    void setTopMargin(qreal m);

    qreal bottomMargin() const;

    void setBottomMargin(qreal m);

    qreal leftMargin() const;

    void setLeftMargin(qreal m);

    qreal rightMargin() const;

    void setRightMargin(qreal m);

    virtual qreal originY() const;

    virtual qreal originX() const;

    bool isMoving() const;

    bool isMovingHorizontally() const;

    bool isMovingVertically() const;

    bool isFlicking() const;

    bool isFlickingHorizontally() const;

    bool isFlickingVertically() const;

    bool isDragging() const;

    bool isDraggingHorizontally() const;

    bool isDraggingVertically() const;

    int pressDelay() const;

    void setPressDelay(int delay);

    qreal maximumFlickVelocity() const;

    void setMaximumFlickVelocity(qreal);

    qreal flickDeceleration() const;

    void setFlickDeceleration(qreal);

    bool isInteractive() const;

    void setInteractive(bool);

    qreal horizontalVelocity() const;

    qreal verticalVelocity() const;

    bool isAtXEnd() const;

    bool isAtXBeginning() const;

    bool isAtYEnd() const;

    bool isAtYBeginning() const;

    QQuickItem *contentItem() const;

    enum FlickableDirection { AutoFlickDirection=0x0, HorizontalFlick=0x1, VerticalFlick=0x2, HorizontalAndVerticalFlick=0x3,

                              AutoFlickIfNeeded=0xc };

    Q_ENUM(FlickableDirection)

    FlickableDirection flickableDirection() const;

    void setFlickableDirection(FlickableDirection);

    bool pixelAligned() const;

    void setPixelAligned(bool align);

    bool synchronousDrag() const;

    void setSynchronousDrag(bool v);

    Qt::MouseButtons acceptedButtons() const;

    void setAcceptedButtons(Qt::MouseButtons buttons);

    qreal horizontalOvershoot() const;

    qreal verticalOvershoot() const;

    enum PositionModeFlag {

        AlignLeft = Qt::AlignLeft,

        AlignRight = Qt::AlignRight,

        AlignHCenter = Qt::AlignHCenter,

        AlignTop = Qt::AlignTop,

        AlignBottom = Qt::AlignBottom,

        AlignVCenter = Qt::AlignVCenter,

        AlignCenter = AlignVCenter | AlignHCenter,

        Visible = 0x01000,

        Contain = 0x02000

};

    Q_DECLARE_FLAGS(PositionMode, PositionModeFlag)

    Q_FLAG(PositionMode)

    Q_INVOKABLE void resizeContent(qreal w, qreal h, QPointF center);

    Q_INVOKABLE void returnToBounds();

    Q_INVOKABLE void flick(qreal xVelocity, qreal yVelocity);

    Q_INVOKABLE void cancelFlick();

    Q_REVISION(6, 11) Q_INVOKABLE void positionViewAtChild(QQuickItem *child, PositionMode mode, const QPointF &offset = QPointF());

    Q_REVISION(6, 11) Q_INVOKABLE void flickToChild(QQuickItem *child, PositionMode mode, const QPointF &offset = QPointF());

    Q_REVISION(6, 11) Q_INVOKABLE void flickTo(const QPointF &position);

Q_SIGNALS:

    void contentWidthChanged();

    void contentHeightChanged();

    void contentXChanged();

    void contentYChanged();

    void topMarginChanged();

    void bottomMarginChanged();

    void leftMarginChanged();

    void rightMarginChanged();

    void originYChanged();

    void originXChanged();

    void movingChanged();

    void movingHorizontallyChanged();

    void movingVerticallyChanged();

    void flickingChanged();

    void flickingHorizontallyChanged();

    void flickingVerticallyChanged();

    void draggingChanged();

    void draggingHorizontallyChanged();

    void draggingVerticallyChanged();

    void horizontalVelocityChanged();

    void verticalVelocityChanged();

    void isAtBoundaryChanged();

    void flickableDirectionChanged();

    void interactiveChanged();

    void boundsBehaviorChanged();

    Q_REVISION(2, 10) void boundsMovementChanged();

    void reboundChanged();

    void maximumFlickVelocityChanged();

    void flickDecelerationChanged();

    void pressDelayChanged();

    void movementStarted();

    void movementEnded();

    void flickStarted();

    void flickEnded();

    void dragStarted();

    void dragEnded();

    void pixelAlignedChanged();

    Q_REVISION(2, 12) void synchronousDragChanged();

    Q_REVISION(2, 9) void horizontalOvershootChanged();

    Q_REVISION(2, 9) void verticalOvershootChanged();

    // The next four signals should be marked as Q_REVISION(2, 12). See QTBUG-71243

    void atXEndChanged();

    void atYEndChanged();

    void atXBeginningChanged();

    void atYBeginningChanged();

    Q_REVISION(6, 9) void acceptedButtonsChanged();

protected:

    bool childMouseEventFilter(QQuickItem *, QEvent *) override;

    void mousePressEvent(QMouseEvent *event) override;

    void mouseMoveEvent(QMouseEvent *event) override;

    void mouseReleaseEvent(QMouseEvent *event) override;

    void touchEvent(QTouchEvent *event) override;

#if QT_CONFIG(wheelevent)

    void wheelEvent(QWheelEvent *event) override;

#endif

    void timerEvent(QTimerEvent *event) override;

    QQuickFlickableVisibleArea *visibleArea();

protected Q_SLOTS:

    void movementStarting();

    void movementEnding();

    void movementEnding(bool hMovementEnding, bool vMovementEnding);

    void velocityTimelineCompleted();

    void timelineCompleted();

protected:

    virtual qreal minXExtent() const;

    virtual qreal minYExtent() const;

    virtual qreal maxXExtent() const;

    virtual qreal maxYExtent() const;

    qreal vWidth() const;

    qreal vHeight() const;

    void componentComplete() override;

    virtual void viewportMoved(Qt::Orientations orient);

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

    void mouseUngrabEvent() override;

    bool filterPointerEvent(QQuickItem *receiver, QPointerEvent *event);

    bool xflick() const;

    bool yflick() const;

    QPointF computePosition(QPointF currentPosition, QRectF itemRect, PositionMode mode,

                            const QPointF &offset = QPointF()) const;

protected:

    QQuickFlickable(QQuickFlickablePrivate &dd, QQuickItem *parent);

private:

    Q_DISABLE_COPY(QQuickFlickable)

    Q_DECLARE_PRIVATE(QQuickFlickable)

    friend class QQuickFlickableVisibleArea;

    friend class QQuickFlickableReboundTransition;

};

Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickFlickable::PositionMode)

QT_END_NAMESPACE

#endif // QQUICKFLICKABLE_P_H