src/guiFormSpecMenu.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20
  21 #include <cstdlib>
  22 #include <algorithm>
  23 #include <iterator>
  24 #include <sstream>
  25 #include <limits>
  26 #include "guiFormSpecMenu.h"
  27 #include "guiTable.h"
  28 #include "constants.h"
  29 #include "gamedef.h"
  30 #include "keycode.h"
  31 #include "strfnd.h"
  32 #include <IGUICheckBox.h>
  33 #include <IGUIEditBox.h>
  34 #include <IGUIButton.h>
  35 #include <IGUIStaticText.h>
  36 #include <IGUIFont.h>
  37 #include <IGUITabControl.h>
  38 #include <IGUIComboBox.h>
  39 #include "log.h"
  40 #include "tile.h" // ITextureSource
  41 #include "hud.h" // drawItemStack
  42 #include "hex.h"
  43 #include "util/string.h"
  44 #include "util/numeric.h"
  45 #include "filesys.h"
  46 #include "gettime.h"
  47 #include "gettext.h"
  48 #include "scripting_game.h"
  49 #include "porting.h"
  50 #include "main.h"
  51 #include "settings.h"
  52 #include "client.h"
  53 #include "util/string.h" // for parseColorString()
  54
  55 #define MY_CHECKPOS(a,b)                                                                                                        \
  56         if (v_pos.size() != 2) {                                                                                                \
  57                 errorstream<< "Invalid pos for element " << a << "specified: \""        \
  58                         << parts[b] << "\"" << std::endl;                                                               \
  59                         return;                                                                                                                 \
  60         }
  61
  62 #define MY_CHECKGEOM(a,b)                                                                                                       \
  63         if (v_geom.size() != 2) {                                                                                               \
  64                 errorstream<< "Invalid pos for element " << a << "specified: \""        \
  65                         << parts[b] << "\"" << std::endl;                                                               \
  66                         return;                                                                                                                 \
  67         }
  68 /*
  69         GUIFormSpecMenu
  70 */
  71 GUIFormSpecMenu::GUIFormSpecMenu(irr::IrrlichtDevice* dev,
  72                 gui::IGUIElement* parent, s32 id, IMenuManager *menumgr,
  73                 InventoryManager *invmgr, IGameDef *gamedef,
  74                 ISimpleTextureSource *tsrc, IFormSource* fsrc, TextDest* tdst,
  75                 Client* client) :
  76         GUIModalMenu(dev->getGUIEnvironment(), parent, id, menumgr),
  77         m_device(dev),
  78         m_invmgr(invmgr),
  79         m_gamedef(gamedef),
  80         m_tsrc(tsrc),
  81         m_client(client),
  82         m_selected_item(NULL),
  83         m_selected_amount(0),
  84         m_selected_dragging(false),
  85         m_tooltip_element(NULL),
  86         m_old_tooltip_id(-1),
  87         m_allowclose(true),
  88         m_lock(false),
  89         m_form_src(fsrc),
  90         m_text_dst(tdst),
  91         m_font(dev->getGUIEnvironment()->getSkin()->getFont()),
  92         m_formspec_version(0)
  93 #ifdef __ANDROID__
  94         ,m_JavaDialogFieldName(L"")
  95 #endif
  96 {
  97         current_keys_pending.key_down = false;
  98         current_keys_pending.key_up = false;
  99         current_keys_pending.key_enter = false;
 100         current_keys_pending.key_escape = false;
 101
 102         m_doubleclickdetect[0].time = 0;
 103         m_doubleclickdetect[1].time = 0;
 104
 105         m_doubleclickdetect[0].pos = v2s32(0, 0);
 106         m_doubleclickdetect[1].pos = v2s32(0, 0);
 107
 108         m_tooltip_show_delay = (u32)g_settings->getS32("tooltip_show_delay");
 109
 110         m_btn_height = g_settings->getS32("font_size") +2;
 111         assert(m_btn_height > 0);
 112 }
 113
 114 GUIFormSpecMenu::~GUIFormSpecMenu()
 115 {
 116         removeChildren();
 117
 118         for (u32 i = 0; i < m_tables.size(); ++i) {
 119                 GUITable *table = m_tables[i].second;
 120                 table->drop();
 121         }
 122
 123         delete m_selected_item;
 124
 125         if (m_form_src != NULL) {
 126                 delete m_form_src;
 127         }
 128         if (m_text_dst != NULL) {
 129                 delete m_text_dst;
 130         }
 131 }
 132
 133 void GUIFormSpecMenu::removeChildren()
 134 {
 135         const core::list<gui::IGUIElement*> &children = getChildren();
 136
 137         while(!children.empty()) {
 138                 (*children.getLast())->remove();
 139         }
 140
 141         if(m_tooltip_element) {
 142                 m_tooltip_element->remove();
 143                 m_tooltip_element->drop();
 144                 m_tooltip_element = NULL;
 145         }
 146
 147 }
 148
 149 void GUIFormSpecMenu::setInitialFocus()
 150 {
 151         // Set initial focus according to following order of precedence:
 152         // 1. first empty editbox
 153         // 2. first editbox
 154         // 3. first table
 155         // 4. last button
 156         // 5. first focusable (not statictext, not tabheader)
 157         // 6. first child element
 158
 159         core::list<gui::IGUIElement*> children = getChildren();
 160
 161         // in case "children" contains any NULL elements, remove them
 162         for (core::list<gui::IGUIElement*>::Iterator it = children.begin();
 163                         it != children.end();) {
 164                 if (*it)
 165                         ++it;
 166                 else
 167                         it = children.erase(it);
 168         }
 169
 170         // 1. first empty editbox
 171         for (core::list<gui::IGUIElement*>::Iterator it = children.begin();
 172                         it != children.end(); ++it) {
 173                 if ((*it)->getType() == gui::EGUIET_EDIT_BOX
 174                                 && (*it)->getText()[0] == 0) {
 175                         Environment->setFocus(*it);
 176                         return;
 177                 }
 178         }
 179
 180         // 2. first editbox
 181         for (core::list<gui::IGUIElement*>::Iterator it = children.begin();
 182                         it != children.end(); ++it) {
 183                 if ((*it)->getType() == gui::EGUIET_EDIT_BOX) {
 184                         Environment->setFocus(*it);
 185                         return;
 186                 }
 187         }
 188
 189         // 3. first table
 190         for (core::list<gui::IGUIElement*>::Iterator it = children.begin();
 191                         it != children.end(); ++it) {
 192                 if ((*it)->getTypeName() == std::string("GUITable")) {
 193                         Environment->setFocus(*it);
 194                         return;
 195                 }
 196         }
 197
 198         // 4. last button
 199         for (core::list<gui::IGUIElement*>::Iterator it = children.getLast();
 200                         it != children.end(); --it) {
 201                 if ((*it)->getType() == gui::EGUIET_BUTTON) {
 202                         Environment->setFocus(*it);
 203                         return;
 204                 }
 205         }
 206
 207         // 5. first focusable (not statictext, not tabheader)
 208         for (core::list<gui::IGUIElement*>::Iterator it = children.begin();
 209                         it != children.end(); ++it) {
 210                 if ((*it)->getType() != gui::EGUIET_STATIC_TEXT &&
 211                                 (*it)->getType() != gui::EGUIET_TAB_CONTROL) {
 212                         Environment->setFocus(*it);
 213                         return;
 214                 }
 215         }
 216
 217         // 6. first child element
 218         if (children.empty())
 219                 Environment->setFocus(this);
 220         else
 221                 Environment->setFocus(*(children.begin()));
 222 }
 223
 224 GUITable* GUIFormSpecMenu::getTable(std::wstring tablename)
 225 {
 226         for (u32 i = 0; i < m_tables.size(); ++i) {
 227                 if (tablename == m_tables[i].first.fname)
 228                         return m_tables[i].second;
 229         }
 230         return 0;
 231 }
 232
 233 std::vector<std::string> split(const std::string &s, char delim) {
 234         std::vector<std::string> tokens;
 235
 236         std::string current = "";
 237         bool last_was_escape = false;
 238         for(unsigned int i=0; i < s.size(); i++) {
 239                 if (last_was_escape) {
 240                         current += '\\';
 241                         current += s.c_str()[i];
 242                         last_was_escape = false;
 243                 }
 244                 else {
 245                         if (s.c_str()[i] == delim) {
 246                                 tokens.push_back(current);
 247                                 current = "";
 248                                 last_was_escape = false;
 249                         }
 250                         else if (s.c_str()[i] == '\\'){
 251                                 last_was_escape = true;
 252                         }
 253                         else {
 254                                 current += s.c_str()[i];
 255                                 last_was_escape = false;
 256                         }
 257                 }
 258         }
 259         //push last element
 260         tokens.push_back(current);
 261
 262         return tokens;
 263 }
 264
 265 void GUIFormSpecMenu::parseSize(parserData* data,std::string element)
 266 {
 267         std::vector<std::string> parts = split(element,',');
 268
 269         if (((parts.size() == 2) || parts.size() == 3) ||
 270                 ((parts.size() > 3) && (m_formspec_version > FORMSPEC_API_VERSION)))
 271         {
 272                 v2f invsize;
 273
 274                 if (parts[1].find(';') != std::string::npos)
 275                         parts[1] = parts[1].substr(0,parts[1].find(';'));
 276
 277                 invsize.X = stof(parts[0]);
 278                 invsize.Y = stof(parts[1]);
 279
 280                 lockSize(false);
 281                 if (parts.size() == 3) {
 282                         if (parts[2] == "true") {
 283                                 lockSize(true,v2u32(800,600));
 284                         }
 285                 }
 286
 287                 double cur_scaling = porting::getDisplayDensity() *
 288                                 g_settings->getFloat("gui_scaling");
 289
 290                 if (m_lock) {
 291                         v2u32 current_screensize = m_device->getVideoDriver()->getScreenSize();
 292                         v2u32 delta = current_screensize - m_lockscreensize;
 293
 294                         if (current_screensize.Y > m_lockscreensize.Y)
 295                                 delta.Y /= 2;
 296                         else
 297                                 delta.Y = 0;
 298
 299                         if (current_screensize.X > m_lockscreensize.X)
 300                                 delta.X /= 2;
 301                         else
 302                                 delta.X = 0;
 303
 304                         offset = v2s32(delta.X,delta.Y);
 305
 306                         data->screensize = m_lockscreensize;
 307
 308                         // fixed scaling for fixed size gui elements */
 309                         cur_scaling = LEGACY_SCALING;
 310                 }
 311                 else {
 312                         offset = v2s32(0,0);
 313                 }
 314
 315                 /* adjust image size to dpi */
 316                 int y_partition = 15;
 317                 imgsize = v2s32(data->screensize.Y/y_partition, data->screensize.Y/y_partition);
 318                 int min_imgsize = DEFAULT_IMGSIZE * cur_scaling;
 319                 while ((min_imgsize > imgsize.Y) && (y_partition > 1)) {
 320                         y_partition--;
 321                         imgsize = v2s32(data->screensize.Y/y_partition, data->screensize.Y/y_partition);
 322                 }
 323                 assert(y_partition > 0);
 324
 325                 /* adjust spacing to dpi */
 326                 spacing = v2s32(imgsize.X+(DEFAULT_XSPACING * cur_scaling),
 327                                 imgsize.Y+(DEFAULT_YSPACING * cur_scaling));
 328
 329                 padding = v2s32(data->screensize.Y/imgsize.Y, data->screensize.Y/imgsize.Y);
 330
 331                 /* adjust padding to dpi */
 332                 padding = v2s32(
 333                                 (padding.X/(2.0/3.0)) * cur_scaling,
 334                                 (padding.X/(2.0/3.0)) * cur_scaling
 335                                 );
 336                 data->size = v2s32(
 337                         padding.X*2+spacing.X*(invsize.X-1.0)+imgsize.X,
 338                         padding.Y*2+spacing.Y*(invsize.Y-1.0)+imgsize.Y + m_btn_height - 5
 339                 );
 340                 data->rect = core::rect<s32>(
 341                                 data->screensize.X/2 - data->size.X/2 + offset.X,
 342                                 data->screensize.Y/2 - data->size.Y/2 + offset.Y,
 343                                 data->screensize.X/2 + data->size.X/2 + offset.X,
 344                                 data->screensize.Y/2 + data->size.Y/2 + offset.Y
 345                 );
 346
 347                 DesiredRect = data->rect;
 348                 recalculateAbsolutePosition(false);
 349                 data->basepos = getBasePos();
 350                 data->bp_set = 2;
 351                 return;
 352         }
 353         errorstream<< "Invalid size element (" << parts.size() << "): '" << element << "'"  << std::endl;
 354 }
 355
 356 void GUIFormSpecMenu::parseList(parserData* data,std::string element)
 357 {
 358         if (m_gamedef == 0) {
 359                 errorstream<<"WARNING: invalid use of 'list' with m_gamedef==0"<<std::endl;
 360                 return;
 361         }
 362
 363         std::vector<std::string> parts = split(element,';');
 364
 365         if (((parts.size() == 4) || (parts.size() == 5)) ||
 366                 ((parts.size() > 5) && (m_formspec_version > FORMSPEC_API_VERSION)))
 367         {
 368                 std::string location = parts[0];
 369                 std::string listname = parts[1];
 370                 std::vector<std::string> v_pos  = split(parts[2],',');
 371                 std::vector<std::string> v_geom = split(parts[3],',');
 372                 std::string startindex = "";
 373                 if (parts.size() == 5)
 374                         startindex = parts[4];
 375
 376                 MY_CHECKPOS("list",2);
 377                 MY_CHECKGEOM("list",3);
 378
 379                 InventoryLocation loc;
 380
 381                 if(location == "context" || location == "current_name")
 382                         loc = m_current_inventory_location;
 383                 else
 384                         loc.deSerialize(location);
 385
 386                 v2s32 pos = padding + AbsoluteRect.UpperLeftCorner;
 387                 pos.X += stof(v_pos[0]) * (float)spacing.X;
 388                 pos.Y += stof(v_pos[1]) * (float)spacing.Y;
 389
 390                 v2s32 geom;
 391                 geom.X = stoi(v_geom[0]);
 392                 geom.Y = stoi(v_geom[1]);
 393
 394                 s32 start_i = 0;
 395                 if(startindex != "")
 396                         start_i = stoi(startindex);
 397
 398                 if (geom.X < 0 || geom.Y < 0 || start_i < 0) {
 399                         errorstream<< "Invalid list element: '" << element << "'"  << std::endl;
 400                         return;
 401                 }
 402
 403                 if(data->bp_set != 2)
 404                         errorstream<<"WARNING: invalid use of list without a size[] element"<<std::endl;
 405                 m_inventorylists.push_back(ListDrawSpec(loc, listname, pos, geom, start_i));
 406                 return;
 407         }
 408         errorstream<< "Invalid list element(" << parts.size() << "): '" << element << "'"  << std::endl;
 409 }
 410
 411 void GUIFormSpecMenu::parseCheckbox(parserData* data,std::string element)
 412 {
 413         std::vector<std::string> parts = split(element,';');
 414
 415         if (((parts.size() >= 3) || (parts.size() <= 4)) ||
 416                 ((parts.size() > 4) && (m_formspec_version > FORMSPEC_API_VERSION)))
 417         {
 418                 std::vector<std::string> v_pos = split(parts[0],',');
 419                 std::string name = parts[1];
 420                 std::string label = parts[2];
 421                 std::string selected = "";
 422
 423                 if (parts.size() >= 4)
 424                         selected = parts[3];
 425
 426                 MY_CHECKPOS("checkbox",0);
 427
 428                 v2s32 pos = padding;
 429                 pos.X += stof(v_pos[0]) * (float) spacing.X;
 430                 pos.Y += stof(v_pos[1]) * (float) spacing.Y;
 431
 432                 bool fselected = false;
 433
 434                 if (selected == "true")
 435                         fselected = true;
 436
 437                 std::wstring wlabel = narrow_to_wide(label.c_str());
 438
 439                 core::rect<s32> rect = core::rect<s32>(
 440                                 pos.X, pos.Y + ((imgsize.Y/2) - m_btn_height),
 441                                 pos.X + m_font->getDimension(wlabel.c_str()).Width + 25, // text size + size of checkbox
 442                                 pos.Y + ((imgsize.Y/2) + m_btn_height));
 443
 444                 FieldSpec spec(
 445                                 narrow_to_wide(name.c_str()),
 446                                 wlabel, //Needed for displaying text on MSVC
 447                                 wlabel,
 448                                 258+m_fields.size()
 449                         );
 450
 451                 spec.ftype = f_CheckBox;
 452
 453                 gui::IGUICheckBox* e = Environment->addCheckBox(fselected, rect, this,
 454                                         spec.fid, spec.flabel.c_str());
 455
 456                 if (spec.fname == data->focused_fieldname) {
 457                         Environment->setFocus(e);
 458                 }
 459
 460                 m_checkboxes.push_back(std::pair<FieldSpec,gui::IGUICheckBox*>(spec,e));
 461                 m_fields.push_back(spec);
 462                 return;
 463         }
 464         errorstream<< "Invalid checkbox element(" << parts.size() << "): '" << element << "'"  << std::endl;
 465 }
 466
 467 void GUIFormSpecMenu::parseScrollBar(parserData* data, std::string element)
 468 {
 469         std::vector<std::string> parts = split(element,';');
 470
 471         if (parts.size() >= 5) {
 472                 std::vector<std::string> v_pos = split(parts[0],',');
 473                 std::vector<std::string> v_dim = split(parts[1],',');
 474                 std::string name = parts[2];
 475                 std::string value = parts[4];
 476
 477                 MY_CHECKPOS("scrollbar",0);
 478
 479                 v2s32 pos = padding;
 480                 pos.X += stof(v_pos[0]) * (float) spacing.X;
 481                 pos.Y += stof(v_pos[1]) * (float) spacing.Y;
 482
 483                 if (v_dim.size() != 2) {
 484                         errorstream<< "Invalid size for element " << "scrollbar"
 485                                 << "specified: \"" << parts[1] << "\"" << std::endl;
 486                         return;
 487                 }
 488
 489                 v2s32 dim;
 490                 dim.X = stof(v_dim[0]) * (float) spacing.X;
 491                 dim.Y = stof(v_dim[1]) * (float) spacing.Y;
 492
 493                 core::rect<s32> rect =
 494                                 core::rect<s32>(pos.X, pos.Y, pos.X + dim.X, pos.Y + dim.Y);
 495
 496                 FieldSpec spec(
 497                                 narrow_to_wide(name.c_str()),
 498                                 L"",
 499                                 L"",
 500                                 258+m_fields.size()
 501                         );
 502
 503                 bool is_horizontal = true;
 504
 505                 if (parts[2] == "vertical")
 506                         is_horizontal = false;
 507
 508                 spec.ftype = f_ScrollBar;
 509                 spec.send  = true;
 510                 gui::IGUIScrollBar* e =
 511                                 Environment->addScrollBar(is_horizontal,rect,this,spec.fid);
 512
 513                 e->setMax(1000);
 514                 e->setMin(0);
 515                 e->setPos(stoi(parts[4]));
 516                 e->setSmallStep(10);
 517                 e->setLargeStep(100);
 518
 519                 if (!m_lock) {
 520                         core::rect<s32> relative_rect = e->getRelativePosition();
 521
 522                         if (!is_horizontal) {
 523                                 s32 original_width = relative_rect.getWidth();
 524                                 s32 width = (original_width/(2.0/3.0))
 525                                                 * porting::getDisplayDensity()
 526                                                 * g_settings->getFloat("gui_scaling");
 527                                 e->setRelativePosition(core::rect<s32>(
 528                                                 relative_rect.UpperLeftCorner.X,
 529                                                 relative_rect.UpperLeftCorner.Y,
 530                                                 relative_rect.LowerRightCorner.X + (width - original_width),
 531                                                 relative_rect.LowerRightCorner.Y
 532                                         ));
 533                         }
 534                         else  {
 535                                 s32 original_height = relative_rect.getHeight();
 536                                 s32 height = (original_height/(2.0/3.0))
 537                                                 * porting::getDisplayDensity()
 538                                                 * g_settings->getFloat("gui_scaling");
 539                                 e->setRelativePosition(core::rect<s32>(
 540                                                 relative_rect.UpperLeftCorner.X,
 541                                                 relative_rect.UpperLeftCorner.Y,
 542                                                 relative_rect.LowerRightCorner.X,
 543                                                 relative_rect.LowerRightCorner.Y + (height - original_height)
 544                                         ));
 545                         }
 546                 }
 547
 548                 m_scrollbars.push_back(std::pair<FieldSpec,gui::IGUIScrollBar*>(spec,e));
 549                 m_fields.push_back(spec);
 550                 return;
 551         }
 552         errorstream<< "Invalid scrollbar element(" << parts.size() << "): '" << element << "'"  << std::endl;
 553 }
 554
 555 void GUIFormSpecMenu::parseImage(parserData* data,std::string element)
 556 {
 557         std::vector<std::string> parts = split(element,';');
 558
 559         if ((parts.size() == 3) ||
 560                 ((parts.size() > 3) && (m_formspec_version > FORMSPEC_API_VERSION)))
 561         {
 562                 std::vector<std::string> v_pos = split(parts[0],',');
 563                 std::vector<std::string> v_geom = split(parts[1],',');
 564                 std::string name = unescape_string(parts[2]);
 565
 566                 MY_CHECKPOS("image",0);
 567                 MY_CHECKGEOM("image",1);
 568
 569                 v2s32 pos = padding + AbsoluteRect.UpperLeftCorner;
 570                 pos.X += stof(v_pos[0]) * (float) spacing.X;
 571                 pos.Y += stof(v_pos[1]) * (float) spacing.Y;
 572
 573                 v2s32 geom;
 574                 geom.X = stof(v_geom[0]) * (float)imgsize.X;
 575                 geom.Y = stof(v_geom[1]) * (float)imgsize.Y;
 576
 577                 if(data->bp_set != 2)
 578                         errorstream<<"WARNING: invalid use of image without a size[] element"<<std::endl;
 579                 m_images.push_back(ImageDrawSpec(name, pos, geom));
 580                 return;
 581         }
 582
 583         if (parts.size() == 2) {
 584                 std::vector<std::string> v_pos = split(parts[0],',');
 585                 std::string name = unescape_string(parts[1]);
 586
 587                 MY_CHECKPOS("image",0);
 588
 589                 v2s32 pos = padding + AbsoluteRect.UpperLeftCorner;
 590                 pos.X += stof(v_pos[0]) * (float) spacing.X;
 591                 pos.Y += stof(v_pos[1]) * (float) spacing.Y;
 592
 593                 if(data->bp_set != 2)
 594                         errorstream<<"WARNING: invalid use of image without a size[] element"<<std::endl;
 595                 m_images.push_back(ImageDrawSpec(name, pos));
 596                 return;
 597         }
 598         errorstream<< "Invalid image element(" << parts.size() << "): '" << element << "'"  << std::endl;
 599 }
 600
 601 void GUIFormSpecMenu::parseItemImage(parserData* data,std::string element)
 602 {
 603         std::vector<std::string> parts = split(element,';');
 604
 605         if ((parts.size() == 3) ||
 606                 ((parts.size() > 3) && (m_formspec_version > FORMSPEC_API_VERSION)))
 607         {
 608                 std::vector<std::string> v_pos = split(parts[0],',');
 609                 std::vector<std::string> v_geom = split(parts[1],',');
 610                 std::string name = parts[2];
 611
 612                 MY_CHECKPOS("itemimage",0);
 613                 MY_CHECKGEOM("itemimage",1);
 614
 615                 v2s32 pos = padding + AbsoluteRect.UpperLeftCorner;
 616                 pos.X += stof(v_pos[0]) * (float) spacing.X;
 617                 pos.Y += stof(v_pos[1]) * (float) spacing.Y;
 618
 619                 v2s32 geom;
 620                 geom.X = stof(v_geom[0]) * (float)imgsize.X;
 621                 geom.Y = stof(v_geom[1]) * (float)imgsize.Y;
 622
 623                 if(data->bp_set != 2)
 624                         errorstream<<"WARNING: invalid use of item_image without a size[] element"<<std::endl;
 625                 m_itemimages.push_back(ImageDrawSpec(name, pos, geom));
 626                 return;
 627         }
 628         errorstream<< "Invalid ItemImage element(" << parts.size() << "): '" << element << "'"  << std::endl;
 629 }
 630
 631 void GUIFormSpecMenu::parseButton(parserData* data,std::string element,
 632                 std::string type)
 633 {
 634         std::vector<std::string> parts = split(element,';');
 635
 636         if ((parts.size() == 4) ||
 637                 ((parts.size() > 4) && (m_formspec_version > FORMSPEC_API_VERSION)))
 638         {
 639                 std::vector<std::string> v_pos = split(parts[0],',');
 640                 std::vector<std::string> v_geom = split(parts[1],',');
 641                 std::string name = parts[2];
 642                 std::string label = parts[3];
 643
 644                 MY_CHECKPOS("button",0);
 645                 MY_CHECKGEOM("button",1);
 646
 647                 v2s32 pos = padding;
 648                 pos.X += stof(v_pos[0]) * (float)spacing.X;
 649                 pos.Y += stof(v_pos[1]) * (float)spacing.Y;
 650
 651                 v2s32 geom;
 652                 geom.X = (stof(v_geom[0]) * (float)spacing.X)-(spacing.X-imgsize.X);
 653                 pos.Y += (stof(v_geom[1]) * (float)imgsize.Y)/2;
 654
 655                 core::rect<s32> rect =
 656                                 core::rect<s32>(pos.X, pos.Y - m_btn_height,
 657                                                 pos.X + geom.X, pos.Y + m_btn_height);
 658
 659                 if(data->bp_set != 2)
 660                         errorstream<<"WARNING: invalid use of button without a size[] element"<<std::endl;
 661
 662                 label = unescape_string(label);
 663
 664                 std::wstring wlabel = narrow_to_wide(label.c_str());
 665
 666                 FieldSpec spec(
 667                         narrow_to_wide(name.c_str()),
 668                         wlabel,
 669                         L"",
 670                         258+m_fields.size()
 671                 );
 672                 spec.ftype = f_Button;
 673                 if(type == "button_exit")
 674                         spec.is_exit = true;
 675                 gui::IGUIButton* e = Environment->addButton(rect, this, spec.fid,
 676                                 spec.flabel.c_str());
 677
 678                 if (spec.fname == data->focused_fieldname) {
 679                         Environment->setFocus(e);
 680                 }
 681
 682                 m_fields.push_back(spec);
 683                 return;
 684         }
 685         errorstream<< "Invalid button element(" << parts.size() << "): '" << element << "'"  << std::endl;
 686 }
 687
 688 void GUIFormSpecMenu::parseBackground(parserData* data,std::string element)
 689 {
 690         std::vector<std::string> parts = split(element,';');
 691
 692         if (((parts.size() == 3) || (parts.size() == 4)) ||
 693                 ((parts.size() > 4) && (m_formspec_version > FORMSPEC_API_VERSION)))
 694         {
 695                 std::vector<std::string> v_pos = split(parts[0],',');
 696                 std::vector<std::string> v_geom = split(parts[1],',');
 697                 std::string name = unescape_string(parts[2]);
 698
 699                 MY_CHECKPOS("background",0);
 700                 MY_CHECKGEOM("background",1);
 701
 702                 v2s32 pos = padding + AbsoluteRect.UpperLeftCorner;
 703                 pos.X += stof(v_pos[0]) * (float)spacing.X - ((float)spacing.X-(float)imgsize.X)/2;
 704                 pos.Y += stof(v_pos[1]) * (float)spacing.Y - ((float)spacing.Y-(float)imgsize.Y)/2;
 705
 706                 v2s32 geom;
 707                 geom.X = stof(v_geom[0]) * (float)spacing.X;
 708                 geom.Y = stof(v_geom[1]) * (float)spacing.Y;
 709
 710                 if (parts.size() == 4) {
 711                         m_clipbackground = is_yes(parts[3]);
 712                         if (m_clipbackground) {
 713                                 pos.X = stoi(v_pos[0]); //acts as offset
 714                                 pos.Y = stoi(v_pos[1]); //acts as offset
 715                         }
 716                 }
 717
 718                 if(data->bp_set != 2)
 719                         errorstream<<"WARNING: invalid use of background without a size[] element"<<std::endl;
 720                 m_backgrounds.push_back(ImageDrawSpec(name, pos, geom));
 721                 return;
 722         }
 723         errorstream<< "Invalid background element(" << parts.size() << "): '" << element << "'"  << std::endl;
 724 }
 725
 726 void GUIFormSpecMenu::parseTableOptions(parserData* data,std::string element)
 727 {
 728         std::vector<std::string> parts = split(element,';');
 729
 730         data->table_options.clear();
 731         for (size_t i = 0; i < parts.size(); ++i) {
 732                 // Parse table option
 733                 std::string opt = unescape_string(parts[i]);
 734                 data->table_options.push_back(GUITable::splitOption(opt));
 735         }
 736 }
 737
 738 void GUIFormSpecMenu::parseTableColumns(parserData* data,std::string element)
 739 {
 740         std::vector<std::string> parts = split(element,';');
 741
 742         data->table_columns.clear();
 743         for (size_t i = 0; i < parts.size(); ++i) {
 744                 std::vector<std::string> col_parts = split(parts[i],',');
 745                 GUITable::TableColumn column;
 746                 // Parse column type
 747                 if (!col_parts.empty())
 748                         column.type = col_parts[0];
 749                 // Parse column options
 750                 for (size_t j = 1; j < col_parts.size(); ++j) {
 751                         std::string opt = unescape_string(col_parts[j]);
 752                         column.options.push_back(GUITable::splitOption(opt));
 753                 }
 754                 data->table_columns.push_back(column);
 755         }
 756 }
 757
 758 void GUIFormSpecMenu::parseTable(parserData* data,std::string element)
 759 {
 760         std::vector<std::string> parts = split(element,';');
 761
 762         if (((parts.size() == 4) || (parts.size() == 5)) ||
 763                 ((parts.size() > 5) && (m_formspec_version > FORMSPEC_API_VERSION)))
 764         {
 765                 std::vector<std::string> v_pos = split(parts[0],',');
 766                 std::vector<std::string> v_geom = split(parts[1],',');
 767                 std::string name = parts[2];
 768                 std::vector<std::string> items = split(parts[3],',');
 769                 std::string str_initial_selection = "";
 770                 std::string str_transparent = "false";
 771
 772                 if (parts.size() >= 5)
 773                         str_initial_selection = parts[4];
 774
 775                 MY_CHECKPOS("table",0);
 776                 MY_CHECKGEOM("table",1);
 777
 778                 v2s32 pos = padding;
 779                 pos.X += stof(v_pos[0]) * (float)spacing.X;
 780                 pos.Y += stof(v_pos[1]) * (float)spacing.Y;
 781
 782                 v2s32 geom;
 783                 geom.X = stof(v_geom[0]) * (float)spacing.X;
 784                 geom.Y = stof(v_geom[1]) * (float)spacing.Y;
 785
 786
 787                 core::rect<s32> rect = core::rect<s32>(pos.X, pos.Y, pos.X+geom.X, pos.Y+geom.Y);
 788
 789                 std::wstring fname_w = narrow_to_wide(name.c_str());
 790
 791                 FieldSpec spec(
 792                         fname_w,
 793                         L"",
 794                         L"",
 795                         258+m_fields.size()
 796                 );
 797
 798                 spec.ftype = f_Table;
 799
 800                 for (unsigned int i = 0; i < items.size(); ++i) {
 801                         items[i] = unescape_string(items[i]);
 802                 }
 803
 804                 //now really show table
 805                 GUITable *e = new GUITable(Environment, this, spec.fid, rect,
 806                                 m_tsrc);
 807
 808                 if (spec.fname == data->focused_fieldname) {
 809                         Environment->setFocus(e);
 810                 }
 811
 812                 e->setTable(data->table_options, data->table_columns, items);
 813
 814                 if (data->table_dyndata.find(fname_w) != data->table_dyndata.end()) {
 815                         e->setDynamicData(data->table_dyndata[fname_w]);
 816                 }
 817
 818                 if ((str_initial_selection != "") &&
 819                                 (str_initial_selection != "0"))
 820                         e->setSelected(stoi(str_initial_selection.c_str()));
 821
 822                 m_tables.push_back(std::pair<FieldSpec,GUITable*>(spec, e));
 823                 m_fields.push_back(spec);
 824                 return;
 825         }
 826         errorstream<< "Invalid table element(" << parts.size() << "): '" << element << "'"  << std::endl;
 827 }
 828
 829 void GUIFormSpecMenu::parseTextList(parserData* data,std::string element)
 830 {
 831         std::vector<std::string> parts = split(element,';');
 832
 833         if (((parts.size() == 4) || (parts.size() == 5) || (parts.size() == 6)) ||
 834                 ((parts.size() > 6) && (m_formspec_version > FORMSPEC_API_VERSION)))
 835         {
 836                 std::vector<std::string> v_pos = split(parts[0],',');
 837                 std::vector<std::string> v_geom = split(parts[1],',');
 838                 std::string name = parts[2];
 839                 std::vector<std::string> items = split(parts[3],',');
 840                 std::string str_initial_selection = "";
 841                 std::string str_transparent = "false";
 842
 843                 if (parts.size() >= 5)
 844                         str_initial_selection = parts[4];
 845
 846                 if (parts.size() >= 6)
 847                         str_transparent = parts[5];
 848
 849                 MY_CHECKPOS("textlist",0);
 850                 MY_CHECKGEOM("textlist",1);
 851
 852                 v2s32 pos = padding;
 853                 pos.X += stof(v_pos[0]) * (float)spacing.X;
 854                 pos.Y += stof(v_pos[1]) * (float)spacing.Y;
 855
 856                 v2s32 geom;
 857                 geom.X = stof(v_geom[0]) * (float)spacing.X;
 858                 geom.Y = stof(v_geom[1]) * (float)spacing.Y;
 859
 860
 861                 core::rect<s32> rect = core::rect<s32>(pos.X, pos.Y, pos.X+geom.X, pos.Y+geom.Y);
 862
 863                 std::wstring fname_w = narrow_to_wide(name.c_str());
 864
 865                 FieldSpec spec(
 866                         fname_w,
 867                         L"",
 868                         L"",
 869                         258+m_fields.size()
 870                 );
 871
 872                 spec.ftype = f_Table;
 873
 874                 for (unsigned int i = 0; i < items.size(); ++i) {
 875                         items[i] = unescape_string(items[i]);
 876                 }
 877
 878                 //now really show list
 879                 GUITable *e = new GUITable(Environment, this, spec.fid, rect,
 880                                 m_tsrc);
 881
 882                 if (spec.fname == data->focused_fieldname) {
 883                         Environment->setFocus(e);
 884                 }
 885
 886                 e->setTextList(items, is_yes(str_transparent));
 887
 888                 if (data->table_dyndata.find(fname_w) != data->table_dyndata.end()) {
 889                         e->setDynamicData(data->table_dyndata[fname_w]);
 890                 }
 891
 892                 if ((str_initial_selection != "") &&
 893                                 (str_initial_selection != "0"))
 894                         e->setSelected(stoi(str_initial_selection.c_str()));
 895
 896                 m_tables.push_back(std::pair<FieldSpec,GUITable*>(spec, e));
 897                 m_fields.push_back(spec);
 898                 return;
 899         }
 900         errorstream<< "Invalid textlist element(" << parts.size() << "): '" << element << "'"  << std::endl;
 901 }
 902
 903
 904 void GUIFormSpecMenu::parseDropDown(parserData* data,std::string element)
 905 {
 906         std::vector<std::string> parts = split(element,';');
 907
 908         if ((parts.size() == 5) ||
 909                 ((parts.size() > 5) && (m_formspec_version > FORMSPEC_API_VERSION)))
 910         {
 911                 std::vector<std::string> v_pos = split(parts[0],',');
 912                 std::string name = parts[2];
 913                 std::vector<std::string> items = split(parts[3],',');
 914                 std::string str_initial_selection = "";
 915                 str_initial_selection = parts[4];
 916
 917                 MY_CHECKPOS("dropdown",0);
 918
 919                 v2s32 pos = padding;
 920                 pos.X += stof(v_pos[0]) * (float)spacing.X;
 921                 pos.Y += stof(v_pos[1]) * (float)spacing.Y;
 922
 923                 s32 width = stof(parts[1]) * (float)spacing.Y;
 924
 925                 core::rect<s32> rect = core::rect<s32>(pos.X, pos.Y,
 926                                 pos.X + width, pos.Y + (m_btn_height * 2));
 927
 928                 std::wstring fname_w = narrow_to_wide(name.c_str());
 929
 930                 FieldSpec spec(
 931                         fname_w,
 932                         L"",
 933                         L"",
 934                         258+m_fields.size()
 935                 );
 936
 937                 spec.ftype = f_DropDown;
 938                 spec.send = true;
 939
 940                 //now really show list
 941                 gui::IGUIComboBox *e = Environment->addComboBox(rect, this,spec.fid);
 942
 943                 if (spec.fname == data->focused_fieldname) {
 944                         Environment->setFocus(e);
 945                 }
 946
 947                 for (unsigned int i=0; i < items.size(); i++) {
 948                         e->addItem(narrow_to_wide(items[i]).c_str());
 949                 }
 950
 951                 if (str_initial_selection != "")
 952                         e->setSelected(stoi(str_initial_selection.c_str())-1);
 953
 954                 m_fields.push_back(spec);
 955                 return;
 956         }
 957         errorstream << "Invalid dropdown element(" << parts.size() << "): '"
 958                                 << element << "'"  << std::endl;
 959 }
 960
 961 void GUIFormSpecMenu::parsePwdField(parserData* data,std::string element)
 962 {
 963         std::vector<std::string> parts = split(element,';');
 964
 965         if ((parts.size() == 4) ||
 966                 ((parts.size() > 4) && (m_formspec_version > FORMSPEC_API_VERSION)))
 967         {
 968                 std::vector<std::string> v_pos = split(parts[0],',');
 969                 std::vector<std::string> v_geom = split(parts[1],',');
 970                 std::string name = parts[2];
 971                 std::string label = parts[3];
 972
 973                 MY_CHECKPOS("pwdfield",0);
 974                 MY_CHECKGEOM("pwdfield",1);
 975
 976                 v2s32 pos;
 977                 pos.X += stof(v_pos[0]) * (float)spacing.X;
 978                 pos.Y += stof(v_pos[1]) * (float)spacing.Y;
 979
 980                 v2s32 geom;
 981                 geom.X = (stof(v_geom[0]) * (float)spacing.X)-(spacing.X-imgsize.X);
 982
 983                 pos.Y += (stof(v_geom[1]) * (float)imgsize.Y)/2;
 984                 pos.Y -= m_btn_height;
 985                 geom.Y = m_btn_height*2;
 986
 987                 core::rect<s32> rect = core::rect<s32>(pos.X, pos.Y, pos.X+geom.X, pos.Y+geom.Y);
 988
 989                 label = unescape_string(label);
 990
 991                 std::wstring wlabel = narrow_to_wide(label.c_str());
 992
 993                 FieldSpec spec(
 994                         narrow_to_wide(name.c_str()),
 995                         wlabel,
 996                         L"",
 997                         258+m_fields.size()
 998                         );
 999
1000                 spec.send = true;
1001                 gui::IGUIEditBox * e = Environment->addEditBox(0, rect, true, this, spec.fid);
1002
1003                 if (spec.fname == data->focused_fieldname) {
1004                         Environment->setFocus(e);
1005                 }
1006
1007                 if (label.length() >= 1)
1008                 {
1009                         rect.UpperLeftCorner.Y -= m_btn_height;
1010                         rect.LowerRightCorner.Y = rect.UpperLeftCorner.Y + m_btn_height;
1011                         Environment->addStaticText(spec.flabel.c_str(), rect, false, true, this, 0);
1012                 }
1013
1014                 e->setPasswordBox(true,L'*');
1015
1016                 irr::SEvent evt;
1017                 evt.EventType            = EET_KEY_INPUT_EVENT;
1018                 evt.KeyInput.Key         = KEY_END;
1019                 evt.KeyInput.Char        = 0;
1020                 evt.KeyInput.Control     = 0;
1021                 evt.KeyInput.Shift       = 0;
1022                 evt.KeyInput.PressedDown = true;
1023                 e->OnEvent(evt);
1024                 m_fields.push_back(spec);
1025                 return;
1026         }
1027         errorstream<< "Invalid pwdfield element(" << parts.size() << "): '" << element << "'"  << std::endl;
1028 }
1029
1030 void GUIFormSpecMenu::parseSimpleField(parserData* data,
1031                 std::vector<std::string> &parts)
1032 {
1033         std::string name = parts[0];
1034         std::string label = parts[1];
1035         std::string default_val = parts[2];
1036
1037         core::rect<s32> rect;
1038
1039         if(!data->bp_set)
1040         {
1041                 rect = core::rect<s32>(
1042                         data->screensize.X/2 - 580/2,
1043                         data->screensize.Y/2 - 300/2,
1044                         data->screensize.X/2 + 580/2,
1045                         data->screensize.Y/2 + 300/2
1046                 );
1047                 DesiredRect = rect;
1048                 recalculateAbsolutePosition(false);
1049                 data->basepos = getBasePos();
1050                 data->bp_set = 1;
1051         }
1052         else if(data->bp_set == 2)
1053                 errorstream<<"WARNING: invalid use of unpositioned \"field\" in inventory"<<std::endl;
1054
1055         v2s32 pos = padding + AbsoluteRect.UpperLeftCorner;
1056         pos.Y = ((m_fields.size()+2)*60);
1057         v2s32 size = DesiredRect.getSize();
1058
1059         rect = core::rect<s32>(size.X / 2 - 150, pos.Y,
1060                         (size.X / 2 - 150) + 300, pos.Y + (m_btn_height*2));
1061
1062
1063         if(m_form_src)
1064                 default_val = m_form_src->resolveText(default_val);
1065
1066         default_val = unescape_string(default_val);
1067         label = unescape_string(label);
1068
1069         std::wstring wlabel = narrow_to_wide(label.c_str());
1070
1071         FieldSpec spec(
1072                 narrow_to_wide(name.c_str()),
1073                 wlabel,
1074                 narrow_to_wide(default_val.c_str()),
1075                 258+m_fields.size()
1076         );
1077
1078         if (name == "")
1079         {
1080                 // spec field id to 0, this stops submit searching for a value that isn't there
1081                 Environment->addStaticText(spec.flabel.c_str(), rect, false, true, this, spec.fid);
1082         }
1083         else
1084         {
1085                 spec.send = true;
1086                 gui::IGUIEditBox *e =
1087                         Environment->addEditBox(spec.fdefault.c_str(), rect, true, this, spec.fid);
1088
1089                 if (spec.fname == data->focused_fieldname) {
1090                         Environment->setFocus(e);
1091                 }
1092
1093                 irr::SEvent evt;
1094                 evt.EventType            = EET_KEY_INPUT_EVENT;
1095                 evt.KeyInput.Key         = KEY_END;
1096                 evt.KeyInput.Char        = 0;
1097                 evt.KeyInput.Control     = 0;
1098                 evt.KeyInput.Shift       = 0;
1099                 evt.KeyInput.PressedDown = true;
1100                 e->OnEvent(evt);
1101
1102                 if (label.length() >= 1)
1103                 {
1104                         rect.UpperLeftCorner.Y -= m_btn_height;
1105                         rect.LowerRightCorner.Y = rect.UpperLeftCorner.Y + m_btn_height;
1106                         Environment->addStaticText(spec.flabel.c_str(), rect, false, true, this, 0);
1107                 }
1108         }
1109
1110         m_fields.push_back(spec);
1111 }
1112
1113 void GUIFormSpecMenu::parseTextArea(parserData* data,
1114                 std::vector<std::string>& parts,std::string type)
1115 {
1116
1117         std::vector<std::string> v_pos = split(parts[0],',');
1118         std::vector<std::string> v_geom = split(parts[1],',');
1119         std::string name = parts[2];
1120         std::string label = parts[3];
1121         std::string default_val = parts[4];
1122
1123         MY_CHECKPOS(type,0);
1124         MY_CHECKGEOM(type,1);
1125
1126         v2s32 pos;
1127         pos.X = stof(v_pos[0]) * (float) spacing.X;
1128         pos.Y = stof(v_pos[1]) * (float) spacing.Y;
1129
1130         v2s32 geom;
1131
1132         geom.X = (stof(v_geom[0]) * (float)spacing.X)-(spacing.X-imgsize.X);
1133
1134         if (type == "textarea")
1135         {
1136                 geom.Y = (stof(v_geom[1]) * (float)imgsize.Y) - (spacing.Y-imgsize.Y);
1137                 pos.Y += m_btn_height;
1138         }
1139         else
1140         {
1141                 pos.Y += (stof(v_geom[1]) * (float)imgsize.Y)/2;
1142                 pos.Y -= m_btn_height;
1143                 geom.Y = m_btn_height*2;
1144         }
1145
1146         core::rect<s32> rect = core::rect<s32>(pos.X, pos.Y, pos.X+geom.X, pos.Y+geom.Y);
1147
1148         if(data->bp_set != 2)
1149                 errorstream<<"WARNING: invalid use of positioned "<<type<<" without a size[] element"<<std::endl;
1150
1151         if(m_form_src)
1152                 default_val = m_form_src->resolveText(default_val);
1153
1154
1155         default_val = unescape_string(default_val);
1156         label = unescape_string(label);
1157
1158         std::wstring wlabel = narrow_to_wide(label.c_str());
1159
1160         FieldSpec spec(
1161                 narrow_to_wide(name.c_str()),
1162                 wlabel,
1163                 narrow_to_wide(default_val.c_str()),
1164                 258+m_fields.size()
1165         );
1166
1167         if (name == "")
1168         {
1169                 // spec field id to 0, this stops submit searching for a value that isn't there
1170                 Environment->addStaticText(spec.flabel.c_str(), rect, false, true, this, spec.fid);
1171         }
1172         else
1173         {
1174                 spec.send = true;
1175                 gui::IGUIEditBox *e =
1176                         Environment->addEditBox(spec.fdefault.c_str(), rect, true, this, spec.fid);
1177
1178                 if (spec.fname == data->focused_fieldname) {
1179                         Environment->setFocus(e);
1180                 }
1181
1182                 if (type == "textarea")
1183                 {
1184                         e->setMultiLine(true);
1185                         e->setWordWrap(true);
1186                         e->setTextAlignment(gui::EGUIA_UPPERLEFT, gui::EGUIA_UPPERLEFT);
1187                 } else {
1188                         irr::SEvent evt;
1189                         evt.EventType            = EET_KEY_INPUT_EVENT;
1190                         evt.KeyInput.Key         = KEY_END;
1191                         evt.KeyInput.Char        = 0;
1192                         evt.KeyInput.Control     = 0;
1193                         evt.KeyInput.Shift       = 0;
1194                         evt.KeyInput.PressedDown = true;
1195                         e->OnEvent(evt);
1196                 }
1197
1198                 if (label.length() >= 1)
1199                 {
1200                         rect.UpperLeftCorner.Y -= m_btn_height;
1201                         rect.LowerRightCorner.Y = rect.UpperLeftCorner.Y + m_btn_height;
1202                         Environment->addStaticText(spec.flabel.c_str(), rect, false, true, this, 0);
1203                 }
1204         }
1205         m_fields.push_back(spec);
1206 }
1207
1208 void GUIFormSpecMenu::parseField(parserData* data,std::string element,
1209                 std::string type)
1210 {
1211         std::vector<std::string> parts = split(element,';');
1212
1213         if (parts.size() == 3 || parts.size() == 4) {
1214                 parseSimpleField(data,parts);
1215                 return;
1216         }
1217
1218         if ((parts.size() == 5) ||
1219                 ((parts.size() > 5) && (m_formspec_version > FORMSPEC_API_VERSION)))
1220         {
1221                 parseTextArea(data,parts,type);
1222                 return;
1223         }
1224         errorstream<< "Invalid field element(" << parts.size() << "): '" << element << "'"  << std::endl;
1225 }
1226
1227 void GUIFormSpecMenu::parseLabel(parserData* data,std::string element)
1228 {
1229         std::vector<std::string> parts = split(element,';');
1230
1231         if ((parts.size() == 2) ||
1232                 ((parts.size() > 2) && (m_formspec_version > FORMSPEC_API_VERSION)))
1233         {
1234                 std::vector<std::string> v_pos = split(parts[0],',');
1235                 std::string text = parts[1];
1236
1237                 MY_CHECKPOS("label",0);
1238
1239                 v2s32 pos = padding;
1240                 pos.X += stof(v_pos[0]) * (float)spacing.X;
1241                 pos.Y += stof(v_pos[1]) * (float)spacing.Y;
1242
1243                 if(data->bp_set != 2)
1244                         errorstream<<"WARNING: invalid use of label without a size[] element"<<std::endl;
1245
1246                 text = unescape_string(text);
1247
1248                 std::wstring wlabel = narrow_to_wide(text.c_str());
1249
1250                 core::rect<s32> rect = core::rect<s32>(
1251                                 pos.X, pos.Y+((imgsize.Y/2) - m_btn_height),
1252                                 pos.X + m_font->getDimension(wlabel.c_str()).Width,
1253                                 pos.Y+((imgsize.Y/2) + m_btn_height));
1254
1255                 FieldSpec spec(
1256                         L"",
1257                         wlabel,
1258                         L"",
1259                         258+m_fields.size()
1260                 );
1261                 Environment->addStaticText(spec.flabel.c_str(), rect, false, false, this, spec.fid);
1262                 m_fields.push_back(spec);
1263                 return;
1264         }
1265         errorstream<< "Invalid label element(" << parts.size() << "): '" << element << "'"  << std::endl;
1266 }
1267
1268 void GUIFormSpecMenu::parseVertLabel(parserData* data,std::string element)
1269 {
1270         std::vector<std::string> parts = split(element,';');
1271
1272         if ((parts.size() == 2) ||
1273                 ((parts.size() > 2) && (m_formspec_version > FORMSPEC_API_VERSION)))
1274         {
1275                 std::vector<std::string> v_pos = split(parts[0],',');
1276                 std::wstring text = narrow_to_wide(unescape_string(parts[1]));
1277
1278                 MY_CHECKPOS("vertlabel",1);
1279
1280                 v2s32 pos = padding;
1281                 pos.X += stof(v_pos[0]) * (float)spacing.X;
1282                 pos.Y += stof(v_pos[1]) * (float)spacing.Y;
1283
1284                 core::rect<s32> rect = core::rect<s32>(
1285                                 pos.X, pos.Y+((imgsize.Y/2)- m_btn_height),
1286                                 pos.X+15, pos.Y +
1287                                         (m_font->getKerningHeight() +
1288                                         m_font->getDimension(text.c_str()).Height)
1289                                         * (text.length()+1));
1290                 //actually text.length() would be correct but adding +1 avoids to break all mods
1291
1292                 if(data->bp_set != 2)
1293                         errorstream<<"WARNING: invalid use of label without a size[] element"<<std::endl;
1294
1295                 std::wstring label = L"";
1296
1297                 for (unsigned int i=0; i < text.length(); i++) {
1298                         label += text[i];
1299                         label += L"\n";
1300                 }
1301
1302                 FieldSpec spec(
1303                         L"",
1304                         label,
1305                         L"",
1306                         258+m_fields.size()
1307                 );
1308                 gui::IGUIStaticText *t =
1309                                 Environment->addStaticText(spec.flabel.c_str(), rect, false, false, this, spec.fid);
1310                 t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_CENTER);
1311                 m_fields.push_back(spec);
1312                 return;
1313         }
1314         errorstream<< "Invalid vertlabel element(" << parts.size() << "): '" << element << "'"  << std::endl;
1315 }
1316
1317 void GUIFormSpecMenu::parseImageButton(parserData* data,std::string element,
1318                 std::string type)
1319 {
1320         std::vector<std::string> parts = split(element,';');
1321
1322         if ((((parts.size() >= 5) && (parts.size() <= 8)) && (parts.size() != 6)) ||
1323                 ((parts.size() > 8) && (m_formspec_version > FORMSPEC_API_VERSION)))
1324         {
1325                 std::vector<std::string> v_pos = split(parts[0],',');
1326                 std::vector<std::string> v_geom = split(parts[1],',');
1327                 std::string image_name = parts[2];
1328                 std::string name = parts[3];
1329                 std::string label = parts[4];
1330
1331                 MY_CHECKPOS("imagebutton",0);
1332                 MY_CHECKGEOM("imagebutton",1);
1333
1334                 v2s32 pos = padding;
1335                 pos.X += stof(v_pos[0]) * (float)spacing.X;
1336                 pos.Y += stof(v_pos[1]) * (float)spacing.Y;
1337                 v2s32 geom;
1338                 geom.X = (stof(v_geom[0]) * (float)spacing.X)-(spacing.X-imgsize.X);
1339                 geom.Y = (stof(v_geom[1]) * (float)spacing.Y)-(spacing.Y-imgsize.Y);
1340
1341                 bool noclip     = false;
1342                 bool drawborder = true;
1343                 std::string pressed_image_name = "";
1344
1345                 if (parts.size() >= 7) {
1346                         if (parts[5] == "true")
1347                                 noclip = true;
1348                         if (parts[6] == "false")
1349                                 drawborder = false;
1350                 }
1351
1352                 if (parts.size() >= 8) {
1353                         pressed_image_name = parts[7];
1354                 }
1355
1356                 core::rect<s32> rect = core::rect<s32>(pos.X, pos.Y, pos.X+geom.X, pos.Y+geom.Y);
1357
1358                 if(data->bp_set != 2)
1359                         errorstream<<"WARNING: invalid use of image_button without a size[] element"<<std::endl;
1360
1361                 image_name = unescape_string(image_name);
1362                 pressed_image_name = unescape_string(pressed_image_name);
1363                 label = unescape_string(label);
1364
1365                 std::wstring wlabel = narrow_to_wide(label.c_str());
1366
1367                 FieldSpec spec(
1368                         narrow_to_wide(name.c_str()),
1369                         wlabel,
1370                         narrow_to_wide(image_name.c_str()),
1371                         258+m_fields.size()
1372                 );
1373                 spec.ftype = f_Button;
1374                 if(type == "image_button_exit")
1375                         spec.is_exit = true;
1376
1377                 video::ITexture *texture = 0;
1378                 video::ITexture *pressed_texture = 0;
1379                 texture = m_tsrc->getTexture(image_name);
1380                 if (pressed_image_name != "")
1381                         pressed_texture = m_tsrc->getTexture(pressed_image_name);
1382                 else
1383                         pressed_texture = texture;
1384
1385                 gui::IGUIButton *e = Environment->addButton(rect, this, spec.fid, spec.flabel.c_str());
1386
1387                 if (spec.fname == data->focused_fieldname) {
1388                         Environment->setFocus(e);
1389                 }
1390
1391                 e->setUseAlphaChannel(true);
1392                 e->setImage(texture);
1393                 e->setPressedImage(pressed_texture);
1394                 e->setScaleImage(true);
1395                 e->setNotClipped(noclip);
1396                 e->setDrawBorder(drawborder);
1397
1398                 m_fields.push_back(spec);
1399                 return;
1400         }
1401
1402         errorstream<< "Invalid imagebutton element(" << parts.size() << "): '" << element << "'"  << std::endl;
1403 }
1404
1405 void GUIFormSpecMenu::parseTabHeader(parserData* data,std::string element)
1406 {
1407         std::vector<std::string> parts = split(element,';');
1408
1409         if (((parts.size() == 4) || (parts.size() == 6)) ||
1410                 ((parts.size() > 6) && (m_formspec_version > FORMSPEC_API_VERSION)))
1411         {
1412                 std::vector<std::string> v_pos = split(parts[0],',');
1413                 std::string name = parts[1];
1414                 std::vector<std::string> buttons = split(parts[2],',');
1415                 std::string str_index = parts[3];
1416                 bool show_background = true;
1417                 bool show_border = true;
1418                 int tab_index = stoi(str_index) -1;
1419
1420                 MY_CHECKPOS("tabheader",0);
1421
1422                 if (parts.size() == 6) {
1423                         if (parts[4] == "true")
1424                                 show_background = false;
1425                         if (parts[5] == "false")
1426                                 show_border = false;
1427                 }
1428
1429                 FieldSpec spec(
1430                         narrow_to_wide(name.c_str()),
1431                         L"",
1432                         L"",
1433                         258+m_fields.size()
1434                 );
1435
1436                 spec.ftype = f_TabHeader;
1437
1438                 v2s32 pos(0,0);
1439                 pos.X += stof(v_pos[0]) * (float)spacing.X;
1440                 pos.Y += stof(v_pos[1]) * (float)spacing.Y - m_btn_height * 2;
1441                 v2s32 geom;
1442                 geom.X = data->screensize.Y;
1443                 geom.Y = m_btn_height*2;
1444
1445                 core::rect<s32> rect = core::rect<s32>(pos.X, pos.Y, pos.X+geom.X,
1446                                 pos.Y+geom.Y);
1447
1448                 gui::IGUITabControl *e = Environment->addTabControl(rect, this,
1449                                 show_background, show_border, spec.fid);
1450                 e->setAlignment(irr::gui::EGUIA_UPPERLEFT, irr::gui::EGUIA_UPPERLEFT,
1451                                 irr::gui::EGUIA_UPPERLEFT, irr::gui::EGUIA_LOWERRIGHT);
1452                 e->setTabHeight(m_btn_height*2);
1453
1454                 if (spec.fname == data->focused_fieldname) {
1455                         Environment->setFocus(e);
1456                 }
1457
1458                 e->setNotClipped(true);
1459
1460                 for (unsigned int i=0; i< buttons.size(); i++) {
1461                         e->addTab(narrow_to_wide(buttons[i]).c_str(), -1);
1462                 }
1463
1464                 if ((tab_index >= 0) &&
1465                                 (buttons.size() < INT_MAX) &&
1466                                 (tab_index < (int) buttons.size()))
1467                         e->setActiveTab(tab_index);
1468
1469                 m_fields.push_back(spec);
1470                 return;
1471         }
1472         errorstream << "Invalid TabHeader element(" << parts.size() << "): '"
1473                         << element << "'"  << std::endl;
1474 }
1475
1476 void GUIFormSpecMenu::parseItemImageButton(parserData* data,std::string element)
1477 {
1478
1479         if (m_gamedef == 0) {
1480                 errorstream <<
1481                                 "WARNING: invalid use of item_image_button with m_gamedef==0"
1482                                 << std::endl;
1483                 return;
1484         }
1485
1486         std::vector<std::string> parts = split(element,';');
1487
1488         if ((parts.size() == 5) ||
1489                 ((parts.size() > 5) && (m_formspec_version > FORMSPEC_API_VERSION)))
1490         {
1491                 std::vector<std::string> v_pos = split(parts[0],',');
1492                 std::vector<std::string> v_geom = split(parts[1],',');
1493                 std::string item_name = parts[2];
1494                 std::string name = parts[3];
1495                 std::string label = parts[4];
1496
1497                 MY_CHECKPOS("itemimagebutton",0);
1498                 MY_CHECKGEOM("itemimagebutton",1);
1499
1500                 v2s32 pos = padding;
1501                 pos.X += stof(v_pos[0]) * (float)spacing.X;
1502                 pos.Y += stof(v_pos[1]) * (float)spacing.Y;
1503                 v2s32 geom;
1504                 geom.X = (stof(v_geom[0]) * (float)spacing.X)-(spacing.X-imgsize.X);
1505                 geom.Y = (stof(v_geom[1]) * (float)spacing.Y)-(spacing.Y-imgsize.Y);
1506
1507                 core::rect<s32> rect = core::rect<s32>(pos.X, pos.Y, pos.X+geom.X, pos.Y+geom.Y);
1508
1509                 if(data->bp_set != 2)
1510                         errorstream<<"WARNING: invalid use of item_image_button without a size[] element"<<std::endl;
1511
1512                 IItemDefManager *idef = m_gamedef->idef();
1513                 ItemStack item;
1514                 item.deSerialize(item_name, idef);
1515                 video::ITexture *texture = idef->getInventoryTexture(item.getDefinition(idef).name, m_gamedef);
1516
1517                 m_tooltips[narrow_to_wide(name.c_str())] =
1518                         TooltipSpec (item.getDefinition(idef).description,
1519                                                 m_default_tooltip_bgcolor,
1520                                                 m_default_tooltip_color);
1521
1522                 label = unescape_string(label);
1523                 FieldSpec spec(
1524                         narrow_to_wide(name.c_str()),
1525                         narrow_to_wide(label.c_str()),
1526                         narrow_to_wide(item_name.c_str()),
1527                         258+m_fields.size()
1528                 );
1529
1530                 gui::IGUIButton *e = Environment->addButton(rect, this, spec.fid, spec.flabel.c_str());
1531
1532                 if (spec.fname == data->focused_fieldname) {
1533                         Environment->setFocus(e);
1534                 }
1535
1536                 e->setUseAlphaChannel(true);
1537                 e->setImage(texture);
1538                 e->setPressedImage(texture);
1539                 e->setScaleImage(true);
1540                 spec.ftype = f_Button;
1541                 rect+=data->basepos-padding;
1542                 spec.rect=rect;
1543                 m_fields.push_back(spec);
1544                 return;
1545         }
1546         errorstream<< "Invalid ItemImagebutton element(" << parts.size() << "): '" << element << "'"  << std::endl;
1547 }
1548
1549 void GUIFormSpecMenu::parseBox(parserData* data,std::string element)
1550 {
1551         std::vector<std::string> parts = split(element,';');
1552
1553         if ((parts.size() == 3) ||
1554                 ((parts.size() > 3) && (m_formspec_version > FORMSPEC_API_VERSION)))
1555         {
1556                 std::vector<std::string> v_pos = split(parts[0],',');
1557                 std::vector<std::string> v_geom = split(parts[1],',');
1558
1559                 MY_CHECKPOS("box",0);
1560                 MY_CHECKGEOM("box",1);
1561
1562                 v2s32 pos = padding + AbsoluteRect.UpperLeftCorner;
1563                 pos.X += stof(v_pos[0]) * (float) spacing.X;
1564                 pos.Y += stof(v_pos[1]) * (float) spacing.Y;
1565
1566                 v2s32 geom;
1567                 geom.X = stof(v_geom[0]) * (float)spacing.X;
1568                 geom.Y = stof(v_geom[1]) * (float)spacing.Y;
1569
1570                 video::SColor tmp_color;
1571
1572                 if (parseColorString(parts[2], tmp_color, false)) {
1573                         BoxDrawSpec spec(pos, geom, tmp_color);
1574
1575                         m_boxes.push_back(spec);
1576                 }
1577                 else {
1578                         errorstream<< "Invalid Box element(" << parts.size() << "): '" << element << "'  INVALID COLOR"  << std::endl;
1579                 }
1580                 return;
1581         }
1582         errorstream<< "Invalid Box element(" << parts.size() << "): '" << element << "'"  << std::endl;
1583 }
1584
1585 void GUIFormSpecMenu::parseBackgroundColor(parserData* data,std::string element)
1586 {
1587         std::vector<std::string> parts = split(element,';');
1588
1589         if (((parts.size() == 1) || (parts.size() == 2)) ||
1590                 ((parts.size() > 2) && (m_formspec_version > FORMSPEC_API_VERSION)))
1591         {
1592                 parseColorString(parts[0],m_bgcolor,false);
1593
1594                 if (parts.size() == 2) {
1595                         std::string fullscreen = parts[1];
1596                         m_bgfullscreen = is_yes(fullscreen);
1597                 }
1598                 return;
1599         }
1600         errorstream<< "Invalid bgcolor element(" << parts.size() << "): '" << element << "'"  << std::endl;
1601 }
1602
1603 void GUIFormSpecMenu::parseListColors(parserData* data,std::string element)
1604 {
1605         std::vector<std::string> parts = split(element,';');
1606
1607         if (((parts.size() == 2) || (parts.size() == 3) || (parts.size() == 5)) ||
1608                 ((parts.size() > 5) && (m_formspec_version > FORMSPEC_API_VERSION)))
1609         {
1610                 parseColorString(parts[0], m_slotbg_n, false);
1611                 parseColorString(parts[1], m_slotbg_h, false);
1612
1613                 if (parts.size() >= 3) {
1614                         if (parseColorString(parts[2], m_slotbordercolor, false)) {
1615                                 m_slotborder = true;
1616                         }
1617                 }
1618                 if (parts.size() == 5) {
1619                         video::SColor tmp_color;
1620
1621                         if (parseColorString(parts[3], tmp_color, false))
1622                                 m_default_tooltip_bgcolor = tmp_color;
1623                         if (parseColorString(parts[4], tmp_color, false))
1624                                 m_default_tooltip_color = tmp_color;
1625                 }
1626                 return;
1627         }
1628         errorstream<< "Invalid listcolors element(" << parts.size() << "): '" << element << "'"  << std::endl;
1629 }
1630
1631 void GUIFormSpecMenu::parseTooltip(parserData* data, std::string element)
1632 {
1633         std::vector<std::string> parts = split(element,';');
1634         if (parts.size() == 2) {
1635                 std::string name = parts[0];
1636                 m_tooltips[narrow_to_wide(name.c_str())] = TooltipSpec (parts[1], m_default_tooltip_bgcolor, m_default_tooltip_color);
1637                 return;
1638         } else if (parts.size() == 4) {
1639                 std::string name = parts[0];
1640                 video::SColor tmp_color1, tmp_color2;
1641                 if ( parseColorString(parts[2], tmp_color1, false) && parseColorString(parts[3], tmp_color2, false) ) {
1642                         m_tooltips[narrow_to_wide(name.c_str())] = TooltipSpec (parts[1], tmp_color1, tmp_color2);
1643                         return;
1644                 }
1645         }
1646         errorstream<< "Invalid tooltip element(" << parts.size() << "): '" << element << "'"  << std::endl;
1647 }
1648
1649 bool GUIFormSpecMenu::parseVersionDirect(std::string data)
1650 {
1651         //some prechecks
1652         if (data == "")
1653                 return false;
1654
1655         std::vector<std::string> parts = split(data,'[');
1656
1657         if (parts.size() < 2) {
1658                 return false;
1659         }
1660
1661         if (parts[0] != "formspec_version") {
1662                 return false;
1663         }
1664
1665         if (is_number(parts[1])) {
1666                 m_formspec_version = mystoi(parts[1]);
1667                 return true;
1668         }
1669
1670         return false;
1671 }
1672
1673 void GUIFormSpecMenu::parseElement(parserData* data, std::string element)
1674 {
1675         //some prechecks
1676         if (element == "")
1677                 return;
1678
1679         std::vector<std::string> parts = split(element,'[');
1680
1681         // ugly workaround to keep compatibility
1682         if (parts.size() > 2) {
1683                 if (trim(parts[0]) == "image") {
1684                         for (unsigned int i=2;i< parts.size(); i++) {
1685                                 parts[1] += "[" + parts[i];
1686                         }
1687                 }
1688                 else { return; }
1689         }
1690
1691         if (parts.size() < 2) {
1692                 return;
1693         }
1694
1695         std::string type = trim(parts[0]);
1696         std::string description = trim(parts[1]);
1697
1698         if (type == "size") {
1699                 parseSize(data,description);
1700                 return;
1701         }
1702
1703         if (type == "invsize") {
1704                 log_deprecated("Deprecated formspec element \"invsize\" is used");
1705                 parseSize(data,description);
1706                 return;
1707         }
1708
1709         if (type == "list") {
1710                 parseList(data,description);
1711                 return;
1712         }
1713
1714         if (type == "checkbox") {
1715                 parseCheckbox(data,description);
1716                 return;
1717         }
1718
1719         if (type == "image") {
1720                 parseImage(data,description);
1721                 return;
1722         }
1723
1724         if (type == "item_image") {
1725                 parseItemImage(data,description);
1726                 return;
1727         }
1728
1729         if ((type == "button") || (type == "button_exit")) {
1730                 parseButton(data,description,type);
1731                 return;
1732         }
1733
1734         if (type == "background") {
1735                 parseBackground(data,description);
1736                 return;
1737         }
1738
1739         if (type == "tableoptions"){
1740                 parseTableOptions(data,description);
1741                 return;
1742         }
1743
1744         if (type == "tablecolumns"){
1745                 parseTableColumns(data,description);
1746                 return;
1747         }
1748
1749         if (type == "table"){
1750                 parseTable(data,description);
1751                 return;
1752         }
1753
1754         if (type == "textlist"){
1755                 parseTextList(data,description);
1756                 return;
1757         }
1758
1759         if (type == "dropdown"){
1760                 parseDropDown(data,description);
1761                 return;
1762         }
1763
1764         if (type == "pwdfield") {
1765                 parsePwdField(data,description);
1766                 return;
1767         }
1768
1769         if ((type == "field") || (type == "textarea")){
1770                 parseField(data,description,type);
1771                 return;
1772         }
1773
1774         if (type == "label") {
1775                 parseLabel(data,description);
1776                 return;
1777         }
1778
1779         if (type == "vertlabel") {
1780                 parseVertLabel(data,description);
1781                 return;
1782         }
1783
1784         if (type == "item_image_button") {
1785                 parseItemImageButton(data,description);
1786                 return;
1787         }
1788
1789         if ((type == "image_button") || (type == "image_button_exit")) {
1790                 parseImageButton(data,description,type);
1791                 return;
1792         }
1793
1794         if (type == "tabheader") {
1795                 parseTabHeader(data,description);
1796                 return;
1797         }
1798
1799         if (type == "box") {
1800                 parseBox(data,description);
1801                 return;
1802         }
1803
1804         if (type == "bgcolor") {
1805                 parseBackgroundColor(data,description);
1806                 return;
1807         }
1808
1809         if (type == "listcolors") {
1810                 parseListColors(data,description);
1811                 return;
1812         }
1813
1814         if (type == "tooltip") {
1815                 parseTooltip(data,description);
1816                 return;
1817         }
1818
1819         if (type == "scrollbar") {
1820                 parseScrollBar(data, description);
1821                 return;
1822         }
1823
1824         // Ignore others
1825         infostream
1826                 << "Unknown DrawSpec: type="<<type<<", data=\""<<description<<"\""
1827                 <<std::endl;
1828 }
1829
1830
1831
1832 void GUIFormSpecMenu::regenerateGui(v2u32 screensize)
1833 {
1834         /* useless to regenerate without a screensize */
1835         if ((screensize.X <= 0) || (screensize.Y <= 0)) {
1836                 return;
1837         }
1838
1839         parserData mydata;
1840
1841         //preserve tables
1842         for (u32 i = 0; i < m_tables.size(); ++i) {
1843                 std::wstring tablename = m_tables[i].first.fname;
1844                 GUITable *table = m_tables[i].second;
1845                 mydata.table_dyndata[tablename] = table->getDynamicData();
1846         }
1847
1848         //preserve focus
1849         gui::IGUIElement *focused_element = Environment->getFocus();
1850         if (focused_element && focused_element->getParent() == this) {
1851                 s32 focused_id = focused_element->getID();
1852                 if (focused_id > 257) {
1853                         for (u32 i=0; i<m_fields.size(); i++) {
1854                                 if (m_fields[i].fid == focused_id) {
1855                                         mydata.focused_fieldname =
1856                                                 m_fields[i].fname;
1857                                         break;
1858                                 }
1859                         }
1860                 }
1861         }
1862
1863         // Remove children
1864         removeChildren();
1865
1866         for (u32 i = 0; i < m_tables.size(); ++i) {
1867                 GUITable *table = m_tables[i].second;
1868                 table->drop();
1869         }
1870
1871         mydata.size= v2s32(100,100);
1872         mydata.screensize = screensize;
1873
1874         // Base position of contents of form
1875         mydata.basepos = getBasePos();
1876
1877         // State of basepos, 0 = not set, 1= set by formspec, 2 = set by size[] element
1878         // Used to adjust form size automatically if needed
1879         // A proceed button is added if there is no size[] element
1880         mydata.bp_set = 0;
1881
1882
1883         /* Convert m_init_draw_spec to m_inventorylists */
1884
1885         m_inventorylists.clear();
1886         m_images.clear();
1887         m_backgrounds.clear();
1888         m_itemimages.clear();
1889         m_tables.clear();
1890         m_checkboxes.clear();
1891         m_scrollbars.clear();
1892         m_fields.clear();
1893         m_boxes.clear();
1894         m_tooltips.clear();
1895
1896         // Set default values (fits old formspec values)
1897         m_bgcolor = video::SColor(140,0,0,0);
1898         m_bgfullscreen = false;
1899
1900         m_slotbg_n = video::SColor(255,128,128,128);
1901         m_slotbg_h = video::SColor(255,192,192,192);
1902
1903         m_default_tooltip_bgcolor = video::SColor(255,110,130,60);
1904         m_default_tooltip_color = video::SColor(255,255,255,255);
1905
1906         m_slotbordercolor = video::SColor(200,0,0,0);
1907         m_slotborder = false;
1908
1909         m_clipbackground = false;
1910         // Add tooltip
1911         {
1912                 assert(m_tooltip_element == NULL);
1913                 // Note: parent != this so that the tooltip isn't clipped by the menu rectangle
1914                 m_tooltip_element = Environment->addStaticText(L"",core::rect<s32>(0,0,110,18));
1915                 m_tooltip_element->enableOverrideColor(true);
1916                 m_tooltip_element->setBackgroundColor(m_default_tooltip_bgcolor);
1917                 m_tooltip_element->setDrawBackground(true);
1918                 m_tooltip_element->setDrawBorder(true);
1919                 m_tooltip_element->setOverrideColor(m_default_tooltip_color);
1920                 m_tooltip_element->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_CENTER);
1921                 m_tooltip_element->setWordWrap(false);
1922                 //we're not parent so no autograb for this one!
1923                 m_tooltip_element->grab();
1924         }
1925
1926         std::vector<std::string> elements = split(m_formspec_string,']');
1927         unsigned int i = 0;
1928
1929         /* try to read version from first element only */
1930         if (elements.size() >= 1) {
1931                 if ( parseVersionDirect(elements[0]) ) {
1932                         i++;
1933                 }
1934         }
1935
1936         for (; i< elements.size(); i++) {
1937                 parseElement(&mydata, elements[i]);
1938         }
1939
1940         // If there's fields, add a Proceed button
1941         if (m_fields.size() && mydata.bp_set != 2) {
1942                 // if the size wasn't set by an invsize[] or size[] adjust it now to fit all the fields
1943                 mydata.rect = core::rect<s32>(
1944                                 mydata.screensize.X/2 - 580/2,
1945                                 mydata.screensize.Y/2 - 300/2,
1946                                 mydata.screensize.X/2 + 580/2,
1947                                 mydata.screensize.Y/2 + 240/2+(m_fields.size()*60)
1948                 );
1949                 DesiredRect = mydata.rect;
1950                 recalculateAbsolutePosition(false);
1951                 mydata.basepos = getBasePos();
1952
1953                 {
1954                         v2s32 pos = mydata.basepos;
1955                         pos.Y = ((m_fields.size()+2)*60);
1956
1957                         v2s32 size = DesiredRect.getSize();
1958                         mydata.rect =
1959                                         core::rect<s32>(size.X/2-70, pos.Y,
1960                                                         (size.X/2-70)+140, pos.Y + (m_btn_height*2));
1961                         wchar_t* text = wgettext("Proceed");
1962                         Environment->addButton(mydata.rect, this, 257, text);
1963                         delete[] text;
1964                 }
1965
1966         }
1967
1968         //set initial focus if parser didn't set it
1969         focused_element = Environment->getFocus();
1970         if (!focused_element
1971                         || !isMyChild(focused_element)
1972                         || focused_element->getType() == gui::EGUIET_TAB_CONTROL)
1973                 setInitialFocus();
1974 }
1975
1976 #ifdef __ANDROID__
1977 bool GUIFormSpecMenu::getAndroidUIInput()
1978 {
1979         /* no dialog shown */
1980         if (m_JavaDialogFieldName == L"") {
1981                 return false;
1982         }
1983
1984         /* still waiting */
1985         if (porting::getInputDialogState() == -1) {
1986                 return true;
1987         }
1988
1989         std::wstring fieldname = m_JavaDialogFieldName;
1990         m_JavaDialogFieldName = L"";
1991
1992         /* no value abort dialog processing */
1993         if (porting::getInputDialogState() != 0) {
1994                 return false;
1995         }
1996
1997         for(std::vector<FieldSpec>::iterator iter =  m_fields.begin();
1998                         iter != m_fields.end(); iter++) {
1999
2000                 if (iter->fname != fieldname) {
2001                         continue;
2002                 }
2003                 IGUIElement* tochange = getElementFromId(iter->fid);
2004
2005                 if (tochange == 0) {
2006                         return false;
2007                 }
2008
2009                 if (tochange->getType() != irr::gui::EGUIET_EDIT_BOX) {
2010                         return false;
2011                 }
2012
2013                 std::string text = porting::getInputDialogValue();
2014
2015                 ((gui::IGUIEditBox*) tochange)->
2016                         setText(narrow_to_wide(text).c_str());
2017         }
2018         return false;
2019 }
2020 #endif
2021
2022 GUIFormSpecMenu::ItemSpec GUIFormSpecMenu::getItemAtPos(v2s32 p) const
2023 {
2024         core::rect<s32> imgrect(0,0,imgsize.X,imgsize.Y);
2025
2026         for(u32 i=0; i<m_inventorylists.size(); i++)
2027         {
2028                 const ListDrawSpec &s = m_inventorylists[i];
2029
2030                 for(s32 i=0; i<s.geom.X*s.geom.Y; i++) {
2031                         s32 item_i = i + s.start_item_i;
2032                         s32 x = (i%s.geom.X) * spacing.X;
2033                         s32 y = (i/s.geom.X) * spacing.Y;
2034                         v2s32 p0(x,y);
2035                         core::rect<s32> rect = imgrect + s.pos + p0;
2036                         if(rect.isPointInside(p))
2037                         {
2038                                 return ItemSpec(s.inventoryloc, s.listname, item_i);
2039                         }
2040                 }
2041         }
2042
2043         return ItemSpec(InventoryLocation(), "", -1);
2044 }
2045
2046 void GUIFormSpecMenu::drawList(const ListDrawSpec &s, int phase)
2047 {
2048         video::IVideoDriver* driver = Environment->getVideoDriver();
2049
2050         // Get font
2051         gui::IGUIFont *font = NULL;
2052         gui::IGUISkin* skin = Environment->getSkin();
2053         if (skin)
2054                 font = skin->getFont();
2055
2056         Inventory *inv = m_invmgr->getInventory(s.inventoryloc);
2057         if(!inv){
2058                 infostream<<"GUIFormSpecMenu::drawList(): WARNING: "
2059                                 <<"The inventory location "
2060                                 <<"\""<<s.inventoryloc.dump()<<"\" doesn't exist"
2061                                 <<std::endl;
2062                 return;
2063         }
2064         InventoryList *ilist = inv->getList(s.listname);
2065         if(!ilist){
2066                 infostream<<"GUIFormSpecMenu::drawList(): WARNING: "
2067                                 <<"The inventory list \""<<s.listname<<"\" @ \""
2068                                 <<s.inventoryloc.dump()<<"\" doesn't exist"
2069                                 <<std::endl;
2070                 return;
2071         }
2072
2073         core::rect<s32> imgrect(0,0,imgsize.X,imgsize.Y);
2074
2075         for(s32 i=0; i<s.geom.X*s.geom.Y; i++)
2076         {
2077                 s32 item_i = i + s.start_item_i;
2078                 if(item_i >= (s32) ilist->getSize())
2079                         break;
2080                 s32 x = (i%s.geom.X) * spacing.X;
2081                 s32 y = (i/s.geom.X) * spacing.Y;
2082                 v2s32 p(x,y);
2083                 core::rect<s32> rect = imgrect + s.pos + p;
2084                 ItemStack item;
2085                 if(ilist)
2086                         item = ilist->getItem(item_i);
2087
2088                 bool selected = m_selected_item
2089                         && m_invmgr->getInventory(m_selected_item->inventoryloc) == inv
2090                         && m_selected_item->listname == s.listname
2091                         && m_selected_item->i == item_i;
2092                 bool hovering = rect.isPointInside(m_pointer);
2093
2094                 if(phase == 0)
2095                 {
2096                         if(hovering)
2097                                 driver->draw2DRectangle(m_slotbg_h, rect, &AbsoluteClippingRect);
2098                         else
2099                                 driver->draw2DRectangle(m_slotbg_n, rect, &AbsoluteClippingRect);
2100                 }
2101
2102                 //Draw inv slot borders
2103                 if (m_slotborder) {
2104                         s32 x1 = rect.UpperLeftCorner.X;
2105                         s32 y1 = rect.UpperLeftCorner.Y;
2106                         s32 x2 = rect.LowerRightCorner.X;
2107                         s32 y2 = rect.LowerRightCorner.Y;
2108                         s32 border = 1;
2109                         driver->draw2DRectangle(m_slotbordercolor,
2110                                 core::rect<s32>(v2s32(x1 - border, y1 - border),
2111                                                                 v2s32(x2 + border, y1)), NULL);
2112                         driver->draw2DRectangle(m_slotbordercolor,
2113                                 core::rect<s32>(v2s32(x1 - border, y2),
2114                                                                 v2s32(x2 + border, y2 + border)), NULL);
2115                         driver->draw2DRectangle(m_slotbordercolor,
2116                                 core::rect<s32>(v2s32(x1 - border, y1),
2117                                                                 v2s32(x1, y2)), NULL);
2118                         driver->draw2DRectangle(m_slotbordercolor,
2119                                 core::rect<s32>(v2s32(x2, y1),
2120                                                                 v2s32(x2 + border, y2)), NULL);
2121                 }
2122
2123                 if(phase == 1)
2124                 {
2125                         // Draw item stack
2126                         if(selected)
2127                         {
2128                                 item.takeItem(m_selected_amount);
2129                         }
2130                         if(!item.empty())
2131                         {
2132                                 drawItemStack(driver, font, item,
2133                                                 rect, &AbsoluteClippingRect, m_gamedef);
2134                         }
2135
2136                         // Draw tooltip
2137                         std::string tooltip_text = "";
2138                         if (hovering && !m_selected_item)
2139                                 tooltip_text = item.getDefinition(m_gamedef->idef()).description;
2140                         if (tooltip_text != "") {
2141                                 std::vector<std::string> tt_rows = str_split(tooltip_text, '\n');
2142                                 m_tooltip_element->setBackgroundColor(m_default_tooltip_bgcolor);
2143                                 m_tooltip_element->setOverrideColor(m_default_tooltip_color);
2144                                 m_tooltip_element->setVisible(true);
2145                                 this->bringToFront(m_tooltip_element);
2146                                 m_tooltip_element->setText(narrow_to_wide(tooltip_text).c_str());
2147                                 s32 tooltip_x = m_pointer.X + m_btn_height;
2148                                 s32 tooltip_y = m_pointer.Y + m_btn_height;
2149                                 s32 tooltip_width = m_tooltip_element->getTextWidth() + m_btn_height;
2150                                 s32 tooltip_height = m_tooltip_element->getTextHeight() * tt_rows.size() + 5;
2151                                 m_tooltip_element->setRelativePosition(core::rect<s32>(
2152                                                 core::position2d<s32>(tooltip_x, tooltip_y),
2153                                                 core::dimension2d<s32>(tooltip_width, tooltip_height)));
2154                         }
2155                 }
2156         }
2157 }
2158
2159 void GUIFormSpecMenu::drawSelectedItem()
2160 {
2161         if(!m_selected_item)
2162                 return;
2163
2164         video::IVideoDriver* driver = Environment->getVideoDriver();
2165
2166         // Get font
2167         gui::IGUIFont *font = NULL;
2168         gui::IGUISkin* skin = Environment->getSkin();
2169         if (skin)
2170                 font = skin->getFont();
2171
2172         Inventory *inv = m_invmgr->getInventory(m_selected_item->inventoryloc);
2173         assert(inv);
2174         InventoryList *list = inv->getList(m_selected_item->listname);
2175         assert(list);
2176         ItemStack stack = list->getItem(m_selected_item->i);
2177         stack.count = m_selected_amount;
2178
2179         core::rect<s32> imgrect(0,0,imgsize.X,imgsize.Y);
2180         core::rect<s32> rect = imgrect + (m_pointer - imgrect.getCenter());
2181         drawItemStack(driver, font, stack, rect, NULL, m_gamedef);
2182 }
2183
2184 void GUIFormSpecMenu::drawMenu()
2185 {
2186         if(m_form_src){
2187                 std::string newform = m_form_src->getForm();
2188                 if(newform != m_formspec_string){
2189                         m_formspec_string = newform;
2190                         regenerateGui(m_screensize_old);
2191                 }
2192         }
2193
2194         updateSelectedItem();
2195
2196         gui::IGUISkin* skin = Environment->getSkin();
2197         if (!skin)
2198                 return;
2199         video::IVideoDriver* driver = Environment->getVideoDriver();
2200
2201         v2u32 screenSize = driver->getScreenSize();
2202         core::rect<s32> allbg(0, 0, screenSize.X ,      screenSize.Y);
2203         if (m_bgfullscreen)
2204                 driver->draw2DRectangle(m_bgcolor, allbg, &allbg);
2205         else
2206                 driver->draw2DRectangle(m_bgcolor, AbsoluteRect, &AbsoluteClippingRect);
2207
2208         m_tooltip_element->setVisible(false);
2209
2210         /*
2211                 Draw backgrounds
2212         */
2213         for(u32 i=0; i<m_backgrounds.size(); i++)
2214         {
2215                 const ImageDrawSpec &spec = m_backgrounds[i];
2216                 video::ITexture *texture = m_tsrc->getTexture(spec.name);
2217
2218                 if (texture != 0) {
2219                         // Image size on screen
2220                         core::rect<s32> imgrect(0, 0, spec.geom.X, spec.geom.Y);
2221                         // Image rectangle on screen
2222                         core::rect<s32> rect = imgrect + spec.pos;
2223
2224                         if (m_clipbackground) {
2225                                 core::dimension2d<s32> absrec_size = AbsoluteRect.getSize();
2226                                 rect = core::rect<s32>(AbsoluteRect.UpperLeftCorner.X - spec.pos.X,
2227                                                                         AbsoluteRect.UpperLeftCorner.Y - spec.pos.Y,
2228                                                                         AbsoluteRect.UpperLeftCorner.X + absrec_size.Width + spec.pos.X,
2229                                                                         AbsoluteRect.UpperLeftCorner.Y + absrec_size.Height + spec.pos.Y);
2230                         }
2231
2232                         const video::SColor color(255,255,255,255);
2233                         const video::SColor colors[] = {color,color,color,color};
2234                         driver->draw2DImage(texture, rect,
2235                                 core::rect<s32>(core::position2d<s32>(0,0),
2236                                                 core::dimension2di(texture->getOriginalSize())),
2237                                 NULL/*&AbsoluteClippingRect*/, colors, true);
2238                 }
2239                 else {
2240                         errorstream << "GUIFormSpecMenu::drawMenu() Draw backgrounds unable to load texture:" << std::endl;
2241                         errorstream << "\t" << spec.name << std::endl;
2242                 }
2243         }
2244
2245         /*
2246                 Draw Boxes
2247         */
2248         for(u32 i=0; i<m_boxes.size(); i++)
2249         {
2250                 const BoxDrawSpec &spec = m_boxes[i];
2251
2252                 irr::video::SColor todraw = spec.color;
2253
2254                 todraw.setAlpha(140);
2255
2256                 core::rect<s32> rect(spec.pos.X,spec.pos.Y,
2257                                                         spec.pos.X + spec.geom.X,spec.pos.Y + spec.geom.Y);
2258
2259                 driver->draw2DRectangle(todraw, rect, 0);
2260         }
2261         /*
2262                 Draw images
2263         */
2264         for(u32 i=0; i<m_images.size(); i++)
2265         {
2266                 const ImageDrawSpec &spec = m_images[i];
2267                 video::ITexture *texture = m_tsrc->getTexture(spec.name);
2268
2269                 if (texture != 0) {
2270                         const core::dimension2d<u32>& img_origsize = texture->getOriginalSize();
2271                         // Image size on screen
2272                         core::rect<s32> imgrect;
2273
2274                         if (spec.scale)
2275                                 imgrect = core::rect<s32>(0,0,spec.geom.X, spec.geom.Y);
2276                         else {
2277
2278                                 imgrect = core::rect<s32>(0,0,img_origsize.Width,img_origsize.Height);
2279                         }
2280                         // Image rectangle on screen
2281                         core::rect<s32> rect = imgrect + spec.pos;
2282                         const video::SColor color(255,255,255,255);
2283                         const video::SColor colors[] = {color,color,color,color};
2284                         driver->draw2DImage(texture, rect,
2285                                 core::rect<s32>(core::position2d<s32>(0,0),img_origsize),
2286                                 NULL/*&AbsoluteClippingRect*/, colors, true);
2287                 }
2288                 else {
2289                         errorstream << "GUIFormSpecMenu::drawMenu() Draw images unable to load texture:" << std::endl;
2290                         errorstream << "\t" << spec.name << std::endl;
2291                 }
2292         }
2293
2294         /*
2295                 Draw item images
2296         */
2297         for(u32 i=0; i<m_itemimages.size(); i++)
2298         {
2299                 if (m_gamedef == 0)
2300                         break;
2301
2302                 const ImageDrawSpec &spec = m_itemimages[i];
2303                 IItemDefManager *idef = m_gamedef->idef();
2304                 ItemStack item;
2305                 item.deSerialize(spec.name, idef);
2306                 video::ITexture *texture = idef->getInventoryTexture(item.getDefinition(idef).name, m_gamedef);
2307                 // Image size on screen
2308                 core::rect<s32> imgrect(0, 0, spec.geom.X, spec.geom.Y);
2309                 // Image rectangle on screen
2310                 core::rect<s32> rect = imgrect + spec.pos;
2311                 const video::SColor color(255,255,255,255);
2312                 const video::SColor colors[] = {color,color,color,color};
2313                 driver->draw2DImage(texture, rect,
2314                         core::rect<s32>(core::position2d<s32>(0,0),
2315                                         core::dimension2di(texture->getOriginalSize())),
2316                         NULL/*&AbsoluteClippingRect*/, colors, true);
2317         }
2318
2319         /*
2320                 Draw items
2321                 Phase 0: Item slot rectangles
2322                 Phase 1: Item images; prepare tooltip
2323         */
2324         int start_phase=0;
2325         for(int phase=start_phase; phase<=1; phase++)
2326         for(u32 i=0; i<m_inventorylists.size(); i++)
2327         {
2328                 drawList(m_inventorylists[i], phase);
2329         }
2330
2331         /*
2332                 Call base class
2333         */
2334         gui::IGUIElement::draw();
2335
2336 /* TODO find way to show tooltips on touchscreen */
2337 #ifndef HAVE_TOUCHSCREENGUI
2338         m_pointer = m_device->getCursorControl()->getPosition();
2339 #endif
2340
2341         /*
2342                 Draw fields/buttons tooltips
2343         */
2344         gui::IGUIElement *hovered =
2345                         Environment->getRootGUIElement()->getElementFromPoint(m_pointer);
2346
2347         if (hovered != NULL) {
2348                 s32 id = hovered->getID();
2349                 u32 delta;
2350                 if (id == -1) {
2351                         m_old_tooltip_id = id;
2352                         m_old_tooltip = "";
2353                         delta = 0;
2354                 } else if (id != m_old_tooltip_id) {
2355                         m_hoovered_time = getTimeMs();
2356                         m_old_tooltip_id = id;
2357                         delta = 0;
2358                 } else if (id == m_old_tooltip_id) {
2359                         delta = porting::getDeltaMs(m_hoovered_time, getTimeMs());
2360                 }
2361                 if (id != -1 && delta >= m_tooltip_show_delay) {
2362                         for(std::vector<FieldSpec>::iterator iter =  m_fields.begin();
2363                                         iter != m_fields.end(); iter++) {
2364                                 if ( (iter->fid == id) && (m_tooltips[iter->fname].tooltip != "") ){
2365                                         if (m_old_tooltip != m_tooltips[iter->fname].tooltip) {
2366                                                 m_old_tooltip = m_tooltips[iter->fname].tooltip;
2367                                                 m_tooltip_element->setText(narrow_to_wide(m_tooltips[iter->fname].tooltip).c_str());
2368                                                 s32 tooltip_x = m_pointer.X + m_btn_height;
2369                                                 s32 tooltip_y = m_pointer.Y + m_btn_height;
2370                                                 s32 tooltip_width = m_tooltip_element->getTextWidth() + m_btn_height;
2371                                                 if (tooltip_x + tooltip_width > (s32)screenSize.X)
2372                                                         tooltip_x = (s32)screenSize.X - tooltip_width - m_btn_height;
2373                                                 std::vector<std::string> tt_rows = str_split(m_tooltips[iter->fname].tooltip, '\n');
2374                                                 s32 tooltip_height = m_tooltip_element->getTextHeight() * tt_rows.size() + 5;
2375                                                 m_tooltip_element->setRelativePosition(core::rect<s32>(
2376                                                 core::position2d<s32>(tooltip_x, tooltip_y),
2377                                                 core::dimension2d<s32>(tooltip_width, tooltip_height)));
2378                                         }
2379                                         m_tooltip_element->setBackgroundColor(m_tooltips[iter->fname].bgcolor);
2380                                         m_tooltip_element->setOverrideColor(m_tooltips[iter->fname].color);
2381                                         m_tooltip_element->setVisible(true);
2382                                         this->bringToFront(m_tooltip_element);
2383                                         break;
2384                                 }
2385                         }
2386                 }
2387         }
2388
2389         /*
2390                 Draw dragged item stack
2391         */
2392         drawSelectedItem();
2393 }
2394
2395 void GUIFormSpecMenu::updateSelectedItem()
2396 {
2397         // If the selected stack has become empty for some reason, deselect it.
2398         // If the selected stack has become inaccessible, deselect it.
2399         // If the selected stack has become smaller, adjust m_selected_amount.
2400         ItemStack selected = verifySelectedItem();
2401
2402         // WARNING: BLACK MAGIC
2403         // See if there is a stack suited for our current guess.
2404         // If such stack does not exist, clear the guess.
2405         if(m_selected_content_guess.name != "" &&
2406                         selected.name == m_selected_content_guess.name &&
2407                         selected.count == m_selected_content_guess.count){
2408                 // Selected item fits the guess. Skip the black magic.
2409         }
2410         else if(m_selected_content_guess.name != ""){
2411                 bool found = false;
2412                 for(u32 i=0; i<m_inventorylists.size() && !found; i++){
2413                         const ListDrawSpec &s = m_inventorylists[i];
2414                         Inventory *inv = m_invmgr->getInventory(s.inventoryloc);
2415                         if(!inv)
2416                                 continue;
2417                         InventoryList *list = inv->getList(s.listname);
2418                         if(!list)
2419                                 continue;
2420                         for(s32 i=0; i<s.geom.X*s.geom.Y && !found; i++){
2421                                 u32 item_i = i + s.start_item_i;
2422                                 if(item_i >= list->getSize())
2423                                         continue;
2424                                 ItemStack stack = list->getItem(item_i);
2425                                 if(stack.name == m_selected_content_guess.name &&
2426                                                 stack.count == m_selected_content_guess.count){
2427                                         found = true;
2428                                         infostream<<"Client: Changing selected content guess to "
2429                                                         <<s.inventoryloc.dump()<<" "<<s.listname
2430                                                         <<" "<<item_i<<std::endl;
2431                                         delete m_selected_item;
2432                                         m_selected_item = new ItemSpec(s.inventoryloc, s.listname, item_i);
2433                                         m_selected_amount = stack.count;
2434                                 }
2435                         }
2436                 }
2437                 if(!found){
2438                         infostream<<"Client: Discarding selected content guess: "
2439                                         <<m_selected_content_guess.getItemString()<<std::endl;
2440                         m_selected_content_guess.name = "";
2441                 }
2442         }
2443
2444         // If craftresult is nonempty and nothing else is selected, select it now.
2445         if(!m_selected_item)
2446         {
2447                 for(u32 i=0; i<m_inventorylists.size(); i++)
2448                 {
2449                         const ListDrawSpec &s = m_inventorylists[i];
2450                         if(s.listname == "craftpreview")
2451                         {
2452                                 Inventory *inv = m_invmgr->getInventory(s.inventoryloc);
2453                                 InventoryList *list = inv->getList("craftresult");
2454                                 if(list && list->getSize() >= 1 && !list->getItem(0).empty())
2455                                 {
2456                                         m_selected_item = new ItemSpec;
2457                                         m_selected_item->inventoryloc = s.inventoryloc;
2458                                         m_selected_item->listname = "craftresult";
2459                                         m_selected_item->i = 0;
2460                                         m_selected_amount = 0;
2461                                         m_selected_dragging = false;
2462                                         break;
2463                                 }
2464                         }
2465                 }
2466         }
2467
2468         // If craftresult is selected, keep the whole stack selected
2469         if(m_selected_item && m_selected_item->listname == "craftresult")
2470         {
2471                 m_selected_amount = verifySelectedItem().count;
2472         }
2473 }
2474
2475 ItemStack GUIFormSpecMenu::verifySelectedItem()
2476 {
2477         // If the selected stack has become empty for some reason, deselect it.
2478         // If the selected stack has become inaccessible, deselect it.
2479         // If the selected stack has become smaller, adjust m_selected_amount.
2480         // Return the selected stack.
2481
2482         if(m_selected_item)
2483         {
2484                 if(m_selected_item->isValid())
2485                 {
2486                         Inventory *inv = m_invmgr->getInventory(m_selected_item->inventoryloc);
2487                         if(inv)
2488                         {
2489                                 InventoryList *list = inv->getList(m_selected_item->listname);
2490                                 if(list && (u32) m_selected_item->i < list->getSize())
2491                                 {
2492                                         ItemStack stack = list->getItem(m_selected_item->i);
2493                                         if(m_selected_amount > stack.count)
2494                                                 m_selected_amount = stack.count;
2495                                         if(!stack.empty())
2496                                                 return stack;
2497                                 }
2498                         }
2499                 }
2500
2501                 // selection was not valid
2502                 delete m_selected_item;
2503                 m_selected_item = NULL;
2504                 m_selected_amount = 0;
2505                 m_selected_dragging = false;
2506         }
2507         return ItemStack();
2508 }
2509
2510 void GUIFormSpecMenu::acceptInput(FormspecQuitMode quitmode=quit_mode_no)
2511 {
2512         if(m_text_dst)
2513         {
2514                 std::map<std::string, std::string> fields;
2515
2516                 if (quitmode == quit_mode_accept) {
2517                         fields["quit"] = "true";
2518                 }
2519
2520                 if (quitmode == quit_mode_cancel) {
2521                         fields["quit"] = "true";
2522                         m_text_dst->gotText(fields);
2523                         return;
2524                 }
2525
2526                 if (current_keys_pending.key_down) {
2527                         fields["key_down"] = "true";
2528                         current_keys_pending.key_down = false;
2529                 }
2530
2531                 if (current_keys_pending.key_up) {
2532                         fields["key_up"] = "true";
2533                         current_keys_pending.key_up = false;
2534                 }
2535
2536                 if (current_keys_pending.key_enter) {
2537                         fields["key_enter"] = "true";
2538                         current_keys_pending.key_enter = false;
2539                 }
2540
2541                 if (current_keys_pending.key_escape) {
2542                         fields["key_escape"] = "true";
2543                         current_keys_pending.key_escape = false;
2544                 }
2545
2546                 for(unsigned int i=0; i<m_fields.size(); i++) {
2547                         const FieldSpec &s = m_fields[i];
2548                         if(s.send) {
2549                                 std::string name  = wide_to_narrow(s.fname);
2550                                 if(s.ftype == f_Button) {
2551                                         fields[name] = wide_to_narrow(s.flabel);
2552                                 }
2553                                 else if(s.ftype == f_Table) {
2554                                         GUITable *table = getTable(s.fname);
2555                                         if (table) {
2556                                                 fields[name] = table->checkEvent();
2557                                         }
2558                                 }
2559                                 else if(s.ftype == f_DropDown) {
2560                                         // no dynamic cast possible due to some distributions shipped
2561                                         // without rtti support in irrlicht
2562                                         IGUIElement * element = getElementFromId(s.fid);
2563                                         gui::IGUIComboBox *e = NULL;
2564                                         if ((element) && (element->getType() == gui::EGUIET_COMBO_BOX)) {
2565                                                 e = static_cast<gui::IGUIComboBox*>(element);
2566                                         }
2567                                         s32 selected = e->getSelected();
2568                                         if (selected >= 0) {
2569                                                 fields[name] =
2570                                                         wide_to_narrow(e->getItem(selected));
2571                                         }
2572                                 }
2573                                 else if (s.ftype == f_TabHeader) {
2574                                         // no dynamic cast possible due to some distributions shipped
2575                                         // without rtti support in irrlicht
2576                                         IGUIElement * element = getElementFromId(s.fid);
2577                                         gui::IGUITabControl *e = NULL;
2578                                         if ((element) && (element->getType() == gui::EGUIET_TAB_CONTROL)) {
2579                                                 e = static_cast<gui::IGUITabControl*>(element);
2580                                         }
2581
2582                                         if (e != 0) {
2583                                                 std::stringstream ss;
2584                                                 ss << (e->getActiveTab() +1);
2585                                                 fields[name] = ss.str();
2586                                         }
2587                                 }
2588                                 else if (s.ftype == f_CheckBox) {
2589                                         // no dynamic cast possible due to some distributions shipped
2590                                         // without rtti support in irrlicht
2591                                         IGUIElement * element = getElementFromId(s.fid);
2592                                         gui::IGUICheckBox *e = NULL;
2593                                         if ((element) && (element->getType() == gui::EGUIET_CHECK_BOX)) {
2594                                                 e = static_cast<gui::IGUICheckBox*>(element);
2595                                         }
2596
2597                                         if (e != 0) {
2598                                                 if (e->isChecked())
2599                                                         fields[name] = "true";
2600                                                 else
2601                                                         fields[name] = "false";
2602                                         }
2603                                 }
2604                                 else if (s.ftype == f_ScrollBar) {
2605                                         // no dynamic cast possible due to some distributions shipped
2606                                         // without rtti support in irrlicht
2607                                         IGUIElement * element = getElementFromId(s.fid);
2608                                         gui::IGUIScrollBar *e = NULL;
2609                                         if ((element) && (element->getType() == gui::EGUIET_SCROLL_BAR)) {
2610                                                 e = static_cast<gui::IGUIScrollBar*>(element);
2611                                         }
2612
2613                                         if (e != 0) {
2614                                                 std::stringstream os;
2615                                                 os << e->getPos();
2616                                                 if (s.fdefault == L"Changed")
2617                                                         fields[name] = "CHG:" + os.str();
2618                                                 else
2619                                                         fields[name] = "VAL:" + os.str();
2620                                         }
2621                                 }
2622                                 else
2623                                 {
2624                                         IGUIElement* e = getElementFromId(s.fid);
2625                                         if(e != NULL) {
2626                                                 fields[name] = wide_to_narrow(e->getText());
2627                                         }
2628                                 }
2629                         }
2630                 }
2631
2632                 m_text_dst->gotText(fields);
2633         }
2634 }
2635
2636 static bool isChild(gui::IGUIElement * tocheck, gui::IGUIElement * parent)
2637 {
2638         while(tocheck != NULL) {
2639                 if (tocheck == parent) {
2640                         return true;
2641                 }
2642                 tocheck = tocheck->getParent();
2643         }
2644         return false;
2645 }
2646
2647 bool GUIFormSpecMenu::preprocessEvent(const SEvent& event)
2648 {
2649         // Fix Esc/Return key being eaten by checkboxen and tables
2650         if(event.EventType==EET_KEY_INPUT_EVENT) {
2651                 KeyPress kp(event.KeyInput);
2652                 if (kp == EscapeKey || kp == CancelKey
2653                                 || kp == getKeySetting("keymap_inventory")
2654                                 || event.KeyInput.Key==KEY_RETURN) {
2655                         gui::IGUIElement *focused = Environment->getFocus();
2656                         if (focused && isMyChild(focused) &&
2657                                         (focused->getType() == gui::EGUIET_LIST_BOX ||
2658                                          focused->getType() == gui::EGUIET_CHECK_BOX)) {
2659                                 OnEvent(event);
2660                                 return true;
2661                         }
2662                 }
2663         }
2664         // Mouse wheel events: send to hovered element instead of focused
2665         if(event.EventType==EET_MOUSE_INPUT_EVENT
2666                         && event.MouseInput.Event == EMIE_MOUSE_WHEEL) {
2667                 s32 x = event.MouseInput.X;
2668                 s32 y = event.MouseInput.Y;
2669                 gui::IGUIElement *hovered =
2670                         Environment->getRootGUIElement()->getElementFromPoint(
2671                                 core::position2d<s32>(x, y));
2672                 if (hovered && isMyChild(hovered)) {
2673                         hovered->OnEvent(event);
2674                         return true;
2675                 }
2676         }
2677
2678         if (event.EventType == EET_MOUSE_INPUT_EVENT) {
2679                 s32 x = event.MouseInput.X;
2680                 s32 y = event.MouseInput.Y;
2681                 gui::IGUIElement *hovered =
2682                         Environment->getRootGUIElement()->getElementFromPoint(
2683                                 core::position2d<s32>(x, y));
2684                 if (event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN) {
2685                         m_old_tooltip_id = -1;
2686                         m_old_tooltip = "";
2687                 }
2688                 if (!isChild(hovered,this)) {
2689                         if (DoubleClickDetection(event)) {
2690                                 return true;
2691                         }
2692                 }
2693         }
2694
2695         #ifdef __ANDROID__
2696         // display software keyboard when clicking edit boxes
2697         if (event.EventType == EET_MOUSE_INPUT_EVENT
2698                         && event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN) {
2699                 gui::IGUIElement *hovered =
2700                         Environment->getRootGUIElement()->getElementFromPoint(
2701                                 core::position2d<s32>(event.MouseInput.X, event.MouseInput.Y));
2702                 if ((hovered) && (hovered->getType() == irr::gui::EGUIET_EDIT_BOX)) {
2703                         bool retval = hovered->OnEvent(event);
2704                         if (retval) {
2705                                 Environment->setFocus(hovered);
2706                         }
2707                         m_JavaDialogFieldName = getNameByID(hovered->getID());
2708                         std::string message   = gettext("Enter ");
2709                         std::string label     = wide_to_narrow(getLabelByID(hovered->getID()));
2710                         if (label == "") {
2711                                 label = "text";
2712                         }
2713                         message += gettext(label) + ":";
2714
2715                         /* single line text input */
2716                         int type = 2;
2717
2718                         /* multi line text input */
2719                         if (((gui::IGUIEditBox*) hovered)->isMultiLineEnabled()) {
2720                                 type = 1;
2721                         }
2722
2723                         /* passwords are always single line */
2724                         if (((gui::IGUIEditBox*) hovered)->isPasswordBox()) {
2725                                 type = 3;
2726                         }
2727
2728                         porting::showInputDialog(gettext("ok"), "",
2729                                         wide_to_narrow(((gui::IGUIEditBox*) hovered)->getText()),
2730                                         type);
2731                         return retval;
2732                 }
2733         }
2734
2735         if (event.EventType == EET_TOUCH_INPUT_EVENT)
2736         {
2737                 SEvent translated;
2738                 memset(&translated, 0, sizeof(SEvent));
2739                 translated.EventType   = EET_MOUSE_INPUT_EVENT;
2740                 gui::IGUIElement* root = Environment->getRootGUIElement();
2741
2742                 if (!root) {
2743                         errorstream
2744                         << "GUIFormSpecMenu::preprocessEvent unable to get root element"
2745                         << std::endl;
2746                         return false;
2747                 }
2748                 gui::IGUIElement* hovered = root->getElementFromPoint(
2749                         core::position2d<s32>(
2750                                         event.TouchInput.X,
2751                                         event.TouchInput.Y));
2752
2753                 translated.MouseInput.X = event.TouchInput.X;
2754                 translated.MouseInput.Y = event.TouchInput.Y;
2755                 translated.MouseInput.Control = false;
2756
2757                 bool dont_send_event = false;
2758
2759                 if (event.TouchInput.touchedCount == 1) {
2760                         switch (event.TouchInput.Event) {
2761                                 case ETIE_PRESSED_DOWN:
2762                                         m_pointer = v2s32(event.TouchInput.X,event.TouchInput.Y);
2763                                         translated.MouseInput.Event = EMIE_LMOUSE_PRESSED_DOWN;
2764                                         translated.MouseInput.ButtonStates = EMBSM_LEFT;
2765                                         m_down_pos = m_pointer;
2766                                         break;
2767                                 case ETIE_MOVED:
2768                                         m_pointer = v2s32(event.TouchInput.X,event.TouchInput.Y);
2769                                         translated.MouseInput.Event = EMIE_MOUSE_MOVED;
2770                                         translated.MouseInput.ButtonStates = EMBSM_LEFT;
2771                                         break;
2772                                 case ETIE_LEFT_UP:
2773                                         translated.MouseInput.Event = EMIE_LMOUSE_LEFT_UP;
2774                                         translated.MouseInput.ButtonStates = 0;
2775                                         hovered = root->getElementFromPoint(m_down_pos);
2776                                         /* we don't have a valid pointer element use last
2777                                          * known pointer pos */
2778                                         translated.MouseInput.X = m_pointer.X;
2779                                         translated.MouseInput.Y = m_pointer.Y;
2780
2781                                         /* reset down pos */
2782                                         m_down_pos = v2s32(0,0);
2783                                         break;
2784                                 default:
2785                                         dont_send_event = true;
2786                                         //this is not supposed to happen
2787                                         errorstream
2788                                         << "GUIFormSpecMenu::preprocessEvent unexpected usecase Event="
2789                                         << event.TouchInput.Event << std::endl;
2790                         }
2791                 } else if ( (event.TouchInput.touchedCount == 2) &&
2792                                 (event.TouchInput.Event == ETIE_PRESSED_DOWN) ) {
2793                         hovered = root->getElementFromPoint(m_down_pos);
2794
2795                         translated.MouseInput.Event = EMIE_RMOUSE_PRESSED_DOWN;
2796                         translated.MouseInput.ButtonStates = EMBSM_LEFT | EMBSM_RIGHT;
2797                         translated.MouseInput.X = m_pointer.X;
2798                         translated.MouseInput.Y = m_pointer.Y;
2799
2800                         if (hovered) {
2801                                 hovered->OnEvent(translated);
2802                         }
2803
2804                         translated.MouseInput.Event = EMIE_RMOUSE_LEFT_UP;
2805                         translated.MouseInput.ButtonStates = EMBSM_LEFT;
2806
2807
2808                         if (hovered) {
2809                                 hovered->OnEvent(translated);
2810                         }
2811                         dont_send_event = true;
2812                 }
2813                 /* ignore unhandled 2 touch events ... accidental moving for example */
2814                 else if (event.TouchInput.touchedCount == 2) {
2815                         dont_send_event = true;
2816                 }
2817                 else if (event.TouchInput.touchedCount > 2) {
2818                         errorstream
2819                         << "GUIFormSpecMenu::preprocessEvent to many multitouch events "
2820                         << event.TouchInput.touchedCount << " ignoring them" << std::endl;
2821                 }
2822
2823                 if (dont_send_event) {
2824                         return true;
2825                 }
2826
2827                 /* check if translated event needs to be preprocessed again */
2828                 if (preprocessEvent(translated)) {
2829                         return true;
2830                 }
2831                 if (hovered) {
2832                         grab();
2833                         bool retval = hovered->OnEvent(translated);
2834
2835                         if (event.TouchInput.Event == ETIE_LEFT_UP) {
2836                                 /* reset pointer */
2837                                 m_pointer = v2s32(0,0);
2838                         }
2839                         drop();
2840                         return retval;
2841                 }
2842         }
2843         #endif
2844
2845         return false;
2846 }
2847
2848 /******************************************************************************/
2849 bool GUIFormSpecMenu::DoubleClickDetection(const SEvent event)
2850 {
2851         if (event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN) {
2852                 m_doubleclickdetect[0].pos  = m_doubleclickdetect[1].pos;
2853                 m_doubleclickdetect[0].time = m_doubleclickdetect[1].time;
2854
2855                 m_doubleclickdetect[1].pos  = m_pointer;
2856                 m_doubleclickdetect[1].time = getTimeMs();
2857         }
2858         else if (event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP) {
2859                 u32 delta = porting::getDeltaMs(m_doubleclickdetect[0].time, getTimeMs());
2860                 if (delta > 400) {
2861                         return false;
2862                 }
2863
2864                 double squaredistance =
2865                                 m_doubleclickdetect[0].pos
2866                                 .getDistanceFromSQ(m_doubleclickdetect[1].pos);
2867
2868                 if (squaredistance > (30*30)) {
2869                         return false;
2870                 }
2871
2872                 SEvent* translated = new SEvent();
2873                 assert(translated != 0);
2874                 //translate doubleclick to escape
2875                 memset(translated, 0, sizeof(SEvent));
2876                 translated->EventType = irr::EET_KEY_INPUT_EVENT;
2877                 translated->KeyInput.Key         = KEY_ESCAPE;
2878                 translated->KeyInput.Control     = false;
2879                 translated->KeyInput.Shift       = false;
2880                 translated->KeyInput.PressedDown = true;
2881                 translated->KeyInput.Char        = 0;
2882                 OnEvent(*translated);
2883
2884                 // no need to send the key up event as we're already deleted
2885                 // and no one else did notice this event
2886                 delete translated;
2887                 return true;
2888         }
2889         return false;
2890 }
2891
2892 bool GUIFormSpecMenu::OnEvent(const SEvent& event)
2893 {
2894         if(event.EventType==EET_KEY_INPUT_EVENT) {
2895                 KeyPress kp(event.KeyInput);
2896                 if (event.KeyInput.PressedDown && ( (kp == EscapeKey) ||
2897                         (kp == getKeySetting("keymap_inventory")) || (kp == CancelKey))) {
2898                         if (m_allowclose) {
2899                                 doPause = false;
2900                                 acceptInput(quit_mode_cancel);
2901                                 quitMenu();
2902                         } else {
2903                                 m_text_dst->gotText(narrow_to_wide("MenuQuit"));
2904                         }
2905                         return true;
2906                 } else if (m_client != NULL && event.KeyInput.PressedDown &&
2907                         (kp == getKeySetting("keymap_screenshot"))) {
2908                                 m_client->makeScreenshot(m_device);
2909                 }
2910                 if (event.KeyInput.PressedDown &&
2911                         (event.KeyInput.Key==KEY_RETURN ||
2912                          event.KeyInput.Key==KEY_UP ||
2913                          event.KeyInput.Key==KEY_DOWN)
2914                         ) {
2915                         switch (event.KeyInput.Key) {
2916                                 case KEY_RETURN:
2917                                         current_keys_pending.key_enter = true;
2918                                         break;
2919                                 case KEY_UP:
2920                                         current_keys_pending.key_up = true;
2921                                         break;
2922                                 case KEY_DOWN:
2923                                         current_keys_pending.key_down = true;
2924                                         break;
2925                                 break;
2926                                 default:
2927                                         //can't happen at all!
2928                                         assert("reached a source line that can't ever been reached" == 0);
2929                                         break;
2930                         }
2931                         if (current_keys_pending.key_enter && m_allowclose) {
2932                                 acceptInput(quit_mode_accept);
2933                                 quitMenu();
2934                         } else {
2935                                 acceptInput();
2936                         }
2937                         return true;
2938                 }
2939
2940         }
2941
2942         /* Mouse event other than movement, or crossing the border of inventory
2943           field while holding right mouse button
2944          */
2945         if (event.EventType == EET_MOUSE_INPUT_EVENT &&
2946                         (event.MouseInput.Event != EMIE_MOUSE_MOVED ||
2947                          (event.MouseInput.Event == EMIE_MOUSE_MOVED &&
2948                           event.MouseInput.isRightPressed() &&
2949                           getItemAtPos(m_pointer).i != getItemAtPos(m_old_pointer).i))) {
2950
2951                 // Get selected item and hovered/clicked item (s)
2952
2953                 m_old_tooltip_id = -1;
2954                 updateSelectedItem();
2955                 ItemSpec s = getItemAtPos(m_pointer);
2956
2957                 Inventory *inv_selected = NULL;
2958                 Inventory *inv_s = NULL;
2959
2960                 if(m_selected_item) {
2961                         inv_selected = m_invmgr->getInventory(m_selected_item->inventoryloc);
2962                         assert(inv_selected);
2963                         assert(inv_selected->getList(m_selected_item->listname) != NULL);
2964                 }
2965
2966                 u32 s_count = 0;
2967
2968                 if(s.isValid())
2969                 do { // breakable
2970                         inv_s = m_invmgr->getInventory(s.inventoryloc);
2971
2972                         if(!inv_s) {
2973                                 errorstream<<"InventoryMenu: The selected inventory location "
2974                                                 <<"\""<<s.inventoryloc.dump()<<"\" doesn't exist"
2975                                                 <<std::endl;
2976                                 s.i = -1;  // make it invalid again
2977                                 break;
2978                         }
2979
2980                         InventoryList *list = inv_s->getList(s.listname);
2981                         if(list == NULL) {
2982                                 verbosestream<<"InventoryMenu: The selected inventory list \""
2983                                                 <<s.listname<<"\" does not exist"<<std::endl;
2984                                 s.i = -1;  // make it invalid again
2985                                 break;
2986                         }
2987
2988                         if((u32)s.i >= list->getSize()) {
2989                                 infostream<<"InventoryMenu: The selected inventory list \""
2990                                                 <<s.listname<<"\" is too small (i="<<s.i<<", size="
2991                                                 <<list->getSize()<<")"<<std::endl;
2992                                 s.i = -1;  // make it invalid again
2993                                 break;
2994                         }
2995
2996                         s_count = list->getItem(s.i).count;
2997                 } while(0);
2998
2999                 bool identical = (m_selected_item != NULL) && s.isValid() &&
3000                         (inv_selected == inv_s) &&
3001                         (m_selected_item->listname == s.listname) &&
3002                         (m_selected_item->i == s.i);
3003
3004                 // buttons: 0 = left, 1 = right, 2 = middle
3005                 // up/down: 0 = down (press), 1 = up (release), 2 = unknown event, -1 movement
3006                 int button = 0;
3007                 int updown = 2;
3008                 if(event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN)
3009                         { button = 0; updown = 0; }
3010                 else if(event.MouseInput.Event == EMIE_RMOUSE_PRESSED_DOWN)
3011                         { button = 1; updown = 0; }
3012                 else if(event.MouseInput.Event == EMIE_MMOUSE_PRESSED_DOWN)
3013                         { button = 2; updown = 0; }
3014                 else if(event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP)
3015                         { button = 0; updown = 1; }
3016                 else if(event.MouseInput.Event == EMIE_RMOUSE_LEFT_UP)
3017                         { button = 1; updown = 1; }
3018                 else if(event.MouseInput.Event == EMIE_MMOUSE_LEFT_UP)
3019                         { button = 2; updown = 1; }
3020                 else if(event.MouseInput.Event == EMIE_MOUSE_MOVED)
3021                         { updown = -1;}
3022
3023                 // Set this number to a positive value to generate a move action
3024                 // from m_selected_item to s.
3025                 u32 move_amount = 0;
3026
3027                 // Set this number to a positive value to generate a drop action
3028                 // from m_selected_item.
3029                 u32 drop_amount = 0;
3030
3031                 // Set this number to a positive value to generate a craft action at s.
3032                 u32 craft_amount = 0;
3033
3034                 if(updown == 0) {
3035                         // Some mouse button has been pressed
3036
3037                         //infostream<<"Mouse button "<<button<<" pressed at p=("
3038                         //      <<p.X<<","<<p.Y<<")"<<std::endl;
3039
3040                         m_selected_dragging = false;
3041
3042                         if(s.isValid() && s.listname == "craftpreview") {
3043                                 // Craft preview has been clicked: craft
3044                                 craft_amount = (button == 2 ? 10 : 1);
3045                         }
3046                         else if(m_selected_item == NULL) {
3047                                 if(s_count != 0) {
3048                                         // Non-empty stack has been clicked: select it
3049                                         m_selected_item = new ItemSpec(s);
3050
3051                                         if(button == 1)  // right
3052                                                 m_selected_amount = (s_count + 1) / 2;
3053                                         else if(button == 2)  // middle
3054                                                 m_selected_amount = MYMIN(s_count, 10);
3055                                         else  // left
3056                                                 m_selected_amount = s_count;
3057
3058                                         m_selected_dragging = true;
3059                                 }
3060                         }
3061                         else { // m_selected_item != NULL
3062                                 assert(m_selected_amount >= 1);
3063
3064                                 if(s.isValid()) {
3065                                         // Clicked a slot: move
3066                                         if(button == 1)  // right
3067                                                 move_amount = 1;
3068                                         else if(button == 2)  // middle
3069                                                 move_amount = MYMIN(m_selected_amount, 10);
3070                                         else  // left
3071                                                 move_amount = m_selected_amount;
3072
3073                                         if(identical) {
3074                                                 if(move_amount >= m_selected_amount)
3075                                                         m_selected_amount = 0;
3076                                                 else
3077                                                         m_selected_amount -= move_amount;
3078                                                 move_amount = 0;
3079                                         }
3080                                 }
3081                                 else if (!getAbsoluteClippingRect().isPointInside(m_pointer)) {
3082                                         // Clicked outside of the window: drop
3083                                         if(button == 1)  // right
3084                                                 drop_amount = 1;
3085                                         else if(button == 2)  // middle
3086                                                 drop_amount = MYMIN(m_selected_amount, 10);
3087                                         else  // left
3088                                                 drop_amount = m_selected_amount;
3089                                 }
3090                         }
3091                 }
3092                 else if(updown == 1) {
3093                         // Some mouse button has been released
3094
3095                         //infostream<<"Mouse button "<<button<<" released at p=("
3096                         //      <<p.X<<","<<p.Y<<")"<<std::endl;
3097
3098                         if(m_selected_item != NULL && m_selected_dragging && s.isValid()) {
3099                                 if(!identical) {
3100                                         // Dragged to different slot: move all selected
3101                                         move_amount = m_selected_amount;
3102                                 }
3103                         }
3104                         else if(m_selected_item != NULL && m_selected_dragging &&
3105                                 !(getAbsoluteClippingRect().isPointInside(m_pointer))) {
3106                                 // Dragged outside of window: drop all selected
3107                                 drop_amount = m_selected_amount;
3108                         }
3109
3110                         m_selected_dragging = false;
3111                 }
3112                 else if(updown == -1) {
3113                         // Mouse has been moved and rmb is down and mouse pointer just
3114                         // entered a new inventory field (checked in the entry-if, this
3115                         // is the only action here that is generated by mouse movement)
3116                         if(m_selected_item != NULL && s.isValid()){
3117                                 // Move 1 item
3118                                 // TODO: middle mouse to move 10 items might be handy
3119                                 move_amount = 1;
3120                         }
3121                 }
3122
3123                 // Possibly send inventory action to server
3124                 if(move_amount > 0)
3125                 {
3126                         // Send IACTION_MOVE
3127
3128                         assert(m_selected_item && m_selected_item->isValid());
3129                         assert(s.isValid());
3130
3131                         assert(inv_selected && inv_s);
3132                         InventoryList *list_from = inv_selected->getList(m_selected_item->listname);
3133                         InventoryList *list_to = inv_s->getList(s.listname);
3134                         assert(list_from && list_to);
3135                         ItemStack stack_from = list_from->getItem(m_selected_item->i);
3136                         ItemStack stack_to = list_to->getItem(s.i);
3137
3138                         // Check how many items can be moved
3139                         move_amount = stack_from.count = MYMIN(move_amount, stack_from.count);
3140                         ItemStack leftover = stack_to.addItem(stack_from, m_gamedef->idef());
3141                         // If source stack cannot be added to destination stack at all,
3142                         // they are swapped
3143                         if ((leftover.count == stack_from.count) &&
3144                                         (leftover.name == stack_from.name)) {
3145                                 m_selected_amount = stack_to.count;
3146                                 // In case the server doesn't directly swap them but instead
3147                                 // moves stack_to somewhere else, set this
3148                                 m_selected_content_guess = stack_to;
3149                                 m_selected_content_guess_inventory = s.inventoryloc;
3150                         }
3151                         // Source stack goes fully into destination stack
3152                         else if(leftover.empty()) {
3153                                 m_selected_amount -= move_amount;
3154                                 m_selected_content_guess = ItemStack(); // Clear
3155                         }
3156                         // Source stack goes partly into destination stack
3157                         else {
3158                                 move_amount -= leftover.count;
3159                                 m_selected_amount -= move_amount;
3160                                 m_selected_content_guess = ItemStack(); // Clear
3161                         }
3162
3163                         infostream<<"Handing IACTION_MOVE to manager"<<std::endl;
3164                         IMoveAction *a = new IMoveAction();
3165                         a->count = move_amount;
3166                         a->from_inv = m_selected_item->inventoryloc;
3167                         a->from_list = m_selected_item->listname;
3168                         a->from_i = m_selected_item->i;
3169                         a->to_inv = s.inventoryloc;
3170                         a->to_list = s.listname;
3171                         a->to_i = s.i;
3172                         m_invmgr->inventoryAction(a);
3173                 }
3174                 else if(drop_amount > 0) {
3175                         m_selected_content_guess = ItemStack(); // Clear
3176
3177                         // Send IACTION_DROP
3178
3179                         assert(m_selected_item && m_selected_item->isValid());
3180                         assert(inv_selected);
3181                         InventoryList *list_from = inv_selected->getList(m_selected_item->listname);
3182                         assert(list_from);
3183                         ItemStack stack_from = list_from->getItem(m_selected_item->i);
3184
3185                         // Check how many items can be dropped
3186                         drop_amount = stack_from.count = MYMIN(drop_amount, stack_from.count);
3187                         assert(drop_amount > 0 && drop_amount <= m_selected_amount);
3188                         m_selected_amount -= drop_amount;
3189
3190                         infostream<<"Handing IACTION_DROP to manager"<<std::endl;
3191                         IDropAction *a = new IDropAction();
3192                         a->count = drop_amount;
3193                         a->from_inv = m_selected_item->inventoryloc;
3194                         a->from_list = m_selected_item->listname;
3195                         a->from_i = m_selected_item->i;
3196                         m_invmgr->inventoryAction(a);
3197                 }
3198                 else if(craft_amount > 0) {
3199                         m_selected_content_guess = ItemStack(); // Clear
3200
3201                         // Send IACTION_CRAFT
3202
3203                         assert(s.isValid());
3204                         assert(inv_s);
3205
3206                         infostream<<"Handing IACTION_CRAFT to manager"<<std::endl;
3207                         ICraftAction *a = new ICraftAction();
3208                         a->count = craft_amount;
3209                         a->craft_inv = s.inventoryloc;
3210                         m_invmgr->inventoryAction(a);
3211                 }
3212
3213                 // If m_selected_amount has been decreased to zero, deselect
3214                 if(m_selected_amount == 0) {
3215                         delete m_selected_item;
3216                         m_selected_item = NULL;
3217                         m_selected_amount = 0;
3218                         m_selected_dragging = false;
3219                         m_selected_content_guess = ItemStack();
3220                 }
3221                 m_old_pointer = m_pointer;
3222         }
3223         if(event.EventType==EET_GUI_EVENT) {
3224
3225                 if(event.GUIEvent.EventType==gui::EGET_TAB_CHANGED
3226                                 && isVisible()) {
3227                         // find the element that was clicked
3228                         for(unsigned int i=0; i<m_fields.size(); i++) {
3229                                 FieldSpec &s = m_fields[i];
3230                                 if ((s.ftype == f_TabHeader) &&
3231                                                 (s.fid == event.GUIEvent.Caller->getID())) {
3232                                         s.send = true;
3233                                         acceptInput();
3234                                         s.send = false;
3235                                         return true;
3236                                 }
3237                         }
3238                 }
3239                 if(event.GUIEvent.EventType==gui::EGET_ELEMENT_FOCUS_LOST
3240                                 && isVisible()) {
3241                         if(!canTakeFocus(event.GUIEvent.Element)) {
3242                                 infostream<<"GUIFormSpecMenu: Not allowing focus change."
3243                                                 <<std::endl;
3244                                 // Returning true disables focus change
3245                                 return true;
3246                         }
3247                 }
3248                 if((event.GUIEvent.EventType == gui::EGET_BUTTON_CLICKED) ||
3249                                 (event.GUIEvent.EventType == gui::EGET_CHECKBOX_CHANGED) ||
3250                                 (event.GUIEvent.EventType == gui::EGET_COMBO_BOX_CHANGED) ||
3251                                 (event.GUIEvent.EventType == gui::EGET_SCROLL_BAR_CHANGED)) {
3252                         unsigned int btn_id = event.GUIEvent.Caller->getID();
3253
3254                         if (btn_id == 257) {
3255                                 if (m_allowclose) {
3256                                         acceptInput(quit_mode_accept);
3257                                         quitMenu();
3258                                 } else {
3259                                         acceptInput();
3260                                         m_text_dst->gotText(narrow_to_wide("ExitButton"));
3261                                 }
3262                                 // quitMenu deallocates menu
3263                                 return true;
3264                         }
3265
3266                         // find the element that was clicked
3267                         for(u32 i=0; i<m_fields.size(); i++) {
3268                                 FieldSpec &s = m_fields[i];
3269                                 // if its a button, set the send field so
3270                                 // lua knows which button was pressed
3271                                 if (((s.ftype == f_Button) || (s.ftype == f_CheckBox)) &&
3272                                                 (s.fid == event.GUIEvent.Caller->getID())) {
3273                                         s.send = true;
3274                                         if(s.is_exit) {
3275                                                 if (m_allowclose) {
3276                                                         acceptInput(quit_mode_accept);
3277                                                         quitMenu();
3278                                                 } else {
3279                                                         m_text_dst->gotText(narrow_to_wide("ExitButton"));
3280                                                 }
3281                                                 return true;
3282                                         } else {
3283                                                 acceptInput(quit_mode_no);
3284                                                 s.send = false;
3285                                                 return true;
3286                                         }
3287                                 }
3288                                 else if ((s.ftype == f_DropDown) &&
3289                                                 (s.fid == event.GUIEvent.Caller->getID())) {
3290                                         // only send the changed dropdown
3291                                         for(u32 i=0; i<m_fields.size(); i++) {
3292                                                 FieldSpec &s2 = m_fields[i];
3293                                                 if (s2.ftype == f_DropDown) {
3294                                                         s2.send = false;
3295                                                 }
3296                                         }
3297                                         s.send = true;
3298                                         acceptInput(quit_mode_no);
3299
3300                                         // revert configuration to make sure dropdowns are sent on
3301                                         // regular button click
3302                                         for(u32 i=0; i<m_fields.size(); i++) {
3303                                                 FieldSpec &s2 = m_fields[i];
3304                                                 if (s2.ftype == f_DropDown) {
3305                                                         s2.send = true;
3306                                                 }
3307                                         }
3308                                         return true;
3309                                 }
3310                                 else if ((s.ftype == f_ScrollBar) &&
3311                                         (s.fid == event.GUIEvent.Caller->getID()))
3312                                 {
3313                                         s.fdefault = L"Changed";
3314                                         acceptInput(quit_mode_no);
3315                                         s.fdefault = L"";
3316                                 }
3317                         }
3318                 }
3319
3320                 if(event.GUIEvent.EventType == gui::EGET_EDITBOX_ENTER) {
3321                         if(event.GUIEvent.Caller->getID() > 257) {
3322
3323                                 if (m_allowclose) {
3324                                         acceptInput(quit_mode_accept);
3325                                         quitMenu();
3326                                 } else {
3327                                         current_keys_pending.key_enter = true;
3328                                         acceptInput();
3329                                 }
3330                                 // quitMenu deallocates menu
3331                                 return true;
3332                         }
3333                 }
3334
3335                 if(event.GUIEvent.EventType == gui::EGET_TABLE_CHANGED) {
3336                         int current_id = event.GUIEvent.Caller->getID();
3337                         if(current_id > 257) {
3338                                 // find the element that was clicked
3339                                 for(u32 i=0; i<m_fields.size(); i++) {
3340                                         FieldSpec &s = m_fields[i];
3341                                         // if it's a table, set the send field
3342                                         // so lua knows which table was changed
3343                                         if ((s.ftype == f_Table) && (s.fid == current_id)) {
3344                                                 s.send = true;
3345                                                 acceptInput();
3346                                                 s.send=false;
3347                                         }
3348                                 }
3349                                 return true;
3350                         }
3351                 }
3352         }
3353
3354         return Parent ? Parent->OnEvent(event) : false;
3355 }
3356
3357 /**
3358  * get name of element by element id
3359  * @param id of element
3360  * @return name string or empty string
3361  */
3362 std::wstring GUIFormSpecMenu::getNameByID(s32 id)
3363 {
3364         for(std::vector<FieldSpec>::iterator iter =  m_fields.begin();
3365                                 iter != m_fields.end(); iter++) {
3366                 if (iter->fid == id) {
3367                         return iter->fname;
3368                 }
3369         }
3370         return L"";
3371 }
3372
3373 /**
3374  * get label of element by id
3375  * @param id of element
3376  * @return label string or empty string
3377  */
3378 std::wstring GUIFormSpecMenu::getLabelByID(s32 id)
3379 {
3380         for(std::vector<FieldSpec>::iterator iter =  m_fields.begin();
3381                                 iter != m_fields.end(); iter++) {
3382                 if (iter->fid == id) {
3383                         return iter->flabel;
3384                 }
3385         }
3386         return L"";
3387 }