src/guiFormSpecMenu.cpp

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2010 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 "guiFormSpecMenu.h"
  22 #include "constants.h"
  23 #include "gamedef.h"
  24 #include "keycode.h"
  25 #include "strfnd.h"
  26 #include <IGUICheckBox.h>
  27 #include <IGUIEditBox.h>
  28 #include <IGUIButton.h>
  29 #include <IGUIStaticText.h>
  30 #include <IGUIFont.h>
  31 #include "log.h"
  32 #include "tile.h" // ITextureSource
  33 #include "util/string.h"
  34 #include "util/numeric.h"
  35
  36 #include "gettext.h"
  37
  38 void drawItemStack(video::IVideoDriver *driver,
  39                 gui::IGUIFont *font,
  40                 const ItemStack &item,
  41                 const core::rect<s32> &rect,
  42                 const core::rect<s32> *clip,
  43                 IGameDef *gamedef)
  44 {
  45         if(item.empty())
  46                 return;
  47
  48         const ItemDefinition &def = item.getDefinition(gamedef->idef());
  49         video::ITexture *texture = def.inventory_texture;
  50
  51         // Draw the inventory texture
  52         if(texture != NULL)
  53         {
  54                 const video::SColor color(255,255,255,255);
  55                 const video::SColor colors[] = {color,color,color,color};
  56                 driver->draw2DImage(texture, rect,
  57                         core::rect<s32>(core::position2d<s32>(0,0),
  58                         core::dimension2di(texture->getOriginalSize())),
  59                         clip, colors, true);
  60         }
  61
  62         if(def.type == ITEM_TOOL && item.wear != 0)
  63         {
  64                 // Draw a progressbar
  65                 float barheight = rect.getHeight()/16;
  66                 float barpad_x = rect.getWidth()/16;
  67                 float barpad_y = rect.getHeight()/16;
  68                 core::rect<s32> progressrect(
  69                         rect.UpperLeftCorner.X + barpad_x,
  70                         rect.LowerRightCorner.Y - barpad_y - barheight,
  71                         rect.LowerRightCorner.X - barpad_x,
  72                         rect.LowerRightCorner.Y - barpad_y);
  73
  74                 // Shrink progressrect by amount of tool damage
  75                 float wear = item.wear / 65535.0;
  76                 int progressmid =
  77                         wear * progressrect.UpperLeftCorner.X +
  78                         (1-wear) * progressrect.LowerRightCorner.X;
  79
  80                 // Compute progressbar color
  81                 //   wear = 0.0: green
  82                 //   wear = 0.5: yellow
  83                 //   wear = 1.0: red
  84                 video::SColor color(255,255,255,255);
  85                 int wear_i = MYMIN(floor(wear * 600), 511);
  86                 wear_i = MYMIN(wear_i + 10, 511);
  87                 if(wear_i <= 255)
  88                         color.set(255, wear_i, 255, 0);
  89                 else
  90                         color.set(255, 255, 511-wear_i, 0);
  91
  92                 core::rect<s32> progressrect2 = progressrect;
  93                 progressrect2.LowerRightCorner.X = progressmid;
  94                 driver->draw2DRectangle(color, progressrect2, clip);
  95
  96                 color = video::SColor(255,0,0,0);
  97                 progressrect2 = progressrect;
  98                 progressrect2.UpperLeftCorner.X = progressmid;
  99                 driver->draw2DRectangle(color, progressrect2, clip);
 100         }
 101
 102         if(font != NULL && item.count >= 2)
 103         {
 104                 // Get the item count as a string
 105                 std::string text = itos(item.count);
 106                 v2u32 dim = font->getDimension(narrow_to_wide(text).c_str());
 107                 v2s32 sdim(dim.X,dim.Y);
 108
 109                 core::rect<s32> rect2(
 110                         /*rect.UpperLeftCorner,
 111                         core::dimension2d<u32>(rect.getWidth(), 15)*/
 112                         rect.LowerRightCorner - sdim,
 113                         sdim
 114                 );
 115
 116                 video::SColor bgcolor(128,0,0,0);
 117                 driver->draw2DRectangle(bgcolor, rect2, clip);
 118
 119                 video::SColor color(255,255,255,255);
 120                 font->draw(text.c_str(), rect2, color, false, false, clip);
 121         }
 122 }
 123
 124 /*
 125         GUIFormSpecMenu
 126 */
 127
 128 GUIFormSpecMenu::GUIFormSpecMenu(irr::IrrlichtDevice* dev,
 129                 gui::IGUIElement* parent, s32 id,
 130                 IMenuManager *menumgr,
 131                 InventoryManager *invmgr,
 132                 IGameDef *gamedef
 133 ):
 134         GUIModalMenu(dev->getGUIEnvironment(), parent, id, menumgr),
 135         m_device(dev),
 136         m_invmgr(invmgr),
 137         m_gamedef(gamedef),
 138         m_form_src(NULL),
 139         m_text_dst(NULL),
 140         m_selected_item(NULL),
 141         m_selected_amount(0),
 142         m_selected_dragging(false),
 143         m_tooltip_element(NULL)
 144 {
 145 }
 146
 147 GUIFormSpecMenu::~GUIFormSpecMenu()
 148 {
 149         removeChildren();
 150
 151         delete m_selected_item;
 152         delete m_form_src;
 153         delete m_text_dst;
 154 }
 155
 156 void GUIFormSpecMenu::removeChildren()
 157 {
 158         const core::list<gui::IGUIElement*> &children = getChildren();
 159         core::list<gui::IGUIElement*> children_copy;
 160         for(core::list<gui::IGUIElement*>::ConstIterator
 161                         i = children.begin(); i != children.end(); i++)
 162         {
 163                 children_copy.push_back(*i);
 164         }
 165         for(core::list<gui::IGUIElement*>::Iterator
 166                         i = children_copy.begin();
 167                         i != children_copy.end(); i++)
 168         {
 169                 (*i)->remove();
 170         }
 171         /*{
 172                 gui::IGUIElement *e = getElementFromId(256);
 173                 if(e != NULL)
 174                         e->remove();
 175         }*/
 176         if(m_tooltip_element)
 177         {
 178                 m_tooltip_element->remove();
 179                 m_tooltip_element = NULL;
 180         }
 181 }
 182
 183 void GUIFormSpecMenu::regenerateGui(v2u32 screensize)
 184 {
 185         // Remove children
 186         removeChildren();
 187
 188         v2s32 size(100,100);
 189         s32 helptext_h = 15;
 190         core::rect<s32> rect;
 191
 192         // Base position of contents of form
 193         v2s32 basepos = getBasePos();
 194         // State of basepos, 0 = not set, 1= set by formspec, 2 = set by size[] element
 195         // Used to adjust form size automatically if needed
 196         // A proceed button is added if there is no size[] element
 197         int bp_set = 0;
 198
 199         /* Convert m_init_draw_spec to m_inventorylists */
 200
 201         m_inventorylists.clear();
 202         m_images.clear();
 203         m_backgrounds.clear();
 204         m_fields.clear();
 205
 206         Strfnd f(m_formspec_string);
 207         while(f.atend() == false)
 208         {
 209                 std::string type = trim(f.next("["));
 210                 if(type == "invsize" || type == "size")
 211                 {
 212                         v2f invsize;
 213                         invsize.X = stof(f.next(","));
 214                         if(type == "size")
 215                         {
 216                                 invsize.Y = stof(f.next("]"));
 217                         }
 218                         else{
 219                                 invsize.Y = stof(f.next(";"));
 220                                 f.next("]");
 221                         }
 222                         infostream<<"Form size ("<<invsize.X<<","<<invsize.Y<<")"<<std::endl;
 223
 224                         padding = v2s32(screensize.Y/40, screensize.Y/40);
 225                         spacing = v2s32(screensize.Y/12, screensize.Y/13);
 226                         imgsize = v2s32(screensize.Y/15, screensize.Y/15);
 227                         size = v2s32(
 228                                 padding.X*2+spacing.X*(invsize.X-1.0)+imgsize.X,
 229                                 padding.Y*2+spacing.Y*(invsize.Y-1.0)+imgsize.Y + (helptext_h-5)
 230                         );
 231                         rect = core::rect<s32>(
 232                                         screensize.X/2 - size.X/2,
 233                                         screensize.Y/2 - size.Y/2,
 234                                         screensize.X/2 + size.X/2,
 235                                         screensize.Y/2 + size.Y/2
 236                         );
 237                         DesiredRect = rect;
 238                         recalculateAbsolutePosition(false);
 239                         basepos = getBasePos();
 240                         bp_set = 2;
 241                 }
 242                 else if(type == "list")
 243                 {
 244                         std::string name = f.next(";");
 245                         InventoryLocation loc;
 246                         if(name == "context" || name == "current_name")
 247                                 loc = m_current_inventory_location;
 248                         else
 249                                 loc.deSerialize(name);
 250                         std::string listname = f.next(";");
 251                         v2s32 pos = basepos;
 252                         pos.X += stof(f.next(",")) * (float)spacing.X;
 253                         pos.Y += stof(f.next(";")) * (float)spacing.Y;
 254                         v2s32 geom;
 255                         geom.X = stoi(f.next(","));
 256                         geom.Y = stoi(f.next(";"));
 257                         infostream<<"list inv="<<name<<", listname="<<listname
 258                                         <<", pos=("<<pos.X<<","<<pos.Y<<")"
 259                                         <<", geom=("<<geom.X<<","<<geom.Y<<")"
 260                                         <<std::endl;
 261                         std::string start_i_s = f.next("]");
 262                         s32 start_i = 0;
 263                         if(start_i_s != "")
 264                                 start_i = stoi(start_i_s);
 265                         if(bp_set != 2)
 266                                 errorstream<<"WARNING: invalid use of list without a size[] element"<<std::endl;
 267                         m_inventorylists.push_back(ListDrawSpec(loc, listname, pos, geom, start_i));
 268                 }
 269                 else if(type == "image")
 270                 {
 271                         v2s32 pos = basepos;
 272                         pos.X += stof(f.next(",")) * (float)spacing.X;
 273                         pos.Y += stof(f.next(";")) * (float)spacing.Y;
 274                         v2s32 geom;
 275                         geom.X = stof(f.next(",")) * (float)imgsize.X;
 276                         geom.Y = stof(f.next(";")) * (float)imgsize.Y;
 277                         std::string name = f.next("]");
 278                         infostream<<"image name="<<name
 279                                         <<", pos=("<<pos.X<<","<<pos.Y<<")"
 280                                         <<", geom=("<<geom.X<<","<<geom.Y<<")"
 281                                         <<std::endl;
 282                         if(bp_set != 2)
 283                                 errorstream<<"WARNING: invalid use of image without a size[] element"<<std::endl;
 284                         m_images.push_back(ImageDrawSpec(name, pos, geom));
 285                 }
 286                 else if(type == "background")
 287                 {
 288                         v2s32 pos = basepos;
 289                         pos.X += stof(f.next(",")) * (float)spacing.X - ((float)spacing.X-(float)imgsize.X)/2;
 290                         pos.Y += stof(f.next(";")) * (float)spacing.Y - ((float)spacing.Y-(float)imgsize.Y)/2;
 291                         v2s32 geom;
 292                         geom.X = stof(f.next(",")) * (float)spacing.X;
 293                         geom.Y = stof(f.next(";")) * (float)spacing.Y;
 294                         std::string name = f.next("]");
 295                         infostream<<"image name="<<name
 296                                         <<", pos=("<<pos.X<<","<<pos.Y<<")"
 297                                         <<", geom=("<<geom.X<<","<<geom.Y<<")"
 298                                         <<std::endl;
 299                         if(bp_set != 2)
 300                                 errorstream<<"WARNING: invalid use of background without a size[] element"<<std::endl;
 301                         m_backgrounds.push_back(ImageDrawSpec(name, pos, geom));
 302                 }
 303                 else if(type == "field")
 304                 {
 305                         std::string fname = f.next(";");
 306                         std::string flabel = f.next(";");
 307
 308                         if(fname.find(",") == std::string::npos && flabel.find(",") == std::string::npos)
 309                         {
 310                                 if(!bp_set)
 311                                 {
 312                                         rect = core::rect<s32>(
 313                                                 screensize.X/2 - 580/2,
 314                                                 screensize.Y/2 - 300/2,
 315                                                 screensize.X/2 + 580/2,
 316                                                 screensize.Y/2 + 300/2
 317                                         );
 318                                         DesiredRect = rect;
 319                                         recalculateAbsolutePosition(false);
 320                                         basepos = getBasePos();
 321                                         bp_set = 1;
 322                                 }
 323                                 else if(bp_set == 2)
 324                                         errorstream<<"WARNING: invalid use of unpositioned field in inventory"<<std::endl;
 325
 326                                 v2s32 pos = basepos;
 327                                 pos.Y = ((m_fields.size()+2)*60);
 328                                 v2s32 size = DesiredRect.getSize();
 329                                 rect = core::rect<s32>(size.X/2-150, pos.Y, (size.X/2-150)+300, pos.Y+30);
 330                         }
 331                         else
 332                         {
 333                                 v2s32 pos;
 334                                 pos.X = stof(fname.substr(0,fname.find(","))) * (float)spacing.X;
 335                                 pos.Y = stof(fname.substr(fname.find(",")+1)) * (float)spacing.Y;
 336                                 v2s32 geom;
 337                                 geom.X = (stof(flabel.substr(0,flabel.find(","))) * (float)spacing.X)-(spacing.X-imgsize.X);
 338                                 pos.Y += (stof(flabel.substr(flabel.find(",")+1)) * (float)imgsize.Y)/2;
 339
 340                                 rect = core::rect<s32>(pos.X, pos.Y-15, pos.X+geom.X, pos.Y+15);
 341
 342                                 fname = f.next(";");
 343                                 flabel = f.next(";");
 344                                 if(bp_set != 2)
 345                                         errorstream<<"WARNING: invalid use of positioned field without a size[] element"<<std::endl;
 346
 347                         }
 348
 349                         std::string odefault = f.next("]");
 350                         std::string fdefault;
 351
 352                         // fdefault may contain a variable reference, which
 353                         // needs to be resolved from the node metadata
 354                         if(m_form_src)
 355                                 fdefault = m_form_src->resolveText(odefault);
 356                         else
 357                                 fdefault = odefault;
 358
 359                         FieldSpec spec = FieldSpec(
 360                                 narrow_to_wide(fname.c_str()),
 361                                 narrow_to_wide(flabel.c_str()),
 362                                 narrow_to_wide(fdefault.c_str()),
 363                                 258+m_fields.size()
 364                         );
 365
 366                         // three cases: field and no label, label and no field, label and field
 367                         if (flabel == "")
 368                         {
 369                                 spec.send = true;
 370                                 gui::IGUIElement *e = Environment->addEditBox(spec.fdefault.c_str(), rect, true, this, spec.fid);
 371                                 Environment->setFocus(e);
 372
 373                                 irr::SEvent evt;
 374                                 evt.EventType = EET_KEY_INPUT_EVENT;
 375                                 evt.KeyInput.Key = KEY_END;
 376                                 evt.KeyInput.PressedDown = true;
 377                                 e->OnEvent(evt);
 378                         }
 379                         else if (fname == "")
 380                         {
 381                                 // set spec field id to 0, this stops submit searching for a value that isn't there
 382                                 Environment->addStaticText(spec.flabel.c_str(), rect, false, true, this, spec.fid);
 383                         }
 384                         else
 385                         {
 386                                 spec.send = true;
 387                                 gui::IGUIElement *e = Environment->addEditBox(spec.fdefault.c_str(), rect, true, this, spec.fid);
 388                                 Environment->setFocus(e);
 389                                 rect.UpperLeftCorner.Y -= 15;
 390                                 rect.LowerRightCorner.Y -= 15;
 391                                 Environment->addStaticText(spec.flabel.c_str(), rect, false, true, this, 0);
 392
 393                                 irr::SEvent evt;
 394                                 evt.EventType = EET_KEY_INPUT_EVENT;
 395                                 evt.KeyInput.Key = KEY_END;
 396                                 evt.KeyInput.PressedDown = true;
 397                                 e->OnEvent(evt);
 398                         }
 399
 400                         m_fields.push_back(spec);
 401                 }
 402                 else if(type == "label")
 403                 {
 404                         v2s32 pos = padding;
 405                         pos.X += stof(f.next(",")) * (float)spacing.X;
 406                         pos.Y += stof(f.next(";")) * (float)spacing.Y;
 407
 408                         rect = core::rect<s32>(pos.X, pos.Y+((imgsize.Y/2)-15), pos.X+300, pos.Y+((imgsize.Y/2)+15));
 409
 410                         std::string flabel = f.next("]");
 411                         if(bp_set != 2)
 412                                 errorstream<<"WARNING: invalid use of label without a size[] element"<<std::endl;
 413
 414                         FieldSpec spec = FieldSpec(
 415                                 narrow_to_wide(""),
 416                                 narrow_to_wide(flabel.c_str()),
 417                                 narrow_to_wide(""),
 418                                 258+m_fields.size()
 419                         );
 420                         Environment->addStaticText(spec.flabel.c_str(), rect, false, true, this, spec.fid);
 421                         m_fields.push_back(spec);
 422                 }
 423                 else if(type == "button" || type == "button_exit")
 424                 {
 425                         v2s32 pos = padding;
 426                         pos.X += stof(f.next(",")) * (float)spacing.X;
 427                         pos.Y += stof(f.next(";")) * (float)spacing.Y;
 428                         v2s32 geom;
 429                         geom.X = (stof(f.next(",")) * (float)spacing.X)-(spacing.X-imgsize.X);
 430                         pos.Y += (stof(f.next(";")) * (float)imgsize.Y)/2;
 431
 432                         rect = core::rect<s32>(pos.X, pos.Y-15, pos.X+geom.X, pos.Y+15);
 433
 434                         std::string fname = f.next(";");
 435                         std::string flabel = f.next("]");
 436                         if(bp_set != 2)
 437                                 errorstream<<"WARNING: invalid use of button without a size[] element"<<std::endl;
 438
 439                         FieldSpec spec = FieldSpec(
 440                                 narrow_to_wide(fname.c_str()),
 441                                 narrow_to_wide(flabel.c_str()),
 442                                 narrow_to_wide(""),
 443                                 258+m_fields.size()
 444                         );
 445                         spec.is_button = true;
 446                         if(type == "button_exit")
 447                                 spec.is_exit = true;
 448                         Environment->addButton(rect, this, spec.fid, spec.flabel.c_str());
 449                         m_fields.push_back(spec);
 450                 }
 451                 else if(type == "image_button" || type == "image_button_exit")
 452                 {
 453                         v2s32 pos = padding;
 454                         pos.X += stof(f.next(",")) * (float)spacing.X;
 455                         pos.Y += stof(f.next(";")) * (float)spacing.Y;
 456                         v2s32 geom;
 457                         geom.X = (stof(f.next(",")) * (float)spacing.X)-(spacing.X-imgsize.X);
 458                         geom.Y = (stof(f.next(";")) * (float)spacing.Y)-(spacing.Y-imgsize.Y);
 459
 460                         rect = core::rect<s32>(pos.X, pos.Y, pos.X+geom.X, pos.Y+geom.Y);
 461
 462                         std::string fimage = f.next(";");
 463                         std::string fname = f.next(";");
 464                         std::string flabel = f.next("]");
 465                         if(bp_set != 2)
 466                                 errorstream<<"WARNING: invalid use of image_button without a size[] element"<<std::endl;
 467
 468                         FieldSpec spec = FieldSpec(
 469                                 narrow_to_wide(fname.c_str()),
 470                                 narrow_to_wide(flabel.c_str()),
 471                                 narrow_to_wide(fimage.c_str()),
 472                                 258+m_fields.size()
 473                         );
 474                         spec.is_button = true;
 475                         if(type == "image_button_exit")
 476                                 spec.is_exit = true;
 477
 478                         video::ITexture *texture = m_gamedef->tsrc()->getTextureRaw(fimage);
 479                         gui::IGUIButton *e = Environment->addButton(rect, this, spec.fid, spec.flabel.c_str());
 480                         e->setUseAlphaChannel(true);
 481                         e->setImage(texture);
 482                         e->setPressedImage(texture);
 483                         e->setScaleImage(true);
 484
 485                         m_fields.push_back(spec);
 486                 }
 487                 else
 488                 {
 489                         // Ignore others
 490                         std::string ts = f.next("]");
 491                         infostream<<"Unknown DrawSpec: type="<<type<<", data=\""<<ts<<"\""
 492                                         <<std::endl;
 493                 }
 494         }
 495
 496         // If there's inventory, put the usage string at the bottom
 497         if (m_inventorylists.size())
 498         {
 499                 changeCtype("");
 500                 core::rect<s32> rect(0, 0, size.X-padding.X*2, helptext_h);
 501                 rect = rect + v2s32(size.X/2 - rect.getWidth()/2,
 502                                 size.Y-rect.getHeight()-5);
 503                 const wchar_t *text = wgettext("Left click: Move all items, Right click: Move single item");
 504                 Environment->addStaticText(text, rect, false, true, this, 256);
 505                 changeCtype("C");
 506         }
 507         // If there's fields, add a Proceed button
 508         if (m_fields.size() && bp_set != 2)
 509         {
 510                 // if the size wasn't set by an invsize[] or size[] adjust it now to fit all the fields
 511                 rect = core::rect<s32>(
 512                         screensize.X/2 - 580/2,
 513                         screensize.Y/2 - 300/2,
 514                         screensize.X/2 + 580/2,
 515                         screensize.Y/2 + 240/2+(m_fields.size()*60)
 516                 );
 517                 DesiredRect = rect;
 518                 recalculateAbsolutePosition(false);
 519                 basepos = getBasePos();
 520
 521                 changeCtype("");
 522                 {
 523                         v2s32 pos = basepos;
 524                         pos.Y = ((m_fields.size()+2)*60);
 525
 526                         v2s32 size = DesiredRect.getSize();
 527                         rect = core::rect<s32>(size.X/2-70, pos.Y, (size.X/2-70)+140, pos.Y+30);
 528                         Environment->addButton(rect, this, 257, wgettext("Proceed"));
 529                 }
 530                 changeCtype("C");
 531         }
 532         // Add tooltip
 533         {
 534                 // Note: parent != this so that the tooltip isn't clipped by the menu rectangle
 535                 m_tooltip_element = Environment->addStaticText(L"",core::rect<s32>(0,0,110,18));
 536                 m_tooltip_element->enableOverrideColor(true);
 537                 m_tooltip_element->setBackgroundColor(video::SColor(255,110,130,60));
 538                 m_tooltip_element->setDrawBackground(true);
 539                 m_tooltip_element->setDrawBorder(true);
 540                 m_tooltip_element->setOverrideColor(video::SColor(255,255,255,255));
 541                 m_tooltip_element->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_CENTER);
 542                 m_tooltip_element->setWordWrap(false);
 543         }
 544 }
 545
 546 GUIFormSpecMenu::ItemSpec GUIFormSpecMenu::getItemAtPos(v2s32 p) const
 547 {
 548         core::rect<s32> imgrect(0,0,imgsize.X,imgsize.Y);
 549
 550         for(u32 i=0; i<m_inventorylists.size(); i++)
 551         {
 552                 const ListDrawSpec &s = m_inventorylists[i];
 553
 554                 for(s32 i=0; i<s.geom.X*s.geom.Y; i++)
 555                 {
 556                         s32 item_i = i + s.start_item_i;
 557                         s32 x = (i%s.geom.X) * spacing.X;
 558                         s32 y = (i/s.geom.X) * spacing.Y;
 559                         v2s32 p0(x,y);
 560                         core::rect<s32> rect = imgrect + s.pos + p0;
 561                         if(rect.isPointInside(p))
 562                         {
 563                                 return ItemSpec(s.inventoryloc, s.listname, item_i);
 564                         }
 565                 }
 566         }
 567
 568         return ItemSpec(InventoryLocation(), "", -1);
 569 }
 570
 571 void GUIFormSpecMenu::drawList(const ListDrawSpec &s, int phase)
 572 {
 573         video::IVideoDriver* driver = Environment->getVideoDriver();
 574
 575         // Get font
 576         gui::IGUIFont *font = NULL;
 577         gui::IGUISkin* skin = Environment->getSkin();
 578         if (skin)
 579                 font = skin->getFont();
 580
 581         Inventory *inv = m_invmgr->getInventory(s.inventoryloc);
 582         if(!inv){
 583                 infostream<<"GUIFormSpecMenu::drawList(): WARNING: "
 584                                 <<"The inventory location "
 585                                 <<"\""<<s.inventoryloc.dump()<<"\" doesn't exist"
 586                                 <<std::endl;
 587                 return;
 588         }
 589         InventoryList *ilist = inv->getList(s.listname);
 590         if(!ilist){
 591                 infostream<<"GUIFormSpecMenu::drawList(): WARNING: "
 592                                 <<"The inventory list \""<<s.listname<<"\" @ \""
 593                                 <<s.inventoryloc.dump()<<"\" doesn't exist"
 594                                 <<std::endl;
 595                 return;
 596         }
 597
 598         core::rect<s32> imgrect(0,0,imgsize.X,imgsize.Y);
 599
 600         for(s32 i=0; i<s.geom.X*s.geom.Y; i++)
 601         {
 602                 u32 item_i = i + s.start_item_i;
 603                 if(item_i >= ilist->getSize())
 604                         break;
 605                 s32 x = (i%s.geom.X) * spacing.X;
 606                 s32 y = (i/s.geom.X) * spacing.Y;
 607                 v2s32 p(x,y);
 608                 core::rect<s32> rect = imgrect + s.pos + p;
 609                 ItemStack item;
 610                 if(ilist)
 611                         item = ilist->getItem(item_i);
 612
 613                 bool selected = m_selected_item
 614                         && m_invmgr->getInventory(m_selected_item->inventoryloc) == inv
 615                         && m_selected_item->listname == s.listname
 616                         && m_selected_item->i == i;
 617                 bool hovering = rect.isPointInside(m_pointer);
 618
 619                 if(phase == 0)
 620                 {
 621                         if(hovering && m_selected_item)
 622                         {
 623                                 video::SColor bgcolor(255,192,192,192);
 624                                 driver->draw2DRectangle(bgcolor, rect, &AbsoluteClippingRect);
 625                         }
 626                         else
 627                         {
 628                                 video::SColor bgcolor(255,128,128,128);
 629                                 driver->draw2DRectangle(bgcolor, rect, &AbsoluteClippingRect);
 630                         }
 631                 }
 632
 633                 if(phase == 1)
 634                 {
 635                         // Draw item stack
 636                         if(selected)
 637                         {
 638                                 item.takeItem(m_selected_amount);
 639                         }
 640                         if(!item.empty())
 641                         {
 642                                 drawItemStack(driver, font, item,
 643                                                 rect, &AbsoluteClippingRect, m_gamedef);
 644                         }
 645
 646                         // Draw tooltip
 647                         std::string tooltip_text = "";
 648                         if(hovering && !m_selected_item)
 649                                 tooltip_text = item.getDefinition(m_gamedef->idef()).description;
 650                         if(tooltip_text != "")
 651                         {
 652                                 m_tooltip_element->setVisible(true);
 653                                 this->bringToFront(m_tooltip_element);
 654                                 m_tooltip_element->setText(narrow_to_wide(tooltip_text).c_str());
 655                                 s32 tooltip_x = m_pointer.X + 15;
 656                                 s32 tooltip_y = m_pointer.Y + 15;
 657                                 s32 tooltip_width = m_tooltip_element->getTextWidth() + 15;
 658                                 s32 tooltip_height = m_tooltip_element->getTextHeight() + 5;
 659                                 m_tooltip_element->setRelativePosition(core::rect<s32>(
 660                                                 core::position2d<s32>(tooltip_x, tooltip_y),
 661                                                 core::dimension2d<s32>(tooltip_width, tooltip_height)));
 662                         }
 663                 }
 664         }
 665 }
 666
 667 void GUIFormSpecMenu::drawSelectedItem()
 668 {
 669         if(!m_selected_item)
 670                 return;
 671
 672         video::IVideoDriver* driver = Environment->getVideoDriver();
 673
 674         // Get font
 675         gui::IGUIFont *font = NULL;
 676         gui::IGUISkin* skin = Environment->getSkin();
 677         if (skin)
 678                 font = skin->getFont();
 679
 680         Inventory *inv = m_invmgr->getInventory(m_selected_item->inventoryloc);
 681         assert(inv);
 682         InventoryList *list = inv->getList(m_selected_item->listname);
 683         assert(list);
 684         ItemStack stack = list->getItem(m_selected_item->i);
 685         stack.count = m_selected_amount;
 686
 687         core::rect<s32> imgrect(0,0,imgsize.X,imgsize.Y);
 688         core::rect<s32> rect = imgrect + (m_pointer - imgrect.getCenter());
 689         drawItemStack(driver, font, stack, rect, NULL, m_gamedef);
 690 }
 691
 692 void GUIFormSpecMenu::drawMenu()
 693 {
 694         if(m_form_src){
 695                 std::string newform = m_form_src->getForm();
 696                 if(newform != m_formspec_string){
 697                         m_formspec_string = newform;
 698                         regenerateGui(m_screensize_old);
 699                 }
 700         }
 701
 702         m_pointer = m_device->getCursorControl()->getPosition();
 703
 704         updateSelectedItem();
 705
 706         gui::IGUISkin* skin = Environment->getSkin();
 707         if (!skin)
 708                 return;
 709         video::IVideoDriver* driver = Environment->getVideoDriver();
 710
 711         video::SColor bgcolor(140,0,0,0);
 712         driver->draw2DRectangle(bgcolor, AbsoluteRect, &AbsoluteClippingRect);
 713
 714         m_tooltip_element->setVisible(false);
 715
 716         /*
 717                 Draw backgrounds
 718         */
 719         for(u32 i=0; i<m_backgrounds.size(); i++)
 720         {
 721                 const ImageDrawSpec &spec = m_backgrounds[i];
 722                 video::ITexture *texture =
 723                                 m_gamedef->tsrc()->getTextureRaw(spec.name);
 724                 // Image size on screen
 725                 core::rect<s32> imgrect(0, 0, spec.geom.X, spec.geom.Y);
 726                 // Image rectangle on screen
 727                 core::rect<s32> rect = imgrect + spec.pos;
 728                 const video::SColor color(255,255,255,255);
 729                 const video::SColor colors[] = {color,color,color,color};
 730                 driver->draw2DImage(texture, rect,
 731                         core::rect<s32>(core::position2d<s32>(0,0),
 732                                         core::dimension2di(texture->getOriginalSize())),
 733                         NULL/*&AbsoluteClippingRect*/, colors, true);
 734         }
 735
 736         /*
 737                 Draw images
 738         */
 739         for(u32 i=0; i<m_images.size(); i++)
 740         {
 741                 const ImageDrawSpec &spec = m_images[i];
 742                 video::ITexture *texture =
 743                                 m_gamedef->tsrc()->getTextureRaw(spec.name);
 744                 // Image size on screen
 745                 core::rect<s32> imgrect(0, 0, spec.geom.X, spec.geom.Y);
 746                 // Image rectangle on screen
 747                 core::rect<s32> rect = imgrect + spec.pos;
 748                 const video::SColor color(255,255,255,255);
 749                 const video::SColor colors[] = {color,color,color,color};
 750                 driver->draw2DImage(texture, rect,
 751                         core::rect<s32>(core::position2d<s32>(0,0),
 752                                         core::dimension2di(texture->getOriginalSize())),
 753                         NULL/*&AbsoluteClippingRect*/, colors, true);
 754         }
 755
 756         /*
 757                 Draw items
 758                 Phase 0: Item slot rectangles
 759                 Phase 1: Item images; prepare tooltip
 760                 If backgrounds used, do not draw Item slot rectangles
 761         */
 762         int start_phase=0;
 763         if (m_backgrounds.size() > 0) start_phase=1;
 764         for(int phase=start_phase; phase<=1; phase++)
 765         for(u32 i=0; i<m_inventorylists.size(); i++)
 766         {
 767                 drawList(m_inventorylists[i], phase);
 768         }
 769
 770         /*
 771                 Draw dragged item stack
 772         */
 773         drawSelectedItem();
 774
 775         /*
 776                 Call base class
 777         */
 778         gui::IGUIElement::draw();
 779 }
 780
 781 void GUIFormSpecMenu::updateSelectedItem()
 782 {
 783         // WARNING: BLACK MAGIC
 784         // See if there is a stack suited for our current guess.
 785         // If such stack does not exist, clear the guess.
 786         if(m_selected_content_guess.name != "")
 787         {
 788                 bool found = false;
 789                 for(u32 i=0; i<m_inventorylists.size() && !found; i++){
 790                         const ListDrawSpec &s = m_inventorylists[i];
 791                         Inventory *inv = m_invmgr->getInventory(s.inventoryloc);
 792                         if(!inv)
 793                                 continue;
 794                         InventoryList *list = inv->getList(s.listname);
 795                         if(!list)
 796                                 continue;
 797                         for(s32 i=0; i<s.geom.X*s.geom.Y && !found; i++){
 798                                 u32 item_i = i + s.start_item_i;
 799                                 if(item_i >= list->getSize())
 800                                         continue;
 801                                 ItemStack stack = list->getItem(item_i);
 802                                 if(stack.name == m_selected_content_guess.name &&
 803                                                 stack.count == m_selected_content_guess.count){
 804                                         found = true;
 805                                         if(m_selected_item){
 806                                                 // If guessed stack is already selected, all is fine
 807                                                 if(m_selected_item->inventoryloc == s.inventoryloc &&
 808                                                                 m_selected_item->listname == s.listname &&
 809                                                                 m_selected_item->i == (s32)item_i &&
 810                                                                 m_selected_amount == stack.count){
 811                                                         break;
 812                                                 }
 813                                                 delete m_selected_item;
 814                                                 m_selected_item = NULL;
 815                                         }
 816                                         infostream<<"Client: Changing selected content guess to "
 817                                                         <<s.inventoryloc.dump()<<" "<<s.listname
 818                                                         <<" "<<item_i<<std::endl;
 819                                         m_selected_item = new ItemSpec(s.inventoryloc, s.listname, item_i);
 820                                         m_selected_amount = stack.count;
 821                                         break;
 822                                 }
 823                         }
 824                 }
 825                 if(!found){
 826                         infostream<<"Client: Discarding selected content guess: "
 827                                         <<m_selected_content_guess.getItemString()<<std::endl;
 828                         m_selected_content_guess.name = "";
 829                 }
 830         }
 831         // If the selected stack has become empty for some reason, deselect it.
 832         // If the selected stack has become smaller, adjust m_selected_amount.
 833         if(m_selected_item)
 834         {
 835                 bool selection_valid = false;
 836                 if(m_selected_item->isValid())
 837                 {
 838                         Inventory *inv = m_invmgr->getInventory(m_selected_item->inventoryloc);
 839                         if(inv)
 840                         {
 841                                 InventoryList *list = inv->getList(m_selected_item->listname);
 842                                 if(list && (u32) m_selected_item->i < list->getSize())
 843                                 {
 844                                         ItemStack stack = list->getItem(m_selected_item->i);
 845                                         if(m_selected_amount > stack.count)
 846                                                 m_selected_amount = stack.count;
 847                                         if(!stack.empty())
 848                                                 selection_valid = true;
 849                                 }
 850                         }
 851                 }
 852                 if(!selection_valid)
 853                 {
 854                         delete m_selected_item;
 855                         m_selected_item = NULL;
 856                         m_selected_amount = 0;
 857                         m_selected_dragging = false;
 858                 }
 859         }
 860
 861         // If craftresult is nonempty and nothing else is selected, select it now.
 862         if(!m_selected_item)
 863         {
 864                 for(u32 i=0; i<m_inventorylists.size(); i++)
 865                 {
 866                         const ListDrawSpec &s = m_inventorylists[i];
 867                         if(s.listname == "craftpreview")
 868                         {
 869                                 Inventory *inv = m_invmgr->getInventory(s.inventoryloc);
 870                                 InventoryList *list = inv->getList("craftresult");
 871                                 if(list && list->getSize() >= 1 && !list->getItem(0).empty())
 872                                 {
 873                                         m_selected_item = new ItemSpec;
 874                                         m_selected_item->inventoryloc = s.inventoryloc;
 875                                         m_selected_item->listname = "craftresult";
 876                                         m_selected_item->i = 0;
 877                                         m_selected_amount = 0;
 878                                         m_selected_dragging = false;
 879                                         break;
 880                                 }
 881                         }
 882                 }
 883         }
 884
 885         // If craftresult is selected, keep the whole stack selected
 886         if(m_selected_item && m_selected_item->listname == "craftresult")
 887         {
 888                 Inventory *inv = m_invmgr->getInventory(m_selected_item->inventoryloc);
 889                 assert(inv);
 890                 InventoryList *list = inv->getList(m_selected_item->listname);
 891                 assert(list);
 892                 m_selected_amount = list->getItem(m_selected_item->i).count;
 893         }
 894 }
 895
 896 void GUIFormSpecMenu::acceptInput()
 897 {
 898         if(m_text_dst)
 899         {
 900                 std::map<std::string, std::string> fields;
 901                 gui::IGUIElement *e;
 902                 for(u32 i=0; i<m_fields.size(); i++)
 903                 {
 904                         const FieldSpec &s = m_fields[i];
 905                         if(s.send)
 906                         {
 907                                 if(s.is_button)
 908                                 {
 909                                         fields[wide_to_narrow(s.fname.c_str())] = wide_to_narrow(s.flabel.c_str());
 910                                 }
 911                                 else
 912                                 {
 913                                         e = getElementFromId(s.fid);
 914                                         if(e != NULL)
 915                                         {
 916                                                 fields[wide_to_narrow(s.fname.c_str())] = wide_to_narrow(e->getText());
 917                                         }
 918                                 }
 919                         }
 920                 }
 921                 m_text_dst->gotText(fields);
 922         }
 923 }
 924
 925 bool GUIFormSpecMenu::OnEvent(const SEvent& event)
 926 {
 927         if(event.EventType==EET_KEY_INPUT_EVENT)
 928         {
 929                 KeyPress kp(event.KeyInput);
 930                 if (event.KeyInput.PressedDown && (kp == EscapeKey ||
 931                         kp == getKeySetting("keymap_inventory")))
 932                 {
 933                         quitMenu();
 934                         return true;
 935                 }
 936                 if(event.KeyInput.Key==KEY_RETURN && event.KeyInput.PressedDown)
 937                 {
 938                         acceptInput();
 939                         quitMenu();
 940                         return true;
 941                 }
 942         }
 943         if(event.EventType==EET_MOUSE_INPUT_EVENT
 944                         && event.MouseInput.Event != EMIE_MOUSE_MOVED)
 945         {
 946                 // Mouse event other than movement
 947
 948                 // Get selected item and hovered/clicked item (s)
 949
 950                 updateSelectedItem();
 951                 ItemSpec s = getItemAtPos(m_pointer);
 952
 953                 Inventory *inv_selected = NULL;
 954                 Inventory *inv_s = NULL;
 955
 956                 if(m_selected_item)
 957                 {
 958                         inv_selected = m_invmgr->getInventory(m_selected_item->inventoryloc);
 959                         assert(inv_selected);
 960                         assert(inv_selected->getList(m_selected_item->listname) != NULL);
 961                 }
 962
 963                 u32 s_count = 0;
 964
 965                 if(s.isValid())
 966                 do{ // breakable
 967                         inv_s = m_invmgr->getInventory(s.inventoryloc);
 968
 969                         if(!inv_s){
 970                                 errorstream<<"InventoryMenu: The selected inventory location "
 971                                                 <<"\""<<s.inventoryloc.dump()<<"\" doesn't exist"
 972                                                 <<std::endl;
 973                                 s.i = -1;  // make it invalid again
 974                                 break;
 975                         }
 976
 977                         InventoryList *list = inv_s->getList(s.listname);
 978                         if(list == NULL){
 979                                 verbosestream<<"InventoryMenu: The selected inventory list \""
 980                                                 <<s.listname<<"\" does not exist"<<std::endl;
 981                                 s.i = -1;  // make it invalid again
 982                                 break;
 983                         }
 984
 985                         if((u32)s.i >= list->getSize()){
 986                                 infostream<<"InventoryMenu: The selected inventory list \""
 987                                                 <<s.listname<<"\" is too small (i="<<s.i<<", size="
 988                                                 <<list->getSize()<<")"<<std::endl;
 989                                 s.i = -1;  // make it invalid again
 990                                 break;
 991                         }
 992
 993                         s_count = list->getItem(s.i).count;
 994                 }while(0);
 995
 996                 bool identical = (m_selected_item != NULL) && s.isValid() &&
 997                         (inv_selected == inv_s) &&
 998                         (m_selected_item->listname == s.listname) &&
 999                         (m_selected_item->i == s.i);
1000
1001                 // buttons: 0 = left, 1 = right, 2 = middle
1002                 // up/down: 0 = down (press), 1 = up (release), 2 = unknown event
1003                 int button = 0;
1004                 int updown = 2;
1005                 if(event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN)
1006                         { button = 0; updown = 0; }
1007                 else if(event.MouseInput.Event == EMIE_RMOUSE_PRESSED_DOWN)
1008                         { button = 1; updown = 0; }
1009                 else if(event.MouseInput.Event == EMIE_MMOUSE_PRESSED_DOWN)
1010                         { button = 2; updown = 0; }
1011                 else if(event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP)
1012                         { button = 0; updown = 1; }
1013                 else if(event.MouseInput.Event == EMIE_RMOUSE_LEFT_UP)
1014                         { button = 1; updown = 1; }
1015                 else if(event.MouseInput.Event == EMIE_MMOUSE_LEFT_UP)
1016                         { button = 2; updown = 1; }
1017
1018                 // Set this number to a positive value to generate a move action
1019                 // from m_selected_item to s.
1020                 u32 move_amount = 0;
1021
1022                 // Set this number to a positive value to generate a drop action
1023                 // from m_selected_item.
1024                 u32 drop_amount = 0;
1025
1026                 // Set this number to a positive value to generate a craft action at s.
1027                 u32 craft_amount = 0;
1028
1029                 if(updown == 0)
1030                 {
1031                         // Some mouse button has been pressed
1032
1033                         //infostream<<"Mouse button "<<button<<" pressed at p=("
1034                         //      <<p.X<<","<<p.Y<<")"<<std::endl;
1035
1036                         m_selected_dragging = false;
1037
1038                         if(s.isValid() && s.listname == "craftpreview")
1039                         {
1040                                 // Craft preview has been clicked: craft
1041                                 craft_amount = (button == 2 ? 10 : 1);
1042                         }
1043                         else if(m_selected_item == NULL)
1044                         {
1045                                 if(s_count != 0)
1046                                 {
1047                                         // Non-empty stack has been clicked: select it
1048                                         m_selected_item = new ItemSpec(s);
1049
1050                                         if(button == 1)  // right
1051                                                 m_selected_amount = (s_count + 1) / 2;
1052                                         else if(button == 2)  // middle
1053                                                 m_selected_amount = MYMIN(s_count, 10);
1054                                         else  // left
1055                                                 m_selected_amount = s_count;
1056
1057                                         m_selected_dragging = true;
1058                                 }
1059                         }
1060                         else  // m_selected_item != NULL
1061                         {
1062                                 assert(m_selected_amount >= 1);
1063
1064                                 if(s.isValid())
1065                                 {
1066                                         // Clicked a slot: move
1067                                         if(button == 1)  // right
1068                                                 move_amount = 1;
1069                                         else if(button == 2)  // middle
1070                                                 move_amount = MYMIN(m_selected_amount, 10);
1071                                         else  // left
1072                                                 move_amount = m_selected_amount;
1073
1074                                         if(identical)
1075                                         {
1076                                                 if(move_amount >= m_selected_amount)
1077                                                         m_selected_amount = 0;
1078                                                 else
1079                                                         m_selected_amount -= move_amount;
1080                                                 move_amount = 0;
1081                                         }
1082                                 }
1083                                 else if(getAbsoluteClippingRect().isPointInside(m_pointer))
1084                                 {
1085                                         // Clicked somewhere else: deselect
1086                                         m_selected_amount = 0;
1087                                 }
1088                                 else
1089                                 {
1090                                         // Clicked outside of the window: drop
1091                                         if(button == 1)  // right
1092                                                 drop_amount = 1;
1093                                         else if(button == 2)  // middle
1094                                                 drop_amount = MYMIN(m_selected_amount, 10);
1095                                         else  // left
1096                                                 drop_amount = m_selected_amount;
1097                                 }
1098                         }
1099                 }
1100                 else if(updown == 1)
1101                 {
1102                         // Some mouse button has been released
1103
1104                         //infostream<<"Mouse button "<<button<<" released at p=("
1105                         //      <<p.X<<","<<p.Y<<")"<<std::endl;
1106
1107                         if(m_selected_item != NULL && m_selected_dragging && s.isValid())
1108                         {
1109                                 if(!identical)
1110                                 {
1111                                         // Dragged to different slot: move all selected
1112                                         move_amount = m_selected_amount;
1113                                 }
1114                         }
1115                         else if(m_selected_item != NULL && m_selected_dragging &&
1116                                 !(getAbsoluteClippingRect().isPointInside(m_pointer)))
1117                         {
1118                                 // Dragged outside of window: drop all selected
1119                                 drop_amount = m_selected_amount;
1120                         }
1121
1122                         m_selected_dragging = false;
1123                 }
1124
1125                 // Possibly send inventory action to server
1126                 if(move_amount > 0)
1127                 {
1128                         // Send IACTION_MOVE
1129
1130                         assert(m_selected_item && m_selected_item->isValid());
1131                         assert(s.isValid());
1132
1133                         assert(inv_selected && inv_s);
1134                         InventoryList *list_from = inv_selected->getList(m_selected_item->listname);
1135                         InventoryList *list_to = inv_s->getList(s.listname);
1136                         assert(list_from && list_to);
1137                         ItemStack stack_from = list_from->getItem(m_selected_item->i);
1138                         ItemStack stack_to = list_to->getItem(s.i);
1139
1140                         // Check how many items can be moved
1141                         move_amount = stack_from.count = MYMIN(move_amount, stack_from.count);
1142                         ItemStack leftover = stack_to.addItem(stack_from, m_gamedef->idef());
1143                         // If source stack cannot be added to destination stack at all,
1144                         // they are swapped
1145                         if(leftover.count == stack_from.count && leftover.name == stack_from.name)
1146                         {
1147                                 m_selected_amount = stack_to.count;
1148                                 // In case the server doesn't directly swap them but instead
1149                                 // moves stack_to somewhere else, set this
1150                                 m_selected_content_guess = stack_to;
1151                                 m_selected_content_guess_inventory = s.inventoryloc;
1152                         }
1153                         // Source stack goes fully into destination stack
1154                         else if(leftover.empty())
1155                         {
1156                                 m_selected_amount -= move_amount;
1157                                 m_selected_content_guess = ItemStack(); // Clear
1158                         }
1159                         // Source stack goes partly into destination stack
1160                         else
1161                         {
1162                                 move_amount -= leftover.count;
1163                                 m_selected_amount -= move_amount;
1164                                 m_selected_content_guess = ItemStack(); // Clear
1165                         }
1166
1167                         infostream<<"Handing IACTION_MOVE to manager"<<std::endl;
1168                         IMoveAction *a = new IMoveAction();
1169                         a->count = move_amount;
1170                         a->from_inv = m_selected_item->inventoryloc;
1171                         a->from_list = m_selected_item->listname;
1172                         a->from_i = m_selected_item->i;
1173                         a->to_inv = s.inventoryloc;
1174                         a->to_list = s.listname;
1175                         a->to_i = s.i;
1176                         m_invmgr->inventoryAction(a);
1177                 }
1178                 else if(drop_amount > 0)
1179                 {
1180                         m_selected_content_guess = ItemStack(); // Clear
1181
1182                         // Send IACTION_DROP
1183
1184                         assert(m_selected_item && m_selected_item->isValid());
1185                         assert(inv_selected);
1186                         InventoryList *list_from = inv_selected->getList(m_selected_item->listname);
1187                         assert(list_from);
1188                         ItemStack stack_from = list_from->getItem(m_selected_item->i);
1189
1190                         // Check how many items can be dropped
1191                         drop_amount = stack_from.count = MYMIN(drop_amount, stack_from.count);
1192                         assert(drop_amount > 0 && drop_amount <= m_selected_amount);
1193                         m_selected_amount -= drop_amount;
1194
1195                         infostream<<"Handing IACTION_DROP to manager"<<std::endl;
1196                         IDropAction *a = new IDropAction();
1197                         a->count = drop_amount;
1198                         a->from_inv = m_selected_item->inventoryloc;
1199                         a->from_list = m_selected_item->listname;
1200                         a->from_i = m_selected_item->i;
1201                         m_invmgr->inventoryAction(a);
1202                 }
1203                 else if(craft_amount > 0)
1204                 {
1205                         m_selected_content_guess = ItemStack(); // Clear
1206
1207                         // Send IACTION_CRAFT
1208
1209                         assert(s.isValid());
1210                         assert(inv_s);
1211
1212                         infostream<<"Handing IACTION_CRAFT to manager"<<std::endl;
1213                         ICraftAction *a = new ICraftAction();
1214                         a->count = craft_amount;
1215                         a->craft_inv = s.inventoryloc;
1216                         m_invmgr->inventoryAction(a);
1217                 }
1218
1219                 // If m_selected_amount has been decreased to zero, deselect
1220                 if(m_selected_amount == 0)
1221                 {
1222                         delete m_selected_item;
1223                         m_selected_item = NULL;
1224                         m_selected_amount = 0;
1225                         m_selected_dragging = false;
1226                         m_selected_content_guess = ItemStack();
1227                 }
1228         }
1229         if(event.EventType==EET_GUI_EVENT)
1230         {
1231                 if(event.GUIEvent.EventType==gui::EGET_ELEMENT_FOCUS_LOST
1232                                 && isVisible())
1233                 {
1234                         if(!canTakeFocus(event.GUIEvent.Element))
1235                         {
1236                                 infostream<<"GUIFormSpecMenu: Not allowing focus change."
1237                                                 <<std::endl;
1238                                 // Returning true disables focus change
1239                                 return true;
1240                         }
1241                 }
1242                 if(event.GUIEvent.EventType==gui::EGET_BUTTON_CLICKED)
1243                 {
1244                         switch(event.GUIEvent.Caller->getID())
1245                         {
1246                         case 257:
1247                                 acceptInput();
1248                                 quitMenu();
1249                                 // quitMenu deallocates menu
1250                                 return true;
1251                         }
1252                         // find the element that was clicked
1253                         for(u32 i=0; i<m_fields.size(); i++)
1254                         {
1255                                 FieldSpec &s = m_fields[i];
1256                                 // if its a button, set the send field so
1257                                 // lua knows which button was pressed
1258                                 if (s.is_button && s.fid == event.GUIEvent.Caller->getID())
1259                                 {
1260                                         s.send = true;
1261                                         acceptInput();
1262                                         if(s.is_exit){
1263                                                 quitMenu();
1264                                                 return true;
1265                                         }else{
1266                                                 s.send = false;
1267                                                 // Restore focus to the full form
1268                                                 Environment->setFocus(this);
1269                                                 return true;
1270                                         }
1271                                 }
1272                         }
1273                 }
1274                 if(event.GUIEvent.EventType==gui::EGET_EDITBOX_ENTER)
1275                 {
1276                         if(event.GUIEvent.Caller->getID() > 257)
1277                         {
1278                                 acceptInput();
1279                                 quitMenu();
1280                                 // quitMenu deallocates menu
1281                                 return true;
1282                         }
1283                 }
1284         }
1285
1286         return Parent ? Parent->OnEvent(event) : false;
1287 }
1288