Line data Source code
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 0 : const CVector2D& GetMousePos() const { return m_MousePos; }
186 :
187 : /**
188 : * Returns the currently pressed mouse buttons.
189 : */
190 0 : 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 96 : 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 0 : 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 0 : const SGUIIcon& GetIcon(const CStr& name) const { return m_Icons.at(name); }
236 :
237 : /**
238 : * Check if a style exists
239 : */
240 4 : 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 4 : 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 0 : 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 0 : const CGUIColor& GetPreDefinedColor(const CStr& name) const { return m_PreDefinedColors.at(name); }
256 :
257 4 : GUIProxyProps* GetProxyData(const js::BaseProxyHandler* ptr) { return m_ProxyData.at(ptr).get(); }
258 :
259 44 : 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 14 : 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
|
