source/gui/CGUI.h

   1 /* Copyright (C) 2022 Wildfire Games.
   2  * This file is part of 0 A.D.
   3  *
   4  * 0 A.D. is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * 0 A.D. is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 /*
  19  * This is the top class of the whole GUI, all objects
  20  * and settings are stored within this class.
  21  */
  22
  23 #ifndef INCLUDED_CGUI
  24 #define INCLUDED_CGUI
  25
  26 #include "gui/GUITooltip.h"
  27 #include "gui/SettingTypes/CGUIColor.h"
  28 #include "gui/SGUIIcon.h"
  29 #include "gui/SGUIMessage.h"
  30 #include "gui/SGUIStyle.h"
  31 #include "lib/input.h"
  32 #include "maths/Rect.h"
  33 #include "maths/Size2D.h"
  34 #include "maths/Vector2D.h"
  35 #include "ps/XML/Xeromyces.h"
  36 #include "scriptinterface/ScriptForward.h"
  37
  38 #include <map>
  39 #include <memory>
  40 #include <unordered_map>
  41 #include <unordered_set>
  42 #include <vector>
  43
  44 extern const double SELECT_DBLCLICK_RATE;
  45
  46 class CCanvas2D;
  47 class CGUISpriteInstance;
  48 class CGUISprite;
  49 class IGUIObject;
  50 struct SGUIImageEffects;
  51 struct SGUIScrollBarStyle;
  52
  53 class GUIProxyProps;
  54
  55 using map_pObjects = std::map<CStr, IGUIObject*>;
  56
  57 /**
  58  * The main object that represents a whole GUI page.
  59  */
  60 class CGUI
  61 {
  62         NONCOPYABLE(CGUI);
  63
  64 private:
  65         // Private typedefs
  66         using ConstructObjectFunction = IGUIObject* (*)(CGUI&);
  67
  68 public:
  69         CGUI(const std::shared_ptr<ScriptContext>& context);
  70         ~CGUI();
  71
  72         /**
  73          * Informs the GUI page which GUI object types may be constructed from XML.
  74          */
  75         void AddObjectTypes();
  76
  77         /**
  78          * Performs processing that should happen every frame
  79          * (including sending the "Tick" event to scripts)
  80          */
  81         void TickObjects();
  82
  83         /**
  84          * Sends a specified script event to every object
  85          *
  86          * @param eventName String representation of event name
  87          */
  88         void SendEventToAll(const CStr& eventName);
  89
  90         /**
  91          * Sends a specified script event to every object
  92          *
  93          * @param eventName String representation of event name
  94          * @param paramData JS::HandleValueArray storing the arguments passed to the event handler.
  95          */
  96         void SendEventToAll(const CStr& eventName, const JS::HandleValueArray& paramData);
  97
  98         /**
  99          * Displays the whole GUI
 100          */
 101         void Draw(CCanvas2D& canvas);
 102
 103         /**
 104          * Draw GUI Sprite
 105          *
 106          * @param Sprite Object referring to the sprite (which also caches
 107          *        calculations for faster rendering)
 108          * @param Canvas Canvas to draw on
 109          * @param Rect Position and Size
 110          * @param Clipping The sprite shouldn't be drawn outside this rectangle
 111          */
 112         void DrawSprite(const CGUISpriteInstance& Sprite, CCanvas2D& canvas, const CRect& Rect, const CRect& Clipping = CRect());
 113
 114         /**
 115          * The replacement of Process(), handles an SDL_Event_
 116          *
 117          * @param ev SDL Event, like mouse/keyboard input
 118          */
 119         InReaction HandleEvent(const SDL_Event_* ev);
 120
 121         /**
 122          * Load a GUI XML file into the GUI.
 123          *
 124          * <b>VERY IMPORTANT!</b> All \<styles\>-files must be read before
 125          * everything else!
 126          *
 127          * @param Filename Name of file
 128          * @param Paths Set of paths; all XML and JS files loaded will be added to this
 129          */
 130         void LoadXmlFile(const VfsPath& Filename, std::unordered_set<VfsPath>& Paths);
 131
 132         /**
 133          * Called after all XML files linked in the page file were loaded.
 134          */
 135         void LoadedXmlFiles();
 136
 137         /**
 138          * Allows the JS side to modify the hotkey setting assigned to a GUI object.
 139          */
 140         void SetObjectHotkey(IGUIObject* pObject, const CStr& hotkeyTag);
 141         void UnsetObjectHotkey(IGUIObject* pObject, const CStr& hotkeyTag);
 142
 143         /**
 144          * Allows the JS side to modify the style setting assigned to a GUI object.
 145          */
 146         void SetObjectStyle(IGUIObject* pObject, const CStr& styleName);
 147         void UnsetObjectStyle(IGUIObject* pObject);
 148
 149         /**
 150          * Allows the JS side to add or remove global hotkeys.
 151          */
 152         void SetGlobalHotkey(const CStr& hotkeyTag, const CStr& eventName, JS::HandleValue function);
 153         void UnsetGlobalHotkey(const CStr& hotkeyTag, const CStr& eventName);
 154
 155         /**
 156          * Return the object which is an ancestor of every other GUI object.
 157          */
 158         IGUIObject* GetBaseObject();
 159
 160         /**
 161          * Checks if object exists and return true or false accordingly
 162          *
 163          * @param Name String name of object
 164          * @return true if object exists
 165          */
 166         bool ObjectExists(const CStr& Name) const;
 167
 168         /**
 169          * Returns the GUI object with the desired name, or nullptr
 170          * if no match is found,
 171          *
 172          * @param Name String name of object
 173          * @return Matching object, or nullptr
 174          */
 175         IGUIObject* FindObjectByName(const CStr& Name) const;
 176
 177         /**
 178          * Returns the GUI object under the mouse, or nullptr if none.
 179          */
 180         IGUIObject* FindObjectUnderMouse();
 181
 182         /**
 183          * Returns the current screen coordinates of the cursor.
 184          */
 185         const CVector2D& GetMousePos() const { return m_MousePos; }
 186
 187         /**
 188          * Returns the currently pressed mouse buttons.
 189          */
 190         const unsigned int& GetMouseButtons() { return m_MouseButtons; }
 191
 192         const SGUIScrollBarStyle* GetScrollBarStyle(const CStr& style) const;
 193
 194         /**
 195          * Returns the current GUI window size.
 196          */
 197         CSize2D GetWindowSize() const;
 198
 199         /**
 200          * The GUI needs to have all object types inputted and
 201          * their constructors. Also it needs to associate a type
 202          * by a string name of the type.
 203          *
 204          * To add a type:
 205          * @code
 206          * AddObjectType("button", &CButton::ConstructObject);
 207          * @endcode
 208          *
 209          * @param str Reference name of object type
 210          * @param pFunc Pointer of function ConstuctObject() in the object
 211          *
 212          * @see CGUI#ConstructObject()
 213          */
 214         void AddObjectType(const CStr& str, ConstructObjectFunction pFunc) { m_ObjectTypes[str] = pFunc; }
 215
 216         /**
 217          * Update Resolution, should be called every time the resolution
 218          * of the OpenGL screen has been changed, this is because it needs
 219          * to re-cache all its actual sizes
 220          *
 221          * Needs no input since screen resolution is global.
 222          *
 223          * @see IGUIObject#UpdateCachedSize()
 224          */
 225         void UpdateResolution();
 226
 227         /**
 228          * Check if an icon exists
 229          */
 230         bool HasIcon(const CStr& name) const { return (m_Icons.find(name) != m_Icons.end()); }
 231
 232         /**
 233          * Get Icon (a const reference, can never be changed)
 234          */
 235         const SGUIIcon& GetIcon(const CStr& name) const { return m_Icons.at(name); }
 236
 237         /**
 238          * Check if a style exists
 239          */
 240         bool HasStyle(const CStr& name) const { return (m_Styles.find(name) != m_Styles.end()); }
 241
 242         /**
 243          * Get Style if it exists, otherwise throws an exception.
 244          */
 245         const SGUIStyle& GetStyle(const CStr& name) const { return m_Styles.at(name); }
 246
 247         /**
 248          * Check if a predefined color of that name exists.
 249          */
 250         bool HasPreDefinedColor(const CStr& name) const { return (m_PreDefinedColors.find(name) != m_PreDefinedColors.end()); }
 251
 252         /**
 253          * Resolve the predefined color if it exists, otherwise throws an exception.
 254          */
 255         const CGUIColor& GetPreDefinedColor(const CStr& name) const { return m_PreDefinedColors.at(name); }
 256
 257         GUIProxyProps* GetProxyData(const js::BaseProxyHandler* ptr) { return m_ProxyData.at(ptr).get(); }
 258
 259         std::shared_ptr<ScriptInterface> GetScriptInterface() { return m_ScriptInterface; };
 260
 261 private:
 262         /**
 263          * The CGUI takes ownership of the child object and links the parent with the child.
 264          * Returns false on failure to take over ownership of the child object.
 265          */
 266         bool AddObject(IGUIObject& parent, IGUIObject& child);
 267
 268         /**
 269          * You input the name of the object type, and let's
 270          * say you input "button", then it will construct a
 271          * CGUIObjet* as a CButton.
 272          *
 273          * @param str Name of object type
 274          * @return Newly constructed IGUIObject (but constructed as a subclass)
 275          */
 276         IGUIObject* ConstructObject(const CStr& str);
 277
 278 public:
 279         /**
 280          * Get Focused Object.
 281          */
 282         IGUIObject* GetFocusedObject() { return m_FocusedObject; }
 283
 284         /**
 285          * Change focus to new object.
 286          * Will send LOST_FOCUS/GOT_FOCUS messages as appropriate.
 287          * pObject can be nullptr to remove all focus.
 288          */
 289         void SetFocusedObject(IGUIObject* pObject);
 290
 291         /**
 292          * Alert the focussed object of this GUIPage that the focus of the page has changed.
 293          */
 294         void SendFocusMessage(EGUIMessageType msg);
 295
 296         /**
 297          * Reads a string value and modifies the given value of type T if successful.
 298          * Does not change the value upon conversion failure.
 299          *
 300          * @param pGUI The GUI page which may contain data relevant to the parsing
 301          *             (for example predefined colors).
 302          * @param Value The value in string form, like "0 0 100% 100%"
 303          * @param tOutput Parsed value of type T
 304          * @return True at success.
 305          */
 306         template <typename T>
 307         static bool ParseString(const CGUI* pGUI, const CStrW& Value, T& tOutput);
 308
 309 private:
 310
 311         //--------------------------------------------------------
 312         /** @name XML Reading Xeromyces specific subroutines
 313          *
 314          * These does not throw!
 315          * Because when reading in XML files, it won't be fatal
 316          * if an error occurs, perhaps one particular object
 317          * fails, but it'll still continue reading in the next.
 318          * All Error are reported with ReportParseError
 319          */
 320         //--------------------------------------------------------
 321
 322         /*
 323                 Xeromyces_* functions tree
 324                 <objects> (ReadRootObjects)
 325                  |
 326                  +-<script> (ReadScript)
 327                  |
 328                  +-<object> (ReadObject)
 329                         |
 330                         +-<action>
 331                         |
 332                         +-Optional Type Extensions (IGUIObject::ReadExtendedElement) TODO
 333                         |
 334                         +-<<object>> *recursive*
 335
 336
 337                 <styles> (ReadRootStyles)
 338                  |
 339                  +-<style> (ReadStyle)
 340
 341
 342                 <sprites> (ReadRootSprites)
 343                  |
 344                  +-<sprite> (ReadSprite)
 345                         |
 346                         +-<image> (ReadImage)
 347
 348
 349                 <setup> (ReadRootSetup)
 350                  |
 351                  +-<tooltip> (ReadToolTip)
 352                  |
 353                  +-<scrollbar> (ReadScrollBar)
 354                  |
 355                  +-<icon> (ReadIcon)
 356                  |
 357                  +-<color> (ReadColor)
 358         */
 359         //@{
 360
 361         // Read Roots
 362
 363         /**
 364          * Reads in the root element \<objects\> (the DOMElement).
 365          *
 366          * @param Element       The Xeromyces object that represents
 367          *                                      the objects-tag.
 368          * @param pFile         The Xeromyces object for the file being read
 369          * @param Paths         Collects the set of all XML/JS files that are loaded
 370          *
 371          * @see LoadXmlFile()
 372          */
 373         void Xeromyces_ReadRootObjects(const XMBData& xmb, XMBElement element, std::unordered_set<VfsPath>& Paths);
 374
 375         /**
 376          * Reads in the root element \<sprites\> (the DOMElement).
 377          *
 378          * @param Element       The Xeromyces object that represents
 379          *                                      the sprites-tag.
 380          * @param pFile         The Xeromyces object for the file being read
 381          *
 382          * @see LoadXmlFile()
 383          */
 384         void Xeromyces_ReadRootSprites(const XMBData& xmb, XMBElement element);
 385
 386         /**
 387          * Reads in the root element \<styles\> (the DOMElement).
 388          *
 389          * @param Element       The Xeromyces object that represents
 390          *                                      the styles-tag.
 391          * @param pFile         The Xeromyces object for the file being read
 392          *
 393          * @see LoadXmlFile()
 394          */
 395         void Xeromyces_ReadRootStyles(const XMBData& xmb, XMBElement element);
 396
 397         /**
 398          * Reads in the root element \<setup\> (the DOMElement).
 399          *
 400          * @param Element       The Xeromyces object that represents
 401          *                                      the setup-tag.
 402          * @param pFile         The Xeromyces object for the file being read
 403          *
 404          * @see LoadXmlFile()
 405          */
 406         void Xeromyces_ReadRootSetup(const XMBData& xmb, XMBElement element);
 407
 408         // Read Subs
 409
 410         /**
 411          * Notice! Recursive function!
 412          *
 413          * Read in an \<object\> (the XMBElement) and stores it
 414          * as a child in the pParent.
 415          *
 416          * It will also check the object's children and call this function
 417          * on them too. Also it will call all other functions that reads
 418          * in other stuff that can be found within an object. Check the
 419          * tree in the beginning of this class' Xeromyces_* section.
 420          *
 421          * @param Element       The Xeromyces object that represents
 422          *                                      the object-tag.
 423          * @param pFile         The Xeromyces object for the file being read
 424          * @param pParent       Parent to add this object as child in.
 425          * @param NameSubst     A set of substitution strings that will be
 426          *                                      applied to all object names within this object.
 427          * @param Paths         Output set of file paths that this GUI object
 428          *                                      relies on.
 429          *
 430          * @see LoadXmlFile()
 431          */
 432         IGUIObject* Xeromyces_ReadObject(const XMBData& xmb, XMBElement element, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth);
 433
 434         /**
 435          * Reads in the element \<repeat\>, which repeats its child \<object\>s
 436          * 'count' times, replacing the string "[n]" (or the value of the attribute
 437          * 'var' enclosed in square brackets) in its descendants' names with "[0]",
 438          * "[1]", etc.
 439          */
 440         void Xeromyces_ReadRepeat(const XMBData& xmb, XMBElement element, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth);
 441
 442         /**
 443          * Reads in the element \<script\> (the XMBElement) and executes
 444          * the script's code.
 445          *
 446          * @param Element       The Xeromyces object that represents
 447          *                                      the script-tag.
 448          * @param pFile         The Xeromyces object for the file being read
 449          * @param Paths         Output set of file paths that this script is loaded from.
 450          *
 451          * @see LoadXmlFile()
 452          */
 453         void Xeromyces_ReadScript(const XMBData& xmb, XMBElement element, std::unordered_set<VfsPath>& Paths);
 454
 455         /**
 456          * Reads in the element \<sprite\> (the XMBElement) and stores the
 457          * result in a new CGUISprite.
 458          *
 459          * @param Element       The Xeromyces object that represents
 460          *                                      the sprite-tag.
 461          * @param pFile         The Xeromyces object for the file being read
 462          *
 463          * @see LoadXmlFile()
 464          */
 465         void Xeromyces_ReadSprite(const XMBData& xmb, XMBElement element);
 466
 467         /**
 468          * Reads in the element \<image\> (the XMBElement) and stores the
 469          * result within the CGUISprite.
 470          *
 471          * @param Element       The Xeromyces object that represents
 472          *                                      the image-tag.
 473          * @param pFile         The Xeromyces object for the file being read
 474          * @param parent        Parent sprite.
 475          *
 476          * @see LoadXmlFile()
 477          */
 478         void Xeromyces_ReadImage(const XMBData& xmb, XMBElement element, CGUISprite& parent);
 479
 480         /**
 481          * Reads in the element \<effect\> (the XMBElement) and stores the
 482          * result within the SGUIImageEffects.
 483          *
 484          * @param Element       The Xeromyces object that represents
 485          *                                      the image-tag.
 486          * @param pFile         The Xeromyces object for the file being read
 487          * @param effects       Effects object to add this effect to.
 488          *
 489          * @see LoadXmlFile()
 490          */
 491         void Xeromyces_ReadEffects(const XMBData& xmb, XMBElement element, SGUIImageEffects& effects);
 492
 493         /**
 494          * Reads in the element \<style\> (the XMBElement) and stores the
 495          * result in m_Styles.
 496          *
 497          * @param Element       The Xeromyces object that represents
 498          *                                      the style-tag.
 499          * @param pFile         The Xeromyces object for the file being read
 500          *
 501          * @see LoadXmlFile()
 502          */
 503         void Xeromyces_ReadStyle(const XMBData& xmb, XMBElement element);
 504
 505         /**
 506          * Reads in the element \<scrollbar\> (the XMBElement) and stores the
 507          * result in m_ScrollBarStyles.
 508          *
 509          * @param Element       The Xeromyces object that represents
 510          *                                      the scrollbar-tag.
 511          * @param pFile         The Xeromyces object for the file being read
 512          *
 513          * @see LoadXmlFile()
 514          */
 515         void Xeromyces_ReadScrollBarStyle(const XMBData& xmb, XMBElement element);
 516
 517         /**
 518          * Reads in the element \<icon\> (the XMBElement) and stores the
 519          * result in m_Icons.
 520          *
 521          * @param Element       The Xeromyces object that represents
 522          *                                      the scrollbar-tag.
 523          * @param pFile         The Xeromyces object for the file being read
 524          *
 525          * @see LoadXmlFile()
 526          */
 527         void Xeromyces_ReadIcon(const XMBData& xmb, XMBElement element);
 528
 529         /**
 530          * Reads in the element \<tooltip\> (the XMBElement) and stores the
 531          * result as an object with the name __tooltip_#.
 532          *
 533          * @param Element       The Xeromyces object that represents
 534          *                                      the scrollbar-tag.
 535          * @param pFile         The Xeromyces object for the file being read
 536          *
 537          * @see LoadXmlFile()
 538          */
 539         void Xeromyces_ReadTooltip(const XMBData& xmb, XMBElement element);
 540
 541         /**
 542          * Reads in the element \<color\> (the XMBElement) and stores the
 543          * result in m_PreDefinedColors
 544          *
 545          * @param Element       The Xeromyces object that represents
 546          *                                      the scrollbar-tag.
 547          * @param pFile         The Xeromyces object for the file being read
 548          *
 549          * @see LoadXmlFile()
 550          */
 551         void Xeromyces_ReadColor(const XMBData& xmb, XMBElement element);
 552
 553         //@}
 554
 555 private:
 556
 557         // Variables
 558
 559         //--------------------------------------------------------
 560         /** @name Miscellaneous */
 561         //--------------------------------------------------------
 562         //@{
 563
 564         std::shared_ptr<ScriptInterface> m_ScriptInterface;
 565
 566         /**
 567          * don't want to pass this around with the
 568          * ChooseMouseOverAndClosest broadcast -
 569          * we'd need to pack this and pNearest in a struct
 570          */
 571         CVector2D m_MousePos;
 572
 573         /**
 574          * Indicates which buttons are pressed (bit 0 = LMB,
 575          * bit 1 = RMB, bit 2 = MMB)
 576          */
 577         unsigned int m_MouseButtons;
 578
 579         // Tooltip
 580         GUITooltip m_Tooltip;
 581
 582         //@}
 583         //--------------------------------------------------------
 584         /** @name Objects */
 585         //--------------------------------------------------------
 586         //@{
 587
 588         /**
 589          * Base Object, all its children are considered parentless
 590          * because this is not a real object per se.
 591          */
 592         std::unique_ptr<IGUIObject> m_BaseObject;
 593
 594         /**
 595          * Focused object!
 596          * Say an input box that is selected. That one is focused.
 597          * There can only be one focused object.
 598          */
 599         IGUIObject* m_FocusedObject;
 600
 601         /**
 602          * Just pointers for fast name access, each object
 603          * is really constructed within its parent for easy
 604          * recursive management.
 605          * Notice m_BaseObject won't belong here since it's
 606          * not considered a real object.
 607          */
 608         map_pObjects m_pAllObjects;
 609
 610         /**
 611          * Number of object that has been given name automatically.
 612          * the name given will be '__internal(#)', the number (#)
 613          * being this variable. When an object's name has been set
 614          * as followed, the value will increment.
 615          */
 616         int m_InternalNameNumber;
 617
 618         /**
 619          * Function pointers to functions that constructs
 620          * IGUIObjects by name... For instance m_ObjectTypes["button"]
 621          * is filled with a function that will "return new CButton();"
 622          */
 623         std::map<CStr, ConstructObjectFunction> m_ObjectTypes;
 624
 625         /**
 626          * This is intended to store the JSFunction when accessing certain properties.
 627          * The problem is that these functions are per-scriptInterface, and proxy handlers aren't.
 628          * So we know what we want to store, but we don't really have anywhere to store it.
 629          * It would be simpler to recreate the functions on every JS call, but that is slower
 630          * (this may or may not matter now and in the future).
 631          * It's not a great solution, but I can't find a better one at the moment.
 632          * An alternative would be to store these on the proxy's prototype,
 633          * but that embarks a lot of un-necessary code.
 634          */
 635         std::unordered_map<const js::BaseProxyHandler*, std::unique_ptr<GUIProxyProps>> m_ProxyData;
 636
 637         /**
 638          * Map from hotkey names to objects that listen to the hotkey.
 639          * (This is an optimisation to avoid recursing over the whole GUI
 640          * tree every time a hotkey is pressed).
 641          */
 642         std::map<CStr, std::vector<IGUIObject*> > m_HotkeyObjects;
 643
 644         /**
 645          * Map from hotkey names to maps of eventNames to functions that are triggered
 646          * when the hotkey goes through the event. Contrary to object hotkeys, this
 647          * allows for only one global function per hotkey name per event type.
 648          */
 649         std::map<CStr, std::map<CStr, JS::PersistentRootedValue>> m_GlobalHotkeys;
 650
 651         /**
 652          * XML and JS can subscribe handlers to events identified by these names.
 653          * Store in static const members to avoid string copies, gain compile errors when misspelling and
 654          * to allow reuse in other classes.
 655          */
 656         static const CStr EventNameLoad;
 657         static const CStr EventNameTick;
 658         static const CStr EventNamePress;
 659         static const CStr EventNameKeyDown;
 660         static const CStr EventNameRelease;
 661         static const CStr EventNameMouseRightPress;
 662         static const CStr EventNameMouseLeftPress;
 663         static const CStr EventNameMouseWheelDown;
 664         static const CStr EventNameMouseWheelUp;
 665         static const CStr EventNameMouseLeftDoubleClick;
 666         static const CStr EventNameMouseLeftRelease;
 667         static const CStr EventNameMouseRightDoubleClick;
 668         static const CStr EventNameMouseRightRelease;
 669
 670         //--------------------------------------------------------
 671         //      Databases
 672         //      These are loaded from XML files and marked as noncopyable and const to
 673         //      rule out unintentional modification and copy, especially during Draw calls.
 674         //--------------------------------------------------------
 675
 676         // Colors
 677         std::map<CStr, const CGUIColor> m_PreDefinedColors;
 678
 679         // Sprites
 680         std::map<CStr, std::unique_ptr<const CGUISprite>> m_Sprites;
 681
 682         // Styles
 683         std::map<CStr, const SGUIStyle> m_Styles;
 684
 685         // Scroll-bar styles
 686         std::map<CStr, const SGUIScrollBarStyle> m_ScrollBarStyles;
 687
 688         // Icons
 689         std::map<CStr, const SGUIIcon> m_Icons;
 690
 691 public:
 692         /**
 693          * Map from event names to object which listen to a given event.
 694          */
 695         std::unordered_map<CStr, std::vector<IGUIObject*>> m_EventObjects;
 696 };
 697
 698 #endif // INCLUDED_CGUI