src/guiFormSpecMenu.h

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20
  21 #ifndef GUIINVENTORYMENU_HEADER
  22 #define GUIINVENTORYMENU_HEADER
  23
  24 #include <utility>
  25
  26 #include "irrlichttypes_extrabloated.h"
  27 #include "inventory.h"
  28 #include "inventorymanager.h"
  29 #include "modalMenu.h"
  30 #include "guiTable.h"
  31 #include "network/networkprotocol.h"
  32 #include "util/string.h"
  33
  34 class IGameDef;
  35 class InventoryManager;
  36 class ISimpleTextureSource;
  37 class Client;
  38
  39 typedef enum {
  40         f_Button,
  41         f_Table,
  42         f_TabHeader,
  43         f_CheckBox,
  44         f_DropDown,
  45         f_ScrollBar,
  46         f_Unknown
  47 } FormspecFieldType;
  48
  49 typedef enum {
  50         quit_mode_no,
  51         quit_mode_accept,
  52         quit_mode_cancel
  53 } FormspecQuitMode;
  54
  55 struct TextDest
  56 {
  57         virtual ~TextDest() {};
  58         // This is deprecated I guess? -celeron55
  59         virtual void gotText(std::wstring text){}
  60         virtual void gotText(const StringMap &fields) = 0;
  61         virtual void setFormName(std::string formname)
  62         { m_formname = formname;};
  63
  64         std::string m_formname;
  65 };
  66
  67 class IFormSource
  68 {
  69 public:
  70         virtual ~IFormSource(){}
  71         virtual std::string getForm() = 0;
  72         // Fill in variables in field text
  73         virtual std::string resolveText(std::string str){ return str; }
  74 };
  75
  76 class GUIFormSpecMenu : public GUIModalMenu
  77 {
  78         struct ItemSpec
  79         {
  80                 ItemSpec()
  81                 {
  82                         i = -1;
  83                 }
  84                 ItemSpec(const InventoryLocation &a_inventoryloc,
  85                                 const std::string &a_listname,
  86                                 s32 a_i)
  87                 {
  88                         inventoryloc = a_inventoryloc;
  89                         listname = a_listname;
  90                         i = a_i;
  91                 }
  92                 bool isValid() const
  93                 {
  94                         return i != -1;
  95                 }
  96
  97                 InventoryLocation inventoryloc;
  98                 std::string listname;
  99                 s32 i;
 100         };
 101
 102         struct ListDrawSpec
 103         {
 104                 ListDrawSpec()
 105                 {
 106                 }
 107                 ListDrawSpec(const InventoryLocation &a_inventoryloc,
 108                                 const std::string &a_listname,
 109                                 v2s32 a_pos, v2s32 a_geom, s32 a_start_item_i):
 110                         inventoryloc(a_inventoryloc),
 111                         listname(a_listname),
 112                         pos(a_pos),
 113                         geom(a_geom),
 114                         start_item_i(a_start_item_i)
 115                 {
 116                 }
 117
 118                 InventoryLocation inventoryloc;
 119                 std::string listname;
 120                 v2s32 pos;
 121                 v2s32 geom;
 122                 s32 start_item_i;
 123         };
 124
 125         struct ListRingSpec
 126         {
 127                 ListRingSpec()
 128                 {
 129                 }
 130                 ListRingSpec(const InventoryLocation &a_inventoryloc,
 131                                 const std::string &a_listname):
 132                         inventoryloc(a_inventoryloc),
 133                         listname(a_listname)
 134                 {
 135                 }
 136
 137                 InventoryLocation inventoryloc;
 138                 std::string listname;
 139         };
 140
 141         struct ImageDrawSpec
 142         {
 143                 ImageDrawSpec():
 144                         parent_button(NULL)
 145                 {
 146                 }
 147                 ImageDrawSpec(const std::string &a_name,
 148                                 const std::string &a_item_name,
 149                                 gui::IGUIButton *a_parent_button,
 150                                 const v2s32 &a_pos, const v2s32 &a_geom):
 151                         name(a_name),
 152                         item_name(a_item_name),
 153                         parent_button(a_parent_button),
 154                         pos(a_pos),
 155                         geom(a_geom),
 156                         scale(true)
 157                 {
 158                 }
 159                 ImageDrawSpec(const std::string &a_name,
 160                                 const std::string &a_item_name,
 161                                 const v2s32 &a_pos, const v2s32 &a_geom):
 162                         name(a_name),
 163                         item_name(a_item_name),
 164                         parent_button(NULL),
 165                         pos(a_pos),
 166                         geom(a_geom),
 167                         scale(true)
 168                 {
 169                 }
 170                 ImageDrawSpec(const std::string &a_name,
 171                                 const v2s32 &a_pos, const v2s32 &a_geom):
 172                         name(a_name),
 173                         parent_button(NULL),
 174                         pos(a_pos),
 175                         geom(a_geom),
 176                         scale(true)
 177                 {
 178                 }
 179                 ImageDrawSpec(const std::string &a_name,
 180                                 const v2s32 &a_pos):
 181                         name(a_name),
 182                         parent_button(NULL),
 183                         pos(a_pos),
 184                         scale(false)
 185                 {
 186                 }
 187                 std::string name;
 188                 std::string item_name;
 189                 gui::IGUIButton *parent_button;
 190                 v2s32 pos;
 191                 v2s32 geom;
 192                 bool scale;
 193         };
 194
 195         /* The responsibility of unescaping the strings has been shifted
 196          * from the formspec parsing methods to the draw methods.
 197          * There still are a few exceptions:
 198          *  - Vertical label, because it modifies the string by inserting
 199          *    '\n' between each character,
 200          *  - Tab header, because it gives the string immediately to
 201          *    Irrlicht and we can't unescape it later.
 202          */
 203         struct FieldSpec
 204         {
 205                 FieldSpec()
 206                 {
 207                 }
 208                 FieldSpec(const std::string &name, const std::wstring &label,
 209                                 const std::wstring &default_text, int id) :
 210                         fname(name),
 211                         fid(id)
 212                 {
 213                         flabel = unescape_string(unescape_enriched(label));
 214                         fdefault = unescape_string(unescape_enriched(default_text));
 215                         send = false;
 216                         ftype = f_Unknown;
 217                         is_exit = false;
 218                 }
 219                 std::string fname;
 220                 std::wstring flabel;
 221                 std::wstring fdefault;
 222                 int fid;
 223                 bool send;
 224                 FormspecFieldType ftype;
 225                 bool is_exit;
 226                 core::rect<s32> rect;
 227         };
 228
 229         struct BoxDrawSpec {
 230                 BoxDrawSpec(v2s32 a_pos, v2s32 a_geom,irr::video::SColor a_color):
 231                         pos(a_pos),
 232                         geom(a_geom),
 233                         color(a_color)
 234                 {
 235                 }
 236                 v2s32 pos;
 237                 v2s32 geom;
 238                 irr::video::SColor color;
 239         };
 240
 241         struct TooltipSpec {
 242                 TooltipSpec()
 243                 {
 244                 }
 245                 TooltipSpec(std::string a_tooltip, irr::video::SColor a_bgcolor,
 246                                 irr::video::SColor a_color):
 247                         bgcolor(a_bgcolor),
 248                         color(a_color)
 249                 {
 250                         tooltip = unescape_string(unescape_enriched(utf8_to_wide(a_tooltip)));
 251                 }
 252                 std::wstring tooltip;
 253                 irr::video::SColor bgcolor;
 254                 irr::video::SColor color;
 255         };
 256
 257         struct StaticTextSpec {
 258                 StaticTextSpec():
 259                         parent_button(NULL)
 260                 {
 261                 }
 262                 StaticTextSpec(const std::wstring &a_text,
 263                                 const core::rect<s32> &a_rect):
 264                         rect(a_rect),
 265                         parent_button(NULL)
 266                 {
 267                         text = unescape_string(unescape_enriched(a_text));
 268                 }
 269                 StaticTextSpec(const std::wstring &a_text,
 270                                 const core::rect<s32> &a_rect,
 271                                 gui::IGUIButton *a_parent_button):
 272                         rect(a_rect),
 273                         parent_button(a_parent_button)
 274                 {
 275                         text = unescape_string(unescape_enriched(a_text));
 276                 }
 277                 std::wstring text;
 278                 core::rect<s32> rect;
 279                 gui::IGUIButton *parent_button;
 280         };
 281
 282 public:
 283         GUIFormSpecMenu(irr::IrrlichtDevice* dev,
 284                         gui::IGUIElement* parent, s32 id,
 285                         IMenuManager *menumgr,
 286                         InventoryManager *invmgr,
 287                         IGameDef *gamedef,
 288                         ISimpleTextureSource *tsrc,
 289                         IFormSource* fs_src,
 290                         TextDest* txt_dst,
 291                         Client* client,
 292                         bool remap_dbl_click = true);
 293
 294         ~GUIFormSpecMenu();
 295
 296         void setFormSpec(const std::string &formspec_string,
 297                         InventoryLocation current_inventory_location)
 298         {
 299                 m_formspec_string = formspec_string;
 300                 m_current_inventory_location = current_inventory_location;
 301                 regenerateGui(m_screensize_old);
 302         }
 303
 304         // form_src is deleted by this GUIFormSpecMenu
 305         void setFormSource(IFormSource *form_src)
 306         {
 307                 if (m_form_src != NULL) {
 308                         delete m_form_src;
 309                 }
 310                 m_form_src = form_src;
 311         }
 312
 313         // text_dst is deleted by this GUIFormSpecMenu
 314         void setTextDest(TextDest *text_dst)
 315         {
 316                 if (m_text_dst != NULL) {
 317                         delete m_text_dst;
 318                 }
 319                 m_text_dst = text_dst;
 320         }
 321
 322         void allowClose(bool value)
 323         {
 324                 m_allowclose = value;
 325         }
 326
 327         void lockSize(bool lock,v2u32 basescreensize=v2u32(0,0))
 328         {
 329                 m_lock = lock;
 330                 m_lockscreensize = basescreensize;
 331         }
 332
 333         void removeChildren();
 334         void setInitialFocus();
 335
 336         void setFocus(std::string &elementname)
 337         {
 338                 m_focused_element = elementname;
 339         }
 340
 341         /*
 342                 Remove and re-add (or reposition) stuff
 343         */
 344         void regenerateGui(v2u32 screensize);
 345
 346         ItemSpec getItemAtPos(v2s32 p) const;
 347         void drawList(const ListDrawSpec &s, int phase, bool &item_hovered);
 348         void drawSelectedItem();
 349         void drawMenu();
 350         void updateSelectedItem();
 351         ItemStack verifySelectedItem();
 352
 353         void acceptInput(FormspecQuitMode quitmode);
 354         bool preprocessEvent(const SEvent& event);
 355         bool OnEvent(const SEvent& event);
 356         bool doPause;
 357         bool pausesGame() { return doPause; }
 358
 359         GUITable* getTable(const std::string &tablename);
 360
 361 #ifdef __ANDROID__
 362         bool getAndroidUIInput();
 363 #endif
 364
 365 protected:
 366         v2s32 getBasePos() const
 367         {
 368                         return padding + offset + AbsoluteRect.UpperLeftCorner;
 369         }
 370
 371         v2s32 padding;
 372         v2s32 spacing;
 373         v2s32 imgsize;
 374         v2s32 offset;
 375
 376         irr::IrrlichtDevice* m_device;
 377         InventoryManager *m_invmgr;
 378         IGameDef *m_gamedef;
 379         ISimpleTextureSource *m_tsrc;
 380         Client *m_client;
 381
 382         std::string m_formspec_string;
 383         InventoryLocation m_current_inventory_location;
 384
 385
 386         std::vector<ListDrawSpec> m_inventorylists;
 387         std::vector<ListRingSpec> m_inventory_rings;
 388         std::vector<ImageDrawSpec> m_backgrounds;
 389         std::vector<ImageDrawSpec> m_images;
 390         std::vector<ImageDrawSpec> m_itemimages;
 391         std::vector<BoxDrawSpec> m_boxes;
 392         std::vector<FieldSpec> m_fields;
 393         std::vector<StaticTextSpec> m_static_texts;
 394         std::vector<std::pair<FieldSpec,GUITable*> > m_tables;
 395         std::vector<std::pair<FieldSpec,gui::IGUICheckBox*> > m_checkboxes;
 396         std::map<std::string, TooltipSpec> m_tooltips;
 397         std::vector<std::pair<FieldSpec,gui::IGUIScrollBar*> > m_scrollbars;
 398
 399         ItemSpec *m_selected_item;
 400         f32 m_timer1;
 401         f32 m_timer2;
 402         u32 m_selected_amount;
 403         bool m_selected_dragging;
 404
 405         // WARNING: BLACK MAGIC
 406         // Used to guess and keep up with some special things the server can do.
 407         // If name is "", no guess exists.
 408         ItemStack m_selected_content_guess;
 409         InventoryLocation m_selected_content_guess_inventory;
 410
 411         v2s32 m_pointer;
 412         v2s32 m_old_pointer;  // Mouse position after previous mouse event
 413         gui::IGUIStaticText *m_tooltip_element;
 414
 415         u32 m_tooltip_show_delay;
 416         s32 m_hovered_time;
 417         s32 m_old_tooltip_id;
 418         std::wstring m_old_tooltip;
 419
 420         bool m_rmouse_auto_place;
 421
 422         bool m_allowclose;
 423         bool m_lock;
 424         v2u32 m_lockscreensize;
 425
 426         bool m_bgfullscreen;
 427         bool m_slotborder;
 428         bool m_clipbackground;
 429         video::SColor m_bgcolor;
 430         video::SColor m_slotbg_n;
 431         video::SColor m_slotbg_h;
 432         video::SColor m_slotbordercolor;
 433         video::SColor m_default_tooltip_bgcolor;
 434         video::SColor m_default_tooltip_color;
 435
 436 private:
 437         IFormSource      *m_form_src;
 438         TextDest         *m_text_dst;
 439         unsigned int      m_formspec_version;
 440         std::string       m_focused_element;
 441
 442         typedef struct {
 443                 bool explicit_size;
 444                 v2f invsize;
 445                 v2s32 size;
 446                 core::rect<s32> rect;
 447                 v2s32 basepos;
 448                 v2u32 screensize;
 449                 std::string focused_fieldname;
 450                 GUITable::TableOptions table_options;
 451                 GUITable::TableColumns table_columns;
 452                 // used to restore table selection/scroll/treeview state
 453                 std::map<std::string, GUITable::DynamicData> table_dyndata;
 454         } parserData;
 455
 456         typedef struct {
 457                 bool key_up;
 458                 bool key_down;
 459                 bool key_enter;
 460                 bool key_escape;
 461         } fs_key_pendig;
 462
 463         fs_key_pendig current_keys_pending;
 464
 465         void parseElement(parserData* data,std::string element);
 466
 467         void parseSize(parserData* data,std::string element);
 468         void parseList(parserData* data,std::string element);
 469         void parseListRing(parserData* data,std::string element);
 470         void parseCheckbox(parserData* data,std::string element);
 471         void parseImage(parserData* data,std::string element);
 472         void parseItemImage(parserData* data,std::string element);
 473         void parseButton(parserData* data,std::string element,std::string typ);
 474         void parseBackground(parserData* data,std::string element);
 475         void parseTableOptions(parserData* data,std::string element);
 476         void parseTableColumns(parserData* data,std::string element);
 477         void parseTable(parserData* data,std::string element);
 478         void parseTextList(parserData* data,std::string element);
 479         void parseDropDown(parserData* data,std::string element);
 480         void parsePwdField(parserData* data,std::string element);
 481         void parseField(parserData* data,std::string element,std::string type);
 482         void parseSimpleField(parserData* data,std::vector<std::string> &parts);
 483         void parseTextArea(parserData* data,std::vector<std::string>& parts,
 484                         std::string type);
 485         void parseLabel(parserData* data,std::string element);
 486         void parseVertLabel(parserData* data,std::string element);
 487         void parseImageButton(parserData* data,std::string element,std::string type);
 488         void parseItemImageButton(parserData* data,std::string element);
 489         void parseTabHeader(parserData* data,std::string element);
 490         void parseBox(parserData* data,std::string element);
 491         void parseBackgroundColor(parserData* data,std::string element);
 492         void parseListColors(parserData* data,std::string element);
 493         void parseTooltip(parserData* data,std::string element);
 494         bool parseVersionDirect(std::string data);
 495         bool parseSizeDirect(parserData* data, std::string element);
 496         void parseScrollBar(parserData* data, std::string element);
 497
 498         /**
 499          * check if event is part of a double click
 500          * @param event event to evaluate
 501          * @return true/false if a doubleclick was detected
 502          */
 503         bool DoubleClickDetection(const SEvent event);
 504
 505         struct clickpos
 506         {
 507                 v2s32 pos;
 508                 s32 time;
 509         };
 510         clickpos m_doubleclickdetect[2];
 511
 512         int m_btn_height;
 513         gui::IGUIFont *m_font;
 514
 515         std::wstring getLabelByID(s32 id);
 516         std::string getNameByID(s32 id);
 517 #ifdef __ANDROID__
 518         v2s32 m_down_pos;
 519         std::string m_JavaDialogFieldName;
 520 #endif
 521
 522         /* If true, remap a double-click (or double-tap) action to ESC. This is so
 523          * that, for example, Android users can double-tap to close a formspec.
 524         *
 525          * This value can (currently) only be set by the class constructor
 526          * and the default value for the setting is true.
 527          */
 528         bool m_remap_dbl_click;
 529
 530 };
 531
 532 class FormspecFormSource: public IFormSource
 533 {
 534 public:
 535         FormspecFormSource(std::string formspec)
 536         {
 537                 m_formspec = formspec;
 538         }
 539
 540         ~FormspecFormSource()
 541         {}
 542
 543         void setForm(std::string formspec) {
 544                 m_formspec = FORMSPEC_VERSION_STRING + formspec;
 545         }
 546
 547         std::string getForm()
 548         {
 549                 return m_formspec;
 550         }
 551
 552         std::string m_formspec;
 553 };
 554
 555 #endif
 556