safex-webgl 1.0.0

package/dist/ui/base/UIWidget.d.ts

@@ -0,0 +1,794 @@
+import { Size } from '../../core/cocoa/Geometry';
+import { ProtectedNode } from './ProtectedNode';
+import { WidgetWebGLRenderCmd } from './UIWidgetRenderCmd';
+export declare const __LAYOUT_COMPONENT_NAME = "__ui_layout";
+export declare class Widget extends ProtectedNode {
+    _enabled: boolean;
+    _bright: boolean;
+    _touchEnabled: boolean;
+    _brightStyle: any;
+    _touchBeganPosition: any;
+    _touchMovePosition: any;
+    _touchEndPosition: any;
+    _touchEventListener: any;
+    _touchEventSelector: any;
+    _name: string;
+    _widgetType: any;
+    _actionTag: number;
+    _customSize: any;
+    _layoutParameterDictionary: any;
+    _layoutParameterType: number;
+    _focused: boolean;
+    _focusEnabled: boolean;
+    _ignoreSize: boolean;
+    _affectByClipping: boolean;
+    _sizeType: any;
+    _sizePercent: any;
+    _positionType: any;
+    _positionPercent: any;
+    _hit: boolean;
+    _nodes: any;
+    _touchListener: any;
+    _className: string;
+    _flippedX: boolean;
+    _flippedY: boolean;
+    _opacity: number;
+    _highlight: boolean;
+    _touchEventCallback: any;
+    _clickEventListener: any;
+    _propagateTouchEvents: boolean;
+    _unifySize: boolean;
+    _callbackName: any;
+    _callbackType: any;
+    _inViewRect: boolean;
+    /**
+     * <p>
+     *    When a widget lose/get focus, this method will be called. Be Caution when you provide your own version,       <br/>
+     *    you must call widget.setFocused(true/false) to change the focus state of the current focused widget;
+     * </p>
+     */
+    onFocusChanged: any;
+    /**
+     * use this function to manually specify the next focused widget regards to each direction
+     */
+    onNextFocusedWidget: any;
+    _sizeDirty: any;
+    /**
+     * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function.
+     * @function
+     */
+    constructor();
+    /**
+     * initializes state of widget. please do not call this function by yourself, you should pass the parameters to constructor to initialize it.
+     * @returns {boolean}
+     */
+    init(): boolean;
+    /**
+     * Calls updateSizeAndPosition and its parent's onEnter
+     * @override
+     */
+    onEnter(): void;
+    /**
+     * Calls unscheduleUpdate and its parent's onExit
+     * @override
+     */
+    onExit(): void;
+    /**
+     * The direct parent when it's a widget also, otherwise equals null
+     * @returns {Widget|null}
+     */
+    getWidgetParent(): Widget;
+    _updateContentSizeWithTextureSize(size: any): void;
+    _isAncestorsEnabled(): any;
+    /**
+     * Allow widget touch events to propagate to its parents. Set false will disable propagation
+     * @since v3.2
+     * @param {Boolean} isPropagate
+     */
+    setPropagateTouchEvents(isPropagate: any): void;
+    /**
+     * Return whether the widget is propagate touch events to its parents or not
+     * @since v3.2
+     * @returns {boolean}
+     */
+    isPropagateTouchEvents(): boolean;
+    /**
+     * Specify widget to swallow touches or not
+     * @since v3.2
+     * @param {Boolean} swallow
+     */
+    setSwallowTouches(swallow: any): void;
+    /**
+     * Return whether the widget is swallowing touch or not
+     * @since v3.2
+     * @returns {boolean}
+     */
+    isSwallowTouches(): any;
+    _getAncensterWidget(node: any): any;
+    _isAncestorsVisible(node: any): any;
+    /**
+     * <p>
+     *     Sets whether the widget is enabled                                                                                    <br/>
+     *     true if the widget is enabled, widget may be touched , false if the widget is disabled, widget cannot be touched.     <br/>
+     *     The default value is true, a widget is default to enabled
+     * </p>
+     * @param {Boolean} enabled
+     */
+    setEnabled(enabled: any): void;
+    /**
+     * initializes renderer of widget.
+     */
+    _initRenderer(): void;
+    /**
+     * Sets _customSize of Widget, if ignoreSize is true, the content size is its renderer's contentSize, otherwise the content size is parameter.
+     * and updates size percent by parent content size. At last, updates its children's size and position.
+     * @param {Size|Number} contentSize content size or width of content size
+     * @param {Number} [height]
+     * @override
+     */
+    setContentSize(contentSize: Size | number, height?: any): void;
+    _setWidth(w: any): void;
+    _setHeight(h: any): void;
+    /**
+     * Changes the percent that is widget's percent size
+     * @param {Point} percent that is widget's percent size, width and height value from 0 to 1.
+     */
+    setSizePercent(percent: any): void;
+    _setWidthPercent(percent: any): void;
+    _setHeightPercent(percent: any): void;
+    /**
+     * updates its size by size type and its position by position type.
+     * @param {Size} [parentSize] parent size
+     */
+    updateSizeAndPosition(parentSize?: any): void;
+    /**TEXTURE_RES_TYPE
+     * Changes the size type of widget.
+     * @param {Widget.SIZE_ABSOLUTE|Widget.SIZE_PERCENT} type that is widget's size type
+     */
+    setSizeType(type: any): void;
+    /**
+     * Gets the size type of widget.
+     * @returns {Widget.SIZE_ABSOLUTE|Widget.SIZE_PERCENT} that is widget's size type
+     */
+    getSizeType(): any;
+    /**
+     * Ignore the widget size
+     * @param {Boolean} ignore true that widget will ignore it's size, use texture size, false otherwise. Default value is true.
+     */
+    ignoreContentAdaptWithSize(ignore: any): void;
+    /**
+     * Gets whether ignore the content size (custom size)
+     * @returns {boolean}  true that widget will ignore it's size, use texture size, false otherwise.
+     */
+    isIgnoreContentAdaptWithSize(): boolean;
+    /**
+     * Get custom size of Widget
+     * @returns {Size}
+     */
+    getCustomSize(): import("../..")._Size;
+    /**
+     * Gets layout size of Widget.
+     * @returns {Size}
+     */
+    getLayoutSize(): import("../..")._Size;
+    /**
+     * Returns size percent of Widget
+     * @returns {Point}
+     */
+    getSizePercent(): any;
+    _getWidthPercent(): any;
+    _getHeightPercent(): any;
+    /**
+     *  Gets world position of Widget.
+     * @returns {Point} world position of Widget.
+     */
+    getWorldPosition(): {
+        x: any;
+        y: any;
+    };
+    /**
+     * Gets the Virtual Renderer of widget.
+     * @returns {Widget}
+     */
+    getVirtualRenderer(): this;
+    /**
+     * Gets the content size of widget.  Content size is widget's texture size.
+     */
+    getVirtualRendererSize(): import("../..")._Size;
+    /**
+     * call back function called when size changed.
+     */
+    _onSizeChanged(): void;
+    /**
+     * Sets whether the widget is touch enabled. The default value is false, a widget is default to touch disabled
+     * @param {Boolean} enable  true if the widget is touch enabled, false if the widget is touch disabled.
+     */
+    setTouchEnabled(enable: any): void;
+    /**
+     * Returns whether or not touch is enabled.
+     * @returns {boolean} true if the widget is touch enabled, false if the widget is touch disabled.
+     */
+    isTouchEnabled(): boolean;
+    /**
+     * Determines if the widget is highlighted
+     * @returns {boolean} true if the widget is highlighted, false if the widget is not highlighted .
+     */
+    isHighlighted(): boolean;
+    /**
+     * Sets whether the widget is highlighted. The default value is false, a widget is default to not highlighted
+     * @param highlight true if the widget is highlighted, false if the widget is not highlighted.
+     */
+    setHighlighted(highlight: any): void;
+    /**
+     * Determines if the widget is on focused
+     * @returns {boolean} whether the widget is focused or not
+     */
+    isFocused(): boolean;
+    /**
+     * Sets whether the widget is on focused
+     * The default value is false, a widget is default to not on focused
+     * @param {boolean} focus  pass true to let the widget get focus or pass false to let the widget lose focus
+     */
+    setFocused(focus: any): void;
+    /**
+     * returns whether the widget could accept focus.
+     * @returns {boolean} true represent the widget could accept focus, false represent the widget couldn't accept focus
+     */
+    isFocusEnabled(): boolean;
+    /**
+     * sets whether the widget could accept focus.
+     * @param {Boolean} enable true represent the widget could accept focus, false represent the widget couldn't accept focus
+     */
+    setFocusEnabled(enable: any): void;
+    /**
+     * <p>
+     *     When a widget is in a layout, you could call this method to get the next focused widget within a specified direction. <br/>
+     *     If the widget is not in a layout, it will return itself
+     * </p>
+     * @param direction the direction to look for the next focused widget in a layout
+     * @param current  the current focused widget
+     * @return  the next focused widget in a layout
+     */
+    findNextFocusedWidget(direction: any, current: any): any;
+    /**
+     * when a widget calls this method, it will get focus immediately.
+     */
+    requestFocus(): void;
+    /**
+     * no matter what widget object you call this method on , it will return you the exact one focused widget
+     */
+    getCurrentFocusedWidget(): any;
+    /**
+     * Sends the touch event to widget's parent, its subclass will override it, e.g. ScrollView, PageView
+     * @param {Number}  eventType
+     * @param {Widget} sender
+     * @param {Touch} touch
+     */
+    interceptTouchEvent(eventType: any, sender: any, touch: any): void;
+    /**
+     * This method is called when a focus change event happens
+     * @param {Widget} widgetLostFocus
+     * @param {Widget} widgetGetFocus
+     */
+    onFocusChange(widgetLostFocus: any, widgetGetFocus: any): void;
+    /**
+     * Dispatch a EventFocus through a EventDispatcher
+     * @param {Widget} widgetLostFocus
+     * @param {Widget} widgetGetFocus
+     */
+    dispatchFocusEvent(widgetLostFocus: any, widgetGetFocus: any): void;
+    /**
+     *  Sets whether the widget is bright. The default value is true, a widget is default to bright
+     * @param {Boolean} bright true if the widget is bright, false if the widget is dark.
+     */
+    setBright(bright: any): void;
+    /**
+     * To set the bright style of Widget.
+     * @param {Number} style BRIGHT_NORMAL the widget is normal state, BRIGHT_HIGHLIGHT the widget is height light state.
+     */
+    setBrightStyle(style: any): void;
+    _onPressStateChangedToNormal(): void;
+    _onPressStateChangedToPressed(): void;
+    _onPressStateChangedToDisabled(): void;
+    _updateChildrenDisplayedRGBA(): void;
+    /**
+     * A call back function when widget lost of focus.
+     */
+    didNotSelectSelf(): void;
+    /**
+     * <p>
+     *    The callback of touch began event.                                                               <br/>
+     *    If the bounding box of Widget contains the touch point, it will do the following things:    <br/>
+     *      1. sets highlight state,                                                                       <br/>
+     *      2. sends event to parent widget by interceptTouchEvent                                         <br/>
+     *      3. calls the callback of touch began event.                                                    <br/>
+     *      4. returns true,                                                                               <br/>
+     *    otherwise returns false directly.                                                                <br/>
+     * </p>
+     * @override
+     * @param {Touch} touch
+     * @param {Event} event
+     * @returns {boolean}
+     */
+    onTouchBegan(touch: any, event: any): boolean;
+    propagateTouchEvent(event: any, sender: any, touch: any): void;
+    /**
+     * <p>
+     *    The callback of touch moved event.                                                                                                <br/>
+     *    It sets the highlight state by touch, sends event to parent widget by interceptTouchEvent and calls the callback of touch moved event.
+     * </p>
+     * @param {Touch} touch
+     * @param {Event} event
+     */
+    onTouchMoved(touch: any, event: any): void;
+    /**
+     * <p>
+     *      The callback of touch end event
+     *      It sends event to parent widget by interceptTouchEvent,
+     *      calls the callback of touch end event (highlight= true) or touch canceled event (highlight= false).
+     *      sets the highlight state to false ,
+     * </p>
+     * @param touch
+     * @param event
+     */
+    onTouchEnded(touch: any, event: any): void;
+    /**
+     * A call back function called when widget is selected, and on touch canceled.
+     * @param {Point} touchPoint
+     */
+    onTouchCancelled(touchPoint: any, event?: any): void;
+    /**
+     * A call back function called when widget is selected, and on touch long clicked.
+     * @param {Point} touchPoint
+     */
+    onTouchLongClicked(touchPoint: any): void;
+    _pushDownEvent(): void;
+    _moveEvent(): void;
+    _releaseUpEvent(): void;
+    _cancelUpEvent(): void;
+    longClickEvent(): void;
+    /**
+     * Sets the touch event target/selector of the Widget
+     * @param {Function} selector
+     * @param {Object} target
+     */
+    addTouchEventListener(selector: any, target?: any): void;
+    addClickEventListener(callback: any): void;
+    /**
+     * Checks a point if is in widget's space
+     * @param {Point} pt
+     * @returns {boolean} true if the point is in widget's space, false otherwise.
+     */
+    hitTest(pt: any): boolean;
+    /**
+     * returns whether clipping parent widget contains point.
+     * @param {Point} pt location point
+     * @returns {Boolean}
+     */
+    isClippingParentContainsPoint(pt: any): any;
+    /**
+     * Calls the checkChildInfo of widget's parent, its subclass will override it.
+     * @param {number} handleState
+     * @param {Widget} sender
+     * @param {Point} touchPoint
+     */
+    checkChildInfo(handleState: any, sender: any, touchPoint: any): void;
+    /**
+     * Changes the position (x,y) of the widget .
+     * The original point (0,0) is at the left-bottom corner of screen.
+     * @override
+     * @param {Point|Number} pos
+     * @param {Number} [posY]
+     */
+    setPosition(pos: any, posY?: any): void;
+    setPositionX(x: any): void;
+    setPositionY(y: any): void;
+    /**
+     * Changes the position (x,y) of the widget
+     * @param {Point} percent
+     */
+    setPositionPercent(percent: any): void;
+    _setXPercent(percent: any): void;
+    _setYPercent(percent: any): void;
+    /**
+     * Gets the percent (x,y) of the widget
+     * @returns {Point} The percent (x,y) of the widget in OpenGL coordinates
+     */
+    getPositionPercent(): import("../..").Point;
+    _getXPercent(): any;
+    _getYPercent(): any;
+    /**
+     * Changes the position type of the widget
+     * @param {Number} type  the position type of widget
+     */
+    setPositionType(type: any): void;
+    /**
+     * Gets the position type of the widget
+     * @returns {Number} the position type of widget
+     */
+    getPositionType(): any;
+    /**
+     * Sets whether the widget should be flipped horizontally or not.
+     * @param {Boolean} flipX true if the widget should be flipped horizontally, false otherwise.
+     */
+    setFlippedX(flipX: any): void;
+    /**
+     * <p>
+     *   Returns the flag which indicates whether the widget is flipped horizontally or not.             <br/>
+     *   It only flips the texture of the widget, and not the texture of the widget's children.          <br/>
+     *   Also, flipping the texture doesn't alter the anchorPoint.                                       <br/>
+     *   If you want to flip the anchorPoint too, and/or to flip the children too use:                   <br/>
+     *   widget.setScaleX(sprite.getScaleX() * -1);
+     * </p>
+     * @returns {Boolean} true if the widget is flipped horizontally, false otherwise.
+     */
+    isFlippedX(): boolean;
+    /**
+     * Sets whether the widget should be flipped vertically or not.
+     * @param {Boolean} flipY  true if the widget should be flipped vertically, false otherwise.
+     */
+    setFlippedY(flipY: any): void;
+    /**
+     * <p>
+     *     Return the flag which indicates whether the widget is flipped vertically or not.                <br/>
+     *     It only flips the texture of the widget, and not the texture of the widget's children.          <br/>
+     *     Also, flipping the texture doesn't alter the anchorPoint.                                       <br/>
+     *     If you want to flip the anchorPoint too, and/or to flip the children too use:                   <br/>
+     *     widget.setScaleY(widget.getScaleY() * -1);
+     * </p>
+     * @returns {Boolean} true if the widget is flipped vertically, false otherwise.
+     */
+    isFlippedY(): boolean;
+    _adaptRenderers(): void;
+    /**
+     * Determines if the widget is bright
+     * @returns {boolean} true if the widget is bright, false if the widget is dark.
+     */
+    isBright(): boolean;
+    /**
+     * Determines if the widget is enabled
+     * @returns {boolean}
+     */
+    isEnabled(): boolean;
+    /**
+     * Gets the left boundary position of this widget.
+     * @returns {number}
+     */
+    getLeftBoundary(): number;
+    /**
+     * Gets the bottom boundary position of this widget.
+     * @returns {number}
+     */
+    getBottomBoundary(): number;
+    /**
+     * Gets the right boundary position of this widget.
+     * @returns {number}
+     */
+    getRightBoundary(): number;
+    /**
+     * Gets the top boundary position of this widget.
+     * @returns {number}
+     */
+    getTopBoundary(): number;
+    /**
+     * Gets the position of touch began event.
+     * @returns {Point}
+     */
+    getTouchBeganPosition(): import("../..").Point;
+    /**
+     * Gets the position of touch moved event
+     * @returns {Point}
+     */
+    getTouchMovePosition(): import("../..").Point;
+    /**
+     * Gets the position of touch end event
+     * @returns {Point}
+     */
+    getTouchEndPosition(): import("../..").Point;
+    /**
+     * get widget type
+     * @returns {Widget.TYPE_WIDGET|Widget.TYPE_CONTAINER}
+     */
+    getWidgetType(): any;
+    /**
+     * Gets LayoutParameter of widget.
+     * @param {LayoutParameter} parameter
+     */
+    setLayoutParameter(parameter: any): void;
+    /**
+     * Gets layout parameter
+     * @param {LayoutParameter.NONE|LayoutParameter.LINEAR|LayoutParameter.RELATIVE} type
+     * @returns {LayoutParameter}
+     */
+    getLayoutParameter(type?: any): any;
+    /**
+     * Returns the "class name" of widget.
+     * @returns {string}
+     */
+    getDescription(): string;
+    /**
+     * Clones a new widget.
+     * @returns {Widget}
+     */
+    clone(): Widget;
+    _createCloneInstance(): Widget;
+    _copyClonedWidgetChildren(model: any): void;
+    _copySpecialProperties(model: any): void;
+    _copyProperties(widget: any): void;
+    setActionTag(tag: any): void;
+    getActionTag(): number;
+    /**
+     * Gets the left boundary position of this widget.
+     * @deprecated since v3.0, please use getLeftBoundary instead.
+     * @returns {number}
+     */
+    getLeftInParent(): number;
+    /**
+     * Gets the bottom boundary position of this widget.
+     * @deprecated since v3.0, please use getBottomBoundary instead.
+     * @returns {number}
+     */
+    getBottomInParent(): number;
+    /**
+     * Gets the right boundary position of this widget.
+     * @deprecated since v3.0, please use getRightBoundary instead.
+     * @returns {number}
+     */
+    getRightInParent(): number;
+    /**
+     * Gets the top boundary position of this widget.
+     * @deprecated since v3.0, please use getTopBoundary instead.
+     * @returns {number}
+     */
+    getTopInParent(): number;
+    /**
+     * Gets the touch end point of widget when widget is selected.
+     * @deprecated since v3.0, please use getTouchEndPosition instead.
+     * @returns {Point} the touch end point.
+     */
+    getTouchEndPos(): import("../..").Point;
+    /**
+     *Gets the touch move point of widget when widget is selected.
+     * @deprecated since v3.0, please use getTouchMovePosition instead.
+     * @returns {Point} the touch move point.
+     */
+    getTouchMovePos(): import("../..").Point;
+    /**
+     * Checks a point if in parent's area.
+     * @deprecated since v3.0, please use isClippingParentContainsPoint instead.
+     * @param {Point} pt
+     * @returns {Boolean}
+     */
+    clippingParentAreaContainPoint(pt: any): void;
+    /**
+     * Gets the touch began point of widget when widget is selected.
+     * @deprecated since v3.0, please use getTouchBeganPosition instead.
+     * @returns {Point} the touch began point.
+     */
+    getTouchStartPos(): import("../..").Point;
+    /**
+     * Changes the size that is widget's size
+     * @deprecated since v3.0, please use setContentSize instead.
+     * @param {Size} size  that is widget's size
+     */
+    setSize(size: any): void;
+    /**
+     * Returns size of widget
+     * @deprecated since v3.0, please use getContentSize instead.
+     * @returns {Size}
+     */
+    getSize(): import("../..")._Size;
+    /**
+     * Adds a node for widget (this function is deleted in -x)
+     * @param {Node} node
+     * @param {Number} zOrder
+     * @param {Number} tag
+     * @deprecated since v3.0, please use addChild instead.
+     */
+    addNode(node: any, zOrder: any, tag: any): void;
+    /**
+     * Gets node by tag
+     * @deprecated since v3.0, please use getChildByTag instead.
+     * @param {Number} tag
+     * @returns {Node}
+     */
+    getNodeByTag(tag: any): any;
+    /**
+     * Returns all children.
+     * @deprecated since v3.0, please use getChildren instead.
+     * @returns {Array}
+     */
+    getNodes(): any;
+    /**
+     * Removes a node from Widget
+     * @deprecated since v3.0, please use removeChild instead.
+     * @param {Node} node
+     * @param {Boolean} cleanup
+     */
+    removeNode(node: any, cleanup: any): void;
+    _getNormalGLProgram(): import("../../shaders").GLProgram;
+    _getGrayGLProgram(): import("../../shaders").GLProgram;
+    /**
+     * Removes node by tag
+     * @deprecated since v3.0, please use removeChildByTag instead.
+     * @param {Number} tag
+     * @param {Boolean} [cleanup]
+     */
+    removeNodeByTag(tag: any, cleanup: any): void;
+    /**
+     * Removes all node
+     * @deprecated since v3.0, please use removeAllChildren instead.
+     */
+    removeAllNodes(): void;
+    _findLayout(): void;
+    /**
+     * @since v3.2
+     * @returns {boolean} true represent the widget use Unify Size, false represent the widget couldn't use Unify Size
+     */
+    isUnifySizeEnabled(): boolean;
+    /**
+     * @since v3.2
+     * @param {Boolean} enable enable Unify Size of a widget
+     */
+    setUnifySizeEnabled(enable: any): void;
+    setScaleX(scaleX: any): void;
+    setScaleY(scaleY: any): void;
+    setScale(scaleX: any, scaleY: any): void;
+    getScaleX(): any;
+    getScaleY(): any;
+    getScale(): any;
+    /**
+     * Sets callback name to widget.
+     * @since v3.3
+     * @param {String} callbackName
+     */
+    setCallbackName(callbackName: any): void;
+    /**
+     * Gets callback name of widget
+     * @since v3.3
+     * @returns {String|Null}
+     */
+    getCallbackName(): any;
+    /**
+     * Sets callback type to widget
+     * @since v3.3
+     * @param {String} callbackType
+     */
+    setCallbackType(callbackType: any): void;
+    /**
+     * Gets callback type of widget
+     * @since v3.3
+     * @returns {String|null}
+     */
+    getCallbackType(): any;
+    _createRenderCmd(): WidgetWebGLRenderCmd;
+    static _focusedWidget: any;
+    static _focusNavigationController: any;
+    /**
+     * call this method with parameter true to enable the Android Dpad focus navigation feature
+     * @note it doesn't implemented on Web
+     * @param {Boolean} enable set true to enable dpad focus navigation, otherwise disable dpad focus navigation
+     */
+    static enableDpadNavigation(enable: any): void;
+    /**
+     * Gets the focused widget of current stage.
+     * @function
+     * @returns {null|Widget}
+     */
+    static getCurrentFocusedWidget(): any;
+    /**
+     * None bright style of Widget.
+     * @constant
+     * @type {number}
+     */
+    static BRIGHT_STYLE_NONE: number;
+    /**
+     * Normal bright style of Widget.
+     * @constant
+     * @type {number}
+     */
+    static BRIGHT_STYLE_NORMAL: number;
+    /**
+     * Light bright style of Widget.
+     * @constant
+     * @type {number}
+     */
+    static BRIGHT_STYLE_HIGH_LIGHT: number;
+    /**
+     * The type code of Widget for ccui controls.
+     * @constant
+     * @type {number}
+     */
+    static TYPE_WIDGET: number;
+    /**
+     * The type code of Container for ccui controls.
+     * @constant
+     * @type {number}
+     */
+    static TYPE_CONTAINER: number;
+    /**
+     * The left of Focus direction for Widget
+     * @constant
+     * @type {number}
+     */
+    static LEFT: number;
+    /**
+     * The right of Focus direction for Widget
+     * @constant
+     * @type {number}
+     */
+    static RIGHT: number;
+    /**
+     * The up of Focus direction for Widget
+     * @constant
+     * @type {number}
+     */
+    static UP: number;
+    /**
+     * The down of Focus direction for Widget
+     * @constant
+     * @type {number}
+     */
+    static DOWN: number;
+    /**
+     * The image file texture type of Widget loads.
+     * @constant
+     * @type {number}
+     */
+    static LOCAL_TEXTURE: number;
+    /**
+     * The sprite frame texture type of Widget loads.
+     * @constant
+     * @type {number}
+     */
+    static PLIST_TEXTURE: number;
+    /**
+     * The touch began type of Widget's touch event
+     * @constant
+     * @type {number}
+     */
+    static TOUCH_BEGAN: number;
+    /**
+     * The touch moved type of Widget's touch event
+     * @constant
+     * @type {number}
+     */
+    static TOUCH_MOVED: number;
+    /**
+     * The touch end type of Widget's touch event
+     * @constant
+     * @type {number}
+     */
+    static TOUCH_ENDED: number;
+    /**
+     * The touch canceled type of Widget's touch event
+     * @constant
+     * @type {number}
+     */
+    static TOUCH_CANCELED: number;
+    /**
+     * The absolute of Widget's size type.
+     * @constant
+     * @type {number}
+     */
+    static SIZE_ABSOLUTE: number;
+    /**
+     * The percent of Widget's size type.
+     * @constant
+     * @type {number}
+     */
+    static SIZE_PERCENT: number;
+    /**
+     * The absolute of Widget's position type.
+     * @constant
+     * @type {number}
+     */
+    static POSITION_ABSOLUTE: number;
+    /**
+     * The percent of Widget's position type.
+     * @constant
+     * @type {number}
+     */
+    static POSITION_PERCENT: number;
+}
+//# sourceMappingURL=UIWidget.d.ts.map