ET/Unity/Packages/FairyGUI/Scripts/UI/GObject.cs

using System;
using UnityEngine;
using FairyGUI.Utils;

namespace FairyGUI
{
    public class GObject : EventDispatcher
    {
        /// <summary>
        /// GObject的id，仅作为内部使用。与name不同，id值是不会相同的。
        /// id is for internal use only.
        /// </summary>
        public string id { get; private set; }

        /// <summary>
        /// Name of the object.
        /// </summary>
        public string name;

        /// <summary>
        /// User defined data. 
        /// </summary>
        public object data;

        /// <summary>
        /// The source width of the object.
        /// </summary>
        public int sourceWidth;

        /// <summary>
        /// The source height of the object.
        /// </summary>
        public int sourceHeight;

        /// <summary>
        /// The initial width of the object.
        /// </summary>
        public int initWidth;

        /// <summary>
        /// The initial height of the object.
        /// </summary>
        public int initHeight;

        /// <summary>
        /// 
        /// </summary>
        public int minWidth;

        /// <summary>
        /// 
        /// </summary>
        public int maxWidth;

        /// <summary>
        /// 
        /// </summary>
        public int minHeight;

        /// <summary>
        /// 
        /// </summary>
        public int maxHeight;

        /// <summary>
        /// Relations Object.
        /// </summary>
        public Relations relations { get; private set; }

        /// <summary>
        /// Restricted range of dragging.
        /// </summary>
        public Rect? dragBounds;

        /// <summary>
        /// Parent object.
        /// </summary>
        public GComponent parent { get; private set; }

        /// <summary>
        /// Lowlevel display object.
        /// </summary>
        public DisplayObject displayObject { get; protected set; }

        /// <summary>
        /// 当前全局正在被拖动的对象
        /// </summary>
        public static GObject draggingObject { get; private set; }

        /// <summary>
        /// 
        /// </summary>
        public PackageItem packageItem;

        float _x;
        float _y;
        float _z;
        float _pivotX;
        float _pivotY;
        bool _pivotAsAnchor;
        float _alpha;
        float _rotation;
        float _rotationX;
        float _rotationY;
        bool _visible;
        bool _internalVisible;
        bool _handlingController;
        bool _touchable;
        bool _grayed;
        bool _draggable;
        float _scaleX;
        float _scaleY;
        int _sortingOrder;
        string _tooltips;
        GGroup _group;

        GearBase[] _gears;

        EventListener _onClick;
        EventListener _onRightClick;
        EventListener _onTouchBegin;
        EventListener _onTouchMove;
        EventListener _onTouchEnd;
        EventListener _onRollOver;
        EventListener _onRollOut;
        EventListener _onAddedToStage;
        EventListener _onRemovedFromStage;
        EventListener _onKeyDown;
        EventListener _onClickLink;
        EventListener _onPositionChanged;
        EventListener _onSizeChanged;
        EventListener _onDragStart;
        EventListener _onDragMove;
        EventListener _onDragEnd;
        EventListener _onGearStop;
        EventListener _onFocusIn;
        EventListener _onFocusOut;

        internal protected bool underConstruct;
        internal float _width;
        internal float _height;
        internal float _rawWidth;
        internal float _rawHeight;
        internal bool _gearLocked;
        internal float _sizePercentInGroup;
        internal bool _disposed;
        internal GTreeNode _treeNode;

        internal static uint _gInstanceCounter;

        public GObject()
        {
            _width = 0;
            _height = 0;
            _alpha = 1;
            _visible = true;
            _touchable = true;
            _scaleX = 1;
            _scaleY = 1;
            _internalVisible = true;
            id = "_n" + _gInstanceCounter++;
            name = string.Empty;

            CreateDisplayObject();

            relations = new Relations(this);
            _gears = new GearBase[10];
        }

        /// <summary>
        /// Dispatched when the object or its child was clicked.
        /// </summary>
        public EventListener onClick
        {
            get { return _onClick ?? (_onClick = new EventListener(this, "onClick")); }
        }

        /// <summary>
        /// Dispatched when the object or its child was clicked by right mouse button. Web only.
        /// </summary>
        public EventListener onRightClick
        {
            get { return _onRightClick ?? (_onRightClick = new EventListener(this, "onRightClick")); }
        }

        /// <summary>
        /// Dispatched when the finger touched the object or its child just now.
        /// </summary>
        public EventListener onTouchBegin
        {
            get { return _onTouchBegin ?? (_onTouchBegin = new EventListener(this, "onTouchBegin")); }
        }

        /// <summary>
        /// 
        /// </summary>
        public EventListener onTouchMove
        {
            get { return _onTouchMove ?? (_onTouchMove = new EventListener(this, "onTouchMove")); }
        }

        /// <summary>
        /// Dispatched when the finger was lifted from the screen or from the mouse button. 
        /// </summary>
        public EventListener onTouchEnd
        {
            get { return _onTouchEnd ?? (_onTouchEnd = new EventListener(this, "onTouchEnd")); }
        }

        /// <summary>
        /// The cursor or finger hovers over an object.
        /// </summary>
        public EventListener onRollOver
        {
            get { return _onRollOver ?? (_onRollOver = new EventListener(this, "onRollOver")); }
        }

        /// <summary>
        /// The cursor or finger leave an object.
        /// </summary>
        public EventListener onRollOut
        {
            get { return _onRollOut ?? (_onRollOut = new EventListener(this, "onRollOut")); }
        }

        /// <summary>
        /// Dispatched when the object was added to the stage.
        /// </summary>
        public EventListener onAddedToStage
        {
            get { return _onAddedToStage ?? (_onAddedToStage = new EventListener(this, "onAddedToStage")); }
        }

        /// <summary>
        /// Dispatched when the object was removed from the stage.
        /// </summary>
        public EventListener onRemovedFromStage
        {
            get { return _onRemovedFromStage ?? (_onRemovedFromStage = new EventListener(this, "onRemovedFromStage")); }
        }

        /// <summary>
        /// Dispatched on key pressed when the object is in focus.
        /// </summary>
        public EventListener onKeyDown
        {
            get { return _onKeyDown ?? (_onKeyDown = new EventListener(this, "onKeyDown")); }
        }

        /// <summary>
        /// Dispatched when links in the object or its child was clicked.
        /// </summary>
        public EventListener onClickLink
        {
            get { return _onClickLink ?? (_onClickLink = new EventListener(this, "onClickLink")); }
        }

        /// <summary>
        /// Dispatched when the object was moved.
        /// </summary>
        public EventListener onPositionChanged
        {
            get { return _onPositionChanged ?? (_onPositionChanged = new EventListener(this, "onPositionChanged")); }
        }

        /// <summary>
        /// Dispatched when the object was resized.
        /// </summary>
        public EventListener onSizeChanged
        {
            get { return _onSizeChanged ?? (_onSizeChanged = new EventListener(this, "onSizeChanged")); }
        }

        /// <summary>
        /// Dispatched when drag start. 
        /// </summary>
        public EventListener onDragStart
        {
            get { return _onDragStart ?? (_onDragStart = new EventListener(this, "onDragStart")); }
        }

        /// <summary>
        /// Dispatched when dragging.
        /// </summary>
        public EventListener onDragMove
        {
            get { return _onDragMove ?? (_onDragMove = new EventListener(this, "onDragMove")); }
        }

        /// <summary>
        /// Dispatched when drag end.
        /// </summary>
        public EventListener onDragEnd
        {
            get { return _onDragEnd ?? (_onDragEnd = new EventListener(this, "onDragEnd")); }
        }

        /// <summary>
        /// 
        /// </summary>
        public EventListener onGearStop
        {
            get { return _onGearStop ?? (_onGearStop = new EventListener(this, "onGearStop")); }
        }

        /// <summary>
        /// 
        /// </summary>
        public EventListener onFocusIn
        {
            get { return _onFocusIn ?? (_onFocusIn = new EventListener(this, "onFocusIn")); }
        }

        /// <summary>
        /// 
        /// </summary>
        public EventListener onFocusOut
        {
            get { return _onFocusOut ?? (_onFocusOut = new EventListener(this, "onFocusOut")); }
        }

        /// <summary>
        /// The x coordinate of the object relative to the local coordinates of the parent.
        /// </summary>
        public float x
        {
            get { return _x; }
            set
            {
                SetPosition(value, _y, _z);
            }
        }

        /// <summary>
        /// The y coordinate of the object relative to the local coordinates of the parent.
        /// </summary>
        public float y
        {
            get { return _y; }
            set
            {
                SetPosition(_x, value, _z);
            }
        }

        /// <summary>
        /// The z coordinate of the object relative to the local coordinates of the parent.
        /// </summary>
        public float z
        {
            get { return _z; }
            set
            {
                SetPosition(_x, _y, value);
            }
        }

        /// <summary>
        /// The x and y coordinates of the object relative to the local coordinates of the parent.
        /// </summary>
        public Vector2 xy
        {
            get { return new Vector2(_x, _y); }
            set { SetPosition(value.x, value.y, _z); }
        }

        /// <summary>
        /// The x,y,z coordinates of the object relative to the local coordinates of the parent.
        /// </summary>
        public Vector3 position
        {
            get { return new Vector3(_x, _y, _z); }
            set { SetPosition(value.x, value.y, value.z); }
        }

        /// <summary>
        /// change the x and y coordinates of the object relative to the local coordinates of the parent.
        /// </summary>
        /// <param name="xv">x value.</param>
        /// <param name="yv">y value.</param>
        public void SetXY(float xv, float yv)
        {
            SetPosition(xv, yv, _z);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="xv"></param>
        /// <param name="yv"></param>
        /// <param name="topLeft"></param>
        public void SetXY(float xv, float yv, bool topLeftValue)
        {
            if (_pivotAsAnchor)
                SetPosition(xv + _pivotX * _width, yv + _pivotY * _height, _z);
            else
                SetPosition(xv, yv, _z);
        }

        /// <summary>
        /// change the x,y,z coordinates of the object relative to the local coordinates of the parent.
        /// </summary>
        /// <param name="xv">x value.</param>
        /// <param name="yv">y value.</param>
        /// <param name="zv">z value.</param>
        public void SetPosition(float xv, float yv, float zv)
        {
            if (_x != xv || _y != yv || _z != zv)
            {
                float dx = xv - _x;
                float dy = yv - _y;
                _x = xv;
                _y = yv;
                _z = zv;

                HandlePositionChanged();

                if (this is GGroup)
                    ((GGroup)this).MoveChildren(dx, dy);

                UpdateGear(1);

                if (parent != null && !(parent is GList))
                {
                    parent.SetBoundsChangedFlag();
                    if (_group != null)
                        _group.SetBoundsChangedFlag(true);
                    DispatchEvent("onPositionChanged", null);
                }

                if (draggingObject == this && !sUpdateInDragging)
                    sGlobalRect = this.LocalToGlobal(new Rect(0, 0, this.width, this.height));
            }
        }

        [Obsolete("Use UIConfig.makePixelPerfect or DisplayObject.pixelPerfect")]
        public bool pixelSnapping
        {
            get { return false; }
            set { }
        }

        /// <summary>
        /// Set the object in middle of the parent or GRoot if the parent is not set.
        /// </summary>
        public void Center()
        {
            Center(false);
        }

        /// <summary>
        /// Set the object in middle of the parent or GRoot if the parent is not set.
        /// </summary>
        /// <param name="restraint">Add relations to maintain the center state.</param>
        public void Center(bool restraint)
        {
            GComponent r;
            if (parent != null)
                r = parent;
            else
                r = this.root;

            this.SetXY((int)((r.width - this.width) / 2), (int)((r.height - this.height) / 2), true);
            if (restraint)
            {
                this.AddRelation(r, RelationType.Center_Center);
                this.AddRelation(r, RelationType.Middle_Middle);
            }
        }

        /// <summary>
        /// 设置对象为全屏大小（逻辑屏幕）。
        /// </summary>
        public void MakeFullScreen()
        {
            this.SetSize(GRoot.inst.width, GRoot.inst.height);
        }

        /// <summary>
        /// The width of the object in pixels.
        /// </summary>
        public float width
        {
            get
            {
                return _width;
            }
            set
            {
                SetSize(value, _rawHeight);
            }
        }

        /// <summary>
        /// The height of the object in pixels.
        /// </summary>
        public float height
        {
            get
            {
                return _height;
            }
            set
            {
                SetSize(_rawWidth, value);
            }
        }

        /// <summary>
        /// The size of the object in pixels.
        /// </summary>
        public Vector2 size
        {
            get { return new Vector2(width, height); }
            set { SetSize(value.x, value.y); }
        }

        /// <summary>
        /// actualWidth = width * scalex
        /// </summary>
        public float actualWidth
        {
            get { return this.width * _scaleX; }
        }

        /// <summary>
        /// actualHeight = height * scaleY
        /// </summary>
        public float actualHeight
        {
            get { return this.height * _scaleY; }
        }

        /// <summary>
        /// Change size.
        /// </summary>
        /// <param name="wv">Width value.</param>
        /// <param name="hv">Height value.</param>
        public void SetSize(float wv, float hv)
        {
            SetSize(wv, hv, false);
        }

        /// <summary>
        /// Change size.
        /// </summary>
        /// <param name="wv">Width value.</param>
        /// <param name="hv">Height value.</param>
        /// <param name="ignorePivot">If pivot is set, the object's positon will change when its size change. Set ignorePivot=true to keep the position.</param>
        public void SetSize(float wv, float hv, bool ignorePivot)
        {
            if (_rawWidth != wv || _rawHeight != hv)
            {
                _rawWidth = wv;
                _rawHeight = hv;
                if (wv < minWidth)
                    wv = minWidth;
                else if (maxWidth > 0 && wv > maxWidth)
                    wv = maxWidth;
                if (hv < minHeight)
                    hv = minHeight;
                else if (maxHeight > 0 && hv > maxHeight)
                    hv = maxHeight;
                float dWidth = wv - _width;
                float dHeight = hv - _height;
                _width = wv;
                _height = hv;

                HandleSizeChanged();

                if (_pivotX != 0 || _pivotY != 0)
                {
                    if (!_pivotAsAnchor)
                    {
                        if (!ignorePivot)
                            SetXY(_x - _pivotX * dWidth, _y - _pivotY * dHeight);
                        else
                            HandlePositionChanged();
                    }
                    else
                        HandlePositionChanged();
                }

                if (this is GGroup)
                    ((GGroup)this).ResizeChildren(dWidth, dHeight);

                UpdateGear(2);

                if (parent != null)
                {
                    relations.OnOwnerSizeChanged(dWidth, dHeight, _pivotAsAnchor || !ignorePivot);
                    parent.SetBoundsChangedFlag();
                    if (_group != null)
                        _group.SetBoundsChangedFlag();
                }

                DispatchEvent("onSizeChanged", null);
            }
        }

        protected void SetSizeDirectly(float wv, float hv)
        {
            _rawWidth = wv;
            _rawHeight = hv;
            if (wv < 0)
                wv = 0;
            if (hv < 0)
                hv = 0;
            _width = wv;
            _height = hv;
        }

        /// <summary>
        /// 
        /// </summary>
        public float xMin
        {
            get
            {
                return _pivotAsAnchor ? (_x - _width * _pivotX) : _x;
            }
            set
            {
                if (_pivotAsAnchor)
                    SetPosition(value + _width * _pivotX, _y, _z);
                else
                    SetPosition(value, _y, _z);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public float yMin
        {
            get
            {
                return _pivotAsAnchor ? (_y - _height * _pivotY) : _y;
            }
            set
            {
                if (_pivotAsAnchor)
                    SetPosition(_x, value + _height * _pivotY, _z);
                else
                    SetPosition(_x, value, _z);
            }
        }

        /// <summary>
        /// The horizontal scale factor. '1' means no scale, cannt be negative.
        /// </summary>
        public float scaleX
        {
            get { return _scaleX; }
            set
            {
                SetScale(value, _scaleY);
            }
        }

        /// <summary>
        /// The vertical scale factor. '1' means no scale, cannt be negative.
        /// </summary>
        public float scaleY
        {
            get { return _scaleY; }
            set
            {
                SetScale(_scaleX, value);
            }
        }

        /// <summary>
        /// The scale factor.
        /// </summary>
        public Vector2 scale
        {
            get { return new Vector2(_scaleX, _scaleY); }
            set { SetScale(value.x, value.y); }
        }

        /// <summary>
        /// Change the scale factor.
        /// </summary>
        /// <param name="wv">The horizontal scale factor.</param>
        /// <param name="hv">The vertical scale factor</param>
        public void SetScale(float wv, float hv)
        {
            if (_scaleX != wv || _scaleY != hv)
            {
                _scaleX = wv;
                _scaleY = hv;
                HandleScaleChanged();

                UpdateGear(2);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public Vector2 skew
        {
            get
            {
                if (displayObject != null)
                    return displayObject.skew;
                else
                    return Vector2.zero;
            }

            set
            {
                if (displayObject != null)
                    displayObject.skew = value;
            }
        }

        /// <summary>
        /// The x coordinate of the object's origin in its own coordinate space.
        /// </summary>
        public float pivotX
        {
            get { return _pivotX; }
            set
            {
                SetPivot(value, _pivotY, _pivotAsAnchor);
            }
        }

        /// <summary>
        /// The y coordinate of the object's origin in its own coordinate space.
        /// </summary>
        public float pivotY
        {
            get { return _pivotY; }
            set
            {
                SetPivot(_pivotX, value, _pivotAsAnchor);
            }
        }

        /// <summary>
        /// The x and y coordinates of the object's origin in its own coordinate space.
        /// </summary>
        public Vector2 pivot
        {
            get { return new Vector2(_pivotX, _pivotY); }
            set { SetPivot(value.x, value.y, _pivotAsAnchor); }
        }

        public bool pivotAsAnchor
        {
            get { return _pivotAsAnchor; }
            set
            {
                SetPivot(_pivotX, _pivotY, value);
            }
        }

        /// <summary>
        /// Change the x and y coordinates of the object's origin in its own coordinate space.
        /// </summary>
        /// <param name="xv">x value in ratio</param>
        /// <param name="yv">y value in ratio</param>
        public void SetPivot(float xv, float yv)
        {
            SetPivot(xv, yv, false);
        }

        /// <summary>
        ///  Change the x and y coordinates of the object's origin in its own coordinate space.
        /// </summary>
        /// <param name="xv">x value in ratio</param>
        /// <param name="yv">y value in ratio</param>
        /// <param name="asAnchor">If use the pivot as the anchor position</param>
        public void SetPivot(float xv, float yv, bool asAnchor)
        {
            if (_pivotX != xv || _pivotY != yv || _pivotAsAnchor != asAnchor)
            {
                _pivotX = xv;
                _pivotY = yv;
                _pivotAsAnchor = asAnchor;
                if (displayObject != null)
                    displayObject.pivot = new Vector2(_pivotX, _pivotY);
                HandlePositionChanged();
            }
        }

        /// <summary>
        /// If the object can touch or click. GImage/GTextField is not touchable even it is true.
        /// </summary>
        public bool touchable
        {
            get
            {
                return _touchable;
            }
            set
            {
                if (_touchable != value)
                {
                    _touchable = value;
                    UpdateGear(3);

                    if (displayObject != null)
                        displayObject.touchable = _touchable;
                }
            }
        }

        /// <summary>
        /// If true, apply a grayed effect on this object.
        /// </summary>
        public bool grayed
        {
            get
            {
                return _grayed;
            }
            set
            {
                if (_grayed != value)
                {
                    _grayed = value;
                    HandleGrayedChanged();
                    UpdateGear(3);
                }
            }
        }

        /// <summary>
        /// Enabled is shortcut for grayed and !touchable combination.
        /// </summary>
        public bool enabled
        {
            get
            {
                return !_grayed && _touchable;
            }
            set
            {
                this.grayed = !value;
                this.touchable = value;
            }
        }

        /// <summary>
        /// The rotation around the z axis of the object in degrees.
        /// </summary>
        public float rotation
        {
            get
            {
                return _rotation;
            }
            set
            {
                _rotation = value;
                if (displayObject != null)
                    displayObject.rotation = _rotation;
                UpdateGear(3);
            }
        }

        /// <summary>
        /// The rotation around the x axis of the object in degrees.
        /// </summary>
        public float rotationX
        {
            get
            {
                return _rotationX;
            }
            set
            {
                _rotationX = value;
                if (displayObject != null)
                    displayObject.rotationX = _rotationX;
            }
        }

        /// <summary>
        /// The rotation around the y axis of the object in degrees.
        /// </summary>
        public float rotationY
        {
            get
            {
                return _rotationY;
            }
            set
            {
                _rotationY = value;
                if (displayObject != null)
                    displayObject.rotationY = _rotationY;
            }
        }

        /// <summary>
        /// The opacity of the object. 0 = transparent, 1 = opaque.
        /// </summary>
        public float alpha
        {

            get
            {
                return _alpha;
            }

            set
            {
                _alpha = value;
                HandleAlphaChanged();
                UpdateGear(3);
            }
        }

        /// <summary>
        /// The visibility of the object. An invisible object will be untouchable.
        /// </summary>
        public bool visible
        {
            get
            {
                return _visible;
            }

            set
            {
                if (_visible != value)
                {
                    _visible = value;
                    HandleVisibleChanged();
                    if (parent != null)
                        parent.SetBoundsChangedFlag();
                    if (_group != null && _group.excludeInvisibles)
                        _group.SetBoundsChangedFlag();
                }
            }
        }

        internal bool internalVisible
        {
            get
            {
                return _internalVisible && (group == null || group.internalVisible);
            }
        }

        internal bool internalVisible2
        {
            get
            {
                return _visible && (group == null || group.internalVisible2);
            }
        }

        internal bool internalVisible3
        {
            get
            {
                return _visible && _internalVisible;
            }
        }

        /// <summary>
        /// By default(when sortingOrder==0), object added to component is arrange by the added roder. 
        /// The bigger is the sorting order, the object is more in front.
        /// </summary>
        public int sortingOrder
        {
            get { return _sortingOrder; }
            set
            {
                if (value < 0)
                    value = 0;
                if (_sortingOrder != value)
                {
                    int old = _sortingOrder;
                    _sortingOrder = value;
                    if (parent != null)
                        parent.ChildSortingOrderChanged(this, old, _sortingOrder);
                }
            }
        }

        /// <summary>
        /// If the object can be focused?
        /// </summary>
        public bool focusable
        {
            get { return displayObject != null && displayObject.focusable; }
            set { if (displayObject != null) displayObject.focusable = value; }
        }

        /// <summary>
        /// If the object can be navigated by TAB?
        /// </summary>
        public bool tabStop
        {
            get { return displayObject != null && displayObject.tabStop; }
            set { if (displayObject != null) displayObject.tabStop = value; }
        }

        /// <summary>
        /// If the object is focused. 
        /// </summary>
        public bool focused
        {
            get { return displayObject != null && displayObject.focused; }
        }

        /// <summary>
        /// Request focus on this object.
        /// </summary>
        public void RequestFocus()
        {
            if (displayObject != null)
                Stage.inst.SetFocus(displayObject, false);
        }

        /// <summary>
        /// Request focus on this object.
        /// </summary>
        public void RequestFocus(bool byKey)
        {
            if (displayObject != null)
                Stage.inst.SetFocus(displayObject, byKey);
        }

        /// <summary>
        /// Tooltips of this object. UIConfig.tooltipsWin must be set first.
        /// </summary>
        public string tooltips
        {
            get { return _tooltips; }
            set
            {
                if (!string.IsNullOrEmpty(_tooltips))
                {
                    this.onRollOver.Remove(__rollOver);
                    this.onRollOut.Remove(__rollOut);
                }

                _tooltips = value;
                if (!string.IsNullOrEmpty(_tooltips))
                {
                    this.onRollOver.Add(__rollOver);
                    this.onRollOut.Add(__rollOut);
                }
            }
        }


        /// <summary>
        /// 
        /// </summary>
        /// <value></value>
        public string cursor
        {
            get { return displayObject != null ? displayObject.cursor : null; }
            set
            {
                if (displayObject != null)
                    displayObject.cursor = value;
            }
        }

        private void __rollOver()
        {
            this.root.ShowTooltips(tooltips);
        }

        private void __rollOut()
        {
            this.root.HideTooltips();
        }

        /// <summary>
        /// 
        /// </summary>
        virtual public IFilter filter
        {
            get { return displayObject != null ? displayObject.filter : null; }
            set { if (displayObject != null) displayObject.filter = value; }
        }

        /// <summary>
        /// 
        /// </summary>
        virtual public BlendMode blendMode
        {
            get { return displayObject != null ? displayObject.blendMode : BlendMode.None; }
            set { if (displayObject != null) displayObject.blendMode = value; }
        }

        /// <summary>
        /// 设定GameObject的名称
        /// </summary>
        public string gameObjectName
        {
            get
            {
                if (displayObject != null)
                    return displayObject.gameObject.name;
                else
                    return null;
            }

            set
            {
                if (displayObject != null)
                    displayObject.gameObject.name = value;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        public void SetHome(GObject obj)
        {
            if (obj != null && displayObject != null && obj.displayObject != null)
                displayObject.home = obj.displayObject.cachedTransform;
        }

        /// <summary>
        /// If the object has lowlevel displayobject and the displayobject has a container parent?
        /// </summary>
        public bool inContainer
        {
            get
            {
                return displayObject != null && displayObject.parent != null;
            }
        }

        /// <summary>
        /// If the object is on stage.
        /// </summary>
        public bool onStage
        {
            get
            {
                return displayObject != null && displayObject.stage != null;
            }
        }

        /// <summary>
        /// Resource url of this object.
        /// </summary>
        public string resourceURL
        {
            get
            {
                if (packageItem != null)
                    return UIPackage.URL_PREFIX + packageItem.owner.id + packageItem.id;
                else
                    return null;
            }
        }

        /// <summary>
        /// Gear to xy controller.
        /// </summary>
        public GearXY gearXY
        {
            get
            {
                return (GearXY)GetGear(1);
            }
        }

        /// <summary>
        /// Gear to size controller.
        /// </summary>
        public GearSize gearSize
        {
            get
            {
                return (GearSize)GetGear(2);
            }
        }

        /// <summary>
        /// Gear to look controller.
        /// </summary>
        public GearLook gearLook
        {
            get
            {
                return (GearLook)GetGear(3);
            }
        }

        public GearBase GetGear(int index)
        {
            GearBase gear = _gears[index];
            if (gear == null)
            {
                switch (index)
                {
                    case 0:
                        gear = new GearDisplay(this);
                        break;
                    case 1:
                        gear = new GearXY(this);
                        break;
                    case 2:
                        gear = new GearSize(this);
                        break;
                    case 3:
                        gear = new GearLook(this);
                        break;
                    case 4:
                        gear = new GearColor(this);
                        break;
                    case 5:
                        gear = new GearAnimation(this);
                        break;
                    case 6:
                        gear = new GearText(this);
                        break;
                    case 7:
                        gear = new GearIcon(this);
                        break;
                    case 8:
                        gear = new GearDisplay2(this);
                        break;
                    case 9:
                        gear = new GearFontSize(this);
                        break;
                    default:
                        throw new System.Exception("FairyGUI: invalid gear index!");
                }
                _gears[index] = gear;
            }
            return gear;
        }

        protected void UpdateGear(int index)
        {
            if (underConstruct || _gearLocked)
                return;

            GearBase gear = _gears[index];
            if (gear != null && gear.controller != null)
                gear.UpdateState();
        }

        internal bool CheckGearController(int index, Controller c)
        {
            return _gears[index] != null && _gears[index].controller == c;
        }

        internal void UpdateGearFromRelations(int index, float dx, float dy)
        {
            if (_gears[index] != null)
                _gears[index].UpdateFromRelations(dx, dy);
        }

        internal uint AddDisplayLock()
        {
            GearDisplay gearDisplay = (GearDisplay)_gears[0];
            if (gearDisplay != null && gearDisplay.controller != null)
            {
                uint ret = gearDisplay.AddLock();
                CheckGearDisplay();

                return ret;
            }
            else
                return 0;
        }

        internal void ReleaseDisplayLock(uint token)
        {
            GearDisplay gearDisplay = (GearDisplay)_gears[0];
            if (gearDisplay != null && gearDisplay.controller != null)
            {
                gearDisplay.ReleaseLock(token);
                CheckGearDisplay();
            }
        }

        void CheckGearDisplay()
        {
            if (_handlingController)
                return;

            bool connected = _gears[0] == null || ((GearDisplay)_gears[0]).connected;
            if (_gears[8] != null)
                connected = ((GearDisplay2)_gears[8]).Evaluate(connected);

            if (connected != _internalVisible)
            {
                _internalVisible = connected;
                if (parent != null)
                    parent.ChildStateChanged(this);
                if (_group != null && _group.excludeInvisibles)
                    _group.SetBoundsChangedFlag();
            }
        }

        /// <summary>
        /// Mark the fairy batching state is invalid. 
        /// </summary>
        public void InvalidateBatchingState()
        {
            if (displayObject != null)
                displayObject.InvalidateBatchingState();
            else if ((this is GGroup) && parent != null)
                parent.container.InvalidateBatchingState(true);
        }

        virtual public void HandleControllerChanged(Controller c)
        {
            _handlingController = true;
            for (int i = 0; i < 10; i++)
            {
                GearBase gear = _gears[i];
                if (gear != null && gear.controller == c)
                    gear.Apply();
            }
            _handlingController = false;

            CheckGearDisplay();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="target"></param>
        /// <param name="relationType"></param>
        public void AddRelation(GObject target, RelationType relationType)
        {
            AddRelation(target, relationType, false);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="target"></param>
        /// <param name="relationType"></param>
        /// <param name="usePercent"></param>
        public void AddRelation(GObject target, RelationType relationType, bool usePercent)
        {
            relations.Add(target, relationType, usePercent);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="target"></param>
        /// <param name="relationType"></param>
        public void RemoveRelation(GObject target, RelationType relationType)
        {
            relations.Remove(target, relationType);
        }

        /// <summary>
        /// 
        /// </summary>
        public void RemoveFromParent()
        {
            if (parent != null)
                parent.RemoveChild(this);
        }

        /// <summary>
        ///  Group belonging to.
        /// </summary>
        public GGroup group
        {
            get { return _group; }
            set
            {
                if (_group != value)
                {
                    if (_group != null)
                        _group.SetBoundsChangedFlag();
                    _group = value;
                    if (_group != null)
                        _group.SetBoundsChangedFlag();
                    HandleVisibleChanged();
                    if (parent != null)
                        parent.ChildStateChanged(this);
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public GRoot root
        {
            get
            {
                GObject p = this;
                while (p.parent != null)
                    p = p.parent;

                if (p is GRoot)
                    return (GRoot)p;

                if (p.displayObject != null && p.displayObject.parent != null)
                {
                    DisplayObject d = p.displayObject.parent.GetChild("GRoot");
                    if (d != null && (d.gOwner is GRoot))
                        return (GRoot)d.gOwner;
                }

                return GRoot.inst;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        virtual public string text
        {
            get { return null; }
            set { /*override in child*/}
        }

        /// <summary>
        /// 
        /// </summary>
        virtual public string icon
        {
            get { return null; }
            set { /*override in child*/}
        }

        /// <summary>
        /// 
        /// </summary>
        public bool draggable
        {
            get { return _draggable; }
            set
            {
                if (_draggable != value)
                {
                    _draggable = value;
                    InitDrag();
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public void StartDrag()
        {
            StartDrag(-1);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="touchId"></param>
        public void StartDrag(int touchId)
        {
            if (displayObject.stage == null)
                return;

            DragBegin(touchId);
        }

        /// <summary>
        /// 
        /// </summary>
        public void StopDrag()
        {
            DragEnd();
        }

        /// <summary>
        /// 
        /// </summary>
        public bool dragging
        {
            get { return draggingObject == this; }
        }

        /// <summary>
        /// Transforms a point from the local coordinate system to global (Stage) coordinates.
        /// </summary>
        /// <param name="pt"></param>
        /// <returns></returns>
        public Vector2 LocalToGlobal(Vector2 pt)
        {
            if (_pivotAsAnchor)
            {
                pt.x += _width * _pivotX;
                pt.y += _height * _pivotY;
            }
            return displayObject.LocalToGlobal(pt);
        }

        /// <summary>
        /// Transforms a point from global (Stage) coordinates to the local coordinate system.
        /// </summary>
        /// <param name="pt"></param>
        /// <returns></returns>
        public Vector2 GlobalToLocal(Vector2 pt)
        {
            pt = displayObject.GlobalToLocal(pt);
            if (_pivotAsAnchor)
            {
                pt.x -= _width * _pivotX;
                pt.y -= _height * _pivotY;
            }
            return pt;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="rect"></param>
        /// <returns></returns>
        public Rect LocalToGlobal(Rect rect)
        {
            Rect ret = new Rect();
            Vector2 v = this.LocalToGlobal(new Vector2(rect.xMin, rect.yMin));
            ret.xMin = v.x;
            ret.yMin = v.y;
            v = this.LocalToGlobal(new Vector2(rect.xMax, rect.yMax));
            ret.xMax = v.x;
            ret.yMax = v.y;
            return ret;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="rect"></param>
        /// <returns></returns>
        public Rect GlobalToLocal(Rect rect)
        {
            Rect ret = new Rect();
            Vector2 v = this.GlobalToLocal(new Vector2(rect.xMin, rect.yMin));
            ret.xMin = v.x;
            ret.yMin = v.y;
            v = this.GlobalToLocal(new Vector2(rect.xMax, rect.yMax));
            ret.xMax = v.x;
            ret.yMax = v.y;
            return ret;
        }

        /// <summary>
        /// Transforms a point from the local coordinate system to GRoot coordinates.
        /// </summary>
        /// <param name="pt"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        public Vector2 LocalToRoot(Vector2 pt, GRoot r)
        {
            pt = LocalToGlobal(pt);
            if (r == null || r == GRoot.inst)
            {
                //fast
                pt.x /= UIContentScaler.scaleFactor;
                pt.y /= UIContentScaler.scaleFactor;
                return pt;
            }
            else
                return r.GlobalToLocal(pt);
        }

        /// <summary>
        /// Transforms a point from the GRoot coordinate  to local coordinates system.
        /// </summary>
        /// <param name="pt"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        public Vector2 RootToLocal(Vector2 pt, GRoot r)
        {
            if (r == null || r == GRoot.inst)
            {
                //fast
                pt.x *= UIContentScaler.scaleFactor;
                pt.y *= UIContentScaler.scaleFactor;
            }
            else
                pt = r.LocalToGlobal(pt);
            return GlobalToLocal(pt);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="pt"></param>
        /// <returns></returns>
        public Vector2 WorldToLocal(Vector3 pt)
        {
            return WorldToLocal(pt, HitTestContext.cachedMainCamera);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="pt"></param>
        /// <param name="camera"></param>
        /// <returns></returns>
        public Vector2 WorldToLocal(Vector3 pt, Camera camera)
        {
            Vector3 v = camera.WorldToScreenPoint(pt);
            v.y = Screen.height - v.y;
            v.z = 0;
            return GlobalToLocal(v);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="point"></param>
        /// <param name="targetSpace"></param>
        /// <returns></returns>
        public Vector2 TransformPoint(Vector2 pt, GObject targetSpace)
        {
            if (_pivotAsAnchor)
            {
                pt.x += _width * _pivotX;
                pt.y += _height * _pivotY;
            }
            return this.displayObject.TransformPoint(pt, targetSpace != null ? targetSpace.displayObject : Stage.inst);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="rect"></param>
        /// <param name="targetSpace"></param>
        /// <returns></returns>
        public Rect TransformRect(Rect rect, GObject targetSpace)
        {
            if (_pivotAsAnchor)
            {
                rect.x += _width * _pivotX;
                rect.y += _height * _pivotY;
            }
            return this.displayObject.TransformRect(rect, targetSpace != null ? targetSpace.displayObject : Stage.inst);
        }

        /// <summary>
        /// 
        /// </summary>
        public bool isDisposed
        {
            get { return _disposed; }
        }

        /// <summary>
        /// 
        /// </summary>
        virtual public void Dispose()
        {
            if (_disposed)
                return;

            _disposed = true;

            RemoveFromParent();
            RemoveEventListeners();
            relations.Dispose();
            relations = null;
            for (int i = 0; i < 10; i++)
            {
                GearBase gear = _gears[i];
                if (gear != null)
                    gear.Dispose();
            }
            if (displayObject != null)
            {
                displayObject.gOwner = null;
                displayObject.Dispose();
            }
            data = null;
        }

        /// <summary>
        /// 
        /// </summary>
        public GImage asImage
        {
            get { return this as GImage; }
        }

        /// <summary>
        /// 
        /// </summary>
        public GComponent asCom
        {
            get { return this as GComponent; }
        }

        /// <summary>
        /// 
        /// </summary>
        public GButton asButton
        {
            get { return this as GButton; }
        }

        /// <summary>
        /// 
        /// </summary>
        public GLabel asLabel
        {
            get { return this as GLabel; }
        }

        /// <summary>
        /// 
        /// </summary>
        public GProgressBar asProgress
        {
            get { return this as GProgressBar; }
        }

        /// <summary>
        /// 
        /// </summary>
        public GSlider asSlider
        {
            get { return this as GSlider; }
        }

        /// <summary>
        /// 
        /// </summary>
        public GComboBox asComboBox
        {
            get { return this as GComboBox; }
        }

        /// <summary>
        /// 
        /// </summary>
        public GTextField asTextField
        {
            get { return this as GTextField; }
        }

        /// <summary>
        /// 
        /// </summary>
        public GRichTextField asRichTextField
        {
            get { return this as GRichTextField; }
        }

        /// <summary>
        /// 
        /// </summary>
        public GTextInput asTextInput
        {
            get { return this as GTextInput; }
        }

        /// <summary>
        /// 
        /// </summary>
        public GLoader asLoader
        {
            get { return this as GLoader; }
        }

        /// <summary>
        /// 
        /// </summary>
        public GLoader3D asLoader3D
        {
            get { return this as GLoader3D; }
        }

        /// <summary>
        /// 
        /// </summary>
        public GList asList
        {
            get { return this as GList; }
        }

        /// <summary>
        /// 
        /// </summary>
        public GGraph asGraph
        {
            get { return this as GGraph; }
        }

        /// <summary>
        /// 
        /// </summary>
        public GGroup asGroup
        {
            get { return this as GGroup; }
        }

        /// <summary>
        /// 
        /// </summary>
        public GMovieClip asMovieClip
        {
            get { return this as GMovieClip; }
        }

        /// <summary>
        /// 
        /// </summary>
        public GTree asTree
        {
            get { return this as GTree; }
        }

        /// <summary>
        /// 
        /// </summary>
        public GTreeNode treeNode
        {
            get { return _treeNode; }
        }

        virtual protected void CreateDisplayObject()
        {
        }

        internal void InternalSetParent(GComponent value)
        {
            parent = value;
        }

        virtual protected void HandlePositionChanged()
        {
            if (displayObject != null)
            {
                float xv = _x;
                float yv = _y;
                if (!_pivotAsAnchor)
                {
                    xv += _width * _pivotX;
                    yv += _height * _pivotY;
                }
                displayObject.location = new Vector3(xv, yv, _z);
            }
        }

        virtual protected void HandleSizeChanged()
        {
            if (displayObject != null)
                displayObject.SetSize(_width, _height);
        }

        virtual protected void HandleScaleChanged()
        {
            if (displayObject != null)
                displayObject.SetScale(_scaleX, _scaleY);
        }

        virtual protected void HandleGrayedChanged()
        {
            if (displayObject != null)
                displayObject.grayed = _grayed;
        }

        virtual protected void HandleAlphaChanged()
        {
            if (displayObject != null)
                displayObject.alpha = _alpha;
        }

        virtual internal protected void HandleVisibleChanged()
        {
            if (displayObject != null)
                displayObject.visible = internalVisible2;
        }

        virtual public void ConstructFromResource()
        {
        }

        virtual public void Setup_BeforeAdd(ByteBuffer buffer, int beginPos)
        {
            buffer.Seek(beginPos, 0);
            buffer.Skip(5);

            id = buffer.ReadS();
            name = buffer.ReadS();
            float f1 = buffer.ReadInt();
            float f2 = buffer.ReadInt();
            SetXY(f1, f2);

            if (buffer.ReadBool())
            {
                initWidth = buffer.ReadInt();
                initHeight = buffer.ReadInt();
                SetSize(initWidth, initHeight, true);
            }

            if (buffer.ReadBool())
            {
                minWidth = buffer.ReadInt();
                maxWidth = buffer.ReadInt();
                minHeight = buffer.ReadInt();
                maxHeight = buffer.ReadInt();
            }

            if (buffer.ReadBool())
            {
                f1 = buffer.ReadFloat();
                f2 = buffer.ReadFloat();
                SetScale(f1, f2);
            }

            if (buffer.ReadBool())
            {
                f1 = buffer.ReadFloat();
                f2 = buffer.ReadFloat();
                this.skew = new Vector2(f1, f2);
            }

            if (buffer.ReadBool())
            {
                f1 = buffer.ReadFloat();
                f2 = buffer.ReadFloat();
                SetPivot(f1, f2, buffer.ReadBool());
            }

            f1 = buffer.ReadFloat();
            if (f1 != 1)
                this.alpha = f1;

            f1 = buffer.ReadFloat();
            if (f1 != 0)
                this.rotation = f1;

            if (!buffer.ReadBool())
                this.visible = false;
            if (!buffer.ReadBool())
                this.touchable = false;
            if (buffer.ReadBool())
                this.grayed = true;
            this.blendMode = (BlendMode)buffer.ReadByte();

            int filter = buffer.ReadByte();
            if (filter == 1)
            {
                ColorFilter cf = new ColorFilter();
                this.filter = cf;

                cf.AdjustBrightness(buffer.ReadFloat());
                cf.AdjustContrast(buffer.ReadFloat());
                cf.AdjustSaturation(buffer.ReadFloat());
                cf.AdjustHue(buffer.ReadFloat());
            }

            string str = buffer.ReadS();
            if (str != null)
                this.data = str;
        }

        virtual public void Setup_AfterAdd(ByteBuffer buffer, int beginPos)
        {
            buffer.Seek(beginPos, 1);

            string str = buffer.ReadS();
            if (str != null)
                this.tooltips = str;

            int groupId = buffer.ReadShort();
            if (groupId >= 0)
                group = parent.GetChildAt(groupId) as GGroup;

            buffer.Seek(beginPos, 2);

            int cnt = buffer.ReadShort();
            for (int i = 0; i < cnt; i++)
            {
                int nextPos = buffer.ReadUshort();
                nextPos += buffer.position;

                GearBase gear = GetGear(buffer.ReadByte());
                gear.Setup(buffer);

                buffer.position = nextPos;
            }
        }

        #region Drag support
        Vector2 _dragTouchStartPos;
        bool _dragTesting;

        static Vector2 sGlobalDragStart = new Vector2();
        static Rect sGlobalRect = new Rect();
        static bool sUpdateInDragging = false;

        private void InitDrag()
        {
            if (_draggable)
            {
                onTouchBegin.Add(__touchBegin);
                onTouchMove.Add(__touchMove);
                onTouchEnd.Add(__touchEnd);
            }
            else
            {
                onTouchBegin.Remove(__touchBegin);
                onTouchMove.Remove(__touchMove);
                onTouchEnd.Remove(__touchEnd);
            }
        }

        private void DragBegin(int touchId)
        {
            if (DispatchEvent("onDragStart", touchId))
                return;

            if (draggingObject != null)
            {
                GObject tmp = draggingObject;
                draggingObject.StopDrag();
                draggingObject = null;
                tmp.DispatchEvent("onDragEnd", null);
            }

            onTouchMove.Add(__touchMove);
            onTouchEnd.Add(__touchEnd);

            sGlobalDragStart = Stage.inst.GetTouchPosition(touchId);
            sGlobalRect = this.LocalToGlobal(new Rect(0, 0, this.width, this.height));
            _dragTesting = false;

            draggingObject = this;
            Stage.inst.AddTouchMonitor(touchId, this);
        }

        private void DragEnd()
        {
            if (draggingObject == this)
            {
                _dragTesting = false;
                draggingObject = null;
            }
        }

        private void __touchBegin(EventContext context)
        {
            if ((Stage.inst.focus is InputTextField) && ((InputTextField)Stage.inst.focus).editable)
            {
                _dragTesting = false;
                return;
            }

            InputEvent evt = context.inputEvent;
            _dragTouchStartPos = evt.position;
            _dragTesting = true;
            context.CaptureTouch();
        }

        private void __touchMove(EventContext context)
        {
            InputEvent evt = context.inputEvent;

            if (_dragTesting && draggingObject != this)
            {
                int sensitivity;
                if (Stage.touchScreen)
                    sensitivity = UIConfig.touchDragSensitivity;
                else
                    sensitivity = UIConfig.clickDragSensitivity;
                if (Mathf.Abs(_dragTouchStartPos.x - evt.x) < sensitivity
                    && Mathf.Abs(_dragTouchStartPos.y - evt.y) < sensitivity)
                    return;

                _dragTesting = false;
                DragBegin(evt.touchId);
            }

            if (draggingObject == this)
            {
                float xx = evt.x - sGlobalDragStart.x + sGlobalRect.x;
                float yy = evt.y - sGlobalDragStart.y + sGlobalRect.y;

                if (dragBounds != null)
                {
                    Rect rect = GRoot.inst.LocalToGlobal((Rect)dragBounds);
                    if (xx < rect.x)
                        xx = rect.x;
                    else if (xx + sGlobalRect.width > rect.xMax)
                    {
                        xx = rect.xMax - sGlobalRect.width;
                        if (xx < rect.x)
                            xx = rect.x;
                    }

                    if (yy < rect.y)
                        yy = rect.y;
                    else if (yy + sGlobalRect.height > rect.yMax)
                    {
                        yy = rect.yMax - sGlobalRect.height;
                        if (yy < rect.y)
                            yy = rect.y;
                    }
                }

                Vector2 pt = this.parent.GlobalToLocal(new Vector2(xx, yy));
                if (float.IsNaN(pt.x))
                    return;

                sUpdateInDragging = true;
                this.SetXY(Mathf.RoundToInt(pt.x), Mathf.RoundToInt(pt.y));
                sUpdateInDragging = false;

                DispatchEvent("onDragMove", null);
            }
        }

        private void __touchEnd(EventContext context)
        {
            if (draggingObject == this)
            {
                draggingObject = null;
                DispatchEvent("onDragEnd", null);
            }
        }
        #endregion

        #region Tween Helpers
        public GTweener TweenMove(Vector2 endValue, float duration)
        {
            return GTween.To(this.xy, endValue, duration).SetTarget(this, TweenPropType.XY);
        }

        public GTweener TweenMoveX(float endValue, float duration)
        {
            return GTween.To(_x, endValue, duration).SetTarget(this, TweenPropType.X);
        }

        public GTweener TweenMoveY(float endValue, float duration)
        {
            return GTween.To(_y, endValue, duration).SetTarget(this, TweenPropType.Y);
        }

        public GTweener TweenScale(Vector2 endValue, float duration)
        {
            return GTween.To(this.scale, endValue, duration).SetTarget(this, TweenPropType.Scale);
        }

        public GTweener TweenScaleX(float endValue, float duration)
        {
            return GTween.To(_scaleX, endValue, duration).SetTarget(this, TweenPropType.ScaleX);
        }

        public GTweener TweenScaleY(float endValue, float duration)
        {
            return GTween.To(_scaleY, endValue, duration).SetTarget(this, TweenPropType.ScaleY);
        }

        public GTweener TweenResize(Vector2 endValue, float duration)
        {
            return GTween.To(this.size, endValue, duration).SetTarget(this, TweenPropType.Size);
        }

        public GTweener TweenFade(float endValue, float duration)
        {
            return GTween.To(_alpha, endValue, duration).SetTarget(this, TweenPropType.Alpha);
        }

        public GTweener TweenRotate(float endValue, float duration)
        {
            return GTween.To(_rotation, endValue, duration).SetTarget(this, TweenPropType.Rotation);
        }
        #endregion
    }
}