using System;
using System.Collections.Generic;
using UnityEngine.Events;

namespace UnityEngine.UI
{
	// Token: 0x0200009C RID: 156
	public class LayoutRebuilder : ICanvasElement
	{
		// Token: 0x060005A0 RID: 1440 RVA: 0x0001CC61 File Offset: 0x0001B061
		static LayoutRebuilder()
		{
			RectTransform.reapplyDrivenProperties += LayoutRebuilder.ReapplyDrivenProperties;
		}

		// Token: 0x060005A2 RID: 1442 RVA: 0x0001CCA5 File Offset: 0x0001B0A5
		private void Initialize(RectTransform controller)
		{
			this.m_ToRebuild = controller;
			this.m_CachedHashFromTransform = controller.GetHashCode();
		}

		// Token: 0x060005A3 RID: 1443 RVA: 0x0001CCBB File Offset: 0x0001B0BB
		private void Clear()
		{
			this.m_ToRebuild = null;
			this.m_CachedHashFromTransform = 0;
		}

		// Token: 0x060005A4 RID: 1444 RVA: 0x0001CCCC File Offset: 0x0001B0CC
		private static void ReapplyDrivenProperties(RectTransform driven)
		{
			LayoutRebuilder.MarkLayoutForRebuild(driven);
		}

		// Token: 0x17000191 RID: 401
		// (get) Token: 0x060005A5 RID: 1445 RVA: 0x0001CCD8 File Offset: 0x0001B0D8
		public Transform transform
		{
			get
			{
				return this.m_ToRebuild;
			}
		}

		// Token: 0x060005A6 RID: 1446 RVA: 0x0001CCF4 File Offset: 0x0001B0F4
		public bool IsDestroyed()
		{
			return this.m_ToRebuild == null;
		}

		// Token: 0x060005A7 RID: 1447 RVA: 0x0001CD15 File Offset: 0x0001B115
		private static void StripDisabledBehavioursFromList(List<Component> components)
		{
			components.RemoveAll((Component e) => e is Behaviour && !((Behaviour)e).isActiveAndEnabled);
		}

		// Token: 0x060005A8 RID: 1448 RVA: 0x0001CD3C File Offset: 0x0001B13C
		public static void ForceRebuildLayoutImmediate(RectTransform layoutRoot)
		{
			LayoutRebuilder layoutRebuilder = LayoutRebuilder.s_Rebuilders.Get();
			layoutRebuilder.Initialize(layoutRoot);
			layoutRebuilder.Rebuild(CanvasUpdate.Layout);
			LayoutRebuilder.s_Rebuilders.Release(layoutRebuilder);
		}

		// Token: 0x060005A9 RID: 1449 RVA: 0x0001CD70 File Offset: 0x0001B170
		public void Rebuild(CanvasUpdate executing)
		{
			if (executing == CanvasUpdate.Layout)
			{
				this.PerformLayoutCalculation(this.m_ToRebuild, delegate(Component e)
				{
					(e as ILayoutElement).CalculateLayoutInputHorizontal();
				});
				this.PerformLayoutControl(this.m_ToRebuild, delegate(Component e)
				{
					(e as ILayoutController).SetLayoutHorizontal();
				});
				this.PerformLayoutCalculation(this.m_ToRebuild, delegate(Component e)
				{
					(e as ILayoutElement).CalculateLayoutInputVertical();
				});
				this.PerformLayoutControl(this.m_ToRebuild, delegate(Component e)
				{
					(e as ILayoutController).SetLayoutVertical();
				});
			}
		}

		// Token: 0x060005AA RID: 1450 RVA: 0x0001CE34 File Offset: 0x0001B234
		private void PerformLayoutControl(RectTransform rect, UnityAction<Component> action)
		{
			if (!(rect == null))
			{
				List<Component> list = ListPool<Component>.Get();
				rect.GetComponents(typeof(ILayoutController), list);
				LayoutRebuilder.StripDisabledBehavioursFromList(list);
				if (list.Count > 0)
				{
					for (int i = 0; i < list.Count; i++)
					{
						if (list[i] is ILayoutSelfController)
						{
							action(list[i]);
						}
					}
					for (int j = 0; j < list.Count; j++)
					{
						if (!(list[j] is ILayoutSelfController))
						{
							action(list[j]);
						}
					}
					for (int k = 0; k < rect.childCount; k++)
					{
						this.PerformLayoutControl(rect.GetChild(k) as RectTransform, action);
					}
				}
				ListPool<Component>.Release(list);
			}
		}

		// Token: 0x060005AB RID: 1451 RVA: 0x0001CF18 File Offset: 0x0001B318
		private void PerformLayoutCalculation(RectTransform rect, UnityAction<Component> action)
		{
			if (!(rect == null))
			{
				List<Component> list = ListPool<Component>.Get();
				rect.GetComponents(typeof(ILayoutElement), list);
				LayoutRebuilder.StripDisabledBehavioursFromList(list);
				if (list.Count > 0 || rect.GetComponent(typeof(ILayoutGroup)))
				{
					for (int i = 0; i < rect.childCount; i++)
					{
						this.PerformLayoutCalculation(rect.GetChild(i) as RectTransform, action);
					}
					for (int j = 0; j < list.Count; j++)
					{
						action(list[j]);
					}
				}
				ListPool<Component>.Release(list);
			}
		}

		// Token: 0x060005AC RID: 1452 RVA: 0x0001CFD0 File Offset: 0x0001B3D0
		public static void MarkLayoutForRebuild(RectTransform rect)
		{
			if (!(rect == null))
			{
				List<Component> list = ListPool<Component>.Get();
				RectTransform rectTransform = rect;
				for (;;)
				{
					RectTransform rectTransform2 = rectTransform.parent as RectTransform;
					if (!LayoutRebuilder.ValidLayoutGroup(rectTransform2, list))
					{
						break;
					}
					rectTransform = rectTransform2;
				}
				if (rectTransform == rect && !LayoutRebuilder.ValidController(rectTransform, list))
				{
					ListPool<Component>.Release(list);
				}
				else
				{
					LayoutRebuilder.MarkLayoutRootForRebuild(rectTransform);
					ListPool<Component>.Release(list);
				}
			}
		}

		// Token: 0x060005AD RID: 1453 RVA: 0x0001D050 File Offset: 0x0001B450
		private static bool ValidLayoutGroup(RectTransform parent, List<Component> comps)
		{
			bool flag;
			if (parent == null)
			{
				flag = false;
			}
			else
			{
				parent.GetComponents(typeof(ILayoutGroup), comps);
				LayoutRebuilder.StripDisabledBehavioursFromList(comps);
				bool flag2 = comps.Count > 0;
				flag = flag2;
			}
			return flag;
		}

		// Token: 0x060005AE RID: 1454 RVA: 0x0001D09C File Offset: 0x0001B49C
		private static bool ValidController(RectTransform layoutRoot, List<Component> comps)
		{
			bool flag;
			if (layoutRoot == null)
			{
				flag = false;
			}
			else
			{
				layoutRoot.GetComponents(typeof(ILayoutController), comps);
				LayoutRebuilder.StripDisabledBehavioursFromList(comps);
				bool flag2 = comps.Count > 0;
				flag = flag2;
			}
			return flag;
		}

		// Token: 0x060005AF RID: 1455 RVA: 0x0001D0E8 File Offset: 0x0001B4E8
		private static void MarkLayoutRootForRebuild(RectTransform controller)
		{
			if (!(controller == null))
			{
				LayoutRebuilder layoutRebuilder = LayoutRebuilder.s_Rebuilders.Get();
				layoutRebuilder.Initialize(controller);
				if (!CanvasUpdateRegistry.TryRegisterCanvasElementForLayoutRebuild(layoutRebuilder))
				{
					LayoutRebuilder.s_Rebuilders.Release(layoutRebuilder);
				}
			}
		}

		// Token: 0x060005B0 RID: 1456 RVA: 0x0001D12F File Offset: 0x0001B52F
		public void LayoutComplete()
		{
			LayoutRebuilder.s_Rebuilders.Release(this);
		}

		// Token: 0x060005B1 RID: 1457 RVA: 0x0001D13D File Offset: 0x0001B53D
		public void GraphicUpdateComplete()
		{
		}

		// Token: 0x060005B2 RID: 1458 RVA: 0x0001D140 File Offset: 0x0001B540
		public override int GetHashCode()
		{
			return this.m_CachedHashFromTransform;
		}

		// Token: 0x060005B3 RID: 1459 RVA: 0x0001D15C File Offset: 0x0001B55C
		public override bool Equals(object obj)
		{
			return obj.GetHashCode() == this.GetHashCode();
		}

		// Token: 0x060005B4 RID: 1460 RVA: 0x0001D180 File Offset: 0x0001B580
		public override string ToString()
		{
			return "(Layout Rebuilder for) " + this.m_ToRebuild;
		}

		// Token: 0x040002AE RID: 686
		private RectTransform m_ToRebuild;

		// Token: 0x040002AF RID: 687
		private int m_CachedHashFromTransform;

		// Token: 0x040002B0 RID: 688
		private static ObjectPool<LayoutRebuilder> s_Rebuilders = new ObjectPool<LayoutRebuilder>(null, delegate(LayoutRebuilder x)
		{
			x.Clear();
		});
	}
}