ylsj/Assets/Scripts/Tools/UGUI/UIWarpContent.cs

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using UnityEngine.UI;

/// <summary>
/// 滚动列表优化
/// </summary>
[DisallowMultipleComponent]
public class UIWarpContent : MonoBehaviour
{
    /// <summary>
    /// 元素初始化
    /// </summary>
    /// <param name="go"> 游戏对象 </param>
    /// <param name="dataIndex"> 数据索引 </param>
    public delegate void OnInitializeItem(GameObject go, int dataIndex);

    /// <summary>
    /// 元素初始化
    /// </summary>
    public OnInitializeItem onInitializeItem;

    /// <summary>
    /// 排列
    /// </summary>
    public enum Arrangement
    {
        /// <summary>
        /// 横
        /// </summary>
        Horizontal,

        /// <summary>
        /// 竖
        /// </summary>
        Vertical,
    }

    /// <summary>
    /// 排列
    /// </summary>
    public Arrangement arrangement = Arrangement.Horizontal;

    /// <summary>
    /// Maximum children per line.
    /// If the arrangement is horizontal, this denotes the number of columns.
    /// If the arrangement is vertical, this stands for the number of rows.
    /// </summary>
    [Range(1, 50)]
    public int maxPerLine = 1;

    /// <summary>
    /// The width of each of the cells.
    /// </summary>
    public float cellWidth = 200f;

    /// <summary>
    /// The height of each of the cells.
    /// </summary>
    public float cellHeight = 200f;

    /// <summary>
    /// The Width Space of each of the cells.
    /// </summary>
    [Range(0, 50)]
    public float cellWidthSpace = 0f;

    /// <summary>
    /// The Height Space of each of the cells.
    /// </summary>
    [Range(0, 50)]
    public float cellHeightSpace = 0f;

    /// <summary>
    /// 窗口能容纳的 行数 或 列数
    /// </summary>
    [Range(0, 30)]
    public int viewCount = 5;

    /// <summary>
    /// scroll view 对象
    /// </summary>
    public ScrollRect scrollRect = null;

    /// <summary>
    /// content 对象
    /// </summary>
    public RectTransform content = null;

    /// <summary>
    /// 元素预制物体
    /// </summary>
    public GameObject goItemPrefab = null;

    /// <summary>
    /// 数据的数量
    /// </summary>
    private int mDataCount = 0;

    /// <summary>
    /// 当前所处的行数
    /// </summary>
    private int curScrollPerLineIndex = -1;

    /// <summary>
    /// 正在使用中的元素
    /// </summary>
    private List<UIWarpContentItem> listItem = new List<UIWarpContentItem>();

    /// <summary>
    /// 未在使用中的元素
    /// </summary>
    private Queue<UIWarpContentItem> unUseItem = new Queue<UIWarpContentItem>();

    /// <summary>
    /// 初始化
    /// </summary>
    private void Awake()
    {
    }

    /// <summary>
    /// 初始化
    /// </summary>
    /// <param name="dataCount"> 数据的数量 </param>
    public void Init(int dataCount)
    {
        if (scrollRect == null || content == null || goItemPrefab == null)
        {
             Debug.LogError("异常:请检测<" + gameObject.name + ">对象上UIWarpContent对应ScrollRect、Content、GoItemPrefab 是否存在值...." + scrollRect + " _" + content + "_" + goItemPrefab);
            return;
        }

        // 不显示元素预制物体
        goItemPrefab.SetActive(false);

        scrollRect.onValueChanged.RemoveAllListeners();
        scrollRect.onValueChanged.AddListener(onValueChanged);

        // 如果数据数量为 0 ，没有初始化的必要
        if (dataCount <= 0)
        {
            return;
        }

        // 设置数据的数量，并计算 content 的尺寸
        setDataCount(dataCount);

        unUseItem.Clear();
        listItem.Clear();

        setUpdateRectItem(0);
    }

    /// <summary>
    /// 数据改变了，比如切换分类功能，全部，前排，中排，后排，元素要重新获取数据
    /// </summary>
    /// <param name="dataCount"> 数据的数量 </param>
    /// <param name="bResetPos"> 是否返回初始位置 </param>
    public void DataChange(int dataCount, bool bResetPos)
    {
        if (scrollRect == null || content == null || goItemPrefab == null)
        {
             Debug.LogError("异常:请检测<" + gameObject.name + ">对象上UIWarpContent对应ScrollRect、Content、GoItemPrefab 是否存在值...." + scrollRect + " _" + content + "_" + goItemPrefab);
            return;
        }

        // 重新设置数量，重新计算 content 的尺寸
        setDataCount(dataCount);


        // 因为数据改变了，元素要重新获取数据
        for (int i = listItem.Count - 1; i >= 0; i--)
        {
            UIWarpContentItem item = listItem[i];

            item.Index = -1;
            listItem.Remove(item);
            unUseItem.Enqueue(item);
        }

        if (bResetPos)
        {
            content.anchoredPosition = Vector3.zero;
        }

        // 计算当前所处的行数，刷新
        int _curScrollPerLineIndex = getCurScrollPerLineIndex();
        setUpdateRectItem(_curScrollPerLineIndex);
    }

    /// <summary>
    /// 设置数据的数量，并重新计算 content 的尺寸
    /// </summary>
    /// <param name="count"> 数据的数量 </param>
    private void setDataCount(int count)
    {
        if (mDataCount == count)
        {
            return;
        }
        mDataCount = count;

        // 计算 content 的尺寸
        setUpdateContentSize();
    }

    /// <summary>
    /// scroll view 拖动时触发
    /// </summary>
    /// <param name="vt2"> 拖动数值 </param>
    private void onValueChanged(Vector2 vt2)
    {
        int _curScrollPerLineIndex = getCurScrollPerLineIndex();
        if (_curScrollPerLineIndex == curScrollPerLineIndex)
        {
            return;
        }

        setUpdateRectItem(_curScrollPerLineIndex);
    }

    /// <summary>
    /// 刷新元素
    /// </summary>
    /// <param name="scrollPerLineIndex"> 当前所处的行数 </param>
    private void setUpdateRectItem(int scrollPerLineIndex)
    {
        if (scrollPerLineIndex < 0)
        {
            return;
        }

        curScrollPerLineIndex = scrollPerLineIndex;
        int startDataIndex = curScrollPerLineIndex * maxPerLine;
        int endDataIndex = (curScrollPerLineIndex + viewCount) * maxPerLine;

        // 移除
        for (int i = listItem.Count - 1; i >= 0; i--)
        {
            UIWarpContentItem item = listItem[i];
            int index = item.Index;
            if (index < startDataIndex || index >= endDataIndex)
            {
                item.Index = -1;
                listItem.Remove(item);
                unUseItem.Enqueue(item);
            }
        }

        // 显示
        for (int dataIndex = startDataIndex; dataIndex < endDataIndex; dataIndex++)
        {
            if (dataIndex >= mDataCount)
            {
                continue;
            }

            if (isExistDataByDataIndex(dataIndex))
            {
                continue;
            }
            createItem(dataIndex);
        }
    }

    /// <summary>
    /// 添加当前数据索引数据
    /// </summary>
    /// <param name="dataIndex"> 数据索引 </param>
    public void AddItem(int dataIndex)
    {
        if (dataIndex < 0 || dataIndex > mDataCount)
        {
            return;
        }

        // 检测是否需添加gameObject
        bool isNeedAdd = false;
        for (int i = listItem.Count - 1; i >= 0; i--)
        {
            UIWarpContentItem item = listItem[i];
            if (item.Index >= (mDataCount - 1))
            {
                isNeedAdd = true;
                break;
            }
        }

        setDataCount(mDataCount + 1);

        if (isNeedAdd)
        {
            for (int i = 0; i < listItem.Count; i++)
            {
                UIWarpContentItem item = listItem[i];
                int oldIndex = item.Index;
                if (oldIndex >= dataIndex)
                {
                    item.Index = oldIndex + 1;
                }

                item = null;
            }

            setUpdateRectItem(getCurScrollPerLineIndex());
        }
        else
        {
            // 重新刷新数据
            for (int i = 0; i < listItem.Count; i++)
            {
                UIWarpContentItem item = listItem[i];
                int oldIndex = item.Index;
                if (oldIndex >= dataIndex)
                {
                    item.Index = oldIndex;
                }

                item = null;
            }
        }
    }

    /// <summary>
    /// 删除当前数据索引下数据
    /// </summary>
    /// <param name="dataIndex"> 数据索引 </param>
    public void DelItem(int dataIndex)
    {
        if (dataIndex < 0 || dataIndex >= mDataCount)
        {
            return;
        }

        ////删除item逻辑三种情况
        ////1.只更新数据，不销毁gameObject,也不移除gameobject
        ////2.更新数据，且移除gameObject,不销毁gameObject
        ////3.更新数据，销毁gameObject

        bool isNeedDestroyGameObject = (listItem.Count >= mDataCount);
        setDataCount(mDataCount - 1);

        for (int i = listItem.Count - 1; i >= 0; i--)
        {
            UIWarpContentItem item = listItem[i];
            int oldIndex = item.Index;
            if (oldIndex == dataIndex)
            {
                listItem.Remove(item);
                if (isNeedDestroyGameObject)
                {
                    GameObject.Destroy(item.gameObject);
                }
                else
                {
                    item.Index = -1;
                    unUseItem.Enqueue(item);
                }
            }

            if (oldIndex > dataIndex)
            {
                item.Index = oldIndex - 1;
            }
        }

        setUpdateRectItem(getCurScrollPerLineIndex());
    }

    /// <summary>
    /// 根据数据索引计算在 content 下的 local position
    /// </summary>
    /// <param name="index"> 数据索引 </param>
    /// <returns> 位置 </returns>
    public Vector3 getLocalPositionByIndex(int index)
    {
        if (index < 0)
        {
            return new Vector3(-2000.0f, 2000.0f, 0.0f);
        }

        float x = 0f;
        float y = 0f;
        float z = 0f;

        switch (arrangement)
        {
            // 水平方向
            case Arrangement.Horizontal:
                {
                    x = (index / maxPerLine) * (cellWidth + cellWidthSpace);
                    y = -(index % maxPerLine) * (cellHeight + cellHeightSpace);
                }

                break;

            // 垂着方向
            case Arrangement.Vertical:
                {
                    x = (index % maxPerLine) * (cellWidth + cellWidthSpace);
                    y = -(index / maxPerLine) * (cellHeight + cellHeightSpace);
                }

                break;

            default:
                {
                    // 不需要处理
                }

                break;
        }

        return new Vector3(x, y, z);
    }

    /// <summary>
    /// 创建元素
    /// </summary>
    /// <param name="dataIndex"> 数据索引 </param>
    private void createItem(int dataIndex)
    {
        UIWarpContentItem item = null;
        if (unUseItem.Count > 0)
        {
            item = unUseItem.Dequeue();
        }
        else
        {
            GameObject temp = addChild(goItemPrefab, content);
            item = temp.GetComponent<UIWarpContentItem>();
            if (item == null)
            {
                AssemblyHelper.Instance.BindScript("UIWarpContentItem", temp);
                item = temp.GetComponent<UIWarpContentItem>();
            }
        }

        item.WarpContent = this;
        item.Index = dataIndex;
        listItem.Add(item);
    }

    /// <summary>
    /// 当前数据是否存在 List 中
    /// </summary>
    /// <param name="dataIndex"> 数据索引 </param>
    /// <returns> 是否已存在 </returns>
    private bool isExistDataByDataIndex(int dataIndex)
    {
        if (listItem == null || listItem.Count <= 0)
        {
            return false;
        }

        for (int i = 0; i < listItem.Count; i++)
        {
            if (listItem[i].Index == dataIndex)
            {
                return true;
            }
        }

        return false;
    }

    /// <summary>
    /// 根据Content偏移,计算当前开始显示所在数据列表中的行或列
    /// </summary>
    /// <returns> 行数 或 列数 </returns>
    private int getCurScrollPerLineIndex()
    {
        int result = 0;

        switch (arrangement)
        {
            // 水平方向
            case Arrangement.Horizontal:
                {
                    result = Mathf.FloorToInt(-(content.anchoredPosition.x) / (cellWidth + cellWidthSpace));
                }

                break;

            // 垂着方向
            case Arrangement.Vertical:
                {
                    result = Mathf.FloorToInt((content.anchoredPosition.y) / (cellHeight + cellHeightSpace));
                }

                break;

            default:
                {
                    // 不需要处理
                }

                break;
        }

        if (result < 0)
        {
            result = 0;
        }

        return result;
    }

    /// <summary>
    /// 计算 content 的尺寸
    /// </summary>
    private void setUpdateContentSize()
    {
        // 行数，向上取整
        int lineCount = Mathf.CeilToInt((float)mDataCount / maxPerLine);

        switch (arrangement)
        {
            case Arrangement.Horizontal:
                {
                    content.sizeDelta = new Vector2((cellWidth * lineCount) + (cellWidthSpace * (lineCount - 1)), content.sizeDelta.y);
                }

                break;

            case Arrangement.Vertical:
                {
                    content.sizeDelta = new Vector2(content.sizeDelta.x, (cellHeight * lineCount) + (cellHeightSpace * (lineCount - 1)));
                }

                break;

            default:
                {
                    // 不需要处理
                }

                break;
        }
    }

    /// <summary>
    /// 实例化预设对象 、添加实例化对象到指定的子对象下
    /// </summary>
    /// <param name="goPrefab"> 元素预制物体 </param>
    /// <param name="parent"> 父节点 </param>
    /// <returns> 新创建的元素对象 </returns>
    private GameObject addChild(GameObject goPrefab, Transform parent)
    {
        if (goPrefab == null || parent == null)
        {
             Debug.LogError("异常。UIWarpContent.cs addChild(goPrefab = null  || parent = null)");
            return null;
        }

        GameObject goChild = GameObject.Instantiate(goPrefab) as GameObject;
        goChild.transform.SetParent(parent, false);
        goChild.SetActive(true);

        return goChild;
    }

    /// <summary>
    /// 销毁
    /// </summary>
    private void OnDestroy()
    {
        scrollRect = null;
        content = null;
        goItemPrefab = null;
        onInitializeItem = null;

        listItem.Clear();
        unUseItem.Clear();

        listItem = null;
        unUseItem = null;
    }


    public void SetContentToEnd()
    {
        float x = 0, y = 0;

        RectTransform temp = scrollRect.GetComponent<RectTransform>();
        if (scrollRect.content.sizeDelta.x > temp.sizeDelta.x)
        {
            x = scrollRect.content.sizeDelta.x - temp.sizeDelta.x;
        }
        if (scrollRect.content.sizeDelta.y > temp.sizeDelta.y)
        {
            y = scrollRect.content.sizeDelta.y - temp.sizeDelta.y;
        }

        switch (arrangement)
        {
            case Arrangement.Horizontal:
                {
                    y = 0;
                }
                break;
            case Arrangement.Vertical:
                {
                    x = 0;
                }
                break;
        }
         Debug.LogError("end::" + x + "  " + y);
        scrollRect.content.anchoredPosition =  new Vector2(x, y);
    }

}