src/touchscreengui.cpp

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