using System;
using System.Collections.Generic;
using UnityEngine;
using FairyGUI.Utils;
#if FAIRYGUI_TOLUA
using LuaInterface;
#endif

namespace FairyGUI
{
    /// <summary>
    /// Component
    /// </summary>
    public class GComponent : GObject
    {
        /// <summary>
        /// Root container.
        /// </summary>
        public Container rootContainer { get; private set; }
        /// <summary>
        /// Content container. If the component is not clipped, then container==rootContainer.
        /// </summary>
        public Container container { get; protected set; }
        /// <summary>
        /// ScrollPane of the component. If the component is not scrollable, the value is null.
        /// </summary>
        public ScrollPane scrollPane { get; private set; }

        internal List<GObject> _children;
        internal List<Controller> _controllers;
        internal List<Transition> _transitions;
        internal bool _buildingDisplayList;

        protected Margin _margin;
        protected bool _trackBounds;
        protected bool _boundsChanged;
        protected ChildrenRenderOrder _childrenRenderOrder;
        protected int _apexIndex;
        internal Vector2 _alignOffset;

        Vector2 _clipSoftness;
        int _sortingChildCount;
        Action _buildDelegate;
        Controller _applyingController;

        EventListener _onDrop;

        public GComponent()
        {
            _children = new List<GObject>();
            _controllers = new List<Controller>();
            _transitions = new List<Transition>();
            _margin = new Margin();
            _buildDelegate = BuildNativeDisplayList;
        }

        override protected void CreateDisplayObject()
        {
            rootContainer = new Container("GComponent");
            rootContainer.gOwner = this;
            rootContainer.onUpdate += OnUpdate;
            container = rootContainer;

            displayObject = rootContainer;
        }

        override public void Dispose()
        {
            int cnt = _transitions.Count;
            for (int i = 0; i < cnt; ++i)
            {
                Transition trans = _transitions[i];
                trans.Dispose();
            }

            cnt = _controllers.Count;
            for (int i = 0; i < cnt; ++i)
            {
                Controller c = _controllers[i];
                c.Dispose();
            }

            if (scrollPane != null)
                scrollPane.Dispose();

            base.Dispose(); //Dispose native tree first, avoid DisplayObject.RemoveFromParent call

            cnt = _children.Count;
            for (int i = cnt - 1; i >= 0; --i)
            {
                GObject obj = _children[i];
                obj.InternalSetParent(null); //Avoid GObject.RemoveParent call
                obj.Dispose();
            }

#if FAIRYGUI_TOLUA
            if (_peerTable != null)
            {
                _peerTable.Dispose();
                _peerTable = null;
            }
#endif

#if FAIRYGUI_PUERTS
            if (__onDispose != null)
                __onDispose();
            __onConstruct = null;
            __onDispose = null;
#endif
        }

        /// <summary>
        /// Dispatched when an object was dragged and dropped to this component.
        /// </summary>
        public EventListener onDrop
        {
            get { return _onDrop ?? (_onDrop = new EventListener(this, "onDrop")); }
        }

        /// <summary>
        /// Draw call optimization switch.
        /// </summary>
        public bool fairyBatching
        {
            get { return rootContainer.fairyBatching; }
            set { rootContainer.fairyBatching = value; }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="childChanged"></param>
        public void InvalidateBatchingState(bool childChanged)
        {
            if (childChanged)
                container.InvalidateBatchingState(childChanged);
            else
                rootContainer.InvalidateBatchingState();
        }

        /// <summary>
        /// If true, mouse/touch events cannot pass through the empty area of the component. Default is true.
        /// </summary>
        public bool opaque
        {
            get { return rootContainer.opaque; }
            set { rootContainer.opaque = value; }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <value></value>
        public Margin margin
        {
            get { return _margin; }
            set
            {
                _margin = value;
                if (rootContainer.clipRect != null && scrollPane == null) //如果scrollPane不为空，则HandleSizeChanged里面的处理会促使ScrollPane处理
                    container.SetXY(_margin.left + _alignOffset.x, _margin.top + _alignOffset.y);
                HandleSizeChanged();
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public ChildrenRenderOrder childrenRenderOrder
        {
            get { return _childrenRenderOrder; }
            set
            {
                if (_childrenRenderOrder != value)
                {
                    _childrenRenderOrder = value;
                    BuildNativeDisplayList();
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public int apexIndex
        {
            get { return _apexIndex; }
            set
            {
                if (_apexIndex != value)
                {
                    _apexIndex = value;

                    if (_childrenRenderOrder == ChildrenRenderOrder.Arch)
                        BuildNativeDisplayList();
                }
            }
        }

        /// <summary>
        /// If true, children can be navigated by TAB from first to last, and repeat
        /// </summary>
        public bool tabStopChildren
        {
            get { return rootContainer.tabStopChildren; }
            set { rootContainer.tabStopChildren = value; }
        }

        /// <summary>
        /// Add a child to the component. It will be at the frontmost position.
        /// </summary>
        /// <param name="child">A child object</param>
        /// <returns>GObject</returns>
        public GObject AddChild(GObject child)
        {
            AddChildAt(child, _children.Count);
            return child;
        }

        /// <summary>
        /// Adds a child to the component at a certain index.
        /// </summary>
        /// <param name="child">A child object</param>
        /// <param name="index">Index</param>
        /// <returns>GObject</returns>
        virtual public GObject AddChildAt(GObject child, int index)
        {
            if (index >= 0 && index <= _children.Count)
            {
                if (child.parent == this)
                {
                    SetChildIndex(child, index);
                }
                else
                {
                    child.RemoveFromParent();
                    child.InternalSetParent(this);

                    int cnt = _children.Count;
                    if (child.sortingOrder != 0)
                    {
                        _sortingChildCount++;
                        index = GetInsertPosForSortingChild(child);
                    }
                    else if (_sortingChildCount > 0)
                    {
                        if (index > (cnt - _sortingChildCount))
                            index = cnt - _sortingChildCount;
                    }

                    if (index == cnt)
                        _children.Add(child);
                    else
                        _children.Insert(index, child);

                    ChildStateChanged(child);
                    SetBoundsChangedFlag();
                }
                return child;
            }
            else
            {
                throw new Exception("Invalid child index: " + index + ">" + _children.Count);
            }
        }

        int GetInsertPosForSortingChild(GObject target)
        {
            int cnt = _children.Count;
            int i;
            for (i = 0; i < cnt; i++)
            {
                GObject child = _children[i];
                if (child == target)
                    continue;

                if (target.sortingOrder < child.sortingOrder)
                    break;
            }
            return i;
        }

        /// <summary>
        /// Removes a child from the component. If the object is not a child, nothing happens. 
        /// </summary>
        /// <param name="child">A child object</param>
        /// <returns>GObject</returns>
        public GObject RemoveChild(GObject child)
        {
            return RemoveChild(child, false);
        }

        /// <summary>
        /// Removes a child from the component. If the object is not a child, nothing happens. 
        /// </summary>
        /// <param name="child">A child object</param>
        /// <param name="dispose">If true, the child will be disposed right away.</param>
        /// <returns>GObject</returns>
        public GObject RemoveChild(GObject child, bool dispose)
        {
            int childIndex = _children.IndexOf(child);
            if (childIndex != -1)
            {
                RemoveChildAt(childIndex, dispose);
            }
            return child;
        }

        /// <summary>
        /// Removes a child at a certain index. Children above the child will move down.
        /// </summary>
        /// <param name="index">Index</param>
        /// <returns>GObject</returns>
        public GObject RemoveChildAt(int index)
        {
            return RemoveChildAt(index, false);
        }

        /// <summary>
        /// Removes a child at a certain index. Children above the child will move down.
        /// </summary>
        /// <param name="index">Index</param>
        /// <param name="dispose">If true, the child will be disposed right away.</param>
        /// <returns>GObject</returns>
        virtual public GObject RemoveChildAt(int index, bool dispose)
        {
            if (index >= 0 && index < numChildren)
            {
                GObject child = _children[index];

                child.InternalSetParent(null);

                if (child.sortingOrder != 0)
                    _sortingChildCount--;

                _children.RemoveAt(index);
                child.group = null;
                if (child.inContainer)
                {
                    container.RemoveChild(child.displayObject);
                    if (_childrenRenderOrder == ChildrenRenderOrder.Arch)
                    {
                        UpdateContext.OnBegin -= _buildDelegate;
                        UpdateContext.OnBegin += _buildDelegate;
                    }
                }

                if (dispose)
                    child.Dispose();

                SetBoundsChangedFlag();
                return child;
            }
            else
                throw new Exception("Invalid child index: " + index + ">" + numChildren);
        }

        /// <summary>
        /// Remove all children.
        /// </summary>
        public void RemoveChildren()
        {
            RemoveChildren(0, -1, false);
        }

        /// <summary>
        /// Removes a range of children from the container (endIndex included). 
        /// </summary>
        /// <param name="beginIndex">Begin index.</param>
        /// <param name="endIndex">End index.(Included).</param>
        /// <param name="dispose">If true, the child will be disposed right away.</param>
        public void RemoveChildren(int beginIndex, int endIndex, bool dispose)
        {
            if (endIndex < 0 || endIndex >= numChildren)
                endIndex = numChildren - 1;

            for (int i = beginIndex; i <= endIndex; ++i)
                RemoveChildAt(beginIndex, dispose);
        }

        /// <summary>
        /// Returns a child object at a certain index. If index out of bounds, exception raised.
        /// </summary>
        /// <param name="index">Index</param>
        /// <returns>A child object.</returns>
        public GObject GetChildAt(int index)
        {
            if (index >= 0 && index < numChildren)
                return _children[index];
            else
                throw new Exception("Invalid child index: " + index + ">" + numChildren);
        }

        /// <summary>
        /// Returns a child object with a certain name.
        /// </summary>
        /// <param name="name">Name</param>
        /// <returns>A child object. Null if not found.</returns>
        public GObject GetChild(string name)
        {
            int cnt = _children.Count;
            for (int i = 0; i < cnt; ++i)
            {
                if (_children[i].name == name)
                    return _children[i];
            }

            return null;
        }

        public GObject GetChildByPath(string path)
        {
            string[] arr = path.Split('.');
            int cnt = arr.Length;
            GComponent gcom = this;
            GObject obj = null;
            for (int i = 0; i < cnt; ++i)
            {
                obj = gcom.GetChild(arr[i]);
                if (obj == null)
                    break;

                if (i != cnt - 1)
                {
                    if (!(obj is GComponent))
                    {
                        obj = null;
                        break;
                    }
                    else
                        gcom = (GComponent)obj;
                }
            }

            return obj;
        }

        /// <summary>
        /// Returns a visible child object with a certain name.
        /// </summary>
        /// <param name="name">Name</param>
        /// <returns>A child object. Null if not found.</returns>
        public GObject GetVisibleChild(string name)
        {
            int cnt = _children.Count;
            for (int i = 0; i < cnt; ++i)
            {
                GObject child = _children[i];
                if (child.internalVisible && child.internalVisible2 && child.name == name)
                    return child;
            }

            return null;
        }

        /// <summary>
        /// Returns a child object belong to a group with a certain name.
        /// </summary>
        /// <param name="group">A group object</param>
        /// <param name="name">Name</param>
        /// <returns>A child object. Null if not found.</returns>
        public GObject GetChildInGroup(GGroup group, string name)
        {
            int cnt = _children.Count;
            for (int i = 0; i < cnt; ++i)
            {
                GObject child = _children[i];
                if (child.group == group && child.name == name)
                    return child;
            }

            return null;
        }

        internal GObject GetChildById(string id)
        {
            int cnt = _children.Count;
            for (int i = 0; i < cnt; ++i)
            {
                if (_children[i].id == id)
                    return _children[i];
            }

            return null;
        }

        /// <summary>
        /// Returns a copy of all children with an array.
        /// </summary>
        /// <returns>An array contains all children</returns>
        public GObject[] GetChildren()
        {
            return _children.ToArray();
        }

        /// <summary>
        /// Returns the index of a child within the container, or "-1" if it is not found.
        /// </summary>
        /// <param name="child">A child object</param>
        /// <returns>Index of the child. -1 If not found.</returns>
        public int GetChildIndex(GObject child)
        {
            return _children.IndexOf(child);
        }

        /// <summary>
        /// Moves a child to a certain index. Children at and after the replaced position move up.
        /// </summary>
        /// <param name="child">A Child</param>
        /// <param name="index">Index</param>
        public void SetChildIndex(GObject child, int index)
        {
            int oldIndex = _children.IndexOf(child);
            if (oldIndex == -1)
                throw new ArgumentException("Not a child of this container");

            if (child.sortingOrder != 0) //no effect
                return;

            if (_sortingChildCount > 0)
            {
                int cnt = _children.Count;
                if (index > (cnt - _sortingChildCount - 1))
                    index = cnt - _sortingChildCount - 1;
            }

            _SetChildIndex(child, oldIndex, index);
        }

        /// <summary>
        /// Moves a child to a certain position which is in front of the child previously at given index.
        /// 与SetChildIndex不同的是，如果child原来在index的前面，那么child插入的位置是index-1，即保证排在原来占据index的对象的前面。
        /// </summary>
        /// <param name="child"></param>
        /// <param name="index"></param>
        public int SetChildIndexBefore(GObject child, int index)
        {
            int oldIndex = _children.IndexOf(child);
            if (oldIndex == -1)
                throw new ArgumentException("Not a child of this container");

            if (child.sortingOrder != 0) //no effect
                return oldIndex;

            int cnt = _children.Count;
            if (_sortingChildCount > 0)
            {
                if (index > (cnt - _sortingChildCount - 1))
                    index = cnt - _sortingChildCount - 1;
            }

            if (oldIndex < index)
                return _SetChildIndex(child, oldIndex, index - 1);
            else
                return _SetChildIndex(child, oldIndex, index);
        }

        int _SetChildIndex(GObject child, int oldIndex, int index)
        {
            int cnt = _children.Count;
            if (index > cnt)
                index = cnt;

            if (oldIndex == index)
                return oldIndex;

            _children.RemoveAt(oldIndex);
            if (index >= cnt)
                _children.Add(child);
            else
                _children.Insert(index, child);

            if (child.inContainer)
            {
                int displayIndex = 0;
                if (_childrenRenderOrder == ChildrenRenderOrder.Ascent)
                {
                    for (int i = 0; i < index; i++)
                    {
                        GObject g = _children[i];
                        if (g.inContainer)
                            displayIndex++;
                    }
                    container.SetChildIndex(child.displayObject, displayIndex);
                }
                else if (_childrenRenderOrder == ChildrenRenderOrder.Descent)
                {
                    for (int i = cnt - 1; i > index; i--)
                    {
                        GObject g = _children[i];
                        if (g.inContainer)
                            displayIndex++;
                    }
                    container.SetChildIndex(child.displayObject, displayIndex);
                }
                else
                {
                    UpdateContext.OnBegin -= _buildDelegate;
                    UpdateContext.OnBegin += _buildDelegate;
                }

                SetBoundsChangedFlag();
            }

            return index;
        }

        /// <summary>
        /// Swaps the indexes of two children. 
        /// </summary>
        /// <param name="child1">A child object</param>
        /// <param name="child2">A child object</param>
        public void SwapChildren(GObject child1, GObject child2)
        {
            int index1 = _children.IndexOf(child1);
            int index2 = _children.IndexOf(child2);
            if (index1 == -1 || index2 == -1)
                throw new Exception("Not a child of this container");
            SwapChildrenAt(index1, index2);
        }

        /// <summary>
        ///  Swaps the indexes of two children.
        /// </summary>
        /// <param name="index1">index of first child</param>
        /// <param name="index2">index of second child</param>
        public void SwapChildrenAt(int index1, int index2)
        {
            GObject child1 = _children[index1];
            GObject child2 = _children[index2];

            SetChildIndex(child1, index2);
            SetChildIndex(child2, index1);
        }

        /// <summary>
        /// The number of children of this component.
        /// </summary>
        public int numChildren
        {
            get { return _children.Count; }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public bool IsAncestorOf(GObject obj)
        {
            if (obj == null)
                return false;

            GComponent p = obj.parent;
            while (p != null)
            {
                if (p == this)
                    return true;

                p = p.parent;
            }
            return false;
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="objs"></param>
        public void ChangeChildrenOrder(IList<GObject> objs)
        {
            int cnt = objs.Count;
            for (int i = 0; i < cnt; i++)
            {
                GObject obj = objs[i];
                if (obj.parent != this)
                    throw new Exception("Not a child of this container");

                _children[i] = obj;
            }
            BuildNativeDisplayList();
            SetBoundsChangedFlag();
        }

        /// <summary>
        /// Adds a controller to the container.
        /// </summary>
        /// <param name="controller">Controller object</param>
        public void AddController(Controller controller)
        {
            _controllers.Add(controller);
            controller.parent = this;
            ApplyController(controller);
        }

        /// <summary>
        /// Returns a controller object  at a certain index.
        /// </summary>
        /// <param name="index">Index</param>
        /// <returns>Controller object.</returns>
        public Controller GetControllerAt(int index)
        {
            return _controllers[index];
        }

        /// <summary>
        /// Returns a controller object with a certain name.
        /// </summary>
        /// <param name="name">Name</param>
        /// <returns>Controller object. Null if not found.</returns>
        public Controller GetController(string name)
        {
            int cnt = _controllers.Count;
            for (int i = 0; i < cnt; ++i)
            {
                Controller c = _controllers[i];
                if (c.name == name)
                    return c;
            }

            return null;
        }

        /// <summary>
        /// Removes a controller from the container. 
        /// </summary>
        /// <param name="c">Controller object.</param>
        public void RemoveController(Controller c)
        {
            int index = _controllers.IndexOf(c);
            if (index == -1)
                throw new Exception("controller not exists: " + c.name);

            c.parent = null;
            _controllers.RemoveAt(index);

            int cnt = _children.Count;
            for (int i = 0; i < cnt; ++i)
            {
                GObject child = _children[i];
                child.HandleControllerChanged(c);
            }
        }

        /// <summary>
        /// Returns controller list.
        /// </summary>
        /// <returns>Controller list</returns>
        public List<Controller> Controllers
        {
            get { return _controllers; }
        }

        /// <summary>
        /// Returns a transition object  at a certain index.
        /// </summary>
        /// <param name="index">Index</param>
        /// <returns>transition object.</returns>
        public Transition GetTransitionAt(int index)
        {
            return _transitions[index];
        }

        /// <summary>
        /// Returns a transition object at a certain name. 
        /// </summary>
        /// <param name="name">Name</param>
        /// <returns>Transition Object</returns>
        public Transition GetTransition(string name)
        {
            int cnt = _transitions.Count;
            for (int i = 0; i < cnt; ++i)
            {
                Transition trans = _transitions[i];
                if (trans.name == name)
                    return trans;
            }

            return null;
        }

        /// <summary>
        /// Returns transition list.
        /// </summary>
        /// <returns>Transition list</returns>
        public List<Transition> Transitions
        {
            get { return _transitions; }
        }

        internal void ChildStateChanged(GObject child)
        {
            if (_buildingDisplayList)
                return;

            int cnt = _children.Count;

            if (child is GGroup)
            {
                for (int i = 0; i < cnt; ++i)
                {
                    GObject g = _children[i];
                    if (g.group == child)
                        ChildStateChanged(g);
                }
                return;
            }

            if (child.displayObject == null)
                return;

            if (child.internalVisible)
            {
                if (child.displayObject.parent == null)
                {
                    if (_childrenRenderOrder == ChildrenRenderOrder.Ascent)
                    {
                        int index = 0;
                        for (int i = 0; i < cnt; i++)
                        {
                            GObject g = _children[i];
                            if (g == child)
                                break;

                            if (g.displayObject != null && g.displayObject.parent != null)
                                index++;
                        }
                        container.AddChildAt(child.displayObject, index);
                    }
                    else if (_childrenRenderOrder == ChildrenRenderOrder.Descent)
                    {
                        int index = 0;
                        for (int i = cnt - 1; i >= 0; i--)
                        {
                            GObject g = _children[i];
                            if (g == child)
                                break;

                            if (g.displayObject != null && g.displayObject.parent != null)
                                index++;
                        }
                        container.AddChildAt(child.displayObject, index);
                    }
                    else
                    {
                        container.AddChild(child.displayObject);

                        UpdateContext.OnBegin -= _buildDelegate;
                        UpdateContext.OnBegin += _buildDelegate;
                    }
                }
            }
            else
            {
                if (child.displayObject.parent != null)
                {
                    container.RemoveChild(child.displayObject);
                    if (_childrenRenderOrder == ChildrenRenderOrder.Arch)
                    {
                        UpdateContext.OnBegin -= _buildDelegate;
                        UpdateContext.OnBegin += _buildDelegate;
                    }
                }
            }
        }

        void BuildNativeDisplayList()
        {
            if (displayObject == null || displayObject.isDisposed)
                return;

            int cnt = _children.Count;
            if (cnt == 0)
                return;

            switch (_childrenRenderOrder)
            {
                case ChildrenRenderOrder.Ascent:
                    {
                        for (int i = 0; i < cnt; i++)
                        {
                            GObject child = _children[i];
                            if (child.displayObject != null && child.internalVisible)
                                container.AddChild(child.displayObject);
                        }
                    }
                    break;
                case ChildrenRenderOrder.Descent:
                    {
                        for (int i = cnt - 1; i >= 0; i--)
                        {
                            GObject child = _children[i];
                            if (child.displayObject != null && child.internalVisible)
                                container.AddChild(child.displayObject);
                        }
                    }
                    break;

                case ChildrenRenderOrder.Arch:
                    {
                        int apex = Mathf.Clamp(_apexIndex, 0, cnt);
                        for (int i = 0; i < apex; i++)
                        {
                            GObject child = _children[i];
                            if (child.displayObject != null && child.internalVisible)
                                container.AddChild(child.displayObject);
                        }
                        for (int i = cnt - 1; i >= apex; i--)
                        {
                            GObject child = _children[i];
                            if (child.displayObject != null && child.internalVisible)
                                container.AddChild(child.displayObject);
                        }
                    }
                    break;
            }
        }

        internal void ApplyController(Controller c)
        {
            _applyingController = c;
            int cnt = _children.Count;
            for (int i = 0; i < cnt; ++i)
            {
                GObject child = _children[i];
                child.HandleControllerChanged(c);
            }
            _applyingController = null;

            c.RunActions();
        }

        void ApplyAllControllers()
        {
            int cnt = _controllers.Count;
            for (int i = 0; i < cnt; ++i)
            {
                Controller controller = _controllers[i];
                ApplyController(controller);
            }
        }

        internal void AdjustRadioGroupDepth(GObject obj, Controller c)
        {
            int cnt = _children.Count;
            int i;
            GObject child;
            int myIndex = -1, maxIndex = -1;
            for (i = 0; i < cnt; i++)
            {
                child = _children[i];
                if (child == obj)
                {
                    myIndex = i;
                }
                else if ((child is GButton)
                    && ((GButton)child).relatedController == c)
                {
                    if (i > maxIndex)
                        maxIndex = i;
                }
            }
            if (myIndex < maxIndex)
            {
                if (_applyingController != null)
                    _children[maxIndex].HandleControllerChanged(_applyingController);
                this.SwapChildrenAt(myIndex, maxIndex);
            }
        }

        /// <summary>
        /// If clipping softness is set, clipped containers will have soft border effect.
        /// </summary>
        public Vector2 clipSoftness
        {
            get { return _clipSoftness; }
            set
            {
                _clipSoftness = value;
                if (scrollPane != null)
                    scrollPane.UpdateClipSoft();
                else if (_clipSoftness.x > 0 || _clipSoftness.y > 0)
                    rootContainer.clipSoftness = new Vector4(value.x, value.y, value.x, value.y);
                else
                    rootContainer.clipSoftness = null;
            }
        }

        /// <summary>
        /// The mask of the component.
        /// </summary>
        public DisplayObject mask
        {
            get { return container.mask; }
            set
            {
                container.mask = value;
                if (value != null && value.parent != container)
                    container.AddChild(value);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public bool reversedMask
        {
            get { return container.reversedMask; }
            set { container.reversedMask = value; }
        }

        /// <summary>
        /// 
        /// </summary>
        public string baseUserData
        {
            get
            {
                ByteBuffer buffer = packageItem.rawData;
                buffer.Seek(0, 4);
                return buffer.ReadS();
            }
        }

        /// <summary>
        /// Test if a child is in view.
        /// </summary>
        /// <param name="child">A child object</param>
        /// <returns>True if in view</returns>
        public bool IsChildInView(GObject child)
        {
            if (scrollPane != null)
            {
                return scrollPane.IsChildInView(child);
            }
            else if (rootContainer.clipRect != null)
            {
                return child.x + child.width >= 0 && child.x <= this.width
                    && child.y + child.height >= 0 && child.y <= this.height;
            }
            else
                return true;
        }

        virtual public int GetFirstChildInView()
        {
            int cnt = _children.Count;
            for (int i = 0; i < cnt; ++i)
            {
                GObject child = _children[i];
                if (IsChildInView(child))
                    return i;
            }
            return -1;
        }

        protected void SetupScroll(ByteBuffer buffer)
        {
            if (rootContainer == container)
            {
                container = new Container();
                rootContainer.AddChild(container);
            }

            scrollPane = new ScrollPane(this);
            scrollPane.Setup(buffer);
        }

        protected void SetupOverflow(OverflowType overflow)
        {
            if (overflow == OverflowType.Hidden)
            {
                if (rootContainer == container)
                {
                    container = new Container();
                    rootContainer.AddChild(container);
                }

                UpdateClipRect();
                container.SetXY(_margin.left, _margin.top);
            }
            else if (_margin.left != 0 || _margin.top != 0)
            {
                if (rootContainer == container)
                {
                    container = new Container();
                    rootContainer.AddChild(container);
                }

                container.SetXY(_margin.left, _margin.top);
            }
        }

        void UpdateClipRect()
        {
            if (scrollPane == null)
            {
                float w = this.width - (_margin.left + _margin.right);
                float h = this.height - (_margin.top + _margin.bottom);
                rootContainer.clipRect = new Rect(_margin.left, _margin.top, w, h);
            }
            else
                rootContainer.clipRect = new Rect(0, 0, this.width, this.height);
        }

        override protected void HandleSizeChanged()
        {
            base.HandleSizeChanged();

            if (scrollPane != null)
                scrollPane.OnOwnerSizeChanged();
            if (rootContainer.clipRect != null)
                UpdateClipRect();
        }

        override protected void HandleGrayedChanged()
        {
            Controller cc = GetController("grayed");
            if (cc != null)
                cc.selectedIndex = this.grayed ? 1 : 0;
            else
                base.HandleGrayedChanged();
        }

        override public void HandleControllerChanged(Controller c)
        {
            base.HandleControllerChanged(c);

            if (scrollPane != null)
                scrollPane.HandleControllerChanged(c);
        }

        /// <summary>
        /// Notify the component the bounds should recaculate.
        /// </summary>
        public void SetBoundsChangedFlag()
        {
            if (scrollPane == null && !_trackBounds)
                return;

            _boundsChanged = true;
        }

        /// <summary>
        /// Make sure the bounds of the component is correct. 
        /// Bounds of the component is not updated on every changed. For example, you add a new child to the list, children in the list will be rearranged in next frame.
        /// If you want to access the correct child position immediatelly, call this function first.
        /// </summary>
        public void EnsureBoundsCorrect()
        {
            if (_boundsChanged)
                UpdateBounds();
        }

        virtual protected void UpdateBounds()
        {
            float ax, ay, aw, ah;
            if (_children.Count > 0)
            {
                ax = int.MaxValue;
                ay = int.MaxValue;
                float ar = int.MinValue, ab = int.MinValue;
                float tmp;

                int cnt = _children.Count;
                for (int i = 0; i < cnt; ++i)
                {
                    GObject child = _children[i];
                    tmp = child.x;
                    if (tmp < ax)
                        ax = tmp;
                    tmp = child.y;
                    if (tmp < ay)
                        ay = tmp;
                    tmp = child.x + child.actualWidth;
                    if (tmp > ar)
                        ar = tmp;
                    tmp = child.y + child.actualHeight;
                    if (tmp > ab)
                        ab = tmp;
                }
                aw = ar - ax;
                ah = ab - ay;
            }
            else
            {
                ax = 0;
                ay = 0;
                aw = 0;
                ah = 0;
            }

            SetBounds(ax, ay, aw, ah);
        }

        protected void SetBounds(float ax, float ay, float aw, float ah)
        {
            _boundsChanged = false;
            if (scrollPane != null)
                scrollPane.SetContentSize(Mathf.RoundToInt(ax + aw), Mathf.RoundToInt(ay + ah));
        }

        /// <summary>
        /// Viwe port width of the container.
        /// </summary>
        public float viewWidth
        {
            get
            {
                if (scrollPane != null)
                    return scrollPane.viewWidth;
                else
                    return this.width - _margin.left - _margin.right;
            }

            set
            {
                if (scrollPane != null)
                    scrollPane.viewWidth = value;
                else
                    this.width = value + _margin.left + _margin.right;
            }
        }

        /// <summary>
        /// View port height of the container.
        /// </summary>
        public float viewHeight
        {
            get
            {
                if (scrollPane != null)
                    return scrollPane.viewHeight;
                else
                    return this.height - _margin.top - _margin.bottom;
            }

            set
            {
                if (scrollPane != null)
                    scrollPane.viewHeight = value;
                else
                    this.height = value + _margin.top + _margin.bottom;
            }
        }

        public void GetSnappingPosition(ref float xValue, ref float yValue)
        {
            GetSnappingPositionWithDir(ref xValue, ref yValue, 0, 0);
        }

        protected bool ShouldSnapToNext(float dir, float delta, float size)
        {
            return dir < 0 && delta > UIConfig.defaultScrollSnappingThreshold * size
                || dir > 0 && delta > (1 - UIConfig.defaultScrollSnappingThreshold) * size
                || dir == 0 && delta > size / 2;
        }

        /**
        * dir正数表示右移或者下移，负数表示左移或者上移
        */
        virtual public void GetSnappingPositionWithDir(ref float xValue, ref float yValue, float xDir, float yDir)
        {
            int cnt = _children.Count;
            if (cnt == 0)
                return;

            EnsureBoundsCorrect();

            GObject obj = null;

            int i = 0;
            if (yValue != 0)
            {
                for (; i < cnt; i++)
                {
                    obj = _children[i];
                    if (yValue < obj.y)
                    {
                        if (i == 0)
                        {
                            yValue = 0;
                            break;
                        }
                        else
                        {
                            GObject prev = _children[i - 1];
                            if (ShouldSnapToNext(yDir, yValue - prev.y, prev.height))
                                yValue = obj.y;
                            else
                                yValue = prev.y;
                            break;
                        }
                    }
                }

                if (i == cnt)
                    yValue = obj.y;
            }

            if (xValue != 0)
            {
                if (i > 0)
                    i--;
                for (; i < cnt; i++)
                {
                    obj = _children[i];
                    if (xValue < obj.x)
                    {
                        if (i == 0)
                        {
                            xValue = 0;
                            break;
                        }
                        else
                        {
                            GObject prev = _children[i - 1];
                            if (ShouldSnapToNext(xDir, xValue - prev.x, prev.width))
                                xValue = obj.x;
                            else
                                xValue = prev.x;
                            break;
                        }
                    }
                }
                if (i == cnt)
                    xValue = obj.x;
            }
        }

        internal void ChildSortingOrderChanged(GObject child, int oldValue, int newValue)
        {
            if (newValue == 0)
            {
                _sortingChildCount--;
                SetChildIndex(child, _children.Count);
            }
            else
            {
                if (oldValue == 0)
                    _sortingChildCount++;

                int oldIndex = _children.IndexOf(child);
                int index = GetInsertPosForSortingChild(child);
                if (oldIndex < index)
                    _SetChildIndex(child, oldIndex, index - 1);
                else
                    _SetChildIndex(child, oldIndex, index);
            }
        }

        /// <summary>
        /// 每帧调用的一个回调。如果你要override，请记住以下两点：
        /// 1、记得调用base.onUpdate;
        /// 2、不要在方法里进行任何会更改显示列表的操作，例如AddChild、RemoveChild、visible等。
        /// </summary>
        virtual protected void OnUpdate()
        {
            if (_boundsChanged)
                UpdateBounds();
        }

        override public void ConstructFromResource()
        {
            ConstructFromResource(null, 0);
        }

        internal void ConstructFromResource(List<GObject> objectPool, int poolIndex)
        {
            this.gameObjectName = packageItem.name;

            PackageItem contentItem = packageItem.getBranch();

            if (!contentItem.translated)
            {
                contentItem.translated = true;
                TranslationHelper.TranslateComponent(contentItem);
            }

            ByteBuffer buffer = contentItem.rawData;
            buffer.Seek(0, 0);

            underConstruct = true;

            sourceWidth = buffer.ReadInt();
            sourceHeight = buffer.ReadInt();
            initWidth = sourceWidth;
            initHeight = sourceHeight;

            SetSize(sourceWidth, sourceHeight);

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

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

            if (buffer.ReadBool())
            {
                _margin.top = buffer.ReadInt();
                _margin.bottom = buffer.ReadInt();
                _margin.left = buffer.ReadInt();
                _margin.right = buffer.ReadInt();
            }

            OverflowType overflow = (OverflowType)buffer.ReadByte();
            if (overflow == OverflowType.Scroll)
            {
                int savedPos = buffer.position;
                buffer.Seek(0, 7);
                SetupScroll(buffer);
                buffer.position = savedPos;
            }
            else
                SetupOverflow(overflow);

            if (buffer.ReadBool())
            {
                int i1 = buffer.ReadInt();
                int i2 = buffer.ReadInt();
                this.clipSoftness = new Vector2(i1, i2);
            }

            _buildingDisplayList = true;

            buffer.Seek(0, 1);

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

                Controller controller = new Controller();
                _controllers.Add(controller);
                controller.parent = this;
                controller.Setup(buffer);

                buffer.position = nextPos;
            }

            buffer.Seek(0, 2);

            GObject child;
            int childCount = buffer.ReadShort();
            for (int i = 0; i < childCount; i++)
            {
                int dataLen = buffer.ReadShort();
                int curPos = buffer.position;

                if (objectPool != null)
                    child = objectPool[poolIndex + i];
                else
                {
                    buffer.Seek(curPos, 0);

                    ObjectType type = (ObjectType)buffer.ReadByte();
                    string src = buffer.ReadS();
                    string pkgId = buffer.ReadS();

                    PackageItem pi = null;
                    if (src != null)
                    {
                        UIPackage pkg;
                        if (pkgId != null)
                            pkg = UIPackage.GetById(pkgId);
                        else
                            pkg = contentItem.owner;

                        pi = pkg != null ? pkg.GetItem(src) : null;
                    }

                    if (pi != null)
                    {
                        child = UIObjectFactory.NewObject(pi);
                        child.ConstructFromResource();
                    }
                    else
                        child = UIObjectFactory.NewObject(type);
                }

                child.underConstruct = true;
                child.Setup_BeforeAdd(buffer, curPos);
                child.InternalSetParent(this);
                _children.Add(child);

                buffer.position = curPos + dataLen;
            }

            buffer.Seek(0, 3);
            this.relations.Setup(buffer, true);

            buffer.Seek(0, 2);
            buffer.Skip(2);

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

                buffer.Seek(buffer.position, 3);
                _children[i].relations.Setup(buffer, false);

                buffer.position = nextPos;
            }

            buffer.Seek(0, 2);
            buffer.Skip(2);

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

                child = _children[i];
                child.Setup_AfterAdd(buffer, buffer.position);
                child.underConstruct = false;
                if (child.displayObject != null)
                    child.displayObject.cachedTransform.SetParent(this.displayObject.cachedTransform, false);

                buffer.position = nextPos;
            }

            buffer.Seek(0, 4);

            buffer.Skip(2); //customData
            this.opaque = buffer.ReadBool();
            int maskId = buffer.ReadShort();
            if (maskId != -1)
            {
                container.mask = GetChildAt(maskId).displayObject;
                if (buffer.ReadBool())
                    container.reversedMask = true;
            }

            {
                string hitTestId = buffer.ReadS();
                int i1 = buffer.ReadInt();
                int i2 = buffer.ReadInt();
                if (hitTestId != null)
                {
                    PackageItem pi = contentItem.owner.GetItem(hitTestId);
                    if (pi != null && pi.pixelHitTestData != null)
                        rootContainer.hitArea = new PixelHitTest(pi.pixelHitTestData, i1, i2, sourceWidth, sourceHeight);
                }
                else if (i1 != 0 && i2 != -1)
                {
                    rootContainer.hitArea = new ShapeHitTest(this.GetChildAt(i2).displayObject);
                }
            }

            if (buffer.version >= 5)
            {
                string str = buffer.ReadS();
                if (!string.IsNullOrEmpty(str))
                    this.onAddedToStage.Add(() => __playSound(str, 1));

                string str2 = buffer.ReadS();
                if (!string.IsNullOrEmpty(str2))
                    this.onRemovedFromStage.Add(() => __playSound(str2, 1));
            }

            buffer.Seek(0, 5);

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

                Transition trans = new Transition(this);
                trans.Setup(buffer);
                _transitions.Add(trans);

                buffer.position = nextPos;
            }

            if (_transitions.Count > 0)
            {
                this.onAddedToStage.Add(__addedToStage);
                this.onRemovedFromStage.Add(__removedFromStage);
            }

            ApplyAllControllers();

            _buildingDisplayList = false;
            underConstruct = false;

            BuildNativeDisplayList();
            SetBoundsChangedFlag();

            if (contentItem.objectType != ObjectType.Component)
                ConstructExtension(buffer);

            ConstructFromXML(null);

#if FAIRYGUI_TOLUA
            CallLua("ctor");
#endif
#if FAIRYGUI_PUERTS
            if (__onConstruct != null)
                __onConstruct();
#endif
        }

        virtual protected void ConstructExtension(ByteBuffer buffer)
        {
        }

        /// <summary>
        /// Method for extensions to override
        /// </summary>
        /// <param name="xml"></param>
        virtual public void ConstructFromXML(XML xml)
        {
        }

        public override void Setup_AfterAdd(ByteBuffer buffer, int beginPos)
        {
            base.Setup_AfterAdd(buffer, beginPos);

            buffer.Seek(beginPos, 4);

            int pageController = buffer.ReadShort();
            if (pageController != -1 && scrollPane != null && scrollPane.pageMode)
                scrollPane.pageController = parent.GetControllerAt(pageController);

            int cnt = buffer.ReadShort();
            for (int i = 0; i < cnt; i++)
            {
                Controller cc = GetController(buffer.ReadS());
                string pageId = buffer.ReadS();
                if (cc != null)
                    cc.selectedPageId = pageId;
            }

            if (buffer.version >= 2)
            {
                cnt = buffer.ReadShort();
                for (int i = 0; i < cnt; i++)
                {
                    string target = buffer.ReadS();
                    int propertyId = buffer.ReadShort();
                    string value = buffer.ReadS();
                    GObject obj = this.GetChildByPath(target);
                    if (obj != null)
                    {
                        if (propertyId == 0)
                            obj.text = value;
                        else if (propertyId == 1)
                            obj.icon = value;
                    }
                }
            }
        }

        void __playSound(string soundRes, float volumeScale)
        {
            NAudioClip sound = UIPackage.GetItemAssetByURL(soundRes) as NAudioClip;
            if (sound != null && sound.nativeClip != null)
                Stage.inst.PlayOneShotSound(sound.nativeClip, volumeScale);
        }

        void __addedToStage()
        {
            int cnt = _transitions.Count;
            for (int i = 0; i < cnt; ++i)
                _transitions[i].OnOwnerAddedToStage();
        }

        void __removedFromStage()
        {
            int cnt = _transitions.Count;
            for (int i = 0; i < cnt; ++i)
                _transitions[i].OnOwnerRemovedFromStage();
        }

#if FAIRYGUI_TOLUA
        internal LuaTable _peerTable;

        public void SetLuaPeer(LuaTable peerTable)
        {
            _peerTable = peerTable;
        }

        [NoToLua]
        public bool CallLua(string funcName)
        {
            if (_peerTable != null)
            {
                LuaFunction ctor = _peerTable.GetLuaFunction(funcName);
                if (ctor != null)
                {
                    try
                    {
                        ctor.Call(this);
                    }
                    catch (Exception err)
                    {
                        Debug.LogError(err);
                    }
                    
                    ctor.Dispose();
                    return true;
                }
            }

            return false;
        }
#endif

#if FAIRYGUI_PUERTS
        public Action __onConstruct;
        public Action __onDispose;
#endif
    }
}