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>
		{
		}
	}
}