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*[]) {
51 static irr::EKEY_CODE id2keycode(touch_gui_button_id id)
102 return keyname_to_keycode(g_settings->get("keymap_" + key).c_str());
105 TouchScreenGUI *g_touchscreengui;
107 static void load_button_texture(button_info* btn, const char* path,
108 rect<s32> button_rect, ISimpleTextureSource* tsrc, video::IVideoDriver *driver)
111 video::ITexture *texture = guiScalingImageButton(driver,
112 tsrc->getTexture(path, &tid), button_rect.getWidth(),
113 button_rect.getHeight());
115 btn->guibutton->setUseAlphaChannel(true);
116 if (g_settings->getBool("gui_scaling_filter")) {
117 rect<s32> txr_rect = rect<s32>(0, 0, button_rect.getWidth(), button_rect.getHeight());
118 btn->guibutton->setImage(texture, txr_rect);
119 btn->guibutton->setPressedImage(texture, txr_rect);
120 btn->guibutton->setScaleImage(false);
122 btn->guibutton->setImage(texture);
123 btn->guibutton->setPressedImage(texture);
124 btn->guibutton->setScaleImage(true);
126 btn->guibutton->setDrawBorder(false);
127 btn->guibutton->setText(L"");
131 AutoHideButtonBar::AutoHideButtonBar(IrrlichtDevice *device,
132 IEventReceiver* receiver) :
133 m_texturesource(NULL),
134 m_driver(device->getVideoDriver()),
135 m_guienv(device->getGUIEnvironment()),
136 m_receiver(receiver),
141 m_initialized(false),
142 m_dir(AHBB_Dir_Right_Left)
144 m_screensize = device->getVideoDriver()->getScreenSize();
148 void AutoHideButtonBar::init(ISimpleTextureSource* tsrc,
149 const char* starter_img, int button_id, v2s32 UpperLeft,
150 v2s32 LowerRight, autohide_button_bar_dir dir, float timeout)
152 m_texturesource = tsrc;
154 m_upper_left = UpperLeft;
155 m_lower_right = LowerRight;
157 /* init settings bar */
159 irr::core::rect<int> current_button = rect<s32>(UpperLeft.X, UpperLeft.Y,
160 LowerRight.X, LowerRight.Y);
162 m_starter.guibutton = m_guienv->addButton(current_button, 0, button_id, L"", 0);
163 m_starter.guibutton->grab();
164 m_starter.repeatcounter = -1;
165 m_starter.keycode = KEY_OEM_8; // use invalid keycode as it's not relevant
166 m_starter.immediate_release = true;
167 m_starter.ids.clear();
169 load_button_texture(&m_starter, starter_img, current_button,
170 m_texturesource, m_driver);
173 m_timeout_value = timeout;
175 m_initialized = true;
178 AutoHideButtonBar::~AutoHideButtonBar()
180 if (m_starter.guibutton) {
181 m_starter.guibutton->setVisible(false);
182 m_starter.guibutton->drop();
186 void AutoHideButtonBar::addButton(touch_gui_button_id button_id,
187 const wchar_t* caption, const char* btn_image)
190 if (!m_initialized) {
191 errorstream << "AutoHideButtonBar::addButton not yet initialized!"
197 if ((m_dir == AHBB_Dir_Top_Bottom) || (m_dir == AHBB_Dir_Bottom_Top)) {
198 button_size = m_lower_right.X - m_upper_left.X;
200 button_size = m_lower_right.Y - m_upper_left.Y;
203 irr::core::rect<int> current_button;
205 if ((m_dir == AHBB_Dir_Right_Left) || (m_dir == AHBB_Dir_Left_Right)) {
210 if (m_dir == AHBB_Dir_Left_Right) {
211 x_start = m_lower_right.X + (button_size * 1.25 * m_buttons.size())
212 + (button_size * 0.25);
213 x_end = x_start + button_size;
215 x_end = m_upper_left.X - (button_size * 1.25 * m_buttons.size())
216 - (button_size * 0.25);
217 x_start = x_end - button_size;
220 current_button = rect<s32>(x_start, m_upper_left.Y, x_end,
226 if (m_dir == AHBB_Dir_Top_Bottom) {
227 y_start = m_lower_right.X + (button_size * 1.25 * m_buttons.size())
228 + (button_size * 0.25);
229 y_end = y_start + button_size;
231 y_end = m_upper_left.X - (button_size * 1.25 * m_buttons.size())
232 - (button_size * 0.25);
233 y_start = y_end - button_size;
236 current_button = rect<s32>(m_upper_left.X, y_start, m_lower_right.Y,
240 button_info* btn = new button_info();
241 btn->guibutton = m_guienv->addButton(current_button, 0, button_id, caption, 0);
242 btn->guibutton->grab();
243 btn->guibutton->setVisible(false);
244 btn->guibutton->setEnabled(false);
245 btn->repeatcounter = -1;
246 btn->keycode = id2keycode(button_id);
247 btn->immediate_release = true;
250 load_button_texture(btn, btn_image, current_button, m_texturesource,
253 m_buttons.push_back(btn);
256 bool AutoHideButtonBar::isButton(const SEvent &event)
258 IGUIElement* rootguielement = m_guienv->getRootGUIElement();
260 if (rootguielement == NULL) {
264 gui::IGUIElement *element = rootguielement->getElementFromPoint(
265 core::position2d<s32>(event.TouchInput.X, event.TouchInput.Y));
267 if (element == NULL) {
272 /* check for all buttons in vector */
274 std::vector<button_info*>::iterator iter = m_buttons.begin();
276 while (iter != m_buttons.end()) {
277 if ((*iter)->guibutton == element) {
279 SEvent* translated = new SEvent();
280 memset(translated, 0, sizeof(SEvent));
281 translated->EventType = irr::EET_KEY_INPUT_EVENT;
282 translated->KeyInput.Key = (*iter)->keycode;
283 translated->KeyInput.Control = false;
284 translated->KeyInput.Shift = false;
285 translated->KeyInput.Char = 0;
288 translated->KeyInput.PressedDown = true;
289 m_receiver->OnEvent(*translated);
291 /* remove this event */
292 translated->KeyInput.PressedDown = false;
293 m_receiver->OnEvent(*translated);
297 (*iter)->ids.push_back(event.TouchInput.ID);
306 /* check for starter button only */
307 if (element == m_starter.guibutton) {
308 m_starter.ids.push_back(event.TouchInput.ID);
309 m_starter.guibutton->setVisible(false);
310 m_starter.guibutton->setEnabled(false);
314 std::vector<button_info*>::iterator iter = m_buttons.begin();
316 while (iter != m_buttons.end()) {
317 (*iter)->guibutton->setVisible(true);
318 (*iter)->guibutton->setEnabled(true);
328 bool AutoHideButtonBar::isReleaseButton(int eventID)
330 std::vector<int>::iterator id = std::find(m_starter.ids.begin(),
331 m_starter.ids.end(), eventID);
333 if (id != m_starter.ids.end()) {
334 m_starter.ids.erase(id);
338 std::vector<button_info*>::iterator iter = m_buttons.begin();
340 while (iter != m_buttons.end()) {
341 std::vector<int>::iterator id = std::find((*iter)->ids.begin(),
342 (*iter)->ids.end(), eventID);
344 if (id != (*iter)->ids.end()) {
345 (*iter)->ids.erase(id);
346 // TODO handle settings button release
355 void AutoHideButtonBar::step(float dtime)
360 if (m_timeout > m_timeout_value) {
366 void AutoHideButtonBar::deactivate()
368 if (m_visible == true) {
369 m_starter.guibutton->setVisible(true);
370 m_starter.guibutton->setEnabled(true);
374 std::vector<button_info*>::iterator iter = m_buttons.begin();
376 while (iter != m_buttons.end()) {
377 (*iter)->guibutton->setVisible(false);
378 (*iter)->guibutton->setEnabled(false);
383 void AutoHideButtonBar::hide()
386 m_starter.guibutton->setVisible(false);
387 m_starter.guibutton->setEnabled(false);
389 std::vector<button_info*>::iterator iter = m_buttons.begin();
391 while (iter != m_buttons.end()) {
392 (*iter)->guibutton->setVisible(false);
393 (*iter)->guibutton->setEnabled(false);
398 void AutoHideButtonBar::show()
403 std::vector<button_info*>::iterator iter = m_buttons.begin();
405 while (iter != m_buttons.end()) {
406 (*iter)->guibutton->setVisible(true);
407 (*iter)->guibutton->setEnabled(true);
411 m_starter.guibutton->setVisible(true);
412 m_starter.guibutton->setEnabled(true);
416 TouchScreenGUI::TouchScreenGUI(IrrlichtDevice *device, IEventReceiver* receiver):
418 m_guienv(device->getGUIEnvironment()),
419 m_camera_yaw_change(0.0),
423 m_receiver(receiver),
424 m_move_has_really_moved(false),
426 m_move_sent_as_mouse_event(false),
427 // use some downlocation way off screen as init value to avoid invalid behaviour
428 m_move_downlocation(v2s32(-10000, -10000)),
429 m_settingsbar(device, receiver),
430 m_rarecontrolsbar(device, receiver)
432 for (unsigned int i=0; i < after_last_element_id; i++) {
433 m_buttons[i].guibutton = 0;
434 m_buttons[i].repeatcounter = -1;
435 m_buttons[i].repeatdelay = BUTTON_REPEAT_DELAY;
438 m_screensize = m_device->getVideoDriver()->getScreenSize();
441 void TouchScreenGUI::initButton(touch_gui_button_id id, rect<s32> button_rect,
442 std::wstring caption, bool immediate_release, float repeat_delay)
445 button_info* btn = &m_buttons[id];
446 btn->guibutton = m_guienv->addButton(button_rect, 0, id, caption.c_str());
447 btn->guibutton->grab();
448 btn->repeatcounter = -1;
449 btn->repeatdelay = repeat_delay;
450 btn->keycode = id2keycode(id);
451 btn->immediate_release = immediate_release;
454 load_button_texture(btn,touchgui_button_imagenames[id],button_rect,
455 m_texturesource, m_device->getVideoDriver());
458 static int getMaxControlPadSize(float density) {
459 return 200 * density * g_settings->getFloat("hud_scaling");
462 int TouchScreenGUI::getGuiButtonSize()
464 u32 control_pad_size = MYMIN((2 * m_screensize.Y) / 3,
465 getMaxControlPadSize(porting::getDisplayDensity()));
467 return control_pad_size / 3;
470 void TouchScreenGUI::init(ISimpleTextureSource* tsrc)
474 u32 button_size = getGuiButtonSize();
476 m_texturesource = tsrc;
477 m_control_pad_rect = rect<s32>(0, m_screensize.Y - 3 * button_size,
478 3 * button_size, m_screensize.Y);
483 for now only 0, 1, 2, and 4 are used
486 for (int y = 0; y < 2; ++y)
487 for (int x = 0; x < 3; ++x, ++number) {
488 rect<s32> button_rect(
489 x * button_size, m_screensize.Y - button_size * (2 - y),
490 (x + 1) * button_size, m_screensize.Y - button_size * (1 - y)
492 touch_gui_button_id id = after_last_element_id;
493 std::wstring caption;
512 if (id != after_last_element_id) {
513 initButton(id, button_rect, caption, false);
517 /* init jump button */
519 rect<s32>(m_screensize.X-(1.75*button_size),
520 m_screensize.Y - (0.5*button_size),
521 m_screensize.X-(0.25*button_size),
525 /* init crunch button */
526 initButton(crunch_id,
527 rect<s32>(m_screensize.X-(3.25*button_size),
528 m_screensize.Y - (0.5*button_size),
529 m_screensize.X-(1.75*button_size),
533 m_settingsbar.init(m_texturesource, "gear_icon.png", settings_starter_id,
534 v2s32(m_screensize.X - (button_size / 2),
535 m_screensize.Y - ((SETTINGS_BAR_Y_OFFSET + 1) * button_size)
536 + (button_size * 0.5)),
537 v2s32(m_screensize.X,
538 m_screensize.Y - (SETTINGS_BAR_Y_OFFSET * button_size)
539 + (button_size * 0.5)), AHBB_Dir_Right_Left,
542 m_settingsbar.addButton(fly_id, L"fly", "fly_btn.png");
543 m_settingsbar.addButton(noclip_id, L"noclip", "noclip_btn.png");
544 m_settingsbar.addButton(fast_id, L"fast", "fast_btn.png");
545 m_settingsbar.addButton(debug_id, L"debug", "debug_btn.png");
546 m_settingsbar.addButton(camera_id, L"camera", "camera_btn.png");
547 m_settingsbar.addButton(range_id, L"rangeview", "rangeview_btn.png");
549 m_rarecontrolsbar.init(m_texturesource, "rare_controls.png",
550 rare_controls_starter_id,
553 - ((RARE_CONTROLS_BAR_Y_OFFSET + 1) * button_size)
554 + (button_size * 0.5)),
555 v2s32(button_size / 2,
556 m_screensize.Y - (RARE_CONTROLS_BAR_Y_OFFSET * button_size)
557 + (button_size * 0.5)), AHBB_Dir_Left_Right,
560 m_rarecontrolsbar.addButton(chat_id, L"Chat", "chat_btn.png");
561 m_rarecontrolsbar.addButton(inventory_id, L"inv", "inventory_btn.png");
562 m_rarecontrolsbar.addButton(drop_id, L"drop", "drop_btn.png");
566 touch_gui_button_id TouchScreenGUI::getButtonID(s32 x, s32 y)
568 IGUIElement* rootguielement = m_guienv->getRootGUIElement();
570 if (rootguielement != NULL) {
571 gui::IGUIElement *element =
572 rootguielement->getElementFromPoint(core::position2d<s32>(x,y));
575 for (unsigned int i=0; i < after_last_element_id; i++) {
576 if (element == m_buttons[i].guibutton) {
577 return (touch_gui_button_id) i;
582 return after_last_element_id;
585 touch_gui_button_id TouchScreenGUI::getButtonID(int eventID)
587 for (unsigned int i=0; i < after_last_element_id; i++) {
588 button_info* btn = &m_buttons[i];
590 std::vector<int>::iterator id =
591 std::find(btn->ids.begin(),btn->ids.end(), eventID);
593 if (id != btn->ids.end())
594 return (touch_gui_button_id) i;
597 return after_last_element_id;
600 bool TouchScreenGUI::isHUDButton(const SEvent &event)
602 // check if hud item is pressed
603 for (std::map<int,rect<s32> >::iterator iter = m_hud_rects.begin();
604 iter != m_hud_rects.end(); ++iter) {
605 if (iter->second.isPointInside(
606 v2s32(event.TouchInput.X,
609 if ( iter->first < 8) {
610 SEvent* translated = new SEvent();
611 memset(translated,0,sizeof(SEvent));
612 translated->EventType = irr::EET_KEY_INPUT_EVENT;
613 translated->KeyInput.Key = (irr::EKEY_CODE) (KEY_KEY_1 + iter->first);
614 translated->KeyInput.Control = false;
615 translated->KeyInput.Shift = false;
616 translated->KeyInput.PressedDown = true;
617 m_receiver->OnEvent(*translated);
618 m_hud_ids[event.TouchInput.ID] = translated->KeyInput.Key;
627 bool TouchScreenGUI::isReleaseHUDButton(int eventID)
629 std::map<int,irr::EKEY_CODE>::iterator iter = m_hud_ids.find(eventID);
631 if (iter != m_hud_ids.end()) {
632 SEvent* translated = new SEvent();
633 memset(translated,0,sizeof(SEvent));
634 translated->EventType = irr::EET_KEY_INPUT_EVENT;
635 translated->KeyInput.Key = iter->second;
636 translated->KeyInput.PressedDown = false;
637 translated->KeyInput.Control = false;
638 translated->KeyInput.Shift = false;
639 m_receiver->OnEvent(*translated);
640 m_hud_ids.erase(iter);
647 void TouchScreenGUI::handleButtonEvent(touch_gui_button_id button,
648 int eventID, bool action)
650 button_info* btn = &m_buttons[button];
651 SEvent* translated = new SEvent();
652 memset(translated,0,sizeof(SEvent));
653 translated->EventType = irr::EET_KEY_INPUT_EVENT;
654 translated->KeyInput.Key = btn->keycode;
655 translated->KeyInput.Control = false;
656 translated->KeyInput.Shift = false;
657 translated->KeyInput.Char = 0;
661 assert(std::find(btn->ids.begin(),btn->ids.end(), eventID) == btn->ids.end());
663 btn->ids.push_back(eventID);
665 if (btn->ids.size() > 1) return;
667 btn->repeatcounter = 0;
668 translated->KeyInput.PressedDown = true;
669 translated->KeyInput.Key = btn->keycode;
670 m_receiver->OnEvent(*translated);
673 if ((!action) || (btn->immediate_release)) {
675 std::vector<int>::iterator pos =
676 std::find(btn->ids.begin(),btn->ids.end(), eventID);
677 /* has to be in touch list */
678 assert(pos != btn->ids.end());
681 if (btn->ids.size() > 0) { return; }
683 translated->KeyInput.PressedDown = false;
684 btn->repeatcounter = -1;
685 m_receiver->OnEvent(*translated);
691 void TouchScreenGUI::handleReleaseEvent(int evt_id)
693 touch_gui_button_id button = getButtonID(evt_id);
695 /* handle button events */
696 if (button != after_last_element_id) {
697 handleButtonEvent(button, evt_id, false);
699 /* handle hud button events */
700 else if (isReleaseHUDButton(evt_id)) {
701 /* nothing to do here */
702 } else if (m_settingsbar.isReleaseButton(evt_id)) {
703 /* nothing to do here */
704 } else if (m_rarecontrolsbar.isReleaseButton(evt_id)) {
705 /* nothing to do here */
707 /* handle the point used for moving view */
708 else if (evt_id == m_move_id) {
711 /* if this pointer issued a mouse event issue symmetric release here */
712 if (m_move_sent_as_mouse_event) {
713 SEvent* translated = new SEvent;
714 memset(translated,0,sizeof(SEvent));
715 translated->EventType = EET_MOUSE_INPUT_EVENT;
716 translated->MouseInput.X = m_move_downlocation.X;
717 translated->MouseInput.Y = m_move_downlocation.Y;
718 translated->MouseInput.Shift = false;
719 translated->MouseInput.Control = false;
720 translated->MouseInput.ButtonStates = 0;
721 translated->MouseInput.Event = EMIE_LMOUSE_LEFT_UP;
722 m_receiver->OnEvent(*translated);
726 /* do double tap detection */
727 doubleTapDetection();
732 << "TouchScreenGUI::translateEvent released unknown button: "
733 << evt_id << std::endl;
736 for (std::vector<id_status>::iterator iter = m_known_ids.begin();
737 iter != m_known_ids.end(); ++iter) {
738 if (iter->id == evt_id) {
739 m_known_ids.erase(iter);
745 void TouchScreenGUI::translateEvent(const SEvent &event)
748 infostream << "TouchScreenGUI::translateEvent got event but not visible?!" << std::endl;
752 if (event.EventType != EET_TOUCH_INPUT_EVENT) {
756 if (event.TouchInput.Event == ETIE_PRESSED_DOWN) {
758 /* add to own copy of eventlist ...
759 * android would provide this information but irrlicht guys don't
760 * wanna design a efficient interface
763 toadd.id = event.TouchInput.ID;
764 toadd.X = event.TouchInput.X;
765 toadd.Y = event.TouchInput.Y;
766 m_known_ids.push_back(toadd);
768 int eventID = event.TouchInput.ID;
770 touch_gui_button_id button =
771 getButtonID(event.TouchInput.X, event.TouchInput.Y);
773 /* handle button events */
774 if (button != after_last_element_id) {
775 handleButtonEvent(button, eventID, true);
776 m_settingsbar.deactivate();
777 m_rarecontrolsbar.deactivate();
778 } else if (isHUDButton(event)) {
779 m_settingsbar.deactivate();
780 m_rarecontrolsbar.deactivate();
781 /* already handled in isHUDButton() */
782 } else if (m_settingsbar.isButton(event)) {
783 m_rarecontrolsbar.deactivate();
784 /* already handled in isSettingsBarButton() */
785 } else if (m_rarecontrolsbar.isButton(event)) {
786 m_settingsbar.deactivate();
787 /* already handled in isSettingsBarButton() */
789 /* handle non button events */
791 m_settingsbar.deactivate();
792 m_rarecontrolsbar.deactivate();
793 /* if we don't already have a moving point make this the moving one */
794 if (m_move_id == -1) {
795 m_move_id = event.TouchInput.ID;
796 m_move_has_really_moved = false;
797 m_move_downtime = porting::getTimeMs();
798 m_move_downlocation = v2s32(event.TouchInput.X, event.TouchInput.Y);
799 m_move_sent_as_mouse_event = false;
803 m_pointerpos[event.TouchInput.ID] = v2s32(event.TouchInput.X, event.TouchInput.Y);
805 else if (event.TouchInput.Event == ETIE_LEFT_UP) {
806 verbosestream << "Up event for pointerid: " << event.TouchInput.ID << std::endl;
807 handleReleaseEvent(event.TouchInput.ID);
810 assert(event.TouchInput.Event == ETIE_MOVED);
811 int move_idx = event.TouchInput.ID;
813 if (m_pointerpos[event.TouchInput.ID] ==
814 v2s32(event.TouchInput.X, event.TouchInput.Y)) {
818 if (m_move_id != -1) {
819 if ((event.TouchInput.ID == m_move_id) &&
820 (!m_move_sent_as_mouse_event)) {
822 double distance = sqrt(
823 (m_pointerpos[event.TouchInput.ID].X - event.TouchInput.X) *
824 (m_pointerpos[event.TouchInput.ID].X - event.TouchInput.X) +
825 (m_pointerpos[event.TouchInput.ID].Y - event.TouchInput.Y) *
826 (m_pointerpos[event.TouchInput.ID].Y - event.TouchInput.Y));
828 if ((distance > g_settings->getU16("touchscreen_threshold")) ||
829 (m_move_has_really_moved)) {
830 m_move_has_really_moved = true;
831 s32 X = event.TouchInput.X;
832 s32 Y = event.TouchInput.Y;
834 // update camera_yaw and camera_pitch
835 s32 dx = X - m_pointerpos[event.TouchInput.ID].X;
836 s32 dy = Y - m_pointerpos[event.TouchInput.ID].Y;
838 /* adapt to similar behaviour as pc screen */
839 double d = g_settings->getFloat("mouse_sensitivity") *4;
840 double old_yaw = m_camera_yaw_change;
841 double old_pitch = m_camera_pitch;
843 m_camera_yaw_change -= dx * d;
844 m_camera_pitch = MYMIN(MYMAX(m_camera_pitch + (dy * d), -180), 180);
847 m_shootline = m_device
849 ->getSceneCollisionManager()
850 ->getRayFromScreenCoordinates(v2s32(X, Y));
851 m_pointerpos[event.TouchInput.ID] = v2s32(X, Y);
854 else if ((event.TouchInput.ID == m_move_id) &&
855 (m_move_sent_as_mouse_event)) {
856 m_shootline = m_device
858 ->getSceneCollisionManager()
859 ->getRayFromScreenCoordinates(
860 v2s32(event.TouchInput.X,event.TouchInput.Y));
863 handleChangedButton(event);
868 void TouchScreenGUI::handleChangedButton(const SEvent &event)
870 for (unsigned int i = 0; i < after_last_element_id; i++) {
872 if (m_buttons[i].ids.empty()) {
875 for (std::vector<int>::iterator iter = m_buttons[i].ids.begin();
876 iter != m_buttons[i].ids.end(); ++iter) {
878 if (event.TouchInput.ID == *iter) {
880 int current_button_id =
881 getButtonID(event.TouchInput.X, event.TouchInput.Y);
883 if (current_button_id == i) {
887 /* remove old button */
888 handleButtonEvent((touch_gui_button_id) i,*iter,false);
890 if (current_button_id == after_last_element_id) {
893 handleButtonEvent((touch_gui_button_id) current_button_id,*iter,true);
900 int current_button_id = getButtonID(event.TouchInput.X, event.TouchInput.Y);
902 if (current_button_id == after_last_element_id) {
906 button_info* btn = &m_buttons[current_button_id];
907 if (std::find(btn->ids.begin(),btn->ids.end(), event.TouchInput.ID)
910 handleButtonEvent((touch_gui_button_id) current_button_id,
911 event.TouchInput.ID, true);
916 bool TouchScreenGUI::doubleTapDetection()
918 m_key_events[0].down_time = m_key_events[1].down_time;
919 m_key_events[0].x = m_key_events[1].x;
920 m_key_events[0].y = m_key_events[1].y;
921 m_key_events[1].down_time = m_move_downtime;
922 m_key_events[1].x = m_move_downlocation.X;
923 m_key_events[1].y = m_move_downlocation.Y;
925 u64 delta = porting::getDeltaMs(m_key_events[0].down_time, porting::getTimeMs());
929 double distance = sqrt(
930 (m_key_events[0].x - m_key_events[1].x) * (m_key_events[0].x - m_key_events[1].x) +
931 (m_key_events[0].y - m_key_events[1].y) * (m_key_events[0].y - m_key_events[1].y));
934 if (distance > (20 + g_settings->getU16("touchscreen_threshold")))
937 SEvent* translated = new SEvent();
938 memset(translated, 0, sizeof(SEvent));
939 translated->EventType = EET_MOUSE_INPUT_EVENT;
940 translated->MouseInput.X = m_key_events[0].x;
941 translated->MouseInput.Y = m_key_events[0].y;
942 translated->MouseInput.Shift = false;
943 translated->MouseInput.Control = false;
944 translated->MouseInput.ButtonStates = EMBSM_RIGHT;
947 m_shootline = m_device
949 ->getSceneCollisionManager()
950 ->getRayFromScreenCoordinates(v2s32(m_key_events[0].x, m_key_events[0].y));
952 translated->MouseInput.Event = EMIE_RMOUSE_PRESSED_DOWN;
953 verbosestream << "TouchScreenGUI::translateEvent right click press" << std::endl;
954 m_receiver->OnEvent(*translated);
956 translated->MouseInput.ButtonStates = 0;
957 translated->MouseInput.Event = EMIE_RMOUSE_LEFT_UP;
958 verbosestream << "TouchScreenGUI::translateEvent right click release" << std::endl;
959 m_receiver->OnEvent(*translated);
965 TouchScreenGUI::~TouchScreenGUI()
967 for (unsigned int i = 0; i < after_last_element_id; i++) {
968 button_info* btn = &m_buttons[i];
969 if (btn->guibutton != 0) {
970 btn->guibutton->drop();
971 btn->guibutton = NULL;
976 void TouchScreenGUI::step(float dtime)
978 /* simulate keyboard repeats */
979 for (unsigned int i = 0; i < after_last_element_id; i++) {
980 button_info* btn = &m_buttons[i];
982 if (btn->ids.size() > 0) {
983 btn->repeatcounter += dtime;
985 /* in case we're moving around digging does not happen */
987 m_move_has_really_moved = true;
989 if (btn->repeatcounter < btn->repeatdelay) continue;
991 btn->repeatcounter = 0;
993 memset(&translated, 0, sizeof(SEvent));
994 translated.EventType = irr::EET_KEY_INPUT_EVENT;
995 translated.KeyInput.Key = btn->keycode;
996 translated.KeyInput.PressedDown = false;
997 m_receiver->OnEvent(translated);
999 translated.KeyInput.PressedDown = true;
1000 m_receiver->OnEvent(translated);
1004 /* if a new placed pointer isn't moved for some time start digging */
1005 if ((m_move_id != -1) &&
1006 (!m_move_has_really_moved) &&
1007 (!m_move_sent_as_mouse_event)) {
1009 u64 delta = porting::getDeltaMs(m_move_downtime, porting::getTimeMs());
1011 if (delta > MIN_DIG_TIME_MS) {
1012 m_shootline = m_device
1014 ->getSceneCollisionManager()
1015 ->getRayFromScreenCoordinates(
1016 v2s32(m_move_downlocation.X,m_move_downlocation.Y));
1019 memset(&translated, 0, sizeof(SEvent));
1020 translated.EventType = EET_MOUSE_INPUT_EVENT;
1021 translated.MouseInput.X = m_move_downlocation.X;
1022 translated.MouseInput.Y = m_move_downlocation.Y;
1023 translated.MouseInput.Shift = false;
1024 translated.MouseInput.Control = false;
1025 translated.MouseInput.ButtonStates = EMBSM_LEFT;
1026 translated.MouseInput.Event = EMIE_LMOUSE_PRESSED_DOWN;
1027 verbosestream << "TouchScreenGUI::step left click press" << std::endl;
1028 m_receiver->OnEvent(translated);
1029 m_move_sent_as_mouse_event = true;
1033 m_settingsbar.step(dtime);
1034 m_rarecontrolsbar.step(dtime);
1037 void TouchScreenGUI::resetHud()
1039 m_hud_rects.clear();
1042 void TouchScreenGUI::registerHudItem(int index, const rect<s32> &rect)
1044 m_hud_rects[index] = rect;
1047 void TouchScreenGUI::Toggle(bool visible)
1049 m_visible = visible;
1050 for (unsigned int i = 0; i < after_last_element_id; i++) {
1051 button_info* btn = &m_buttons[i];
1052 if (btn->guibutton != 0) {
1053 btn->guibutton->setVisible(visible);
1057 /* clear all active buttons */
1059 while (m_known_ids.size() > 0) {
1060 handleReleaseEvent(m_known_ids.begin()->id);
1063 m_settingsbar.hide();
1064 m_rarecontrolsbar.hide();
1066 m_settingsbar.show();
1067 m_rarecontrolsbar.show();
1071 void TouchScreenGUI::hide()
1079 void TouchScreenGUI::show()