src/gui/touchscreengui.cpp

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