using CommonLang;
using CommonLang.Property;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;
namespace CommonUnity3D.UGUI
{ //----------------------------------------------------------------------------------------------------------------------------------
/// <summary>
/// 普通滑动控件
/// </summary>
public class ScrollablePanel : DisplayNode
{
protected readonly DisplayNode mContent;
protected readonly RectMask2D mRectMask;
protected readonly Image mMaskGraphics;
protected readonly ScrollRectInteractive mMaskScrollRect;
//protected readonly Mask mMask;
public ScrollRectInteractive Scroll
{
get { return mMaskScrollRect; }
}
public Rect ScrollRect2D
{
get { return mMaskScrollRect.ScrollRect2D; }
}
public DisplayNode Container
{
get { return mContent; }
}
public bool ShowSlider
{
get { return mMaskScrollRect.ShowSlider; }
set { mMaskScrollRect.ShowSlider = value; }
}
public float ScrollFadeTimeMaxMS
{
get { return mMaskScrollRect.ScrollFadeTimeMaxMS; }
set { mMaskScrollRect.ScrollFadeTimeMaxMS = value; }
}
public ScrollablePanel(string name = null) : base(name)
{
this.EnableChildren = true;
this.mContent = new DisplayNode("container");
this.mContent.EnableChildren = true;
this.AddChild(mContent);
this.mMaskGraphics = mGameObject.AddComponent<InteractiveDummyGraphics>();
this.mMaskGraphics.color = Color.white;
this.mMaskGraphics.type = Image.Type.Filled;
this.mMaskScrollRect = mGameObject.AddComponent<ScrollRectInteractive>();
this.mMaskScrollRect.movementType = ScrollRectInteractive.MovementType.Elastic;
this.mMaskScrollRect.content = mContent.Transform;
this.mMaskScrollRect.viewport = this.Transform;
this.mMaskScrollRect.event_Scrolled += DoScrolled;
this.mMaskScrollRect.event_OnEndDrag += DoEndDrag;
this.mRectMask = mGameObject.AddComponent<RectMask2D>();
// this.mMask = mGameObject.AddComponent<Mask>();
// this.mMask.showMaskGraphic = false;
this.IsInteractive = true;
this.Enable = true;
}
public bool IsInViewRect(ref Rect src, ref Rect dst)
{
return mMaskScrollRect.IsInViewRect(ref src, ref dst);
}
public void LookAt(Vector2 pos)
{
mMaskScrollRect.LookAt(pos, false);
}
public void LookAt(Vector2 pos, bool scroll)
{
mMaskScrollRect.LookAt(pos, scroll);
}
public void SetScrollBarPair(DisplayNode scrollh, DisplayNode scrollv)
{
mMaskScrollRect.SetScrollBarPair(scrollh, scrollv);
}
//-----------------------------------------------------------------------------------------------------------------------
protected override void OnUpdate()
{
base.OnUpdate();
if (!Scroll.AutoUpdateContentSize)
{
this.OnUpdateContentSize();
}
}
protected virtual void OnUpdateContentSize()
{
}
#region _Events_
protected override void OnDisposeEvents()
{
this.event_Scrolled = null;
this.event_OnEndDrag = null;
base.OnDisposeEvents();
}
private void DoEndDrag(DisplayNode sender, PointerEventData e)
{
if (event_OnEndDrag != null)
{
event_OnEndDrag(sender, e);
}
}
private void DoScrolled(Vector2 value)
{
OnScrolled(value);
if (event_Scrolled != null)
{
event_Scrolled.Invoke(this, value);
}
}
protected virtual void OnScrolled(Vector2 value) { }
public delegate void ScrollEventHandler(DisplayNode sender, Vector2 e);
public ScrollEventHandler event_Scrolled;
public DisplayNode.PointerEventHandler event_OnEndDrag;
public event ScrollEventHandler Scrolled { add { event_Scrolled += value; } remove { event_Scrolled -= value; } }
public event DisplayNode.PointerEventHandler OnEndDragEvent { add { event_OnEndDrag += value; } remove { event_OnEndDrag -= value; } }
#endregion
}
//----------------------------------------------------------------------------------------------------------------------------------
/// <summary>
/// 静态网格滚动控件
/// </summary>
public class GridScrollablePanel : ScrollablePanel
{
private int mRowCount = 0, mColumnCount = 0;
private Vector2 mCellSize;
private Vector2 mContentSize;
private DisplayNode[,] mGridMatrix;
public GridScrollablePanel(string name = null) : base(name)
{
Scroll.AutoUpdateContentSize = false;
}
public Vector2 CellSize { get { return mCellSize; } }
public int RowCount { get { return mRowCount; } }
public int ColumnCount { get { return mColumnCount; } }
private void CleanMatrix()
{
if (mGridMatrix != null)
{
for (int r = 0; r < mRowCount; r++)
{
for (int c = 0; c < mColumnCount; c++)
{
DisplayNode cell = mGridMatrix[c, r];
this.mContent.RemoveChild(cell, true);
}
}
mGridMatrix = null;
}
}
public void Initialize(DisplayNode[,] cells, Vector2 cellSize)
{
CleanMatrix();
if (mGridMatrix == null)
{
mGridMatrix = cells;
mColumnCount = cells.GetLength(0);
mRowCount = cells.GetLength(1);
mCellSize = cellSize;
mContentSize = new Vector2(cellSize.x * mColumnCount, cellSize.y * mRowCount);
for (int r = 0; r < mRowCount; r++)
{
for (int c = 0; c < mColumnCount; c++)
{
DisplayNode cell = mGridMatrix[c, r];
cell.Bounds2D = new Rect(c * cellSize.x, r * cellSize.y, cellSize.x, cellSize.y);
mGridMatrix[c, r] = cell;
this.mContent.AddChild(cell);
}
}
}
}
public void Initialize(int columns, int rows, Vector2 cellSize, CreateCellItemHandler createCell)
{
CleanMatrix();
if (mGridMatrix == null)
{
if (rows < 1 || columns < 1) throw new Exception("rows columns must be lager than 1.");
if (cellSize.x < 0 || cellSize.y < 0) throw new Exception("unitWidth unitHeight must be lager than 0.");
mGridMatrix = new DisplayNode[columns, rows];
mColumnCount = columns;
mRowCount = rows;
mCellSize = cellSize;
mContentSize = new Vector2(cellSize.x * mColumnCount, cellSize.y * mRowCount);
for (int r = 0; r < mRowCount; r++)
{
for (int c = 0; c < mColumnCount; c++)
{
DisplayNode cell = createCell(this, c, r);
cell.Bounds2D = new Rect(c * cellSize.x, r * cellSize.y, cellSize.x, cellSize.y);
mGridMatrix[c, r] = cell;
this.mContent.AddChild(cell);
}
}
}
}
public DisplayNode GetCell(int column, int row)
{
if (mGridMatrix != null && CMath.isInRange(row, mRowCount) && CMath.isInRange(column, mColumnCount))
{
return mGridMatrix[column, row];
}
return null;
}
protected override void OnUpdateContentSize()
{
base.OnUpdateContentSize();
this.mContent.Size2D = mContentSize;
}
public delegate DisplayNode CreateCellItemHandler(GridScrollablePanel panel, int column, int row);
}
//----------------------------------------------------------------------------------------------------------------------------------
/// <summary>
/// 网格滚动控件（缓冲模式）
/// 适合大量固定数量数据的列表
/// </summary>
public class CachedGridScrollablePanel : ScrollablePanel
{
private Vector2 mCellSize = Vector2.zero;
private Vector2 mContentSize = Vector2.one;
private int mCacheSize = 2;
private int mRowCount = 0, mColumnCount = 0;
private int mViewRowCount = 0, mViewColumnCount = 0;
private Cell[,] mGridMatrix;
private LinkedList<Cell> mViewList = new LinkedList<Cell>();
private LinkedList<Cell> mHideList = new LinkedList<Cell>();
private List<Cell> mHidingList = new List<Cell>();
public CachedGridScrollablePanel(string name = null)
: base(name)
{
base.Scroll.AutoUpdateContentSize = false;
Gap = new Vector2();
Border = new Vector2();
}
public Vector2 CellSize { get { return mCellSize; } }
public int RowCount { get { return mRowCount; } }
public int ColumnCount { get { return mColumnCount; } }
public int ViewRowCount { get { return mViewRowCount; } }
public int ViewColumnCount { get { return mViewColumnCount; } }
public bool IsUseCache { get { return mCacheSize > -1; } }
public Vector2 Gap { get; set; }
public Vector2 Border { get; set; }
/// <summary>
/// 初始化滚动控件.CacheSize = -1时候为非托管模式，需要自己维护销毁节点.
/// </summary>
/// <param name="columns"></param>
/// <param name="rows"></param>
/// <param name="cellSize"></param>
/// <param name="cacheSize"></param>
public void Initialize(int columns, int rows, Vector2 cellSize, int cacheSize = 1)
{
ClearGrid();
if (mGridMatrix == null)
{
if (cellSize.x < 0 || cellSize.y < 0) throw new Exception("unitWidth unitHeight must be lager than 0.");
this.mCacheSize = cacheSize;
this.mCellSize = cellSize;
CalViewContent(columns, rows, true);
}
}
public void Reset(int columns, int rows)
{
if (mGridMatrix != null)
{
for (int r = 0; r < mRowCount; r++)
{
for (int c = 0; c < mColumnCount; c++)
{
Cell cell = mGridMatrix[c, r];
if (cell != null)
{
OnHideCell(cell);
}
}
}
mGridMatrix = null;
}
if (mGridMatrix == null)
{
CalViewContent(columns, rows, false);
}
}
public DisplayNode GetCell(int column, int row)
{
if (mGridMatrix != null && CMath.isInRange(row, mRowCount) && CMath.isInRange(column, mColumnCount))
{
Cell cell = mGridMatrix[column, row];
if (cell != null)
{
return cell.Node;
}
}
return null;
}
protected override void OnUpdateContentSize()
{
this.mContent.Size2D = this.mContentSize;
this.UpdateGrid();
}
/// <summary>
/// 清理所有滚动并销毁节点.
/// </summary>
public void ClearGrid()
{
bool isCache = IsUseCache;
if (mGridMatrix != null)
{
for (int r = 0; r < mRowCount; r++)
{
for (int c = 0; c < mColumnCount; c++)
{
Cell cell = mGridMatrix[c, r];
if (cell != null && cell.Node != null)
{
if (isCache)
{
//缓存托管模式主动释放销毁节点.
cell.Node.Dispose();
}
else
{
//非托管模式需要自己释放销毁节点.
cell.Node.RemoveFromParent(false);
}
mGridMatrix[c, r] = null;
}
}
}
mGridMatrix = null;
}
if (mHideList != null)
{
if (isCache)
{
for (LinkedListNode<Cell> it = mHideList.First; it != null; it = it.Next)
{
Cell cell = it.Value;
if (cell != null && cell.Node != null)
{
cell.Node.Dispose();
}
}
}
mHideList.Clear();
}
if (mViewList != null)
{
mViewList.Clear();
}
mColumnCount = 0;
mRowCount = 0;
mGridMatrix = null;
}
/// <summary>
/// 计算需要创建的节点个数.
/// </summary>
private void CalViewContent(int columns, int rows, bool isCreate)
{
if (columns < 1 || rows < 1) { return; }
Vector2 viewSize = this.Size2D;
this.mGridMatrix = new Cell[columns, rows];
this.mRowCount = rows;
this.mColumnCount = columns;
this.mContentSize = new Vector2(Border.x + columns * (mCellSize.x + Gap.x), Border.y + rows * (mCellSize.y + Gap.y));
this.mContent.Position2D = Vector2.zero;
this.mContent.Size2D = this.mContentSize;
if (IsUseCache == true)
{
this.mViewRowCount = (rows == 1) ? 1 : (int)(viewSize.y / mCellSize.y) + mCacheSize;
this.mViewRowCount = Math.Min(mRowCount, mViewRowCount);
this.mViewColumnCount = (columns == 1) ? 1 : (int)(viewSize.x / mCellSize.x) + mCacheSize;
this.mViewColumnCount = Math.Min(mColumnCount, mViewColumnCount);
}
else
{
this.mViewRowCount = rows;
this.mViewColumnCount = columns;
}
for (int r = 0; r < mViewRowCount; r++)
{
for (int c = 0; c < mViewColumnCount; c++)
{
//这里的Create应该注释掉，否则会在下一个update才会正真初始化完成。如果一定要区分create和show，建议重构一下.
//if (isCreate)
//{
// OnCreateCell();
//}
//else
{
OnShowCell(c, r);
}
}
}
}
//-----------------------------------------------------------------------------------------------------------------------
#region _Events_
protected override void OnDisposeEvents()
{
this.event_CreateCell = null;
this.event_HideCell = null;
this.event_ShowCell = null;
base.OnDisposeEvents();
}
public delegate DisplayNode CreateCellItemHandler(CachedGridScrollablePanel panel);
public delegate void HideCellItemHandler(CachedGridScrollablePanel panel, int column, int row, DisplayNode cell);
public delegate void ShowCellItemHandler(CachedGridScrollablePanel panel, int column, int row, DisplayNode cell);
[Desc("请求创建节点")]
public CreateCellItemHandler event_CreateCell;
[Desc("节点被隐藏")]
public HideCellItemHandler event_HideCell;
[Desc("节点将显示")]
public ShowCellItemHandler event_ShowCell;
#endregion
//-----------------------------------------------------------------------------------------------------------------------
#region _Cells_
private Cell OnCreateCell()
{
DisplayNode node = null;
if (event_CreateCell != null)
{
node = event_CreateCell.Invoke(this);
}
else
{
node = new DisplayNode("default cell");
}
//实际上代价很大，setactive会产生大量的gc，这里由rect2d来保证clip
//node.VisibleInParent = false;
Cell cell = new Cell(node);
mContent.AddChild(node);
mHideList.AddLast(cell);
return cell;
}
private Cell OnShowCell(int column, int row)
{
Cell cell = mGridMatrix[column, row];
if (cell == null)
{
if (mHideList.Count == 0)
{
cell = OnCreateCell();
}
cell = mHideList.First.Value;
mHideList.RemoveFirst();
mViewList.AddFirst(cell);
mGridMatrix[column, row] = cell;
cell.column = column;
cell.row = row;
cell.Node.Position2D = new Vector2(Border.x + (column * (mCellSize.x + Gap.x)), Border.y + row * (mCellSize.y+Gap.y));
//cell.Node.VisibleInParent = true;
if (event_ShowCell != null)
{
event_ShowCell.Invoke(this, column, row, cell.Node);
}
}
return cell;
}
private void OnHideCell(Cell cell)
{
mGridMatrix[cell.column, cell.row] = null;
mHideList.AddFirst(cell);
mViewList.Remove(cell);
cell.Node.Position2D = new Vector2(10000, 10000);
//cell.Node.VisibleInParent = false;
if (event_HideCell != null)
{
event_HideCell.Invoke(this, cell.column, cell.row, cell.Node);
}
}
private void UpdateGrid()
{
if (mGridMatrix != null)
{
Rect scroll_rect = this.ScrollRect2D;
Vector2 vsize = this.Size2D;
int sx1 = (int)((scroll_rect.x - Border.x) / (mCellSize.x + Gap.x));
int sx2 = (int)((scroll_rect.x - Border.x + scroll_rect.width) / (mCellSize.x + Gap.x));
int sy1 = (int)((scroll_rect.y - Border.y) / (mCellSize.y + Gap.y));
int sy2 = (int)((scroll_rect.y - Border.y + scroll_rect.height) / (mCellSize.y + Gap.y));
sx1 = Math.Max(sx1, 0);
sy1 = Math.Max(sy1, 0);
sx2 = Math.Min(sx2, this.mColumnCount - 1);
sy2 = Math.Min(sy2, this.mRowCount - 1);
//隐藏超出视野的//
mHidingList.Clear();
for (LinkedListNode<Cell> it = mViewList.First; it != null; it = it.Next)
{
Cell cell = it.Value;
if (!CMath.isIncludeEqual(cell.column, sx1, sx2) || !CMath.isIncludeEqual(cell.row, sy1, sy2))
{
mHidingList.Add(cell);
}
}
if (mHidingList.Count > 0)
{
for (int i = mHidingList.Count - 1; i >= 0; --i)
{
OnHideCell(mHidingList[i]);
}
mHidingList.Clear();
}
//显示进入视野//
for (int x = sx1; x <= sx2; x++)
{
for (int y = sy1; y <= sy2; y++)
{
OnShowCell(x, y);
}
}
}
}
public void RefreshShowCell()
{
if (mGridMatrix != null && mMaskScrollRect.Binding != null)
{
Rect scroll_rect = this.ScrollRect2D;
int sx1 = (int)((scroll_rect.x) / mCellSize.x);
int sx2 = (int)((scroll_rect.x + scroll_rect.width) / mCellSize.x);
int sy1 = (int)((scroll_rect.y) / mCellSize.y);
int sy2 = (int)((scroll_rect.y + scroll_rect.height) / mCellSize.y);
sx1 = Math.Max(sx1, 0);
sy1 = Math.Max(sy1, 0);
sx2 = Math.Min(sx2, this.mColumnCount - 1);
sy2 = Math.Min(sy2, this.mRowCount - 1);
//显示进入视野//
for (int x = sx1; x <= sx2; x++)
{
for (int y = sy1; y <= sy2; y++)
{
Cell cell = mGridMatrix[x, y];
if (event_ShowCell != null)
{
event_ShowCell.Invoke(this, x, y, cell.Node);
}
}
}
}
}
class Cell
{
public DisplayNode Node;
public int column, row;
public Cell(DisplayNode node)
{
this.Node = node;
}
}
#endregion
}
//-----------------------------------------------------------------------------------------------------------------------
/// <summary>
/// 分页式滚动控件
/// </summary>
public class PagedScrollablePanel : ScrollablePanel
{
private readonly PagedScrollableSnap mScrollSnap;
private int mPageCount;
private Vector2 mPageSize;
private Vector2 mContentSize;
private DisplayNode[] mPageList;
public PagedScrollablePanel(string name = null)
: base(name)
{
this.mScrollSnap = mGameObject.AddComponent<PagedScrollableSnap>();
this.Scroll.inertia = false;
this.Scroll.movementType = ScrollRectInteractive.MovementType.Clamped;
this.Scroll.horizontal = true;
this.Scroll.vertical = false;
this.Scroll.AutoUpdateContentSize = true;
}
public Vector2 ContentSize { get { return mContentSize; } }
public Vector2 PageSize { get { return mPageSize; } }
public int PageCount { get { return mPageCount; } }
public PagedScrollableSnap ScrollSnap { get { return mScrollSnap; } }
private void CleanPages()
{
if (mPageList != null)
{
for (int i = 0; i < mPageCount; i++)
{
DisplayNode cell = mPageList[i];
this.mContent.RemoveChild(cell, true);
}
mPageList = null;
}
}
public void Initialize(DisplayNode[] pages, Vector2 pageSize)
{
CleanPages();
if (mPageList == null)
{
mPageList = pages;
mPageCount = pages.Length;
mPageSize = pageSize;
mContentSize = new Vector2(pageSize.x * mPageCount, pageSize.y);
for (int i = 0; i < mPageCount; i++)
{
DisplayNode cell = mPageList[i];
cell.Bounds2D = new Rect(i * pageSize.x, 0, pageSize.x, pageSize.y);
mPageList[i] = cell;
this.mContent.AddChild(cell);
}
this.mContent.Size2D = mContentSize;
this.mScrollSnap.Reset();
}
}
public void Initialize(int pages, Vector2 pageSize, CreatePageItemHandler createPage)
{
CleanPages();
if (mPageList == null)
{
if (pages < 1) throw new Exception("rows columns must be lager than 1.");
if (pageSize.x < 0 || pageSize.y < 0) throw new Exception("unitWidth unitHeight must be lager than 0.");
mPageList = new DisplayNode[pages];
mPageCount = pages;
mPageSize = pageSize;
mContentSize = new Vector2(pageSize.x * mPageCount, pageSize.y);
for (int i = 0; i < mPageCount; i++)
{
DisplayNode page = createPage(this, i);
page.Bounds2D = new Rect(i * pageSize.x, 0, pageSize.x, pageSize.y);
mPageList[i] = page;
this.mContent.AddChild(page);
}
this.mContent.Size2D = mContentSize;
this.mScrollSnap.Reset();
}
}
public DisplayNode GetPage(int index)
{
if (mPageList != null && CMath.isInRange(index, mPageCount))
{
return mPageList[index];
}
return null;
}
protected override void OnUpdateContentSize()
{
base.OnUpdateContentSize();
this.mContent.Size2D = mContentSize;
}
public delegate DisplayNode CreatePageItemHandler(PagedScrollablePanel panel, int index);
}
[RequireComponent(typeof(ScrollRect))]
public class PagedScrollableSnap : MonoBehaviour, IBeginDragHandler, IEndDragHandler, IDragHandler
{
private PagedScrollablePanel _owner;
private Transform _screensContainer;
private int _screens = 1;
private int _startingScreen = 1;
private System.Collections.Generic.List<Vector3> _positions;
private ScrollRect _scroll_rect;
private Vector3 _lerp_target;
private bool _lerp;
private float _containerSize;
private bool _startDrag = true;
private Vector3 _startPosition = new Vector3();
private int _currentScreen;
public float LerpSpeed = 10;
public float DockDistance = 1;
/// <summary>
/// If set to something above zero, it will be possible to move to the next page after dragging past the specified threshold.
/// </summary>
public float nextPageThreshold = 0f;
// Use this for initialization
public void Reset()
{
_owner = DisplayNode.AsDisplayNode(gameObject) as PagedScrollablePanel;
_scroll_rect = _owner.Scroll;
_screensContainer = _owner.Container.Transform;
_screens = _owner.PageCount;
_lerp = false;
_positions = new System.Collections.Generic.List<Vector3>();
if (_screens > 0)
{
float step = _owner.PageSize.x;
for (int i = 0; i < _screens; ++i)
{
_scroll_rect.horizontalNormalizedPosition = (float)i / (float)(_screens - 1);
Vector3 pos = _screensContainer.localPosition;
pos.x = (int)(pos.x);
_positions.Add(pos);
}
}
_scroll_rect.horizontalNormalizedPosition = (float)(_startingScreen - 1) / (float)(_screens - 1);
_containerSize = _owner.ContentSize.x;
}
void Update()
{
if (_lerp)
{
float lpspeed = Mathf.Max(0.1f, LerpSpeed);
float dock = Mathf.Max(0.005f, DockDistance);
_screensContainer.localPosition = Vector3.Lerp(_screensContainer.localPosition, _lerp_target, lpspeed * Time.deltaTime);
if (Vector3.Distance(_screensContainer.localPosition, _lerp_target) < dock)
{
_screensContainer.localPosition = _lerp_target;
_lerp = false;
}
}
}
//Function for switching screens with buttons
public void NextScreen()
{
if (CurrentScreen() < _screens - 1)
{
_lerp = true;
_lerp_target = _positions[CurrentScreen() + 1];
}
}
//Function for switching screens with buttons
public void PreviousScreen()
{
if (CurrentScreen() > 0)
{
_lerp = true;
_lerp_target = _positions[CurrentScreen() - 1];
}
}
//Because the CurrentScreen function is not so reliable, these are the functions used for swipes
private void NextScreenCommand()
{
if (_currentScreen < _screens - 1)
{
_lerp = true;
_lerp_target = _positions[_currentScreen + 1];
}
}
//Because the CurrentScreen function is not so reliable, these are the functions used for swipes
private void PrevScreenCommand()
{
if (_currentScreen > 0)
{
_lerp = true;
_lerp_target = _positions[_currentScreen - 1];
}
}
//find the closest registered point to the releasing point
private Vector3 FindClosestFrom(Vector3 start, System.Collections.Generic.List<Vector3> positions)
{
Vector3 closest = Vector3.zero;
float distance = Mathf.Infinity;
foreach (Vector3 position in _positions)
{
if (Vector3.Distance(start, position) < distance)
{
distance = Vector3.Distance(start, position);
closest = position;
}
}
return closest;
}
private Vector3 FindMatchCondition(Vector3 start)
{
float delta = 0f;
if (_scroll_rect.horizontal)
{
delta = start.x - _positions[_currentScreen].x;
}
else if(_scroll_rect.vertical)
{
delta = start.y - _positions[_currentScreen].y;
}
if (Mathf.Abs(delta) > nextPageThreshold)
{
if (delta < -nextPageThreshold)
{
// Next page
if (_currentScreen < _positions.Count - 1)
{
_currentScreen = _currentScreen + 1;
}
}
else if (delta > nextPageThreshold)
{
// Previous page
if (_currentScreen > 0)
{
_currentScreen = _currentScreen - 1;
}
}
}
return _positions[_currentScreen];
}
//returns the current screen that the is seeing
public int CurrentScreen()
{
float absPoz = Math.Abs((_screensContainer as RectTransform).offsetMin.x);
absPoz = Mathf.Clamp(absPoz, 1, _containerSize - 1);
//0.5f为4舍5入的附加值，防止6.9被转成6的情况
float calc = (absPoz / _containerSize) * _screens + 0.5f;
return (int)calc;
}
#region Interfaces
public void OnBeginDrag(PointerEventData eventData)
{
if (_owner.EnableTouchInParents)
{
_startPosition = _screensContainer.localPosition;
_currentScreen = CurrentScreen();
}
}
public void OnEndDrag(PointerEventData eventData)
{
if (_owner.EnableTouchInParents)
{
_startDrag = true;
if (_scroll_rect.horizontal)
{
_lerp = true;
// If we have a touch in progress and the next page threshold set
if (nextPageThreshold > 0f)
{
_lerp_target = FindMatchCondition(_screensContainer.localPosition);
}
else
{
_lerp_target = FindClosestFrom(_screensContainer.localPosition, _positions);
}
}
}
}
public void OnDrag(PointerEventData eventData)
{
_lerp = false;
if (_startDrag)
{
OnBeginDrag(eventData);
_startDrag = false;
}
}
#endregion
}
//----------------------------------------------------------------------------------------------------------------------------------
}