Crazy Eddie's GUI System  0.8.7
Window.h
1 /***********************************************************************
2  created: 21/2/2004
3  author: Paul D Turner
4 
5  purpose: Defines abstract base class for Window objects
6 *************************************************************************/
7 /***************************************************************************
8  * Copyright (C) 2004 - 2012 Paul D Turner & The CEGUI Development Team
9  *
10  * Permission is hereby granted, free of charge, to any person obtaining
11  * a copy of this software and associated documentation files (the
12  * "Software"), to deal in the Software without restriction, including
13  * without limitation the rights to use, copy, modify, merge, publish,
14  * distribute, sublicense, and/or sell copies of the Software, and to
15  * permit persons to whom the Software is furnished to do so, subject to
16  * the following conditions:
17  *
18  * The above copyright notice and this permission notice shall be
19  * included in all copies or substantial portions of the Software.
20  *
21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
22  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
24  * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
25  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
26  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
27  * OTHER DEALINGS IN THE SOFTWARE.
28  ***************************************************************************/
29 
30 #ifndef _CEGUIWindow_h_
31 #define _CEGUIWindow_h_
32 
33 #include "CEGUI/Base.h"
34 #include "CEGUI/NamedElement.h"
35 #include "CEGUI/Vector.h"
36 #include "CEGUI/Quaternion.h"
37 #include "CEGUI/Rect.h"
38 #include "CEGUI/Size.h"
39 #include "CEGUI/EventSet.h"
40 #include "CEGUI/PropertySet.h"
41 #include "CEGUI/TplWindowProperty.h"
42 #include "CEGUI/System.h"
43 #include "CEGUI/GUIContext.h"
44 #include "CEGUI/InputEvent.h"
45 #include "CEGUI/UDim.h"
46 #include "CEGUI/WindowRenderer.h"
47 #include "CEGUI/TextUtils.h"
48 #include "CEGUI/BasicRenderedStringParser.h"
49 #include "CEGUI/DefaultRenderedStringParser.h"
50 #include <vector>
51 #include <set>
52 
53 #if defined(_MSC_VER)
54 # pragma warning(push)
55 # pragma warning(disable : 4251)
56 #endif
57 
58 
59 namespace CEGUI
60 {
61 
71 {
78 };
79 
80 template<>
82 {
83 public:
87  typedef String string_return_type;
88 
89  static const String& getDataTypeName()
90  {
91  static String type("WindowUpdateMode");
92 
93  return type;
94  }
95 
96  static return_type fromString(const String& str)
97  {
98 
99  if (str == "Always")
100  {
101  return WUM_ALWAYS;
102  }
103  else if (str == "Never")
104  {
105  return WUM_NEVER;
106  }
107  else
108  {
109  return WUM_VISIBLE;
110  }
111  }
112 
113  static string_return_type toString(pass_type val)
114  {
115  if (val == WUM_ALWAYS)
116  {
117  return "Always";
118  }
119  else if (val == WUM_NEVER)
120  {
121  return "Never";
122  }
123  else if (val == WUM_VISIBLE)
124  {
125  return "Visible";
126  }
127  else
128  {
129  assert(false && "Invalid Window Update Mode");
130  return "Always";
131  }
132  }
133 };
134 
135 
149 class CEGUIEXPORT Window :
150  public NamedElement
151 {
152 public:
153  /*************************************************************************
154  Property name constants
155  *************************************************************************/
157  static const String AlphaPropertyName;
167  static const String FontPropertyName;
169  static const String IDPropertyName;
179  static const String TextPropertyName;
216 
217  /*************************************************************************
218  Event name constants
219  *************************************************************************/
221  static const String EventNamespace;
222 
223  // generated internally by Window
227  static const String EventUpdated;
228 
233  static const String EventTextChanged;
238  static const String EventFontChanged;
243  static const String EventAlphaChanged;
248  static const String EventIDChanged;
255  static const String EventActivated;
262  static const String EventDeactivated;
267  static const String EventShown;
272  static const String EventHidden;
277  static const String EventEnabled;
283  static const String EventDisabled;
331  static const String EventInvalidated;
401 
402  // generated externally (inputs)
439  static const String EventMouseMove;
445  static const String EventMouseWheel;
462  static const String EventMouseClick;
483  static const String EventKeyDown;
492  static const String EventKeyUp;
500  static const String EventCharacterKey;
501 
502  /*************************************************************************
503  Child Widget name suffix constants
504  *************************************************************************/
506  static const String TooltipNameSuffix;
507 
508  // XML element and attribute names that relate to Window.
509  static const String WindowXMLElementName;
510  static const String AutoWindowXMLElementName;
511  static const String UserStringXMLElementName;
512  static const String WindowTypeXMLAttributeName;
513  static const String WindowNameXMLAttributeName;
514  static const String AutoWindowNamePathXMLAttributeName;
515  static const String UserStringNameXMLAttributeName;
516  static const String UserStringValueXMLAttributeName;
517 
528  Window(const String& type, const String& name);
529 
534  virtual ~Window(void);
535 
543  const String& getType(void) const;
544 
554  bool isDestroyedByParent(void) const {return d_destroyedByParent;}
555 
565  bool isAlwaysOnTop(void) const {return d_alwaysOnTop;}
566 
579  bool isDisabled() const;
580 
593  bool isEffectiveDisabled() const;
594 
611  bool isVisible() const;
612 
629  bool isEffectiveVisible() const;
630 
645  bool isActive(void) const;
646 
656  bool isClippedByParent(void) const {return d_clippedByParent;}
657 
665  uint getID(void) const {return d_ID;}
666 
667  using NamedElement::isChild;
684  bool isChild(uint ID) const;
685 
706  bool isChildRecursive(uint ID) const;
707 
708 
723  inline Window* getChildAtIdx(size_t idx) const
724  {
725  return static_cast<Window*>(getChildElementAtIdx(idx));
726  }
727 
751  inline Window* getChild(const String& name_path) const
752  {
753  return static_cast<Window*>(getChildElement(name_path));
754  }
755 
777  inline Window* getChildRecursive(const String& name) const
778  {
779  return static_cast<Window*>(getChildElementRecursive(name));
780  }
781 
803  Window* getChild(uint ID) const;
804 
826  Window* getChildRecursive(uint ID) const;
827 
841  const Window* getActiveChild(void) const;
842 
857  bool isAncestor(uint ID) const;
858 
878  const Font* getFont(bool useDefault = true) const;
879 
887  const String& getText(void) const {return d_textLogical;}
888 
890  const String& getTextVisual() const;
891 
900  bool inheritsAlpha(void) const {return d_inheritsAlpha;}
901 
919  float getAlpha(void) const {return d_alpha;}
920 
930  float getEffectiveAlpha(void) const;
931 
944  const Rectf& getOuterRectClipper() const;
945 
958  const Rectf& getInnerRectClipper() const;
959 
978  const Rectf& getClipRect(const bool non_client = false) const;
979 
990  const Rectf& getHitTestRect() const;
991 
1001  {return getGUIContext().getInputCaptureWindow();}
1002 
1011  bool isCapturedByThis(void) const {return getCaptureWindow() == this;}
1012 
1022  bool isCapturedByAncestor(void) const
1023  {return isAncestor(getCaptureWindow());}
1024 
1033  bool isCapturedByChild(void) const {return isChild(getCaptureWindow());}
1034 
1051  virtual bool isHit(const Vector2f& position,
1052  const bool allow_disabled = false) const;
1053 
1066  Window* getChildAtPosition(const Vector2f& position) const;
1067 
1086  const bool allow_disabled = false) const;
1087 
1096  inline Window* getParent() const
1097  {
1098  return static_cast<Window*>(getParentElement());
1099  }
1100 
1115  const Image* getMouseCursor(bool useDefault = true) const;
1116 
1128  void* getUserData(void) const {return d_userData;}
1129 
1144  bool restoresOldCapture(void) const {return d_restoreOldCapture;}
1145 
1165  bool isZOrderingEnabled(void) const;
1166 
1177  bool wantsMultiClickEvents(void) const;
1178 
1190  bool isMouseAutoRepeatEnabled(void) const;
1191 
1200  float getAutoRepeatDelay(void) const;
1201 
1211  float getAutoRepeatRate(void) const;
1212 
1222  bool distributesCapturedInputs(void) const;
1223 
1233  bool isUsingDefaultTooltip(void) const;
1234 
1244  Tooltip* getTooltip(void) const;
1245 
1254  String getTooltipType(void) const;
1255 
1263  const String& getTooltipText(void) const;
1264 
1276 
1288  bool inheritsTooltipText(void) const;
1289 
1310  bool isRiseOnClickEnabled(void) const { return d_riseOnClick; }
1311 
1320 
1329  const String& getLookNFeel() const;
1330 
1338  bool getModalState(void) const
1339  {return(getGUIContext().getModalWindow() == this);}
1340 
1354  const String& getUserString(const String& name) const;
1355 
1367  bool isUserStringDefined(const String& name) const;
1368 
1385 
1396  bool isMousePassThroughEnabled(void) const {return d_mousePassThroughEnabled;}
1397 
1405  bool isAutoWindow(void) const {return d_autoWindow;}
1406 
1411  bool isWritingXMLAllowed(void) const {return d_allowWriteXML;}
1412 
1422  bool isDragDropTarget() const;
1423 
1430 
1432  virtual void getRenderingContext_impl(RenderingContext& ctx) const;
1433 
1440 
1447 
1460 
1471  const Window* getRootWindow() const;
1472  Window* getRootWindow();
1473 
1485  virtual void initialiseComponents(void) {}
1486 
1500  void setDestroyedByParent(bool setting);
1501 
1514  void setAlwaysOnTop(bool setting);
1515 
1528  void setEnabled(bool setting);
1529 
1542  void setDisabled(bool setting);
1543 
1551  void enable(void) {setEnabled(true);}
1552 
1560  void disable(void) {setEnabled(false);}
1561 
1579  void setVisible(bool setting);
1580 
1593  void show(void) {setVisible(true);}
1594 
1605  void hide(void) {setVisible(false);}
1606 
1615  void activate(void);
1616 
1626  void deactivate(void);
1627 
1640  void setClippedByParent(bool setting);
1641 
1653  void setID(uint ID);
1654 
1665  void setText(const String& text);
1666 
1680  void insertText(const String& text, const String::size_type position);
1681 
1691  void appendText(const String& text);
1692 
1704  void setFont(const Font* font);
1705 
1720  void setFont(const String& name);
1721 
1736  void removeChild(uint ID);
1737 
1753  Window* createChild(const String& type, const String& name = "");
1754 
1762  void destroyChild(Window* wnd);
1763 
1771  void destroyChild(const String& name_path);
1772 
1786  void moveToFront();
1787 
1802  void moveToBack();
1803 
1817  void moveInFront(const Window* const window);
1818 
1833  void moveBehind(const Window* const window);
1834 
1847  size_t getZIndex() const;
1848 
1858  bool isInFront(const Window& wnd) const;
1859 
1869  bool isBehind(const Window& wnd) const;
1870 
1880  bool captureInput(void);
1881 
1890  void releaseInput(void);
1891 
1910  void setRestoreOldCapture(bool setting);
1911 
1932  void setAlpha(const float alpha);
1933 
1945  void setInheritsAlpha(bool setting);
1946 
1958  void invalidate(void);
1959 
1975  void invalidate(const bool recursive);
1976 
1988  void setMouseCursor(const Image* image);
1989 
2007  void setMouseCursor(const String& name);
2008 
2023  void setUserData(void* user_data) {d_userData = user_data;}
2024 
2047  void setZOrderingEnabled(bool setting);
2048 
2062  void setWantsMultiClickEvents(bool setting);
2063 
2076  void setMouseAutoRepeatEnabled(bool setting);
2077 
2089  void setAutoRepeatDelay(float delay);
2090 
2103  void setAutoRepeatRate(float rate);
2104 
2114  void setDistributesCapturedInputs(bool setting);
2115 
2122 
2129 
2136 
2150  virtual void destroy(void);
2151 
2167  void setTooltip(Tooltip* tooltip);
2168 
2187  void setTooltipType(const String& tooltipType);
2188 
2200  void setTooltipText(const String& tip);
2201 
2216  void setInheritsTooltipText(bool setting);
2217 
2241  void setRiseOnClickEnabled(bool setting) { d_riseOnClick = setting; }
2242 
2274  virtual void setLookNFeel(const String& look);
2275 
2289  void setModalState(bool state);
2290 
2320  virtual void performChildWindowLayout(bool nonclient_sized_hint = false,
2321  bool client_sized_hint = false);
2322 
2336  void setUserString(const String& name, const String& value);
2337 
2346  void render();
2347 
2366  virtual void update(float elapsed);
2367 
2378  virtual bool performCopy(Clipboard& clipboard);
2379 
2390  virtual bool performCut(Clipboard& clipboard);
2391 
2402  virtual bool performPaste(Clipboard& clipboard);
2403 
2414  virtual void writeXMLToStream(XMLSerializer& xml_stream) const;
2415 
2424  virtual void beginInitialisation(void) {d_initialising = true;}
2425 
2433  virtual void endInitialisation(void) {d_initialising = false;}
2434 
2445  void setMousePassThroughEnabled(bool setting) {d_mousePassThroughEnabled = setting;}
2446 
2461  void setWindowRenderer(const String& name);
2462 
2472 
2483 
2488  void setWritingXMLAllowed(bool allow) {d_allowWriteXML = allow;}
2489 
2500  virtual void notifyScreenAreaChanged(bool recursive = true);
2501 
2513  void setFalagardType(const String& type, const String& rendererType = "");
2514 
2524  void setDragDropTarget(bool setting);
2525 
2547 
2555 
2597  void setUsingAutoRenderingSurface(bool setting);
2598 
2608  bool isTextParsingEnabled() const;
2610  void setTextParsingEnabled(const bool setting);
2611 
2613  virtual void setMargin(const UBox& margin);
2615  const UBox& getMargin() const;
2616 
2619 
2622  {return d_bidiVisualMapping;}
2623 
2636  void banPropertyFromXML(const String& property_name);
2637 
2650  void banPropertyFromXMLRecursive(const String& property_name);
2651 
2663  void unbanPropertyFromXML(const String& property_name);
2664 
2676  void unbanPropertyFromXMLRecursive(const String& property_name);
2677 
2678 
2687  bool isPropertyBannedFromXML(const String& property_name) const;
2688 
2690  void banPropertyFromXML(const Property* property);
2691 
2693  void unbanPropertyFromXML(const Property* property);
2694 
2703  bool isPropertyBannedFromXML(const Property* property) const;
2704 
2723 
2742 
2753  void setMouseInputPropagationEnabled(const bool enabled);
2754 
2766 
2777  Window* clone(const bool deepCopy = true) const;
2778 
2780  virtual void clonePropertiesTo(Window& target) const;
2782  virtual void cloneChildWidgetsTo(Window& target) const;
2783 
2787  void setGUIContext(GUIContext* context);
2788 
2791 
2799  void setAutoWindow(bool is_auto);
2800 
2812 
2813  // overridden from Element
2814  const Sizef& getRootContainerSize() const;
2815 
2816 protected:
2817  // friend classes for construction / initialisation purposes (for now)
2818  friend class System;
2819  friend class WindowManager;
2820  friend class GUIContext;
2821 
2822  /*************************************************************************
2823  Event trigger methods
2824  *************************************************************************/
2834  virtual void onSized(ElementEventArgs& e);
2835 
2845  virtual void onMoved(ElementEventArgs& e);
2846 
2847  virtual void onRotated(ElementEventArgs& e);
2848 
2858  virtual void onTextChanged(WindowEventArgs& e);
2859 
2869  virtual void onFontChanged(WindowEventArgs& e);
2870 
2881 
2891  virtual void onIDChanged(WindowEventArgs& e);
2892 
2902  virtual void onShown(WindowEventArgs& e);
2903 
2913  virtual void onHidden(WindowEventArgs& e);
2914 
2924  virtual void onEnabled(WindowEventArgs& e);
2925 
2935  virtual void onDisabled(WindowEventArgs& e);
2936 
2948 
2960 
2972 
2983 
2994 
3004  virtual void onCaptureLost(WindowEventArgs& e);
3005 
3015  virtual void onInvalidated(WindowEventArgs& e);
3016 
3027 
3038 
3048  virtual void onZChanged(WindowEventArgs& e);
3049 
3060 
3070 
3081 
3094 
3103  virtual void onChildAdded(ElementEventArgs& e);
3104 
3114 
3123 
3132 
3147  virtual void onMouseEnters(MouseEventArgs& e);
3148 
3163  virtual void onMouseLeaves(MouseEventArgs& e);
3164 
3173  virtual void onMouseMove(MouseEventArgs& e);
3174 
3183  virtual void onMouseWheel(MouseEventArgs& e);
3184 
3194 
3204 
3213  virtual void onMouseClicked(MouseEventArgs& e);
3214 
3224 
3234 
3246  virtual void onKeyDown(KeyEventArgs& e);
3247 
3259  virtual void onKeyUp(KeyEventArgs& e);
3260 
3272  virtual void onCharacter(KeyEventArgs& e);
3273 
3285 
3297 
3309 
3320 
3331 
3343 
3344  virtual void onMarginChanged(WindowEventArgs& e);
3345 
3346  /*************************************************************************
3347  Implementation Functions
3348  *************************************************************************/
3360  virtual void updateSelf(float elapsed);
3361 
3373  virtual void drawSelf(const RenderingContext& ctx);
3374 
3386 
3398 
3405  virtual void populateGeometryBuffer() {}
3406 
3418  virtual void setParent(Element* parent);
3419 
3425 
3437  virtual bool validateWindowRenderer(const WindowRenderer* renderer) const;
3438 
3445  bool isPropertyAtDefault(const Property* property) const;
3446 
3453 
3456 
3459 
3462 
3464  virtual void setArea_impl(const UVector2& pos, const USize& size, bool topLeftSizing = false, bool fireEvents = true);
3465 
3470  virtual void cleanupChildren(void);
3471 
3475  virtual void addChild_impl(Element* element);
3476 
3480  virtual void removeChild_impl(Element* element);
3481 
3486  virtual void onZChange_impl(void);
3487 
3493 
3502  virtual bool moveToFront_impl(bool wasClicked);
3503 
3523  void addWindowToDrawList(Window& wnd, bool at_back = false);
3524 
3537 
3549  bool isTopOfZOrder() const;
3550 
3557 
3560 
3562  Rectf getParentElementClipIntersection(const Rectf& unclipped_area) const;
3563 
3565  void invalidate_impl(const bool recursive);
3566 
3574 
3575  virtual Rectf getUnclippedInnerRect_impl(bool skipAllPixelAlignment) const;
3581  virtual Rectf getHitTestRect_impl() const;
3582 
3583  virtual int writePropertiesXML(XMLSerializer& xml_stream) const;
3584  virtual int writeChildWindowsXML(XMLSerializer& xml_stream) const;
3585  virtual bool writeAutoChildWindowXML(XMLSerializer& xml_stream) const;
3586 
3587  virtual void banPropertiesForAutoWindow();
3588 
3590  virtual bool handleFontRenderSizeChange(const EventArgs& args);
3591 
3592  // mark the rect caches defined on Window invalid (does not affect Element)
3593  void markCachedWindowRectsInvalid();
3594  void layoutLookNFeelChildWidgets();
3595 
3596  Window* getChildAtPosition(const Vector2f& position,
3597  bool (Window::*hittestfunc)(const Vector2f&, bool) const,
3598  bool allow_disabled = false) const;
3599 
3600  bool isHitTargetWindow(const Vector2f& position, bool allow_disabled) const;
3601 
3602  /*************************************************************************
3603  Properties for Window base class
3604  *************************************************************************/
3605 
3617  static
3618  class WindowRendererProperty : public TplWindowProperty<Window, String>
3619  {
3620  public:
3622  void writeXMLToStream(const PropertyReceiver* receiver,
3623  XMLSerializer& xml_stream) const;
3624  } d_windowRendererProperty;
3625 
3637  static
3638  class LookNFeelProperty : public TplWindowProperty<Window, String>
3639  {
3640  public:
3642  void writeXMLToStream(const PropertyReceiver* receiver,
3643  XMLSerializer& xml_stream) const;
3644  } d_lookNFeelProperty;
3645 
3646  /*************************************************************************
3647  Implementation Data
3648  *************************************************************************/
3650  typedef std::vector<Window*
3651  CEGUI_VECTOR_ALLOC(Window*)> ChildDrawList;
3653  typedef std::map<String, String, StringFastLessCompare
3654  CEGUI_MAP_ALLOC(String, String)> UserStringMap;
3656  typedef std::set<String, StringFastLessCompare
3657  CEGUI_SET_ALLOC(String)> BannedXMLPropertySet;
3658 
3665 
3675  bool d_active;
3676 
3681 
3684 
3694  mutable bool d_needsRedraw;
3697 
3700 
3702  float d_alpha;
3705 
3712 
3714  const Font* d_font;
3720  mutable bool d_bidiDataValid;
3733 
3736 
3738  uint d_ID;
3740  void* d_userData;
3743 
3750 
3767 
3770 
3779 
3784 
3791 
3792  mutable bool d_outerRectClipperValid;
3793  mutable bool d_innerRectClipperValid;
3794  mutable bool d_hitTestRectValid;
3795 
3798 
3801 
3804 
3807 
3808 private:
3809  /*************************************************************************
3810  May not copy or assign Window objects
3811  *************************************************************************/
3812  Window(const Window&): NamedElement() {}
3813  Window& operator=(const Window&) {return *this;}
3814 
3816  const Font* property_getFont() const;
3818  const Image* property_getMouseCursor() const;
3819 
3821  Event::ScopedConnection d_fontRenderSizeChangeConnection;
3822 };
3823 
3824 } // End of CEGUI namespace section
3825 
3826 
3827 #if defined(_MSC_VER)
3828 # pragma warning(pop)
3829 #endif
3830 
3831 #endif // end of guard _CEGUIWindow_h_
3832 
CEGUI::Window::invalidate
void invalidate(void)
Invalidate this window causing at least this window to be redrawn during the next rendering pass.
CEGUI::Clipboard
Defines a clipboard handling class.
Definition: Clipboard.h:84
CEGUI::Window::setZOrderingEnabled
void setZOrderingEnabled(bool setting)
Set whether z-order changes are enabled or disabled for this Window.
CEGUI::Window::EventDeactivated
static const String EventDeactivated
Definition: Window.h:262
CEGUI::Window::onClippingChanged
virtual void onClippingChanged(WindowEventArgs &e)
Handler called when the window's setting for being clipped by it's parent is changed.
CEGUI::Window::unbanPropertyFromXML
void unbanPropertyFromXML(const Property *property)
Remove the given property from the XML ban list for this window.
CEGUI::Window::MouseInputPropagationEnabledPropertyName
static const String MouseInputPropagationEnabledPropertyName
Name of property to access whether unhandled mouse inputs should be propagated back to the Window's p...
Definition: Window.h:213
CEGUI::GeometryBuffer
Abstract class defining the interface for objects that buffer geometry for later rendering.
Definition: GeometryBuffer.h:44
CEGUI::Window::onDisabled
virtual void onDisabled(WindowEventArgs &e)
Handler called when the window is disabled.
CEGUI::Window::EventMouseEntersArea
static const String EventMouseEntersArea
Definition: Window.h:407
CEGUI::Window::performCut
virtual bool performCut(Clipboard &clipboard)
Asks the widget to perform a clipboard cut to the provided clipboard.
CEGUI::Window::getTooltip
Tooltip * getTooltip(void) const
Return a pointer to the Tooltip object used by this Window. The value returned may point to the syste...
CEGUI::Window::EventMouseLeavesSurface
static const String EventMouseLeavesSurface
Definition: Window.h:434
CEGUI::Window::isTextParsingEnabled
bool isTextParsingEnabled() const
return whether text parsing is enabled for this window.
CEGUI::Window::d_repeatDelay
float d_repeatDelay
seconds before first repeat event is fired
Definition: Window.h:3758
CEGUI::Font
Class that encapsulates a typeface.
Definition: Font.h:62
CEGUI::Window::appendText
void appendText(const String &text)
Append the string text to the currect text string for the Window object.
CEGUI::Window::BannedXMLPropertySet
std::set< String, StringFastLessCompare CEGUI_SET_ALLOC(String)> BannedXMLPropertySet
definition of type used to track properties banned from writing XML.
Definition: Window.h:3657
CEGUI::Window::validateWindowRenderer
virtual bool validateWindowRenderer(const WindowRenderer *renderer) const
Function used in checking if a WindowRenderer is valid for this window.
CEGUI::Window::isChild
bool isChild(uint ID) const
returns whether at least one window with the given ID code is attached to this Window as a child.
CEGUI::Window::d_distCapturedInputs
bool d_distCapturedInputs
Whether to distribute captured inputs to child windows.
Definition: Window.h:3711
CEGUI::Window::isZOrderingEnabled
bool isZOrderingEnabled(void) const
Return whether z-order changes are enabled or disabled for this Window.
CEGUI::Window::d_repeating
bool d_repeating
implements repeating - is true after delay has elapsed,
Definition: Window.h:3764
CEGUI::Window::getGUIContext
GUIContext & getGUIContext() const
return the GUIContext this window is associated with.
CEGUI::Window::moveToBack
void moveToBack()
Move the Window to the bottom of the Z order.
CEGUI::Window::isWritingXMLAllowed
bool isWritingXMLAllowed(void) const
Returns whether this window is allowed to write XML.
Definition: Window.h:1411
CEGUI::Window::setMousePassThroughEnabled
void setMousePassThroughEnabled(bool setting)
Sets whether this window should ignore mouse events and pass them through to any windows behind it....
Definition: Window.h:2445
CEGUI::Window::getTooltipTextIncludingInheritance
const String & getTooltipTextIncludingInheritance(void) const
Return the current tooltip text set for this Window or the inherited one. If the tooltip text of this...
CEGUI::Window::setDistributesCapturedInputs
void setDistributesCapturedInputs(bool setting)
Set whether the window wants inputs passed to its attached child windows when the window has inputs c...
CEGUI::Window::setParent
virtual void setParent(Element *parent)
Set the parent window for this window object.
CEGUI::Window::setTooltip
void setTooltip(Tooltip *tooltip)
Set the custom Tooltip object for this Window. This value may be 0 to indicate that the Window should...
CEGUI::Window::EventHidden
static const String EventHidden
Definition: Window.h:272
CEGUI::Window::restoresOldCapture
bool restoresOldCapture(void) const
Return whether this window is set to restore old input capture when it loses input capture.
Definition: Window.h:1144
CEGUI::Window::onDragDropItemDropped
virtual void onDragDropItemDropped(DragDropEventArgs &e)
Handler called when a DragContainer is dragged over this window.
CEGUI::Window::MousePassThroughEnabledPropertyName
static const String MousePassThroughEnabledPropertyName
Name of property to access for the window ignores mouse events and pass them through to any windows b...
Definition: Window.h:201
CEGUI::Window::cleanupChildren
virtual void cleanupChildren(void)
Cleanup child windows.
CEGUI::Window::deactivate
void deactivate(void)
Deactivate the window. No further inputs will be received by the window until it is re-activated eith...
CEGUI::Window::onAlphaChanged
virtual void onAlphaChanged(WindowEventArgs &e)
Handler called when the window's alpha blend value is changed.
CEGUI::Window::setMouseInputPropagationEnabled
void setMouseInputPropagationEnabled(const bool enabled)
Set whether mouse input that is not directly handled by this Window (including it's event subscribers...
CEGUI::Window::d_autoRenderingWindow
bool d_autoRenderingWindow
holds setting for automatic creation of of surface (RenderingWindow)
Definition: Window.h:3696
CEGUI::Window::onMouseLeavesArea
virtual void onMouseLeavesArea(MouseEventArgs &e)
Handler called when the mouse cursor has left this window's area.
CEGUI::Window::invalidateRenderingSurface
void invalidateRenderingSurface()
Invalidate the chain of rendering surfaces from this window backwards to ensure they get properly red...
CEGUI::Window::setRenderingSurface
void setRenderingSurface(RenderingSurface *surface)
Set the RenderingSurface to be associated with this Window, or 0 if none is required.
CEGUI::Window::removeChild_impl
virtual void removeChild_impl(Element *element)
Remove given element from child list.
CEGUI::Window::d_weOwnTip
bool d_weOwnTip
true if this Window created the custom Tooltip.
Definition: Window.h:3776
CEGUI::Window::setUsingAutoRenderingSurface
void setUsingAutoRenderingSurface(bool setting)
Sets whether automatic use of an imagery caching RenderingSurface (i.e. a RenderingWindow) is enabled...
CEGUI::Window::setGUIContext
void setGUIContext(GUIContext *context)
function used internally. Do not call this from client code.
CEGUI::Window::banPropertyFromXML
void banPropertyFromXML(const String &property_name)
Adds the named property to the XML ban list for this window Essentially a property that is banned fro...
CEGUI::Window::d_visible
bool d_visible
is window visible (i.e. it will be rendered, but may still be obscured)
Definition: Window.h:3673
CEGUI::Window::setUpdateMode
void setUpdateMode(const WindowUpdateMode mode)
Set the window update mode. This mode controls the behaviour of the Window::update member function su...
CEGUI::Window::d_outerRectClipper
Rectf d_outerRectClipper
outer area clipping rect in screen pixels
Definition: Window.h:3786
CEGUI::Window::onMouseButtonDown
virtual void onMouseButtonDown(MouseEventArgs &e)
Handler called when a mouse button has been depressed within this window's area.
CEGUI::Window::onHidden
virtual void onHidden(WindowEventArgs &e)
Handler called when the window is hidden.
CEGUI::Window::initialiseClippers
void initialiseClippers(const RenderingContext &ctx)
Helper to intialise the needed clipping for geometry and render surface.
CEGUI::Window::getUserString
const String & getUserString(const String &name) const
Returns a named user string.
CEGUI::Window::d_mouseCursor
const Image * d_mouseCursor
Holds pointer to the Window objects current mouse cursor image.
Definition: Window.h:3699
CEGUI::Window::d_lookName
String d_lookName
Name of the Look assigned to this window (if any).
Definition: Window.h:3686
CEGUI::NamedElement::isAncestor
bool isAncestor(const Element *element) const
Checks whether the specified Element is an ancestor of this Element.
CEGUI::Window::setEnabled
void setEnabled(bool setting)
Set whether this window is enabled or disabled. A disabled window normally can not be interacted with...
CEGUI::Window::d_bannedXMLProperties
BannedXMLPropertySet d_bannedXMLProperties
collection of properties not to be written to XML for this window.
Definition: Window.h:3783
CEGUI::Window::releaseInput
void releaseInput(void)
Releases input capture from this Window. If this Window does not have inputs captured,...
CEGUI::Tooltip
Base class for Tooltip widgets.
Definition: widgets/Tooltip.h:80
CEGUI::Window::WindowRendererProperty::writeXMLToStream
void writeXMLToStream(const PropertyReceiver *receiver, XMLSerializer &xml_stream) const
Writes out an XML representation of this class to the given stream.
CEGUI::Window::performPaste
virtual bool performPaste(Clipboard &clipboard)
Asks the widget to perform a clipboard paste from the provided clipboard.
CEGUI::DragContainer
Generic drag & drop enabled window class.
Definition: DragContainer.h:46
CEGUI::Window::d_autoWindow
bool d_autoWindow
true when this window is an auto-window
Definition: Window.h:3664
CEGUI::Window::setFalagardType
void setFalagardType(const String &type, const String &rendererType="")
Changes the widget's falagard type, thus changing its look'n'feel and optionally its renderer in the ...
CEGUI::Window::EventFontChanged
static const String EventFontChanged
Definition: Window.h:238
CEGUI::Window::activate
void activate(void)
Activate the Window giving it input focus and bringing it to the top of all windows with the same alw...
CEGUI::Window::invalidate_impl
void invalidate_impl(const bool recursive)
helper function to invalidate window and optionally child windows.
CEGUI::Window::onFontChanged
virtual void onFontChanged(WindowEventArgs &e)
Handler called when the window's font is changed.
CEGUI::Window::cloneChildWidgetsTo
virtual void cloneChildWidgetsTo(Window &target) const
copies this widget's child widgets to given target widget
CEGUI::Window::getType
const String & getType(void) const
return a String object holding the type name for this Window.
CEGUI::Window::wantsMultiClickEvents
bool wantsMultiClickEvents(void) const
Return whether this window will receive multi-click events or multiple 'down' events instead.
CEGUI::Window::d_bidiDataValid
bool d_bidiDataValid
whether bidi visual mapping has been updated since last text change.
Definition: Window.h:3720
CEGUI::Window::d_customStringParser
RenderedStringParser * d_customStringParser
Pointer to a custom (user assigned) RenderedStringParser object.
Definition: Window.h:3730
CEGUI::Window::d_propagateMouseInputs
bool d_propagateMouseInputs
specifies whether mouse inputs should be propagated to parent(s)
Definition: Window.h:3800
CEGUI::Window::getHitTestRect_impl
virtual Rectf getHitTestRect_impl() const
Default implementation of function to return Window hit-test area.
CEGUI::Window::onMouseEntersArea
virtual void onMouseEntersArea(MouseEventArgs &e)
Handler called when the mouse cursor has entered this window's area.
CEGUI::StringFastLessCompare
Functor that can be used as comparator in a std::map with String keys. It's faster than using the def...
Definition: String.h:5580
CEGUI::Window::getRootWindow
const Window * getRootWindow() const
Returns the window at the root of the hierarchy starting at this Window. The root window is defined a...
CEGUI::Window::queueGeometry
void queueGeometry(const RenderingContext &ctx)
Perform drawing operations concerned with positioning, clipping and queueing of window geometry to Re...
CEGUI::Window::onCharacter
virtual void onCharacter(KeyEventArgs &e)
Handler called when a character-key has been pressed while this window has input focus.
CEGUI::Window::enable
void enable(void)
enable the Window to allow interaction.
Definition: Window.h:1551
CEGUI::Window::destroy
virtual void destroy(void)
Internal destroy method which actually just adds the window and any parent destructed child windows t...
CEGUI::Window::drawSelf
virtual void drawSelf(const RenderingContext &ctx)
Perform the actual rendering for this Window.
CEGUI::WindowUpdateMode
WindowUpdateMode
Enumerated type used for specifying Window::update mode to be used. Note that the setting specified w...
Definition: Window.h:71
CEGUI::Window::d_initialising
bool d_initialising
true when this window is currently being initialised (creating children etc)
Definition: Window.h:3667
CEGUI::Window::onIDChanged
virtual void onIDChanged(WindowEventArgs &e)
Handler called when the window's client assigned ID is changed.
CEGUI::Window::d_falagardType
String d_falagardType
Type name of the window as defined in a Falagard mapping.
Definition: Window.h:3662
CEGUI::Window::d_repeatRate
float d_repeatRate
seconds between further repeats after delay has expired.
Definition: Window.h:3760
CEGUI::Window::EventMouseDoubleClick
static const String EventMouseDoubleClick
Definition: Window.h:468
CEGUI::Window::onMouseWheel
virtual void onMouseWheel(MouseEventArgs &e)
Handler called when the mouse wheel (z-axis) position changes within this window's area.
CEGUI::Window::EventUpdated
static const String EventUpdated
Definition: Window.h:227
CEGUI::Window::getWindowRendererName
const String & getWindowRendererName() const
Get the factory name of the currently assigned WindowRenderer. (Look'N'Feel specification).
CEGUI::Window::clone
Window * clone(const bool deepCopy=true) const
Clones this Window and returns the result.
CEGUI::Window::handleFontRenderSizeChange
virtual bool handleFontRenderSizeChange(const EventArgs &args)
handler function for when font render size changes.
CEGUI::Window::onChildRemoved
virtual void onChildRemoved(ElementEventArgs &e)
Handler called when a child window is removed from this window.
CEGUI::Window::MarginPropertyName
static const String MarginPropertyName
Name of property to access for the margin for the Window.
Definition: Window.h:209
CEGUI::Window::EventCharacterKey
static const String EventCharacterKey
Definition: Window.h:500
CEGUI::Window::d_bidiVisualMapping
BidiVisualMapping * d_bidiVisualMapping
pointer to bidirection support object
Definition: Window.h:3718
CEGUI::Window::addChild_impl
virtual void addChild_impl(Element *element)
Add given element to child list at an appropriate position.
CEGUI::Window::InheritsTooltipTextPropertyName
static const String InheritsTooltipTextPropertyName
Name of property to access for the window inherits its parents tooltip text when it has none of its o...
Definition: Window.h:197
CEGUI::WUM_NEVER
@ WUM_NEVER
Never call the Window::update function for this window.
Definition: Window.h:75
CEGUI::Window::d_inheritsAlpha
bool d_inheritsAlpha
true if the Window inherits alpha from the parent Window
Definition: Window.h:3704
CEGUI::Window::EventAlphaChanged
static const String EventAlphaChanged
Definition: Window.h:243
CEGUI::Window::UpdateModePropertyName
static const String UpdateModePropertyName
Name of property to access for the window update mode setting.
Definition: Window.h:211
CEGUI::Window::updateGeometryRenderSettings
void updateGeometryRenderSettings()
Update position and clip region on this Windows geometry / rendering surface.
CEGUI::RenderingSurface
Class that represents a surface that can have geometry based imagery drawn to it.
Definition: RenderingSurface.h:111
CEGUI::Window::EventDestructionStarted
static const String EventDestructionStarted
Definition: Window.h:352
CEGUI::Window::notifyDragDropItemLeaves
void notifyDragDropItemLeaves(DragContainer *item)
Internal support method for drag & drop. You do not normally call this directly from client code....
CEGUI::Window::EventDragDropItemLeaves
static const String EventDragDropItemLeaves
Definition: Window.h:368
CEGUI::ElementEventArgs
EventArgs based class that is used for objects passed to handlers triggered for events concerning som...
Definition: Element.h:211
CEGUI::RenderingContext
struct that holds some context relating to a RenderingSurface object.
Definition: RenderingContext.h:41
CEGUI::Window::EventMouseClick
static const String EventMouseClick
Definition: Window.h:462
CEGUI::Window::onAlwaysOnTopChanged
virtual void onAlwaysOnTopChanged(WindowEventArgs &e)
Handler called when the window's always-on-top setting is changed.
CEGUI::Window::isHit
virtual bool isHit(const Vector2f &position, const bool allow_disabled=false) const
check if the given pixel position would hit this window.
CEGUI::Window::onDragDropItemEnters
virtual void onDragDropItemEnters(DragDropEventArgs &e)
Handler called when a DragContainer is dragged over this window.
CEGUI::Window::getRenderedStringParser
virtual RenderedStringParser & getRenderedStringParser() const
return the active RenderedStringParser to be used
CEGUI::Window::FontPropertyName
static const String FontPropertyName
Name of property to access for the font for the Window.
Definition: Window.h:167
CEGUI::Window::DistributeCapturedInputsPropertyName
static const String DistributeCapturedInputsPropertyName
Name of property to access for the whether captured inputs are passed to child windows.
Definition: Window.h:191
CEGUI::Window::onDestructionStarted
virtual void onDestructionStarted(WindowEventArgs &e)
Handler called when this window's destruction sequence has begun.
CEGUI::Window::setTooltipType
void setTooltipType(const String &tooltipType)
Set the custom Tooltip to be used by this Window by specifying a Window type.
CEGUI::Window::d_innerRectClipper
Rectf d_innerRectClipper
inner area clipping rect in screen pixels
Definition: Window.h:3788
CEGUI::Window::d_inheritsTipText
bool d_inheritsTipText
whether tooltip text may be inherited from parent.
Definition: Window.h:3778
CEGUI::Window::getInnerRectClipper
const Rectf & getInnerRectClipper() const
Return a Rect that describes the rendering clipping rect based upon the inner rect area of the window...
CEGUI::Window::setTooltipText
void setTooltipText(const String &tip)
Set the tooltip text for this window.
CEGUI::Window::setMargin
virtual void setMargin(const UBox &margin)
set margin
CEGUI::Window::performCopy
virtual bool performCopy(Clipboard &clipboard)
Asks the widget to perform a clipboard copy to the provided clipboard.
CEGUI::Window::bufferGeometry
void bufferGeometry(const RenderingContext &ctx)
Perform drawing operations concerned with generating and buffering window geometry.
CEGUI::Window::EventMouseEntersSurface
static const String EventMouseEntersSurface
Definition: Window.h:423
CEGUI::XMLSerializer
Class used to create XML Document.
Definition: XMLSerializer.h:87
CEGUI::Window::update
virtual void update(float elapsed)
Cause window to update itself and any attached children. Client code does not need to call this metho...
CEGUI::Window::getBidiVisualMapping
const BidiVisualMapping * getBidiVisualMapping() const
return the pointer to the BidiVisualMapping for this window, if any.
Definition: Window.h:2621
CEGUI::Window::getLookNFeel
const String & getLookNFeel() const
Get the name of the LookNFeel assigned to this window.
CEGUI::Window::setID
void setID(uint ID)
Set the current ID for the Window.
CEGUI::Window::getInnerRectClipper_impl
virtual Rectf getInnerRectClipper_impl() const
Default implementation of function to return Window inner clipper area.
CEGUI::Window::EventInputCaptureGained
static const String EventInputCaptureGained
Definition: Window.h:312
CEGUI::Window::isAutoWindow
bool isAutoWindow(void) const
Returns whether this window is an auto window.
Definition: Window.h:1405
CEGUI::Window::isPropertyBannedFromXML
bool isPropertyBannedFromXML(const String &property_name) const
Return whether the named property is banned from XML.
CEGUI::Window::setUserString
void setUserString(const String &name, const String &value)
Sets the value a named user string, creating it as required.
CEGUI::Window::setRestoreOldCapture
void setRestoreOldCapture(bool setting)
Set whether this window will remember and restore the previous window that had inputs captured.
CEGUI::Window::d_destroyedByParent
bool d_destroyedByParent
true when Window will be auto-destroyed by parent.
Definition: Window.h:3680
CEGUI::Window::onWindowRendererDetached
virtual void onWindowRendererDetached(WindowEventArgs &e)
Handler called when the currently attached window renderer object is detached.
CEGUI::Window::setMouseAutoRepeatEnabled
void setMouseAutoRepeatEnabled(bool setting)
Set whether mouse button down event autorepeat is enabled for this window.
CEGUI::Window::isDragDropTarget
bool isDragDropTarget() const
Returns whether this Window object will receive events generated by the drag and drop support in the ...
CEGUI::Window::destroyChild
void destroyChild(const String &name_path)
Destroys a child window of this window.
CEGUI::Window::EventRenderingEnded
static const String EventRenderingEnded
Definition: Window.h:347
CEGUI::DragDropEventArgs
EventArgs based class used for certain drag/drop notifications.
Definition: InputEvent.h:342
CEGUI::Window::AutoRepeatDelayPropertyName
static const String AutoRepeatDelayPropertyName
Name of property to access for the autorepeat delay.
Definition: Window.h:187
CEGUI::Window::addWindowToDrawList
void addWindowToDrawList(Window &wnd, bool at_back=false)
Add the given window to the drawing list at an appropriate position for it's settings and the require...
CEGUI::Window::moveToFront_impl
virtual bool moveToFront_impl(bool wasClicked)
Implements move to front behavior.
CEGUI
Main namespace for Crazy Eddie's GUI Library.
Definition: arch_overview.dox:1
CEGUI::Window::onChildAdded
virtual void onChildAdded(ElementEventArgs &e)
Handler called when a child window is added to this window.
CEGUI::Window::EventInvalidated
static const String EventInvalidated
Definition: Window.h:331
CEGUI::Window::d_windowRenderer
WindowRenderer * d_windowRenderer
The WindowRenderer module that implements the Look'N'Feel specification.
Definition: Window.h:3688
CEGUI::Window::EventMouseLeavesArea
static const String EventMouseLeavesArea
Definition: Window.h:412
CEGUI::Window::getMouseCursor
const Image * getMouseCursor(bool useDefault=true) const
Return a pointer to the mouse cursor image to use when the mouse cursor is within this window's area.
CEGUI::Window::distributesCapturedInputs
bool distributesCapturedInputs(void) const
Return whether the window wants inputs passed to its attached child windows when the window has input...
CEGUI::Window::addWindowProperties
void addWindowProperties(void)
Add standard CEGUI::Window properties.
CEGUI::RenderedString
Class representing a rendered string of entities.
Definition: RenderedString.h:52
CEGUI::Window::onRotated
virtual void onRotated(ElementEventArgs &e)
Handler called when the element's rotation is changed.
CEGUI::MouseEventArgs
EventArgs based class that is used for objects passed to input event handlers concerning mouse input.
Definition: InputEvent.h:281
CEGUI::Window::EventShown
static const String EventShown
Definition: Window.h:267
CEGUI::Window::releaseRenderingWindow
void releaseRenderingWindow()
helper to clean up the auto RenderingWindow surface
CEGUI::Window::d_surface
RenderingSurface * d_surface
RenderingSurface owned by this window (may be 0)
Definition: Window.h:3692
CEGUI::Window::ClippedByParentPropertyName
static const String ClippedByParentPropertyName
Name of property to access for the 'clipped by parent' setting for the Window.
Definition: Window.h:161
CEGUI::Window::EventMouseTripleClick
static const String EventMouseTripleClick
Definition: Window.h:474
CEGUI::Window::setWindowRenderer
void setWindowRenderer(const String &name)
Assign the WindowRenderer type to be used when rendering this window.
CEGUI::Window::d_tooltipText
String d_tooltipText
Text string used as tip for this window.
Definition: Window.h:3772
CEGUI::Window::getParentElementClipIntersection
Rectf getParentElementClipIntersection(const Rectf &unclipped_area) const
helper function for calculating clipping rectangles.
CEGUI::Window::AutoWindowPropertyName
static const String AutoWindowPropertyName
Name of property to access whether the system considers this window to be an automatically created su...
Definition: Window.h:215
CEGUI::Window::getChildAtIdx
Window * getChildAtIdx(size_t idx) const
returns a pointer to the child window at the specified index. Idx is the index of the window in the c...
Definition: Window.h:723
CEGUI::Window::setAlpha
void setAlpha(const float alpha)
Set the current alpha value for this window.
CEGUI::Window::getUpdateMode
WindowUpdateMode getUpdateMode() const
Return the current window update mode that is set for this Window. This mode controls the behaviour o...
CEGUI::Window::setFont
void setFont(const String &name)
Set the font used by this Window.
CEGUI::Window::Window
Window(const String &type, const String &name)
Constructor for Window base class.
CEGUI::Window::isAncestor
bool isAncestor(uint ID) const
return true if any Window with the given ID is some ancestor of this Window.
CEGUI::Window::onMouseLeaves
virtual void onMouseLeaves(MouseEventArgs &e)
Handler called when the mouse cursor is no longer over this window's surface area....
CEGUI::Vector2< float >
CEGUI::Window::getRootContainerSize
const Sizef & getRootContainerSize() const
Return the size of the root container (such as screen size).
CEGUI::Window::getChild
Window * getChild(uint ID) const
return a pointer to the first attached child window with the specified ID value.
CEGUI::Window::TextPropertyName
static const String TextPropertyName
Name of property to access for the text / caption for the Window.
Definition: Window.h:179
CEGUI::Window::setCustomRenderedStringParser
void setCustomRenderedStringParser(RenderedStringParser *parser)
Set a custom RenderedStringParser, or 0 to remove an existing one.
CEGUI::Window::isActive
bool isActive(void) const
return true if this is the active Window. An active window is a window that may receive user inputs.
CEGUI::Window::getGeometryBuffer
GeometryBuffer & getGeometryBuffer()
Return the GeometryBuffer object for this Window.
CEGUI::WindowEventArgs
EventArgs based class that is used for objects passed to handlers triggered for events concerning som...
Definition: InputEvent.h:252
CEGUI::Window::EventTextParsingChanged
static const String EventTextParsingChanged
Definition: Window.h:394
CEGUI::Window::getRenderedString
const RenderedString & getRenderedString() const
Return the parsed RenderedString object for this window.
CEGUI::BidiVisualMapping
Abstract class to wrap a Bidi visual mapping of a text string.
Definition: BidiVisualMapping.h:52
CEGUI::Window::setAlwaysOnTop
void setAlwaysOnTop(bool setting)
Set whether this window is always on top, or not.
CEGUI::Window::isInFront
bool isInFront(const Window &wnd) const
Return whether /a this Window is in front of the given window.
CEGUI::Window::d_destructionStarted
bool d_destructionStarted
true when this window is being destroyed.
Definition: Window.h:3669
CEGUI::Window::notifyDragDropItemDropped
void notifyDragDropItemDropped(DragContainer *item)
Internal support method for drag & drop. You do not normally call this directly from client code....
CEGUI::Window::UserStringMap
std::map< String, String, StringFastLessCompare CEGUI_MAP_ALLOC(String, String)> UserStringMap
definition of type used for the UserString dictionary.
Definition: Window.h:3654
CEGUI::String::size_type
size_t size_type
Unsigned type used for size values and indices.
Definition: String.h:70
CEGUI::Window::d_enabled
bool d_enabled
true when Window is enabled
Definition: Window.h:3671
CEGUI::TplWindowProperty
Definition: TplWindowProperty.h:38
CEGUI::Window::initialiseComponents
virtual void initialiseComponents(void)
Initialises the Window based object ready for use.
Definition: Window.h:1485
CEGUI::Window::setMouseCursor
void setMouseCursor(const String &name)
Set the mouse cursor image to be used when the mouse enters this window.
CEGUI::Window::onInheritsAlphaChanged
virtual void onInheritsAlphaChanged(WindowEventArgs &e)
Handler called when the window's setting for inheriting alpha-blending is changed.
CEGUI::Window::onMouseEnters
virtual void onMouseEnters(MouseEventArgs &e)
Handler called when the mouse cursor has entered this window's area and is actually over some part of...
CEGUI::Window::getUnclippedInnerRect_impl
virtual Rectf getUnclippedInnerRect_impl(bool skipAllPixelAlignment) const
Default implementation of function to return Element's inner rect area.
CEGUI::Window::d_autoRepeat
bool d_autoRepeat
whether pressed mouse button will auto-repeat the down event.
Definition: Window.h:3756
CEGUI::Window::setAutoRepeatDelay
void setAutoRepeatDelay(float delay)
Set the current auto-repeat delay setting for this window.
CEGUI::Window::getTooltipText
const String & getTooltipText(void) const
Return the current tooltip text set for this Window.
CEGUI::Window::setWritingXMLAllowed
void setWritingXMLAllowed(bool allow)
Sets whether this window is allowed to write XML.
Definition: Window.h:2488
CEGUI::Window::isEffectiveDisabled
bool isEffectiveDisabled() const
return whether the Window is currently disabled
CEGUI::Window::getZIndex
size_t getZIndex() const
Return the (visual) z index of the window on it's parent.
CEGUI::Window::syncTargetSurface
void syncTargetSurface()
ensure that the window will be rendered to the correct target surface.
CEGUI::Window::onMoved
virtual void onMoved(ElementEventArgs &e)
Handler called when the window's position changes.
CEGUI::Window::getWindowAttachedToCommonAncestor
const Window * getWindowAttachedToCommonAncestor(const Window &wnd) const
Helper function to return the ancestor Window of /a wnd that is attached as a child to a window that ...
CEGUI::Window::WindowRendererProperty
Property to access/change the assigned window renderer object.
Definition: Window.h:3619
CEGUI::Window::onSized
virtual void onSized(ElementEventArgs &e)
Handler called when the window's size changes.
CEGUI::Window::d_geometry
GeometryBuffer * d_geometry
Object which acts as a cache of geometry drawn by this Window.
Definition: Window.h:3690
CEGUI::Window::isChildRecursive
bool isChildRecursive(uint ID) const
returns whether at least one window with the given ID code is attached to this Window or any of it's ...
CEGUI::Window::getAlpha
float getAlpha(void) const
return the current alpha value set for this Window
Definition: Window.h:919
CEGUI::Window::d_basicStringParser
static BasicRenderedStringParser d_basicStringParser
Shared instance of a parser to be used in most instances.
Definition: Window.h:3726
CEGUI::Window::d_containsMouse
bool d_containsMouse
true when mouse is contained within this Window's area.
Definition: Window.h:3806
CEGUI::Window::setMouseCursor
void setMouseCursor(const Image *image)
Set the mouse cursor image to be used when the mouse enters this window.
CEGUI::Window::setFont
void setFont(const Font *font)
Set the font used by this Window.
CEGUI::Window::removeChild
void removeChild(uint ID)
Remove the first child Window with the specified ID. If there is more than one attached Window object...
CEGUI::Window::EventInheritsAlphaChanged
static const String EventInheritsAlphaChanged
Definition: Window.h:301
CEGUI::Window::TooltipTypePropertyName
static const String TooltipTypePropertyName
Name of property to access for the custom tooltip for the window.
Definition: Window.h:193
CEGUI::Window::getID
uint getID(void) const
return the ID code currently assigned to this Window by client code.
Definition: Window.h:665
CEGUI::KeyEventArgs
EventArgs based class that is used for objects passed to input event handlers concerning keyboard inp...
Definition: InputEvent.h:315
CEGUI::NamedElement::removeChild
void removeChild(Element *element)
Remove the Element Element's child list.
CEGUI::Window::d_oldCapture
Window * d_oldCapture
The Window that previously had capture (used for restoreOldCapture mode)
Definition: Window.h:3707
CEGUI::Window::getUnprojectedPosition
Vector2f getUnprojectedPosition(const Vector2f &pos) const
return Vector2 pos after being fully unprojected for this Window.
CEGUI::Window::banPropertyFromXMLRecursive
void banPropertyFromXMLRecursive(const String &property_name)
Adds the named property to the XML ban list for this window and all of its child windows....
CEGUI::Window::ChildDrawList
std::vector< Window *CEGUI_VECTOR_ALLOC(Window *)> ChildDrawList
definition of type used for the list of child windows to be drawn
Definition: Window.h:3651
CEGUI::Window::d_clippedByParent
bool d_clippedByParent
true when Window will be clipped by parent Window area Rect.
Definition: Window.h:3683
CEGUI::Window::onDeactivated
virtual void onDeactivated(ActivationEventArgs &e)
Handler called when this window has lost input focus and has been deactivated.
CEGUI::Window::ZOrderingEnabledPropertyName
static const String ZOrderingEnabledPropertyName
Name of property to access for the 'z-order changing enabled' setting for the Window.
Definition: Window.h:181
CEGUI::Window::onRenderingEnded
virtual void onRenderingEnded(WindowEventArgs &e)
Handler called when rendering for this window has ended.
CEGUI::ActivationEventArgs
EventArgs based class that is used for Activated and Deactivated window events.
Definition: InputEvent.h:330
CEGUI::Window::onDragDropItemLeaves
virtual void onDragDropItemLeaves(DragDropEventArgs &e)
Handler called when a DragContainer is dragged over this window.
CEGUI::Window::d_textLogical
String d_textLogical
Holds the text / label / caption for this Window.
Definition: Window.h:3716
CEGUI::UBox
Class encapsulating the 'Unified Box' - this is usually used for margin.
Definition: UDim.h:249
CEGUI::Window::isBehind
bool isBehind(const Window &wnd) const
Return whether /a this Window is behind the given window.
CEGUI::Window::onMouseDoubleClicked
virtual void onMouseDoubleClicked(MouseEventArgs &e)
Handler called when a mouse button has been double-clicked within this window's area.
CEGUI::Window::EventRenderingStarted
static const String EventRenderingStarted
Definition: Window.h:339
CEGUI::Window::onKeyUp
virtual void onKeyUp(KeyEventArgs &e)
Handler called when a key as been released while this window has input focus.
CEGUI::Window::LookNFeelProperty
Property to access/change the assigned look'n'feel.
Definition: Window.h:3639
CEGUI::Window::d_active
bool d_active
true when Window is the active Window (receiving inputs).
Definition: Window.h:3675
CEGUI::Window::getTooltipType
String getTooltipType(void) const
Return the custom tooltip type.
CEGUI::Window::EventKeyDown
static const String EventKeyDown
Definition: Window.h:483
CEGUI::Window::EventNamespace
static const String EventNamespace
Namespace for global events.
Definition: Window.h:221
CEGUI::Window::onParentSized
virtual void onParentSized(ElementEventArgs &e)
Handler called when this window's parent window has been resized. If this window is the root / GUI Sh...
CEGUI::Window::removeWindowFromDrawList
void removeWindowFromDrawList(const Window &wnd)
Removes the window from the drawing list. If the window is not attached to the drawing list then noth...
CEGUI::Window::isMousePassThroughEnabled
bool isMousePassThroughEnabled(void) const
Returns whether this window should ignore mouse event and pass them through to and other windows behi...
Definition: Window.h:1396
CEGUI::Window::onMouseMove
virtual void onMouseMove(MouseEventArgs &e)
Handler called when the mouse cursor has been moved within this window's area.
CEGUI::Window::transferChildSurfaces
void transferChildSurfaces()
transfer RenderingSurfaces to be owned by our target RenderingSurface.
CEGUI::Window::onCaptureGained
virtual void onCaptureGained(WindowEventArgs &e)
Handler called when this window gains capture of mouse inputs.
CEGUI::Window::getFont
const Font * getFont(bool useDefault=true) const
return the active Font object for the Window.
CEGUI::Window::createChild
Window * createChild(const String &type, const String &name="")
Creates a child window attached to this window.
CEGUI::Window::isDisabled
bool isDisabled() const
return whether the Window is currently disabled
CEGUI::Window::isMouseInputPropagationEnabled
bool isMouseInputPropagationEnabled() const
Return whether mouse input that is not directly handled by this Window (including it's event subscrib...
CEGUI::Window::d_riseOnClick
bool d_riseOnClick
whether window should rise in the z order when left clicked.
Definition: Window.h:3747
CEGUI::Window::getTargetRenderingSurface
RenderingSurface & getTargetRenderingSurface() const
return the RenderingSurface that will be used by this window as the target for rendering.
CEGUI::Window::onZChange_impl
virtual void onZChange_impl(void)
Notify 'this' and all siblings of a ZOrder change event.
CEGUI::Window::d_repeatButton
MouseButton d_repeatButton
button we're tracking for auto-repeat purposes.
Definition: Window.h:3762
CEGUI::NamedElement::isChild
bool isChild(const Element *element) const
Checks whether given element is attached to this Element.
CEGUI::Window::getWindowRenderer
WindowRenderer * getWindowRenderer(void) const
Get the currently assigned WindowRenderer. (Look'N'Feel specification).
CEGUI::Window::getChildAtPosition
Window * getChildAtPosition(const Vector2f &position) const
return the child Window that is hit by the given pixel position
CEGUI::Window::setWantsMultiClickEvents
void setWantsMultiClickEvents(bool setting)
Set whether this window will receive multi-click events or multiple 'down' events instead.
CEGUI::Window::onZChanged
virtual void onZChanged(WindowEventArgs &e)
Handler called when the z-order position of this window has changed.
CEGUI::Window::EventAlwaysOnTopChanged
static const String EventAlwaysOnTopChanged
Definition: Window.h:307
CEGUI::Window::beginInitialisation
virtual void beginInitialisation(void)
Sets the internal 'initialising' flag to true. This can be use to optimize initialisation of some wid...
Definition: Window.h:2424
CEGUI::Window::allocateRenderingWindow
void allocateRenderingWindow()
helper to create and setup the auto RenderingWindow surface
CEGUI::Window::d_userData
void * d_userData
Holds pointer to some user assigned data.
Definition: Window.h:3740
CEGUI::Window::MouseCursorImagePropertyName
static const String MouseCursorImagePropertyName
Name of property to access for the the mouse cursor image for the Window.
Definition: Window.h:173
CEGUI::Window::getParent
Window * getParent() const
return the parent of this Window.
Definition: Window.h:1096
CEGUI::Window::EventWindowRendererDetached
static const String EventWindowRendererDetached
Definition: Window.h:387
CEGUI::Window::getModalState
bool getModalState(void) const
Get whether or not this Window is the modal target.
Definition: Window.h:1338
CEGUI::Window::isEffectiveVisible
bool isEffectiveVisible() const
return true if the Window is currently visible.
CEGUI::Window::onTextParsingChanged
virtual void onTextParsingChanged(WindowEventArgs &e)
Handler called when the window's setting for whether text parsing is enabled is changed.
CEGUI::Window::TooltipTextPropertyName
static const String TooltipTextPropertyName
Name of property to access for the tooltip text for the window.
Definition: Window.h:195
CEGUI::Window::isDestroyedByParent
bool isDestroyedByParent(void) const
returns whether or not this Window is set to be destroyed when its parent window is destroyed.
Definition: Window.h:554
CEGUI::Window::d_margin
UBox d_margin
Margin, only used when the Window is inside LayoutContainer class.
Definition: Window.h:3735
CEGUI::Window::VisiblePropertyName
static const String VisiblePropertyName
Name of property to access for the the 'visible state' setting for the Window.
Definition: Window.h:175
CEGUI::Window::RestoreOldCapturePropertyName
static const String RestoreOldCapturePropertyName
Name of property to access for the 'restore old capture' setting for the Window.
Definition: Window.h:177
CEGUI::Window::EventClippedByParentChanged
static const String EventClippedByParentChanged
Definition: Window.h:289
CEGUI::Window::TooltipNameSuffix
static const String TooltipNameSuffix
Widget name suffix for automatically created tooltip widgets.
Definition: Window.h:506
CEGUI::Window::isPropertyAtDefault
bool isPropertyAtDefault(const Property *property) const
Returns whether a property is at it's default value. This function is different from Property::isDefa...
CEGUI::Window::notifyDragDropItemEnters
void notifyDragDropItemEnters(DragContainer *item)
Internal support method for drag & drop. You do not normally call this directly from client code....
CEGUI::Window::isUsingDefaultTooltip
bool isUsingDefaultTooltip(void) const
Return whether this Window is using the system default Tooltip for its Tooltip window.
CEGUI::Window::getRenderingContext
void getRenderingContext(RenderingContext &ctx) const
Fill in the RenderingContext ctx with details of the RenderingSurface where this Window object should...
CEGUI::Window::WantsMultiClickEventsPropertyName
static const String WantsMultiClickEventsPropertyName
Name of property to access for whether the window will receive double-click and triple-click events.
Definition: Window.h:183
CEGUI::Window::isMouseAutoRepeatEnabled
bool isMouseAutoRepeatEnabled(void) const
Return whether mouse button down event autorepeat is enabled for this window.
CEGUI::Window::getText
const String & getText(void) const
return the current text for the Window
Definition: Window.h:887
CEGUI::Window::EventDragDropItemDropped
static const String EventDragDropItemDropped
Definition: Window.h:375
CEGUI::Window::d_customTip
Tooltip * d_customTip
Possible custom Tooltip for this window.
Definition: Window.h:3774
CEGUI::Window::notifyScreenAreaChanged
virtual void notifyScreenAreaChanged(bool recursive=true)
Inform the window, and optionally all children, that screen area rectangles have changed.
CEGUI::Window::getTargetChildAtPosition
Window * getTargetChildAtPosition(const Vector2f &position, const bool allow_disabled=false) const
return the child Window that is 'hit' by the given position, and is allowed to handle mouse events.
CEGUI::Window::AlwaysOnTopPropertyName
static const String AlwaysOnTopPropertyName
Name of property to access for the 'always on top' setting for the Window.
Definition: Window.h:159
CEGUI::Window::onMouseClicked
virtual void onMouseClicked(MouseEventArgs &e)
Handler called when a mouse button has been clicked (that is depressed and then released,...
CEGUI::Window::EventInputCaptureLost
static const String EventInputCaptureLost
Definition: Window.h:321
CEGUI::Window::getHitTestRect
const Rectf & getHitTestRect() const
Return the Rect that descibes the clipped screen area that is used for determining whether this windo...
CEGUI::Window::d_guiContext
GUIContext * d_guiContext
GUIContext. Set when this window is used as a root window.
Definition: Window.h:3803
CEGUI::Window::isUsingAutoRenderingSurface
bool isUsingAutoRenderingSurface() const
Returns whether automatic use of an imagery caching RenderingSurface (i.e. a RenderingWindow) is enab...
CEGUI::Window::d_ID
uint d_ID
User ID assigned to this Window.
Definition: Window.h:3738
CEGUI::Window::getClipRect
const Rectf & getClipRect(const bool non_client=false) const
Return a Rect that describes the rendering clipping rect for the Window.
CEGUI::Window::EventDestroyedByParentChanged
static const String EventDestroyedByParentChanged
Definition: Window.h:295
CEGUI::Window::onMouseButtonUp
virtual void onMouseButtonUp(MouseEventArgs &e)
Handler called when a mouse button has been released within this window's area.
CEGUI::Window::notifyClippingChanged
void notifyClippingChanged(void)
Recursively inform all children that the clipping has changed and screen rects needs to be recached.
CEGUI::Window::d_defaultStringParser
static DefaultRenderedStringParser d_defaultStringParser
Shared instance of a parser to be used when rendering text verbatim.
Definition: Window.h:3728
CEGUI::Window::d_restoreOldCapture
bool d_restoreOldCapture
Restore capture to the previous capture window when releasing capture.
Definition: Window.h:3709
CEGUI::Window::setClippedByParent
void setClippedByParent(bool setting)
Set whether this Window will be clipped by its parent window(s).
CEGUI::Window::isVisible
bool isVisible() const
return true if the Window is currently visible.
CEGUI::Window::unbanPropertyFromXML
void unbanPropertyFromXML(const String &property_name)
Removes the named property from the XML ban list for this window. Essentially a property that is bann...
CEGUI::Window::AutoRenderingSurfacePropertyName
static const String AutoRenderingSurfacePropertyName
Name of property to access for the Window will automatically attempt to use a full imagery caching Re...
Definition: Window.h:205
CEGUI::Window::~Window
virtual ~Window(void)
Destructor for Window base class.
CEGUI::Window::destroyChild
void destroyChild(Window *wnd)
Destroys a child window of this window.
CEGUI::Window::hide
void hide(void)
hide the Window.
Definition: Window.h:1605
CEGUI::Window::DragDropTargetPropertyName
static const String DragDropTargetPropertyName
Name of property to access for the Window will receive drag and drop related notifications.
Definition: Window.h:203
CEGUI::Window::captureInput
bool captureInput(void)
Captures input to this window.
CEGUI::Window::MouseAutoRepeatEnabledPropertyName
static const String MouseAutoRepeatEnabledPropertyName
Name of property to access for whether the window will receive autorepeat mouse button down events.
Definition: Window.h:185
CEGUI::Window::EventIDChanged
static const String EventIDChanged
Definition: Window.h:248
CEGUI::Window::isMouseContainedInArea
bool isMouseContainedInArea() const
Return whether Window thinks mouse is currently within its area.
CEGUI::Window::EventMouseButtonDown
static const String EventMouseButtonDown
Definition: Window.h:450
CEGUI::Window::setDragDropTarget
void setDragDropTarget(bool setting)
Specifies whether this Window object will receive events generated by the drag and drop support in th...
CEGUI::Window::setAutoWindow
void setAutoWindow(bool is_auto)
Set whether this window is marked as an auto window.
CEGUI::Window::LookNFeelProperty::writeXMLToStream
void writeXMLToStream(const PropertyReceiver *receiver, XMLSerializer &xml_stream) const
Writes out an XML representation of this class to the given stream.
CEGUI::Window::getRenderingSurface
RenderingSurface * getRenderingSurface() const
return the RenderingSurface currently set for this window. May return 0.
CEGUI::Window::onTextChanged
virtual void onTextChanged(WindowEventArgs &e)
Handler called when the window's text is changed.
CEGUI::Window::EventWindowRendererAttached
static const String EventWindowRendererAttached
Definition: Window.h:381
CEGUI::Window::disable
void disable(void)
disable the Window to prevent interaction.
Definition: Window.h:1560
CEGUI::Window::unbanPropertyFromXMLRecursive
void unbanPropertyFromXMLRecursive(const String &property_name)
Removes the named property from the XML ban list for this window and all of its child windows....
CEGUI::Window
An abstract base class providing common functionality and specifying the required interface for deriv...
Definition: Window.h:151
CEGUI::Window::getChild
Window * getChild(const String &name_path) const
return the attached child window that the given name path references.
Definition: Window.h:751
CEGUI::Window::onEnabled
virtual void onEnabled(WindowEventArgs &e)
Handler called when the window is enabled.
CEGUI::Window::isCapturedByThis
bool isCapturedByThis(void) const
return true if this Window has input captured.
Definition: Window.h:1011
CEGUI::RenderedStringParser
Specifies interface for classes that parse text into RenderedString objects.
Definition: RenderedStringParser.h:39
CEGUI::Window::getAutoRepeatDelay
float getAutoRepeatDelay(void) const
Return the current auto-repeat delay setting for this window.
CEGUI::Window::writeXMLToStream
virtual void writeXMLToStream(XMLSerializer &xml_stream) const
Writes an xml representation of this window object to out_stream.
CEGUI::WUM_ALWAYS
@ WUM_ALWAYS
Always call the Window::update function for this window.
Definition: Window.h:73
CEGUI::Window::EventDisabled
static const String EventDisabled
Definition: Window.h:283
CEGUI::WindowRenderer
Base-class for the assignable WindowRenderer object.
Definition: WindowRenderer.h:52
CEGUI::Window::getCaptureWindow
Window * getCaptureWindow() const
return the Window that currently has inputs captured.
Definition: Window.h:1000
CEGUI::Window::getAutoRepeatRate
float getAutoRepeatRate(void) const
Return the current auto-repeat rate setting for this window.
CEGUI::Window::IDPropertyName
static const String IDPropertyName
Name of property to access for the ID value of the Window.
Definition: Window.h:169
CEGUI::Window::RiseOnClickEnabledPropertyName
static const String RiseOnClickEnabledPropertyName
Name of property to access for the window will come to the top of the Z-order when clicked.
Definition: Window.h:199
CEGUI::Window::getCustomRenderedStringParser
RenderedStringParser * getCustomRenderedStringParser() const
Return a pointer to any custom RenderedStringParser set, or 0 if none.
CEGUI::Window::getOuterRectClipper_impl
virtual Rectf getOuterRectClipper_impl() const
Default implementation of function to return Window outer clipper area.
CEGUI::Window::d_font
const Font * d_font
Holds pointer to the Window objects current Font.
Definition: Window.h:3714
CEGUI::Window::d_textParsingEnabled
bool d_textParsingEnabled
true if use of parser other than d_defaultStringParser is enabled
Definition: Window.h:3732
CEGUI::Window::setArea_impl
virtual void setArea_impl(const UVector2 &pos, const USize &size, bool topLeftSizing=false, bool fireEvents=true)
Implementation method to modify element area while correctly applying min / max size processing,...
CEGUI::Window::getEffectiveAlpha
float getEffectiveAlpha(void) const
return the effective alpha value that will be used when rendering this window, taking into account in...
CEGUI::Window::banPropertyFromXML
void banPropertyFromXML(const Property *property)
Add the given property to the XML ban list for this window.
CEGUI::Window::EventMouseWheel
static const String EventMouseWheel
Definition: Window.h:445
CEGUI::Window::isUserStringDefined
bool isUserStringDefined(const String &name) const
Return whether a user string with the specified name exists.
CEGUI::Window::isCapturedByAncestor
bool isCapturedByAncestor(void) const
return true if an ancestor window has captured inputs.
Definition: Window.h:1022
CEGUI::Window::getActiveSibling
Window * getActiveSibling()
Returns the active sibling window.
CEGUI::Window::invalidate
void invalidate(const bool recursive)
Invalidate this window and - dependant upon recursive - all child content, causing affected windows t...
CEGUI::Window::d_alpha
float d_alpha
Alpha transparency setting for the Window.
Definition: Window.h:3702
CEGUI::Window::moveToFront
void moveToFront()
Move the Window to the top of the z order.
CEGUI::Window::getMargin
const UBox & getMargin() const
retrieves currently set margin
CEGUI::Window::getOuterRectClipper
const Rectf & getOuterRectClipper() const
Return a Rect that describes the rendering clipping rect based upon the outer rect area of the window...
CEGUI::Window::getChildRecursive
Window * getChildRecursive(const String &name) const
return a pointer to the first attached child window with the specified name. Children are traversed r...
Definition: Window.h:777
CEGUI::Window::d_zOrderingEnabled
bool d_zOrderingEnabled
true if the Window responds to z-order change requests.
Definition: Window.h:3749
CEGUI::Window::populateGeometryBuffer
virtual void populateGeometryBuffer()
Update the rendering cache.
Definition: Window.h:3405
CEGUI::Size< float >
CEGUI::Window::onKeyDown
virtual void onKeyDown(KeyEventArgs &e)
Handler called when a key as been depressed while this window has input focus.
CEGUI::Window::EventKeyUp
static const String EventKeyUp
Definition: Window.h:492
CEGUI::Window::d_type
const String d_type
type of Window (also the name of the WindowFactory that created us)
Definition: Window.h:3660
CEGUI::Window::isCapturedByChild
bool isCapturedByChild(void) const
return true if a child window has captured inputs.
Definition: Window.h:1033
CEGUI::GUIContext
Definition: GUIContext.h:70
CEGUI::Window::onParentDestroyChanged
virtual void onParentDestroyChanged(WindowEventArgs &e)
Handler called when the window's setting for being destroyed automatically be it's parent is changed.
CEGUI::Window::onRenderingStarted
virtual void onRenderingStarted(WindowEventArgs &e)
Handler called when rendering for this window has started.
CEGUI::System
The System class is the CEGUI class that provides access to all other elements in this system.
Definition: System.h:69
CEGUI::Window::onActivated
virtual void onActivated(ActivationEventArgs &e)
Handler called when this window has become the active window.
CEGUI::Window::onCaptureLost
virtual void onCaptureLost(WindowEventArgs &e)
Handler called when this window loses capture of mouse inputs.
CEGUI::Window::EventEnabled
static const String EventEnabled
Definition: Window.h:277
CEGUI::Window::moveBehind
void moveBehind(const Window *const window)
Move this window immediately behind it's sibling window in the z order.
CEGUI::String
String class used within the GUI system.
Definition: String.h:64
CEGUI::Window::isClippedByParent
bool isClippedByParent(void) const
return true if this Window is clipped so that its rendering will not pass outside of its parent Windo...
Definition: Window.h:656
CEGUI::Window::d_wantsMultiClicks
bool d_wantsMultiClicks
true if the Window wishes to hear about multi-click mouse events.
Definition: Window.h:3752
CEGUI::Window::setModalState
void setModalState(bool state)
Set the modal state for this Window.
CEGUI::Window::inheritsTooltipText
bool inheritsTooltipText(void) const
Return whether this window inherits Tooltip text from its parent when its own tooltip text is not set...
CEGUI::Window::setRiseOnClickEnabled
void setRiseOnClickEnabled(bool setting)
Set whether this window will rise to the top of the z-order when clicked with the left mouse button.
Definition: Window.h:2241
CEGUI::Window::insertText
void insertText(const String &text, const String::size_type position)
Insert the text string text into the current text string for the Window object at the position specif...
CEGUI::Window::setText
void setText(const String &text)
Set the current text string for the Window.
CEGUI::Window::clonePropertiesTo
virtual void clonePropertiesTo(Window &target) const
copies this widget's properties to given target widget
CEGUI::Window::InheritsAlphaPropertyName
static const String InheritsAlphaPropertyName
Name of property to access for the get/set the 'inherits alpha' setting for the Window.
Definition: Window.h:171
CEGUI::Property
An abstract class that defines the interface to access object properties by name.
Definition: Property.h:62
CEGUI::Window::EventMouseButtonUp
static const String EventMouseButtonUp
Definition: Window.h:455
CEGUI::Window::moveInFront
void moveInFront(const Window *const window)
Move this window immediately above it's sibling window in the z order.
CEGUI::MouseButton
MouseButton
Enumeration of mouse buttons.
Definition: InputEvent.h:210
CEGUI::Window::isTopOfZOrder
bool isTopOfZOrder() const
Return whether the window is at the top of the Z-Order. This will correctly take into account 'Always...
CEGUI::Window::endInitialisation
virtual void endInitialisation(void)
Sets the internal 'initialising' flag to false. This is called automatically by the layout XML handle...
Definition: Window.h:2433
CEGUI::Window::DestroyedByParentPropertyName
static const String DestroyedByParentPropertyName
Name of property to access for the 'destroyed by parent' setting for the Window.
Definition: Window.h:163
CEGUI::DefaultRenderedStringParser
Effectively a 'null' parser that returns a RenderedString representation that will draw the input tex...
Definition: DefaultRenderedStringParser.h:41
CEGUI::WindowManager
The WindowManager class describes an object that manages creation and lifetime of Window objects.
Definition: WindowManager.h:63
CEGUI::Window::getRenderingContext_impl
virtual void getRenderingContext_impl(RenderingContext &ctx) const
implementation of the default getRenderingContext logic.
CEGUI::Window::d_hitTestRect
Rectf d_hitTestRect
area rect used for hit-testing against this window
Definition: Window.h:3790
CEGUI::Window::d_drawList
ChildDrawList d_drawList
Child window objects arranged in rendering order.
Definition: Window.h:3678
CEGUI::Window::updateSelf
virtual void updateSelf(float elapsed)
Perform actual update processing for this Window.
CEGUI::Rect< float >
CEGUI::Window::AutoRepeatRatePropertyName
static const String AutoRepeatRatePropertyName
Name of property to access for the autorepeat rate.
Definition: Window.h:189
CEGUI::Window::onShown
virtual void onShown(WindowEventArgs &e)
Handler called when the window is shown (made visible).
CEGUI::Window::d_repeatElapsed
float d_repeatElapsed
implements repeating - tracks time elapsed.
Definition: Window.h:3766
CEGUI::BasicRenderedStringParser
Basic RenderedStringParser class that offers support for the following tags:
Definition: BasicRenderedStringParser.h:65
CEGUI::Window::d_renderedStringValid
bool d_renderedStringValid
true if d_renderedString is valid, false if needs re-parse.
Definition: Window.h:3724
CEGUI::Window::getChildRecursive
Window * getChildRecursive(uint ID) const
return a pointer to the first attached child window with the specified ID value. Children are travers...
CEGUI::Window::setInheritsTooltipText
void setInheritsTooltipText(bool setting)
Set whether this window inherits Tooltip text from its parent when its own tooltip text is not set.
CEGUI::Window::d_renderedString
RenderedString d_renderedString
RenderedString representation of text string as ouput from a parser.
Definition: Window.h:3722
CEGUI::Window::generateAutoRepeatEvent
void generateAutoRepeatEvent(MouseButton button)
Fires off a repeated mouse button down event for this window.
CEGUI::Window::EventTextChanged
static const String EventTextChanged
Definition: Window.h:233
CEGUI::Window::AlphaPropertyName
static const String AlphaPropertyName
Name of property to access for the alpha value of the Window.
Definition: Window.h:157
CEGUI::Image
Interface for Image.
Definition: Image.h:161
CEGUI::Window::getTextVisual
const String & getTextVisual() const
return text string with visual ordering of glyphs.
CEGUI::PropertyHelper
Helper class used to convert various data types to and from the format expected in Property strings.
Definition: ForwardRefs.h:84
CEGUI::Window::setVisible
void setVisible(bool setting)
Set whether the Window is visible or hidden.
CEGUI::Window::d_needsRedraw
bool d_needsRedraw
true if window geometry cache needs to be regenerated.
Definition: Window.h:3694
CEGUI::Window::render
void render()
Causes the Window object to render itself and all of it's attached children.
CEGUI::Window::EventMarginChanged
static const String EventMarginChanged
Definition: Window.h:400
CEGUI::Window::EventMouseMove
static const String EventMouseMove
Definition: Window.h:439
CEGUI::Window::performChildWindowLayout
virtual void performChildWindowLayout(bool nonclient_sized_hint=false, bool client_sized_hint=false)
Layout child window content.
CEGUI::Window::setAutoRepeatRate
void setAutoRepeatRate(float rate)
Set the current auto-repeat rate setting for this window.
CEGUI::Window::d_updateMode
WindowUpdateMode d_updateMode
The mode to use for calling Window::update.
Definition: Window.h:3797
CEGUI::Window::setDisabled
void setDisabled(bool setting)
Set whether this window is enabled or disabled. A disabled window normally can not be interacted with...
CEGUI::PropertyReceiver
Dummy base class to ensure correct casting of receivers.
Definition: Property.h:46
CEGUI::Window::setUserData
void setUserData(void *user_data)
Set the user data set for this Window.
Definition: Window.h:2023
CEGUI::Window::setTextParsingEnabled
void setTextParsingEnabled(const bool setting)
set whether text parsing is enabled for this window.
CEGUI::Window::setDestroyedByParent
void setDestroyedByParent(bool setting)
Set whether or not this Window will automatically be destroyed when its parent Window is destroyed.
CEGUI::Window::d_userStrings
UserStringMap d_userStrings
Holds a collection of named user string values.
Definition: Window.h:3742
CEGUI::Window::setLookNFeel
virtual void setLookNFeel(const String &look)
Set the LookNFeel that shoule be used for this window.
CEGUI::Window::getUserData
void * getUserData(void) const
Return the user data set for this Window.
Definition: Window.h:1128
CEGUI::Window::TextParsingEnabledPropertyName
static const String TextParsingEnabledPropertyName
Name of property to access for the text parsing setting for the Window.
Definition: Window.h:207
CEGUI::Window::onWindowRendererAttached
virtual void onWindowRendererAttached(WindowEventArgs &e)
Handler called when a new window renderer object is attached.
CEGUI::Window::show
void show(void)
show the Window.
Definition: Window.h:1593
CEGUI::Window::onInvalidated
virtual void onInvalidated(WindowEventArgs &e)
Handler called when this window gets invalidated.
CEGUI::Window::getActiveChild
Window * getActiveChild(void)
return a pointer to the Window that currently has input focus starting with this Window.
CEGUI::Window::DisabledPropertyName
static const String DisabledPropertyName
Name of property to access for the 'disabled state' setting for the Window.
Definition: Window.h:165
CEGUI::Window::onMouseTripleClicked
virtual void onMouseTripleClicked(MouseEventArgs &e)
Handler called when a mouse button has been triple-clicked within this window's area.
CEGUI::Window::isAlwaysOnTop
bool isAlwaysOnTop(void) const
returns whether or not this Window is an always on top Window. Also known as a top-most window.
Definition: Window.h:565
CEGUI::Window::d_allowWriteXML
bool d_allowWriteXML
true if this window is allowed to write XML, false if not
Definition: Window.h:3781
CEGUI::EventArgs
Base class used as the argument to all subscribers Event object.
Definition: EventArgs.h:51
CEGUI::NamedElement
Adds name to the Element class, including name path traversal.
Definition: NamedElement.h:76
CEGUI::Window::d_alwaysOnTop
bool d_alwaysOnTop
true if Window will be drawn on top of all other Windows
Definition: Window.h:3745
CEGUI::Element
A positioned and sized rectangular node in a tree graph.
Definition: Element.h:246
CEGUI::WUM_VISIBLE
@ WUM_VISIBLE
Only call the Window::update function for this window if it is visible.
Definition: Window.h:77
CEGUI::Window::isPropertyBannedFromXML
bool isPropertyBannedFromXML(const Property *property) const
Return whether given property is banned from XML.
CEGUI::Window::d_dragDropTarget
bool d_dragDropTarget
true if window will receive drag and drop related notifications
Definition: Window.h:3769
CEGUI::Window::inheritsAlpha
bool inheritsAlpha(void) const
return true if the Window inherits alpha from its parent(s).
Definition: Window.h:900
CEGUI::Window::setInheritsAlpha
void setInheritsAlpha(bool setting)
Sets whether this Window will inherit alpha from its parent windows.
CEGUI::Window::EventDragDropItemEnters
static const String EventDragDropItemEnters
Definition: Window.h:360
CEGUI::Window::isRiseOnClickEnabled
bool isRiseOnClickEnabled(void) const
Return whether this window will rise to the top of the z-order when clicked with the left mouse butto...
Definition: Window.h:1310
CEGUI::Window::d_mousePassThroughEnabled
bool d_mousePassThroughEnabled
whether (most) mouse events pass through this window
Definition: Window.h:3754
CEGUI::Window::EventActivated
static const String EventActivated
Definition: Window.h:255