17 * |
17 * |
18 * Description: |
18 * Description: |
19 * |
19 * |
20 */ |
20 */ |
21 |
21 |
22 #include <QWidget> |
|
23 #include <QApplication> |
|
24 #include "qstmgestureevent.h" |
22 #include "qstmgestureevent.h" |
25 #include "qstmuievent_if.h" |
23 #include "qstmuievent_if.h" |
26 |
24 |
|
25 #include <QGraphicsSceneMouseEvent> |
|
26 |
27 using namespace qstmUiEventEngine; |
27 using namespace qstmUiEventEngine; |
28 |
28 using namespace qstmGesture; |
29 Qt::GestureType QStm_Gesture::s_assignedType = Qt::CustomGesture; |
29 |
|
30 static Qt::GestureType s_assignedType = Qt::CustomGesture; |
|
31 static int s_stmGestureEventType = QEvent::User; |
|
32 static QGraphicsItem* s_gestureGrabberItem = NULL; |
|
33 static QGraphicsItem* s_gestureFocusedItem = NULL; |
|
34 |
|
35 |
|
36 QStm_GestureEventFilter* QStm_GestureEventFilter::m_instance = 0; |
|
37 |
|
38 QStm_GestureEventFilter* QStm_GestureEventFilter::instance() |
|
39 { |
|
40 if (!m_instance) { |
|
41 m_instance = new QStm_GestureEventFilter(); |
|
42 } |
|
43 return m_instance; |
|
44 } |
|
45 |
|
46 bool QStm_GestureEventFilter::eventFilter(QObject* receiver, QEvent* evt) |
|
47 { |
|
48 return qstmIsGraphicsSceneMouseEvent(evt) || qstmIsMouseEvent(evt) || |
|
49 qstmIsTouchEvent(evt) || qstmIsContextMenuEvent(evt); |
|
50 } |
|
51 |
|
52 |
|
53 |
|
54 |
|
55 bool QStm_GestureEventFilter::sendGraphicsSceneMouseEvent(QEvent* event, QGraphicsObject* go) |
|
56 { |
|
57 bool ret = false; |
|
58 if (event->type() == QEvent::Gesture) { |
|
59 QStm_Gesture* gesture = getQStmGesture(event); |
|
60 if (gesture) { |
|
61 ret = gesture->sendGraphicsSceneMouseEvent(go); |
|
62 } |
|
63 |
|
64 } |
|
65 return ret; |
|
66 } |
|
67 |
|
68 |
|
69 bool QStm_GestureEventFilter::event(QEvent* event) |
|
70 { |
|
71 if (event->type() == QEvent::Gesture) { |
|
72 QStm_Gesture* gesture = getQStmGesture(event); |
|
73 if (gesture) { |
|
74 QStm_GestureType gtype = gesture->getGestureStmType(); |
|
75 |
|
76 /* |
|
77 * Touch mapped to mouse press, Tap mapped to mouse release |
|
78 * UpDown, LeftRight and Pan are mapped to mouse move. |
|
79 */ |
|
80 if (gtype == QStmMaybeTapGestureType) {// in case of tap send mouse release |
|
81 gesture->setGestureStmType(QStmReleaseGestureType); |
|
82 } |
|
83 |
|
84 bool ret = (gtype == QStmTouchGestureType || |
|
85 gtype == QStmMaybeTapGestureType || |
|
86 gtype == QStmLeftRightGestureType || |
|
87 gtype == QStmUpDownGestureType || |
|
88 gtype == QStmPanGestureType || |
|
89 gtype == QStmReleaseGestureType || |
|
90 gtype == QStmFlickGestureType || |
|
91 gtype == QStmUknownGestureType) ; |
|
92 |
|
93 if (ret) { |
|
94 gesture->sendMouseEvents(); |
|
95 (static_cast<QGestureEvent*>(event))->accept(QStm_Gesture::assignedType()); |
|
96 (static_cast<QGestureEvent*>(event))->accept(); |
|
97 } |
|
98 |
|
99 if (gtype == QStmTapGestureType) {// restore gesture type. |
|
100 gesture->setGestureStmType(QStmTapGestureType); |
|
101 } |
|
102 |
|
103 return ret; |
|
104 } |
|
105 } |
|
106 return false; |
|
107 } |
|
108 |
|
109 |
|
110 |
|
111 |
|
112 |
30 |
113 |
31 QStm_GestureEvent::QStm_GestureEvent(): |
114 QStm_GestureEvent::QStm_GestureEvent(): |
32 QEvent(QStm_GestureEvent::stmGestureEventType()) |
115 QEvent(QStm_GestureEvent::stmGestureEventType()) |
33 |
116 |
34 { |
117 { |
37 QStm_GestureEvent::~QStm_GestureEvent() |
120 QStm_GestureEvent::~QStm_GestureEvent() |
38 { |
121 { |
39 } |
122 } |
40 |
123 |
41 |
124 |
42 |
125 QEvent::Type QStm_GestureEvent::stmGestureEventType() |
43 |
126 { |
|
127 if (s_stmGestureEventType == QEvent::User) { |
|
128 s_stmGestureEventType = QEvent::registerEventType(QStmGestureEventType); |
|
129 } |
|
130 return static_cast<QEvent::Type>(QStmGestureEventType); |
|
131 } |
|
132 |
|
133 |
|
134 |
|
135 void QStm_Gesture::setAssignedGestureType(Qt::GestureType type) |
|
136 { |
|
137 s_assignedType = type; |
|
138 } |
|
139 |
|
140 Qt::GestureType QStm_Gesture::assignedType() |
|
141 { |
|
142 return s_assignedType; |
|
143 } |
|
144 |
|
145 |
|
146 QGraphicsItem* QStm_Gesture::gestureGrabberItem() |
|
147 { |
|
148 return s_gestureGrabberItem; |
|
149 } |
|
150 |
|
151 void QStm_Gesture::setGestureGrabberItem(QGraphicsItem* item) |
|
152 { |
|
153 s_gestureGrabberItem = item; |
|
154 } |
|
155 |
|
156 |
|
157 QGraphicsItem* QStm_Gesture::gestureFocusedItem() |
|
158 { |
|
159 return s_gestureFocusedItem; |
|
160 } |
|
161 |
|
162 void QStm_Gesture::setGestureFocusedItem(QGraphicsItem* item) |
|
163 { |
|
164 s_gestureFocusedItem = item; |
|
165 } |
44 |
166 |
45 QStm_Gesture::QStm_Gesture(QObject* parent) : QGesture(parent) |
167 QStm_Gesture::QStm_Gesture(QObject* parent) : QGesture(parent) |
46 { |
168 { |
47 m_speed = 0.0; |
169 m_speed = 0.0; |
48 m_direction = -1; |
170 m_direction = -1; |
49 m_vector = QPoint(0,0); |
171 m_vector = QPoint(0,0); |
50 m_gstType = QStmUknownGestureType; |
172 m_gstType = QStmUknownGestureType; |
51 m_state = Qt::NoGesture; |
173 m_state = Qt::NoGesture; |
52 m_gstSubType = 0; |
174 m_gstSubType = 0; |
53 m_pos = QPoint(INT_MIN,INT_MIN); |
175 m_pos = QPoint(INT_MIN,INT_MIN); |
|
176 m_pos2 = QPoint(INT_MIN,INT_MIN); |
54 m_details = NULL; |
177 m_details = NULL; |
55 m_speedVec = QPointF(0.0, 0.0); |
178 m_speedVec = QPointF(0.0, 0.0); |
56 m_target = NULL; |
179 m_target = NULL; |
|
180 m_timestamp = QTime::currentTime(); |
57 }; |
181 }; |
58 |
182 |
59 |
183 |
60 QStm_Gesture& QStm_Gesture::operator=(QStm_Gesture& other) |
184 QStm_Gesture& QStm_Gesture::operator=(QStm_Gesture& other) |
61 { |
185 { |
64 m_vector = other.getLengthAndDirection(); |
188 m_vector = other.getLengthAndDirection(); |
65 m_gstType = other.getGestureStmType(); |
189 m_gstType = other.getGestureStmType(); |
66 m_state = other.gestureState(); |
190 m_state = other.gestureState(); |
67 m_gstSubType = other.getGestureSubType(); |
191 m_gstSubType = other.getGestureSubType(); |
68 m_pos = other.position(); |
192 m_pos = other.position(); |
|
193 m_pos2 = other.position2(); |
69 m_details = other.getDetails(); |
194 m_details = other.getDetails(); |
70 m_speedVec = other.getSpeedVec(); |
195 m_speedVec = other.getSpeedVec(); |
71 m_target = other.m_target; |
196 m_target = other.target(); |
|
197 m_timestamp = other.timestamp(); |
|
198 setHotSpot(other.hotSpot()); |
72 return *this; |
199 return *this; |
73 } |
200 } |
74 |
201 |
75 |
202 |
76 QString QStm_Gesture::gestureName() |
203 QString QStm_Gesture::gestureName() |
107 default: |
234 default: |
108 return QString("XZ Gesture"); |
235 return QString("XZ Gesture"); |
109 } |
236 } |
110 } |
237 } |
111 |
238 |
|
239 |
|
240 |
|
241 QStm_GestureType QStm_Gesture::gestureUidToStmType(QStm_GestureUid uid, int stmGestSubType) |
|
242 { |
|
243 QStm_GestureType gtype = QStmUknownGestureType; |
|
244 |
|
245 switch (uid) { |
|
246 case EGestureUidTap: |
|
247 { |
|
248 QStm_TapType type = qstmGesture::QStm_TapType(stmGestSubType); |
|
249 if (type == qstmGesture::ETapTypeDouble) { |
|
250 gtype = QStmDoubleTapGestureType; |
|
251 } |
|
252 else { |
|
253 gtype = QStmTapGestureType; |
|
254 } |
|
255 break; |
|
256 } |
|
257 |
|
258 case EGestureUidTouch: |
|
259 { |
|
260 gtype = QStmTouchGestureType; |
|
261 break; |
|
262 } |
|
263 |
|
264 case EGestureUidRelease: |
|
265 { |
|
266 gtype = QStmReleaseGestureType; |
|
267 break; |
|
268 } |
|
269 |
|
270 case EGestureUidFlick: |
|
271 { |
|
272 gtype = QStmFlickGestureType; |
|
273 break; |
|
274 } |
|
275 |
|
276 case EGestureUidLeftRight: |
|
277 { |
|
278 gtype = QStmLeftRightGestureType; |
|
279 break; |
|
280 } |
|
281 |
|
282 case EGestureUidUpDown: |
|
283 { |
|
284 gtype = QStmUpDownGestureType; |
|
285 break; |
|
286 } |
|
287 |
|
288 case EGestureUidPan: |
|
289 { |
|
290 gtype = QStmPanGestureType; |
|
291 break; |
|
292 } |
|
293 |
|
294 case EGestureUidHover: |
|
295 { |
|
296 gtype = QStmHoverGestureType; |
|
297 break; |
|
298 } |
|
299 |
|
300 case EGestureUidLongPress: |
|
301 { |
|
302 gtype = QStmLongPressGestureType; |
|
303 break; |
|
304 } |
|
305 |
|
306 case EGestureUidEdgeScroll: |
|
307 { |
|
308 gtype = QStmEdgeScrollGestureType; |
|
309 break; |
|
310 } |
|
311 |
|
312 case EGestureUidCornerZoom: |
|
313 { |
|
314 gtype = QStmCornerZoomGestureType; |
|
315 break; |
|
316 } |
|
317 |
|
318 case EGestureUidPinch: |
|
319 { |
|
320 gtype = QStmPinchGestureType; |
|
321 break; |
|
322 } |
|
323 case EGestureUidMaybeTap: |
|
324 { |
|
325 gtype = QStmMaybeTapGestureType; |
|
326 break; |
|
327 } |
|
328 default: |
|
329 { |
|
330 gtype = QStmUknownGestureType; |
|
331 break; |
|
332 } |
|
333 } |
|
334 return gtype; |
|
335 } |
|
336 |
112 void QStm_Gesture::gestureTypeToMouseTypes(QVarLengthArray<int, 4>& types) |
337 void QStm_Gesture::gestureTypeToMouseTypes(QVarLengthArray<int, 4>& types) |
113 { |
338 { |
114 switch (m_gstType) { |
339 switch (m_gstType) { |
115 case QStmTouchGestureType: |
340 case QStmTouchGestureType: |
116 { |
341 { |
150 QEvent::Type evType = uiEvent->mapToMouseEventType(); |
377 QEvent::Type evType = uiEvent->mapToMouseEventType(); |
151 types.append(evType); |
378 types.append(evType); |
152 } |
379 } |
153 break; |
380 break; |
154 } |
381 } |
155 case QStmFlickGestureType: |
|
156 case QStmEdgeScrollGestureType: |
382 case QStmEdgeScrollGestureType: |
157 case QStmPinchGestureType: |
383 case QStmPinchGestureType: |
158 case QStmLongPressGestureType: |
384 case QStmLongPressGestureType: |
159 default: |
385 default: |
160 break; |
386 break; |
161 } |
387 } |
162 return; |
388 return; |
163 } |
389 } |
164 |
390 |
|
391 |
|
392 |
|
393 |
165 bool QStm_Gesture::sendOrPostMouseEvents(QObject* receiver, Qt::KeyboardModifier modifier, bool send) |
394 bool QStm_Gesture::sendOrPostMouseEvents(QObject* receiver, Qt::KeyboardModifier modifier, bool send) |
166 { |
395 { |
167 bool ret = false; |
396 bool ret = false; |
168 QPoint pos = position(); |
397 QPoint pos = position(); |
169 QPoint gpos = pos; |
398 QPoint gpos = pos; |
174 buttons &= ~Qt::RightButton; |
403 buttons &= ~Qt::RightButton; |
175 buttons &= ~Qt::MidButton; |
404 buttons &= ~Qt::MidButton; |
176 buttons &= Qt::MouseButtonMask; |
405 buttons &= Qt::MouseButtonMask; |
177 |
406 |
178 if (receiver->isWidgetType()) { |
407 if (receiver->isWidgetType()) { |
179 QWidget* w = static_cast<QWidget*>(receiver); |
408 w = static_cast<QWidget*>(receiver); |
180 pos = w->mapFromGlobal(gpos); |
409 pos = w->mapFromGlobal(gpos); |
181 } |
410 } |
182 |
411 |
|
412 |
183 QVarLengthArray<int, 4> mouseTypes; |
413 QVarLengthArray<int, 4> mouseTypes; |
184 gestureTypeToMouseTypes(mouseTypes); |
414 gestureTypeToMouseTypes(mouseTypes); |
185 |
415 |
186 for (int i = 0; i < mouseTypes.size(); i++) { |
416 for (int i = 0; i < mouseTypes.size(); i++) { |
187 QEvent::Type mtype = static_cast<QEvent::Type>(mouseTypes[i]); |
417 QEvent::Type mtype = static_cast<QEvent::Type>(mouseTypes[i]); |
188 |
418 |
|
419 if (mtype == QEvent::None) { |
|
420 continue; |
|
421 } |
|
422 else if (mtype != QEvent::MouseButtonRelease && w) { |
|
423 QPoint wtl = w->mapToGlobal(w->pos()); |
|
424 QRect wgeom = QRect(wtl, w->size()); |
|
425 if (!wgeom.contains(m_pos)) { |
|
426 continue; |
|
427 } |
|
428 } |
|
429 |
189 if (mtype == QEvent::MouseButtonRelease) { |
430 if (mtype == QEvent::MouseButtonRelease) { |
190 buttons = 0; |
431 buttons = 0; |
191 } |
432 } |
192 |
433 |
193 if (send) { |
434 if (send) { |
194 QMouseEvent evt(mtype, pos, gpos, Qt::LeftButton, buttons, modifier); |
435 QMouseEvent evt(mtype, pos, gpos, Qt::LeftButton, buttons, modifier); |
195 if (w) w->grabMouse(); |
436 //if (w) w->grabMouse(); |
196 QApplication::sendEvent(receiver, &evt); |
437 QApplication::sendEvent(receiver, &evt); |
197 if (w) w->releaseMouse(); |
438 //if (w) w->releaseMouse(); |
198 } |
439 } |
199 else { |
440 else { |
200 QMouseEvent* evt = new QMouseEvent(mtype, pos, gpos, Qt::LeftButton, buttons, modifier); |
441 QMouseEvent* evt = new QMouseEvent(mtype, pos, gpos, Qt::LeftButton, buttons, modifier); |
201 QApplication::postEvent(receiver, evt); |
442 QApplication::postEvent(receiver, evt); |
202 } |
443 } |
208 |
449 |
209 bool QStm_Gesture::sendEvent(QEvent* event) |
450 bool QStm_Gesture::sendEvent(QEvent* event) |
210 { |
451 { |
211 QWidget* target = static_cast<QWidget*>(m_target); |
452 QWidget* target = static_cast<QWidget*>(m_target); |
212 QWidget* w = NULL; |
453 QWidget* w = NULL; |
|
454 QWidget* modal = QApplication::activeModalWidget(); |
|
455 |
|
456 |
|
457 |
|
458 if (modal) { |
|
459 target = modal; |
|
460 } |
213 |
461 |
214 if (target) { |
462 if (target) { |
215 QPoint pos = target->mapFromGlobal(m_pos); |
463 QPoint pos = target->mapFromGlobal(m_pos); |
216 w = target->childAt(pos); |
464 w = target->childAt(pos); |
217 if (!w) { |
465 if (!w) { |
218 w = target; |
466 w = target; |
219 } |
467 } |
220 } |
468 } |
221 |
469 |
222 if (w) { |
470 if (w) { |
223 if (event->type() == QStm_GestureEvent::stmGestureEventType() && |
471 if (modal) { //we send mouse events to modal dialogs. |
|
472 return(sendMouseEvents(w)); |
|
473 } |
|
474 /* |
|
475 else if (event->type() == QStm_GestureEvent::stmGestureEventType() && |
224 m_gstType == QStmUknownGestureType) { |
476 m_gstType == QStmUknownGestureType) { |
225 QStm_UiEventIf* uiEvent = static_cast<QStm_UiEventIf*>(m_details); |
477 QStm_UiEventIf* uiEvent = static_cast<QStm_UiEventIf*>(m_details); |
226 QWidget* modal = QApplication::activeModalWidget(); |
478 |
227 if (uiEvent && m_target == modal) { |
479 if (uiEvent && m_target == modal) { |
228 //re-generate mouse events |
480 //re-generate mouse events |
229 sendMouseEvents(w); |
481 return(sendMouseEvents(w)); |
230 } |
482 } |
231 } |
483 |
232 else { |
484 else { |
233 QApplication::sendEvent(w, event); |
485 return(QApplication::sendEvent(w, event)); |
234 } |
486 } |
235 } |
487 } |
236 } |
488 */ |
237 |
489 else { |
|
490 if (!target->hasFocus()) { |
|
491 target->setFocus(Qt::MouseFocusReason); |
|
492 } |
|
493 return(QApplication::sendEvent(w, event)); |
|
494 } |
|
495 } |
|
496 return false; |
|
497 } |
|
498 |
|
499 |
|
500 bool QStm_Gesture::sendGraphicsSceneMouseEvent(QGraphicsObject* go) |
|
501 { |
|
502 QEvent::Type eventType = gestureType2GraphicsSceneMouseType(); |
|
503 bool ret = false; |
|
504 |
|
505 if (eventType != QEvent::None) { |
|
506 QGraphicsSceneMouseEvent gsme(eventType); |
|
507 QPointF scenePos = qstmMapToScene(m_pos, go); |
|
508 qstmSetGraphicsSceneMouseEvent(scenePos, go, gsme); |
|
509 ret = go->event(&gsme); |
|
510 } |
|
511 return ret; |
|
512 } |
|
513 |
|
514 |
|
515 QEvent::Type QStm_Gesture::gestureType2GraphicsSceneMouseType() |
|
516 { |
|
517 QEvent::Type type = QEvent::None; |
|
518 switch(m_gstType) |
|
519 { |
|
520 case QStmTouchGestureType: |
|
521 type = QEvent::GraphicsSceneMousePress; |
|
522 break; |
|
523 case QStmMaybeTapGestureType: |
|
524 case QStmReleaseGestureType: |
|
525 case QStmFlickGestureType: |
|
526 type = QEvent::GraphicsSceneMouseRelease; |
|
527 break; |
|
528 case QStmLeftRightGestureType: |
|
529 case QStmUpDownGestureType: |
|
530 case QStmPanGestureType: |
|
531 type = QEvent::GraphicsSceneMouseMove; |
|
532 break; |
|
533 case QStmUknownGestureType: |
|
534 { |
|
535 QVarLengthArray<int, 4> mouseTypes; |
|
536 gestureTypeToMouseTypes(mouseTypes); |
|
537 switch (mouseTypes[0]) |
|
538 { |
|
539 case QEvent::MouseButtonPress: |
|
540 type = QEvent::GraphicsSceneMousePress; |
|
541 break; |
|
542 case QEvent::MouseButtonRelease: |
|
543 type = QEvent::GraphicsSceneMouseRelease; |
|
544 break; |
|
545 case QEvent::MouseMove: |
|
546 type = QEvent::GraphicsSceneMouseMove; |
|
547 break; |
|
548 } |
|
549 } |
|
550 } |
|
551 return type; |
|
552 } |
238 |
553 |
239 bool QStm_Gesture::sendMouseEvents(Qt::KeyboardModifier modifier) |
554 bool QStm_Gesture::sendMouseEvents(Qt::KeyboardModifier modifier) |
240 { |
555 { |
241 Q_ASSERT(m_target); |
|
242 QWidget* target = static_cast<QWidget*>(m_target); |
556 QWidget* target = static_cast<QWidget*>(m_target); |
|
557 |
|
558 if (!target) { |
|
559 target = QApplication::widgetAt(m_pos); |
|
560 } |
|
561 if (!target) return false; |
243 QPoint pos = target->mapFromGlobal(m_pos); |
562 QPoint pos = target->mapFromGlobal(m_pos); |
244 QWidget* w = target->childAt(pos); |
563 QWidget* w = target->childAt(pos); |
245 if (!w) { |
564 if (!w) { |
246 w = target; |
565 w = target; |
247 } |
566 } |
280 mouseEventsList.append(evt); |
599 mouseEventsList.append(evt); |
281 } |
600 } |
282 return mouseEventsList; |
601 return mouseEventsList; |
283 } |
602 } |
284 |
603 |
|
604 |
|
605 bool QStm_Gesture::isGestureEnded() |
|
606 { |
|
607 bool gestureEnded = false; |
|
608 |
|
609 if (m_gstType == QStmUknownGestureType) { |
|
610 QStm_UiEventIf* uiEvent = static_cast<QStm_UiEventIf*>(m_details); |
|
611 if (uiEvent) { |
|
612 QEvent::Type evType = uiEvent->mapToMouseEventType(); |
|
613 gestureEnded = (evType == ERelease); |
|
614 } |
|
615 } |
|
616 else if (m_gstType == QStmReleaseGestureType || |
|
617 m_gstType == QStmFlickGestureType || |
|
618 m_gstType == QStmTapGestureType || |
|
619 m_gstType == QStmDoubleTapGestureType) { |
|
620 gestureEnded = true; |
|
621 } |
|
622 return gestureEnded; |
|
623 } |
|
624 |
|
625 bool QStm_Gesture::clearGestureFocusedItemIfNeeded() |
|
626 { |
|
627 bool reset = isGestureEnded(); |
|
628 if (reset) { |
|
629 QStm_Gesture::setGestureFocusedItem(NULL); |
|
630 } |
|
631 return reset; |
|
632 } |
|
633 |
|
634 void QStm_Gesture::updateGestureFocusedItemIfNeeded(QGraphicsItem* gi) |
|
635 { |
|
636 if (isGestureEnded()) { |
|
637 QStm_Gesture::setGestureFocusedItem(NULL); |
|
638 } |
|
639 else if (gestureState() != Qt::GestureFinished) { |
|
640 QStm_Gesture::setGestureFocusedItem(gi); |
|
641 } |
|
642 } |
|
643 |
|
644 QPointF QStm_Gesture::scenePosition(QGraphicsItem* i) |
|
645 { |
|
646 return qstmMapToScene(m_pos, static_cast<QGraphicsObject*>(i)); |
|
647 } |
|
648 |
|
649 QPointF QStm_Gesture::scenePosition2(QGraphicsItem* i) |
|
650 { |
|
651 return qstmMapToScene(m_pos2, static_cast<QGraphicsObject*>(i)); |
|
652 } |
|
653 |
|
654 QPointF QStm_Gesture::sceneSpeedVec(QGraphicsItem* i) |
|
655 { |
|
656 QGraphicsObject* o = static_cast<QGraphicsObject*>(i); |
|
657 |
|
658 return qstmMapToScene(m_speedVec,o) - qstmMapToScene(QPointF(0, 0), o); |
|
659 } |
|
660 |
|
661 QPointF QStm_Gesture::sceneLengthAndDirection(QGraphicsItem* i) |
|
662 { |
|
663 QGraphicsObject* o = static_cast<QGraphicsObject*>(i); |
|
664 |
|
665 return qstmMapToScene(QPointF(-m_vector.x(), m_vector.y()),o) - qstmMapToScene(QPointF(0, 0), o); |
|
666 } |
|
667 |
|
668 int QStm_Gesture::sceneDirection(QGraphicsItem *i) |
|
669 { |
|
670 QStm_GestureDirection dir = ENorth ; |
|
671 QPointF v = sceneLengthAndDirection(i); |
|
672 |
|
673 qreal x = qAbs(v.x()) ; |
|
674 qreal y = qAbs(v.y()) ; |
|
675 |
|
676 if (y == 0 && x == 0) { |
|
677 dir = ENoDirection; |
|
678 } |
|
679 else if (y <= x/2) { |
|
680 if (v.x() < 0) |
|
681 dir = EWest ; |
|
682 else |
|
683 dir = EEast ; |
|
684 } |
|
685 else if (y > x/2 && y <= (x+x/2)) { |
|
686 if (v.x() < 0) { |
|
687 if (v.y() < 0 ) |
|
688 dir = ESouthWest ; |
|
689 else |
|
690 dir = ENorthWest ; |
|
691 } |
|
692 else { |
|
693 if (v.y() < 0 ) |
|
694 dir = ESouthEast ; |
|
695 else |
|
696 dir = ENorthEast ; |
|
697 } |
|
698 } |
|
699 else if (y > x+x/2) { |
|
700 if (v.y() < 0) |
|
701 dir = ESouth ; |
|
702 else |
|
703 dir = ENorth ; |
|
704 } |
|
705 |
|
706 return dir ; |
|
707 } |
|
708 |
|
709 QSTMGESTURELIB_EXPORT QPoint qstmMapFromScene(const QPointF& gpos, QGraphicsObject* graphicsObj) |
|
710 { |
|
711 QGraphicsView* grView = qstmGetGraphicsView(graphicsObj); |
|
712 QPointF pos = QPointF(0.0, 0.0); |
|
713 if (grView) { |
|
714 pos = grView->mapFromScene(gpos); |
|
715 return grView->mapToGlobal(pos.toPoint()); |
|
716 } |
|
717 return QPoint(0, 0); |
|
718 } |
|
719 |
|
720 |
|
721 QSTMGESTURELIB_EXPORT QPointF qstmMapToScene(const QPointF& gpos, QGraphicsObject* graphicsObj) |
|
722 { |
|
723 QGraphicsView* grView = qstmGetGraphicsView(graphicsObj); |
|
724 QPointF pos = QPointF(0.0, 0.0); |
|
725 if (grView) { |
|
726 pos = grView->mapFromGlobal(gpos.toPoint()); |
|
727 pos = grView->mapToScene(pos.toPoint()); |
|
728 } |
|
729 return pos; |
|
730 } |
|
731 |
|
732 |
|
733 QSTMGESTURELIB_EXPORT QPointF qstmMapFromGlobal(const QPointF& gpos, QGraphicsObject* graphicsObj) |
|
734 { |
|
735 QGraphicsView* grView = qstmGetGraphicsView(graphicsObj); |
|
736 QPointF pos = QPointF(0.0, 0.0); |
|
737 if (grView) { |
|
738 pos = grView->mapFromGlobal(gpos.toPoint()); |
|
739 } |
|
740 return pos; |
|
741 } |
|
742 |
|
743 QSTMGESTURELIB_EXPORT QGraphicsView* qstmGetGraphicsView(QGraphicsObject* graphicsObj) |
|
744 { |
|
745 QGraphicsScene* scene = graphicsObj->scene(); |
|
746 QList<QGraphicsView*> gvList = scene->views(); |
|
747 QList<QGraphicsView*>::iterator it; |
|
748 |
|
749 /* |
|
750 for (it = gvList.begin(); it != gvList.end(); it++) { |
|
751 if (static_cast<QGraphicsView*>(*it)->hasFocus()) { |
|
752 return static_cast<QGraphicsView*>(*it); |
|
753 } |
|
754 } |
|
755 */ |
|
756 return gvList.isEmpty() ? NULL : gvList[0]; |
|
757 } |
285 |
758 |
286 QSTMGESTURELIB_EXPORT QStm_Gesture* getQStmGesture(QEvent* event) |
759 QSTMGESTURELIB_EXPORT QStm_Gesture* getQStmGesture(QEvent* event) |
287 { |
760 { |
288 QStm_Gesture* gesture = NULL; |
761 QStm_Gesture* gesture = NULL; |
289 if (event->type() == QEvent::Gesture) { |
762 if (event->type() == QEvent::Gesture) { |
295 } |
768 } |
296 } |
769 } |
297 return gesture; |
770 return gesture; |
298 } |
771 } |
299 |
772 |
|
773 QSTMGESTURELIB_EXPORT bool qstmDeliverGestureEventToGraphicsItem(QGraphicsView* gv, QEvent* event) |
|
774 { |
|
775 if (event->type() != QEvent::Gesture) return false; |
|
776 |
|
777 bool ret = false; |
|
778 QStm_Gesture* gesture = getQStmGesture(event); |
|
779 if (gesture) { |
|
780 |
|
781 QGraphicsScene* gs = gv->scene(); |
|
782 QGraphicsItem* gestureGrabber = QStm_Gesture::gestureGrabberItem(); |
|
783 QGraphicsItem* gi = QStm_Gesture::gestureFocusedItem(); |
|
784 QGraphicsItem* mgItem = gs->mouseGrabberItem(); |
|
785 |
|
786 if (gestureGrabber) { |
|
787 gs->sendEvent(gestureGrabber, event); |
|
788 ret = true; //no fallback to mouse events |
|
789 } |
|
790 else { |
|
791 if (!gi) { |
|
792 gi = mgItem; |
|
793 } |
|
794 if (!gi) { |
|
795 QPoint pos = gv->mapFromGlobal(gesture->position()); |
|
796 pos = gv->mapToScene(pos).toPoint(); |
|
797 QList<QGraphicsItem *> itemsList = gs->items(pos, Qt::IntersectsItemShape, |
|
798 Qt::DescendingOrder); |
|
799 for(int i = 0; i < itemsList.size(); i++) { |
|
800 |
|
801 if (itemsList[i] && (itemsList[i])->opacity() < qreal(0.001)) { |
|
802 continue; |
|
803 } |
|
804 gi = itemsList[i]; |
|
805 gs->setFocusItem(gi, Qt::MouseFocusReason); |
|
806 break; |
|
807 } |
|
808 } |
|
809 if (gi) { |
|
810 //gs->setFocusItem(gi, Qt::MouseFocusReason); |
|
811 //ret = gs->sendEvent(gi, event); |
|
812 //gs->setFocusItem(0, Qt::MouseFocusReason); |
|
813 |
|
814 QGraphicsObject* go = gi->toGraphicsObject(); |
|
815 if (go) { |
|
816 ret = go->event(event); |
|
817 } |
|
818 |
|
819 } |
|
820 } |
|
821 |
|
822 if (!ret) { // fallback to mouse events |
|
823 QStm_GestureEventFilter::instance()->event(event); |
|
824 ret = true; |
|
825 } |
|
826 else if (!gestureGrabber) { |
|
827 gesture->updateGestureFocusedItemIfNeeded(gi); |
|
828 } |
|
829 } |
|
830 return ret; |
|
831 } |
|
832 |
|
833 |
|
834 QSTMGESTURELIB_EXPORT void qstmSetGraphicsSceneMouseEvent(const QPointF& scenePos, QGraphicsObject* graphicsObj, |
|
835 QGraphicsSceneMouseEvent& event, bool select) |
|
836 { |
|
837 QPointF pos = scenePos; |
|
838 QPoint gpos = qstmMapFromScene(pos, graphicsObj); |
|
839 |
|
840 event.setScenePos(pos); |
|
841 event.setScreenPos(gpos); |
|
842 event.setPos(graphicsObj->mapFromScene(pos)); |
|
843 if (!select && event.type() != QEvent::GraphicsSceneMouseMove) { |
|
844 event.setButton(Qt::LeftButton); |
|
845 } |
|
846 else { |
|
847 event.setButton(Qt::NoButton); |
|
848 } |
|
849 if (!select) { |
|
850 event.setButtons(Qt::NoButton); |
|
851 } |
|
852 else { |
|
853 event.setButtons(Qt::LeftButton); |
|
854 } |
|
855 event.setModifiers(Qt::NoModifier); |
|
856 } |
|
857 |
|
858 QSTMGESTURELIB_EXPORT bool qstmIsGraphicsSceneMouseEvent(QEvent* event) |
|
859 { |
|
860 QEvent::Type type = event->type(); |
|
861 return type == QEvent::GraphicsSceneMouseMove || |
|
862 type == QEvent::GraphicsSceneMousePress || |
|
863 type == QEvent::GraphicsSceneMouseRelease || |
|
864 type == QEvent::GraphicsSceneMouseDoubleClick; |
|
865 } |
|
866 |
|
867 QSTMGESTURELIB_EXPORT bool qstmIsMouseEvent(QEvent* event) |
|
868 { |
|
869 QEvent::Type type = event->type(); |
|
870 return type == QEvent::MouseButtonPress || |
|
871 type == QEvent::MouseButtonRelease || |
|
872 type == QEvent::MouseMove || |
|
873 type == QEvent::MouseButtonDblClick; |
|
874 } |
|
875 |
|
876 QSTMGESTURELIB_EXPORT bool qstmIsTouchEvent(QEvent* event) |
|
877 { |
|
878 QEvent::Type type = event->type(); |
|
879 return type == QEvent::TouchBegin || |
|
880 type == QEvent::TouchEnd || |
|
881 type == QEvent::TouchUpdate; |
|
882 } |
|
883 |
|
884 QSTMGESTURELIB_EXPORT bool qstmIsContextMenuEvent(QEvent* event) |
|
885 { |
|
886 QEvent::Type type = event->type(); |
|
887 return type == QEvent::ContextMenu || |
|
888 type == QEvent::GraphicsSceneContextMenu; |
|
889 } |