/* Minetest Copyright (C) 2013 celeron55, Perttu Ahola This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include #include #include #include #include #include "guiFormSpecMenu.h" #include "guiTable.h" #include "constants.h" #include "gamedef.h" #include "keycode.h" #include "strfnd.h" #include #include #include #include #include #include #include #include "log.h" #include "client/tile.h" // ITextureSource #include "hud.h" // drawItemStack #include "filesys.h" #include "gettime.h" #include "gettext.h" #include "scripting_game.h" #include "porting.h" #include "settings.h" #include "client.h" #include "fontengine.h" #include "util/hex.h" #include "util/numeric.h" #include "util/string.h" // for parseColorString() #include "guiscalingfilter.h" #if USE_FREETYPE && IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR < 9 #include "intlGUIEditBox.h" #endif #define MY_CHECKPOS(a,b) \ if (v_pos.size() != 2) { \ errorstream<< "Invalid pos for element " << a << "specified: \"" \ << parts[b] << "\"" << std::endl; \ return; \ } #define MY_CHECKGEOM(a,b) \ if (v_geom.size() != 2) { \ errorstream<< "Invalid pos for element " << a << "specified: \"" \ << parts[b] << "\"" << std::endl; \ return; \ } /* GUIFormSpecMenu */ static unsigned int font_line_height(gui::IGUIFont *font) { return font->getDimension(L"Ay").Height + font->getKerningHeight(); } GUIFormSpecMenu::GUIFormSpecMenu(irr::IrrlichtDevice* dev, gui::IGUIElement* parent, s32 id, IMenuManager *menumgr, InventoryManager *invmgr, IGameDef *gamedef, ISimpleTextureSource *tsrc, IFormSource* fsrc, TextDest* tdst, Client* client, bool remap_dbl_click) : GUIModalMenu(dev->getGUIEnvironment(), parent, id, menumgr), m_device(dev), m_invmgr(invmgr), m_gamedef(gamedef), m_tsrc(tsrc), m_client(client), m_selected_item(NULL), m_selected_amount(0), m_selected_dragging(false), m_tooltip_element(NULL), m_hovered_time(0), m_old_tooltip_id(-1), m_rmouse_auto_place(false), m_allowclose(true), m_lock(false), m_form_src(fsrc), m_text_dst(tdst), m_formspec_version(0), m_focused_element(""), m_font(NULL), m_remap_dbl_click(remap_dbl_click) #ifdef __ANDROID__ , m_JavaDialogFieldName("") #endif { current_keys_pending.key_down = false; current_keys_pending.key_up = false; current_keys_pending.key_enter = false; current_keys_pending.key_escape = false; m_doubleclickdetect[0].time = 0; m_doubleclickdetect[1].time = 0; m_doubleclickdetect[0].pos = v2s32(0, 0); m_doubleclickdetect[1].pos = v2s32(0, 0); m_tooltip_show_delay = (u32)g_settings->getS32("tooltip_show_delay"); } GUIFormSpecMenu::~GUIFormSpecMenu() { removeChildren(); for (u32 i = 0; i < m_tables.size(); ++i) { GUITable *table = m_tables[i].second; table->drop(); } delete m_selected_item; if (m_form_src != NULL) { delete m_form_src; } if (m_text_dst != NULL) { delete m_text_dst; } } void GUIFormSpecMenu::removeChildren() { const core::list &children = getChildren(); while(!children.empty()) { (*children.getLast())->remove(); } if(m_tooltip_element) { m_tooltip_element->remove(); m_tooltip_element->drop(); m_tooltip_element = NULL; } } void GUIFormSpecMenu::setInitialFocus() { // Set initial focus according to following order of precedence: // 1. first empty editbox // 2. first editbox // 3. first table // 4. last button // 5. first focusable (not statictext, not tabheader) // 6. first child element core::list children = getChildren(); // in case "children" contains any NULL elements, remove them for (core::list::Iterator it = children.begin(); it != children.end();) { if (*it) ++it; else it = children.erase(it); } // 1. first empty editbox for (core::list::Iterator it = children.begin(); it != children.end(); ++it) { if ((*it)->getType() == gui::EGUIET_EDIT_BOX && (*it)->getText()[0] == 0) { Environment->setFocus(*it); return; } } // 2. first editbox for (core::list::Iterator it = children.begin(); it != children.end(); ++it) { if ((*it)->getType() == gui::EGUIET_EDIT_BOX) { Environment->setFocus(*it); return; } } // 3. first table for (core::list::Iterator it = children.begin(); it != children.end(); ++it) { if ((*it)->getTypeName() == std::string("GUITable")) { Environment->setFocus(*it); return; } } // 4. last button for (core::list::Iterator it = children.getLast(); it != children.end(); --it) { if ((*it)->getType() == gui::EGUIET_BUTTON) { Environment->setFocus(*it); return; } } // 5. first focusable (not statictext, not tabheader) for (core::list::Iterator it = children.begin(); it != children.end(); ++it) { if ((*it)->getType() != gui::EGUIET_STATIC_TEXT && (*it)->getType() != gui::EGUIET_TAB_CONTROL) { Environment->setFocus(*it); return; } } // 6. first child element if (children.empty()) Environment->setFocus(this); else Environment->setFocus(*(children.begin())); } GUITable* GUIFormSpecMenu::getTable(const std::string &tablename) { for (u32 i = 0; i < m_tables.size(); ++i) { if (tablename == m_tables[i].first.fname) return m_tables[i].second; } return 0; } static std::vector split(const std::string &s, char delim) { std::vector tokens; std::string current = ""; bool last_was_escape = false; for (unsigned int i = 0; i < s.size(); i++) { char si = s.c_str()[i]; if (last_was_escape) { current += '\\'; current += si; last_was_escape = false; } else { if (si == delim) { tokens.push_back(current); current = ""; last_was_escape = false; } else if (si == '\\') { last_was_escape = true; } else { current += si; last_was_escape = false; } } } //push last element tokens.push_back(current); return tokens; } void GUIFormSpecMenu::parseSize(parserData* data,std::string element) { std::vector parts = split(element,','); if (((parts.size() == 2) || parts.size() == 3) || ((parts.size() > 3) && (m_formspec_version > FORMSPEC_API_VERSION))) { if (parts[1].find(';') != std::string::npos) parts[1] = parts[1].substr(0,parts[1].find(';')); data->invsize.X = MYMAX(0, stof(parts[0])); data->invsize.Y = MYMAX(0, stof(parts[1])); lockSize(false); if (parts.size() == 3) { if (parts[2] == "true") { lockSize(true,v2u32(800,600)); } } data->explicit_size = true; return; } errorstream<< "Invalid size element (" << parts.size() << "): '" << element << "'" << std::endl; } void GUIFormSpecMenu::parseList(parserData* data,std::string element) { if (m_gamedef == 0) { warningstream<<"invalid use of 'list' with m_gamedef==0"< parts = split(element,';'); if (((parts.size() == 4) || (parts.size() == 5)) || ((parts.size() > 5) && (m_formspec_version > FORMSPEC_API_VERSION))) { std::string location = parts[0]; std::string listname = parts[1]; std::vector v_pos = split(parts[2],','); std::vector v_geom = split(parts[3],','); std::string startindex = ""; if (parts.size() == 5) startindex = parts[4]; MY_CHECKPOS("list",2); MY_CHECKGEOM("list",3); InventoryLocation loc; if(location == "context" || location == "current_name") loc = m_current_inventory_location; else loc.deSerialize(location); v2s32 pos = padding + AbsoluteRect.UpperLeftCorner; pos.X += stof(v_pos[0]) * (float)spacing.X; pos.Y += stof(v_pos[1]) * (float)spacing.Y; v2s32 geom; geom.X = stoi(v_geom[0]); geom.Y = stoi(v_geom[1]); s32 start_i = 0; if(startindex != "") start_i = stoi(startindex); if (geom.X < 0 || geom.Y < 0 || start_i < 0) { errorstream<< "Invalid list element: '" << element << "'" << std::endl; return; } if(!data->explicit_size) warningstream<<"invalid use of list without a size[] element"< parts = split(element, ';'); if (parts.size() == 2) { std::string location = parts[0]; std::string listname = parts[1]; InventoryLocation loc; if (location == "context" || location == "current_name") loc = m_current_inventory_location; else loc.deSerialize(location); m_inventory_rings.push_back(ListRingSpec(loc, listname)); return; } else if ((element == "") && (m_inventorylists.size() > 1)) { size_t siz = m_inventorylists.size(); // insert the last two inv list elements into the list ring const ListDrawSpec &spa = m_inventorylists[siz - 2]; const ListDrawSpec &spb = m_inventorylists[siz - 1]; m_inventory_rings.push_back(ListRingSpec(spa.inventoryloc, spa.listname)); m_inventory_rings.push_back(ListRingSpec(spb.inventoryloc, spb.listname)); return; } errorstream<< "Invalid list ring element(" << parts.size() << ", " << m_inventorylists.size() << "): '" << element << "'" << std::endl; } void GUIFormSpecMenu::parseCheckbox(parserData* data,std::string element) { std::vector parts = split(element,';'); if (((parts.size() >= 3) && (parts.size() <= 4)) || ((parts.size() > 4) && (m_formspec_version > FORMSPEC_API_VERSION))) { std::vector v_pos = split(parts[0],','); std::string name = parts[1]; std::string label = parts[2]; std::string selected = ""; if (parts.size() >= 4) selected = parts[3]; MY_CHECKPOS("checkbox",0); v2s32 pos = padding; pos.X += stof(v_pos[0]) * (float) spacing.X; pos.Y += stof(v_pos[1]) * (float) spacing.Y; bool fselected = false; if (selected == "true") fselected = true; std::wstring wlabel = utf8_to_wide(label); core::rect rect = core::rect( pos.X, pos.Y + ((imgsize.Y/2) - m_btn_height), pos.X + m_font->getDimension(wlabel.c_str()).Width + 25, // text size + size of checkbox pos.Y + ((imgsize.Y/2) + m_btn_height)); FieldSpec spec( name, wlabel, //Needed for displaying text on MSVC wlabel, 258+m_fields.size() ); spec.ftype = f_CheckBox; gui::IGUICheckBox* e = Environment->addCheckBox(fselected, rect, this, spec.fid, spec.flabel.c_str()); if (spec.fname == data->focused_fieldname) { Environment->setFocus(e); } m_checkboxes.push_back(std::pair(spec,e)); m_fields.push_back(spec); return; } errorstream<< "Invalid checkbox element(" << parts.size() << "): '" << element << "'" << std::endl; } void GUIFormSpecMenu::parseScrollBar(parserData* data, std::string element) { std::vector parts = split(element,';'); if (parts.size() >= 5) { std::vector v_pos = split(parts[0],','); std::vector v_dim = split(parts[1],','); std::string name = parts[3]; std::string value = parts[4]; MY_CHECKPOS("scrollbar",0); v2s32 pos = padding; pos.X += stof(v_pos[0]) * (float) spacing.X; pos.Y += stof(v_pos[1]) * (float) spacing.Y; if (v_dim.size() != 2) { errorstream<< "Invalid size for element " << "scrollbar" << "specified: \"" << parts[1] << "\"" << std::endl; return; } v2s32 dim; dim.X = stof(v_dim[0]) * (float) spacing.X; dim.Y = stof(v_dim[1]) * (float) spacing.Y; core::rect rect = core::rect(pos.X, pos.Y, pos.X + dim.X, pos.Y + dim.Y); FieldSpec spec( name, L"", L"", 258+m_fields.size() ); bool is_horizontal = true; if (parts[2] == "vertical") is_horizontal = false; spec.ftype = f_ScrollBar; spec.send = true; gui::IGUIScrollBar* e = Environment->addScrollBar(is_horizontal,rect,this,spec.fid); e->setMax(1000); e->setMin(0); e->setPos(stoi(parts[4])); e->setSmallStep(10); e->setLargeStep(100); m_scrollbars.push_back(std::pair(spec,e)); m_fields.push_back(spec); return; } errorstream<< "Invalid scrollbar element(" << parts.size() << "): '" << element << "'" << std::endl; } void GUIFormSpecMenu::parseImage(parserData* data,std::string element) { std::vector parts = split(element,';'); if ((parts.size() == 3) || ((parts.size() > 3) && (m_formspec_version > FORMSPEC_API_VERSION))) { std::vector v_pos = split(parts[0],','); std::vector v_geom = split(parts[1],','); std::string name = unescape_string(parts[2]); MY_CHECKPOS("image",0); MY_CHECKGEOM("image",1); v2s32 pos = padding + AbsoluteRect.UpperLeftCorner; pos.X += stof(v_pos[0]) * (float) spacing.X; pos.Y += stof(v_pos[1]) * (float) spacing.Y; v2s32 geom; geom.X = stof(v_geom[0]) * (float)imgsize.X; geom.Y = stof(v_geom[1]) * (float)imgsize.Y; if(!data->explicit_size) warningstream<<"invalid use of image without a size[] element"< v_pos = split(parts[0],','); std::string name = unescape_string(parts[1]); MY_CHECKPOS("image",0); v2s32 pos = padding + AbsoluteRect.UpperLeftCorner; pos.X += stof(v_pos[0]) * (float) spacing.X; pos.Y += stof(v_pos[1]) * (float) spacing.Y; if(!data->explicit_size) warningstream<<"invalid use of image without a size[] element"< parts = split(element,';'); if ((parts.size() == 3) || ((parts.size() > 3) && (m_formspec_version > FORMSPEC_API_VERSION))) { std::vector v_pos = split(parts[0],','); std::vector v_geom = split(parts[1],','); std::string name = parts[2]; MY_CHECKPOS("itemimage",0); MY_CHECKGEOM("itemimage",1); v2s32 pos = padding + AbsoluteRect.UpperLeftCorner; pos.X += stof(v_pos[0]) * (float) spacing.X; pos.Y += stof(v_pos[1]) * (float) spacing.Y; v2s32 geom; geom.X = stof(v_geom[0]) * (float)imgsize.X; geom.Y = stof(v_geom[1]) * (float)imgsize.Y; if(!data->explicit_size) warningstream<<"invalid use of item_image without a size[] element"< parts = split(element,';'); if ((parts.size() == 4) || ((parts.size() > 4) && (m_formspec_version > FORMSPEC_API_VERSION))) { std::vector v_pos = split(parts[0],','); std::vector v_geom = split(parts[1],','); std::string name = parts[2]; std::string label = parts[3]; MY_CHECKPOS("button",0); MY_CHECKGEOM("button",1); v2s32 pos = padding; pos.X += stof(v_pos[0]) * (float)spacing.X; pos.Y += stof(v_pos[1]) * (float)spacing.Y; v2s32 geom; geom.X = (stof(v_geom[0]) * (float)spacing.X)-(spacing.X-imgsize.X); pos.Y += (stof(v_geom[1]) * (float)imgsize.Y)/2; core::rect rect = core::rect(pos.X, pos.Y - m_btn_height, pos.X + geom.X, pos.Y + m_btn_height); if(!data->explicit_size) warningstream<<"invalid use of button without a size[] element"<addButton(rect, this, spec.fid, spec.flabel.c_str()); if (spec.fname == data->focused_fieldname) { Environment->setFocus(e); } m_fields.push_back(spec); return; } errorstream<< "Invalid button element(" << parts.size() << "): '" << element << "'" << std::endl; } void GUIFormSpecMenu::parseBackground(parserData* data,std::string element) { std::vector parts = split(element,';'); if (((parts.size() == 3) || (parts.size() == 4)) || ((parts.size() > 4) && (m_formspec_version > FORMSPEC_API_VERSION))) { std::vector v_pos = split(parts[0],','); std::vector v_geom = split(parts[1],','); std::string name = unescape_string(parts[2]); MY_CHECKPOS("background",0); MY_CHECKGEOM("background",1); v2s32 pos = padding + AbsoluteRect.UpperLeftCorner; pos.X += stof(v_pos[0]) * (float)spacing.X - ((float)spacing.X-(float)imgsize.X)/2; pos.Y += stof(v_pos[1]) * (float)spacing.Y - ((float)spacing.Y-(float)imgsize.Y)/2; v2s32 geom; geom.X = stof(v_geom[0]) * (float)spacing.X; geom.Y = stof(v_geom[1]) * (float)spacing.Y; if (parts.size() == 4) { m_clipbackground = is_yes(parts[3]); if (m_clipbackground) { pos.X = stoi(v_pos[0]); //acts as offset pos.Y = stoi(v_pos[1]); //acts as offset } } if(!data->explicit_size) warningstream<<"invalid use of background without a size[] element"< parts = split(element,';'); data->table_options.clear(); for (size_t i = 0; i < parts.size(); ++i) { // Parse table option std::string opt = unescape_string(parts[i]); data->table_options.push_back(GUITable::splitOption(opt)); } } void GUIFormSpecMenu::parseTableColumns(parserData* data,std::string element) { std::vector parts = split(element,';'); data->table_columns.clear(); for (size_t i = 0; i < parts.size(); ++i) { std::vector col_parts = split(parts[i],','); GUITable::TableColumn column; // Parse column type if (!col_parts.empty()) column.type = col_parts[0]; // Parse column options for (size_t j = 1; j < col_parts.size(); ++j) { std::string opt = unescape_string(col_parts[j]); column.options.push_back(GUITable::splitOption(opt)); } data->table_columns.push_back(column); } } void GUIFormSpecMenu::parseTable(parserData* data,std::string element) { std::vector parts = split(element,';'); if (((parts.size() == 4) || (parts.size() == 5)) || ((parts.size() > 5) && (m_formspec_version > FORMSPEC_API_VERSION))) { std::vector v_pos = split(parts[0],','); std::vector v_geom = split(parts[1],','); std::string name = parts[2]; std::vector items = split(parts[3],','); std::string str_initial_selection = ""; std::string str_transparent = "false"; if (parts.size() >= 5) str_initial_selection = parts[4]; MY_CHECKPOS("table",0); MY_CHECKGEOM("table",1); v2s32 pos = padding; pos.X += stof(v_pos[0]) * (float)spacing.X; pos.Y += stof(v_pos[1]) * (float)spacing.Y; v2s32 geom; geom.X = stof(v_geom[0]) * (float)spacing.X; geom.Y = stof(v_geom[1]) * (float)spacing.Y; core::rect rect = core::rect(pos.X, pos.Y, pos.X+geom.X, pos.Y+geom.Y); FieldSpec spec( name, L"", L"", 258+m_fields.size() ); spec.ftype = f_Table; for (unsigned int i = 0; i < items.size(); ++i) { items[i] = unescape_string(items[i]); } //now really show table GUITable *e = new GUITable(Environment, this, spec.fid, rect, m_tsrc); if (spec.fname == data->focused_fieldname) { Environment->setFocus(e); } e->setTable(data->table_options, data->table_columns, items); { SCRIPTAPI_PRECHECKHEADER // Get core.registered_on_punchplayers lua_getglobal(L, "core"); lua_getfield(L, -1, "registered_on_punchplayers"); // Call callbacks objectrefGetOrCreate(L, player); objectrefGetOrCreate(L, hitter); lua_pushnumber(L, time_from_last_punch); push_tool_capabilities(L, *toolcap); push_v3f(L, dir); lua_pushnumber(L, damage); runCallbacks(6, RUN_CALLBACKS_MODE_OR); return readParam<bool>(L, -1); } s32 ScriptApiPlayer::on_player_hpchange(ServerActiveObject *player, s32 hp_change, const PlayerHPChangeReason &reason) { SCRIPTAPI_PRECHECKHEADER int error_handler = PUSH_ERROR_HANDLER(L); // Get core.registered_on_player_hpchange lua_getglobal(L, "core"); lua_getfield(L, -1, "registered_on_player_hpchange"); lua_remove(L, -2); // Push arguments objectrefGetOrCreate(L, player); lua_pushnumber(L, hp_change); pushPlayerHPChangeReason(L, reason); // Call callbacks PCALL_RES(lua_pcall(L, 3, 1, error_handler)); hp_change = lua_tointeger(L, -1); lua_pop(L, 2); // Pop result and error handler return hp_change; } bool ScriptApiPlayer::on_respawnplayer(ServerActiveObject *player) { SCRIPTAPI_PRECHECKHEADER // Get core.registered_on_respawnplayers lua_getglobal(L, "core"); lua_getfield(L, -1, "registered_on_respawnplayers"); // Call callbacks objectrefGetOrCreate(L, player); runCallbacks(1, RUN_CALLBACKS_MODE_OR); return readParam<bool>(L, -1); } bool ScriptApiPlayer::on_prejoinplayer( const std::string &name, const std::string &ip, std::string *reason) { SCRIPTAPI_PRECHECKHEADER // Get core.registered_on_prejoinplayers lua_getglobal(L, "core"); lua_getfield(L, -1, "registered_on_prejoinplayers"); lua_pushstring(L, name.c_str()); lua_pushstring(L, ip.c_str()); runCallbacks(2, RUN_CALLBACKS_MODE_OR); if (lua_isstring(L, -1)) { reason->assign(readParam<std::string>(L, -1)); return true; } return false; } bool ScriptApiPlayer::can_bypass_userlimit(const std::string &name, const std::string &ip) { SCRIPTAPI_PRECHECKHEADER // Get core.registered_on_prejoinplayers lua_getglobal(L, "core"); lua_getfield(L, -1, "registered_can_bypass_userlimit"); lua_pushstring(L, name.c_str()); lua_pushstring(L, ip.c_str()); runCallbacks(2, RUN_CALLBACKS_MODE_OR); return lua_toboolean(L, -1); } void ScriptApiPlayer::on_joinplayer(ServerActiveObject *player) { SCRIPTAPI_PRECHECKHEADER // Get core.registered_on_joinplayers lua_getglobal(L, "core"); lua_getfield(L, -1, "registered_on_joinplayers"); // Call callbacks objectrefGetOrCreate(L, player); runCallbacks(1, RUN_CALLBACKS_MODE_FIRST); } void ScriptApiPlayer::on_leaveplayer(ServerActiveObject *player, bool timeout) { SCRIPTAPI_PRECHECKHEADER // Get core.registered_on_leaveplayers lua_getglobal(L, "core"); lua_getfield(L, -1, "registered_on_leaveplayers"); // Call callbacks objectrefGetOrCreate(L, player); lua_pushboolean(L, timeout); runCallbacks(2, RUN_CALLBACKS_MODE_FIRST); } void ScriptApiPlayer::on_cheat(ServerActiveObject *player, const std::string &cheat_type) { SCRIPTAPI_PRECHECKHEADER // Get core.registered_on_cheats lua_getglobal(L, "core"); lua_getfield(L, -1, "registered_on_cheats"); // Call callbacks objectrefGetOrCreate(L, player); lua_newtable(L); lua_pushlstring(L, cheat_type.c_str(), cheat_type.size()); lua_setfield(L, -2, "type"); runCallbacks(2, RUN_CALLBACKS_MODE_FIRST); } void ScriptApiPlayer::on_playerReceiveFields(ServerActiveObject *player, const std::string &formname, const StringMap &fields) { SCRIPTAPI_PRECHECKHEADER // Get core.registered_on_player_receive_fields lua_getglobal(L, "core"); lua_getfield(L, -1, "registered_on_player_receive_fields"); // Call callbacks // param 1 objectrefGetOrCreate(L, player); // param 2 lua_pushstring(L, formname.c_str()); // param 3 lua_newtable(L); StringMap::const_iterator it; for (it = fields.begin(); it != fields.end(); ++it) { const std::string &name = it->first; const std::string &value = it->second; lua_pushstring(L, name.c_str()); lua_pushlstring(L, value.c_str(), value.size()); lua_settable(L, -3); } runCallbacks(3, RUN_CALLBACKS_MODE_OR_SC); } void ScriptApiPlayer::on_auth_failure(const std::string &name, const std::string &ip) { SCRIPTAPI_PRECHECKHEADER // Get core.registered_on_auth_failure lua_getglobal(L, "core"); lua_getfield(L, -1, "registered_on_auth_fail"); lua_pushstring(L, name.c_str()); lua_pushstring(L, ip.c_str()); runCallbacks(2, RUN_CALLBACKS_MODE_FIRST); } void ScriptApiPlayer::pushMoveArguments( const MoveAction &ma, int count, ServerActiveObject *player) { lua_State *L = getStack(); objectrefGetOrCreate(L, player); // player lua_pushstring(L, "move"); // action InvRef::create(L, ma.from_inv); // inventory lua_newtable(L); { // Table containing the action information lua_pushstring(L, ma.from_list.c_str()); lua_setfield(L, -2, "from_list"); lua_pushstring(L, ma.to_list.c_str()); lua_setfield(L, -2, "to_list"); lua_pushinteger(L, ma.from_i + 1); lua_setfield(L, -2, "from_index"); lua_pushinteger(L, ma.to_i + 1); lua_setfield(L, -2, "to_index"); lua_pushinteger(L, count); lua_setfield(L, -2, "count"); } } void ScriptApiPlayer::pushPutTakeArguments( const char *method, const InventoryLocation &loc, const std::string &listname, int index, const ItemStack &stack, ServerActiveObject *player) { lua_State *L = getStack(); objectrefGetOrCreate(L, player); // player lua_pushstring(L, method); // action InvRef::create(L, loc); // inventory lua_newtable(L); { // Table containing the action information lua_pushstring(L, listname.c_str()); lua_setfield(L, -2, "listname"); lua_pushinteger(L, index + 1); lua_setfield(L, -2, "index"); LuaItemStack::create(L, stack); lua_setfield(L, -2, "stack"); } } // Return number of accepted items to be moved int ScriptApiPlayer::player_inventory_AllowMove( const MoveAction &ma, int count, ServerActiveObject *player) { SCRIPTAPI_PRECHECKHEADER lua_getglobal(L, "core"); lua_getfield(L, -1, "registered_allow_player_inventory_actions"); pushMoveArguments(ma, count, player); runCallbacks(4, RUN_CALLBACKS_MODE_OR_SC); return lua_type(L, -1) == LUA_TNUMBER ? lua_tonumber(L, -1) : count; } // Return number of accepted items to be put int ScriptApiPlayer::player_inventory_AllowPut( const MoveAction &ma, const ItemStack &stack, ServerActiveObject *player) { SCRIPTAPI_PRECHECKHEADER lua_getglobal(L, "core"); lua_getfield(L, -1, "registered_allow_player_inventory_actions"); pushPutTakeArguments("put", ma.to_inv, ma.to_list, ma.to_i, stack, player); runCallbacks(4, RUN_CALLBACKS_MODE_OR_SC); return lua_type(L, -1) == LUA_TNUMBER ? lua_tonumber(L, -1) : stack.count; } // Return number of accepted items to be taken int ScriptApiPlayer::player_inventory_AllowTake( const MoveAction &ma, const ItemStack &stack, ServerActiveObject *player) { SCRIPTAPI_PRECHECKHEADER lua_getglobal(L, "core"); lua_getfield(L, -1, "registered_allow_player_inventory_actions"); pushPutTakeArguments("take", ma.from_inv, ma.from_list, ma.from_i, stack, player); runCallbacks(4, RUN_CALLBACKS_MODE_OR_SC); return lua_type(L, -1) == LUA_TNUMBER ? lua_tonumber(L, -1) : stack.count; } // Report moved items void ScriptApiPlayer::player_inventory_OnMove( const MoveAction &ma, int count, ServerActiveObject *player) { SCRIPTAPI_PRECHECKHEADER lua_getglobal(L, "core"); lua_getfield(L, -1, "registered_on_player_inventory_actions"); pushMoveArguments(ma, count, player); runCallbacks(4, RUN_CALLBACKS_MODE_FIRST); } // Report put items void ScriptApiPlayer::player_inventory_OnPut( const MoveAction &ma, const ItemStack &stack, ServerActiveObject *player) { SCRIPTAPI_PRECHECKHEADER lua_getglobal(L, "core"); lua_getfield(L, -1, "registered_on_player_inventory_actions"); pushPutTakeArguments("put", ma.to_inv, ma.to_list, ma.to_i, stack, player); runCallbacks(4, RUN_CALLBACKS_MODE_FIRST); } // Report taken items void ScriptApiPlayer::player_inventory_OnTake( const MoveAction &ma, const ItemStack &stack, ServerActiveObject *player) { SCRIPTAPI_PRECHECKHEADER lua_getglobal(L, "core"); lua_getfield(L, -1, "registered_on_player_inventory_actions"); pushPutTakeArguments("take", ma.from_inv, ma.from_list, ma.from_i, stack, player); runCallbacks(4, RUN_CALLBACKS_MODE_FIRST); } rder) { s32 x1 = rect.UpperLeftCorner.X; s32 y1 = rect.UpperLeftCorner.Y; s32 x2 = rect.LowerRightCorner.X; s32 y2 = rect.LowerRightCorner.Y; s32 border = 1; driver->draw2DRectangle(m_slotbordercolor, core::rect(v2s32(x1 - border, y1 - border), v2s32(x2 + border, y1)), NULL); driver->draw2DRectangle(m_slotbordercolor, core::rect(v2s32(x1 - border, y2), v2s32(x2 + border, y2 + border)), NULL); driver->draw2DRectangle(m_slotbordercolor, core::rect(v2s32(x1 - border, y1), v2s32(x1, y2)), NULL); driver->draw2DRectangle(m_slotbordercolor, core::rect(v2s32(x2, y1), v2s32(x2 + border, y2)), NULL); } if(phase == 1) { // Draw item stack if(selected) { item.takeItem(m_selected_amount); } if(!item.empty()) { drawItemStack(driver, m_font, item, rect, &AbsoluteClippingRect, m_gamedef, rotation_kind); } // Draw tooltip std::string tooltip_text = ""; if (hovering && !m_selected_item) tooltip_text = item.getDefinition(m_gamedef->idef()).description; if (tooltip_text != "") { std::vector tt_rows = str_split(tooltip_text, '\n'); m_tooltip_element->setBackgroundColor(m_default_tooltip_bgcolor); m_tooltip_element->setOverrideColor(m_default_tooltip_color); m_tooltip_element->setVisible(true); this->bringToFront(m_tooltip_element); m_tooltip_element->setText(utf8_to_wide(tooltip_text).c_str()); s32 tooltip_width = m_tooltip_element->getTextWidth() + m_btn_height; s32 tooltip_height = m_tooltip_element->getTextHeight() * tt_rows.size() + 5; v2u32 screenSize = driver->getScreenSize(); int tooltip_offset_x = m_btn_height; int tooltip_offset_y = m_btn_height; #ifdef __ANDROID__ tooltip_offset_x *= 3; tooltip_offset_y = 0; if (m_pointer.X > (s32)screenSize.X / 2) tooltip_offset_x = (tooltip_offset_x + tooltip_width) * -1; #endif s32 tooltip_x = m_pointer.X + tooltip_offset_x; s32 tooltip_y = m_pointer.Y + tooltip_offset_y; if (tooltip_x + tooltip_width > (s32)screenSize.X) tooltip_x = (s32)screenSize.X - tooltip_width - m_btn_height; if (tooltip_y + tooltip_height > (s32)screenSize.Y) tooltip_y = (s32)screenSize.Y - tooltip_height - m_btn_height; m_tooltip_element->setRelativePosition(core::rect( core::position2d(tooltip_x, tooltip_y), core::dimension2d(tooltip_width, tooltip_height))); } } } } void GUIFormSpecMenu::drawSelectedItem() { video::IVideoDriver* driver = Environment->getVideoDriver(); if (!m_selected_item) { drawItemStack(driver, m_font, ItemStack(), core::rect(v2s32(0, 0), v2s32(0, 0)), NULL, m_gamedef, IT_ROT_DRAGGED); return; } Inventory *inv = m_invmgr->getInventory(m_selected_item->inventoryloc); sanity_check(inv); InventoryList *list = inv->getList(m_selected_item->listname); sanity_check(list); ItemStack stack = list->getItem(m_selected_item->i); stack.count = m_selected_amount; core::rect imgrect(0,0,imgsize.X,imgsize.Y); core::rect rect = imgrect + (m_pointer - imgrect.getCenter()); drawItemStack(driver, m_font, stack, rect, NULL, m_gamedef, IT_ROT_DRAGGED); } void GUIFormSpecMenu::drawMenu() { if(m_form_src){ std::string newform = m_form_src->getForm(); if(newform != m_formspec_string){ m_formspec_string = newform; regenerateGui(m_screensize_old); } } gui::IGUISkin* skin = Environment->getSkin(); sanity_check(skin != NULL); gui::IGUIFont *old_font = skin->getFont(); skin->setFont(m_font); updateSelectedItem(); video::IVideoDriver* driver = Environment->getVideoDriver(); v2u32 screenSize = driver->getScreenSize(); core::rect allbg(0, 0, screenSize.X , screenSize.Y); if (m_bgfullscreen) driver->draw2DRectangle(m_bgcolor, allbg, &allbg); else driver->draw2DRectangle(m_bgcolor, AbsoluteRect, &AbsoluteClippingRect); m_tooltip_element->setVisible(false); /* Draw backgrounds */ for(u32 i=0; igetTexture(spec.name); if (texture != 0) { // Image size on screen core::rect imgrect(0, 0, spec.geom.X, spec.geom.Y); // Image rectangle on screen core::rect rect = imgrect + spec.pos; if (m_clipbackground) { core::dimension2d absrec_size = AbsoluteRect.getSize(); rect = core::rect(AbsoluteRect.UpperLeftCorner.X - spec.pos.X, AbsoluteRect.UpperLeftCorner.Y - spec.pos.Y, AbsoluteRect.UpperLeftCorner.X + absrec_size.Width + spec.pos.X, AbsoluteRect.UpperLeftCorner.Y + absrec_size.Height + spec.pos.Y); } const video::SColor color(255,255,255,255); const video::SColor colors[] = {color,color,color,color}; draw2DImageFilterScaled(driver, texture, rect, core::rect(core::position2d(0,0), core::dimension2di(texture->getOriginalSize())), NULL/*&AbsoluteClippingRect*/, colors, true); } else { errorstream << "GUIFormSpecMenu::drawMenu() Draw backgrounds unable to load texture:" << std::endl; errorstream << "\t" << spec.name << std::endl; } } /* Draw Boxes */ for(u32 i=0; i rect(spec.pos.X,spec.pos.Y, spec.pos.X + spec.geom.X,spec.pos.Y + spec.geom.Y); driver->draw2DRectangle(todraw, rect, 0); } /* Call base class */ gui::IGUIElement::draw(); /* Draw images */ for(u32 i=0; igetTexture(spec.name); if (texture != 0) { const core::dimension2d& img_origsize = texture->getOriginalSize(); // Image size on screen core::rect imgrect; if (spec.scale) imgrect = core::rect(0,0,spec.geom.X, spec.geom.Y); else { imgrect = core::rect(0,0,img_origsize.Width,img_origsize.Height); } // Image rectangle on screen core::rect rect = imgrect + spec.pos; const video::SColor color(255,255,255,255); const video::SColor colors[] = {color,color,color,color}; draw2DImageFilterScaled(driver, texture, rect, core::rect(core::position2d(0,0),img_origsize), NULL/*&AbsoluteClippingRect*/, colors, true); } else { errorstream << "GUIFormSpecMenu::drawMenu() Draw images unable to load texture:" << std::endl; errorstream << "\t" << spec.name << std::endl; } } /* Draw item images */ for(u32 i=0; iidef(); ItemStack item; item.deSerialize(spec.item_name, idef); core::rect imgrect(0, 0, spec.geom.X, spec.geom.Y); // Viewport rectangle on screen core::rect rect = imgrect + spec.pos; if (spec.parent_button && spec.parent_button->isPressed()) { #if (IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR < 8) rect += core::dimension2d( 0.05 * (float)rect.getWidth(), 0.05 * (float)rect.getHeight()); #else rect += core::dimension2d( skin->getSize(irr::gui::EGDS_BUTTON_PRESSED_IMAGE_OFFSET_X), skin->getSize(irr::gui::EGDS_BUTTON_PRESSED_IMAGE_OFFSET_Y)); #endif } drawItemStack(driver, m_font, item, rect, &AbsoluteClippingRect, m_gamedef, IT_ROT_NONE); } /* Draw items Phase 0: Item slot rectangles Phase 1: Item images; prepare tooltip */ bool item_hovered = false; int start_phase = 0; for (int phase = start_phase; phase <= 1; phase++) { for (u32 i = 0; i < m_inventorylists.size(); i++) { drawList(m_inventorylists[i], phase, item_hovered); } } if (!item_hovered) { drawItemStack(driver, m_font, ItemStack(), core::rect(v2s32(0, 0), v2s32(0, 0)), NULL, m_gamedef, IT_ROT_HOVERED); } /* TODO find way to show tooltips on touchscreen */ #ifndef HAVE_TOUCHSCREENGUI m_pointer = m_device->getCursorControl()->getPosition(); #endif /* Draw static text elements */ for (u32 i = 0; i < m_static_texts.size(); i++) { const StaticTextSpec &spec = m_static_texts[i]; core::rect rect = spec.rect; if (spec.parent_button && spec.parent_button->isPressed()) { #if (IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR < 8) rect += core::dimension2d( 0.05 * (float)rect.getWidth(), 0.05 * (float)rect.getHeight()); #else // Use image offset instead of text's because its a bit smaller // and fits better, also TEXT_OFFSET_X is always 0 rect += core::dimension2d( skin->getSize(irr::gui::EGDS_BUTTON_PRESSED_IMAGE_OFFSET_X), skin->getSize(irr::gui::EGDS_BUTTON_PRESSED_IMAGE_OFFSET_Y)); #endif } video::SColor color(255, 255, 255, 255); m_font->draw(spec.text.c_str(), rect, color, true, true, &rect); } /* Draw fields/buttons tooltips */ gui::IGUIElement *hovered = Environment->getRootGUIElement()->getElementFromPoint(m_pointer); if (hovered != NULL) { s32 id = hovered->getID(); u32 delta = 0; if (id == -1) { m_old_tooltip_id = id; m_old_tooltip = ""; } else { if (id == m_old_tooltip_id) { delta = porting::getDeltaMs(m_hovered_time, getTimeMs()); } else { m_hovered_time = getTimeMs(); m_old_tooltip_id = id; } } if (id != -1 && delta >= m_tooltip_show_delay) { for(std::vector::iterator iter = m_fields.begin(); iter != m_fields.end(); ++iter) { if ( (iter->fid == id) && (m_tooltips[iter->fname].tooltip != "") ){ if (m_old_tooltip != m_tooltips[iter->fname].tooltip) { m_old_tooltip = m_tooltips[iter->fname].tooltip; m_tooltip_element->setText(utf8_to_wide(m_tooltips[iter->fname].tooltip).c_str()); std::vector tt_rows = str_split(m_tooltips[iter->fname].tooltip, '\n'); s32 tooltip_width = m_tooltip_element->getTextWidth() + m_btn_height; s32 tooltip_height = m_tooltip_element->getTextHeight() * tt_rows.size() + 5; int tooltip_offset_x = m_btn_height; int tooltip_offset_y = m_btn_height; #ifdef __ANDROID__ tooltip_offset_x *= 3; tooltip_offset_y = 0; if (m_pointer.X > (s32)screenSize.X / 2) tooltip_offset_x = (tooltip_offset_x + tooltip_width) * -1; #endif s32 tooltip_x = m_pointer.X + tooltip_offset_x; s32 tooltip_y = m_pointer.Y + tooltip_offset_y; if (tooltip_x + tooltip_width > (s32)screenSize.X) tooltip_x = (s32)screenSize.X - tooltip_width - m_btn_height; if (tooltip_y + tooltip_height > (s32)screenSize.Y) tooltip_y = (s32)screenSize.Y - tooltip_height - m_btn_height; m_tooltip_element->setRelativePosition(core::rect( core::position2d(tooltip_x, tooltip_y), core::dimension2d(tooltip_width, tooltip_height))); } m_tooltip_element->setBackgroundColor(m_tooltips[iter->fname].bgcolor); m_tooltip_element->setOverrideColor(m_tooltips[iter->fname].color); m_tooltip_element->setVisible(true); this->bringToFront(m_tooltip_element); break; } } } } /* Draw dragged item stack */ drawSelectedItem(); skin->setFont(old_font); } void GUIFormSpecMenu::updateSelectedItem() { // If the selected stack has become empty for some reason, deselect it. // If the selected stack has become inaccessible, deselect it. // If the selected stack has become smaller, adjust m_selected_amount. ItemStack selected = verifySelectedItem(); // WARNING: BLACK MAGIC // See if there is a stack suited for our current guess. // If such stack does not exist, clear the guess. if(m_selected_content_guess.name != "" && selected.name == m_selected_content_guess.name && selected.count == m_selected_content_guess.count){ // Selected item fits the guess. Skip the black magic. } else if(m_selected_content_guess.name != ""){ bool found = false; for(u32 i=0; igetInventory(s.inventoryloc); if(!inv) continue; InventoryList *list = inv->getList(s.listname); if(!list) continue; for(s32 i=0; i= list->getSize()) continue; ItemStack stack = list->getItem(item_i); if(stack.name == m_selected_content_guess.name && stack.count == m_selected_content_guess.count){ found = true; infostream<<"Client: Changing selected content guess to " <getInventory(s.inventoryloc); InventoryList *list = inv->getList("craftresult"); if(list && list->getSize() >= 1 && !list->getItem(0).empty()) { m_selected_item = new ItemSpec; m_selected_item->inventoryloc = s.inventoryloc; m_selected_item->listname = "craftresult"; m_selected_item->i = 0; m_selected_amount = 0; m_selected_dragging = false; break; } } } } // If craftresult is selected, keep the whole stack selected if(m_selected_item && m_selected_item->listname == "craftresult") { m_selected_amount = verifySelectedItem().count; } } ItemStack GUIFormSpecMenu::verifySelectedItem() { // If the selected stack has become empty for some reason, deselect it. // If the selected stack has become inaccessible, deselect it. // If the selected stack has become smaller, adjust m_selected_amount. // Return the selected stack. if(m_selected_item) { if(m_selected_item->isValid()) { Inventory *inv = m_invmgr->getInventory(m_selected_item->inventoryloc); if(inv) { InventoryList *list = inv->getList(m_selected_item->listname); if(list && (u32) m_selected_item->i < list->getSize()) { ItemStack stack = list->getItem(m_selected_item->i); if(m_selected_amount > stack.count) m_selected_amount = stack.count; if(!stack.empty()) return stack; } } } // selection was not valid delete m_selected_item; m_selected_item = NULL; m_selected_amount = 0; m_selected_dragging = false; } return ItemStack(); } void GUIFormSpecMenu::acceptInput(FormspecQuitMode quitmode=quit_mode_no) { if(m_text_dst) { StringMap fields; if (quitmode == quit_mode_accept) { fields["quit"] = "true"; } if (quitmode == quit_mode_cancel) { fields["quit"] = "true"; m_text_dst->gotText(fields); return; } if (current_keys_pending.key_down) { fields["key_down"] = "true"; current_keys_pending.key_down = false; } if (current_keys_pending.key_up) { fields["key_up"] = "true"; current_keys_pending.key_up = false; } if (current_keys_pending.key_enter) { fields["key_enter"] = "true"; current_keys_pending.key_enter = false; } if (current_keys_pending.key_escape) { fields["key_escape"] = "true"; current_keys_pending.key_escape = false; } for(unsigned int i=0; icheckEvent(); } } else if(s.ftype == f_DropDown) { // no dynamic cast possible due to some distributions shipped // without rtti support in irrlicht IGUIElement * element = getElementFromId(s.fid); gui::IGUIComboBox *e = NULL; if ((element) && (element->getType() == gui::EGUIET_COMBO_BOX)) { e = static_cast(element); } s32 selected = e->getSelected(); if (selected >= 0) { fields[name] = wide_to_utf8(e->getItem(selected)); } } else if (s.ftype == f_TabHeader) { // no dynamic cast possible due to some distributions shipped // without rtti support in irrlicht IGUIElement * element = getElementFromId(s.fid); gui::IGUITabControl *e = NULL; if ((element) && (element->getType() == gui::EGUIET_TAB_CONTROL)) { e = static_cast(element); } if (e != 0) { std::stringstream ss; ss << (e->getActiveTab() +1); fields[name] = ss.str(); } } else if (s.ftype == f_CheckBox) { // no dynamic cast possible due to some distributions shipped // without rtti support in irrlicht IGUIElement * element = getElementFromId(s.fid); gui::IGUICheckBox *e = NULL; if ((element) && (element->getType() == gui::EGUIET_CHECK_BOX)) { e = static_cast(element); } if (e != 0) { if (e->isChecked()) fields[name] = "true"; else fields[name] = "false"; } } else if (s.ftype == f_ScrollBar) { // no dynamic cast possible due to some distributions shipped // without rtti support in irrlicht IGUIElement * element = getElementFromId(s.fid); gui::IGUIScrollBar *e = NULL; if ((element) && (element->getType() == gui::EGUIET_SCROLL_BAR)) { e = static_cast(element); } if (e != 0) { std::stringstream os; os << e->getPos(); if (s.fdefault == L"Changed") fields[name] = "CHG:" + os.str(); else fields[name] = "VAL:" + os.str(); } } else { IGUIElement* e = getElementFromId(s.fid); if(e != NULL) { fields[name] = wide_to_utf8(e->getText()); } } } } m_text_dst->gotText(fields); } } static bool isChild(gui::IGUIElement * tocheck, gui::IGUIElement * parent) { while(tocheck != NULL) { if (tocheck == parent) { return true; } tocheck = tocheck->getParent(); } return false; } bool GUIFormSpecMenu::preprocessEvent(const SEvent& event) { // The IGUITabControl renders visually using the skin's selected // font, which we override for the duration of form drawing, // but computes tab hotspots based on how it would have rendered // using the font that is selected at the time of button release. // To make these two consistent, temporarily override the skin's // font while the IGUITabControl is processing the event. if (event.EventType == EET_MOUSE_INPUT_EVENT && event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP) { s32 x = event.MouseInput.X; s32 y = event.MouseInput.Y; gui::IGUIElement *hovered = Environment->getRootGUIElement()->getElementFromPoint( core::position2d(x, y)); if (hovered && isMyChild(hovered) && hovered->getType() == gui::EGUIET_TAB_CONTROL) { gui::IGUISkin* skin = Environment->getSkin(); sanity_check(skin != NULL); gui::IGUIFont *old_font = skin->getFont(); skin->setFont(m_font); bool retval = hovered->OnEvent(event); skin->setFont(old_font); return retval; } } // Fix Esc/Return key being eaten by checkboxen and tables if(event.EventType==EET_KEY_INPUT_EVENT) { KeyPress kp(event.KeyInput); if (kp == EscapeKey || kp == CancelKey || kp == getKeySetting("keymap_inventory") || event.KeyInput.Key==KEY_RETURN) { gui::IGUIElement *focused = Environment->getFocus(); if (focused && isMyChild(focused) && (focused->getType() == gui::EGUIET_LIST_BOX || focused->getType() == gui::EGUIET_CHECK_BOX)) { OnEvent(event); return true; } } } // Mouse wheel events: send to hovered element instead of focused if(event.EventType==EET_MOUSE_INPUT_EVENT && event.MouseInput.Event == EMIE_MOUSE_WHEEL) { s32 x = event.MouseInput.X; s32 y = event.MouseInput.Y; gui::IGUIElement *hovered = Environment->getRootGUIElement()->getElementFromPoint( core::position2d(x, y)); if (hovered && isMyChild(hovered)) { hovered->OnEvent(event); return true; } } if (event.EventType == EET_MOUSE_INPUT_EVENT) { s32 x = event.MouseInput.X; s32 y = event.MouseInput.Y; gui::IGUIElement *hovered = Environment->getRootGUIElement()->getElementFromPoint( core::position2d(x, y)); if (event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN) { m_old_tooltip_id = -1; m_old_tooltip = ""; } if (!isChild(hovered,this)) { if (DoubleClickDetection(event)) { return true; } } } #ifdef __ANDROID__ // display software keyboard when clicking edit boxes if (event.EventType == EET_MOUSE_INPUT_EVENT && event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN) { gui::IGUIElement *hovered = Environment->getRootGUIElement()->getElementFromPoint( core::position2d(event.MouseInput.X, event.MouseInput.Y)); if ((hovered) && (hovered->getType() == irr::gui::EGUIET_EDIT_BOX)) { bool retval = hovered->OnEvent(event); if (retval) { Environment->setFocus(hovered); } m_JavaDialogFieldName = getNameByID(hovered->getID()); std::string message = gettext("Enter "); std::string label = wide_to_utf8(getLabelByID(hovered->getID())); if (label == "") { label = "text"; } message += gettext(label) + ":"; /* single line text input */ int type = 2; /* multi line text input */ if (((gui::IGUIEditBox*) hovered)->isMultiLineEnabled()) { type = 1; } /* passwords are always single line */ if (((gui::IGUIEditBox*) hovered)->isPasswordBox()) { type = 3; } porting::showInputDialog(gettext("ok"), "", wide_to_utf8(((gui::IGUIEditBox*) hovered)->getText()), type); return retval; } } if (event.EventType == EET_TOUCH_INPUT_EVENT) { SEvent translated; memset(&translated, 0, sizeof(SEvent)); translated.EventType = EET_MOUSE_INPUT_EVENT; gui::IGUIElement* root = Environment->getRootGUIElement(); if (!root) { errorstream << "GUIFormSpecMenu::preprocessEvent unable to get root element" << std::endl; return false; } gui::IGUIElement* hovered = root->getElementFromPoint( core::position2d( event.TouchInput.X, event.TouchInput.Y)); translated.MouseInput.X = event.TouchInput.X; translated.MouseInput.Y = event.TouchInput.Y; translated.MouseInput.Control = false; bool dont_send_event = false; if (event.TouchInput.touchedCount == 1) { switch (event.TouchInput.Event) { case ETIE_PRESSED_DOWN: m_pointer = v2s32(event.TouchInput.X,event.TouchInput.Y); translated.MouseInput.Event = EMIE_LMOUSE_PRESSED_DOWN; translated.MouseInput.ButtonStates = EMBSM_LEFT; m_down_pos = m_pointer; break; case ETIE_MOVED: m_pointer = v2s32(event.TouchInput.X,event.TouchInput.Y); translated.MouseInput.Event = EMIE_MOUSE_MOVED; translated.MouseInput.ButtonStates = EMBSM_LEFT; break; case ETIE_LEFT_UP: translated.MouseInput.Event = EMIE_LMOUSE_LEFT_UP; translated.MouseInput.ButtonStates = 0; hovered = root->getElementFromPoint(m_down_pos); /* we don't have a valid pointer element use last * known pointer pos */ translated.MouseInput.X = m_pointer.X; translated.MouseInput.Y = m_pointer.Y; /* reset down pos */ m_down_pos = v2s32(0,0); break; default: dont_send_event = true; //this is not supposed to happen errorstream << "GUIFormSpecMenu::preprocessEvent unexpected usecase Event=" << event.TouchInput.Event << std::endl; } } else if ( (event.TouchInput.touchedCount == 2) && (event.TouchInput.Event == ETIE_PRESSED_DOWN) ) { hovered = root->getElementFromPoint(m_down_pos); translated.MouseInput.Event = EMIE_RMOUSE_PRESSED_DOWN; translated.MouseInput.ButtonStates = EMBSM_LEFT | EMBSM_RIGHT; translated.MouseInput.X = m_pointer.X; translated.MouseInput.Y = m_pointer.Y; if (hovered) { hovered->OnEvent(translated); } translated.MouseInput.Event = EMIE_RMOUSE_LEFT_UP; translated.MouseInput.ButtonStates = EMBSM_LEFT; if (hovered) { hovered->OnEvent(translated); } dont_send_event = true; } /* ignore unhandled 2 touch events ... accidental moving for example */ else if (event.TouchInput.touchedCount == 2) { dont_send_event = true; } else if (event.TouchInput.touchedCount > 2) { errorstream << "GUIFormSpecMenu::preprocessEvent to many multitouch events " << event.TouchInput.touchedCount << " ignoring them" << std::endl; } if (dont_send_event) { return true; } /* check if translated event needs to be preprocessed again */ if (preprocessEvent(translated)) { return true; } if (hovered) { grab(); bool retval = hovered->OnEvent(translated); if (event.TouchInput.Event == ETIE_LEFT_UP) { /* reset pointer */ m_pointer = v2s32(0,0); } drop(); return retval; } } #endif return false; } /******************************************************************************/ bool GUIFormSpecMenu::DoubleClickDetection(const SEvent event) { /* The following code is for capturing double-clicks of the mouse button * and translating the double-click into an EET_KEY_INPUT_EVENT event * -- which closes the form -- under some circumstances. * * There have been many github issues reporting this as a bug even though it * was an intended feature. For this reason, remapping the double-click as * an ESC must be explicitly set when creating this class via the * /p remap_dbl_click parameter of the constructor. */ if (!m_remap_dbl_click) return false; if (event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN) { m_doubleclickdetect[0].pos = m_doubleclickdetect[1].pos; m_doubleclickdetect[0].time = m_doubleclickdetect[1].time; m_doubleclickdetect[1].pos = m_pointer; m_doubleclickdetect[1].time = getTimeMs(); } else if (event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP) { u32 delta = porting::getDeltaMs(m_doubleclickdetect[0].time, getTimeMs()); if (delta > 400) { return false; } double squaredistance = m_doubleclickdetect[0].pos .getDistanceFromSQ(m_doubleclickdetect[1].pos); if (squaredistance > (30*30)) { return false; } SEvent* translated = new SEvent(); assert(translated != 0); //translate doubleclick to escape memset(translated, 0, sizeof(SEvent)); translated->EventType = irr::EET_KEY_INPUT_EVENT; translated->KeyInput.Key = KEY_ESCAPE; translated->KeyInput.Control = false; translated->KeyInput.Shift = false; translated->KeyInput.PressedDown = true; translated->KeyInput.Char = 0; OnEvent(*translated); // no need to send the key up event as we're already deleted // and no one else did notice this event delete translated; return true; } return false; } bool GUIFormSpecMenu::OnEvent(const SEvent& event) { if (event.EventType==EET_KEY_INPUT_EVENT) { KeyPress kp(event.KeyInput); if (event.KeyInput.PressedDown && ( (kp == EscapeKey) || (kp == getKeySetting("keymap_inventory")) || (kp == CancelKey))) { if (m_allowclose) { doPause = false; acceptInput(quit_mode_cancel); quitMenu(); } else { m_text_dst->gotText(L"MenuQuit"); } return true; } else if (m_client != NULL && event.KeyInput.PressedDown && (kp == getKeySetting("keymap_screenshot"))) { m_client->makeScreenshot(m_device); } if (event.KeyInput.PressedDown && (event.KeyInput.Key==KEY_RETURN || event.KeyInput.Key==KEY_UP || event.KeyInput.Key==KEY_DOWN) ) { switch (event.KeyInput.Key) { case KEY_RETURN: current_keys_pending.key_enter = true; break; case KEY_UP: current_keys_pending.key_up = true; break; case KEY_DOWN: current_keys_pending.key_down = true; break; break; default: //can't happen at all! FATAL_ERROR("Reached a source line that can't ever been reached"); break; } if (current_keys_pending.key_enter && m_allowclose) { acceptInput(quit_mode_accept); quitMenu(); } else { acceptInput(); } return true; } } /* Mouse event other than movement, or crossing the border of inventory field while holding right mouse button */ if (event.EventType == EET_MOUSE_INPUT_EVENT && (event.MouseInput.Event != EMIE_MOUSE_MOVED || (event.MouseInput.Event == EMIE_MOUSE_MOVED && event.MouseInput.isRightPressed() && getItemAtPos(m_pointer).i != getItemAtPos(m_old_pointer).i))) { // Get selected item and hovered/clicked item (s) m_old_tooltip_id = -1; updateSelectedItem(); ItemSpec s = getItemAtPos(m_pointer); Inventory *inv_selected = NULL; Inventory *inv_s = NULL; InventoryList *list_s = NULL; if (m_selected_item) { inv_selected = m_invmgr->getInventory(m_selected_item->inventoryloc); sanity_check(inv_selected); sanity_check(inv_selected->getList(m_selected_item->listname) != NULL); } u32 s_count = 0; if (s.isValid()) do { // breakable inv_s = m_invmgr->getInventory(s.inventoryloc); if (!inv_s) { errorstream << "InventoryMenu: The selected inventory location " << "\"" << s.inventoryloc.dump() << "\" doesn't exist" << std::endl; s.i = -1; // make it invalid again break; } list_s = inv_s->getList(s.listname); if (list_s == NULL) { verbosestream << "InventoryMenu: The selected inventory list \"" << s.listname << "\" does not exist" << std::endl; s.i = -1; // make it invalid again break; } if ((u32)s.i >= list_s->getSize()) { infostream << "InventoryMenu: The selected inventory list \"" << s.listname << "\" is too small (i=" << s.i << ", size=" << list_s->getSize() << ")" << std::endl; s.i = -1; // make it invalid again break; } s_count = list_s->getItem(s.i).count; } while(0); bool identical = (m_selected_item != NULL) && s.isValid() && (inv_selected == inv_s) && (m_selected_item->listname == s.listname) && (m_selected_item->i == s.i); // buttons: 0 = left, 1 = right, 2 = middle // up/down: 0 = down (press), 1 = up (release), 2 = unknown event, -1 movement int button = 0; int updown = 2; if (event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN) { button = 0; updown = 0; } else if (event.MouseInput.Event == EMIE_RMOUSE_PRESSED_DOWN) { button = 1; updown = 0; } else if (event.MouseInput.Event == EMIE_MMOUSE_PRESSED_DOWN) { button = 2; updown = 0; } else if (event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP) { button = 0; updown = 1; } else if (event.MouseInput.Event == EMIE_RMOUSE_LEFT_UP) { button = 1; updown = 1; } else if (event.MouseInput.Event == EMIE_MMOUSE_LEFT_UP) { button = 2; updown = 1; } else if (event.MouseInput.Event == EMIE_MOUSE_MOVED) { updown = -1;} // Set this number to a positive value to generate a move action // from m_selected_item to s. u32 move_amount = 0; // Set this number to a positive value to generate a move action // from s to the next inventory ring. u32 shift_move_amount = 0; // Set this number to a positive value to generate a drop action // from m_selected_item. u32 drop_amount = 0; // Set this number to a positive value to generate a craft action at s. u32 craft_amount = 0; if (updown == 0) { // Some mouse button has been pressed //infostream<<"Mouse button "<= 1); if (s.isValid()) { // Clicked a slot: move if (button == 1) // right move_amount = 1; else if (button == 2) // middle move_amount = MYMIN(m_selected_amount, 10); else // left move_amount = m_selected_amount; if (identical) { if (move_amount >= m_selected_amount) m_selected_amount = 0; else m_selected_amount -= move_amount; move_amount = 0; } } else if (!getAbsoluteClippingRect().isPointInside(m_pointer)) { // Clicked outside of the window: drop if (button == 1) // right drop_amount = 1; else if (button == 2) // middle drop_amount = MYMIN(m_selected_amount, 10); else // left drop_amount = m_selected_amount; } } } else if (updown == 1) { // Some mouse button has been released //infostream<<"Mouse button "<getList(m_selected_item->listname); InventoryList *list_to = list_s; assert(list_from && list_to); ItemStack stack_from = list_from->getItem(m_selected_item->i); ItemStack stack_to = list_to->getItem(s.i); if (stack_to.empty() || stack_to.name == stack_from.name) move_amount = 1; } } } // Possibly send inventory action to server if (move_amount > 0) { // Send IACTION_MOVE assert(m_selected_item && m_selected_item->isValid()); assert(s.isValid()); assert(inv_selected && inv_s); InventoryList *list_from = inv_selected->getList(m_selected_item->listname); InventoryList *list_to = list_s; assert(list_from && list_to); ItemStack stack_from = list_from->getItem(m_selected_item->i); ItemStack stack_to = list_to->getItem(s.i); // Check how many items can be moved move_amount = stack_from.count = MYMIN(move_amount, stack_from.count); ItemStack leftover = stack_to.addItem(stack_from, m_gamedef->idef()); // If source stack cannot be added to destination stack at all, // they are swapped if ((leftover.count == stack_from.count) && (leftover.name == stack_from.name)) { m_selected_amount = stack_to.count; // In case the server doesn't directly swap them but instead // moves stack_to somewhere else, set this m_selected_content_guess = stack_to; m_selected_content_guess_inventory = s.inventoryloc; } // Source stack goes fully into destination stack else if (leftover.empty()) { m_selected_amount -= move_amount; m_selected_content_guess = ItemStack(); // Clear } // Source stack goes partly into destination stack else { move_amount -= leftover.count; m_selected_amount -= move_amount; m_selected_content_guess = ItemStack(); // Clear } infostream << "Handing IACTION_MOVE to manager" << std::endl; IMoveAction *a = new IMoveAction(); a->count = move_amount; a->from_inv = m_selected_item->inventoryloc; a->from_list = m_selected_item->listname; a->from_i = m_selected_item->i; a->to_inv = s.inventoryloc; a->to_list = s.listname; a->to_i = s.i; m_invmgr->inventoryAction(a); } else if (shift_move_amount > 0) { u32 mis = m_inventory_rings.size(); u32 i = 0; for (; i < mis; i++) { const ListRingSpec &sp = m_inventory_rings[i]; if (sp.inventoryloc == s.inventoryloc && sp.listname == s.listname) break; } do { if (i >= mis) // if not found break; u32 to_inv_ind = (i + 1) % mis; const ListRingSpec &to_inv_sp = m_inventory_rings[to_inv_ind]; InventoryList *list_from = list_s; if (!s.isValid()) break; Inventory *inv_to = m_invmgr->getInventory(to_inv_sp.inventoryloc); if (!inv_to) break; InventoryList *list_to = inv_to->getList(to_inv_sp.listname); if (!list_to) break; ItemStack stack_from = list_from->getItem(s.i); assert(shift_move_amount <= stack_from.count); if (m_client->getProtoVersion() >= 25) { infostream << "Handing IACTION_MOVE to manager" << std::endl; IMoveAction *a = new IMoveAction(); a->count = shift_move_amount; a->from_inv = s.inventoryloc; a->from_list = s.listname; a->from_i = s.i; a->to_inv = to_inv_sp.inventoryloc; a->to_list = to_inv_sp.listname; a->move_somewhere = true; m_invmgr->inventoryAction(a); } else { // find a place (or more than one) to add the new item u32 ilt_size = list_to->getSize(); ItemStack leftover; for (u32 slot_to = 0; slot_to < ilt_size && shift_move_amount > 0; slot_to++) { list_to->itemFits(slot_to, stack_from, &leftover); if (leftover.count < stack_from.count) { infostream << "Handing IACTION_MOVE to manager" << std::endl; IMoveAction *a = new IMoveAction(); a->count = MYMIN(shift_move_amount, (u32) (stack_from.count - leftover.count)); shift_move_amount -= a->count; a->from_inv = s.inventoryloc; a->from_list = s.listname; a->from_i = s.i; a->to_inv = to_inv_sp.inventoryloc; a->to_list = to_inv_sp.listname; a->to_i = slot_to; m_invmgr->inventoryAction(a); stack_from = leftover; } } } } while (0); } else if (drop_amount > 0) { m_selected_content_guess = ItemStack(); // Clear // Send IACTION_DROP assert(m_selected_item && m_selected_item->isValid()); assert(inv_selected); InventoryList *list_from = inv_selected->getList(m_selected_item->listname); assert(list_from); ItemStack stack_from = list_from->getItem(m_selected_item->i); // Check how many items can be dropped drop_amount = stack_from.count = MYMIN(drop_amount, stack_from.count); assert(drop_amount > 0 && drop_amount <= m_selected_amount); m_selected_amount -= drop_amount; infostream << "Handing IACTION_DROP to manager" << std::endl; IDropAction *a = new IDropAction(); a->count = drop_amount; a->from_inv = m_selected_item->inventoryloc; a->from_list = m_selected_item->listname; a->from_i = m_selected_item->i; m_invmgr->inventoryAction(a); } else if (craft_amount > 0) { m_selected_content_guess = ItemStack(); // Clear // Send IACTION_CRAFT assert(s.isValid()); assert(inv_s); infostream << "Handing IACTION_CRAFT to manager" << std::endl; ICraftAction *a = new ICraftAction(); a->count = craft_amount; a->craft_inv = s.inventoryloc; m_invmgr->inventoryAction(a); } // If m_selected_amount has been decreased to zero, deselect if (m_selected_amount == 0) { delete m_selected_item; m_selected_item = NULL; m_selected_amount = 0; m_selected_dragging = false; m_selected_content_guess = ItemStack(); } m_old_pointer = m_pointer; } if (event.EventType == EET_GUI_EVENT) { if (event.GUIEvent.EventType == gui::EGET_TAB_CHANGED && isVisible()) { // find the element that was clicked for (unsigned int i=0; igetID())) { s.send = true; acceptInput(); s.send = false; return true; } } } if (event.GUIEvent.EventType == gui::EGET_ELEMENT_FOCUS_LOST && isVisible()) { if (!canTakeFocus(event.GUIEvent.Element)) { infostream<<"GUIFormSpecMenu: Not allowing focus change." <getID(); if (btn_id == 257) { if (m_allowclose) { acceptInput(quit_mode_accept); quitMenu(); } else { acceptInput(); m_text_dst->gotText(L"ExitButton"); } // quitMenu deallocates menu return true; } // find the element that was clicked for (u32 i = 0; i < m_fields.size(); i++) { FieldSpec &s = m_fields[i]; // if its a button, set the send field so // lua knows which button was pressed if (((s.ftype == f_Button) || (s.ftype == f_CheckBox)) && (s.fid == event.GUIEvent.Caller->getID())) { s.send = true; if (s.is_exit) { if (m_allowclose) { acceptInput(quit_mode_accept); quitMenu(); } else { m_text_dst->gotText(L"ExitButton"); } return true; } else { acceptInput(quit_mode_no); s.send = false; return true; } } else if ((s.ftype == f_DropDown) && (s.fid == event.GUIEvent.Caller->getID())) { // only send the changed dropdown for (u32 i = 0; i < m_fields.size(); i++) { FieldSpec &s2 = m_fields[i]; if (s2.ftype == f_DropDown) { s2.send = false; } } s.send = true; acceptInput(quit_mode_no); // revert configuration to make sure dropdowns are sent on // regular button click for (u32 i = 0; i < m_fields.size(); i++) { FieldSpec &s2 = m_fields[i]; if (s2.ftype == f_DropDown) { s2.send = true; } } return true; } else if ((s.ftype == f_ScrollBar) && (s.fid == event.GUIEvent.Caller->getID())) { s.fdefault = L"Changed"; acceptInput(quit_mode_no); s.fdefault = L""; } } } if (event.GUIEvent.EventType == gui::EGET_EDITBOX_ENTER) { if (event.GUIEvent.Caller->getID() > 257) { if (m_allowclose) { acceptInput(quit_mode_accept); quitMenu(); } else { current_keys_pending.key_enter = true; acceptInput(); } // quitMenu deallocates menu return true; } } if (event.GUIEvent.EventType == gui::EGET_TABLE_CHANGED) { int current_id = event.GUIEvent.Caller->getID(); if (current_id > 257) { // find the element that was clicked for (u32 i = 0; i < m_fields.size(); i++) { FieldSpec &s = m_fields[i]; // if it's a table, set the send field // so lua knows which table was changed if ((s.ftype == f_Table) && (s.fid == current_id)) { s.send = true; acceptInput(); s.send=false; } } return true; } } } return Parent ? Parent->OnEvent(event) : false; } /** * get name of element by element id * @param id of element * @return name string or empty string */ std::string GUIFormSpecMenu::getNameByID(s32 id) { for(std::vector::iterator iter = m_fields.begin(); iter != m_fields.end(); ++iter) { if (iter->fid == id) { return iter->fname; } } return ""; } /** * get label of element by id * @param id of element * @return label string or empty string */ std::wstring GUIFormSpecMenu::getLabelByID(s32 id) { for(std::vector::iterator iter = m_fields.begin(); iter != m_fields.end(); ++iter) { if (iter->fid == id) { return iter->flabel; } } return L""; }