chenbin/tianrunCRM
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Files
9e8c6f080f840850bbb4078537aae9388227470e
tianrunCRM/Assets/CoolapeFrame/Scripts/ui/NguiExtend/CLUILoopTable.cs

730 lines
24 KiB
C#
Raw Normal View History

add
2020-07-04 14:41:25 +08:00
/*
********************************************************************************
*Copyright(C),coolae.net
*Author: chenbin
*Version: 2.0
*Date: 2017-01-09
*Description: 循环列表，只能是单排或单列
* 1、脚本放在Scroll View下面的UIGrid的那个物体上
* 2、Scroll View上面的UIPanel的Cull勾选上
* 3、每一个Item都放上一个CLUILoopTableCell，调整到合适的大小（用它的Visiable） ，设置Dimensions
* 4、需要提前把Item放到Grid下，不能动态加载进去
* 5、注意元素的个数要多出可视范围至少4个
* 6、特别注意，因为使用的是ngui的Widget来处理排列的，
* 因此在编辑cell里要保证通过计算后widget可以全部覆盖完整个cell（可以使用anchor来处理）
* 7、特别注意Table.CellAlignment要设置正确，不然可能单元的位置计算有会问题
*Others:
*History:
*********************************************************************************
*/
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using XLua;
namespace Coolape
{
[RequireComponent (typeof(UITable))]
public class CLUILoopTable : MonoBehaviour
{
public int cellCount = 10;
public Vector2 mOffset = Vector2.zero;
private List<CLUILoopTableCell> itemList = new List<CLUILoopTableCell> ();
private Transform cachedTransform;
UITable table = null;
bool isFinishInit = false;
int times = 0;
int RealCellCount = 0;
Vector3 oldGridPosition = Vector3.zero;
Vector3 oldScrollViewPos = Vector3.zero;
Vector2 oldClipOffset = Vector2.zero;
UIScrollView _scrollView;
public UIScrollView scrollView {
get {
if (_scrollView == null) {
_scrollView = NGUITools.FindInParents<UIScrollView> (transform);
if (_scrollView != null) {
oldScrollViewPos = _scrollView.transform.localPosition;
oldClipOffset = _scrollView.panel.clipOffset;
_scrollView.panel.cullWhileDragging = true;
upgrade
2020-08-01 17:55:18 +08:00
_scrollView.panel.onClipMove = OnMove;
add
2020-07-04 14:41:25 +08:00
}
}
return _scrollView;
}
}
public void init ()
{
if (isFinishInit)
return;
cachedTransform = this.transform;
table = this.GetComponent<UITable> ();
table.hideInactive = true;
table.sorting = UITable.Sorting.Alphabetic;
oldGridPosition = table.transform.localPosition;
_scrollView = scrollView;
Transform prefab = cachedTransform.GetChild (0);
CLUILoopTableCell prefabCell = prefab.GetComponent<CLUILoopTableCell> ();
table.cellAlignment = prefabCell.widget.pivot;
if (cachedTransform.childCount < cellCount) {
for (int i = cachedTransform.childCount; i < cellCount; i++) {
NGUITools.AddChild (gameObject, prefab.gameObject);
}
}
for (int i = 0; i < cachedTransform.childCount; ++i) {
Transform t = cachedTransform.GetChild (i);
CLUILoopTableCell uiw = t.GetComponent<CLUILoopTableCell> ();
// uiw.name = string.Format ("{0:D5}", itemList.Count);
uiw.name = NumEx.nStrForLen (itemList.Count, 6);
itemList.Add (uiw);
}
RealCellCount = itemList.Count;
table.Reposition ();
isFinishInit = true;
if (itemList.Count < 3) {
Debug.LogError ("The childCount < 3");
}
}
public void setOldClip (Vector2 oldClipOffset, Vector3 oldScrollViewPos, Vector3 oldGridPosition)
{
this.oldClipOffset = oldClipOffset;
this.oldScrollViewPos = oldScrollViewPos;
this.oldGridPosition = oldGridPosition;
}
public void resetClip ()
{
scrollView.panel.clipOffset = oldClipOffset;
scrollView.transform.localPosition = oldScrollViewPos;
table.transform.localPosition = oldGridPosition;
}
object data = null;
ArrayList list = null;
object initCellCallback;
object onEndListCallback;
public void refreshContentOnly ()
{
refreshContentOnly (list);
}
public void refreshContentOnly(object data){
refreshContentOnly(data, false);
}
public void refreshContentOnly (object data, bool isRePositionTable)
{
ArrayList _list = null;
if (data == null) {
_list = new ArrayList ();
} else if (data is LuaTable) {
_list = CLUtlLua.luaTableVals2List ((LuaTable)data);
} else if (data is ArrayList) {
_list = (ArrayList)data;
} else if (data is object[]) {
_list = new ArrayList ();
_list.AddRange ((object[])data);
} else {
_list = new ArrayList ();
}
list = _list;
if (RealCellCount > itemList.Count) {
setList (list, this.initCellCallback);
} else {
Transform t = null;
int tmpIndex = 0;
CLUILoopTableCell cell = null;
CLUILoopTableCell preCell = null;
//for (int i = 0; i < cachedTransform.childCount; ++i) {
for (int i = 0; i < itemList.Count; i++){
//t = cachedTransform.GetChild (i);
cell = itemList[i];
if (!cell.gameObject.activeSelf)
continue;
tmpIndex = int.Parse (cell.name);
//cell = t.GetComponent<CLUILoopTableCell> ();
if (cell != null) {
Utl.doCallback (this.initCellCallback, cell, list [tmpIndex]);
}
if (cell.isSetWidgetSize)
{
BoxCollider box = cell.GetComponent<BoxCollider>();
if (box != null)
{
box.size = Vector2.zero;
}
cell.widget.SetDimensions(0, 0);
}
NGUITools.updateAll(cell.transform);
if (cell.isSetWidgetSize)
{
Bounds bound = NGUIMath.CalculateRelativeWidgetBounds(t, false);
cell.widget.SetDimensions((int)(bound.size.x), (int)(bound.size.y));
}
if (isRePositionTable)
{
if (preCell != null)
{
setPosition(cell, preCell, table.direction);
}
}
preCell = cell;
}
}
}
public void setList (object data, object initCellCallback)
{
setList (data, initCellCallback, null);
}
public void setList (object data, object initCellCallback, object onEndListCallback)
{
setList (data, initCellCallback, onEndListCallback, true);
}
public void setList (object data, object initCellCallback, object onEndListCallback, bool isNeedRePosition)
{
_setList (data, initCellCallback, onEndListCallback, isNeedRePosition);
}
public void setList (object data, object initCellCallback, object onEndListCallback, bool isNeedRePosition, bool isCalculatePosition)
{
_setList (data, initCellCallback, onEndListCallback, isNeedRePosition, isCalculatePosition);
}
void _setList (object data, object initCellCallback, object onEndListCallback, bool isNeedRePosition, bool isCalculatePosition = false)
{
ArrayList _list = null;
if (data == null) {
_list = new ArrayList ();
} else if (data is LuaTable) {
_list = CLUtlLua.luaTableVals2List ((LuaTable)data);
} else if (data is ArrayList) {
_list = (ArrayList)data;
} else if (data is object[]) {
_list = new ArrayList ();
_list.AddRange ((object[])data);
} else {
_list = new ArrayList ();
}
try {
this.data = data;
this.list = _list;
this.initCellCallback = initCellCallback;
this.onEndListCallback = onEndListCallback;
if (!isFinishInit) {
init ();
}
int tmpIndex = 0;
times = 0;
itemList.Clear ();
for (int i = 0; i < cachedTransform.childCount; ++i) {
Transform t = cachedTransform.GetChild (i);
CLUILoopTableCell uiw = t.GetComponent<CLUILoopTableCell> ();
tmpIndex = i;
// uiw.name = string.Format ("{0:D5}", tmpIndex);
uiw.name = NumEx.nStrForLen (tmpIndex, 6);
if (tmpIndex >= 0 && tmpIndex < this.list.Count) {
NGUITools.SetActive (t.gameObject, true);
Utl.doCallback (this.initCellCallback, t.GetComponent<CLCellBase> (), list [tmpIndex]);
if (uiw.isSetWidgetSize) {
BoxCollider box = uiw.GetComponent<BoxCollider> ();
if (box != null) {
box.size = Vector2.zero;
}
uiw.widget.SetDimensions (0, 0);
}
NGUITools.updateAll (uiw.transform);
if (uiw.isSetWidgetSize) {
Bounds bound = NGUIMath.CalculateRelativeWidgetBounds (t, false);
uiw.widget.SetDimensions ((int)(bound.size.x), (int)(bound.size.y));
}
if (!isNeedRePosition) {
if (itemList.Count > 0) {
CLUILoopTableCell targetUIW = itemList [itemList.Count - 1];
setPosition (uiw, targetUIW, table.direction);
}
}
itemList.Add (uiw);
} else {
NGUITools.SetActive (t.gameObject, false);
}
}
if (isNeedRePosition) {
resetClip ();
table.Reposition ();
if (scrollView != null) {
scrollView.ResetPosition ();
}
}
} catch (System.Exception e) {
Debug.LogError (e);
}
}
public void insertList (object data, bool isNeedRePosition, bool isCalculatePosition)
{
ArrayList _list = null;
if (data is LuaTable) {
_list = CLUtlLua.luaTableVals2List ((LuaTable)data);
} else if (data is ArrayList) {
_list = (ArrayList)data;
} else if (data is object[]) {
_list = new ArrayList ();
_list.AddRange ((object[])data);
}
times = (int)(_list.Count / RealCellCount);
//------------------------------------------------
CLUILoopTableCell uiw = null;
CLUILoopTableCell targetUIW = null;
int newDataCount = _list.Count;
Transform t = null;
int _startIndex = 0;
if (itemList != null && itemList.Count > 0) {
_startIndex = NumEx.stringToInt (itemList [0].name);
for (int i = 0; i < itemList.Count; i++) {
uiw = itemList [i];
if (uiw == null)
continue;
uiw.name = NumEx.nStrForLen (newDataCount + _startIndex + i, 6);
}
}
//------------------------------------------------
if (RealCellCount > itemList.Count) {
Debug.Log ("说明之前加载的数据没有占用完所有单元");
//说明之前加载的数据没有占用完所有单元
_insertList (_list, isCalculatePosition);
if (isNeedRePosition) {
table.Reposition ();
}
}
//------------------------------------------------
if (list != null) {
_list.AddRange (list);
}
list = _list;
}
void _insertList (ArrayList list, bool isCalculatePosition)
{
if (list.Count == 0)
return;
int dataIndex = list.Count - 1;
// int tmpIndex = itemList.Count;
CLUILoopTableCell uiw = null;
CLUILoopTableCell targetUIW = null;
Transform t = null;
for (int i = 0; i < cachedTransform.childCount; i++) {
if (dataIndex < 0) {
break;
}
t = cachedTransform.GetChild (i);
if (t.gameObject.activeSelf)
continue;
uiw = t.GetComponent<CLUILoopTableCell> ();
if (uiw == null)
continue;
// uiw.name = string.Format ("{0:D5}", (tmpIndex + dataIndex));
uiw.name = NumEx.nStrForLen (dataIndex, 6);
NGUITools.SetActive (t.gameObject, true);
Utl.doCallback (this.initCellCallback, t.GetComponent<CLCellBase> (), list [dataIndex]);
if (uiw.isSetWidgetSize) {
BoxCollider box = uiw.GetComponent<BoxCollider> ();
if (box != null) {
box.size = Vector2.zero;
}
uiw.widget.SetDimensions (0, 0);
}
NGUITools.updateAll (uiw.transform);
if (uiw.isSetWidgetSize) {
Bounds bound = NGUIMath.CalculateRelativeWidgetBounds (t, false);
uiw.widget.SetDimensions ((int)(bound.size.x), (int)(bound.size.y));
}
if (isCalculatePosition) {
if (itemList.Count > 0) {
targetUIW = itemList [0];
UITable.Direction dir = table.direction;
if (table.direction == UITable.Direction.Up) {
dir = UITable.Direction.Down;
} else {
dir = UITable.Direction.Up;
}
setPosition (uiw, targetUIW, dir);
}
}
itemList.Insert (0, uiw);
dataIndex--;
}
}
public void appendList (object data, bool isNeedRePosition, bool isCalculatePosition)
{
ArrayList _list = null;
if (data is LuaTable) {
_list = CLUtlLua.luaTableVals2List ((LuaTable)data);
} else if (data is ArrayList) {
_list = (ArrayList)data;
} else if (data is object[]) {
_list = new ArrayList ();
_list.AddRange ((object[])data);
}
if (_list != null) {
list.AddRange (_list);
}
if (RealCellCount > itemList.Count) {
//说明之前加载的数据没有占用完所有单元
_appendList (_list, isCalculatePosition);
if (isNeedRePosition) {
table.Reposition ();
}
}
}
void _appendList (ArrayList list, bool isCalculatePosition)
{
if (list.Count == 0)
return;
int dataIndex = 0;
int tmpIndex = itemList.Count;
CLUILoopTableCell uiw = null;
CLUILoopTableCell targetUIW = null;
Transform t = null;
for (int i = 0; i < cachedTransform.childCount; i++) {
if (dataIndex >= list.Count) {
break;
}
t = cachedTransform.GetChild (i);
if (t.gameObject.activeSelf)
continue;
uiw = t.GetComponent<CLUILoopTableCell> ();
if (uiw == null)
continue;
// uiw.name = string.Format ("{0:D5}", (tmpIndex + dataIndex));
uiw.name = NumEx.nStrForLen (tmpIndex + dataIndex, 6);
NGUITools.SetActive (t.gameObject, true);
Utl.doCallback (this.initCellCallback, t.GetComponent<CLCellBase> (), list [dataIndex]);
if (uiw.isSetWidgetSize) {
BoxCollider box = uiw.GetComponent<BoxCollider> ();
if (box != null) {
box.size = Vector2.zero;
}
uiw.widget.SetDimensions (0, 0);
}
NGUITools.updateAll (uiw.transform);
if (uiw.isSetWidgetSize) {
Bounds bound = NGUIMath.CalculateRelativeWidgetBounds (t, false);
uiw.widget.SetDimensions ((int)(bound.size.x), (int)(bound.size.y));
}
if (isCalculatePosition) {
if (itemList.Count > 0) {
targetUIW = itemList [itemList.Count - 1];
setPosition (uiw, targetUIW, table.direction);
}
}
itemList.Add (uiw);
dataIndex++;
}
}
void setPosition (CLUILoopTableCell movement, CLUILoopTableCell target, UITable.Direction direction)
{
Vector3 v3Offset = Vector3.zero;
int flag = 1;
if (table.columns == 1) {
if (direction == UITable.Direction.Down) {
flag = -1;
switch (table.cellAlignment) {
case UIWidget.Pivot.Bottom:
v3Offset = new Vector3 (0, flag * (movement.widget.height + mOffset.y + (table.padding.y) * 2), 0);
break;
case UIWidget.Pivot.BottomLeft:
v3Offset = new Vector3 (0, flag * (movement.widget.height + mOffset.y + (table.padding.y) * 2), 0);
break;
case UIWidget.Pivot.BottomRight:
v3Offset = new Vector3 (0, flag * (movement.widget.height + mOffset.y + (table.padding.y) * 2), 0);
break;
case UIWidget.Pivot.Center:
v3Offset = new Vector3 (0, flag * ((movement.widget.height + target.widget.height) / 2.0f + mOffset.y + (table.padding.y) * 2), 0);
break;
case UIWidget.Pivot.Left:
v3Offset = new Vector3 (0, flag * ((movement.widget.height + target.widget.height) / 2.0f + mOffset.y + (table.padding.y) * 2), 0);
break;
case UIWidget.Pivot.Right:
v3Offset = new Vector3 (0, flag * ((movement.widget.height + target.widget.height) / 2.0f + mOffset.y + (table.padding.y) * 2), 0);
break;
case UIWidget.Pivot.Top:
v3Offset = new Vector3 (0, flag * (target.widget.height + mOffset.y + (table.padding.y) * 2), 0);
break;
case UIWidget.Pivot.TopLeft:
v3Offset = new Vector3 (0, flag * (target.widget.height + mOffset.y + (table.padding.y) * 2), 0);
break;
case UIWidget.Pivot.TopRight:
v3Offset = new Vector3 (0, flag * (target.widget.height + mOffset.y + (table.padding.y) * 2), 0);
break;
}
} else {
flag = 1;
switch (table.cellAlignment) {
case UIWidget.Pivot.Bottom:
v3Offset = new Vector3 (0, flag * (target.widget.height + mOffset.y + (table.padding.y) * 2), 0);
break;
case UIWidget.Pivot.BottomLeft:
v3Offset = new Vector3 (0, flag * (target.widget.height + mOffset.y + (table.padding.y) * 2), 0);
break;
case UIWidget.Pivot.BottomRight:
v3Offset = new Vector3 (0, flag * (target.widget.height + mOffset.y + (table.padding.y) * 2), 0);
break;
case UIWidget.Pivot.Center:
v3Offset = new Vector3 (0, flag * ((movement.widget.height + target.widget.height) / 2.0f + mOffset.y + (table.padding.y) * 2), 0);
break;
case UIWidget.Pivot.Left:
v3Offset = new Vector3 (0, flag * ((movement.widget.height + target.widget.height) / 2.0f + mOffset.y + (table.padding.y) * 2), 0);
break;
case UIWidget.Pivot.Right:
v3Offset = new Vector3 (0, flag * ((movement.widget.height + target.widget.height) / 2.0f + mOffset.y + (table.padding.y) * 2), 0);
break;
case UIWidget.Pivot.Top:
v3Offset = new Vector3 (0, flag * (movement.widget.height + mOffset.y + (table.padding.y) * 2), 0);
break;
case UIWidget.Pivot.TopLeft:
v3Offset = new Vector3 (0, flag * (movement.widget.height + mOffset.y + (table.padding.y) * 2), 0);
break;
case UIWidget.Pivot.TopRight:
v3Offset = new Vector3 (0, flag * (movement.widget.height + mOffset.y + (table.padding.y) * 2), 0);
break;
}
}
} else if (table.columns == 0) {
flag = 1;
if (direction == UITable.Direction.Down) {
switch (table.cellAlignment) {
case UIWidget.Pivot.Bottom:
v3Offset = new Vector3 (flag * ((target.widget.width + movement.widget.width) / 2.0f + mOffset.x + (table.padding.x) * 2), 0, 0);
break;
case UIWidget.Pivot.BottomLeft:
v3Offset = new Vector3 (flag * (target.widget.width + mOffset.x + (table.padding.x) * 2), 0, 0);
break;
case UIWidget.Pivot.BottomRight:
v3Offset = new Vector3 (flag * (movement.widget.width + mOffset.x + (table.padding.x) * 2), 0, 0);
break;
case UIWidget.Pivot.Center:
v3Offset = new Vector3 (flag * ((target.widget.width + movement.widget.width) / 2.0f + mOffset.x + (table.padding.x) * 2), 0, 0);
break;
case UIWidget.Pivot.Left:
v3Offset = new Vector3 (flag * (target.widget.width + mOffset.x + (table.padding.x) * 2), 0, 0);
break;
case UIWidget.Pivot.Right:
v3Offset = new Vector3 (flag * (movement.widget.width + mOffset.x + (table.padding.x) * 2), 0, 0);
break;
case UIWidget.Pivot.Top:
v3Offset = new Vector3 (flag * ((target.widget.width + movement.widget.width) / 2.0f + mOffset.x + (table.padding.x) * 2), 0, 0);
break;
case UIWidget.Pivot.TopLeft:
v3Offset = new Vector3 (flag * (target.widget.width + mOffset.x + (table.padding.x) * 2), 0, 0);
break;
case UIWidget.Pivot.TopRight:
v3Offset = new Vector3 (flag * (movement.widget.width + mOffset.x + (table.padding.x) * 2), 0, 0);
break;
}
} else {
flag = -1;
switch (table.cellAlignment) {
case UIWidget.Pivot.Bottom:
v3Offset = new Vector3 (flag * ((target.widget.width + movement.widget.width) / 2.0f + mOffset.x + (table.padding.x) * 2), 0, 0);
break;
case UIWidget.Pivot.BottomLeft:
v3Offset = new Vector3 (flag * (movement.widget.width + mOffset.x + (table.padding.x) * 2), 0, 0);
break;
case UIWidget.Pivot.BottomRight:
v3Offset = new Vector3 (flag * (target.widget.width + mOffset.x + (table.padding.x) * 2), 0, 0);
break;
case UIWidget.Pivot.Center:
v3Offset = new Vector3 (flag * ((target.widget.width + movement.widget.width) / 2.0f + mOffset.x + (table.padding.x) * 2), 0, 0);
break;
case UIWidget.Pivot.Left:
v3Offset = new Vector3 (flag * (movement.widget.width + mOffset.x + (table.padding.x) * 2), 0, 0);
break;
case UIWidget.Pivot.Right:
v3Offset = new Vector3 (flag * (target.widget.width + mOffset.x + (table.padding.x) * 2), 0, 0);
break;
case UIWidget.Pivot.Top:
v3Offset = new Vector3 (flag * ((target.widget.width + movement.widget.width) / 2.0f + mOffset.x + (table.padding.x) * 2), 0, 0);
break;
case UIWidget.Pivot.TopLeft:
v3Offset = new Vector3 (flag * (movement.widget.width + mOffset.x + (table.padding.x) * 2), 0, 0);
break;
case UIWidget.Pivot.TopRight:
v3Offset = new Vector3 (flag * (target.widget.width + mOffset.x + (table.padding.x) * 2), 0, 0);
break;
}
}
} else {
Debug.LogError ("The loop table cannot suport this setting! columes must in (0, 1)");
}
movement.transform.localPosition = target.transform.localPosition + v3Offset;
}
int sourceIndex = -1;
int targetIndex = -1;
bool forward = true;
bool firstVislable = false;
bool lastVisiable = false;
CLUILoopTableCell head;
CLUILoopTableCell tail;
CLUILoopTableCell checkHead;
CLUILoopTableCell checkTail;
bool isCanCallOnEndList = true;
CLUILoopTableCell movedWidget = null;
CLUILoopTableCell targetWidget = null;
BoxCollider _boxCollidr;
Bounds _bound;
Vector3 _offset;
// void LateUpdate ()
android
2020-08-03 23:05:29 +08:00
void _Update ()
add
2020-07-04 14:41:25 +08:00
{
if (itemList.Count < 3) {
return;
}
sourceIndex = -1;
targetIndex = -1;
// sign = 0;
head = itemList [0];
tail = itemList [itemList.Count - 1];
checkHead = itemList [1];
checkTail = itemList [itemList.Count - 2];
firstVislable = checkHead.widget.isVisible;
lastVisiable = checkTail.widget.isVisible;
// if first and last both visiable or invisiable then return
if (firstVislable == lastVisiable) {
return;
}
if (firstVislable && int.Parse (head.name) > 0) {
isCanCallOnEndList = true;
times--;
// move last to first one
sourceIndex = itemList.Count - 1;
targetIndex = 0;
forward = false;
} else if (lastVisiable && int.Parse (tail.name) < list.Count - 1) {
isCanCallOnEndList = true;
times++;
// move first to last one
sourceIndex = 0;
targetIndex = itemList.Count - 1;
forward = true;
} else if (lastVisiable && int.Parse (tail.name) == list.Count - 1) {
//说明已经到最后了
if (isCanCallOnEndList) {
isCanCallOnEndList = false;
#if UNITY_EDITOR
Debug.Log ("说明已经到最后了");
#endif
Utl.doCallback (this.onEndListCallback);
}
} else {
isCanCallOnEndList = true;
}
if (sourceIndex > -1) {
movedWidget = itemList [sourceIndex];
if (forward) {
// movedWidget.name = string.Format ("{0:D5}",);
movedWidget.name = NumEx.nStrForLen (NumEx.stringToInt (tail.name) + 1, 6);
// movedWidget.name = NumEx.nStrForLen( ((times - 1) / RealCellCount + 1) * RealCellCount + int.Parse (movedWidget.name) % RealCellCount, 6);
} else {
movedWidget.name = NumEx.nStrForLen (NumEx.stringToInt (head.name) - 1, 6);
// movedWidget.name = string.Format ("{0:D5}", ((times) / RealCellCount) * RealCellCount + int.Parse (movedWidget.name) % RealCellCount);
// movedWidget.name = NumEx.nStrForLen(((times) / RealCellCount) * RealCellCount + int.Parse (movedWidget.name) % RealCellCount, 6);
}
int index = int.Parse (movedWidget.name);
Utl.doCallback (this.initCellCallback, movedWidget.GetComponent<CLCellBase> (), this.list [index]);
// ***after init call, then set the position***
if (movedWidget.isSetWidgetSize) {
_boxCollidr = movedWidget.GetComponent<BoxCollider> ();
if (_boxCollidr != null) {
_boxCollidr.size = Vector2.zero;
}
movedWidget.widget.SetDimensions (0, 0);
}
NGUITools.updateAll (movedWidget.transform);
if (movedWidget.isSetWidgetSize) {
_bound = NGUIMath.CalculateRelativeWidgetBounds (movedWidget.transform, false);
movedWidget.widget.SetDimensions ((int)(_bound.size.x), (int)(_bound.size.y));
}
targetWidget = itemList [targetIndex];
if (forward) {
setPosition (movedWidget, targetWidget, table.direction);
} else {
UITable.Direction dir = table.direction;
if (table.direction == UITable.Direction.Up) {
dir = UITable.Direction.Down;
} else {
dir = UITable.Direction.Up;
}
setPosition (movedWidget, targetWidget, dir);
}
// change item index
itemList.RemoveAt (sourceIndex);
itemList.Insert (targetIndex, movedWidget);
}
}
upgrade
2020-08-01 17:55:18 +08:00
protected virtual void OnMove(UIPanel panel)
{
if (scrollView == null) return;
android
2020-08-03 23:05:29 +08:00
_Update();
upgrade
2020-08-01 17:55:18 +08:00
bool restrictWithinPanel = false;
if (list == null || list.Count == 0)
{
restrictWithinPanel = true;
}
if (!restrictWithinPanel && firstVislable && int.Parse(head.name) == 0)
{
restrictWithinPanel = true;
}
if (!restrictWithinPanel && lastVisiable && int.Parse(tail.name) == list.Count - 1)
{
restrictWithinPanel = true;
}
scrollView.restrictWithinPanel = restrictWithinPanel;
}
add
2020-07-04 14:41:25 +08:00
}
upgrade
2020-08-01 17:55:18 +08:00
}
Reference in New Issue Copy Permalink