2010-12-21 20:34:21 -05:00
|
|
|
/*
|
2013-02-24 12:40:43 -05:00
|
|
|
Minetest
|
2013-02-24 13:38:45 -05:00
|
|
|
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
|
2010-12-21 20:34:21 -05:00
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
2012-06-05 10:56:56 -04:00
|
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
2010-12-21 20:34:21 -05:00
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2012-06-05 10:56:56 -04:00
|
|
|
GNU Lesser General Public License for more details.
|
2010-12-21 20:34:21 -05:00
|
|
|
|
2012-06-05 10:56:56 -04:00
|
|
|
You should have received a copy of the GNU Lesser General Public License along
|
2010-12-21 20:34:21 -05:00
|
|
|
with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef GUIINVENTORYMENU_HEADER
|
|
|
|
#define GUIINVENTORYMENU_HEADER
|
|
|
|
|
2013-06-23 12:30:21 -04:00
|
|
|
#include <utility>
|
|
|
|
|
2012-06-16 21:00:31 -04:00
|
|
|
#include "irrlichttypes_extrabloated.h"
|
2010-12-21 20:34:21 -05:00
|
|
|
#include "inventory.h"
|
2012-01-12 00:10:39 -05:00
|
|
|
#include "inventorymanager.h"
|
2010-12-23 08:31:50 -05:00
|
|
|
#include "modalMenu.h"
|
2013-08-23 06:24:11 -04:00
|
|
|
#include "guiTable.h"
|
2015-01-12 11:01:41 -05:00
|
|
|
#include "network/networkprotocol.h"
|
2010-12-21 20:34:21 -05:00
|
|
|
|
2012-01-12 00:10:39 -05:00
|
|
|
class IGameDef;
|
2011-12-06 08:21:56 -05:00
|
|
|
class InventoryManager;
|
2013-08-20 16:38:14 -04:00
|
|
|
class ISimpleTextureSource;
|
2014-09-20 20:23:55 -04:00
|
|
|
class Client;
|
2011-11-13 17:19:48 -05:00
|
|
|
|
2013-06-23 12:30:21 -04:00
|
|
|
typedef enum {
|
|
|
|
f_Button,
|
2013-08-23 06:24:11 -04:00
|
|
|
f_Table,
|
2013-06-23 12:30:21 -04:00
|
|
|
f_TabHeader,
|
|
|
|
f_CheckBox,
|
|
|
|
f_DropDown,
|
2014-06-19 12:17:35 -04:00
|
|
|
f_ScrollBar,
|
2013-06-23 12:30:21 -04:00
|
|
|
f_Unknown
|
|
|
|
} FormspecFieldType;
|
|
|
|
|
2014-03-04 13:57:39 -05:00
|
|
|
typedef enum {
|
|
|
|
quit_mode_no,
|
|
|
|
quit_mode_accept,
|
|
|
|
quit_mode_cancel
|
|
|
|
} FormspecQuitMode;
|
|
|
|
|
2012-07-15 12:19:38 -04:00
|
|
|
struct TextDest
|
|
|
|
{
|
|
|
|
virtual ~TextDest() {};
|
|
|
|
// This is deprecated I guess? -celeron55
|
2012-07-22 10:10:58 -04:00
|
|
|
virtual void gotText(std::wstring text){}
|
2015-05-19 02:24:14 -04:00
|
|
|
virtual void gotText(const StringMap &fields) = 0;
|
2014-03-04 13:57:39 -05:00
|
|
|
virtual void setFormName(std::string formname)
|
|
|
|
{ m_formname = formname;};
|
|
|
|
|
|
|
|
std::string m_formname;
|
2012-07-15 12:19:38 -04:00
|
|
|
};
|
|
|
|
|
2012-06-03 11:30:34 -04:00
|
|
|
class IFormSource
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
virtual ~IFormSource(){}
|
|
|
|
virtual std::string getForm() = 0;
|
2012-07-15 12:19:38 -04:00
|
|
|
// Fill in variables in field text
|
|
|
|
virtual std::string resolveText(std::string str){ return str; }
|
2012-06-03 11:30:34 -04:00
|
|
|
};
|
|
|
|
|
2012-07-15 12:19:38 -04:00
|
|
|
class GUIFormSpecMenu : public GUIModalMenu
|
2010-12-21 20:34:21 -05:00
|
|
|
{
|
2010-12-22 09:30:23 -05:00
|
|
|
struct ItemSpec
|
2010-12-21 20:34:21 -05:00
|
|
|
{
|
2010-12-22 09:30:23 -05:00
|
|
|
ItemSpec()
|
|
|
|
{
|
|
|
|
i = -1;
|
|
|
|
}
|
2012-01-12 00:10:39 -05:00
|
|
|
ItemSpec(const InventoryLocation &a_inventoryloc,
|
2011-04-04 08:13:19 -04:00
|
|
|
const std::string &a_listname,
|
|
|
|
s32 a_i)
|
2010-12-22 09:30:23 -05:00
|
|
|
{
|
2012-01-12 00:10:39 -05:00
|
|
|
inventoryloc = a_inventoryloc;
|
2011-04-04 08:13:19 -04:00
|
|
|
listname = a_listname;
|
2010-12-22 09:30:23 -05:00
|
|
|
i = a_i;
|
|
|
|
}
|
|
|
|
bool isValid() const
|
|
|
|
{
|
|
|
|
return i != -1;
|
|
|
|
}
|
|
|
|
|
2012-01-12 00:10:39 -05:00
|
|
|
InventoryLocation inventoryloc;
|
2010-12-22 09:30:23 -05:00
|
|
|
std::string listname;
|
|
|
|
s32 i;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ListDrawSpec
|
|
|
|
{
|
|
|
|
ListDrawSpec()
|
|
|
|
{
|
|
|
|
}
|
2012-01-12 00:10:39 -05:00
|
|
|
ListDrawSpec(const InventoryLocation &a_inventoryloc,
|
2011-04-04 08:13:19 -04:00
|
|
|
const std::string &a_listname,
|
2012-07-24 13:57:17 -04:00
|
|
|
v2s32 a_pos, v2s32 a_geom, s32 a_start_item_i):
|
2012-06-03 10:18:08 -04:00
|
|
|
inventoryloc(a_inventoryloc),
|
|
|
|
listname(a_listname),
|
|
|
|
pos(a_pos),
|
2012-07-24 13:57:17 -04:00
|
|
|
geom(a_geom),
|
|
|
|
start_item_i(a_start_item_i)
|
2010-12-22 09:30:23 -05:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2012-01-12 00:10:39 -05:00
|
|
|
InventoryLocation inventoryloc;
|
2010-12-22 09:30:23 -05:00
|
|
|
std::string listname;
|
|
|
|
v2s32 pos;
|
|
|
|
v2s32 geom;
|
2012-07-24 13:57:17 -04:00
|
|
|
s32 start_item_i;
|
2010-12-22 09:30:23 -05:00
|
|
|
};
|
2012-06-03 10:18:08 -04:00
|
|
|
|
2015-06-16 04:48:54 -04:00
|
|
|
struct ListRingSpec
|
|
|
|
{
|
|
|
|
ListRingSpec()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
ListRingSpec(const InventoryLocation &a_inventoryloc,
|
|
|
|
const std::string &a_listname):
|
|
|
|
inventoryloc(a_inventoryloc),
|
|
|
|
listname(a_listname)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
InventoryLocation inventoryloc;
|
|
|
|
std::string listname;
|
|
|
|
};
|
|
|
|
|
2012-06-03 10:18:08 -04:00
|
|
|
struct ImageDrawSpec
|
|
|
|
{
|
2016-02-09 04:43:38 -05:00
|
|
|
ImageDrawSpec():
|
|
|
|
parent_button(NULL)
|
2012-06-03 10:18:08 -04:00
|
|
|
{
|
|
|
|
}
|
|
|
|
ImageDrawSpec(const std::string &a_name,
|
2016-01-24 08:19:17 -05:00
|
|
|
const std::string &a_item_name,
|
2016-02-09 04:43:38 -05:00
|
|
|
gui::IGUIButton *a_parent_button,
|
2016-01-24 08:19:17 -05:00
|
|
|
const v2s32 &a_pos, const v2s32 &a_geom):
|
2012-06-03 10:18:08 -04:00
|
|
|
name(a_name),
|
2016-02-09 04:43:38 -05:00
|
|
|
item_name(a_item_name),
|
|
|
|
parent_button(a_parent_button),
|
2012-06-03 10:18:08 -04:00
|
|
|
pos(a_pos),
|
2016-02-09 04:43:38 -05:00
|
|
|
geom(a_geom),
|
|
|
|
scale(true)
|
2012-06-03 10:18:08 -04:00
|
|
|
{
|
2013-06-23 12:30:21 -04:00
|
|
|
}
|
|
|
|
ImageDrawSpec(const std::string &a_name,
|
2016-02-09 04:43:38 -05:00
|
|
|
const std::string &a_item_name,
|
2016-01-24 08:19:17 -05:00
|
|
|
const v2s32 &a_pos, const v2s32 &a_geom):
|
|
|
|
name(a_name),
|
2016-02-09 04:43:38 -05:00
|
|
|
item_name(a_item_name),
|
|
|
|
parent_button(NULL),
|
2016-01-24 08:19:17 -05:00
|
|
|
pos(a_pos),
|
2016-02-09 04:43:38 -05:00
|
|
|
geom(a_geom),
|
|
|
|
scale(true)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
ImageDrawSpec(const std::string &a_name,
|
|
|
|
const v2s32 &a_pos, const v2s32 &a_geom):
|
|
|
|
name(a_name),
|
|
|
|
parent_button(NULL),
|
|
|
|
pos(a_pos),
|
|
|
|
geom(a_geom),
|
|
|
|
scale(true)
|
2016-01-24 08:19:17 -05:00
|
|
|
{
|
|
|
|
}
|
|
|
|
ImageDrawSpec(const std::string &a_name,
|
|
|
|
const v2s32 &a_pos):
|
2013-06-23 12:30:21 -04:00
|
|
|
name(a_name),
|
2016-02-09 04:43:38 -05:00
|
|
|
parent_button(NULL),
|
|
|
|
pos(a_pos),
|
|
|
|
scale(false)
|
2013-06-23 12:30:21 -04:00
|
|
|
{
|
2012-06-03 10:18:08 -04:00
|
|
|
}
|
|
|
|
std::string name;
|
2016-01-24 08:19:17 -05:00
|
|
|
std::string item_name;
|
2016-02-09 04:43:38 -05:00
|
|
|
gui::IGUIButton *parent_button;
|
2012-06-03 10:18:08 -04:00
|
|
|
v2s32 pos;
|
|
|
|
v2s32 geom;
|
2013-06-23 12:30:21 -04:00
|
|
|
bool scale;
|
2012-06-03 10:18:08 -04:00
|
|
|
};
|
2014-05-29 21:07:48 -04:00
|
|
|
|
2012-07-15 12:19:38 -04:00
|
|
|
struct FieldSpec
|
|
|
|
{
|
|
|
|
FieldSpec()
|
|
|
|
{
|
|
|
|
}
|
2015-06-09 19:54:33 -04:00
|
|
|
FieldSpec(const std::string &name, const std::wstring &label,
|
2014-04-21 08:10:59 -04:00
|
|
|
const std::wstring &fdeflt, int id) :
|
2012-07-15 12:19:38 -04:00
|
|
|
fname(name),
|
|
|
|
flabel(label),
|
|
|
|
fdefault(fdeflt),
|
|
|
|
fid(id)
|
|
|
|
{
|
|
|
|
send = false;
|
2013-06-23 12:30:21 -04:00
|
|
|
ftype = f_Unknown;
|
2012-07-22 10:28:09 -04:00
|
|
|
is_exit = false;
|
2012-07-15 12:19:38 -04:00
|
|
|
}
|
2015-06-09 19:54:33 -04:00
|
|
|
std::string fname;
|
2012-07-15 12:19:38 -04:00
|
|
|
std::wstring flabel;
|
|
|
|
std::wstring fdefault;
|
|
|
|
int fid;
|
|
|
|
bool send;
|
2013-06-23 12:30:21 -04:00
|
|
|
FormspecFieldType ftype;
|
2012-07-22 10:28:09 -04:00
|
|
|
bool is_exit;
|
2012-12-01 12:36:42 -05:00
|
|
|
core::rect<s32> rect;
|
2012-07-15 12:19:38 -04:00
|
|
|
};
|
2012-06-03 10:18:08 -04:00
|
|
|
|
2013-06-23 12:30:21 -04:00
|
|
|
struct BoxDrawSpec {
|
|
|
|
BoxDrawSpec(v2s32 a_pos, v2s32 a_geom,irr::video::SColor a_color):
|
|
|
|
pos(a_pos),
|
|
|
|
geom(a_geom),
|
|
|
|
color(a_color)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
v2s32 pos;
|
|
|
|
v2s32 geom;
|
|
|
|
irr::video::SColor color;
|
|
|
|
};
|
|
|
|
|
2014-06-24 06:28:24 -04:00
|
|
|
struct TooltipSpec {
|
|
|
|
TooltipSpec()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
TooltipSpec(std::string a_tooltip, irr::video::SColor a_bgcolor,
|
|
|
|
irr::video::SColor a_color):
|
|
|
|
tooltip(a_tooltip),
|
|
|
|
bgcolor(a_bgcolor),
|
|
|
|
color(a_color)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
std::string tooltip;
|
|
|
|
irr::video::SColor bgcolor;
|
|
|
|
irr::video::SColor color;
|
|
|
|
};
|
|
|
|
|
2016-02-09 00:06:10 -05:00
|
|
|
struct StaticTextSpec {
|
2016-02-09 04:43:38 -05:00
|
|
|
StaticTextSpec():
|
|
|
|
parent_button(NULL)
|
2016-02-09 00:06:10 -05:00
|
|
|
{
|
|
|
|
}
|
|
|
|
StaticTextSpec(const std::wstring &a_text,
|
|
|
|
const core::rect<s32> &a_rect):
|
|
|
|
text(a_text),
|
2016-02-09 04:43:38 -05:00
|
|
|
rect(a_rect),
|
|
|
|
parent_button(NULL)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
StaticTextSpec(const std::wstring &a_text,
|
|
|
|
const core::rect<s32> &a_rect,
|
|
|
|
gui::IGUIButton *a_parent_button):
|
|
|
|
text(a_text),
|
|
|
|
rect(a_rect),
|
|
|
|
parent_button(a_parent_button)
|
2016-02-09 00:06:10 -05:00
|
|
|
{
|
|
|
|
}
|
|
|
|
std::wstring text;
|
|
|
|
core::rect<s32> rect;
|
2016-02-09 04:43:38 -05:00
|
|
|
gui::IGUIButton *parent_button;
|
2016-02-09 00:06:10 -05:00
|
|
|
};
|
|
|
|
|
2010-12-21 20:34:21 -05:00
|
|
|
public:
|
2012-11-28 12:39:58 -05:00
|
|
|
GUIFormSpecMenu(irr::IrrlichtDevice* dev,
|
2010-12-21 20:34:21 -05:00
|
|
|
gui::IGUIElement* parent, s32 id,
|
2011-04-04 08:13:19 -04:00
|
|
|
IMenuManager *menumgr,
|
2011-11-13 17:19:48 -05:00
|
|
|
InventoryManager *invmgr,
|
2013-08-20 16:38:14 -04:00
|
|
|
IGameDef *gamedef,
|
2014-04-19 20:40:25 -04:00
|
|
|
ISimpleTextureSource *tsrc,
|
|
|
|
IFormSource* fs_src,
|
|
|
|
TextDest* txt_dst,
|
2015-03-14 05:55:35 -04:00
|
|
|
Client* client,
|
|
|
|
bool remap_dbl_click = true);
|
2013-06-23 12:30:21 -04:00
|
|
|
|
2012-07-15 12:19:38 -04:00
|
|
|
~GUIFormSpecMenu();
|
2010-12-21 20:34:21 -05:00
|
|
|
|
2012-06-03 09:03:19 -04:00
|
|
|
void setFormSpec(const std::string &formspec_string,
|
|
|
|
InventoryLocation current_inventory_location)
|
2011-04-04 17:24:47 -04:00
|
|
|
{
|
2012-06-03 09:03:19 -04:00
|
|
|
m_formspec_string = formspec_string;
|
|
|
|
m_current_inventory_location = current_inventory_location;
|
|
|
|
regenerateGui(m_screensize_old);
|
2011-04-04 17:24:47 -04:00
|
|
|
}
|
2014-05-29 21:07:48 -04:00
|
|
|
|
2012-07-15 12:19:38 -04:00
|
|
|
// form_src is deleted by this GUIFormSpecMenu
|
2012-06-03 11:30:34 -04:00
|
|
|
void setFormSource(IFormSource *form_src)
|
|
|
|
{
|
2014-04-19 20:40:25 -04:00
|
|
|
if (m_form_src != NULL) {
|
|
|
|
delete m_form_src;
|
|
|
|
}
|
2012-06-03 11:30:34 -04:00
|
|
|
m_form_src = form_src;
|
|
|
|
}
|
2011-04-04 17:24:47 -04:00
|
|
|
|
2012-07-15 12:19:38 -04:00
|
|
|
// text_dst is deleted by this GUIFormSpecMenu
|
|
|
|
void setTextDest(TextDest *text_dst)
|
|
|
|
{
|
2014-04-19 20:40:25 -04:00
|
|
|
if (m_text_dst != NULL) {
|
|
|
|
delete m_text_dst;
|
|
|
|
}
|
2012-07-15 12:19:38 -04:00
|
|
|
m_text_dst = text_dst;
|
|
|
|
}
|
|
|
|
|
2013-06-23 12:30:21 -04:00
|
|
|
void allowClose(bool value)
|
|
|
|
{
|
|
|
|
m_allowclose = value;
|
|
|
|
}
|
|
|
|
|
2015-01-26 19:17:04 -05:00
|
|
|
void lockSize(bool lock,v2u32 basescreensize=v2u32(0,0))
|
|
|
|
{
|
2013-06-23 12:30:21 -04:00
|
|
|
m_lock = lock;
|
|
|
|
m_lockscreensize = basescreensize;
|
|
|
|
}
|
|
|
|
|
2010-12-25 09:04:51 -05:00
|
|
|
void removeChildren();
|
2013-08-19 05:26:51 -04:00
|
|
|
void setInitialFocus();
|
2015-01-26 19:17:04 -05:00
|
|
|
|
2015-06-09 19:54:33 -04:00
|
|
|
void setFocus(std::string &elementname)
|
2015-01-26 19:17:04 -05:00
|
|
|
{
|
|
|
|
m_focused_element = elementname;
|
|
|
|
}
|
|
|
|
|
2010-12-21 20:34:21 -05:00
|
|
|
/*
|
|
|
|
Remove and re-add (or reposition) stuff
|
|
|
|
*/
|
2010-12-23 08:31:50 -05:00
|
|
|
void regenerateGui(v2u32 screensize);
|
2014-05-29 21:07:48 -04:00
|
|
|
|
2010-12-22 09:30:23 -05:00
|
|
|
ItemSpec getItemAtPos(v2s32 p) const;
|
2016-01-24 08:19:17 -05:00
|
|
|
void drawList(const ListDrawSpec &s, int phase, bool &item_hovered);
|
2012-01-21 15:21:41 -05:00
|
|
|
void drawSelectedItem();
|
2010-12-23 08:31:50 -05:00
|
|
|
void drawMenu();
|
2012-01-21 15:21:41 -05:00
|
|
|
void updateSelectedItem();
|
2013-06-17 19:32:11 -04:00
|
|
|
ItemStack verifySelectedItem();
|
2010-12-21 20:34:21 -05:00
|
|
|
|
2014-03-04 13:57:39 -05:00
|
|
|
void acceptInput(FormspecQuitMode quitmode);
|
2013-08-19 05:26:51 -04:00
|
|
|
bool preprocessEvent(const SEvent& event);
|
2010-12-21 20:34:21 -05:00
|
|
|
bool OnEvent(const SEvent& event);
|
2014-03-13 09:06:18 -04:00
|
|
|
bool doPause;
|
|
|
|
bool pausesGame() { return doPause; }
|
2013-08-15 15:46:55 -04:00
|
|
|
|
2015-06-09 19:54:33 -04:00
|
|
|
GUITable* getTable(const std::string &tablename);
|
2013-08-23 06:24:11 -04:00
|
|
|
|
2014-04-21 08:10:59 -04:00
|
|
|
#ifdef __ANDROID__
|
|
|
|
bool getAndroidUIInput();
|
|
|
|
#endif
|
|
|
|
|
2011-04-04 17:24:47 -04:00
|
|
|
protected:
|
2010-12-22 09:30:23 -05:00
|
|
|
v2s32 getBasePos() const
|
|
|
|
{
|
2013-06-23 12:30:21 -04:00
|
|
|
return padding + offset + AbsoluteRect.UpperLeftCorner;
|
2010-12-22 09:30:23 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
v2s32 padding;
|
|
|
|
v2s32 spacing;
|
|
|
|
v2s32 imgsize;
|
2013-06-23 12:30:21 -04:00
|
|
|
v2s32 offset;
|
2014-05-29 21:07:48 -04:00
|
|
|
|
2012-11-28 12:39:58 -05:00
|
|
|
irr::IrrlichtDevice* m_device;
|
2011-04-04 08:13:19 -04:00
|
|
|
InventoryManager *m_invmgr;
|
2012-01-12 00:10:39 -05:00
|
|
|
IGameDef *m_gamedef;
|
2013-08-20 16:38:14 -04:00
|
|
|
ISimpleTextureSource *m_tsrc;
|
2014-09-20 20:23:55 -04:00
|
|
|
Client *m_client;
|
2010-12-22 09:30:23 -05:00
|
|
|
|
2012-06-03 09:03:19 -04:00
|
|
|
std::string m_formspec_string;
|
|
|
|
InventoryLocation m_current_inventory_location;
|
2012-06-03 10:18:08 -04:00
|
|
|
|
2014-09-19 09:27:48 -04:00
|
|
|
|
2012-12-20 12:19:49 -05:00
|
|
|
std::vector<ListDrawSpec> m_inventorylists;
|
2015-06-16 04:48:54 -04:00
|
|
|
std::vector<ListRingSpec> m_inventory_rings;
|
2012-12-20 12:19:49 -05:00
|
|
|
std::vector<ImageDrawSpec> m_backgrounds;
|
|
|
|
std::vector<ImageDrawSpec> m_images;
|
|
|
|
std::vector<ImageDrawSpec> m_itemimages;
|
2013-06-23 12:30:21 -04:00
|
|
|
std::vector<BoxDrawSpec> m_boxes;
|
2012-12-20 12:19:49 -05:00
|
|
|
std::vector<FieldSpec> m_fields;
|
2016-02-09 00:06:10 -05:00
|
|
|
std::vector<StaticTextSpec> m_static_texts;
|
2013-08-23 06:24:11 -04:00
|
|
|
std::vector<std::pair<FieldSpec,GUITable*> > m_tables;
|
2013-06-23 12:30:21 -04:00
|
|
|
std::vector<std::pair<FieldSpec,gui::IGUICheckBox*> > m_checkboxes;
|
2015-06-09 19:54:33 -04:00
|
|
|
std::map<std::string, TooltipSpec> m_tooltips;
|
2014-06-19 12:17:35 -04:00
|
|
|
std::vector<std::pair<FieldSpec,gui::IGUIScrollBar*> > m_scrollbars;
|
|
|
|
|
2010-12-22 09:30:23 -05:00
|
|
|
ItemSpec *m_selected_item;
|
2016-01-24 08:19:17 -05:00
|
|
|
f32 m_timer1;
|
|
|
|
f32 m_timer2;
|
2012-01-21 15:21:41 -05:00
|
|
|
u32 m_selected_amount;
|
|
|
|
bool m_selected_dragging;
|
2014-05-29 21:07:48 -04:00
|
|
|
|
2012-09-02 15:51:38 -04:00
|
|
|
// WARNING: BLACK MAGIC
|
|
|
|
// Used to guess and keep up with some special things the server can do.
|
|
|
|
// If name is "", no guess exists.
|
|
|
|
ItemStack m_selected_content_guess;
|
|
|
|
InventoryLocation m_selected_content_guess_inventory;
|
2012-01-21 15:21:41 -05:00
|
|
|
|
2011-12-01 04:25:55 -05:00
|
|
|
v2s32 m_pointer;
|
2014-09-19 09:27:48 -04:00
|
|
|
v2s32 m_old_pointer; // Mouse position after previous mouse event
|
2012-01-13 06:35:55 -05:00
|
|
|
gui::IGUIStaticText *m_tooltip_element;
|
2013-06-23 12:30:21 -04:00
|
|
|
|
2014-06-25 05:52:09 -04:00
|
|
|
u32 m_tooltip_show_delay;
|
2014-10-30 02:53:20 -04:00
|
|
|
s32 m_hovered_time;
|
2014-06-24 06:28:24 -04:00
|
|
|
s32 m_old_tooltip_id;
|
|
|
|
std::string m_old_tooltip;
|
|
|
|
|
2014-10-09 03:53:20 -04:00
|
|
|
bool m_rmouse_auto_place;
|
|
|
|
|
2013-06-23 12:30:21 -04:00
|
|
|
bool m_allowclose;
|
|
|
|
bool m_lock;
|
|
|
|
v2u32 m_lockscreensize;
|
2013-11-01 23:26:44 -04:00
|
|
|
|
|
|
|
bool m_bgfullscreen;
|
|
|
|
bool m_slotborder;
|
|
|
|
bool m_clipbackground;
|
|
|
|
video::SColor m_bgcolor;
|
|
|
|
video::SColor m_slotbg_n;
|
|
|
|
video::SColor m_slotbg_h;
|
|
|
|
video::SColor m_slotbordercolor;
|
2014-06-24 06:28:24 -04:00
|
|
|
video::SColor m_default_tooltip_bgcolor;
|
|
|
|
video::SColor m_default_tooltip_color;
|
|
|
|
|
2013-06-23 12:30:21 -04:00
|
|
|
private:
|
2014-06-18 16:38:29 -04:00
|
|
|
IFormSource *m_form_src;
|
|
|
|
TextDest *m_text_dst;
|
2014-06-25 13:04:47 -04:00
|
|
|
unsigned int m_formspec_version;
|
2015-06-09 19:54:33 -04:00
|
|
|
std::string m_focused_element;
|
2014-04-19 20:40:25 -04:00
|
|
|
|
2013-06-23 12:30:21 -04:00
|
|
|
typedef struct {
|
Scale form elements consistently
The ratios between the sizes of form elements, including text, is now
fixed, aside from variations caused by rounding. This makes form layout
almost fully predictable, and particularly independent of player's
screen size. The proportions of non-text elements are the traditional
proportions.
For compatibility, the way in which element positions and sizes are
specified remains unchanged, in all its baroqueness, with one exception.
The exception is that the position of a label[] element is now defined
in terms of the vertically center of the first line of the label,
rather than the bottom of the first line of the label. This change
allows a label to be precisely aligned with button text or an edit box,
which are positioned in a centering manner. Label positioning remains
consistent with the previous system, just more precisely defined.
Make multi-line label[] elements work properly. Previously the code set
a bounding rectangle assuming that there would be only a single line,
and as a result a multi-line label would be cut somewhere in the middle
of the second line. Now multi-line labels not only work, but have
guaranteed line spacing relative to inventory slots, to aid alignment.
Incidentally fix tabheader[] elements which were being constrained to
the wrong width.
Given an unusually large form, in variable-size mode, the form rendering
system now chooses a scale that will fit the entire form on the screen,
if that doesn't make elements too small. Fixed-size forms, including the
main menu, are have their sizes fixed in inch terms. The fixed size for
fixed-size forms and the preferred and minimum sizes for variable-size
forms all scale according to the gui_scaling parameter.
2014-08-20 18:42:27 -04:00
|
|
|
bool explicit_size;
|
|
|
|
v2f invsize;
|
2013-06-23 12:30:21 -04:00
|
|
|
v2s32 size;
|
|
|
|
core::rect<s32> rect;
|
|
|
|
v2s32 basepos;
|
|
|
|
v2u32 screensize;
|
2015-06-09 19:54:33 -04:00
|
|
|
std::string focused_fieldname;
|
2013-08-23 06:24:11 -04:00
|
|
|
GUITable::TableOptions table_options;
|
|
|
|
GUITable::TableColumns table_columns;
|
|
|
|
// used to restore table selection/scroll/treeview state
|
2015-06-09 19:54:33 -04:00
|
|
|
std::map<std::string, GUITable::DynamicData> table_dyndata;
|
2013-06-23 12:30:21 -04:00
|
|
|
} parserData;
|
|
|
|
|
2013-07-07 15:53:40 -04:00
|
|
|
typedef struct {
|
|
|
|
bool key_up;
|
|
|
|
bool key_down;
|
|
|
|
bool key_enter;
|
|
|
|
bool key_escape;
|
|
|
|
} fs_key_pendig;
|
|
|
|
|
|
|
|
fs_key_pendig current_keys_pending;
|
|
|
|
|
2013-06-23 12:30:21 -04:00
|
|
|
void parseElement(parserData* data,std::string element);
|
|
|
|
|
|
|
|
void parseSize(parserData* data,std::string element);
|
|
|
|
void parseList(parserData* data,std::string element);
|
2015-06-16 04:48:54 -04:00
|
|
|
void parseListRing(parserData* data,std::string element);
|
2013-06-23 12:30:21 -04:00
|
|
|
void parseCheckbox(parserData* data,std::string element);
|
|
|
|
void parseImage(parserData* data,std::string element);
|
|
|
|
void parseItemImage(parserData* data,std::string element);
|
|
|
|
void parseButton(parserData* data,std::string element,std::string typ);
|
|
|
|
void parseBackground(parserData* data,std::string element);
|
2013-08-23 06:24:11 -04:00
|
|
|
void parseTableOptions(parserData* data,std::string element);
|
|
|
|
void parseTableColumns(parserData* data,std::string element);
|
|
|
|
void parseTable(parserData* data,std::string element);
|
2013-06-23 12:30:21 -04:00
|
|
|
void parseTextList(parserData* data,std::string element);
|
|
|
|
void parseDropDown(parserData* data,std::string element);
|
|
|
|
void parsePwdField(parserData* data,std::string element);
|
|
|
|
void parseField(parserData* data,std::string element,std::string type);
|
|
|
|
void parseSimpleField(parserData* data,std::vector<std::string> &parts);
|
2014-03-04 13:57:39 -05:00
|
|
|
void parseTextArea(parserData* data,std::vector<std::string>& parts,
|
|
|
|
std::string type);
|
2013-06-23 12:30:21 -04:00
|
|
|
void parseLabel(parserData* data,std::string element);
|
|
|
|
void parseVertLabel(parserData* data,std::string element);
|
|
|
|
void parseImageButton(parserData* data,std::string element,std::string type);
|
|
|
|
void parseItemImageButton(parserData* data,std::string element);
|
|
|
|
void parseTabHeader(parserData* data,std::string element);
|
|
|
|
void parseBox(parserData* data,std::string element);
|
2013-11-01 23:26:44 -04:00
|
|
|
void parseBackgroundColor(parserData* data,std::string element);
|
|
|
|
void parseListColors(parserData* data,std::string element);
|
2014-06-24 06:28:24 -04:00
|
|
|
void parseTooltip(parserData* data,std::string element);
|
2014-06-25 13:04:47 -04:00
|
|
|
bool parseVersionDirect(std::string data);
|
Scale form elements consistently
The ratios between the sizes of form elements, including text, is now
fixed, aside from variations caused by rounding. This makes form layout
almost fully predictable, and particularly independent of player's
screen size. The proportions of non-text elements are the traditional
proportions.
For compatibility, the way in which element positions and sizes are
specified remains unchanged, in all its baroqueness, with one exception.
The exception is that the position of a label[] element is now defined
in terms of the vertically center of the first line of the label,
rather than the bottom of the first line of the label. This change
allows a label to be precisely aligned with button text or an edit box,
which are positioned in a centering manner. Label positioning remains
consistent with the previous system, just more precisely defined.
Make multi-line label[] elements work properly. Previously the code set
a bounding rectangle assuming that there would be only a single line,
and as a result a multi-line label would be cut somewhere in the middle
of the second line. Now multi-line labels not only work, but have
guaranteed line spacing relative to inventory slots, to aid alignment.
Incidentally fix tabheader[] elements which were being constrained to
the wrong width.
Given an unusually large form, in variable-size mode, the form rendering
system now chooses a scale that will fit the entire form on the screen,
if that doesn't make elements too small. Fixed-size forms, including the
main menu, are have their sizes fixed in inch terms. The fixed size for
fixed-size forms and the preferred and minimum sizes for variable-size
forms all scale according to the gui_scaling parameter.
2014-08-20 18:42:27 -04:00
|
|
|
bool parseSizeDirect(parserData* data, std::string element);
|
2014-06-19 12:17:35 -04:00
|
|
|
void parseScrollBar(parserData* data, std::string element);
|
2014-05-29 21:07:48 -04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* check if event is part of a double click
|
|
|
|
* @param event event to evaluate
|
|
|
|
* @return true/false if a doubleclick was detected
|
|
|
|
*/
|
|
|
|
bool DoubleClickDetection(const SEvent event);
|
|
|
|
|
|
|
|
struct clickpos
|
|
|
|
{
|
|
|
|
v2s32 pos;
|
|
|
|
s32 time;
|
|
|
|
};
|
|
|
|
clickpos m_doubleclickdetect[2];
|
2014-06-14 05:22:09 -04:00
|
|
|
|
|
|
|
int m_btn_height;
|
Scale form elements consistently
The ratios between the sizes of form elements, including text, is now
fixed, aside from variations caused by rounding. This makes form layout
almost fully predictable, and particularly independent of player's
screen size. The proportions of non-text elements are the traditional
proportions.
For compatibility, the way in which element positions and sizes are
specified remains unchanged, in all its baroqueness, with one exception.
The exception is that the position of a label[] element is now defined
in terms of the vertically center of the first line of the label,
rather than the bottom of the first line of the label. This change
allows a label to be precisely aligned with button text or an edit box,
which are positioned in a centering manner. Label positioning remains
consistent with the previous system, just more precisely defined.
Make multi-line label[] elements work properly. Previously the code set
a bounding rectangle assuming that there would be only a single line,
and as a result a multi-line label would be cut somewhere in the middle
of the second line. Now multi-line labels not only work, but have
guaranteed line spacing relative to inventory slots, to aid alignment.
Incidentally fix tabheader[] elements which were being constrained to
the wrong width.
Given an unusually large form, in variable-size mode, the form rendering
system now chooses a scale that will fit the entire form on the screen,
if that doesn't make elements too small. Fixed-size forms, including the
main menu, are have their sizes fixed in inch terms. The fixed size for
fixed-size forms and the preferred and minimum sizes for variable-size
forms all scale according to the gui_scaling parameter.
2014-08-20 18:42:27 -04:00
|
|
|
gui::IGUIFont *m_font;
|
2014-04-21 08:10:59 -04:00
|
|
|
|
|
|
|
std::wstring getLabelByID(s32 id);
|
2015-06-09 19:54:33 -04:00
|
|
|
std::string getNameByID(s32 id);
|
2014-04-21 08:10:59 -04:00
|
|
|
#ifdef __ANDROID__
|
|
|
|
v2s32 m_down_pos;
|
2015-06-09 19:54:33 -04:00
|
|
|
std::string m_JavaDialogFieldName;
|
2014-04-21 08:10:59 -04:00
|
|
|
#endif
|
|
|
|
|
2015-03-14 05:55:35 -04:00
|
|
|
/* If true, remap a double-click (or double-tap) action to ESC. This is so
|
|
|
|
* that, for example, Android users can double-tap to close a formspec.
|
|
|
|
*
|
|
|
|
* This value can (currently) only be set by the class constructor
|
|
|
|
* and the default value for the setting is true.
|
|
|
|
*/
|
|
|
|
bool m_remap_dbl_click;
|
|
|
|
|
2013-06-23 12:30:21 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
class FormspecFormSource: public IFormSource
|
|
|
|
{
|
|
|
|
public:
|
2014-04-19 20:40:25 -04:00
|
|
|
FormspecFormSource(std::string formspec)
|
2013-06-23 12:30:21 -04:00
|
|
|
{
|
|
|
|
m_formspec = formspec;
|
|
|
|
}
|
|
|
|
|
|
|
|
~FormspecFormSource()
|
2014-04-19 20:40:25 -04:00
|
|
|
{}
|
2013-06-23 12:30:21 -04:00
|
|
|
|
|
|
|
void setForm(std::string formspec) {
|
2014-06-25 13:04:47 -04:00
|
|
|
m_formspec = FORMSPEC_VERSION_STRING + formspec;
|
2013-06-23 12:30:21 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
std::string getForm()
|
|
|
|
{
|
|
|
|
return m_formspec;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string m_formspec;
|
2010-12-21 20:34:21 -05:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|