| /**************************************************************************** | |
| ** | |
| ** Copyright (C) 2016 The Qt Company Ltd. | |
| ** Contact: https://www.qt.io/licensing/ | |
| ** | |
| ** This file is part of the Qt Quick Controls module of the Qt Toolkit. | |
| ** | |
| ** $QT_BEGIN_LICENSE:LGPL$ | |
| ** Commercial License Usage | |
| ** Licensees holding valid commercial Qt licenses may use this file in | |
| ** accordance with the commercial license agreement provided with the | |
| ** Software or, alternatively, in accordance with the terms contained in | |
| ** a written agreement between you and The Qt Company. For licensing terms | |
| ** and conditions see https://www.qt.io/terms-conditions. For further | |
| ** information use the contact form at https://www.qt.io/contact-us. | |
| ** | |
| ** GNU Lesser General Public License Usage | |
| ** Alternatively, this file may be used under the terms of the GNU Lesser | |
| ** General Public License version 3 as published by the Free Software | |
| ** Foundation and appearing in the file LICENSE.LGPL3 included in the | |
| ** packaging of this file. Please review the following information to | |
| ** ensure the GNU Lesser General Public License version 3 requirements | |
| ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. | |
| ** | |
| ** GNU General Public License Usage | |
| ** Alternatively, this file may be used under the terms of the GNU | |
| ** General Public License version 2.0 or (at your option) the GNU General | |
| ** Public license version 3 or any later version approved by the KDE Free | |
| ** Qt Foundation. The licenses are as published by the Free Software | |
| ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 | |
| ** included in the packaging of this file. Please review the following | |
| ** information to ensure the GNU General Public License requirements will | |
| ** be met: https://www.gnu.org/licenses/gpl-2.0.html and | |
| ** https://www.gnu.org/licenses/gpl-3.0.html. | |
| ** | |
| ** $QT_END_LICENSE$ | |
| ** | |
| ****************************************************************************/ | |
| #include "qquickwheelarea_p.h" | |
| QT_BEGIN_NAMESPACE | |
| // On Mac OS X, the scrolling speed in Safari is roughly 2.5 times faster | |
| // than in TextEdit (the native app). The former is using high-resolution | |
| // pixel-based delta values as they are, which is fine for a typical web | |
| // content, whereas the latter evidently makes scrolling slower to make it | |
| // feel natural and more precise for typical document type of content. | |
| // => we'll compromise between the two for now, and pick an arbitrary value | |
| // to make the pixel-based scrolling speed something between the two | |
| static const qreal pixelDeltaAdjustment = 0.5; | |
| // The default scroll speed for typical angle-based mouse wheels. The value | |
| // comes originally from QTextEdit, which sets 20px steps by default. | |
| static const qreal defaultScrollSpeed = 20.0; | |
| QQuickWheelArea1::QQuickWheelArea1(QQuickItem *parent) | |
| : QQuickItem(parent), | |
| m_horizontalMinimumValue(0), | |
| m_horizontalMaximumValue(0), | |
| m_verticalMinimumValue(0), | |
| m_verticalMaximumValue(0), | |
| m_horizontalValue(0), | |
| m_verticalValue(0), | |
| m_verticalDelta(0), | |
| m_horizontalDelta(0), | |
| m_scrollSpeed(defaultScrollSpeed), | |
| m_active(false) | |
| { | |
| } | |
| QQuickWheelArea1::~QQuickWheelArea1() | |
| { | |
| } | |
| bool QQuickWheelArea1::isAtXEnd() const | |
| { | |
| return qFuzzyCompare(m_horizontalMaximumValue, m_horizontalValue); | |
| } | |
| bool QQuickWheelArea1::isAtXBeginning() const | |
| { | |
| return qFuzzyCompare(m_horizontalMinimumValue, m_horizontalValue); | |
| } | |
| bool QQuickWheelArea1::isAtYEnd() const | |
| { | |
| return qFuzzyCompare(m_verticalMaximumValue, m_verticalValue); | |
| } | |
| bool QQuickWheelArea1::isAtYBeginning() const | |
| { | |
| return qFuzzyCompare(m_verticalMinimumValue, m_verticalValue); | |
| } | |
| bool QQuickWheelArea1::isInverted() const | |
| { | |
| return m_inverted; | |
| } | |
| #ifndef QT_NO_WHEELEVENT | |
| void QQuickWheelArea1::wheelEvent(QWheelEvent *we) | |
| { | |
| if (we->phase() == Qt::ScrollBegin) | |
| setActive(true); | |
| else if (we->phase() == Qt::ScrollEnd) | |
| setActive(false); | |
| QPoint numPixels = we->pixelDelta(); | |
| QPoint numDegrees = we->angleDelta() / 8; | |
| m_inverted = we->inverted(); | |
| if (!numPixels.isNull()) { | |
| setHorizontalDelta(numPixels.x() * pixelDeltaAdjustment); | |
| setVerticalDelta(numPixels.y() * pixelDeltaAdjustment); | |
| } else if (!numDegrees.isNull()) { | |
| setHorizontalDelta(numDegrees.x() / 15.0 * m_scrollSpeed); | |
| setVerticalDelta(numDegrees.y() / 15.0 * m_scrollSpeed); | |
| } | |
| // This allows other parent WheelArea's to handle scrolling | |
| // For example this allows for ScrollView inside of another ScrollView to work correctly | |
| // Once this scrollbar can't scroll anymore, ie it reaches the limits, | |
| // it will ignore the scroll event so the parent WheelArea can start scrolling | |
| if ((numPixels.x() != 0 || numDegrees.x() != 0) && | |
| m_horizontalMinimumValue <= m_horizontalMaximumValue && | |
| (isAtXBeginning() || isAtXEnd())) { | |
| we->ignore(); | |
| } else if ((numPixels.y() != 0 || numDegrees.y() != 0) && | |
| m_verticalMinimumValue <= m_verticalMaximumValue && | |
| (isAtYBeginning() || isAtYEnd())) { | |
| we->ignore(); | |
| } else { | |
| we->accept(); | |
| } | |
| } | |
| #endif | |
| void QQuickWheelArea1::setHorizontalMinimumValue(qreal value) | |
| { | |
| if (value == m_horizontalMinimumValue) | |
| return; | |
| m_horizontalMinimumValue = value; | |
| emit horizontalMinimumValueChanged(); | |
| } | |
| qreal QQuickWheelArea1::horizontalMinimumValue() const | |
| { | |
| return m_horizontalMinimumValue; | |
| } | |
| void QQuickWheelArea1::setHorizontalMaximumValue(qreal value) | |
| { | |
| if (value == m_horizontalMaximumValue) | |
| return; | |
| m_horizontalMaximumValue = value; | |
| emit horizontalMaximumValueChanged(); | |
| } | |
| qreal QQuickWheelArea1::horizontalMaximumValue() const | |
| { | |
| return m_horizontalMaximumValue; | |
| } | |
| void QQuickWheelArea1::setVerticalMinimumValue(qreal value) | |
| { | |
| if (value == m_verticalMinimumValue) | |
| return; | |
| m_verticalMinimumValue = value; | |
| emit verticalMinimumValueChanged(); | |
| } | |
| qreal QQuickWheelArea1::verticalMinimumValue() const | |
| { | |
| return m_verticalMinimumValue; | |
| } | |
| void QQuickWheelArea1::setVerticalMaximumValue(qreal value) | |
| { | |
| if (value == m_verticalMaximumValue) | |
| return; | |
| m_verticalMaximumValue = value; | |
| emit verticalMaximumValueChanged(); | |
| } | |
| qreal QQuickWheelArea1::verticalMaximumValue() const | |
| { | |
| return m_verticalMaximumValue; | |
| } | |
| void QQuickWheelArea1::setHorizontalValue(qreal value) | |
| { | |
| value = qBound<qreal>(m_horizontalMinimumValue, value, m_horizontalMaximumValue); | |
| if (value != m_horizontalValue) { | |
| m_horizontalValue = value; | |
| emit horizontalValueChanged(); | |
| } | |
| } | |
| qreal QQuickWheelArea1::horizontalValue() const | |
| { | |
| return m_horizontalValue; | |
| } | |
| void QQuickWheelArea1::setVerticalValue(qreal value) | |
| { | |
| value = qBound<qreal>(m_verticalMinimumValue, value, m_verticalMaximumValue); | |
| if (value != m_verticalValue) { | |
| m_verticalValue = value; | |
| emit verticalValueChanged(); | |
| } | |
| } | |
| qreal QQuickWheelArea1::verticalValue() const | |
| { | |
| return m_verticalValue; | |
| } | |
| void QQuickWheelArea1::setVerticalDelta(qreal value) | |
| { | |
| m_verticalDelta = value; | |
| setVerticalValue(m_verticalValue - m_verticalDelta); | |
| emit verticalWheelMoved(); | |
| } | |
| qreal QQuickWheelArea1::verticalDelta() const | |
| { | |
| return m_verticalDelta; | |
| } | |
| void QQuickWheelArea1::setHorizontalDelta(qreal value) | |
| { | |
| m_horizontalDelta = value; | |
| setHorizontalValue(m_horizontalValue - m_horizontalDelta); | |
| emit horizontalWheelMoved(); | |
| } | |
| qreal QQuickWheelArea1::horizontalDelta() const | |
| { | |
| return m_horizontalDelta; | |
| } | |
| void QQuickWheelArea1::setScrollSpeed(qreal value) | |
| { | |
| if (value != m_scrollSpeed) { | |
| m_scrollSpeed = value; | |
| emit scrollSpeedChanged(); | |
| } | |
| } | |
| qreal QQuickWheelArea1::scrollSpeed() const | |
| { | |
| return m_scrollSpeed; | |
| } | |
| bool QQuickWheelArea1::isActive() const | |
| { | |
| return m_active; | |
| } | |
| void QQuickWheelArea1::setActive(bool active) | |
| { | |
| if (active != m_active) { | |
| m_active = active; | |
| emit activeChanged(); | |
| } | |
| } | |
| QT_END_NAMESPACE |