using System;
using System.Collections.Generic;
using UnityEngine.EventSystems;
using UnityEngine.Serialization;

namespace UnityEngine.UI
{
	// Token: 0x02000072 RID: 114
	[AddComponentMenu("UI/Selectable", 70)]
	[ExecuteInEditMode]
	[SelectionBase]
	[DisallowMultipleComponent]
	public class Selectable : UIBehaviour, IMoveHandler, IPointerDownHandler, IPointerUpHandler, IPointerEnterHandler, IPointerExitHandler, ISelectHandler, IDeselectHandler, IEventSystemHandler
	{
		// Token: 0x0600041B RID: 1051 RVA: 0x00006C9C File Offset: 0x0000509C
		protected Selectable()
		{
		}

		// Token: 0x1700011F RID: 287
		// (get) Token: 0x0600041C RID: 1052 RVA: 0x00006CF4 File Offset: 0x000050F4
		public static List<Selectable> allSelectables
		{
			get
			{
				return Selectable.s_List;
			}
		}

		// Token: 0x17000120 RID: 288
		// (get) Token: 0x0600041D RID: 1053 RVA: 0x00006D10 File Offset: 0x00005110
		// (set) Token: 0x0600041E RID: 1054 RVA: 0x00006D2B File Offset: 0x0000512B
		public Navigation navigation
		{
			get
			{
				return this.m_Navigation;
			}
			set
			{
				if (SetPropertyUtility.SetStruct<Navigation>(ref this.m_Navigation, value))
				{
					this.OnSetProperty();
				}
			}
		}

		// Token: 0x17000121 RID: 289
		// (get) Token: 0x0600041F RID: 1055 RVA: 0x00006D48 File Offset: 0x00005148
		// (set) Token: 0x06000420 RID: 1056 RVA: 0x00006D63 File Offset: 0x00005163
		public Selectable.Transition transition
		{
			get
			{
				return this.m_Transition;
			}
			set
			{
				if (SetPropertyUtility.SetStruct<Selectable.Transition>(ref this.m_Transition, value))
				{
					this.OnSetProperty();
				}
			}
		}

		// Token: 0x17000122 RID: 290
		// (get) Token: 0x06000421 RID: 1057 RVA: 0x00006D80 File Offset: 0x00005180
		// (set) Token: 0x06000422 RID: 1058 RVA: 0x00006D9B File Offset: 0x0000519B
		public ColorBlock colors
		{
			get
			{
				return this.m_Colors;
			}
			set
			{
				if (SetPropertyUtility.SetStruct<ColorBlock>(ref this.m_Colors, value))
				{
					this.OnSetProperty();
				}
			}
		}

		// Token: 0x17000123 RID: 291
		// (get) Token: 0x06000423 RID: 1059 RVA: 0x00006DB8 File Offset: 0x000051B8
		// (set) Token: 0x06000424 RID: 1060 RVA: 0x00006DD3 File Offset: 0x000051D3
		public SpriteState spriteState
		{
			get
			{
				return this.m_SpriteState;
			}
			set
			{
				if (SetPropertyUtility.SetStruct<SpriteState>(ref this.m_SpriteState, value))
				{
					this.OnSetProperty();
				}
			}
		}

		// Token: 0x17000124 RID: 292
		// (get) Token: 0x06000425 RID: 1061 RVA: 0x00006DF0 File Offset: 0x000051F0
		// (set) Token: 0x06000426 RID: 1062 RVA: 0x00006E0B File Offset: 0x0000520B
		public AnimationTriggers animationTriggers
		{
			get
			{
				return this.m_AnimationTriggers;
			}
			set
			{
				if (SetPropertyUtility.SetClass<AnimationTriggers>(ref this.m_AnimationTriggers, value))
				{
					this.OnSetProperty();
				}
			}
		}

		// Token: 0x17000125 RID: 293
		// (get) Token: 0x06000427 RID: 1063 RVA: 0x00006E28 File Offset: 0x00005228
		// (set) Token: 0x06000428 RID: 1064 RVA: 0x00006E43 File Offset: 0x00005243
		public Graphic targetGraphic
		{
			get
			{
				return this.m_TargetGraphic;
			}
			set
			{
				if (SetPropertyUtility.SetClass<Graphic>(ref this.m_TargetGraphic, value))
				{
					this.OnSetProperty();
				}
			}
		}

		// Token: 0x17000126 RID: 294
		// (get) Token: 0x06000429 RID: 1065 RVA: 0x00006E60 File Offset: 0x00005260
		// (set) Token: 0x0600042A RID: 1066 RVA: 0x00006E7C File Offset: 0x0000527C
		public bool interactable
		{
			get
			{
				return this.m_Interactable;
			}
			set
			{
				if (SetPropertyUtility.SetStruct<bool>(ref this.m_Interactable, value))
				{
					if (!this.m_Interactable && EventSystem.current != null && EventSystem.current.currentSelectedGameObject == base.gameObject)
					{
						EventSystem.current.SetSelectedGameObject(null);
					}
					if (this.m_Interactable)
					{
						this.UpdateSelectionState(null);
					}
					this.OnSetProperty();
				}
			}
		}

		// Token: 0x17000127 RID: 295
		// (get) Token: 0x0600042B RID: 1067 RVA: 0x00006EF8 File Offset: 0x000052F8
		// (set) Token: 0x0600042C RID: 1068 RVA: 0x00006F12 File Offset: 0x00005312
		private bool isPointerInside { get; set; }

		// Token: 0x17000128 RID: 296
		// (get) Token: 0x0600042D RID: 1069 RVA: 0x00006F1C File Offset: 0x0000531C
		// (set) Token: 0x0600042E RID: 1070 RVA: 0x00006F36 File Offset: 0x00005336
		private bool isPointerDown { get; set; }

		// Token: 0x17000129 RID: 297
		// (get) Token: 0x0600042F RID: 1071 RVA: 0x00006F40 File Offset: 0x00005340
		// (set) Token: 0x06000430 RID: 1072 RVA: 0x00006F5A File Offset: 0x0000535A
		private bool hasSelection { get; set; }

		// Token: 0x1700012A RID: 298
		// (get) Token: 0x06000431 RID: 1073 RVA: 0x00006F64 File Offset: 0x00005364
		// (set) Token: 0x06000432 RID: 1074 RVA: 0x00006F84 File Offset: 0x00005384
		public Image image
		{
			get
			{
				return this.m_TargetGraphic as Image;
			}
			set
			{
				this.m_TargetGraphic = value;
			}
		}

		// Token: 0x1700012B RID: 299
		// (get) Token: 0x06000433 RID: 1075 RVA: 0x00006F90 File Offset: 0x00005390
		public Animator animator
		{
			get
			{
				return base.GetComponent<Animator>();
			}
		}

		// Token: 0x06000434 RID: 1076 RVA: 0x00006FAB File Offset: 0x000053AB
		protected override void Awake()
		{
			if (this.m_TargetGraphic == null)
			{
				this.m_TargetGraphic = base.GetComponent<Graphic>();
			}
		}

		// Token: 0x06000435 RID: 1077 RVA: 0x00006FCC File Offset: 0x000053CC
		protected override void OnCanvasGroupChanged()
		{
			bool flag = true;
			Transform transform = base.transform;
			while (transform != null)
			{
				transform.GetComponents<CanvasGroup>(this.m_CanvasGroupCache);
				bool flag2 = false;
				for (int i = 0; i < this.m_CanvasGroupCache.Count; i++)
				{
					if (!this.m_CanvasGroupCache[i].interactable)
					{
						flag = false;
						flag2 = true;
					}
					if (this.m_CanvasGroupCache[i].ignoreParentGroups)
					{
						flag2 = true;
					}
				}
				if (flag2)
				{
					break;
				}
				transform = transform.parent;
			}
			if (flag != this.m_GroupsAllowInteraction)
			{
				this.m_GroupsAllowInteraction = flag;
				this.OnSetProperty();
			}
		}

		// Token: 0x06000436 RID: 1078 RVA: 0x00007084 File Offset: 0x00005484
		public virtual bool IsInteractable()
		{
			return this.m_GroupsAllowInteraction && this.m_Interactable;
		}

		// Token: 0x06000437 RID: 1079 RVA: 0x000070AD File Offset: 0x000054AD
		protected override void OnDidApplyAnimationProperties()
		{
			this.OnSetProperty();
		}

		// Token: 0x06000438 RID: 1080 RVA: 0x000070B8 File Offset: 0x000054B8
		protected override void OnEnable()
		{
			base.OnEnable();
			Selectable.s_List.Add(this);
			Selectable.SelectionState selectionState = Selectable.SelectionState.Normal;
			if (this.hasSelection)
			{
				selectionState = Selectable.SelectionState.Highlighted;
			}
			this.m_CurrentSelectionState = selectionState;
			this.InternalEvaluateAndTransitionToSelectionState(true);
		}

		// Token: 0x06000439 RID: 1081 RVA: 0x000070F4 File Offset: 0x000054F4
		private void OnSetProperty()
		{
			this.InternalEvaluateAndTransitionToSelectionState(false);
		}

		// Token: 0x0600043A RID: 1082 RVA: 0x000070FE File Offset: 0x000054FE
		protected override void OnDisable()
		{
			Selectable.s_List.Remove(this);
			this.InstantClearState();
			base.OnDisable();
		}

		// Token: 0x1700012C RID: 300
		// (get) Token: 0x0600043B RID: 1083 RVA: 0x0000711C File Offset: 0x0000551C
		protected Selectable.SelectionState currentSelectionState
		{
			get
			{
				return this.m_CurrentSelectionState;
			}
		}

		// Token: 0x0600043C RID: 1084 RVA: 0x00007138 File Offset: 0x00005538
		protected virtual void InstantClearState()
		{
			string normalTrigger = this.m_AnimationTriggers.normalTrigger;
			this.isPointerInside = false;
			this.isPointerDown = false;
			this.hasSelection = false;
			Selectable.Transition transition = this.m_Transition;
			if (transition != Selectable.Transition.ColorTint)
			{
				if (transition != Selectable.Transition.SpriteSwap)
				{
					if (transition == Selectable.Transition.Animation)
					{
						this.TriggerAnimation(normalTrigger);
					}
				}
				else
				{
					this.DoSpriteSwap(null);
				}
			}
			else
			{
				this.StartColorTween(Color.white, true);
			}
		}

		// Token: 0x0600043D RID: 1085 RVA: 0x000071B4 File Offset: 0x000055B4
		protected virtual void DoStateTransition(Selectable.SelectionState state, bool instant)
		{
			Color color;
			Sprite sprite;
			string text;
			switch (state)
			{
			case Selectable.SelectionState.Normal:
				color = this.m_Colors.normalColor;
				sprite = null;
				text = this.m_AnimationTriggers.normalTrigger;
				break;
			case Selectable.SelectionState.Highlighted:
				color = this.m_Colors.highlightedColor;
				sprite = this.m_SpriteState.highlightedSprite;
				text = this.m_AnimationTriggers.highlightedTrigger;
				break;
			case Selectable.SelectionState.Pressed:
				color = this.m_Colors.pressedColor;
				sprite = this.m_SpriteState.pressedSprite;
				text = this.m_AnimationTriggers.pressedTrigger;
				break;
			case Selectable.SelectionState.Disabled:
				color = this.m_Colors.disabledColor;
				sprite = this.m_SpriteState.disabledSprite;
				text = this.m_AnimationTriggers.disabledTrigger;
				break;
			default:
				color = Color.black;
				sprite = null;
				text = string.Empty;
				break;
			}
			if (base.gameObject.activeInHierarchy)
			{
				Selectable.Transition transition = this.m_Transition;
				if (transition != Selectable.Transition.ColorTint)
				{
					if (transition != Selectable.Transition.SpriteSwap)
					{
						if (transition == Selectable.Transition.Animation)
						{
							this.TriggerAnimation(text);
						}
					}
					else
					{
						this.DoSpriteSwap(sprite);
					}
				}
				else
				{
					this.StartColorTween(color * this.m_Colors.colorMultiplier, instant);
				}
			}
		}

		// Token: 0x0600043E RID: 1086 RVA: 0x000072F4 File Offset: 0x000056F4
		public Selectable FindSelectable(Vector3 dir)
		{
			dir = dir.normalized;
			Vector3 vector = Quaternion.Inverse(base.transform.rotation) * dir;
			Vector3 vector2 = base.transform.TransformPoint(Selectable.GetPointOnRectEdge(base.transform as RectTransform, vector));
			float num = float.NegativeInfinity;
			Selectable selectable = null;
			for (int i = 0; i < Selectable.s_List.Count; i++)
			{
				Selectable selectable2 = Selectable.s_List[i];
				if (!(selectable2 == this) && !(selectable2 == null))
				{
					if (selectable2.IsInteractable() && selectable2.navigation.mode != Navigation.Mode.None)
					{
						RectTransform rectTransform = selectable2.transform as RectTransform;
						Vector3 vector3 = ((!(rectTransform != null)) ? Vector3.zero : rectTransform.rect.center);
						Vector3 vector4 = selectable2.transform.TransformPoint(vector3) - vector2;
						float num2 = Vector3.Dot(dir, vector4);
						if (num2 > 0f)
						{
							float num3 = num2 / vector4.sqrMagnitude;
							if (num3 > num)
							{
								num = num3;
								selectable = selectable2;
							}
						}
					}
				}
			}
			return selectable;
		}

		// Token: 0x0600043F RID: 1087 RVA: 0x00007454 File Offset: 0x00005854
		private static Vector3 GetPointOnRectEdge(RectTransform rect, Vector2 dir)
		{
			Vector3 vector;
			if (rect == null)
			{
				vector = Vector3.zero;
			}
			else
			{
				if (dir != Vector2.zero)
				{
					dir /= Mathf.Max(Mathf.Abs(dir.x), Mathf.Abs(dir.y));
				}
				dir = rect.rect.center + Vector2.Scale(rect.rect.size, dir * 0.5f);
				vector = dir;
			}
			return vector;
		}

		// Token: 0x06000440 RID: 1088 RVA: 0x000074EE File Offset: 0x000058EE
		private void Navigate(AxisEventData eventData, Selectable sel)
		{
			if (sel != null && sel.IsActive())
			{
				eventData.selectedObject = sel.gameObject;
			}
		}

		// Token: 0x06000441 RID: 1089 RVA: 0x00007514 File Offset: 0x00005914
		public virtual Selectable FindSelectableOnLeft()
		{
			Selectable selectable;
			if (this.m_Navigation.mode == Navigation.Mode.Explicit)
			{
				selectable = this.m_Navigation.selectOnLeft;
			}
			else if ((this.m_Navigation.mode & Navigation.Mode.Horizontal) != Navigation.Mode.None)
			{
				selectable = this.FindSelectable(base.transform.rotation * Vector3.left);
			}
			else
			{
				selectable = null;
			}
			return selectable;
		}

		// Token: 0x06000442 RID: 1090 RVA: 0x00007584 File Offset: 0x00005984
		public virtual Selectable FindSelectableOnRight()
		{
			Selectable selectable;
			if (this.m_Navigation.mode == Navigation.Mode.Explicit)
			{
				selectable = this.m_Navigation.selectOnRight;
			}
			else if ((this.m_Navigation.mode & Navigation.Mode.Horizontal) != Navigation.Mode.None)
			{
				selectable = this.FindSelectable(base.transform.rotation * Vector3.right);
			}
			else
			{
				selectable = null;
			}
			return selectable;
		}

		// Token: 0x06000443 RID: 1091 RVA: 0x000075F4 File Offset: 0x000059F4
		public virtual Selectable FindSelectableOnUp()
		{
			Selectable selectable;
			if (this.m_Navigation.mode == Navigation.Mode.Explicit)
			{
				selectable = this.m_Navigation.selectOnUp;
			}
			else if ((this.m_Navigation.mode & Navigation.Mode.Vertical) != Navigation.Mode.None)
			{
				selectable = this.FindSelectable(base.transform.rotation * Vector3.up);
			}
			else
			{
				selectable = null;
			}
			return selectable;
		}

		// Token: 0x06000444 RID: 1092 RVA: 0x00007664 File Offset: 0x00005A64
		public virtual Selectable FindSelectableOnDown()
		{
			Selectable selectable;
			if (this.m_Navigation.mode == Navigation.Mode.Explicit)
			{
				selectable = this.m_Navigation.selectOnDown;
			}
			else if ((this.m_Navigation.mode & Navigation.Mode.Vertical) != Navigation.Mode.None)
			{
				selectable = this.FindSelectable(base.transform.rotation * Vector3.down);
			}
			else
			{
				selectable = null;
			}
			return selectable;
		}

		// Token: 0x06000445 RID: 1093 RVA: 0x000076D4 File Offset: 0x00005AD4
		public virtual void OnMove(AxisEventData eventData)
		{
			switch (eventData.moveDir)
			{
			case MoveDirection.Left:
				this.Navigate(eventData, this.FindSelectableOnLeft());
				break;
			case MoveDirection.Up:
				this.Navigate(eventData, this.FindSelectableOnUp());
				break;
			case MoveDirection.Right:
				this.Navigate(eventData, this.FindSelectableOnRight());
				break;
			case MoveDirection.Down:
				this.Navigate(eventData, this.FindSelectableOnDown());
				break;
			}
		}

		// Token: 0x06000446 RID: 1094 RVA: 0x0000774C File Offset: 0x00005B4C
		private void StartColorTween(Color targetColor, bool instant)
		{
			if (!(this.m_TargetGraphic == null))
			{
				this.m_TargetGraphic.CrossFadeColor(targetColor, (!instant) ? this.m_Colors.fadeDuration : 0f, true, true);
			}
		}

		// Token: 0x06000447 RID: 1095 RVA: 0x00007799 File Offset: 0x00005B99
		private void DoSpriteSwap(Sprite newSprite)
		{
			if (!(this.image == null))
			{
				this.image.overrideSprite = newSprite;
			}
		}

		// Token: 0x06000448 RID: 1096 RVA: 0x000077C0 File Offset: 0x00005BC0
		private void TriggerAnimation(string triggername)
		{
			if (this.transition == Selectable.Transition.Animation && !(this.animator == null) && this.animator.isActiveAndEnabled && this.animator.hasBoundPlayables && !string.IsNullOrEmpty(triggername))
			{
				this.animator.ResetTrigger(this.m_AnimationTriggers.normalTrigger);
				this.animator.ResetTrigger(this.m_AnimationTriggers.pressedTrigger);
				this.animator.ResetTrigger(this.m_AnimationTriggers.highlightedTrigger);
				this.animator.ResetTrigger(this.m_AnimationTriggers.disabledTrigger);
				this.animator.SetTrigger(triggername);
			}
		}

		// Token: 0x06000449 RID: 1097 RVA: 0x00007880 File Offset: 0x00005C80
		protected bool IsHighlighted(BaseEventData eventData)
		{
			bool flag;
			if (!this.IsActive())
			{
				flag = false;
			}
			else if (this.IsPressed())
			{
				flag = false;
			}
			else
			{
				bool flag2 = this.hasSelection;
				if (eventData is PointerEventData)
				{
					PointerEventData pointerEventData = eventData as PointerEventData;
					flag2 |= (this.isPointerDown && !this.isPointerInside && pointerEventData.pointerPress == base.gameObject) || (!this.isPointerDown && this.isPointerInside && pointerEventData.pointerPress == base.gameObject) || (!this.isPointerDown && this.isPointerInside && pointerEventData.pointerPress == null);
				}
				else
				{
					flag2 |= this.isPointerInside;
				}
				flag = flag2;
			}
			return flag;
		}

		// Token: 0x0600044A RID: 1098 RVA: 0x00007968 File Offset: 0x00005D68
		[Obsolete("Is Pressed no longer requires eventData", false)]
		protected bool IsPressed(BaseEventData eventData)
		{
			return this.IsPressed();
		}

		// Token: 0x0600044B RID: 1099 RVA: 0x00007984 File Offset: 0x00005D84
		protected bool IsPressed()
		{
			return this.IsActive() && this.isPointerInside && this.isPointerDown;
		}

		// Token: 0x0600044C RID: 1100 RVA: 0x000079BF File Offset: 0x00005DBF
		protected void UpdateSelectionState(BaseEventData eventData)
		{
			if (this.IsPressed())
			{
				this.m_CurrentSelectionState = Selectable.SelectionState.Pressed;
			}
			else if (this.IsHighlighted(eventData))
			{
				this.m_CurrentSelectionState = Selectable.SelectionState.Highlighted;
			}
			else
			{
				this.m_CurrentSelectionState = Selectable.SelectionState.Normal;
			}
		}

		// Token: 0x0600044D RID: 1101 RVA: 0x000079FA File Offset: 0x00005DFA
		private void EvaluateAndTransitionToSelectionState(BaseEventData eventData)
		{
			if (this.IsActive() && this.IsInteractable())
			{
				this.UpdateSelectionState(eventData);
				this.InternalEvaluateAndTransitionToSelectionState(false);
			}
		}

		// Token: 0x0600044E RID: 1102 RVA: 0x00007A28 File Offset: 0x00005E28
		private void InternalEvaluateAndTransitionToSelectionState(bool instant)
		{
			Selectable.SelectionState selectionState = this.m_CurrentSelectionState;
			if (this.IsActive() && !this.IsInteractable())
			{
				selectionState = Selectable.SelectionState.Disabled;
			}
			this.DoStateTransition(selectionState, instant);
		}

		// Token: 0x0600044F RID: 1103 RVA: 0x00007A60 File Offset: 0x00005E60
		public virtual void OnPointerDown(PointerEventData eventData)
		{
			if (eventData.button == PointerEventData.InputButton.Left)
			{
				if (this.IsInteractable() && this.navigation.mode != Navigation.Mode.None && EventSystem.current != null)
				{
					EventSystem.current.SetSelectedGameObject(base.gameObject, eventData);
				}
				this.isPointerDown = true;
				this.EvaluateAndTransitionToSelectionState(eventData);
			}
		}

		// Token: 0x06000450 RID: 1104 RVA: 0x00007ACB File Offset: 0x00005ECB
		public virtual void OnPointerUp(PointerEventData eventData)
		{
			if (eventData.button == PointerEventData.InputButton.Left)
			{
				this.isPointerDown = false;
				this.EvaluateAndTransitionToSelectionState(eventData);
			}
		}

		// Token: 0x06000451 RID: 1105 RVA: 0x00007AEC File Offset: 0x00005EEC
		public virtual void OnPointerEnter(PointerEventData eventData)
		{
			this.isPointerInside = true;
			this.EvaluateAndTransitionToSelectionState(eventData);
		}

		// Token: 0x06000452 RID: 1106 RVA: 0x00007AFD File Offset: 0x00005EFD
		public virtual void OnPointerExit(PointerEventData eventData)
		{
			this.isPointerInside = false;
			this.EvaluateAndTransitionToSelectionState(eventData);
		}

		// Token: 0x06000453 RID: 1107 RVA: 0x00007B0E File Offset: 0x00005F0E
		public virtual void OnSelect(BaseEventData eventData)
		{
			this.hasSelection = true;
			this.EvaluateAndTransitionToSelectionState(eventData);
		}

		// Token: 0x06000454 RID: 1108 RVA: 0x00007B1F File Offset: 0x00005F1F
		public virtual void OnDeselect(BaseEventData eventData)
		{
			this.hasSelection = false;
			this.EvaluateAndTransitionToSelectionState(eventData);
		}

		// Token: 0x06000455 RID: 1109 RVA: 0x00007B30 File Offset: 0x00005F30
		public virtual void Select()
		{
			if (!(EventSystem.current == null) && !EventSystem.current.alreadySelecting)
			{
				EventSystem.current.SetSelectedGameObject(base.gameObject);
			}
		}

		// Token: 0x04000205 RID: 517
		private static List<Selectable> s_List = new List<Selectable>();

		// Token: 0x04000206 RID: 518
		[FormerlySerializedAs("navigation")]
		[SerializeField]
		private Navigation m_Navigation = Navigation.defaultNavigation;

		// Token: 0x04000207 RID: 519
		[FormerlySerializedAs("transition")]
		[SerializeField]
		private Selectable.Transition m_Transition = Selectable.Transition.ColorTint;

		// Token: 0x04000208 RID: 520
		[FormerlySerializedAs("colors")]
		[SerializeField]
		private ColorBlock m_Colors = ColorBlock.defaultColorBlock;

		// Token: 0x04000209 RID: 521
		[FormerlySerializedAs("spriteState")]
		[SerializeField]
		private SpriteState m_SpriteState;

		// Token: 0x0400020A RID: 522
		[FormerlySerializedAs("animationTriggers")]
		[SerializeField]
		private AnimationTriggers m_AnimationTriggers = new AnimationTriggers();

		// Token: 0x0400020B RID: 523
		[Tooltip("Can the Selectable be interacted with?")]
		[SerializeField]
		private bool m_Interactable = true;

		// Token: 0x0400020C RID: 524
		[FormerlySerializedAs("highlightGraphic")]
		[FormerlySerializedAs("m_HighlightGraphic")]
		[SerializeField]
		private Graphic m_TargetGraphic;

		// Token: 0x0400020D RID: 525
		private bool m_GroupsAllowInteraction = true;

		// Token: 0x0400020E RID: 526
		private Selectable.SelectionState m_CurrentSelectionState;

		// Token: 0x04000212 RID: 530
		private readonly List<CanvasGroup> m_CanvasGroupCache = new List<CanvasGroup>();

		// Token: 0x02000073 RID: 115
		public enum Transition
		{
			// Token: 0x04000214 RID: 532
			None,
			// Token: 0x04000215 RID: 533
			ColorTint,
			// Token: 0x04000216 RID: 534
			SpriteSwap,
			// Token: 0x04000217 RID: 535
			Animation
		}

		// Token: 0x02000074 RID: 116
		protected enum SelectionState
		{
			// Token: 0x04000219 RID: 537
			Normal,
			// Token: 0x0400021A RID: 538
			Highlighted,
			// Token: 0x0400021B RID: 539
			Pressed,
			// Token: 0x0400021C RID: 540
			Disabled
		}
	}
}