using System;

namespace UnityEngine.UI
{
	// Token: 0x02000094 RID: 148
	public abstract class HorizontalOrVerticalLayoutGroup : LayoutGroup
	{
		// Token: 0x17000170 RID: 368
		// (get) Token: 0x0600054B RID: 1355 RVA: 0x0001C41C File Offset: 0x0001A81C
		// (set) Token: 0x0600054C RID: 1356 RVA: 0x0001C437 File Offset: 0x0001A837
		public float spacing
		{
			get
			{
				return this.m_Spacing;
			}
			set
			{
				base.SetProperty<float>(ref this.m_Spacing, value);
			}
		}

		// Token: 0x17000171 RID: 369
		// (get) Token: 0x0600054D RID: 1357 RVA: 0x0001C448 File Offset: 0x0001A848
		// (set) Token: 0x0600054E RID: 1358 RVA: 0x0001C463 File Offset: 0x0001A863
		public bool childForceExpandWidth
		{
			get
			{
				return this.m_ChildForceExpandWidth;
			}
			set
			{
				base.SetProperty<bool>(ref this.m_ChildForceExpandWidth, value);
			}
		}

		// Token: 0x17000172 RID: 370
		// (get) Token: 0x0600054F RID: 1359 RVA: 0x0001C474 File Offset: 0x0001A874
		// (set) Token: 0x06000550 RID: 1360 RVA: 0x0001C48F File Offset: 0x0001A88F
		public bool childForceExpandHeight
		{
			get
			{
				return this.m_ChildForceExpandHeight;
			}
			set
			{
				base.SetProperty<bool>(ref this.m_ChildForceExpandHeight, value);
			}
		}

		// Token: 0x17000173 RID: 371
		// (get) Token: 0x06000551 RID: 1361 RVA: 0x0001C4A0 File Offset: 0x0001A8A0
		// (set) Token: 0x06000552 RID: 1362 RVA: 0x0001C4BB File Offset: 0x0001A8BB
		public bool childControlWidth
		{
			get
			{
				return this.m_ChildControlWidth;
			}
			set
			{
				base.SetProperty<bool>(ref this.m_ChildControlWidth, value);
			}
		}

		// Token: 0x17000174 RID: 372
		// (get) Token: 0x06000553 RID: 1363 RVA: 0x0001C4CC File Offset: 0x0001A8CC
		// (set) Token: 0x06000554 RID: 1364 RVA: 0x0001C4E7 File Offset: 0x0001A8E7
		public bool childControlHeight
		{
			get
			{
				return this.m_ChildControlHeight;
			}
			set
			{
				base.SetProperty<bool>(ref this.m_ChildControlHeight, value);
			}
		}

		// Token: 0x06000555 RID: 1365 RVA: 0x0001C4F8 File Offset: 0x0001A8F8
		protected void CalcAlongAxis(int axis, bool isVertical)
		{
			float num = (float)((axis != 0) ? base.padding.vertical : base.padding.horizontal);
			bool flag = ((axis != 0) ? this.m_ChildControlHeight : this.m_ChildControlWidth);
			bool flag2 = ((axis != 0) ? this.childForceExpandHeight : this.childForceExpandWidth);
			float num2 = num;
			float num3 = num;
			float num4 = 0f;
			bool flag3 = isVertical ^ (axis == 1);
			for (int i = 0; i < base.rectChildren.Count; i++)
			{
				RectTransform rectTransform = base.rectChildren[i];
				float num5;
				float num6;
				float num7;
				this.GetChildSizes(rectTransform, axis, flag, flag2, out num5, out num6, out num7);
				if (flag3)
				{
					num2 = Mathf.Max(num5 + num, num2);
					num3 = Mathf.Max(num6 + num, num3);
					num4 = Mathf.Max(num7, num4);
				}
				else
				{
					num2 += num5 + this.spacing;
					num3 += num6 + this.spacing;
					num4 += num7;
				}
			}
			if (!flag3 && base.rectChildren.Count > 0)
			{
				num2 -= this.spacing;
				num3 -= this.spacing;
			}
			num3 = Mathf.Max(num2, num3);
			base.SetLayoutInputForAxis(num2, num3, num4, axis);
		}

		// Token: 0x06000556 RID: 1366 RVA: 0x0001C648 File Offset: 0x0001AA48
		protected void SetChildrenAlongAxis(int axis, bool isVertical)
		{
			float num = base.rectTransform.rect.size[axis];
			bool flag = ((axis != 0) ? this.m_ChildControlHeight : this.m_ChildControlWidth);
			bool flag2 = ((axis != 0) ? this.childForceExpandHeight : this.childForceExpandWidth);
			float alignmentOnAxis = base.GetAlignmentOnAxis(axis);
			bool flag3 = isVertical ^ (axis == 1);
			if (flag3)
			{
				float num2 = num - (float)((axis != 0) ? base.padding.vertical : base.padding.horizontal);
				for (int i = 0; i < base.rectChildren.Count; i++)
				{
					RectTransform rectTransform = base.rectChildren[i];
					float num3;
					float num4;
					float num5;
					this.GetChildSizes(rectTransform, axis, flag, flag2, out num3, out num4, out num5);
					float num6 = Mathf.Clamp(num2, num3, (num5 <= 0f) ? num4 : num);
					float startOffset = base.GetStartOffset(axis, num6);
					if (flag)
					{
						base.SetChildAlongAxis(rectTransform, axis, startOffset, num6);
					}
					else
					{
						float num7 = (num6 - rectTransform.sizeDelta[axis]) * alignmentOnAxis;
						base.SetChildAlongAxis(rectTransform, axis, startOffset + num7);
					}
				}
			}
			else
			{
				float num8 = (float)((axis != 0) ? base.padding.top : base.padding.left);
				if (base.GetTotalFlexibleSize(axis) == 0f && base.GetTotalPreferredSize(axis) < num)
				{
					num8 = base.GetStartOffset(axis, base.GetTotalPreferredSize(axis) - (float)((axis != 0) ? base.padding.vertical : base.padding.horizontal));
				}
				float num9 = 0f;
				if (base.GetTotalMinSize(axis) != base.GetTotalPreferredSize(axis))
				{
					num9 = Mathf.Clamp01((num - base.GetTotalMinSize(axis)) / (base.GetTotalPreferredSize(axis) - base.GetTotalMinSize(axis)));
				}
				float num10 = 0f;
				if (num > base.GetTotalPreferredSize(axis))
				{
					if (base.GetTotalFlexibleSize(axis) > 0f)
					{
						num10 = (num - base.GetTotalPreferredSize(axis)) / base.GetTotalFlexibleSize(axis);
					}
				}
				for (int j = 0; j < base.rectChildren.Count; j++)
				{
					RectTransform rectTransform2 = base.rectChildren[j];
					float num11;
					float num12;
					float num13;
					this.GetChildSizes(rectTransform2, axis, flag, flag2, out num11, out num12, out num13);
					float num14 = Mathf.Lerp(num11, num12, num9);
					num14 += num13 * num10;
					if (flag)
					{
						base.SetChildAlongAxis(rectTransform2, axis, num8, num14);
					}
					else
					{
						float num15 = (num14 - rectTransform2.sizeDelta[axis]) * alignmentOnAxis;
						base.SetChildAlongAxis(rectTransform2, axis, num8 + num15);
					}
					num8 += num14 + this.spacing;
				}
			}
		}

		// Token: 0x06000557 RID: 1367 RVA: 0x0001C930 File Offset: 0x0001AD30
		private void GetChildSizes(RectTransform child, int axis, bool controlSize, bool childForceExpand, out float min, out float preferred, out float flexible)
		{
			if (!controlSize)
			{
				min = child.sizeDelta[axis];
				preferred = min;
				flexible = 0f;
			}
			else
			{
				min = LayoutUtility.GetMinSize(child, axis);
				preferred = LayoutUtility.GetPreferredSize(child, axis);
				flexible = LayoutUtility.GetFlexibleSize(child, axis);
			}
			if (childForceExpand)
			{
				flexible = Mathf.Max(flexible, 1f);
			}
		}

		// Token: 0x04000299 RID: 665
		[SerializeField]
		protected float m_Spacing = 0f;

		// Token: 0x0400029A RID: 666
		[SerializeField]
		protected bool m_ChildForceExpandWidth = true;

		// Token: 0x0400029B RID: 667
		[SerializeField]
		protected bool m_ChildForceExpandHeight = true;

		// Token: 0x0400029C RID: 668
		[SerializeField]
		protected bool m_ChildControlWidth = true;

		// Token: 0x0400029D RID: 669
		[SerializeField]
		protected bool m_ChildControlHeight = true;
	}
}