2 Copyright (C) 2014 sapier
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU Lesser General Public License as published by
6 the Free Software Foundation; either version 2.1 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU Lesser General Public License for more details.
14 You should have received a copy of the GNU Lesser General Public License along
15 with this program; if not, write to the Free Software Foundation, Inc.,
16 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 #include "touchscreengui.h"
20 #include "irrlichttypes.h"
26 #include "util/numeric.h"
28 #include "guiscalingfilter.h"
33 #include <ISceneCollisionManager.h>
35 // Very slow button repeat frequency (in seconds)
36 #define SLOW_BUTTON_REPEAT (1.0f)
38 using namespace irr::core;
40 extern Settings *g_settings;
42 const char** touchgui_button_imagenames = (const char*[]) {
60 static irr::EKEY_CODE id2keycode(touch_gui_button_id id)
111 return keyname_to_keycode(g_settings->get("keymap_" + key).c_str());
114 TouchScreenGUI *g_touchscreengui;
116 TouchScreenGUI::TouchScreenGUI(IrrlichtDevice *device, IEventReceiver* receiver):
118 m_guienv(device->getGUIEnvironment()),
125 for (unsigned int i=0; i < after_last_element_id; i++) {
126 m_buttons[i].guibutton = 0;
127 m_buttons[i].repeatcounter = -1;
128 m_buttons[i].repeatdelay = BUTTON_REPEAT_DELAY;
131 m_screensize = m_device->getVideoDriver()->getScreenSize();
134 void TouchScreenGUI::loadButtonTexture(button_info* btn, const char* path, rect<s32> button_rect)
137 video::ITexture *texture = guiScalingImageButton(m_device->getVideoDriver(),
138 m_texturesource->getTexture(path, &tid), button_rect.getWidth(), button_rect.getHeight());
140 btn->guibutton->setUseAlphaChannel(true);
141 if (g_settings->getBool("gui_scaling_filter")) {
142 rect<s32> txr_rect = rect<s32>(0, 0, button_rect.getWidth(), button_rect.getHeight());
143 btn->guibutton->setImage(texture, txr_rect);
144 btn->guibutton->setPressedImage(texture, txr_rect);
145 btn->guibutton->setScaleImage(false);
147 btn->guibutton->setImage(texture);
148 btn->guibutton->setPressedImage(texture);
149 btn->guibutton->setScaleImage(true);
151 btn->guibutton->setDrawBorder(false);
152 btn->guibutton->setText(L"");
156 void TouchScreenGUI::initButton(touch_gui_button_id id, rect<s32> button_rect,
157 std::wstring caption, bool immediate_release, float repeat_delay)
160 button_info* btn = &m_buttons[id];
161 btn->guibutton = m_guienv->addButton(button_rect, 0, id, caption.c_str());
162 btn->guibutton->grab();
163 btn->repeatcounter = -1;
164 btn->repeatdelay = repeat_delay;
165 btn->keycode = id2keycode(id);
166 btn->immediate_release = immediate_release;
169 loadButtonTexture(btn,touchgui_button_imagenames[id], button_rect);
172 static int getMaxControlPadSize(float density) {
173 return 200 * density * g_settings->getFloat("hud_scaling");
176 void TouchScreenGUI::init(ISimpleTextureSource* tsrc, float density)
180 u32 control_pad_size =
181 MYMIN((2 * m_screensize.Y) / 3,getMaxControlPadSize(density));
183 u32 button_size = control_pad_size / 3;
185 m_texturesource = tsrc;
186 m_control_pad_rect = rect<s32>(0, m_screensize.Y - 3 * button_size,
187 3 * button_size, m_screensize.Y);
192 for now only 0, 1, 2, and 4 are used
195 for (int y = 0; y < 2; ++y)
196 for (int x = 0; x < 3; ++x, ++number) {
197 rect<s32> button_rect(
198 x * button_size, m_screensize.Y - button_size * (2 - y),
199 (x + 1) * button_size, m_screensize.Y - button_size * (1 - y)
201 touch_gui_button_id id = after_last_element_id;
202 std::wstring caption;
221 if (id != after_last_element_id) {
222 initButton(id, button_rect, caption, false);
226 /* init inventory button */
227 initButton(inventory_id,
228 rect<s32>(0, m_screensize.Y - (button_size/2),
229 (button_size/2), m_screensize.Y), L"inv", true);
231 /* init drop button */
233 rect<s32>(2.5*button_size, m_screensize.Y - (button_size/2),
234 3*button_size, m_screensize.Y), L"drop", true);
236 /* init jump button */
238 rect<s32>(m_screensize.X-(1.75*button_size),
239 m_screensize.Y - (0.5*button_size),
240 m_screensize.X-(0.25*button_size),
244 /* init crunch button */
245 initButton(crunch_id,
246 rect<s32>(m_screensize.X-(3.25*button_size),
247 m_screensize.Y - (0.5*button_size),
248 m_screensize.X-(1.75*button_size),
252 /* init fly button */
254 rect<s32>(m_screensize.X - (0.75*button_size),
255 m_screensize.Y - (2.25*button_size),
256 m_screensize.X, m_screensize.Y - (button_size*1.5)),
257 L"fly", false, SLOW_BUTTON_REPEAT);
259 /* init noclip button */
260 initButton(noclip_id,
261 rect<s32>(m_screensize.X - (0.75*button_size), 2.25*button_size,
262 m_screensize.X, 3*button_size),
263 L"clip", false, SLOW_BUTTON_REPEAT);
265 /* init fast button */
267 rect<s32>(m_screensize.X - (0.75*button_size), 1.5*button_size,
268 m_screensize.X, 2.25*button_size),
269 L"fast", false, SLOW_BUTTON_REPEAT);
271 /* init debug button */
273 rect<s32>(m_screensize.X - (0.75*button_size), 0.75*button_size,
274 m_screensize.X, 1.5*button_size),
275 L"dbg", false, SLOW_BUTTON_REPEAT);
277 /* init chat button */
279 rect<s32>(m_screensize.X - (0.75*button_size), 0,
280 m_screensize.X, 0.75*button_size),
283 /* init camera button */
284 initButton(camera_id,
285 rect<s32>(m_screensize.X - (1.5*button_size), 0,
286 m_screensize.X - (0.75*button_size), 0.75*button_size),
287 L"cam", false, SLOW_BUTTON_REPEAT);
289 /* init rangeselect button */
291 rect<s32>(m_screensize.X - (2.25*button_size), 0,
292 m_screensize.X - (1.5*button_size), 0.75*button_size),
293 L"far", false, SLOW_BUTTON_REPEAT);
296 touch_gui_button_id TouchScreenGUI::getButtonID(s32 x, s32 y)
298 IGUIElement* rootguielement = m_guienv->getRootGUIElement();
300 if (rootguielement != NULL) {
301 gui::IGUIElement *element =
302 rootguielement->getElementFromPoint(core::position2d<s32>(x,y));
305 for (unsigned int i=0; i < after_last_element_id; i++) {
306 if (element == m_buttons[i].guibutton) {
307 return (touch_gui_button_id) i;
312 return after_last_element_id;
315 touch_gui_button_id TouchScreenGUI::getButtonID(int eventID)
317 for (unsigned int i=0; i < after_last_element_id; i++) {
318 button_info* btn = &m_buttons[i];
320 std::vector<int>::iterator id =
321 std::find(btn->ids.begin(),btn->ids.end(), eventID);
323 if (id != btn->ids.end())
324 return (touch_gui_button_id) i;
327 return after_last_element_id;
330 bool TouchScreenGUI::isHUDButton(const SEvent &event)
332 // check if hud item is pressed
333 for (std::map<int,rect<s32> >::iterator iter = m_hud_rects.begin();
334 iter != m_hud_rects.end(); ++iter) {
335 if (iter->second.isPointInside(
336 v2s32(event.TouchInput.X,
339 if ( iter->first < 8) {
340 SEvent* translated = new SEvent();
341 memset(translated,0,sizeof(SEvent));
342 translated->EventType = irr::EET_KEY_INPUT_EVENT;
343 translated->KeyInput.Key = (irr::EKEY_CODE) (KEY_KEY_1 + iter->first);
344 translated->KeyInput.Control = false;
345 translated->KeyInput.Shift = false;
346 translated->KeyInput.PressedDown = true;
347 m_receiver->OnEvent(*translated);
348 m_hud_ids[event.TouchInput.ID] = translated->KeyInput.Key;
357 bool TouchScreenGUI::isReleaseHUDButton(int eventID)
359 std::map<int,irr::EKEY_CODE>::iterator iter = m_hud_ids.find(eventID);
361 if (iter != m_hud_ids.end()) {
362 SEvent* translated = new SEvent();
363 memset(translated,0,sizeof(SEvent));
364 translated->EventType = irr::EET_KEY_INPUT_EVENT;
365 translated->KeyInput.Key = iter->second;
366 translated->KeyInput.PressedDown = false;
367 translated->KeyInput.Control = false;
368 translated->KeyInput.Shift = false;
369 m_receiver->OnEvent(*translated);
370 m_hud_ids.erase(iter);
377 void TouchScreenGUI::ButtonEvent(touch_gui_button_id button,
378 int eventID, bool action)
380 button_info* btn = &m_buttons[button];
381 SEvent* translated = new SEvent();
382 memset(translated,0,sizeof(SEvent));
383 translated->EventType = irr::EET_KEY_INPUT_EVENT;
384 translated->KeyInput.Key = btn->keycode;
385 translated->KeyInput.Control = false;
386 translated->KeyInput.Shift = false;
387 translated->KeyInput.Char = 0;
391 assert(std::find(btn->ids.begin(),btn->ids.end(), eventID) == btn->ids.end());
393 btn->ids.push_back(eventID);
395 if (btn->ids.size() > 1) return;
397 btn->repeatcounter = 0;
398 translated->KeyInput.PressedDown = true;
399 translated->KeyInput.Key = btn->keycode;
400 m_receiver->OnEvent(*translated);
403 if ((!action) || (btn->immediate_release)) {
405 std::vector<int>::iterator pos =
406 std::find(btn->ids.begin(),btn->ids.end(), eventID);
407 /* has to be in touch list */
408 assert(pos != btn->ids.end());
411 if (btn->ids.size() > 0) { return; }
413 translated->KeyInput.PressedDown = false;
414 btn->repeatcounter = -1;
415 m_receiver->OnEvent(*translated);
421 void TouchScreenGUI::handleReleaseEvent(int evt_id)
423 touch_gui_button_id button = getButtonID(evt_id);
425 /* handle button events */
426 if (button != after_last_element_id) {
427 ButtonEvent(button, evt_id, false);
429 /* handle hud button events */
430 else if (isReleaseHUDButton(evt_id)) {
431 /* nothing to do here */
433 /* handle the point used for moving view */
434 else if (evt_id == m_move_id) {
437 /* if this pointer issued a mouse event issue symmetric release here */
438 if (m_move_sent_as_mouse_event) {
439 SEvent* translated = new SEvent;
440 memset(translated,0,sizeof(SEvent));
441 translated->EventType = EET_MOUSE_INPUT_EVENT;
442 translated->MouseInput.X = m_move_downlocation.X;
443 translated->MouseInput.Y = m_move_downlocation.Y;
444 translated->MouseInput.Shift = false;
445 translated->MouseInput.Control = false;
446 translated->MouseInput.ButtonStates = 0;
447 translated->MouseInput.Event = EMIE_LMOUSE_LEFT_UP;
448 m_receiver->OnEvent(*translated);
452 /* do double tap detection */
453 doubleTapDetection();
458 << "TouchScreenGUI::translateEvent released unknown button: "
459 << evt_id << std::endl;
462 for (std::vector<id_status>::iterator iter = m_known_ids.begin();
463 iter != m_known_ids.end(); ++iter) {
464 if (iter->id == evt_id) {
465 m_known_ids.erase(iter);
471 void TouchScreenGUI::translateEvent(const SEvent &event)
474 infostream << "TouchScreenGUI::translateEvent got event but not visible?!" << std::endl;
478 if (event.EventType != EET_TOUCH_INPUT_EVENT) {
482 if (event.TouchInput.Event == ETIE_PRESSED_DOWN) {
484 /* add to own copy of eventlist ...
485 * android would provide this information but irrlicht guys don't
486 * wanna design a efficient interface
489 toadd.id = event.TouchInput.ID;
490 toadd.X = event.TouchInput.X;
491 toadd.Y = event.TouchInput.Y;
492 m_known_ids.push_back(toadd);
494 int eventID = event.TouchInput.ID;
496 touch_gui_button_id button =
497 getButtonID(event.TouchInput.X, event.TouchInput.Y);
499 /* handle button events */
500 if (button != after_last_element_id) {
501 ButtonEvent(button,eventID,true);
503 else if (isHUDButton(event))
505 /* already handled in isHUDButton() */
507 /* handle non button events */
509 /* if we don't already have a moving point make this the moving one */
510 if (m_move_id == -1) {
511 m_move_id = event.TouchInput.ID;
512 m_move_has_really_moved = false;
513 m_move_downtime = getTimeMs();
514 m_move_downlocation = v2s32(event.TouchInput.X, event.TouchInput.Y);
515 m_move_sent_as_mouse_event = false;
519 m_pointerpos[event.TouchInput.ID] = v2s32(event.TouchInput.X, event.TouchInput.Y);
521 else if (event.TouchInput.Event == ETIE_LEFT_UP) {
522 verbosestream << "Up event for pointerid: " << event.TouchInput.ID << std::endl;
524 handleReleaseEvent(event.TouchInput.ID);
527 assert(event.TouchInput.Event == ETIE_MOVED);
528 int move_idx = event.TouchInput.ID;
530 if (m_pointerpos[event.TouchInput.ID] ==
531 v2s32(event.TouchInput.X, event.TouchInput.Y)) {
535 if (m_move_id != -1) {
536 if ((event.TouchInput.ID == m_move_id) &&
537 (!m_move_sent_as_mouse_event)) {
539 double distance = sqrt(
540 (m_pointerpos[event.TouchInput.ID].X - event.TouchInput.X) *
541 (m_pointerpos[event.TouchInput.ID].X - event.TouchInput.X) +
542 (m_pointerpos[event.TouchInput.ID].Y - event.TouchInput.Y) *
543 (m_pointerpos[event.TouchInput.ID].Y - event.TouchInput.Y));
545 if ((distance > g_settings->getU16("touchscreen_threshold")) ||
546 (m_move_has_really_moved)) {
547 m_move_has_really_moved = true;
548 s32 X = event.TouchInput.X;
549 s32 Y = event.TouchInput.Y;
551 // update camera_yaw and camera_pitch
552 s32 dx = X - m_pointerpos[event.TouchInput.ID].X;
553 s32 dy = Y - m_pointerpos[event.TouchInput.ID].Y;
555 /* adapt to similar behaviour as pc screen */
556 double d = g_settings->getFloat("mouse_sensitivity") *4;
557 double old_yaw = m_camera_yaw;
558 double old_pitch = m_camera_pitch;
560 m_camera_yaw -= dx * d;
561 m_camera_pitch = MYMIN(MYMAX( m_camera_pitch + (dy * d),-180),180);
563 while (m_camera_yaw < 0)
566 while (m_camera_yaw > 360)
570 m_shootline = m_device
572 ->getSceneCollisionManager()
573 ->getRayFromScreenCoordinates(v2s32(X, Y));
574 m_pointerpos[event.TouchInput.ID] = v2s32(X, Y);
577 else if ((event.TouchInput.ID == m_move_id) &&
578 (m_move_sent_as_mouse_event)) {
579 m_shootline = m_device
581 ->getSceneCollisionManager()
582 ->getRayFromScreenCoordinates(
583 v2s32(event.TouchInput.X,event.TouchInput.Y));
587 handleChangedButton(event);
592 void TouchScreenGUI::handleChangedButton(const SEvent &event)
594 for (unsigned int i = 0; i < after_last_element_id; i++) {
596 if (m_buttons[i].ids.empty()) {
599 for(std::vector<int>::iterator iter = m_buttons[i].ids.begin();
600 iter != m_buttons[i].ids.end(); ++iter) {
602 if (event.TouchInput.ID == *iter) {
604 int current_button_id =
605 getButtonID(event.TouchInput.X, event.TouchInput.Y);
607 if (current_button_id == i) {
611 /* remove old button */
612 ButtonEvent((touch_gui_button_id) i,*iter,false);
614 if (current_button_id == after_last_element_id) {
617 ButtonEvent((touch_gui_button_id) current_button_id,*iter,true);
624 int current_button_id = getButtonID(event.TouchInput.X, event.TouchInput.Y);
626 if (current_button_id == after_last_element_id) {
630 button_info* btn = &m_buttons[current_button_id];
631 if (std::find(btn->ids.begin(),btn->ids.end(), event.TouchInput.ID) == btn->ids.end()) {
632 ButtonEvent((touch_gui_button_id) current_button_id,event.TouchInput.ID,true);
637 bool TouchScreenGUI::doubleTapDetection()
639 m_key_events[0].down_time = m_key_events[1].down_time;
640 m_key_events[0].x = m_key_events[1].x;
641 m_key_events[0].y = m_key_events[1].y;
642 m_key_events[1].down_time = m_move_downtime;
643 m_key_events[1].x = m_move_downlocation.X;
644 m_key_events[1].y = m_move_downlocation.Y;
646 u32 delta = porting::getDeltaMs(m_key_events[0].down_time,getTimeMs());
650 double distance = sqrt(
651 (m_key_events[0].x - m_key_events[1].x) * (m_key_events[0].x - m_key_events[1].x) +
652 (m_key_events[0].y - m_key_events[1].y) * (m_key_events[0].y - m_key_events[1].y));
655 if (distance >(20 + g_settings->getU16("touchscreen_threshold")))
658 SEvent* translated = new SEvent();
659 memset(translated,0,sizeof(SEvent));
660 translated->EventType = EET_MOUSE_INPUT_EVENT;
661 translated->MouseInput.X = m_key_events[0].x;
662 translated->MouseInput.Y = m_key_events[0].y;
663 translated->MouseInput.Shift = false;
664 translated->MouseInput.Control = false;
665 translated->MouseInput.ButtonStates = EMBSM_RIGHT;
668 m_shootline = m_device
670 ->getSceneCollisionManager()
671 ->getRayFromScreenCoordinates(v2s32(m_key_events[0].x, m_key_events[0].y));
673 translated->MouseInput.Event = EMIE_RMOUSE_PRESSED_DOWN;
674 verbosestream << "TouchScreenGUI::translateEvent right click press" << std::endl;
675 m_receiver->OnEvent(*translated);
677 translated->MouseInput.ButtonStates = 0;
678 translated->MouseInput.Event = EMIE_RMOUSE_LEFT_UP;
679 verbosestream << "TouchScreenGUI::translateEvent right click release" << std::endl;
680 m_receiver->OnEvent(*translated);
686 TouchScreenGUI::~TouchScreenGUI()
688 for (unsigned int i=0; i < after_last_element_id; i++) {
689 button_info* btn = &m_buttons[i];
690 if (btn->guibutton != 0) {
691 btn->guibutton->drop();
692 btn->guibutton = NULL;
697 void TouchScreenGUI::step(float dtime)
699 /* simulate keyboard repeats */
700 for (unsigned int i=0; i < after_last_element_id; i++) {
701 button_info* btn = &m_buttons[i];
703 if (btn->ids.size() > 0) {
704 btn->repeatcounter += dtime;
706 /* in case we're moving around digging does not happen */
708 m_move_has_really_moved = true;
710 if (btn->repeatcounter < btn->repeatdelay) continue;
712 btn->repeatcounter = 0;
714 memset(&translated,0,sizeof(SEvent));
715 translated.EventType = irr::EET_KEY_INPUT_EVENT;
716 translated.KeyInput.Key = btn->keycode;
717 translated.KeyInput.PressedDown = false;
718 m_receiver->OnEvent(translated);
720 translated.KeyInput.PressedDown = true;
721 m_receiver->OnEvent(translated);
725 /* if a new placed pointer isn't moved for some time start digging */
726 if ((m_move_id != -1) &&
727 (!m_move_has_really_moved) &&
728 (!m_move_sent_as_mouse_event)) {
730 u32 delta = porting::getDeltaMs(m_move_downtime,getTimeMs());
732 if (delta > MIN_DIG_TIME_MS) {
733 m_shootline = m_device
735 ->getSceneCollisionManager()
736 ->getRayFromScreenCoordinates(
737 v2s32(m_move_downlocation.X,m_move_downlocation.Y));
740 memset(&translated,0,sizeof(SEvent));
741 translated.EventType = EET_MOUSE_INPUT_EVENT;
742 translated.MouseInput.X = m_move_downlocation.X;
743 translated.MouseInput.Y = m_move_downlocation.Y;
744 translated.MouseInput.Shift = false;
745 translated.MouseInput.Control = false;
746 translated.MouseInput.ButtonStates = EMBSM_LEFT;
747 translated.MouseInput.Event = EMIE_LMOUSE_PRESSED_DOWN;
748 verbosestream << "TouchScreenGUI::step left click press" << std::endl;
749 m_receiver->OnEvent(translated);
750 m_move_sent_as_mouse_event = true;
755 void TouchScreenGUI::resetHud()
760 void TouchScreenGUI::registerHudItem(int index, const rect<s32> &rect)
762 m_hud_rects[index] = rect;
765 void TouchScreenGUI::Toggle(bool visible)
768 for (unsigned int i=0; i < after_last_element_id; i++) {
769 button_info* btn = &m_buttons[i];
770 if (btn->guibutton != 0) {
771 btn->guibutton->setVisible(visible);
775 /* clear all active buttons */
777 while (m_known_ids.size() > 0) {
778 handleReleaseEvent(m_known_ids.begin()->id);
783 void TouchScreenGUI::Hide()
791 void TouchScreenGUI::Show()