class EE::UI::UIMenu

Overview

#include <uimenu.hpp>

class UIMenu: public EE::UI::UIWidget {
public:
    // construction

    virtual ~UIMenu();

    // methods

    static UIMenu* New();
    static void findBestMenuPos(Vector2f& position, UIMenu* menu, UIMenu* parent = NULL, UIMenuSubMenu* subMenu = NULL);
    virtual Uint32 getType() const;
    virtual bool isType(const Uint32& type) const;
    UIMenuItem* add(const String& text, Drawable* icon = NULL, const String& shortcutText = "");
    UIWidget* add(UIWidget* widget);
    UIMenuSeparator* addSeparator();
    UIMenuCheckBox* addCheckBox(const String& text, const bool& active = false, const String& shortcutText = "");
    UIMenuRadioButton* addRadioButton(const String& text, const bool& active = false);
    UIMenuSubMenu* addSubMenu(const String& text, Drawable* icon = NULL, UIMenu* subMenu = NULL);
    UIWidget* getItem(const Uint32& index);
    UIMenuItem* getItem(const String& text);
    UIMenuItem* getItemId(const std::string& id);
    Uint32 getItemIndex(UIWidget* item);
    Uint32 getCount() const;
    UIWidget* getItemSelected() const;
    void remove(const Uint32& index);
    void remove(UIWidget* widget);
    void removeAll();
    void insert(const String& text, Drawable* icon, const Uint32& index);
    void insert(UIWidget* widget, const Uint32& index);
    virtual void setTheme(UITheme* theme);
    virtual bool show();
    virtual bool hide();
    virtual void loadFromXmlNode(const pugi::xml_node& node);
    virtual bool applyProperty(const StyleSheetProperty& attribute);
    virtual std::string getPropertyString(const PropertyDefinition* propertyDef, const Uint32& propertyIndex = 0) const;
    virtual std::vector<PropertyId> getPropertiesImplemented() const;
    UINode* getOwnerNode() const;
    void setOwnerNode(UIWidget* ownerNode);
    void setIconMinimumSize(const Sizei& minIconSize);
    const Sizei& getIconMinimumSize() const;
    void backpropagateHide();
    const Clock& getInactiveTime() const;
};

Inherited Members

public:
    // typedefs

    typedef std::function<void(const Event*)> EventCallback;
    typedef std::function<void(const Event*)> EventCallback;

    // methods

    virtual void setPosition(const Vector2f& position);
    virtual void setRotation(float angle);
    virtual void setScale(float factorX, float factorY);
    virtual void setScale(const Vector2f& factors);
    virtual void setScaleOrigin(float x, float y);
    virtual void setScaleOrigin(const Vector2f& origin);
    virtual void setRotationOrigin(float x, float y);
    virtual void setRotationOrigin(const Vector2f& origin);
    virtual const Vector2f& getRotationOrigin() const;
    virtual const Vector2f& getPosition() const;
    virtual const float& getRotation() const;
    virtual const Vector2f& getScale() const;
    virtual const Vector2f& getScaleOrigin() const;
    void move(float offsetX, float offsetY);
    void move(const Vector2f& offset);
    void rotate(float angle);
    void scale(float factorX, float factorY);
    void scale(const Vector2f& factor);
    const Transform& getTransform() const;
    const Transform& getInverseTransform() const;
    static Node* New();
    virtual void worldToNodeTranslation(Vector2f& position) const;
    virtual void nodeToWorldTranslation(Vector2f& position) const;
    virtual void worldToNode(Vector2i& pos) const;
    virtual void nodeToWorld(Vector2i& pos) const;
    virtual void worldToNode(Vector2f& pos) const;
    virtual void nodeToWorld(Vector2f& pos) const;
    virtual Uint32 getType() const;
    virtual bool isType(const Uint32& type) const;
    void messagePost(const NodeMessage* Msg);
    virtual void setPosition(const Vector2f& Pos);
    virtual Node* setPosition(const Float& x, const Float& y);
    virtual Node* setSize(const Sizef& size);
    Node* setSize(const Float& Width, const Float& Height);
    virtual const Sizef& getSize() const;
    const Sizef& getPixelsSize() const;
    Node* setVisible(const bool& visible, bool emitEventNotification = true);
    Node* setChildsVisibility(bool visible, bool emitEventNotification = true);
    bool isVisible() const;
    bool isHided() const;
    Node* setEnabled(const bool& enabled);
    bool isEnabled() const;
    bool isDisabled() const;
    Node* getParent() const;
    Node* setParent(Node* parent);
    virtual void close();
    virtual void draw();
    virtual void update(const Time& time);
    virtual void scheduledUpdate(const Time& time);
    Node* getNextNode() const;
    Node* getPrevNode() const;
    Node* getNextNodeLoop() const;
    Node* setData(const UintPtr& data);
    const UintPtr& getData() const;
    Node* setBlendMode(const BlendMode& blend);
    const BlendMode& getBlendMode() const;
    Node* toFront();
    Node* toBack();
    void toPosition(const Uint32& position);
    const Uint32& getNodeFlags() const;
    void setNodeFlags(const Uint32& flags);
    bool isSceneNode() const;
    bool isUISceneNode() const;
    bool isUINode() const;
    bool isWidget() const;
    bool isWindow() const;
    bool isLayout() const;
    bool isClipped() const;
    bool isRotated() const;
    bool isScaled() const;
    bool isFrameBuffer() const;
    bool isMouseOver() const;
    bool isMouseOverMeOrChilds() const;
    bool isMeOrParentTreeVisible() const;
    bool isMeOrParentTreeRotated() const;
    bool isMeOrParentTreeScaled() const;
    bool isMeOrParentTreeScaledOrRotated() const;
    bool isMeOrParentTreeScaledOrRotatedOrFrameBuffer() const;
    Uint32 addEventListener(const Uint32& eventType, const EventCallback& callback);
    Uint32 on(const Uint32& eventType, const EventCallback& callback);
    Uint32 onClick(const std::function<void(const MouseEvent*)>& callback, const MouseButton& button = MouseButton::EE_BUTTON_LEFT);
    Uint32 onDoubleClick(const std::function<void(const MouseEvent*)>& callback, const MouseButton& button = MouseButton::EE_BUTTON_LEFT);
    void removeEventsOfType(const Uint32& eventType);
    void removeEventListener(const Uint32& callbackId);
    void removeEventListener(const std::vector<Uint32>& callbacksIds);
    void clearEventListener();
    Node* getFirstChild() const;
    Node* getLastChild() const;
    const Polygon2f& getWorldPolygon();
    const Rectf& getWorldBounds();
    bool isParentOf(const Node* node) const;
    void sendEvent(const Event* Event);
    void sendMouseEvent(const Uint32& Event, const Vector2i& position, const Uint32& flags);
    void sendCommonEvent(const Uint32& Event);
    void sendTextEvent(const Uint32& event, const std::string& text);
    void childsCloseAll();
    const std::string& getId() const;
    virtual Node* setId(const std::string& id);
    const String::HashType& getIdHash() const;
    Node* find(const std::string& id) const;
    Node* hasChild(const std::string& id) const;

    template <typename T>
    T* find(const std::string& id) const;

    template <typename T>
    T* bind(const std::string& id, T*& node);

    template <typename T>
    T* asType();

    template <typename T>
    const T* asConstType() const;

    Node* findByType(const Uint32& type) const;

    template <typename T>
    T* findByType(const Uint32& type) const;

    template <typename T>
    T* bindByType(const Uint32& type, T*& node);

    std::vector<Node*> findAllByType(const Uint32& type) const;

    template <typename T>
    std::vector<T*> findAllByType(const Uint32& type) const;

    bool inNodeTree(Node* node) const;
    bool isReverseDraw() const;
    void setReverseDraw(bool reverseDraw);
    void invalidateDraw();
    virtual void setRotation(float angle);
    void setRotation(const Float& angle, const OriginPoint& center);
    const OriginPoint& getRotationOriginPoint() const;
    void setRotationOriginPoint(const OriginPoint& center);
    void setRotationOriginPointX(const std::string& xEq);
    void setRotationOriginPointY(const std::string& yEq);
    Vector2f getRotationCenter() const;
    virtual void setScale(const Vector2f& scale);
    void setScale(const Vector2f& scale, const OriginPoint& center);
    void setScale(const Float& scale, const OriginPoint& center = OriginPoint::OriginCenter);
    const OriginPoint& getScaleOriginPoint() const;
    void setScaleOriginPoint(const OriginPoint& center);
    void setScaleOriginPointX(const std::string& xEq);
    void setScaleOriginPointY(const std::string& yEq);
    Vector2f getScaleCenter() const;
    virtual void setScale(float factorX, float factorY);
    virtual void setScaleOrigin(float x, float y);
    virtual void setRotationOrigin(float x, float y);
    const Float& getAlpha() const;
    virtual void setAlpha(const Float& alpha);
    virtual void setChildsAlpha(const Float& alpha);
    ActionManager* getActionManager() const;
    Node* runAction(Action* action);
    bool removeAction(Action* action);
    bool removeActions(const std::vector<Action*>& actions);
    bool removeActionsByTag(const String::HashType& tag);
    std::vector<Action*> getActions();
    std::vector<Action*> getActionsByTag(const Uint32& tag);
    void clearActions();
    Transform getLocalTransform() const;
    Transform getGlobalTransform() const;
    Transform getNodeToWorldTransform() const;
    Transform getWorldToNodeTransform() const;
    Vector2f convertToNodeSpace(const Vector2f& worldPoint) const;
    Vector2f convertToWorldSpace(const Vector2f& nodePoint) const;
    Rectf getLocalBounds() const;
    bool hasFocus() const;
    bool hasFocusWithin() const;
    virtual Node* setFocus(NodeFocusReason reason = NodeFocusReason::Unknown);
    Node* getFirstWidget() const;
    Node* getParentWidget() const;
    void enableReportSizeChangeToChilds();
    void disableReportSizeChangeToChilds();
    bool reportSizeChangeToChilds() const;
    Node* centerHorizontal();
    Node* centerVertical();
    Node* center();
    Node* clipEnable();
    Node* clipDisable();
    void writeNodeFlag(const Uint32& Flag, const Uint32& Val);
    SceneNode* getSceneNode() const;
    EventDispatcher* getEventDispatcher() const;
    virtual bool isDrawInvalidator() const;
    bool invalidated() const;
    virtual void invalidate(Node* invalidator);
    Uint32 getChildCount() const;
    Uint32 getChildOfTypeCount(const Uint32& type) const;
    Node* getChildAt(Uint32 Index) const;
    Uint32 getNodeIndex() const;
    Uint32 getNodeOfTypeIndex() const;
    void runOnMainThread(Actions::Runnable::RunnableFunc runnable, const Time& delay = Seconds(0), const Action::UniqueID& uniqueIdentifier = 0);
    void setTimeout(Actions::Runnable::RunnableFunc runnable, const Time& delay = Seconds(0), const Action::UniqueID& uniqueIdentifier = 0);
    void debounce(Actions::Runnable::RunnableFunc runnable, const Time& delay, const Action::UniqueID& uniqueIdentifier);
    void setInterval(Actions::Runnable::RunnableFunc runnable, const Time& interval, const Action::UniqueID& uniqueIdentifier = 0);
    bool isChild(Node* child) const;
    bool inParentTreeOf(Node* child) const;
    void setLoadingState(bool loading);
    bool isLoadingState() const;
    virtual void onIdChange();
    bool isClosing() const;
    bool isClosingChildren() const;
    virtual Node* overFind(const Vector2f& Point);
    void detach();
    void forEachNode(std::function<void(Node*)> func);
    void forEachChild(std::function<void(Node*)> func);
    virtual void nodeDraw();
    Uint32 forceKeyDown(const KeyEvent& event);
    Uint32 foceKeyUp(const KeyEvent& event);
    Uint32 forceTextInput(const TextInputEvent& Event);
    const Vector2f& getScreenPos() const;
    Rectf getScreenRect() const;
    bool hasEventsOfType(const Uint32& eventType) const;
    static UINode* New();
    virtual void worldToNodeTranslation(Vector2f& position) const;
    virtual void nodeToWorldTranslation(Vector2f& position) const;
    virtual void worldToNode(Vector2i& pos) const;
    virtual void nodeToWorld(Vector2i& pos) const;
    virtual void worldToNode(Vector2f& pos) const;
    virtual void nodeToWorld(Vector2f& pos) const;
    virtual Uint32 getType() const;
    virtual bool isType(const Uint32& type) const;
    virtual void setPosition(const Vector2f& Pos);
    virtual Node* setPosition(const Float& x, const Float& y);
    UINode* setPixelsPosition(const Vector2f& position);
    UINode* setPixelsPosition(const Float& x, const Float& y);
    virtual const Vector2f& getPosition() const;
    const Vector2f& getPixelsPosition() const;
    virtual Node* setSize(const Sizef& size);
    virtual Node* setSize(const Float& Width, const Float& Height);
    UINode* setPixelsSize(const Sizef& size);
    UINode* setPixelsSize(const Float& x, const Float& y);
    virtual const Sizef& getSize() const;
    Rect getRect() const;
    Rectf getRectBox() const;
    virtual void draw();
    Uint32 getHorizontalAlign() const;
    UINode* setHorizontalAlign(Uint32 halign);
    Uint32 getVerticalAlign() const;
    UINode* setVerticalAlign(Uint32 valign);
    UINode* setGravity(Uint32 hvalign);
    UINodeDrawable* setBackgroundFillEnabled(bool enabled);
    UINode* setBackgroundDrawable(Drawable* drawable, bool ownIt = false, int index = 0);
    UINode* setBackgroundDrawable(const std::string& drawable, int index);
    UINode* setBackgroundColor(const Color& color);
    UINode* setBackgroundTint(const Color& color, int index);
    UINode* setBackgroundPositionX(const std::string& positionX, int index = 0);
    UINode* setBackgroundPositionY(const std::string& positionY, int index = 0);
    UINode* setBackgroundRepeat(const std::string& repeatRule, int index = 0);
    UINode* setBackgroundSize(const std::string& size, int index = 0);
    Color getBackgroundColor() const;
    Color getBackgroundTint(int index = 0) const;
    UINode* setBorderRadius(const unsigned int& corners);
    UINode* setTopLeftRadius(const std::string& radius);
    UINode* setTopRightRadius(const std::string& radius);
    UINode* setBottomLeftRadius(const std::string& radius);
    UINode* setBottomRightRadius(const std::string& radius);
    Uint32 getBorderRadius() const;
    UINodeDrawable* setForegroundFillEnabled(bool enabled);
    UINode* setForegroundDrawable(Drawable* drawable, bool ownIt = false, int index = 0);
    UINode* setForegroundDrawable(const std::string& drawable, int index = 0);
    UINode* setForegroundColor(const Color& color);
    UINode* setForegroundTint(const Color& color, int index);
    UINode* setForegroundPositionX(const std::string& positionX, int index = 0);
    UINode* setForegroundPositionY(const std::string& positionY, int index = 0);
    UINode* setForegroundRepeat(const std::string& repeatRule, int index = 0);
    UINode* setForegroundSize(const std::string& size, int index = 0);
    Color getForegroundColor() const;
    Color getForegroundTint(int index) const;
    UINode* setForegroundRadius(const unsigned int& corners);
    Uint32 getForegroundRadius() const;
    UIBorderDrawable* setBorderEnabled(bool enabled) const;
    UINode* setBorderColor(const Color& color);
    Color getBorderColor();
    UINode* setBorderWidth(const unsigned int& width);
    Float getBorderWidth() const;
    const Uint32& getFlags() const;
    virtual UINode* setFlags(const Uint32& flags);
    virtual UINode* unsetFlags(const Uint32& flags);
    virtual UINode* resetFlags(Uint32 newFlags = 0);
    UINodeDrawable* getBackground() const;
    bool hasBackground() const;
    UINodeDrawable* getForeground() const;
    bool hasForeground() const;
    UIBorderDrawable* getBorder() const;
    void setThemeByName(const std::string& Theme);
    virtual void setTheme(UITheme* Theme);
    virtual UINode* setThemeSkin(UITheme* Theme, const std::string& skinName);
    virtual UINode* setThemeSkin(const std::string& skinName);
    void setThemeToChilds(UITheme* Theme);
    UISkin* getSkin() const;
    virtual UINode* setSkin(const UISkin& Skin);
    UINode* setSkin(UISkin* skin);
    UINode* setSkinColor(const Color& color);
    const Color& getSkinColor() const;
    void removeSkin();
    virtual void pushState(const Uint32& State, bool emitEvent = true);
    virtual void popState(const Uint32& State, bool emitEvent = true);
    Sizef getSkinSize(const Uint32& state = UIState::StateFlagNormal) const;
    void applyDefaultTheme();
    Node* getWindowContainer() const;
    bool isTabFocusable() const;
    bool isDragging() const;
    void setDragging(const bool& dragging);
    void startDragging(const Vector2f& position);
    bool ownsChildPosition() const;
    const Vector2f& getDragPoint() const;
    void setDragPoint(const Vector2f& Point);
    bool isDragEnabled() const;
    void setDragEnabled(const bool& enable);
    void setDragButton(const Uint32& Button);
    const Uint32& getDragButton() const;
    virtual Node* setFocus(NodeFocusReason reason = NodeFocusReason::Unknown);
    Float getPropertyRelativeTargetContainerLength(const CSS::PropertyRelativeTarget& relativeTarget, const Float& defaultValue = 0, const Uint32& propertyIndex = 0) const;
    virtual Float convertLength(const CSS::StyleSheetLength& length, const Float& containerLength) const;
    Float convertLengthAsDp(const CSS::StyleSheetLength& length, const Float& containerLength) const;
    Float lengthFromValue(const std::string& value, const CSS::PropertyRelativeTarget& relativeTarget, const Float& defaultValue = 0, const Uint32& propertyIndex = 0) const;
    Float lengthFromValue(const CSS::StyleSheetProperty& property, const Float& defaultValue = 0);
    Float lengthFromValueAsDp(const std::string& value, const CSS::PropertyRelativeTarget& relativeTarget, const Float& defaultValue = 0, const Uint32& propertyIndex = 0) const;
    Float lengthFromValueAsDp(const CSS::StyleSheetProperty& property, const Float& defaultValue = 0) const;
    UISceneNode* getUISceneNode() const;
    void setMinWidth(const Float& width);
    void setMinHeight(const Float& height);
    void setMinSize(const Sizef& size);
    const Sizef& getCurMinSize() const;
    Rectf getLocalDpBounds() const;
    virtual void nodeDraw();
    void clearForeground();
    void clearBackground();
    const ClipType& getClipType() const;
    UINode* setClipType(const ClipType& clipType);
    bool hasBorder() const;
    virtual const Rectf& getPixelsPadding() const;
    const std::string& getMinWidthEq() const;
    void setMinSizeEq(const std::string& minWidthEq, const std::string& minHeightEq);
    void setMinWidthEq(const std::string& minWidthEq);
    const std::string& getMinHeightEq() const;
    void setMinHeightEq(const std::string& minHeightEq);
    const std::string& getMaxWidthEq() const;
    void setMaxSizeEq(const std::string& maxWidthEq, const std::string& maxHeightEq);
    void setMaxWidthEq(const std::string& maxWidthEq);
    const std::string& getMaxHeightEq() const;
    void setMaxHeightEq(const std::string& maxHeightEq);
    Sizef getMinSize() const;
    Sizef getMaxSize() const;
    Sizef getMinSizePx() const;
    Sizef getMaxSizePx() const;
    Sizef fitMinMaxSizeDp(const Sizef& size) const;
    Sizef fitMinMaxSizePx(const Sizef& size) const;
    virtual bool isScrollable() const;
    static UIWidget* New();
    static UIWidget* NewWithTag(const std::string& tag);
    virtual Uint32 getType() const;
    virtual bool isType(const Uint32& type) const;
    virtual UINode* setFlags(const Uint32& flags);
    virtual UINode* unsetFlags(const Uint32& flags);
    virtual UIWidget* setAnchors(const Uint32& flags);
    virtual void setTheme(UITheme* Theme);
    virtual UINode* setThemeSkin(const std::string& skinName);
    virtual UINode* setThemeSkin(UITheme* Theme, const std::string& skinName);
    virtual Node* setId(const std::string& id);
    virtual bool acceptsDropOfWidget(const UIWidget* widget);
    UIWidget* acceptsDropOfWidgetInTree(const UIWidget* widget);
    UITooltip* getTooltip();
    void tooltipRemove();
    UIWidget* setTooltipText(const String& text);
    String getTooltipText();
    void updateAnchorsDistances();
    const Rectf& getLayoutMargin() const;
    const Rectf& getLayoutPixelsMargin() const;
    UIWidget* setLayoutMargin(const Rectf& margin);
    UIWidget* setLayoutMarginLeft(const Float& marginLeft);
    UIWidget* setLayoutMarginRight(const Float& marginRight);
    UIWidget* setLayoutMarginTop(const Float& marginTop);
    UIWidget* setLayoutMarginBottom(const Float& marginBottom);
    UIWidget* setLayoutPixelsMargin(const Rectf& margin);
    UIWidget* setLayoutPixelsMarginLeft(const Float& marginLeft);
    UIWidget* setLayoutPixelsMarginRight(const Float& marginRight);
    UIWidget* setLayoutPixelsMarginTop(const Float& marginTop);
    UIWidget* setLayoutPixelsMarginBottom(const Float& marginBottom);
    Float getLayoutWeight() const;
    UIWidget* setLayoutWeight(const Float& weight);
    Uint32 getLayoutGravity() const;
    UIWidget* setLayoutGravity(const Uint32& layoutGravity);
    const SizePolicy& getLayoutWidthPolicy() const;
    UIWidget* setLayoutWidthPolicy(const SizePolicy& widthPolicy);
    const SizePolicy& getLayoutHeightPolicy() const;
    UIWidget* setLayoutHeightPolicy(const SizePolicy& heightPolicy);
    UIWidget* setLayoutSizePolicy(const SizePolicy& widthPolicy, const SizePolicy& heightPolicy);
    UIWidget* setLayoutPositionPolicy(const PositionPolicy& layoutPositionPolicy, UIWidget* of);
    UIWidget* getLayoutPositionPolicyWidget() const;
    PositionPolicy getLayoutPositionPolicy() const;
    virtual void loadFromXmlNode(const pugi::xml_node& node);
    void notifyLayoutAttrChange();
    void notifyLayoutAttrChangeParent();
    void setStyleSheetInlineProperty(const std::string& name, const std::string& value, const Uint32& specificity = UINT32_MAX - 1);
    virtual bool applyProperty(const StyleSheetProperty& attribute);
    const Rectf& getPadding() const;
    virtual const Rectf& getPixelsPadding() const;
    UIWidget* setPadding(const Rectf& padding);
    UIWidget* setPaddingLeft(const Float& paddingLeft);
    UIWidget* setPaddingRight(const Float& paddingRight);
    UIWidget* setPaddingTop(const Float& paddingTop);
    UIWidget* setPaddingBottom(const Float& paddingBottom);
    UIWidget* setPaddingPixels(const Rectf& padding);
    UIWidget* setPaddingPixelsLeft(const Float& paddingLeft);
    UIWidget* setPaddingPixelsRight(const Float& paddingRight);
    UIWidget* setPaddingPixelsTop(const Float& paddingTop);
    UIWidget* setPaddingPixelsBottom(const Float& paddingBottom);
    const std::string& getStyleSheetTag() const;
    const std::string& getStyleSheetId() const;
    const std::vector<std::string>& getStyleSheetClasses() const;
    UIWidget* getStyleSheetParentElement() const;
    UIWidget* getStyleSheetPreviousSiblingElement() const;
    UIWidget* getStyleSheetNextSiblingElement() const;
    const std::vector<std::string>& getStyleSheetPseudoClasses() const;
    UIWidget* resetClass();
    UIWidget* setClass(const std::string& cls);
    UIWidget* setClass(std::string&& cls);
    UIWidget* setClasses(const std::vector<std::string>& classes);
    UIWidget* addClass(const std::string& cls);
    UIWidget* addClasses(const std::vector<std::string>& classes);
    UIWidget* removeClass(const std::string& cls);
    UIWidget* removeClasses(const std::vector<std::string>& classes);
    bool hasClass(const std::string_view& cls) const;
    void toggleClass(const std::string& cls);
    void setElementTag(const std::string& tag);
    const std::vector<std::string>& getClasses() const;
    const std::string& getElementTag() const;
    virtual void pushState(const Uint32& State, bool emitEvent = true);
    virtual void popState(const Uint32& State, bool emitEvent = true);
    UIStyle* getUIStyle() const;
    void reloadStyle(const bool& reloadChilds = true, const bool& disableAnimations = false, const bool& reportStateChange = true, const bool& forceReApplyProperties = false);
    void beginAttributesTransaction();
    void endAttributesTransaction();
    const Uint32& getStyleState() const;
    const Uint32& getStylePreviousState() const;
    std::vector<UIWidget*> findAllByClass(const std::string& className);
    std::vector<UIWidget*> findAllByTag(const std::string& tag);
    UIWidget* findByClass(const std::string& className);

    template <typename T>
    T* findByClass(const std::string& className);

    UIWidget* findByTag(const std::string& tag);

    template <typename T>
    T* findByTag(const std::string& tag);

    UIWidget* querySelector(const CSS::StyleSheetSelector& selector);
    UIWidget* querySelector(const std::string& selector);

    template <typename T>
    T* querySelector(const std::string& selector);

    std::vector<UIWidget*> querySelectorAll(const CSS::StyleSheetSelector& selector);
    std::vector<UIWidget*> querySelectorAll(const std::string& selector);
    std::string getPropertyString(const std::string& property) const;
    virtual std::string getPropertyString(const PropertyDefinition* propertyDef, const Uint32& propertyIndex = 0) const;
    virtual std::vector<PropertyId> getPropertiesImplemented() const;
    bool isSceneNodeLoading() const;
    void reportStyleStateChangeRecursive(bool disableAnimations = false, bool forceReApplyStyles = false);
    UITooltip* createTooltip();
    bool isTabStop() const;
    void setTabStop();
    void unsetTabStop();
    bool isTabFocusable() const;
    void setTabFocusable();
    void unsetTabFocusable();
    UIWidget* getPrevTabWidget() const;
    UIWidget* getNextTabWidget() const;
    bool hasPseudoClass(const std::string& pseudoCls) const;
    bool isTooltipEnabled() const;
    void setTooltipEnabled(bool enabled);
    UIWidget* getPrevWidget() const;
    UIWidget* getNextWidget() const;
    String getTranslatorString(const std::string& str);
    String getTranslatorString(const std::string& str, const String& defaultValue);
    String i18n(const std::string& str);
    String i18n(const std::string& str, const String& defaultValue);

Detailed Documentation

Methods

void setOwnerNode(UIWidget* ownerNode)

The owner node is the node who triggers the visibility of the menu