rhodes 5.5.0.3 → 5.5.0.7
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/README.md +10 -0
- data/lib/commonAPI/coreapi/ext/platform/android/src/com/rho/notification/NotificationSingleton.java +20 -8
- data/lib/commonAPI/coreapi/ext/platform/iphone/cpp_based_impl/SystemImpl.mm +1 -2
- data/lib/commonAPI/coreapi/ext/system.xml +1 -1
- data/platform/android/build/android.rake +1 -0
- data/platform/iphone/Classes/AppManager/AppManager.m +44 -3
- data/platform/iphone/Classes/NativeView/RhoNativeViewManager.mm +4 -3
- data/platform/iphone/Classes/NativeView/RhoNativeViewManagerOC.h +1 -1
- data/platform/iphone/Classes/RhoMainView.h +8 -2
- data/platform/iphone/Classes/RhoUIWebView.h +75 -0
- data/platform/iphone/Classes/RhoUIWebView.m +142 -0
- data/platform/iphone/Classes/RhoWKWebView.h +87 -0
- data/platform/iphone/Classes/RhoWKWebView.m +187 -0
- data/platform/iphone/Classes/RhoWebView.h +72 -0
- data/platform/iphone/Classes/RhoWebViewFabrique.h +35 -0
- data/platform/iphone/Classes/RhoWebViewFabrique.m +87 -0
- data/platform/iphone/Classes/Rhodes.m +17 -6
- data/platform/iphone/Classes/Signature.old/SignatureDelegate.m +11 -4
- data/platform/iphone/Classes/Signature/SignatureDelegate.m +3 -4
- data/platform/iphone/Classes/SimpleMainView.h +7 -5
- data/platform/iphone/Classes/SimpleMainView.m +174 -179
- data/platform/iphone/Classes/SplitView/RightViewController.h +2 -2
- data/platform/iphone/Classes/SplitView/RightViewController.m +9 -10
- data/platform/iphone/Classes/SplitView/SplittedMainView.h +2 -3
- data/platform/iphone/Classes/SplitView/SplittedMainView.m +10 -7
- data/platform/iphone/Classes/TabbedMainView.h +2 -1
- data/platform/iphone/Classes/TabbedMainView.m +13 -10
- data/platform/iphone/Classes/URLProtocol/CRhoURLProtocol.m +21 -5
- data/platform/iphone/Classes/WebView.m +1 -1
- data/platform/iphone/RhoAppBaseLib/RhoAppBaseLib.xcodeproj/project.pbxproj +40 -3
- data/platform/iphone/RhoLib/RhoLib.xcodeproj/project.pbxproj +4 -0
- data/platform/iphone/rbuild/iphone.rake +51 -0
- data/platform/shared/common/RhoNativeViewManager.h +9 -9
- data/platform/shared/common/RhodesApp.cpp +13 -1
- data/platform/shared/net/HttpServer.cpp +12 -2
- data/platform/shared/qt/rhodes/ExternalWebView.ui +11 -2
- data/platform/shared/qt/rhodes/QtMainWindow.cpp +9 -7
- data/platform/shared/qt/rhodes/QtMainWindow.ui +13 -4
- data/platform/shared/qt/rhodes/qkineticscroller.cpp +1245 -0
- data/platform/shared/qt/rhodes/qkineticscroller.h +165 -0
- data/platform/shared/qt/rhodes/qkineticscroller_p.h +168 -0
- data/platform/shared/qt/rhodes/qtflickgesture.cpp +696 -0
- data/platform/shared/qt/rhodes/qtflickgesture_p.h +107 -0
- data/platform/shared/qt/rhodes/qtscroller.cpp +2080 -0
- data/platform/shared/qt/rhodes/qtscroller.h +138 -0
- data/platform/shared/qt/rhodes/qtscroller_p.h +205 -0
- data/platform/shared/qt/rhodes/qtscrollerfilter.cpp +350 -0
- data/platform/shared/qt/rhodes/qtscrollerfilter_p.h +110 -0
- data/platform/shared/qt/rhodes/qtscrollerproperties.cpp +412 -0
- data/platform/shared/qt/rhodes/qtscrollerproperties.h +135 -0
- data/platform/shared/qt/rhodes/qtscrollerproperties_p.h +90 -0
- data/platform/shared/qt/rhodes/qtscrollevent.cpp +190 -0
- data/platform/shared/qt/rhodes/qtscrollevent.h +100 -0
- data/platform/shared/qt/rhodes/qtscrollevent_p.h +33 -0
- data/platform/shared/qt/rhodes/qwebviewkineticscroller.cpp +347 -0
- data/platform/shared/qt/rhodes/qwebviewkineticscroller.h +90 -0
- data/platform/shared/qt/rhodes/qwebviewselectionsuppressor.h +113 -0
- data/platform/shared/qt/rhodes/rhodes.pro +19 -0
- data/res/generators/rhogen.rb +307 -15
- data/res/generators/templates/application/app/Settings/err_sync.erb +12 -6
- data/res/generators/templates/application/app/Settings/home.erb +32 -17
- data/res/generators/templates/application/app/Settings/index.erb +55 -26
- data/res/generators/templates/application/app/Settings/javascript_index.html +111 -0
- data/res/generators/templates/application/app/Settings/javascript_login.html +65 -0
- data/res/generators/templates/application/app/Settings/login.erb +25 -19
- data/res/generators/templates/application/app/Settings/reset.erb +18 -9
- data/res/generators/templates/application/app/Settings/wait.erb +10 -7
- data/res/generators/templates/application/app/index.erb +32 -20
- data/res/generators/templates/application/app/javascript_index.html +66 -0
- data/res/generators/templates/application/app/javascript_index.js +250 -0
- data/res/generators/templates/application/app/layout.erb +12 -67
- data/res/generators/templates/application/javascript_build.yml +41 -0
- data/res/generators/templates/application/javascript_rhoconfig.txt +123 -0
- data/res/generators/templates/application/public/bootstrap-3.3.7/css/bootstrap-theme.css +587 -0
- data/res/generators/templates/application/public/bootstrap-3.3.7/css/bootstrap-theme.css.map +1 -0
- data/res/generators/templates/application/public/bootstrap-3.3.7/css/bootstrap-theme.min.css +6 -0
- data/res/generators/templates/application/public/bootstrap-3.3.7/css/bootstrap-theme.min.css.map +1 -0
- data/res/generators/templates/application/public/bootstrap-3.3.7/css/bootstrap.css +6757 -0
- data/res/generators/templates/application/public/bootstrap-3.3.7/css/bootstrap.css.map +1 -0
- data/res/generators/templates/application/public/bootstrap-3.3.7/css/bootstrap.min.css +6 -0
- data/res/generators/templates/application/public/bootstrap-3.3.7/css/bootstrap.min.css.map +1 -0
- data/res/generators/templates/application/public/bootstrap-3.3.7/fonts/glyphicons-halflings-regular.eot +0 -0
- data/res/generators/templates/application/public/bootstrap-3.3.7/fonts/glyphicons-halflings-regular.svg +288 -0
- data/res/generators/templates/application/public/bootstrap-3.3.7/fonts/glyphicons-halflings-regular.ttf +0 -0
- data/res/generators/templates/application/public/bootstrap-3.3.7/fonts/glyphicons-halflings-regular.woff +0 -0
- data/res/generators/templates/application/public/bootstrap-3.3.7/fonts/glyphicons-halflings-regular.woff2 +0 -0
- data/res/generators/templates/application/public/bootstrap-3.3.7/js/bootstrap.js +2377 -0
- data/res/generators/templates/application/public/bootstrap-3.3.7/js/bootstrap.min.js +7 -0
- data/res/generators/templates/application/public/bootstrap-3.3.7/js/npm.js +13 -0
- data/res/generators/templates/application/public/css/style.css +3 -0
- data/res/generators/templates/application/public/jquery/jquery-3.1.1.min.js +4 -0
- data/res/generators/templates/application/public/jquery/jquery-3.1.1.min.map +1 -0
- data/res/generators/templates/application/rhoconfig.txt +16 -0
- data/res/generators/templates/iphone_project/Bremen7.xcodeproj/project.pbxproj +4 -0
- data/res/generators/templates/model/edit.erb +22 -21
- data/res/generators/templates/model/index.erb +24 -22
- data/res/generators/templates/model/javascript_edit.html +65 -0
- data/res/generators/templates/model/javascript_index.html +56 -0
- data/res/generators/templates/model/javascript_index.js +83 -0
- data/res/generators/templates/model/javascript_model.js +16 -0
- data/res/generators/templates/model/javascript_new.html +64 -0
- data/res/generators/templates/model/javascript_show.html +66 -0
- data/res/generators/templates/model/new.erb +22 -19
- data/res/generators/templates/model/show.erb +22 -14
- data/res/prebuild_base_app/app/index.erb +31 -18
- data/res/prebuild_base_app/app/layout.erb +11 -56
- data/version +1 -1
- metadata +59 -24
- data/res/generators/templates/application/public/css/android.css +0 -418
- data/res/generators/templates/application/public/css/iphone.css +0 -378
- data/res/generators/templates/application/public/css/jqmobile-patch.css +0 -62
- data/res/generators/templates/application/public/css/re_webkit.css +0 -736
- data/res/generators/templates/application/public/css/re_webkit_flat.css +0 -753
- data/res/generators/templates/application/public/css/windows_mobile.css +0 -327
- data/res/generators/templates/application/public/jqmobile/images/ajax-loader.gif +0 -0
- data/res/generators/templates/application/public/jqmobile/images/icon-search-black.png +0 -0
- data/res/generators/templates/application/public/jqmobile/images/icons-18-black.png +0 -0
- data/res/generators/templates/application/public/jqmobile/images/icons-18-white.png +0 -0
- data/res/generators/templates/application/public/jqmobile/images/icons-36-black.png +0 -0
- data/res/generators/templates/application/public/jqmobile/images/icons-36-white.png +0 -0
- data/res/generators/templates/application/public/jqmobile/jquery.mobile-1.4.5.min.css +0 -3
- data/res/generators/templates/application/public/jqmobile/jquery.mobile-1.4.5.min.js +0 -10
- data/res/generators/templates/application/public/jqmobile/jquery.mobile-1.4.5.min.map +0 -1
- data/res/generators/templates/application/public/jqmobile/jquery.mobile.structure-1.4.5.min.css +0 -3
- data/res/generators/templates/application/public/jqmobile/jquery.mobile.theme-1.4.5.min.css +0 -3
- data/res/generators/templates/application/public/jquery/jquery-1.9.1.min.js +0 -5
- data/res/generators/templates/application/public/jquery/jquery-1.9.1.min.map +0 -1
- data/res/generators/templates/application/public/js/application.js +0 -1
- data/res/generators/templates/application/public/js/jqmobile-patch.js +0 -466
- data/res/generators/templates/application/public/js/syncengine.js +0 -504
@@ -0,0 +1,107 @@
|
|
1
|
+
/****************************************************************************
|
2
|
+
**
|
3
|
+
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
|
4
|
+
** All rights reserved.
|
5
|
+
** Contact: Nokia Corporation (qt-info@nokia.com)
|
6
|
+
**
|
7
|
+
** This file is part of the QtGui module of the Qt Toolkit.
|
8
|
+
**
|
9
|
+
** $QT_BEGIN_LICENSE:LGPL$
|
10
|
+
** No Commercial Usage
|
11
|
+
** This file contains pre-release code and may not be distributed.
|
12
|
+
** You may use this file in accordance with the terms and conditions
|
13
|
+
** contained in the Technology Preview License Agreement accompanying
|
14
|
+
** this package.
|
15
|
+
**
|
16
|
+
** GNU Lesser General Public License Usage
|
17
|
+
** Alternatively, this file may be used under the terms of the GNU Lesser
|
18
|
+
** General Public License version 2.1 as published by the Free Software
|
19
|
+
** Foundation and appearing in the file LICENSE.LGPL included in the
|
20
|
+
** packaging of this file. Please review the following information to
|
21
|
+
** ensure the GNU Lesser General Public License version 2.1 requirements
|
22
|
+
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
23
|
+
**
|
24
|
+
** In addition, as a special exception, Nokia gives you certain additional
|
25
|
+
** rights. These rights are described in the Nokia Qt LGPL Exception
|
26
|
+
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
27
|
+
**
|
28
|
+
** If you have questions regarding the use of this file, please contact
|
29
|
+
** Nokia at qt-info@nokia.com.
|
30
|
+
**
|
31
|
+
**
|
32
|
+
**
|
33
|
+
**
|
34
|
+
**
|
35
|
+
**
|
36
|
+
**
|
37
|
+
**
|
38
|
+
** $QT_END_LICENSE$
|
39
|
+
**
|
40
|
+
****************************************************************************/
|
41
|
+
|
42
|
+
#ifndef QTFLICKGESTURE_P_H
|
43
|
+
#define QTFLICKGESTURE_P_H
|
44
|
+
|
45
|
+
//
|
46
|
+
// W A R N I N G
|
47
|
+
// -------------
|
48
|
+
//
|
49
|
+
// This file is not part of the Qt API. It exists for the convenience
|
50
|
+
// of other Qt classes. This header file may change from version to
|
51
|
+
// version without notice, or even be removed.
|
52
|
+
//
|
53
|
+
// We mean it.
|
54
|
+
//
|
55
|
+
|
56
|
+
#include "qobject.h"
|
57
|
+
#include "qpointer.h"
|
58
|
+
#include "qevent.h"
|
59
|
+
#include "qgesture.h"
|
60
|
+
#include "qgesturerecognizer.h"
|
61
|
+
#include "qtscroller.h"
|
62
|
+
|
63
|
+
#ifndef QT_NO_GESTURES
|
64
|
+
|
65
|
+
class PressDelayHandler;
|
66
|
+
|
67
|
+
class QtFlickGesture : public QGesture
|
68
|
+
{
|
69
|
+
Q_OBJECT
|
70
|
+
|
71
|
+
public:
|
72
|
+
QtFlickGesture(QObject *receiver, Qt::MouseButton button, QObject *parent = 0);
|
73
|
+
~QtFlickGesture();
|
74
|
+
|
75
|
+
protected:
|
76
|
+
bool eventFilter(QObject *o, QEvent *e);
|
77
|
+
|
78
|
+
private:
|
79
|
+
QPointer<QObject> receiver;
|
80
|
+
QtScroller *receiverScroller;
|
81
|
+
Qt::MouseButton button; // NoButton == Touch
|
82
|
+
bool macIgnoreWheel;
|
83
|
+
// QWidget::mapFromGlobal is very expensive on X11, so we cache the global position of the widget
|
84
|
+
QPointer<QWidget> receiverWindow;
|
85
|
+
QPoint receiverWindowPos;
|
86
|
+
|
87
|
+
static PressDelayHandler *pressDelayHandler;
|
88
|
+
|
89
|
+
friend class QtFlickGestureRecognizer;
|
90
|
+
};
|
91
|
+
|
92
|
+
class QtFlickGestureRecognizer : public QGestureRecognizer
|
93
|
+
{
|
94
|
+
public:
|
95
|
+
QtFlickGestureRecognizer(Qt::MouseButton button);
|
96
|
+
|
97
|
+
QGesture *create(QObject *target);
|
98
|
+
QGestureRecognizer::Result recognize(QGesture *state, QObject *watched, QEvent *event);
|
99
|
+
void reset(QGesture *state);
|
100
|
+
|
101
|
+
private:
|
102
|
+
Qt::MouseButton button; // NoButton == Touch
|
103
|
+
};
|
104
|
+
|
105
|
+
#endif // QT_NO_GESTURES
|
106
|
+
|
107
|
+
#endif // QTFLICKGESTURE_P_H
|
@@ -0,0 +1,2080 @@
|
|
1
|
+
/****************************************************************************
|
2
|
+
**
|
3
|
+
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
|
4
|
+
** All rights reserved.
|
5
|
+
** Contact: Nokia Corporation (qt-info@nokia.com)
|
6
|
+
**
|
7
|
+
** This file is part of the QtGui module of the Qt Toolkit.
|
8
|
+
**
|
9
|
+
** $QT_BEGIN_LICENSE:LGPL$
|
10
|
+
** No Commercial Usage
|
11
|
+
** This file contains pre-release code and may not be distributed.
|
12
|
+
** You may use this file in accordance with the terms and conditions
|
13
|
+
** contained in the Technology Preview License Agreement accompanying
|
14
|
+
** this package.
|
15
|
+
**
|
16
|
+
** GNU Lesser General Public License Usage
|
17
|
+
** Alternatively, this file may be used under the terms of the GNU Lesser
|
18
|
+
** General Public License version 2.1 as published by the Free Software
|
19
|
+
** Foundation and appearing in the file LICENSE.LGPL included in the
|
20
|
+
** packaging of this file. Please review the following information to
|
21
|
+
** ensure the GNU Lesser General Public License version 2.1 requirements
|
22
|
+
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
23
|
+
**
|
24
|
+
** In addition, as a special exception, Nokia gives you certain additional
|
25
|
+
** rights. These rights are described in the Nokia Qt LGPL Exception
|
26
|
+
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
27
|
+
**
|
28
|
+
** If you have questions regarding the use of this file, please contact
|
29
|
+
** Nokia at qt-info@nokia.com.
|
30
|
+
**
|
31
|
+
**
|
32
|
+
**
|
33
|
+
**
|
34
|
+
**
|
35
|
+
**
|
36
|
+
**
|
37
|
+
**
|
38
|
+
** $QT_END_LICENSE$
|
39
|
+
**
|
40
|
+
****************************************************************************/
|
41
|
+
|
42
|
+
#include "qevent.h"
|
43
|
+
#include "qwidget.h"
|
44
|
+
#include "qtscroller.h"
|
45
|
+
#include "qtflickgesture_p.h"
|
46
|
+
#include "qtscroller_p.h"
|
47
|
+
#include "qtscrollerproperties.h"
|
48
|
+
#include "qtscrollerproperties_p.h"
|
49
|
+
|
50
|
+
#include "math.h"
|
51
|
+
|
52
|
+
#include <QTime>
|
53
|
+
#include <QMap>
|
54
|
+
#include <QApplication>
|
55
|
+
#include <QAbstractScrollArea>
|
56
|
+
#include <QGraphicsObject>
|
57
|
+
#include <QGraphicsScene>
|
58
|
+
#include <QGraphicsView>
|
59
|
+
#include <QDesktopWidget>
|
60
|
+
#include <QtCore/qmath.h>
|
61
|
+
#include <QtGui/qevent.h>
|
62
|
+
#include <qnumeric.h>
|
63
|
+
|
64
|
+
// completely optional warning, but you can go nuts if you forget to set the scroll mode right
|
65
|
+
#define ITEMVIEW_SCROLLMODE_WARNING 1
|
66
|
+
#ifdef ITEMVIEW_SCROLLMODE_WARNING
|
67
|
+
# include <QAbstractItemView>
|
68
|
+
#endif
|
69
|
+
|
70
|
+
#include <QtDebug>
|
71
|
+
|
72
|
+
// vvv QScroller Solution only
|
73
|
+
#include "qtscrollerfilter_p.h"
|
74
|
+
#include "qtscrollevent.h"
|
75
|
+
// ^^^ QScroller Solution only
|
76
|
+
|
77
|
+
#if defined(Q_WS_X11)
|
78
|
+
# include <QX11Info>
|
79
|
+
# include <QLibrary>
|
80
|
+
#endif
|
81
|
+
|
82
|
+
|
83
|
+
bool qt_sendSpontaneousEvent(QObject *receiver, QEvent *event);
|
84
|
+
|
85
|
+
//#define QSCROLLER_DEBUG
|
86
|
+
|
87
|
+
#ifdef QSCROLLER_DEBUG
|
88
|
+
# define qScrollerDebug qDebug
|
89
|
+
#else
|
90
|
+
# define qScrollerDebug while (false) qDebug
|
91
|
+
#endif
|
92
|
+
|
93
|
+
QDebug &operator<<(QDebug &dbg, const QtScrollerPrivate::ScrollSegment &s)
|
94
|
+
{
|
95
|
+
dbg << "\n Time: start:" << s.startTime << " duration:" << s.deltaTime << " stop progress:" << s.stopProgress;
|
96
|
+
dbg << "\n Pos: start:" << s.startPos << " delta:" << s.deltaPos << " stop:" << s.stopPos;
|
97
|
+
dbg << "\n Curve: type:" << s.curve.type() << "\n";
|
98
|
+
return dbg;
|
99
|
+
}
|
100
|
+
|
101
|
+
|
102
|
+
// a few helper operators to make the code below a lot more readable:
|
103
|
+
// otherwise a lot of ifs would have to be multi-line to check both the x
|
104
|
+
// and y coordinate separately.
|
105
|
+
|
106
|
+
// returns true only if the abs. value of BOTH x and y are <= f
|
107
|
+
inline bool operator<=(const QPointF &p, qreal f)
|
108
|
+
{
|
109
|
+
return (qAbs(p.x()) <= f) && (qAbs(p.y()) <= f);
|
110
|
+
}
|
111
|
+
|
112
|
+
// returns true only if the abs. value of BOTH x and y are < f
|
113
|
+
inline bool operator<(const QPointF &p, qreal f)
|
114
|
+
{
|
115
|
+
return (qAbs(p.x()) < f) && (qAbs(p.y()) < f);
|
116
|
+
}
|
117
|
+
|
118
|
+
// returns true if the abs. value of EITHER x or y are >= f
|
119
|
+
inline bool operator>=(const QPointF &p, qreal f)
|
120
|
+
{
|
121
|
+
return (qAbs(p.x()) >= f) || (qAbs(p.y()) >= f);
|
122
|
+
}
|
123
|
+
|
124
|
+
// returns true if the abs. value of EITHER x or y are > f
|
125
|
+
inline bool operator>(const QPointF &p, qreal f)
|
126
|
+
{
|
127
|
+
return (qAbs(p.x()) > f) || (qAbs(p.y()) > f);
|
128
|
+
}
|
129
|
+
|
130
|
+
// returns a new point with both coordinates having the abs. value of the original one
|
131
|
+
inline QPointF qAbs(const QPointF &p)
|
132
|
+
{
|
133
|
+
return QPointF(qAbs(p.x()), qAbs(p.y()));
|
134
|
+
}
|
135
|
+
|
136
|
+
// returns a new point with all components of p1 multiplied by the corresponding components of p2
|
137
|
+
inline QPointF operator*(const QPointF &p1, const QPointF &p2)
|
138
|
+
{
|
139
|
+
return QPointF(p1.x() * p2.x(), p1.y() * p2.y());
|
140
|
+
}
|
141
|
+
|
142
|
+
// returns a new point with all components of p1 divided by the corresponding components of p2
|
143
|
+
inline QPointF operator/(const QPointF &p1, const QPointF &p2)
|
144
|
+
{
|
145
|
+
return QPointF(p1.x() / p2.x(), p1.y() / p2.y());
|
146
|
+
}
|
147
|
+
|
148
|
+
inline QPointF clampToRect(const QPointF &p, const QRectF &rect)
|
149
|
+
{
|
150
|
+
qreal x = qBound(rect.left(), p.x(), rect.right());
|
151
|
+
qreal y = qBound(rect.top(), p.y(), rect.bottom());
|
152
|
+
return QPointF(x, y);
|
153
|
+
}
|
154
|
+
|
155
|
+
// returns -1, 0 or +1 according to r being <0, ==0 or >0
|
156
|
+
inline int qSign(qreal r)
|
157
|
+
{
|
158
|
+
return (r < 0) ? -1 : ((r > 0) ? 1 : 0);
|
159
|
+
}
|
160
|
+
|
161
|
+
// this version is not mathematically exact, but it just works for every
|
162
|
+
// easing curve type (even custom ones)
|
163
|
+
|
164
|
+
static qreal differentialForProgress(const QEasingCurve &curve, qreal pos)
|
165
|
+
{
|
166
|
+
const qreal dx = 0.01;
|
167
|
+
qreal left = (pos < qreal(0.5)) ? pos : pos - qreal(dx);
|
168
|
+
qreal right = (pos >= qreal(0.5)) ? pos : pos + qreal(dx);
|
169
|
+
qreal d = (curve.valueForProgress(right) - curve.valueForProgress(left)) / qreal(dx);
|
170
|
+
|
171
|
+
//qScrollerDebug() << "differentialForProgress(type: " << curve.type() << ", pos: " << pos << ") = " << d;
|
172
|
+
|
173
|
+
return d;
|
174
|
+
}
|
175
|
+
|
176
|
+
// this version is not mathematically exact, but it just works for every
|
177
|
+
// easing curve type (even custom ones)
|
178
|
+
|
179
|
+
static qreal progressForValue(const QEasingCurve &curve, qreal value)
|
180
|
+
{
|
181
|
+
if (curve.type() >= QEasingCurve::InElastic &&
|
182
|
+
curve.type() < QEasingCurve::Custom) {
|
183
|
+
qWarning("progressForValue(): QEasingCurves of type %d do not have an inverse, since they are not injective.", curve.type());
|
184
|
+
return value;
|
185
|
+
}
|
186
|
+
if (value < qreal(0) || value > qreal(1))
|
187
|
+
return value;
|
188
|
+
|
189
|
+
qreal progress = value, left(0), right(1);
|
190
|
+
for (int iterations = 6; iterations; --iterations) {
|
191
|
+
qreal v = curve.valueForProgress(progress);
|
192
|
+
if (v < value)
|
193
|
+
left = progress;
|
194
|
+
else if (v > value)
|
195
|
+
right = progress;
|
196
|
+
else
|
197
|
+
break;
|
198
|
+
progress = (left + right) / qreal(2);
|
199
|
+
}
|
200
|
+
return progress;
|
201
|
+
}
|
202
|
+
|
203
|
+
|
204
|
+
class QScrollTimer : public QAbstractAnimation
|
205
|
+
{
|
206
|
+
public:
|
207
|
+
QScrollTimer(QtScrollerPrivate *_d)
|
208
|
+
: d(_d), ignoreUpdate(false), skip(0)
|
209
|
+
{ }
|
210
|
+
|
211
|
+
int duration() const
|
212
|
+
{
|
213
|
+
return -1;
|
214
|
+
}
|
215
|
+
|
216
|
+
void start()
|
217
|
+
{
|
218
|
+
// QAbstractAnimation::start() will immediately call
|
219
|
+
// updateCurrentTime(), but our state is not set correctly yet
|
220
|
+
ignoreUpdate = true;
|
221
|
+
QAbstractAnimation::start();
|
222
|
+
ignoreUpdate = false;
|
223
|
+
skip = 0;
|
224
|
+
}
|
225
|
+
|
226
|
+
protected:
|
227
|
+
void updateCurrentTime(int /*currentTime*/)
|
228
|
+
{
|
229
|
+
if (!ignoreUpdate) {
|
230
|
+
if (++skip >= d->frameRateSkip()) {
|
231
|
+
skip = 0;
|
232
|
+
d->timerTick();
|
233
|
+
}
|
234
|
+
}
|
235
|
+
}
|
236
|
+
|
237
|
+
private:
|
238
|
+
QtScrollerPrivate *d;
|
239
|
+
bool ignoreUpdate;
|
240
|
+
int skip;
|
241
|
+
};
|
242
|
+
|
243
|
+
/*!
|
244
|
+
\class QScroller
|
245
|
+
\brief The QScroller class enables kinetic scrolling for any scrolling widget or graphics item.
|
246
|
+
\class QtScroller
|
247
|
+
\brief The QtScroller class enables kinetic scrolling for any scrolling widget or graphics item.
|
248
|
+
\since 4.8
|
249
|
+
|
250
|
+
With kinetic scrolling, the user can push the widget in a given
|
251
|
+
direction and it will continue to scroll in this direction until it is
|
252
|
+
stopped either by the user or by friction. Aspects of inertia, friction
|
253
|
+
and other physical concepts can be changed in order to fine-tune an
|
254
|
+
intuitive user experience.
|
255
|
+
|
256
|
+
The QtScroller object is the object that stores the current position and
|
257
|
+
scrolling speed and takes care of updates.
|
258
|
+
QtScroller can be triggered by a flick gesture
|
259
|
+
|
260
|
+
\code
|
261
|
+
QWidget *w = ...;
|
262
|
+
QtScroller::grabGesture(w, QtScroller::LeftMouseButtonGesture);
|
263
|
+
\endcode
|
264
|
+
|
265
|
+
or directly like this:
|
266
|
+
|
267
|
+
\code
|
268
|
+
QWidget *w = ...;
|
269
|
+
QtScroller *scroller = QtScroller::scroller(w);
|
270
|
+
scroller->scrollTo(QPointF(100, 100));
|
271
|
+
\endcode
|
272
|
+
|
273
|
+
The scrolled QObjects receive a QScrollPrepareEvent whenever the scroller needs to
|
274
|
+
update its geometry information and a QScrollEvent whenever the content of the object should
|
275
|
+
actually be scrolled.
|
276
|
+
|
277
|
+
The scroller uses the global QAbstractAnimation timer to generate its QScrollEvents. This
|
278
|
+
can be changed with QtScrollerProperties::FrameRate on a per-QtScroller basis.
|
279
|
+
|
280
|
+
Several examples in the \c scroller examples directory show how QtScroller,
|
281
|
+
QScrollEvent and the scroller gesture can be used.
|
282
|
+
|
283
|
+
Even though this kinetic scroller has a large number of settings available via
|
284
|
+
QtScrollerProperties, we recommend that you leave them all at their default, platform optimized
|
285
|
+
values. Before changing them you can experiment with the \c plot example in
|
286
|
+
the \c scroller examples directory.
|
287
|
+
|
288
|
+
\sa QtScrollEvent, QtScrollPrepareEvent, QtScrollerProperties
|
289
|
+
*/
|
290
|
+
|
291
|
+
|
292
|
+
QMap<QObject *, QtScroller *> QtScrollerPrivate::allScrollers;
|
293
|
+
QSet<QtScroller *> QtScrollerPrivate::activeScrollers;
|
294
|
+
|
295
|
+
/*!
|
296
|
+
Returns \c true if a QtScroller object was already created for \a target; \c false otherwise.
|
297
|
+
|
298
|
+
\sa scroller()
|
299
|
+
*/
|
300
|
+
bool QtScroller::hasScroller(QObject *target)
|
301
|
+
{
|
302
|
+
return (QtScrollerPrivate::allScrollers.value(target));
|
303
|
+
}
|
304
|
+
|
305
|
+
/*!
|
306
|
+
Returns the scroller for the given \a target.
|
307
|
+
As long as the object exists this function will always return the same QtScroller instance.
|
308
|
+
If no QtScroller exists for the \a target, one will implicitly be created.
|
309
|
+
At no point more than one QtScroller will be active on an object.
|
310
|
+
|
311
|
+
\sa hasScroller(), target()
|
312
|
+
*/
|
313
|
+
QtScroller *QtScroller::scroller(QObject *target)
|
314
|
+
{
|
315
|
+
if (!target) {
|
316
|
+
qWarning("QtScroller::scroller() was called with a null target.");
|
317
|
+
return 0;
|
318
|
+
}
|
319
|
+
|
320
|
+
if (QtScrollerPrivate::allScrollers.contains(target))
|
321
|
+
return QtScrollerPrivate::allScrollers.value(target);
|
322
|
+
|
323
|
+
QtScroller *s = new QtScroller(target);
|
324
|
+
QtScrollerPrivate::allScrollers.insert(target, s);
|
325
|
+
return s;
|
326
|
+
}
|
327
|
+
|
328
|
+
/*!
|
329
|
+
\overload
|
330
|
+
This is the const version of scroller().
|
331
|
+
*/
|
332
|
+
const QtScroller *QtScroller::scroller(const QObject *target)
|
333
|
+
{
|
334
|
+
return scroller(const_cast<QObject*>(target));
|
335
|
+
}
|
336
|
+
|
337
|
+
/*!
|
338
|
+
Returns an application wide list of currently active QtScroller objects.
|
339
|
+
Active QtScroller objects are in a state() that is not QtScroller::Inactive.
|
340
|
+
This function is useful when writing your own gesture recognizer.
|
341
|
+
*/
|
342
|
+
QList<QtScroller *> QtScroller::activeScrollers()
|
343
|
+
{
|
344
|
+
return QtScrollerPrivate::activeScrollers.toList();
|
345
|
+
}
|
346
|
+
|
347
|
+
/*!
|
348
|
+
Returns the target object of this scroller.
|
349
|
+
\sa hasScroller(), scroller()
|
350
|
+
*/
|
351
|
+
QObject *QtScroller::target() const
|
352
|
+
{
|
353
|
+
Q_D(const QtScroller);
|
354
|
+
return d->target;
|
355
|
+
}
|
356
|
+
|
357
|
+
/*!
|
358
|
+
\fn QtScroller::scrollerPropertiesChanged(const QtScrollerProperties &newProperties);
|
359
|
+
|
360
|
+
QtScroller emits this signal whenever its scroller properties change.
|
361
|
+
\a newProperties are the new scroller properties.
|
362
|
+
|
363
|
+
\sa scrollerProperties
|
364
|
+
*/
|
365
|
+
|
366
|
+
|
367
|
+
/*! \property QtScroller::scrollerProperties
|
368
|
+
\brief The scroller properties of this scroller.
|
369
|
+
The properties are used by the QtScroller to determine its scrolling behavior.
|
370
|
+
*/
|
371
|
+
QtScrollerProperties QtScroller::scrollerProperties() const
|
372
|
+
{
|
373
|
+
Q_D(const QtScroller);
|
374
|
+
return d->properties;
|
375
|
+
}
|
376
|
+
|
377
|
+
void QtScroller::setScrollerProperties(const QtScrollerProperties &sp)
|
378
|
+
{
|
379
|
+
Q_D(QtScroller);
|
380
|
+
if (d->properties != sp) {
|
381
|
+
d->properties = sp;
|
382
|
+
emit scrollerPropertiesChanged(sp);
|
383
|
+
|
384
|
+
// we need to force the recalculation here, since the overshootPolicy may have changed and
|
385
|
+
// existing segments may include an overshoot animation.
|
386
|
+
d->recalcScrollingSegments(true);
|
387
|
+
}
|
388
|
+
}
|
389
|
+
|
390
|
+
|
391
|
+
/*!
|
392
|
+
Registers a custom scroll gesture recognizer, grabs it for the \a
|
393
|
+
target and returns the resulting gesture type. If \a scrollGestureType is
|
394
|
+
set to TouchGesture the gesture triggers on touch events. If it is set to
|
395
|
+
one of LeftMouseButtonGesture, RightMouseButtonGesture or
|
396
|
+
MiddleMouseButtonGesture it triggers on mouse events of the
|
397
|
+
corresponding button.
|
398
|
+
|
399
|
+
Only one scroll gesture can be active on a single object at the same
|
400
|
+
time. If you call this function twice on the same object, it will
|
401
|
+
ungrab the existing gesture before grabbing the new one.
|
402
|
+
|
403
|
+
\note To avoid unwanted side-effects, mouse events are consumed while
|
404
|
+
the gesture is triggered. Since the initial mouse press event is
|
405
|
+
not consumed, the gesture sends a fake mouse release event
|
406
|
+
at the global position \c{(INT_MIN, INT_MIN)}. This ensures that
|
407
|
+
internal states of the widget that received the original mouse press
|
408
|
+
are consistent.
|
409
|
+
|
410
|
+
\sa ungrabGesture, grabbedGesture
|
411
|
+
*/
|
412
|
+
Qt::GestureType QtScroller::grabGesture(QObject *target, ScrollerGestureType scrollGestureType)
|
413
|
+
{
|
414
|
+
// ensure that a scroller for target is created
|
415
|
+
QtScroller *s = scroller(target);
|
416
|
+
if (!s)
|
417
|
+
return Qt::GestureType(0);
|
418
|
+
|
419
|
+
QtScrollerPrivate *sp = s->d_ptr;
|
420
|
+
if (sp->recognizer)
|
421
|
+
ungrabGesture(target); // ungrab the old gesture
|
422
|
+
|
423
|
+
Qt::MouseButton button;
|
424
|
+
switch (scrollGestureType) {
|
425
|
+
case LeftMouseButtonGesture : button = Qt::LeftButton; break;
|
426
|
+
case RightMouseButtonGesture : button = Qt::RightButton; break;
|
427
|
+
case MiddleMouseButtonGesture: button = Qt::MidButton; break;
|
428
|
+
default :
|
429
|
+
case TouchGesture : button = Qt::NoButton; break; // NoButton == Touch
|
430
|
+
}
|
431
|
+
|
432
|
+
sp->recognizer = new QtFlickGestureRecognizer(button);
|
433
|
+
sp->recognizerType = QGestureRecognizer::registerRecognizer(sp->recognizer);
|
434
|
+
if (target->isWidgetType()) {
|
435
|
+
QWidget *widget = static_cast<QWidget *>(target);
|
436
|
+
widget->grabGesture(sp->recognizerType);
|
437
|
+
if (scrollGestureType == TouchGesture)
|
438
|
+
widget->setAttribute(Qt::WA_AcceptTouchEvents);
|
439
|
+
#if ITEMVIEW_SCROLLMODE_WARNING
|
440
|
+
QAbstractItemView *view = 0;
|
441
|
+
if ((view = qobject_cast<QAbstractItemView *>(widget->parentWidget())) &&
|
442
|
+
(view->viewport() == widget)) {
|
443
|
+
if (view->verticalScrollMode() != QAbstractItemView::ScrollPerPixel)
|
444
|
+
qWarning("QtScroller::grabGesture() was called on a QAbstractItemView with verticaScrollMode not set to ScrollPerPixel");
|
445
|
+
if (view->horizontalScrollMode() != QAbstractItemView::ScrollPerPixel)
|
446
|
+
qWarning("QtScroller::grabGesture() was called on a QAbstractItemView with horizontalScrollMode not set to ScrollPerPixel");
|
447
|
+
}
|
448
|
+
#endif // ITEMVIEW_SCROLLMODE_WARNING
|
449
|
+
} else if (QGraphicsObject *go = qobject_cast<QGraphicsObject*>(target)) {
|
450
|
+
if (scrollGestureType == TouchGesture)
|
451
|
+
go->setAcceptTouchEvents(true);
|
452
|
+
go->grabGesture(sp->recognizerType);
|
453
|
+
}
|
454
|
+
|
455
|
+
// vvv QScroller Solution only
|
456
|
+
QtScrollerFilter::instance()->add(target);
|
457
|
+
// ^^^ QScroller Solution only
|
458
|
+
|
459
|
+
return sp->recognizerType;
|
460
|
+
}
|
461
|
+
|
462
|
+
/*!
|
463
|
+
Returns the gesture type currently grabbed for the \a target or 0 if no
|
464
|
+
gesture is grabbed.
|
465
|
+
|
466
|
+
\sa grabGesture, ungrabGesture
|
467
|
+
*/
|
468
|
+
Qt::GestureType QtScroller::grabbedGesture(QObject *target)
|
469
|
+
{
|
470
|
+
QtScroller *s = scroller(target);
|
471
|
+
if (s && s->d_ptr)
|
472
|
+
return s->d_ptr->recognizerType;
|
473
|
+
else
|
474
|
+
return Qt::GestureType(0);
|
475
|
+
}
|
476
|
+
|
477
|
+
/*!
|
478
|
+
Ungrabs the gesture for the \a target.
|
479
|
+
Does nothing if no gesture is grabbed.
|
480
|
+
|
481
|
+
\sa grabGesture, grabbedGesture
|
482
|
+
*/
|
483
|
+
void QtScroller::ungrabGesture(QObject *target)
|
484
|
+
{
|
485
|
+
QtScroller *s = scroller(target);
|
486
|
+
if (!s)
|
487
|
+
return;
|
488
|
+
|
489
|
+
QtScrollerPrivate *sp = s->d_ptr;
|
490
|
+
if (!sp->recognizer)
|
491
|
+
return; // nothing to do
|
492
|
+
|
493
|
+
if (target->isWidgetType()) {
|
494
|
+
QWidget *widget = static_cast<QWidget *>(target);
|
495
|
+
widget->ungrabGesture(sp->recognizerType);
|
496
|
+
|
497
|
+
} else if (QGraphicsObject *go = qobject_cast<QGraphicsObject*>(target)) {
|
498
|
+
go->ungrabGesture(sp->recognizerType);
|
499
|
+
}
|
500
|
+
|
501
|
+
QGestureRecognizer::unregisterRecognizer(sp->recognizerType);
|
502
|
+
// do not delete the recognizer. The QGestureManager is doing this.
|
503
|
+
sp->recognizer = 0;
|
504
|
+
|
505
|
+
// vvv QScroller Solution only
|
506
|
+
QtScrollerFilter::instance()->remove(target);
|
507
|
+
// ^^^ QScroller Solution only
|
508
|
+
}
|
509
|
+
|
510
|
+
/*!
|
511
|
+
\internal
|
512
|
+
*/
|
513
|
+
QtScroller::QtScroller(QObject *target)
|
514
|
+
: d_ptr(new QtScrollerPrivate(this, target))
|
515
|
+
{
|
516
|
+
Q_ASSERT(target); // you can't create a scroller without a target in any normal way
|
517
|
+
Q_D(QtScroller);
|
518
|
+
d->init();
|
519
|
+
}
|
520
|
+
|
521
|
+
/*!
|
522
|
+
\internal
|
523
|
+
*/
|
524
|
+
QtScroller::~QtScroller()
|
525
|
+
{
|
526
|
+
Q_D(QtScroller);
|
527
|
+
QGestureRecognizer::unregisterRecognizer(d->recognizerType);
|
528
|
+
// do not delete the recognizer. The QGestureManager is doing this.
|
529
|
+
d->recognizer = 0;
|
530
|
+
QtScrollerPrivate::allScrollers.remove(d->target);
|
531
|
+
QtScrollerPrivate::activeScrollers.remove(this);
|
532
|
+
|
533
|
+
delete d_ptr;
|
534
|
+
}
|
535
|
+
|
536
|
+
|
537
|
+
/*!
|
538
|
+
\fn QtScroller::stateChanged(QtScroller::State newState);
|
539
|
+
|
540
|
+
QtScroller emits this signal whenever the state changes. \a newState is the new State.
|
541
|
+
|
542
|
+
\sa state
|
543
|
+
*/
|
544
|
+
|
545
|
+
/*!
|
546
|
+
\property QtScroller::state
|
547
|
+
\brief the state of the scroller
|
548
|
+
|
549
|
+
\sa QtScroller::State
|
550
|
+
*/
|
551
|
+
QtScroller::State QtScroller::state() const
|
552
|
+
{
|
553
|
+
Q_D(const QtScroller);
|
554
|
+
return d->state;
|
555
|
+
}
|
556
|
+
|
557
|
+
/*!
|
558
|
+
Stops the scroller and resets its state back to Inactive.
|
559
|
+
*/
|
560
|
+
void QtScroller::stop()
|
561
|
+
{
|
562
|
+
Q_D(QtScroller);
|
563
|
+
if (d->state != Inactive) {
|
564
|
+
QPointF here = clampToRect(d->contentPosition, d->contentPosRange);
|
565
|
+
qreal snapX = d->nextSnapPos(here.x(), 0, Qt::Horizontal);
|
566
|
+
qreal snapY = d->nextSnapPos(here.y(), 0, Qt::Vertical);
|
567
|
+
QPointF snap = here;
|
568
|
+
if (!qIsNaN(snapX))
|
569
|
+
snap.setX(snapX);
|
570
|
+
if (!qIsNaN(snapY))
|
571
|
+
snap.setY(snapY);
|
572
|
+
d->contentPosition = snap;
|
573
|
+
d->overshootPosition = QPointF(0, 0);
|
574
|
+
|
575
|
+
d->setState(Inactive);
|
576
|
+
}
|
577
|
+
}
|
578
|
+
|
579
|
+
/*!
|
580
|
+
Returns the pixel per meter metric for the scrolled widget.
|
581
|
+
|
582
|
+
The value is reported for both the x and y axis separately by using a QPointF.
|
583
|
+
|
584
|
+
\note Please note that this value should be physically correct. The actual DPI settings
|
585
|
+
that Qt returns for the display may be reported wrongly on purpose by the underlying
|
586
|
+
windowing system, for example on Mac OS X or Maemo 5.
|
587
|
+
*/
|
588
|
+
QPointF QtScroller::pixelPerMeter() const
|
589
|
+
{
|
590
|
+
Q_D(const QtScroller);
|
591
|
+
QPointF ppm = d->pixelPerMeter;
|
592
|
+
|
593
|
+
if (QGraphicsObject *go = qobject_cast<QGraphicsObject *>(d->target)) {
|
594
|
+
QTransform viewtr;
|
595
|
+
//TODO: the first view isn't really correct - maybe use an additional field in the prepare event?
|
596
|
+
if (go->scene() && !go->scene()->views().isEmpty())
|
597
|
+
viewtr = go->scene()->views().first()->viewportTransform();
|
598
|
+
QTransform tr = go->deviceTransform(viewtr);
|
599
|
+
if (tr.isScaling()) {
|
600
|
+
QPointF p0 = tr.map(QPointF(0, 0));
|
601
|
+
QPointF px = tr.map(QPointF(1, 0));
|
602
|
+
QPointF py = tr.map(QPointF(0, 1));
|
603
|
+
ppm.rx() /= QLineF(p0, px).length();
|
604
|
+
ppm.ry() /= QLineF(p0, py).length();
|
605
|
+
}
|
606
|
+
}
|
607
|
+
return ppm;
|
608
|
+
}
|
609
|
+
|
610
|
+
/*!
|
611
|
+
Returns the current scrolling velocity in meter per second when the state is Scrolling or Dragging.
|
612
|
+
Returns a zero velocity otherwise.
|
613
|
+
|
614
|
+
The velocity is reported for both the x and y axis separately by using a QPointF.
|
615
|
+
|
616
|
+
\sa pixelPerMeter()
|
617
|
+
*/
|
618
|
+
QPointF QtScroller::velocity() const
|
619
|
+
{
|
620
|
+
Q_D(const QtScroller);
|
621
|
+
const QtScrollerPropertiesPrivate *sp = d->properties.d.data();
|
622
|
+
|
623
|
+
switch (state()) {
|
624
|
+
case Dragging:
|
625
|
+
return d->releaseVelocity;
|
626
|
+
case Scrolling: {
|
627
|
+
QPointF vel;
|
628
|
+
qint64 now = d->monotonicTimer.elapsed();
|
629
|
+
|
630
|
+
if (!d->xSegments.isEmpty()) {
|
631
|
+
const QtScrollerPrivate::ScrollSegment &s = d->xSegments.head();
|
632
|
+
qreal progress = qreal(now - s.startTime) / qreal(s.deltaTime);
|
633
|
+
qreal v = qSign(s.deltaPos) * qreal(s.deltaTime) / qreal(1000) * sp->decelerationFactor * qreal(0.5) * differentialForProgress(s.curve, progress);
|
634
|
+
vel.setX(v);
|
635
|
+
}
|
636
|
+
|
637
|
+
if (!d->ySegments.isEmpty()) {
|
638
|
+
const QtScrollerPrivate::ScrollSegment &s = d->ySegments.head();
|
639
|
+
qreal progress = qreal(now - s.startTime) / qreal(s.deltaTime);
|
640
|
+
qreal v = qSign(s.deltaPos) * qreal(s.deltaTime) / qreal(1000) * sp->decelerationFactor * qreal(0.5) * differentialForProgress(s.curve, progress);
|
641
|
+
vel.setY(v);
|
642
|
+
}
|
643
|
+
return vel;
|
644
|
+
}
|
645
|
+
default:
|
646
|
+
return QPointF(0, 0);
|
647
|
+
}
|
648
|
+
}
|
649
|
+
|
650
|
+
/*!
|
651
|
+
Returns the estimated final position for the current scroll movement.
|
652
|
+
Returns the current position if the scroller state is not Scrolling.
|
653
|
+
The result is undefined when the scroller state is Inactive.
|
654
|
+
|
655
|
+
The target position is in pixel.
|
656
|
+
|
657
|
+
\sa pixelPerMeter(), scrollTo()
|
658
|
+
*/
|
659
|
+
QPointF QtScroller::finalPosition() const
|
660
|
+
{
|
661
|
+
Q_D(const QtScroller);
|
662
|
+
return QPointF(d->scrollingSegmentsEndPos(Qt::Horizontal),
|
663
|
+
d->scrollingSegmentsEndPos(Qt::Vertical));
|
664
|
+
}
|
665
|
+
|
666
|
+
/*!
|
667
|
+
Starts scrolling the widget so that point \a pos is at the top-left position in
|
668
|
+
the viewport.
|
669
|
+
|
670
|
+
The behaviour when scrolling outside the valid scroll area is undefined.
|
671
|
+
In this case the scroller might or might not overshoot.
|
672
|
+
|
673
|
+
The scrolling speed will be calculated so that the given position will
|
674
|
+
be reached after a platform-defined time span.
|
675
|
+
|
676
|
+
\a pos is given in viewport coordinates.
|
677
|
+
|
678
|
+
\sa ensureVisible()
|
679
|
+
*/
|
680
|
+
void QtScroller::scrollTo(const QPointF &pos)
|
681
|
+
{
|
682
|
+
// we could make this adjustable via QtScrollerProperties
|
683
|
+
scrollTo(pos, 300);
|
684
|
+
}
|
685
|
+
|
686
|
+
/*! \overload
|
687
|
+
|
688
|
+
This version will reach its destination position in \a scrollTime milliseconds.
|
689
|
+
*/
|
690
|
+
void QtScroller::scrollTo(const QPointF &pos, int scrollTime)
|
691
|
+
{
|
692
|
+
Q_D(QtScroller);
|
693
|
+
|
694
|
+
if (d->state == Pressed || d->state == Dragging )
|
695
|
+
return;
|
696
|
+
|
697
|
+
// no need to resend a prepare event if we are already scrolling
|
698
|
+
if (d->state == Inactive && !d->prepareScrolling(QPointF()))
|
699
|
+
return;
|
700
|
+
|
701
|
+
QPointF newpos = clampToRect(pos, d->contentPosRange);
|
702
|
+
qreal snapX = d->nextSnapPos(newpos.x(), 0, Qt::Horizontal);
|
703
|
+
qreal snapY = d->nextSnapPos(newpos.y(), 0, Qt::Vertical);
|
704
|
+
if (!qIsNaN(snapX))
|
705
|
+
newpos.setX(snapX);
|
706
|
+
if (!qIsNaN(snapY))
|
707
|
+
newpos.setY(snapY);
|
708
|
+
|
709
|
+
qScrollerDebug() << "QtScroller::scrollTo(req:" << pos << " [pix] / snap:" << newpos << ", " << scrollTime << " [ms])";
|
710
|
+
|
711
|
+
if (newpos == d->contentPosition + d->overshootPosition)
|
712
|
+
return;
|
713
|
+
|
714
|
+
QPointF vel = velocity();
|
715
|
+
|
716
|
+
if (scrollTime < 0)
|
717
|
+
scrollTime = 0;
|
718
|
+
qreal time = qreal(scrollTime) / 1000;
|
719
|
+
|
720
|
+
d->createScrollToSegments(vel.x(), time, newpos.x(), Qt::Horizontal, QtScrollerPrivate::ScrollTypeScrollTo);
|
721
|
+
d->createScrollToSegments(vel.y(), time, newpos.y(), Qt::Vertical, QtScrollerPrivate::ScrollTypeScrollTo);
|
722
|
+
|
723
|
+
if (!scrollTime)
|
724
|
+
d->setContentPositionHelperScrolling();
|
725
|
+
d->setState(scrollTime ? Scrolling : Inactive);
|
726
|
+
}
|
727
|
+
|
728
|
+
/*!
|
729
|
+
Starts scrolling so that the rectangle \a rect is visible inside the
|
730
|
+
viewport with additional margins specified in pixels by \a xmargin and \a ymargin around
|
731
|
+
the rect.
|
732
|
+
|
733
|
+
In cases where it is not possible to fit the rect plus margins inside the viewport the contents
|
734
|
+
are scrolled so that as much as possible is visible from \a rect.
|
735
|
+
|
736
|
+
The scrolling speed is calculated so that the given position is reached after a platform-defined
|
737
|
+
time span.
|
738
|
+
|
739
|
+
This function performs the actual scrolling by calling scrollTo().
|
740
|
+
|
741
|
+
\sa scrollTo
|
742
|
+
*/
|
743
|
+
void QtScroller::ensureVisible(const QRectF &rect, qreal xmargin, qreal ymargin)
|
744
|
+
{
|
745
|
+
// we could make this adjustable via QtScrollerProperties
|
746
|
+
ensureVisible(rect, xmargin, ymargin, 1000);
|
747
|
+
}
|
748
|
+
|
749
|
+
/*! \overload
|
750
|
+
|
751
|
+
This version will reach its destination position in \a scrollTime milliseconds.
|
752
|
+
*/
|
753
|
+
void QtScroller::ensureVisible(const QRectF &rect, qreal xmargin, qreal ymargin, int scrollTime)
|
754
|
+
{
|
755
|
+
Q_D(QtScroller);
|
756
|
+
|
757
|
+
if (d->state == Pressed || d->state == Dragging)
|
758
|
+
return;
|
759
|
+
|
760
|
+
if (d->state == Inactive && !d->prepareScrolling(QPointF()))
|
761
|
+
return;
|
762
|
+
|
763
|
+
// -- calculate the current pos (or the position after the current scroll)
|
764
|
+
QPointF startPos = d->contentPosition + d->overshootPosition;
|
765
|
+
startPos = QPointF(d->scrollingSegmentsEndPos(Qt::Horizontal),
|
766
|
+
d->scrollingSegmentsEndPos(Qt::Vertical));
|
767
|
+
|
768
|
+
QRectF marginRect(rect.x() - xmargin, rect.y() - ymargin,
|
769
|
+
rect.width() + 2 * xmargin, rect.height() + 2 * ymargin);
|
770
|
+
|
771
|
+
QSizeF visible = d->viewportSize;
|
772
|
+
QRectF visibleRect(startPos, visible);
|
773
|
+
|
774
|
+
qScrollerDebug() << "QtScroller::ensureVisible(" << rect << " [pix], " << xmargin << " [pix], " << ymargin << " [pix], " << scrollTime << "[ms])";
|
775
|
+
qScrollerDebug() << " --> content position:" << d->contentPosition;
|
776
|
+
|
777
|
+
if (visibleRect.contains(marginRect))
|
778
|
+
return;
|
779
|
+
|
780
|
+
QPointF newPos = startPos;
|
781
|
+
|
782
|
+
if (visibleRect.width() < rect.width()) {
|
783
|
+
// at least try to move the rect into view
|
784
|
+
if (rect.left() > visibleRect.left())
|
785
|
+
newPos.setX(rect.left());
|
786
|
+
else if (rect.right() < visibleRect.right())
|
787
|
+
newPos.setX(rect.right() - visible.width());
|
788
|
+
|
789
|
+
} else if (visibleRect.width() < marginRect.width()) {
|
790
|
+
newPos.setX(rect.center().x() - visibleRect.width() / 2);
|
791
|
+
} else if (marginRect.left() > visibleRect.left()) {
|
792
|
+
newPos.setX(marginRect.left());
|
793
|
+
} else if (marginRect.right() < visibleRect.right()) {
|
794
|
+
newPos.setX(marginRect.right() - visible.width());
|
795
|
+
}
|
796
|
+
|
797
|
+
if (visibleRect.height() < rect.height()) {
|
798
|
+
// at least try to move the rect into view
|
799
|
+
if (rect.top() > visibleRect.top())
|
800
|
+
newPos.setX(rect.top());
|
801
|
+
else if (rect.bottom() < visibleRect.bottom())
|
802
|
+
newPos.setX(rect.bottom() - visible.height());
|
803
|
+
|
804
|
+
} else if (visibleRect.height() < marginRect.height()) {
|
805
|
+
newPos.setY(rect.center().y() - visibleRect.height() / 2);
|
806
|
+
} else if (marginRect.top() > visibleRect.top()) {
|
807
|
+
newPos.setY(marginRect.top());
|
808
|
+
} else if (marginRect.bottom() < visibleRect.bottom()) {
|
809
|
+
newPos.setY(marginRect.bottom() - visible.height());
|
810
|
+
}
|
811
|
+
|
812
|
+
// clamp to maximum content position
|
813
|
+
newPos = clampToRect(newPos, d->contentPosRange);
|
814
|
+
if (newPos == startPos)
|
815
|
+
return;
|
816
|
+
|
817
|
+
scrollTo(newPos, scrollTime);
|
818
|
+
}
|
819
|
+
|
820
|
+
/*! This function resends the QScrollPrepareEvent.
|
821
|
+
Calling resendPrepareEvent triggers a QScrollPrepareEvent from the scroller.
|
822
|
+
This allows the receiver to re-set content position and content size while
|
823
|
+
scrolling.
|
824
|
+
Calling this function while in the Inactive state is useless as the prepare event
|
825
|
+
is sent again before scrolling starts.
|
826
|
+
*/
|
827
|
+
void QtScroller::resendPrepareEvent()
|
828
|
+
{
|
829
|
+
Q_D(QtScroller);
|
830
|
+
d->prepareScrolling(d->pressPosition);
|
831
|
+
}
|
832
|
+
|
833
|
+
/*! Set the snap positions for the horizontal axis to a list of \a positions.
|
834
|
+
This overwrites all previously set snap positions and also a previously
|
835
|
+
set snapping interval.
|
836
|
+
Snapping can be deactivated by setting an empty list of positions.
|
837
|
+
*/
|
838
|
+
void QtScroller::setSnapPositionsX(const QList<qreal> &positions)
|
839
|
+
{
|
840
|
+
Q_D(QtScroller);
|
841
|
+
d->snapPositionsX = positions;
|
842
|
+
d->snapIntervalX = 0.0;
|
843
|
+
|
844
|
+
d->recalcScrollingSegments();
|
845
|
+
}
|
846
|
+
|
847
|
+
/*! Set the snap positions for the horizontal axis to regular spaced intervals.
|
848
|
+
The first snap position is at \a first. The next at \a first + \a interval.
|
849
|
+
This can be used to implement a list header.
|
850
|
+
This overwrites all previously set snap positions and also a previously
|
851
|
+
set snapping interval.
|
852
|
+
Snapping can be deactivated by setting an interval of 0.0
|
853
|
+
*/
|
854
|
+
void QtScroller::setSnapPositionsX(qreal first, qreal interval)
|
855
|
+
{
|
856
|
+
Q_D(QtScroller);
|
857
|
+
d->snapFirstX = first;
|
858
|
+
d->snapIntervalX = interval;
|
859
|
+
d->snapPositionsX.clear();
|
860
|
+
|
861
|
+
d->recalcScrollingSegments();
|
862
|
+
}
|
863
|
+
|
864
|
+
/*! Set the snap positions for the vertical axis to a list of \a positions.
|
865
|
+
This overwrites all previously set snap positions and also a previously
|
866
|
+
set snapping interval.
|
867
|
+
Snapping can be deactivated by setting an empty list of positions.
|
868
|
+
*/
|
869
|
+
void QtScroller::setSnapPositionsY(const QList<qreal> &positions)
|
870
|
+
{
|
871
|
+
Q_D(QtScroller);
|
872
|
+
d->snapPositionsY = positions;
|
873
|
+
d->snapIntervalY = 0.0;
|
874
|
+
|
875
|
+
d->recalcScrollingSegments();
|
876
|
+
}
|
877
|
+
|
878
|
+
/*! Set the snap positions for the vertical axis to regular spaced intervals.
|
879
|
+
The first snap position is at \a first. The next at \a first + \a interval.
|
880
|
+
This overwrites all previously set snap positions and also a previously
|
881
|
+
set snapping interval.
|
882
|
+
Snapping can be deactivated by setting an interval of 0.0
|
883
|
+
*/
|
884
|
+
void QtScroller::setSnapPositionsY(qreal first, qreal interval)
|
885
|
+
{
|
886
|
+
Q_D(QtScroller);
|
887
|
+
d->snapFirstY = first;
|
888
|
+
d->snapIntervalY = interval;
|
889
|
+
d->snapPositionsY.clear();
|
890
|
+
|
891
|
+
d->recalcScrollingSegments();
|
892
|
+
}
|
893
|
+
|
894
|
+
|
895
|
+
|
896
|
+
// -------------- private ------------
|
897
|
+
|
898
|
+
QtScrollerPrivate::QtScrollerPrivate(QtScroller *q, QObject *_target)
|
899
|
+
: target(_target)
|
900
|
+
, recognizer(0)
|
901
|
+
, recognizerType(Qt::CustomGesture)
|
902
|
+
, state(QtScroller::Inactive)
|
903
|
+
, firstScroll(true)
|
904
|
+
, pressTimestamp(0)
|
905
|
+
, lastTimestamp(0)
|
906
|
+
, snapFirstX(-1.0)
|
907
|
+
, snapIntervalX(0.0)
|
908
|
+
, snapFirstY(-1.0)
|
909
|
+
, snapIntervalY(0.0)
|
910
|
+
, scrollTimer(new QScrollTimer(this))
|
911
|
+
, q_ptr(q)
|
912
|
+
{
|
913
|
+
connect(target, SIGNAL(destroyed(QObject*)), this, SLOT(targetDestroyed()));
|
914
|
+
}
|
915
|
+
|
916
|
+
void QtScrollerPrivate::init()
|
917
|
+
{
|
918
|
+
setDpiFromWidget(0);
|
919
|
+
monotonicTimer.start();
|
920
|
+
}
|
921
|
+
|
922
|
+
void QtScrollerPrivate::sendEvent(QObject *o, QEvent *e)
|
923
|
+
{
|
924
|
+
qt_sendSpontaneousEvent(o, e);
|
925
|
+
}
|
926
|
+
|
927
|
+
const char *QtScrollerPrivate::stateName(QtScroller::State state)
|
928
|
+
{
|
929
|
+
switch (state) {
|
930
|
+
case QtScroller::Inactive: return "inactive";
|
931
|
+
case QtScroller::Pressed: return "pressed";
|
932
|
+
case QtScroller::Dragging: return "dragging";
|
933
|
+
case QtScroller::Scrolling: return "scrolling";
|
934
|
+
default: return "(invalid)";
|
935
|
+
}
|
936
|
+
}
|
937
|
+
|
938
|
+
const char *QtScrollerPrivate::inputName(QtScroller::Input input)
|
939
|
+
{
|
940
|
+
switch (input) {
|
941
|
+
case QtScroller::InputPress: return "press";
|
942
|
+
case QtScroller::InputMove: return "move";
|
943
|
+
case QtScroller::InputRelease: return "release";
|
944
|
+
default: return "(invalid)";
|
945
|
+
}
|
946
|
+
}
|
947
|
+
|
948
|
+
void QtScrollerPrivate::targetDestroyed()
|
949
|
+
{
|
950
|
+
scrollTimer->stop();
|
951
|
+
delete q_ptr;
|
952
|
+
}
|
953
|
+
|
954
|
+
void QtScrollerPrivate::timerTick()
|
955
|
+
{
|
956
|
+
struct timerevent {
|
957
|
+
QtScroller::State state;
|
958
|
+
typedef void (QtScrollerPrivate::*timerhandler_t)();
|
959
|
+
timerhandler_t handler;
|
960
|
+
};
|
961
|
+
|
962
|
+
timerevent timerevents[] = {
|
963
|
+
{ QtScroller::Dragging, &QtScrollerPrivate::timerEventWhileDragging },
|
964
|
+
{ QtScroller::Scrolling, &QtScrollerPrivate::timerEventWhileScrolling },
|
965
|
+
};
|
966
|
+
|
967
|
+
for (int i = 0; i < int(sizeof(timerevents) / sizeof(*timerevents)); ++i) {
|
968
|
+
timerevent *te = timerevents + i;
|
969
|
+
|
970
|
+
if (state == te->state) {
|
971
|
+
(this->*te->handler)();
|
972
|
+
return;
|
973
|
+
}
|
974
|
+
}
|
975
|
+
|
976
|
+
scrollTimer->stop();
|
977
|
+
}
|
978
|
+
|
979
|
+
/*!
|
980
|
+
This function is used by gesture recognizers to inform the scroller about a new input event.
|
981
|
+
The scroller changes its internal state() according to the input event and its attached
|
982
|
+
scroller properties. The scroller doesn't distinguish between the kind of input device the
|
983
|
+
event came from. Therefore the event needs to be split into the \a input type, a \a position and a
|
984
|
+
milli-second \a timestamp. The \a position needs to be in the target's coordinate system.
|
985
|
+
|
986
|
+
The return value is \c true if the event should be consumed by the calling filter or \c false
|
987
|
+
if the event should be forwarded to the control.
|
988
|
+
|
989
|
+
\note Using grabGesture() should be sufficient for most use cases.
|
990
|
+
*/
|
991
|
+
bool QtScroller::handleInput(Input input, const QPointF &position, qint64 timestamp)
|
992
|
+
{
|
993
|
+
Q_D(QtScroller);
|
994
|
+
|
995
|
+
qScrollerDebug() << "QtScroller::handleInput(" << input << ", " << d->stateName(d->state) << ", " << position << ", " << timestamp << ")";
|
996
|
+
struct statechange {
|
997
|
+
State state;
|
998
|
+
Input input;
|
999
|
+
typedef bool (QtScrollerPrivate::*inputhandler_t)(const QPointF &position, qint64 timestamp);
|
1000
|
+
inputhandler_t handler;
|
1001
|
+
};
|
1002
|
+
|
1003
|
+
statechange statechanges[] = {
|
1004
|
+
{ QtScroller::Inactive, InputPress, &QtScrollerPrivate::pressWhileInactive },
|
1005
|
+
{ QtScroller::Pressed, InputMove, &QtScrollerPrivate::moveWhilePressed },
|
1006
|
+
{ QtScroller::Pressed, InputRelease, &QtScrollerPrivate::releaseWhilePressed },
|
1007
|
+
{ QtScroller::Dragging, InputMove, &QtScrollerPrivate::moveWhileDragging },
|
1008
|
+
{ QtScroller::Dragging, InputRelease, &QtScrollerPrivate::releaseWhileDragging },
|
1009
|
+
{ QtScroller::Scrolling, InputPress, &QtScrollerPrivate::pressWhileScrolling }
|
1010
|
+
};
|
1011
|
+
|
1012
|
+
for (int i = 0; i < int(sizeof(statechanges) / sizeof(*statechanges)); ++i) {
|
1013
|
+
statechange *sc = statechanges + i;
|
1014
|
+
|
1015
|
+
if (d->state == sc->state && input == sc->input)
|
1016
|
+
return (d->*sc->handler)(position - d->overshootPosition, timestamp);
|
1017
|
+
}
|
1018
|
+
return false;
|
1019
|
+
}
|
1020
|
+
|
1021
|
+
#if !defined(Q_WS_MAC)
|
1022
|
+
// the Mac version is implemented in qtscroller_mac.mm
|
1023
|
+
|
1024
|
+
QPointF QtScrollerPrivate::realDpi(int screen)
|
1025
|
+
{
|
1026
|
+
# ifdef Q_WS_MAEMO_5
|
1027
|
+
Q_UNUSED(screen);
|
1028
|
+
|
1029
|
+
// The DPI value is hardcoded to 96 on Maemo5:
|
1030
|
+
// https://projects.maemo.org/bugzilla/show_bug.cgi?id=152525
|
1031
|
+
// This value (260) is only correct for the N900 though, but
|
1032
|
+
// there's no way to get the real DPI at run time.
|
1033
|
+
return QPointF(260, 260);
|
1034
|
+
|
1035
|
+
# elif defined(Q_WS_X11) && !defined(QT_NO_XRANDR)
|
1036
|
+
// Avoid including the libXRandR header for a very simple struct
|
1037
|
+
struct structXRRScreenSize
|
1038
|
+
{
|
1039
|
+
int width, height;
|
1040
|
+
int mwidth, mheight;
|
1041
|
+
};
|
1042
|
+
typedef structXRRScreenSize *(*PtrXRRSizes)(Display *, int, int *);
|
1043
|
+
typedef int (*PtrXRRRootToScreen)(Display *, Qt::HANDLE);
|
1044
|
+
static PtrXRRSizes ptrXRRSizes = 0;
|
1045
|
+
static PtrXRRRootToScreen ptrXRRRootToScreen = 0;
|
1046
|
+
static bool resolvedXRR = false;
|
1047
|
+
|
1048
|
+
if (!resolvedXRR) {
|
1049
|
+
QLibrary xrandrLib(QLatin1String("Xrandr"), 2);
|
1050
|
+
if (!xrandrLib.load()) { // try without the version number
|
1051
|
+
xrandrLib.setFileName(QLatin1String("Xrandr"));
|
1052
|
+
xrandrLib.load();
|
1053
|
+
}
|
1054
|
+
if (xrandrLib.isLoaded()) {
|
1055
|
+
ptrXRRSizes = (PtrXRRSizes) xrandrLib.resolve("XRRSizes");
|
1056
|
+
ptrXRRRootToScreen = (PtrXRRRootToScreen) xrandrLib.resolve("XRRRootToScreen");
|
1057
|
+
}
|
1058
|
+
resolvedXRR = true;
|
1059
|
+
}
|
1060
|
+
|
1061
|
+
if (ptrXRRSizes && ptrXRRRootToScreen) {
|
1062
|
+
int nsizes = 0;
|
1063
|
+
// QDesktopWidget is based on Xinerama screens, which do not always
|
1064
|
+
// correspond to RandR screens: NVidia's TwinView e.g. will show up
|
1065
|
+
// as 2 screens in QDesktopWidget, but libXRandR will only see 1 screen.
|
1066
|
+
// (although with the combined size of the Xinerama screens).
|
1067
|
+
// Additionally, libXrandr will simply crash when calling XRRSizes
|
1068
|
+
// for (the non-existant) screen 1 in this scenario.
|
1069
|
+
Qt::HANDLE root = QX11Info::appRootWindow(screen == -1 ? QX11Info::appScreen() : screen);
|
1070
|
+
int randrscreen = (root != 0) ? ptrXRRRootToScreen(QX11Info::display(), root) : -1;
|
1071
|
+
|
1072
|
+
structXRRScreenSize *sizes = ptrXRRSizes(QX11Info::display(), randrscreen == -1 ? 0 : randrscreen, &nsizes);
|
1073
|
+
|
1074
|
+
if (nsizes > 0 && sizes && sizes->width && sizes->height && sizes->mwidth && sizes->mheight) {
|
1075
|
+
qScrollerDebug() << "XRandR DPI:" << QPointF(qreal(25.4) * qreal(sizes->width) / qreal(sizes->mwidth),
|
1076
|
+
qreal(25.4) * qreal(sizes->height) / qreal(sizes->mheight));
|
1077
|
+
return QPointF(qreal(25.4) * qreal(sizes->width) / qreal(sizes->mwidth),
|
1078
|
+
qreal(25.4) * qreal(sizes->height) / qreal(sizes->mheight));
|
1079
|
+
}
|
1080
|
+
}
|
1081
|
+
# endif
|
1082
|
+
|
1083
|
+
QWidget *w = QApplication::desktop()->screen(screen);
|
1084
|
+
return QPointF(w->physicalDpiX(), w->physicalDpiY());
|
1085
|
+
}
|
1086
|
+
|
1087
|
+
#endif // !Q_WS_MAC
|
1088
|
+
|
1089
|
+
|
1090
|
+
/*! \internal
|
1091
|
+
Returns the resolution of the used screen.
|
1092
|
+
*/
|
1093
|
+
QPointF QtScrollerPrivate::dpi() const
|
1094
|
+
{
|
1095
|
+
return pixelPerMeter * qreal(0.0254);
|
1096
|
+
}
|
1097
|
+
|
1098
|
+
/*! \internal
|
1099
|
+
Sets the resolution used for scrolling.
|
1100
|
+
This resolution is only used by the kinetic scroller. If you change this
|
1101
|
+
then the scroller will behave quite different as a lot of the values are
|
1102
|
+
given in physical distances (millimeter).
|
1103
|
+
*/
|
1104
|
+
void QtScrollerPrivate::setDpi(const QPointF &dpi)
|
1105
|
+
{
|
1106
|
+
pixelPerMeter = dpi / qreal(0.0254);
|
1107
|
+
}
|
1108
|
+
|
1109
|
+
/*! \internal
|
1110
|
+
Sets the dpi used for scrolling to the value of the widget.
|
1111
|
+
*/
|
1112
|
+
void QtScrollerPrivate::setDpiFromWidget(QWidget *widget)
|
1113
|
+
{
|
1114
|
+
QDesktopWidget *dw = QApplication::desktop();
|
1115
|
+
setDpi(realDpi(widget ? dw->screenNumber(widget) : dw->primaryScreen()));
|
1116
|
+
}
|
1117
|
+
|
1118
|
+
/*! \internal
|
1119
|
+
Updates the velocity during dragging.
|
1120
|
+
Sets releaseVelocity.
|
1121
|
+
*/
|
1122
|
+
void QtScrollerPrivate::updateVelocity(const QPointF &deltaPixelRaw, qint64 deltaTime)
|
1123
|
+
{
|
1124
|
+
if (deltaTime <= 0)
|
1125
|
+
return;
|
1126
|
+
|
1127
|
+
Q_Q(QtScroller);
|
1128
|
+
QPointF ppm = q->pixelPerMeter();
|
1129
|
+
const QtScrollerPropertiesPrivate *sp = properties.d.data();
|
1130
|
+
QPointF deltaPixel = deltaPixelRaw;
|
1131
|
+
|
1132
|
+
qScrollerDebug() << "QtScroller::updateVelocity(" << deltaPixelRaw << " [delta pix], " << deltaTime << " [delta ms])";
|
1133
|
+
|
1134
|
+
// faster than 2.5mm/ms seems bogus (that would be a screen height in ~20 ms)
|
1135
|
+
if (((deltaPixelRaw / qreal(deltaTime)).manhattanLength() / ((ppm.x() + ppm.y()) / 2) * 1000) > qreal(2.5))
|
1136
|
+
deltaPixel = deltaPixelRaw * qreal(2.5) * ppm / 1000 / (deltaPixelRaw / qreal(deltaTime)).manhattanLength();
|
1137
|
+
|
1138
|
+
QPointF newv = -deltaPixel / qreal(deltaTime) * qreal(1000) / ppm;
|
1139
|
+
// around 95% of all updates are in the [1..50] ms range, so make sure
|
1140
|
+
// to scale the smoothing factor over that range: this way a 50ms update
|
1141
|
+
// will have full impact, while 5ms update will only have a 10% impact.
|
1142
|
+
qreal smoothing = sp->dragVelocitySmoothingFactor * qMin(qreal(deltaTime), qreal(50)) / qreal(50);
|
1143
|
+
|
1144
|
+
// only smooth if we already have a release velocity and only if the
|
1145
|
+
// user hasn't stopped to move his finger for more than 100ms
|
1146
|
+
if ((releaseVelocity != QPointF(0, 0)) && (deltaTime < 100)) {
|
1147
|
+
qScrollerDebug() << "SMOOTHED from " << newv << " to " << newv * smoothing + releaseVelocity * (qreal(1) - smoothing);
|
1148
|
+
// smooth x or y only if the new velocity is either 0 or at least in
|
1149
|
+
// the same direction of the release velocity
|
1150
|
+
if (!newv.x() || (qSign(releaseVelocity.x()) == qSign(newv.x())))
|
1151
|
+
newv.setX(newv.x() * smoothing + releaseVelocity.x() * (qreal(1) - smoothing));
|
1152
|
+
if (!newv.y() || (qSign(releaseVelocity.y()) == qSign(newv.y())))
|
1153
|
+
newv.setY(newv.y() * smoothing + releaseVelocity.y() * (qreal(1) - smoothing));
|
1154
|
+
} else
|
1155
|
+
qScrollerDebug() << "NO SMOOTHING to " << newv;
|
1156
|
+
|
1157
|
+
releaseVelocity.setX(qBound(-sp->maximumVelocity, newv.x(), sp->maximumVelocity));
|
1158
|
+
releaseVelocity.setY(qBound(-sp->maximumVelocity, newv.y(), sp->maximumVelocity));
|
1159
|
+
|
1160
|
+
qScrollerDebug() << " --> new velocity:" << releaseVelocity;
|
1161
|
+
}
|
1162
|
+
|
1163
|
+
void QtScrollerPrivate::pushSegment(ScrollType type, qreal deltaTime, qreal stopProgress, qreal startPos, qreal deltaPos, qreal stopPos, QEasingCurve::Type curve, Qt::Orientation orientation)
|
1164
|
+
{
|
1165
|
+
if (startPos == stopPos || deltaPos == 0)
|
1166
|
+
return;
|
1167
|
+
|
1168
|
+
ScrollSegment s;
|
1169
|
+
if (orientation == Qt::Horizontal && !xSegments.isEmpty())
|
1170
|
+
s.startTime = xSegments.last().startTime + xSegments.last().deltaTime * xSegments.last().stopProgress;
|
1171
|
+
else if (orientation == Qt::Vertical && !ySegments.isEmpty())
|
1172
|
+
s.startTime = ySegments.last().startTime + ySegments.last().deltaTime * ySegments.last().stopProgress;
|
1173
|
+
else
|
1174
|
+
s.startTime = monotonicTimer.elapsed();
|
1175
|
+
|
1176
|
+
s.startPos = startPos;
|
1177
|
+
s.deltaPos = deltaPos;
|
1178
|
+
s.stopPos = stopPos;
|
1179
|
+
s.deltaTime = deltaTime * 1000;
|
1180
|
+
s.stopProgress = stopProgress;
|
1181
|
+
s.curve.setType(curve);
|
1182
|
+
s.type = type;
|
1183
|
+
|
1184
|
+
if (orientation == Qt::Horizontal)
|
1185
|
+
xSegments.enqueue(s);
|
1186
|
+
else
|
1187
|
+
ySegments.enqueue(s);
|
1188
|
+
|
1189
|
+
qScrollerDebug() << "+++ Added a new ScrollSegment: " << s;
|
1190
|
+
}
|
1191
|
+
|
1192
|
+
|
1193
|
+
/*! \internal
|
1194
|
+
Clears the old segments and recalculates them if the current segments are not longer valid
|
1195
|
+
*/
|
1196
|
+
void QtScrollerPrivate::recalcScrollingSegments(bool forceRecalc)
|
1197
|
+
{
|
1198
|
+
Q_Q(QtScroller);
|
1199
|
+
QPointF ppm = q->pixelPerMeter();
|
1200
|
+
|
1201
|
+
releaseVelocity = q->velocity();
|
1202
|
+
|
1203
|
+
if (forceRecalc || !scrollingSegmentsValid(Qt::Horizontal))
|
1204
|
+
createScrollingSegments(releaseVelocity.x(), contentPosition.x() + overshootPosition.x(), ppm.x(), Qt::Horizontal);
|
1205
|
+
|
1206
|
+
if (forceRecalc || !scrollingSegmentsValid(Qt::Vertical))
|
1207
|
+
createScrollingSegments(releaseVelocity.y(), contentPosition.y() + overshootPosition.y(), ppm.y(), Qt::Vertical);
|
1208
|
+
}
|
1209
|
+
|
1210
|
+
/*! \internal
|
1211
|
+
Returns the end position after the current scroll has finished.
|
1212
|
+
*/
|
1213
|
+
qreal QtScrollerPrivate::scrollingSegmentsEndPos(Qt::Orientation orientation) const
|
1214
|
+
{
|
1215
|
+
if (orientation == Qt::Horizontal) {
|
1216
|
+
if (xSegments.isEmpty())
|
1217
|
+
return contentPosition.x() + overshootPosition.x();
|
1218
|
+
else
|
1219
|
+
return xSegments.last().stopPos;
|
1220
|
+
} else {
|
1221
|
+
if (ySegments.isEmpty())
|
1222
|
+
return contentPosition.y() + overshootPosition.y();
|
1223
|
+
else
|
1224
|
+
return ySegments.last().stopPos;
|
1225
|
+
}
|
1226
|
+
}
|
1227
|
+
|
1228
|
+
/*! \internal
|
1229
|
+
Checks if the scroller segment end in a valid position.
|
1230
|
+
*/
|
1231
|
+
bool QtScrollerPrivate::scrollingSegmentsValid(Qt::Orientation orientation)
|
1232
|
+
{
|
1233
|
+
QQueue<ScrollSegment> *segments;
|
1234
|
+
qreal minPos;
|
1235
|
+
qreal maxPos;
|
1236
|
+
|
1237
|
+
if (orientation == Qt::Horizontal) {
|
1238
|
+
segments = &xSegments;
|
1239
|
+
minPos = contentPosRange.left();
|
1240
|
+
maxPos = contentPosRange.right();
|
1241
|
+
} else {
|
1242
|
+
segments = &ySegments;
|
1243
|
+
minPos = contentPosRange.top();
|
1244
|
+
maxPos = contentPosRange.bottom();
|
1245
|
+
}
|
1246
|
+
|
1247
|
+
if (segments->isEmpty())
|
1248
|
+
return true;
|
1249
|
+
|
1250
|
+
const ScrollSegment &last = segments->last();
|
1251
|
+
qreal stopPos = last.stopPos;
|
1252
|
+
|
1253
|
+
if (last.type == ScrollTypeScrollTo)
|
1254
|
+
return true; // scrollTo is always valid
|
1255
|
+
|
1256
|
+
if (last.type == ScrollTypeOvershoot &&
|
1257
|
+
(stopPos != minPos && stopPos != maxPos))
|
1258
|
+
return false;
|
1259
|
+
|
1260
|
+
if (stopPos < minPos || stopPos > maxPos)
|
1261
|
+
return false;
|
1262
|
+
|
1263
|
+
if (stopPos == minPos || stopPos == maxPos) // the begin and the end of the list are always ok
|
1264
|
+
return true;
|
1265
|
+
|
1266
|
+
qreal nextSnap = nextSnapPos(stopPos, 0, orientation);
|
1267
|
+
if (!qIsNaN(nextSnap) && stopPos != nextSnap)
|
1268
|
+
return false;
|
1269
|
+
|
1270
|
+
return true;
|
1271
|
+
}
|
1272
|
+
|
1273
|
+
/*! \internal
|
1274
|
+
Creates the sections needed to scroll to the specific \a endPos to the segments queue.
|
1275
|
+
*/
|
1276
|
+
void QtScrollerPrivate::createScrollToSegments(qreal v, qreal deltaTime, qreal endPos, Qt::Orientation orientation, ScrollType type)
|
1277
|
+
{
|
1278
|
+
Q_UNUSED(v);
|
1279
|
+
|
1280
|
+
if (orientation == Qt::Horizontal)
|
1281
|
+
xSegments.clear();
|
1282
|
+
else
|
1283
|
+
ySegments.clear();
|
1284
|
+
|
1285
|
+
qScrollerDebug() << "+++ createScrollToSegments: t:" << deltaTime << "ep:" << endPos << "o:" << int(orientation);
|
1286
|
+
|
1287
|
+
const QtScrollerPropertiesPrivate *sp = properties.d.data();
|
1288
|
+
|
1289
|
+
qreal startPos = (orientation == Qt::Horizontal) ? contentPosition.x() + overshootPosition.x()
|
1290
|
+
: contentPosition.y() + overshootPosition.y();
|
1291
|
+
qreal deltaPos = (endPos - startPos) / 2;
|
1292
|
+
|
1293
|
+
pushSegment(type, deltaTime * qreal(0.3), qreal(1.0), startPos, deltaPos, startPos + deltaPos, QEasingCurve::InQuad, orientation);
|
1294
|
+
pushSegment(type, deltaTime * qreal(0.7), qreal(1.0), startPos + deltaPos, deltaPos, endPos, sp->scrollingCurve.type(), orientation);
|
1295
|
+
}
|
1296
|
+
|
1297
|
+
/*! \internal
|
1298
|
+
*/
|
1299
|
+
void QtScrollerPrivate::createScrollingSegments(qreal v, qreal startPos, qreal ppm, Qt::Orientation orientation)
|
1300
|
+
{
|
1301
|
+
const QtScrollerPropertiesPrivate *sp = properties.d.data();
|
1302
|
+
|
1303
|
+
QtScrollerProperties::OvershootPolicy policy;
|
1304
|
+
qreal minPos;
|
1305
|
+
qreal maxPos;
|
1306
|
+
qreal viewSize;
|
1307
|
+
|
1308
|
+
if (orientation == Qt::Horizontal) {
|
1309
|
+
xSegments.clear();
|
1310
|
+
policy = sp->hOvershootPolicy;
|
1311
|
+
minPos = contentPosRange.left();
|
1312
|
+
maxPos = contentPosRange.right();
|
1313
|
+
viewSize = viewportSize.width();
|
1314
|
+
} else {
|
1315
|
+
ySegments.clear();
|
1316
|
+
policy = sp->vOvershootPolicy;
|
1317
|
+
minPos = contentPosRange.top();
|
1318
|
+
maxPos = contentPosRange.bottom();
|
1319
|
+
viewSize = viewportSize.height();
|
1320
|
+
}
|
1321
|
+
|
1322
|
+
bool alwaysOvershoot = (policy == QtScrollerProperties::OvershootAlwaysOn);
|
1323
|
+
bool noOvershoot = (policy == QtScrollerProperties::OvershootAlwaysOff) || !sp->overshootScrollDistanceFactor;
|
1324
|
+
bool canOvershoot = !noOvershoot && (alwaysOvershoot || maxPos);
|
1325
|
+
|
1326
|
+
qScrollerDebug() << "+++ createScrollingSegments: s:" << startPos << "maxPos:" << maxPos << "o:" << int(orientation);
|
1327
|
+
|
1328
|
+
qScrollerDebug() << "v = " << v << ", decelerationFactor = " << sp->decelerationFactor << ", curveType = " << sp->scrollingCurve.type();
|
1329
|
+
|
1330
|
+
// This is only correct for QEasingCurve::OutQuad (linear velocity,
|
1331
|
+
// constant deceleration), but the results look and feel ok for OutExpo
|
1332
|
+
// and OutSine as well
|
1333
|
+
|
1334
|
+
// v(t) = deltaTime * a * 0.5 * differentialForProgress(t / deltaTime)
|
1335
|
+
// v(0) = vrelease
|
1336
|
+
// v(deltaTime) = 0
|
1337
|
+
// deltaTime = (2 * vrelease) / (a * differntial(0))
|
1338
|
+
|
1339
|
+
// pos(t) = integrate(v(t)dt)
|
1340
|
+
// pos(t) = vrelease * t - 0.5 * a * t * t
|
1341
|
+
// pos(t) = deltaTime * a * 0.5 * progress(t / deltaTime) * deltaTime
|
1342
|
+
// deltaPos = pos(deltaTime)
|
1343
|
+
|
1344
|
+
qreal deltaTime = (qreal(2) * qAbs(v)) / (sp->decelerationFactor * differentialForProgress(sp->scrollingCurve, 0));
|
1345
|
+
qreal deltaPos = qSign(v) * deltaTime * deltaTime * qreal(0.5) * sp->decelerationFactor * ppm;
|
1346
|
+
qreal endPos = startPos + deltaPos;
|
1347
|
+
|
1348
|
+
qScrollerDebug() << " Real Delta:" << deltaPos;
|
1349
|
+
|
1350
|
+
// -- determine snap points
|
1351
|
+
qreal nextSnap = nextSnapPos(endPos, 0, orientation);
|
1352
|
+
qreal lowerSnapPos = nextSnapPos(startPos, -1, orientation);
|
1353
|
+
qreal higherSnapPos = nextSnapPos(startPos, 1, orientation);
|
1354
|
+
|
1355
|
+
qScrollerDebug() << " Real Delta:" << lowerSnapPos <<"-"<<nextSnap <<"-"<<higherSnapPos;
|
1356
|
+
|
1357
|
+
// - check if we can reach another snap point
|
1358
|
+
if (nextSnap > higherSnapPos || qIsNaN(higherSnapPos))
|
1359
|
+
higherSnapPos = nextSnap;
|
1360
|
+
if (nextSnap < lowerSnapPos || qIsNaN(lowerSnapPos))
|
1361
|
+
lowerSnapPos = nextSnap;
|
1362
|
+
|
1363
|
+
// -- check if are in overshoot and end in overshoot
|
1364
|
+
if ((startPos < minPos && endPos < minPos) ||
|
1365
|
+
(startPos > maxPos && endPos > maxPos)) {
|
1366
|
+
qreal stopPos = endPos < minPos ? minPos : maxPos;
|
1367
|
+
qreal oDeltaTime = sp->overshootScrollTime;
|
1368
|
+
|
1369
|
+
pushSegment(ScrollTypeOvershoot, oDeltaTime * qreal(0.7), qreal(1.0), startPos, stopPos - startPos, stopPos, sp->scrollingCurve.type(), orientation);
|
1370
|
+
return;
|
1371
|
+
}
|
1372
|
+
|
1373
|
+
if (qAbs(v) < sp->minimumVelocity) {
|
1374
|
+
|
1375
|
+
qScrollerDebug() << "### below minimum Vel" << orientation;
|
1376
|
+
|
1377
|
+
// - no snap points or already at one
|
1378
|
+
if (qIsNaN(nextSnap) || nextSnap == startPos)
|
1379
|
+
return; // nothing to do, no scrolling needed.
|
1380
|
+
|
1381
|
+
// - decide which point to use
|
1382
|
+
|
1383
|
+
qreal snapDistance = higherSnapPos - lowerSnapPos;
|
1384
|
+
|
1385
|
+
qreal pressDistance = (orientation == Qt::Horizontal) ?
|
1386
|
+
lastPosition.x() - pressPosition.x() :
|
1387
|
+
lastPosition.y() - pressPosition.y();
|
1388
|
+
|
1389
|
+
// if not dragged far enough, pick the next snap point.
|
1390
|
+
if (sp->snapPositionRatio == 0.0 || qAbs(pressDistance / sp->snapPositionRatio) > snapDistance)
|
1391
|
+
endPos = nextSnap;
|
1392
|
+
else if (pressDistance < 0.0)
|
1393
|
+
endPos = lowerSnapPos;
|
1394
|
+
else
|
1395
|
+
endPos = higherSnapPos;
|
1396
|
+
|
1397
|
+
deltaPos = endPos - startPos;
|
1398
|
+
qreal midPos = startPos + deltaPos * qreal(0.3);
|
1399
|
+
pushSegment(ScrollTypeFlick, sp->snapTime * qreal(0.3), qreal(1.0), startPos, midPos - startPos, midPos, QEasingCurve::InQuad, orientation);
|
1400
|
+
pushSegment(ScrollTypeFlick, sp->snapTime * qreal(0.7), qreal(1.0), midPos, endPos - midPos, endPos, sp->scrollingCurve.type(), orientation);
|
1401
|
+
return;
|
1402
|
+
}
|
1403
|
+
|
1404
|
+
// - go to the next snappoint if there is one
|
1405
|
+
if (v > 0 && !qIsNaN(higherSnapPos)) {
|
1406
|
+
// change the time in relation to the changed end position
|
1407
|
+
if (endPos - startPos)
|
1408
|
+
deltaTime *= qAbs((higherSnapPos - startPos) / (endPos - startPos));
|
1409
|
+
if (deltaTime > sp->snapTime)
|
1410
|
+
deltaTime = sp->snapTime;
|
1411
|
+
endPos = higherSnapPos;
|
1412
|
+
|
1413
|
+
} else if (v < 0 && !qIsNaN(lowerSnapPos)) {
|
1414
|
+
// change the time in relation to the changed end position
|
1415
|
+
if (endPos - startPos)
|
1416
|
+
deltaTime *= qAbs((lowerSnapPos - startPos) / (endPos - startPos));
|
1417
|
+
if (deltaTime > sp->snapTime)
|
1418
|
+
deltaTime = sp->snapTime;
|
1419
|
+
endPos = lowerSnapPos;
|
1420
|
+
|
1421
|
+
// -- check if we are overshooting
|
1422
|
+
} else if (endPos < minPos || endPos > maxPos) {
|
1423
|
+
qreal stopPos = endPos < minPos ? minPos : maxPos;
|
1424
|
+
|
1425
|
+
qScrollerDebug() << "Overshoot: delta:" << (stopPos - startPos);
|
1426
|
+
|
1427
|
+
qreal stopProgress = progressForValue(sp->scrollingCurve, qAbs((stopPos - startPos) / deltaPos));
|
1428
|
+
|
1429
|
+
if (!canOvershoot) {
|
1430
|
+
qScrollerDebug() << "Overshoot stopp:" << stopProgress;
|
1431
|
+
|
1432
|
+
pushSegment(ScrollTypeFlick, deltaTime, stopProgress, startPos, endPos, stopPos, sp->scrollingCurve.type(), orientation);
|
1433
|
+
} else {
|
1434
|
+
qreal oDeltaTime = sp->overshootScrollTime;
|
1435
|
+
qreal oStopProgress = qMin(stopProgress + oDeltaTime * qreal(0.3) / deltaTime, qreal(1));
|
1436
|
+
qreal oDistance = startPos + deltaPos * sp->scrollingCurve.valueForProgress(oStopProgress) - stopPos;
|
1437
|
+
qreal oMaxDistance = qSign(oDistance) * (viewSize * sp->overshootScrollDistanceFactor);
|
1438
|
+
|
1439
|
+
qScrollerDebug() << "1 oDistance:" << oDistance << "Max:" << oMaxDistance << "stopP/oStopP" << stopProgress << oStopProgress;
|
1440
|
+
|
1441
|
+
if (qAbs(oDistance) > qAbs(oMaxDistance)) {
|
1442
|
+
oStopProgress = progressForValue(sp->scrollingCurve, qAbs((stopPos + oMaxDistance - startPos) / deltaPos));
|
1443
|
+
oDistance = oMaxDistance;
|
1444
|
+
qScrollerDebug() << "2 oDistance:" << oDistance << "Max:" << oMaxDistance << "stopP/oStopP" << stopProgress << oStopProgress;
|
1445
|
+
}
|
1446
|
+
|
1447
|
+
pushSegment(ScrollTypeFlick, deltaTime, oStopProgress, startPos, deltaPos, stopPos + oDistance, sp->scrollingCurve.type(), orientation);
|
1448
|
+
pushSegment(ScrollTypeOvershoot, oDeltaTime * qreal(0.7), qreal(1.0), stopPos + oDistance, -oDistance, stopPos, sp->scrollingCurve.type(), orientation);
|
1449
|
+
}
|
1450
|
+
return;
|
1451
|
+
}
|
1452
|
+
|
1453
|
+
pushSegment(ScrollTypeFlick, deltaTime, qreal(1.0), startPos, deltaPos, endPos, sp->scrollingCurve.type(), orientation);
|
1454
|
+
}
|
1455
|
+
|
1456
|
+
|
1457
|
+
/*! \internal
|
1458
|
+
Prepares scrolling by sending a QScrollPrepareEvent to the receiver widget.
|
1459
|
+
Returns true if the scrolling was accepted and a target was returned.
|
1460
|
+
*/
|
1461
|
+
bool QtScrollerPrivate::prepareScrolling(const QPointF &position)
|
1462
|
+
{
|
1463
|
+
QtScrollPrepareEvent spe(position);
|
1464
|
+
spe.ignore();
|
1465
|
+
sendEvent(target, &spe);
|
1466
|
+
|
1467
|
+
qScrollerDebug() << "QScrollPrepareEvent returned from" << target << "with" << spe.isAccepted() << "mcp:" << spe.contentPosRange() << "cp:" << spe.contentPos();
|
1468
|
+
if (spe.isAccepted()) {
|
1469
|
+
QPointF oldContentPos = contentPosition + overshootPosition;
|
1470
|
+
QPointF contentDelta = spe.contentPos() - oldContentPos;
|
1471
|
+
|
1472
|
+
viewportSize = spe.viewportSize();
|
1473
|
+
contentPosRange = spe.contentPosRange();
|
1474
|
+
if (contentPosRange.width() < 0)
|
1475
|
+
contentPosRange.setWidth(0);
|
1476
|
+
if (contentPosRange.height() < 0)
|
1477
|
+
contentPosRange.setHeight(0);
|
1478
|
+
contentPosition = clampToRect(spe.contentPos(), contentPosRange);
|
1479
|
+
overshootPosition = spe.contentPos() - contentPosition;
|
1480
|
+
|
1481
|
+
// - check if the content position was moved
|
1482
|
+
if (contentDelta != QPointF(0, 0)) {
|
1483
|
+
// need to correct all segments
|
1484
|
+
for (int i = 0; i < xSegments.count(); i++)
|
1485
|
+
xSegments[i].startPos -= contentDelta.x();
|
1486
|
+
|
1487
|
+
for (int i = 0; i < ySegments.count(); i++)
|
1488
|
+
ySegments[i].startPos -= contentDelta.y();
|
1489
|
+
}
|
1490
|
+
|
1491
|
+
if (QWidget *w = qobject_cast<QWidget *>(target))
|
1492
|
+
setDpiFromWidget(w);
|
1493
|
+
if (QGraphicsObject *go = qobject_cast<QGraphicsObject *>(target)) {
|
1494
|
+
//TODO: the first view isn't really correct - maybe use an additional field in the prepare event?
|
1495
|
+
if (go->scene() && !go->scene()->views().isEmpty())
|
1496
|
+
setDpiFromWidget(go->scene()->views().first());
|
1497
|
+
}
|
1498
|
+
|
1499
|
+
if (state == QtScroller::Scrolling) {
|
1500
|
+
recalcScrollingSegments();
|
1501
|
+
}
|
1502
|
+
return true;
|
1503
|
+
}
|
1504
|
+
|
1505
|
+
return false;
|
1506
|
+
}
|
1507
|
+
|
1508
|
+
void QtScrollerPrivate::handleDrag(const QPointF &position, qint64 timestamp)
|
1509
|
+
{
|
1510
|
+
const QtScrollerPropertiesPrivate *sp = properties.d.data();
|
1511
|
+
|
1512
|
+
QPointF deltaPixel = position - lastPosition;
|
1513
|
+
qint64 deltaTime = timestamp - lastTimestamp;
|
1514
|
+
|
1515
|
+
if (sp->axisLockThreshold) {
|
1516
|
+
int dx = qAbs(deltaPixel.x());
|
1517
|
+
int dy = qAbs(deltaPixel.y());
|
1518
|
+
if (dx || dy) {
|
1519
|
+
bool vertical = (dy > dx);
|
1520
|
+
qreal alpha = qreal(vertical ? dx : dy) / qreal(vertical ? dy : dx);
|
1521
|
+
//qScrollerDebug() << "QtScroller::handleDrag() -- axis lock:" << alpha << " / " << axisLockThreshold << "- isvertical:" << vertical << "- dx:" << dx << "- dy:" << dy;
|
1522
|
+
if (alpha <= sp->axisLockThreshold) {
|
1523
|
+
if (vertical)
|
1524
|
+
deltaPixel.setX(0);
|
1525
|
+
else
|
1526
|
+
deltaPixel.setY(0);
|
1527
|
+
}
|
1528
|
+
}
|
1529
|
+
}
|
1530
|
+
|
1531
|
+
// calculate velocity (if the user would release the mouse NOW)
|
1532
|
+
updateVelocity(deltaPixel, deltaTime);
|
1533
|
+
|
1534
|
+
// restrict velocity, if content is not scrollable
|
1535
|
+
QRectF max = contentPosRange;
|
1536
|
+
bool canScrollX = (max.width() > 0) || (sp->hOvershootPolicy == QtScrollerProperties::OvershootAlwaysOn);
|
1537
|
+
bool canScrollY = (max.height() > 0) || (sp->vOvershootPolicy == QtScrollerProperties::OvershootAlwaysOn);
|
1538
|
+
|
1539
|
+
if (!canScrollX) {
|
1540
|
+
deltaPixel.setX(0);
|
1541
|
+
releaseVelocity.setX(0);
|
1542
|
+
}
|
1543
|
+
if (!canScrollY) {
|
1544
|
+
deltaPixel.setY(0);
|
1545
|
+
releaseVelocity.setY(0);
|
1546
|
+
}
|
1547
|
+
|
1548
|
+
// if (firstDrag) {
|
1549
|
+
// // Do not delay the first drag
|
1550
|
+
// setContentPositionHelper(q->contentPosition() - overshootDistance - deltaPixel);
|
1551
|
+
// dragDistance = QPointF(0, 0);
|
1552
|
+
// } else {
|
1553
|
+
dragDistance += deltaPixel;
|
1554
|
+
// }
|
1555
|
+
//qScrollerDebug() << "######################" << deltaPixel << position.y() << lastPosition.y();
|
1556
|
+
if (canScrollX)
|
1557
|
+
lastPosition.setX(position.x());
|
1558
|
+
if (canScrollY)
|
1559
|
+
lastPosition.setY(position.y());
|
1560
|
+
lastTimestamp = timestamp;
|
1561
|
+
}
|
1562
|
+
|
1563
|
+
bool QtScrollerPrivate::pressWhileInactive(const QPointF &position, qint64 timestamp)
|
1564
|
+
{
|
1565
|
+
if (prepareScrolling(position)) {
|
1566
|
+
const QtScrollerPropertiesPrivate *sp = properties.d.data();
|
1567
|
+
|
1568
|
+
if (!contentPosRange.isNull() ||
|
1569
|
+
(sp->hOvershootPolicy == QtScrollerProperties::OvershootAlwaysOn) ||
|
1570
|
+
(sp->vOvershootPolicy == QtScrollerProperties::OvershootAlwaysOn)) {
|
1571
|
+
|
1572
|
+
lastPosition = pressPosition = position;
|
1573
|
+
lastTimestamp = pressTimestamp = timestamp;
|
1574
|
+
setState(QtScroller::Pressed);
|
1575
|
+
}
|
1576
|
+
}
|
1577
|
+
return false;
|
1578
|
+
}
|
1579
|
+
|
1580
|
+
bool QtScrollerPrivate::releaseWhilePressed(const QPointF &, qint64)
|
1581
|
+
{
|
1582
|
+
if (overshootPosition != QPointF(0.0, 0.0)) {
|
1583
|
+
setState(QtScroller::Scrolling);
|
1584
|
+
return true;
|
1585
|
+
} else {
|
1586
|
+
setState(QtScroller::Inactive);
|
1587
|
+
return false;
|
1588
|
+
}
|
1589
|
+
}
|
1590
|
+
|
1591
|
+
bool QtScrollerPrivate::moveWhilePressed(const QPointF &position, qint64 timestamp)
|
1592
|
+
{
|
1593
|
+
Q_Q(QtScroller);
|
1594
|
+
const QtScrollerPropertiesPrivate *sp = properties.d.data();
|
1595
|
+
QPointF ppm = q->pixelPerMeter();
|
1596
|
+
|
1597
|
+
QPointF deltaPixel = position - pressPosition;
|
1598
|
+
|
1599
|
+
bool moveAborted = false;
|
1600
|
+
bool moveStarted = (((deltaPixel / ppm).manhattanLength()) > sp->dragStartDistance);
|
1601
|
+
|
1602
|
+
// check the direction of the mouse drag and abort if it's too much in the wrong direction.
|
1603
|
+
if (moveStarted) {
|
1604
|
+
QRectF max = contentPosRange;
|
1605
|
+
bool canScrollX = (max.width() > 0);
|
1606
|
+
bool canScrollY = (max.height() > 0);
|
1607
|
+
|
1608
|
+
if (sp->hOvershootPolicy == QtScrollerProperties::OvershootAlwaysOn)
|
1609
|
+
canScrollX = true;
|
1610
|
+
if (sp->vOvershootPolicy == QtScrollerProperties::OvershootAlwaysOn)
|
1611
|
+
canScrollY = true;
|
1612
|
+
|
1613
|
+
if (qAbs(deltaPixel.x() / ppm.x()) < qAbs(deltaPixel.y() / ppm.y())) {
|
1614
|
+
if (!canScrollY)
|
1615
|
+
moveAborted = true;
|
1616
|
+
} else {
|
1617
|
+
if (!canScrollX)
|
1618
|
+
moveAborted = true;
|
1619
|
+
}
|
1620
|
+
}
|
1621
|
+
|
1622
|
+
if (moveAborted) {
|
1623
|
+
setState(QtScroller::Inactive);
|
1624
|
+
moveStarted = false;
|
1625
|
+
|
1626
|
+
} else if (moveStarted) {
|
1627
|
+
setState(QtScroller::Dragging);
|
1628
|
+
|
1629
|
+
// subtract the dragStartDistance
|
1630
|
+
deltaPixel = deltaPixel - deltaPixel * (sp->dragStartDistance / deltaPixel.manhattanLength());
|
1631
|
+
|
1632
|
+
if (deltaPixel != QPointF(0, 0)) {
|
1633
|
+
// handleDrag updates lastPosition, lastTimestamp and velocity
|
1634
|
+
handleDrag(pressPosition + deltaPixel, timestamp);
|
1635
|
+
}
|
1636
|
+
}
|
1637
|
+
return moveStarted;
|
1638
|
+
}
|
1639
|
+
|
1640
|
+
bool QtScrollerPrivate::moveWhileDragging(const QPointF &position, qint64 timestamp)
|
1641
|
+
{
|
1642
|
+
// handleDrag updates lastPosition, lastTimestamp and velocity
|
1643
|
+
handleDrag(position, timestamp);
|
1644
|
+
return true;
|
1645
|
+
}
|
1646
|
+
|
1647
|
+
void QtScrollerPrivate::timerEventWhileDragging()
|
1648
|
+
{
|
1649
|
+
if (dragDistance != QPointF(0, 0)) {
|
1650
|
+
qScrollerDebug() << "QtScroller::timerEventWhileDragging() -- dragDistance:" << dragDistance;
|
1651
|
+
|
1652
|
+
setContentPositionHelperDragging(-dragDistance);
|
1653
|
+
dragDistance = QPointF(0, 0);
|
1654
|
+
}
|
1655
|
+
}
|
1656
|
+
|
1657
|
+
bool QtScrollerPrivate::releaseWhileDragging(const QPointF &position, qint64 timestamp)
|
1658
|
+
{
|
1659
|
+
Q_Q(QtScroller);
|
1660
|
+
const QtScrollerPropertiesPrivate *sp = properties.d.data();
|
1661
|
+
|
1662
|
+
// handleDrag updates lastPosition, lastTimestamp and velocity
|
1663
|
+
handleDrag(position, timestamp);
|
1664
|
+
|
1665
|
+
// check if we moved at all - this can happen if you stop a running
|
1666
|
+
// scroller with a press and release shortly afterwards
|
1667
|
+
QPointF deltaPixel = position - pressPosition;
|
1668
|
+
if (((deltaPixel / q->pixelPerMeter()).manhattanLength()) > sp->dragStartDistance) {
|
1669
|
+
|
1670
|
+
// handle accelerating flicks
|
1671
|
+
if ((oldVelocity != QPointF(0, 0)) && sp->acceleratingFlickMaximumTime &&
|
1672
|
+
((timestamp - pressTimestamp) < qint64(sp->acceleratingFlickMaximumTime * 1000))) {
|
1673
|
+
|
1674
|
+
// - determine if the direction was changed
|
1675
|
+
int signX = 0, signY = 0;
|
1676
|
+
if (releaseVelocity.x())
|
1677
|
+
signX = (releaseVelocity.x() > 0) == (oldVelocity.x() > 0) ? 1 : -1;
|
1678
|
+
if (releaseVelocity.y())
|
1679
|
+
signY = (releaseVelocity.y() > 0) == (oldVelocity.y() > 0) ? 1 : -1;
|
1680
|
+
|
1681
|
+
if (signX > 0)
|
1682
|
+
releaseVelocity.setX(qBound(-sp->maximumVelocity,
|
1683
|
+
oldVelocity.x() * sp->acceleratingFlickSpeedupFactor,
|
1684
|
+
sp->maximumVelocity));
|
1685
|
+
if (signY > 0)
|
1686
|
+
releaseVelocity.setY(qBound(-sp->maximumVelocity,
|
1687
|
+
oldVelocity.y() * sp->acceleratingFlickSpeedupFactor,
|
1688
|
+
sp->maximumVelocity));
|
1689
|
+
}
|
1690
|
+
}
|
1691
|
+
|
1692
|
+
QPointF ppm = q->pixelPerMeter();
|
1693
|
+
createScrollingSegments(releaseVelocity.x(), contentPosition.x() + overshootPosition.x(), ppm.x(), Qt::Horizontal);
|
1694
|
+
createScrollingSegments(releaseVelocity.y(), contentPosition.y() + overshootPosition.y(), ppm.y(), Qt::Vertical);
|
1695
|
+
|
1696
|
+
qScrollerDebug() << "QtScroller::releaseWhileDragging() -- velocity:" << releaseVelocity << "-- minimum velocity:" << sp->minimumVelocity << "overshoot" << overshootPosition;
|
1697
|
+
|
1698
|
+
if (xSegments.isEmpty() && ySegments.isEmpty())
|
1699
|
+
setState(QtScroller::Inactive);
|
1700
|
+
else
|
1701
|
+
setState(QtScroller::Scrolling);
|
1702
|
+
|
1703
|
+
return true;
|
1704
|
+
}
|
1705
|
+
|
1706
|
+
void QtScrollerPrivate::timerEventWhileScrolling()
|
1707
|
+
{
|
1708
|
+
qScrollerDebug() << "QtScroller::timerEventWhileScrolling()";
|
1709
|
+
|
1710
|
+
setContentPositionHelperScrolling();
|
1711
|
+
if (xSegments.isEmpty() && ySegments.isEmpty())
|
1712
|
+
setState(QtScroller::Inactive);
|
1713
|
+
}
|
1714
|
+
|
1715
|
+
bool QtScrollerPrivate::pressWhileScrolling(const QPointF &position, qint64 timestamp)
|
1716
|
+
{
|
1717
|
+
Q_Q(QtScroller);
|
1718
|
+
|
1719
|
+
if ((q->velocity() <= properties.d->maximumClickThroughVelocity) &&
|
1720
|
+
(overshootPosition == QPointF(0.0, 0.0))) {
|
1721
|
+
setState(QtScroller::Inactive);
|
1722
|
+
return false;
|
1723
|
+
} else {
|
1724
|
+
lastPosition = pressPosition = position;
|
1725
|
+
lastTimestamp = pressTimestamp = timestamp;
|
1726
|
+
setState(QtScroller::Pressed);
|
1727
|
+
setState(QtScroller::Dragging);
|
1728
|
+
return true;
|
1729
|
+
}
|
1730
|
+
}
|
1731
|
+
|
1732
|
+
/*! \internal
|
1733
|
+
This function handles all state changes of the scroller.
|
1734
|
+
*/
|
1735
|
+
void QtScrollerPrivate::setState(QtScroller::State newstate)
|
1736
|
+
{
|
1737
|
+
Q_Q(QtScroller);
|
1738
|
+
bool sendLastScroll = false;
|
1739
|
+
|
1740
|
+
if (state == newstate)
|
1741
|
+
return;
|
1742
|
+
|
1743
|
+
qScrollerDebug() << q << "QtScroller::setState(" << stateName(newstate) << ")";
|
1744
|
+
|
1745
|
+
switch (newstate) {
|
1746
|
+
case QtScroller::Inactive:
|
1747
|
+
scrollTimer->stop();
|
1748
|
+
|
1749
|
+
// send the last scroll event (but only after the current state change was finished)
|
1750
|
+
if (!firstScroll)
|
1751
|
+
sendLastScroll = true;
|
1752
|
+
|
1753
|
+
releaseVelocity = QPointF(0, 0);
|
1754
|
+
break;
|
1755
|
+
|
1756
|
+
case QtScroller::Pressed:
|
1757
|
+
scrollTimer->stop();
|
1758
|
+
|
1759
|
+
oldVelocity = releaseVelocity;
|
1760
|
+
releaseVelocity = QPointF(0, 0);
|
1761
|
+
break;
|
1762
|
+
|
1763
|
+
case QtScroller::Dragging:
|
1764
|
+
dragDistance = QPointF(0, 0);
|
1765
|
+
if (state == QtScroller::Pressed)
|
1766
|
+
scrollTimer->start();
|
1767
|
+
break;
|
1768
|
+
|
1769
|
+
case QtScroller::Scrolling:
|
1770
|
+
scrollTimer->start();
|
1771
|
+
break;
|
1772
|
+
}
|
1773
|
+
|
1774
|
+
qSwap(state, newstate);
|
1775
|
+
|
1776
|
+
if (sendLastScroll) {
|
1777
|
+
QtScrollEvent se(contentPosition, overshootPosition, QtScrollEvent::ScrollFinished);
|
1778
|
+
sendEvent(target, &se);
|
1779
|
+
firstScroll = true;
|
1780
|
+
}
|
1781
|
+
if (state == QtScroller::Dragging || state == QtScroller::Scrolling)
|
1782
|
+
activeScrollers.insert(q);
|
1783
|
+
else
|
1784
|
+
activeScrollers.remove(q);
|
1785
|
+
emit q->stateChanged(state);
|
1786
|
+
}
|
1787
|
+
|
1788
|
+
|
1789
|
+
/*! \internal
|
1790
|
+
Helps when setting the content position.
|
1791
|
+
It will try to move the content by the requested delta but stop in case
|
1792
|
+
when we are coming back from an overshoot or a scrollTo.
|
1793
|
+
It will also indicate a new overshooting condition by the overshootX and oversthootY flags.
|
1794
|
+
|
1795
|
+
In this cases it will reset the velocity variables and other flags.
|
1796
|
+
|
1797
|
+
Also keeps track of the current over-shooting value in overshootPosition.
|
1798
|
+
|
1799
|
+
\a deltaPos is the amount of pixels the current content position should be moved
|
1800
|
+
*/
|
1801
|
+
void QtScrollerPrivate::setContentPositionHelperDragging(const QPointF &deltaPos)
|
1802
|
+
{
|
1803
|
+
Q_Q(QtScroller);
|
1804
|
+
QPointF ppm = q->pixelPerMeter();
|
1805
|
+
const QtScrollerPropertiesPrivate *sp = properties.d.data();
|
1806
|
+
QPointF v = q->velocity();
|
1807
|
+
|
1808
|
+
if (sp->overshootDragResistanceFactor)
|
1809
|
+
overshootPosition /= sp->overshootDragResistanceFactor;
|
1810
|
+
|
1811
|
+
QPointF oldPos = contentPosition + overshootPosition;
|
1812
|
+
QPointF newPos = oldPos + deltaPos;
|
1813
|
+
|
1814
|
+
qScrollerDebug() << "QtScroller::setContentPositionHelperDragging(" << deltaPos << " [pix])";
|
1815
|
+
qScrollerDebug() << " --> overshoot:" << overshootPosition << "- old pos:" << oldPos << "- new pos:" << newPos;
|
1816
|
+
|
1817
|
+
QPointF oldClampedPos = clampToRect(oldPos, contentPosRange);
|
1818
|
+
QPointF newClampedPos = clampToRect(newPos, contentPosRange);
|
1819
|
+
|
1820
|
+
// --- handle overshooting and stop if the coordinate is going back inside the normal area
|
1821
|
+
bool alwaysOvershootX = (sp->hOvershootPolicy == QtScrollerProperties::OvershootAlwaysOn);
|
1822
|
+
bool alwaysOvershootY = (sp->vOvershootPolicy == QtScrollerProperties::OvershootAlwaysOn);
|
1823
|
+
bool noOvershootX = (sp->hOvershootPolicy == QtScrollerProperties::OvershootAlwaysOff) ||
|
1824
|
+
((state == QtScroller::Dragging) && !sp->overshootDragResistanceFactor) ||
|
1825
|
+
!sp->overshootDragDistanceFactor;
|
1826
|
+
bool noOvershootY = (sp->vOvershootPolicy == QtScrollerProperties::OvershootAlwaysOff) ||
|
1827
|
+
((state == QtScroller::Dragging) && !sp->overshootDragResistanceFactor) ||
|
1828
|
+
!sp->overshootDragDistanceFactor;
|
1829
|
+
bool canOvershootX = !noOvershootX && (alwaysOvershootX || contentPosRange.width());
|
1830
|
+
bool canOvershootY = !noOvershootY && (alwaysOvershootY || contentPosRange.height());
|
1831
|
+
|
1832
|
+
qreal oldOvershootX = (canOvershootX) ? oldPos.x() - oldClampedPos.x() : 0;
|
1833
|
+
qreal oldOvershootY = (canOvershootY) ? oldPos.y() - oldClampedPos.y() : 0;
|
1834
|
+
|
1835
|
+
qreal newOvershootX = (canOvershootX) ? newPos.x() - newClampedPos.x() : 0;
|
1836
|
+
qreal newOvershootY = (canOvershootY) ? newPos.y() - newClampedPos.y() : 0;
|
1837
|
+
|
1838
|
+
qreal maxOvershootX = viewportSize.width() * sp->overshootDragDistanceFactor;
|
1839
|
+
qreal maxOvershootY = viewportSize.height() * sp->overshootDragDistanceFactor;
|
1840
|
+
|
1841
|
+
qScrollerDebug() << " --> noOs:" << noOvershootX << "drf:" << sp->overshootDragResistanceFactor << "mdf:" << sp->overshootScrollDistanceFactor << "ossP:"<<sp->hOvershootPolicy;
|
1842
|
+
qScrollerDebug() << " --> canOS:" << canOvershootX << "newOS:" << newOvershootX << "maxOS:" << maxOvershootX;
|
1843
|
+
|
1844
|
+
if (sp->overshootDragResistanceFactor) {
|
1845
|
+
oldOvershootX *= sp->overshootDragResistanceFactor;
|
1846
|
+
oldOvershootY *= sp->overshootDragResistanceFactor;
|
1847
|
+
newOvershootX *= sp->overshootDragResistanceFactor;
|
1848
|
+
newOvershootY *= sp->overshootDragResistanceFactor;
|
1849
|
+
}
|
1850
|
+
|
1851
|
+
// -- stop at the maximum overshoot distance
|
1852
|
+
|
1853
|
+
newOvershootX = qBound(-maxOvershootX, newOvershootX, maxOvershootX);
|
1854
|
+
newOvershootY = qBound(-maxOvershootY, newOvershootY, maxOvershootY);
|
1855
|
+
|
1856
|
+
overshootPosition.setX(newOvershootX);
|
1857
|
+
overshootPosition.setY(newOvershootY);
|
1858
|
+
contentPosition = newClampedPos;
|
1859
|
+
|
1860
|
+
QtScrollEvent se(contentPosition, overshootPosition, firstScroll ? QtScrollEvent::ScrollStarted : QtScrollEvent::ScrollUpdated);
|
1861
|
+
sendEvent(target, &se);
|
1862
|
+
firstScroll = false;
|
1863
|
+
|
1864
|
+
qScrollerDebug() << " --> new position:" << newClampedPos << "- new overshoot:" << overshootPosition <<
|
1865
|
+
"- overshoot x/y?:" << overshootPosition;
|
1866
|
+
}
|
1867
|
+
|
1868
|
+
|
1869
|
+
qreal QtScrollerPrivate::nextSegmentPosition(QQueue<ScrollSegment> &segments, qint64 now, qreal oldPos)
|
1870
|
+
{
|
1871
|
+
qreal pos = oldPos;
|
1872
|
+
|
1873
|
+
// check the X segments for new positions
|
1874
|
+
while (!segments.isEmpty()) {
|
1875
|
+
const ScrollSegment s = segments.head();
|
1876
|
+
|
1877
|
+
if ((s.startTime + s.deltaTime * s.stopProgress) <= now) {
|
1878
|
+
segments.dequeue();
|
1879
|
+
pos = s.stopPos;
|
1880
|
+
} else if (s.startTime <= now) {
|
1881
|
+
qreal progress = qreal(now - s.startTime) / qreal(s.deltaTime);
|
1882
|
+
pos = s.startPos + s.deltaPos * s.curve.valueForProgress(progress);
|
1883
|
+
if (s.deltaPos > 0 ? pos > s.stopPos : pos < s.stopPos) {
|
1884
|
+
segments.dequeue();
|
1885
|
+
pos = s.stopPos;
|
1886
|
+
} else {
|
1887
|
+
break;
|
1888
|
+
}
|
1889
|
+
} else {
|
1890
|
+
break;
|
1891
|
+
}
|
1892
|
+
}
|
1893
|
+
return pos;
|
1894
|
+
}
|
1895
|
+
|
1896
|
+
void QtScrollerPrivate::setContentPositionHelperScrolling()
|
1897
|
+
{
|
1898
|
+
qint64 now = monotonicTimer.elapsed();
|
1899
|
+
QPointF newPos = contentPosition + overshootPosition;
|
1900
|
+
|
1901
|
+
newPos.setX(nextSegmentPosition(xSegments, now, newPos.x()));
|
1902
|
+
newPos.setY(nextSegmentPosition(ySegments, now, newPos.y()));
|
1903
|
+
|
1904
|
+
// -- set the position and handle overshoot
|
1905
|
+
qScrollerDebug() << "QtScroller::setContentPositionHelperScrolling()";
|
1906
|
+
qScrollerDebug() << " --> overshoot:" << overshootPosition << "- new pos:" << newPos;
|
1907
|
+
|
1908
|
+
QPointF newClampedPos = clampToRect(newPos, contentPosRange);
|
1909
|
+
|
1910
|
+
overshootPosition = newPos - newClampedPos;
|
1911
|
+
contentPosition = newClampedPos;
|
1912
|
+
|
1913
|
+
QtScrollEvent se(contentPosition, overshootPosition, firstScroll ? QtScrollEvent::ScrollStarted : QtScrollEvent::ScrollUpdated);
|
1914
|
+
sendEvent(target, &se);
|
1915
|
+
firstScroll = false;
|
1916
|
+
|
1917
|
+
qScrollerDebug() << " --> new position:" << newClampedPos << "- new overshoot:" << overshootPosition;
|
1918
|
+
}
|
1919
|
+
|
1920
|
+
/*! \internal
|
1921
|
+
Returns the next snap point in direction.
|
1922
|
+
If \a direction >0 it will return the next snap point that is larger than the current position.
|
1923
|
+
If \a direction <0 it will return the next snap point that is smaller than the current position.
|
1924
|
+
If \a direction ==0 it will return the nearest snap point (or the current position if we are already
|
1925
|
+
on a snap point.
|
1926
|
+
Returns the nearest snap position or NaN if no such point could be found.
|
1927
|
+
*/
|
1928
|
+
qreal QtScrollerPrivate::nextSnapPos(qreal p, int dir, Qt::Orientation orientation)
|
1929
|
+
{
|
1930
|
+
qreal bestSnapPos = Q_QNAN;
|
1931
|
+
qreal bestSnapPosDist = Q_INFINITY;
|
1932
|
+
|
1933
|
+
qreal minPos;
|
1934
|
+
qreal maxPos;
|
1935
|
+
|
1936
|
+
if (orientation == Qt::Horizontal) {
|
1937
|
+
minPos = contentPosRange.left();
|
1938
|
+
maxPos = contentPosRange.right();
|
1939
|
+
} else {
|
1940
|
+
minPos = contentPosRange.top();
|
1941
|
+
maxPos = contentPosRange.bottom();
|
1942
|
+
}
|
1943
|
+
|
1944
|
+
if (orientation == Qt::Horizontal) {
|
1945
|
+
// the snap points in the list
|
1946
|
+
foreach (qreal snapPos, snapPositionsX) {
|
1947
|
+
qreal snapPosDist = snapPos - p;
|
1948
|
+
if ((dir > 0 && snapPosDist < 0) ||
|
1949
|
+
(dir < 0 && snapPosDist > 0))
|
1950
|
+
continue; // wrong direction
|
1951
|
+
if (snapPos < minPos || snapPos > maxPos)
|
1952
|
+
continue; // invalid
|
1953
|
+
|
1954
|
+
if (qIsNaN(bestSnapPos) ||
|
1955
|
+
qAbs(snapPosDist) < bestSnapPosDist) {
|
1956
|
+
bestSnapPos = snapPos;
|
1957
|
+
bestSnapPosDist = qAbs(snapPosDist);
|
1958
|
+
}
|
1959
|
+
}
|
1960
|
+
|
1961
|
+
// the snap point interval
|
1962
|
+
if (snapIntervalX > 0.0) {
|
1963
|
+
qreal first = minPos + snapFirstX;
|
1964
|
+
qreal snapPos;
|
1965
|
+
if (dir > 0)
|
1966
|
+
snapPos = qCeil((p - first) / snapIntervalX) * snapIntervalX + first;
|
1967
|
+
else if (dir < 0)
|
1968
|
+
snapPos = qFloor((p - first) / snapIntervalX) * snapIntervalX + first;
|
1969
|
+
else if (p <= first)
|
1970
|
+
snapPos = first;
|
1971
|
+
else
|
1972
|
+
{
|
1973
|
+
qreal last = qFloor((maxPos - first) / snapIntervalX) * snapIntervalX + first;
|
1974
|
+
if (p >= last)
|
1975
|
+
snapPos = last;
|
1976
|
+
else
|
1977
|
+
snapPos = qRound((p - first) / snapIntervalX) * snapIntervalX + first;
|
1978
|
+
}
|
1979
|
+
|
1980
|
+
if (snapPos >= first && snapPos <= maxPos ) {
|
1981
|
+
qreal snapPosDist = snapPos - p;
|
1982
|
+
|
1983
|
+
if (qIsNaN(bestSnapPos) ||
|
1984
|
+
qAbs(snapPosDist) < bestSnapPosDist) {
|
1985
|
+
bestSnapPos = snapPos;
|
1986
|
+
bestSnapPosDist = qAbs(snapPosDist);
|
1987
|
+
}
|
1988
|
+
}
|
1989
|
+
}
|
1990
|
+
|
1991
|
+
} else { // (orientation == Qt::Vertical)
|
1992
|
+
// the snap points in the list
|
1993
|
+
foreach (qreal snapPos, snapPositionsY) {
|
1994
|
+
qreal snapPosDist = snapPos - p;
|
1995
|
+
if ((dir > 0 && snapPosDist < 0) ||
|
1996
|
+
(dir < 0 && snapPosDist > 0))
|
1997
|
+
continue; // wrong direction
|
1998
|
+
if (snapPos < minPos || snapPos > maxPos)
|
1999
|
+
continue; // invalid
|
2000
|
+
|
2001
|
+
if (qIsNaN(bestSnapPos) ||
|
2002
|
+
qAbs(snapPosDist) < bestSnapPosDist) {
|
2003
|
+
bestSnapPos = snapPos;
|
2004
|
+
bestSnapPosDist = qAbs(snapPosDist);
|
2005
|
+
}
|
2006
|
+
}
|
2007
|
+
|
2008
|
+
// the snap point interval
|
2009
|
+
if (snapIntervalY > 0.0) {
|
2010
|
+
qreal first = minPos + snapFirstY;
|
2011
|
+
qreal snapPos;
|
2012
|
+
if (dir > 0)
|
2013
|
+
snapPos = qCeil((p - first) / snapIntervalY) * snapIntervalY + first;
|
2014
|
+
else if (dir < 0)
|
2015
|
+
snapPos = qFloor((p - first) / snapIntervalY) * snapIntervalY + first;
|
2016
|
+
else if (p <= first)
|
2017
|
+
snapPos = first;
|
2018
|
+
else
|
2019
|
+
{
|
2020
|
+
qreal last = qFloor((maxPos - first) / snapIntervalY) * snapIntervalY + first;
|
2021
|
+
if (p >= last)
|
2022
|
+
snapPos = last;
|
2023
|
+
else
|
2024
|
+
snapPos = qRound((p - first) / snapIntervalY) * snapIntervalY + first;
|
2025
|
+
}
|
2026
|
+
|
2027
|
+
if (snapPos >= first && snapPos <= maxPos ) {
|
2028
|
+
qreal snapPosDist = snapPos - p;
|
2029
|
+
|
2030
|
+
if (qIsNaN(bestSnapPos) ||
|
2031
|
+
qAbs(snapPosDist) < bestSnapPosDist) {
|
2032
|
+
bestSnapPos = snapPos;
|
2033
|
+
bestSnapPosDist = qAbs(snapPosDist);
|
2034
|
+
}
|
2035
|
+
}
|
2036
|
+
}
|
2037
|
+
}
|
2038
|
+
|
2039
|
+
return bestSnapPos;
|
2040
|
+
}
|
2041
|
+
|
2042
|
+
/*!
|
2043
|
+
\enum QtScroller::State
|
2044
|
+
|
2045
|
+
This enum contains the different QtScroller states.
|
2046
|
+
|
2047
|
+
\value Inactive The scroller is not scrolling and nothing is pressed.
|
2048
|
+
\value Pressed A touch event was received or the mouse button was pressed but the scroll area is currently not dragged.
|
2049
|
+
\value Dragging The scroll area is currently following the touch point or mouse.
|
2050
|
+
\value Scrolling The scroll area is moving on it's own.
|
2051
|
+
*/
|
2052
|
+
|
2053
|
+
/*!
|
2054
|
+
\enum QtScroller::ScrollerGestureType
|
2055
|
+
|
2056
|
+
This enum contains the different gesture types that are supported by the QtScroller gesture recognizer.
|
2057
|
+
|
2058
|
+
\value TouchGesture The gesture recognizer will only trigger on touch
|
2059
|
+
events. Specifically it will react on single touch points when using a
|
2060
|
+
touch screen and dual touch points when using a touchpad.
|
2061
|
+
\value LeftMouseButtonGesture The gesture recognizer will only trigger on left mouse button events.
|
2062
|
+
\value MiddleMouseButtonGesture The gesture recognizer will only trigger on middle mouse button events.
|
2063
|
+
\value RightMouseButtonGesture The gesture recognizer will only trigger on right mouse button events.
|
2064
|
+
*/
|
2065
|
+
|
2066
|
+
/*!
|
2067
|
+
\enum QtScroller::Input
|
2068
|
+
|
2069
|
+
This enum contains an input device agnostic view of input events that are relevant for QtScroller.
|
2070
|
+
|
2071
|
+
\value InputPress The user pressed the input device (e.g. QEvent::MouseButtonPress,
|
2072
|
+
QEvent::GraphicsSceneMousePress, QEvent::TouchBegin)
|
2073
|
+
|
2074
|
+
\value InputMove The user moved the input device (e.g. QEvent::MouseMove,
|
2075
|
+
QEvent::GraphicsSceneMouseMove, QEvent::TouchUpdate)
|
2076
|
+
|
2077
|
+
\value InputRelease The user released the input device (e.g. QEvent::MouseButtonRelease,
|
2078
|
+
QEvent::GraphicsSceneMouseRelease, QEvent::TouchEnd)
|
2079
|
+
|
2080
|
+
*/
|