Update copyright headers
[qt:qt.git] / demos / embedded / flickable / flickable.cpp
1 /****************************************************************************
2 **
3 ** Copyright (C) 2015 The Qt Company Ltd.
4 ** Contact: http://www.qt.io/licensing/
5 **
6 ** This file is part of the demonstration applications of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and The Qt Company. For licensing terms
14 ** and conditions see http://www.qt.io/terms-conditions. For further
15 ** information use the contact form at http://www.qt.io/contact-us.
16 **
17 ** GNU Lesser General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU Lesser
19 ** General Public License version 2.1 or version 3 as published by the Free
20 ** Software Foundation and appearing in the file LICENSE.LGPLv21 and
21 ** LICENSE.LGPLv3 included in the packaging of this file. Please review the
22 ** following information to ensure the GNU Lesser General Public License
23 ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
24 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
25 **
26 ** As a special exception, The Qt Company gives you certain additional
27 ** rights. These rights are described in The Qt Company LGPL Exception
28 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
29 **
30 ** GNU General Public License Usage
31 ** Alternatively, this file may be used under the terms of the GNU
32 ** General Public License version 3.0 as published by the Free Software
33 ** Foundation and appearing in the file LICENSE.GPL included in the
34 ** packaging of this file.  Please review the following information to
35 ** ensure the GNU General Public License version 3.0 requirements will be
36 ** met: http://www.gnu.org/copyleft/gpl.html.
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41
42 #include "flickable.h"
43
44 #include <QtCore>
45 #include <QtGui>
46
47 class FlickableTicker: QObject
48 {
49 public:
50     FlickableTicker(Flickable *scroller) {
51         m_scroller = scroller;
52     }
53
54     void start(int interval) {
55         if (!m_timer.isActive())
56             m_timer.start(interval, this);
57     }
58
59     void stop() {
60         m_timer.stop();
61     }
62
63 protected:
64     void timerEvent(QTimerEvent *event) {
65         Q_UNUSED(event);
66         m_scroller->tick();
67     }
68
69 private:
70     Flickable *m_scroller;
71     QBasicTimer m_timer;
72 };
73
74 class FlickablePrivate
75 {
76 public:
77     typedef enum {
78         Steady,
79         Pressed,
80         ManualScroll,
81         AutoScroll,
82         Stop
83     } State;
84
85     State state;
86     int threshold;
87     QPoint pressPos;
88     QPoint offset;
89     QPoint delta;
90     QPoint speed;
91     FlickableTicker *ticker;
92     QTime timeStamp;
93     QWidget *target;
94     QList<QEvent*> ignoreList;
95 };
96
97 Flickable::Flickable()
98 {
99     d = new FlickablePrivate;
100     d->state = FlickablePrivate::Steady;
101     d->threshold = 10;
102     d->ticker = new FlickableTicker(this);
103     d->timeStamp = QTime::currentTime();
104     d->target = 0;
105 }
106
107 Flickable::~Flickable()
108 {
109     delete d;
110 }
111
112 void Flickable::setThreshold(int th)
113 {
114     if (th >= 0)
115         d->threshold = th;
116 }
117
118 int Flickable::threshold() const
119 {
120     return d->threshold;
121 }
122
123 void Flickable::setAcceptMouseClick(QWidget *target)
124 {
125     d->target = target;
126 }
127
128 static QPoint deaccelerate(const QPoint &speed, int a = 1, int max = 64)
129 {
130     int x = qBound(-max, speed.x(), max);
131     int y = qBound(-max, speed.y(), max);
132     x = (x == 0) ? x : (x > 0) ? qMax(0, x - a) : qMin(0, x + a);
133     y = (y == 0) ? y : (y > 0) ? qMax(0, y - a) : qMin(0, y + a);
134     return QPoint(x, y);
135 }
136
137 void Flickable::handleMousePress(QMouseEvent *event)
138 {
139     event->ignore();
140
141     if (event->button() != Qt::LeftButton)
142         return;
143
144     if (d->ignoreList.removeAll(event))
145         return;
146
147     switch (d->state) {
148
149     case FlickablePrivate::Steady:
150         event->accept();
151         d->state = FlickablePrivate::Pressed;
152         d->pressPos = event->pos();
153         break;
154
155     case FlickablePrivate::AutoScroll:
156         event->accept();
157         d->state = FlickablePrivate::Stop;
158         d->speed = QPoint(0, 0);
159         d->pressPos = event->pos();
160         d->offset = scrollOffset();
161         d->ticker->stop();
162         break;
163
164     default:
165         break;
166     }
167 }
168
169 void Flickable::handleMouseRelease(QMouseEvent *event)
170 {
171     event->ignore();
172
173     if (event->button() != Qt::LeftButton)
174         return;
175
176     if (d->ignoreList.removeAll(event))
177         return;
178
179     QPoint delta;
180
181     switch (d->state) {
182
183     case FlickablePrivate::Pressed:
184         event->accept();
185         d->state = FlickablePrivate::Steady;
186         if (d->target) {
187             QMouseEvent *event1 = new QMouseEvent(QEvent::MouseButtonPress,
188                                                   d->pressPos, Qt::LeftButton,
189                                                   Qt::LeftButton, Qt::NoModifier);
190             QMouseEvent *event2 = new QMouseEvent(*event);
191             d->ignoreList << event1;
192             d->ignoreList << event2;
193             QApplication::postEvent(d->target, event1);
194             QApplication::postEvent(d->target, event2);
195         }
196         break;
197
198     case FlickablePrivate::ManualScroll:
199         event->accept();
200         delta = event->pos() - d->pressPos;
201         if (d->timeStamp.elapsed() > 100) {
202             d->timeStamp = QTime::currentTime();
203             d->speed = delta - d->delta;
204             d->delta = delta;
205         }
206         d->offset = scrollOffset();
207         d->pressPos = event->pos();
208         if (d->speed == QPoint(0, 0)) {
209             d->state = FlickablePrivate::Steady;
210         } else {
211             d->speed /= 4;
212             d->state = FlickablePrivate::AutoScroll;
213             d->ticker->start(20);
214         }
215         break;
216
217     case FlickablePrivate::Stop:
218         event->accept();
219         d->state = FlickablePrivate::Steady;
220         d->offset = scrollOffset();
221         break;
222
223     default:
224         break;
225     }
226 }
227
228 void Flickable::handleMouseMove(QMouseEvent *event)
229 {
230     event->ignore();
231
232     if (!(event->buttons() & Qt::LeftButton))
233         return;
234
235     if (d->ignoreList.removeAll(event))
236         return;
237
238     QPoint delta;
239
240     switch (d->state) {
241
242     case FlickablePrivate::Pressed:
243     case FlickablePrivate::Stop:
244         delta = event->pos() - d->pressPos;
245         if (delta.x() > d->threshold || delta.x() < -d->threshold ||
246                 delta.y() > d->threshold || delta.y() < -d->threshold) {
247             d->timeStamp = QTime::currentTime();
248             d->state = FlickablePrivate::ManualScroll;
249             d->delta = QPoint(0, 0);
250             d->pressPos = event->pos();
251             event->accept();
252         }
253         break;
254
255     case FlickablePrivate::ManualScroll:
256         event->accept();
257         delta = event->pos() - d->pressPos;
258         setScrollOffset(d->offset - delta);
259         if (d->timeStamp.elapsed() > 100) {
260             d->timeStamp = QTime::currentTime();
261             d->speed = delta - d->delta;
262             d->delta = delta;
263         }
264         break;
265
266     default:
267         break;
268     }
269 }
270
271 void Flickable::tick()
272 {
273     if (d->state == FlickablePrivate:: AutoScroll) {
274         d->speed = deaccelerate(d->speed);
275         setScrollOffset(d->offset - d->speed);
276         d->offset = scrollOffset();
277         if (d->speed == QPoint(0, 0)) {
278             d->state = FlickablePrivate::Steady;
279             d->ticker->stop();
280         }
281     } else {
282         d->ticker->stop();
283     }
284 }