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