ryzom/client/src/item_group_manager.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010-2017  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "stdpch.h"
  21
  22 #include "item_group_manager.h"
  23 #include "interface_v3/inventory_manager.h"
  24 #include "nel/gui/widget_manager.h"
  25 #include "nel/misc/sheet_id.h"
  26 #include "nel/misc/stream.h"
  27 #include "nel/misc/o_xml.h"
  28 #include "nel/misc/i_xml.h"
  29 #include "nel/misc/file.h"
  30 #include "nel/misc/xml_macros.h"
  31 #include "libxml/tree.h"
  32 #include "game_share/item_type.h"
  33 #include "client_sheets/item_sheet.h"
  34 #include "net_manager.h"
  35 #include "connection.h" // Used to access PlayerSelectedFileName for xml filename
  36 #include "nel/gui/db_manager.h"
  37 #include "interface_v3/interface_manager.h"
  38 #include "nel/gui/group_menu.h"
  39 #include "nel/misc/i18n.h"
  40 #include "nel/misc/algo.h"
  41 CItemGroupManager *CItemGroupManager::_Instance = NULL;
  42
  43 CItemGroup::CItemGroup()
  44 {
  45 }
  46
  47 // return true if any item in the group match the parameter ; slot is UNDEFINED unless the item has been found in the group
  48 bool CItemGroup::contains(CDBCtrlSheet *pCS)
  49 {
  50         for (int i = 0; i < items.size(); i++)
  51         {
  52                 CItem item = items[i];
  53                 if (item.createTime == pCS->getItemCreateTime() && item.serial == pCS->getItemSerial())
  54                         return true;
  55         }
  56         return false;
  57 }
  58
  59 void CItemGroup::addSheet(CDBCtrlSheet *pCS, CSlot slot, bool removeEmpty)
  60 {
  61         if (!pCS)
  62                 return;
  63
  64         if (pCS->isSheetValid())
  65         {
  66                 addItem(CItem(pCS->getItemCreateTime(), pCS->getItemSerial(), slot));
  67         }
  68         else if (removeEmpty)
  69         {
  70                 addRemoveSlot(slot);
  71         }
  72 }
  73
  74 void CItemGroup::addItem(CItem item)
  75 {
  76         if (!item.dstSlot.isValid())
  77                 return;
  78
  79         // Check if item already exists in group, this could happen if:
  80         // 1. Creating a group with a 2-hand item (and the item is found both in handR and handL)
  81         // 2. If user incorrectly edits the xml file
  82         for (int i = 0; i < items.size(); i++)
  83         {
  84                 CItem existingItem = items[i];
  85                 if (existingItem.createTime == item.createTime && existingItem.serial == item.serial)
  86                 {
  87                         nldebug("<CItemGroup::addItem> Not adding duplicate item, createTime: %d, serial: %d", item.createTime, item.serial);
  88                         // If duplicate item because of a 2-hand item:
  89                         // If it's existing as a left hand item, overwrite it as a right hand item instead (so we have only 1 correct item)
  90                         if (existingItem.dstSlot == CSlot::handSlot(1) && item.dstSlot == CSlot::handSlot(0))
  91                                 existingItem.dstSlot = CSlot::handSlot(0);
  92                         return;
  93                 }
  94         }
  95
  96         items.push_back(item);
  97 }
  98
  99 void CItemGroup::addRemoveSlot(CSlot slot)
 100 {
 101         if (!slot.isValid())
 102                 return;
 103
 104         removeSlots.push_back(slot);
 105 }
 106
 107 void CItemGroup::CItem::equip(uint32 &equipTime)
 108 {
 109         if (!pCS)
 110         {
 111                 nlwarning("<CItemGroup::CItem::equip> inv item is invalid");
 112                 return;
 113         }
 114
 115         if (!dstSlot.isValid())
 116         {
 117                 nlwarning("<CItemGroup::CItem::equip> item destination slot is invalid");
 118                 return;
 119         }
 120
 121         // if item is already equipped, and in the good slot, no need to equip
 122         if (dstSlot.getSheet()->isSheetEqual(pCS))
 123         {
 124                 return;
 125         }
 126
 127         // make sure the item can go into the slot (for example left-hand item can't always in left-hand slot)
 128         // this is also checked on the server, but avoids visual glitch if checked on client too
 129         if (!dstSlot.getSheet()->canDropItem(pCS))
 130         {
 131                 nlwarning("<CItemGroup::CItem::equip> item %d can't be dropped in slot %s", pCS->getSheetId(), dstSlot.toDbPath().c_str());
 132                 return;
 133         }
 134
 135         std::string srcPath = pCS->getSheet();
 136         equipTime = std::max(equipTime, pCS->asItemSheet()->EquipTime);
 137         CInventoryManager::getInstance()->equip(srcPath, dstSlot.toDbPath());
 138 }
 139
 140 // return if the item is already in it's destination slot
 141 bool CItemGroup::CItem::isInDestinationSlot()
 142 {
 143         return dstSlot.getSheet()->getInventoryIndex() == pCS->getInventoryIndex() && dstSlot.getSheet()->getIndexInDB() == pCS->getIndexInDB();
 144 }
 145
 146 void CItemGroup::CSlot::writeTo(xmlNodePtr node)
 147 {
 148         xmlSetProp(node, (const xmlChar *)"branch", (const xmlChar *)INVENTORIES::toString(branch).c_str());
 149         xmlSetProp(node, (const xmlChar *)"index", (const xmlChar *)NLMISC::toString(index).c_str());
 150 }
 151
 152 void CItemGroup::CItem::writeTo(xmlNodePtr node)
 153 {
 154         xmlSetProp(node, (const xmlChar *)"createTime", (const xmlChar *)NLMISC::toString(createTime).c_str());
 155         xmlSetProp(node, (const xmlChar *)"serial", (const xmlChar *)NLMISC::toString(serial).c_str());
 156         dstSlot.writeTo(node);
 157 }
 158
 159 void CItemGroup::writeTo(xmlNodePtr node)
 160 {
 161         xmlNodePtr groupNode = xmlNewChild(node, NULL, (const xmlChar *)"group", NULL);
 162         xmlSetProp(groupNode, (const xmlChar *)"name", (const xmlChar *)name.c_str());
 163         for (int i = 0; i < items.size(); i++)
 164         {
 165                 xmlNodePtr itemNode = xmlNewChild(groupNode, NULL, (const xmlChar *)"item", NULL);
 166                 items[i].writeTo(itemNode);
 167         }
 168         for (int i = 0; i < removeSlots.size(); i++)
 169         {
 170                 xmlNodePtr removeNode = xmlNewChild(groupNode, NULL, (const xmlChar *)"remove", NULL);
 171                 removeSlots[i].writeTo(removeNode);
 172         }
 173 }
 174
 175 CItemGroup::CSlot CItemGroup::CSlot::readFromV1(xmlNodePtr node)
 176 {
 177         CXMLAutoPtr prop;
 178         string equipSlot;
 179         XML_READ_STRING(node, "slot", equipSlot, "");
 180         return CItemGroup::CSlot::fromSlotEquipment(SLOT_EQUIPMENT::stringToSlotEquipment(NLMISC::toUpperAscii(equipSlot)));
 181 }
 182
 183 CItemGroup::CSlot CItemGroup::CSlot::readFromV2(xmlNodePtr node)
 184 {
 185         CXMLAutoPtr prop;
 186         INVENTORIES::TInventory branch = INVENTORIES::UNDEFINED;
 187         prop = xmlGetProp(node, (xmlChar *)"branch");
 188         if (prop)
 189                 branch = INVENTORIES::toInventory((const char *)prop);
 190
 191         uint16 index = 0;
 192         prop = (char *)xmlGetProp(node, (xmlChar *)"index");
 193         if (prop)
 194                 NLMISC::fromString((const char *)prop, index);
 195
 196         return CSlot(branch, index);
 197 }
 198
 199 CItemGroup::CItem CItemGroup::CItem::readFrom(xmlNodePtr node)
 200 {
 201         CXMLAutoPtr prop;
 202
 203         sint32 createTime = 0;
 204         prop = (char *)xmlGetProp(node, (xmlChar *)"createTime");
 205         if (prop)
 206                 NLMISC::fromString((const char *)prop, createTime);
 207
 208         // Version 0 does not use createTime, version 0 is not supported for migrations
 209         if (createTime == 0)
 210                 nlwarning("<CItemGroup::CItem::readFrom> Possibly on unsupported item group version, please remake the item group or contact support.");
 211
 212         sint32 serial = 0;
 213         prop = (char *)xmlGetProp(node, (xmlChar *)"serial");
 214         if (prop)
 215                 NLMISC::fromString((const char *)prop, serial);
 216
 217         return CItem(createTime, serial, CSlot());
 218 }
 219
 220 void CItemGroup::deserialize(xmlNodePtr node, std::string version)
 221 {
 222         CXMLAutoPtr prop;
 223
 224         prop = (char *)xmlGetProp(node, (xmlChar *)"name");
 225         if (prop)
 226                 NLMISC::fromString((const char *)prop, name);
 227
 228         xmlNodePtr curNode = node->children;
 229         while (curNode)
 230         {
 231                 CSlot slot;
 232                 if (version == "1")
 233                         slot = CSlot::readFromV1(curNode);
 234                 else if (version == "2")
 235                         slot = CSlot::readFromV2(curNode);
 236                 else
 237                 {
 238                         nlwarning("<CItemGroup::deserialize> unknown version, can't deserialize group");
 239                         return;
 240                 }
 241
 242                 if (strcmp((char *)curNode->name, "item") == 0)
 243                 {
 244                         CItem item = CItem::readFrom(curNode);
 245                         item.dstSlot = slot;
 246                         addItem(item);
 247                 }
 248                 else if (strcmp((char *)curNode->name, "remove") == 0)
 249                         addRemoveSlot(slot);
 250
 251                 curNode = curNode->next;
 252         }
 253
 254         // sort the items by slot (important so that left hand is equipped after right hand)
 255         std::sort(items.begin(), items.end());
 256 }
 257
 258 // Updates the CDBCtrlSheet in each CItem
 259 // ! This function must be called before every interaction with items of a CItemGroup
 260 //
 261 // Explanation: We must link the CItem (which just represents identifiers of an item) of the CItemGroup
 262 // with an item in the current inventory. Basically, here we are locating the position of the item in the inventory
 263 // and we are setting it to the pCS property of CItem, so we can then equip or move CItem via its CDBCtrlSheet.
 264 // It is possible that the item is deleted or moved, so we must check for this.
 265 void CItemGroup::updateSheets()
 266 {
 267         CInventoryManager *pIM = CInventoryManager::getInstance();
 268         for (uint i = 0; i < items.size(); i++)
 269         {
 270                 CItem item = items[i];
 271                 bool found = false;
 272                 for (int i = 0; i < INVENTORIES::NUM_ALL_INVENTORY; i++)
 273                 {
 274                         INVENTORIES::TInventory inventory = (INVENTORIES::TInventory)i;
 275                         if (pIM->isInventoryAvailable(inventory))
 276                         {
 277                                 std::string dbPath = CInventoryManager::invToDbPath(inventory);
 278                                 if (dbPath.empty() || (inventory == INVENTORIES::guild && !ClientCfg.ItemGroupAllowGuild))
 279                                 {
 280                                         nldebug("<CItemGroup::updateSheets> Inventory type %s not supported", INVENTORIES::toString(inventory).c_str());
 281                                         continue;
 282                                 }
 283                                 IListSheetBase *pList = dynamic_cast<IListSheetBase *>(CWidgetManager::getInstance()->getElementFromId(dbPath));
 284                                 for (int i = 0; i < pList->getNbSheet(); i++)
 285                                 {
 286                                         CDBCtrlSheet *pCS = pList->getSheet(i);
 287                                         if (item.createTime == pCS->getItemCreateTime() && item.serial == pCS->getItemSerial())
 288                                         {
 289                                                 item.pCS = pCS;
 290                                                 found = true;
 291                                                 break;
 292                                         }
 293                                 }
 294                                 if (found)
 295                                         break;
 296                         }
 297                 }
 298                 if (!found)
 299                 {
 300                         nlinfo("<CItemGroup::updateSheets> Item not found in inventory: createTime: %d, serial: %d", item.createTime, item.serial);
 301                         item.pCS = NULL;
 302                 }
 303                 items.at(i) = item;
 304         }
 305 }
 306
 307 const std::string CItemGroup::CSlot::toDbPath()
 308 {
 309         std::string dbPath = "";
 310         std::string dbBranch = INVENTORIES::toLocalDbBranch(branch);
 311
 312         if (!dbBranch.empty())
 313                 dbPath = string(LOCAL_INVENTORY) + ":" + dbBranch + ":" + NLMISC::toString(index);
 314
 315         return dbPath;
 316 }
 317
 318 const std::string CItemGroup::CSlot::toString()
 319 {
 320         std::string commonName;
 321         if (branch == INVENTORIES::handling)
 322                 commonName = "Hand" + string(index == 0 ? "R" : "L");
 323         else if (branch == INVENTORIES::equipment)
 324                 commonName = SLOT_EQUIPMENT::toString((SLOT_EQUIPMENT::TSlotEquipment)index);
 325         else if (branch == INVENTORIES::hotbar)
 326                 commonName = "Pocket #" + NLMISC::toString(index + 1);
 327         else
 328                 commonName = "unknown";
 329         return NLMISC::toString("%s:%sindex=\"%d\"", commonName.c_str(), string(10 - commonName.length(), ' ').c_str(), index);
 330 }
 331
 332 bool CItemGroup::CSlot::isValid()
 333 {
 334         return ((branch == INVENTORIES::handling && index < MAX_HANDINV_ENTRIES)
 335             || (branch == INVENTORIES::equipment && index < MAX_EQUIPINV_ENTRIES)
 336             || (branch == INVENTORIES::hotbar && index < MAX_HOTBARINV_ENTRIES));
 337 }
 338
 339 CDBCtrlSheet *CItemGroup::CSlot::getSheet()
 340 {
 341         CInventoryManager *pIM = CInventoryManager::getInstance();
 342         CDBCtrlSheet *pCS = NULL;
 343         if (branch == INVENTORIES::handling)
 344                 pCS = pIM->getHandSheet(index);
 345         else if (branch == INVENTORIES::equipment)
 346                 pCS = pIM->getEquipSheet(index);
 347         else if (branch == INVENTORIES::hotbar)
 348                 pCS = pIM->getHotbarSheet(index);
 349         return pCS;
 350 }
 351
 352 CItemGroup::CSlot CItemGroup::CSlot::fromSlotEquipment(SLOT_EQUIPMENT::TSlotEquipment slotEquipment)
 353 {
 354         CSlot slot;
 355         if (slotEquipment == SLOT_EQUIPMENT::HANDR)
 356                 slot = handSlot(0);
 357         else if (slotEquipment == SLOT_EQUIPMENT::HANDL)
 358                 slot = handSlot(1);
 359         else
 360                 slot = equipSlot(slotEquipment);
 361         return slot;
 362 }
 363
 364 CItemGroupManager::CItemGroupManager()
 365 {
 366 }
 367
 368 void CItemGroupManager::init()
 369 {
 370         loadGroups();
 371         linkInterface();
 372 }
 373
 374 void CItemGroupManager::linkInterface()
 375 {
 376         // attach item group subgroup to right-click in bag group
 377         CWidgetManager *pWM = CWidgetManager::getInstance();
 378         CGroupMenu *pRootMenu = dynamic_cast<CGroupMenu *>(pWM->getElementFromId(MENU_IN_BAG));
 379         CGroupSubMenu *pMenu = pRootMenu->getRootMenu();
 380         // get item subgroup
 381         CGroupMenu *pGroupMenu = dynamic_cast<CGroupMenu *>(pWM->getElementFromId(ITEMGROUP_MENU));
 382         CGroupSubMenu *pGroupSubMenu = NULL;
 383         if (pGroupMenu)
 384                 pGroupSubMenu = pGroupMenu->getRootMenu();
 385         if (pMenu && pGroupSubMenu)
 386                 pMenu->setSubMenu(pMenu->getNumLine() - 1, pGroupSubMenu);
 387         else
 388                 nlwarning("<CItemGroupManager::linkInterface> Couldn't link group submenu to item_menu_in_bag, check your widgets.xml file");
 389
 390         // must draw the list equip tab
 391         drawGroupsList();
 392 }
 393
 394 void CItemGroupManager::uninit()
 395 {
 396         saveGroups();
 397         unlinkInterface();
 398         _Groups.clear();
 399 }
 400
 401 void CItemGroupManager::unlinkInterface()
 402 {
 403         // We need to unlink our menu to avoid crash on interface release
 404         CWidgetManager *pWM = CWidgetManager::getInstance();
 405         CGroupMenu *pGroupMenu = dynamic_cast<CGroupMenu *>(pWM->getElementFromId(ITEMGROUP_MENU));
 406         CGroupSubMenu *pGroupSubMenu = NULL;
 407         if (pGroupMenu)
 408                 pGroupSubMenu = pGroupMenu->getRootMenu();
 409         if (pGroupMenu)
 410                 pGroupMenu->reset();
 411         if (pGroupMenu && pGroupSubMenu)
 412                 pGroupMenu->delGroup(pGroupSubMenu, true);
 413         undrawGroupsList();
 414 }
 415
 416 std::string CItemGroupManager::getFilePath(std::string playerName)
 417 {
 418         return "save/groups_" + playerName + ".xml";
 419 }
 420
 421 // Inspired from macro parsing
 422 void CItemGroupManager::saveGroups()
 423 {
 424         if (PlayerSelectedFileName.empty())
 425         {
 426                 nlwarning("<CItemGroupManager::saveGroups> Trying to save group with an empty PlayerSelectedFileName, aborting");
 427                 return;
 428         }
 429
 430         std::string userGroupFileName = getFilePath(PlayerSelectedFileName);
 431         try
 432         {
 433                 NLMISC::COFile f;
 434                 if (f.open(userGroupFileName, false, false, true))
 435                 {
 436                         NLMISC::COXml xmlStream;
 437                         xmlStream.init(&f);
 438                         xmlDocPtr doc = xmlStream.getDocument();
 439                         xmlNodePtr comment = xmlNewDocComment(doc, (const xmlChar *)generateDocumentation().c_str());
 440                         xmlNodePtr node = xmlNewDocNode(doc, NULL, (const xmlChar *)"item_groups", NULL);
 441                         xmlSetProp(node, (const xmlChar *)"version", (const xmlChar *)ITEMGROUPS_CURRENT_VERSION);
 442                         xmlDocSetRootElement(doc, comment);
 443                         xmlAddSibling(comment, node);
 444                         for (int i = 0; i < _Groups.size(); i++)
 445                         {
 446                                 CItemGroup group = _Groups[i];
 447                                 group.writeTo(node);
 448                         }
 449                         xmlStream.flush();
 450                         f.close();
 451                 }
 452                 else
 453                         nlwarning("<CItemGroupManager::saveGroups> Can't open the file %s", userGroupFileName.c_str());
 454         }
 455         catch (const NLMISC::Exception &e)
 456         {
 457                 nlwarning("<CItemGroupManager::saveGroups> Error while writing the file %s : %s.", userGroupFileName.c_str(), e.what());
 458         }
 459 }
 460
 461 bool CItemGroupManager::loadGroups()
 462 {
 463         if (PlayerSelectedFileName.empty())
 464         {
 465                 nlwarning("<CItemGroupManager::loadGroups> Trying to load group with an empty PlayerSelectedFileName, aborting");
 466                 return false;
 467         }
 468
 469         std::string userGroupFileName = getFilePath(PlayerSelectedFileName);
 470         if (!NLMISC::CFile::fileExists(userGroupFileName) || NLMISC::CFile::getFileSize(userGroupFileName) == 0)
 471         {
 472                 nlinfo("<CItemGroupManager::loadGroups> No item groups file found !");
 473                 return false;
 474         }
 475         // Init loading
 476         NLMISC::CIFile f;
 477         f.open(userGroupFileName);
 478         NLMISC::CIXml xmlStream;
 479         xmlNodePtr globalEnclosing;
 480         try
 481         {
 482                 xmlStream.init(f);
 483                 // Actual loading
 484                 globalEnclosing = xmlStream.getRootNode();
 485         }
 486         catch (const NLMISC::EXmlParsingError &ex)
 487         {
 488                 nlwarning("<CItemGroupManager::loadGroups> Failed to parse '%s', skip", userGroupFileName.c_str());
 489                 return false;
 490         }
 491         if (!globalEnclosing)
 492         {
 493                 nlwarning("<CItemGroupManager::loadGroups> no root element in item_group xml, skipping xml parsing");
 494                 return false;
 495         }
 496         if (strcmp(((char *)globalEnclosing->name), "item_groups"))
 497         {
 498                 nlwarning("<CItemGroupManager::loadGroups> wrong root element in item_group xml, skipping xml parsing");
 499                 return false;
 500         }
 501
 502         // get version of the item groups file
 503         CXMLAutoPtr prop;
 504         string version;
 505         XML_READ_STRING(globalEnclosing, "version", version, "1");
 506
 507         // check if we need to migrate item groups save file
 508         if (version != ITEMGROUPS_CURRENT_VERSION)
 509         {
 510                 nlinfo("<CItemGroupManager::loadGroups> item group version mismatch, performing migration if possible");
 511                 // backup current file
 512                 NLMISC::CFile::copyFile(getFilePath(PlayerSelectedFileName + "_backup"), getFilePath(PlayerSelectedFileName));
 513         }
 514
 515         xmlNodePtr curNode = globalEnclosing->children;
 516         while (curNode)
 517         {
 518                 if (strcmp((char *)curNode->name, "group") == 0)
 519                 {
 520                         CItemGroup group;
 521                         group.deserialize(curNode, version);
 522                         if (group.empty())
 523                                 nlwarning("<CItemGroupManager::loadGroups> Item group '%s' loaded empty. Possibly on unsupported item group version, please remake the item group or contact support.", group.name.c_str());
 524                         _Groups.push_back(group);
 525                 }
 526                 curNode = curNode->next;
 527         }
 528         f.close();
 529
 530         return true;
 531 }
 532
 533 void CItemGroupManager::undrawGroupsList()
 534 {
 535         CGroupList *pParent = dynamic_cast<CGroupList *>(CWidgetManager::getInstance()->getElementFromId(LIST_ITEMGROUPS));
 536         if (!pParent)
 537                 return;
 538         pParent->clearGroups();
 539         pParent->setDynamicDisplaySize(false);
 540         CGroupList *pParent2 = dynamic_cast<CGroupList *>(CWidgetManager::getInstance()->getElementFromId(LIST_ITEMGROUPS_2));
 541         if (!pParent2)
 542                 return;
 543         pParent2->clearGroups();
 544         pParent2->setDynamicDisplaySize(false);
 545 }
 546
 547 void CItemGroupManager::drawGroupsList()
 548 {
 549         // rebuild groups list
 550         undrawGroupsList();
 551         CGroupList *pParent = dynamic_cast<CGroupList *>(CWidgetManager::getInstance()->getElementFromId(LIST_ITEMGROUPS));
 552         if (!pParent)
 553                 return;
 554         CGroupList *pParent2 = dynamic_cast<CGroupList *>(CWidgetManager::getInstance()->getElementFromId(LIST_ITEMGROUPS_2));
 555         if (!pParent2)
 556                 return;
 557         CViewBase *pView = pParent->getParent()->getView(LIST_EMPTY_TEXT);
 558         CViewBase *pView2 = pParent2->getParent()->getView(LIST_EMPTY_TEXT);
 559         if (_Groups.empty())
 560         {
 561                 pView->setActive(true);
 562                 pView2->setActive(true);
 563                 return;
 564         }
 565         else
 566         {
 567                 pView->setActive(false);
 568                 pView2->setActive(false);
 569         }
 570         for (uint i = 0; i < _Groups.size(); i++)
 571         {
 572                 CInterfaceGroup *pLine = generateGroupsListLine(LIST_ITEMGROUPS, i);
 573                 if (!pLine)
 574                         continue;
 575                 CInterfaceGroup *pLine2 = generateGroupsListLine(LIST_ITEMGROUPS_2, i);
 576                 if (!pLine2)
 577                         continue;
 578
 579                 // Add to the list
 580                 pLine->setParent(pParent);
 581                 pParent->addChild(pLine);
 582                 pLine2->setParent(pParent2);
 583                 pParent2->addChild(pLine2);
 584         }
 585 }
 586
 587 CInterfaceGroup *CItemGroupManager::generateGroupsListLine(std::string parent, uint i)
 588 {
 589         // create the group line
 590         std::string templateId = parent + ":g" + NLMISC::toString(i).c_str();
 591         std::vector<std::pair<string, string>> vParams;
 592         vParams.push_back(std::pair<string, string>("id", templateId));
 593         vParams.push_back(std::pair<string, string>("name", _Groups[i].name));
 594         CInterfaceGroup *pLine = NULL;
 595         pLine = CWidgetManager::getInstance()->getParser()->createGroupInstance(TEMPLATE_ITEMGROUP_ITEM, parent, vParams);
 596         if (!pLine)
 597                 return NULL;
 598
 599         // Set name
 600         CViewText *pViewName = dynamic_cast<CViewText *>(pLine->getView(TEMPLATE_ITEMGROUP_ITEM_NAME));
 601         if (pViewName)
 602                 pViewName->setText(_Groups[i].name);
 603
 604         return pLine;
 605 }
 606
 607 // move a group from all available inventory to dst
 608 bool CItemGroupManager::moveGroup(std::string name, INVENTORIES::TInventory dst)
 609 {
 610         CItemGroup *group = findGroup(name);
 611         if (!group)
 612         {
 613                 nlinfo("<CItemGroupManager::moveGroup> group %s not found", name.c_str());
 614                 return false;
 615         }
 616
 617         if (dst == INVENTORIES::UNDEFINED)
 618         {
 619                 nlinfo("<CItemGroupManager::moveGroup> Destination inventory not found");
 620                 return false;
 621         }
 622
 623         // update location of items in the inventory
 624         group->updateSheets();
 625
 626         CInventoryManager *pIM = CInventoryManager::getInstance();
 627         for (uint i = 0; i < group->items.size(); i++)
 628         {
 629                 CItemGroup::CItem item = group->items[i];
 630
 631                 if (!item.pCS)
 632                         continue;
 633
 634                 // if the item is equipped, don't move
 635                 CItemGroup::CSlot currentSlot;
 636                 if (isItemEquipped(item.pCS, currentSlot))
 637                 {
 638                         // if item is equipped, but not already in the wanted slot, unequip it first
 639                         if (!item.dstSlot.getSheet()->isSheetEqual(item.pCS))
 640                                 pIM->unequip(currentSlot.toDbPath());
 641                         continue;
 642                 }
 643
 644                 // If the item is already in dst inventory, no need to move it
 645                 if (item.pCS->getInventoryIndex() == dst)
 646                         continue;
 647
 648                 CAHManager::getInstance()->runActionHandler("move_item", item.pCS, "to=lists|nblist=1|listsheet0=" + CInventoryManager::invToDbPath(dst));
 649         }
 650
 651         return true;
 652 }
 653
 654 bool CItemGroupManager::equipGroup(std::string name, bool pullBefore)
 655 {
 656         CItemGroup *pGroup = findGroup(name);
 657         if (!pGroup)
 658         {
 659                 nlinfo("<CItemGroupManager::equipGroup> group %s not found", name.c_str());
 660                 return false;
 661         }
 662
 663         if (pullBefore)
 664                 moveGroup(name, INVENTORIES::bag);
 665
 666         // we must update the location of items, even after they were moved
 667         pGroup->updateSheets();
 668
 669         // first, unequip all remove slots
 670         for (int i = 0; i < pGroup->removeSlots.size(); i++)
 671         {
 672                 CItemGroup::CSlot slot = pGroup->removeSlots[i];
 673                 std::string dbPath = slot.toDbPath();
 674                 if (!dbPath.empty())
 675                         CInventoryManager::getInstance()->unequip(dbPath);
 676         }
 677
 678         // then, equip items
 679         uint32 equipTime = 0;
 680         for (int i = 0; i < pGroup->items.size(); i++)
 681         {
 682                 CItemGroup::CItem item = pGroup->items[i];
 683
 684                 item.equip(equipTime);
 685         }
 686
 687         return true;
 688 }
 689
 690 bool CItemGroupManager::createGroup(std::string name, bool removeEmpty)
 691 {
 692         if (findGroup(name))
 693                 return false;
 694
 695         CInventoryManager *pIM = CInventoryManager::getInstance();
 696         CItemGroup group = CItemGroup();
 697         group.name = name;
 698         uint16 i;
 699         for (i = 0; i < MAX_HANDINV_ENTRIES; i++)
 700         {
 701                 group.addSheet(pIM->getHandSheet(i), CItemGroup::CSlot::handSlot(i), removeEmpty);
 702         }
 703         for (i = 0; i < MAX_EQUIPINV_ENTRIES; ++i)
 704         {
 705                 group.addSheet(pIM->getEquipSheet(i), CItemGroup::CSlot::equipSlot(i), removeEmpty);
 706         }
 707         for (i = 0; i < MAX_HOTBARINV_ENTRIES; ++i)
 708         {
 709                 group.addSheet(pIM->getHotbarSheet(i), CItemGroup::CSlot::hotbarSlot(i), removeEmpty);
 710         }
 711
 712         _Groups.push_back(group);
 713
 714         // must redraw the list equip tab
 715         drawGroupsList();
 716
 717         return true;
 718 }
 719
 720 bool CItemGroupManager::deleteGroup(std::string name)
 721 {
 722         std::vector<CItemGroup> tmp;
 723         for (int i = 0; i < _Groups.size(); i++)
 724         {
 725                 CItemGroup group = _Groups[i];
 726                 if (group.name == name)
 727                         continue;
 728                 tmp.push_back(group);
 729         }
 730         // Nothing removed, error
 731         if (tmp.size() == _Groups.size())
 732                 return false;
 733         _Groups = tmp;
 734
 735         // must redraw the list equip tab
 736         drawGroupsList();
 737
 738         return true;
 739 }
 740
 741 void CItemGroupManager::listGroup()
 742 {
 743         CInterfaceManager *pIM = CInterfaceManager::getInstance();
 744         pIM->displaySystemInfo(NLMISC::CI18N::get("cmdListGroupHeader"));
 745         for (int i = 0; i < _Groups.size(); i++)
 746         {
 747                 CItemGroup group = _Groups[i];
 748                 string msg = NLMISC::CI18N::get("cmdListGroupLine");
 749                 NLMISC::strFindReplace(msg, "%name", group.name);
 750                 NLMISC::strFindReplace(msg, "%size", NLMISC::toString(group.items.size()));
 751                 pIM->displaySystemInfo(msg);
 752         }
 753 }
 754
 755 // Used by AH
 756 std::vector<std::string> CItemGroupManager::getGroupNames(CDBCtrlSheet *pCS)
 757 {
 758         std::vector<std::string> out;
 759         for (int i = 0; i < _Groups.size(); i++)
 760         {
 761                 CItemGroup group = _Groups[i];
 762                 if (group.contains(pCS))
 763                         out.push_back(group.name);
 764         }
 765         return out;
 766 }
 767
 768 // Private methods
 769 CItemGroup *CItemGroupManager::findGroup(std::string name)
 770 {
 771         for (int i = 0; i < _Groups.size(); i++)
 772         {
 773                 if (_Groups[i].name == name)
 774                         return &_Groups[i];
 775         }
 776         return NULL;
 777 }
 778
 779 // Workaround: sometimes item are marked as equipped by pIM->isBagItemWeared() even though they aren't really
 780 // Because of a synchronisation error between client and server
 781 bool CItemGroupManager::isItemEquipped(CDBCtrlSheet *pItem, CItemGroup::CSlot &equipSlot)
 782 {
 783         if (!pItem)
 784         {
 785                 nlinfo("<CItemGroupManager::isItemEquipped> item is null");
 786                 return true;
 787         }
 788
 789         CInventoryManager *pIM = CInventoryManager::getInstance();
 790         CDBCtrlSheet *pCS;
 791         for (uint i = 0; i < MAX_HANDINV_ENTRIES; i++)
 792         {
 793                 pCS = pIM->getHandSheet(i);
 794                 equipSlot = CItemGroup::CSlot::handSlot(i);
 795                 if (pItem->isSheetEqual(pCS))
 796                         return true;
 797         }
 798         for (uint32 i = 0; i < MAX_EQUIPINV_ENTRIES; ++i)
 799         {
 800                 pCS = pIM->getEquipSheet(i);
 801                 equipSlot = CItemGroup::CSlot::equipSlot(i);
 802                 if (pItem->isSheetEqual(pCS))
 803                         return true;
 804         }
 805
 806         for (uint32 i = 0; i < MAX_HOTBARINV_ENTRIES; ++i)
 807         {
 808                 pCS = pIM->getHotbarSheet(i);
 809                 equipSlot = CItemGroup::CSlot::hotbarSlot(i);
 810                 if (pItem->isSheetEqual(pCS))
 811                         return true;
 812         }
 813         return false;
 814 }
 815
 816 std::string CItemGroupManager::generateDocumentation()
 817 {
 818         std::string out;
 819         uint16 i;
 820         out += "\r\nItem Groups - Version " + string(ITEMGROUPS_CURRENT_VERSION) + "\r\n\r\n/// branch=\"handling\" ///\r\n";
 821         for (i = 0; i < MAX_HANDINV_ENTRIES; i++)
 822                 out += CItemGroup::CSlot::handSlot(i).toString() + "\r\n";
 823         out += "\r\n/// branch=\"equipment\" ///\r\n";
 824         for (i = 0; i < MAX_EQUIPINV_ENTRIES; ++i)
 825                 if (i != SLOT_EQUIPMENT::HANDL && i != SLOT_EQUIPMENT::HANDR)
 826                         out += CItemGroup::CSlot::equipSlot(i).toString() + "\r\n";
 827         out += "\r\n/// branch=\"hotbar\" ///\r\n";
 828         for (i = 0; i < MAX_HOTBARINV_ENTRIES; ++i)
 829                 out += CItemGroup::CSlot::hotbarSlot(i).toString() + "\r\n";
 830         return out;
 831 }
 832
 833 // Singleton management
 834 CItemGroupManager *CItemGroupManager::getInstance()
 835 {
 836         if (!_Instance)
 837                 _Instance = new CItemGroupManager();
 838         return _Instance;
 839 }
 840
 841 void CItemGroupManager::releaseInstance()
 842 {
 843         if (_Instance)
 844                 delete _Instance;
 845         _Instance = NULL;
 846 }