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         "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 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 - (button_size / 2),
 579                                         m_screensize.Y - ((SETTINGS_BAR_Y_OFFSET + 1) * button_size)
 580                                                         + (button_size * 0.5)),
 581                         v2s32(m_screensize.X,
 582                                         m_screensize.Y - (SETTINGS_BAR_Y_OFFSET * button_size)
 583                                                         + (button_size * 0.5)), AHBB_Dir_Right_Left,
 584                         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,
 601                                         m_screensize.Y
 602                                                         - ((RARE_CONTROLS_BAR_Y_OFFSET + 1) * button_size)
 603                                                         + (button_size * 0.5)),
 604                         v2s32(button_size / 2,
 605                                         m_screensize.Y - (RARE_CONTROLS_BAR_Y_OFFSET * button_size)
 606                                                         + (button_size * 0.5)), AHBB_Dir_Left_Right,
 607                         2);
 608
 609         m_rarecontrolsbar.addButton(chat_id,      L"Chat", "chat_btn.png");
 610         m_rarecontrolsbar.addButton(inventory_id, L"inv",  "inventory_btn.png");
 611         m_rarecontrolsbar.addButton(drop_id,      L"drop", "drop_btn.png");
 612
 613 }
 614
 615 touch_gui_button_id TouchScreenGUI::getButtonID(s32 x, s32 y)
 616 {
 617         IGUIElement *rootguielement = m_guienv->getRootGUIElement();
 618
 619         if (rootguielement != NULL) {
 620                 gui::IGUIElement *element =
 621                                 rootguielement->getElementFromPoint(core::position2d<s32>(x, y));
 622
 623                 if (element) {
 624                         for (unsigned int i=0; i < after_last_element_id; i++) {
 625                                 if (element == m_buttons[i].guibutton) {
 626                                         return (touch_gui_button_id) i;
 627                                 }
 628                         }
 629                 }
 630         }
 631         return after_last_element_id;
 632 }
 633
 634 touch_gui_button_id TouchScreenGUI::getButtonID(int eventID)
 635 {
 636         for (unsigned int i=0; i < after_last_element_id; i++) {
 637                 button_info *btn = &m_buttons[i];
 638
 639                 std::vector<int>::iterator id =
 640                                 std::find(btn->ids.begin(), btn->ids.end(), eventID);
 641
 642                 if (id != btn->ids.end())
 643                         return (touch_gui_button_id) i;
 644         }
 645
 646         return after_last_element_id;
 647 }
 648
 649 bool TouchScreenGUI::isHUDButton(const SEvent &event)
 650 {
 651         // check if hud item is pressed
 652         for (std::map<int, rect<s32> >::iterator iter = m_hud_rects.begin();
 653                         iter != m_hud_rects.end(); ++iter) {
 654                 if (iter->second.isPointInside(
 655                                 v2s32(event.TouchInput.X,
 656                                                 event.TouchInput.Y)
 657                         )) {
 658                         if ( iter->first < 8) {
 659                                 SEvent *translated = new SEvent();
 660                                 memset(translated, 0, sizeof(SEvent));
 661                                 translated->EventType = irr::EET_KEY_INPUT_EVENT;
 662                                 translated->KeyInput.Key         = (irr::EKEY_CODE) (KEY_KEY_1 + iter->first);
 663                                 translated->KeyInput.Control     = false;
 664                                 translated->KeyInput.Shift       = false;
 665                                 translated->KeyInput.PressedDown = true;
 666                                 m_receiver->OnEvent(*translated);
 667                                 m_hud_ids[event.TouchInput.ID]   = translated->KeyInput.Key;
 668                                 delete translated;
 669                                 return true;
 670                         }
 671                 }
 672         }
 673         return false;
 674 }
 675
 676 bool TouchScreenGUI::isReleaseHUDButton(int eventID)
 677 {
 678         std::map<int, irr::EKEY_CODE>::iterator iter = m_hud_ids.find(eventID);
 679
 680         if (iter != m_hud_ids.end()) {
 681                 SEvent *translated = new SEvent();
 682                 memset(translated, 0, sizeof(SEvent));
 683                 translated->EventType            = irr::EET_KEY_INPUT_EVENT;
 684                 translated->KeyInput.Key         = iter->second;
 685                 translated->KeyInput.PressedDown = false;
 686                 translated->KeyInput.Control     = false;
 687                 translated->KeyInput.Shift       = false;
 688                 m_receiver->OnEvent(*translated);
 689                 m_hud_ids.erase(iter);
 690                 delete translated;
 691                 return true;
 692         }
 693         return false;
 694 }
 695
 696 void TouchScreenGUI::handleButtonEvent(touch_gui_button_id button,
 697                 int eventID, bool action)
 698 {
 699         button_info *btn = &m_buttons[button];
 700         SEvent *translated = new SEvent();
 701         memset(translated, 0, sizeof(SEvent));
 702         translated->EventType            = irr::EET_KEY_INPUT_EVENT;
 703         translated->KeyInput.Key         = btn->keycode;
 704         translated->KeyInput.Control     = false;
 705         translated->KeyInput.Shift       = false;
 706         translated->KeyInput.Char        = 0;
 707
 708         // add this event
 709         if (action) {
 710                 assert(std::find(btn->ids.begin(), btn->ids.end(), eventID) == btn->ids.end());
 711
 712                 btn->ids.push_back(eventID);
 713
 714                 if (btn->ids.size() > 1) return;
 715
 716                 btn->repeatcounter = 0;
 717                 translated->KeyInput.PressedDown = true;
 718                 translated->KeyInput.Key = btn->keycode;
 719                 m_receiver->OnEvent(*translated);
 720         }
 721         // remove event
 722         if ((!action) || (btn->immediate_release)) {
 723
 724                 std::vector<int>::iterator pos =
 725                                 std::find(btn->ids.begin(), btn->ids.end(), eventID);
 726                 // has to be in touch list
 727                 assert(pos != btn->ids.end());
 728                 btn->ids.erase(pos);
 729
 730                 if (btn->ids.size() > 0)  { return; }
 731
 732                 translated->KeyInput.PressedDown = false;
 733                 btn->repeatcounter               = -1;
 734                 m_receiver->OnEvent(*translated);
 735         }
 736         delete translated;
 737 }
 738
 739
 740 void TouchScreenGUI::handleReleaseEvent(int evt_id)
 741 {
 742         touch_gui_button_id button = getButtonID(evt_id);
 743
 744         // handle button events
 745         if (button != after_last_element_id) {
 746                 handleButtonEvent(button, evt_id, false);
 747         }
 748         // handle hud button events
 749         else if (isReleaseHUDButton(evt_id)) {
 750                 // nothing to do here
 751         } else if (m_settingsbar.isReleaseButton(evt_id)) {
 752                 // nothing to do here
 753         } else if (m_rarecontrolsbar.isReleaseButton(evt_id)) {
 754                 // nothing to do here
 755         }
 756         // handle the point used for moving view
 757         else if (evt_id == m_move_id) {
 758                 m_move_id = -1;
 759
 760                 // if this pointer issued a mouse event issue symmetric release here
 761                 if (m_move_sent_as_mouse_event) {
 762                         SEvent *translated = new SEvent;
 763                         memset(translated, 0, sizeof(SEvent));
 764                         translated->EventType               = EET_MOUSE_INPUT_EVENT;
 765                         translated->MouseInput.X            = m_move_downlocation.X;
 766                         translated->MouseInput.Y            = m_move_downlocation.Y;
 767                         translated->MouseInput.Shift        = false;
 768                         translated->MouseInput.Control      = false;
 769                         translated->MouseInput.ButtonStates = 0;
 770                         translated->MouseInput.Event        = EMIE_LMOUSE_LEFT_UP;
 771                         m_receiver->OnEvent(*translated);
 772                         delete translated;
 773                 }
 774                 else {
 775                         // do double tap detection
 776                         doubleTapDetection();
 777                 }
 778         }
 779         // handle joystick
 780         else if (evt_id == m_joystick_id) {
 781                 m_joystick_id = -1;
 782
 783                 // reset joystick
 784                 for (unsigned int i = 0; i < 4; i ++)
 785                         m_joystick_status[i] = false;
 786                 applyJoystickStatus();
 787
 788                 m_joystick_btn_off->guibutton->setVisible(true);
 789                 m_joystick_btn_bg->guibutton->setVisible(false);
 790                 m_joystick_btn_center->guibutton->setVisible(false);
 791         }
 792         else {
 793                 infostream
 794                         << "TouchScreenGUI::translateEvent released unknown button: "
 795                         << evt_id << std::endl;
 796         }
 797
 798         for (std::vector<id_status>::iterator iter = m_known_ids.begin();
 799                         iter != m_known_ids.end(); ++iter) {
 800                 if (iter->id == evt_id) {
 801                         m_known_ids.erase(iter);
 802                         break;
 803                 }
 804         }
 805 }
 806
 807 void TouchScreenGUI::translateEvent(const SEvent &event)
 808 {
 809         if (!m_visible) {
 810                 infostream << "TouchScreenGUI::translateEvent got event but not visible?!" << std::endl;
 811                 return;
 812         }
 813
 814         if (event.EventType != EET_TOUCH_INPUT_EVENT) {
 815                 return;
 816         }
 817
 818         if (event.TouchInput.Event == ETIE_PRESSED_DOWN) {
 819
 820                 /* add to own copy of eventlist ...
 821                  * android would provide this information but irrlicht guys don't
 822                  * wanna design a efficient interface
 823                  */
 824                 id_status toadd;
 825                 toadd.id = event.TouchInput.ID;
 826                 toadd.X  = event.TouchInput.X;
 827                 toadd.Y  = event.TouchInput.Y;
 828                 m_known_ids.push_back(toadd);
 829
 830                 int eventID = event.TouchInput.ID;
 831
 832                 touch_gui_button_id button =
 833                                 getButtonID(event.TouchInput.X, event.TouchInput.Y);
 834
 835                 // handle button events
 836                 if (button != after_last_element_id) {
 837                         handleButtonEvent(button, eventID, true);
 838                         m_settingsbar.deactivate();
 839                         m_rarecontrolsbar.deactivate();
 840                 } else if (isHUDButton(event)) {
 841                         m_settingsbar.deactivate();
 842                         m_rarecontrolsbar.deactivate();
 843                         // already handled in isHUDButton()
 844                 } else if (m_settingsbar.isButton(event)) {
 845                         m_rarecontrolsbar.deactivate();
 846                         // already handled in isSettingsBarButton()
 847                 } else if (m_rarecontrolsbar.isButton(event)) {
 848                         m_settingsbar.deactivate();
 849                         // already handled in isSettingsBarButton()
 850                 }
 851                 // handle non button events
 852                 else {
 853                         m_settingsbar.deactivate();
 854                         m_rarecontrolsbar.deactivate();
 855
 856                         u32 button_size = getGuiButtonSize();
 857                         s32 dxj = event.TouchInput.X - button_size * 5 / 2;
 858                         s32 dyj = event.TouchInput.Y - m_screensize.Y + button_size * 5 / 2;
 859
 860                         /* Select joystick when left 1/3 of screen dragged or
 861                          * when joystick tapped (fixed joystick position)
 862                          */
 863                         if ((m_fixed_joystick && dxj * dxj + dyj * dyj <= button_size * button_size * 1.5 * 1.5) ||
 864                                         (!m_fixed_joystick && event.TouchInput.X < m_screensize.X / 3)) {
 865                                 // If we don't already have a starting point for joystick make this the one.
 866                                 if (m_joystick_id == -1) {
 867                                         m_joystick_id               = event.TouchInput.ID;
 868                                         m_joystick_has_really_moved = false;
 869
 870                                         m_joystick_btn_off->guibutton->setVisible(false);
 871                                         m_joystick_btn_bg->guibutton->setVisible(true);
 872                                         m_joystick_btn_center->guibutton->setVisible(true);
 873
 874                                         // If it's a fixed joystick, don't move the joystick "button".
 875                                         if (!m_fixed_joystick) {
 876                                                 m_joystick_btn_bg->guibutton->setRelativePosition(v2s32(
 877                                                                 event.TouchInput.X - button_size * 3 / 2,
 878                                                                 event.TouchInput.Y - button_size * 3 / 2));
 879                                         }
 880                                         m_joystick_btn_center->guibutton->setRelativePosition(v2s32(
 881                                                         event.TouchInput.X - button_size / 2,
 882                                                         event.TouchInput.Y - button_size / 2));
 883                                 }
 884                         } else {
 885                                 // If we don't already have a moving point make this the moving one.
 886                                 if (m_move_id == -1) {
 887                                         m_move_id                  = event.TouchInput.ID;
 888                                         m_move_has_really_moved    = false;
 889                                         m_move_downtime            = porting::getTimeMs();
 890                                         m_move_downlocation        = v2s32(event.TouchInput.X, event.TouchInput.Y);
 891                                         m_move_sent_as_mouse_event = false;
 892                                 }
 893                         }
 894                 }
 895
 896                 m_pointerpos[event.TouchInput.ID] = v2s32(event.TouchInput.X, event.TouchInput.Y);
 897         }
 898         else if (event.TouchInput.Event == ETIE_LEFT_UP) {
 899                 verbosestream << "Up event for pointerid: " << event.TouchInput.ID << std::endl;
 900                 handleReleaseEvent(event.TouchInput.ID);
 901         }
 902         else {
 903                 assert(event.TouchInput.Event == ETIE_MOVED);
 904                 int move_idx = event.TouchInput.ID;
 905
 906                 if (m_pointerpos[event.TouchInput.ID] ==
 907                                 v2s32(event.TouchInput.X, event.TouchInput.Y)) {
 908                         return;
 909                 }
 910
 911                 if (m_move_id != -1) {
 912                         if ((event.TouchInput.ID == m_move_id) &&
 913                                 (!m_move_sent_as_mouse_event)) {
 914
 915                                 double distance = sqrt(
 916                                                 (m_pointerpos[event.TouchInput.ID].X - event.TouchInput.X) *
 917                                                 (m_pointerpos[event.TouchInput.ID].X - event.TouchInput.X) +
 918                                                 (m_pointerpos[event.TouchInput.ID].Y - event.TouchInput.Y) *
 919                                                 (m_pointerpos[event.TouchInput.ID].Y - event.TouchInput.Y));
 920
 921                                 if ((distance > m_touchscreen_threshold) ||
 922                                                 (m_move_has_really_moved)) {
 923                                         m_move_has_really_moved = true;
 924                                         s32 X = event.TouchInput.X;
 925                                         s32 Y = event.TouchInput.Y;
 926
 927                                         // update camera_yaw and camera_pitch
 928                                         s32 dx = X - m_pointerpos[event.TouchInput.ID].X;
 929                                         s32 dy = Y - m_pointerpos[event.TouchInput.ID].Y;
 930
 931                                         // adapt to similar behaviour as pc screen
 932                                         double d         = g_settings->getFloat("mouse_sensitivity") * 4;
 933                                         double old_yaw   = m_camera_yaw_change;
 934                                         double old_pitch = m_camera_pitch;
 935
 936                                         m_camera_yaw_change -= dx * d;
 937                                         m_camera_pitch = MYMIN(MYMAX(m_camera_pitch + (dy * d), -180), 180);
 938
 939                                         // update shootline
 940                                         m_shootline = m_device
 941                                                         ->getSceneManager()
 942                                                         ->getSceneCollisionManager()
 943                                                         ->getRayFromScreenCoordinates(v2s32(X, Y));
 944                                         m_pointerpos[event.TouchInput.ID] = v2s32(X, Y);
 945                                 }
 946                         }
 947                         else if ((event.TouchInput.ID == m_move_id) &&
 948                                         (m_move_sent_as_mouse_event)) {
 949                                 m_shootline = m_device
 950                                                 ->getSceneManager()
 951                                                 ->getSceneCollisionManager()
 952                                                 ->getRayFromScreenCoordinates(
 953                                                                 v2s32(event.TouchInput.X, event.TouchInput.Y));
 954                         }
 955                 }
 956
 957                 if (m_joystick_id != -1 && event.TouchInput.ID == m_joystick_id) {
 958                         u32 button_size = getGuiButtonSize();
 959                         s32 X = event.TouchInput.X;
 960                         s32 Y = event.TouchInput.Y;
 961
 962                         s32 dx = X - m_pointerpos[event.TouchInput.ID].X;
 963                         s32 dy = Y - m_pointerpos[event.TouchInput.ID].Y;
 964                         if (m_fixed_joystick) {
 965                                 dx = X - button_size * 5 / 2;
 966                                 dy = Y - m_screensize.Y + button_size * 5 / 2;
 967                         }
 968
 969                         double distance_sq = dx * dx + dy * dy;
 970
 971                         s32 dxj = event.TouchInput.X - button_size * 5 / 2;
 972                         s32 dyj = event.TouchInput.Y - m_screensize.Y + button_size * 5 / 2;
 973                         bool inside_joystick = (dxj * dxj + dyj * dyj <= button_size * button_size * 1.5 * 1.5);
 974
 975                         if (m_joystick_has_really_moved ||
 976                                         (!m_joystick_has_really_moved && inside_joystick) ||
 977                                         (!m_fixed_joystick &&
 978                                         distance_sq > m_touchscreen_threshold * m_touchscreen_threshold)) {
 979                                 m_joystick_has_really_moved = true;
 980                                 double distance = sqrt(distance_sq);
 981
 982                                 // angle in degrees
 983                                 double angle = acos(dx / distance) * 180 / M_PI;
 984                                 if (dy < 0)
 985                                         angle *= -1;
 986                                 // rotate to make comparing easier
 987                                 angle = fmod(angle + 180 + 22.5, 360);
 988
 989                                 // reset state before applying
 990                                 for (unsigned int i = 0; i < 5; i ++)
 991                                         m_joystick_status[i] = false;
 992
 993                                 if (distance <= m_touchscreen_threshold) {
 994                                         // do nothing
 995                                 } else if (angle < 45)
 996                                         m_joystick_status[j_left] = true;
 997                                 else if (angle < 90) {
 998                                         m_joystick_status[j_forward] = true;
 999                                         m_joystick_status[j_left] = true;
1000                                 } else if (angle < 135)
1001                                         m_joystick_status[j_forward] = true;
1002                                 else if (angle < 180) {
1003                                         m_joystick_status[j_forward] = true;
1004                                         m_joystick_status[j_right] = true;
1005                                 } else if (angle < 225)
1006                                         m_joystick_status[j_right] = true;
1007                                 else if (angle < 270) {
1008                                         m_joystick_status[j_backward] = true;
1009                                         m_joystick_status[j_right] = true;
1010                                 } else if (angle < 315)
1011                                         m_joystick_status[j_backward] = true;
1012                                 else if (angle <= 360) {
1013                                         m_joystick_status[j_backward] = true;
1014                                         m_joystick_status[j_left] = true;
1015                                 }
1016
1017                                 if (distance > button_size) {
1018                                         m_joystick_status[j_special1] = true;
1019                                         // move joystick "button"
1020                                         s32 ndx = (s32) button_size * dx / distance - (s32) button_size / 2;
1021                                         s32 ndy = (s32) button_size * dy / distance - (s32) button_size / 2;
1022                                         if (m_fixed_joystick) {
1023                                                 m_joystick_btn_center->guibutton->setRelativePosition(v2s32(
1024                                                         button_size * 5 / 2 + ndx,
1025                                                         m_screensize.Y - button_size * 5 / 2 + ndy));
1026                                         } else {
1027                                                 m_joystick_btn_center->guibutton->setRelativePosition(v2s32(
1028                                                         m_pointerpos[event.TouchInput.ID].X + ndx,
1029                                                         m_pointerpos[event.TouchInput.ID].Y + ndy));
1030                                         }
1031                                 } else {
1032                                         m_joystick_btn_center->guibutton->setRelativePosition(v2s32(
1033                                                 X - button_size / 2, Y - button_size / 2));
1034                                 }
1035                         }
1036                 }
1037
1038                 if (m_move_id == -1 && m_joystick_id == -1) {
1039                         handleChangedButton(event);
1040                 }
1041         }
1042 }
1043
1044 void TouchScreenGUI::handleChangedButton(const SEvent &event)
1045 {
1046         for (unsigned int i = 0; i < after_last_element_id; i++) {
1047
1048                 if (m_buttons[i].ids.empty()) {
1049                         continue;
1050                 }
1051                 for (std::vector<int>::iterator iter = m_buttons[i].ids.begin();
1052                                 iter != m_buttons[i].ids.end(); ++iter) {
1053
1054                         if (event.TouchInput.ID == *iter) {
1055
1056                                 int current_button_id =
1057                                                 getButtonID(event.TouchInput.X, event.TouchInput.Y);
1058
1059                                 if (current_button_id == i) {
1060                                         continue;
1061                                 }
1062
1063                                 // remove old button
1064                                 handleButtonEvent((touch_gui_button_id) i, *iter, false);
1065
1066                                 if (current_button_id == after_last_element_id) {
1067                                         return;
1068                                 }
1069                                 handleButtonEvent((touch_gui_button_id) current_button_id, *iter, true);
1070                                 return;
1071
1072                         }
1073                 }
1074         }
1075
1076         int current_button_id = getButtonID(event.TouchInput.X, event.TouchInput.Y);
1077
1078         if (current_button_id == after_last_element_id) {
1079                 return;
1080         }
1081
1082         button_info *btn = &m_buttons[current_button_id];
1083         if (std::find(btn->ids.begin(), btn->ids.end(), event.TouchInput.ID)
1084                         == btn->ids.end())
1085         {
1086                 handleButtonEvent((touch_gui_button_id) current_button_id,
1087                                 event.TouchInput.ID, true);
1088         }
1089
1090 }
1091
1092 bool TouchScreenGUI::doubleTapDetection()
1093 {
1094         m_key_events[0].down_time = m_key_events[1].down_time;
1095         m_key_events[0].x         = m_key_events[1].x;
1096         m_key_events[0].y         = m_key_events[1].y;
1097         m_key_events[1].down_time = m_move_downtime;
1098         m_key_events[1].x         = m_move_downlocation.X;
1099         m_key_events[1].y         = m_move_downlocation.Y;
1100
1101         u64 delta = porting::getDeltaMs(m_key_events[0].down_time, porting::getTimeMs());
1102         if (delta > 400)
1103                 return false;
1104
1105         double distance = sqrt(
1106                         (m_key_events[0].x - m_key_events[1].x) * (m_key_events[0].x - m_key_events[1].x) +
1107                         (m_key_events[0].y - m_key_events[1].y) * (m_key_events[0].y - m_key_events[1].y));
1108
1109
1110         if (distance > (20 + m_touchscreen_threshold))
1111                 return false;
1112
1113         SEvent *translated = new SEvent();
1114         memset(translated, 0, sizeof(SEvent));
1115         translated->EventType               = EET_MOUSE_INPUT_EVENT;
1116         translated->MouseInput.X            = m_key_events[0].x;
1117         translated->MouseInput.Y            = m_key_events[0].y;
1118         translated->MouseInput.Shift        = false;
1119         translated->MouseInput.Control      = false;
1120         translated->MouseInput.ButtonStates = EMBSM_RIGHT;
1121
1122         // update shootline
1123         m_shootline = m_device
1124                         ->getSceneManager()
1125                         ->getSceneCollisionManager()
1126                         ->getRayFromScreenCoordinates(v2s32(m_key_events[0].x, m_key_events[0].y));
1127
1128         translated->MouseInput.Event = EMIE_RMOUSE_PRESSED_DOWN;
1129         verbosestream << "TouchScreenGUI::translateEvent right click press" << std::endl;
1130         m_receiver->OnEvent(*translated);
1131
1132         translated->MouseInput.ButtonStates = 0;
1133         translated->MouseInput.Event        = EMIE_RMOUSE_LEFT_UP;
1134         verbosestream << "TouchScreenGUI::translateEvent right click release" << std::endl;
1135         m_receiver->OnEvent(*translated);
1136         delete translated;
1137         return true;
1138
1139 }
1140
1141 void TouchScreenGUI::applyJoystickStatus()
1142 {
1143         for (unsigned int i = 0; i < 5; i ++) {
1144                 if (i == 4 && !m_joystick_triggers_special1)
1145                         continue;
1146
1147                 SEvent translated{};
1148                 translated.EventType            = irr::EET_KEY_INPUT_EVENT;
1149                 translated.KeyInput.Key         = id2keycode(m_joystick_names[i]);
1150                 translated.KeyInput.PressedDown = false;
1151                 m_receiver->OnEvent(translated);
1152
1153                 if (m_joystick_status[i]) {
1154                         translated.KeyInput.PressedDown = true;
1155                         m_receiver->OnEvent(translated);
1156                 }
1157         }
1158 }
1159
1160 TouchScreenGUI::~TouchScreenGUI()
1161 {
1162         for (unsigned int i = 0; i < after_last_element_id; i++) {
1163                 button_info *btn = &m_buttons[i];
1164                 if (btn->guibutton) {
1165                         btn->guibutton->drop();
1166                         btn->guibutton = NULL;
1167                 }
1168         }
1169
1170         if (m_joystick_btn_off->guibutton) {
1171                 m_joystick_btn_off->guibutton->drop();
1172                 m_joystick_btn_off->guibutton = NULL;
1173         }
1174
1175         if (m_joystick_btn_bg->guibutton) {
1176                 m_joystick_btn_bg->guibutton->drop();
1177                 m_joystick_btn_bg->guibutton = NULL;
1178         }
1179
1180         if (m_joystick_btn_center->guibutton) {
1181                 m_joystick_btn_center->guibutton->drop();
1182                 m_joystick_btn_center->guibutton = NULL;
1183         }
1184 }
1185
1186 void TouchScreenGUI::step(float dtime)
1187 {
1188         // simulate keyboard repeats
1189         for (unsigned int i = 0; i < after_last_element_id; i++) {
1190                 button_info *btn = &m_buttons[i];
1191
1192                 if (btn->ids.size() > 0) {
1193                         btn->repeatcounter += dtime;
1194
1195                         // in case we're moving around digging does not happen
1196                         if (m_move_id != -1)
1197                                 m_move_has_really_moved = true;
1198
1199                         if (btn->repeatcounter < btn->repeatdelay) continue;
1200
1201                         btn->repeatcounter              = 0;
1202                         SEvent translated;
1203                         memset(&translated, 0, sizeof(SEvent));
1204                         translated.EventType            = irr::EET_KEY_INPUT_EVENT;
1205                         translated.KeyInput.Key         = btn->keycode;
1206                         translated.KeyInput.PressedDown = false;
1207                         m_receiver->OnEvent(translated);
1208
1209                         translated.KeyInput.PressedDown = true;
1210                         m_receiver->OnEvent(translated);
1211                 }
1212         }
1213
1214         // joystick
1215         applyJoystickStatus();
1216
1217         // if a new placed pointer isn't moved for some time start digging
1218         if ((m_move_id != -1) &&
1219                         (!m_move_has_really_moved) &&
1220                         (!m_move_sent_as_mouse_event)) {
1221
1222                 u64 delta = porting::getDeltaMs(m_move_downtime, porting::getTimeMs());
1223
1224                 if (delta > MIN_DIG_TIME_MS) {
1225                         m_shootline = m_device
1226                                         ->getSceneManager()
1227                                         ->getSceneCollisionManager()
1228                                         ->getRayFromScreenCoordinates(
1229                                                         v2s32(m_move_downlocation.X,m_move_downlocation.Y));
1230
1231                         SEvent translated;
1232                         memset(&translated, 0, sizeof(SEvent));
1233                         translated.EventType               = EET_MOUSE_INPUT_EVENT;
1234                         translated.MouseInput.X            = m_move_downlocation.X;
1235                         translated.MouseInput.Y            = m_move_downlocation.Y;
1236                         translated.MouseInput.Shift        = false;
1237                         translated.MouseInput.Control      = false;
1238                         translated.MouseInput.ButtonStates = EMBSM_LEFT;
1239                         translated.MouseInput.Event        = EMIE_LMOUSE_PRESSED_DOWN;
1240                         verbosestream << "TouchScreenGUI::step left click press" << std::endl;
1241                         m_receiver->OnEvent(translated);
1242                         m_move_sent_as_mouse_event         = true;
1243                 }
1244         }
1245
1246         m_settingsbar.step(dtime);
1247         m_rarecontrolsbar.step(dtime);
1248 }
1249
1250 void TouchScreenGUI::resetHud()
1251 {
1252         m_hud_rects.clear();
1253 }
1254
1255 void TouchScreenGUI::registerHudItem(int index, const rect<s32> &rect)
1256 {
1257         m_hud_rects[index] = rect;
1258 }
1259
1260 void TouchScreenGUI::Toggle(bool visible)
1261 {
1262         m_visible = visible;
1263         for (unsigned int i = 0; i < after_last_element_id; i++) {
1264                 button_info *btn = &m_buttons[i];
1265                 if (btn->guibutton) {
1266                         btn->guibutton->setVisible(visible);
1267                 }
1268         }
1269
1270         if (m_joystick_btn_off->guibutton) {
1271                 m_joystick_btn_off->guibutton->setVisible(visible);
1272         }
1273
1274         // clear all active buttons
1275         if (!visible) {
1276                 while (m_known_ids.size() > 0) {
1277                         handleReleaseEvent(m_known_ids.begin()->id);
1278                 }
1279
1280                 m_settingsbar.hide();
1281                 m_rarecontrolsbar.hide();
1282         } else {
1283                 m_settingsbar.show();
1284                 m_rarecontrolsbar.show();
1285         }
1286 }
1287
1288 void TouchScreenGUI::hide()
1289 {
1290         if (!m_visible)
1291                 return;
1292
1293         Toggle(false);
1294 }
1295
1296 void TouchScreenGUI::show()
1297 {
1298         if (m_visible)
1299                 return;
1300
1301         Toggle(true);
1302 }