qquickpathview_p.h

++ // 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

++ // Qt-Security score:significant reason:default

++

++ #ifndef QQUICKPATHVIEW_P_H

++ #define QQUICKPATHVIEW_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 <private/qtquickglobal_p.h>

++

++ QT_REQUIRE_CONFIG(quick_pathview);

++

++ #include "qquickitem.h"

++

++ #include <private/qtquickglobal_p.h>

++ #include <private/qquickpath_p.h>

++

++ QT_BEGIN_NAMESPACE

++

++ class QQmlChangeSet;

++ class QQmlComponent;

++

++ class QQuickPathViewPrivate;

++ class QQuickPathViewAttached;

++ class Q_QUICK_EXPORT QQuickPathView : public QQuickItem

++ {

++     Q_OBJECT

++

++     Q_PROPERTY(QVariant model READ model WRITE setModel NOTIFY modelChanged)

++     Q_PROPERTY(QQuickPath *path READ path WRITE setPath NOTIFY pathChanged)

++     Q_PROPERTY(int currentIndex READ currentIndex WRITE setCurrentIndex NOTIFY currentIndexChanged)

++     Q_PROPERTY(QQuickItem *currentItem READ currentItem NOTIFY currentItemChanged)

++     Q_PROPERTY(qreal offset READ offset WRITE setOffset NOTIFY offsetChanged)

++

++     Q_PROPERTY(QQmlComponent *highlight READ highlight WRITE setHighlight NOTIFY highlightChanged)

++     Q_PROPERTY(QQuickItem *highlightItem READ highlightItem NOTIFY highlightItemChanged)

++

++     Q_PROPERTY(qreal preferredHighlightBegin READ preferredHighlightBegin WRITE setPreferredHighlightBegin NOTIFY preferredHighlightBeginChanged)

++     Q_PROPERTY(qreal preferredHighlightEnd READ preferredHighlightEnd WRITE setPreferredHighlightEnd NOTIFY preferredHighlightEndChanged)

++     Q_PROPERTY(HighlightRangeMode highlightRangeMode READ highlightRangeMode WRITE setHighlightRangeMode NOTIFY highlightRangeModeChanged)

++     Q_PROPERTY(int highlightMoveDuration READ highlightMoveDuration WRITE setHighlightMoveDuration NOTIFY highlightMoveDurationChanged)

++

++     Q_PROPERTY(qreal dragMargin READ dragMargin WRITE setDragMargin NOTIFY dragMarginChanged)

++     Q_PROPERTY(qreal maximumFlickVelocity READ maximumFlickVelocity WRITE setMaximumFlickVelocity NOTIFY maximumFlickVelocityChanged)

++     Q_PROPERTY(qreal flickDeceleration READ flickDeceleration WRITE setFlickDeceleration NOTIFY flickDecelerationChanged)

++     Q_PROPERTY(bool interactive READ isInteractive WRITE setInteractive NOTIFY interactiveChanged)

++

++     Q_PROPERTY(bool moving READ isMoving NOTIFY movingChanged)

++     Q_PROPERTY(bool flicking READ isFlicking NOTIFY flickingChanged)

++     Q_PROPERTY(bool dragging READ isDragging NOTIFY draggingChanged)

++

++     Q_PROPERTY(int count READ count NOTIFY countChanged)

++     Q_PROPERTY(QQmlComponent *delegate READ delegate WRITE setDelegate NOTIFY delegateChanged)

++     Q_PROPERTY(int pathItemCount READ pathItemCount WRITE setPathItemCount RESET resetPathItemCount NOTIFY pathItemCountChanged)

++     Q_PROPERTY(SnapMode snapMode READ snapMode WRITE setSnapMode NOTIFY snapModeChanged)

++     Q_PROPERTY(MovementDirection movementDirection READ movementDirection WRITE setMovementDirection NOTIFY movementDirectionChanged REVISION(2, 7))

++

++     Q_PROPERTY(int cacheItemCount READ cacheItemCount WRITE setCacheItemCount NOTIFY cacheItemCountChanged)

++     QML_NAMED_ELEMENT(PathView)

++     QML_ADDED_IN_VERSION(2, 0)

++     QML_ATTACHED(QQuickPathViewAttached)

++

++ public:

++     QQuickPathView(QQuickItem *parent = nullptr);

++     virtual ~QQuickPathView();

++

++     QVariant model() const;

++     void setModel(const QVariant &);

++

++     QQuickPath *path() const;

++     void setPath(QQuickPath *);

++

++     int currentIndex() const;

++     void setCurrentIndex(int idx);

++

++     QQuickItem *currentItem() const;

++

++     qreal offset() const;

++     void setOffset(qreal offset);

++

++     QQmlComponent *highlight() const;

++     void setHighlight(QQmlComponent *highlight);

++     QQuickItem *highlightItem() const;

++

++     enum HighlightRangeMode { NoHighlightRange, ApplyRange, StrictlyEnforceRange };

++     Q_ENUM(HighlightRangeMode)

++     HighlightRangeMode highlightRangeMode() const;

++     void setHighlightRangeMode(HighlightRangeMode mode);

++

++     qreal preferredHighlightBegin() const;

++     void setPreferredHighlightBegin(qreal);

++

++     qreal preferredHighlightEnd() const;

++     void setPreferredHighlightEnd(qreal);

++

++     int highlightMoveDuration() const;

++     void setHighlightMoveDuration(int);

++

++     qreal dragMargin() const;

++     void setDragMargin(qreal margin);

++

++     qreal flickDeceleration() const;

++     void setFlickDeceleration(qreal dec);

++

++     qreal maximumFlickVelocity() const;

++     void setMaximumFlickVelocity(qreal);

++

++     bool isInteractive() const;

++     void setInteractive(bool);

++

++     bool isMoving() const;

++     bool isFlicking() const;

++     bool isDragging() const;

++

++     int count() const;

++

++     QQmlComponent *delegate() const;

++     void setDelegate(QQmlComponent *);

++

++     int pathItemCount() const;

++     void setPathItemCount(int);

++     void resetPathItemCount();

++

++     int cacheItemCount() const;

++     void setCacheItemCount(int);

++

++     enum SnapMode { NoSnap, SnapToItem, SnapOneItem };

++     Q_ENUM(SnapMode)

++     SnapMode snapMode() const;

++     void setSnapMode(SnapMode mode);

++

++     enum MovementDirection { Shortest, Negative, Positive };

++     Q_ENUM(MovementDirection)

++     MovementDirection movementDirection() const;

++     void setMovementDirection(MovementDirection dir);

++

++     enum PositionMode { Beginning, Center, End, Contain=4, SnapPosition }; // 3 == Visible in other views

++     Q_ENUM(PositionMode)

++     Q_INVOKABLE void positionViewAtIndex(int index, int mode);

++     Q_INVOKABLE int indexAt(qreal x, qreal y) const;

++     Q_INVOKABLE QQuickItem *itemAt(qreal x, qreal y) const;

++     Q_REVISION(2, 13) Q_INVOKABLE QQuickItem *itemAtIndex(int index) const;

++

++     static QQuickPathViewAttached *qmlAttachedProperties(QObject *);

++

++ public Q_SLOTS:

++     void incrementCurrentIndex();

++     void decrementCurrentIndex();

++

++ Q_SIGNALS:

++     void currentIndexChanged();

++     void currentItemChanged();

++     void offsetChanged();

++     void modelChanged();

++     void countChanged();

++     void pathChanged();

++     void preferredHighlightBeginChanged();

++     void preferredHighlightEndChanged();

++     void highlightRangeModeChanged();

++     void dragMarginChanged();

++     void snapPositionChanged();

++     void delegateChanged();

++     void pathItemCountChanged();

++     void maximumFlickVelocityChanged();

++     void flickDecelerationChanged();

++     void interactiveChanged();

++     void movingChanged();

++     void flickingChanged();

++     void draggingChanged();

++     void highlightChanged();

++     void highlightItemChanged();

++     void highlightMoveDurationChanged();

++     void movementStarted();

++     void movementEnded();

++     Q_REVISION(2, 7) void movementDirectionChanged();

++     void flickStarted();

++     void flickEnded();

++     void dragStarted();

++     void dragEnded();

++     void snapModeChanged();

++     void cacheItemCountChanged();

++

++ protected:

++     void updatePolish() override;

++     void mousePressEvent(QMouseEvent *event) override;

++     void mouseMoveEvent(QMouseEvent *event) override;

++     void mouseReleaseEvent(QMouseEvent *) override;

++     bool childMouseEventFilter(QQuickItem *, QEvent *) override;

++     void mouseUngrabEvent() override;

++     void componentComplete() override;

++

++ private Q_SLOTS:

++     void refill();

++     void ticked();

++     void movementEnding();

++     void modelUpdated(const QQmlChangeSet &changeSet, bool reset);

++     void createdItem(int index, QObject *item);

++     void initItem(int index, QObject *item);

++     void destroyingItem(QObject *item);

++     void pathUpdated();

++

++ private:

++     friend class QQuickPathViewAttached;

++     Q_DISABLE_COPY(QQuickPathView)

++     Q_DECLARE_PRIVATE(QQuickPathView)

++ };

++

++ class QQmlOpenMetaObject;

++ class QQuickPathViewAttached : public QObject

++ {

++     Q_OBJECT

++

++     Q_PROPERTY(QQuickPathView *view READ view CONSTANT FINAL)

++     Q_PROPERTY(bool isCurrentItem READ isCurrentItem NOTIFY currentItemChanged FINAL)

++     Q_PROPERTY(bool onPath READ isOnPath NOTIFY pathChanged FINAL)

++

++ public:

++     QQuickPathViewAttached(QObject *parent);

++     ~QQuickPathViewAttached();

++

++     QQuickPathView *view() const { return m_view; }

++

++     bool isCurrentItem() const { return m_isCurrent; }

++     void setIsCurrentItem(bool c) {

++         if (m_isCurrent != c) {

++             m_isCurrent = c;

++             Q_EMIT currentItemChanged();

++         }

++     }

++

++     QVariant value(const QByteArray &name) const;

++     void setValue(const QByteArray &name, const QVariant &val);

++

++     bool isOnPath() const { return m_onPath; }

++     void setOnPath(bool on) {

++         if (on != m_onPath) {

++             m_onPath = on;

++             Q_EMIT pathChanged();

++         }

++     }

++     qreal m_percent;

++

++ Q_SIGNALS:

++     void currentItemChanged();

++     void pathChanged();

++

++ private:

++     friend class QQuickPathViewPrivate;

++     friend class QQuickPathView;

++     QQuickPathView *m_view;

++     QQmlOpenMetaObject *m_metaobject;

++     bool m_onPath : 1;

++     bool m_isCurrent : 1;

++ };

++

++

++ QT_END_NAMESPACE

++

++ #endif // QQUICKPATHVIEW_P_H

Revision control