qquickflickable_p_p.h

Go to the documentation of this file.

// 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_P_H
#define QQUICKFLICKABLE_P_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 "qquickflickable_p.h"
#include "qquickitem_p.h"
#include "qquickitemchangelistener_p.h"
#include "qquickflickablebehavior_p.h"
 
#include <QtQml/qqml.h>
#include <QtCore/qdatetime.h>
#include "qplatformdefs.h"
 
#include <private/qquicktimeline_p_p.h>
#include <private/qquickanimation_p_p.h>
#include <private/qquicktransitionmanager_p_p.h>
 
#if QT_CONFIG(accessibility)
#  include <QElapsedTimer>
#endif
 
#include <array>
 
QT_BEGIN_NAMESPACE
 
class QQuickFlickableVisibleArea;
class QQuickTransition;
class QQuickFlickableReboundTransition;
 
class Q_QUICK_EXPORT QQuickFlickablePrivate : public QQuickItemPrivate,
                                              public QSafeQuickItemChangeListener<QQuickFlickablePrivate>
{
    Q_DECLARE_PUBLIC(QQuickFlickable)
 
public:
    static inline QQuickFlickablePrivate *get(QQuickFlickable *o) { return o->d_func(); }
 
    QQuickFlickablePrivate();
    void init();
 
    struct Velocity : public QQuickTimeLineValue
    {
        Velocity(QQuickFlickablePrivate *p)
            : parent(p) {}
        void setValue(qreal v) override {
            if (v != value()) {
                QQuickTimeLineValue::setValue(v);
                parent->updateVelocity();
            }
        }
        QQuickFlickablePrivate *parent;
    };
 
    enum MovementReason { Other, SetIndex, Mouse };
 
    struct AxisData {
        AxisData(QQuickFlickablePrivate *fp, void (QQuickFlickablePrivate::*func)(qreal))
            : move(fp, func)
            , smoothVelocity(fp), atEnd(false), atBeginning(true)
            , transitionToSet(false)
            , fixingUp(false), inOvershoot(false), inRebound(false), moving(false), flicking(false)
            , flickingWhenDragBegan(false), dragging(false), extentsChanged(false)
            , explicitValue(false), contentPositionChangedExternallyDuringDrag(false)
            , minExtentDirty(true), maxExtentDirty(true)
        {}
 
        ~AxisData();
 
        void reset() {
            velocitySamples = 0;
            velocityWritePos = 0;
            dragStartOffset = 0;
            fixingUp = false;
            inOvershoot = false;
            contentPositionChangedExternallyDuringDrag = false;
        }
 
        void markExtentsDirty() {
            minExtentDirty = true;
            maxExtentDirty = true;
            extentsChanged = true;
        }
 
        void resetTransitionTo() {
            transitionTo = 0;
            transitionToSet = false;
        }
 
        void addVelocitySample(qreal v, qreal maxVelocity);
        void updateVelocity();
 
        QQuickTimeLineValueProxy<QQuickFlickablePrivate> move;
        QQuickFlickableReboundTransition *transitionToBounds = nullptr;
        qreal viewSize = -1;
        qreal pressPos = 0;
        qreal lastPos = 0;
        qreal dragStartOffset = 0;
        qreal dragMinBound = 0;
        qreal dragMaxBound = 0;
        qreal previousDragDelta = 0;
        qreal velocity = 0;
        qreal flickTarget = 0;
        qreal startMargin = 0;
        qreal endMargin = 0;
        qreal origin = 0;
        qreal overshoot = 0;
        qreal transitionTo = 0;
        qreal continuousFlickVelocity = 0;
        QElapsedTimer velocityTime;
        int vTime = 0;
        QQuickFlickablePrivate::Velocity smoothVelocity;
        std::array<qreal, QML_FLICK_SAMPLEBUFFER> velocityBuffer;
        int velocitySamples = 0;
        int velocityWritePos = 0;
        // bitfield
        uint atEnd : 1;
        uint atBeginning : 1;
        uint transitionToSet : 1;
        uint fixingUp : 1;
        uint inOvershoot : 1;
        uint inRebound : 1;
        uint moving : 1;
        uint flicking : 1;
        uint flickingWhenDragBegan : 1;
        uint dragging : 1;
        uint extentsChanged : 1;
        uint explicitValue : 1;
        uint contentPositionChangedExternallyDuringDrag : 1;
        // mutable portion of bitfield
        mutable uint minExtentDirty : 1;
        mutable uint maxExtentDirty : 1;
        // end bitfield
    };
 
    bool flickX(QEvent::Type eventType, qreal velocity);
    bool flickY(QEvent::Type eventType, qreal velocity);
    virtual bool flick(AxisData &data, qreal minExtent, qreal maxExtent, qreal vSize,
                       QQuickTimeLineCallback::Callback fixupCallback,
                       QEvent::Type eventType, qreal velocity);
    void flickingStarted(bool flickingH, bool flickingV);
 
    void fixupX();
    void fixupY();
    virtual void fixup(AxisData &data, qreal minExtent, qreal maxExtent);
    void adjustContentPos(AxisData &data, qreal toPos);
    void resetTimeline(AxisData &data);
    void clearTimeline();
 
    void updateBeginningEnd();
 
    bool isInnermostPressDelay(QQuickItem *item) const;
    void captureDelayedPress(QQuickItem *item, QPointerEvent *event);
    void clearDelayedPress();
    void replayDelayedPress();
 
    void setViewportX(qreal x);
    void setViewportY(qreal y);
 
    qreal overShootDistance(qreal velocity) const;
 
    void itemGeometryChanged(QQuickItem *, QQuickGeometryChange, const QRectF &) override;
 
    void draggingStarting();
    void draggingEnding();
 
    bool isViewMoving() const;
 
    void cancelInteraction();
 
    void addPointerHandler(QQuickPointerHandler *h) override;
 
    virtual bool wantsPointerEvent(const QPointerEvent *) { return true; }
 
public:
    QQuickItem *contentItem;
 
    AxisData hData;
    AxisData vData;
 
    MovementReason moveReason = Other;
 
    QQuickTimeLine timeline;
    bool hMoved : 1;
    bool vMoved : 1;
    bool stealGrab : 1;
    bool pressed : 1;
    bool scrollingPhase : 1;
    bool interactive : 1;
    bool calcVelocity : 1;
    bool pixelAligned : 1;
    bool syncDrag : 1;
    Qt::MouseButtons acceptedButtons = Qt::LeftButton;
    QElapsedTimer timer;
    qint64 lastPosTime;
    qint64 lastPressTime;
    QPointF lastPos;
    QPointF pressPos;
    QVector2D accumulatedWheelPixelDelta;
    qreal deceleration;
    qreal wheelDeceleration;
    qreal maxVelocity;
    QPointerEvent *delayedPressEvent;
    QBasicTimer delayedPressTimer;
    int pressDelay;
    int fixupDuration;
    qreal flickBoost;
    qreal initialWheelFlickDistance;
 
    enum FixupMode { Normal, Immediate, ExtentChanged };
    FixupMode fixupMode;
 
    static void fixupY_callback(void *);
    static void fixupX_callback(void *);
 
    void updateVelocity();
    int vTime;
    QQuickTimeLine velocityTimeline;
    QQuickFlickableVisibleArea *visibleArea;
    QQuickFlickable::FlickableDirection flickableDirection;
    QQuickFlickable::BoundsBehavior boundsBehavior;
    QQuickFlickable::BoundsMovement boundsMovement;
    QQuickTransition *rebound;
 
    void viewportAxisMoved(AxisData &data, qreal minExtent, qreal maxExtent,
                       QQuickTimeLineCallback::Callback fixupCallback);
 
    void handlePressEvent(QPointerEvent *);
    void handleMoveEvent(QPointerEvent *);
    void handleReleaseEvent(QPointerEvent *);
    bool buttonsAccepted(const QSinglePointEvent *event);
 
    void maybeBeginDrag(qint64 currentTimestamp, const QPointF &pressPosn,
                        Qt::MouseButtons buttons = Qt::NoButton);
    void drag(qint64 currentTimestamp, QEvent::Type eventType, const QPointF &localPos,
              const QVector2D &deltas, bool overThreshold, bool momentum,
              bool velocitySensitiveOverBounds, const QVector2D &velocity);
 
    QVector2D firstPointLocalVelocity(QPointerEvent *event);
    qint64 computeCurrentTime(QInputEvent *event) const;
 
    // flickableData property
    static void data_append(QQmlListProperty<QObject> *, QObject *);
    static qsizetype data_count(QQmlListProperty<QObject> *);
    static QObject *data_at(QQmlListProperty<QObject> *, qsizetype);
    static void data_clear(QQmlListProperty<QObject> *);
 
#if QT_CONFIG(accessibility)
private:
    QElapsedTimer m_scrollEventTimer;
#endif
};
 
class Q_QUICK_EXPORT QQuickFlickableVisibleArea : public QObject
{
    Q_OBJECT
 
    Q_PROPERTY(qreal xPosition READ xPosition NOTIFY xPositionChanged FINAL)
    Q_PROPERTY(qreal yPosition READ yPosition NOTIFY yPositionChanged FINAL)
    Q_PROPERTY(qreal widthRatio READ widthRatio NOTIFY widthRatioChanged FINAL)
    Q_PROPERTY(qreal heightRatio READ heightRatio NOTIFY heightRatioChanged FINAL)
    QML_ANONYMOUS
    QML_ADDED_IN_VERSION(2, 0)
 
public:
    QQuickFlickableVisibleArea(QQuickFlickable *parent=nullptr);
 
    qreal xPosition() const;
    qreal widthRatio() const;
    qreal yPosition() const;
    qreal heightRatio() const;
 
    void updateVisible();
 
Q_SIGNALS:
    void xPositionChanged(qreal xPosition);
    void yPositionChanged(qreal yPosition);
    void widthRatioChanged(qreal widthRatio);
    void heightRatioChanged(qreal heightRatio);
 
private:
    QQuickFlickable *flickable;
    qreal m_xPosition;
    qreal m_widthRatio;
    qreal m_yPosition;
    qreal m_heightRatio;
};
 
QT_END_NAMESPACE
 
#endif // QQUICKFLICKABLE_P_P_H