plugins/Ubuntu/Gestures/DirectionalDragArea.cpp · unity8

git.iko.soy/unity8

on 815a6dc help sign in

unity8/plugins/Ubuntu/Gestures/DirectionalDragArea.cpp

299 lines 8.0 kB history raw

1/*

3 *

4 * This program is free software; you can redistribute it and/or modify

5 * it under the terms of the GNU General Public License as published by

6 * the Free Software Foundation; version 3.

7 *

8 * This program is distributed in the hope that it will be useful,

9 * but WITHOUT ANY WARRANTY; without even the implied warranty of

10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11 * GNU General Public License for more details.

12 *

13 * You should have received a copy of the GNU General Public License

14 * along with this program. If not, see <http://www.gnu.org/licenses/>.

15 */

17#include "DirectionalDragArea.h"

19#include <QtCore/qmath.h>

21DirectionalDragArea::DirectionalDragArea(QQuickItem *parent)

22 : QQuickItem(parent)

23 , m_status(WaitingForTouch)

24 , m_touchId(-1)

25 , m_direction(DirectionalDragArea::Rightwards)

26 , m_wideningAngle(0)

27 , m_wideningFactor(0)

28 , m_distanceThreshold(0)

29{

30}

32DirectionalDragArea::Direction DirectionalDragArea::direction() const

33{

34 return m_direction;

35}

37void DirectionalDragArea::setDirection(DirectionalDragArea::Direction direction)

38{

39 if (direction != m_direction) {

40 m_direction = direction;

41 Q_EMIT directionChanged(m_direction);

42 }

43}

45void DirectionalDragArea::setMaxDeviation(qreal value)

46{

47 if (m_dampedPos.maxDelta() != value) {

48 m_dampedPos.setMaxDelta(value);

49 Q_EMIT maxDeviationChanged(value);

50 }

51}

53qreal DirectionalDragArea::wideningAngle() const

54{

55 return m_wideningAngle;

56}

58void DirectionalDragArea::setWideningAngle(qreal angle)

59{

60 if (angle == m_wideningAngle)

61 return;

63 m_wideningAngle = angle;

64 m_wideningFactor = qTan(angle * M_PI / 180.0);

65 Q_EMIT wideningAngleChanged(angle);

66}

68void DirectionalDragArea::setDistanceThreshold(qreal value)

69{

70 if (m_distanceThreshold != value) {

71 m_distanceThreshold = value;

72 Q_EMIT distanceThresholdChanged(value);

73 }

74}

76qreal DirectionalDragArea::distance() const

77{

78 if (directionIsHorizontal()) {

79 return m_previousPos.x() - m_startPos.x();

80 } else {

81 return m_previousPos.y() - m_startPos.y();

82 }

83}

85qreal DirectionalDragArea::touchX() const

86{

87 return m_previousPos.x();

88}

90qreal DirectionalDragArea::touchY() const

91{

92 return m_previousPos.y();

93}

95void DirectionalDragArea::touchEvent(QTouchEvent *event)

96{

97 if (!isEnabled() || !isVisible()) {

98 QQuickItem::touchEvent(event);

99 return;

100 }

101

102 switch (m_status) {

103 case WaitingForTouch:

104 touchEvent_absent(event);

105 break;

106 case Undecided:

107 touchEvent_undecided(event);

108 break;

109 case Recognized:

110 touchEvent_recognized(event);

111 break;

112 default: // Rejected

113 touchEvent_rejected(event);

114 break;

115 }

116}

117

118void DirectionalDragArea::touchEvent_absent(QTouchEvent *event)

119{

120 if ((event->touchPointStates() && (Qt::TouchPointPressed || Qt::TouchPointMoved))

121 && event->touchPoints().count() == 1) {

122 m_startPos = event->touchPoints()[0].pos();

123 m_touchId = event->touchPoints()[0].id();

124 m_dampedPos.reset(m_startPos);

125 setPreviousPos(m_startPos);

126 setStatus(Undecided);

127 }

128}

129

130void DirectionalDragArea::touchEvent_undecided(QTouchEvent *event)

131{

132 const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(event);

133 const QPointF &touchPos = touchPoint->pos();

134

135 if (touchPoint->state() == Qt::TouchPointReleased) {

136 // touch has ended before recognition concluded

137 setStatus(WaitingForTouch);

138 return;

139 }

140

141 if (event->touchPointStates().testFlag(Qt::TouchPointPressed)

142 || event->touchPoints().count() > 1) {

143 // multi-finger drags are not accepted

144 setStatus(Rejected);

145 return;

146 }

147

148 m_previousDampedPos.setX(m_dampedPos.x());

149 m_previousDampedPos.setY(m_dampedPos.y());

150 m_dampedPos.update(touchPos);

151

152 if (!pointInsideAllowedArea()) {

153 setStatus(Rejected);

154 return;

155 }

156

157 if (!movingInRightDirection()) {

158 setStatus(Rejected);

159 return;

160 }

161

162 setPreviousPos(touchPos);

163

164 if (movedFarEnough(touchPos)) {

165 setStatus(Recognized);

166 }

167}

168

169void DirectionalDragArea::touchEvent_recognized(QTouchEvent *event)

170{

171 const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(event);

172

173 setPreviousPos(touchPoint->pos());

174

175 if (touchPoint->state() == Qt::TouchPointReleased) {

176 setStatus(WaitingForTouch);

177 }

178}

179

180void DirectionalDragArea::touchEvent_rejected(QTouchEvent *event)

181{

182 const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(event);

183

184 if (!touchPoint || touchPoint->state() == Qt::TouchPointReleased) {

185 setStatus(WaitingForTouch);

186 }

187}

188

189const QTouchEvent::TouchPoint *DirectionalDragArea::fetchTargetTouchPoint(QTouchEvent *event)

190{

191 const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();

192 const QTouchEvent::TouchPoint *touchPoint = 0;

193 for (int i = 0; i < touchPoints.size(); ++i) {

194 if (touchPoints.at(i).id() == m_touchId) {

195 touchPoint = &touchPoints.at(i);

196 break;

197 }

198 }

199 return touchPoint;

200}

201

202bool DirectionalDragArea::pointInsideAllowedArea() const

203{

204 qreal dX = m_dampedPos.x() - m_startPos.x();

205 qreal dY = m_dampedPos.y() - m_startPos.y();

206

207 switch (m_direction) {

208 case Upwards:

209 return dY <= 0 && qFabs(dX) <= qFabs(dY) * m_wideningFactor;

210 case Downwards:

211 return dY >= 0 && qFabs(dX) <= dY * m_wideningFactor;

212 case Leftwards:

213 return dX <= 0 && qFabs(dY) <= qFabs(dX) * m_wideningFactor;

214 default: // Rightwards:

215 return dX >= 0 && qFabs(dY) <= dX * m_wideningFactor;

216 }

217}

218

219bool DirectionalDragArea::movingInRightDirection() const

220{

221 switch (m_direction) {

222 case Upwards:

223 return m_dampedPos.y() <= m_previousDampedPos.y();

224 case Downwards:

225 return m_dampedPos.y() >= m_previousDampedPos.y();

226 case Leftwards:

227 return m_dampedPos.x() <= m_previousDampedPos.x();

228 default: // Rightwards:

229 return m_dampedPos.x() >= m_previousDampedPos.x();

230 }

231}

232

233bool DirectionalDragArea::movedFarEnough(const QPointF &point) const

234{

235 if (directionIsHorizontal())

236 return qFabs(point.x() - m_startPos.x()) > m_distanceThreshold;

237 else

238 return qFabs(point.y() - m_startPos.y()) > m_distanceThreshold;

239}

240

241void DirectionalDragArea::setStatus(DirectionalDragArea::Status newStatus)

242{

243 if (newStatus == m_status)

244 return;

245

246 DirectionalDragArea::Status oldStatus = m_status;

247

248 m_status = newStatus;

249 Q_EMIT statusChanged(m_status);

250

251 switch (newStatus) {

252 case WaitingForTouch:

253 if (oldStatus != DirectionalDragArea::Rejected) {

254 Q_EMIT draggingChanged(false);

255 }

256 break;

257 case Undecided:

258 Q_EMIT draggingChanged(true);

259 break;

260 case Rejected:

261 Q_EMIT draggingChanged(false);

262 break;

263 default:

264 // no-op

265 break;

266 }

267}

268

269void DirectionalDragArea::setPreviousPos(QPointF point)

270{

271 Q_ASSERT(m_status != Rejected);

272

273 bool xChanged = m_previousPos.x() != point.x();

274 bool yChanged = m_previousPos.y() != point.y();

275

276 m_previousPos = point;

277

278 if (xChanged) {

279 Q_EMIT touchXChanged(point.x());

280 if (directionIsHorizontal())

281 Q_EMIT distanceChanged(distance());

282 }

283

284 if (yChanged) {

285 Q_EMIT touchYChanged(point.y());

286 if (directionIsVertical())

287 Q_EMIT distanceChanged(distance());

288 }

289}

290

291bool DirectionalDragArea::directionIsHorizontal() const

292{

293 return m_direction == Leftwards || m_direction == Rightwards;

294}

295

296bool DirectionalDragArea::directionIsVertical() const

297{

298 return m_direction == Upwards || m_direction == Downwards;

299}