X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fgui%2FguiFormSpecMenu.cpp;h=7e3ad3b15119cfe23a4acbf7b8ec8dce2bc34441;hb=b2f3f663858e6d2a2174066e425bb6f2edea910b;hp=92e6547659d9e05d9aa45cebd8b1392e6dc9c902;hpb=f409f4476539f32dcce3ff6832be4bc48bd25634;p=minetest.git diff --git a/src/gui/guiFormSpecMenu.cpp b/src/gui/guiFormSpecMenu.cpp index 92e654765..7e3ad3b15 100644 --- a/src/gui/guiFormSpecMenu.cpp +++ b/src/gui/guiFormSpecMenu.cpp @@ -21,21 +21,20 @@ with this program; if not, write to the Free Software Foundation, Inc., #include #include #include -#include #include +#include #include "guiFormSpecMenu.h" -#include "guiTable.h" #include "constants.h" #include "gamedef.h" #include "client/keycode.h" #include "util/strfnd.h" +#include #include +#include #include -#include #include #include #include -#include #include "client/renderingengine.h" #include "log.h" #include "client/tile.h" // ITextureSource @@ -54,8 +53,18 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "util/string.h" // for parseColorString() #include "irrlicht_changes/static_text.h" #include "client/guiscalingfilter.h" +#include "guiAnimatedImage.h" +#include "guiBackgroundImage.h" +#include "guiBox.h" +#include "guiButton.h" +#include "guiButtonImage.h" +#include "guiButtonItemImage.h" #include "guiEditBoxWithScrollbar.h" +#include "guiInventoryList.h" +#include "guiItemImage.h" +#include "guiScrollContainer.h" #include "intlGUIEditBox.h" +#include "guiHyperText.h" #define MY_CHECKPOS(a,b) \ if (v_pos.size() != 2) { \ @@ -66,8 +75,8 @@ with this program; if not, write to the Free Software Foundation, Inc., #define MY_CHECKGEOM(a,b) \ if (v_geom.size() != 2) { \ - errorstream<< "Invalid pos for element " << a << "specified: \"" \ - << parts[b] << "\"" << std::endl; \ + errorstream<< "Invalid geometry for element " << a << \ + "specified: \"" << parts[b] << "\"" << std::endl; \ return; \ } /* @@ -86,29 +95,21 @@ inline u32 clamp_u8(s32 value) GUIFormSpecMenu::GUIFormSpecMenu(JoystickController *joystick, gui::IGUIElement *parent, s32 id, IMenuManager *menumgr, Client *client, ISimpleTextureSource *tsrc, IFormSource *fsrc, TextDest *tdst, - std::string formspecPrepend, - bool remap_dbl_click): - GUIModalMenu(RenderingEngine::get_gui_env(), parent, id, menumgr), + const std::string &formspecPrepend, bool remap_dbl_click): + GUIModalMenu(RenderingEngine::get_gui_env(), parent, id, menumgr, remap_dbl_click), m_invmgr(client), m_tsrc(tsrc), m_client(client), m_formspec_prepend(formspecPrepend), m_form_src(fsrc), m_text_dst(tdst), - m_joystick(joystick), - m_remap_dbl_click(remap_dbl_click) + m_joystick(joystick) { 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"); m_tooltip_append_itemname = g_settings->getBool("tooltip_append_itemname"); } @@ -117,9 +118,22 @@ GUIFormSpecMenu::~GUIFormSpecMenu() { removeChildren(); - for (auto &table_it : m_tables) { + for (auto &table_it : m_tables) table_it.second->drop(); - } + for (auto &inventorylist_it : m_inventorylists) + inventorylist_it->drop(); + for (auto &checkbox_it : m_checkboxes) + checkbox_it.second->drop(); + for (auto &scrollbar_it : m_scrollbars) + scrollbar_it.second->drop(); + for (auto &background_it : m_backgrounds) + background_it->drop(); + for (auto &tooltip_rect_it : m_tooltip_rects) + tooltip_rect_it.first->drop(); + for (auto &clickthrough_it : m_clickthrough_elements) + clickthrough_it->drop(); + for (auto &scroll_container_it : m_scroll_containers) + scroll_container_it.second->drop(); delete m_selected_item; delete m_form_src; @@ -154,16 +168,15 @@ void GUIFormSpecMenu::removeChildren() { const core::list &children = getChildren(); - while(!children.empty()) { + while (!children.empty()) { (*children.getLast())->remove(); } - if(m_tooltip_element) { + if (m_tooltip_element) { m_tooltip_element->remove(); m_tooltip_element->drop(); - m_tooltip_element = NULL; + m_tooltip_element = nullptr; } - } void GUIFormSpecMenu::setInitialFocus() @@ -255,14 +268,9 @@ std::vector* GUIFormSpecMenu::getDropDownValues(const std::string & return NULL; } -v2s32 GUIFormSpecMenu::getElementBasePos(bool absolute, - const std::vector *v_pos) +v2s32 GUIFormSpecMenu::getElementBasePos(const std::vector *v_pos) { - v2s32 pos = padding; - if (absolute) - pos += AbsoluteRect.UpperLeftCorner; - - v2f32 pos_f = v2f32(pos.X, pos.Y) + pos_offset * spacing; + v2f32 pos_f = v2f32(padding.X, padding.Y) + pos_offset * spacing; if (v_pos) { pos_f.X += stof((*v_pos)[0]) * spacing.X; pos_f.Y += stof((*v_pos)[1]) * spacing.Y; @@ -270,6 +278,17 @@ v2s32 GUIFormSpecMenu::getElementBasePos(bool absolute, return v2s32(pos_f.X, pos_f.Y); } +v2s32 GUIFormSpecMenu::getRealCoordinateBasePos(const std::vector &v_pos) +{ + return v2s32((stof(v_pos[0]) + pos_offset.X) * imgsize.X, + (stof(v_pos[1]) + pos_offset.Y) * imgsize.Y); +} + +v2s32 GUIFormSpecMenu::getRealCoordinateGeometry(const std::vector &v_geom) +{ + return v2s32(stof(v_geom[0]) * imgsize.X, stof(v_geom[1]) * imgsize.Y); +} + void GUIFormSpecMenu::parseSize(parserData* data, const std::string &element) { std::vector parts = split(element,','); @@ -306,8 +325,8 @@ void GUIFormSpecMenu::parseContainer(parserData* data, const std::string &elemen parts[1] = parts[1].substr(0, parts[1].find(';')); container_stack.push(pos_offset); - pos_offset.X += MYMAX(0, stof(parts[0])); - pos_offset.Y += MYMAX(0, stof(parts[1])); + pos_offset.X += stof(parts[0]); + pos_offset.Y += stof(parts[1]); return; } errorstream<< "Invalid container start element (" << parts.size() << "): '" << element << "'" << std::endl; @@ -323,7 +342,103 @@ void GUIFormSpecMenu::parseContainerEnd(parserData* data) } } -void GUIFormSpecMenu::parseList(parserData* data, const std::string &element) +void GUIFormSpecMenu::parseScrollContainer(parserData *data, const std::string &element) +{ + std::vector parts = split(element, ';'); + + if (parts.size() < 4 || + (parts.size() > 5 && m_formspec_version <= FORMSPEC_API_VERSION)) { + errorstream << "Invalid scroll_container start element (" << parts.size() + << "): '" << element << "'" << std::endl; + return; + } + + std::vector v_pos = split(parts[0], ','); + std::vector v_geom = split(parts[1], ','); + std::string scrollbar_name = parts[2]; + std::string orientation = parts[3]; + f32 scroll_factor = 0.1f; + if (parts.size() >= 5 && !parts[4].empty()) + scroll_factor = stof(parts[4]); + + MY_CHECKPOS("scroll_container", 0); + MY_CHECKGEOM("scroll_container", 1); + + v2s32 pos = getRealCoordinateBasePos(v_pos); + v2s32 geom = getRealCoordinateGeometry(v_geom); + + if (orientation == "vertical") + scroll_factor *= -imgsize.Y; + else if (orientation == "horizontal") + scroll_factor *= -imgsize.X; + else + warningstream << "GUIFormSpecMenu::parseScrollContainer(): " + << "Invalid scroll_container orientation: " << orientation + << std::endl; + + // old parent (at first: this) + // ^ is parent of clipper + // ^ is parent of mover + // ^ is parent of other elements + + // make clipper + core::rect rect_clipper = core::rect(pos, pos + geom); + + gui::IGUIElement *clipper = new gui::IGUIElement(EGUIET_ELEMENT, Environment, + data->current_parent, 0, rect_clipper); + + // make mover + FieldSpec spec_mover( + "", + L"", + L"", + 258 + m_fields.size() + ); + + core::rect rect_mover = core::rect(0, 0, geom.X, geom.Y); + + GUIScrollContainer *mover = new GUIScrollContainer(Environment, + clipper, spec_mover.fid, rect_mover, orientation, scroll_factor); + + data->current_parent = mover; + + m_scroll_containers.emplace_back(scrollbar_name, mover); + + m_fields.push_back(spec_mover); + + clipper->drop(); + + // remove interferring offset of normal containers + container_stack.push(pos_offset); + pos_offset.X = 0.0f; + pos_offset.Y = 0.0f; +} + +void GUIFormSpecMenu::parseScrollContainerEnd(parserData *data) +{ + if (data->current_parent == this || data->current_parent->getParent() == this || + container_stack.empty()) { + errorstream << "Invalid scroll_container end element, " + << "no matching scroll_container start element" << std::endl; + return; + } + + if (pos_offset.getLengthSQ() != 0.0f) { + // pos_offset is only set by containers and scroll_containers. + // scroll_containers always set it to 0,0 which means that if it is + // not 0,0, it is a normal container that was opened last, not a + // scroll_container + errorstream << "Invalid scroll_container end element, " + << "an inner container was left open" << std::endl; + return; + } + + data->current_parent = data->current_parent->getParent()->getParent(); + pos_offset = container_stack.top(); + container_stack.pop(); +} + +void GUIFormSpecMenu::parseList(parserData *data, const std::string &element) { if (m_client == 0) { warningstream<<"invalid use of 'list' with m_client==0"<explicit_size) - warningstream<<"invalid use of list without a size[] element"<explicit_size) + warningstream << "invalid use of list without a size[] element" << std::endl; + + FieldSpec spec( + "", + L"", + L"", + 258 + m_fields.size(), + 3 + ); + + v2f32 slot_spacing = data->real_coordinates ? + v2f32(imgsize.X * 1.25f, imgsize.Y * 1.25f) : spacing; + + v2s32 pos = data->real_coordinates ? getRealCoordinateBasePos(v_pos) + : getElementBasePos(&v_pos); + + core::rect rect = core::rect(pos.X, pos.Y, + pos.X + (geom.X - 1) * slot_spacing.X + imgsize.X, + pos.Y + (geom.Y - 1) * slot_spacing.Y + imgsize.Y); + + GUIInventoryList *e = new GUIInventoryList(Environment, data->current_parent, + spec.fid, rect, m_invmgr, loc, listname, geom, start_i, imgsize, + slot_spacing, this, data->inventorylist_options, m_font); + + m_inventorylists.push_back(e); + m_fields.push_back(spec); return; } errorstream<< "Invalid list element(" << parts.size() << "): '" << element << "'" << std::endl; } -void GUIFormSpecMenu::parseListRing(parserData* data, const std::string &element) +void GUIFormSpecMenu::parseListRing(parserData *data, const std::string &element) { if (m_client == 0) { errorstream << "WARNING: invalid use of 'listring' with m_client==0" << std::endl; @@ -402,10 +540,10 @@ void GUIFormSpecMenu::parseListRing(parserData* data, const std::string &element if (element.empty() && 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.emplace_back(spa.inventoryloc, spa.listname); - m_inventory_rings.emplace_back(spb.inventoryloc, spb.listname); + const GUIInventoryList *spa = m_inventorylists[siz - 2]; + const GUIInventoryList *spb = m_inventorylists[siz - 1]; + m_inventory_rings.emplace_back(spa->getInventoryloc(), spa->getListname()); + m_inventory_rings.emplace_back(spb->getInventoryloc(), spb->getListname()); return; } @@ -430,8 +568,6 @@ void GUIFormSpecMenu::parseCheckbox(parserData* data, const std::string &element MY_CHECKPOS("checkbox",0); - v2s32 pos = getElementBasePos(false, &v_pos); - bool fselected = false; if (selected == "true") @@ -442,12 +578,27 @@ void GUIFormSpecMenu::parseCheckbox(parserData* data, const std::string &element s32 cb_size = Environment->getSkin()->getSize(gui::EGDS_CHECK_BOX_WIDTH); s32 y_center = (std::max(label_size.Height, (u32)cb_size) + 1) / 2; - core::rect rect = core::rect( - pos.X, - pos.Y + imgsize.Y / 2 - y_center, - pos.X + label_size.Width + cb_size + 7, - pos.Y + imgsize.Y / 2 + y_center - ); + v2s32 pos; + core::rect rect; + + if (data->real_coordinates) { + pos = getRealCoordinateBasePos(v_pos); + + rect = core::rect( + pos.X, + pos.Y - y_center, + pos.X + label_size.Width + cb_size + 7, + pos.Y + y_center + ); + } else { + pos = getElementBasePos(&v_pos); + rect = core::rect( + pos.X, + pos.Y + imgsize.Y / 2 - y_center, + pos.X + label_size.Width + cb_size + 7, + pos.Y + imgsize.Y / 2 + y_center + ); + } FieldSpec spec( name, @@ -458,14 +609,18 @@ void GUIFormSpecMenu::parseCheckbox(parserData* data, const std::string &element spec.ftype = f_CheckBox; - gui::IGUICheckBox* e = Environment->addCheckBox(fselected, rect, this, - spec.fid, spec.flabel.c_str()); + gui::IGUICheckBox *e = Environment->addCheckBox(fselected, rect, + data->current_parent, spec.fid, spec.flabel.c_str()); + + auto style = getDefaultStyleForElement("checkbox", name); + e->setNotClipped(style.getBool(StyleSpec::NOCLIP, false)); - if (spec.fname == data->focused_fieldname) { + if (spec.fname == m_focused_element) { Environment->setFocus(e); } - m_checkboxes.emplace_back(spec,e); + e->grab(); + m_checkboxes.emplace_back(spec, e); m_fields.push_back(spec); return; } @@ -478,24 +633,25 @@ void GUIFormSpecMenu::parseScrollBar(parserData* data, const std::string &elemen if (parts.size() >= 5) { std::vector v_pos = split(parts[0],','); - std::vector v_dim = split(parts[1],','); + std::vector v_geom = split(parts[1],','); std::string name = parts[3]; std::string value = parts[4]; MY_CHECKPOS("scrollbar",0); + MY_CHECKGEOM("scrollbar",1); - v2s32 pos = getElementBasePos(false, &v_pos); + v2s32 pos; + v2s32 dim; - if (v_dim.size() != 2) { - errorstream<< "Invalid size for element " << "scrollbar" - << "specified: \"" << parts[1] << "\"" << std::endl; - return; + if (data->real_coordinates) { + pos = getRealCoordinateBasePos(v_pos); + dim = getRealCoordinateGeometry(v_geom); + } else { + pos = getElementBasePos(&v_pos); + dim.X = stof(v_geom[0]) * spacing.X; + dim.Y = stof(v_geom[1]) * spacing.Y; } - v2s32 dim; - dim.X = stof(v_dim[0]) * spacing.X; - dim.Y = stof(v_dim[1]) * spacing.Y; - core::rect rect = core::rect(pos.X, pos.Y, pos.X + dim.X, pos.Y + dim.Y); @@ -513,20 +669,91 @@ void GUIFormSpecMenu::parseScrollBar(parserData* data, const std::string &elemen spec.ftype = f_ScrollBar; spec.send = true; - gui::IGUIScrollBar* e = - Environment->addScrollBar(is_horizontal,rect,this,spec.fid); + GUIScrollBar *e = new GUIScrollBar(Environment, data->current_parent, + spec.fid, rect, is_horizontal, true); + + auto style = getDefaultStyleForElement("scrollbar", name); + e->setNotClipped(style.getBool(StyleSpec::NOCLIP, false)); + e->setArrowsVisible(data->scrollbar_options.arrow_visiblity); + + s32 max = data->scrollbar_options.max; + s32 min = data->scrollbar_options.min; + + e->setMax(max); + e->setMin(min); - e->setMax(1000); - e->setMin(0); e->setPos(stoi(parts[4])); - e->setSmallStep(10); - e->setLargeStep(100); + + e->setSmallStep(data->scrollbar_options.small_step); + e->setLargeStep(data->scrollbar_options.large_step); + + s32 scrollbar_size = is_horizontal ? dim.X : dim.Y; + + e->setPageSize(scrollbar_size * (max - min + 1) / data->scrollbar_options.thumb_size); + + if (spec.fname == m_focused_element) { + Environment->setFocus(e); + } m_scrollbars.emplace_back(spec,e); m_fields.push_back(spec); return; } - errorstream<< "Invalid scrollbar element(" << parts.size() << "): '" << element << "'" << std::endl; + errorstream << "Invalid scrollbar element(" << parts.size() << "): '" << element + << "'" << std::endl; +} + +void GUIFormSpecMenu::parseScrollBarOptions(parserData* data, const std::string &element) +{ + std::vector parts = split(element, ';'); + + if (parts.size() == 0) { + warningstream << "Invalid scrollbaroptions element(" << parts.size() << "): '" << + element << "'" << std::endl; + return; + } + + for (const std::string &i : parts) { + std::vector options = split(i, '='); + + if (options.size() != 2) { + warningstream << "Invalid scrollbaroptions option syntax: '" << + element << "'" << std::endl; + continue; // Go to next option + } + + if (options[0] == "max") { + data->scrollbar_options.max = stoi(options[1]); + continue; + } else if (options[0] == "min") { + data->scrollbar_options.min = stoi(options[1]); + continue; + } else if (options[0] == "smallstep") { + int value = stoi(options[1]); + data->scrollbar_options.small_step = value < 0 ? 10 : value; + continue; + } else if (options[0] == "largestep") { + int value = stoi(options[1]); + data->scrollbar_options.large_step = value < 0 ? 100 : value; + continue; + } else if (options[0] == "thumbsize") { + int value = stoi(options[1]); + data->scrollbar_options.thumb_size = value <= 0 ? 1 : value; + continue; + } else if (options[0] == "arrows") { + std::string value = trim(options[1]); + if (value == "hide") + data->scrollbar_options.arrow_visiblity = GUIScrollBar::HIDE; + else if (value == "show") + data->scrollbar_options.arrow_visiblity = GUIScrollBar::SHOW; + else // Auto hide/show + data->scrollbar_options.arrow_visiblity = GUIScrollBar::DEFAULT; + continue; + } + + warningstream << "Invalid scrollbaroptions option(" << options[0] << + "): '" << element << "'" << std::endl; + } } void GUIFormSpecMenu::parseImage(parserData* data, const std::string &element) @@ -543,14 +770,47 @@ void GUIFormSpecMenu::parseImage(parserData* data, const std::string &element) MY_CHECKPOS("image", 0); MY_CHECKGEOM("image", 1); - v2s32 pos = getElementBasePos(true, &v_pos); + v2s32 pos; v2s32 geom; - geom.X = stof(v_geom[0]) * (float)imgsize.X; - geom.Y = stof(v_geom[1]) * (float)imgsize.Y; + + if (data->real_coordinates) { + pos = getRealCoordinateBasePos(v_pos); + geom = getRealCoordinateGeometry(v_geom); + } else { + pos = getElementBasePos(&v_pos); + 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"<getTexture(name); + if (!texture) { + errorstream << "GUIFormSpecMenu::parseImage() Unable to load texture:" + << std::endl << "\t" << name << std::endl; + return; + } + + FieldSpec spec( + name, + L"", + L"", + 258 + m_fields.size(), + 1 + ); + core::rect rect(pos, pos + geom); + gui::IGUIImage *e = Environment->addImage(rect, data->current_parent, + spec.fid, 0, true); + e->setImage(texture); + e->setScaleImage(true); + auto style = getDefaultStyleForElement("image", spec.fname); + e->setNotClipped(style.getBool(StyleSpec::NOCLIP, m_formspec_version < 3)); + m_fields.push_back(spec); + + // images should let events through + e->grab(); + m_clickthrough_elements.push_back(e); return; } @@ -560,16 +820,100 @@ void GUIFormSpecMenu::parseImage(parserData* data, const std::string &element) MY_CHECKPOS("image", 0); - v2s32 pos = getElementBasePos(true, &v_pos); + v2s32 pos = getElementBasePos(&v_pos); if (!data->explicit_size) warningstream<<"invalid use of image without a size[] element"<getTexture(name); + if (!texture) { + errorstream << "GUIFormSpecMenu::parseImage() Unable to load texture:" + << std::endl << "\t" << name << std::endl; + return; + } + + FieldSpec spec( + name, + L"", + L"", + 258 + m_fields.size() + ); + gui::IGUIImage *e = Environment->addImage(texture, pos, true, + data->current_parent, spec.fid, 0); + auto style = getDefaultStyleForElement("image", spec.fname); + e->setNotClipped(style.getBool(StyleSpec::NOCLIP, m_formspec_version < 3)); + m_fields.push_back(spec); + + // images should let events through + e->grab(); + m_clickthrough_elements.push_back(e); return; } errorstream<< "Invalid image element(" << parts.size() << "): '" << element << "'" << std::endl; } +void GUIFormSpecMenu::parseAnimatedImage(parserData *data, const std::string &element) +{ + std::vector parts = split(element, ';'); + + if (parts.size() != 6 && parts.size() != 7 && + !(parts.size() > 7 && m_formspec_version > FORMSPEC_API_VERSION)) { + errorstream << "Invalid animated_image element(" << parts.size() + << "): '" << element << "'" << std::endl; + return; + } + + std::vector v_pos = split(parts[0], ','); + std::vector v_geom = split(parts[1], ','); + std::string name = parts[2]; + std::string texture_name = unescape_string(parts[3]); + s32 frame_count = stoi(parts[4]); + s32 frame_duration = stoi(parts[5]); + + MY_CHECKPOS("animated_image", 0); + MY_CHECKGEOM("animated_image", 1); + + v2s32 pos; + v2s32 geom; + + if (data->real_coordinates) { + pos = getRealCoordinateBasePos(v_pos); + geom = getRealCoordinateGeometry(v_geom); + } else { + pos = getElementBasePos(&v_pos); + 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 animated_image without a size[] element" << std::endl; + + FieldSpec spec( + name, + L"", + L"", + 258 + m_fields.size() + ); + spec.ftype = f_AnimatedImage; + spec.send = true; + + core::rect rect = core::rect(pos, pos + geom); + + GUIAnimatedImage *e = new GUIAnimatedImage(Environment, this, spec.fid, + rect, texture_name, frame_count, frame_duration, m_tsrc); + + if (parts.size() >= 7) + e->setFrameIndex(stoi(parts[6]) - 1); + + auto style = getDefaultStyleForElement("animated_image", spec.fname, "image"); + e->setNotClipped(style.getBool(StyleSpec::NOCLIP, false)); + + // Animated images should let events through + m_clickthrough_elements.push_back(e); + + m_fields.push_back(spec); +} + void GUIFormSpecMenu::parseItemImage(parserData* data, const std::string &element) { std::vector parts = split(element,';'); @@ -584,14 +928,39 @@ void GUIFormSpecMenu::parseItemImage(parserData* data, const std::string &elemen MY_CHECKPOS("itemimage",0); MY_CHECKGEOM("itemimage",1); - v2s32 pos = getElementBasePos(true, &v_pos); + v2s32 pos; v2s32 geom; - geom.X = stof(v_geom[0]) * (float)imgsize.X; - geom.Y = stof(v_geom[1]) * (float)imgsize.Y; + + if (data->real_coordinates) { + pos = getRealCoordinateBasePos(v_pos); + geom = getRealCoordinateGeometry(v_geom); + } else { + pos = getElementBasePos(&v_pos); + 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"<current_parent, spec.fid, + core::rect(pos, pos + geom), name, m_font, m_client); + auto style = getDefaultStyleForElement("item_image", spec.fname); + e->setNotClipped(style.getBool(StyleSpec::NOCLIP, false)); + + // item images should let events through + m_clickthrough_elements.push_back(e); + + m_fields.push_back(spec); return; } errorstream<< "Invalid ItemImage element(" << parts.size() << "): '" << element << "'" << std::endl; @@ -613,14 +982,23 @@ void GUIFormSpecMenu::parseButton(parserData* data, const std::string &element, MY_CHECKPOS("button",0); MY_CHECKGEOM("button",1); - v2s32 pos = getElementBasePos(false, &v_pos); + v2s32 pos; v2s32 geom; - geom.X = (stof(v_geom[0]) * spacing.X) - (spacing.X - imgsize.X); - pos.Y += (stof(v_geom[1]) * (float)imgsize.Y)/2; + core::rect rect; - core::rect rect = - core::rect(pos.X, pos.Y - m_btn_height, + if (data->real_coordinates) { + pos = getRealCoordinateBasePos(v_pos); + geom = getRealCoordinateGeometry(v_geom); + rect = core::rect(pos.X, pos.Y, pos.X+geom.X, + pos.Y+geom.Y); + } else { + pos = getElementBasePos(&v_pos); + geom.X = (stof(v_geom[0]) * spacing.X) - (spacing.X - imgsize.X); + pos.Y += (stof(v_geom[1]) * (float)imgsize.Y)/2; + + 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) { + GUIButton *e = GUIButton::addButton(Environment, rect, m_tsrc, + data->current_parent, spec.fid, spec.flabel.c_str()); + + auto style = getStyleForElement(type, name, (type != "button") ? "button" : ""); + e->setStyles(style); + + if (spec.fname == m_focused_element) { Environment->setFocus(e); } @@ -653,9 +1035,8 @@ void GUIFormSpecMenu::parseBackground(parserData* data, const std::string &eleme { std::vector parts = split(element,';'); - if (((parts.size() == 3) || (parts.size() == 4)) || - ((parts.size() > 4) && (m_formspec_version > FORMSPEC_API_VERSION))) - { + if ((parts.size() >= 3 && 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 = unescape_string(parts[2]); @@ -663,26 +1044,84 @@ void GUIFormSpecMenu::parseBackground(parserData* data, const std::string &eleme MY_CHECKPOS("background",0); MY_CHECKGEOM("background",1); - v2s32 pos = getElementBasePos(true, &v_pos); - pos.X -= (spacing.X - (float)imgsize.X) / 2; - pos.Y -= (spacing.Y - (float)imgsize.Y) / 2; - + v2s32 pos; v2s32 geom; - geom.X = stof(v_geom[0]) * spacing.X; - geom.Y = stof(v_geom[1]) * spacing.Y; + + if (data->real_coordinates) { + pos = getRealCoordinateBasePos(v_pos); + geom = getRealCoordinateGeometry(v_geom); + } else { + pos = getElementBasePos(&v_pos); + pos.X -= (spacing.X - (float)imgsize.X) / 2; + pos.Y -= (spacing.Y - (float)imgsize.Y) / 2; + + geom.X = stof(v_geom[0]) * spacing.X; + geom.Y = stof(v_geom[1]) * spacing.Y; + } bool clip = false; - if (parts.size() == 4 && is_yes(parts[3])) { - pos.X = stoi(v_pos[0]); //acts as offset - pos.Y = stoi(v_pos[1]); //acts as offset + if (parts.size() >= 4 && is_yes(parts[3])) { + if (data->real_coordinates) { + pos = getRealCoordinateBasePos(v_pos) * -1; + geom = v2s32(0, 0); + } else { + pos.X = stoi(v_pos[0]); //acts as offset + pos.Y = stoi(v_pos[1]); + } clip = true; } + core::rect middle; + if (parts.size() >= 5) { + std::vector v_middle = split(parts[4], ','); + if (v_middle.size() == 1) { + s32 x = stoi(v_middle[0]); + middle.UpperLeftCorner = core::vector2di(x, x); + middle.LowerRightCorner = core::vector2di(-x, -x); + } else if (v_middle.size() == 2) { + s32 x = stoi(v_middle[0]); + s32 y = stoi(v_middle[1]); + middle.UpperLeftCorner = core::vector2di(x, y); + middle.LowerRightCorner = core::vector2di(-x, -y); + // `-x` is interpreted as `w - x` + } else if (v_middle.size() == 4) { + middle.UpperLeftCorner = core::vector2di(stoi(v_middle[0]), stoi(v_middle[1])); + middle.LowerRightCorner = core::vector2di(stoi(v_middle[2]), stoi(v_middle[3])); + } else { + warningstream << "Invalid rectangle given to middle param of background[] element" << std::endl; + } + } + if (!data->explicit_size && !clip) warningstream << "invalid use of unclipped background without a size[] element" << std::endl; - m_backgrounds.emplace_back(name, pos, geom, clip); + FieldSpec spec( + name, + L"", + L"", + 258 + m_fields.size() + ); + + core::rect rect; + if (!clip) { + // no auto_clip => position like normal image + rect = core::rect(pos, pos + geom); + } else { + // it will be auto-clipped when drawing + rect = core::rect(-pos, pos); + } + + GUIBackgroundImage *e = new GUIBackgroundImage(Environment, this, spec.fid, + rect, name, middle, m_tsrc, clip); + + FATAL_ERROR_IF(!e, "Failed to create background formspec element"); + + e->setNotClipped(true); + + e->setVisible(false); // the element is drawn manually before all others + m_backgrounds.push_back(e); + m_fields.push_back(spec); return; } errorstream<< "Invalid background element(" << parts.size() << "): '" << element << "'" << std::endl; @@ -740,10 +1179,17 @@ void GUIFormSpecMenu::parseTable(parserData* data, const std::string &element) MY_CHECKPOS("table",0); MY_CHECKGEOM("table",1); - v2s32 pos = getElementBasePos(false, &v_pos); + v2s32 pos; v2s32 geom; - geom.X = stof(v_geom[0]) * spacing.X; - geom.Y = stof(v_geom[1]) * spacing.Y; + + if (data->real_coordinates) { + pos = getRealCoordinateBasePos(v_pos); + geom = getRealCoordinateGeometry(v_geom); + } else { + pos = getElementBasePos(&v_pos); + geom.X = stof(v_geom[0]) * spacing.X; + geom.Y = stof(v_geom[1]) * spacing.Y; + } core::rect rect = core::rect(pos.X, pos.Y, pos.X+geom.X, pos.Y+geom.Y); @@ -751,7 +1197,7 @@ void GUIFormSpecMenu::parseTable(parserData* data, const std::string &element) name, L"", L"", - 258+m_fields.size() + 258 + m_fields.size() ); spec.ftype = f_Table; @@ -761,10 +1207,10 @@ void GUIFormSpecMenu::parseTable(parserData* data, const std::string &element) } //now really show table - GUITable *e = new GUITable(Environment, this, spec.fid, rect, - m_tsrc); + GUITable *e = new GUITable(Environment, data->current_parent, spec.fid, + rect, m_tsrc); - if (spec.fname == data->focused_fieldname) { + if (spec.fname == m_focused_element) { Environment->setFocus(e); } @@ -777,6 +1223,10 @@ void GUIFormSpecMenu::parseTable(parserData* data, const std::string &element) if (!str_initial_selection.empty() && str_initial_selection != "0") e->setSelected(stoi(str_initial_selection)); + auto style = getDefaultStyleForElement("table", name); + e->setNotClipped(style.getBool(StyleSpec::NOCLIP, false)); + e->setOverrideFont(style.getFont()); + m_tables.emplace_back(spec, e); m_fields.push_back(spec); return; @@ -807,11 +1257,17 @@ void GUIFormSpecMenu::parseTextList(parserData* data, const std::string &element MY_CHECKPOS("textlist",0); MY_CHECKGEOM("textlist",1); - v2s32 pos = getElementBasePos(false, &v_pos); + v2s32 pos; v2s32 geom; - geom.X = stof(v_geom[0]) * spacing.X; - geom.Y = stof(v_geom[1]) * spacing.Y; + if (data->real_coordinates) { + pos = getRealCoordinateBasePos(v_pos); + geom = getRealCoordinateGeometry(v_geom); + } else { + pos = getElementBasePos(&v_pos); + geom.X = stof(v_geom[0]) * spacing.X; + geom.Y = stof(v_geom[1]) * spacing.Y; + } core::rect rect = core::rect(pos.X, pos.Y, pos.X+geom.X, pos.Y+geom.Y); @@ -819,7 +1275,7 @@ void GUIFormSpecMenu::parseTextList(parserData* data, const std::string &element name, L"", L"", - 258+m_fields.size() + 258 + m_fields.size() ); spec.ftype = f_Table; @@ -829,10 +1285,10 @@ void GUIFormSpecMenu::parseTextList(parserData* data, const std::string &element } //now really show list - GUITable *e = new GUITable(Environment, this, spec.fid, rect, - m_tsrc); + GUITable *e = new GUITable(Environment, data->current_parent, spec.fid, + rect, m_tsrc); - if (spec.fname == data->focused_fieldname) { + if (spec.fname == m_focused_element) { Environment->setFocus(e); } @@ -845,6 +1301,10 @@ void GUIFormSpecMenu::parseTextList(parserData* data, const std::string &element if (!str_initial_selection.empty() && str_initial_selection != "0") e->setSelected(stoi(str_initial_selection)); + auto style = getDefaultStyleForElement("textlist", name); + e->setNotClipped(style.getBool(StyleSpec::NOCLIP, false)); + e->setOverrideFont(style.getFont()); + m_tables.emplace_back(spec, e); m_fields.push_back(spec); return; @@ -852,43 +1312,62 @@ void GUIFormSpecMenu::parseTextList(parserData* data, const std::string &element errorstream<< "Invalid textlist element(" << parts.size() << "): '" << element << "'" << std::endl; } - void GUIFormSpecMenu::parseDropDown(parserData* data, const std::string &element) { - std::vector parts = split(element,';'); + std::vector parts = split(element, ';'); - if ((parts.size() == 5) || - ((parts.size() > 5) && (m_formspec_version > FORMSPEC_API_VERSION))) + if (parts.size() == 5 || parts.size() == 6 || + (parts.size() > 6 && m_formspec_version > FORMSPEC_API_VERSION)) { - std::vector v_pos = split(parts[0],','); + std::vector v_pos = split(parts[0], ','); std::string name = parts[2]; - std::vector items = split(parts[3],','); - std::string str_initial_selection; - str_initial_selection = parts[4]; + std::vector items = split(parts[3], ','); + std::string str_initial_selection = parts[4]; + + if (parts.size() >= 6 && is_yes(parts[5])) + m_dropdown_index_event[name] = true; MY_CHECKPOS("dropdown",0); - v2s32 pos = getElementBasePos(false, &v_pos); + v2s32 pos; + v2s32 geom; + core::rect rect; + + if (data->real_coordinates) { + std::vector v_geom = split(parts[1],','); - s32 width = stof(parts[1]) * spacing.Y; + if (v_geom.size() == 1) + v_geom.emplace_back("1"); - core::rect rect = core::rect(pos.X, pos.Y, - pos.X + width, pos.Y + (m_btn_height * 2)); + MY_CHECKGEOM("dropdown",1); + + pos = getRealCoordinateBasePos(v_pos); + geom = getRealCoordinateGeometry(v_geom); + rect = core::rect(pos.X, pos.Y, pos.X+geom.X, pos.Y+geom.Y); + } else { + pos = getElementBasePos(&v_pos); + + s32 width = stof(parts[1]) * spacing.Y; + + rect = core::rect(pos.X, pos.Y, + pos.X + width, pos.Y + (m_btn_height * 2)); + } FieldSpec spec( name, L"", L"", - 258+m_fields.size() + 258 + m_fields.size() ); spec.ftype = f_DropDown; spec.send = true; //now really show list - gui::IGUIComboBox *e = Environment->addComboBox(rect, this,spec.fid); + gui::IGUIComboBox *e = Environment->addComboBox(rect, data->current_parent, + spec.fid); - if (spec.fname == data->focused_fieldname) { + if (spec.fname == m_focused_element) { Environment->setFocus(e); } @@ -900,6 +1379,9 @@ void GUIFormSpecMenu::parseDropDown(parserData* data, const std::string &element if (!str_initial_selection.empty()) e->setSelected(stoi(str_initial_selection)-1); + auto style = getDefaultStyleForElement("dropdown", name); + e->setNotClipped(style.getBool(StyleSpec::NOCLIP, false)); + m_fields.push_back(spec); m_dropdowns.emplace_back(spec, std::vector()); @@ -910,8 +1392,8 @@ void GUIFormSpecMenu::parseDropDown(parserData* data, const std::string &element return; } - errorstream << "Invalid dropdown element(" << parts.size() << "): '" - << element << "'" << std::endl; + errorstream << "Invalid dropdown element(" << parts.size() << "): '" << element + << "'" << std::endl; } void GUIFormSpecMenu::parseFieldCloseOnEnter(parserData *data, const std::string &element) @@ -927,8 +1409,8 @@ void GUIFormSpecMenu::parsePwdField(parserData* data, const std::string &element { std::vector parts = split(element,';'); - if ((parts.size() == 4) || (parts.size() == 5) || - ((parts.size() > 5) && (m_formspec_version > FORMSPEC_API_VERSION))) + 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],','); @@ -938,15 +1420,22 @@ void GUIFormSpecMenu::parsePwdField(parserData* data, const std::string &element MY_CHECKPOS("pwdfield",0); MY_CHECKGEOM("pwdfield",1); - v2s32 pos = getElementBasePos(false, &v_pos); - pos -= padding; - + v2s32 pos; v2s32 geom; - geom.X = (stof(v_geom[0]) * spacing.X) - (spacing.X - imgsize.X); - pos.Y += (stof(v_geom[1]) * (float)imgsize.Y)/2; - pos.Y -= m_btn_height; - geom.Y = m_btn_height*2; + if (data->real_coordinates) { + pos = getRealCoordinateBasePos(v_pos); + geom = getRealCoordinateGeometry(v_geom); + } else { + pos = getElementBasePos(&v_pos); + pos -= padding; + + geom.X = (stof(v_geom[0]) * spacing.X) - (spacing.X - imgsize.X); + + pos.Y += (stof(v_geom[1]) * (float)imgsize.Y)/2; + pos.Y -= m_btn_height; + geom.Y = m_btn_height*2; + } core::rect rect = core::rect(pos.X, pos.Y, pos.X+geom.X, pos.Y+geom.Y); @@ -956,13 +1445,16 @@ void GUIFormSpecMenu::parsePwdField(parserData* data, const std::string &element name, wlabel, L"", - 258+m_fields.size() + 258 + m_fields.size(), + 0, + ECI_IBEAM ); spec.send = true; - gui::IGUIEditBox * e = Environment->addEditBox(0, rect, true, this, spec.fid); + gui::IGUIEditBox *e = Environment->addEditBox(0, rect, true, + data->current_parent, spec.fid); - if (spec.fname == data->focused_fieldname) { + if (spec.fname == m_focused_element) { Environment->setFocus(e); } @@ -971,11 +1463,17 @@ void GUIFormSpecMenu::parsePwdField(parserData* data, const std::string &element rect.UpperLeftCorner.Y -= font_height; rect.LowerRightCorner.Y = rect.UpperLeftCorner.Y + font_height; gui::StaticText::add(Environment, spec.flabel.c_str(), rect, false, true, - this, 0); + data->current_parent, 0); } e->setPasswordBox(true,L'*'); + auto style = getDefaultStyleForElement("pwdfield", name, "field"); + e->setNotClipped(style.getBool(StyleSpec::NOCLIP, false)); + e->setDrawBorder(style.getBool(StyleSpec::BORDER, true)); + e->setOverrideColor(style.getColor(StyleSpec::TEXTCOLOR, video::SColor(0xFFFFFFFF))); + e->setOverrideFont(style.getFont()); + irr::SEvent evt; evt.EventType = EET_KEY_INPUT_EVENT; evt.KeyInput.Key = KEY_END; @@ -985,12 +1483,8 @@ void GUIFormSpecMenu::parsePwdField(parserData* data, const std::string &element evt.KeyInput.PressedDown = true; e->OnEvent(evt); - if (parts.size() >= 5) { - // TODO: remove after 2016-11-03 - warningstream << "pwdfield: use field_close_on_enter[name, enabled]" << - " instead of the 5th param" << std::endl; - field_close_on_enter[name] = is_yes(parts[4]); - } + // Note: Before 5.2.0 "parts.size() >= 5" resulted in a + // warning referring to field_close_on_enter[]! m_fields.push_back(spec); return; @@ -1005,7 +1499,7 @@ void GUIFormSpecMenu::createTextField(parserData *data, FieldSpec &spec, if (!is_editable && !is_multiline) { // spec field id to 0, this stops submit searching for a value that isn't there gui::StaticText::add(Environment, spec.flabel.c_str(), rect, false, true, - this, spec.fid); + data->current_parent, 0); return; } @@ -1022,20 +1516,23 @@ void GUIFormSpecMenu::createTextField(parserData *data, FieldSpec &spec, IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR < 9; if (use_intl_edit_box && g_settings->getBool("freetype")) { - e = new gui::intlGUIEditBox(spec.fdefault.c_str(), - true, Environment, this, spec.fid, rect, is_editable, is_multiline); - e->drop(); + e = new gui::intlGUIEditBox(spec.fdefault.c_str(), true, Environment, + data->current_parent, spec.fid, rect, is_editable, is_multiline); } else { - if (is_multiline) - e = new GUIEditBoxWithScrollBar(spec.fdefault.c_str(), true, - Environment, this, spec.fid, rect, is_editable, true); - else if (is_editable) + if (is_multiline) { + e = new GUIEditBoxWithScrollBar(spec.fdefault.c_str(), true, Environment, + data->current_parent, spec.fid, rect, is_editable, true); + } else if (is_editable) { e = Environment->addEditBox(spec.fdefault.c_str(), rect, true, - this, spec.fid); + data->current_parent, spec.fid); + e->grab(); + } } + auto style = getDefaultStyleForElement(is_multiline ? "textarea" : "field", spec.fname); + if (e) { - if (is_editable && spec.fname == data->focused_fieldname) + if (is_editable && spec.fname == m_focused_element) Environment->setFocus(e); if (is_multiline) { @@ -1052,19 +1549,32 @@ void GUIFormSpecMenu::createTextField(parserData *data, FieldSpec &spec, evt.KeyInput.PressedDown = true; e->OnEvent(evt); } + + e->setNotClipped(style.getBool(StyleSpec::NOCLIP, false)); + e->setDrawBorder(style.getBool(StyleSpec::BORDER, true)); + e->setOverrideColor(style.getColor(StyleSpec::TEXTCOLOR, video::SColor(0xFFFFFFFF))); + if (style.get(StyleSpec::BGCOLOR, "") == "transparent") { + e->setDrawBackground(false); + } + e->setOverrideFont(style.getFont()); + + e->drop(); } if (!spec.flabel.empty()) { int font_height = g_fontengine->getTextHeight(); rect.UpperLeftCorner.Y -= font_height; rect.LowerRightCorner.Y = rect.UpperLeftCorner.Y + font_height; - gui::StaticText::add(Environment, spec.flabel.c_str(), rect, false, true, - this, 0); + IGUIElement *t = gui::StaticText::add(Environment, spec.flabel.c_str(), + rect, false, true, data->current_parent, 0); + + if (t) + t->setNotClipped(style.getBool(StyleSpec::NOCLIP, false)); } } -void GUIFormSpecMenu::parseSimpleField(parserData* data, - std::vector &parts) +void GUIFormSpecMenu::parseSimpleField(parserData *data, + std::vector &parts) { std::string name = parts[0]; std::string label = parts[1]; @@ -1072,18 +1582,20 @@ void GUIFormSpecMenu::parseSimpleField(parserData* data, core::rect rect; - if(data->explicit_size) - warningstream<<"invalid use of unpositioned \"field\" in inventory"<explicit_size) + warningstream << "invalid use of unpositioned \"field\" in inventory" << std::endl; - v2s32 pos = getElementBasePos(false, nullptr); - pos.Y = ((m_fields.size()+2)*60); + v2s32 pos = getElementBasePos(nullptr); + pos.Y = (data->simple_field_count + 2) * 60; v2s32 size = DesiredRect.getSize(); - rect = core::rect(size.X / 2 - 150, pos.Y, - (size.X / 2 - 150) + 300, pos.Y + (m_btn_height*2)); + rect = core::rect( + size.X / 2 - 150, pos.Y, + size.X / 2 - 150 + 300, pos.Y + m_btn_height * 2 + ); - if(m_form_src) + if (m_form_src) default_val = m_form_src->resolveText(default_val); @@ -1093,25 +1605,21 @@ void GUIFormSpecMenu::parseSimpleField(parserData* data, name, wlabel, utf8_to_wide(unescape_string(default_val)), - 258+m_fields.size() + 258 + m_fields.size(), + 0, + ECI_IBEAM ); createTextField(data, spec, rect, false); - if (parts.size() >= 4) { - // TODO: remove after 2016-11-03 - warningstream << "field/simple: use field_close_on_enter[name, enabled]" << - " instead of the 4th param" << std::endl; - field_close_on_enter[name] = is_yes(parts[3]); - } - m_fields.push_back(spec); + + data->simple_field_count++; } void GUIFormSpecMenu::parseTextArea(parserData* data, std::vector& parts, const std::string &type) { - std::vector v_pos = split(parts[0],','); std::vector v_geom = split(parts[1],','); std::string name = parts[2]; @@ -1121,23 +1629,29 @@ void GUIFormSpecMenu::parseTextArea(parserData* data, std::vector& MY_CHECKPOS(type,0); MY_CHECKGEOM(type,1); - v2s32 pos = getElementBasePos(false, &v_pos); - pos -= padding; - + v2s32 pos; v2s32 geom; - geom.X = (stof(v_geom[0]) * spacing.X) - (spacing.X - imgsize.X); + if (data->real_coordinates) { + pos = getRealCoordinateBasePos(v_pos); + geom = getRealCoordinateGeometry(v_geom); + } else { + pos = getElementBasePos(&v_pos); + pos -= padding; + + geom.X = (stof(v_geom[0]) * spacing.X) - (spacing.X - imgsize.X); - if (type == "textarea") - { - geom.Y = (stof(v_geom[1]) * (float)imgsize.Y) - (spacing.Y-imgsize.Y); - pos.Y += m_btn_height; - } - else - { - pos.Y += (stof(v_geom[1]) * (float)imgsize.Y)/2; - pos.Y -= m_btn_height; - geom.Y = m_btn_height*2; + if (type == "textarea") + { + geom.Y = (stof(v_geom[1]) * (float)imgsize.Y) - (spacing.Y-imgsize.Y); + pos.Y += m_btn_height; + } + else + { + pos.Y += (stof(v_geom[1]) * (float)imgsize.Y)/2; + pos.Y -= m_btn_height; + geom.Y = m_btn_height*2; + } } core::rect rect = core::rect(pos.X, pos.Y, pos.X+geom.X, pos.Y+geom.Y); @@ -1155,17 +1669,15 @@ void GUIFormSpecMenu::parseTextArea(parserData* data, std::vector& name, wlabel, utf8_to_wide(unescape_string(default_val)), - 258+m_fields.size() + 258 + m_fields.size(), + 0, + ECI_IBEAM ); createTextField(data, spec, rect, type == "textarea"); - if (parts.size() >= 6) { - // TODO: remove after 2016-11-03 - warningstream << "field/textarea: use field_close_on_enter[name, enabled]" << - " instead of the 6th param" << std::endl; - field_close_on_enter[name] = is_yes(parts[5]); - } + // Note: Before 5.2.0 "parts.size() >= 6" resulted in a + // warning referring to field_close_on_enter[]! m_fields.push_back(spec); } @@ -1180,8 +1692,8 @@ void GUIFormSpecMenu::parseField(parserData* data, const std::string &element, return; } - if ((parts.size() == 5) || (parts.size() == 6) || - ((parts.size() > 6) && (m_formspec_version > FORMSPEC_API_VERSION))) + if ((parts.size() == 5) || + ((parts.size() > 5) && (m_formspec_version > FORMSPEC_API_VERSION))) { parseTextArea(data,parts,type); return; @@ -1189,6 +1701,58 @@ void GUIFormSpecMenu::parseField(parserData* data, const std::string &element, errorstream<< "Invalid field element(" << parts.size() << "): '" << element << "'" << std::endl; } +void GUIFormSpecMenu::parseHyperText(parserData *data, const std::string &element) +{ + std::vector parts = split(element, ';'); + + if (parts.size() != 4 && m_formspec_version < FORMSPEC_API_VERSION) { + errorstream << "Invalid text element(" << parts.size() << "): '" << element << "'" << std::endl; + return; + } + + std::vector v_pos = split(parts[0], ','); + std::vector v_geom = split(parts[1], ','); + std::string name = parts[2]; + std::string text = parts[3]; + + MY_CHECKPOS("hypertext", 0); + MY_CHECKGEOM("hypertext", 1); + + v2s32 pos; + v2s32 geom; + + if (data->real_coordinates) { + pos = getRealCoordinateBasePos(v_pos); + geom = getRealCoordinateGeometry(v_geom); + } else { + pos = getElementBasePos(&v_pos); + pos -= padding; + + geom.X = (stof(v_geom[0]) * spacing.X) - (spacing.X - imgsize.X); + geom.Y = (stof(v_geom[1]) * (float)imgsize.Y) - (spacing.Y - imgsize.Y); + pos.Y += m_btn_height; + } + + core::rect rect = core::rect(pos.X, pos.Y, pos.X + geom.X, pos.Y + geom.Y); + + if(m_form_src) + text = m_form_src->resolveText(text); + + FieldSpec spec( + name, + translate_string(utf8_to_wide(unescape_string(text))), + L"", + 258 + m_fields.size() + ); + + spec.ftype = f_HyperText; + GUIHyperText *e = new GUIHyperText(spec.flabel.c_str(), Environment, + data->current_parent, spec.fid, rect, m_client, m_tsrc); + e->drop(); + + m_fields.push_back(spec); +} + void GUIFormSpecMenu::parseLabel(parserData* data, const std::string &element) { std::vector parts = split(element,';'); @@ -1201,46 +1765,90 @@ void GUIFormSpecMenu::parseLabel(parserData* data, const std::string &element) MY_CHECKPOS("label",0); - v2s32 pos = getElementBasePos(false, nullptr); - pos.X += stof(v_pos[0]) * spacing.X; - pos.Y += (stof(v_pos[1]) + 7.0f / 30.0f) * spacing.Y; - if(!data->explicit_size) warningstream<<"invalid use of label without a size[] element"< lines = split(text, '\n'); + auto style = getDefaultStyleForElement("label", ""); + gui::IGUIFont *font = style.getFont(); + if (!font) + font = m_font; + for (unsigned int i = 0; i != lines.size(); i++) { - // Lines are spaced at the nominal distance of - // 2/5 inventory slot, even if the font doesn't - // quite match that. This provides consistent - // form layout, at the expense of sometimes - // having sub-optimal spacing for the font. - // We multiply by 2 and then divide by 5, rather - // than multiply by 0.4, to get exact results - // in the integer cases: 0.4 is not exactly - // representable in binary floating point. - s32 posy = pos.Y + ((float)i) * spacing.Y * 2.0 / 5.0; - std::wstring wlabel = utf8_to_wide(unescape_string(lines[i])); - core::rect rect = core::rect( - pos.X, posy - m_btn_height, - pos.X + m_font->getDimension(wlabel.c_str()).Width, - posy + m_btn_height); + std::wstring wlabel_colors = translate_string( + utf8_to_wide(unescape_string(lines[i]))); + // Without color escapes to get the font dimensions + std::wstring wlabel_plain = unescape_enriched(wlabel_colors); + + core::rect rect; + + if (data->real_coordinates) { + // Lines are spaced at the distance of 1/2 imgsize. + // This alows lines that line up with the new elements + // easily without sacrificing good line distance. If + // it was one whole imgsize, it would have too much + // spacing. + v2s32 pos = getRealCoordinateBasePos(v_pos); + + // Labels are positioned by their center, not their top. + pos.Y += (((float) imgsize.Y) / -2) + (((float) imgsize.Y) * i / 2); + + rect = core::rect( + pos.X, pos.Y, + pos.X + font->getDimension(wlabel_plain.c_str()).Width, + pos.Y + imgsize.Y); + + } else { + // Lines are spaced at the nominal distance of + // 2/5 inventory slot, even if the font doesn't + // quite match that. This provides consistent + // form layout, at the expense of sometimes + // having sub-optimal spacing for the font. + // We multiply by 2 and then divide by 5, rather + // than multiply by 0.4, to get exact results + // in the integer cases: 0.4 is not exactly + // representable in binary floating point. + + v2s32 pos = getElementBasePos(nullptr); + pos.X += stof(v_pos[0]) * spacing.X; + pos.Y += (stof(v_pos[1]) + 7.0f / 30.0f) * spacing.Y; + + pos.Y += ((float) i) * spacing.Y * 2.0 / 5.0; + + rect = core::rect( + pos.X, pos.Y - m_btn_height, + pos.X + font->getDimension(wlabel_plain.c_str()).Width, + pos.Y + m_btn_height); + } + FieldSpec spec( "", - wlabel, + wlabel_colors, L"", - 258+m_fields.size() + 258 + m_fields.size(), + 4 ); gui::IGUIStaticText *e = gui::StaticText::add(Environment, - spec.flabel.c_str(), rect, false, false, this, spec.fid); + spec.flabel.c_str(), rect, false, false, data->current_parent, + spec.fid); e->setTextAlignment(gui::EGUIA_UPPERLEFT, gui::EGUIA_CENTER); + + e->setNotClipped(style.getBool(StyleSpec::NOCLIP, false)); + e->setOverrideColor(style.getColor(StyleSpec::TEXTCOLOR, video::SColor(0xFFFFFFFF))); + e->setOverrideFont(font); + m_fields.push_back(spec); + + // labels should let events through + e->grab(); + m_clickthrough_elements.push_back(e); } return; } - errorstream<< "Invalid label element(" << parts.size() << "): '" << element << "'" << std::endl; + errorstream << "Invalid label element(" << parts.size() << "): '" << element + << "'" << std::endl; } void GUIFormSpecMenu::parseVertLabel(parserData* data, const std::string &element) @@ -1256,15 +1864,40 @@ void GUIFormSpecMenu::parseVertLabel(parserData* data, const std::string &elemen MY_CHECKPOS("vertlabel",1); - v2s32 pos = getElementBasePos(false, &v_pos); + auto style = getDefaultStyleForElement("vertlabel", "", "label"); + gui::IGUIFont *font = style.getFont(); + if (!font) + font = m_font; + + v2s32 pos; + core::rect rect; + + if (data->real_coordinates) { + pos = getRealCoordinateBasePos(v_pos); + + // Vertlabels are positioned by center, not left. + pos.X -= imgsize.X / 2; - core::rect rect = core::rect( - pos.X, pos.Y+((imgsize.Y/2)- m_btn_height), + // We use text.length + 1 because without it, the rect + // isn't quite tall enough and cuts off the text. + rect = core::rect(pos.X, pos.Y, + pos.X + imgsize.X, + pos.Y + font_line_height(font) * + (text.length() + 1)); + + } else { + pos = getElementBasePos(&v_pos); + + // As above, the length must be one longer. The width of + // the rect (15 pixels) seems rather arbitrary, but + // changing it might break something. + rect = core::rect( + pos.X, pos.Y+((imgsize.Y/2) - m_btn_height), pos.X+15, pos.Y + - font_line_height(m_font) - * (text.length()+1) - +((imgsize.Y/2)- m_btn_height)); - //actually text.length() would be correct but adding +1 avoids to break all mods + font_line_height(font) * + (text.length() + 1) + + ((imgsize.Y/2) - m_btn_height)); + } if(!data->explicit_size) warningstream<<"invalid use of label without a size[] element"<setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_CENTER); + gui::IGUIStaticText *e = gui::StaticText::add(Environment, spec.flabel.c_str(), + rect, false, false, data->current_parent, spec.fid); + e->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_CENTER); + + e->setNotClipped(style.getBool(StyleSpec::NOCLIP, false)); + e->setOverrideColor(style.getColor(StyleSpec::TEXTCOLOR, video::SColor(0xFFFFFFFF))); + e->setOverrideFont(font); + m_fields.push_back(spec); + + // vertlabels should let events through + e->grab(); + m_clickthrough_elements.push_back(e); return; } errorstream<< "Invalid vertlabel element(" << parts.size() << "): '" << element << "'" << std::endl; @@ -1308,29 +1950,28 @@ void GUIFormSpecMenu::parseImageButton(parserData* data, const std::string &elem MY_CHECKPOS("imagebutton",0); MY_CHECKGEOM("imagebutton",1); - v2s32 pos = getElementBasePos(false, &v_pos); - v2s32 geom; - geom.X = (stof(v_geom[0]) * spacing.X) - (spacing.X - imgsize.X); - geom.Y = (stof(v_geom[1]) * spacing.Y) - (spacing.Y - imgsize.Y); - - bool noclip = false; - bool drawborder = true; std::string pressed_image_name; - if (parts.size() >= 7) { - if (parts[5] == "true") - noclip = true; - if (parts[6] == "false") - drawborder = false; - } - if (parts.size() >= 8) { pressed_image_name = parts[7]; } - core::rect rect = core::rect(pos.X, pos.Y, pos.X+geom.X, pos.Y+geom.Y); + v2s32 pos; + v2s32 geom; - if(!data->explicit_size) + if (data->real_coordinates) { + pos = getRealCoordinateBasePos(v_pos); + geom = getRealCoordinateGeometry(v_geom); + } else { + pos = getElementBasePos(&v_pos); + geom.X = (stof(v_geom[0]) * spacing.X) - (spacing.X - imgsize.X); + geom.Y = (stof(v_geom[1]) * spacing.Y) - (spacing.Y - imgsize.Y); + } + + core::rect rect = core::rect(pos.X, pos.Y, pos.X+geom.X, + pos.Y+geom.Y); + + if (!data->explicit_size) warningstream<<"invalid use of image_button without a size[] element"<getTexture(image_name); - if (!pressed_image_name.empty()) - pressed_texture = m_tsrc->getTexture(pressed_image_name); - else - pressed_texture = texture; - - gui::IGUIButton *e = Environment->addButton(rect, this, spec.fid, spec.flabel.c_str()); + GUIButtonImage *e = GUIButtonImage::addButton(Environment, rect, m_tsrc, + data->current_parent, spec.fid, spec.flabel.c_str()); - if (spec.fname == data->focused_fieldname) { + if (spec.fname == m_focused_element) { Environment->setFocus(e); } - e->setUseAlphaChannel(true); - e->setImage(guiScalingImageButton( - Environment->getVideoDriver(), texture, geom.X, geom.Y)); - e->setPressedImage(guiScalingImageButton( - Environment->getVideoDriver(), pressed_texture, geom.X, geom.Y)); + auto style = getStyleForElement("image_button", spec.fname); + + // Override style properties with values specified directly in the element + if (!image_name.empty()) + style[StyleSpec::STATE_DEFAULT].set(StyleSpec::FGIMG, image_name); + + if (!pressed_image_name.empty()) + style[StyleSpec::STATE_PRESSED].set(StyleSpec::FGIMG, pressed_image_name); + + if (parts.size() >= 7) { + style[StyleSpec::STATE_DEFAULT].set(StyleSpec::NOCLIP, parts[5]); + style[StyleSpec::STATE_DEFAULT].set(StyleSpec::BORDER, parts[6]); + } + + e->setStyles(style); e->setScaleImage(true); - e->setNotClipped(noclip); - e->setDrawBorder(drawborder); m_fields.push_back(spec); return; @@ -1380,25 +2022,43 @@ void GUIFormSpecMenu::parseImageButton(parserData* data, const std::string &elem void GUIFormSpecMenu::parseTabHeader(parserData* data, const std::string &element) { - std::vector parts = split(element,';'); + std::vector parts = split(element, ';'); - if (((parts.size() == 4) || (parts.size() == 6)) || - ((parts.size() > 6) && (m_formspec_version > FORMSPEC_API_VERSION))) + if (((parts.size() == 4) || (parts.size() == 6)) || (parts.size() == 7 && + data->real_coordinates) || ((parts.size() > 6) && + (m_formspec_version > FORMSPEC_API_VERSION))) { std::vector v_pos = split(parts[0],','); - std::string name = parts[1]; - std::vector buttons = split(parts[2],','); - std::string str_index = parts[3]; + + // If we're using real coordinates, add an extra field for height. + // Width is not here because tabs are the width of the text, and + // there's no reason to change that. + unsigned int i = 0; + std::vector v_geom = {"1", "1"}; // Dummy width and height + bool auto_width = true; + if (parts.size() == 7) { + i++; + + v_geom = split(parts[1], ','); + if (v_geom.size() == 1) + v_geom.insert(v_geom.begin(), "1"); // Dummy value + else + auto_width = false; + } + + std::string name = parts[i+1]; + std::vector buttons = split(parts[i+2], ','); + std::string str_index = parts[i+3]; bool show_background = true; bool show_border = true; - int tab_index = stoi(str_index) -1; + int tab_index = stoi(str_index) - 1; - MY_CHECKPOS("tabheader",0); + MY_CHECKPOS("tabheader", 0); - if (parts.size() == 6) { - if (parts[4] == "true") + if (parts.size() == 6 + i) { + if (parts[4+i] == "true") show_background = false; - if (parts[5] == "false") + if (parts[5+i] == "false") show_border = false; } @@ -1406,40 +2066,55 @@ void GUIFormSpecMenu::parseTabHeader(parserData* data, const std::string &elemen name, L"", L"", - 258+m_fields.size() + 258 + m_fields.size() ); spec.ftype = f_TabHeader; v2s32 pos; - { + v2s32 geom; + + if (data->real_coordinates) { + pos = getRealCoordinateBasePos(v_pos); + + geom = getRealCoordinateGeometry(v_geom); + // Set default height + if (parts.size() <= 6) + geom.Y = m_btn_height * 2; + pos.Y -= geom.Y; // TabHeader base pos is the bottom, not the top. + if (auto_width) + geom.X = DesiredRect.getWidth(); // Set automatic width + + MY_CHECKGEOM("tabheader", 1); + } else { v2f32 pos_f = pos_offset * spacing; pos_f.X += stof(v_pos[0]) * spacing.X; pos_f.Y += stof(v_pos[1]) * spacing.Y - m_btn_height * 2; pos = v2s32(pos_f.X, pos_f.Y); + + geom.Y = m_btn_height * 2; + geom.X = DesiredRect.getWidth(); } - v2s32 geom; - geom.X = DesiredRect.getWidth(); - geom.Y = m_btn_height*2; core::rect rect = core::rect(pos.X, pos.Y, pos.X+geom.X, pos.Y+geom.Y); - gui::IGUITabControl *e = Environment->addTabControl(rect, this, - show_background, show_border, spec.fid); + gui::IGUITabControl *e = Environment->addTabControl(rect, + data->current_parent, show_background, show_border, spec.fid); e->setAlignment(irr::gui::EGUIA_UPPERLEFT, irr::gui::EGUIA_UPPERLEFT, irr::gui::EGUIA_UPPERLEFT, irr::gui::EGUIA_LOWERRIGHT); - e->setTabHeight(m_btn_height*2); + e->setTabHeight(geom.Y); - if (spec.fname == data->focused_fieldname) { - Environment->setFocus(e); - } - - e->setNotClipped(true); + auto style = getDefaultStyleForElement("tabheader", name); + e->setNotClipped(style.getBool(StyleSpec::NOCLIP, true)); for (const std::string &button : buttons) { - e->addTab(unescape_translate(unescape_string( + auto tab = e->addTab(unescape_translate(unescape_string( utf8_to_wide(button))).c_str(), -1); + if (style.isNotDefault(StyleSpec::BGCOLOR)) + tab->setBackgroundColor(style.getColor(StyleSpec::BGCOLOR)); + + tab->setTextColor(style.getColor(StyleSpec::TEXTCOLOR, video::SColor(0xFFFFFFFF))); } if ((tab_index >= 0) && @@ -1456,7 +2131,6 @@ void GUIFormSpecMenu::parseTabHeader(parserData* data, const std::string &elemen void GUIFormSpecMenu::parseItemImageButton(parserData* data, const std::string &element) { - if (m_client == 0) { warningstream << "invalid use of item_image_button with m_client==0" << std::endl; @@ -1480,10 +2154,17 @@ void GUIFormSpecMenu::parseItemImageButton(parserData* data, const std::string & MY_CHECKPOS("itemimagebutton",0); MY_CHECKGEOM("itemimagebutton",1); - v2s32 pos = getElementBasePos(false, &v_pos); + v2s32 pos; v2s32 geom; - geom.X = (stof(v_geom[0]) * spacing.X) - (spacing.X - imgsize.X); - geom.Y = (stof(v_geom[1]) * spacing.Y) - (spacing.Y - imgsize.Y); + + if (data->real_coordinates) { + pos = getRealCoordinateBasePos(v_pos); + geom = getRealCoordinateGeometry(v_geom); + } else { + pos = getElementBasePos(&v_pos); + geom.X = (stof(v_geom[0]) * spacing.X) - (spacing.X - imgsize.X); + geom.Y = (stof(v_geom[1]) * spacing.Y) - (spacing.Y - imgsize.Y); + } core::rect rect = core::rect(pos.X, pos.Y, pos.X+geom.X, pos.Y+geom.Y); @@ -1499,27 +2180,30 @@ void GUIFormSpecMenu::parseItemImageButton(parserData* data, const std::string & m_default_tooltip_bgcolor, m_default_tooltip_color); - FieldSpec spec( + // the spec for the button + FieldSpec spec_btn( name, utf8_to_wide(label), utf8_to_wide(item_name), - 258 + m_fields.size() + 258 + m_fields.size(), + 2 ); - gui::IGUIButton *e = Environment->addButton(rect, this, spec.fid, L""); + GUIButtonItemImage *e_btn = GUIButtonItemImage::addButton(Environment, + rect, m_tsrc, data->current_parent, spec_btn.fid, spec_btn.flabel.c_str(), + item_name, m_client); - if (spec.fname == data->focused_fieldname) { - Environment->setFocus(e); - } + auto style = getStyleForElement("item_image_button", spec_btn.fname, "image_button"); + e_btn->setStyles(style); - spec.ftype = f_Button; - rect+=data->basepos-padding; - spec.rect=rect; - m_fields.push_back(spec); + if (spec_btn.fname == m_focused_element) { + Environment->setFocus(e_btn); + } - pos = getElementBasePos(true, &v_pos); - m_itemimages.emplace_back("", item_name, e, pos, geom); - m_static_texts.emplace_back(utf8_to_wide(label), rect, e); + spec_btn.ftype = f_Button; + rect += data->basepos-padding; + spec_btn.rect = rect; + m_fields.push_back(spec_btn); return; } errorstream<< "Invalid ItemImagebutton element(" << parts.size() << "): '" << element << "'" << std::endl; @@ -1527,55 +2211,101 @@ void GUIFormSpecMenu::parseItemImageButton(parserData* data, const std::string & void GUIFormSpecMenu::parseBox(parserData* data, const std::string &element) { - std::vector parts = split(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::vector v_pos = split(parts[0], ','); + std::vector v_geom = split(parts[1], ','); - MY_CHECKPOS("box",0); - MY_CHECKGEOM("box",1); + MY_CHECKPOS("box", 0); + MY_CHECKGEOM("box", 1); - v2s32 pos = getElementBasePos(true, &v_pos); + v2s32 pos; v2s32 geom; - geom.X = stof(v_geom[0]) * spacing.X; - geom.Y = stof(v_geom[1]) * spacing.Y; - video::SColor tmp_color; + if (data->real_coordinates) { + pos = getRealCoordinateBasePos(v_pos); + geom = getRealCoordinateGeometry(v_geom); + } else { + pos = getElementBasePos(&v_pos); + geom.X = stof(v_geom[0]) * spacing.X; + geom.Y = stof(v_geom[1]) * spacing.Y; + } + + FieldSpec spec( + "", + L"", + L"", + 258 + m_fields.size(), + -2 + ); + spec.ftype = f_Box; - if (parseColorString(parts[2], tmp_color, false, 0x8C)) { - BoxDrawSpec spec(pos, geom, tmp_color); + auto style = getDefaultStyleForElement("box", spec.fname); - m_boxes.push_back(spec); - } - else { - errorstream<< "Invalid Box element(" << parts.size() << "): '" << element << "' INVALID COLOR" << std::endl; + video::SColor tmp_color; + std::array colors; + std::array bordercolors = {0x0, 0x0, 0x0, 0x0}; + std::array borderwidths = {0, 0, 0, 0}; + + if (parseColorString(parts[2], tmp_color, true, 0x8C)) { + colors = {tmp_color, tmp_color, tmp_color, tmp_color}; + } else { + colors = style.getColorArray(StyleSpec::COLORS, {0x0, 0x0, 0x0, 0x0}); + bordercolors = style.getColorArray(StyleSpec::BORDERCOLORS, + {0x0, 0x0, 0x0, 0x0}); + borderwidths = style.getIntArray(StyleSpec::BORDERWIDTHS, {0, 0, 0, 0}); } + + core::rect rect(pos, pos + geom); + + GUIBox *e = new GUIBox(Environment, data->current_parent, spec.fid, rect, + colors, bordercolors, borderwidths); + e->setNotClipped(style.getBool(StyleSpec::NOCLIP, m_formspec_version < 3)); + e->drop(); + + m_fields.push_back(spec); return; } - errorstream<< "Invalid Box element(" << parts.size() << "): '" << element << "'" << std::endl; + errorstream << "Invalid Box element(" << parts.size() << "): '" << element + << "'" << std::endl; } void GUIFormSpecMenu::parseBackgroundColor(parserData* data, const std::string &element) { std::vector parts = split(element,';'); + const u32 parameter_count = parts.size(); + + if ((parameter_count > 2 && m_formspec_version < 3) || + (parameter_count > 3 && m_formspec_version <= FORMSPEC_API_VERSION)) { + errorstream << "Invalid bgcolor element(" << parameter_count << "): '" + << element << "'" << std::endl; + return; + } - if (((parts.size() == 1) || (parts.size() == 2)) || - ((parts.size() > 2) && (m_formspec_version > FORMSPEC_API_VERSION))) { + // bgcolor + if (parameter_count >= 1 && parts[0] != "") parseColorString(parts[0], m_bgcolor, false); - if (parts.size() == 2) { - std::string fullscreen = parts[1]; - m_bgfullscreen = is_yes(fullscreen); + // fullscreen + if (parameter_count >= 2) { + if (parts[1] == "both") { + m_bgnonfullscreen = true; + m_bgfullscreen = true; + } else if (parts[1] == "neither") { + m_bgnonfullscreen = false; + m_bgfullscreen = false; + } else if (parts[1] != "" || m_formspec_version < 3) { + m_bgfullscreen = is_yes(parts[1]); + m_bgnonfullscreen = !m_bgfullscreen; } - - return; } - errorstream << "Invalid bgcolor element(" << parts.size() << "): '" << element << "'" - << std::endl; + // fbgcolor + if (parameter_count >= 3 && parts[2] != "") + parseColorString(parts[2], m_fullscreen_bgcolor, false); } void GUIFormSpecMenu::parseListColors(parserData* data, const std::string &element) @@ -1585,12 +2315,13 @@ void GUIFormSpecMenu::parseListColors(parserData* data, const std::string &eleme if (((parts.size() == 2) || (parts.size() == 3) || (parts.size() == 5)) || ((parts.size() > 5) && (m_formspec_version > FORMSPEC_API_VERSION))) { - parseColorString(parts[0], m_slotbg_n, false); - parseColorString(parts[1], m_slotbg_h, false); + parseColorString(parts[0], data->inventorylist_options.slotbg_n, false); + parseColorString(parts[1], data->inventorylist_options.slotbg_h, false); if (parts.size() >= 3) { - if (parseColorString(parts[2], m_slotbordercolor, false)) { - m_slotborder = true; + if (parseColorString(parts[2], data->inventorylist_options.slotbordercolor, + false)) { + data->inventorylist_options.slotborder = true; } } if (parts.size() == 5) { @@ -1601,6 +2332,14 @@ void GUIFormSpecMenu::parseListColors(parserData* data, const std::string &eleme if (parseColorString(parts[4], tmp_color, false)) m_default_tooltip_color = tmp_color; } + + // update all already parsed inventorylists + for (GUIInventoryList *e : m_inventorylists) { + e->setSlotBGColors(data->inventorylist_options.slotbg_n, + data->inventorylist_options.slotbg_h); + e->setSlotBorders(data->inventorylist_options.slotborder, + data->inventorylist_options.slotbordercolor); + } return; } errorstream<< "Invalid listcolors element(" << parts.size() << "): '" << element << "'" << std::endl; @@ -1644,16 +2383,39 @@ void GUIFormSpecMenu::parseTooltip(parserData* data, const std::string &element) std::vector v_pos = split(parts[0], ','); std::vector v_geom = split(parts[1], ','); - MY_CHECKPOS("tooltip", 0); + MY_CHECKPOS("tooltip", 0); MY_CHECKGEOM("tooltip", 1); - v2s32 pos = getElementBasePos(true, &v_pos); + v2s32 pos; v2s32 geom; - geom.X = stof(v_geom[0]) * spacing.X; - geom.Y = stof(v_geom[1]) * spacing.Y; - irr::core::rect rect(pos, pos + geom); - m_tooltip_rects.emplace_back(rect, spec); + if (data->real_coordinates) { + pos = getRealCoordinateBasePos(v_pos); + geom = getRealCoordinateGeometry(v_geom); + } else { + pos = getElementBasePos(&v_pos); + geom.X = stof(v_geom[0]) * spacing.X; + geom.Y = stof(v_geom[1]) * spacing.Y; + } + + FieldSpec fieldspec( + "", + L"", + L"", + 258 + m_fields.size() + ); + + core::rect rect(pos, pos + geom); + + gui::IGUIElement *e = new gui::IGUIElement(EGUIET_ELEMENT, Environment, + data->current_parent, fieldspec.fid, rect); + + // the element the rect tooltip is bound to should not block mouse-clicks + e->setVisible(false); + + m_fields.push_back(fieldspec); + m_tooltip_rects.emplace_back(e, spec); + } else { m_tooltips[parts[0]] = spec; } @@ -1671,7 +2433,7 @@ bool GUIFormSpecMenu::parseVersionDirect(const std::string &data) return false; } - if (parts[0] != "formspec_version") { + if (trim(parts[0]) != "formspec_version") { return false; } @@ -1700,7 +2462,7 @@ bool GUIFormSpecMenu::parseSizeDirect(parserData* data, const std::string &eleme return false; if (type == "invsize") - log_deprecated("Deprecated formspec element \"invsize\" is used"); + warningstream << "Deprecated formspec element \"invsize\" is used" << std::endl; parseSize(data, description); @@ -1776,30 +2538,178 @@ void GUIFormSpecMenu::parseAnchor(parserData *data, const std::string &element) << "'" << std::endl; } -void GUIFormSpecMenu::parseElement(parserData* data, const std::string &element) +bool GUIFormSpecMenu::parseStyle(parserData *data, const std::string &element, bool style_type) { - //some prechecks - if (element.empty()) - return; + std::vector parts = split(element, ';'); - std::vector parts = split(element,'['); + if (parts.size() < 2) { + errorstream << "Invalid style element (" << parts.size() << "): '" << element + << "'" << std::endl; + return false; + } + + StyleSpec spec; + + // Parse properties + for (size_t i = 1; i < parts.size(); i++) { + size_t equal_pos = parts[i].find('='); + if (equal_pos == std::string::npos) { + errorstream << "Invalid style element (Property missing value): '" << element + << "'" << std::endl; + return false; + } + + std::string propname = trim(parts[i].substr(0, equal_pos)); + std::string value = trim(unescape_string(parts[i].substr(equal_pos + 1))); - // ugly workaround to keep compatibility - if (parts.size() > 2) { - if (trim(parts[0]) == "image") { - for (unsigned int i=2;i< parts.size(); i++) { - parts[1] += "[" + parts[i]; + std::transform(propname.begin(), propname.end(), propname.begin(), ::tolower); + + StyleSpec::Property prop = StyleSpec::GetPropertyByName(propname); + if (prop == StyleSpec::NONE) { + if (property_warned.find(propname) != property_warned.end()) { + warningstream << "Invalid style element (Unknown property " << propname << "): '" + << element + << "'" << std::endl; + property_warned.insert(propname); } + continue; } - else { return; } + + spec.set(prop, value); } - if (parts.size() < 2) { + std::vector selectors = split(parts[0], ','); + for (size_t sel = 0; sel < selectors.size(); sel++) { + std::string selector = trim(selectors[sel]); + + // Copy the style properties to a new StyleSpec + // This allows a separate state mask per-selector + StyleSpec selector_spec = spec; + + // Parse state information, if it exists + bool state_valid = true; + size_t state_pos = selector.find(':'); + if (state_pos != std::string::npos) { + std::string state_str = selector.substr(state_pos + 1); + selector = selector.substr(0, state_pos); + + if (state_str.empty()) { + errorstream << "Invalid style element (Invalid state): '" << element + << "'" << std::endl; + state_valid = false; + } else { + std::vector states = split(state_str, '+'); + for (std::string &state : states) { + StyleSpec::State converted = StyleSpec::getStateByName(state); + if (converted == StyleSpec::STATE_INVALID) { + infostream << "Unknown style state " << state << + " in element '" << element << "'" << std::endl; + state_valid = false; + break; + } + + selector_spec.addState(converted); + } + } + } + + if (!state_valid) { + // Skip this selector + continue; + } + + if (style_type) { + theme_by_type[selector].push_back(selector_spec); + } else { + theme_by_name[selector].push_back(selector_spec); + } + + // Backwards-compatibility for existing _hovered/_pressed properties + if (selector_spec.hasProperty(StyleSpec::BGCOLOR_HOVERED) + || selector_spec.hasProperty(StyleSpec::BGIMG_HOVERED) + || selector_spec.hasProperty(StyleSpec::FGIMG_HOVERED)) { + StyleSpec hover_spec; + hover_spec.addState(StyleSpec::STATE_HOVERED); + + if (selector_spec.hasProperty(StyleSpec::BGCOLOR_HOVERED)) { + hover_spec.set(StyleSpec::BGCOLOR, selector_spec.get(StyleSpec::BGCOLOR_HOVERED, "")); + } + if (selector_spec.hasProperty(StyleSpec::BGIMG_HOVERED)) { + hover_spec.set(StyleSpec::BGIMG, selector_spec.get(StyleSpec::BGIMG_HOVERED, "")); + } + if (selector_spec.hasProperty(StyleSpec::FGIMG_HOVERED)) { + hover_spec.set(StyleSpec::FGIMG, selector_spec.get(StyleSpec::FGIMG_HOVERED, "")); + } + + if (style_type) { + theme_by_type[selector].push_back(hover_spec); + } else { + theme_by_name[selector].push_back(hover_spec); + } + } + if (selector_spec.hasProperty(StyleSpec::BGCOLOR_PRESSED) + || selector_spec.hasProperty(StyleSpec::BGIMG_PRESSED) + || selector_spec.hasProperty(StyleSpec::FGIMG_PRESSED)) { + StyleSpec press_spec; + press_spec.addState(StyleSpec::STATE_PRESSED); + + if (selector_spec.hasProperty(StyleSpec::BGCOLOR_PRESSED)) { + press_spec.set(StyleSpec::BGCOLOR, selector_spec.get(StyleSpec::BGCOLOR_PRESSED, "")); + } + if (selector_spec.hasProperty(StyleSpec::BGIMG_PRESSED)) { + press_spec.set(StyleSpec::BGIMG, selector_spec.get(StyleSpec::BGIMG_PRESSED, "")); + } + if (selector_spec.hasProperty(StyleSpec::FGIMG_PRESSED)) { + press_spec.set(StyleSpec::FGIMG, selector_spec.get(StyleSpec::FGIMG_PRESSED, "")); + } + + if (style_type) { + theme_by_type[selector].push_back(press_spec); + } else { + theme_by_name[selector].push_back(press_spec); + } + } + } + + return true; +} + +void GUIFormSpecMenu::parseSetFocus(const std::string &element) +{ + std::vector parts = split(element, ';'); + + if (parts.size() <= 2 || + (parts.size() > 2 && m_formspec_version > FORMSPEC_API_VERSION)) + { + if (m_is_form_regenerated) + return; // Never focus on resizing + + bool force_focus = parts.size() >= 2 && is_yes(parts[1]); + if (force_focus || m_text_dst->m_formname != m_last_formname) + setFocus(parts[0]); + return; } - std::string type = trim(parts[0]); - std::string description = trim(parts[1]); + errorstream << "Invalid set_focus element (" << parts.size() << "): '" << element + << "'" << std::endl; +} + +void GUIFormSpecMenu::parseElement(parserData* data, const std::string &element) +{ + //some prechecks + if (element.empty()) + return; + + if (parseVersionDirect(element)) + return; + + size_t pos = element.find('['); + if (pos == std::string::npos) + return; + + std::string type = trim(element.substr(0, pos)); + std::string description = element.substr(pos+1); if (type == "container") { parseContainer(data, description); @@ -1831,6 +2741,11 @@ void GUIFormSpecMenu::parseElement(parserData* data, const std::string &element) return; } + if (type == "animated_image") { + parseAnimatedImage(data, description); + return; + } + if (type == "item_image") { parseItemImage(data, description); return; @@ -1841,8 +2756,8 @@ void GUIFormSpecMenu::parseElement(parserData* data, const std::string &element) return; } - if (type == "background") { - parseBackground(data,description); + if (type == "background" || type == "background9") { + parseBackground(data, description); return; } @@ -1886,6 +2801,11 @@ void GUIFormSpecMenu::parseElement(parserData* data, const std::string &element) return; } + if (type == "hypertext") { + parseHyperText(data,description); + return; + } + if (type == "label") { parseLabel(data,description); return; @@ -1931,8 +2851,43 @@ void GUIFormSpecMenu::parseElement(parserData* data, const std::string &element) return; } - if (type == "scrollbar") { - parseScrollBar(data, description); + if (type == "scrollbar") { + parseScrollBar(data, description); + return; + } + + if (type == "real_coordinates") { + data->real_coordinates = is_yes(description); + return; + } + + if (type == "style") { + parseStyle(data, description, false); + return; + } + + if (type == "style_type") { + parseStyle(data, description, true); + return; + } + + if (type == "scrollbaroptions") { + parseScrollBarOptions(data, description); + return; + } + + if (type == "scroll_container") { + parseScrollContainer(data, description); + return; + } + + if (type == "scroll_container_end") { + parseScrollContainerEnd(data); + return; + } + + if (type == "set_focus") { + parseSetFocus(description); return; } @@ -1943,72 +2898,94 @@ void GUIFormSpecMenu::parseElement(parserData* data, const std::string &element) void GUIFormSpecMenu::regenerateGui(v2u32 screensize) { - /* useless to regenerate without a screensize */ + // Useless to regenerate without a screensize if ((screensize.X <= 0) || (screensize.Y <= 0)) { return; } parserData mydata; - //preserve tables - for (auto &m_table : m_tables) { - std::string tablename = m_table.first.fname; - GUITable *table = m_table.second; - mydata.table_dyndata[tablename] = table->getDynamicData(); - } - - //set focus - if (!m_focused_element.empty()) - mydata.focused_fieldname = m_focused_element; + // Preserve stuff only on same form, not on a new form. + if (m_text_dst->m_formname == m_last_formname) { + // Preserve tables/textlists + for (auto &m_table : m_tables) { + std::string tablename = m_table.first.fname; + GUITable *table = m_table.second; + mydata.table_dyndata[tablename] = table->getDynamicData(); + } - //preserve focus - gui::IGUIElement *focused_element = Environment->getFocus(); - if (focused_element && focused_element->getParent() == this) { - s32 focused_id = focused_element->getID(); - if (focused_id > 257) { - for (const GUIFormSpecMenu::FieldSpec &field : m_fields) { - if (field.fid == focused_id) { - mydata.focused_fieldname = field.fname; - break; + // Preserve focus + gui::IGUIElement *focused_element = Environment->getFocus(); + if (focused_element && focused_element->getParent() == this) { + s32 focused_id = focused_element->getID(); + if (focused_id > 257) { + for (const GUIFormSpecMenu::FieldSpec &field : m_fields) { + if (field.fid == focused_id) { + m_focused_element = field.fname; + break; + } } } } + } else { + // Don't keep old focus value + m_focused_element = ""; } // Remove children removeChildren(); - for (auto &table_it : m_tables) { + for (auto &table_it : m_tables) table_it.second->drop(); - } - - mydata.size= v2s32(100,100); + for (auto &inventorylist_it : m_inventorylists) + inventorylist_it->drop(); + for (auto &checkbox_it : m_checkboxes) + checkbox_it.second->drop(); + for (auto &scrollbar_it : m_scrollbars) + scrollbar_it.second->drop(); + for (auto &background_it : m_backgrounds) + background_it->drop(); + for (auto &tooltip_rect_it : m_tooltip_rects) + tooltip_rect_it.first->drop(); + for (auto &clickthrough_it : m_clickthrough_elements) + clickthrough_it->drop(); + for (auto &scroll_container_it : m_scroll_containers) + scroll_container_it.second->drop(); + + mydata.size = v2s32(100, 100); mydata.screensize = screensize; mydata.offset = v2f32(0.5f, 0.5f); mydata.anchor = v2f32(0.5f, 0.5f); + mydata.simple_field_count = 0; // Base position of contents of form mydata.basepos = getBasePos(); - /* Convert m_init_draw_spec to m_inventorylists */ + // the parent for the parsed elements + mydata.current_parent = this; m_inventorylists.clear(); - m_images.clear(); m_backgrounds.clear(); - m_itemimages.clear(); m_tables.clear(); m_checkboxes.clear(); m_scrollbars.clear(); m_fields.clear(); - m_boxes.clear(); m_tooltips.clear(); m_tooltip_rects.clear(); m_inventory_rings.clear(); - m_static_texts.clear(); m_dropdowns.clear(); - + m_scroll_containers.clear(); + theme_by_name.clear(); + theme_by_type.clear(); + m_clickthrough_elements.clear(); + field_close_on_enter.clear(); + m_dropdown_index_event.clear(); + + m_bgnonfullscreen = true; m_bgfullscreen = false; + m_formspec_version = 1; + { v3f formspec_bgcolor = g_settings->getV3F("formspec_default_bg_color"); m_bgcolor = video::SColor( @@ -2029,15 +3006,9 @@ void GUIFormSpecMenu::regenerateGui(v2u32 screensize) ); } - m_slotbg_n = video::SColor(255,128,128,128); - m_slotbg_h = video::SColor(255,192,192,192); - m_default_tooltip_bgcolor = video::SColor(255,110,130,60); m_default_tooltip_color = video::SColor(255,255,255,255); - m_slotbordercolor = video::SColor(200,0,0,0); - m_slotborder = false; - // Add tooltip { assert(!m_tooltip_element); @@ -2100,6 +3071,17 @@ void GUIFormSpecMenu::regenerateGui(v2u32 screensize) break; } + /* Copy of the "real_coordinates" element for after the form size. */ + mydata.real_coordinates = m_formspec_version >= 2; + for (; i < elements.size(); i++) { + std::vector parts = split(elements[i], '['); + std::string name = trim(parts[0]); + if (name != "real_coordinates" || parts.size() != 2) + break; // Invalid format + + mydata.real_coordinates = is_yes(trim(parts[1])); + } + if (mydata.explicit_size) { // compute scaling for specified form size if (m_lock) { @@ -2137,42 +3119,42 @@ void GUIFormSpecMenu::regenerateGui(v2u32 screensize) // and default scaling (1.00). use_imgsize = 0.5555 * screen_dpi * gui_scaling; } else { - // In variable-size mode, we prefer to make the - // inventory image size 1/15 of screen height, - // multiplied by the gui_scaling config parameter. - // If the preferred size won't fit the whole - // form on the screen, either horizontally or - // vertically, then we scale it down to fit. - // (The magic numbers in the computation of what - // fits arise from the scaling factors in the - // following stanza, including the form border, - // help text space, and 0.1 inventory slot spare.) - // However, a minimum size is also set, that - // the image size can't be less than 0.3 inch - // multiplied by gui_scaling, even if this means - // the form doesn't fit the screen. + // Variables for the maximum imgsize that can fit in the screen. + double fitx_imgsize; + double fity_imgsize; + + // Pad the screensize with 5% of the screensize on all sides to ensure + // that even the largest formspecs don't touch the screen borders. + v2f padded_screensize( + mydata.screensize.X * 0.9f, + mydata.screensize.Y * 0.9f + ); + + if (mydata.real_coordinates) { + fitx_imgsize = padded_screensize.X / mydata.invsize.X; + fity_imgsize = padded_screensize.Y / mydata.invsize.Y; + } else { + // The maximum imgsize in the old coordinate system also needs to + // factor in padding and spacing along with 0.1 inventory slot spare + // and help text space, hence the magic numbers. + fitx_imgsize = padded_screensize.X / + ((5.0 / 4.0) * (0.5 + mydata.invsize.X)); + fity_imgsize = padded_screensize.Y / + ((15.0 / 13.0) * (0.85 + mydata.invsize.Y)); + } + #ifdef __ANDROID__ - // For mobile devices these magic numbers are - // different and forms should always use the - // maximum screen space available. - double prefer_imgsize = mydata.screensize.Y / 10 * gui_scaling; - double fitx_imgsize = mydata.screensize.X / - ((12.0 / 8.0) * (0.5 + mydata.invsize.X)); - double fity_imgsize = mydata.screensize.Y / - ((15.0 / 11.0) * (0.85 + mydata.invsize.Y)); - use_imgsize = MYMIN(prefer_imgsize, - MYMIN(fitx_imgsize, fity_imgsize)); + // In Android, the preferred imgsize should be larger to accommodate the + // smaller screensize. + double prefer_imgsize = padded_screensize.Y / 10 * gui_scaling; #else - double prefer_imgsize = mydata.screensize.Y / 15 * gui_scaling; - double fitx_imgsize = mydata.screensize.X / - ((5.0 / 4.0) * (0.5 + mydata.invsize.X)); - double fity_imgsize = mydata.screensize.Y / - ((15.0 / 13.0) * (0.85 * mydata.invsize.Y)); - double screen_dpi = RenderingEngine::getDisplayDensity() * 96; - double min_imgsize = 0.3 * screen_dpi * gui_scaling; - use_imgsize = MYMAX(min_imgsize, MYMIN(prefer_imgsize, - MYMIN(fitx_imgsize, fity_imgsize))); + // Desktop computers have more space, so try to fit 15 coordinates. + double prefer_imgsize = padded_screensize.Y / 15 * gui_scaling; #endif + // Try to use the preferred imgsize, but if that's bigger than the maximum + // size, use the maximum size. + use_imgsize = std::min(prefer_imgsize, + std::min(fitx_imgsize, fity_imgsize)); } // Everything else is scaled in proportion to the @@ -2190,10 +3172,18 @@ void GUIFormSpecMenu::regenerateGui(v2u32 screensize) m_font = g_fontengine->getFont(); - mydata.size = v2s32( - padding.X*2+spacing.X*(mydata.invsize.X-1.0)+imgsize.X, - padding.Y*2+spacing.Y*(mydata.invsize.Y-1.0)+imgsize.Y + m_btn_height*2.0/3.0 - ); + if (mydata.real_coordinates) { + mydata.size = v2s32( + mydata.invsize.X*imgsize.X, + mydata.invsize.Y*imgsize.Y + ); + } else { + mydata.size = v2s32( + padding.X*2+spacing.X*(mydata.invsize.X-1.0)+imgsize.X, + padding.Y*2+spacing.Y*(mydata.invsize.Y-1.0)+imgsize.Y + m_btn_height*2.0/3.0 + ); + } + DesiredRect = mydata.rect = core::rect( (s32)((f32)mydata.screensize.X * mydata.offset.X) - (s32)(mydata.anchor.X * (f32)mydata.size.X) + offset.X, (s32)((f32)mydata.screensize.Y * mydata.offset.Y) - (s32)(mydata.anchor.Y * (f32)mydata.size.Y) + offset.Y, @@ -2224,57 +3214,142 @@ void GUIFormSpecMenu::regenerateGui(v2u32 screensize) pos_offset = v2f32(); + // used for formspec versions < 3 + core::list::Iterator legacy_sort_start = Children.getLast(); + if (enable_prepends) { + // Backup the coordinates so that prepends can use the coordinates of choice. + bool rc_backup = mydata.real_coordinates; + u16 version_backup = m_formspec_version; + mydata.real_coordinates = false; // Old coordinates by default. + std::vector prepend_elements = split(m_formspec_prepend, ']'); for (const auto &element : prepend_elements) parseElement(&mydata, element); + + // legacy sorting for formspec versions < 3 + if (m_formspec_version >= 3) + // prepends do not need to be reordered + legacy_sort_start = Children.getLast(); + else if (version_backup >= 3) + // only prepends elements have to be reordered + legacySortElements(legacy_sort_start); + + m_formspec_version = version_backup; + mydata.real_coordinates = rc_backup; // Restore coordinates } for (; i< elements.size(); i++) { parseElement(&mydata, elements[i]); } - if (!container_stack.empty()) { + if (mydata.current_parent != this) { + errorstream << "Invalid formspec string: scroll_container was never closed!" + << std::endl; + } else if (!container_stack.empty()) { errorstream << "Invalid formspec string: container was never closed!" << std::endl; } + // get the scrollbar elements for scroll_containers + for (const std::pair &c : m_scroll_containers) { + for (const std::pair &b : m_scrollbars) { + if (c.first == b.first.fname) { + c.second->setScrollBar(b.second); + break; + } + } + } + // If there are fields without explicit size[], add a "Proceed" // button and adjust size to fit all the fields. - if (!m_fields.empty() && !mydata.explicit_size) { + if (mydata.simple_field_count > 0 && !mydata.explicit_size) { mydata.rect = core::rect( - mydata.screensize.X/2 - 580/2, - mydata.screensize.Y/2 - 300/2, - mydata.screensize.X/2 + 580/2, - mydata.screensize.Y/2 + 240/2+(m_fields.size()*60) + mydata.screensize.X / 2 - 580 / 2, + mydata.screensize.Y / 2 - 300 / 2, + mydata.screensize.X / 2 + 580 / 2, + mydata.screensize.Y / 2 + 240 / 2 + mydata.simple_field_count * 60 ); + DesiredRect = mydata.rect; recalculateAbsolutePosition(false); mydata.basepos = getBasePos(); { v2s32 pos = mydata.basepos; - pos.Y = ((m_fields.size()+2)*60); + pos.Y = (mydata.simple_field_count + 2) * 60; v2s32 size = DesiredRect.getSize(); - mydata.rect = - core::rect(size.X/2-70, pos.Y, - (size.X/2-70)+140, pos.Y + (m_btn_height*2)); + mydata.rect = core::rect( + size.X / 2 - 70, pos.Y, + size.X / 2 - 70 + 140, pos.Y + m_btn_height * 2 + ); const wchar_t *text = wgettext("Proceed"); - Environment->addButton(mydata.rect, this, 257, text); + GUIButton::addButton(Environment, mydata.rect, m_tsrc, this, 257, text); delete[] text; } - } - //set initial focus if parser didn't set it - focused_element = Environment->getFocus(); + // Set initial focus if parser didn't set it + gui::IGUIElement *focused_element = Environment->getFocus(); if (!focused_element || !isMyChild(focused_element) || focused_element->getType() == gui::EGUIET_TAB_CONTROL) setInitialFocus(); skin->setFont(old_font); + + // legacy sorting + if (m_formspec_version < 3) + legacySortElements(legacy_sort_start); + + // Formname and regeneration setting + if (!m_is_form_regenerated) { + // Only set previous form name if we purposefully showed a new formspec + m_last_formname = m_text_dst->m_formname; + m_is_form_regenerated = true; + } +} + +void GUIFormSpecMenu::legacySortElements(core::list::Iterator from) +{ + /* + Draw order for formspec_version <= 2: + -3 bgcolor + -2 background + -1 box + 0 All other elements + 1 image + 2 item_image, item_image_button + 3 list + 4 label + */ + + if (from == Children.end()) + from = Children.begin(); + else + from++; + + core::list::Iterator to = Children.end(); + // 1: Copy into a sortable container + std::vector elements; + for (auto it = from; it != to; ++it) + elements.emplace_back(*it); + + // 2: Sort the container + std::stable_sort(elements.begin(), elements.end(), + [this] (const IGUIElement *a, const IGUIElement *b) -> bool { + const FieldSpec *spec_a = getSpecByID(a->getID()); + const FieldSpec *spec_b = getSpecByID(b->getID()); + return spec_a && spec_b && + spec_a->priority < spec_b->priority; + }); + + // 3: Re-assign the pointers + for (auto e : elements) { + *from = e; + from++; + } } #ifdef __ANDROID__ @@ -2283,161 +3358,41 @@ bool GUIFormSpecMenu::getAndroidUIInput() if (!hasAndroidUIInput()) return false; + // still waiting + if (porting::getInputDialogState() == -1) + return true; + std::string fieldname = m_jni_field_name; m_jni_field_name.clear(); - for(std::vector::iterator iter = m_fields.begin(); - iter != m_fields.end(); ++iter) { - - if (iter->fname != fieldname) { + for (const FieldSpec &field : m_fields) { + if (field.fname != fieldname) continue; - } - IGUIElement* tochange = getElementFromId(iter->fid); - if (tochange == 0) { - return false; - } + IGUIElement *element = getElementFromId(field.fid, true); - if (tochange->getType() != irr::gui::EGUIET_EDIT_BOX) { + if (!element || element->getType() != irr::gui::EGUIET_EDIT_BOX) return false; - } std::string text = porting::getInputDialogValue(); - - ((gui::IGUIEditBox *)tochange)->setText(utf8_to_wide(text).c_str()); + ((gui::IGUIEditBox *)element)->setText(utf8_to_wide(text).c_str()); } return false; } #endif -GUIFormSpecMenu::ItemSpec GUIFormSpecMenu::getItemAtPos(v2s32 p) const -{ - core::rect imgrect(0,0,imgsize.X,imgsize.Y); - - for (const GUIFormSpecMenu::ListDrawSpec &s : m_inventorylists) { - for(s32 i=0; i rect = imgrect + s.pos + p0; - if(rect.isPointInside(p)) - { - return ItemSpec(s.inventoryloc, s.listname, item_i); - } - } - } - - return ItemSpec(InventoryLocation(), "", -1); -} - -void GUIFormSpecMenu::drawList(const ListDrawSpec &s, int layer, - bool &item_hovered) +GUIInventoryList::ItemSpec GUIFormSpecMenu::getItemAtPos(v2s32 p) const { - video::IVideoDriver* driver = Environment->getVideoDriver(); + core::rect imgrect(0, 0, imgsize.X, imgsize.Y); - Inventory *inv = m_invmgr->getInventory(s.inventoryloc); - if(!inv){ - warningstream<<"GUIFormSpecMenu::drawList(): " - <<"The inventory location " - <<"\""<getList(s.listname); - if(!ilist){ - warningstream<<"GUIFormSpecMenu::drawList(): " - <<"The inventory list \""<getItemIndexAtPos(p); + if (item_index != -1) + return GUIInventoryList::ItemSpec(e->getInventoryloc(), e->getListname(), + item_index); } - core::rect imgrect(0,0,imgsize.X,imgsize.Y); - - for (s32 i = 0; i < s.geom.X * s.geom.Y; i++) { - s32 item_i = i + s.start_item_i; - if (item_i >= (s32)ilist->getSize()) - break; - - s32 x = (i%s.geom.X) * spacing.X; - s32 y = (i/s.geom.X) * spacing.Y; - v2s32 p(x,y); - core::rect rect = imgrect + s.pos + p; - ItemStack item = ilist->getItem(item_i); - - bool selected = m_selected_item - && m_invmgr->getInventory(m_selected_item->inventoryloc) == inv - && m_selected_item->listname == s.listname - && m_selected_item->i == item_i; - bool hovering = rect.isPointInside(m_pointer); - ItemRotationKind rotation_kind = selected ? IT_ROT_SELECTED : - (hovering ? IT_ROT_HOVERED : IT_ROT_NONE); - - if (layer == 0) { - if (hovering) { - item_hovered = true; - driver->draw2DRectangle(m_slotbg_h, rect, &AbsoluteClippingRect); - } else { - driver->draw2DRectangle(m_slotbg_n, rect, &AbsoluteClippingRect); - } - } - - //Draw inv slot borders - if (m_slotborder) { - 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 (layer == 1) { - // Draw item stack - if (selected) - item.takeItem(m_selected_amount); - - if (!item.empty()) { - drawItemStack(driver, m_font, item, - rect, &AbsoluteClippingRect, m_client, - rotation_kind); - } - - // Draw tooltip - std::wstring tooltip_text; - if (hovering && !m_selected_item) { - const std::string &desc = item.metadata.getString("description"); - if (desc.empty()) - tooltip_text = - utf8_to_wide(item.getDefinition(m_client->idef()).description); - else - tooltip_text = utf8_to_wide(desc); - - if (!item.name.empty()) { - if (tooltip_text.empty()) - tooltip_text = utf8_to_wide(item.name); - else if (m_tooltip_append_itemname) - tooltip_text += utf8_to_wide("\n[" + item.name + "]"); - } - } - if (!tooltip_text.empty()) { - showTooltip(tooltip_text, m_default_tooltip_color, - m_default_tooltip_bgcolor); - } - } - } + return GUIInventoryList::ItemSpec(InventoryLocation(), "", -1); } void GUIFormSpecMenu::drawSelectedItem() @@ -2445,9 +3400,10 @@ void GUIFormSpecMenu::drawSelectedItem() video::IVideoDriver* driver = Environment->getVideoDriver(); if (!m_selected_item) { + // reset rotation time drawItemStack(driver, m_font, ItemStack(), - core::rect(v2s32(0, 0), v2s32(0, 0)), - NULL, m_client, IT_ROT_DRAGGED); + core::rect(v2s32(0, 0), v2s32(0, 0)), NULL, + m_client, IT_ROT_DRAGGED); return; } @@ -2470,6 +3426,7 @@ void GUIFormSpecMenu::drawMenu() const std::string &newform = m_form_src->getForm(); if (newform != m_formspec_string) { m_formspec_string = newform; + m_is_form_regenerated = false; regenerateGui(m_screensize_old); } } @@ -2479,22 +3436,31 @@ void GUIFormSpecMenu::drawMenu() gui::IGUIFont *old_font = skin->getFont(); skin->setFont(m_font); + m_hovered_item_tooltips.clear(); + updateSelectedItem(); video::IVideoDriver* driver = Environment->getVideoDriver(); + /* + Draw background color + */ v2u32 screenSize = driver->getScreenSize(); core::rect allbg(0, 0, screenSize.X, screenSize.Y); if (m_bgfullscreen) driver->draw2DRectangle(m_fullscreen_bgcolor, allbg, &allbg); - else + if (m_bgnonfullscreen) driver->draw2DRectangle(m_bgcolor, AbsoluteRect, &AbsoluteClippingRect); + /* + Draw rect_mode tooltip + */ m_tooltip_element->setVisible(false); for (const auto &pair : m_tooltip_rects) { - if (pair.first.isPointInside(m_pointer)) { + const core::rect &rect = pair.first->getAbsoluteClippingRect(); + if (rect.getArea() > 0 && rect.isPointInside(m_pointer)) { const std::wstring &text = pair.second.tooltip; if (!text.empty()) { showTooltip(text, pair.second.color, pair.second.bgcolor); @@ -2506,122 +3472,37 @@ void GUIFormSpecMenu::drawMenu() /* Draw backgrounds */ - for (const GUIFormSpecMenu::ImageDrawSpec &spec : m_backgrounds) { - video::ITexture *texture = m_tsrc->getTexture(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 (spec.clip) { - 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 (const GUIFormSpecMenu::BoxDrawSpec &spec : m_boxes) { - irr::video::SColor todraw = spec.color; - - core::rect rect(spec.pos.X,spec.pos.Y, - spec.pos.X + spec.geom.X,spec.pos.Y + spec.geom.Y); - - driver->draw2DRectangle(todraw, rect, 0); + for (gui::IGUIElement *e : m_backgrounds) { + e->setVisible(true); + e->draw(); + e->setVisible(false); } - /* - Call base class - */ - gui::IGUIElement::draw(); + // Some elements are only visible while being drawn + for (gui::IGUIElement *e : m_clickthrough_elements) + e->setVisible(true); /* - Draw images + This is where all the drawing happens. */ - for (const GUIFormSpecMenu::ImageDrawSpec &spec : m_images) { - video::ITexture *texture = m_tsrc->getTexture(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; - } - } + core::list::Iterator it = Children.begin(); + for (; it != Children.end(); ++it) + if ((*it)->isNotClipped() || + AbsoluteClippingRect.isRectCollided( + (*it)->getAbsolutePosition())) + (*it)->draw(); - /* - Draw item images - */ - for (const GUIFormSpecMenu::ImageDrawSpec &spec : m_itemimages) { - if (m_client == 0) - break; + for (gui::IGUIElement *e : m_clickthrough_elements) + e->setVisible(false); - IItemDefManager *idef = m_client->idef(); - 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_client, IT_ROT_NONE); + // Draw hovered item tooltips + for (const std::string &tooltip : m_hovered_item_tooltips) { + showTooltip(utf8_to_wide(tooltip), m_default_tooltip_color, + m_default_tooltip_bgcolor); } - /* - Draw items - Layer 0: Item slot rectangles - Layer 1: Item images; prepare tooltip - */ - bool item_hovered = false; - for (int layer = 0; layer < 2; layer++) { - for (const GUIFormSpecMenu::ListDrawSpec &spec : m_inventorylists) { - drawList(spec, layer, item_hovered); - } - } - if (!item_hovered) { + if (m_hovered_item_tooltips.empty()) { + // reset rotation time drawItemStack(driver, m_font, ItemStack(), core::rect(v2s32(0, 0), v2s32(0, 0)), NULL, m_client, IT_ROT_HOVERED); @@ -2633,35 +3514,25 @@ void GUIFormSpecMenu::drawMenu() #endif /* - Draw static text elements - */ - for (const GUIFormSpecMenu::StaticTextSpec &spec : m_static_texts) { - 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 + Draw fields/buttons tooltips and update the mouse cursor */ gui::IGUIElement *hovered = Environment->getRootGUIElement()->getElementFromPoint(m_pointer); +#ifndef HAVE_TOUCHSCREENGUI + gui::ICursorControl *cursor_control = RenderingEngine::get_raw_device()-> + getCursorControl(); + gui::ECURSOR_ICON current_cursor_icon = cursor_control->getActiveIcon(); +#endif + bool hovered_element_found = false; + if (hovered != NULL) { - s32 id = hovered->getID(); + if (m_show_debug) { + core::rect rect = hovered->getAbsoluteClippingRect(); + driver->draw2DRectangle(0x22FFFF00, rect, &rect); + } + s32 id = hovered->getID(); u64 delta = 0; if (id == -1) { m_old_tooltip_id = id; @@ -2674,23 +3545,41 @@ void GUIFormSpecMenu::drawMenu() } } - // Find and update the current tooltip - if (id != -1 && delta >= m_tooltip_show_delay) { + // Find and update the current tooltip and cursor icon + if (id != -1) { for (const FieldSpec &field : m_fields) { if (field.fid != id) continue; - const std::wstring &text = m_tooltips[field.fname].tooltip; - if (!text.empty()) - showTooltip(text, m_tooltips[field.fname].color, - m_tooltips[field.fname].bgcolor); + if (delta >= m_tooltip_show_delay) { + const std::wstring &text = m_tooltips[field.fname].tooltip; + if (!text.empty()) + showTooltip(text, m_tooltips[field.fname].color, + m_tooltips[field.fname].bgcolor); + } + +#ifndef HAVE_TOUCHSCREENGUI + if (field.ftype != f_HyperText && // Handled directly in guiHyperText + current_cursor_icon != field.fcursor_icon) + cursor_control->setActiveIcon(field.fcursor_icon); +#endif + + hovered_element_found = true; break; } } } + if (!hovered_element_found) { + // no element is hovered +#ifndef HAVE_TOUCHSCREENGUI + if (current_cursor_icon != ECI_NORMAL) + cursor_control->setActiveIcon(ECI_NORMAL); +#endif + } + m_tooltip_element->draw(); /* @@ -2705,19 +3594,16 @@ void GUIFormSpecMenu::drawMenu() void GUIFormSpecMenu::showTooltip(const std::wstring &text, const irr::video::SColor &color, const irr::video::SColor &bgcolor) { - const std::wstring ntext = translate_string(text); - m_tooltip_element->setOverrideColor(color); - m_tooltip_element->setBackgroundColor(bgcolor); - setStaticText(m_tooltip_element, ntext.c_str()); + EnrichedString ntext(text); + ntext.setDefaultColor(color); + ntext.setBackground(bgcolor); + + setStaticText(m_tooltip_element, ntext); // Tooltip size and offset s32 tooltip_width = m_tooltip_element->getTextWidth() + m_btn_height; -#if (IRRLICHT_VERSION_MAJOR <= 1 && IRRLICHT_VERSION_MINOR <= 8 && IRRLICHT_VERSION_REVISION < 2) || USE_FREETYPE == 1 - std::vector text_rows = str_split(ntext, L'\n'); - s32 tooltip_height = m_tooltip_element->getTextHeight() * text_rows.size() + 5; -#else s32 tooltip_height = m_tooltip_element->getTextHeight() + 5; -#endif + v2u32 screenSize = Environment->getVideoDriver()->getScreenSize(); int tooltip_offset_x = m_btn_height; int tooltip_offset_y = m_btn_height; @@ -2726,6 +3612,10 @@ void GUIFormSpecMenu::showTooltip(const std::wstring &text, tooltip_offset_y = 0; if (m_pointer.X > (s32)screenSize.X / 2) tooltip_offset_x = -(tooltip_offset_x + tooltip_width); + + // Hide tooltip after ETIE_LEFT_UP + if (m_pointer.X == 0) + return; #endif // Calculate and set the tooltip position @@ -2754,11 +3644,11 @@ void GUIFormSpecMenu::updateSelectedItem() // If craftresult is nonempty and nothing else is selected, select it now. if (!m_selected_item) { - for (const GUIFormSpecMenu::ListDrawSpec &s : m_inventorylists) { - if (s.listname != "craftpreview") + for (const GUIInventoryList *e : m_inventorylists) { + if (e->getListname() != "craftpreview") continue; - Inventory *inv = m_invmgr->getInventory(s.inventoryloc); + Inventory *inv = m_invmgr->getInventory(e->getInventoryloc()); if (!inv) continue; @@ -2772,8 +3662,8 @@ void GUIFormSpecMenu::updateSelectedItem() continue; // Grab selected item from the crafting result list - m_selected_item = new ItemSpec; - m_selected_item->inventoryloc = s.inventoryloc; + m_selected_item = new GUIInventoryList::ItemSpec; + m_selected_item->inventoryloc = e->getInventoryloc(); m_selected_item->listname = "craftresult"; m_selected_item->i = 0; m_selected_amount = item.count; @@ -2794,16 +3684,12 @@ ItemStack GUIFormSpecMenu::verifySelectedItem() // If the selected stack has become smaller, adjust m_selected_amount. // Return the selected stack. - if(m_selected_item) - { - if(m_selected_item->isValid()) - { + if (m_selected_item) { + if (m_selected_item->isValid()) { Inventory *inv = m_invmgr->getInventory(m_selected_item->inventoryloc); - if(inv) - { + if (inv) { InventoryList *list = inv->getList(m_selected_item->listname); - if(list && (u32) m_selected_item->i < list->getSize()) - { + if (list && (u32) m_selected_item->i < list->getSize()) { ItemStack stack = list->getItem(m_selected_item->i); if (!m_selected_swap.empty()) { if (m_selected_swap.name == stack.name && @@ -2821,7 +3707,7 @@ ItemStack GUIFormSpecMenu::verifySelectedItem() // selection was not valid delete m_selected_item; - m_selected_item = NULL; + m_selected_item = nullptr; m_selected_amount = 0; m_selected_dragging = false; } @@ -2870,7 +3756,7 @@ void GUIFormSpecMenu::acceptInput(FormspecQuitMode quitmode=quit_mode_no) } for (const GUIFormSpecMenu::FieldSpec &s : m_fields) { - if(s.send) { + if (s.send) { std::string name = s.fname; if (s.ftype == f_Button) { fields[name] = wide_to_utf8(s.flabel); @@ -2879,29 +3765,35 @@ void GUIFormSpecMenu::acceptInput(FormspecQuitMode quitmode=quit_mode_no) if (table) { fields[name] = table->checkEvent(); } - } - 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); + } 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, true); gui::IGUIComboBox *e = NULL; if ((element) && (element->getType() == gui::EGUIET_COMBO_BOX)) { - e = static_cast(element); + e = static_cast(element); + } else { + warningstream << "GUIFormSpecMenu::acceptInput: dropdown " + << "field without dropdown element" << std::endl; + continue; } s32 selected = e->getSelected(); if (selected >= 0) { - std::vector *dropdown_values = - getDropDownValues(s.fname); - if (dropdown_values && selected < (s32)dropdown_values->size()) { - fields[name] = (*dropdown_values)[selected]; + if (m_dropdown_index_event.find(s.fname) != + m_dropdown_index_event.end()) { + fields[name] = std::to_string(selected + 1); + } else { + std::vector *dropdown_values = + getDropDownValues(s.fname); + if (dropdown_values && selected < (s32)dropdown_values->size()) + fields[name] = (*dropdown_values)[selected]; } } - } - else if (s.ftype == f_TabHeader) { - // no dynamic cast possible due to some distributions shipped - // without rttzi support in irrlicht - IGUIElement * element = getElementFromId(s.fid); - gui::IGUITabControl *e = NULL; + } 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, true); + gui::IGUITabControl *e = nullptr; if ((element) && (element->getType() == gui::EGUIET_TAB_CONTROL)) { e = static_cast(element); } @@ -2911,12 +3803,11 @@ void GUIFormSpecMenu::acceptInput(FormspecQuitMode quitmode=quit_mode_no) 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; + } 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, true); + gui::IGUICheckBox *e = nullptr; if ((element) && (element->getType() == gui::EGUIET_CHECK_BOX)) { e = static_cast(element); } @@ -2927,17 +3818,15 @@ void GUIFormSpecMenu::acceptInput(FormspecQuitMode quitmode=quit_mode_no) 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) { + } 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, true); + GUIScrollBar *e = nullptr; + if (element && element->getType() == gui::EGUIET_ELEMENT) + e = static_cast(element); + + if (e) { std::stringstream os; os << e->getPos(); if (s.fdefault == L"Changed") @@ -2945,13 +3834,20 @@ void GUIFormSpecMenu::acceptInput(FormspecQuitMode quitmode=quit_mode_no) else fields[name] = "VAL:" + os.str(); } - } - else - { - IGUIElement* e = getElementFromId(s.fid); - if(e != NULL) { + } else if (s.ftype == f_AnimatedImage) { + // No dynamic cast possible due to some distributions shipped + // without rtti support in Irrlicht + IGUIElement *element = getElementFromId(s.fid, true); + GUIAnimatedImage *e = nullptr; + if (element && element->getType() == gui::EGUIET_ELEMENT) + e = static_cast(element); + + if (e) + fields[name] = std::to_string(e->getFrameIndex() + 1); + } else { + IGUIElement *e = getElementFromId(s.fid, true); + if (e) fields[name] = wide_to_utf8(e->getText()); - } } } } @@ -2960,17 +3856,6 @@ void GUIFormSpecMenu::acceptInput(FormspecQuitMode quitmode=quit_mode_no) } } -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 @@ -2999,8 +3884,8 @@ bool GUIFormSpecMenu::preprocessEvent(const SEvent& event) } // Fix Esc/Return key being eaten by checkboxen and tables - if(event.EventType==EET_KEY_INPUT_EVENT) { - KeyPress kp(event.KeyInput); + 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) { @@ -3015,9 +3900,11 @@ bool GUIFormSpecMenu::preprocessEvent(const SEvent& event) } } } - // Mouse wheel events: send to hovered element instead of focused - if(event.EventType==EET_MOUSE_INPUT_EVENT - && event.MouseInput.Event == EMIE_MOUSE_WHEEL) { + // Mouse wheel and move events: send to hovered element instead of focused + if (event.EventType == EET_MOUSE_INPUT_EVENT && + (event.MouseInput.Event == EMIE_MOUSE_WHEEL || + (event.MouseInput.Event == EMIE_MOUSE_MOVED && + event.MouseInput.ButtonStates == 0))) { s32 x = event.MouseInput.X; s32 y = event.MouseInput.Y; gui::IGUIElement *hovered = @@ -3025,23 +3912,7 @@ bool GUIFormSpecMenu::preprocessEvent(const SEvent& event) 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; - } - if (!isChild(hovered,this)) { - if (DoubleClickDetection(event)) { - return true; - } + return event.MouseInput.Event == EMIE_MOUSE_WHEEL; } } @@ -3067,64 +3938,6 @@ bool GUIFormSpecMenu::preprocessEvent(const SEvent& event) return GUIModalMenu::preprocessEvent(event); } -/******************************************************************************/ -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 = porting::getTimeMs(); - } - else if (event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP) { - u64 delta = porting::getDeltaMs(m_doubleclickdetect[0].time, porting::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; -} - void GUIFormSpecMenu::tryClose() { if (m_allowclose) { @@ -3164,6 +3977,10 @@ bool GUIFormSpecMenu::OnEvent(const SEvent& event) (kp == getKeySetting("keymap_screenshot"))) { m_client->makeScreenshot(); } + + if (event.KeyInput.PressedDown && kp == getKeySetting("keymap_toggle_debug")) + m_show_debug = !m_show_debug; + if (event.KeyInput.PressedDown && (event.KeyInput.Key==KEY_RETURN || event.KeyInput.Key==KEY_UP || @@ -3209,7 +4026,7 @@ bool GUIFormSpecMenu::OnEvent(const SEvent& event) m_old_tooltip_id = -1; updateSelectedItem(); - ItemSpec s = getItemAtPos(m_pointer); + GUIInventoryList::ItemSpec s = getItemAtPos(m_pointer); Inventory *inv_selected = NULL; Inventory *inv_s = NULL; @@ -3311,8 +4128,9 @@ bool GUIFormSpecMenu::OnEvent(const SEvent& event) case BET_DOWN: // Some mouse button has been pressed - //infostream<<"Mouse button "<isValid() || m_selected_item->listname == "craftresult") { assert(inv_s); @@ -3568,14 +4386,14 @@ bool GUIFormSpecMenu::OnEvent(const SEvent& event) if (m_selected_amount == 0) { m_selected_swap.clear(); delete m_selected_item; - m_selected_item = NULL; + m_selected_item = nullptr; m_selected_amount = 0; m_selected_dragging = false; } m_old_pointer = m_pointer; } - if (event.EventType == EET_GUI_EVENT) { + if (event.EventType == EET_GUI_EVENT) { if (event.GUIEvent.EventType == gui::EGET_TAB_CHANGED && isVisible()) { // find the element that was clicked @@ -3602,9 +4420,9 @@ bool GUIFormSpecMenu::OnEvent(const SEvent& event) (event.GUIEvent.EventType == gui::EGET_CHECKBOX_CHANGED) || (event.GUIEvent.EventType == gui::EGET_COMBO_BOX_CHANGED) || (event.GUIEvent.EventType == gui::EGET_SCROLL_BAR_CHANGED)) { - unsigned int btn_id = event.GUIEvent.Caller->getID(); + s32 caller_id = event.GUIEvent.Caller->getID(); - if (btn_id == 257) { + if (caller_id == 257) { if (m_allowclose) { acceptInput(quit_mode_accept); quitMenu(); @@ -3620,8 +4438,11 @@ bool GUIFormSpecMenu::OnEvent(const SEvent& event) for (GUIFormSpecMenu::FieldSpec &s : m_fields) { // 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()) { + + if (caller_id != s.fid) + continue; + + if (s.ftype == f_Button || s.ftype == f_CheckBox) { s.send = true; if (s.is_exit) { if (m_allowclose) { @@ -3637,8 +4458,7 @@ bool GUIFormSpecMenu::OnEvent(const SEvent& event) s.send = false; return true; - } else if ((s.ftype == f_DropDown) && - (s.fid == event.GUIEvent.Caller->getID())) { + } else if (s.ftype == f_DropDown) { // only send the changed dropdown for (GUIFormSpecMenu::FieldSpec &s2 : m_fields) { if (s2.ftype == f_DropDown) { @@ -3656,15 +4476,24 @@ bool GUIFormSpecMenu::OnEvent(const SEvent& event) } } return true; - } else if ((s.ftype == f_ScrollBar) && - (s.fid == event.GUIEvent.Caller->getID())) { + } else if (s.ftype == f_ScrollBar) { s.fdefault = L"Changed"; acceptInput(quit_mode_no); s.fdefault = L""; + } else if (s.ftype == f_Unknown || s.ftype == f_HyperText) { + s.send = true; + acceptInput(); + s.send = false; } } } + if (event.GUIEvent.EventType == gui::EGET_SCROLL_BAR_CHANGED) { + // move scroll_containers + for (const std::pair &c : m_scroll_containers) + c.second->onScrollEvent(event.GUIEvent.Caller); + } + if (event.GUIEvent.EventType == gui::EGET_EDITBOX_ENTER) { if (event.GUIEvent.Caller->getID() > 257) { bool close_on_enter = true; @@ -3723,13 +4552,22 @@ bool GUIFormSpecMenu::OnEvent(const SEvent& event) std::string GUIFormSpecMenu::getNameByID(s32 id) { for (FieldSpec &spec : m_fields) { - if (spec.fid == id) { + if (spec.fid == id) return spec.fname; - } } return ""; } + +const GUIFormSpecMenu::FieldSpec *GUIFormSpecMenu::getSpecByID(s32 id) +{ + for (FieldSpec &spec : m_fields) { + if (spec.fid == id) + return &spec; + } + return nullptr; +} + /** * get label of element by id * @param id of element @@ -3738,9 +4576,53 @@ std::string GUIFormSpecMenu::getNameByID(s32 id) std::wstring GUIFormSpecMenu::getLabelByID(s32 id) { for (FieldSpec &spec : m_fields) { - if (spec.fid == id) { + if (spec.fid == id) return spec.flabel; - } } return L""; } + +StyleSpec GUIFormSpecMenu::getDefaultStyleForElement(const std::string &type, + const std::string &name, const std::string &parent_type) { + return getStyleForElement(type, name, parent_type)[StyleSpec::STATE_DEFAULT]; +} + +std::array GUIFormSpecMenu::getStyleForElement( + const std::string &type, const std::string &name, const std::string &parent_type) +{ + std::array ret; + + auto it = theme_by_type.find("*"); + if (it != theme_by_type.end()) { + for (const StyleSpec &spec : it->second) + ret[(u32)spec.getState()] |= spec; + } + + it = theme_by_name.find("*"); + if (it != theme_by_name.end()) { + for (const StyleSpec &spec : it->second) + ret[(u32)spec.getState()] |= spec; + } + + if (!parent_type.empty()) { + it = theme_by_type.find(parent_type); + if (it != theme_by_type.end()) { + for (const StyleSpec &spec : it->second) + ret[(u32)spec.getState()] |= spec; + } + } + + it = theme_by_type.find(type); + if (it != theme_by_type.end()) { + for (const StyleSpec &spec : it->second) + ret[(u32)spec.getState()] |= spec; + } + + it = theme_by_name.find(name); + if (it != theme_by_name.end()) { + for (const StyleSpec &spec : it->second) + ret[(u32)spec.getState()] |= spec; + } + + return ret; +}