Revision control
Copy as Markdown
// Copyright (C) 2017 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
#include "qquickpageindicator_p.h"
#include "qquickcontrol_p_p.h"
#include <QtCore/qmath.h>
#include <QtQuick/private/qquickitem_p.h>
QT_BEGIN_NAMESPACE
/*!
\qmltype PageIndicator
\inherits Control
//! \nativetype QQuickPageIndicator
\inqmlmodule QtQuick.Controls
\since 5.7
\ingroup qtquickcontrols-indicators
\brief Indicates the currently active page.
PageIndicator is used to indicate the currently active page
in a container of multiple pages. PageIndicator consists of
delegate items that present pages.
\image qtquickcontrols-pageindicator.png
{Page indicator showing current page position}
\code
Column {
StackLayout {
id: stackLayout
Page {
// ...
}
Page {
// ...
}
Page {
// ...
}
}
PageIndicator {
currentIndex: stackLayout.currentIndex
count: stackLayout.count
}
}
\endcode
\sa SwipeView, {Customizing PageIndicator}, {Indicator Controls}
*/
class QQuickPageIndicatorPrivate : public QQuickControlPrivate
{
Q_DECLARE_PUBLIC(QQuickPageIndicator)
public:
bool handlePress(const QPointF &point, ulong timestamp) override;
bool handleMove(const QPointF &point, ulong timestamp) override;
bool handleRelease(const QPointF &point, ulong timestamp) override;
void handleUngrab() override;
QQuickItem *itemAt(const QPointF &pos) const;
void updatePressed(bool pressed, const QPointF &pos = QPointF());
void setContextProperty(QQuickItem *item, const QString &name, const QVariant &value);
void itemChildAdded(QQuickItem *, QQuickItem *child) override;
int count = 0;
int currentIndex = 0;
bool interactive = false;
QQmlComponent *delegate = nullptr;
QQuickItem *pressedItem = nullptr;
};
bool QQuickPageIndicatorPrivate::handlePress(const QPointF &point, ulong timestamp)
{
QQuickControlPrivate::handlePress(point, timestamp);
if (interactive) {
updatePressed(true, point);
return true;
}
return false;
}
bool QQuickPageIndicatorPrivate::handleMove(const QPointF &point, ulong timestamp)
{
QQuickControlPrivate::handleMove(point, timestamp);
if (interactive) {
updatePressed(true, point);
return true;
}
return false;
}
bool QQuickPageIndicatorPrivate::handleRelease(const QPointF &point, ulong timestamp)
{
Q_Q(QQuickPageIndicator);
QQuickControlPrivate::handleRelease(point, timestamp);
if (interactive) {
if (pressedItem && contentItem)
q->setCurrentIndex(contentItem->childItems().indexOf(pressedItem));
updatePressed(false);
return true;
}
return false;
}
void QQuickPageIndicatorPrivate::handleUngrab()
{
QQuickControlPrivate::handleUngrab();
if (interactive)
updatePressed(false);
}
QQuickItem *QQuickPageIndicatorPrivate::itemAt(const QPointF &pos) const
{
Q_Q(const QQuickPageIndicator);
if (!contentItem || !q->contains(pos))
return nullptr;
QPointF contentPos = q->mapToItem(contentItem, pos);
QQuickItem *item = contentItem->childAt(contentPos.x(), contentPos.y());
while (item && item->parentItem() != contentItem)
item = item->parentItem();
if (item && !QQuickItemPrivate::get(item)->isTransparentForPositioner())
return item;
// find the nearest
qreal distance = qInf();
QQuickItem *nearest = nullptr;
const auto childItems = contentItem->childItems();
for (QQuickItem *child : childItems) {
if (QQuickItemPrivate::get(child)->isTransparentForPositioner())
continue;
QPointF center = child->boundingRect().center();
QPointF pt = contentItem->mapToItem(child, contentPos);
qreal len = QLineF(center, pt).length();
if (len < distance) {
distance = len;
nearest = child;
}
}
return nearest;
}
void QQuickPageIndicatorPrivate::updatePressed(bool pressed, const QPointF &pos)
{
QQuickItem *prevItem = pressedItem;
pressedItem = pressed ? itemAt(pos) : nullptr;
if (prevItem != pressedItem) {
setContextProperty(prevItem, QStringLiteral("pressed"), false);
setContextProperty(pressedItem, QStringLiteral("pressed"), pressed);
}
}
void QQuickPageIndicatorPrivate::setContextProperty(QQuickItem *item, const QString &name, const QVariant &value)
{
QQmlContext *context = qmlContext(item);
if (context && context->isValid()) {
context = context->parentContext();
if (context && context->isValid())
context->setContextProperty(name, value);
}
}
void QQuickPageIndicatorPrivate::itemChildAdded(QQuickItem *, QQuickItem *child)
{
if (!QQuickItemPrivate::get(child)->isTransparentForPositioner())
setContextProperty(child, QStringLiteral("pressed"), false);
}
QQuickPageIndicator::QQuickPageIndicator(QQuickItem *parent)
: QQuickControl(*(new QQuickPageIndicatorPrivate), parent)
{
}
QQuickPageIndicator::~QQuickPageIndicator()
{
Q_D(QQuickPageIndicator);
if (d->contentItem)
QQuickItemPrivate::get(d->contentItem)->removeItemChangeListener(d, QQuickItemPrivate::Children);
}
/*!
\qmlproperty int QtQuick.Controls::PageIndicator::count
This property holds the number of pages.
*/
int QQuickPageIndicator::count() const
{
Q_D(const QQuickPageIndicator);
return d->count;
}
void QQuickPageIndicator::setCount(int count)
{
Q_D(QQuickPageIndicator);
if (d->count == count)
return;
d->count = count;
emit countChanged();
}
/*!
\qmlproperty int QtQuick.Controls::PageIndicator::currentIndex
This property holds the index of the current page.
*/
int QQuickPageIndicator::currentIndex() const
{
Q_D(const QQuickPageIndicator);
return d->currentIndex;
}
void QQuickPageIndicator::setCurrentIndex(int index)
{
Q_D(QQuickPageIndicator);
if (d->currentIndex == index)
return;
d->currentIndex = index;
emit currentIndexChanged();
}
/*!
\qmlproperty bool QtQuick.Controls::PageIndicator::interactive
This property holds whether the control is interactive. An interactive page indicator
reacts to presses and automatically changes the \l {currentIndex}{current index}
appropriately.
\snippet qtquickcontrols-pageindicator-interactive.qml 1
\note Page indicators are typically quite small (in order to avoid
distracting the user from the actual content of the user interface). They
can be hard to click, and might not be easily recognized as interactive by
the user. For these reasons, they are best used to complement primary
methods of navigation (such as \l SwipeView), not replace them.
The default value is \c false.
*/
bool QQuickPageIndicator::isInteractive() const
{
Q_D(const QQuickPageIndicator);
return d->interactive;
}
void QQuickPageIndicator::setInteractive(bool interactive)
{
Q_D(QQuickPageIndicator);
if (d->interactive == interactive)
return;
d->interactive = interactive;
if (interactive) {
setAcceptedMouseButtons(Qt::LeftButton);
#if QT_CONFIG(quicktemplates2_multitouch)
setAcceptTouchEvents(true);
#endif
#if QT_CONFIG(cursor)
setCursor(Qt::ArrowCursor);
#endif
} else {
setAcceptedMouseButtons(Qt::NoButton);
#if QT_CONFIG(quicktemplates2_multitouch)
setAcceptTouchEvents(true);
#endif
#if QT_CONFIG(cursor)
unsetCursor();
#endif
}
emit interactiveChanged();
}
/*!
\qmlproperty Component QtQuick.Controls::PageIndicator::delegate
This property holds a delegate that presents a page.
The following properties are available in the context of each delegate:
\table
\row \li \b index : int \li The index of the item
\row \li \b pressed : bool \li Whether the item is pressed
\endtable
\include delegate-ownership.qdocinc {no-ownership} {PageIndicator}
*/
QQmlComponent *QQuickPageIndicator::delegate() const
{
Q_D(const QQuickPageIndicator);
return d->delegate;
}
void QQuickPageIndicator::setDelegate(QQmlComponent *delegate)
{
Q_D(QQuickPageIndicator);
if (d->delegate == delegate)
return;
d->delegate = delegate;
emit delegateChanged();
}
void QQuickPageIndicator::contentItemChange(QQuickItem *newItem, QQuickItem *oldItem)
{
Q_D(QQuickPageIndicator);
QQuickControl::contentItemChange(newItem, oldItem);
if (oldItem)
QQuickItemPrivate::get(oldItem)->removeItemChangeListener(d, QQuickItemPrivate::Children);
if (newItem)
QQuickItemPrivate::get(newItem)->addItemChangeListener(d, QQuickItemPrivate::Children);
}
#if QT_CONFIG(quicktemplates2_multitouch)
void QQuickPageIndicator::touchEvent(QTouchEvent *event)
{
Q_D(QQuickPageIndicator);
if (d->interactive)
QQuickControl::touchEvent(event);
else
event->ignore(); // QTBUG-61785
}
#endif
#if QT_CONFIG(accessibility)
QAccessible::Role QQuickPageIndicator::accessibleRole() const
{
return QAccessible::Indicator;
}
#endif
QT_END_NAMESPACE
#include "moc_qquickpageindicator_p.cpp"