无限列表【UIGridView】应用示例

最新推荐文章于 2022-04-09 17:45:29 发布
最新推荐文章于 2022-04-09 17:45:29 发布
阅读量287 收藏
点赞数
分类专栏： C# Unity 经验总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Le_Sam/article/details/106625039
版权
Unity 同时被 3 个专栏收录
66 篇文章 7 订阅
订阅专栏
C#
39 篇文章 1 订阅
订阅专栏
经验总结
36 篇文章 0 订阅
订阅专栏

 UIGridView 源码

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

//Introduction: 无限列表
//Content上禁止挂载ContentSizeFilter和LayOutGroup之类组件
[DisallowMultipleComponent]
[RequireComponent(typeof(ScrollRect))]
public class UIGridView : MonoBehaviour
{
    private Action<Transform, int> _handle;

    public enum Arrangement
    {
        Horizontal = 0,
        Vertical,
    }

    public enum HorizontalAlign
    {
        Left,
        Middle,
        Right,
    }

    public enum VerticalAlign
    {
        Top,
        Middle,
        Bottom,
    }
    public Arrangement arrangement = Arrangement.Vertical;

    // 当选择水平或垂直流动是有用，指每行/列最大个数
    public int MaxPerLine
    {
        get { return maxPerLine; }
        set { SetMaxPerLine(value); }
    }

    public HorizontalAlign horizontalAlign = HorizontalAlign.Left;
    public VerticalAlign verticalAlign = VerticalAlign.Top;
    public Vector2 viewPort;

    public float rowSpace = 0;
    public float columuSpace = 0;
    public float marginTop = 0;
    public float marginBottom = 0;
    public float marginLeft = 0;
    public float marginRight = 0;

    public int maxPerLine;
    public int childCount; //需要渲染的总数据个数
    public GameObject item;
    

    public GameObject Child
    {
        get { return item; }
        set { SetItem(value); }
    }

    public int ChildCount
    {
        get { return childCount; }
        set { SetChildCount(value, true); }
    }

    public Vector2 ViewPort
    {
        get { return viewPort; }
        set { SetViewPort(value); }
    }

    
    ScrollRect scrollRect;
       
    RectTransform content;
    Vector2 itemSize;
    List<Transform> items;
    Dictionary<int, int> contains;
    List<int> outOfContains;
    
    int scrollLineIndex; //当前第一个元素索引
    int totalCount; //在UI中显示的个数(不乘以maxPerLine)
    Vector2 startPos; //第一个元素所在位置
    int startIndex; //当前渲染起始坐标
    int endIndex; //当前渲染结束坐标
        

    void Start()
    {
        maxPerLine = maxPerLine == 0 ? 1 : maxPerLine;
        items = new List<Transform>();
        contains = new Dictionary<int, int>();
        outOfContains = new List<int>();
        scrollRect = transform.GetComponent<ScrollRect>();
        content = scrollRect.content;
        if (content == null)
        {
            Debug.Log("ScrollRect " + scrollRect.gameObject.name + " Has No Content, Please Check And Retry.");
            return;
        }
        //viewPort = scrollRect.viewport.rect.size;

        if (item != null)
            SetItem(item);

        content.anchorMax = new Vector2(0, 1);
        content.anchorMin = new Vector2(0, 1);
        content.pivot = new Vector2(0, 1);
        ReBuild();
    }

    public void ReBuild()
    {
        if (scrollRect == null || content == null || item == null) return;
        ResetChildren();

        Vector2 maskSize = viewPort;
        int count = 0;

        if (arrangement == Arrangement.Horizontal)
        {
            count = Mathf.CeilToInt(maskSize.x / itemSize.x) + 1; //横向列数
            startPos = Vector2.zero;
            startPos.x = marginLeft;
            if (verticalAlign == VerticalAlign.Top)
            {
                startPos.y = -marginTop;
            }
            else if (verticalAlign == VerticalAlign.Middle)
            {
                startPos.y = -(maskSize.y * 0.5f - (itemSize.y * maxPerLine + (maxPerLine - 1) * rowSpace) * 0.5f);
            }
            else if (verticalAlign == VerticalAlign.Bottom)
            {
                startPos.y = -(maskSize.y - marginBottom - itemSize.y * maxPerLine - rowSpace * (maxPerLine - 1));
            }
        }
        else if (arrangement == Arrangement.Vertical)
        {
            count = Mathf.CeilToInt(maskSize.y / itemSize.y) + 1; //竖向行数
            startPos = Vector2.zero;
            startPos.y = -marginTop; //重置开始节点位置
            if (horizontalAlign == HorizontalAlign.Left)
            {
                startPos.x = marginLeft;
            }
            else if (horizontalAlign == HorizontalAlign.Middle)
            {
                startPos.x = (maskSize.x * 0.5f - (itemSize.x * maxPerLine + (maxPerLine - 1) * columuSpace) * 0.5f);
            }
            else if (horizontalAlign == HorizontalAlign.Right)
            {
                startPos.x = maskSize.x - marginRight - itemSize.x * maxPerLine - columuSpace * (maxPerLine - 1);
            }
        }
        totalCount = count;

        SetChildCount(childCount, true);
        BackTop();

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


    //列表滚动
    private void OnValueChanged(Vector2 vec)
    {
        switch (arrangement)
        {
            case Arrangement.Horizontal:
                vec.x = Mathf.Clamp(vec.x, 0, 1);
                break;
            case Arrangement.Vertical:
                vec.y = Mathf.Clamp(vec.y, 0, 1);
                break;
        }

        int curLineIndex = GetCurLineIndex();
        if (curLineIndex != scrollLineIndex)
            UpdateRectItem(curLineIndex, false);
    }

    private int GetCurLineIndex()
    {
        switch (arrangement)
        {
            case Arrangement.Horizontal:
                return
                    Mathf.FloorToInt(Mathf.Abs(content.anchoredPosition.x < 0.1f ? content.anchoredPosition.x : 0.1f - marginLeft) /
                                        (columuSpace + itemSize.x));
            case Arrangement.Vertical:
                return
                    Mathf.FloorToInt(Mathf.Abs(content.anchoredPosition.y > -0.1f ? content.anchoredPosition.y : -0.1f - marginTop) /
                                        (rowSpace + itemSize.y));
        }
        return 0;
    }

    private void UpdateRectItem(int curLineIndex, bool forceRender)
    {
        if (curLineIndex < 0)
            return;
        startIndex = curLineIndex * maxPerLine;
        endIndex = (curLineIndex + totalCount) * maxPerLine;
        if (endIndex >= childCount)
            endIndex = childCount;

        contains.Clear(); //渲染序号
        outOfContains.Clear(); //items的索引
        for (int i = 0; i < items.Count; i++)//如果当前已渲染的item中包含
        {
            int index = int.Parse(items[i].gameObject.name);
            if (index < startIndex || index >= endIndex)
            {
                outOfContains.Add(i);
                items[i].gameObject.SetActive(false);
            }
            else
            {
                items[i].gameObject.SetActive(true);
                contains.Add(index, i);
            }
        }

        // *************更改渲染****************
        for (int i = startIndex; i < endIndex; i++)
        {
            if (!contains.ContainsKey(i))
            {
                Transform child = items[outOfContains[0]];
                outOfContains.RemoveAt(0);
                child.gameObject.SetActive(true);
                int row = i / maxPerLine;
                int col = i % maxPerLine;
                if (arrangement == Arrangement.Vertical)
                    child.localPosition = startPos +
                                            new Vector2(col * itemSize.x + (col) * columuSpace,
                                                -row * itemSize.y - (row) * rowSpace);
                else
                    child.localPosition = startPos +
                                            new Vector2(row * itemSize.x + (row) * columuSpace,
                                                -col * itemSize.y - (col) * rowSpace);
                child.gameObject.name = i.ToString();
                if (_handle != null)
                    _handle(child, i);
            }
            else if (forceRender)
            {
                if (_handle != null)
                    _handle(items[contains[i]], i);
            }
        }

        scrollLineIndex = curLineIndex;
    }

    /// 移除当前所有
    private void ResetChildren()
    {
        items.Clear();
        for (int i = 0; i < content.childCount; i++)
        {
            Transform child = content.GetChild(i);
            child.gameObject.SetActive(false);
        }
    }
    
    // 创建新节点
    private RectTransform CreateItem(int index)
    {
        Transform child;
        if (content.childCount > index)
        {
            child = content.GetChild(index);
        }
        else
        {
            GameObject obj = GameObject.Instantiate(item) as GameObject;
            obj.transform.SetParent(content);
            obj.transform.localScale = Vector3.one;
            child = obj.transform;
        }
        child.gameObject.name = index.ToString();
        items.Add(child);

        return child as RectTransform;
    }

    // 设置资源
    public void SetItem(GameObject child)
    {
        if (child == null) return;
        this.item = child;
        RectTransform itemTrans = child.transform as RectTransform;
        itemTrans.pivot = new Vector2(0, 1);
        itemSize = itemTrans.sizeDelta;
        //ReBuild();
    }

    // 更新需要渲染的个数
    public void SetChildCount(int value, bool forceRender)
    {
        if (value < 0) childCount = 0;
        else childCount = value;

        if (totalCount <= 0)//还未初始化
            return;
        if (value > items.Count && items.Count < maxPerLine * totalCount)
        {
            //当前格子数量少于应生成的数量
            int count = items.Count;
            int max = value < maxPerLine * totalCount ? value : maxPerLine * totalCount;
            for (int i = count; i < max; i++)
            {
                int row = i / maxPerLine;
                int col = i % maxPerLine;
                RectTransform child = CreateItem(i);
                if (arrangement == Arrangement.Vertical)
                    child.localPosition = startPos +
                                            new Vector2(col * itemSize.x + (col) * columuSpace,
                                                -row * itemSize.y - (row) * rowSpace);
                else
                    child.localPosition = startPos +
                                            new Vector2(row * itemSize.x + (row) * columuSpace,
                                                -col * itemSize.y - (col) * rowSpace);
            }
        }

        if (content == null) return;

        int rc = Mathf.CeilToInt((float)childCount / (float)maxPerLine); //设置content的大小
        if (arrangement == Arrangement.Horizontal)
        {
            content.sizeDelta = new Vector2(marginLeft + marginRight + itemSize.x * rc + columuSpace * (rc - 1),
                viewPort.y);
            if (content.sizeDelta.x > viewPort.x && content.anchoredPosition.x < viewPort.x - content.sizeDelta.x)
                content.anchoredPosition = new Vector2(viewPort.x - content.sizeDelta.x, content.anchoredPosition.y);
        }
        else
        {
            content.sizeDelta = new Vector2(viewPort.x, marginTop + marginBottom + itemSize.y * rc + rowSpace * (rc - 1));
            if (content.sizeDelta.y > viewPort.y && content.anchoredPosition.y > content.sizeDelta.y - viewPort.y)
                content.anchoredPosition = new Vector2(content.anchoredPosition.x, content.sizeDelta.y - viewPort.y);
        }
        UpdateRectItem(GetCurLineIndex(), true);
    }

    // 添加子节点
    public void AddChild(int index)
    {
        if (index < 0) return;
        startIndex = scrollLineIndex * maxPerLine;
        endIndex = (scrollLineIndex + totalCount) * maxPerLine;
        SetChildCount(childCount + 1, index >= startIndex && index < endIndex);
    }

    // 删除子节点
    public void RemoveChild(int index)
    {
        if (index < 0 || index >= childCount) return;
        startIndex = scrollLineIndex * maxPerLine;
        endIndex = (scrollLineIndex + totalCount) * maxPerLine;
        SetChildCount(childCount - 1, index >= startIndex && index < endIndex);
    }


    // <summary>
    // 设置显示窗口大小(现在貌似可以废弃了)
    public void SetViewPort(Vector2 port)
    {
        if (port == viewPort) return;
        viewPort = port;
        //ReBuild();
    }

    // 设置行列最大
    public void SetMaxPerLine(int max)
    {
        maxPerLine = max;
        //ReBuild();
    }
    
    // 返回顶部
    public void BackTop()
    {
        content.localPosition = Vector3.zero;
        UpdateRectItem(0, true);
    }


    // 返回底部
    public void BackBottom()
    {
        if (arrangement == Arrangement.Vertical)
        {
            content.localPosition = new Vector3(0, -viewPort.y + content.sizeDelta.y, 0);
        }
        else
        {
            content.localPosition = new Vector3(viewPort.x - content.sizeDelta.x, 0);
        }
        UpdateRectItem(Mathf.CeilToInt((float)childCount / (float)maxPerLine) - totalCount + 1, true);
    }

    public void RefreshViewItem()
    {
        UpdateRectItem(scrollLineIndex, true);
    }


    public void SetArrangement(int arr)
    {
        arrangement = (Arrangement)arr;
    }

    public void SetHorizontal(int h)
    {
        horizontalAlign = (HorizontalAlign)h;
    }

    public void SetVerticle(int v)
    {
        verticalAlign = (VerticalAlign)v;
    }

    public void AddChangeItemListener(Action<Transform, int> handle)
    {
        _handle = handle;
    }
}

 示例：
Lua应用示例：

local Tool = require("Tool")
 
local SprogExtendWindow = {}

local mediate = nil
local gridView = nil
local extendItem = nil
local extendItemInfo = nil
local sortList = nil
local extendCfgs = nil

local rewardState = 
{
    UNFINISH = 0,  --可领取
    UNREACH  = 1,  --未达成
    FINISHED = 2,  --已领取
}

function SprogExtendWindow.Init(data)

	mediate = data

    -- 创建ITEM实例
    ResMgr.LoadAssets("prefab", { "SprogExtendItem" },function(objs)
        extendItem = objs[0]
    end)

	extendItemInfo = {} -- 服务器下发数据
    sortList = {} -- 前端已排序处理，用于显示的数据

    SprogExtendWindow.InitGridView()
    SprogExtendWindow.RegistEvents()

    SprogExtendWindow.UpdateAllExtendInfo()
	return SprogExtendWindow
end

function SprogExtendWindow.InitGridView()

    gridView = mediate:FindChild("Layer_Sprite/panelGroup/extendPanel/bottom/Scroll View"):GetComponent("UIGridView") -- 获取UIGridView组件
    gridView.maxPerLine = 1
    gridView.rowSpace = 1
    gridView:SetItem(extendItem)
    gridView:SetViewPort(Vector2(565,325))

    -- 在ScrollView拖动时，UIGridView会回调即将出现的item，客户端只需要填入相应的UI数据.
    -- PS: 此函数会不停地调用，得考虑性能问题，避免处理过大的数据
    gridView:AddChangeItemListener(function(transform, index)
        local index = index + 1

        if sortList and sortList[index] then
            local item = sortList[index]
            Tool.subGetObject(transform, "time", "Text").text = item.config.time .. " " .. item.config.id
            Tool.subGetObject(transform, "content", "Text").text = item.config.name
            Tool.subGetObject(transform, "image", "Image").sprite = Tool.LoadImgSpriteFromAb("image", item.config.img)

            SprogExtendWindow.SetStateInfo(item.state, transform)

            transform:FindChild("Button").onClick = function(obj, eventData)
                SprogExtendWindow.CheckExtendItemInfo(item.config.id, transform)
            end
        end
	end)

end


function SprogExtendWindow.RegistEvents()

	mediate:AddClick("Layer_Sprite/panelGroup/extendPanel/top/btn_num", function () 
		log("按钮1")
	end)

	mediate:AddClick("Layer_Sprite/panelGroup/extendPanel/top/btn_link", function () 
		log("按钮2")
    end)
        
	mediate:AddClick("Layer_Sprite/panelGroup/extendPanel/top/btn_share", function () 
		log("按钮3")
	end)
end

function SprogExtendWindow.InitScrollView()

end

function SprogExtendWindow.UpdateAllExtendInfo()

    -- TEST,选用临时数据
    local data = 
    {
        [1] = {id = 1, type = 1, time = "2020.01.01", name = "床", img = "yxdt_tx1.png", vip = 1, liquanNum = 99999},
        [2] = {id = 2, type = 1, time = "2020.01.02", name = "前", img = "yxdt_tx1.png", vip = 2, liquanNum = 99999},
        [3] = {id = 3, type = 1, time = "2020.01.03", name = "明", img = "yxdt_tx1.png", vip = 3, liquanNum = 99999},
        [4] = {id = 4, type = 1, time = "2020.01.04", name = "月", img = "yxdt_tx1.png", vip = 4, liquanNum = 99999},
        [5] = {id = 5, type = 1, time = "2020.01.05", name = "光", img = "yxdt_tx1.png", vip = 5, liquanNum = 99999},
        [6] = {id = 6, type = 1, time = "2020.01.06", name = "床", img = "yxdt_tx1.png", vip = 6, liquanNum = 99999},
        [7] = {id = 7, type = 1, time = "2020.01.07", name = "前", img = "yxdt_tx1.png", vip = 7, liquanNum = 99999},   
        [8] = {id = 8, type = 1, time = "2020.01.08", name = "明", img = "yxdt_tx1.png", vip = 8, liquanNum = 99999},
        [9] = {id = 9, type = 1, time = "2020.01.09", name = "月", img = "yxdt_tx1.png", vip = 9, liquanNum = 99999},
        [10] = {id = 10, type = 1, time = "2020.01.10", name = "光", img = "yxdt_tx1.png", vip = 10, liquanNum = 99999},
        [11] = {id = 11, type = 1, time = "2020.01.01", name = "床", img = "yxdt_tx1.png", vip = 1, liquanNum = 99999},
        [12] = {id = 12, type = 1, time = "2020.01.02", name = "前", img = "yxdt_tx1.png", vip = 2, liquanNum = 99999},
        [13] = {id = 13, type = 1, time = "2020.01.03", name = "明", img = "yxdt_tx1.png", vip = 3, liquanNum = 99999},
        [14] = {id = 14, type = 1, time = "2020.01.04", name = "月", img = "yxdt_tx1.png", vip = 4, liquanNum = 99999},
        [15] = {id = 15, type = 1, time = "2020.01.05", name = "光", img = "yxdt_tx1.png", vip = 5, liquanNum = 99999},
        [16] = {id = 16, type = 1, time = "2020.01.06", name = "床", img = "yxdt_tx1.png", vip = 6, liquanNum = 99999},
        [17] = {id = 17, type = 1, time = "2020.01.07", name = "前", img = "yxdt_tx1.png", vip = 7, liquanNum = 99999},   
        [18] = {id = 18, type = 1, time = "2020.01.08", name = "明", img = "yxdt_tx1.png", vip = 8, liquanNum = 99999},
        [19] = {id = 19, type = 1, time = "2020.01.09", name = "月", img = "yxdt_tx1.png", vip = 9, liquanNum = 99999},
        [20] = {id = 20, type = 1, time = "2020.01.10", name = "光", img = "yxdt_tx1.png", vip = 10, liquanNum = 99999},
        [21] = {id = 21, type = 1, time = "2020.01.01", name = "床", img = "yxdt_tx1.png", vip = 1, liquanNum = 99999},
        [22] = {id = 22, type = 1, time = "2020.01.02", name = "前", img = "yxdt_tx1.png", vip = 2, liquanNum = 99999},
        [23] = {id = 23, type = 1, time = "2020.01.03", name = "明", img = "yxdt_tx1.png", vip = 3, liquanNum = 99999},
        [24] = {id = 24, type = 1, time = "2020.01.04", name = "月", img = "yxdt_tx1.png", vip = 4, liquanNum = 99999},
        [25] = {id = 25, type = 1, time = "2020.01.05", name = "光", img = "yxdt_tx1.png", vip = 5, liquanNum = 99999}
    } 

    extendItemInfo = {}
    for k, v in ipairs(data) do
        extendItemInfo[v.id] = 
        {   
            config = v, -- 本地配置
            state = math.random(0, 2) -- 随机一个状态
        }
    end

    SprogExtendWindow.OnSortAllExtendItem()

    gridView.ChildCount = #sortList -- 设置当前item总数
    gridView:ReBuild() -- 启动UIGridView
end

-- 整理数据并排序
function SprogExtendWindow.OnSortAllExtendItem()

    -- 按rewardState分组, 可领取>未达成>已领取
    local templist = {}
    for index = 1, 3 do
        for _,v in ipairs(extendItemInfo) do
            if index == v.state + 1 then
                if templist[index] == nil then
                    templist[index] = {}
                end
                table.insert(templist[index], v)
            end
        end
    end

    -- 每组按VIP等级排序
    for _,v in ipairs(templist) do
        table.sort(v, function (a, b)
			return a.config.vip > b.config.vip
		end)
	end

    sortList = {}
    for _,v in ipairs(templist) do
        for _,m in ipairs(v) do
            table.insert(sortList, m)
        end
	end

    -- log("排序后列表 " .. tostring(sortList))
end

function SprogExtendWindow.SetStateInfo(state, obj)
    local text = nil
    local isInteract = nil
    if state == rewardState.UNREACH then
        text = "未达成"
        isInteract = false
    elseif state == rewardState.UNFINISH then
        text =  "可领取"
        isInteract = true
    elseif state == rewardState.FINISHED then
        text =  "已领取"
        isInteract = false
    end

    obj.transform:FindChild("Button").interactable = isInteract
    Tool.subGetObject(obj, "Button/Text", "Text").text = text
end

function SprogExtendWindow.CheckExtendItemInfo(id, obj)

    if extendItemInfo ~= nil and extendItemInfo[id] ~= nil then

        local item = extendItemInfo[id]

        local reqSuccess = function(www)
            --local data = Json.decode(www.text).data
            log("领取成功，data: " .. CC.uu.Dump(data))
            
            item.state = 2
            SprogExtendWindow.SetStateInfo(item.state, obj)
        end
        
        local reqFailed = function(err)
            log("领取失败:" .. tostring(err))
        end
    
        -- 发送请求
        local Url = Tool.UrlMgr.UrlMapping("http://172.0.0.1:8000/GetTestData", {id = id, channelId = id})
        Tool.HttpPost(Url, nil, reqSuccess, reqSuccess)
    end
end


function SprogExtendWindow.Destroy()


end

return SprogExtendWindow

 

Unity组件挂载：








 

Le_Sam
关注
专栏目录
uigridView
08-14
uigridview
[Android]如何实现无限滚动的ListViw/GridView(翻译)
weixin_30505485的博客
07-01 110
ListView和GridView已经成为原生的Android应用实现中两个最流行的设计模式。目前，这些模式被大量的开发者使用，主要是因为他们是简单而直接的实现，同时他们提供了一个良好，整洁的用户体验。 对于ListView和GridView一个共同的需求就是在用户不断向下滚动，组件仍能动态的加载更多地加载更多数据。这篇博客就将带领大家实现在ListView和GridView中这个功能。 我们...
第30讲 UI组件之 GridView组件
weixin_30606669的博客
11-14 103
第30讲 UI组件之 GridView组件 1.网格布局组件GridView GridView是一个ViewGroup(布局控件)，可使用表格的方式显示组件，可滚动的控件。一般用于显示多张图片，比如实现九宫格图，用GridView是首选，也是最简单的。主要用于设置Adapter。 GridView常用的XML属性： 属性名称 描述 ...
一、简单gridview列表展示
weixin_30520015的博客
04-13 183
1.HomeController 1 public ActionResult Index() 2 { 3 //返回绑定models的index.cshtml 4 return View(NorthwindDataProvider.GetDocuments()); 5 } 6 ...
UI控件--GridView
Hate Bugs
03-18 299
GridView的用法与ListView的用法相同，都需要使用Adapter适配器。GridView与ListView控件唯一的不同便是显示形式不同，GridView是以行*列的形式展现的，使多条数据在一行。我们手机上的相册一个很好的例子。 首先在总布局中定义一个GridView控件，注意定义numCulumns属性，这是用于定义列数的属性 <LinearLayout xmlns:andro
ASP.NET-[其他类别]简单无限级分类(表格、下拉列表)源码.zip
11-20
这个资源“ASP.NET-[其他类别]简单无限级分类(表格、下拉列表)源码.zip”提供了实现无限级分类功能的示例代码，适用于在网页中展示层次结构数据，如组织结构、产品分类或导航菜单等。 无限级分类是指可以在任意深度...
android的GridView底部加载更多例子
08-10
本示例"android的GridView底部加载更多例子"探讨了如何在GridView中实现无限滚动加载功能，即用户无需点击加载更多按钮，只需上拉屏幕，内容就会自动加载。这种特性极大地提升了用户体验，尤其是在处理大量数据时。 ...
LayoutsFlutter:Flutter中内置布局的示例
05-12
`GridView`可以创建一个可滚动的网格，通常用于显示列表项，如应用的图标列表或照片集。`GridView.count`构造函数常用于创建固定列数的网格，而`GridView.extent`则基于每个子项的最大宽度来创建网格。 `...
Android应用源码之MyGridView.zip
12-10
GridView是Android平台中常用的布局控件，用于展示多行多列的数据，常见于图片浏览、应用列表等场景。下面，我们将详细讨论 GridView 的工作原理及其自定义方法。 1. GridView的基本使用： GridView继承自...
gridview 的异步加载图片,加载更多功能
04-13
在处理大量图片时，直接在GridView中加载所有图片可能会消耗大量内存，导致应用性能下降甚至崩溃。因此，"gridview的异步加载图片"是解决这个问题的关键技术。异步加载图片可以在后台线程中进行，避免阻塞主线程，...
iOS-GridView:iOS自定义网格组件，基于UICollectionView的GridView
05-12
iOS-GridView iOS自定义网格组件，基于UICollectionView的GridView 基于前一个组件 的优化，由于发现原先的组件在实际运行中，展示较大量的数据时，对内存占用有点大，于是做了此番优化，结果发现在展示相同数量的多条数据时，优化过后的GridView比之前的版本能节省5M左右的内存，说明此次优化还是有成果的。  1、初始化 MLHGridView *grid = [[MLHGridView alloc]initWithFrame:CGRectMake(10, 64, self.view.frame.size.width-20, CGRectGetHeight(self.view.bounds) - 64)]; grid.delegate = self; 2、实现delegate (NSInteger)numberOfColumnsForGridView:(M
Super ScrollView for UGUI 2.2.2一款unity3d非常强大的滑动制作插件
01-08
Super ScrollView for UGUI提供基于UGUI ScrollRect的可轻松定制的ScrollView。它是一组C＃脚本，可帮助您创建所需的ScrollView。这是非常强大的和高度优化的性能。 文件 Android演示应用程序 演示： - 聊天消息列表演示 - 水平画廊演示 - 垂直画廊演示 - GridView演示 - PageVew演示 - TreeVew演示 - 与稠粘头演示的TreeView - 旋转日期选择器 - 更改项目高度演示 - 下拉刷新演示 - 拉起来加载更多的演示 - 点击加载更多演示 - 选择并删除演示 - GridView删除项目演示 - 顶部到底部的演示 - 自下而上的演示 - 从左到右的演示 - 右侧演示 - 响应GridView演示 - TreeViewWithChildrenIndent演示 特征： - ListView和GridView和TreeView - 无限的项目 - 项目在不同的大小（高度/宽度） - 具有不同预制的物品 - 在初始时间大小未知的项目 - 垂直滚动视图（从上到下，从下到上） - 水平滚动视图（从左到右，从右到左） - 项目填充 - 滚动到指定的项目 - 滚动到具有偏移量的项目 - 项目计数在运行时更改 - 项目大小（高度/宽度）在运行时更改 - 物品捕捉到视口中的任何位置 - 项目循环，如微调 - 添加/删除项目 - 全部删除/删除所有项目 - 刷新并重新加载项目 - 使用池缓存项目，不要在运行时销毁项目 - 有效回收物品 - 平台无关 - UGUI支持 - 支持Unity平台（IOS / Android / Mac / PC / Console / Winphone / WebGL ...）
UGUI - 制作listview gridview ugui
09-05
UGUI - 制作listview ugui 适合于列表 gridview UGUI - 制作listview ugui 适合于列表 gridview
Unity 超级列表SuperScrollview使用Demo
qq_40120946的博客
09-30 7895
首先，说一下使用SuperScrollview的基本配置： 创建一个scrollview，然后把横纵滑动条设置可配置的，然后再加上LoopListView2代码，如下： 然后我们创建四个代码类： 1、数据类： 2、数据管理类方便增删查改： public class StudentInfoMgr { List<StudentInfo> mItemDataL...
Unity3D UI多元素布局
qq_39131023的博客
12-04 447
1.Grid Layout Group组件实现布局 1.新建空物体1，添加Grid Layout Group组件作为布局区域，把需要布局的对象作为布局区域的子物体。 2.新建空物体2，作为需要布局的对象，此空物体会作为布局的元素，修改Cell Size时会改变此空物体的宽和高，所以需要此空物体作为其他需要布局的对象父物体，这样在修改布局宽高的时候不会改变布局对象的宽高 修改Cell Size可以修改每个元素（一级子物体）在布局区域内所占的宽和高。 2.Toggle Group组件 1.给Imag
Unity 中实现可复用的 GridView
NRatel的博客
04-09 3897
源码已放入我的 github，地址：Unity-ListView 一、确定使用参数 “GridView的参数，要怎么设计才能强大且易用”，我想了很久之后看了UGUIGridLayoutGroup的源码，发现我还是 too young。它的设计已经很合理了，沿用即可。原因： 1、StartCorner 和 StartAxis 可以确定出八种排布方式。 2、Constraint 为 Flexible时的，Padding 可能影响自适应的行列数。 3、Padding 和 对齐方式配合的也很巧妙...
UGUI自定义GridView(流式布局)
qq_37896049的博客
06-17 939
引言 Unity中对子物体的排序我们一般是使用GridLayoutGroup这个组件，但是这个组件会强行将子物体的width和height设置为相同的，但是如果遇到子物体的宽高不同的需求时，这个GridLayoutGroup将不再适用。此时需要我们自定义的编写一套排序子物体的算法（分为子View宽度一致，高度不一致或者高度一致，宽度不一致两种情况）。 温馨提示 本文排序子物体采用了设置本地坐...
UGUI_PointerEventData()__检测鼠标点击的位置上，所包含的全部UI控件
Le_Sam的博客
07-23 6609
需求：有时候拖动/点击UI时，需要判断鼠标所在位置上，对重叠的UI进行分别的处理 实现：利用PointerEventData()   一；判断当前鼠标上重叠的UI有多少个 private int IsPointerOverUIObject() { PointerEventData eventDataCurrentPosition = new Pointer...
Element UI日期时间选择器示例与应用
"Element DateTimePicker 是一个用于选择日期和时间的UI组件，常用于Web应用中，让用户能够方便地输入或选择特定的日期和时间。它提供了多种样式和功能，如默认选择、快捷选项和设置默认时间等。下面将详细介绍其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值