class EE::UI::UIDropDownList

#include <uidropdownlist.hpp>

class UIDropDownList: public EE::UI::UITextInput {
public:
    // classes

    class StyleConfig;

    // construction

    UIDropDownList(const std::string& tag = "dropdownlist");
    virtual ~UIDropDownList();

    // methods

    static UIDropDownList* NewWithTag(const std::string& tag);
    static UIDropDownList* New();
    virtual Uint32 getType() const;
    virtual bool isType(const Uint32& type) const;
    virtual void setTheme(UITheme* Theme);
    UIListBox* getListBox() const;
    void showList();
    bool getPopUpToRoot() const;
    void setPopUpToRoot(bool popUpToRoot);
    Uint32 getMaxNumVisibleItems() const;
    void setMaxNumVisibleItems(const Uint32& maxNumVisibleItems);
    const StyleConfig& getStyleConfig() const;
    void setStyleConfig(const StyleConfig& styleConfig);
    virtual bool applyProperty(const StyleSheetProperty& attribute);
    virtual std::string getPropertyString(const PropertyDefinition* propertyDef, const Uint32& propertyIndex = 0) const;
    virtual std::vector<PropertyId> getPropertiesImplemented() const;
    virtual void loadFromXmlNode(const pugi::xml_node& node);
};

Inherited Members

public:
    // typedefs

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

    // structs

    struct SelPosCache;

    // 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);
    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 Uint32& uniqueIdentifier = 0);
    void setTimeout(Actions::Runnable::RunnableFunc runnable, const Time& delay = Seconds(0), const Uint32& uniqueIdentifier = 0);
    void debounce(Actions::Runnable::RunnableFunc runnable, const Time& delay, const Uint32& uniqueIdentifier);
    void setInterval(Actions::Runnable::RunnableFunc runnable, const Time& interval, const Uint32& 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* 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& 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);
    static UITextView* New();
    static UITextView* NewWithTag(const std::string& tag);
    virtual Uint32 getType() const;
    virtual bool isType(const Uint32& type) const;
    virtual void draw();
    Graphics::Font* getFont() const;
    UITextView* setFont(Graphics::Font* font);
    Uint32 getFontSize() const;
    UITextView* setFontSize(const Uint32& characterSize);
    const Uint32& getFontStyle() const;
    UITextView* setFontStyle(const Uint32& fontStyle);
    const Float& getOutlineThickness() const;
    UITextView* setOutlineThickness(const Float& outlineThickness);
    const Color& getOutlineColor() const;
    UITextView* setOutlineColor(const Color& outlineColor);
    virtual const String& getText() const;
    virtual UITextView* setText(const String& text);
    const Color& getFontColor() const;
    UITextView* setFontColor(const Color& color);
    const Color& getFontShadowColor() const;
    UITextView* setFontShadowColor(const Color& color);
    const Vector2f& getFontShadowOffset() const;
    UITextView* setFontShadowOffset(const Vector2f& offset);
    const Color& getSelectionBackColor() const;
    UITextView* setSelectionBackColor(const Color& color);
    virtual void setTheme(UITheme* Theme);
    Float getTextWidth();
    Float getTextHeight();
    Uint32 getNumLines();
    Vector2f getAlignOffset() const;
    virtual void wrapText(const Uint32& maxWidth);
    bool isTextSelectionEnabled() const;
    void setTextSelection(const bool& active);
    const UIFontStyleConfig& getFontStyleConfig() const;
    void setFontStyleConfig(const UIFontStyleConfig& fontStyleConfig);
    virtual bool applyProperty(const StyleSheetProperty& attribute);
    virtual std::string getPropertyString(const PropertyDefinition* propertyDef, const Uint32& propertyIndex = 0) const;
    virtual std::vector<PropertyId> getPropertiesImplemented() const;
    void setTextAlign(const Uint32& align);
    UITextView* setFontFillColor(const Color& color, Uint32 from, Uint32 to);
    const Text* getTextCache() const;
    Text* getTextCache();
    const Vector2f& getRealAlignOffset() const;
    const TextTransform::Value& getTextTransform() const;
    void setTextTransform(const TextTransform::Value& textTransform);
    virtual void loadFromXmlNode(const pugi::xml_node& node);
    UITextView* setTextOverflow(const std::string_view& textOverflow);
    const std::string& getTextOverflow() const;
    bool hasTextOverflow() const;
    bool getUsingCustomStyling() const;
    void setUsingCustomStyling(bool usingCustomStyling);
    void setWordWrap(bool set);
    bool isWordWrap() const;
    virtual void onDocumentLoaded(TextDocument*);
    virtual void onDocumentTextChanged(const DocumentContentChange&) = 0;
    virtual void onDocumentUndoRedo(const UndoRedo& eventType) = 0;
    virtual void onDocumentCursorChange(const TextPosition&) = 0;
    virtual void onDocumentInterestingCursorChange(const TextPosition&);
    virtual void onDocumentSelectionChange(const TextRange&) = 0;
    virtual void onDocumentLineCountChange(const size_t& lastCount, const size_t& newCount) = 0;
    virtual void onDocumentLineChanged(const Int64& lineIndex) = 0;
    virtual void onDocumentSaved(TextDocument*) = 0;
    virtual void onDocumentClosed(TextDocument*) = 0;
    virtual void onDocumentDirtyOnFileSystem(TextDocument*) = 0;
    virtual void onDocumentMoved(TextDocument*) = 0;
    virtual void onDocumentReloaded(TextDocument* doc);
    virtual void onDocumentReset(TextDocument*) = 0;
    virtual void onDocumentSyntaxDefinitionChange(const SyntaxDefinition&);
    virtual void onDocumentLineMove(const Int64&, const Int64&, const Int64&);
    virtual TextRange getVisibleRange() const;
    static UITextInput* New();
    static UITextInput* NewWithTag(const std::string& tag);
    virtual Uint32 getType() const;
    virtual bool isType(const Uint32& type) const;
    virtual void scheduledUpdate(const Time& time);
    virtual void draw();
    virtual void setTheme(UITheme* Theme);
    UITextInput* setAllowEditing(const bool& allow);
    const bool& isEditingAllowed() const;
    virtual const String& getText() const;
    virtual UITextView* setText(const String& text);
    virtual void wrapText(const Uint32& MaxWidth);
    UITextInput* setMaxLength(const Uint32& maxLength);
    const Uint32& getMaxLength() const;
    virtual bool applyProperty(const StyleSheetProperty& attribute);
    virtual std::string getPropertyString(const PropertyDefinition* propertyDef, const Uint32& propertyIndex = 0) const;
    virtual std::vector<PropertyId> getPropertiesImplemented() const;
    virtual UIWidget* setPadding(const Rectf& padding);
    const String& getHint() const;
    UITextInput* setHint(const String& hint);
    const Color& getHintColor() const;
    UITextInput* setHintColor(const Color& hintColor);
    const Color& getHintShadowColor() const;
    UITextInput* setHintShadowColor(const Color& shadowColor);
    const Vector2f& getHintShadowOffset() const;
    UITextInput* setHintShadowOffset(const Vector2f& shadowOffset);
    Font* getHintFont() const;
    UITextInput* setHintFont(Font* font);
    Uint32 getHintFontSize() const;
    UITextView* setHintFontSize(const Uint32& characterSize);
    const Uint32& getHintFontStyle() const;
    UITextView* setHintFontStyle(const Uint32& fontStyle);
    const Float& getHintOutlineThickness() const;
    UITextView* setHintOutlineThickness(const Float& outlineThickness);
    const Color& getHintOutlineColor() const;
    UITextView* setHintOutlineColor(const Color& outlineColor);
    void setAllowOnlyNumbers(const bool& onlyNumbers, const bool& allowFloat = false);
    bool onlyNumbersAllowed() const;
    bool floatingPointAllowed() const;
    TextDocument& getDocument();
    KeyBindings& getKeyBindings();
    size_t getMenuIconSize() const;
    void setMenuIconSize(size_t menuIconSize);
    bool getEscapePastedText() const;
    void setEscapePastedText(bool escapePastedText);
    void setHintDisplay(HintDisplay);
    HintDisplay getHintDisplay() const;
    bool getSelectAllDocOnTabNavigate() const;
    void setSelectAllDocOnTabNavigate(bool selectAllDocOnTabNavigate);