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 const char** touchgui_button_imagenames = (const char*[]) {
49 static irr::EKEY_CODE id2keycode(touch_gui_button_id id)
100 return keyname_to_keycode(g_settings->get("keymap_" + key).c_str());
103 TouchScreenGUI *g_touchscreengui;
105 static void load_button_texture(button_info* btn, const char* path,
106 rect<s32> button_rect, ISimpleTextureSource* tsrc, video::IVideoDriver *driver)
109 video::ITexture *texture = guiScalingImageButton(driver,
110 tsrc->getTexture(path, &tid), button_rect.getWidth(),
111 button_rect.getHeight());
113 btn->guibutton->setUseAlphaChannel(true);
114 if (g_settings->getBool("gui_scaling_filter")) {
115 rect<s32> txr_rect = rect<s32>(0, 0, button_rect.getWidth(), button_rect.getHeight());
116 btn->guibutton->setImage(texture, txr_rect);
117 btn->guibutton->setPressedImage(texture, txr_rect);
118 btn->guibutton->setScaleImage(false);
120 btn->guibutton->setImage(texture);
121 btn->guibutton->setPressedImage(texture);
122 btn->guibutton->setScaleImage(true);
124 btn->guibutton->setDrawBorder(false);
125 btn->guibutton->setText(L"");
129 AutoHideButtonBar::AutoHideButtonBar(IrrlichtDevice *device,
130 IEventReceiver* receiver) :
131 m_driver(device->getVideoDriver()),
132 m_guienv(device->getGUIEnvironment()),
137 void AutoHideButtonBar::init(ISimpleTextureSource* tsrc,
138 const char* starter_img, int button_id, v2s32 UpperLeft,
139 v2s32 LowerRight, autohide_button_bar_dir dir, float timeout)
141 m_texturesource = tsrc;
143 m_upper_left = UpperLeft;
144 m_lower_right = LowerRight;
146 /* init settings bar */
148 irr::core::rect<int> current_button = rect<s32>(UpperLeft.X, UpperLeft.Y,
149 LowerRight.X, LowerRight.Y);
151 m_starter.guibutton = m_guienv->addButton(current_button, 0, button_id, L"", 0);
152 m_starter.guibutton->grab();
153 m_starter.repeatcounter = -1;
154 m_starter.keycode = KEY_OEM_8; // use invalid keycode as it's not relevant
155 m_starter.immediate_release = true;
156 m_starter.ids.clear();
158 load_button_texture(&m_starter, starter_img, current_button,
159 m_texturesource, m_driver);
162 m_timeout_value = timeout;
164 m_initialized = true;
167 AutoHideButtonBar::~AutoHideButtonBar()
169 if (m_starter.guibutton) {
170 m_starter.guibutton->setVisible(false);
171 m_starter.guibutton->drop();
175 void AutoHideButtonBar::addButton(touch_gui_button_id button_id,
176 const wchar_t* caption, const char* btn_image)
179 if (!m_initialized) {
180 errorstream << "AutoHideButtonBar::addButton not yet initialized!"
186 if ((m_dir == AHBB_Dir_Top_Bottom) || (m_dir == AHBB_Dir_Bottom_Top)) {
187 button_size = m_lower_right.X - m_upper_left.X;
189 button_size = m_lower_right.Y - m_upper_left.Y;
192 irr::core::rect<int> current_button;
194 if ((m_dir == AHBB_Dir_Right_Left) || (m_dir == AHBB_Dir_Left_Right)) {
199 if (m_dir == AHBB_Dir_Left_Right) {
200 x_start = m_lower_right.X + (button_size * 1.25 * m_buttons.size())
201 + (button_size * 0.25);
202 x_end = x_start + button_size;
204 x_end = m_upper_left.X - (button_size * 1.25 * m_buttons.size())
205 - (button_size * 0.25);
206 x_start = x_end - button_size;
209 current_button = rect<s32>(x_start, m_upper_left.Y, x_end,
215 if (m_dir == AHBB_Dir_Top_Bottom) {
216 y_start = m_lower_right.X + (button_size * 1.25 * m_buttons.size())
217 + (button_size * 0.25);
218 y_end = y_start + button_size;
220 y_end = m_upper_left.X - (button_size * 1.25 * m_buttons.size())
221 - (button_size * 0.25);
222 y_start = y_end - button_size;
225 current_button = rect<s32>(m_upper_left.X, y_start, m_lower_right.Y,
229 button_info* btn = new button_info();
230 btn->guibutton = m_guienv->addButton(current_button, 0, button_id, caption, 0);
231 btn->guibutton->grab();
232 btn->guibutton->setVisible(false);
233 btn->guibutton->setEnabled(false);
234 btn->repeatcounter = -1;
235 btn->keycode = id2keycode(button_id);
236 btn->immediate_release = true;
239 load_button_texture(btn, btn_image, current_button, m_texturesource,
242 m_buttons.push_back(btn);
245 bool AutoHideButtonBar::isButton(const SEvent &event)
247 IGUIElement* rootguielement = m_guienv->getRootGUIElement();
249 if (rootguielement == NULL) {
253 gui::IGUIElement *element = rootguielement->getElementFromPoint(
254 core::position2d<s32>(event.TouchInput.X, event.TouchInput.Y));
256 if (element == NULL) {
261 /* check for all buttons in vector */
263 std::vector<button_info*>::iterator iter = m_buttons.begin();
265 while (iter != m_buttons.end()) {
266 if ((*iter)->guibutton == element) {
268 SEvent* translated = new SEvent();
269 memset(translated, 0, sizeof(SEvent));
270 translated->EventType = irr::EET_KEY_INPUT_EVENT;
271 translated->KeyInput.Key = (*iter)->keycode;
272 translated->KeyInput.Control = false;
273 translated->KeyInput.Shift = false;
274 translated->KeyInput.Char = 0;
277 translated->KeyInput.PressedDown = true;
278 m_receiver->OnEvent(*translated);
280 /* remove this event */
281 translated->KeyInput.PressedDown = false;
282 m_receiver->OnEvent(*translated);
286 (*iter)->ids.push_back(event.TouchInput.ID);
295 /* check for starter button only */
296 if (element == m_starter.guibutton) {
297 m_starter.ids.push_back(event.TouchInput.ID);
298 m_starter.guibutton->setVisible(false);
299 m_starter.guibutton->setEnabled(false);
303 std::vector<button_info*>::iterator iter = m_buttons.begin();
305 while (iter != m_buttons.end()) {
306 (*iter)->guibutton->setVisible(true);
307 (*iter)->guibutton->setEnabled(true);
317 bool AutoHideButtonBar::isReleaseButton(int eventID)
319 std::vector<int>::iterator id = std::find(m_starter.ids.begin(),
320 m_starter.ids.end(), eventID);
322 if (id != m_starter.ids.end()) {
323 m_starter.ids.erase(id);
327 std::vector<button_info*>::iterator iter = m_buttons.begin();
329 while (iter != m_buttons.end()) {
330 std::vector<int>::iterator id = std::find((*iter)->ids.begin(),
331 (*iter)->ids.end(), eventID);
333 if (id != (*iter)->ids.end()) {
334 (*iter)->ids.erase(id);
335 // TODO handle settings button release
344 void AutoHideButtonBar::step(float dtime)
349 if (m_timeout > m_timeout_value) {
355 void AutoHideButtonBar::deactivate()
358 m_starter.guibutton->setVisible(true);
359 m_starter.guibutton->setEnabled(true);
363 std::vector<button_info*>::iterator iter = m_buttons.begin();
365 while (iter != m_buttons.end()) {
366 (*iter)->guibutton->setVisible(false);
367 (*iter)->guibutton->setEnabled(false);
372 void AutoHideButtonBar::hide()
375 m_starter.guibutton->setVisible(false);
376 m_starter.guibutton->setEnabled(false);
378 std::vector<button_info*>::iterator iter = m_buttons.begin();
380 while (iter != m_buttons.end()) {
381 (*iter)->guibutton->setVisible(false);
382 (*iter)->guibutton->setEnabled(false);
387 void AutoHideButtonBar::show()
392 std::vector<button_info*>::iterator iter = m_buttons.begin();
394 while (iter != m_buttons.end()) {
395 (*iter)->guibutton->setVisible(true);
396 (*iter)->guibutton->setEnabled(true);
400 m_starter.guibutton->setVisible(true);
401 m_starter.guibutton->setEnabled(true);
405 TouchScreenGUI::TouchScreenGUI(IrrlichtDevice *device, IEventReceiver* receiver):
407 m_guienv(device->getGUIEnvironment()),
408 m_receiver(receiver),
409 m_settingsbar(device, receiver),
410 m_rarecontrolsbar(device, receiver)
412 for (unsigned int i=0; i < after_last_element_id; i++) {
413 m_buttons[i].guibutton = 0;
414 m_buttons[i].repeatcounter = -1;
415 m_buttons[i].repeatdelay = BUTTON_REPEAT_DELAY;
418 m_screensize = m_device->getVideoDriver()->getScreenSize();
421 void TouchScreenGUI::initButton(touch_gui_button_id id, rect<s32> button_rect,
422 std::wstring caption, bool immediate_release, float repeat_delay)
425 button_info* btn = &m_buttons[id];
426 btn->guibutton = m_guienv->addButton(button_rect, 0, id, caption.c_str());
427 btn->guibutton->grab();
428 btn->repeatcounter = -1;
429 btn->repeatdelay = repeat_delay;
430 btn->keycode = id2keycode(id);
431 btn->immediate_release = immediate_release;
434 load_button_texture(btn,touchgui_button_imagenames[id],button_rect,
435 m_texturesource, m_device->getVideoDriver());
438 static int getMaxControlPadSize(float density) {
439 return 200 * density * g_settings->getFloat("hud_scaling");
442 int TouchScreenGUI::getGuiButtonSize()
444 u32 control_pad_size = MYMIN((2 * m_screensize.Y) / 3,
445 getMaxControlPadSize(porting::getDisplayDensity()));
447 return control_pad_size / 3;
450 void TouchScreenGUI::init(ISimpleTextureSource* tsrc)
454 u32 button_size = getGuiButtonSize();
456 m_texturesource = tsrc;
461 for now only 0, 1, 2, and 4 are used
464 for (int y = 0; y < 2; ++y)
465 for (int x = 0; x < 3; ++x, ++number) {
466 rect<s32> button_rect(
467 x * button_size, m_screensize.Y - button_size * (2 - y),
468 (x + 1) * button_size, m_screensize.Y - button_size * (1 - y)
470 touch_gui_button_id id = after_last_element_id;
471 std::wstring caption;
490 if (id != after_last_element_id) {
491 initButton(id, button_rect, caption, false);
495 /* init jump button */
497 rect<s32>(m_screensize.X-(1.75*button_size),
498 m_screensize.Y - (0.5*button_size),
499 m_screensize.X-(0.25*button_size),
503 /* init crunch button */
504 initButton(crunch_id,
505 rect<s32>(m_screensize.X-(3.25*button_size),
506 m_screensize.Y - (0.5*button_size),
507 m_screensize.X-(1.75*button_size),
511 m_settingsbar.init(m_texturesource, "gear_icon.png", settings_starter_id,
512 v2s32(m_screensize.X - (button_size / 2),
513 m_screensize.Y - ((SETTINGS_BAR_Y_OFFSET + 1) * button_size)
514 + (button_size * 0.5)),
515 v2s32(m_screensize.X,
516 m_screensize.Y - (SETTINGS_BAR_Y_OFFSET * button_size)
517 + (button_size * 0.5)), AHBB_Dir_Right_Left,
520 m_settingsbar.addButton(fly_id, L"fly", "fly_btn.png");
521 m_settingsbar.addButton(noclip_id, L"noclip", "noclip_btn.png");
522 m_settingsbar.addButton(fast_id, L"fast", "fast_btn.png");
523 m_settingsbar.addButton(debug_id, L"debug", "debug_btn.png");
524 m_settingsbar.addButton(camera_id, L"camera", "camera_btn.png");
525 m_settingsbar.addButton(range_id, L"rangeview", "rangeview_btn.png");
527 m_rarecontrolsbar.init(m_texturesource, "rare_controls.png",
528 rare_controls_starter_id,
531 - ((RARE_CONTROLS_BAR_Y_OFFSET + 1) * button_size)
532 + (button_size * 0.5)),
533 v2s32(button_size / 2,
534 m_screensize.Y - (RARE_CONTROLS_BAR_Y_OFFSET * button_size)
535 + (button_size * 0.5)), AHBB_Dir_Left_Right,
538 m_rarecontrolsbar.addButton(chat_id, L"Chat", "chat_btn.png");
539 m_rarecontrolsbar.addButton(inventory_id, L"inv", "inventory_btn.png");
540 m_rarecontrolsbar.addButton(drop_id, L"drop", "drop_btn.png");
544 touch_gui_button_id TouchScreenGUI::getButtonID(s32 x, s32 y)
546 IGUIElement* rootguielement = m_guienv->getRootGUIElement();
548 if (rootguielement != NULL) {
549 gui::IGUIElement *element =
550 rootguielement->getElementFromPoint(core::position2d<s32>(x,y));
553 for (unsigned int i=0; i < after_last_element_id; i++) {
554 if (element == m_buttons[i].guibutton) {
555 return (touch_gui_button_id) i;
560 return after_last_element_id;
563 touch_gui_button_id TouchScreenGUI::getButtonID(int eventID)
565 for (unsigned int i=0; i < after_last_element_id; i++) {
566 button_info* btn = &m_buttons[i];
568 std::vector<int>::iterator id =
569 std::find(btn->ids.begin(),btn->ids.end(), eventID);
571 if (id != btn->ids.end())
572 return (touch_gui_button_id) i;
575 return after_last_element_id;
578 bool TouchScreenGUI::isHUDButton(const SEvent &event)
580 // check if hud item is pressed
581 for (std::map<int,rect<s32> >::iterator iter = m_hud_rects.begin();
582 iter != m_hud_rects.end(); ++iter) {
583 if (iter->second.isPointInside(
584 v2s32(event.TouchInput.X,
587 if ( iter->first < 8) {
588 SEvent* translated = new SEvent();
589 memset(translated,0,sizeof(SEvent));
590 translated->EventType = irr::EET_KEY_INPUT_EVENT;
591 translated->KeyInput.Key = (irr::EKEY_CODE) (KEY_KEY_1 + iter->first);
592 translated->KeyInput.Control = false;
593 translated->KeyInput.Shift = false;
594 translated->KeyInput.PressedDown = true;
595 m_receiver->OnEvent(*translated);
596 m_hud_ids[event.TouchInput.ID] = translated->KeyInput.Key;
605 bool TouchScreenGUI::isReleaseHUDButton(int eventID)
607 std::map<int,irr::EKEY_CODE>::iterator iter = m_hud_ids.find(eventID);
609 if (iter != m_hud_ids.end()) {
610 SEvent* translated = new SEvent();
611 memset(translated,0,sizeof(SEvent));
612 translated->EventType = irr::EET_KEY_INPUT_EVENT;
613 translated->KeyInput.Key = iter->second;
614 translated->KeyInput.PressedDown = false;
615 translated->KeyInput.Control = false;
616 translated->KeyInput.Shift = false;
617 m_receiver->OnEvent(*translated);
618 m_hud_ids.erase(iter);
625 void TouchScreenGUI::handleButtonEvent(touch_gui_button_id button,
626 int eventID, bool action)
628 button_info* btn = &m_buttons[button];
629 SEvent* translated = new SEvent();
630 memset(translated,0,sizeof(SEvent));
631 translated->EventType = irr::EET_KEY_INPUT_EVENT;
632 translated->KeyInput.Key = btn->keycode;
633 translated->KeyInput.Control = false;
634 translated->KeyInput.Shift = false;
635 translated->KeyInput.Char = 0;
639 assert(std::find(btn->ids.begin(),btn->ids.end(), eventID) == btn->ids.end());
641 btn->ids.push_back(eventID);
643 if (btn->ids.size() > 1) return;
645 btn->repeatcounter = 0;
646 translated->KeyInput.PressedDown = true;
647 translated->KeyInput.Key = btn->keycode;
648 m_receiver->OnEvent(*translated);
651 if ((!action) || (btn->immediate_release)) {
653 std::vector<int>::iterator pos =
654 std::find(btn->ids.begin(),btn->ids.end(), eventID);
655 /* has to be in touch list */
656 assert(pos != btn->ids.end());
659 if (btn->ids.size() > 0) { return; }
661 translated->KeyInput.PressedDown = false;
662 btn->repeatcounter = -1;
663 m_receiver->OnEvent(*translated);
669 void TouchScreenGUI::handleReleaseEvent(int evt_id)
671 touch_gui_button_id button = getButtonID(evt_id);
673 /* handle button events */
674 if (button != after_last_element_id) {
675 handleButtonEvent(button, evt_id, false);
677 /* handle hud button events */
678 else if (isReleaseHUDButton(evt_id)) {
679 /* nothing to do here */
680 } else if (m_settingsbar.isReleaseButton(evt_id)) {
681 /* nothing to do here */
682 } else if (m_rarecontrolsbar.isReleaseButton(evt_id)) {
683 /* nothing to do here */
685 /* handle the point used for moving view */
686 else if (evt_id == m_move_id) {
689 /* if this pointer issued a mouse event issue symmetric release here */
690 if (m_move_sent_as_mouse_event) {
691 SEvent* translated = new SEvent;
692 memset(translated,0,sizeof(SEvent));
693 translated->EventType = EET_MOUSE_INPUT_EVENT;
694 translated->MouseInput.X = m_move_downlocation.X;
695 translated->MouseInput.Y = m_move_downlocation.Y;
696 translated->MouseInput.Shift = false;
697 translated->MouseInput.Control = false;
698 translated->MouseInput.ButtonStates = 0;
699 translated->MouseInput.Event = EMIE_LMOUSE_LEFT_UP;
700 m_receiver->OnEvent(*translated);
704 /* do double tap detection */
705 doubleTapDetection();
710 << "TouchScreenGUI::translateEvent released unknown button: "
711 << evt_id << std::endl;
714 for (std::vector<id_status>::iterator iter = m_known_ids.begin();
715 iter != m_known_ids.end(); ++iter) {
716 if (iter->id == evt_id) {
717 m_known_ids.erase(iter);
723 void TouchScreenGUI::translateEvent(const SEvent &event)
726 infostream << "TouchScreenGUI::translateEvent got event but not visible?!" << std::endl;
730 if (event.EventType != EET_TOUCH_INPUT_EVENT) {
734 if (event.TouchInput.Event == ETIE_PRESSED_DOWN) {
736 /* add to own copy of eventlist ...
737 * android would provide this information but irrlicht guys don't
738 * wanna design a efficient interface
741 toadd.id = event.TouchInput.ID;
742 toadd.X = event.TouchInput.X;
743 toadd.Y = event.TouchInput.Y;
744 m_known_ids.push_back(toadd);
746 int eventID = event.TouchInput.ID;
748 touch_gui_button_id button =
749 getButtonID(event.TouchInput.X, event.TouchInput.Y);
751 /* handle button events */
752 if (button != after_last_element_id) {
753 handleButtonEvent(button, eventID, true);
754 m_settingsbar.deactivate();
755 m_rarecontrolsbar.deactivate();
756 } else if (isHUDButton(event)) {
757 m_settingsbar.deactivate();
758 m_rarecontrolsbar.deactivate();
759 /* already handled in isHUDButton() */
760 } else if (m_settingsbar.isButton(event)) {
761 m_rarecontrolsbar.deactivate();
762 /* already handled in isSettingsBarButton() */
763 } else if (m_rarecontrolsbar.isButton(event)) {
764 m_settingsbar.deactivate();
765 /* already handled in isSettingsBarButton() */
767 /* handle non button events */
769 m_settingsbar.deactivate();
770 m_rarecontrolsbar.deactivate();
771 /* if we don't already have a moving point make this the moving one */
772 if (m_move_id == -1) {
773 m_move_id = event.TouchInput.ID;
774 m_move_has_really_moved = false;
775 m_move_downtime = porting::getTimeMs();
776 m_move_downlocation = v2s32(event.TouchInput.X, event.TouchInput.Y);
777 m_move_sent_as_mouse_event = false;
781 m_pointerpos[event.TouchInput.ID] = v2s32(event.TouchInput.X, event.TouchInput.Y);
783 else if (event.TouchInput.Event == ETIE_LEFT_UP) {
784 verbosestream << "Up event for pointerid: " << event.TouchInput.ID << std::endl;
785 handleReleaseEvent(event.TouchInput.ID);
788 assert(event.TouchInput.Event == ETIE_MOVED);
789 int move_idx = event.TouchInput.ID;
791 if (m_pointerpos[event.TouchInput.ID] ==
792 v2s32(event.TouchInput.X, event.TouchInput.Y)) {
796 if (m_move_id != -1) {
797 if ((event.TouchInput.ID == m_move_id) &&
798 (!m_move_sent_as_mouse_event)) {
800 double distance = sqrt(
801 (m_pointerpos[event.TouchInput.ID].X - event.TouchInput.X) *
802 (m_pointerpos[event.TouchInput.ID].X - event.TouchInput.X) +
803 (m_pointerpos[event.TouchInput.ID].Y - event.TouchInput.Y) *
804 (m_pointerpos[event.TouchInput.ID].Y - event.TouchInput.Y));
806 if ((distance > g_settings->getU16("touchscreen_threshold")) ||
807 (m_move_has_really_moved)) {
808 m_move_has_really_moved = true;
809 s32 X = event.TouchInput.X;
810 s32 Y = event.TouchInput.Y;
812 // update camera_yaw and camera_pitch
813 s32 dx = X - m_pointerpos[event.TouchInput.ID].X;
814 s32 dy = Y - m_pointerpos[event.TouchInput.ID].Y;
816 /* adapt to similar behaviour as pc screen */
817 double d = g_settings->getFloat("mouse_sensitivity") *4;
818 double old_yaw = m_camera_yaw_change;
819 double old_pitch = m_camera_pitch;
821 m_camera_yaw_change -= dx * d;
822 m_camera_pitch = MYMIN(MYMAX(m_camera_pitch + (dy * d), -180), 180);
825 m_shootline = m_device
827 ->getSceneCollisionManager()
828 ->getRayFromScreenCoordinates(v2s32(X, Y));
829 m_pointerpos[event.TouchInput.ID] = v2s32(X, Y);
832 else if ((event.TouchInput.ID == m_move_id) &&
833 (m_move_sent_as_mouse_event)) {
834 m_shootline = m_device
836 ->getSceneCollisionManager()
837 ->getRayFromScreenCoordinates(
838 v2s32(event.TouchInput.X,event.TouchInput.Y));
841 handleChangedButton(event);
846 void TouchScreenGUI::handleChangedButton(const SEvent &event)
848 for (unsigned int i = 0; i < after_last_element_id; i++) {
850 if (m_buttons[i].ids.empty()) {
853 for (std::vector<int>::iterator iter = m_buttons[i].ids.begin();
854 iter != m_buttons[i].ids.end(); ++iter) {
856 if (event.TouchInput.ID == *iter) {
858 int current_button_id =
859 getButtonID(event.TouchInput.X, event.TouchInput.Y);
861 if (current_button_id == i) {
865 /* remove old button */
866 handleButtonEvent((touch_gui_button_id) i,*iter,false);
868 if (current_button_id == after_last_element_id) {
871 handleButtonEvent((touch_gui_button_id) current_button_id,*iter,true);
878 int current_button_id = getButtonID(event.TouchInput.X, event.TouchInput.Y);
880 if (current_button_id == after_last_element_id) {
884 button_info* btn = &m_buttons[current_button_id];
885 if (std::find(btn->ids.begin(),btn->ids.end(), event.TouchInput.ID)
888 handleButtonEvent((touch_gui_button_id) current_button_id,
889 event.TouchInput.ID, true);
894 bool TouchScreenGUI::doubleTapDetection()
896 m_key_events[0].down_time = m_key_events[1].down_time;
897 m_key_events[0].x = m_key_events[1].x;
898 m_key_events[0].y = m_key_events[1].y;
899 m_key_events[1].down_time = m_move_downtime;
900 m_key_events[1].x = m_move_downlocation.X;
901 m_key_events[1].y = m_move_downlocation.Y;
903 u64 delta = porting::getDeltaMs(m_key_events[0].down_time, porting::getTimeMs());
907 double distance = sqrt(
908 (m_key_events[0].x - m_key_events[1].x) * (m_key_events[0].x - m_key_events[1].x) +
909 (m_key_events[0].y - m_key_events[1].y) * (m_key_events[0].y - m_key_events[1].y));
912 if (distance > (20 + g_settings->getU16("touchscreen_threshold")))
915 SEvent* translated = new SEvent();
916 memset(translated, 0, sizeof(SEvent));
917 translated->EventType = EET_MOUSE_INPUT_EVENT;
918 translated->MouseInput.X = m_key_events[0].x;
919 translated->MouseInput.Y = m_key_events[0].y;
920 translated->MouseInput.Shift = false;
921 translated->MouseInput.Control = false;
922 translated->MouseInput.ButtonStates = EMBSM_RIGHT;
925 m_shootline = m_device
927 ->getSceneCollisionManager()
928 ->getRayFromScreenCoordinates(v2s32(m_key_events[0].x, m_key_events[0].y));
930 translated->MouseInput.Event = EMIE_RMOUSE_PRESSED_DOWN;
931 verbosestream << "TouchScreenGUI::translateEvent right click press" << std::endl;
932 m_receiver->OnEvent(*translated);
934 translated->MouseInput.ButtonStates = 0;
935 translated->MouseInput.Event = EMIE_RMOUSE_LEFT_UP;
936 verbosestream << "TouchScreenGUI::translateEvent right click release" << std::endl;
937 m_receiver->OnEvent(*translated);
943 TouchScreenGUI::~TouchScreenGUI()
945 for (unsigned int i = 0; i < after_last_element_id; i++) {
946 button_info* btn = &m_buttons[i];
947 if (btn->guibutton != 0) {
948 btn->guibutton->drop();
949 btn->guibutton = NULL;
954 void TouchScreenGUI::step(float dtime)
956 /* simulate keyboard repeats */
957 for (unsigned int i = 0; i < after_last_element_id; i++) {
958 button_info* btn = &m_buttons[i];
960 if (btn->ids.size() > 0) {
961 btn->repeatcounter += dtime;
963 /* in case we're moving around digging does not happen */
965 m_move_has_really_moved = true;
967 if (btn->repeatcounter < btn->repeatdelay) continue;
969 btn->repeatcounter = 0;
971 memset(&translated, 0, sizeof(SEvent));
972 translated.EventType = irr::EET_KEY_INPUT_EVENT;
973 translated.KeyInput.Key = btn->keycode;
974 translated.KeyInput.PressedDown = false;
975 m_receiver->OnEvent(translated);
977 translated.KeyInput.PressedDown = true;
978 m_receiver->OnEvent(translated);
982 /* if a new placed pointer isn't moved for some time start digging */
983 if ((m_move_id != -1) &&
984 (!m_move_has_really_moved) &&
985 (!m_move_sent_as_mouse_event)) {
987 u64 delta = porting::getDeltaMs(m_move_downtime, porting::getTimeMs());
989 if (delta > MIN_DIG_TIME_MS) {
990 m_shootline = m_device
992 ->getSceneCollisionManager()
993 ->getRayFromScreenCoordinates(
994 v2s32(m_move_downlocation.X,m_move_downlocation.Y));
997 memset(&translated, 0, sizeof(SEvent));
998 translated.EventType = EET_MOUSE_INPUT_EVENT;
999 translated.MouseInput.X = m_move_downlocation.X;
1000 translated.MouseInput.Y = m_move_downlocation.Y;
1001 translated.MouseInput.Shift = false;
1002 translated.MouseInput.Control = false;
1003 translated.MouseInput.ButtonStates = EMBSM_LEFT;
1004 translated.MouseInput.Event = EMIE_LMOUSE_PRESSED_DOWN;
1005 verbosestream << "TouchScreenGUI::step left click press" << std::endl;
1006 m_receiver->OnEvent(translated);
1007 m_move_sent_as_mouse_event = true;
1011 m_settingsbar.step(dtime);
1012 m_rarecontrolsbar.step(dtime);
1015 void TouchScreenGUI::resetHud()
1017 m_hud_rects.clear();
1020 void TouchScreenGUI::registerHudItem(int index, const rect<s32> &rect)
1022 m_hud_rects[index] = rect;
1025 void TouchScreenGUI::Toggle(bool visible)
1027 m_visible = visible;
1028 for (unsigned int i = 0; i < after_last_element_id; i++) {
1029 button_info* btn = &m_buttons[i];
1030 if (btn->guibutton != 0) {
1031 btn->guibutton->setVisible(visible);
1035 /* clear all active buttons */
1037 while (m_known_ids.size() > 0) {
1038 handleReleaseEvent(m_known_ids.begin()->id);
1041 m_settingsbar.hide();
1042 m_rarecontrolsbar.hide();
1044 m_settingsbar.show();
1045 m_rarecontrolsbar.show();
1049 void TouchScreenGUI::hide()
1057 void TouchScreenGUI::show()