using System;
using System.Collections.Generic;
using System.Diagnostics;
using UnityEngine.CSSLayout;
using UnityEngine.Experimental.UIElements.StyleEnums;
using UnityEngine.Experimental.UIElements.StyleSheets;

namespace UnityEngine.Experimental.UIElements
{
	// Token: 0x0200035B RID: 859
	public class VisualElement : IEventHandler
	{
		// Token: 0x06003455 RID: 13397 RVA: 0x0005422C File Offset: 0x0005242C
		public VisualElement()
		{
			this.controlid = (VisualElement.s_NextId += 1U);
			this.m_ClassList = new HashSet<string>();
			this.m_FullTypeName = string.Empty;
			this.m_TypeName = string.Empty;
			this.enabled = true;
			this.visible = true;
			this.phaseInterest = EventPhase.BubbleUp;
			this.name = string.Empty;
			this.cssNode = new CSSNode();
			this.cssNode.SetMeasureFunction(new MeasureFunction(this.Measure));
			this.changesNeeded = (ChangeType)0;
		}

		// Token: 0x17000BF4 RID: 3060
		// (get) Token: 0x06003456 RID: 13398 RVA: 0x000542E0 File Offset: 0x000524E0
		// (set) Token: 0x06003457 RID: 13399 RVA: 0x000542FC File Offset: 0x000524FC
		public bool usePixelCaching { get; set; }

		// Token: 0x17000BF5 RID: 3061
		// (get) Token: 0x06003458 RID: 13400 RVA: 0x00054308 File Offset: 0x00052508
		internal RenderData renderData
		{
			get
			{
				RenderData renderData;
				if ((renderData = this.m_RenderData) == null)
				{
					renderData = (this.m_RenderData = new RenderData());
				}
				return renderData;
			}
		}

		// Token: 0x17000BF6 RID: 3062
		// (get) Token: 0x06003459 RID: 13401 RVA: 0x00054338 File Offset: 0x00052538
		// (set) Token: 0x0600345A RID: 13402 RVA: 0x00054354 File Offset: 0x00052554
		public Matrix4x4 transform
		{
			get
			{
				return this.m_Transform;
			}
			set
			{
				if (!(this.m_Transform == value))
				{
					this.m_Transform = value;
					this.Dirty(ChangeType.Transform);
				}
			}
		}

		// Token: 0x17000BF7 RID: 3063
		// (get) Token: 0x0600345B RID: 13403 RVA: 0x0005437C File Offset: 0x0005257C
		// (set) Token: 0x0600345C RID: 13404 RVA: 0x000543FC File Offset: 0x000525FC
		public Rect position
		{
			get
			{
				Rect position = this.m_Position;
				if (this.cssNode != null && this.positionType != PositionType.Manual)
				{
					position.x = this.cssNode.LayoutX;
					position.y = this.cssNode.LayoutY;
					position.width = this.cssNode.LayoutWidth;
					position.height = this.cssNode.LayoutHeight;
				}
				return position;
			}
			set
			{
				if (this.cssNode == null)
				{
					this.cssNode = new CSSNode();
				}
				if (this.positionType != PositionType.Manual || !(this.m_Position == value))
				{
					this.m_Position = value;
					this.cssNode.SetPosition(CSSEdge.Left, value.x);
					this.cssNode.SetPosition(CSSEdge.Top, value.y);
					this.cssNode.Width = value.width;
					this.cssNode.Height = value.height;
					this.EnsureInlineStyles();
					this.m_Styles.positionType = Style<int>.Create(2);
					this.m_Styles.marginLeft = Style<float>.Create(0f);
					this.m_Styles.marginRight = Style<float>.Create(0f);
					this.m_Styles.marginBottom = Style<float>.Create(0f);
					this.m_Styles.marginTop = Style<float>.Create(0f);
					this.m_Styles.positionLeft = Style<float>.Create(value.x);
					this.m_Styles.positionTop = Style<float>.Create(value.y);
					this.m_Styles.positionRight = Style<float>.Create(float.NaN);
					this.m_Styles.positionBottom = Style<float>.Create(float.NaN);
					this.m_Styles.width = Style<float>.Create(value.width);
					this.m_Styles.height = Style<float>.Create(value.height);
					this.Dirty(ChangeType.Layout);
				}
			}
		}

		// Token: 0x17000BF8 RID: 3064
		// (get) Token: 0x0600345D RID: 13405 RVA: 0x00054590 File Offset: 0x00052790
		public Rect contentRect
		{
			get
			{
				Spacing spacing = new Spacing(this.paddingLeft, this.paddingTop, this.paddingRight, this.paddingBottom);
				return this.paddingRect - spacing;
			}
		}

		// Token: 0x17000BF9 RID: 3065
		// (get) Token: 0x0600345E RID: 13406 RVA: 0x000545D0 File Offset: 0x000527D0
		protected Rect paddingRect
		{
			get
			{
				Spacing spacing = new Spacing(this.borderWidth, this.borderWidth, this.borderWidth, this.borderWidth);
				return this.position - spacing;
			}
		}

		// Token: 0x17000BFA RID: 3066
		// (get) Token: 0x0600345F RID: 13407 RVA: 0x00054610 File Offset: 0x00052810
		public Rect globalBound
		{
			get
			{
				Matrix4x4 globalTransform = this.globalTransform;
				Vector3 vector = globalTransform.MultiplyPoint3x4(this.position.min);
				Vector3 vector2 = globalTransform.MultiplyPoint3x4(this.position.max);
				return Rect.MinMaxRect(Math.Min(vector.x, vector2.x), Math.Min(vector.y, vector2.y), Math.Max(vector.x, vector2.x), Math.Max(vector.y, vector2.y));
			}
		}

		// Token: 0x17000BFB RID: 3067
		// (get) Token: 0x06003460 RID: 13408 RVA: 0x000546B8 File Offset: 0x000528B8
		public Rect localBound
		{
			get
			{
				Matrix4x4 transform = this.transform;
				Vector3 vector = transform.MultiplyPoint3x4(this.position.min);
				Vector3 vector2 = transform.MultiplyPoint3x4(this.position.max);
				return Rect.MinMaxRect(Math.Min(vector.x, vector2.x), Math.Min(vector.y, vector2.y), Math.Max(vector.x, vector2.x), Math.Max(vector.y, vector2.y));
			}
		}

		// Token: 0x17000BFC RID: 3068
		// (get) Token: 0x06003461 RID: 13409 RVA: 0x00054760 File Offset: 0x00052960
		public Matrix4x4 globalTransform
		{
			get
			{
				if (this.IsDirty(ChangeType.Transform))
				{
					if (this.parent != null)
					{
						this.renderData.worldTransForm = this.parent.globalTransform * Matrix4x4.Translate(new Vector3(this.parent.position.x, this.parent.position.y, 0f)) * this.transform;
					}
					else
					{
						this.renderData.worldTransForm = this.transform;
					}
					this.ClearDirty(ChangeType.Transform);
				}
				return this.renderData.worldTransForm;
			}
		}

		// Token: 0x17000BFD RID: 3069
		// (get) Token: 0x06003462 RID: 13410 RVA: 0x00054818 File Offset: 0x00052A18
		// (set) Token: 0x06003463 RID: 13411 RVA: 0x00054834 File Offset: 0x00052A34
		internal PseudoStates pseudoStates
		{
			get
			{
				return this.m_PseudoStates;
			}
			set
			{
				if (this.m_PseudoStates != value)
				{
					this.m_PseudoStates = value;
					this.Dirty(ChangeType.Styles);
				}
			}
		}

		// Token: 0x17000BFE RID: 3070
		// (get) Token: 0x06003464 RID: 13412 RVA: 0x00054854 File Offset: 0x00052A54
		// (set) Token: 0x06003465 RID: 13413 RVA: 0x00054870 File Offset: 0x00052A70
		public VisualContainer parent
		{
			get
			{
				return this.m_Parent;
			}
			set
			{
				this.m_Parent = value;
				if (value != null)
				{
					this.ChangePanel(this.m_Parent.elementPanel);
				}
				else
				{
					this.ChangePanel(null);
				}
			}
		}

		// Token: 0x17000BFF RID: 3071
		// (get) Token: 0x06003466 RID: 13414 RVA: 0x000548A0 File Offset: 0x00052AA0
		// (set) Token: 0x06003467 RID: 13415 RVA: 0x000548BC File Offset: 0x00052ABC
		internal BaseVisualElementPanel elementPanel { get; private set; }

		// Token: 0x17000C00 RID: 3072
		// (get) Token: 0x06003468 RID: 13416 RVA: 0x000548C8 File Offset: 0x00052AC8
		public IPanel panel
		{
			get
			{
				return this.elementPanel;
			}
		}

		// Token: 0x17000C01 RID: 3073
		// (get) Token: 0x06003469 RID: 13417 RVA: 0x000548E4 File Offset: 0x00052AE4
		// (set) Token: 0x0600346A RID: 13418 RVA: 0x00054900 File Offset: 0x00052B00
		public EventPhase phaseInterest { get; set; }

		// Token: 0x17000C02 RID: 3074
		// (get) Token: 0x0600346B RID: 13419 RVA: 0x0005490C File Offset: 0x00052B0C
		// (set) Token: 0x0600346C RID: 13420 RVA: 0x00054928 File Offset: 0x00052B28
		public PickingMode pickingMode { get; set; }

		// Token: 0x17000C03 RID: 3075
		// (get) Token: 0x0600346D RID: 13421 RVA: 0x00054934 File Offset: 0x00052B34
		// (set) Token: 0x0600346E RID: 13422 RVA: 0x00054950 File Offset: 0x00052B50
		public string name
		{
			get
			{
				return this.m_Name;
			}
			set
			{
				if (!(this.m_Name == value))
				{
					this.m_Name = value;
					this.Dirty(ChangeType.Styles);
				}
			}
		}

		// Token: 0x17000C04 RID: 3076
		// (get) Token: 0x0600346F RID: 13423 RVA: 0x00054978 File Offset: 0x00052B78
		internal string fullTypeName
		{
			get
			{
				if (string.IsNullOrEmpty(this.m_FullTypeName))
				{
					this.m_FullTypeName = base.GetType().FullName;
				}
				return this.m_FullTypeName;
			}
		}

		// Token: 0x17000C05 RID: 3077
		// (get) Token: 0x06003470 RID: 13424 RVA: 0x000549B4 File Offset: 0x00052BB4
		internal string typeName
		{
			get
			{
				if (string.IsNullOrEmpty(this.m_TypeName))
				{
					this.m_TypeName = base.GetType().Name;
				}
				return this.m_TypeName;
			}
		}

		// Token: 0x17000C06 RID: 3078
		// (get) Token: 0x06003471 RID: 13425 RVA: 0x000549F0 File Offset: 0x00052BF0
		// (set) Token: 0x06003472 RID: 13426 RVA: 0x00054A0C File Offset: 0x00052C0C
		internal CSSNode cssNode { get; private set; }

		// Token: 0x06003473 RID: 13427 RVA: 0x00054A18 File Offset: 0x00052C18
		public virtual void OnStylesResolved(ICustomStyles styles)
		{
			this.FinalizeLayout();
		}

		// Token: 0x17000C07 RID: 3079
		// (get) Token: 0x06003474 RID: 13428 RVA: 0x00054A24 File Offset: 0x00052C24
		internal VisualElementStyles styles
		{
			get
			{
				return this.m_Styles;
			}
		}

		// Token: 0x17000C08 RID: 3080
		// (get) Token: 0x06003475 RID: 13429 RVA: 0x00054A40 File Offset: 0x00052C40
		// (set) Token: 0x06003476 RID: 13430 RVA: 0x00054A68 File Offset: 0x00052C68
		public float width
		{
			get
			{
				return this.m_Styles.width;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.width = Style<float>.Create(value);
				this.cssNode.Width = value;
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C09 RID: 3081
		// (get) Token: 0x06003477 RID: 13431 RVA: 0x00054A98 File Offset: 0x00052C98
		// (set) Token: 0x06003478 RID: 13432 RVA: 0x00054AC0 File Offset: 0x00052CC0
		public float height
		{
			get
			{
				return this.m_Styles.height;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.height = Style<float>.Create(value);
				this.cssNode.Height = value;
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C0A RID: 3082
		// (get) Token: 0x06003479 RID: 13433 RVA: 0x00054AF0 File Offset: 0x00052CF0
		// (set) Token: 0x0600347A RID: 13434 RVA: 0x00054B18 File Offset: 0x00052D18
		public float maxWidth
		{
			get
			{
				return this.m_Styles.maxWidth;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.maxWidth = Style<float>.Create(value);
				this.cssNode.MaxWidth = value;
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C0B RID: 3083
		// (get) Token: 0x0600347B RID: 13435 RVA: 0x00054B48 File Offset: 0x00052D48
		// (set) Token: 0x0600347C RID: 13436 RVA: 0x00054B70 File Offset: 0x00052D70
		public float maxHeight
		{
			get
			{
				return this.m_Styles.maxHeight;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.maxHeight = Style<float>.Create(value);
				this.cssNode.MaxHeight = value;
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C0C RID: 3084
		// (get) Token: 0x0600347D RID: 13437 RVA: 0x00054BA0 File Offset: 0x00052DA0
		// (set) Token: 0x0600347E RID: 13438 RVA: 0x00054BC8 File Offset: 0x00052DC8
		public float minWidth
		{
			get
			{
				return this.m_Styles.minWidth;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.minWidth = Style<float>.Create(value);
				this.cssNode.MinWidth = value;
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C0D RID: 3085
		// (get) Token: 0x0600347F RID: 13439 RVA: 0x00054BF8 File Offset: 0x00052DF8
		// (set) Token: 0x06003480 RID: 13440 RVA: 0x00054C20 File Offset: 0x00052E20
		public float minHeight
		{
			get
			{
				return this.m_Styles.minHeight;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.minHeight = Style<float>.Create(value);
				this.cssNode.MinHeight = value;
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C0E RID: 3086
		// (get) Token: 0x06003481 RID: 13441 RVA: 0x00054C50 File Offset: 0x00052E50
		// (set) Token: 0x06003482 RID: 13442 RVA: 0x00054C78 File Offset: 0x00052E78
		public float flex
		{
			get
			{
				return this.m_Styles.flex;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.flex = Style<float>.Create(value);
				this.cssNode.Flex = value;
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C0F RID: 3087
		// (get) Token: 0x06003483 RID: 13443 RVA: 0x00054CA8 File Offset: 0x00052EA8
		// (set) Token: 0x06003484 RID: 13444 RVA: 0x00054CD0 File Offset: 0x00052ED0
		public float positionLeft
		{
			get
			{
				return this.m_Styles.positionLeft;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.positionLeft = Style<float>.Create(value);
				this.cssNode.SetPosition(CSSEdge.Left, value);
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C10 RID: 3088
		// (get) Token: 0x06003485 RID: 13445 RVA: 0x00054D00 File Offset: 0x00052F00
		// (set) Token: 0x06003486 RID: 13446 RVA: 0x00054D28 File Offset: 0x00052F28
		public float positionTop
		{
			get
			{
				return this.m_Styles.positionTop;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.positionTop = Style<float>.Create(value);
				this.cssNode.SetPosition(CSSEdge.Top, value);
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C11 RID: 3089
		// (get) Token: 0x06003487 RID: 13447 RVA: 0x00054D58 File Offset: 0x00052F58
		// (set) Token: 0x06003488 RID: 13448 RVA: 0x00054D80 File Offset: 0x00052F80
		public float positionRight
		{
			get
			{
				return this.m_Styles.positionRight;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.positionRight = Style<float>.Create(value);
				this.cssNode.SetPosition(CSSEdge.Right, value);
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C12 RID: 3090
		// (get) Token: 0x06003489 RID: 13449 RVA: 0x00054DB0 File Offset: 0x00052FB0
		// (set) Token: 0x0600348A RID: 13450 RVA: 0x00054DD8 File Offset: 0x00052FD8
		public float positionBottom
		{
			get
			{
				return this.m_Styles.positionBottom;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.positionBottom = Style<float>.Create(value);
				this.cssNode.SetPosition(CSSEdge.Bottom, value);
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C13 RID: 3091
		// (get) Token: 0x0600348B RID: 13451 RVA: 0x00054E08 File Offset: 0x00053008
		// (set) Token: 0x0600348C RID: 13452 RVA: 0x00054E30 File Offset: 0x00053030
		public float marginLeft
		{
			get
			{
				return this.m_Styles.marginLeft;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.marginLeft = Style<float>.Create(value);
				this.cssNode.SetMargin(CSSEdge.Left, value);
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C14 RID: 3092
		// (get) Token: 0x0600348D RID: 13453 RVA: 0x00054E60 File Offset: 0x00053060
		// (set) Token: 0x0600348E RID: 13454 RVA: 0x00054E88 File Offset: 0x00053088
		public float marginTop
		{
			get
			{
				return this.m_Styles.marginTop;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.marginTop = Style<float>.Create(value);
				this.cssNode.SetMargin(CSSEdge.Top, value);
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C15 RID: 3093
		// (get) Token: 0x0600348F RID: 13455 RVA: 0x00054EB8 File Offset: 0x000530B8
		// (set) Token: 0x06003490 RID: 13456 RVA: 0x00054EE0 File Offset: 0x000530E0
		public float marginRight
		{
			get
			{
				return this.m_Styles.marginRight;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.marginRight = Style<float>.Create(value);
				this.cssNode.SetMargin(CSSEdge.Right, value);
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C16 RID: 3094
		// (get) Token: 0x06003491 RID: 13457 RVA: 0x00054F10 File Offset: 0x00053110
		// (set) Token: 0x06003492 RID: 13458 RVA: 0x00054F38 File Offset: 0x00053138
		public float marginBottom
		{
			get
			{
				return this.m_Styles.marginBottom;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.marginBottom = Style<float>.Create(value);
				this.cssNode.SetMargin(CSSEdge.Bottom, value);
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C17 RID: 3095
		// (get) Token: 0x06003493 RID: 13459 RVA: 0x00054F68 File Offset: 0x00053168
		// (set) Token: 0x06003494 RID: 13460 RVA: 0x00054F90 File Offset: 0x00053190
		public float borderLeft
		{
			get
			{
				return this.m_Styles.borderLeft;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.borderLeft = Style<float>.Create(value);
				this.cssNode.SetBorder(CSSEdge.Left, value);
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C18 RID: 3096
		// (get) Token: 0x06003495 RID: 13461 RVA: 0x00054FC0 File Offset: 0x000531C0
		// (set) Token: 0x06003496 RID: 13462 RVA: 0x00054FE8 File Offset: 0x000531E8
		public float borderTop
		{
			get
			{
				return this.m_Styles.borderTop;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.borderTop = Style<float>.Create(value);
				this.cssNode.SetBorder(CSSEdge.Top, value);
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C19 RID: 3097
		// (get) Token: 0x06003497 RID: 13463 RVA: 0x00055018 File Offset: 0x00053218
		// (set) Token: 0x06003498 RID: 13464 RVA: 0x00055040 File Offset: 0x00053240
		public float borderRight
		{
			get
			{
				return this.m_Styles.borderRight;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.borderRight = Style<float>.Create(value);
				this.cssNode.SetBorder(CSSEdge.Right, value);
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C1A RID: 3098
		// (get) Token: 0x06003499 RID: 13465 RVA: 0x00055070 File Offset: 0x00053270
		// (set) Token: 0x0600349A RID: 13466 RVA: 0x00055098 File Offset: 0x00053298
		public float borderBottom
		{
			get
			{
				return this.m_Styles.borderBottom;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.borderBottom = Style<float>.Create(value);
				this.cssNode.SetBorder(CSSEdge.Bottom, value);
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C1B RID: 3099
		// (get) Token: 0x0600349B RID: 13467 RVA: 0x000550C8 File Offset: 0x000532C8
		// (set) Token: 0x0600349C RID: 13468 RVA: 0x000550F0 File Offset: 0x000532F0
		public float paddingLeft
		{
			get
			{
				return this.m_Styles.paddingLeft;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.paddingLeft = Style<float>.Create(value);
				this.cssNode.SetPadding(CSSEdge.Left, value);
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C1C RID: 3100
		// (get) Token: 0x0600349D RID: 13469 RVA: 0x00055120 File Offset: 0x00053320
		// (set) Token: 0x0600349E RID: 13470 RVA: 0x00055148 File Offset: 0x00053348
		public float paddingTop
		{
			get
			{
				return this.m_Styles.paddingTop;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.paddingTop = Style<float>.Create(value);
				this.cssNode.SetPadding(CSSEdge.Top, value);
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C1D RID: 3101
		// (get) Token: 0x0600349F RID: 13471 RVA: 0x00055178 File Offset: 0x00053378
		// (set) Token: 0x060034A0 RID: 13472 RVA: 0x000551A0 File Offset: 0x000533A0
		public float paddingRight
		{
			get
			{
				return this.m_Styles.paddingRight;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.paddingRight = Style<float>.Create(value);
				this.cssNode.SetPadding(CSSEdge.Right, value);
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C1E RID: 3102
		// (get) Token: 0x060034A1 RID: 13473 RVA: 0x000551D0 File Offset: 0x000533D0
		// (set) Token: 0x060034A2 RID: 13474 RVA: 0x000551F8 File Offset: 0x000533F8
		public float paddingBottom
		{
			get
			{
				return this.m_Styles.paddingBottom;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.paddingBottom = Style<float>.Create(value);
				this.cssNode.SetPadding(CSSEdge.Bottom, value);
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C1F RID: 3103
		// (get) Token: 0x060034A3 RID: 13475 RVA: 0x00055228 File Offset: 0x00053428
		// (set) Token: 0x060034A4 RID: 13476 RVA: 0x00055250 File Offset: 0x00053450
		public PositionType positionType
		{
			get
			{
				return (PositionType)this.m_Styles.positionType.value;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.positionType = Style<int>.Create((int)value);
				this.cssNode.PositionType = (CSSPositionType)value;
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C20 RID: 3104
		// (get) Token: 0x060034A5 RID: 13477 RVA: 0x00055280 File Offset: 0x00053480
		// (set) Token: 0x060034A6 RID: 13478 RVA: 0x000552A8 File Offset: 0x000534A8
		public ImageScaleMode backgroundSize
		{
			get
			{
				return (ImageScaleMode)this.m_Styles.backgroundSize.value;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.backgroundSize = Style<int>.Create((int)value);
			}
		}

		// Token: 0x17000C21 RID: 3105
		// (get) Token: 0x060034A7 RID: 13479 RVA: 0x000552C4 File Offset: 0x000534C4
		// (set) Token: 0x060034A8 RID: 13480 RVA: 0x000552EC File Offset: 0x000534EC
		public Align alignSelf
		{
			get
			{
				return (Align)this.m_Styles.alignSelf.value;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.alignSelf = Style<int>.Create((int)value);
				this.cssNode.AlignSelf = (CSSAlign)value;
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C22 RID: 3106
		// (get) Token: 0x060034A9 RID: 13481 RVA: 0x0005531C File Offset: 0x0005351C
		// (set) Token: 0x060034AA RID: 13482 RVA: 0x00055344 File Offset: 0x00053544
		public TextAnchor textAlignment
		{
			get
			{
				return (TextAnchor)this.m_Styles.textAlignment.value;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.textAlignment = Style<int>.Create((int)value);
			}
		}

		// Token: 0x17000C23 RID: 3107
		// (get) Token: 0x060034AB RID: 13483 RVA: 0x00055360 File Offset: 0x00053560
		// (set) Token: 0x060034AC RID: 13484 RVA: 0x00055388 File Offset: 0x00053588
		public FontStyle fontStyle
		{
			get
			{
				return (FontStyle)this.m_Styles.fontStyle.value;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.fontStyle = Style<int>.Create((int)value);
			}
		}

		// Token: 0x17000C24 RID: 3108
		// (get) Token: 0x060034AD RID: 13485 RVA: 0x000553A4 File Offset: 0x000535A4
		// (set) Token: 0x060034AE RID: 13486 RVA: 0x000553CC File Offset: 0x000535CC
		public TextClipping textClipping
		{
			get
			{
				return (TextClipping)this.m_Styles.textClipping.value;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.textClipping = Style<int>.Create((int)value);
			}
		}

		// Token: 0x17000C25 RID: 3109
		// (get) Token: 0x060034AF RID: 13487 RVA: 0x000553E8 File Offset: 0x000535E8
		// (set) Token: 0x060034B0 RID: 13488 RVA: 0x00055410 File Offset: 0x00053610
		public Font font
		{
			get
			{
				return this.m_Styles.font;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.font = Style<Font>.Create(value);
			}
		}

		// Token: 0x17000C26 RID: 3110
		// (get) Token: 0x060034B1 RID: 13489 RVA: 0x0005542C File Offset: 0x0005362C
		// (set) Token: 0x060034B2 RID: 13490 RVA: 0x00055454 File Offset: 0x00053654
		public int fontSize
		{
			get
			{
				return this.m_Styles.fontSize;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.fontSize = Style<int>.Create(value);
			}
		}

		// Token: 0x17000C27 RID: 3111
		// (get) Token: 0x060034B3 RID: 13491 RVA: 0x00055470 File Offset: 0x00053670
		// (set) Token: 0x060034B4 RID: 13492 RVA: 0x00055498 File Offset: 0x00053698
		public bool wordWrap
		{
			get
			{
				return this.m_Styles.wordWrap;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.wordWrap = Style<bool>.Create(value);
			}
		}

		// Token: 0x17000C28 RID: 3112
		// (get) Token: 0x060034B5 RID: 13493 RVA: 0x000554B4 File Offset: 0x000536B4
		// (set) Token: 0x060034B6 RID: 13494 RVA: 0x000554DC File Offset: 0x000536DC
		public Texture2D backgroundImage
		{
			get
			{
				return this.m_Styles.backgroundImage;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.backgroundImage = Style<Texture2D>.Create(value);
			}
		}

		// Token: 0x17000C29 RID: 3113
		// (get) Token: 0x060034B7 RID: 13495 RVA: 0x000554F8 File Offset: 0x000536F8
		// (set) Token: 0x060034B8 RID: 13496 RVA: 0x00055524 File Offset: 0x00053724
		public Color textColor
		{
			get
			{
				return this.m_Styles.textColor.GetSpecifiedValueOrDefault(Color.black);
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.textColor = Style<Color>.Create(value);
			}
		}

		// Token: 0x17000C2A RID: 3114
		// (get) Token: 0x060034B9 RID: 13497 RVA: 0x00055540 File Offset: 0x00053740
		// (set) Token: 0x060034BA RID: 13498 RVA: 0x00055568 File Offset: 0x00053768
		public Color backgroundColor
		{
			get
			{
				return this.m_Styles.backgroundColor;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.backgroundColor = Style<Color>.Create(value);
			}
		}

		// Token: 0x17000C2B RID: 3115
		// (get) Token: 0x060034BB RID: 13499 RVA: 0x00055584 File Offset: 0x00053784
		// (set) Token: 0x060034BC RID: 13500 RVA: 0x000555AC File Offset: 0x000537AC
		public Color borderColor
		{
			get
			{
				return this.m_Styles.borderColor;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.borderColor = Style<Color>.Create(value);
			}
		}

		// Token: 0x17000C2C RID: 3116
		// (get) Token: 0x060034BD RID: 13501 RVA: 0x000555C8 File Offset: 0x000537C8
		// (set) Token: 0x060034BE RID: 13502 RVA: 0x000555F0 File Offset: 0x000537F0
		public float borderWidth
		{
			get
			{
				return this.m_Styles.borderWidth;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.borderWidth = Style<float>.Create(value);
			}
		}

		// Token: 0x17000C2D RID: 3117
		// (get) Token: 0x060034BF RID: 13503 RVA: 0x0005560C File Offset: 0x0005380C
		// (set) Token: 0x060034C0 RID: 13504 RVA: 0x00055634 File Offset: 0x00053834
		public float borderRadius
		{
			get
			{
				return this.m_Styles.borderRadius;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.borderRadius = Style<float>.Create(value);
			}
		}

		// Token: 0x17000C2E RID: 3118
		// (get) Token: 0x060034C1 RID: 13505 RVA: 0x00055650 File Offset: 0x00053850
		// (set) Token: 0x060034C2 RID: 13506 RVA: 0x00055678 File Offset: 0x00053878
		public Overflow overflow
		{
			get
			{
				return (Overflow)this.m_Styles.overflow.value;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.overflow = Style<int>.Create((int)value);
				this.cssNode.Overflow = (CSSOverflow)value;
				this.Dirty(ChangeType.Layout);
			}
		}

		// Token: 0x17000C2F RID: 3119
		// (get) Token: 0x060034C3 RID: 13507 RVA: 0x000556A8 File Offset: 0x000538A8
		// (set) Token: 0x060034C4 RID: 13508 RVA: 0x000556D0 File Offset: 0x000538D0
		internal float opacity
		{
			get
			{
				return this.m_Styles.opacity.value;
			}
			set
			{
				this.EnsureInlineStyles();
				this.m_Styles.opacity = Style<float>.Create(value);
				this.Dirty(ChangeType.Repaint);
			}
		}

		// Token: 0x060034C5 RID: 13509 RVA: 0x000556F4 File Offset: 0x000538F4
		internal List<IManipulator>.Enumerator GetManipulatorsInternal()
		{
			List<IManipulator>.Enumerator enumerator;
			if (this.m_Manipulators != null)
			{
				enumerator = this.m_Manipulators.GetEnumerator();
			}
			else
			{
				enumerator = default(List<IManipulator>.Enumerator);
			}
			return enumerator;
		}

		// Token: 0x060034C6 RID: 13510 RVA: 0x00055730 File Offset: 0x00053930
		public void InsertManipulator(int index, IManipulator manipulator)
		{
			if (this.m_Manipulators == null)
			{
				this.m_Manipulators = new List<IManipulator>();
			}
			manipulator.target = this;
			if (!this.m_Manipulators.Contains(manipulator))
			{
				this.m_Manipulators.Insert(index, manipulator);
			}
		}

		// Token: 0x060034C7 RID: 13511 RVA: 0x00055770 File Offset: 0x00053970
		public void AddManipulator(IManipulator manipulator)
		{
			if (this.m_Manipulators == null)
			{
				this.m_Manipulators = new List<IManipulator>();
			}
			manipulator.target = this;
			if (!this.m_Manipulators.Contains(manipulator))
			{
				this.m_Manipulators.Add(manipulator);
			}
		}

		// Token: 0x060034C8 RID: 13512 RVA: 0x000557B0 File Offset: 0x000539B0
		public void RemoveManipulator(IManipulator manipulator)
		{
			manipulator.target = null;
			if (this.m_Manipulators != null)
			{
				this.m_Manipulators.Remove(manipulator);
			}
		}

		// Token: 0x060034C9 RID: 13513 RVA: 0x000557D4 File Offset: 0x000539D4
		internal virtual void ChangePanel(BaseVisualElementPanel p)
		{
			if (this.panel != p)
			{
				if (this.panel != null && this.onLeave != null)
				{
					this.onLeave();
				}
				this.elementPanel = p;
				if (this.panel != null && this.onEnter != null)
				{
					this.onEnter();
				}
			}
		}

		// Token: 0x060034CA RID: 13514 RVA: 0x00055840 File Offset: 0x00053A40
		private void PropagateToChildren(ChangeType type)
		{
			if ((type & this.changesNeeded) != type)
			{
				this.changesNeeded |= type;
				type &= ChangeType.Styles | ChangeType.Transform;
				if (type != (ChangeType)0)
				{
					VisualContainer visualContainer = this as VisualContainer;
					if (visualContainer != null)
					{
						foreach (VisualElement visualElement in visualContainer)
						{
							visualElement.PropagateToChildren(type);
						}
					}
				}
			}
		}

		// Token: 0x060034CB RID: 13515 RVA: 0x000558DC File Offset: 0x00053ADC
		protected internal void PropagateChangesToParents()
		{
			ChangeType changeType = (ChangeType)0;
			if ((this.changesNeeded & ChangeType.Styles) > (ChangeType)0)
			{
				changeType |= ChangeType.StylesPath;
				changeType |= ChangeType.Repaint;
			}
			if ((this.changesNeeded & ChangeType.Transform) > (ChangeType)0)
			{
				changeType |= ChangeType.Repaint;
			}
			if ((this.changesNeeded & ChangeType.Layout) > (ChangeType)0)
			{
				changeType |= ChangeType.Repaint;
			}
			if ((this.changesNeeded & ChangeType.Repaint) > (ChangeType)0)
			{
				changeType |= ChangeType.Repaint;
			}
			for (VisualContainer visualContainer = this.parent; visualContainer != null; visualContainer = visualContainer.parent)
			{
				if ((visualContainer.changesNeeded & changeType) == changeType)
				{
					break;
				}
				visualContainer.changesNeeded |= changeType;
			}
		}

		// Token: 0x060034CC RID: 13516 RVA: 0x00055980 File Offset: 0x00053B80
		public void Dirty(ChangeType type)
		{
			if ((type & this.changesNeeded) != type)
			{
				if ((type & ChangeType.Layout) > (ChangeType)0 && this.cssNode != null && this.cssNode.IsMeasureDefined)
				{
					this.cssNode.MarkDirty();
				}
				this.PropagateToChildren(type);
				this.PropagateChangesToParents();
			}
		}

		// Token: 0x060034CD RID: 13517 RVA: 0x000559E0 File Offset: 0x00053BE0
		public bool IsDirty(ChangeType type)
		{
			return (this.changesNeeded & type) > (ChangeType)0;
		}

		// Token: 0x060034CE RID: 13518 RVA: 0x00055A00 File Offset: 0x00053C00
		public void ClearDirty(ChangeType type)
		{
			this.changesNeeded &= ~type;
		}

		// Token: 0x14000029 RID: 41
		// (add) Token: 0x060034CF RID: 13519 RVA: 0x00055A14 File Offset: 0x00053C14
		// (remove) Token: 0x060034D0 RID: 13520 RVA: 0x00055A4C File Offset: 0x00053C4C
		[field: DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event Action onEnter;

		// Token: 0x1400002A RID: 42
		// (add) Token: 0x060034D1 RID: 13521 RVA: 0x00055A84 File Offset: 0x00053C84
		// (remove) Token: 0x060034D2 RID: 13522 RVA: 0x00055ABC File Offset: 0x00053CBC
		[field: DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event Action onLeave;

		// Token: 0x17000C30 RID: 3120
		// (get) Token: 0x060034D3 RID: 13523 RVA: 0x00055AF4 File Offset: 0x00053CF4
		// (set) Token: 0x060034D4 RID: 13524 RVA: 0x00055B1C File Offset: 0x00053D1C
		public string text
		{
			get
			{
				return this.m_Text ?? string.Empty;
			}
			set
			{
				if (this.m_Text != value)
				{
					this.m_Text = value;
					this.Dirty(ChangeType.Layout);
				}
			}
		}

		// Token: 0x17000C31 RID: 3121
		// (get) Token: 0x060034D5 RID: 13525 RVA: 0x00055B44 File Offset: 0x00053D44
		// (set) Token: 0x060034D6 RID: 13526 RVA: 0x00055B6C File Offset: 0x00053D6C
		public string tooltip
		{
			get
			{
				return this.m_Tooltip ?? string.Empty;
			}
			set
			{
				if (this.m_Tooltip != value)
				{
					this.m_Tooltip = value;
					this.Dirty(ChangeType.Layout);
				}
			}
		}

		// Token: 0x17000C32 RID: 3122
		// (get) Token: 0x060034D7 RID: 13527 RVA: 0x00055B94 File Offset: 0x00053D94
		// (set) Token: 0x060034D8 RID: 13528 RVA: 0x00055BBC File Offset: 0x00053DBC
		public virtual bool enabled
		{
			get
			{
				return (this.pseudoStates & PseudoStates.Disabled) != PseudoStates.Disabled;
			}
			set
			{
				if (value)
				{
					this.pseudoStates &= ~PseudoStates.Disabled;
				}
				else
				{
					this.pseudoStates |= PseudoStates.Disabled;
				}
			}
		}

		// Token: 0x060034D9 RID: 13529 RVA: 0x00055BE8 File Offset: 0x00053DE8
		protected internal virtual void OnPostLayout(bool hasNewLayout)
		{
		}

		// Token: 0x17000C33 RID: 3123
		// (get) Token: 0x060034DA RID: 13530 RVA: 0x00055BEC File Offset: 0x00053DEC
		// (set) Token: 0x060034DB RID: 13531 RVA: 0x00055C18 File Offset: 0x00053E18
		public bool visible
		{
			get
			{
				return (this.pseudoStates & PseudoStates.Invisible) != PseudoStates.Invisible;
			}
			set
			{
				if (value)
				{
					this.pseudoStates &= (PseudoStates)2147483647;
				}
				else
				{
					this.pseudoStates |= PseudoStates.Invisible;
				}
			}
		}

		// Token: 0x060034DC RID: 13532 RVA: 0x00055C4C File Offset: 0x00053E4C
		public virtual void DoRepaint()
		{
			ScaleMode backgroundSize = (ScaleMode)this.backgroundSize;
			IStylePainter stylePainter = this.elementPanel.stylePainter;
			if (this.backgroundImage != null)
			{
				stylePainter.DrawTexture(this.position, this.backgroundImage, Color.white, backgroundSize, 0f, this.borderRadius, this.m_Styles.sliceLeft, this.m_Styles.sliceTop, this.m_Styles.sliceRight, this.m_Styles.sliceBottom);
			}
			else if (this.backgroundColor != Color.clear)
			{
				stylePainter.DrawRect(this.position, this.backgroundColor, 0f, this.borderRadius);
			}
			if (this.borderColor != Color.clear && this.borderWidth > 0f)
			{
				stylePainter.DrawRect(this.position, this.borderColor, this.borderWidth, this.borderRadius);
			}
			if (!string.IsNullOrEmpty(this.text) && this.contentRect.width > 0f && this.contentRect.height > 0f)
			{
				stylePainter.DrawText(this.contentRect, this.text, this.font, this.fontSize, this.fontStyle, this.textColor, this.textAlignment, this.wordWrap, this.contentRect.width, false, this.textClipping);
			}
		}

		// Token: 0x060034DD RID: 13533 RVA: 0x00055DF0 File Offset: 0x00053FF0
		internal virtual void DoRepaint(IStylePainter painter)
		{
			if ((this.pseudoStates & PseudoStates.Invisible) != PseudoStates.Invisible)
			{
				this.DoRepaint();
			}
		}

		// Token: 0x060034DE RID: 13534 RVA: 0x00055E18 File Offset: 0x00054018
		public virtual bool ContainsPoint(Vector2 localPoint)
		{
			return this.position.Contains(localPoint);
		}

		// Token: 0x060034DF RID: 13535 RVA: 0x00055E3C File Offset: 0x0005403C
		public virtual bool ContainsPointToLocal(Vector2 point)
		{
			return this.ContainsPoint(this.ChangeCoordinatesTo(this.parent, point));
		}

		// Token: 0x060034E0 RID: 13536 RVA: 0x00055E64 File Offset: 0x00054064
		public virtual bool Overlaps(Rect rectangle)
		{
			return this.position.Overlaps(rectangle, true);
		}

		// Token: 0x060034E1 RID: 13537 RVA: 0x00055E8C File Offset: 0x0005408C
		public virtual EventPropagation HandleEvent(Event evt, VisualElement finalTarget)
		{
			return EventPropagation.Continue;
		}

		// Token: 0x060034E2 RID: 13538 RVA: 0x00055EA4 File Offset: 0x000540A4
		public virtual void OnLostCapture()
		{
		}

		// Token: 0x060034E3 RID: 13539 RVA: 0x00055EA8 File Offset: 0x000540A8
		public virtual void OnLostKeyboardFocus()
		{
		}

		// Token: 0x060034E4 RID: 13540 RVA: 0x00055EAC File Offset: 0x000540AC
		protected internal virtual Vector2 DoMeasure(float width, VisualElement.MeasureMode widthMode, float height, VisualElement.MeasureMode heightMode)
		{
			float num = float.NaN;
			float num2 = float.NaN;
			Vector2 vector;
			if (string.IsNullOrEmpty(this.text) || this.font == null)
			{
				vector = new Vector2(num, num2);
			}
			else
			{
				if (widthMode == VisualElement.MeasureMode.Exactly)
				{
					num = width;
				}
				else
				{
					num = this.elementPanel.stylePainter.ComputeTextWidth(this.text, this.font, this.fontSize, this.fontStyle, this.textAlignment, true);
					if (widthMode == VisualElement.MeasureMode.AtMost)
					{
						num = Mathf.Min(num, width);
					}
				}
				if (heightMode == VisualElement.MeasureMode.Exactly)
				{
					num2 = height;
				}
				else
				{
					num2 = this.elementPanel.stylePainter.ComputeTextHeight(this.text, num, this.wordWrap, this.font, this.fontSize, this.fontStyle, this.textAlignment, true);
					if (heightMode == VisualElement.MeasureMode.AtMost)
					{
						num2 = Mathf.Min(num2, height);
					}
				}
				vector = new Vector2(num, num2);
			}
			return vector;
		}

		// Token: 0x060034E5 RID: 13541 RVA: 0x00055FB4 File Offset: 0x000541B4
		internal long Measure(CSSNode node, float width, CSSMeasureMode widthMode, float height, CSSMeasureMode heightMode)
		{
			Debug.Assert(node == this.cssNode, "CSSNode instance mismatch");
			Vector2 vector = this.DoMeasure(width, (VisualElement.MeasureMode)widthMode, height, (VisualElement.MeasureMode)heightMode);
			return MeasureOutput.Make(Mathf.RoundToInt(vector.x), Mathf.RoundToInt(vector.y));
		}

		// Token: 0x060034E6 RID: 13542 RVA: 0x00056008 File Offset: 0x00054208
		public void SetSize(Vector2 size)
		{
			Rect position = this.position;
			position.width = size.x;
			position.height = size.y;
			this.position = position;
		}

		// Token: 0x060034E7 RID: 13543 RVA: 0x00056040 File Offset: 0x00054240
		internal void FinalizeLayout()
		{
			this.cssNode.Flex = this.styles.flex.GetSpecifiedValueOrDefault(float.NaN);
			this.cssNode.SetPosition(CSSEdge.Left, this.styles.positionLeft.GetSpecifiedValueOrDefault(float.NaN));
			this.cssNode.SetPosition(CSSEdge.Top, this.styles.positionTop.GetSpecifiedValueOrDefault(float.NaN));
			this.cssNode.SetPosition(CSSEdge.Right, this.styles.positionRight.GetSpecifiedValueOrDefault(float.NaN));
			this.cssNode.SetPosition(CSSEdge.Bottom, this.styles.positionBottom.GetSpecifiedValueOrDefault(float.NaN));
			this.cssNode.SetMargin(CSSEdge.Left, this.styles.marginLeft.GetSpecifiedValueOrDefault(float.NaN));
			this.cssNode.SetMargin(CSSEdge.Top, this.styles.marginTop.GetSpecifiedValueOrDefault(float.NaN));
			this.cssNode.SetMargin(CSSEdge.Right, this.styles.marginRight.GetSpecifiedValueOrDefault(float.NaN));
			this.cssNode.SetMargin(CSSEdge.Bottom, this.styles.marginBottom.GetSpecifiedValueOrDefault(float.NaN));
			this.cssNode.SetPadding(CSSEdge.Left, this.styles.paddingLeft.GetSpecifiedValueOrDefault(float.NaN));
			this.cssNode.SetPadding(CSSEdge.Top, this.styles.paddingTop.GetSpecifiedValueOrDefault(float.NaN));
			this.cssNode.SetPadding(CSSEdge.Right, this.styles.paddingRight.GetSpecifiedValueOrDefault(float.NaN));
			this.cssNode.SetPadding(CSSEdge.Bottom, this.styles.paddingBottom.GetSpecifiedValueOrDefault(float.NaN));
			this.cssNode.SetBorder(CSSEdge.Left, this.styles.borderLeft.GetSpecifiedValueOrDefault(float.NaN));
			this.cssNode.SetBorder(CSSEdge.Top, this.styles.borderTop.GetSpecifiedValueOrDefault(float.NaN));
			this.cssNode.SetBorder(CSSEdge.Right, this.styles.borderRight.GetSpecifiedValueOrDefault(float.NaN));
			this.cssNode.SetBorder(CSSEdge.Bottom, this.styles.borderBottom.GetSpecifiedValueOrDefault(float.NaN));
			this.cssNode.Width = this.styles.width.GetSpecifiedValueOrDefault(float.NaN);
			this.cssNode.Height = this.styles.height.GetSpecifiedValueOrDefault(float.NaN);
			PositionType value = (PositionType)this.styles.positionType.value;
			if (value != PositionType.Absolute && value != PositionType.Manual)
			{
				if (value == PositionType.Relative)
				{
					this.cssNode.PositionType = CSSPositionType.Relative;
				}
			}
			else
			{
				this.cssNode.PositionType = CSSPositionType.Absolute;
			}
			this.cssNode.Overflow = (CSSOverflow)this.styles.overflow.value;
			this.cssNode.AlignSelf = (CSSAlign)this.styles.alignSelf.value;
			this.cssNode.MaxWidth = this.styles.maxWidth.GetSpecifiedValueOrDefault(float.NaN);
			this.cssNode.MaxHeight = this.styles.maxHeight.GetSpecifiedValueOrDefault(float.NaN);
			this.cssNode.MinWidth = this.styles.minWidth.GetSpecifiedValueOrDefault(float.NaN);
			this.cssNode.MinHeight = this.styles.minHeight.GetSpecifiedValueOrDefault(float.NaN);
			this.cssNode.FlexDirection = (CSSFlexDirection)this.styles.flexDirection.value;
			this.cssNode.AlignContent = (CSSAlign)this.styles.alignContent.GetSpecifiedValueOrDefault(1);
			this.cssNode.AlignItems = (CSSAlign)this.styles.alignItems.GetSpecifiedValueOrDefault(4);
			this.cssNode.JustifyContent = (CSSJustify)this.styles.justifyContent.value;
			this.cssNode.Wrap = (CSSWrap)this.styles.flexWrap.value;
			this.Dirty(ChangeType.Layout);
		}

		// Token: 0x1400002B RID: 43
		// (add) Token: 0x060034E8 RID: 13544 RVA: 0x00056454 File Offset: 0x00054654
		// (remove) Token: 0x060034E9 RID: 13545 RVA: 0x0005648C File Offset: 0x0005468C
		[field: DebuggerBrowsable(DebuggerBrowsableState.Never)]
		internal event OnStylesResolved onStylesResolved;

		// Token: 0x060034EA RID: 13546 RVA: 0x000564C4 File Offset: 0x000546C4
		internal void SetSharedStyles(VisualElementStyles styles)
		{
			Debug.Assert(styles.isShared);
			this.ClearDirty(ChangeType.Styles | ChangeType.StylesPath);
			if (styles != this.m_Styles)
			{
				if (!this.m_Styles.isShared)
				{
					this.m_Styles.Apply(styles, StylePropertyApplyMode.CopyIfNotInline);
				}
				else
				{
					this.m_Styles = styles;
				}
				if (this.onStylesResolved != null)
				{
					this.onStylesResolved(this.m_Styles);
				}
				this.OnStylesResolved(this.m_Styles);
				this.Dirty(ChangeType.Repaint);
			}
		}

		// Token: 0x060034EB RID: 13547 RVA: 0x00056558 File Offset: 0x00054758
		internal void EnsureInlineStyles()
		{
			if (this.m_Styles.isShared)
			{
				this.m_Styles = new VisualElementStyles(this.m_Styles, false);
			}
		}

		// Token: 0x060034EC RID: 13548 RVA: 0x00056580 File Offset: 0x00054780
		public void ResetPositionProperties()
		{
			if (this.m_Styles != null && !this.m_Styles.isShared)
			{
				this.m_Styles.positionType = Style<int>.nil;
				this.m_Styles.marginLeft = Style<float>.nil;
				this.m_Styles.marginRight = Style<float>.nil;
				this.m_Styles.marginBottom = Style<float>.nil;
				this.m_Styles.marginTop = Style<float>.nil;
				this.m_Styles.positionLeft = Style<float>.nil;
				this.m_Styles.positionTop = Style<float>.nil;
				this.m_Styles.positionRight = Style<float>.nil;
				this.m_Styles.positionBottom = Style<float>.nil;
				this.m_Styles.width = Style<float>.nil;
				this.m_Styles.height = Style<float>.nil;
				this.Dirty(ChangeType.Styles);
			}
		}

		// Token: 0x060034ED RID: 13549 RVA: 0x00056668 File Offset: 0x00054868
		public override string ToString()
		{
			return string.Concat(new object[] { this.name, " ", this.position, " global rect: ", this.globalBound });
		}

		// Token: 0x060034EE RID: 13550 RVA: 0x000566C0 File Offset: 0x000548C0
		internal IEnumerable<string> GetClasses()
		{
			return this.m_ClassList;
		}

		// Token: 0x060034EF RID: 13551 RVA: 0x000566DC File Offset: 0x000548DC
		public void ClearClassList()
		{
			if (this.m_ClassList != null && this.m_ClassList.Count > 0)
			{
				this.m_ClassList.Clear();
				this.Dirty(ChangeType.Styles);
			}
		}

		// Token: 0x060034F0 RID: 13552 RVA: 0x00056710 File Offset: 0x00054910
		public void AddToClassList(string className)
		{
			if (this.m_ClassList == null)
			{
				this.m_ClassList = new HashSet<string>();
			}
			if (this.m_ClassList.Add(className))
			{
				this.Dirty(ChangeType.Styles);
			}
		}

		// Token: 0x060034F1 RID: 13553 RVA: 0x00056744 File Offset: 0x00054944
		public void RemoveFromClassList(string className)
		{
			if (this.m_ClassList != null && this.m_ClassList.Remove(className))
			{
				this.Dirty(ChangeType.Styles);
			}
		}

		// Token: 0x060034F2 RID: 13554 RVA: 0x0005676C File Offset: 0x0005496C
		public bool ClassListContains(string cls)
		{
			return this.m_ClassList != null && this.m_ClassList.Contains(cls);
		}

		// Token: 0x04000B17 RID: 2839
		private static uint s_NextId;

		// Token: 0x04000B18 RID: 2840
		private string m_Name;

		// Token: 0x04000B19 RID: 2841
		private HashSet<string> m_ClassList;

		// Token: 0x04000B1A RID: 2842
		private string m_TypeName;

		// Token: 0x04000B1B RID: 2843
		private string m_FullTypeName;

		// Token: 0x04000B1D RID: 2845
		private RenderData m_RenderData;

		// Token: 0x04000B1E RID: 2846
		internal Matrix4x4 m_Transform = Matrix4x4.identity;

		// Token: 0x04000B1F RID: 2847
		private Rect m_Position;

		// Token: 0x04000B20 RID: 2848
		private PseudoStates m_PseudoStates;

		// Token: 0x04000B21 RID: 2849
		private VisualContainer m_Parent;

		// Token: 0x04000B26 RID: 2854
		internal VisualElementStyles m_Styles = VisualElementStyles.none;

		// Token: 0x04000B27 RID: 2855
		private List<IManipulator> m_Manipulators = new List<IManipulator>();

		// Token: 0x04000B28 RID: 2856
		internal readonly uint controlid;

		// Token: 0x04000B29 RID: 2857
		private ChangeType changesNeeded;

		// Token: 0x04000B2C RID: 2860
		[SerializeField]
		private string m_Text;

		// Token: 0x04000B2D RID: 2861
		[SerializeField]
		private string m_Tooltip;

		// Token: 0x04000B2E RID: 2862
		protected const int DefaultAlignContent = 1;

		// Token: 0x04000B2F RID: 2863
		protected const int DefaultAlignItems = 4;

		// Token: 0x0200035C RID: 860
		public enum MeasureMode
		{
			// Token: 0x04000B32 RID: 2866
			Undefined,
			// Token: 0x04000B33 RID: 2867
			Exactly,
			// Token: 0x04000B34 RID: 2868
			AtMost
		}
	}
}