src/guiInventoryMenu.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 "guiInventoryMenu.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
  34 void drawItemStack(video::IVideoDriver *driver,
  35                 gui::IGUIFont *font,
  36                 const ItemStack &item,
  37                 const core::rect<s32> &rect,
  38                 const core::rect<s32> *clip,
  39                 IGameDef *gamedef)
  40 {
  41         if(item.empty())
  42                 return;
  43
  44         const ItemDefinition &def = item.getDefinition(gamedef->idef());
  45         video::ITexture *texture = def.inventory_texture;
  46
  47         // Draw the inventory texture
  48         if(texture != NULL)
  49         {
  50                 const video::SColor color(255,255,255,255);
  51                 const video::SColor colors[] = {color,color,color,color};
  52                 driver->draw2DImage(texture, rect,
  53                         core::rect<s32>(core::position2d<s32>(0,0),
  54                         core::dimension2di(texture->getOriginalSize())),
  55                         clip, colors, true);
  56         }
  57
  58         if(def.type == ITEM_TOOL && item.wear != 0)
  59         {
  60                 // Draw a progressbar
  61                 float barheight = rect.getHeight()/16;
  62                 float barpad_x = rect.getWidth()/16;
  63                 float barpad_y = rect.getHeight()/16;
  64                 core::rect<s32> progressrect(
  65                         rect.UpperLeftCorner.X + barpad_x,
  66                         rect.LowerRightCorner.Y - barpad_y - barheight,
  67                         rect.LowerRightCorner.X - barpad_x,
  68                         rect.LowerRightCorner.Y - barpad_y);
  69
  70                 // Shrink progressrect by amount of tool damage
  71                 float wear = item.wear / 65535.0;
  72                 int progressmid =
  73                         wear * progressrect.UpperLeftCorner.X +
  74                         (1-wear) * progressrect.LowerRightCorner.X;
  75
  76                 // Compute progressbar color
  77                 //   wear = 0.0: green
  78                 //   wear = 0.5: yellow
  79                 //   wear = 1.0: red
  80                 video::SColor color(255,255,255,255);
  81                 int wear_i = MYMIN(floor(wear * 600), 511);
  82                 wear_i = MYMIN(wear_i + 10, 511);
  83                 if(wear_i <= 255)
  84                         color.set(255, wear_i, 255, 0);
  85                 else
  86                         color.set(255, 255, 511-wear_i, 0);
  87
  88                 core::rect<s32> progressrect2 = progressrect;
  89                 progressrect2.LowerRightCorner.X = progressmid;
  90                 driver->draw2DRectangle(color, progressrect2, clip);
  91
  92                 color = video::SColor(255,0,0,0);
  93                 progressrect2 = progressrect;
  94                 progressrect2.UpperLeftCorner.X = progressmid;
  95                 driver->draw2DRectangle(color, progressrect2, clip);
  96         }
  97
  98         if(font != NULL && item.count >= 2)
  99         {
 100                 // Get the item count as a string
 101                 std::string text = itos(item.count);
 102                 v2u32 dim = font->getDimension(narrow_to_wide(text).c_str());
 103                 v2s32 sdim(dim.X,dim.Y);
 104
 105                 core::rect<s32> rect2(
 106                         /*rect.UpperLeftCorner,
 107                         core::dimension2d<u32>(rect.getWidth(), 15)*/
 108                         rect.LowerRightCorner - sdim,
 109                         sdim
 110                 );
 111
 112                 video::SColor bgcolor(128,0,0,0);
 113                 driver->draw2DRectangle(bgcolor, rect2, clip);
 114
 115                 video::SColor color(255,255,255,255);
 116                 font->draw(text.c_str(), rect2, color, false, false, clip);
 117         }
 118 }
 119
 120 /*
 121         GUIInventoryMenu
 122 */
 123
 124 GUIInventoryMenu::GUIInventoryMenu(gui::IGUIEnvironment* env,
 125                 gui::IGUIElement* parent, s32 id,
 126                 IMenuManager *menumgr,
 127                 InventoryManager *invmgr,
 128                 IGameDef *gamedef
 129 ):
 130         GUIModalMenu(env, parent, id, menumgr),
 131         m_invmgr(invmgr),
 132         m_gamedef(gamedef),
 133         m_form_src(NULL),
 134         m_selected_item(NULL),
 135         m_selected_amount(0),
 136         m_selected_dragging(false),
 137         m_tooltip_element(NULL)
 138 {
 139 }
 140
 141 GUIInventoryMenu::~GUIInventoryMenu()
 142 {
 143         removeChildren();
 144
 145         delete m_selected_item;
 146         delete m_form_src;
 147 }
 148
 149 void GUIInventoryMenu::removeChildren()
 150 {
 151         const core::list<gui::IGUIElement*> &children = getChildren();
 152         core::list<gui::IGUIElement*> children_copy;
 153         for(core::list<gui::IGUIElement*>::ConstIterator
 154                         i = children.begin(); i != children.end(); i++)
 155         {
 156                 children_copy.push_back(*i);
 157         }
 158         for(core::list<gui::IGUIElement*>::Iterator
 159                         i = children_copy.begin();
 160                         i != children_copy.end(); i++)
 161         {
 162                 (*i)->remove();
 163         }
 164         /*{
 165                 gui::IGUIElement *e = getElementFromId(256);
 166                 if(e != NULL)
 167                         e->remove();
 168         }*/
 169         if(m_tooltip_element)
 170         {
 171                 m_tooltip_element->remove();
 172                 m_tooltip_element = NULL;
 173         }
 174 }
 175
 176 void GUIInventoryMenu::regenerateGui(v2u32 screensize)
 177 {
 178         // Remove children
 179         removeChildren();
 180
 181         v2s32 size(100,100);
 182         s32 helptext_h = 15;
 183         core::rect<s32> rect;
 184         v2s32 basepos = getBasePos();
 185
 186         /* Convert m_init_draw_spec to m_inventorylists */
 187
 188         m_inventorylists.clear();
 189         m_images.clear();
 190
 191         Strfnd f(m_formspec_string);
 192         while(f.atend() == false)
 193         {
 194                 std::string type = trim(f.next("["));
 195                 if(type == "invsize")
 196                 {
 197                         v2f invsize;
 198                         invsize.X = stof(f.next(","));
 199                         invsize.Y = stof(f.next(";"));
 200                         infostream<<"invsize ("<<invsize.X<<","<<invsize.Y<<")"<<std::endl;
 201                         f.next("]");
 202
 203                         padding = v2s32(screensize.Y/40, screensize.Y/40);
 204                         spacing = v2s32(screensize.Y/12, screensize.Y/13);
 205                         imgsize = v2s32(screensize.Y/15, screensize.Y/15);
 206                         size = v2s32(
 207                                 padding.X*2+spacing.X*(invsize.X-1.0)+imgsize.X,
 208                                 padding.Y*2+spacing.Y*(invsize.Y-1.0)+imgsize.Y + (helptext_h-5)
 209                         );
 210                         rect = core::rect<s32>(
 211                                         screensize.X/2 - size.X/2,
 212                                         screensize.Y/2 - size.Y/2,
 213                                         screensize.X/2 + size.X/2,
 214                                         screensize.Y/2 + size.Y/2
 215                         );
 216                         DesiredRect = rect;
 217                         recalculateAbsolutePosition(false);
 218                         basepos = getBasePos();
 219                 }
 220                 else if(type == "list")
 221                 {
 222                         std::string name = f.next(";");
 223                         InventoryLocation loc;
 224                         if(name == "context" || name == "current_name")
 225                                 loc = m_current_inventory_location;
 226                         else
 227                                 loc.deSerialize(name);
 228                         std::string listname = f.next(";");
 229                         v2s32 pos = basepos;
 230                         pos.X += stof(f.next(",")) * (float)spacing.X;
 231                         pos.Y += stof(f.next(";")) * (float)spacing.Y;
 232                         v2s32 geom;
 233                         geom.X = stoi(f.next(","));
 234                         geom.Y = stoi(f.next(";"));
 235                         infostream<<"list inv="<<name<<", listname="<<listname
 236                                         <<", pos=("<<pos.X<<","<<pos.Y<<")"
 237                                         <<", geom=("<<geom.X<<","<<geom.Y<<")"
 238                                         <<std::endl;
 239                         f.next("]");
 240                         m_inventorylists.push_back(ListDrawSpec(loc, listname, pos, geom));
 241                 }
 242                 else if(type == "image")
 243                 {
 244                         v2s32 pos = basepos;
 245                         pos.X += stof(f.next(",")) * (float)spacing.X;
 246                         pos.Y += stof(f.next(";")) * (float)spacing.Y;
 247                         v2s32 geom;
 248                         geom.X = stof(f.next(",")) * (float)imgsize.X;
 249                         geom.Y = stof(f.next(";")) * (float)imgsize.Y;
 250                         std::string name = f.next("]");
 251                         infostream<<"image name="<<name
 252                                         <<", pos=("<<pos.X<<","<<pos.Y<<")"
 253                                         <<", geom=("<<geom.X<<","<<geom.Y<<")"
 254                                         <<std::endl;
 255                         m_images.push_back(ImageDrawSpec(name, pos, geom));
 256                 }
 257                 else
 258                 {
 259                         // Ignore others
 260                         std::string ts = f.next("]");
 261                         infostream<<"Unknown DrawSpec: type="<<type<<", data=\""<<ts<<"\""
 262                                         <<std::endl;
 263                 }
 264         }
 265
 266         // Add children
 267         {
 268                 core::rect<s32> rect(0, 0, size.X-padding.X*2, helptext_h);
 269                 rect = rect + v2s32(size.X/2 - rect.getWidth()/2,
 270                                 size.Y-rect.getHeight()-5);
 271                 const wchar_t *text =
 272                 L"Left click: Move all items, Right click: Move single item";
 273                 Environment->addStaticText(text, rect, false, true, this, 256);
 274
 275                 // Add tooltip
 276                 // Note: parent != this so that the tooltip isn't clipped by the menu rectangle
 277                 m_tooltip_element = Environment->addStaticText(L"",core::rect<s32>(0,0,110,18));
 278                 m_tooltip_element->enableOverrideColor(true);
 279                 m_tooltip_element->setBackgroundColor(video::SColor(255,110,130,60));
 280                 m_tooltip_element->setDrawBackground(true);
 281                 m_tooltip_element->setDrawBorder(true);
 282                 m_tooltip_element->setOverrideColor(video::SColor(255,255,255,255));
 283                 m_tooltip_element->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_CENTER);
 284                 m_tooltip_element->setWordWrap(false);
 285         }
 286 }
 287
 288 GUIInventoryMenu::ItemSpec GUIInventoryMenu::getItemAtPos(v2s32 p) const
 289 {
 290         core::rect<s32> imgrect(0,0,imgsize.X,imgsize.Y);
 291
 292         for(u32 i=0; i<m_inventorylists.size(); i++)
 293         {
 294                 const ListDrawSpec &s = m_inventorylists[i];
 295
 296                 for(s32 i=0; i<s.geom.X*s.geom.Y; i++)
 297                 {
 298                         s32 x = (i%s.geom.X) * spacing.X;
 299                         s32 y = (i/s.geom.X) * spacing.Y;
 300                         v2s32 p0(x,y);
 301                         core::rect<s32> rect = imgrect + s.pos + p0;
 302                         if(rect.isPointInside(p))
 303                         {
 304                                 return ItemSpec(s.inventoryloc, s.listname, i);
 305                         }
 306                 }
 307         }
 308
 309         return ItemSpec(InventoryLocation(), "", -1);
 310 }
 311
 312 void GUIInventoryMenu::drawList(const ListDrawSpec &s, int phase)
 313 {
 314         video::IVideoDriver* driver = Environment->getVideoDriver();
 315
 316         // Get font
 317         gui::IGUIFont *font = NULL;
 318         gui::IGUISkin* skin = Environment->getSkin();
 319         if (skin)
 320                 font = skin->getFont();
 321
 322         Inventory *inv = m_invmgr->getInventory(s.inventoryloc);
 323         if(!inv){
 324                 infostream<<"GUIInventoryMenu::drawList(): WARNING: "
 325                                 <<"The inventory location "
 326                                 <<"\""<<s.inventoryloc.dump()<<"\" doesn't exist"
 327                                 <<std::endl;
 328                 return;
 329         }
 330         InventoryList *ilist = inv->getList(s.listname);
 331         if(!ilist){
 332                 infostream<<"GUIInventoryMenu::drawList(): WARNING: "
 333                                 <<"The inventory list \""<<s.listname<<"\" @ \""
 334                                 <<s.inventoryloc.dump()<<"\" doesn't exist"
 335                                 <<std::endl;
 336                 return;
 337         }
 338
 339         core::rect<s32> imgrect(0,0,imgsize.X,imgsize.Y);
 340
 341         for(s32 i=0; i<s.geom.X*s.geom.Y; i++)
 342         {
 343                 s32 x = (i%s.geom.X) * spacing.X;
 344                 s32 y = (i/s.geom.X) * spacing.Y;
 345                 v2s32 p(x,y);
 346                 core::rect<s32> rect = imgrect + s.pos + p;
 347                 ItemStack item;
 348                 if(ilist)
 349                         item = ilist->getItem(i);
 350
 351                 bool selected = m_selected_item
 352                         && m_invmgr->getInventory(m_selected_item->inventoryloc) == inv
 353                         && m_selected_item->listname == s.listname
 354                         && m_selected_item->i == i;
 355                 bool hovering = rect.isPointInside(m_pointer);
 356
 357                 if(phase == 0)
 358                 {
 359                         if(hovering && m_selected_item)
 360                         {
 361                                 video::SColor bgcolor(255,192,192,192);
 362                                 driver->draw2DRectangle(bgcolor, rect, &AbsoluteClippingRect);
 363                         }
 364                         else
 365                         {
 366                                 video::SColor bgcolor(255,128,128,128);
 367                                 driver->draw2DRectangle(bgcolor, rect, &AbsoluteClippingRect);
 368                         }
 369                 }
 370
 371                 if(phase == 1)
 372                 {
 373                         // Draw item stack
 374                         if(selected)
 375                         {
 376                                 item.takeItem(m_selected_amount);
 377                         }
 378                         if(!item.empty())
 379                         {
 380                                 drawItemStack(driver, font, item,
 381                                                 rect, &AbsoluteClippingRect, m_gamedef);
 382                         }
 383
 384                         // Draw tooltip
 385                         std::string tooltip_text = "";
 386                         if(hovering && !m_selected_item)
 387                                 tooltip_text = item.getDefinition(m_gamedef->idef()).description;
 388                         if(tooltip_text != "")
 389                         {
 390                                 m_tooltip_element->setVisible(true);
 391                                 this->bringToFront(m_tooltip_element);
 392                                 m_tooltip_element->setText(narrow_to_wide(tooltip_text).c_str());
 393                                 s32 tooltip_x = m_pointer.X + 15;
 394                                 s32 tooltip_y = m_pointer.Y + 15;
 395                                 s32 tooltip_width = m_tooltip_element->getTextWidth() + 15;
 396                                 s32 tooltip_height = m_tooltip_element->getTextHeight() + 5;
 397                                 m_tooltip_element->setRelativePosition(core::rect<s32>(
 398                                                 core::position2d<s32>(tooltip_x, tooltip_y),
 399                                                 core::dimension2d<s32>(tooltip_width, tooltip_height)));
 400                         }
 401                 }
 402         }
 403 }
 404
 405 void GUIInventoryMenu::drawSelectedItem()
 406 {
 407         if(!m_selected_item)
 408                 return;
 409
 410         video::IVideoDriver* driver = Environment->getVideoDriver();
 411
 412         // Get font
 413         gui::IGUIFont *font = NULL;
 414         gui::IGUISkin* skin = Environment->getSkin();
 415         if (skin)
 416                 font = skin->getFont();
 417
 418         Inventory *inv = m_invmgr->getInventory(m_selected_item->inventoryloc);
 419         assert(inv);
 420         InventoryList *list = inv->getList(m_selected_item->listname);
 421         assert(list);
 422         ItemStack stack = list->getItem(m_selected_item->i);
 423         stack.count = m_selected_amount;
 424
 425         core::rect<s32> imgrect(0,0,imgsize.X,imgsize.Y);
 426         core::rect<s32> rect = imgrect + (m_pointer - imgrect.getCenter());
 427         drawItemStack(driver, font, stack, rect, NULL, m_gamedef);
 428 }
 429
 430 void GUIInventoryMenu::drawMenu()
 431 {
 432         if(m_form_src){
 433                 std::string newform = m_form_src->getForm();
 434                 if(newform != m_formspec_string){
 435                         m_formspec_string = newform;
 436                         regenerateGui(m_screensize_old);
 437                 }
 438         }
 439
 440         updateSelectedItem();
 441
 442         gui::IGUISkin* skin = Environment->getSkin();
 443         if (!skin)
 444                 return;
 445         video::IVideoDriver* driver = Environment->getVideoDriver();
 446
 447         video::SColor bgcolor(140,0,0,0);
 448         driver->draw2DRectangle(bgcolor, AbsoluteRect, &AbsoluteClippingRect);
 449
 450         m_tooltip_element->setVisible(false);
 451
 452         /*
 453                 Draw items
 454                 Phase 0: Item slot rectangles
 455                 Phase 1: Item images; prepare tooltip
 456         */
 457
 458         for(int phase=0; phase<=1; phase++)
 459         for(u32 i=0; i<m_inventorylists.size(); i++)
 460         {
 461                 drawList(m_inventorylists[i], phase);
 462         }
 463
 464         for(u32 i=0; i<m_images.size(); i++)
 465         {
 466                 const ImageDrawSpec &spec = m_images[i];
 467                 video::ITexture *texture =
 468                                 m_gamedef->tsrc()->getTextureRaw(spec.name);
 469                 // Image size on screen
 470                 core::rect<s32> imgrect(0, 0, spec.geom.X, spec.geom.Y);
 471                 // Image rectangle on screen
 472                 core::rect<s32> rect = imgrect + spec.pos;
 473                 const video::SColor color(255,255,255,255);
 474                 const video::SColor colors[] = {color,color,color,color};
 475                 driver->draw2DImage(texture, rect,
 476                         core::rect<s32>(core::position2d<s32>(0,0),
 477                                         core::dimension2di(texture->getOriginalSize())),
 478                         NULL/*&AbsoluteClippingRect*/, colors, true);
 479         }
 480
 481         /*
 482                 Draw dragged item stack
 483         */
 484         drawSelectedItem();
 485
 486         /*
 487                 Call base class
 488         */
 489         gui::IGUIElement::draw();
 490 }
 491
 492 void GUIInventoryMenu::updateSelectedItem()
 493 {
 494         // If the selected stack has become empty for some reason, deselect it.
 495         // If the selected stack has become smaller, adjust m_selected_amount.
 496         if(m_selected_item)
 497         {
 498                 bool selection_valid = false;
 499                 if(m_selected_item->isValid())
 500                 {
 501                         Inventory *inv = m_invmgr->getInventory(m_selected_item->inventoryloc);
 502                         if(inv)
 503                         {
 504                                 InventoryList *list = inv->getList(m_selected_item->listname);
 505                                 if(list && (u32) m_selected_item->i < list->getSize())
 506                                 {
 507                                         ItemStack stack = list->getItem(m_selected_item->i);
 508                                         if(m_selected_amount > stack.count)
 509                                                 m_selected_amount = stack.count;
 510                                         if(!stack.empty())
 511                                                 selection_valid = true;
 512                                 }
 513                         }
 514                 }
 515                 if(!selection_valid)
 516                 {
 517                         delete m_selected_item;
 518                         m_selected_item = NULL;
 519                         m_selected_amount = 0;
 520                         m_selected_dragging = false;
 521                 }
 522         }
 523
 524         // If craftresult is nonempty and nothing else is selected, select it now.
 525         if(!m_selected_item)
 526         {
 527                 for(u32 i=0; i<m_inventorylists.size(); i++)
 528                 {
 529                         const ListDrawSpec &s = m_inventorylists[i];
 530                         if(s.listname == "craftpreview")
 531                         {
 532                                 Inventory *inv = m_invmgr->getInventory(s.inventoryloc);
 533                                 InventoryList *list = inv->getList("craftresult");
 534                                 if(list && list->getSize() >= 1 && !list->getItem(0).empty())
 535                                 {
 536                                         m_selected_item = new ItemSpec;
 537                                         m_selected_item->inventoryloc = s.inventoryloc;
 538                                         m_selected_item->listname = "craftresult";
 539                                         m_selected_item->i = 0;
 540                                         m_selected_amount = 0;
 541                                         m_selected_dragging = false;
 542                                         break;
 543                                 }
 544                         }
 545                 }
 546         }
 547
 548         // If craftresult is selected, keep the whole stack selected
 549         if(m_selected_item && m_selected_item->listname == "craftresult")
 550         {
 551                 Inventory *inv = m_invmgr->getInventory(m_selected_item->inventoryloc);
 552                 assert(inv);
 553                 InventoryList *list = inv->getList(m_selected_item->listname);
 554                 assert(list);
 555                 m_selected_amount = list->getItem(m_selected_item->i).count;
 556         }
 557 }
 558
 559 bool GUIInventoryMenu::OnEvent(const SEvent& event)
 560 {
 561         if(event.EventType==EET_KEY_INPUT_EVENT)
 562         {
 563                 KeyPress kp(event.KeyInput);
 564                 if (event.KeyInput.PressedDown && (kp == EscapeKey ||
 565                         kp == getKeySetting("keymap_inventory")))
 566                 {
 567                         quitMenu();
 568                         return true;
 569                 }
 570         }
 571         if(event.EventType==EET_MOUSE_INPUT_EVENT
 572                         && event.MouseInput.Event == EMIE_MOUSE_MOVED)
 573         {
 574                 // Mouse moved
 575                 m_pointer = v2s32(event.MouseInput.X, event.MouseInput.Y);
 576         }
 577         if(event.EventType==EET_MOUSE_INPUT_EVENT
 578                         && event.MouseInput.Event != EMIE_MOUSE_MOVED)
 579         {
 580                 // Mouse event other than movement
 581
 582                 v2s32 p(event.MouseInput.X, event.MouseInput.Y);
 583                 m_pointer = p;
 584
 585                 // Get selected item and hovered/clicked item (s)
 586
 587                 updateSelectedItem();
 588                 ItemSpec s = getItemAtPos(p);
 589
 590                 Inventory *inv_selected = NULL;
 591                 Inventory *inv_s = NULL;
 592
 593                 if(m_selected_item)
 594                 {
 595                         inv_selected = m_invmgr->getInventory(m_selected_item->inventoryloc);
 596                         assert(inv_selected);
 597                         assert(inv_selected->getList(m_selected_item->listname) != NULL);
 598                 }
 599
 600                 u32 s_count = 0;
 601
 602                 if(s.isValid())
 603                 do{ // breakable
 604                         inv_s = m_invmgr->getInventory(s.inventoryloc);
 605
 606                         if(!inv_s){
 607                                 errorstream<<"InventoryMenu: The selected inventory location "
 608                                                 <<"\""<<s.inventoryloc.dump()<<"\" doesn't exist"
 609                                                 <<std::endl;
 610                                 s.i = -1;  // make it invalid again
 611                                 break;
 612                         }
 613
 614                         InventoryList *list = inv_s->getList(s.listname);
 615                         if(list == NULL){
 616                                 errorstream<<"InventoryMenu: The selected inventory list \""
 617                                                 <<s.listname<<"\" does not exist"<<std::endl;
 618                                 s.i = -1;  // make it invalid again
 619                                 break;
 620                         }
 621
 622                         if((u32)s.i >= list->getSize()){
 623                                 errorstream<<"InventoryMenu: The selected inventory list \""
 624                                                 <<s.listname<<"\" is too small (i="<<s.i<<", size="
 625                                                 <<list->getSize()<<")"<<std::endl;
 626                                 s.i = -1;  // make it invalid again
 627                                 break;
 628                         }
 629
 630                         s_count = list->getItem(s.i).count;
 631                 }while(0);
 632
 633                 bool identical = (m_selected_item != NULL) && s.isValid() &&
 634                         (inv_selected == inv_s) &&
 635                         (m_selected_item->listname == s.listname) &&
 636                         (m_selected_item->i == s.i);
 637
 638                 // buttons: 0 = left, 1 = right, 2 = middle
 639                 // up/down: 0 = down (press), 1 = up (release), 2 = unknown event
 640                 int button = 0;
 641                 int updown = 2;
 642                 if(event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN)
 643                         { button = 0; updown = 0; }
 644                 else if(event.MouseInput.Event == EMIE_RMOUSE_PRESSED_DOWN)
 645                         { button = 1; updown = 0; }
 646                 else if(event.MouseInput.Event == EMIE_MMOUSE_PRESSED_DOWN)
 647                         { button = 2; updown = 0; }
 648                 else if(event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP)
 649                         { button = 0; updown = 1; }
 650                 else if(event.MouseInput.Event == EMIE_RMOUSE_LEFT_UP)
 651                         { button = 1; updown = 1; }
 652                 else if(event.MouseInput.Event == EMIE_MMOUSE_LEFT_UP)
 653                         { button = 2; updown = 1; }
 654
 655                 // Set this number to a positive value to generate a move action
 656                 // from m_selected_item to s.
 657                 u32 move_amount = 0;
 658
 659                 // Set this number to a positive value to generate a drop action
 660                 // from m_selected_item.
 661                 u32 drop_amount = 0;
 662
 663                 // Set this number to a positive value to generate a craft action at s.
 664                 u32 craft_amount = 0;
 665
 666                 if(updown == 0)
 667                 {
 668                         // Some mouse button has been pressed
 669
 670                         //infostream<<"Mouse button "<<button<<" pressed at p=("
 671                         //      <<p.X<<","<<p.Y<<")"<<std::endl;
 672
 673                         m_selected_dragging = false;
 674
 675                         if(s.isValid() && s.listname == "craftpreview")
 676                         {
 677                                 // Craft preview has been clicked: craft
 678                                 craft_amount = (button == 2 ? 10 : 1);
 679                         }
 680                         else if(m_selected_item == NULL)
 681                         {
 682                                 if(s_count != 0)
 683                                 {
 684                                         // Non-empty stack has been clicked: select it
 685                                         m_selected_item = new ItemSpec(s);
 686
 687                                         if(button == 1)  // right
 688                                                 m_selected_amount = (s_count + 1) / 2;
 689                                         else if(button == 2)  // middle
 690                                                 m_selected_amount = MYMIN(s_count, 10);
 691                                         else  // left
 692                                                 m_selected_amount = s_count;
 693
 694                                         m_selected_dragging = true;
 695                                 }
 696                         }
 697                         else  // m_selected_item != NULL
 698                         {
 699                                 assert(m_selected_amount >= 1);
 700
 701                                 if(s.isValid())
 702                                 {
 703                                         // Clicked a slot: move
 704                                         if(button == 1)  // right
 705                                                 move_amount = 1;
 706                                         else if(button == 2)  // middle
 707                                                 move_amount = MYMIN(m_selected_amount, 10);
 708                                         else  // left
 709                                                 move_amount = m_selected_amount;
 710
 711                                         if(identical)
 712                                         {
 713                                                 if(move_amount >= m_selected_amount)
 714                                                         m_selected_amount = 0;
 715                                                 else
 716                                                         m_selected_amount -= move_amount;
 717                                                 move_amount = 0;
 718                                         }
 719                                 }
 720                                 else if(getAbsoluteClippingRect().isPointInside(m_pointer))
 721                                 {
 722                                         // Clicked somewhere else: deselect
 723                                         m_selected_amount = 0;
 724                                 }
 725                                 else
 726                                 {
 727                                         // Clicked outside of the window: drop
 728                                         if(button == 1)  // right
 729                                                 drop_amount = 1;
 730                                         else if(button == 2)  // middle
 731                                                 drop_amount = MYMIN(m_selected_amount, 10);
 732                                         else  // left
 733                                                 drop_amount = m_selected_amount;
 734                                 }
 735                         }
 736                 }
 737                 else if(updown == 1)
 738                 {
 739                         // Some mouse button has been released
 740
 741                         //infostream<<"Mouse button "<<button<<" released at p=("
 742                         //      <<p.X<<","<<p.Y<<")"<<std::endl;
 743
 744                         if(m_selected_item != NULL && m_selected_dragging && s.isValid())
 745                         {
 746                                 if(!identical)
 747                                 {
 748                                         // Dragged to different slot: move all selected
 749                                         move_amount = m_selected_amount;
 750                                 }
 751                         }
 752                         else if(m_selected_item != NULL && m_selected_dragging &&
 753                                 !(getAbsoluteClippingRect().isPointInside(m_pointer)))
 754                         {
 755                                 // Dragged outside of window: drop all selected
 756                                 drop_amount = m_selected_amount;
 757                         }
 758
 759                         m_selected_dragging = false;
 760                 }
 761
 762                 // Possibly send inventory action to server
 763                 if(move_amount > 0)
 764                 {
 765                         // Send IACTION_MOVE
 766
 767                         assert(m_selected_item && m_selected_item->isValid());
 768                         assert(s.isValid());
 769
 770                         assert(inv_selected && inv_s);
 771                         InventoryList *list_from = inv_selected->getList(m_selected_item->listname);
 772                         InventoryList *list_to = inv_s->getList(s.listname);
 773                         assert(list_from && list_to);
 774                         ItemStack stack_from = list_from->getItem(m_selected_item->i);
 775                         ItemStack stack_to = list_to->getItem(s.i);
 776
 777                         // Check how many items can be moved
 778                         move_amount = stack_from.count = MYMIN(move_amount, stack_from.count);
 779                         ItemStack leftover = stack_to.addItem(stack_from, m_gamedef->idef());
 780                         if(leftover.count == stack_from.count)
 781                         {
 782                                 // Swap the stacks
 783                                 m_selected_amount -= stack_to.count;
 784                         }
 785                         else if(leftover.empty())
 786                         {
 787                                 // Item fits
 788                                 m_selected_amount -= move_amount;
 789                         }
 790                         else
 791                         {
 792                                 // Item only fits partially
 793                                 move_amount -= leftover.count;
 794                                 m_selected_amount -= move_amount;
 795                         }
 796
 797                         infostream<<"Handing IACTION_MOVE to manager"<<std::endl;
 798                         IMoveAction *a = new IMoveAction();
 799                         a->count = move_amount;
 800                         a->from_inv = m_selected_item->inventoryloc;
 801                         a->from_list = m_selected_item->listname;
 802                         a->from_i = m_selected_item->i;
 803                         a->to_inv = s.inventoryloc;
 804                         a->to_list = s.listname;
 805                         a->to_i = s.i;
 806                         m_invmgr->inventoryAction(a);
 807                 }
 808                 else if(drop_amount > 0)
 809                 {
 810                         // Send IACTION_DROP
 811
 812                         assert(m_selected_item && m_selected_item->isValid());
 813                         assert(inv_selected);
 814                         InventoryList *list_from = inv_selected->getList(m_selected_item->listname);
 815                         assert(list_from);
 816                         ItemStack stack_from = list_from->getItem(m_selected_item->i);
 817
 818                         // Check how many items can be dropped
 819                         drop_amount = stack_from.count = MYMIN(drop_amount, stack_from.count);
 820                         assert(drop_amount > 0 && drop_amount <= m_selected_amount);
 821                         m_selected_amount -= drop_amount;
 822
 823                         infostream<<"Handing IACTION_DROP to manager"<<std::endl;
 824                         IDropAction *a = new IDropAction();
 825                         a->count = drop_amount;
 826                         a->from_inv = m_selected_item->inventoryloc;
 827                         a->from_list = m_selected_item->listname;
 828                         a->from_i = m_selected_item->i;
 829                         m_invmgr->inventoryAction(a);
 830                 }
 831                 else if(craft_amount > 0)
 832                 {
 833                         // Send IACTION_CRAFT
 834
 835                         assert(s.isValid());
 836                         assert(inv_s);
 837
 838                         infostream<<"Handing IACTION_CRAFT to manager"<<std::endl;
 839                         ICraftAction *a = new ICraftAction();
 840                         a->count = craft_amount;
 841                         a->craft_inv = s.inventoryloc;
 842                         m_invmgr->inventoryAction(a);
 843                 }
 844
 845                 // If m_selected_amount has been decreased to zero, deselect
 846                 if(m_selected_amount == 0)
 847                 {
 848                         delete m_selected_item;
 849                         m_selected_item = NULL;
 850                         m_selected_amount = 0;
 851                         m_selected_dragging = false;
 852                 }
 853         }
 854         if(event.EventType==EET_GUI_EVENT)
 855         {
 856                 if(event.GUIEvent.EventType==gui::EGET_ELEMENT_FOCUS_LOST
 857                                 && isVisible())
 858                 {
 859                         if(!canTakeFocus(event.GUIEvent.Element))
 860                         {
 861                                 infostream<<"GUIInventoryMenu: Not allowing focus change."
 862                                                 <<std::endl;
 863                                 // Returning true disables focus change
 864                                 return true;
 865                         }
 866                 }
 867                 if(event.GUIEvent.EventType==gui::EGET_BUTTON_CLICKED)
 868                 {
 869                         /*switch(event.GUIEvent.Caller->getID())
 870                         {
 871                         case 256: // continue
 872                                 setVisible(false);
 873                                 break;
 874                         case 257: // exit
 875                                 dev->closeDevice();
 876                                 break;
 877                         }*/
 878                 }
 879         }
 880
 881         return Parent ? Parent->OnEvent(event) : false;
 882 }
 883