popupmenu.cpp

Go to the documentation of this file.

/*
 * The ManaPlus Client
 * Copyright (C) 2004-2009 The Mana World Development Team
 * Copyright (C) 2009-2010 The Mana Developers
 * Copyright (C) 2011-2019 The ManaPlus Developers
 *
 * This file is part of The ManaPlus Client.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "gui/popups/popupmenu.h"
 
#include "actormanager.h"
#include "configuration.h"
#include "party.h"
#include "settings.h"
 
#include "being/flooritem.h"
#include "being/localplayer.h"
#include "being/playerinfo.h"
#include "being/playerrelation.h"
#include "being/playerrelations.h"
 
#include "const/spells.h"
 
#include "enums/resources/map/mapitemtype.h"
 
#include "input/inputmanager.h"
 
#include "gui/buttontext.h"
#include "gui/gui.h"
#include "gui/popupmanager.h"
#include "gui/viewport.h"
#include "gui/windowmenu.h"
 
#include "gui/windows/chatwindow.h"
#include "gui/windows/inventorywindow.h"
#include "gui/windows/minimap.h"
#include "gui/windows/ministatuswindow.h"
#include "gui/windows/npcdialog.h"
#include "gui/windows/outfitwindow.h"
#include "gui/windows/socialwindow.h"
#include "gui/windows/textcommandeditor.h"
#include "gui/windows/textdialog.h"
#include "gui/windows/tradewindow.h"
 
#include "gui/widgets/button.h"
#include "gui/widgets/createwidget.h"
#include "gui/widgets/progressbar.h"
#include "gui/widgets/scrollarea.h"
#include "gui/widgets/staticbrowserbox.h"
#include "gui/widgets/textfield.h"
 
#include "gui/widgets/tabs/chat/whispertab.h"
 
#include "net/adminhandler.h"
#include "net/chathandler.h"
#include "net/guildhandler.h"
#include "net/npchandler.h"
#include "net/net.h"
 
#ifdef TMWA_SUPPORT
#include "net/tmwa/guildmanager.h"
#endif // TMWA_SUPPORT
 
#include "resources/chatobject.h"
#include "resources/groupinfo.h"
#include "resources/iteminfo.h"
#include "resources/itemmenuitem.h"
 
#include "resources/db/groupdb.h"
#include "resources/db/npcdb.h"
 
#include "resources/item/item.h"
 
#include "resources/map/map.h"
#include "resources/map/mapitem.h"
#include "resources/map/speciallayer.h"
 
#include "resources/skill/skillinfo.h"
 
#include "utils/checkutils.h"
#include "utils/foreach.h"
#include "utils/gettext.h"
 
#include "debug.h"
 
std::string tradePartnerName;
 
PopupMenu *popupMenu = nullptr;
 
PopupMenu::PopupMenu() :
 Popup("PopupMenu", "popupmenu.xml"),
 mBrowserBox(new StaticBrowserBox(this, Opaque_true,
 "popupbrowserbox.xml")),
 mScrollArea(nullptr),
 mBeingId(BeingId_zero),
 mFloorItemId(BeingId_zero),
 mItemId(0),
 mItemIndex(-1),
 mItemColor(ItemColor_one),
 mMapItem(nullptr),
 mTab(nullptr),
 mSpell(nullptr),
 mCallerWindow(nullptr),
 mRenameListener(),
 mPlayerListener(),
 mDialog(nullptr),
 mButton(nullptr),
 mGroup(nullptr),
 mName(),
 mExtName(),
 mTextField(nullptr),
 mType(ActorType::Unknown),
 mSubType(BeingTypeId_zero),
 mX(0),
 mY(0),
 mAllowCleanMenu(true)
{
 mBrowserBox->setOpaque(Opaque_false);
 mBrowserBox->setLinkHandler(this);
 mRenameListener.setMapItem(nullptr);
 mRenameListener.setDialog(nullptr);
 mPlayerListener.setNick("");
 mPlayerListener.setDialog(nullptr);
 mPlayerListener.setType(ActorType::Unknown);
 mScrollArea = new ScrollArea(this,
 mBrowserBox, Opaque_false, std::string());
 mScrollArea->setVerticalScrollPolicy(ScrollArea::SHOW_AUTO);
 addMouseListener(this);
}
 
void PopupMenu::postInit()
{
 Popup::postInit();
 add(mScrollArea);
}
 
void PopupMenu::initPopup()
{
 if (localPlayer == nullptr)
 return;
 const int groupId = localPlayer->getGroupId();
 mGroup = GroupDb::getGroup(groupId);
}
 
bool PopupMenu::isAllowCommand(const ServerCommandTypeT command)
{
 if (mGroup == nullptr)
 return false;
#ifdef TMWA_SUPPORT
 // allow any commands for legacy if group > 0
 if (Net::getNetworkType() == ServerType::TMWATHENA &&
 localPlayer != nullptr &&
 localPlayer->isGM())
 {
 return true;
 }
#endif
 if (mGroup->mPermissions[CAST_SIZE(ServerPermissionType::all_commands)] ==
 Enable_true)
 {
 return true;
 }
 const ServerCommandEnable::Type enabled =
 mGroup->mCommands[CAST_SIZE(command)];
 return (enabled & ServerCommandEnable::Self) != 0;
}
 
bool PopupMenu::isAllowOtherCommand(const ServerCommandTypeT command)
{
 if (mGroup == nullptr ||
 localPlayer == nullptr)
 return false;
#ifdef TMWA_SUPPORT
 // allow any commands for legacy if group > 0
 if (Net::getNetworkType() == ServerType::TMWATHENA &&
 localPlayer->isGM())
 {
 return true;
 }
#endif
 const ServerCommandEnable::Type enabled =
 mGroup->mCommands[CAST_SIZE(command)];
 if (mName == localPlayer->getName())
 return (enabled & ServerCommandEnable::Self) != 0;
 return (enabled & ServerCommandEnable::Other) != 0;
}
 
void PopupMenu::showPopup(const int x, const int y, const Being *const being)
{
 if (being == nullptr ||
 localPlayer == nullptr ||
 actorManager == nullptr)
 {
 return;
 }
 
 initPopup();
 mBeingId = being->getId();
 mName = being->getName();
 mExtName = being->getExtName();
 mType = being->getType();
 mSubType = being->getSubType();
 mBrowserBox->clearRows();
 mX = x;
 mY = y;
 
 const std::string &name = mName;
 if (being->getType() != ActorType::SkillUnit)
 {
 mBrowserBox->addRow(name + being->getGenderSignWithSpace(),
 false);
 }
 
 switch (being->getType())
 {
 case ActorType::Player:
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: trade with player
 mBrowserBox->addRow("/trade 'NAME'", _("Trade"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: trade attack player
 mBrowserBox->addRow("/attack 'NAME'", _("Attack"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: send whisper to player
 mBrowserBox->addRow("/whispertext 'NAME'", _("Whisper"));
 addMailCommands();
 addGmCommands();
 mBrowserBox->addSeparator("##3---");
 
#ifdef TMWA_SUPPORT
 if (Net::getNetworkType() == ServerType::TMWATHENA)
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: heal player
 mBrowserBox->addRow("/heal :'BEINGID'", _("Heal"));
 mBrowserBox->addSeparator("##3---");
 }
#endif // TMWA_SUPPORT
 
 addPlayerRelation(name);
 mBrowserBox->addSeparator("##3---");
 
 addFollow();
 addPartyName(being->getPartyName());
 
 const Guild *const guild1 = being->getGuild();
 const Guild *const guild2 = localPlayer->getGuild();
 if (guild2 != nullptr)
 {
 if (guild1 != nullptr)
 {
 if (guild1->getId() == guild2->getId())
 {
 mBrowserBox->addRow("/kickguild 'NAME'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: kick player from guild
 _("Kick from guild"));
 if (guild2->getServerGuild())
 {
 mBrowserBox->addRow(strprintf(
 "@@guild-pos|%s >@@",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: change player position in guild
 _("Change pos in guild")),
 false);
 }
 }
 }
 else if (guild2->getMember(mName) != nullptr)
 {
 mBrowserBox->addRow("/kickguild 'NAME'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: kick player from guild
 _("Kick from guild"));
 if (guild2->getServerGuild())
 {
 mBrowserBox->addRow(strprintf(
 "@@guild-pos|%s >@@",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: change player position in guild
 _("Change pos in guild")),
 false);
 }
 }
 else
 {
#ifdef TMWA_SUPPORT
 if (guild2->getServerGuild() ||
 (guildManager != nullptr && guildManager->havePower()))
#endif // TMWA_SUPPORT
 {
 mBrowserBox->addRow("/guild 'NAME'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: invite player to guild
 _("Invite to guild"));
 }
 }
 }
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: set player invisible for self by id
 mBrowserBox->addRow("/nuke 'NAME'", _("Nuke"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: move to player location
 mBrowserBox->addRow("/navigateto 'NAME'", _("Move"));
 addPlayerMisc();
 addBuySell(being);
 addChat(being);
 break;
 }
 
 case ActorType::Npc:
 if (!addBeingMenu())
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: talk with npc
 mBrowserBox->addRow("/talk :'BEINGID'", _("Talk"));
#ifdef TMWA_SUPPORT
 if (Net::getNetworkType() != ServerType::TMWATHENA)
#endif
 {
 mBrowserBox->addRow("/whispertext NPC:'NAME'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: whisper to npc
 _("Whisper"));
 }
 // TRANSLATORS: popup menu item
 // TRANSLATORS: buy from npc
 mBrowserBox->addRow("/buy 'NAME'", _("Buy"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: sell to npc
 mBrowserBox->addRow("/sell 'NAME'", _("Sell"));
 }
 
 addGmCommands();
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: move to npc location
 mBrowserBox->addRow("/navigateto 'NAME'", _("Move"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add comment to npc
 mBrowserBox->addRow("addcomment", _("Add comment"));
 addChat(being);
 break;
 
 case ActorType::Monster:
 {
 // Monsters can be attacked
 // TRANSLATORS: popup menu item
 // TRANSLATORS: attack monster
 mBrowserBox->addRow("/attack :'BEINGID'", _("Attack"));
 addCatchPetCommands();
 addGmCommands();
 mBrowserBox->addSeparator("##3---");
 
 if (config.getBoolValue("enableAttackFilter"))
 {
 mBrowserBox->addSeparator("##3---");
 if (actorManager->isInAttackList(name)
 || actorManager->isInIgnoreAttackList(name)
 || actorManager->isInPriorityAttackList(name))
 {
 mBrowserBox->addRow("/removeattack 'NAME'",
 // TRANSLATORS: remove monster from attack list
 // TRANSLATORS: popup menu item
 _("Remove from attack list"));
 }
 else
 {
 mBrowserBox->addRow("/addpriorityattack 'NAME'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add monster to priotiry attack list
 _("Add to priority attack list"));
 mBrowserBox->addRow("/addattack 'NAME'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add monster to attack list
 _("Add to attack list"));
 mBrowserBox->addRow("/addignoreattack 'NAME'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add monster to ignore list
 _("Add to ignore list"));
 }
 }
 break;
 }
 
 case ActorType::Mercenary:
 // TRANSLATORS: popup menu item
 // TRANSLATORS: Mercenary move to master
 mBrowserBox->addRow("/mercenarytomaster", _("Move to master"));
 addGmCommands();
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: fire mercenary
 mBrowserBox->addRow("/firemercenary", _("Fire"));
 mBrowserBox->addSeparator("##3---");
 break;
 
 case ActorType::Homunculus:
 {
 const HomunculusInfo *const info = PlayerInfo::getHomunculus();
 if (info != nullptr)
 {
 mBrowserBox->addRow("/homunculustomaster",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: homunculus move to master
 _("Move to master"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: feed homunculus
 mBrowserBox->addRow("/homunculusfeed", _("Feed"));
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: pet rename item
 mBrowserBox->addRow("/sethomunname", _("Rename"));
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: delete homunculus
 mBrowserBox->addRow("/homunculusfire", _("Kill"));
 mBrowserBox->addSeparator("##3---");
 }
 addGmCommands();
 break;
 }
 case ActorType::Pet:
 if (being->getOwner() == localPlayer)
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: feed pet
 mBrowserBox->addRow("/petfeed", _("Feed"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: pet drop loot
 mBrowserBox->addRow("/petdroploot", _("Drop loot"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: pet unequip item
 mBrowserBox->addRow("/petunequip", _("Unequip"));
 addGmCommands();
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: pet rename item
 mBrowserBox->addRow("/setpetname", _("Rename"));
 mBrowserBox->addSeparator("##3---");
 const BeingInfo *const info = being->getInfo();
 std::string msg;
 if (info != nullptr)
 msg = info->getString(0);
 if (!msg.empty())
 {
 mBrowserBox->addRow("/petreturnegg", msg.c_str());
 }
 else
 {
 mBrowserBox->addRow("/petreturnegg",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: pet return to egg
 _("Return to egg"));
 }
 mBrowserBox->addSeparator("##3---");
 }
 else
 {
 addCatchPetCommands();
 }
 break;
 case ActorType::SkillUnit:
 {
 const BeingId id = being->getCreatorId();
 std::string creatorName;
 Being *const creator = actorManager->findBeing(id);
 if (creator != nullptr)
 creatorName = creator->getName();
 else
 creatorName = actorManager->getSeenPlayerById(id);
 
 if (creatorName.empty())
 creatorName = strprintf("?%d", CAST_S32(id));
 
 mBrowserBox->addRow(strprintf("%s, %d (%s)",
 name.c_str(),
 CAST_S32(being->getSubType()),
 creatorName.c_str()),
 false);
 break;
 }
 case ActorType::Avatar:
 case ActorType::Unknown:
 case ActorType::FloorItem:
 case ActorType::Portal:
 case ActorType::Elemental:
 default:
 break;
 }
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add being name to chat
 mBrowserBox->addRow("/addtext 'NAME'", _("Add name to chat"));
 mBrowserBox->addSeparator("##3---");
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(x, y);
}
 
bool PopupMenu::addBeingMenu()
{
 Being *being = actorManager->findBeing(mBeingId);
 if (being == nullptr)
 return false;
 
 BeingInfo *const info = NPCDB::get(fromInt(
 being->getSubType(), BeingTypeId));
 if (info == nullptr)
 return false;
 
 const STD_VECTOR<BeingMenuItem> &menu = info->getMenu();
 FOR_EACH (STD_VECTOR<BeingMenuItem>::const_iterator, it, menu)
 {
 const BeingMenuItem &item = *it;
 mBrowserBox->addRow("/" + item.command, item.name.c_str());
 }
 return true;
}
 
void PopupMenu::setMousePos()
{
 if (viewport != nullptr)
 {
 mX = viewport->mMouseX;
 mY = viewport->mMouseY;
 }
 else
 {
 Gui::getMouseState(mX, mY);
 }
}
 
void PopupMenu::setMousePos2()
{
 if (mX == 0 && mY == 0)
 {
 if (viewport != nullptr)
 {
 mX = viewport->mMouseX;
 mY = viewport->mMouseY;
 }
 else
 {
 Gui::getMouseState(mX, mY);
 }
 }
}
 
void PopupMenu::showPopup(const int x, const int y,
 const STD_VECTOR<ActorSprite*> &beings)
{
 initPopup();
 mX = x;
 mY = y;
 mBrowserBox->clearRows();
 // TRANSLATORS: popup menu header
 mBrowserBox->addRow(_("Players"), false);
 FOR_EACH (STD_VECTOR<ActorSprite*>::const_iterator, it, beings)
 {
 const Being *const being = dynamic_cast<const Being*>(*it);
 const ActorSprite *const actor = *it;
 if ((being != nullptr) && !being->getName().empty())
 {
 mBrowserBox->addRow(strprintf("@@player_%u|%s >@@",
 CAST_U32(being->getId()), (being->getName()
 + being->getGenderSignWithSpace()).c_str()),
 false);
 }
 else if (actor->getType() == ActorType::FloorItem)
 {
 const FloorItem *const floorItem
 = static_cast<const FloorItem*>(actor);
 mBrowserBox->addRow(strprintf("@@flooritem_%u|%s >@@",
 CAST_U32(actor->getId()),
 floorItem->getName().c_str()),
 false);
 }
 }
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 showPopup(x, y);
}
 
void PopupMenu::showPlayerPopup(const std::string &nick)
{
 if (nick.empty() || (localPlayer == nullptr))
 return;
 
 initPopup();
 setMousePos();
 mName = nick;
 mExtName = nick;
 mBeingId = BeingId_zero;
 mType = ActorType::Player;
 mSubType = BeingTypeId_zero;
 mBrowserBox->clearRows();
 
 const std::string &name = mName;
 
 mBrowserBox->addRow(name, false);
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: send whisper to player
 mBrowserBox->addRow("/whispertext 'NAME'", _("Whisper"));
 addMailCommands();
 addGmCommands();
 mBrowserBox->addSeparator("##3---");
 
 addPlayerRelation(name);
 mBrowserBox->addSeparator("##3---");
 
 addFollow();
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add comment to player
 mBrowserBox->addRow("addcomment", _("Add comment"));
 
 if (localPlayer->isInParty())
 {
 const Party *const party = localPlayer->getParty();
 if (party != nullptr)
 {
 const PartyMember *const member = party->getMember(mName);
 if (member != nullptr)
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: kick player from party
 mBrowserBox->addRow("/kickparty 'NAME'", _("Kick from party"));
 mBrowserBox->addSeparator("##3---");
 const PartyMember *const o = party->getMember(
 localPlayer->getName());
 showAdoptCommands();
 if ((o != nullptr) && member->getMap() == o->getMap())
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: move to player position
 mBrowserBox->addRow("/navigate 'X' 'Y'", _("Move"));
 }
 }
 }
 }
 
 const Guild *const guild2 = localPlayer->getGuild();
 if (guild2 != nullptr)
 {
 if (guild2->getMember(mName) != nullptr)
 {
#ifdef TMWA_SUPPORT
 if (guild2->getServerGuild() || (guildManager != nullptr
 && guildManager->havePower()))
#endif // TMWA_SUPPORT
 {
 mBrowserBox->addRow("/kickguild 'NAME'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: kick player from guild
 _("Kick from guild"));
 }
 if (guild2->getServerGuild())
 {
 mBrowserBox->addRow(strprintf(
 // TRANSLATORS: popup menu item
 // TRANSLATORS: change player position in guild
 "@@guild-pos|%s >@@", _("Change pos in guild")),
 false);
 }
 }
 else
 {
#ifdef TMWA_SUPPORT
 if (guild2->getServerGuild() || (guildManager != nullptr
 && guildManager->havePower()))
#endif // TMWA_SUPPORT
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: invite player to guild
 mBrowserBox->addRow("/guild 'NAME'", _("Invite to guild"));
 }
 }
 }
 
 addBuySellDefault();
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player name to chat
 mBrowserBox->addRow("/addtext 'NAME'", _("Add name to chat"));
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(mX, mY);
}
 
void PopupMenu::showPopup(const int x, const int y,
 const FloorItem *const floorItem)
{
 if (floorItem == nullptr)
 return;
 
 initPopup();
 mX = x;
 mY = y;
 mFloorItemId = floorItem->getId();
 mItemId = floorItem->getItemId();
 mType = ActorType::FloorItem;
 mSubType = BeingTypeId_zero;
 for (int f = 0; f < maxCards; f ++)
 mItemCards[f] = floorItem->getCard(f);
 mBrowserBox->clearRows();
 const std::string name = floorItem->getName();
 mName = name;
 mExtName = name;
 
 mBrowserBox->addRow(name, false);
 
 if (config.getBoolValue("enablePickupFilter"))
 {
 if (actorManager->isInPickupList(name)
 || (actorManager->isInPickupList("")
 && !actorManager->isInIgnorePickupList(name)))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: pickup item from ground
 mBrowserBox->addRow("/pickup 'FLOORID'", _("Pick up"));
 mBrowserBox->addSeparator("##3---");
 }
 addPickupFilter(name);
 }
 else
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: pickup item from ground
 mBrowserBox->addRow("/pickup 'FLOORID'", _("Pick up"));
 }
 addProtection();
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add item name to chat
 mBrowserBox->addRow("/addchat 'FLOORID''CARDS'", _("Add to chat"));
 mBrowserBox->addSeparator("##3---");
 addGmCommands();
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(mX, mY);
}
 
void PopupMenu::showPopup(const int x, const int y, MapItem *const mapItem)
{
 if (mapItem == nullptr)
 return;
 
 initPopup();
 mMapItem = mapItem;
 mX = x;
 mY = y;
 
 mBrowserBox->clearRows();
 
 // TRANSLATORS: popup menu header
 mBrowserBox->addRow(_("Map Item"), false);
 // TRANSLATORS: popup menu item
 // TRANSLATORS: rename map item
 mBrowserBox->addRow("rename map", _("Rename"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: remove map item
 mBrowserBox->addRow("remove map", _("Remove"));
 
 if (isAllowCommand(ServerCommandType::slide))
 {
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: warp to map item
 mBrowserBox->addRow("/slide 'MAPX' 'MAPY'", _("Warp"));
 }
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(x, y);
}
 
void PopupMenu::showMapPopup(const int x, const int y,
 const int x2, const int y2,
 const bool isMinimap)
{
 initPopup();
 mX = x2;
 mY = y2;
 
 if (isMinimap)
 mCallerWindow = minimap;
 
 mBrowserBox->clearRows();
 
 // TRANSLATORS: popup menu header
 mBrowserBox->addRow(_("Map Item"), false);
 
 if (isAllowCommand(ServerCommandType::slide))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: warp to map item
 mBrowserBox->addRow("/slide 'MAPX' 'MAPY'", _("Warp"));
 }
 // TRANSLATORS: popup menu item
 // TRANSLATORS: move to map item
 mBrowserBox->addRow("/navigate 'X' 'Y'", _("Move"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: move camera to map item
 mBrowserBox->addRow("/movecamera 'X' 'Y'", _("Move camera"));
 if (settings.cameraMode != 0)
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: restore camera to default view
 mBrowserBox->addRow("/restorecamera", _("Restore camera"));
 }
 mBrowserBox->addSeparator("##3---");
 if (isMinimap)
 {
 // TRANSLATORS: popup menu item
 mBrowserBox->addRow("window close", _("Close"));
 }
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(x, y);
}
 
void PopupMenu::showOutfitsWindowPopup(const int x, const int y)
{
 initPopup();
 mX = x;
 mY = y;
 mCallerWindow = outfitWindow;
 
 mBrowserBox->clearRows();
 
 // TRANSLATORS: popup menu header
 mBrowserBox->addRow(_("Outfits"), false);
 // TRANSLATORS: popup menu item
 // TRANSLATORS: copy selected outfit to chat input
 mBrowserBox->addRow("/outfittochat", _("Add to chat"));
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: copy equipment from player to outfit
 mBrowserBox->addRow("/itemstooutfit", _("Copy from player"));
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: clear selected outfit
 mBrowserBox->addRow("/clearoutfit", _("Clear outfit"));
 mBrowserBox->addSeparator("##3---");
 
 addWindowMenu(outfitWindow);
 mBrowserBox->addSeparator("##3---");
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(x, y);
}
 
void PopupMenu::showSpellPopup(const int x, const int y,
 TextCommand *const cmd)
{
 if (cmd == nullptr)
 return;
 
 initPopup();
 mBrowserBox->clearRows();
 
 mSpell = cmd;
 mX = x;
 mY = y;
 
 // TRANSLATORS: popup menu header
 mBrowserBox->addRow(_("Spells"), false);
 // TRANSLATORS: popup menu item
 // TRANSLATORS: edit selected spell
 mBrowserBox->addRow("edit spell", _("Edit spell"));
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(x, y);
}
 
void PopupMenu::showChatPopup(const int x, const int y, ChatTab *const tab)
{
 if (tab == nullptr ||
 actorManager == nullptr ||
 localPlayer == nullptr)
 {
 return;
 }
 
 initPopup();
 mTab = tab;
 mX = x;
 mY = y;
 mCallerWindow = chatWindow;
 
 mBrowserBox->clearRows();
 
 const ChatTabTypeT &type = tab->getType();
 if (type == ChatTabType::WHISPER || type == ChatTabType::CHANNEL)
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close chat tab
 mBrowserBox->addRow("/close", _("Close"));
 }
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: remove all text from chat tab
 mBrowserBox->addRow("/chatclear", _("Clear"));
 mBrowserBox->addSeparator("##3---");
 
 if (tab->getAllowHighlight())
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: disable chat tab highlight
 mBrowserBox->addRow("/disablehighlight", _("Disable highlight"));
 }
 else
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: enable chat tab highlight
 mBrowserBox->addRow("/enablehighlight", _("Enable highlight"));
 }
 if (tab->getRemoveNames())
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: do not remove player names from chat tab
 mBrowserBox->addRow("/dontremovename", _("Don't remove name"));
 }
 else
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: remove player names from chat tab
 mBrowserBox->addRow("/removename", _("Remove name"));
 }
 if (tab->getNoAway())
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: enable away messages in chat tab
 mBrowserBox->addRow("/enableaway", _("Enable away"));
 }
 else
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: disable away messages in chat tab
 mBrowserBox->addRow("/disableaway", _("Disable away"));
 }
 mBrowserBox->addSeparator("##3---");
 if (type == ChatTabType::PARTY)
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: enable away messages in chat tab
 mBrowserBox->addRow("/leaveparty", _("Leave"));
 mBrowserBox->addSeparator("##3---");
 }
 // TRANSLATORS: popup menu item
 // TRANSLATORS: copy selected text to clipboard
 mBrowserBox->addRow("/chatclipboard 'X' 'Y'", _("Copy to clipboard"));
 mBrowserBox->addSeparator("##3---");
 
 if (type == ChatTabType::WHISPER)
 {
 const WhisperTab *const wTab = static_cast<WhisperTab*>(tab);
 const std::string &name = wTab->getNick();
 
 const Being* const being = actorManager->findBeingByName(
 name, ActorType::Player);
 
 addGmCommands();
 if (being != nullptr)
 {
 mBeingId = being->getId();
 mName = being->getName();
 mExtName = being->getExtName();
 mType = being->getType();
 mSubType = being->getSubType();
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: trade with player
 mBrowserBox->addRow("/trade 'NAME'", _("Trade"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: attack player
 mBrowserBox->addRow("/attack 'NAME'", _("Attack"));
 addMailCommands();
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: heal player
 mBrowserBox->addRow("/heal :'BEINGID'", _("Heal"));
 mBrowserBox->addSeparator("##3---");
 addPlayerRelation(name);
 mBrowserBox->addSeparator("##3---");
 addFollow();
 // TRANSLATORS: popup menu item
 // TRANSLATORS: move to player position
 mBrowserBox->addRow("/navigateto 'NAME'", _("Move"));
 addPlayerMisc();
 addBuySell(being);
 mBrowserBox->addSeparator("##3---");
 addParty(wTab->getNick());
 const Guild *const guild1 = being->getGuild();
 const Guild *const guild2 = localPlayer->getGuild();
 if (guild2 != nullptr)
 {
 if (guild1 != nullptr)
 {
 if (guild1->getId() == guild2->getId())
 {
#ifdef TMWA_SUPPORT
 if (guild2->getServerGuild() ||
 (guildManager != nullptr &&
 guildManager->havePower()))
#endif // TMWA_SUPPORT
 {
 mBrowserBox->addRow("/kickguild 'NAME'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: kick player from guild
 _("Kick from guild"));
 }
 if (guild2->getServerGuild())
 {
 mBrowserBox->addRow(strprintf("@@guild-pos|%s >@@",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: change player position in guild
 _("Change pos in guild")),
 false);
 }
 }
 }
 else
 {
#ifdef TMWA_SUPPORT
 if (guild2->getServerGuild() || (guildManager != nullptr
 && guildManager->havePower()))
#endif // TMWA_SUPPORT
 {
 mBrowserBox->addRow("/guild 'NAME'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: invite player to guild
 _("Invite to guild"));
 }
 }
 }
 }
 else
 {
 mBeingId = BeingId_zero;
 mName = name;
 mExtName = name;
 mType = ActorType::Player;
 mSubType = BeingTypeId_zero;
 addPlayerRelation(name);
 mBrowserBox->addSeparator("##3---");
 addMailCommands();
 addFollow();
 
 if (localPlayer->isInParty())
 {
 const Party *const party = localPlayer->getParty();
 if (party != nullptr)
 {
 const PartyMember *const m = party->getMember(mName);
 if (m != nullptr)
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: move to player location
 mBrowserBox->addRow("/navigateto 'NAME'", _("Move"));
 }
 }
 }
 addPlayerMisc();
 addBuySellDefault();
 if (Net::getNetworkType() != ServerType::TMWATHENA)
 addParty(wTab->getNick());
 mBrowserBox->addSeparator("##3---");
 }
 }
 
 addWindowMenu(chatWindow);
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(x, y);
}
 
void PopupMenu::showChangePos(const int x, const int y)
{
 initPopup();
 mBrowserBox->clearRows();
 // TRANSLATORS: popup menu header
 mBrowserBox->addRow(_("Change guild position"), false);
 
 if (localPlayer == nullptr)
 return;
 
 mX = x;
 mY = y;
 const Guild *const guild = localPlayer->getGuild();
 if (guild != nullptr)
 {
 const PositionsMap &map = guild->getPositions();
 FOR_EACH (PositionsMap::const_iterator, itr, map)
 {
 mBrowserBox->addRow(strprintf("@@guild-pos-%u|%[email protected]@",
 itr->first, itr->second.c_str()),
 false);
 }
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(x, y);
 }
 else
 {
 mBeingId = BeingId_zero;
 mFloorItemId = BeingId_zero;
 mItemIndex = -1;
 mItemId = 0;
 for (int f = 0; f < maxCards; f ++)
 mItemCards[f] = 0;
 mMapItem = nullptr;
 mName.clear();
 mExtName.clear();
 mType = ActorType::Unknown;
 mSubType = BeingTypeId_zero;
 mX = 0;
 mY = 0;
 setVisible(Visible_false);
 }
}
 
void PopupMenu::showWindowPopup(Window *const window)
{
 if (window == nullptr)
 return;
 
 initPopup();
 setMousePos();
 mCallerWindow = window;
 mBrowserBox->clearRows();
 // TRANSLATORS: popup menu header
 mBrowserBox->addRow(_("window"), false);
 
 addWindowMenu(window);
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(mX, mY);
}
 
void PopupMenu::addWindowMenu(const Window *const window)
{
 if (window == nullptr)
 return;
 
 initPopup();
 if (window->getAlowClose())
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close window
 mBrowserBox->addRow("window close", _("Close"));
 }
 
 if (window->isStickyButtonLock())
 {
 if (window->isSticky())
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: unlock window
 mBrowserBox->addRow("window unlock", _("Unlock"));
 }
 else
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: lock window
 mBrowserBox->addRow("window lock", _("Lock"));
 }
 }
}
 
void PopupMenu::showEmoteType()
{
 initPopup();
 setMousePos();
 
 mBrowserBox->clearRows();
 // TRANSLATORS: popup menu header
 mBrowserBox->addRow(_("Show emotes for:"), false);
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: show emotes for player
 mBrowserBox->addRow("/setemotetype player", _("Player"));
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: show emotes for pet
 mBrowserBox->addRow("/setemotetype pet", _("Pet"));
 
 if (Net::getNetworkType() == ServerType::EVOL2)
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: show emotes for homuncules
 mBrowserBox->addRow("/setemotetype homun", _("Homunculus"));
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: show emotes for mercenary
 mBrowserBox->addRow("/setemotetype merc", _("Mercenary"));
 }
 mBrowserBox->addSeparator("##3---");
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(mX, mY);
}
 
void PopupMenu::handleLink(const std::string &link,
 MouseEvent *event A_UNUSED)
{
 Being *being = nullptr;
 if (actorManager != nullptr)
 being = actorManager->findBeing(mBeingId);
 
 mAllowCleanMenu = true;
 
 if (link == "remove map" && (mMapItem != nullptr))
 {
 if (viewport != nullptr)
 {
 const Map *const map = viewport->getMap();
 if (map != nullptr)
 {
 SpecialLayer *const specialLayer = map->getSpecialLayer();
 if (specialLayer != nullptr)
 {
 const bool isHome = (mMapItem->getType()
 == CAST_S32(MapItemType::HOME));
 const int x = static_cast<int>(mMapItem->getX());
 const int y = static_cast<int>(mMapItem->getY());
 specialLayer->setTile(x, y,
 CAST_S32(MapItemType::EMPTY));
 specialLayer->updateCache();
 if (socialWindow != nullptr)
 socialWindow->removePortal(x, y);
 if (isHome && (localPlayer != nullptr))
 {
 localPlayer->removeHome();
 localPlayer->saveHomes();
 }
 }
 }
 }
 }
 else if (link == "rename map" && (mMapItem != nullptr))
 {
 mRenameListener.setMapItem(mMapItem);
 CREATEWIDGETV(mDialog, TextDialog,
 // TRANSLATORS: dialog caption
 // TRANSLATORS: number of chars in string should be near original
 _("Rename map sign "),
 // TRANSLATORS: label
 // TRANSLATORS: number of chars in string should be near original
 _("Name: "),
 nullptr,
 false);
 mRenameListener.setDialog(mDialog);
 mDialog->setText(mMapItem->getComment());
 mDialog->setActionEventId("ok");
 mDialog->addActionListener(&mRenameListener);
 }
 else if (link == "edit spell" && (mSpell != nullptr))
 {
 CREATEWIDGET(TextCommandEditor, mSpell);
 }
 else if (link == "addcomment" && !mName.empty())
 {
 TextDialog *const dialog = CREATEWIDGETR(TextDialog,
 // TRANSLATORS: dialog caption
 // TRANSLATORS: number of chars in string should be near original
 _("Player comment "),
 // TRANSLATORS: label
 // TRANSLATORS: number of chars in string should be near original
 _("Comment: "),
 nullptr,
 false);
 mPlayerListener.setDialog(dialog);
 mPlayerListener.setNick(mName);
 mPlayerListener.setType(mType);
 
 if (being != nullptr)
 {
 being->updateComment();
 dialog->setText(being->getComment());
 }
 else
 {
 dialog->setText(Being::loadComment(mName,
 static_cast<ActorTypeT>(mType)));
 }
 dialog->setActionEventId("ok");
 dialog->addActionListener(&mPlayerListener);
 }
 else if (link == "guild-pos" && !mName.empty())
 {
 showChangePos(getX(), getY());
 return;
 }
 else if (link == "clipboard copy")
 {
 if (mTextField != nullptr)
 mTextField->handleCopy();
 }
 else if (link == "clipboard paste")
 {
 if (mTextField != nullptr)
 mTextField->handlePaste();
 }
 else if (link == "gm" && !mName.empty())
 {
 showGMPopup(mName);
 return;
 }
 else if (link == "mute" && !mName.empty())
 {
 showMuteCommands();
 return;
 }
 else if (link == "show" && !mName.empty())
 {
 showPlayerMenu();
 return;
 }
 else if (link == "window close" && (mCallerWindow != nullptr))
 {
 if (Widget::widgetExists(mCallerWindow))
 mCallerWindow->close();
 }
 else if (link == "window unlock" && (mCallerWindow != nullptr))
 {
 if (Widget::widgetExists(mCallerWindow))
 mCallerWindow->setSticky(false);
 }
 else if (link == "window lock" && (mCallerWindow != nullptr))
 {
 if (Widget::widgetExists(mCallerWindow))
 mCallerWindow->setSticky(true);
 }
 else if (link == "join chat" && (being != nullptr))
 {
 const ChatObject *const chat = being->getChat();
 if (chat != nullptr)
 chatHandler->joinChat(chat, "");
 }
 else if (link == "craftmenu")
 {
 showCraftPopup();
 return;
 }
 else if (link.compare(0, 10, "guild-pos-") == 0)
 {
 if (localPlayer != nullptr)
 {
 const Guild *const guild = localPlayer->getGuild();
 if (guild != nullptr)
 {
 const int num = atoi(link.substr(10).c_str());
 guildHandler->changeMemberPostion(
 guild->getMember(mName), num);
 }
 }
 }
 else if (link.compare(0, 7, "player_") == 0)
 {
 if (actorManager != nullptr)
 {
 mBeingId = fromInt(atoi(link.substr(7).c_str()), BeingId);
 being = actorManager->findBeing(mBeingId);
 if (being != nullptr)
 {
 showPopup(getX(), getY(), being);
 return;
 }
 }
 }
 else if (link.compare(0, 10, "flooritem_") == 0)
 {
 if (actorManager != nullptr)
 {
 const BeingId id = fromInt(atoi(
 link.substr(10).c_str()), BeingId);
 if (id != BeingId_zero)
 {
 const FloorItem *const item = actorManager->findItem(id);
 if (item != nullptr)
 {
 mFloorItemId = item->getId();
 mItemId = item->getItemId();
 for (int f = 0; f < maxCards; f ++)
 mItemCards[f] = item->getCard(f);
 showPopup(getX(), getY(), item);
 return;
 }
 }
 }
 }
 else if (link.compare(0, 12, "hide button_") == 0)
 {
 if (windowMenu != nullptr)
 windowMenu->showButton(link.substr(12), Visible_false);
 }
 else if (link.compare(0, 12, "show button_") == 0)
 {
 if (windowMenu != nullptr)
 windowMenu->showButton(link.substr(12), Visible_true);
 }
 else if (link.compare(0, 9, "hide bar_") == 0)
 {
 if (miniStatusWindow != nullptr)
 miniStatusWindow->showBar(link.substr(9), Visible_false);
 }
 else if (link.compare(0, 9, "show bar_") == 0)
 {
 if (miniStatusWindow != nullptr)
  miniStatusWindow->showBar(link.substr(9), Visible_true);
 }
 else if (link.compare(0, 12, "show window_") == 0)
 {
 const int id = atoi(link.substr(12).c_str());
 if (id >= 0)
 inputManager.executeAction(static_cast<InputActionT>(id));
 }
 else if (link.compare(0, 6, "mute_+") == 0)
 {
 if (being != nullptr)
 {
 const int time = atoi(link.substr(6).c_str());
 adminHandler->mute(being, 1, time);
 }
 }
 else if (link.compare(0, 6, "mute_-") == 0)
 {
 if (being != nullptr)
 {
 const int time = atoi(link.substr(6).c_str());
 adminHandler->mute(being, 0, time);
 }
 }
 else if (!link.empty() && link[0] == '/')
 {
 std::string cmd = link.substr(1);
 replaceAll(cmd, "'NAME'", mName);
 replaceAll(cmd, "'ENAME'", escapeString(mName));
 replaceAll(cmd, "'EXTNAME'", mExtName);
 replaceAll(cmd, "'EEXTNAME'", escapeString(mExtName));
 replaceAll(cmd, "'X'", toString(mX));
 replaceAll(cmd, "'Y'", toString(mY));
 replaceAll(cmd, "'BEINGID'", toString(toInt(mBeingId, int)));
 replaceAll(cmd, "'FLOORID'", toString(toInt(mFloorItemId, int)));
 replaceAll(cmd, "'ITEMID'", toString(mItemId));
 replaceAll(cmd, "'ITEMCOLOR'", toString(toInt(mItemColor, int)));
 replaceAll(cmd, "'BEINGTYPEID'", toString(CAST_S32(mType)));
 replaceAll(cmd, "'BEINGSUBTYPEID'", toString(CAST_S32(mSubType)));
 replaceAll(cmd, "'PLAYER'", localPlayer->getName());
 replaceAll(cmd, "'EPLAYER'", escapeString(localPlayer->getName()));
 replaceAll(cmd, "'PLAYERX'", toString(localPlayer->getTileX()));
 replaceAll(cmd, "'PLAYERY'", toString(localPlayer->getTileY()));
 if (mItemIndex >= 0)
 replaceAll(cmd, "'INVINDEX'", toString(mItemIndex));
 else
 replaceAll(cmd, "'INVINDEX'", "0");
 if (mMapItem != nullptr)
 {
 replaceAll(cmd, "'MAPX'", toString(mMapItem->getX()));
 replaceAll(cmd, "'MAPY'", toString(mMapItem->getY()));
 }
 else
 {
 replaceAll(cmd, "'MAPX'", toString(mX));
 replaceAll(cmd, "'MAPY'", toString(mY));
 }
 
 std::string cards;
 for (int f = 0; f < maxCards; f ++)
 {
 const int id = mItemCards[f];
 if (id != 0)
 {
 cards.append(",");
 cards.append(toString(id));
 }
 }
 replaceAll(cmd, "'CARDS'", cards);
 replaceAll(cmd, "'ECARDS'", escapeString(cards));
 if (actorManager != nullptr)
 {
 if (being == nullptr)
 {
 being = actorManager->findBeingByName(mName,
 ActorType::Player);
 }
 }
 if (being != nullptr)
 replaceAll(cmd, "'PARTY'", being->getPartyName());
 else
 replaceAll(cmd, "'PARTY'", "");
 
 const size_t pos = cmd.find(' ');
 const std::string type(cmd, 0, pos);
 std::string args(cmd, pos == std::string::npos ? cmd.size() : pos + 1);
 args = trim(args);
 inputManager.executeChatCommand(type, args, mTab);
 }
 // Unknown actions
 else if (link != "cancel")
 {
 reportAlways("PopupMenu: Warning, unknown action '%s'", link.c_str())
 }
 
 if (!mAllowCleanMenu)
 return;
 
 setVisible(Visible_false);
 
 mBeingId = BeingId_zero;
 mFloorItemId = BeingId_zero;
 mItemId = 0;
 mItemIndex = -1;
 for (int f = 0; f < maxCards; f ++)
 mItemCards[f] = 0;
 mItemColor = ItemColor_one;
 mMapItem = nullptr;
 mTab = nullptr;
 mSpell = nullptr;
 mCallerWindow = nullptr;
 mDialog = nullptr;
 mButton = nullptr;
 mName.clear();
 mExtName.clear();
 mTextField = nullptr;
 mType = ActorType::Unknown;
 mSubType = BeingTypeId_zero;
 mX = 0;
 mY = 0;
}
 
void PopupMenu::showPopup(Window *const parent,
 const int x, const int y,
 const Item *const item,
 const InventoryTypeT type)
{
 if (item == nullptr)
 return;
 
 initPopup();
 mItemId = item->getId();
 mItemIndex = item->getInvIndex();
 for (int f = 0; f < maxCards; f ++)
 mItemCards[f] = item->getCard(f);
 mItemColor = item->getColor();
 mCallerWindow = parent;
 mX = x;
 mY = y;
 mName.clear();
 mExtName.clear();
 mBrowserBox->clearRows();
 
 const int cnt = item->getQuantity();
 const bool isProtected = PlayerInfo::isItemProtected(mItemId);
 
 switch (type)
 {
 case InventoryType::Inventory:
 if (tradeWindow != nullptr &&
 tradeWindow->isWindowVisible() &&
 !isProtected)
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add item to trade
 mBrowserBox->addRow("/addtrade 'INVINDEX'", _("Add to trade"));
 if (cnt > 1)
 {
 if (cnt > 10)
 {
 mBrowserBox->addRow("/addtrade 'INVINDEX' 10",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add 10 item amount to trade
 _("Add to trade 10"));
 }
 mBrowserBox->addRow("/addtrade 'INVINDEX' /",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add half item amount to trade
 _("Add to trade half"));
 mBrowserBox->addRow("/addtrade 'INVINDEX' -1",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add all amount except one item to trade
 _("Add to trade all-1"));
 mBrowserBox->addRow("/addtrade 'INVINDEX' all",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add all amount item to trade
 _("Add to trade all"));
 }
 mBrowserBox->addSeparator("##3---");
 }
 if (InventoryWindow::isStorageActive())
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add item to storage
 mBrowserBox->addRow("/invtostorage 'INVINDEX'", _("Store"));
 if (cnt > 1)
 {
 if (cnt > 10)
 {
 mBrowserBox->addRow("/invtostorage 'INVINDEX' 10",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add 10 item amount to storage
 _("Store 10"));
 }
 mBrowserBox->addRow("/invtostorage 'INVINDEX' /",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add half item amount to storage
 _("Store half"));
 mBrowserBox->addRow("/invtostorage 'INVINDEX' -1",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add all except one item to storage
 _("Store all-1"));
 mBrowserBox->addRow("/invtostorage 'INVINDEX' all",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add all item amount to storage
 _("Store all"));
 }
 mBrowserBox->addSeparator("##3---");
 }
 if (npcHandler != nullptr)
 {
 NpcDialog *const dialog = npcHandler->getCurrentNpcDialog();
 if ((dialog != nullptr) &&
 dialog->getInputState() == NpcInputState::ITEM_CRAFT)
 {
 mBrowserBox->addRow("craftmenu",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: sub menu for craft
 _("Move to craft..."));
 }
 }
 addItemMenu(item, InventoryType::Inventory);
 addDrop(item, isProtected);
 break;
 
 case InventoryType::Storage:
 // TRANSLATORS: popup menu item
 // TRANSLATORS: get item from storage
 mBrowserBox->addRow("/storagetoinv 'INVINDEX'", _("Retrieve"));
 if (cnt > 1)
 {
 if (cnt > 10)
 {
 mBrowserBox->addRow("/storagetoinv 'INVINDEX' 10",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: get 10 item amount from storage
 _("Retrieve 10"));
 }
 mBrowserBox->addRow("/storagetoinv 'INVINDEX' /",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: get half item amount from storage
 _("Retrieve half"));
 mBrowserBox->addRow("/storagetoinv 'INVINDEX' -1",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: get all except one item amount from storage
 _("Retrieve all-1"));
 mBrowserBox->addRow("/storagetoinv 'INVINDEX' all",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: get all item amount from storage
 _("Retrieve all"));
 mBrowserBox->addSeparator("##3---");
 }
 addItemMenu(item, InventoryType::Storage);
 break;
 case InventoryType::Cart:
 addItemMenu(item, InventoryType::Cart);
 break;
 
 case InventoryType::Trade:
 case InventoryType::Npc:
 case InventoryType::Vending:
 case InventoryType::MailEdit:
 case InventoryType::MailView:
 case InventoryType::Craft:
 case InventoryType::TypeEnd:
 default:
 break;
 }
 
 
 addProtection();
 if (config.getBoolValue("enablePickupFilter"))
 {
 mName = item->getName();
 mExtName = mName;
 mBrowserBox->addSeparator("##3---");
 addPickupFilter(mName);
 }
 addGmCommands();
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add item name to chat
 mBrowserBox->addRow("/addchat 'ITEMID''CARDS'", _("Add to chat"));
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(x, y);
}
 
void PopupMenu::showItemPopup(const int x, const int y,
 const int itemId,
 const ItemColor color)
{
 const Inventory *const inv = PlayerInfo::getInventory();
 if (inv == nullptr)
 return;
 
 Item *const item = inv->findItem(itemId, color);
 if (item != nullptr)
 {
 showItemPopup(x, y, item);
 }
 else
 {
 initPopup();
 mItemId = itemId;
 mItemIndex = -1;
 mItemColor = color;
 for (int f = 0; f < maxCards; f ++)
 mItemCards[f] = 0;
 mX = x;
 mY = y;
 mBrowserBox->clearRows();
 
 if (!PlayerInfo::isItemProtected(mItemId))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: use item
 mBrowserBox->addRow("/use 'ITEMID'", _("Use"));
 }
 addProtection();
 addGmCommands();
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(x, y);
 }
}
 
void PopupMenu::showItemPopup(const int x, const int y,
 const Item *const item)
{
 initPopup();
 mX = x;
 mY = y;
 if (item != nullptr)
 {
 mItemId = item->getId();
 mItemColor = item->getColor();
 mItemIndex = item->getInvIndex();
 for (int f = 0; f < maxCards; f ++)
 mItemCards[f] = item->getCard(f);
 }
 else
 {
 mItemId = 0;
 mItemColor = ItemColor_one;
 mItemIndex = -1;
 for (int f = 0; f < maxCards; f ++)
 mItemCards[f] = 0;
 }
 mName.clear();
 mExtName.clear();
 mBrowserBox->clearRows();
 
 if (item != nullptr)
 {
 const bool isProtected = PlayerInfo::isItemProtected(mItemId);
 addUse(item);
 addDrop(item, isProtected);
 if (InventoryWindow::isStorageActive())
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add item to storage
 mBrowserBox->addRow("/invtostorage 'INVINDEX'", _("Store"));
 }
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add item name to chat
 mBrowserBox->addRow("/addchat 'ITEMID''CARDS'", _("Add to chat"));
 
 if (config.getBoolValue("enablePickupFilter"))
 {
 mName = item->getName();
 mExtName = mName;
 mBrowserBox->addSeparator("##3---");
 addPickupFilter(mName);
 }
 }
 addProtection();
 addGmCommands();
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(x, y);
}
 
void PopupMenu::showDropPopup(const int x,
 const int y,
 const Item *const item)
{
 initPopup();
 mX = x;
 mY = y;
 mName.clear();
 mExtName.clear();
 mBrowserBox->clearRows();
 
 if (item != nullptr)
 {
 mItemId = item->getId();
 mItemColor = item->getColor();
 mItemIndex = item->getInvIndex();
 for (int f = 0; f < maxCards; f ++)
 mItemCards[f] = item->getCard(f);
 const bool isProtected = PlayerInfo::isItemProtected(mItemId);
 addUse(item);
 addDrop(item, isProtected);
 if (InventoryWindow::isStorageActive())
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add item to storage
 mBrowserBox->addRow("/invtostorage 'INVINDEX'", _("Store"));
 }
 addProtection();
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add item name to chat
 mBrowserBox->addRow("/addchat 'ITEMID''CARDS'", _("Add to chat"));
 if (config.getBoolValue("enablePickupFilter"))
 {
 mName = item->getName();
 mExtName = mName;
 mBrowserBox->addSeparator("##3---");
 addPickupFilter(mName);
 }
 }
 addGmCommands();
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 mBrowserBox->addRow("/cleardrops", _("Clear drop window"));
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(x, y);
}
 
void PopupMenu::showPopup(const int x, const int y, Button *const button)
{
 if ((button == nullptr) || (windowMenu == nullptr))
 return;
 
 initPopup();
 mButton = button;
 mX = x;
 mY = y;
 
 mBrowserBox->clearRows();
 STD_VECTOR<Button *> names = windowMenu->getButtons();
 for (STD_VECTOR<Button *>::const_iterator it = names.begin(),
 it_end = names.end(); it != it_end; ++ it)
 {
 const Button *const btn = *it;
 if ((btn == nullptr) || btn->getActionEventId() == "SET")
 continue;
 
 if (btn->mVisible == Visible_true)
 {
 mBrowserBox->addRow(strprintf("@@hide button_%s|%s %s (%s)@@",
 // TRANSLATORS: popup menu item
 btn->getActionEventId().c_str(), _("Hide"),
 btn->getDescription().c_str(), btn->getCaption().c_str()),
 false);
 }
 else
 {
 mBrowserBox->addRow(strprintf("@@show button_%s|%s %s (%s)@@",
 // TRANSLATORS: popup menu item
 btn->getActionEventId().c_str(), _("Show"),
 btn->getDescription().c_str(), btn->getCaption().c_str()),
 false);
 }
 }
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(x, y);
}
 
void PopupMenu::showPopup(const int x, const int y, const ProgressBar *const b)
{
 if ((b == nullptr) || (miniStatusWindow == nullptr))
 return;
 
 initPopup();
 mName = b->text();
 mExtName = mName;
 mX = x;
 mY = y;
 
 mBrowserBox->clearRows();
 STD_VECTOR <ProgressBar*> bars = miniStatusWindow->getBars();
 ProgressBar *onlyBar = nullptr;
 int cnt = 0;
 
 // search for alone visible bar
 for (STD_VECTOR <ProgressBar*>::const_iterator it = bars.begin(),
 it_end = bars.end(); it != it_end; ++it)
 {
 ProgressBar *const bar = *it;
 if (bar == nullptr)
 continue;
 
 if (bar->mVisible == Visible_true)
 {
 cnt ++;
 onlyBar = bar;
 }
 }
 if (cnt > 1)
 onlyBar = nullptr;
 
 for (STD_VECTOR <ProgressBar*>::const_iterator it = bars.begin(),
 it_end = bars.end(); it != it_end; ++it)
 {
 ProgressBar *const bar = *it;
 if ((bar == nullptr) || bar == onlyBar)
 continue;
 
 if (bar->mVisible == Visible_true)
 {
 mBrowserBox->addRow(strprintf("@@hide bar_%s|%s %[email protected]@",
 // TRANSLATORS: popup menu item
 bar->getActionEventId().c_str(), _("Hide"),
 bar->getId().c_str()),
 false);
 }
 else
 {
 mBrowserBox->addRow(strprintf("@@show bar_%s|%s %[email protected]@",
 // TRANSLATORS: popup menu item
 bar->getActionEventId().c_str(), _("Show"),
 bar->getId().c_str()),
 false);
 }
 }
 
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 mBrowserBox->addRow("/yellowbar", _("Open yellow bar settings"));
 // TRANSLATORS: popup menu item
 mBrowserBox->addRow("/resetmodifiers", _("Reset yellow bar"));
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: copy status to chat
 mBrowserBox->addRow("/bartochat 'NAME'", _("Copy to chat"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(x, y);
}
 
void PopupMenu::showAttackMonsterPopup(const int x, const int y,
 const std::string &name,
 const int type)
{
 if ((localPlayer == nullptr) || (actorManager == nullptr))
 return;
 
 initPopup();
 mName = name;
 mExtName = name;
 mType = ActorType::Monster;
 mSubType = BeingTypeId_zero;
 mX = x;
 mY = y;
 
 mBrowserBox->clearRows();
 
 if (name.empty())
 {
 // TRANSLATORS: popup menu header
 mBrowserBox->addRow(_("(default)"), false);
 }
 else
 {
 mBrowserBox->addRow(name, false);
 }
 switch (type)
 {
 case MapItemType::ATTACK:
 {
 const int idx = actorManager->getAttackMobIndex(name);
 const int size = actorManager->getAttackMobsSize();
 if (idx > 0)
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: move attack target up
 mBrowserBox->addRow("/moveattackup 'NAME'", _("Move up"));
 }
 if (idx + 1 < size)
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: move attack target down
 mBrowserBox->addRow("/moveattackdown 'NAME'", _("Move down"));
 }
 break;
 }
 case MapItemType::PRIORITY:
 {
 const int idx = actorManager->
 getPriorityAttackMobIndex(name);
 const int size = actorManager->getPriorityAttackMobsSize();
 if (idx > 0)
 {
 mBrowserBox->addRow("/movepriorityattackup 'NAME'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: move attack target up
 _("Move up"));
 }
 if (idx + 1 < size)
 {
 mBrowserBox->addRow("/movepriorityattackdown 'NAME'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: move attack target down
 _("Move down"));
 }
 break;
 }
 case MapItemType::IGNORE_:
 default:
 break;
 }
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: remove attack target
 mBrowserBox->addRow("/removeattack 'NAME'", _("Remove"));
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(x, y);
}
 
void PopupMenu::showPickupItemPopup(const int x, const int y,
 const std::string &name)
{
 if ((localPlayer == nullptr) || (actorManager == nullptr))
 return;
 
 initPopup();
 mName = name;
 mExtName = name;
 mType = ActorType::FloorItem;
 mSubType = BeingTypeId_zero;
 mX = x;
 mY = y;
 
 mBrowserBox->clearRows();
 
 if (name.empty())
 {
 // TRANSLATORS: popup menu header
 mBrowserBox->addRow(_("(default)"), false);
 }
 else
 {
 mBrowserBox->addRow(name, false);
 }
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: remove item from pickup filter
 mBrowserBox->addRow("/removepickup 'NAME'", _("Remove"));
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(x, y);
}
 
void PopupMenu::showUndressPopup(const int x, const int y,
 const Being *const being,
 const Item *const item)
{
 if ((being == nullptr) || (item == nullptr))
 return;
 
 initPopup();
 mBeingId = being->getId();
 mItemId = item->getId();
 mItemColor = item->getColor();
 mItemIndex = item->getInvIndex();
 for (int f = 0; f < maxCards; f ++)
 mItemCards[f] = item->getCard(f);
 mX = x;
 mY = y;
 
 mBrowserBox->clearRows();
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: undress item from player
 mBrowserBox->addRow("/undress :'BEINGID' 'ITEMID'", _("Undress"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add item name to chat
 mBrowserBox->addRow("/addchat 'ITEMID''CARDS'", _("Add to chat"));
 addGmCommands();
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(x, y);
}
 
void PopupMenu::showTextFieldPopup(TextField *const input)
{
 initPopup();
 setMousePos();
 mTextField = input;
 
 mBrowserBox->clearRows();
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: copy text to clipboard
 mBrowserBox->addRow("clipboard copy", _("Copy"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: paste text from clipboard
 mBrowserBox->addRow("clipboard paste", _("Paste"));
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(mX, mY);
}
 
void PopupMenu::showLinkPopup(const std::string &link)
{
 initPopup();
 setMousePos();
 mName = link;
 mExtName = link;
 
 mBrowserBox->clearRows();
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: open link in browser
 mBrowserBox->addRow("/open 'NAME'", _("Open link"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: copy link to clipboard
 mBrowserBox->addRow("/clipboardcopy 'NAME'", _("Copy to clipboard"));
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(mX, mY);
}
 
void PopupMenu::showWindowsPopup()
{
 initPopup();
 setMousePos();
 mBrowserBox->clearRows();
 const STD_VECTOR<ButtonText*> &names = windowMenu->getButtonTexts();
 // TRANSLATORS: popup menu header
 mBrowserBox->addRow(_("Show window"), false);
 
 FOR_EACH (STD_VECTOR<ButtonText*>::const_iterator, it, names)
 {
 const ButtonText *const btn = *it;
 if (btn == nullptr)
 continue;
 
 mBrowserBox->addRow(strprintf("show window_%d",
 CAST_S32(btn->key)),
 btn->text.c_str());
 }
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(mX, mY);
}
 
void PopupMenu::showNpcDialogPopup(const BeingId npcId,
 const int x, const int y)
{
 initPopup();
 mBeingId = npcId;
 mX = x;
 mY = y;
 mBrowserBox->clearRows();
 // TRANSLATORS: popup menu item
 // TRANSLATORS: copy npc text to clipboard
 mBrowserBox->addRow("/npcclipboard 'X' 'Y'", _("Copy to clipboard"));
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(x, y);
}
 
void PopupMenu::showSkillPopup(const SkillInfo *const info)
{
 if (info == nullptr)
 return;
 
 initPopup();
 setMousePos();
 
 // using mItemId as skill id
 mItemId = info->id;
 // using mItemIndex as skill level
 mItemIndex = info->level;
 mBrowserBox->clearRows();
 
 // TRANSLATORS: popup menu header
 mBrowserBox->addRow(_("Skill"), false);
 mBrowserBox->addRow("/addskillshortcut 'ITEMID'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add skill to shortcurs tab
 _("Add skill shortcut"));
 mBrowserBox->addSeparator("##3---");
 mBrowserBox->addRow("/showskilllevels 'ITEMID'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: set skill level
 _("Skill level..."));
 mBrowserBox->addRow("/showskilltypes 'ITEMID'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: set skill cast type
 _("Skill cast type..."));
 mBrowserBox->addRow("/showskilloffsetx 'ITEMID'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: set skill cast offset by x
 _("Skill offset by x..."));
 mBrowserBox->addRow("/showskilloffsety 'ITEMID'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: set skill cast offset by y
 _("Skill offset by y..."));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(mX, mY);
}
 
void PopupMenu::showSkillOffsetPopup(const SkillInfo *const info,
 const bool isOffsetX)
{
 if (info == nullptr)
 return;
 
 initPopup();
 setMousePos2();
 
 // using mItemId as skill id
 mItemId = info->id;
 // using mItemIndex as skill level
 mItemIndex = info->level;
 mBrowserBox->clearRows();
 char letter = ' ';
 
 if (isOffsetX)
 {
 // TRANSLATORS: popup menu header
 mBrowserBox->addRow(_("Skill cast offset by x"), false);
 letter = 'x';
 }
 else
 {
 // TRANSLATORS: popup menu header
 mBrowserBox->addRow(_("Skill cast offset by y"), false);
 letter = 'y';
 }
 for (int f = -9; f <= 9; f ++)
 {
 const std::string command = strprintf(
 "/setskilloffset%c 'ITEMID' %d", letter, f);
 if (f == 0)
 {
 mBrowserBox->addRow(command,
 strprintf("%d", f).c_str());
 }
 else
 {
 mBrowserBox->addRow(command,
 strprintf("%+d", f).c_str());
 }
 }
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 showPopup(mX, mY);
}
 
void PopupMenu::showSkillLevelPopup(const SkillInfo *const info)
{
 if (info == nullptr)
 return;
 
 initPopup();
 setMousePos2();
 
 // using mItemId as skill id
 mItemId = info->id;
 // using mItemIndex as skill level
 mItemIndex = info->level;
 
 for (int f = 0; f < maxCards; f ++)
 mItemCards[f] = 0;
 mBrowserBox->clearRows();
 // TRANSLATORS: popup menu item
 // TRANSLATORS: skill level header
 mBrowserBox->addRow(_("Select skill level"), false);
 for (int f = 1; f <= mItemIndex; f ++)
 {
 mBrowserBox->addRow(strprintf("/selectskilllevel %d %d", mItemId, f),
 // TRANSLATORS: popup menu item
 // TRANSLATORS: skill level
 strprintf(_("Level: %d"), f).c_str());
 }
 mBrowserBox->addRow(strprintf("/selectskilllevel %d 0", mItemId),
 // TRANSLATORS: popup menu item
 // TRANSLATORS: skill level
 _("Max level"));
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(mX, mY);
}
 
void PopupMenu::showSkillTypePopup(const SkillInfo *const info)
{
 if (info == nullptr)
 return;
 
 initPopup();
 setMousePos2();
 
 // using mItemId as skill id
 mItemId = info->id;
 // using mItemIndex as skill level
 mItemIndex = info->level;
 
 for (int f = 0; f < maxCards; f ++)
 mItemCards[f] = 0;
 mBrowserBox->clearRows();
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: skill cast type header
 mBrowserBox->addRow(_("Select skill cast type"), false);
 mBrowserBox->addRow(strprintf("/selectskilltype %d 0", mItemId),
 // TRANSLATORS: popup menu item
 // TRANSLATORS: skill cast type
 _("Default"));
 mBrowserBox->addRow(strprintf("/selectskilltype %d 1", mItemId),
 // TRANSLATORS: popup menu item
 // TRANSLATORS: skill cast type
 _("Target"));
 mBrowserBox->addRow(strprintf("/selectskilltype %d 2", mItemId),
 // TRANSLATORS: popup menu item
 // TRANSLATORS: skill cast type
 _("Mouse position"));
 mBrowserBox->addRow(strprintf("/selectskilltype %d 3", mItemId),
 // TRANSLATORS: popup menu item
 // TRANSLATORS: skill cast type
 _("Self"));
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(mX, mY);
}
 
void PopupMenu::showPopup(int x, int y)
{
 PopupManager::hideItemPopup();
 const int pad2 = 2 * mPadding;
 mBrowserBox->setPosition(mPadding, mPadding);
 mScrollArea->setPosition(mPadding, mPadding);
 mBrowserBox->updateHeight();
 // add padding to initial size before draw browserbox
 int height = mBrowserBox->getHeight();
 if (height + pad2 >= mainGraphics->getHeight())
 {
 height = mainGraphics->getHeight() - pad2;
 mBrowserBox->setWidth(mBrowserBox->getWidth() + 5);
 mScrollArea->setWidth(mBrowserBox->getWidth() + pad2 + 10);
 setContentSize(mBrowserBox->getWidth() + pad2 + 20,
 height + pad2);
 }
 else
 {
 mBrowserBox->setWidth(mBrowserBox->getWidth());
 mScrollArea->setWidth(mBrowserBox->getWidth() + pad2);
 setContentSize(mBrowserBox->getWidth() + pad2,
 height + pad2);
 }
 if (mainGraphics->mWidth < (x + getWidth() + 5))
 x = mainGraphics->mWidth - getWidth();
 if (mainGraphics->mHeight < (y + getHeight() + 5))
 y = mainGraphics->mHeight - getHeight();
 mScrollArea->setHeight(height);
 setPosition(x, y);
 setVisible(Visible_true);
 requestMoveToTop();
 mAllowCleanMenu = false;
}
 
void PopupMenu::addNormalRelations()
{
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player to disregarded list
 mBrowserBox->addRow("/disregard 'NAME'", _("Disregard"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player to ignore list
 mBrowserBox->addRow("/ignore 'NAME'", _("Ignore"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player to black list
 mBrowserBox->addRow("/blacklist 'NAME'", _("Black list"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player to enemy list
 mBrowserBox->addRow("/enemy 'NAME'", _("Set as enemy"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player to erased list
 mBrowserBox->addRow("/erase 'NAME'", _("Erase"));
}
 
void PopupMenu::addPlayerRelation(const std::string &name)
{
 switch (playerRelations.getRelation(name))
 {
 case Relation::NEUTRAL:
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player to friends list
 mBrowserBox->addRow("/friend 'NAME'", _("Be friend"));
 addNormalRelations();
 break;
 
 case Relation::FRIEND:
 addNormalRelations();
 break;
 
 case Relation::BLACKLISTED:
 // TRANSLATORS: popup menu item
 // TRANSLATORS: remove player from ignore list
 mBrowserBox->addRow("/unignore 'NAME'", _("Unignore"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player to disregarded list
 mBrowserBox->addRow("/disregard 'NAME'", _("Disregard"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player to ignore list
 mBrowserBox->addRow("/ignore 'NAME'", _("Ignore"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player to enemy list
 mBrowserBox->addRow("/enemy 'NAME'", _("Set as enemy"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player to erased list
 mBrowserBox->addRow("/erase 'NAME'", _("Erase"));
 break;
 
 case Relation::DISREGARDED:
 // TRANSLATORS: popup menu item
 // TRANSLATORS: remove player from ignore list
 mBrowserBox->addRow("/unignore 'NAME'", _("Unignore"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player to completle ignore list
 mBrowserBox->addRow("/ignore 'NAME'", _("Completely ignore"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player to erased list
 mBrowserBox->addRow("/erase 'NAME'", _("Erase"));
 break;
 
 case Relation::IGNORED:
 // TRANSLATORS: popup menu item
 // TRANSLATORS: remove player from ignore list
 mBrowserBox->addRow("/unignore 'NAME'", _("Unignore"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player to erased list
 mBrowserBox->addRow("/erase 'NAME'", _("Erase"));
 break;
 
 case Relation::ENEMY2:
 // TRANSLATORS: popup menu item
 // TRANSLATORS: remove player from ignore list
 mBrowserBox->addRow("/unignore 'NAME'", _("Unignore"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player to disregarded list
 mBrowserBox->addRow("/disregard 'NAME'", _("Disregard"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player to ignore list
 mBrowserBox->addRow("/ignore 'NAME'", _("Ignore"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player to black list
 mBrowserBox->addRow("/blacklist 'NAME'", _("Black list"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player to erased list
 mBrowserBox->addRow("/erase 'NAME'", _("Erase"));
 break;
 
 case Relation::ERASED:
 // TRANSLATORS: popup menu item
 // TRANSLATORS: remove player from ignore list
 mBrowserBox->addRow("/unignore 'NAME'", _("Unignore"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player to disregarded list
 mBrowserBox->addRow("/disregard 'NAME'", _("Disregard"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add player to ignore list
 mBrowserBox->addRow("/ignore 'NAME'", _("Completely ignore"));
 break;
 
 default:
 break;
 }
}
 
void PopupMenu::addFollow()
{
 if (features.getBoolValue("allowFollow"))
 {
 // TRANSLATORS: popup menu item
 mBrowserBox->addRow("/follow 'NAME'", _("Follow"));
 }
 // TRANSLATORS: popup menu item
 // TRANSLATORS: imitate player
 mBrowserBox->addRow("/imitation 'NAME'", _("Imitate"));
}
 
void PopupMenu::addBuySell(const Being *const being)
{
 if ((playerRelations.getDefault() & PlayerRelation::TRADE) != 0U)
 {
 mBrowserBox->addSeparator("##3---");
 const bool haveVending =
 (Net::getNetworkType() != ServerType::TMWATHENA);
 if (being->isSellShopEnabled())
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: buy item
 mBrowserBox->addRow("/buy 'NAME'", _("Buy"));
 }
 else if (!haveVending)
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: buy item
 mBrowserBox->addRow("/buy 'NAME'", _("Buy (?)"));
 }
 if (being->isBuyShopEnabled())
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: sell item
 mBrowserBox->addRow("/sell 'NAME'", _("Sell"));
 }
 else if (!haveVending)
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: sell item
 mBrowserBox->addRow("/sell 'NAME'", _("Sell (?)"));
 }
 }
}
 
void PopupMenu::addBuySellDefault()
{
 if ((playerRelations.getDefault() & PlayerRelation::TRADE) != 0U)
 {
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: buy item
 mBrowserBox->addRow("/buy 'NAME'", _("Buy (?)"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: sell item
 mBrowserBox->addRow("/sell 'NAME'", _("Sell (?)"));
 }
}
 
void PopupMenu::addPartyName(const std::string &partyName)
{
 if (localPlayer->isInParty())
 {
 if (localPlayer->getParty() != nullptr)
 {
 if (localPlayer->getParty()->getName() != partyName)
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: invite player to party
 mBrowserBox->addRow("/party 'NAME'", _("Invite to party"));
 }
 else
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: kick player from party
 mBrowserBox->addRow("/kickparty 'NAME'", _("Kick from party"));
 showAdoptCommands();
 }
 mBrowserBox->addSeparator("##3---");
 }
 }
}
 
void PopupMenu::addParty(const std::string &nick)
{
 if (localPlayer->isInParty())
 {
 const Party *const party = localPlayer->getParty();
 if (party != nullptr)
 {
 if (!party->isMember(nick))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: invite player to party
 mBrowserBox->addRow("/party 'NAME'", _("Invite to party"));
 }
 else
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: kick player from party
 mBrowserBox->addRow("/kickparty 'NAME'", _("Kick from party"));
 showAdoptCommands();
 }
 mBrowserBox->addSeparator("##3---");
 }
 }
}
 
void PopupMenu::addChat(const Being *const being)
{
 if (being == nullptr)
 return;
 const ChatObject *const chat = being->getChat();
 if (chat != nullptr)
 {
 mBrowserBox->addRow("join chat",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: invite player to party
 strprintf(_("Join chat %s"), chat->title.c_str()).c_str());
 mBrowserBox->addSeparator("##3---");
 }
}
 
void PopupMenu::addPlayerMisc()
{
 // TRANSLATORS: popup menu item
 mBrowserBox->addRow("/showitems :'BEINGID'", _("Show Items"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: undress player
 mBrowserBox->addRow("/undress :'BEINGID'", _("Undress"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add comment to player
 mBrowserBox->addRow("addcomment", _("Add comment"));
}
 
void PopupMenu::addPickupFilter(const std::string &name)
{
 if (actorManager->isInPickupList(name)
 || actorManager->isInIgnorePickupList(name))
 {
 mBrowserBox->addRow("/removepickup 'NAME'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: remove item from pickup list
 _("Remove from pickup list"));
 }
 else
 {
 mBrowserBox->addRow("/addpickup 'NAME'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: popup menu item
 _("Add to pickup list"));
 mBrowserBox->addRow("/ignorepickup 'NAME'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add item to pickup list
 _("Add to ignore list"));
 }
}
 
void PopupMenu::showPopup(const int x, const int y,
 ListModel *const model)
{
 if (model == nullptr)
 return;
 
 mBrowserBox->clearRows();
 for (int f = 0, sz = model->getNumberOfElements(); f < sz; f ++)
 {
 mBrowserBox->addRow(strprintf("dropdown_%d", f),
 model->getElementAt(f).c_str());
 }
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 showPopup(x, y);
}
 
void PopupMenu::clear()
{
 if (mDialog != nullptr)
 {
 mDialog->close();
 mDialog = nullptr;
 }
 mItemIndex = -1;
 mItemId = 0;
 for (int f = 0; f < maxCards; f ++)
 mItemCards[f] = 0;
 mMapItem = nullptr;
 mTab = nullptr;
 mSpell = nullptr;
 mCallerWindow = nullptr;
 mButton = nullptr;
 mTextField = nullptr;
}
 
void PopupMenu::addProtection()
{
 if (PlayerInfo::isItemProtected(mItemId))
 {
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: remove protection from item
 mBrowserBox->addRow("/unprotectitem 'ITEMID'", _("Unprotect item"));
 }
 else
 {
 if (mItemId < SPELL_MIN_ID)
 {
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: add protection to item
 mBrowserBox->addRow("/protectitem 'ITEMID'", _("Protect item"));
 }
 }
}
 
void PopupMenu::addUse(const Item *const item)
{
 const ItemInfo &info = item->getInfo();
 const std::string &str = (item->isEquipment() == Equipm_true
 && item->isEquipped() == Equipped_true)
 ? info.getUseButton2() : info.getUseButton();
 
 if (str.empty())
 {
 // TRANSLATORS: popup menu item
 mBrowserBox->addRow("/useinv 'INVINDEX'", _("Use"));
 }
 else
 {
 // TRANSLATORS: popup menu item
 mBrowserBox->addRow("/useinv 'INVINDEX'", str.c_str());
 }
}
 
void PopupMenu::addItemMenu(const Item *const item,
 const InventoryTypeT type)
{
 const ItemInfo &info = item->getInfo();
 const STD_VECTOR<ItemMenuItem> *menu = nullptr;
 switch (type)
 {
 case InventoryType::Inventory:
 menu = &info.getInventoryMenuConst();
 break;
 case InventoryType::Storage:
 menu = &info.getStorageMenuConst();
 break;
 case InventoryType::Cart:
 menu = &info.getCartMenuConst();
 break;
 case InventoryType::Trade:
 case InventoryType::Npc:
 case InventoryType::Vending:
 case InventoryType::MailEdit:
 case InventoryType::MailView:
 case InventoryType::Craft:
 case InventoryType::TypeEnd:
 default:
 return;
 }
 
 const bool firstMode = (item->isEquipment() == Equipm_true ?
 (item->isEquipped() != Equipped_true) : (item->getQuantity() == 1));
 
 FOR_EACHP (STD_VECTOR<ItemMenuItem>::const_iterator, it, menu)
 {
 const ItemMenuItem &menuItem = *it;
 const std::string &name = firstMode ?
 menuItem.name1 : menuItem.name2;
 const std::string &command = firstMode ?
 menuItem.command1 : menuItem.command2;
 if (command.empty() ||
 name.empty())
 {
 continue;
 }
 mBrowserBox->addRow("/" + command, name.c_str());
 }
 mBrowserBox->addSeparator("##3---");
}
 
void PopupMenu::addDrop(const Item *const item,
 const bool isProtected)
{
 if (!isProtected)
 {
 mBrowserBox->addSeparator("##3---");
 if (item->getQuantity() > 1)
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: drop item
 mBrowserBox->addRow("/dropinv 'INVINDEX'", _("Drop..."));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: drop all item amount
 mBrowserBox->addRow("/dropinvall 'INVINDEX'", _("Drop all"));
 }
 else
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: drop item
 mBrowserBox->addRow("/dropinv 'INVINDEX'", _("Drop"));
 }
 }
}
 
void PopupMenu::addGmCommands()
{
 if (localPlayer->isGM())
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: gm commands
 mBrowserBox->addRow("gm", _("GM..."));
 }
}
 
void PopupMenu::showPlayerMenu()
{
 mBrowserBox->clearRows();
 // TRANSLATORS: popup menu header
 mBrowserBox->addRow(strprintf(_("Show %s"),
 mName.c_str()),
 false);
 if (isAllowCommand(ServerCommandType::accinfo))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: show player account info
 mBrowserBox->addRow("/showaccountinfo 'NAME'", _("Account info"));
 }
 if (isAllowOtherCommand(ServerCommandType::exp))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: show player level
 mBrowserBox->addRow("/showlevel 'NAME'", _("Level"));
 }
 if (isAllowOtherCommand(ServerCommandType::stats))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: show player stats
 mBrowserBox->addRow("/showstats 'NAME'", _("Stats"));
 }
 if (isAllowOtherCommand(ServerCommandType::itemlist))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: show player inventory list
 mBrowserBox->addRow("/showinventory 'NAME'", _("Inventory"));
 }
 if (isAllowOtherCommand(ServerCommandType::storagelist))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: show player storage list
 mBrowserBox->addRow("/showstorage 'NAME'", _("Storage"));
 }
 if (isAllowOtherCommand(ServerCommandType::cartlist))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: show player cart list
 mBrowserBox->addRow("/showcart 'NAME'", _("Cart"));
 }
 if (isAllowOtherCommand(ServerCommandType::commands))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: gm commands
 mBrowserBox->addRow("/gmcommands 'NAME'", _("Commands"));
 }
 if (isAllowOtherCommand(ServerCommandType::charcommands))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: gm char commands
 mBrowserBox->addRow("/gmcharcommands 'NAME'", _("Char commands"));
 }
 // TRANSLATORS: popup menu item
 // TRANSLATORS: back to gm menu
 mBrowserBox->addRow("gm", _("Back"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 showPopup(getX(), getY());
}
 
void PopupMenu::showPlayerGMCommands(const std::string &name)
{
 if (localPlayer == nullptr)
 return;
 const bool legacy = Net::getNetworkType() == ServerType::TMWATHENA;
 if (!legacy && isAllowCommand(ServerCommandType::where))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: find player position
 mBrowserBox->addRow("/locateplayer 'NAME'", _("Locate"));
 }
 if (legacy)
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: check player ip
 mBrowserBox->addRow("/ipcheck 'NAME'", _("Check ip"));
 }
 if (isAllowCommand(ServerCommandType::jumpto))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: go to player position
 mBrowserBox->addRow("/gotopc 'NAME'", _("Goto"));
 }
 if (isAllowCommand(ServerCommandType::recall))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: recall player to current position
 mBrowserBox->addRow("/recallpc 'NAME'", _("Recall"));
 }
 if (isAllowOtherCommand(ServerCommandType::alive))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: revive player
 mBrowserBox->addRow("/alive 'NAME'", _("Revive"));
 }
 if (!legacy)
 {
 Being *const being = actorManager->findBeingByName(name,
 ActorType::Player);
 if (being != nullptr && being == localPlayer)
 {
 if (!being->getPartyName().empty() &&
 isAllowCommand(ServerCommandType::partyrecall))
 {
 mBrowserBox->addRow("/partyrecall 'PARTY'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: recall all party members to player location
 _("Recall party"));
 }
 if (!being->getGuildName().empty() &&
 isAllowCommand(ServerCommandType::guildrecall))
 {
 mBrowserBox->addRow("/guildrecall 'PARTY'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: recall all guild members to player location
 _("Recall guild"));
 }
 }
 if (localPlayer->isInParty())
 {
 const Party *const party = localPlayer->getParty();
 if (party != nullptr &&
 party->isMember(name) &&
 isAllowCommand(ServerCommandType::changeleader))
 {
 mBrowserBox->addRow("/gmpartyleader 'NAME'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: give party leader status
 _("Give party leader"));
 }
 }
 
 if (isAllowCommand(ServerCommandType::nuke))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: nuke player
 mBrowserBox->addRow("/gmnuke 'NAME'", _("Nuke"));
 }
 if (isAllowOtherCommand(ServerCommandType::kill))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: kill player
 mBrowserBox->addRow("/kill 'NAME'", _("Kill"));
 }
 if (mBeingId != BeingId_zero)
 {
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: show menu
 mBrowserBox->addRow("show", _("Show..."));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: mute menu
 mBrowserBox->addRow("mute", _("Mute..."));
 }
 }
 if (legacy)
 {
 if (localPlayer->getName() == mName)
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: hide player
 mBrowserBox->addRow("/hide", _("Hide"));
 mBrowserBox->addSeparator("##3---");
 }
 }
 else
 {
 if (isAllowOtherCommand(ServerCommandType::heal))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: heal player
 mBrowserBox->addRow("/gmheal 'NAME'", _("Heal"));
 }
 if (isAllowOtherCommand(ServerCommandType::monsterignore))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: enable immortal mode for player
 mBrowserBox->addRow("/immortal 'NAME'", _("Immortal"));
 }
 if (isAllowCommand(ServerCommandType::jail))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: send player to jail
 mBrowserBox->addRow("/jail 'NAME'", _("Jail"));
 }
 if (isAllowCommand(ServerCommandType::unjail))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: restore player from jail
 mBrowserBox->addRow("/unjail 'NAME'", _("Unjail"));
 }
 if (name == localPlayer->getName() &&
 isAllowCommand(ServerCommandType::hide))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: hide player
 mBrowserBox->addRow("/hide 'NAME'", _("Hide"));
 }
 mBrowserBox->addSeparator("##3---");
 if (isAllowOtherCommand(ServerCommandType::killer))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: set player as killer
 mBrowserBox->addRow("/killer 'NAME'", _("Killer"));
 }
 if (isAllowOtherCommand(ServerCommandType::killable))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: set player as killable
 mBrowserBox->addRow("/killable 'NAME'", _("Killable"));
 }
 if (isAllowOtherCommand(ServerCommandType::save))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: set player save position
 mBrowserBox->addRow("/savepos 'NAME'", _("Set save"));
 }
 if (isAllowOtherCommand(ServerCommandType::load))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: warp player to save position
 mBrowserBox->addRow("/loadpos 'NAME'", _("Warp to save"));
 }
 if (isAllowOtherCommand(ServerCommandType::jump))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: warp player to random position on same map
 mBrowserBox->addRow("/randomwarp 'NAME'", _("Warp to random"));
 }
 mBrowserBox->addSeparator("##3---");
 if (isAllowCommand(ServerCommandType::clone))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: spawn player clone
 mBrowserBox->addRow("/spawnclone 'NAME'", _("Spawn clone"));
 }
 if (isAllowCommand(ServerCommandType::slaveclone))
 {
 mBrowserBox->addRow("/spawnslaveclone 'NAME'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: spawn slave player clone
 _("Spawn slave clone"));
 }
 if (isAllowCommand(ServerCommandType::evilclone))
 {
 mBrowserBox->addRow("/spawnevilclone 'NAME'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: spawn evil player clone
 _("Spawn evil clone"));
 }
 mBrowserBox->addSeparator("##3---");
 if (isAllowOtherCommand(ServerCommandType::breakguild))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: break guild
 mBrowserBox->addRow("/gmbreakguild 'NAME'", _("Break guild"));
 }
 }
 if (mBeingId != BeingId_zero &&
 isAllowCommand(ServerCommandType::kick))
 {
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: kick player
 mBrowserBox->addRow("/kick :'BEINGID'", _("Kick"));
 }
}
 
void PopupMenu::showMuteCommands()
{
 mBrowserBox->clearRows();
 // TRANSLATORS: popup menu header
 mBrowserBox->addRow(strprintf(_("Mute %s"),
 mName.c_str()),
 false);
 if (mBeingId != BeingId_zero &&
 Net::getNetworkType() != ServerType::TMWATHENA &&
 isAllowCommand(ServerCommandType::mute))
 {
 mBrowserBox->addRow("mute_+1",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: mute player
 strprintf(_("Mute %d"), 1).c_str());
 mBrowserBox->addRow("mute_+5",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: mute player
 strprintf(_("Mute %d"), 5).c_str());
 mBrowserBox->addRow("mute_+10",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: mute player
 strprintf(_("Mute %d"), 10).c_str());
 mBrowserBox->addRow("mute_+15",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: mute player
 strprintf(_("Mute %d"), 15).c_str());
 mBrowserBox->addRow("mute_+30",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: mute player
 strprintf(_("Mute %d"), 30).c_str());
 
 mBrowserBox->addRow("mute_-1",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: mute player
 strprintf(_("Unmute %d"), 1).c_str());
 mBrowserBox->addRow("mute_-5",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: mute player
 strprintf(_("Unmute %d"), 5).c_str());
 mBrowserBox->addRow("mute_-10",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: mute player
 strprintf(_("Unmute %d"), 10).c_str());
 mBrowserBox->addRow("mute_-15",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: mute player
 strprintf(_("Unmute %d"), 15).c_str());
 mBrowserBox->addRow("mute_-30",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: mute player
 strprintf(_("Unmute %d"), 30).c_str());
 mBrowserBox->addSeparator("##3---");
 }
 // TRANSLATORS: popup menu item
 // TRANSLATORS: back to gm menu
 mBrowserBox->addRow("gm", _("Back"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 showPopup(getX(), getY());
}
 
void PopupMenu::showNpcGMCommands()
{
 if (mBeingId != BeingId_zero)
 {
 if (isAllowCommand(ServerCommandType::kick))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: kick player
 mBrowserBox->addRow("/kick :'BEINGID'", _("Kick"));
 }
 const bool legacy = Net::getNetworkType() == ServerType::TMWATHENA;
 if (!legacy)
 {
 if (isAllowCommand(ServerCommandType::hidenpc))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: hide npc
 mBrowserBox->addRow("/hidenpc 'EXTNAME'", _("Hide"));
 }
 mBrowserBox->addSeparator("##3---");
 if (isAllowCommand(ServerCommandType::npcmove))
 {
 mBrowserBox->addRow("/npcmove 'EEXTNAME' 'PLAYERX' 'PLAYERY'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: warp npc to player location
 _("Recall"));
 }
 if (isAllowCommand(ServerCommandType::disguise))
 {
 mBrowserBox->addRow("/disguise 'BEINGSUBTYPEID'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: disguise to npc
 _("Disguise"));
 }
 if (isAllowCommand(ServerCommandType::tonpc))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: warp to npc
 mBrowserBox->addRow("/gotonpc 'EXTNAME'", _("Goto"));
 }
 }
 }
}
 
void PopupMenu::showMonsterGMCommands()
{
 if (mBeingId != BeingId_zero)
 {
 const bool legacy = Net::getNetworkType() == ServerType::TMWATHENA;
 if (isAllowCommand(ServerCommandType::kick))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: kick monster
 mBrowserBox->addRow("/kick :'BEINGID'", _("Kick"));
 }
 if (isAllowCommand(ServerCommandType::monster))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: spawn monster
 mBrowserBox->addRow("/spawn 'BEINGSUBTYPEID'", _("Spawn same"));
 }
 if (!legacy)
 {
 if (isAllowCommand(ServerCommandType::summon))
 {
 mBrowserBox->addRow("/spawnslave 'BEINGSUBTYPEID'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: spawn slave monster
 _("Spawn slave"));
 }
 if (isAllowCommand(ServerCommandType::disguise))
 {
 mBrowserBox->addRow("/disguise 'BEINGSUBTYPEID'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: disguise to monster
 _("Disguise"));
 }
 mBrowserBox->addSeparator("##3---");
 if (isAllowCommand(ServerCommandType::mobinfo))
 {
 mBrowserBox->addRow("/monsterinfo 'BEINGSUBTYPEID'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: show monster information
 _("Info"));
 }
 if (isAllowCommand(ServerCommandType::mobsearch))
 {
 mBrowserBox->addRow("/mobsearch 'BEINGSUBTYPEID'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: show selected monster in current map
 _("Search"));
 }
 if (isAllowCommand(ServerCommandType::whereis))
 {
 mBrowserBox->addRow("/mobspawnsearch 'BEINGSUBTYPEID'",
 // TRANSLATORS: popup menu item
 // TRANSLATORS: show selected monster spawns in all maps
 _("Search spawns"));
 }
 }
 }
}
 
void PopupMenu::showFloorItemGMCommands()
{
 const bool legacy = Net::getNetworkType() == ServerType::TMWATHENA;
 if (legacy)
 return;
 if (isAllowCommand(ServerCommandType::iteminfo))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: show item information
 mBrowserBox->addRow("/iteminfo 'ITEMID'", _("Info"));
 }
 if (isAllowCommand(ServerCommandType::whodrops))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: show who drops item
 mBrowserBox->addRow("/whodrops 'ITEMID'", _("Who drops"));
 }
}
 
void PopupMenu::showItemGMCommands()
{
 const bool legacy = Net::getNetworkType() == ServerType::TMWATHENA;
 if (legacy)
 return;
 if (isAllowCommand(ServerCommandType::iteminfo))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: show item information
 mBrowserBox->addRow("/iteminfo 'ITEMID'", _("Info"));
 }
 if (isAllowCommand(ServerCommandType::whodrops))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: show who drops item
 mBrowserBox->addRow("/whodrops 'ITEMID'", _("Who drops"));
 }
 mBrowserBox->addSeparator("##3---");
 if (isAllowCommand(ServerCommandType::item))
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: gm create item
 mBrowserBox->addRow("/createitem 'ITEMID' 1", _("Add 1"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: gm create item
 mBrowserBox->addRow("/createitem 'ITEMID' 5", _("Add 5"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: gm create item
 mBrowserBox->addRow("/createitem 'ITEMID' 10", _("Add 10"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: gm create item
 mBrowserBox->addRow("/createitem 'ITEMID' 100", _("Add 100"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: gm create item
 mBrowserBox->addRow("/createitem 'ITEMID' 1000", _("Add 1000"));
 // TRANSLATORS: popup menu item
 // TRANSLATORS: gm create item
 mBrowserBox->addRow("/createitem 'ITEMID' 10000", _("Add 10000"));
 }
}
 
void PopupMenu::showGMPopup(const std::string &name)
{
 mBrowserBox->clearRows();
 // TRANSLATORS: popup menu header
 mBrowserBox->addRow(_("GM commands"), false);
 if (localPlayer->isGM())
 {
 switch (mType)
 {
 case ActorType::Player:
 showPlayerGMCommands(name);
 break;
 case ActorType::Npc:
 showNpcGMCommands();
 break;
 case ActorType::Monster:
 showMonsterGMCommands();
 break;
 case ActorType::FloorItem:
 showFloorItemGMCommands();
 break;
 case ActorType::Homunculus:
 showHomunGMCommands();
 break;
 case ActorType::Pet:
 showPetGMCommands();
 break;
 case ActorType::Mercenary:
 showMercenaryGMCommands();
 break;
 case ActorType::SkillUnit:
 break;
 default:
 case ActorType::Unknown:
 if (mItemId != 0)
 showItemGMCommands();
 break;
 case ActorType::Portal:
 case ActorType::Avatar:
 case ActorType::Elemental:
 break;
 }
 }
 
 mBrowserBox->addSeparator("##3---");
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(getX(), getY());
}
 
void PopupMenu::showHomunGMCommands()
{
}
 
void PopupMenu::showPetGMCommands()
{
}
 
void PopupMenu::showMercenaryGMCommands()
{
}
 
void PopupMenu::showCraftPopup()
{
 mBrowserBox->clearRows();
 
 for (int f = 0; f < 9; f ++)
 {
 const std::string cmd = strprintf("/craft %d", f);
 mBrowserBox->addRow(cmd,
 // TRANSLATORS: popup menu item
 // TRANSLATORS: move current item to craft slot
 strprintf(_("Move to craft %d"), f + 1).c_str());
 }
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 
 showPopup(mX, mY);
}
 
void PopupMenu::addMailCommands()
{
 if (Net::getNetworkType() == ServerType::TMWATHENA)
 return;
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: open mail dialog
 mBrowserBox->addRow("/mailto 'NAME'", _("Mail to..."));
}
 
void PopupMenu::addCatchPetCommands()
{
 if (Net::getNetworkType() == ServerType::TMWATHENA)
 return;
 // TRANSLATORS: popup menu item
 // TRANSLATORS: catch pet command
 mBrowserBox->addRow("/catchpet :'BEINGID'", _("Taming pet"));
}
 
void PopupMenu::showAdoptCommands()
{
 if (Net::getNetworkType() == ServerType::TMWATHENA)
 return;
 // TRANSLATORS: popup menu item
 // TRANSLATORS: adopt child command
 mBrowserBox->addRow("/adoptchild 'NAME'", _("Adopt child"));
}
 
void PopupMenu::addSocialMenu()
{
 initPopup();
 mBrowserBox->clearRows();
 setMousePos();
 const Party *const party = localPlayer->getParty();
 if (party != nullptr)
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: leave party
 mBrowserBox->addRow("/leaveparty", _("Leave party"));
 }
 else
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: create party
 mBrowserBox->addRow("/createparty", _("Create party"));
 }
 
 if (Net::getNetworkType() != ServerType::TMWATHENA)
 {
 const Guild *const guild = localPlayer->getGuild();
 if (guild != nullptr)
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: leave guild
 mBrowserBox->addRow("/leaveguild", _("Leave guild"));
 }
 else
 {
 // TRANSLATORS: popup menu item
 // TRANSLATORS: create guild
 mBrowserBox->addRow("/createguild", _("Create guild"));
 }
 }
 mBrowserBox->addSeparator("##3---");
}
 
void PopupMenu::showPartyPopup()
{
 addSocialMenu();
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 showPopup(mX, mY);
}
 
void PopupMenu::showGuildPopup()
{
 addSocialMenu();
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: change guild notice message
 mBrowserBox->addRow("/guildnotice", _("Change notice"));
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 showPopup(mX, mY);
}
 
void PopupMenu::showAttackPopup()
{
 addSocialMenu();
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 showPopup(mX, mY);
}
 
void PopupMenu::showNavigationPopup()
{
 addSocialMenu();
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 showPopup(mX, mY);
}
 
void PopupMenu::showPickupPopup()
{
 addSocialMenu();
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 showPopup(mX, mY);
}
 
void PopupMenu::showPlayersPopup()
{
 addSocialMenu();
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 showPopup(mX, mY);
}
 
void PopupMenu::showFriendsPopup()
{
 addSocialMenu();
 
 // TRANSLATORS: popup menu item
 // TRANSLATORS: close menu
 mBrowserBox->addRow("cancel", _("Cancel"));
 showPopup(mX, mY);
}
 
void PopupMenu::moveUp()
{
 mBrowserBox->moveSelectionUp();
}
 
void PopupMenu::moveDown()
{
 mBrowserBox->moveSelectionDown();
}
 
void PopupMenu::select()
{
 mBrowserBox->selectSelection();
}