InputSourceTouch.cpp 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354
  1. /*
  2. * InputSourceTouch.cpp, part of VCMI engine
  3. *
  4. * Authors: listed in file AUTHORS in main folder
  5. *
  6. * License: GNU General Public License v2.0 or later
  7. * Full text of license available in license.txt file, in main folder
  8. *
  9. */
  10. #include "StdInc.h"
  11. #include "InputSourceTouch.h"
  12. #include "InputHandler.h"
  13. #include "../../lib/CConfigHandler.h"
  14. #include "../CGameInfo.h"
  15. #include "../gui/CursorHandler.h"
  16. #include "../gui/CGuiHandler.h"
  17. #include "../gui/EventDispatcher.h"
  18. #include "../gui/MouseButton.h"
  19. #include "../gui/WindowHandler.h"
  20. #include "../render/IScreenHandler.h"
  21. #include "../CServerHandler.h"
  22. #include "../globalLobby/GlobalLobbyClient.h"
  23. #if defined(VCMI_ANDROID)
  24. #include "../../lib/CAndroidVMHelper.h"
  25. #elif defined(VCMI_IOS)
  26. #include "../ios/utils.h"
  27. #endif
  28. #include <SDL_events.h>
  29. #include <SDL_hints.h>
  30. #include <SDL_timer.h>
  31. InputSourceTouch::InputSourceTouch()
  32. : lastTapTimeTicks(0), lastLeftClickTimeTicks(0), numTouchFingers(0)
  33. {
  34. params.useRelativeMode = settings["general"]["userRelativePointer"].Bool();
  35. params.relativeModeSpeedFactor = settings["general"]["relativePointerSpeedMultiplier"].Float();
  36. params.longTouchTimeMilliseconds = settings["general"]["longTouchTimeMilliseconds"].Float();
  37. params.hapticFeedbackEnabled = settings["general"]["hapticFeedback"].Bool();
  38. params.touchToleranceDistance = settings["input"]["touchToleranceDistance"].Float();
  39. if (params.useRelativeMode)
  40. state = TouchState::RELATIVE_MODE;
  41. else
  42. state = TouchState::IDLE;
  43. #ifdef VCMI_EMULATE_TOUCHSCREEN_WITH_MOUSE
  44. SDL_SetHint(SDL_HINT_MOUSE_TOUCH_EVENTS, "1");
  45. #else
  46. SDL_SetHint(SDL_HINT_MOUSE_TOUCH_EVENTS, "0");
  47. #endif
  48. SDL_SetHint(SDL_HINT_TOUCH_MOUSE_EVENTS, "0");
  49. }
  50. void InputSourceTouch::handleEventFingerMotion(const SDL_TouchFingerEvent & tfinger)
  51. {
  52. if (CCS && CCS->curh && settings["video"]["cursor"].String() == "software" && state != TouchState::RELATIVE_MODE)
  53. CCS->curh->cursorMove(GH.getCursorPosition().x, GH.getCursorPosition().y);
  54. switch(state)
  55. {
  56. case TouchState::RELATIVE_MODE:
  57. {
  58. Point screenSize = GH.screenDimensions();
  59. int scalingFactor = GH.screenHandler().getScalingFactor();
  60. Point moveDistance {
  61. static_cast<int>(screenSize.x * params.relativeModeSpeedFactor * tfinger.dx),
  62. static_cast<int>(screenSize.y * params.relativeModeSpeedFactor * tfinger.dy)
  63. };
  64. GH.input().moveCursorPosition(moveDistance);
  65. if (CCS && CCS->curh)
  66. CCS->curh->cursorMove(GH.getCursorPosition().x * scalingFactor, GH.getCursorPosition().y * scalingFactor);
  67. break;
  68. }
  69. case TouchState::IDLE:
  70. {
  71. // no-op, might happen in some edge cases, e.g. when fingerdown event was ignored
  72. break;
  73. }
  74. case TouchState::TAP_DOWN_SHORT:
  75. case TouchState::TAP_DOWN_LONG_AWAIT:
  76. {
  77. Point distance = convertTouchToMouse(tfinger) - lastTapPosition;
  78. if ( std::abs(distance.x) > params.panningSensitivityThreshold || std::abs(distance.y) > params.panningSensitivityThreshold)
  79. {
  80. state = state == TouchState::TAP_DOWN_SHORT ? TouchState::TAP_DOWN_PANNING : TouchState::TAP_DOWN_PANNING_POPUP;
  81. GH.events().dispatchGesturePanningStarted(lastTapPosition);
  82. }
  83. break;
  84. }
  85. case TouchState::TAP_DOWN_PANNING:
  86. case TouchState::TAP_DOWN_PANNING_POPUP:
  87. {
  88. emitPanningEvent(tfinger);
  89. break;
  90. }
  91. case TouchState::TAP_DOWN_DOUBLE:
  92. {
  93. emitPinchEvent(tfinger);
  94. break;
  95. }
  96. case TouchState::TAP_DOWN_LONG:
  97. {
  98. // no-op
  99. break;
  100. }
  101. }
  102. }
  103. void InputSourceTouch::handleEventFingerDown(const SDL_TouchFingerEvent & tfinger)
  104. {
  105. numTouchFingers = SDL_GetNumTouchFingers(tfinger.touchId);
  106. // FIXME: better place to update potentially changed settings?
  107. params.longTouchTimeMilliseconds = settings["general"]["longTouchTimeMilliseconds"].Float();
  108. params.hapticFeedbackEnabled = settings["general"]["hapticFeedback"].Bool();
  109. lastTapTimeTicks = tfinger.timestamp;
  110. switch(state)
  111. {
  112. case TouchState::RELATIVE_MODE:
  113. {
  114. if(tfinger.x > 0.5)
  115. {
  116. if (tfinger.y < 0.5)
  117. GH.events().dispatchShowPopup(GH.getCursorPosition(), params.touchToleranceDistance);
  118. else
  119. GH.events().dispatchMouseLeftButtonPressed(GH.getCursorPosition(), params.touchToleranceDistance);
  120. }
  121. break;
  122. }
  123. case TouchState::IDLE:
  124. {
  125. lastTapPosition = convertTouchToMouse(tfinger);
  126. GH.input().setCursorPosition(lastTapPosition);
  127. state = TouchState::TAP_DOWN_SHORT;
  128. break;
  129. }
  130. case TouchState::TAP_DOWN_SHORT:
  131. {
  132. GH.input().setCursorPosition(convertTouchToMouse(tfinger));
  133. GH.events().dispatchGesturePanningStarted(lastTapPosition);
  134. state = TouchState::TAP_DOWN_DOUBLE;
  135. break;
  136. }
  137. case TouchState::TAP_DOWN_PANNING:
  138. {
  139. GH.input().setCursorPosition(convertTouchToMouse(tfinger));
  140. state = TouchState::TAP_DOWN_DOUBLE;
  141. break;
  142. }
  143. case TouchState::TAP_DOWN_DOUBLE:
  144. {
  145. CSH->getGlobalLobby().activateInterface();
  146. break;
  147. }
  148. case TouchState::TAP_DOWN_LONG_AWAIT:
  149. lastTapPosition = convertTouchToMouse(tfinger);
  150. break;
  151. case TouchState::TAP_DOWN_LONG:
  152. case TouchState::TAP_DOWN_PANNING_POPUP:
  153. {
  154. // no-op
  155. break;
  156. }
  157. }
  158. }
  159. void InputSourceTouch::handleEventFingerUp(const SDL_TouchFingerEvent & tfinger)
  160. {
  161. numTouchFingers = SDL_GetNumTouchFingers(tfinger.touchId);
  162. switch(state)
  163. {
  164. case TouchState::RELATIVE_MODE:
  165. {
  166. if(tfinger.x > 0.5)
  167. {
  168. if (tfinger.y < 0.5)
  169. GH.events().dispatchClosePopup(GH.getCursorPosition());
  170. else
  171. GH.events().dispatchMouseLeftButtonReleased(GH.getCursorPosition(), params.touchToleranceDistance);
  172. }
  173. break;
  174. }
  175. case TouchState::IDLE:
  176. {
  177. // no-op, might happen in some edge cases, e.g. when fingerdown event was ignored
  178. break;
  179. }
  180. case TouchState::TAP_DOWN_SHORT:
  181. {
  182. GH.input().setCursorPosition(convertTouchToMouse(tfinger));
  183. if(tfinger.timestamp - lastLeftClickTimeTicks < params.doubleTouchTimeMilliseconds && (convertTouchToMouse(tfinger) - lastLeftClickPosition).length() < params.doubleTouchToleranceDistance)
  184. {
  185. GH.events().dispatchMouseDoubleClick(convertTouchToMouse(tfinger), params.touchToleranceDistance);
  186. GH.events().dispatchMouseLeftButtonReleased(convertTouchToMouse(tfinger), params.touchToleranceDistance);
  187. }
  188. else
  189. {
  190. GH.events().dispatchMouseLeftButtonPressed(convertTouchToMouse(tfinger), params.touchToleranceDistance);
  191. GH.events().dispatchMouseLeftButtonReleased(convertTouchToMouse(tfinger), params.touchToleranceDistance);
  192. lastLeftClickTimeTicks = tfinger.timestamp;
  193. lastLeftClickPosition = convertTouchToMouse(tfinger);
  194. }
  195. state = TouchState::IDLE;
  196. break;
  197. }
  198. case TouchState::TAP_DOWN_PANNING:
  199. case TouchState::TAP_DOWN_PANNING_POPUP:
  200. {
  201. GH.events().dispatchGesturePanningEnded(lastTapPosition, convertTouchToMouse(tfinger));
  202. state = state == TouchState::TAP_DOWN_PANNING ? TouchState::IDLE : TouchState::TAP_DOWN_LONG_AWAIT;
  203. break;
  204. }
  205. case TouchState::TAP_DOWN_DOUBLE:
  206. {
  207. if (SDL_GetNumTouchFingers(tfinger.touchId) == 1)
  208. state = TouchState::TAP_DOWN_PANNING;
  209. if (SDL_GetNumTouchFingers(tfinger.touchId) == 0)
  210. {
  211. GH.events().dispatchGesturePanningEnded(lastTapPosition, convertTouchToMouse(tfinger));
  212. state = TouchState::IDLE;
  213. }
  214. break;
  215. }
  216. case TouchState::TAP_DOWN_LONG:
  217. {
  218. if (SDL_GetNumTouchFingers(tfinger.touchId) == 0)
  219. {
  220. state = TouchState::TAP_DOWN_LONG_AWAIT;
  221. }
  222. break;
  223. }
  224. case TouchState::TAP_DOWN_LONG_AWAIT:
  225. {
  226. if (SDL_GetNumTouchFingers(tfinger.touchId) == 0)
  227. {
  228. GH.input().setCursorPosition(convertTouchToMouse(tfinger));
  229. GH.events().dispatchClosePopup(convertTouchToMouse(tfinger));
  230. state = TouchState::IDLE;
  231. }
  232. break;
  233. }
  234. }
  235. }
  236. void InputSourceTouch::handleUpdate()
  237. {
  238. if ( state == TouchState::TAP_DOWN_SHORT)
  239. {
  240. uint32_t currentTime = SDL_GetTicks();
  241. if (currentTime > lastTapTimeTicks + params.longTouchTimeMilliseconds)
  242. {
  243. GH.events().dispatchShowPopup(GH.getCursorPosition(), params.touchToleranceDistance);
  244. if (GH.windows().isTopWindowPopup())
  245. {
  246. hapticFeedback();
  247. state = TouchState::TAP_DOWN_LONG;
  248. }
  249. }
  250. }
  251. }
  252. Point InputSourceTouch::convertTouchToMouse(const SDL_TouchFingerEvent & tfinger)
  253. {
  254. return convertTouchToMouse(tfinger.x, tfinger.y);
  255. }
  256. Point InputSourceTouch::convertTouchToMouse(float x, float y)
  257. {
  258. return Point(x * GH.screenDimensions().x, y * GH.screenDimensions().y);
  259. }
  260. bool InputSourceTouch::hasTouchInputDevice() const
  261. {
  262. return SDL_GetNumTouchDevices() > 0;
  263. }
  264. int InputSourceTouch::getNumTouchFingers() const
  265. {
  266. return numTouchFingers;
  267. }
  268. void InputSourceTouch::emitPanningEvent(const SDL_TouchFingerEvent & tfinger)
  269. {
  270. Point distance = convertTouchToMouse(-tfinger.dx, -tfinger.dy);
  271. GH.events().dispatchGesturePanning(lastTapPosition, convertTouchToMouse(tfinger), distance);
  272. }
  273. void InputSourceTouch::emitPinchEvent(const SDL_TouchFingerEvent & tfinger)
  274. {
  275. int fingers = SDL_GetNumTouchFingers(tfinger.touchId);
  276. if (fingers < 2)
  277. return;
  278. bool otherFingerFound = false;
  279. double otherX;
  280. double otherY;
  281. for (int i = 0; i < fingers; ++i)
  282. {
  283. SDL_Finger * finger = SDL_GetTouchFinger(tfinger.touchId, i);
  284. if (finger && finger->id != tfinger.fingerId)
  285. {
  286. otherX = finger->x * GH.screenDimensions().x;
  287. otherY = finger->y * GH.screenDimensions().y;
  288. otherFingerFound = true;
  289. break;
  290. }
  291. }
  292. if (!otherFingerFound)
  293. return; // should be impossible, but better to avoid weird edge cases
  294. float thisX = tfinger.x * GH.screenDimensions().x;
  295. float thisY = tfinger.y * GH.screenDimensions().y;
  296. float deltaX = tfinger.dx * GH.screenDimensions().x;
  297. float deltaY = tfinger.dy * GH.screenDimensions().y;
  298. float oldX = thisX - deltaX - otherX;
  299. float oldY = thisY - deltaY - otherY;
  300. float newX = thisX - otherX;
  301. float newY = thisY - otherY;
  302. double distanceOld = std::sqrt(oldX * oldX + oldY * oldY);
  303. double distanceNew = std::sqrt(newX * newX + newY * newY);
  304. if (distanceOld > params.pinchSensitivityThreshold)
  305. GH.events().dispatchGesturePinch(lastTapPosition, distanceNew / distanceOld);
  306. }
  307. void InputSourceTouch::hapticFeedback() {
  308. if(params.hapticFeedbackEnabled) {
  309. #if defined(VCMI_ANDROID)
  310. CAndroidVMHelper vmHelper;
  311. vmHelper.callStaticVoidMethod(CAndroidVMHelper::NATIVE_METHODS_DEFAULT_CLASS, "hapticFeedback");
  312. #elif defined(VCMI_IOS)
  313. iOS_utils::hapticFeedback();
  314. #endif
  315. }
  316. }