minetest/src/guiFormSpecMenu.h

548 lines
12 KiB
C
Raw Normal View History

2010-12-22 02:34:21 +01:00
/*
2013-02-24 18:40:43 +01:00
Minetest
2013-02-24 19:38:45 +01:00
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
2010-12-22 02:34:21 +01:00
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
2010-12-22 02:34:21 +01: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
GNU Lesser General Public License for more details.
2010-12-22 02:34:21 +01:00
You should have received a copy of the GNU Lesser General Public License along
2010-12-22 02:34:21 +01: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
#include <utility>
2012-06-17 03:00:31 +02:00
#include "irrlichttypes_extrabloated.h"
2010-12-22 02:34:21 +01:00
#include "inventory.h"
#include "inventorymanager.h"
2010-12-23 14:31:50 +01:00
#include "modalMenu.h"
2013-08-23 12:24:11 +02:00
#include "guiTable.h"
#include "network/networkprotocol.h"
2010-12-22 02:34:21 +01:00
class IGameDef;
class InventoryManager;
class ISimpleTextureSource;
class Client;
typedef enum {
f_Button,
2013-08-23 12:24:11 +02:00
f_Table,
f_TabHeader,
f_CheckBox,
f_DropDown,
2014-06-19 18:17:35 +02:00
f_ScrollBar,
f_Unknown
} FormspecFieldType;
typedef enum {
quit_mode_no,
quit_mode_accept,
quit_mode_cancel
} FormspecQuitMode;
2012-07-15 18:19:38 +02:00
struct TextDest
{
virtual ~TextDest() {};
// This is deprecated I guess? -celeron55
virtual void gotText(std::wstring text){}
virtual void gotText(const StringMap &fields) = 0;
virtual void setFormName(std::string formname)
{ m_formname = formname;};
std::string m_formname;
2012-07-15 18:19:38 +02:00
};
class IFormSource
{
public:
virtual ~IFormSource(){}
virtual std::string getForm() = 0;
2012-07-15 18:19:38 +02:00
// Fill in variables in field text
virtual std::string resolveText(std::string str){ return str; }
};
2012-07-15 18:19:38 +02:00
class GUIFormSpecMenu : public GUIModalMenu
2010-12-22 02:34:21 +01:00
{
2010-12-22 15:30:23 +01:00
struct ItemSpec
2010-12-22 02:34:21 +01:00
{
2010-12-22 15:30:23 +01:00
ItemSpec()
{
i = -1;
}
ItemSpec(const InventoryLocation &a_inventoryloc,
2011-04-04 14:13:19 +02:00
const std::string &a_listname,
s32 a_i)
2010-12-22 15:30:23 +01:00
{
inventoryloc = a_inventoryloc;
2011-04-04 14:13:19 +02:00
listname = a_listname;
2010-12-22 15:30:23 +01:00
i = a_i;
}
bool isValid() const
{
return i != -1;
}
InventoryLocation inventoryloc;
2010-12-22 15:30:23 +01:00
std::string listname;
s32 i;
};
struct ListDrawSpec
{
ListDrawSpec()
{
}
ListDrawSpec(const InventoryLocation &a_inventoryloc,
2011-04-04 14:13:19 +02:00
const std::string &a_listname,
2012-07-24 19:57:17 +02:00
v2s32 a_pos, v2s32 a_geom, s32 a_start_item_i):
inventoryloc(a_inventoryloc),
listname(a_listname),
pos(a_pos),
2012-07-24 19:57:17 +02:00
geom(a_geom),
start_item_i(a_start_item_i)
2010-12-22 15:30:23 +01:00
{
}
InventoryLocation inventoryloc;
2010-12-22 15:30:23 +01:00
std::string listname;
v2s32 pos;
v2s32 geom;
2012-07-24 19:57:17 +02:00
s32 start_item_i;
2010-12-22 15:30:23 +01: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;
};
struct ImageDrawSpec
{
ImageDrawSpec():
parent_button(NULL)
{
}
ImageDrawSpec(const std::string &a_name,
2016-01-24 14:19:17 +01:00
const std::string &a_item_name,
gui::IGUIButton *a_parent_button,
2016-01-24 14:19:17 +01:00
const v2s32 &a_pos, const v2s32 &a_geom):
name(a_name),
item_name(a_item_name),
parent_button(a_parent_button),
pos(a_pos),
geom(a_geom),
scale(true)
{
}
ImageDrawSpec(const std::string &a_name,
const std::string &a_item_name,
2016-01-24 14:19:17 +01:00
const v2s32 &a_pos, const v2s32 &a_geom):
name(a_name),
item_name(a_item_name),
parent_button(NULL),
2016-01-24 14:19:17 +01:00
pos(a_pos),
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 14:19:17 +01:00
{
}
ImageDrawSpec(const std::string &a_name,
const v2s32 &a_pos):
name(a_name),
parent_button(NULL),
pos(a_pos),
scale(false)
{
}
std::string name;
2016-01-24 14:19:17 +01:00
std::string item_name;
gui::IGUIButton *parent_button;
v2s32 pos;
v2s32 geom;
bool scale;
};
2012-07-15 18:19:38 +02:00
struct FieldSpec
{
FieldSpec()
{
}
2015-06-10 01:54:33 +02:00
FieldSpec(const std::string &name, const std::wstring &label,
const std::wstring &fdeflt, int id) :
2012-07-15 18:19:38 +02:00
fname(name),
flabel(label),
fdefault(fdeflt),
fid(id)
{
send = false;
ftype = f_Unknown;
is_exit = false;
2012-07-15 18:19:38 +02:00
}
2015-06-10 01:54:33 +02:00
std::string fname;
2012-07-15 18:19:38 +02:00
std::wstring flabel;
std::wstring fdefault;
int fid;
bool send;
FormspecFieldType ftype;
bool is_exit;
core::rect<s32> rect;
2012-07-15 18:19:38 +02: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;
};
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;
};
struct StaticTextSpec {
StaticTextSpec():
parent_button(NULL)
{
}
StaticTextSpec(const std::wstring &a_text,
const core::rect<s32> &a_rect):
text(a_text),
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)
{
}
std::wstring text;
core::rect<s32> rect;
gui::IGUIButton *parent_button;
};
2010-12-22 02:34:21 +01:00
public:
GUIFormSpecMenu(irr::IrrlichtDevice* dev,
2010-12-22 02:34:21 +01:00
gui::IGUIElement* parent, s32 id,
2011-04-04 14:13:19 +02:00
IMenuManager *menumgr,
InventoryManager *invmgr,
IGameDef *gamedef,
ISimpleTextureSource *tsrc,
IFormSource* fs_src,
TextDest* txt_dst,
Client* client,
bool remap_dbl_click = true);
2012-07-15 18:19:38 +02:00
~GUIFormSpecMenu();
2010-12-22 02:34:21 +01:00
2012-06-03 15:03:19 +02:00
void setFormSpec(const std::string &formspec_string,
InventoryLocation current_inventory_location)
{
2012-06-03 15:03:19 +02:00
m_formspec_string = formspec_string;
m_current_inventory_location = current_inventory_location;
regenerateGui(m_screensize_old);
}
2012-07-15 18:19:38 +02:00
// form_src is deleted by this GUIFormSpecMenu
void setFormSource(IFormSource *form_src)
{
if (m_form_src != NULL) {
delete m_form_src;
}
m_form_src = form_src;
}
2012-07-15 18:19:38 +02:00
// text_dst is deleted by this GUIFormSpecMenu
void setTextDest(TextDest *text_dst)
{
if (m_text_dst != NULL) {
delete m_text_dst;
}
2012-07-15 18:19:38 +02:00
m_text_dst = text_dst;
}
void allowClose(bool value)
{
m_allowclose = value;
}
void lockSize(bool lock,v2u32 basescreensize=v2u32(0,0))
{
m_lock = lock;
m_lockscreensize = basescreensize;
}
2010-12-25 15:04:51 +01:00
void removeChildren();
2013-08-19 11:26:51 +02:00
void setInitialFocus();
2015-06-10 01:54:33 +02:00
void setFocus(std::string &elementname)
{
m_focused_element = elementname;
}
2010-12-22 02:34:21 +01:00
/*
Remove and re-add (or reposition) stuff
*/
2010-12-23 14:31:50 +01:00
void regenerateGui(v2u32 screensize);
2010-12-22 15:30:23 +01:00
ItemSpec getItemAtPos(v2s32 p) const;
2016-01-24 14:19:17 +01:00
void drawList(const ListDrawSpec &s, int phase, bool &item_hovered);
void drawSelectedItem();
2010-12-23 14:31:50 +01:00
void drawMenu();
void updateSelectedItem();
ItemStack verifySelectedItem();
2010-12-22 02:34:21 +01:00
void acceptInput(FormspecQuitMode quitmode);
2013-08-19 11:26:51 +02:00
bool preprocessEvent(const SEvent& event);
2010-12-22 02:34:21 +01:00
bool OnEvent(const SEvent& event);
2014-03-13 14:06:18 +01:00
bool doPause;
bool pausesGame() { return doPause; }
2015-06-10 01:54:33 +02:00
GUITable* getTable(const std::string &tablename);
2013-08-23 12:24:11 +02:00
#ifdef __ANDROID__
bool getAndroidUIInput();
#endif
protected:
2010-12-22 15:30:23 +01:00
v2s32 getBasePos() const
{
return padding + offset + AbsoluteRect.UpperLeftCorner;
2010-12-22 15:30:23 +01:00
}
v2s32 padding;
v2s32 spacing;
v2s32 imgsize;
v2s32 offset;
irr::IrrlichtDevice* m_device;
2011-04-04 14:13:19 +02:00
InventoryManager *m_invmgr;
IGameDef *m_gamedef;
ISimpleTextureSource *m_tsrc;
Client *m_client;
2010-12-22 15:30:23 +01:00
2012-06-03 15:03:19 +02:00
std::string m_formspec_string;
InventoryLocation m_current_inventory_location;
2012-12-20 18:19:49 +01:00
std::vector<ListDrawSpec> m_inventorylists;
std::vector<ListRingSpec> m_inventory_rings;
2012-12-20 18:19:49 +01:00
std::vector<ImageDrawSpec> m_backgrounds;
std::vector<ImageDrawSpec> m_images;
std::vector<ImageDrawSpec> m_itemimages;
std::vector<BoxDrawSpec> m_boxes;
2012-12-20 18:19:49 +01:00
std::vector<FieldSpec> m_fields;
std::vector<StaticTextSpec> m_static_texts;
2013-08-23 12:24:11 +02:00
std::vector<std::pair<FieldSpec,GUITable*> > m_tables;
std::vector<std::pair<FieldSpec,gui::IGUICheckBox*> > m_checkboxes;
2015-06-10 01:54:33 +02:00
std::map<std::string, TooltipSpec> m_tooltips;
2014-06-19 18:17:35 +02:00
std::vector<std::pair<FieldSpec,gui::IGUIScrollBar*> > m_scrollbars;
2010-12-22 15:30:23 +01:00
ItemSpec *m_selected_item;
2016-01-24 14:19:17 +01:00
f32 m_timer1;
f32 m_timer2;
u32 m_selected_amount;
bool m_selected_dragging;
// 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;
2011-12-01 10:25:55 +01:00
v2s32 m_pointer;
v2s32 m_old_pointer; // Mouse position after previous mouse event
gui::IGUIStaticText *m_tooltip_element;
2014-06-25 11:52:09 +02:00
u32 m_tooltip_show_delay;
2014-10-30 07:53:20 +01:00
s32 m_hovered_time;
s32 m_old_tooltip_id;
std::string m_old_tooltip;
bool m_rmouse_auto_place;
bool m_allowclose;
bool m_lock;
v2u32 m_lockscreensize;
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;
video::SColor m_default_tooltip_bgcolor;
video::SColor m_default_tooltip_color;
private:
IFormSource *m_form_src;
TextDest *m_text_dst;
2014-06-25 19:04:47 +02:00
unsigned int m_formspec_version;
2015-06-10 01:54:33 +02:00
std::string m_focused_element;
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-21 00:42:27 +02:00
bool explicit_size;
v2f invsize;
v2s32 size;
core::rect<s32> rect;
v2s32 basepos;
v2u32 screensize;
2015-06-10 01:54:33 +02:00
std::string focused_fieldname;
2013-08-23 12:24:11 +02:00
GUITable::TableOptions table_options;
GUITable::TableColumns table_columns;
// used to restore table selection/scroll/treeview state
2015-06-10 01:54:33 +02:00
std::map<std::string, GUITable::DynamicData> table_dyndata;
} parserData;
2013-07-07 21:53:40 +02:00
typedef struct {
bool key_up;
bool key_down;
bool key_enter;
bool key_escape;
} fs_key_pendig;
fs_key_pendig current_keys_pending;
void parseElement(parserData* data,std::string element);
void parseSize(parserData* data,std::string element);
void parseList(parserData* data,std::string element);
void parseListRing(parserData* data,std::string element);
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 12:24:11 +02:00
void parseTableOptions(parserData* data,std::string element);
void parseTableColumns(parserData* data,std::string element);
void parseTable(parserData* data,std::string element);
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);
void parseTextArea(parserData* data,std::vector<std::string>& parts,
std::string type);
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);
void parseBackgroundColor(parserData* data,std::string element);
void parseListColors(parserData* data,std::string element);
void parseTooltip(parserData* data,std::string element);
2014-06-25 19:04:47 +02: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-21 00:42:27 +02:00
bool parseSizeDirect(parserData* data, std::string element);
2014-06-19 18:17:35 +02:00
void parseScrollBar(parserData* data, std::string element);
/**
* 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];
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-21 00:42:27 +02:00
gui::IGUIFont *m_font;
std::wstring getLabelByID(s32 id);
2015-06-10 01:54:33 +02:00
std::string getNameByID(s32 id);
#ifdef __ANDROID__
v2s32 m_down_pos;
2015-06-10 01:54:33 +02:00
std::string m_JavaDialogFieldName;
#endif
/* 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;
};
class FormspecFormSource: public IFormSource
{
public:
FormspecFormSource(std::string formspec)
{
m_formspec = formspec;
}
~FormspecFormSource()
{}
void setForm(std::string formspec) {
2014-06-25 19:04:47 +02:00
m_formspec = FORMSPEC_VERSION_STRING + formspec;
}
std::string getForm()
{
return m_formspec;
}
std::string m_formspec;
2010-12-22 02:34:21 +01:00
};
#endif