src/gui/touchscreengui.cpp

   1 /*
   2 Copyright (C) 2014 sapier
   3 Copyright (C) 2018 srifqi, Muhammad Rifqi Priyo Susanto
   4                 <muhammadrifqipriyosusanto@gmail.com>
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU Lesser General Public License as published by
   8 the Free Software Foundation; either version 2.1 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU Lesser General Public License for more details.
  15
  16 You should have received a copy of the GNU Lesser General Public License along
  17 with this program; if not, write to the Free Software Foundation, Inc.,
  18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 */
  20
  21 #include "touchscreengui.h"
  22 #include "irrlichttypes.h"
  23 #include "irr_v2d.h"
  24 #include "log.h"
  25 #include "client/keycode.h"
  26 #include "settings.h"
  27 #include "gettime.h"
  28 #include "util/numeric.h"
  29 #include "porting.h"
  30 #include "client/guiscalingfilter.h"
  31
  32 #include <iostream>
  33 #include <algorithm>
  34
  35 #include <ISceneCollisionManager.h>
  36
  37 // Very slow button repeat frequency (in seconds)
  38 #define SLOW_BUTTON_REPEAT      (1.0f)
  39
  40 using namespace irr::core;
  41
  42 const char **touchgui_button_imagenames = (const char *[]) {
  43         "jump_btn.png",
  44         "down.png",
  45         "zoom.png",
  46         "aux_btn.png"
  47 };
  48
  49 const char **touchgui_joystick_imagenames = (const char *[]) {
  50         "joystick_off.png",
  51         "joystick_bg.png",
  52         "joystick_center.png"
  53 };
  54
  55 static irr::EKEY_CODE id2keycode(touch_gui_button_id id)
  56 {
  57         std::string key = "";
  58         switch (id) {
  59                 case forward_id:
  60                         key = "forward";
  61                         break;
  62                 case left_id:
  63                         key = "left";
  64                         break;
  65                 case right_id:
  66                         key = "right";
  67                         break;
  68                 case backward_id:
  69                         key = "backward";
  70                         break;
  71                 case inventory_id:
  72                         key = "inventory";
  73                         break;
  74                 case drop_id:
  75                         key = "drop";
  76                         break;
  77                 case jump_id:
  78                         key = "jump";
  79                         break;
  80                 case crunch_id:
  81                         key = "sneak";
  82                         break;
  83                 case zoom_id:
  84                         key = "zoom";
  85                         break;
  86                 case special1_id:
  87                         key = "special1";
  88                         break;
  89                 case fly_id:
  90                         key = "freemove";
  91                         break;
  92                 case noclip_id:
  93                         key = "noclip";
  94                         break;
  95                 case fast_id:
  96                         key = "fastmove";
  97                         break;
  98                 case debug_id:
  99                         key = "toggle_debug";
 100                         break;
 101                 case toggle_chat_id:
 102                         key = "toggle_chat";
 103                         break;
 104                 case minimap_id:
 105                         key = "minimap";
 106                         break;
 107                 case chat_id:
 108                         key = "chat";
 109                         break;
 110                 case camera_id:
 111                         key = "camera_mode";
 112                         break;
 113                 case range_id:
 114                         key = "rangeselect";
 115                         break;
 116         }
 117         assert(key != "");
 118         return keyname_to_keycode(g_settings->get("keymap_" + key).c_str());
 119 }
 120
 121 TouchScreenGUI *g_touchscreengui;
 122
 123 static void load_button_texture(button_info *btn, const char *path,
 124                 rect<s32> button_rect, ISimpleTextureSource *tsrc, video::IVideoDriver *driver)
 125 {
 126         unsigned int tid;
 127         video::ITexture *texture = guiScalingImageButton(driver,
 128                         tsrc->getTexture(path, &tid), button_rect.getWidth(),
 129                         button_rect.getHeight());
 130         if (texture) {
 131                 btn->guibutton->setUseAlphaChannel(true);
 132                 if (g_settings->getBool("gui_scaling_filter")) {
 133                         rect<s32> txr_rect = rect<s32>(0, 0, button_rect.getWidth(), button_rect.getHeight());
 134                         btn->guibutton->setImage(texture, txr_rect);
 135                         btn->guibutton->setPressedImage(texture, txr_rect);
 136                         btn->guibutton->setScaleImage(false);
 137                 } else {
 138                         btn->guibutton->setImage(texture);
 139                         btn->guibutton->setPressedImage(texture);
 140                         btn->guibutton->setScaleImage(true);
 141                 }
 142                 btn->guibutton->setDrawBorder(false);
 143                 btn->guibutton->setText(L"");
 144                 }
 145 }
 146
 147 AutoHideButtonBar::AutoHideButtonBar(IrrlichtDevice *device,
 148                 IEventReceiver *receiver) :
 149                         m_driver(device->getVideoDriver()),
 150                         m_guienv(device->getGUIEnvironment()),
 151                         m_receiver(receiver)
 152 {
 153 }
 154
 155 void AutoHideButtonBar::init(ISimpleTextureSource *tsrc,
 156                 const char *starter_img, int button_id, v2s32 UpperLeft,
 157                 v2s32 LowerRight, autohide_button_bar_dir dir, float timeout)
 158 {
 159         m_texturesource = tsrc;
 160
 161         m_upper_left = UpperLeft;
 162         m_lower_right = LowerRight;
 163
 164         // init settings bar
 165
 166         irr::core::rect<int> current_button = rect<s32>(UpperLeft.X, UpperLeft.Y,
 167                         LowerRight.X, LowerRight.Y);
 168
 169         m_starter.guibutton         = m_guienv->addButton(current_button, 0, button_id, L"", 0);
 170         m_starter.guibutton->grab();
 171         m_starter.repeatcounter     = -1;
 172         m_starter.keycode           = KEY_OEM_8; // use invalid keycode as it's not relevant
 173         m_starter.immediate_release = true;
 174         m_starter.ids.clear();
 175
 176         load_button_texture(&m_starter, starter_img, current_button,
 177                         m_texturesource, m_driver);
 178
 179         m_dir = dir;
 180         m_timeout_value = timeout;
 181
 182         m_initialized = true;
 183 }
 184
 185 AutoHideButtonBar::~AutoHideButtonBar()
 186 {
 187         if (m_starter.guibutton) {
 188                 m_starter.guibutton->setVisible(false);
 189                 m_starter.guibutton->drop();
 190         }
 191 }
 192
 193 void AutoHideButtonBar::addButton(touch_gui_button_id button_id,
 194                 const wchar_t *caption, const char *btn_image)
 195 {
 196
 197         if (!m_initialized) {
 198                 errorstream << "AutoHideButtonBar::addButton not yet initialized!"
 199                                 << std::endl;
 200                 return;
 201         }
 202         int button_size = 0;
 203
 204         if ((m_dir == AHBB_Dir_Top_Bottom) || (m_dir == AHBB_Dir_Bottom_Top)) {
 205                 button_size = m_lower_right.X - m_upper_left.X;
 206         } else {
 207                 button_size = m_lower_right.Y - m_upper_left.Y;
 208         }
 209
 210         irr::core::rect<int> current_button;
 211
 212         if ((m_dir == AHBB_Dir_Right_Left) || (m_dir == AHBB_Dir_Left_Right)) {
 213
 214                 int x_start = 0;
 215                 int x_end = 0;
 216
 217                 if (m_dir == AHBB_Dir_Left_Right) {
 218                         x_start = m_lower_right.X + (button_size * 1.25 * m_buttons.size())
 219                                         + (button_size * 0.25);
 220                         x_end = x_start + button_size;
 221                 } else {
 222                         x_end = m_upper_left.X - (button_size * 1.25 * m_buttons.size())
 223                                         - (button_size * 0.25);
 224                         x_start = x_end - button_size;
 225                 }
 226
 227                 current_button = rect<s32>(x_start, m_upper_left.Y, x_end,
 228                                 m_lower_right.Y);
 229         } else {
 230                 int y_start = 0;
 231                 int y_end = 0;
 232
 233                 if (m_dir == AHBB_Dir_Top_Bottom) {
 234                         y_start = m_lower_right.X + (button_size * 1.25 * m_buttons.size())
 235                                         + (button_size * 0.25);
 236                         y_end = y_start + button_size;
 237                 } else {
 238                         y_end = m_upper_left.X - (button_size * 1.25 * m_buttons.size())
 239                                         - (button_size * 0.25);
 240                         y_start = y_end - button_size;
 241                 }
 242
 243                 current_button = rect<s32>(m_upper_left.X, y_start, m_lower_right.Y,
 244                                 y_end);
 245         }
 246
 247         button_info *btn       = new button_info();
 248         btn->guibutton         = m_guienv->addButton(current_button, 0, button_id, caption, 0);
 249         btn->guibutton->grab();
 250         btn->guibutton->setVisible(false);
 251         btn->guibutton->setEnabled(false);
 252         btn->repeatcounter     = -1;
 253         btn->keycode           = id2keycode(button_id);
 254         btn->immediate_release = true;
 255         btn->ids.clear();
 256
 257         load_button_texture(btn, btn_image, current_button, m_texturesource,
 258                         m_driver);
 259
 260         m_buttons.push_back(btn);
 261 }
 262
 263 void AutoHideButtonBar::addToggleButton(touch_gui_button_id button_id,
 264                 const wchar_t *caption, const char *btn_image_1,
 265                 const char *btn_image_2)
 266 {
 267         addButton(button_id, caption, btn_image_1);
 268         button_info *btn = m_buttons.back();
 269         btn->togglable = 1;
 270         btn->textures.push_back(btn_image_1);
 271         btn->textures.push_back(btn_image_2);
 272 }
 273
 274 bool AutoHideButtonBar::isButton(const SEvent &event)
 275 {
 276         IGUIElement *rootguielement = m_guienv->getRootGUIElement();
 277
 278         if (rootguielement == NULL) {
 279                 return false;
 280         }
 281
 282         gui::IGUIElement *element = rootguielement->getElementFromPoint(
 283                         core::position2d<s32>(event.TouchInput.X, event.TouchInput.Y));
 284
 285         if (element == NULL) {
 286                 return false;
 287         }
 288
 289         if (m_active) {
 290                 // check for all buttons in vector
 291
 292                 std::vector<button_info *>::iterator iter = m_buttons.begin();
 293
 294                 while (iter != m_buttons.end()) {
 295                         if ((*iter)->guibutton == element) {
 296
 297                                 SEvent *translated = new SEvent();
 298                                 memset(translated, 0, sizeof(SEvent));
 299                                 translated->EventType            = irr::EET_KEY_INPUT_EVENT;
 300                                 translated->KeyInput.Key         = (*iter)->keycode;
 301                                 translated->KeyInput.Control     = false;
 302                                 translated->KeyInput.Shift       = false;
 303                                 translated->KeyInput.Char        = 0;
 304
 305                                 // add this event
 306                                 translated->KeyInput.PressedDown = true;
 307                                 m_receiver->OnEvent(*translated);
 308
 309                                 // remove this event
 310                                 translated->KeyInput.PressedDown = false;
 311                                 m_receiver->OnEvent(*translated);
 312
 313                                 delete translated;
 314
 315                                 (*iter)->ids.push_back(event.TouchInput.ID);
 316
 317                                 m_timeout = 0;
 318
 319                                 if ((*iter)->togglable == 1) {
 320                                         (*iter)->togglable = 2;
 321                                         load_button_texture(*iter, (*iter)->textures[1],
 322                                                         (*iter)->guibutton->getRelativePosition(),
 323                                                         m_texturesource, m_driver);
 324                                 } else if ((*iter)->togglable == 2) {
 325                                         (*iter)->togglable = 1;
 326                                         load_button_texture(*iter, (*iter)->textures[0],
 327                                                         (*iter)->guibutton->getRelativePosition(),
 328                                                         m_texturesource, m_driver);
 329                                 }
 330
 331                                 return true;
 332                         }
 333                         ++iter;
 334                 }
 335         } else {
 336                 // check for starter button only
 337                 if (element == m_starter.guibutton) {
 338                         m_starter.ids.push_back(event.TouchInput.ID);
 339                         m_starter.guibutton->setVisible(false);
 340                         m_starter.guibutton->setEnabled(false);
 341                         m_active = true;
 342                         m_timeout = 0;
 343
 344                         std::vector<button_info*>::iterator iter = m_buttons.begin();
 345
 346                         while (iter != m_buttons.end()) {
 347                                 (*iter)->guibutton->setVisible(true);
 348                                 (*iter)->guibutton->setEnabled(true);
 349                                 ++iter;
 350                         }
 351
 352                         return true;
 353                 }
 354         }
 355         return false;
 356 }
 357
 358 bool AutoHideButtonBar::isReleaseButton(int eventID)
 359 {
 360         std::vector<int>::iterator id = std::find(m_starter.ids.begin(),
 361                         m_starter.ids.end(), eventID);
 362
 363         if (id != m_starter.ids.end()) {
 364                 m_starter.ids.erase(id);
 365                 return true;
 366         }
 367
 368         std::vector<button_info *>::iterator iter = m_buttons.begin();
 369
 370         while (iter != m_buttons.end()) {
 371                 std::vector<int>::iterator id = std::find((*iter)->ids.begin(),
 372                                 (*iter)->ids.end(), eventID);
 373
 374                 if (id != (*iter)->ids.end()) {
 375                         (*iter)->ids.erase(id);
 376                         // TODO handle settings button release
 377                         return true;
 378                 }
 379                 ++iter;
 380         }
 381
 382         return false;
 383 }
 384
 385 void AutoHideButtonBar::step(float dtime)
 386 {
 387         if (m_active) {
 388                 m_timeout += dtime;
 389
 390                 if (m_timeout > m_timeout_value) {
 391                         deactivate();
 392                 }
 393         }
 394 }
 395
 396 void AutoHideButtonBar::deactivate()
 397 {
 398         if (m_visible) {
 399                 m_starter.guibutton->setVisible(true);
 400                 m_starter.guibutton->setEnabled(true);
 401         }
 402         m_active = false;
 403
 404         std::vector<button_info *>::iterator iter = m_buttons.begin();
 405
 406         while (iter != m_buttons.end()) {
 407                         (*iter)->guibutton->setVisible(false);
 408                         (*iter)->guibutton->setEnabled(false);
 409                 ++iter;
 410         }
 411 }
 412
 413 void AutoHideButtonBar::hide()
 414 {
 415         m_visible = false;
 416         m_starter.guibutton->setVisible(false);
 417         m_starter.guibutton->setEnabled(false);
 418
 419         std::vector<button_info *>::iterator iter = m_buttons.begin();
 420
 421         while (iter != m_buttons.end()) {
 422                 (*iter)->guibutton->setVisible(false);
 423                 (*iter)->guibutton->setEnabled(false);
 424                 ++iter;
 425         }
 426 }
 427
 428 void AutoHideButtonBar::show()
 429 {
 430         m_visible = true;
 431
 432         if (m_active) {
 433                 std::vector<button_info *>::iterator iter = m_buttons.begin();
 434
 435                 while (iter != m_buttons.end()) {
 436                         (*iter)->guibutton->setVisible(true);
 437                         (*iter)->guibutton->setEnabled(true);
 438                         ++iter;
 439                 }
 440         } else {
 441                 m_starter.guibutton->setVisible(true);
 442                 m_starter.guibutton->setEnabled(true);
 443         }
 444 }
 445
 446 TouchScreenGUI::TouchScreenGUI(IrrlichtDevice *device, IEventReceiver *receiver):
 447         m_device(device),
 448         m_guienv(device->getGUIEnvironment()),
 449         m_receiver(receiver),
 450         m_settingsbar(device, receiver),
 451         m_rarecontrolsbar(device, receiver)
 452 {
 453         for (unsigned int i=0; i < after_last_element_id; i++) {
 454                 m_buttons[i].guibutton     =  0;
 455                 m_buttons[i].repeatcounter = -1;
 456                 m_buttons[i].repeatdelay   = BUTTON_REPEAT_DELAY;
 457         }
 458
 459         m_touchscreen_threshold = g_settings->getU16("touchscreen_threshold");
 460         m_fixed_joystick = g_settings->getBool("fixed_virtual_joystick");
 461         m_joystick_triggers_special1 = g_settings->getBool("virtual_joystick_triggers_aux");
 462         m_screensize = m_device->getVideoDriver()->getScreenSize();
 463 }
 464
 465 void TouchScreenGUI::initButton(touch_gui_button_id id, rect<s32> button_rect,
 466                 std::wstring caption, bool immediate_release, float repeat_delay)
 467 {
 468
 469         button_info *btn       = &m_buttons[id];
 470         btn->guibutton         = m_guienv->addButton(button_rect, 0, id, caption.c_str());
 471         btn->guibutton->grab();
 472         btn->repeatcounter     = -1;
 473         btn->repeatdelay       = repeat_delay;
 474         btn->keycode           = id2keycode(id);
 475         btn->immediate_release = immediate_release;
 476         btn->ids.clear();
 477
 478         load_button_texture(btn, touchgui_button_imagenames[id], button_rect,
 479                         m_texturesource, m_device->getVideoDriver());
 480 }
 481
 482 button_info *TouchScreenGUI::initJoystickButton(touch_gui_button_id id, rect<s32> button_rect,
 483                 int texture_id, bool visible)
 484 {
 485         button_info *btn = new button_info();
 486         btn->guibutton   = m_guienv->addButton(button_rect, 0, id, L"O");
 487         btn->guibutton->setVisible(visible);
 488         btn->guibutton->grab();
 489         btn->ids.clear();
 490
 491         load_button_texture(btn, touchgui_joystick_imagenames[texture_id], button_rect,
 492                         m_texturesource, m_device->getVideoDriver());
 493
 494         return btn;
 495 }
 496
 497 static int getMaxControlPadSize(float density) {
 498         return 200 * density * g_settings->getFloat("hud_scaling");
 499 }
 500
 501 int TouchScreenGUI::getGuiButtonSize()
 502 {
 503         u32 control_pad_size = MYMIN((2 * m_screensize.Y) / 3,
 504                         getMaxControlPadSize(porting::getDisplayDensity()));
 505
 506         return control_pad_size / 3;
 507 }
 508
 509 void TouchScreenGUI::init(ISimpleTextureSource *tsrc)
 510 {
 511         assert(tsrc);
 512
 513         u32 button_size = getGuiButtonSize();
 514         m_visible       = true;
 515         m_texturesource = tsrc;
 516
 517         /* Init joystick display "button"
 518          * Joystick is placed on bottom left of screen.
 519          */
 520         if (m_fixed_joystick) {
 521                 m_joystick_btn_off = initJoystickButton(joystick_off_id,
 522                                 rect<s32>(button_size,
 523                                                 m_screensize.Y - button_size * 4,
 524                                                 button_size * 4,
 525                                                 m_screensize.Y - button_size), 0);
 526         } else {
 527                 m_joystick_btn_off = initJoystickButton(joystick_off_id,
 528                                 rect<s32>(button_size,
 529                                                 m_screensize.Y - button_size * 3,
 530                                                 button_size * 3,
 531                                                 m_screensize.Y - button_size), 0);
 532         }
 533
 534         m_joystick_btn_bg = initJoystickButton(joystick_bg_id,
 535                         rect<s32>(button_size,
 536                                         m_screensize.Y - button_size * 4,
 537                                         button_size * 4,
 538                                         m_screensize.Y - button_size),
 539                         1, false);
 540
 541         m_joystick_btn_center = initJoystickButton(joystick_center_id,
 542                         rect<s32>(0, 0, button_size, button_size), 2, false);
 543
 544         // init jump button
 545         initButton(jump_id,
 546                         rect<s32>(m_screensize.X - (1.75 * button_size),
 547                                         m_screensize.Y - button_size,
 548                                         m_screensize.X - (0.25 * button_size),
 549                                         m_screensize.Y),
 550                         L"x", false);
 551
 552         // init crunch button
 553         initButton(crunch_id,
 554                         rect<s32>(m_screensize.X - (3.25 * button_size),
 555                                         m_screensize.Y - button_size,
 556                                         m_screensize.X - (1.75 * button_size),
 557                                         m_screensize.Y),
 558                         L"H", false);
 559
 560         // init zoom button
 561         initButton(zoom_id,
 562                         rect<s32>(m_screensize.X - (1.25 * button_size),
 563                                         m_screensize.Y - (4 * button_size),
 564                                         m_screensize.X - (0.25 * button_size),
 565                                         m_screensize.Y - (3 * button_size)),
 566                         L"z", false);
 567
 568         // init special1/aux button
 569         if (!m_joystick_triggers_special1)
 570                 initButton(special1_id,
 571                                 rect<s32>(m_screensize.X - (1.25 * button_size),
 572                                                 m_screensize.Y - (2.5 * button_size),
 573                                                 m_screensize.X - (0.25 * button_size),
 574                                                 m_screensize.Y - (1.5 * button_size)),
 575                                 L"spc1", false);
 576
 577         m_settingsbar.init(m_texturesource, "gear_icon.png", settings_starter_id,
 578                 v2s32(m_screensize.X - (1.25 * button_size),
 579                         m_screensize.Y - ((SETTINGS_BAR_Y_OFFSET + 1.0) * button_size)
 580                                 + (0.5 * button_size)),
 581                 v2s32(m_screensize.X - (0.25 * button_size),
 582                         m_screensize.Y - (SETTINGS_BAR_Y_OFFSET * button_size)
 583                                 + (0.5 * button_size)),
 584                 AHBB_Dir_Right_Left, 3.0);
 585
 586         m_settingsbar.addButton(fly_id,     L"fly",       "fly_btn.png");
 587         m_settingsbar.addButton(noclip_id,  L"noclip",    "noclip_btn.png");
 588         m_settingsbar.addButton(fast_id,    L"fast",      "fast_btn.png");
 589         m_settingsbar.addButton(debug_id,   L"debug",     "debug_btn.png");
 590         m_settingsbar.addButton(camera_id,  L"camera",    "camera_btn.png");
 591         m_settingsbar.addButton(range_id,   L"rangeview", "rangeview_btn.png");
 592         m_settingsbar.addButton(minimap_id, L"minimap",   "minimap_btn.png");
 593
 594         // Chat is shown by default, so chat_hide_btn.png is shown first.
 595         m_settingsbar.addToggleButton(toggle_chat_id, L"togglechat",
 596                         "chat_hide_btn.png", "chat_show_btn.png");
 597
 598         m_rarecontrolsbar.init(m_texturesource, "rare_controls.png",
 599                 rare_controls_starter_id,
 600                 v2s32(0.25 * button_size,
 601                         m_screensize.Y - ((RARE_CONTROLS_BAR_Y_OFFSET + 1.0) * button_size)
 602                                 + (0.5 * button_size)),
 603                 v2s32(0.75 * button_size,
 604                         m_screensize.Y - (RARE_CONTROLS_BAR_Y_OFFSET * button_size)
 605                                 + (0.5 * button_size)),
 606                 AHBB_Dir_Left_Right, 2.0);
 607
 608         m_rarecontrolsbar.addButton(chat_id,      L"Chat", "chat_btn.png");
 609         m_rarecontrolsbar.addButton(inventory_id, L"inv",  "inventory_btn.png");
 610         m_rarecontrolsbar.addButton(drop_id,      L"drop", "drop_btn.png");
 611
 612 }
 613
 614 touch_gui_button_id TouchScreenGUI::getButtonID(s32 x, s32 y)
 615 {
 616         IGUIElement *rootguielement = m_guienv->getRootGUIElement();
 617
 618         if (rootguielement != NULL) {
 619                 gui::IGUIElement *element =
 620                                 rootguielement->getElementFromPoint(core::position2d<s32>(x, y));
 621
 622                 if (element) {
 623                         for (unsigned int i=0; i < after_last_element_id; i++) {
 624                                 if (element == m_buttons[i].guibutton) {
 625                                         return (touch_gui_button_id) i;
 626                                 }
 627                         }
 628                 }
 629         }
 630         return after_last_element_id;
 631 }
 632
 633 touch_gui_button_id TouchScreenGUI::getButtonID(int eventID)
 634 {
 635         for (unsigned int i=0; i < after_last_element_id; i++) {
 636                 button_info *btn = &m_buttons[i];
 637
 638                 std::vector<int>::iterator id =
 639                                 std::find(btn->ids.begin(), btn->ids.end(), eventID);
 640
 641                 if (id != btn->ids.end())
 642                         return (touch_gui_button_id) i;
 643         }
 644
 645         return after_last_element_id;
 646 }
 647
 648 bool TouchScreenGUI::isHUDButton(const SEvent &event)
 649 {
 650         // check if hud item is pressed
 651         for (std::map<int, rect<s32> >::iterator iter = m_hud_rects.begin();
 652                         iter != m_hud_rects.end(); ++iter) {
 653                 if (iter->second.isPointInside(
 654                                 v2s32(event.TouchInput.X,
 655                                                 event.TouchInput.Y)
 656                         )) {
 657                         if ( iter->first < 8) {
 658                                 SEvent *translated = new SEvent();
 659                                 memset(translated, 0, sizeof(SEvent));
 660                                 translated->EventType = irr::EET_KEY_INPUT_EVENT;
 661                                 translated->KeyInput.Key         = (irr::EKEY_CODE) (KEY_KEY_1 + iter->first);
 662                                 translated->KeyInput.Control     = false;
 663                                 translated->KeyInput.Shift       = false;
 664                                 translated->KeyInput.PressedDown = true;
 665                                 m_receiver->OnEvent(*translated);
 666                                 m_hud_ids[event.TouchInput.ID]   = translated->KeyInput.Key;
 667                                 delete translated;
 668                                 return true;
 669                         }
 670                 }
 671         }
 672         return false;
 673 }
 674
 675 bool TouchScreenGUI::isReleaseHUDButton(int eventID)
 676 {
 677         std::map<int, irr::EKEY_CODE>::iterator iter = m_hud_ids.find(eventID);
 678
 679         if (iter != m_hud_ids.end()) {
 680                 SEvent *translated = new SEvent();
 681                 memset(translated, 0, sizeof(SEvent));
 682                 translated->EventType            = irr::EET_KEY_INPUT_EVENT;
 683                 translated->KeyInput.Key         = iter->second;
 684                 translated->KeyInput.PressedDown = false;
 685                 translated->KeyInput.Control     = false;
 686                 translated->KeyInput.Shift       = false;
 687                 m_receiver->OnEvent(*translated);
 688                 m_hud_ids.erase(iter);
 689                 delete translated;
 690                 return true;
 691         }
 692         return false;
 693 }
 694
 695 void TouchScreenGUI::handleButtonEvent(touch_gui_button_id button,
 696                 int eventID, bool action)
 697 {
 698         button_info *btn = &m_buttons[button];
 699         SEvent *translated = new SEvent();
 700         memset(translated, 0, sizeof(SEvent));
 701         translated->EventType            = irr::EET_KEY_INPUT_EVENT;
 702         translated->KeyInput.Key         = btn->keycode;
 703         translated->KeyInput.Control     = false;
 704         translated->KeyInput.Shift       = false;
 705         translated->KeyInput.Char        = 0;
 706
 707         // add this event
 708         if (action) {
 709                 assert(std::find(btn->ids.begin(), btn->ids.end(), eventID) == btn->ids.end());
 710
 711                 btn->ids.push_back(eventID);
 712
 713                 if (btn->ids.size() > 1) return;
 714
 715                 btn->repeatcounter = 0;
 716                 translated->KeyInput.PressedDown = true;
 717                 translated->KeyInput.Key = btn->keycode;
 718                 m_receiver->OnEvent(*translated);
 719         }
 720         // remove event
 721         if ((!action) || (btn->immediate_release)) {
 722
 723                 std::vector<int>::iterator pos =
 724                                 std::find(btn->ids.begin(), btn->ids.end(), eventID);
 725                 // has to be in touch list
 726                 assert(pos != btn->ids.end());
 727                 btn->ids.erase(pos);
 728
 729                 if (btn->ids.size() > 0)  { return; }
 730
 731                 translated->KeyInput.PressedDown = false;
 732                 btn->repeatcounter               = -1;
 733                 m_receiver->OnEvent(*translated);
 734         }
 735         delete translated;
 736 }
 737
 738
 739 void TouchScreenGUI::handleReleaseEvent(int evt_id)
 740 {
 741         touch_gui_button_id button = getButtonID(evt_id);
 742
 743         // handle button events
 744         if (button != after_last_element_id) {
 745                 handleButtonEvent(button, evt_id, false);
 746         }
 747         // handle hud button events
 748         else if (isReleaseHUDButton(evt_id)) {
 749                 // nothing to do here
 750         } else if (m_settingsbar.isReleaseButton(evt_id)) {
 751                 // nothing to do here
 752         } else if (m_rarecontrolsbar.isReleaseButton(evt_id)) {
 753                 // nothing to do here
 754         }
 755         // handle the point used for moving view
 756         else if (evt_id == m_move_id) {
 757                 m_move_id = -1;
 758
 759                 // if this pointer issued a mouse event issue symmetric release here
 760                 if (m_move_sent_as_mouse_event) {
 761                         SEvent *translated = new SEvent;
 762                         memset(translated, 0, sizeof(SEvent));
 763                         translated->EventType               = EET_MOUSE_INPUT_EVENT;
 764                         translated->MouseInput.X            = m_move_downlocation.X;
 765                         translated->MouseInput.Y            = m_move_downlocation.Y;
 766                         translated->MouseInput.Shift        = false;
 767                         translated->MouseInput.Control      = false;
 768                         translated->MouseInput.ButtonStates = 0;
 769                         translated->MouseInput.Event        = EMIE_LMOUSE_LEFT_UP;
 770                         m_receiver->OnEvent(*translated);
 771                         delete translated;
 772                 }
 773                 else {
 774                         // do double tap detection
 775                         doubleTapDetection();
 776                 }
 777         }
 778         // handle joystick
 779         else if (evt_id == m_joystick_id) {
 780                 m_joystick_id = -1;
 781
 782                 // reset joystick
 783                 for (unsigned int i = 0; i < 4; i ++)
 784                         m_joystick_status[i] = false;
 785                 applyJoystickStatus();
 786
 787                 m_joystick_btn_off->guibutton->setVisible(true);
 788                 m_joystick_btn_bg->guibutton->setVisible(false);
 789                 m_joystick_btn_center->guibutton->setVisible(false);
 790         }
 791         else {
 792                 infostream
 793                         << "TouchScreenGUI::translateEvent released unknown button: "
 794                         << evt_id << std::endl;
 795         }
 796
 797         for (std::vector<id_status>::iterator iter = m_known_ids.begin();
 798                         iter != m_known_ids.end(); ++iter) {
 799                 if (iter->id == evt_id) {
 800                         m_known_ids.erase(iter);
 801                         break;
 802                 }
 803         }
 804 }
 805
 806 void TouchScreenGUI::translateEvent(const SEvent &event)
 807 {
 808         if (!m_visible) {
 809                 infostream << "TouchScreenGUI::translateEvent got event but not visible?!" << std::endl;
 810                 return;
 811         }
 812
 813         if (event.EventType != EET_TOUCH_INPUT_EVENT) {
 814                 return;
 815         }
 816
 817         if (event.TouchInput.Event == ETIE_PRESSED_DOWN) {
 818
 819                 /* add to own copy of eventlist ...
 820                  * android would provide this information but irrlicht guys don't
 821                  * wanna design a efficient interface
 822                  */
 823                 id_status toadd;
 824                 toadd.id = event.TouchInput.ID;
 825                 toadd.X  = event.TouchInput.X;
 826                 toadd.Y  = event.TouchInput.Y;
 827                 m_known_ids.push_back(toadd);
 828
 829                 int eventID = event.TouchInput.ID;
 830
 831                 touch_gui_button_id button =
 832                                 getButtonID(event.TouchInput.X, event.TouchInput.Y);
 833
 834                 // handle button events
 835                 if (button != after_last_element_id) {
 836                         handleButtonEvent(button, eventID, true);
 837                         m_settingsbar.deactivate();
 838                         m_rarecontrolsbar.deactivate();
 839                 } else if (isHUDButton(event)) {
 840                         m_settingsbar.deactivate();
 841                         m_rarecontrolsbar.deactivate();
 842                         // already handled in isHUDButton()
 843                 } else if (m_settingsbar.isButton(event)) {
 844                         m_rarecontrolsbar.deactivate();
 845                         // already handled in isSettingsBarButton()
 846                 } else if (m_rarecontrolsbar.isButton(event)) {
 847                         m_settingsbar.deactivate();
 848                         // already handled in isSettingsBarButton()
 849                 }
 850                 // handle non button events
 851                 else {
 852                         m_settingsbar.deactivate();
 853                         m_rarecontrolsbar.deactivate();
 854
 855                         u32 button_size = getGuiButtonSize();
 856                         s32 dxj = event.TouchInput.X - button_size * 5 / 2;
 857                         s32 dyj = event.TouchInput.Y - m_screensize.Y + button_size * 5 / 2;
 858
 859                         /* Select joystick when left 1/3 of screen dragged or
 860                          * when joystick tapped (fixed joystick position)
 861                          */
 862                         if ((m_fixed_joystick && dxj * dxj + dyj * dyj <= button_size * button_size * 1.5 * 1.5) ||
 863                                         (!m_fixed_joystick && event.TouchInput.X < m_screensize.X / 3)) {
 864                                 // If we don't already have a starting point for joystick make this the one.
 865                                 if (m_joystick_id == -1) {
 866                                         m_joystick_id               = event.TouchInput.ID;
 867                                         m_joystick_has_really_moved = false;
 868
 869                                         m_joystick_btn_off->guibutton->setVisible(false);
 870                                         m_joystick_btn_bg->guibutton->setVisible(true);
 871                                         m_joystick_btn_center->guibutton->setVisible(true);
 872
 873                                         // If it's a fixed joystick, don't move the joystick "button".
 874                                         if (!m_fixed_joystick) {
 875                                                 m_joystick_btn_bg->guibutton->setRelativePosition(v2s32(
 876                                                                 event.TouchInput.X - button_size * 3 / 2,
 877                                                                 event.TouchInput.Y - button_size * 3 / 2));
 878                                         }
 879                                         m_joystick_btn_center->guibutton->setRelativePosition(v2s32(
 880                                                         event.TouchInput.X - button_size / 2,
 881                                                         event.TouchInput.Y - button_size / 2));
 882                                 }
 883                         } else {
 884                                 // If we don't already have a moving point make this the moving one.
 885                                 if (m_move_id == -1) {
 886                                         m_move_id                  = event.TouchInput.ID;
 887                                         m_move_has_really_moved    = false;
 888                                         m_move_downtime            = porting::getTimeMs();
 889                                         m_move_downlocation        = v2s32(event.TouchInput.X, event.TouchInput.Y);
 890                                         m_move_sent_as_mouse_event = false;
 891                                 }
 892                         }
 893                 }
 894
 895                 m_pointerpos[event.TouchInput.ID] = v2s32(event.TouchInput.X, event.TouchInput.Y);
 896         }
 897         else if (event.TouchInput.Event == ETIE_LEFT_UP) {
 898                 verbosestream << "Up event for pointerid: " << event.TouchInput.ID << std::endl;
 899                 handleReleaseEvent(event.TouchInput.ID);
 900         }
 901         else {
 902                 assert(event.TouchInput.Event == ETIE_MOVED);
 903                 int move_idx = event.TouchInput.ID;
 904
 905                 if (m_pointerpos[event.TouchInput.ID] ==
 906                                 v2s32(event.TouchInput.X, event.TouchInput.Y)) {
 907                         return;
 908                 }
 909
 910                 if (m_move_id != -1) {
 911                         if ((event.TouchInput.ID == m_move_id) &&
 912                                 (!m_move_sent_as_mouse_event)) {
 913
 914                                 double distance = sqrt(
 915                                                 (m_pointerpos[event.TouchInput.ID].X - event.TouchInput.X) *
 916                                                 (m_pointerpos[event.TouchInput.ID].X - event.TouchInput.X) +
 917                                                 (m_pointerpos[event.TouchInput.ID].Y - event.TouchInput.Y) *
 918                                                 (m_pointerpos[event.TouchInput.ID].Y - event.TouchInput.Y));
 919
 920                                 if ((distance > m_touchscreen_threshold) ||
 921                                                 (m_move_has_really_moved)) {
 922                                         m_move_has_really_moved = true;
 923                                         s32 X = event.TouchInput.X;
 924                                         s32 Y = event.TouchInput.Y;
 925
 926                                         // update camera_yaw and camera_pitch
 927                                         s32 dx = X - m_pointerpos[event.TouchInput.ID].X;
 928                                         s32 dy = Y - m_pointerpos[event.TouchInput.ID].Y;
 929
 930                                         // adapt to similar behaviour as pc screen
 931                                         double d         = g_settings->getFloat("mouse_sensitivity") * 4;
 932                                         double old_yaw   = m_camera_yaw_change;
 933                                         double old_pitch = m_camera_pitch;
 934
 935                                         m_camera_yaw_change -= dx * d;
 936                                         m_camera_pitch = MYMIN(MYMAX(m_camera_pitch + (dy * d), -180), 180);
 937
 938                                         // update shootline
 939                                         m_shootline = m_device
 940                                                         ->getSceneManager()
 941                                                         ->getSceneCollisionManager()
 942                                                         ->getRayFromScreenCoordinates(v2s32(X, Y));
 943                                         m_pointerpos[event.TouchInput.ID] = v2s32(X, Y);
 944                                 }
 945                         }
 946                         else if ((event.TouchInput.ID == m_move_id) &&
 947                                         (m_move_sent_as_mouse_event)) {
 948                                 m_shootline = m_device
 949                                                 ->getSceneManager()
 950                                                 ->getSceneCollisionManager()
 951                                                 ->getRayFromScreenCoordinates(
 952                                                                 v2s32(event.TouchInput.X, event.TouchInput.Y));
 953                         }
 954                 }
 955
 956                 if (m_joystick_id != -1 && event.TouchInput.ID == m_joystick_id) {
 957                         u32 button_size = getGuiButtonSize();
 958                         s32 X = event.TouchInput.X;
 959                         s32 Y = event.TouchInput.Y;
 960
 961                         s32 dx = X - m_pointerpos[event.TouchInput.ID].X;
 962                         s32 dy = Y - m_pointerpos[event.TouchInput.ID].Y;
 963                         if (m_fixed_joystick) {
 964                                 dx = X - button_size * 5 / 2;
 965                                 dy = Y - m_screensize.Y + button_size * 5 / 2;
 966                         }
 967
 968                         double distance_sq = dx * dx + dy * dy;
 969
 970                         s32 dxj = event.TouchInput.X - button_size * 5 / 2;
 971                         s32 dyj = event.TouchInput.Y - m_screensize.Y + button_size * 5 / 2;
 972                         bool inside_joystick = (dxj * dxj + dyj * dyj <= button_size * button_size * 1.5 * 1.5);
 973
 974                         if (m_joystick_has_really_moved ||
 975                                         (!m_joystick_has_really_moved && inside_joystick) ||
 976                                         (!m_fixed_joystick &&
 977                                         distance_sq > m_touchscreen_threshold * m_touchscreen_threshold)) {
 978                                 m_joystick_has_really_moved = true;
 979                                 double distance = sqrt(distance_sq);
 980
 981                                 // angle in degrees
 982                                 double angle = acos(dx / distance) * 180 / M_PI;
 983                                 if (dy < 0)
 984                                         angle *= -1;
 985                                 // rotate to make comparing easier
 986                                 angle = fmod(angle + 180 + 22.5, 360);
 987
 988                                 // reset state before applying
 989                                 for (unsigned int i = 0; i < 5; i ++)
 990                                         m_joystick_status[i] = false;
 991
 992                                 if (distance <= m_touchscreen_threshold) {
 993                                         // do nothing
 994                                 } else if (angle < 45)
 995                                         m_joystick_status[j_left] = true;
 996                                 else if (angle < 90) {
 997                                         m_joystick_status[j_forward] = true;
 998                                         m_joystick_status[j_left] = true;
 999                                 } else if (angle < 135)
1000                                         m_joystick_status[j_forward] = true;
1001                                 else if (angle < 180) {
1002                                         m_joystick_status[j_forward] = true;
1003                                         m_joystick_status[j_right] = true;
1004                                 } else if (angle < 225)
1005                                         m_joystick_status[j_right] = true;
1006                                 else if (angle < 270) {
1007                                         m_joystick_status[j_backward] = true;
1008                                         m_joystick_status[j_right] = true;
1009                                 } else if (angle < 315)
1010                                         m_joystick_status[j_backward] = true;
1011                                 else if (angle <= 360) {
1012                                         m_joystick_status[j_backward] = true;
1013                                         m_joystick_status[j_left] = true;
1014                                 }
1015
1016                                 if (distance > button_size) {
1017                                         m_joystick_status[j_special1] = true;
1018                                         // move joystick "button"
1019                                         s32 ndx = (s32) button_size * dx / distance - (s32) button_size / 2;
1020                                         s32 ndy = (s32) button_size * dy / distance - (s32) button_size / 2;
1021                                         if (m_fixed_joystick) {
1022                                                 m_joystick_btn_center->guibutton->setRelativePosition(v2s32(
1023                                                         button_size * 5 / 2 + ndx,
1024                                                         m_screensize.Y - button_size * 5 / 2 + ndy));
1025                                         } else {
1026                                                 m_joystick_btn_center->guibutton->setRelativePosition(v2s32(
1027                                                         m_pointerpos[event.TouchInput.ID].X + ndx,
1028                                                         m_pointerpos[event.TouchInput.ID].Y + ndy));
1029                                         }
1030                                 } else {
1031                                         m_joystick_btn_center->guibutton->setRelativePosition(v2s32(
1032                                                 X - button_size / 2, Y - button_size / 2));
1033                                 }
1034                         }
1035                 }
1036
1037                 if (m_move_id == -1 && m_joystick_id == -1) {
1038                         handleChangedButton(event);
1039                 }
1040         }
1041 }
1042
1043 void TouchScreenGUI::handleChangedButton(const SEvent &event)
1044 {
1045         for (unsigned int i = 0; i < after_last_element_id; i++) {
1046
1047                 if (m_buttons[i].ids.empty()) {
1048                         continue;
1049                 }
1050                 for (std::vector<int>::iterator iter = m_buttons[i].ids.begin();
1051                                 iter != m_buttons[i].ids.end(); ++iter) {
1052
1053                         if (event.TouchInput.ID == *iter) {
1054
1055                                 int current_button_id =
1056                                                 getButtonID(event.TouchInput.X, event.TouchInput.Y);
1057
1058                                 if (current_button_id == i) {
1059                                         continue;
1060                                 }
1061
1062                                 // remove old button
1063                                 handleButtonEvent((touch_gui_button_id) i, *iter, false);
1064
1065                                 if (current_button_id == after_last_element_id) {
1066                                         return;
1067                                 }
1068                                 handleButtonEvent((touch_gui_button_id) current_button_id, *iter, true);
1069                                 return;
1070
1071                         }
1072                 }
1073         }
1074
1075         int current_button_id = getButtonID(event.TouchInput.X, event.TouchInput.Y);
1076
1077         if (current_button_id == after_last_element_id) {
1078                 return;
1079         }
1080
1081         button_info *btn = &m_buttons[current_button_id];
1082         if (std::find(btn->ids.begin(), btn->ids.end(), event.TouchInput.ID)
1083                         == btn->ids.end())
1084         {
1085                 handleButtonEvent((touch_gui_button_id) current_button_id,
1086                                 event.TouchInput.ID, true);
1087         }
1088
1089 }
1090
1091 bool TouchScreenGUI::doubleTapDetection()
1092 {
1093         m_key_events[0].down_time = m_key_events[1].down_time;
1094         m_key_events[0].x         = m_key_events[1].x;
1095         m_key_events[0].y         = m_key_events[1].y;
1096         m_key_events[1].down_time = m_move_downtime;
1097         m_key_events[1].x         = m_move_downlocation.X;
1098         m_key_events[1].y         = m_move_downlocation.Y;
1099
1100         u64 delta = porting::getDeltaMs(m_key_events[0].down_time, porting::getTimeMs());
1101         if (delta > 400)
1102                 return false;
1103
1104         double distance = sqrt(
1105                         (m_key_events[0].x - m_key_events[1].x) * (m_key_events[0].x - m_key_events[1].x) +
1106                         (m_key_events[0].y - m_key_events[1].y) * (m_key_events[0].y - m_key_events[1].y));
1107
1108
1109         if (distance > (20 + m_touchscreen_threshold))
1110                 return false;
1111
1112         SEvent *translated = new SEvent();
1113         memset(translated, 0, sizeof(SEvent));
1114         translated->EventType               = EET_MOUSE_INPUT_EVENT;
1115         translated->MouseInput.X            = m_key_events[0].x;
1116         translated->MouseInput.Y            = m_key_events[0].y;
1117         translated->MouseInput.Shift        = false;
1118         translated->MouseInput.Control      = false;
1119         translated->MouseInput.ButtonStates = EMBSM_RIGHT;
1120
1121         // update shootline
1122         m_shootline = m_device
1123                         ->getSceneManager()
1124                         ->getSceneCollisionManager()
1125                         ->getRayFromScreenCoordinates(v2s32(m_key_events[0].x, m_key_events[0].y));
1126
1127         translated->MouseInput.Event = EMIE_RMOUSE_PRESSED_DOWN;
1128         verbosestream << "TouchScreenGUI::translateEvent right click press" << std::endl;
1129         m_receiver->OnEvent(*translated);
1130
1131         translated->MouseInput.ButtonStates = 0;
1132         translated->MouseInput.Event        = EMIE_RMOUSE_LEFT_UP;
1133         verbosestream << "TouchScreenGUI::translateEvent right click release" << std::endl;
1134         m_receiver->OnEvent(*translated);
1135         delete translated;
1136         return true;
1137
1138 }
1139
1140 void TouchScreenGUI::applyJoystickStatus()
1141 {
1142         for (unsigned int i = 0; i < 5; i ++) {
1143                 if (i == 4 && !m_joystick_triggers_special1)
1144                         continue;
1145
1146                 SEvent translated{};
1147                 translated.EventType            = irr::EET_KEY_INPUT_EVENT;
1148                 translated.KeyInput.Key         = id2keycode(m_joystick_names[i]);
1149                 translated.KeyInput.PressedDown = false;
1150                 m_receiver->OnEvent(translated);
1151
1152                 if (m_joystick_status[i]) {
1153                         translated.KeyInput.PressedDown = true;
1154                         m_receiver->OnEvent(translated);
1155                 }
1156         }
1157 }
1158
1159 TouchScreenGUI::~TouchScreenGUI()
1160 {
1161         for (unsigned int i = 0; i < after_last_element_id; i++) {
1162                 button_info *btn = &m_buttons[i];
1163                 if (btn->guibutton) {
1164                         btn->guibutton->drop();
1165                         btn->guibutton = NULL;
1166                 }
1167         }
1168
1169         if (m_joystick_btn_off->guibutton) {
1170                 m_joystick_btn_off->guibutton->drop();
1171                 m_joystick_btn_off->guibutton = NULL;
1172         }
1173
1174         if (m_joystick_btn_bg->guibutton) {
1175                 m_joystick_btn_bg->guibutton->drop();
1176                 m_joystick_btn_bg->guibutton = NULL;
1177         }
1178
1179         if (m_joystick_btn_center->guibutton) {
1180                 m_joystick_btn_center->guibutton->drop();
1181                 m_joystick_btn_center->guibutton = NULL;
1182         }
1183 }
1184
1185 void TouchScreenGUI::step(float dtime)
1186 {
1187         // simulate keyboard repeats
1188         for (unsigned int i = 0; i < after_last_element_id; i++) {
1189                 button_info *btn = &m_buttons[i];
1190
1191                 if (btn->ids.size() > 0) {
1192                         btn->repeatcounter += dtime;
1193
1194                         // in case we're moving around digging does not happen
1195                         if (m_move_id != -1)
1196                                 m_move_has_really_moved = true;
1197
1198                         if (btn->repeatcounter < btn->repeatdelay) continue;
1199
1200                         btn->repeatcounter              = 0;
1201                         SEvent translated;
1202                         memset(&translated, 0, sizeof(SEvent));
1203                         translated.EventType            = irr::EET_KEY_INPUT_EVENT;
1204                         translated.KeyInput.Key         = btn->keycode;
1205                         translated.KeyInput.PressedDown = false;
1206                         m_receiver->OnEvent(translated);
1207
1208                         translated.KeyInput.PressedDown = true;
1209                         m_receiver->OnEvent(translated);
1210                 }
1211         }
1212
1213         // joystick
1214         for (unsigned int i = 0; i < 4; i++) {
1215                 if (m_joystick_status[i]) {
1216                         applyJoystickStatus();
1217                         break;
1218                 }
1219         }
1220
1221         // if a new placed pointer isn't moved for some time start digging
1222         if ((m_move_id != -1) &&
1223                         (!m_move_has_really_moved) &&
1224                         (!m_move_sent_as_mouse_event)) {
1225
1226                 u64 delta = porting::getDeltaMs(m_move_downtime, porting::getTimeMs());
1227
1228                 if (delta > MIN_DIG_TIME_MS) {
1229                         m_shootline = m_device
1230                                         ->getSceneManager()
1231                                         ->getSceneCollisionManager()
1232                                         ->getRayFromScreenCoordinates(
1233                                                         v2s32(m_move_downlocation.X,m_move_downlocation.Y));
1234
1235                         SEvent translated;
1236                         memset(&translated, 0, sizeof(SEvent));
1237                         translated.EventType               = EET_MOUSE_INPUT_EVENT;
1238                         translated.MouseInput.X            = m_move_downlocation.X;
1239                         translated.MouseInput.Y            = m_move_downlocation.Y;
1240                         translated.MouseInput.Shift        = false;
1241                         translated.MouseInput.Control      = false;
1242                         translated.MouseInput.ButtonStates = EMBSM_LEFT;
1243                         translated.MouseInput.Event        = EMIE_LMOUSE_PRESSED_DOWN;
1244                         verbosestream << "TouchScreenGUI::step left click press" << std::endl;
1245                         m_receiver->OnEvent(translated);
1246                         m_move_sent_as_mouse_event         = true;
1247                 }
1248         }
1249
1250         m_settingsbar.step(dtime);
1251         m_rarecontrolsbar.step(dtime);
1252 }
1253
1254 void TouchScreenGUI::resetHud()
1255 {
1256         m_hud_rects.clear();
1257 }
1258
1259 void TouchScreenGUI::registerHudItem(int index, const rect<s32> &rect)
1260 {
1261         m_hud_rects[index] = rect;
1262 }
1263
1264 void TouchScreenGUI::Toggle(bool visible)
1265 {
1266         m_visible = visible;
1267         for (unsigned int i = 0; i < after_last_element_id; i++) {
1268                 button_info *btn = &m_buttons[i];
1269                 if (btn->guibutton) {
1270                         btn->guibutton->setVisible(visible);
1271                 }
1272         }
1273
1274         if (m_joystick_btn_off->guibutton) {
1275                 m_joystick_btn_off->guibutton->setVisible(visible);
1276         }
1277
1278         // clear all active buttons
1279         if (!visible) {
1280                 while (m_known_ids.size() > 0) {
1281                         handleReleaseEvent(m_known_ids.begin()->id);
1282                 }
1283
1284                 m_settingsbar.hide();
1285                 m_rarecontrolsbar.hide();
1286         } else {
1287                 m_settingsbar.show();
1288                 m_rarecontrolsbar.show();
1289         }
1290 }
1291
1292 void TouchScreenGUI::hide()
1293 {
1294         if (!m_visible)
1295                 return;
1296
1297         Toggle(false);
1298 }
1299
1300 void TouchScreenGUI::show()
1301 {
1302         if (m_visible)
1303                 return;
1304
1305         Toggle(true);
1306 }