niko
1298 lines
38 KiB
C#
1298 lines
38 KiB
C#
using System;
|
|
using UnityEngine.Events;
|
|
using UnityEngine.EventSystems;
|
|
|
|
namespace UnityEngine.UI
|
|
{
|
|
// Token: 0x0200006E RID: 110
|
|
[AddComponentMenu("UI/Scroll Rect", 37)]
|
|
[SelectionBase]
|
|
[ExecuteInEditMode]
|
|
[DisallowMultipleComponent]
|
|
[RequireComponent(typeof(RectTransform))]
|
|
public class ScrollRect : UIBehaviour, IInitializePotentialDragHandler, IBeginDragHandler, IEndDragHandler, IDragHandler, IScrollHandler, ICanvasElement, ILayoutElement, ILayoutGroup, IEventSystemHandler, ILayoutController
|
|
{
|
|
// Token: 0x060003BF RID: 959 RVA: 0x00015D2C File Offset: 0x0001412C
|
|
protected ScrollRect()
|
|
{
|
|
}
|
|
|
|
// Token: 0x17000100 RID: 256
|
|
// (get) Token: 0x060003C0 RID: 960 RVA: 0x00015DBC File Offset: 0x000141BC
|
|
// (set) Token: 0x060003C1 RID: 961 RVA: 0x00015DD7 File Offset: 0x000141D7
|
|
public RectTransform content
|
|
{
|
|
get
|
|
{
|
|
return this.m_Content;
|
|
}
|
|
set
|
|
{
|
|
this.m_Content = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000101 RID: 257
|
|
// (get) Token: 0x060003C2 RID: 962 RVA: 0x00015DE4 File Offset: 0x000141E4
|
|
// (set) Token: 0x060003C3 RID: 963 RVA: 0x00015DFF File Offset: 0x000141FF
|
|
public bool horizontal
|
|
{
|
|
get
|
|
{
|
|
return this.m_Horizontal;
|
|
}
|
|
set
|
|
{
|
|
this.m_Horizontal = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000102 RID: 258
|
|
// (get) Token: 0x060003C4 RID: 964 RVA: 0x00015E0C File Offset: 0x0001420C
|
|
// (set) Token: 0x060003C5 RID: 965 RVA: 0x00015E27 File Offset: 0x00014227
|
|
public bool vertical
|
|
{
|
|
get
|
|
{
|
|
return this.m_Vertical;
|
|
}
|
|
set
|
|
{
|
|
this.m_Vertical = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000103 RID: 259
|
|
// (get) Token: 0x060003C6 RID: 966 RVA: 0x00015E34 File Offset: 0x00014234
|
|
// (set) Token: 0x060003C7 RID: 967 RVA: 0x00015E4F File Offset: 0x0001424F
|
|
public ScrollRect.MovementType movementType
|
|
{
|
|
get
|
|
{
|
|
return this.m_MovementType;
|
|
}
|
|
set
|
|
{
|
|
this.m_MovementType = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000104 RID: 260
|
|
// (get) Token: 0x060003C8 RID: 968 RVA: 0x00015E5C File Offset: 0x0001425C
|
|
// (set) Token: 0x060003C9 RID: 969 RVA: 0x00015E77 File Offset: 0x00014277
|
|
public float elasticity
|
|
{
|
|
get
|
|
{
|
|
return this.m_Elasticity;
|
|
}
|
|
set
|
|
{
|
|
this.m_Elasticity = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000105 RID: 261
|
|
// (get) Token: 0x060003CA RID: 970 RVA: 0x00015E84 File Offset: 0x00014284
|
|
// (set) Token: 0x060003CB RID: 971 RVA: 0x00015E9F File Offset: 0x0001429F
|
|
public bool inertia
|
|
{
|
|
get
|
|
{
|
|
return this.m_Inertia;
|
|
}
|
|
set
|
|
{
|
|
this.m_Inertia = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000106 RID: 262
|
|
// (get) Token: 0x060003CC RID: 972 RVA: 0x00015EAC File Offset: 0x000142AC
|
|
// (set) Token: 0x060003CD RID: 973 RVA: 0x00015EC7 File Offset: 0x000142C7
|
|
public float decelerationRate
|
|
{
|
|
get
|
|
{
|
|
return this.m_DecelerationRate;
|
|
}
|
|
set
|
|
{
|
|
this.m_DecelerationRate = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000107 RID: 263
|
|
// (get) Token: 0x060003CE RID: 974 RVA: 0x00015ED4 File Offset: 0x000142D4
|
|
// (set) Token: 0x060003CF RID: 975 RVA: 0x00015EEF File Offset: 0x000142EF
|
|
public float scrollSensitivity
|
|
{
|
|
get
|
|
{
|
|
return this.m_ScrollSensitivity;
|
|
}
|
|
set
|
|
{
|
|
this.m_ScrollSensitivity = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000108 RID: 264
|
|
// (get) Token: 0x060003D0 RID: 976 RVA: 0x00015EFC File Offset: 0x000142FC
|
|
// (set) Token: 0x060003D1 RID: 977 RVA: 0x00015F17 File Offset: 0x00014317
|
|
public RectTransform viewport
|
|
{
|
|
get
|
|
{
|
|
return this.m_Viewport;
|
|
}
|
|
set
|
|
{
|
|
this.m_Viewport = value;
|
|
this.SetDirtyCaching();
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000109 RID: 265
|
|
// (get) Token: 0x060003D2 RID: 978 RVA: 0x00015F28 File Offset: 0x00014328
|
|
// (set) Token: 0x060003D3 RID: 979 RVA: 0x00015F44 File Offset: 0x00014344
|
|
public Scrollbar horizontalScrollbar
|
|
{
|
|
get
|
|
{
|
|
return this.m_HorizontalScrollbar;
|
|
}
|
|
set
|
|
{
|
|
if (this.m_HorizontalScrollbar)
|
|
{
|
|
this.m_HorizontalScrollbar.onValueChanged.RemoveListener(new UnityAction<float>(this.SetHorizontalNormalizedPosition));
|
|
}
|
|
this.m_HorizontalScrollbar = value;
|
|
if (this.m_HorizontalScrollbar)
|
|
{
|
|
this.m_HorizontalScrollbar.onValueChanged.AddListener(new UnityAction<float>(this.SetHorizontalNormalizedPosition));
|
|
}
|
|
this.SetDirtyCaching();
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700010A RID: 266
|
|
// (get) Token: 0x060003D4 RID: 980 RVA: 0x00015FB8 File Offset: 0x000143B8
|
|
// (set) Token: 0x060003D5 RID: 981 RVA: 0x00015FD4 File Offset: 0x000143D4
|
|
public Scrollbar verticalScrollbar
|
|
{
|
|
get
|
|
{
|
|
return this.m_VerticalScrollbar;
|
|
}
|
|
set
|
|
{
|
|
if (this.m_VerticalScrollbar)
|
|
{
|
|
this.m_VerticalScrollbar.onValueChanged.RemoveListener(new UnityAction<float>(this.SetVerticalNormalizedPosition));
|
|
}
|
|
this.m_VerticalScrollbar = value;
|
|
if (this.m_VerticalScrollbar)
|
|
{
|
|
this.m_VerticalScrollbar.onValueChanged.AddListener(new UnityAction<float>(this.SetVerticalNormalizedPosition));
|
|
}
|
|
this.SetDirtyCaching();
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700010B RID: 267
|
|
// (get) Token: 0x060003D6 RID: 982 RVA: 0x00016048 File Offset: 0x00014448
|
|
// (set) Token: 0x060003D7 RID: 983 RVA: 0x00016063 File Offset: 0x00014463
|
|
public ScrollRect.ScrollbarVisibility horizontalScrollbarVisibility
|
|
{
|
|
get
|
|
{
|
|
return this.m_HorizontalScrollbarVisibility;
|
|
}
|
|
set
|
|
{
|
|
this.m_HorizontalScrollbarVisibility = value;
|
|
this.SetDirtyCaching();
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700010C RID: 268
|
|
// (get) Token: 0x060003D8 RID: 984 RVA: 0x00016074 File Offset: 0x00014474
|
|
// (set) Token: 0x060003D9 RID: 985 RVA: 0x0001608F File Offset: 0x0001448F
|
|
public ScrollRect.ScrollbarVisibility verticalScrollbarVisibility
|
|
{
|
|
get
|
|
{
|
|
return this.m_VerticalScrollbarVisibility;
|
|
}
|
|
set
|
|
{
|
|
this.m_VerticalScrollbarVisibility = value;
|
|
this.SetDirtyCaching();
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700010D RID: 269
|
|
// (get) Token: 0x060003DA RID: 986 RVA: 0x000160A0 File Offset: 0x000144A0
|
|
// (set) Token: 0x060003DB RID: 987 RVA: 0x000160BB File Offset: 0x000144BB
|
|
public float horizontalScrollbarSpacing
|
|
{
|
|
get
|
|
{
|
|
return this.m_HorizontalScrollbarSpacing;
|
|
}
|
|
set
|
|
{
|
|
this.m_HorizontalScrollbarSpacing = value;
|
|
this.SetDirty();
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700010E RID: 270
|
|
// (get) Token: 0x060003DC RID: 988 RVA: 0x000160CC File Offset: 0x000144CC
|
|
// (set) Token: 0x060003DD RID: 989 RVA: 0x000160E7 File Offset: 0x000144E7
|
|
public float verticalScrollbarSpacing
|
|
{
|
|
get
|
|
{
|
|
return this.m_VerticalScrollbarSpacing;
|
|
}
|
|
set
|
|
{
|
|
this.m_VerticalScrollbarSpacing = value;
|
|
this.SetDirty();
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700010F RID: 271
|
|
// (get) Token: 0x060003DE RID: 990 RVA: 0x000160F8 File Offset: 0x000144F8
|
|
// (set) Token: 0x060003DF RID: 991 RVA: 0x00016113 File Offset: 0x00014513
|
|
public ScrollRect.ScrollRectEvent onValueChanged
|
|
{
|
|
get
|
|
{
|
|
return this.m_OnValueChanged;
|
|
}
|
|
set
|
|
{
|
|
this.m_OnValueChanged = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000110 RID: 272
|
|
// (get) Token: 0x060003E0 RID: 992 RVA: 0x00016120 File Offset: 0x00014520
|
|
protected RectTransform viewRect
|
|
{
|
|
get
|
|
{
|
|
if (this.m_ViewRect == null)
|
|
{
|
|
this.m_ViewRect = this.m_Viewport;
|
|
}
|
|
if (this.m_ViewRect == null)
|
|
{
|
|
this.m_ViewRect = (RectTransform)base.transform;
|
|
}
|
|
return this.m_ViewRect;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000111 RID: 273
|
|
// (get) Token: 0x060003E1 RID: 993 RVA: 0x0001617C File Offset: 0x0001457C
|
|
// (set) Token: 0x060003E2 RID: 994 RVA: 0x00016197 File Offset: 0x00014597
|
|
public Vector2 velocity
|
|
{
|
|
get
|
|
{
|
|
return this.m_Velocity;
|
|
}
|
|
set
|
|
{
|
|
this.m_Velocity = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000112 RID: 274
|
|
// (get) Token: 0x060003E3 RID: 995 RVA: 0x000161A4 File Offset: 0x000145A4
|
|
private RectTransform rectTransform
|
|
{
|
|
get
|
|
{
|
|
if (this.m_Rect == null)
|
|
{
|
|
this.m_Rect = base.GetComponent<RectTransform>();
|
|
}
|
|
return this.m_Rect;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060003E4 RID: 996 RVA: 0x000161DC File Offset: 0x000145DC
|
|
public virtual void Rebuild(CanvasUpdate executing)
|
|
{
|
|
if (executing == CanvasUpdate.Prelayout)
|
|
{
|
|
this.UpdateCachedData();
|
|
}
|
|
if (executing == CanvasUpdate.PostLayout)
|
|
{
|
|
this.UpdateBounds();
|
|
this.UpdateScrollbars(Vector2.zero);
|
|
this.UpdatePrevData();
|
|
this.m_HasRebuiltLayout = true;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060003E5 RID: 997 RVA: 0x00016214 File Offset: 0x00014614
|
|
public virtual void LayoutComplete()
|
|
{
|
|
}
|
|
|
|
// Token: 0x060003E6 RID: 998 RVA: 0x00016217 File Offset: 0x00014617
|
|
public virtual void GraphicUpdateComplete()
|
|
{
|
|
}
|
|
|
|
// Token: 0x060003E7 RID: 999 RVA: 0x0001621C File Offset: 0x0001461C
|
|
private void UpdateCachedData()
|
|
{
|
|
Transform transform = base.transform;
|
|
this.m_HorizontalScrollbarRect = ((!(this.m_HorizontalScrollbar == null)) ? (this.m_HorizontalScrollbar.transform as RectTransform) : null);
|
|
this.m_VerticalScrollbarRect = ((!(this.m_VerticalScrollbar == null)) ? (this.m_VerticalScrollbar.transform as RectTransform) : null);
|
|
bool flag = this.viewRect.parent == transform;
|
|
bool flag2 = !this.m_HorizontalScrollbarRect || this.m_HorizontalScrollbarRect.parent == transform;
|
|
bool flag3 = !this.m_VerticalScrollbarRect || this.m_VerticalScrollbarRect.parent == transform;
|
|
bool flag4 = flag && flag2 && flag3;
|
|
this.m_HSliderExpand = flag4 && this.m_HorizontalScrollbarRect && this.horizontalScrollbarVisibility == ScrollRect.ScrollbarVisibility.AutoHideAndExpandViewport;
|
|
this.m_VSliderExpand = flag4 && this.m_VerticalScrollbarRect && this.verticalScrollbarVisibility == ScrollRect.ScrollbarVisibility.AutoHideAndExpandViewport;
|
|
this.m_HSliderHeight = ((!(this.m_HorizontalScrollbarRect == null)) ? this.m_HorizontalScrollbarRect.rect.height : 0f);
|
|
this.m_VSliderWidth = ((!(this.m_VerticalScrollbarRect == null)) ? this.m_VerticalScrollbarRect.rect.width : 0f);
|
|
}
|
|
|
|
// Token: 0x060003E8 RID: 1000 RVA: 0x000163B8 File Offset: 0x000147B8
|
|
protected override void OnEnable()
|
|
{
|
|
base.OnEnable();
|
|
if (this.m_HorizontalScrollbar)
|
|
{
|
|
this.m_HorizontalScrollbar.onValueChanged.AddListener(new UnityAction<float>(this.SetHorizontalNormalizedPosition));
|
|
}
|
|
if (this.m_VerticalScrollbar)
|
|
{
|
|
this.m_VerticalScrollbar.onValueChanged.AddListener(new UnityAction<float>(this.SetVerticalNormalizedPosition));
|
|
}
|
|
CanvasUpdateRegistry.RegisterCanvasElementForLayoutRebuild(this);
|
|
}
|
|
|
|
// Token: 0x060003E9 RID: 1001 RVA: 0x0001642C File Offset: 0x0001482C
|
|
protected override void OnDisable()
|
|
{
|
|
CanvasUpdateRegistry.UnRegisterCanvasElementForRebuild(this);
|
|
if (this.m_HorizontalScrollbar)
|
|
{
|
|
this.m_HorizontalScrollbar.onValueChanged.RemoveListener(new UnityAction<float>(this.SetHorizontalNormalizedPosition));
|
|
}
|
|
if (this.m_VerticalScrollbar)
|
|
{
|
|
this.m_VerticalScrollbar.onValueChanged.RemoveListener(new UnityAction<float>(this.SetVerticalNormalizedPosition));
|
|
}
|
|
this.m_HasRebuiltLayout = false;
|
|
this.m_Tracker.Clear();
|
|
this.m_Velocity = Vector2.zero;
|
|
LayoutRebuilder.MarkLayoutForRebuild(this.rectTransform);
|
|
base.OnDisable();
|
|
}
|
|
|
|
// Token: 0x060003EA RID: 1002 RVA: 0x000164C8 File Offset: 0x000148C8
|
|
public override bool IsActive()
|
|
{
|
|
return base.IsActive() && this.m_Content != null;
|
|
}
|
|
|
|
// Token: 0x060003EB RID: 1003 RVA: 0x000164F7 File Offset: 0x000148F7
|
|
private void EnsureLayoutHasRebuilt()
|
|
{
|
|
if (!this.m_HasRebuiltLayout && !CanvasUpdateRegistry.IsRebuildingLayout())
|
|
{
|
|
Canvas.ForceUpdateCanvases();
|
|
}
|
|
}
|
|
|
|
// Token: 0x060003EC RID: 1004 RVA: 0x00016514 File Offset: 0x00014914
|
|
public virtual void StopMovement()
|
|
{
|
|
this.m_Velocity = Vector2.zero;
|
|
}
|
|
|
|
// Token: 0x060003ED RID: 1005 RVA: 0x00016524 File Offset: 0x00014924
|
|
public virtual void OnScroll(PointerEventData data)
|
|
{
|
|
if (this.IsActive())
|
|
{
|
|
this.EnsureLayoutHasRebuilt();
|
|
this.UpdateBounds();
|
|
Vector2 scrollDelta = data.scrollDelta;
|
|
scrollDelta.y *= -1f;
|
|
if (this.vertical && !this.horizontal)
|
|
{
|
|
if (Mathf.Abs(scrollDelta.x) > Mathf.Abs(scrollDelta.y))
|
|
{
|
|
scrollDelta.y = scrollDelta.x;
|
|
}
|
|
scrollDelta.x = 0f;
|
|
}
|
|
if (this.horizontal && !this.vertical)
|
|
{
|
|
if (Mathf.Abs(scrollDelta.y) > Mathf.Abs(scrollDelta.x))
|
|
{
|
|
scrollDelta.x = scrollDelta.y;
|
|
}
|
|
scrollDelta.y = 0f;
|
|
}
|
|
Vector2 vector = this.m_Content.anchoredPosition;
|
|
vector += scrollDelta * this.m_ScrollSensitivity;
|
|
if (this.m_MovementType == ScrollRect.MovementType.Clamped)
|
|
{
|
|
vector += this.CalculateOffset(vector - this.m_Content.anchoredPosition);
|
|
}
|
|
this.SetContentAnchoredPosition(vector);
|
|
this.UpdateBounds();
|
|
}
|
|
}
|
|
|
|
// Token: 0x060003EE RID: 1006 RVA: 0x0001665C File Offset: 0x00014A5C
|
|
public virtual void OnInitializePotentialDrag(PointerEventData eventData)
|
|
{
|
|
if (eventData.button == PointerEventData.InputButton.Left)
|
|
{
|
|
this.m_Velocity = Vector2.zero;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060003EF RID: 1007 RVA: 0x0001667C File Offset: 0x00014A7C
|
|
public virtual void OnBeginDrag(PointerEventData eventData)
|
|
{
|
|
if (eventData.button == PointerEventData.InputButton.Left)
|
|
{
|
|
if (this.IsActive())
|
|
{
|
|
this.UpdateBounds();
|
|
this.m_PointerStartLocalCursor = Vector2.zero;
|
|
RectTransformUtility.ScreenPointToLocalPointInRectangle(this.viewRect, eventData.position, eventData.pressEventCamera, out this.m_PointerStartLocalCursor);
|
|
this.m_ContentStartPosition = this.m_Content.anchoredPosition;
|
|
this.m_Dragging = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060003F0 RID: 1008 RVA: 0x000166F1 File Offset: 0x00014AF1
|
|
public virtual void OnEndDrag(PointerEventData eventData)
|
|
{
|
|
if (eventData.button == PointerEventData.InputButton.Left)
|
|
{
|
|
this.m_Dragging = false;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060003F1 RID: 1009 RVA: 0x0001670C File Offset: 0x00014B0C
|
|
public virtual void OnDrag(PointerEventData eventData)
|
|
{
|
|
if (eventData.button == PointerEventData.InputButton.Left)
|
|
{
|
|
if (this.IsActive())
|
|
{
|
|
Vector2 vector;
|
|
if (RectTransformUtility.ScreenPointToLocalPointInRectangle(this.viewRect, eventData.position, eventData.pressEventCamera, out vector))
|
|
{
|
|
this.UpdateBounds();
|
|
Vector2 vector2 = vector - this.m_PointerStartLocalCursor;
|
|
Vector2 vector3 = this.m_ContentStartPosition + vector2;
|
|
Vector2 vector4 = this.CalculateOffset(vector3 - this.m_Content.anchoredPosition);
|
|
vector3 += vector4;
|
|
if (this.m_MovementType == ScrollRect.MovementType.Elastic)
|
|
{
|
|
if (vector4.x != 0f)
|
|
{
|
|
vector3.x -= ScrollRect.RubberDelta(vector4.x, this.m_ViewBounds.size.x);
|
|
}
|
|
if (vector4.y != 0f)
|
|
{
|
|
vector3.y -= ScrollRect.RubberDelta(vector4.y, this.m_ViewBounds.size.y);
|
|
}
|
|
}
|
|
this.SetContentAnchoredPosition(vector3);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060003F2 RID: 1010 RVA: 0x00016834 File Offset: 0x00014C34
|
|
protected virtual void SetContentAnchoredPosition(Vector2 position)
|
|
{
|
|
if (!this.m_Horizontal)
|
|
{
|
|
position.x = this.m_Content.anchoredPosition.x;
|
|
}
|
|
if (!this.m_Vertical)
|
|
{
|
|
position.y = this.m_Content.anchoredPosition.y;
|
|
}
|
|
if (position != this.m_Content.anchoredPosition)
|
|
{
|
|
this.m_Content.anchoredPosition = position;
|
|
this.UpdateBounds();
|
|
}
|
|
}
|
|
|
|
// Token: 0x060003F3 RID: 1011 RVA: 0x000168B8 File Offset: 0x00014CB8
|
|
protected virtual void LateUpdate()
|
|
{
|
|
if (this.m_Content)
|
|
{
|
|
this.EnsureLayoutHasRebuilt();
|
|
this.UpdateScrollbarVisibility();
|
|
this.UpdateBounds();
|
|
float unscaledDeltaTime = Time.unscaledDeltaTime;
|
|
Vector2 vector = this.CalculateOffset(Vector2.zero);
|
|
if (!this.m_Dragging && (vector != Vector2.zero || this.m_Velocity != Vector2.zero))
|
|
{
|
|
Vector2 vector2 = this.m_Content.anchoredPosition;
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
if (this.m_MovementType == ScrollRect.MovementType.Elastic && vector[i] != 0f)
|
|
{
|
|
float num = this.m_Velocity[i];
|
|
vector2[i] = Mathf.SmoothDamp(this.m_Content.anchoredPosition[i], this.m_Content.anchoredPosition[i] + vector[i], ref num, this.m_Elasticity, float.PositiveInfinity, unscaledDeltaTime);
|
|
if (Mathf.Abs(num) < 1f)
|
|
{
|
|
num = 0f;
|
|
}
|
|
this.m_Velocity[i] = num;
|
|
}
|
|
else if (this.m_Inertia)
|
|
{
|
|
ref Vector2 ptr = ref this.m_Velocity;
|
|
int num2;
|
|
this.m_Velocity[num2 = i] = ptr[num2] * Mathf.Pow(this.m_DecelerationRate, unscaledDeltaTime);
|
|
if (Mathf.Abs(this.m_Velocity[i]) < 1f)
|
|
{
|
|
this.m_Velocity[i] = 0f;
|
|
}
|
|
ptr = ref vector2;
|
|
int num3;
|
|
vector2[num3 = i] = ptr[num3] + this.m_Velocity[i] * unscaledDeltaTime;
|
|
}
|
|
else
|
|
{
|
|
this.m_Velocity[i] = 0f;
|
|
}
|
|
}
|
|
if (this.m_Velocity != Vector2.zero)
|
|
{
|
|
if (this.m_MovementType == ScrollRect.MovementType.Clamped)
|
|
{
|
|
vector = this.CalculateOffset(vector2 - this.m_Content.anchoredPosition);
|
|
vector2 += vector;
|
|
}
|
|
this.SetContentAnchoredPosition(vector2);
|
|
}
|
|
}
|
|
if (this.m_Dragging && this.m_Inertia)
|
|
{
|
|
Vector3 vector3 = (this.m_Content.anchoredPosition - this.m_PrevPosition) / unscaledDeltaTime;
|
|
this.m_Velocity = Vector3.Lerp(this.m_Velocity, vector3, unscaledDeltaTime * 10f);
|
|
}
|
|
if (this.m_ViewBounds != this.m_PrevViewBounds || this.m_ContentBounds != this.m_PrevContentBounds || this.m_Content.anchoredPosition != this.m_PrevPosition)
|
|
{
|
|
this.UpdateScrollbars(vector);
|
|
UISystemProfilerApi.AddMarker("ScrollRect.value", this);
|
|
this.m_OnValueChanged.Invoke(this.normalizedPosition);
|
|
this.UpdatePrevData();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060003F4 RID: 1012 RVA: 0x00016BB4 File Offset: 0x00014FB4
|
|
protected void UpdatePrevData()
|
|
{
|
|
if (this.m_Content == null)
|
|
{
|
|
this.m_PrevPosition = Vector2.zero;
|
|
}
|
|
else
|
|
{
|
|
this.m_PrevPosition = this.m_Content.anchoredPosition;
|
|
}
|
|
this.m_PrevViewBounds = this.m_ViewBounds;
|
|
this.m_PrevContentBounds = this.m_ContentBounds;
|
|
}
|
|
|
|
// Token: 0x060003F5 RID: 1013 RVA: 0x00016C0C File Offset: 0x0001500C
|
|
private void UpdateScrollbars(Vector2 offset)
|
|
{
|
|
if (this.m_HorizontalScrollbar)
|
|
{
|
|
if (this.m_ContentBounds.size.x > 0f)
|
|
{
|
|
this.m_HorizontalScrollbar.size = Mathf.Clamp01((this.m_ViewBounds.size.x - Mathf.Abs(offset.x)) / this.m_ContentBounds.size.x);
|
|
}
|
|
else
|
|
{
|
|
this.m_HorizontalScrollbar.size = 1f;
|
|
}
|
|
this.m_HorizontalScrollbar.value = this.horizontalNormalizedPosition;
|
|
}
|
|
if (this.m_VerticalScrollbar)
|
|
{
|
|
if (this.m_ContentBounds.size.y > 0f)
|
|
{
|
|
this.m_VerticalScrollbar.size = Mathf.Clamp01((this.m_ViewBounds.size.y - Mathf.Abs(offset.y)) / this.m_ContentBounds.size.y);
|
|
}
|
|
else
|
|
{
|
|
this.m_VerticalScrollbar.size = 1f;
|
|
}
|
|
this.m_VerticalScrollbar.value = this.verticalNormalizedPosition;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000113 RID: 275
|
|
// (get) Token: 0x060003F6 RID: 1014 RVA: 0x00016D50 File Offset: 0x00015150
|
|
// (set) Token: 0x060003F7 RID: 1015 RVA: 0x00016D76 File Offset: 0x00015176
|
|
public Vector2 normalizedPosition
|
|
{
|
|
get
|
|
{
|
|
return new Vector2(this.horizontalNormalizedPosition, this.verticalNormalizedPosition);
|
|
}
|
|
set
|
|
{
|
|
this.SetNormalizedPosition(value.x, 0);
|
|
this.SetNormalizedPosition(value.y, 1);
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000114 RID: 276
|
|
// (get) Token: 0x060003F8 RID: 1016 RVA: 0x00016D98 File Offset: 0x00015198
|
|
// (set) Token: 0x060003F9 RID: 1017 RVA: 0x00016E6D File Offset: 0x0001526D
|
|
public float horizontalNormalizedPosition
|
|
{
|
|
get
|
|
{
|
|
this.UpdateBounds();
|
|
float num;
|
|
if (this.m_ContentBounds.size.x <= this.m_ViewBounds.size.x)
|
|
{
|
|
num = (float)((this.m_ViewBounds.min.x <= this.m_ContentBounds.min.x) ? 0 : 1);
|
|
}
|
|
else
|
|
{
|
|
num = (this.m_ViewBounds.min.x - this.m_ContentBounds.min.x) / (this.m_ContentBounds.size.x - this.m_ViewBounds.size.x);
|
|
}
|
|
return num;
|
|
}
|
|
set
|
|
{
|
|
this.SetNormalizedPosition(value, 0);
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000115 RID: 277
|
|
// (get) Token: 0x060003FA RID: 1018 RVA: 0x00016E78 File Offset: 0x00015278
|
|
// (set) Token: 0x060003FB RID: 1019 RVA: 0x00016F4D File Offset: 0x0001534D
|
|
public float verticalNormalizedPosition
|
|
{
|
|
get
|
|
{
|
|
this.UpdateBounds();
|
|
float num;
|
|
if (this.m_ContentBounds.size.y <= this.m_ViewBounds.size.y)
|
|
{
|
|
num = (float)((this.m_ViewBounds.min.y <= this.m_ContentBounds.min.y) ? 0 : 1);
|
|
}
|
|
else
|
|
{
|
|
num = (this.m_ViewBounds.min.y - this.m_ContentBounds.min.y) / (this.m_ContentBounds.size.y - this.m_ViewBounds.size.y);
|
|
}
|
|
return num;
|
|
}
|
|
set
|
|
{
|
|
this.SetNormalizedPosition(value, 1);
|
|
}
|
|
}
|
|
|
|
// Token: 0x060003FC RID: 1020 RVA: 0x00016F58 File Offset: 0x00015358
|
|
private void SetHorizontalNormalizedPosition(float value)
|
|
{
|
|
this.SetNormalizedPosition(value, 0);
|
|
}
|
|
|
|
// Token: 0x060003FD RID: 1021 RVA: 0x00016F63 File Offset: 0x00015363
|
|
private void SetVerticalNormalizedPosition(float value)
|
|
{
|
|
this.SetNormalizedPosition(value, 1);
|
|
}
|
|
|
|
// Token: 0x060003FE RID: 1022 RVA: 0x00016F70 File Offset: 0x00015370
|
|
protected virtual void SetNormalizedPosition(float value, int axis)
|
|
{
|
|
this.EnsureLayoutHasRebuilt();
|
|
this.UpdateBounds();
|
|
float num = this.m_ContentBounds.size[axis] - this.m_ViewBounds.size[axis];
|
|
float num2 = this.m_ViewBounds.min[axis] - value * num;
|
|
float num3 = this.m_Content.localPosition[axis] + num2 - this.m_ContentBounds.min[axis];
|
|
Vector3 localPosition = this.m_Content.localPosition;
|
|
if (Mathf.Abs(localPosition[axis] - num3) > 0.01f)
|
|
{
|
|
localPosition[axis] = num3;
|
|
this.m_Content.localPosition = localPosition;
|
|
this.m_Velocity[axis] = 0f;
|
|
this.UpdateBounds();
|
|
}
|
|
}
|
|
|
|
// Token: 0x060003FF RID: 1023 RVA: 0x00017054 File Offset: 0x00015454
|
|
private static float RubberDelta(float overStretching, float viewSize)
|
|
{
|
|
return (1f - 1f / (Mathf.Abs(overStretching) * 0.55f / viewSize + 1f)) * viewSize * Mathf.Sign(overStretching);
|
|
}
|
|
|
|
// Token: 0x06000400 RID: 1024 RVA: 0x00017092 File Offset: 0x00015492
|
|
protected override void OnRectTransformDimensionsChange()
|
|
{
|
|
this.SetDirty();
|
|
}
|
|
|
|
// Token: 0x17000116 RID: 278
|
|
// (get) Token: 0x06000401 RID: 1025 RVA: 0x0001709C File Offset: 0x0001549C
|
|
private bool hScrollingNeeded
|
|
{
|
|
get
|
|
{
|
|
return !Application.isPlaying || this.m_ContentBounds.size.x > this.m_ViewBounds.size.x + 0.01f;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000117 RID: 279
|
|
// (get) Token: 0x06000402 RID: 1026 RVA: 0x000170F0 File Offset: 0x000154F0
|
|
private bool vScrollingNeeded
|
|
{
|
|
get
|
|
{
|
|
return !Application.isPlaying || this.m_ContentBounds.size.y > this.m_ViewBounds.size.y + 0.01f;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000403 RID: 1027 RVA: 0x00017144 File Offset: 0x00015544
|
|
public virtual void CalculateLayoutInputHorizontal()
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000404 RID: 1028 RVA: 0x00017147 File Offset: 0x00015547
|
|
public virtual void CalculateLayoutInputVertical()
|
|
{
|
|
}
|
|
|
|
// Token: 0x17000118 RID: 280
|
|
// (get) Token: 0x06000405 RID: 1029 RVA: 0x0001714C File Offset: 0x0001554C
|
|
public virtual float minWidth
|
|
{
|
|
get
|
|
{
|
|
return -1f;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000119 RID: 281
|
|
// (get) Token: 0x06000406 RID: 1030 RVA: 0x00017168 File Offset: 0x00015568
|
|
public virtual float preferredWidth
|
|
{
|
|
get
|
|
{
|
|
return -1f;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700011A RID: 282
|
|
// (get) Token: 0x06000407 RID: 1031 RVA: 0x00017184 File Offset: 0x00015584
|
|
public virtual float flexibleWidth
|
|
{
|
|
get
|
|
{
|
|
return -1f;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700011B RID: 283
|
|
// (get) Token: 0x06000408 RID: 1032 RVA: 0x000171A0 File Offset: 0x000155A0
|
|
public virtual float minHeight
|
|
{
|
|
get
|
|
{
|
|
return -1f;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700011C RID: 284
|
|
// (get) Token: 0x06000409 RID: 1033 RVA: 0x000171BC File Offset: 0x000155BC
|
|
public virtual float preferredHeight
|
|
{
|
|
get
|
|
{
|
|
return -1f;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700011D RID: 285
|
|
// (get) Token: 0x0600040A RID: 1034 RVA: 0x000171D8 File Offset: 0x000155D8
|
|
public virtual float flexibleHeight
|
|
{
|
|
get
|
|
{
|
|
return -1f;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700011E RID: 286
|
|
// (get) Token: 0x0600040B RID: 1035 RVA: 0x000171F4 File Offset: 0x000155F4
|
|
public virtual int layoutPriority
|
|
{
|
|
get
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600040C RID: 1036 RVA: 0x0001720C File Offset: 0x0001560C
|
|
public virtual void SetLayoutHorizontal()
|
|
{
|
|
this.m_Tracker.Clear();
|
|
if (this.m_HSliderExpand || this.m_VSliderExpand)
|
|
{
|
|
this.m_Tracker.Add(this, this.viewRect, DrivenTransformProperties.AnchoredPositionX | DrivenTransformProperties.AnchoredPositionY | DrivenTransformProperties.AnchorMinX | DrivenTransformProperties.AnchorMinY | DrivenTransformProperties.AnchorMaxX | DrivenTransformProperties.AnchorMaxY | DrivenTransformProperties.SizeDeltaX | DrivenTransformProperties.SizeDeltaY);
|
|
this.viewRect.anchorMin = Vector2.zero;
|
|
this.viewRect.anchorMax = Vector2.one;
|
|
this.viewRect.sizeDelta = Vector2.zero;
|
|
this.viewRect.anchoredPosition = Vector2.zero;
|
|
LayoutRebuilder.ForceRebuildLayoutImmediate(this.content);
|
|
this.m_ViewBounds = new Bounds(this.viewRect.rect.center, this.viewRect.rect.size);
|
|
this.m_ContentBounds = this.GetBounds();
|
|
}
|
|
if (this.m_VSliderExpand && this.vScrollingNeeded)
|
|
{
|
|
this.viewRect.sizeDelta = new Vector2(-(this.m_VSliderWidth + this.m_VerticalScrollbarSpacing), this.viewRect.sizeDelta.y);
|
|
LayoutRebuilder.ForceRebuildLayoutImmediate(this.content);
|
|
this.m_ViewBounds = new Bounds(this.viewRect.rect.center, this.viewRect.rect.size);
|
|
this.m_ContentBounds = this.GetBounds();
|
|
}
|
|
if (this.m_HSliderExpand && this.hScrollingNeeded)
|
|
{
|
|
this.viewRect.sizeDelta = new Vector2(this.viewRect.sizeDelta.x, -(this.m_HSliderHeight + this.m_HorizontalScrollbarSpacing));
|
|
this.m_ViewBounds = new Bounds(this.viewRect.rect.center, this.viewRect.rect.size);
|
|
this.m_ContentBounds = this.GetBounds();
|
|
}
|
|
if (this.m_VSliderExpand && this.vScrollingNeeded && this.viewRect.sizeDelta.x == 0f && this.viewRect.sizeDelta.y < 0f)
|
|
{
|
|
this.viewRect.sizeDelta = new Vector2(-(this.m_VSliderWidth + this.m_VerticalScrollbarSpacing), this.viewRect.sizeDelta.y);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600040D RID: 1037 RVA: 0x0001749C File Offset: 0x0001589C
|
|
public virtual void SetLayoutVertical()
|
|
{
|
|
this.UpdateScrollbarLayout();
|
|
this.m_ViewBounds = new Bounds(this.viewRect.rect.center, this.viewRect.rect.size);
|
|
this.m_ContentBounds = this.GetBounds();
|
|
}
|
|
|
|
// Token: 0x0600040E RID: 1038 RVA: 0x000174F7 File Offset: 0x000158F7
|
|
private void UpdateScrollbarVisibility()
|
|
{
|
|
ScrollRect.UpdateOneScrollbarVisibility(this.vScrollingNeeded, this.m_Vertical, this.m_VerticalScrollbarVisibility, this.m_VerticalScrollbar);
|
|
ScrollRect.UpdateOneScrollbarVisibility(this.hScrollingNeeded, this.m_Horizontal, this.m_HorizontalScrollbarVisibility, this.m_HorizontalScrollbar);
|
|
}
|
|
|
|
// Token: 0x0600040F RID: 1039 RVA: 0x00017534 File Offset: 0x00015934
|
|
private static void UpdateOneScrollbarVisibility(bool xScrollingNeeded, bool xAxisEnabled, ScrollRect.ScrollbarVisibility scrollbarVisibility, Scrollbar scrollbar)
|
|
{
|
|
if (scrollbar)
|
|
{
|
|
if (scrollbarVisibility == ScrollRect.ScrollbarVisibility.Permanent)
|
|
{
|
|
if (scrollbar.gameObject.activeSelf != xAxisEnabled)
|
|
{
|
|
scrollbar.gameObject.SetActive(xAxisEnabled);
|
|
}
|
|
}
|
|
else if (scrollbar.gameObject.activeSelf != xScrollingNeeded)
|
|
{
|
|
scrollbar.gameObject.SetActive(xScrollingNeeded);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000410 RID: 1040 RVA: 0x00017598 File Offset: 0x00015998
|
|
private void UpdateScrollbarLayout()
|
|
{
|
|
if (this.m_VSliderExpand && this.m_HorizontalScrollbar)
|
|
{
|
|
this.m_Tracker.Add(this, this.m_HorizontalScrollbarRect, DrivenTransformProperties.AnchoredPositionX | DrivenTransformProperties.AnchorMinX | DrivenTransformProperties.AnchorMaxX | DrivenTransformProperties.SizeDeltaX);
|
|
this.m_HorizontalScrollbarRect.anchorMin = new Vector2(0f, this.m_HorizontalScrollbarRect.anchorMin.y);
|
|
this.m_HorizontalScrollbarRect.anchorMax = new Vector2(1f, this.m_HorizontalScrollbarRect.anchorMax.y);
|
|
this.m_HorizontalScrollbarRect.anchoredPosition = new Vector2(0f, this.m_HorizontalScrollbarRect.anchoredPosition.y);
|
|
if (this.vScrollingNeeded)
|
|
{
|
|
this.m_HorizontalScrollbarRect.sizeDelta = new Vector2(-(this.m_VSliderWidth + this.m_VerticalScrollbarSpacing), this.m_HorizontalScrollbarRect.sizeDelta.y);
|
|
}
|
|
else
|
|
{
|
|
this.m_HorizontalScrollbarRect.sizeDelta = new Vector2(0f, this.m_HorizontalScrollbarRect.sizeDelta.y);
|
|
}
|
|
}
|
|
if (this.m_HSliderExpand && this.m_VerticalScrollbar)
|
|
{
|
|
this.m_Tracker.Add(this, this.m_VerticalScrollbarRect, DrivenTransformProperties.AnchoredPositionY | DrivenTransformProperties.AnchorMinY | DrivenTransformProperties.AnchorMaxY | DrivenTransformProperties.SizeDeltaY);
|
|
this.m_VerticalScrollbarRect.anchorMin = new Vector2(this.m_VerticalScrollbarRect.anchorMin.x, 0f);
|
|
this.m_VerticalScrollbarRect.anchorMax = new Vector2(this.m_VerticalScrollbarRect.anchorMax.x, 1f);
|
|
this.m_VerticalScrollbarRect.anchoredPosition = new Vector2(this.m_VerticalScrollbarRect.anchoredPosition.x, 0f);
|
|
if (this.hScrollingNeeded)
|
|
{
|
|
this.m_VerticalScrollbarRect.sizeDelta = new Vector2(this.m_VerticalScrollbarRect.sizeDelta.x, -(this.m_HSliderHeight + this.m_HorizontalScrollbarSpacing));
|
|
}
|
|
else
|
|
{
|
|
this.m_VerticalScrollbarRect.sizeDelta = new Vector2(this.m_VerticalScrollbarRect.sizeDelta.x, 0f);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000411 RID: 1041 RVA: 0x000177D8 File Offset: 0x00015BD8
|
|
protected void UpdateBounds()
|
|
{
|
|
this.m_ViewBounds = new Bounds(this.viewRect.rect.center, this.viewRect.rect.size);
|
|
this.m_ContentBounds = this.GetBounds();
|
|
if (!(this.m_Content == null))
|
|
{
|
|
Vector3 size = this.m_ContentBounds.size;
|
|
Vector3 vector = this.m_ContentBounds.center;
|
|
Vector2 pivot = this.m_Content.pivot;
|
|
ScrollRect.AdjustBounds(ref this.m_ViewBounds, ref pivot, ref size, ref vector);
|
|
this.m_ContentBounds.size = size;
|
|
this.m_ContentBounds.center = vector;
|
|
if (this.movementType == ScrollRect.MovementType.Clamped)
|
|
{
|
|
Vector2 zero = Vector2.zero;
|
|
if (this.m_ViewBounds.max.x > this.m_ContentBounds.max.x)
|
|
{
|
|
zero.x = Math.Min(this.m_ViewBounds.min.x - this.m_ContentBounds.min.x, this.m_ViewBounds.max.x - this.m_ContentBounds.max.x);
|
|
}
|
|
else if (this.m_ViewBounds.min.x < this.m_ContentBounds.min.x)
|
|
{
|
|
zero.x = Math.Max(this.m_ViewBounds.min.x - this.m_ContentBounds.min.x, this.m_ViewBounds.max.x - this.m_ContentBounds.max.x);
|
|
}
|
|
if (this.m_ViewBounds.min.y < this.m_ContentBounds.min.y)
|
|
{
|
|
zero.y = Math.Max(this.m_ViewBounds.min.y - this.m_ContentBounds.min.y, this.m_ViewBounds.max.y - this.m_ContentBounds.max.y);
|
|
}
|
|
else if (this.m_ViewBounds.max.y > this.m_ContentBounds.max.y)
|
|
{
|
|
zero.y = Math.Min(this.m_ViewBounds.min.y - this.m_ContentBounds.min.y, this.m_ViewBounds.max.y - this.m_ContentBounds.max.y);
|
|
}
|
|
if (zero.sqrMagnitude > 1E-45f)
|
|
{
|
|
vector = this.m_Content.anchoredPosition + zero;
|
|
if (!this.m_Horizontal)
|
|
{
|
|
vector.x = this.m_Content.anchoredPosition.x;
|
|
}
|
|
if (!this.m_Vertical)
|
|
{
|
|
vector.y = this.m_Content.anchoredPosition.y;
|
|
}
|
|
ScrollRect.AdjustBounds(ref this.m_ViewBounds, ref pivot, ref size, ref vector);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000412 RID: 1042 RVA: 0x00017B6C File Offset: 0x00015F6C
|
|
internal static void AdjustBounds(ref Bounds viewBounds, ref Vector2 contentPivot, ref Vector3 contentSize, ref Vector3 contentPos)
|
|
{
|
|
Vector3 vector = viewBounds.size - contentSize;
|
|
if (vector.x > 0f)
|
|
{
|
|
contentPos.x -= vector.x * (contentPivot.x - 0.5f);
|
|
contentSize.x = viewBounds.size.x;
|
|
}
|
|
if (vector.y > 0f)
|
|
{
|
|
contentPos.y -= vector.y * (contentPivot.y - 0.5f);
|
|
contentSize.y = viewBounds.size.y;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000413 RID: 1043 RVA: 0x00017C1C File Offset: 0x0001601C
|
|
private Bounds GetBounds()
|
|
{
|
|
Bounds bounds;
|
|
if (this.m_Content == null)
|
|
{
|
|
bounds = default(Bounds);
|
|
}
|
|
else
|
|
{
|
|
this.m_Content.GetWorldCorners(this.m_Corners);
|
|
Matrix4x4 worldToLocalMatrix = this.viewRect.worldToLocalMatrix;
|
|
bounds = ScrollRect.InternalGetBounds(this.m_Corners, ref worldToLocalMatrix);
|
|
}
|
|
return bounds;
|
|
}
|
|
|
|
// Token: 0x06000414 RID: 1044 RVA: 0x00017C7C File Offset: 0x0001607C
|
|
internal static Bounds InternalGetBounds(Vector3[] corners, ref Matrix4x4 viewWorldToLocalMatrix)
|
|
{
|
|
Vector3 vector = new Vector3(float.MaxValue, float.MaxValue, float.MaxValue);
|
|
Vector3 vector2 = new Vector3(float.MinValue, float.MinValue, float.MinValue);
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
Vector3 vector3 = viewWorldToLocalMatrix.MultiplyPoint3x4(corners[i]);
|
|
vector = Vector3.Min(vector3, vector);
|
|
vector2 = Vector3.Max(vector3, vector2);
|
|
}
|
|
Bounds bounds = new Bounds(vector, Vector3.zero);
|
|
bounds.Encapsulate(vector2);
|
|
return bounds;
|
|
}
|
|
|
|
// Token: 0x06000415 RID: 1045 RVA: 0x00017D10 File Offset: 0x00016110
|
|
private Vector2 CalculateOffset(Vector2 delta)
|
|
{
|
|
return ScrollRect.InternalCalculateOffset(ref this.m_ViewBounds, ref this.m_ContentBounds, this.m_Horizontal, this.m_Vertical, this.m_MovementType, ref delta);
|
|
}
|
|
|
|
// Token: 0x06000416 RID: 1046 RVA: 0x00017D4C File Offset: 0x0001614C
|
|
internal static Vector2 InternalCalculateOffset(ref Bounds viewBounds, ref Bounds contentBounds, bool horizontal, bool vertical, ScrollRect.MovementType movementType, ref Vector2 delta)
|
|
{
|
|
Vector2 zero = Vector2.zero;
|
|
Vector2 vector;
|
|
if (movementType == ScrollRect.MovementType.Unrestricted)
|
|
{
|
|
vector = zero;
|
|
}
|
|
else
|
|
{
|
|
Vector2 vector2 = contentBounds.min;
|
|
Vector2 vector3 = contentBounds.max;
|
|
if (horizontal)
|
|
{
|
|
vector2.x += delta.x;
|
|
vector3.x += delta.x;
|
|
if (vector2.x > viewBounds.min.x)
|
|
{
|
|
zero.x = viewBounds.min.x - vector2.x;
|
|
}
|
|
else if (vector3.x < viewBounds.max.x)
|
|
{
|
|
zero.x = viewBounds.max.x - vector3.x;
|
|
}
|
|
}
|
|
if (vertical)
|
|
{
|
|
vector2.y += delta.y;
|
|
vector3.y += delta.y;
|
|
if (vector3.y < viewBounds.max.y)
|
|
{
|
|
zero.y = viewBounds.max.y - vector3.y;
|
|
}
|
|
else if (vector2.y > viewBounds.min.y)
|
|
{
|
|
zero.y = viewBounds.min.y - vector2.y;
|
|
}
|
|
}
|
|
vector = zero;
|
|
}
|
|
return vector;
|
|
}
|
|
|
|
// Token: 0x06000417 RID: 1047 RVA: 0x00017EE0 File Offset: 0x000162E0
|
|
protected void SetDirty()
|
|
{
|
|
if (this.IsActive())
|
|
{
|
|
LayoutRebuilder.MarkLayoutForRebuild(this.rectTransform);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000418 RID: 1048 RVA: 0x00017EFE File Offset: 0x000162FE
|
|
protected void SetDirtyCaching()
|
|
{
|
|
if (this.IsActive())
|
|
{
|
|
CanvasUpdateRegistry.RegisterCanvasElementForLayoutRebuild(this);
|
|
LayoutRebuilder.MarkLayoutForRebuild(this.rectTransform);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000419 RID: 1049 RVA: 0x00017F22 File Offset: 0x00016322
|
|
Transform ICanvasElement.get_transform()
|
|
{
|
|
return base.transform;
|
|
}
|
|
|
|
// Token: 0x040001D9 RID: 473
|
|
[SerializeField]
|
|
private RectTransform m_Content;
|
|
|
|
// Token: 0x040001DA RID: 474
|
|
[SerializeField]
|
|
private bool m_Horizontal = true;
|
|
|
|
// Token: 0x040001DB RID: 475
|
|
[SerializeField]
|
|
private bool m_Vertical = true;
|
|
|
|
// Token: 0x040001DC RID: 476
|
|
[SerializeField]
|
|
private ScrollRect.MovementType m_MovementType = ScrollRect.MovementType.Elastic;
|
|
|
|
// Token: 0x040001DD RID: 477
|
|
[SerializeField]
|
|
private float m_Elasticity = 0.1f;
|
|
|
|
// Token: 0x040001DE RID: 478
|
|
[SerializeField]
|
|
private bool m_Inertia = true;
|
|
|
|
// Token: 0x040001DF RID: 479
|
|
[SerializeField]
|
|
private float m_DecelerationRate = 0.135f;
|
|
|
|
// Token: 0x040001E0 RID: 480
|
|
[SerializeField]
|
|
private float m_ScrollSensitivity = 1f;
|
|
|
|
// Token: 0x040001E1 RID: 481
|
|
[SerializeField]
|
|
private RectTransform m_Viewport;
|
|
|
|
// Token: 0x040001E2 RID: 482
|
|
[SerializeField]
|
|
private Scrollbar m_HorizontalScrollbar;
|
|
|
|
// Token: 0x040001E3 RID: 483
|
|
[SerializeField]
|
|
private Scrollbar m_VerticalScrollbar;
|
|
|
|
// Token: 0x040001E4 RID: 484
|
|
[SerializeField]
|
|
private ScrollRect.ScrollbarVisibility m_HorizontalScrollbarVisibility;
|
|
|
|
// Token: 0x040001E5 RID: 485
|
|
[SerializeField]
|
|
private ScrollRect.ScrollbarVisibility m_VerticalScrollbarVisibility;
|
|
|
|
// Token: 0x040001E6 RID: 486
|
|
[SerializeField]
|
|
private float m_HorizontalScrollbarSpacing;
|
|
|
|
// Token: 0x040001E7 RID: 487
|
|
[SerializeField]
|
|
private float m_VerticalScrollbarSpacing;
|
|
|
|
// Token: 0x040001E8 RID: 488
|
|
[SerializeField]
|
|
private ScrollRect.ScrollRectEvent m_OnValueChanged = new ScrollRect.ScrollRectEvent();
|
|
|
|
// Token: 0x040001E9 RID: 489
|
|
private Vector2 m_PointerStartLocalCursor = Vector2.zero;
|
|
|
|
// Token: 0x040001EA RID: 490
|
|
protected Vector2 m_ContentStartPosition = Vector2.zero;
|
|
|
|
// Token: 0x040001EB RID: 491
|
|
private RectTransform m_ViewRect;
|
|
|
|
// Token: 0x040001EC RID: 492
|
|
protected Bounds m_ContentBounds;
|
|
|
|
// Token: 0x040001ED RID: 493
|
|
private Bounds m_ViewBounds;
|
|
|
|
// Token: 0x040001EE RID: 494
|
|
private Vector2 m_Velocity;
|
|
|
|
// Token: 0x040001EF RID: 495
|
|
private bool m_Dragging;
|
|
|
|
// Token: 0x040001F0 RID: 496
|
|
private Vector2 m_PrevPosition = Vector2.zero;
|
|
|
|
// Token: 0x040001F1 RID: 497
|
|
private Bounds m_PrevContentBounds;
|
|
|
|
// Token: 0x040001F2 RID: 498
|
|
private Bounds m_PrevViewBounds;
|
|
|
|
// Token: 0x040001F3 RID: 499
|
|
[NonSerialized]
|
|
private bool m_HasRebuiltLayout = false;
|
|
|
|
// Token: 0x040001F4 RID: 500
|
|
private bool m_HSliderExpand;
|
|
|
|
// Token: 0x040001F5 RID: 501
|
|
private bool m_VSliderExpand;
|
|
|
|
// Token: 0x040001F6 RID: 502
|
|
private float m_HSliderHeight;
|
|
|
|
// Token: 0x040001F7 RID: 503
|
|
private float m_VSliderWidth;
|
|
|
|
// Token: 0x040001F8 RID: 504
|
|
[NonSerialized]
|
|
private RectTransform m_Rect;
|
|
|
|
// Token: 0x040001F9 RID: 505
|
|
private RectTransform m_HorizontalScrollbarRect;
|
|
|
|
// Token: 0x040001FA RID: 506
|
|
private RectTransform m_VerticalScrollbarRect;
|
|
|
|
// Token: 0x040001FB RID: 507
|
|
private DrivenRectTransformTracker m_Tracker;
|
|
|
|
// Token: 0x040001FC RID: 508
|
|
private readonly Vector3[] m_Corners = new Vector3[4];
|
|
|
|
// Token: 0x0200006F RID: 111
|
|
public enum MovementType
|
|
{
|
|
// Token: 0x040001FE RID: 510
|
|
Unrestricted,
|
|
// Token: 0x040001FF RID: 511
|
|
Elastic,
|
|
// Token: 0x04000200 RID: 512
|
|
Clamped
|
|
}
|
|
|
|
// Token: 0x02000070 RID: 112
|
|
public enum ScrollbarVisibility
|
|
{
|
|
// Token: 0x04000202 RID: 514
|
|
Permanent,
|
|
// Token: 0x04000203 RID: 515
|
|
AutoHide,
|
|
// Token: 0x04000204 RID: 516
|
|
AutoHideAndExpandViewport
|
|
}
|
|
|
|
// Token: 0x02000071 RID: 113
|
|
[Serializable]
|
|
public class ScrollRectEvent : UnityEvent<Vector2>
|
|
{
|
|
}
|
|
}
|
|
}
|