using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.SymbolStore;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Xml;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using Il2CppInterop.Common;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using Mono.CSharp;
using Mono.CSharp.IL2CPP;
using Mono.CSharp.Linq;
using Mono.CSharp.Nullable;
using Mono.CSharp.yyParser;
using Mono.CSharp.yydebug;
using Mono.CompilerServices.SymbolWriter;
using MonoMod.RuntimeDetour;
using Tomlet;
using Tomlet.Attributes;
using Tomlet.Exceptions;
using Tomlet.Models;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityExplorer.CSConsole;
using UnityExplorer.CSConsole.Lexers;
using UnityExplorer.CacheObject;
using UnityExplorer.CacheObject.IValues;
using UnityExplorer.CacheObject.Views;
using UnityExplorer.Config;
using UnityExplorer.Hooks;
using UnityExplorer.Inspectors;
using UnityExplorer.Inspectors.MouseInspectors;
using UnityExplorer.Loader.BIE;
using UnityExplorer.ObjectExplorer;
using UnityExplorer.Runtime;
using UnityExplorer.UI;
using UnityExplorer.UI.Panels;
using UnityExplorer.UI.Widgets;
using UnityExplorer.UI.Widgets.AutoComplete;
using UniverseLib;
using UniverseLib.Config;
using UniverseLib.Input;
using UniverseLib.Runtime;
using UniverseLib.UI;
using UniverseLib.UI.Models;
using UniverseLib.UI.ObjectPool;
using UniverseLib.UI.Panels;
using UniverseLib.UI.Widgets;
using UniverseLib.UI.Widgets.ButtonList;
using UniverseLib.UI.Widgets.ScrollView;
using UniverseLib.Utility;

[assembly: AssemblyTitle("UnityExplorer")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyCompany("Sinai, yukieiji")]
[assembly: Guid("b21dbde3-5d6f-4726-93ab-cc3cc68bae7d")]
[assembly: AssemblyFileVersion("4.12.3")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: ComVisible(false)]
[assembly: AssemblyProduct("UnityExplorer")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("4.12.3.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<b4aa4dc3-257c-4023-be86-077a1b202459>Embedded]
	internal sealed class <b4aa4dc3-257c-4023-be86-077a1b202459>EmbeddedAttribute : System.Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[<b4aa4dc3-257c-4023-be86-077a1b202459>Embedded]
	[CompilerGenerated]
	internal sealed class <9ced412d-a286-472d-aa8e-ac6db7941b78>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <9ced412d-a286-472d-aa8e-ac6db7941b78>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <9ced412d-a286-472d-aa8e-ac6db7941b78>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	[<b4aa4dc3-257c-4023-be86-077a1b202459>Embedded]
	internal sealed class <f53caacd-7f86-4d3a-91d0-b8db8ecef87f>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <f53caacd-7f86-4d3a-91d0-b8db8ecef87f>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[<b4aa4dc3-257c-4023-be86-077a1b202459>Embedded]
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace UnityExplorer
{
	public class ExplorerBehaviour : MonoBehaviour
	{
		internal bool quitting;

		internal static ExplorerBehaviour Instance { get; private set; }

		public ExplorerBehaviour(IntPtr ptr)
			: base(ptr)
		{
		}

		internal static void Setup()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			ClassInjector.RegisterTypeInIl2Cpp<ExplorerBehaviour>();
			GameObject val = new GameObject("ExplorerBehaviour");
			Object.DontDestroyOnLoad((Object)(object)val);
			((Object)val).hideFlags = (HideFlags)61;
			Instance = val.AddComponent<ExplorerBehaviour>();
		}

		internal void Update()
		{
			ExplorerCore.Update();
		}

		internal void OnDestroy()
		{
			OnApplicationQuit();
		}

		internal void OnApplicationQuit()
		{
			if (!quitting)
			{
				quitting = true;
				if (Object.op_Implicit((Object)(object)UIManager.UIRoot))
				{
					TryDestroy(((Component)UIManager.UIRoot.transform.root).gameObject);
				}
				object? value = typeof(Universe).Assembly.GetType("UniverseLib.UniversalBehaviour").GetProperty("Instance", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null, null);
				TryDestroy(((Component)((value is Component) ? value : null)).gameObject);
				TryDestroy(((Component)this).gameObject);
			}
		}

		internal void TryDestroy(GameObject obj)
		{
			try
			{
				if (Object.op_Implicit((Object)(object)obj))
				{
					Object.Destroy((Object)(object)obj);
				}
			}
			catch (Exception ex)
			{
				ExplorerCore.LogError("Destroy Error!! " + ex.Message);
			}
		}
	}
	public static class ExplorerCore
	{
		public const string NAME = "UnityExplorer";

		public const string VERSION = "4.12.3";

		public const string AUTHOR = "Sinai, yukieiji";

		public const string GUID = "com.sinai.unityexplorer";

		public const string DEFAULT_EXPLORER_FOLDER_NAME = "sinai-dev-UnityExplorer";

		public static IExplorerLoader Loader { get; private set; }

		public static string ExplorerFolder => Path.Combine(Loader.ExplorerFolderDestination, Loader.ExplorerFolderName);

		public static Harmony Harmony { get; } = new Harmony("com.sinai.unityexplorer");


		public static void Init(IExplorerLoader loader)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			if (Loader != null)
			{
				throw new Exception("UnityExplorer is already loaded.");
			}
			Loader = loader;
			Log("UnityExplorer 4.12.3 initializing...");
			CheckLegacyExplorerFolder();
			Directory.CreateDirectory(ExplorerFolder);
			ConfigManager.Init(Loader.ConfigHandler);
			Universe.Init(ConfigManager.Startup_Delay_Time.Value, (Action)LateInit, (Action<string, LogType>)Log, new UniverseLibConfig
			{
				Disable_EventSystem_Override = ConfigManager.Disable_EventSystem_Override.Value,
				Force_Unlock_Mouse = ConfigManager.Force_Unlock_Mouse.Value,
				Unhollowed_Modules_Folder = loader.UnhollowedModulesFolder
			});
			UERuntimeHelper.Init();
			ExplorerBehaviour.Setup();
			UnityCrashPrevention.Init();
		}

		private static void LateInit()
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			SceneHandler.Init();
			Log("Creating UI...");
			UIManager.InitUI();
			Log($"{"UnityExplorer"} {"4.12.3"} ({Universe.Context}) initialized.");
		}

		internal static void Update()
		{
			ExplorerKeybind.Update();
		}

		public static void Log(object message)
		{
			Log(message, (LogType)3);
		}

		public static void LogWarning(object message)
		{
			Log(message, (LogType)2);
		}

		public static void LogError(object message)
		{
			Log(message, (LogType)0);
		}

		public static void LogUnity(object message, LogType logType)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (ConfigManager.Log_Unity_Debug.Value)
			{
				Log($"[Unity] {message}", logType);
			}
		}

		private static void Log(object message, LogType logType)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected I4, but got Unknown
			string text = message?.ToString() ?? "";
			LogPanel.Log(text, logType);
			switch ((int)logType)
			{
			case 1:
			case 3:
				Loader.OnLogMessage(text);
				break;
			case 2:
				Loader.OnLogWarning(text);
				break;
			case 0:
			case 4:
				Loader.OnLogError(text);
				break;
			}
		}

		private static void CheckLegacyExplorerFolder()
		{
			string text = Path.Combine(Loader.ExplorerFolderDestination, "UnityExplorer");
			if (!Directory.Exists(text))
			{
				return;
			}
			LogWarning("Attempting to migrate old 'UnityExplorer/' folder to 'sinai-dev-UnityExplorer/'...");
			if (!Directory.Exists(ExplorerFolder))
			{
				try
				{
					Directory.Move(text, ExplorerFolder);
					Log("Migrated successfully.");
					return;
				}
				catch (Exception value)
				{
					LogWarning($"Exception migrating folder: {value}");
					return;
				}
			}
			try
			{
				CopyAll(new DirectoryInfo(text), new DirectoryInfo(ExplorerFolder));
				Directory.Delete(text, recursive: true);
				Log("Migrated successfully.");
			}
			catch (Exception value2)
			{
				LogWarning($"Exception migrating folder: {value2}");
			}
		}

		public static void CopyAll(DirectoryInfo source, DirectoryInfo target)
		{
			Directory.CreateDirectory(target.FullName);
			FileInfo[] files = source.GetFiles();
			foreach (FileInfo fileInfo in files)
			{
				fileInfo.MoveTo(Path.Combine(target.ToString(), fileInfo.Name));
			}
			DirectoryInfo[] directories = source.GetDirectories();
			foreach (DirectoryInfo directoryInfo in directories)
			{
				DirectoryInfo target2 = target.CreateSubdirectory(directoryInfo.Name);
				CopyAll(directoryInfo, target2);
			}
		}
	}
	public static class ExplorerKeybind
	{
		public static void Update()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (InputManager.GetKeyDown(ConfigManager.Master_Toggle.Value))
			{
				UIManager.ShowMenu = !UIManager.ShowMenu;
			}
			TimeScaleKeyBindUpdate();
		}

		private static void TimeScaleKeyBindUpdate()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			TimeScaleWidget instance = TimeScaleWidget.Instance;
			if (instance != null)
			{
				if (InputManager.GetKeyDown(ConfigManager.TIME_SCALE_TOGGLE.Value))
				{
					instance.OnPauseButtonClicked();
				}
				if (InputManager.GetKeyDown(ConfigManager.LOCK_TIME_SCALE_TO_ZERO.Value))
				{
					instance.LockTo(0f);
				}
				if (InputManager.GetKeyDown(ConfigManager.LOCK_TIME_SCALE_TO_NORMAL.Value))
				{
					instance.LockTo(1f);
				}
				if (InputManager.GetKeyDown(ConfigManager.LOCK_TIME_SCALE_TO_HALF.Value))
				{
					instance.LockTo(instance.DesiredTime * 0.5f);
				}
				if (InputManager.GetKeyDown(ConfigManager.LOCK_TIME_SCALE_TO_DOUBLE.Value))
				{
					instance.LockTo(instance.DesiredTime * 2f);
				}
			}
		}
	}
	public static class InspectorManager
	{
		public static readonly List<InspectorBase> Inspectors = new List<InspectorBase>();

		private static InspectorBase lastActiveInspector;

		public static float PanelWidth;

		public static InspectorBase ActiveInspector { get; private set; }

		public static event Action OnInspectedTabsChanged;

		public static void Inspect(object obj, CacheObjectBase parent = null)
		{
			if (UnityHelpers.IsNullOrDestroyed(obj, true))
			{
				return;
			}
			obj = ReflectionExtensions.TryCast(obj);
			if (!TryFocusActiveInspector(obj))
			{
				if ((Object)(object)ReflectionExtensions.TryCast<GameObject>(obj) != (Object)null)
				{
					CreateInspector<GameObjectInspector>(obj);
				}
				else
				{
					CreateInspector<ReflectionInspector>(obj, staticReflection: false, parent);
				}
			}
		}

		public static void Inspect(Type type)
		{
			if (!TryFocusActiveInspector(type))
			{
				CreateInspector<ReflectionInspector>(type, staticReflection: true);
			}
		}

		private static bool TryFocusActiveInspector(object target)
		{
			foreach (InspectorBase inspector in Inspectors)
			{
				bool flag = false;
				if (target is Type type)
				{
					if (inspector.TargetType.FullName == type.FullName)
					{
						flag = true;
					}
				}
				else if (ReflectionExtensions.ReferenceEqual(inspector.Target, target))
				{
					flag = true;
				}
				if (flag)
				{
					UIManager.SetPanelActive(UIManager.Panels.Inspector, active: true);
					SetInspectorActive(inspector);
					return true;
				}
			}
			return false;
		}

		public static void SetInspectorActive(InspectorBase inspector)
		{
			UnsetActiveInspector();
			ActiveInspector = inspector;
			inspector.OnSetActive();
		}

		public static void UnsetActiveInspector()
		{
			if (ActiveInspector != null)
			{
				lastActiveInspector = ActiveInspector;
				ActiveInspector.OnSetInactive();
				ActiveInspector = null;
			}
		}

		public static void CloseAllTabs()
		{
			if (Inspectors.Any())
			{
				for (int num = Inspectors.Count - 1; num >= 0; num--)
				{
					Inspectors[num].CloseInspector();
				}
				Inspectors.Clear();
			}
			UIManager.SetPanelActive(UIManager.Panels.Inspector, active: false);
		}

		private static void CreateInspector<T>(object target, bool staticReflection = false, CacheObjectBase parent = null) where T : InspectorBase
		{
			T val = Pool<T>.Borrow();
			Inspectors.Add(val);
			val.Target = target;
			if (parent != null && parent.CanWrite && target.GetType().IsValueType && val is ReflectionInspector reflectionInspector)
			{
				reflectionInspector.ParentCacheObject = parent;
			}
			UIManager.SetPanelActive(UIManager.Panels.Inspector, active: true);
			val.UIRoot.transform.SetParent(InspectorPanel.Instance.ContentHolder.transform, false);
			if (val is ReflectionInspector reflectionInspector2)
			{
				reflectionInspector2.StaticOnly = staticReflection;
			}
			val.OnBorrowedFromPool(target);
			SetInspectorActive(val);
			InspectorManager.OnInspectedTabsChanged?.Invoke();
		}

		public static void ReleaseInspector<T>(T inspector) where T : InspectorBase
		{
			if (lastActiveInspector == inspector)
			{
				lastActiveInspector = null;
			}
			bool flag = ActiveInspector == inspector;
			int num = Inspectors.IndexOf(inspector);
			Inspectors.Remove(inspector);
			inspector.OnReturnToPool();
			Pool<T>.Return(inspector);
			if (flag)
			{
				ActiveInspector = null;
				if (lastActiveInspector != null)
				{
					SetInspectorActive(lastActiveInspector);
					lastActiveInspector = null;
				}
				else if (Inspectors.Any())
				{
					int index = Math.Min(Inspectors.Count - 1, Math.Max(0, num - 1));
					SetInspectorActive(Inspectors[index]);
				}
				else
				{
					UIManager.SetPanelActive(UIManager.Panels.Inspector, active: false);
				}
			}
			InspectorManager.OnInspectedTabsChanged?.Invoke();
		}

		internal static void Update()
		{
			for (int num = Inspectors.Count - 1; num >= 0; num--)
			{
				Inspectors[num].Update();
			}
		}

		internal static void OnPanelResized(float width)
		{
			PanelWidth = width;
			foreach (InspectorBase inspector in Inspectors)
			{
				if (inspector is ReflectionInspector reflectionInspector)
				{
					reflectionInspector.SetLayouts();
				}
			}
		}
	}
	[BepInPlugin("com.sinai.unityexplorer", "UnityExplorer", "4.12.3")]
	public class ExplorerBepInPlugin : BasePlugin, IExplorerLoader
	{
		public static ExplorerBepInPlugin Instance;

		private const string IL2CPP_LIBS_FOLDER = "interop";

		private BepInExConfigHandler _configHandler;

		private static readonly Harmony s_harmony = new Harmony("com.sinai.unityexplorer");

		public ManualLogSource LogSource => ((BasePlugin)this).Log;

		public string UnhollowedModulesFolder => Path.Combine(Paths.BepInExRootPath, "interop");

		public ConfigHandler ConfigHandler => _configHandler;

		public Harmony HarmonyInstance => s_harmony;

		public string ExplorerFolderName => "sinai-dev-UnityExplorer";

		public string ExplorerFolderDestination => Paths.PluginPath;

		public Action<object> OnLogMessage => LogSource.LogMessage;

		public Action<object> OnLogWarning => LogSource.LogWarning;

		public Action<object> OnLogError => LogSource.LogError;

		private void Init()
		{
			Instance = this;
			_configHandler = new BepInExConfigHandler();
			ExplorerCore.Init(this);
		}

		public override void Load()
		{
			Init();
		}
	}
	public interface IExplorerLoader
	{
		string ExplorerFolderDestination { get; }

		string ExplorerFolderName { get; }

		string UnhollowedModulesFolder { get; }

		ConfigHandler ConfigHandler { get; }

		Action<object> OnLogMessage { get; }

		Action<object> OnLogWarning { get; }

		Action<object> OnLogError { get; }
	}
}
namespace UnityExplorer.UI
{
	public static class DisplayManager
	{
		private static Camera canvasCamera;

		public static int ActiveDisplayIndex { get; private set; }

		public static Display ActiveDisplay => ((Il2CppArrayBase<Display>)(object)Display.displays)[ActiveDisplayIndex];

		public static int Width => ActiveDisplay.renderingWidth;

		public static int Height => ActiveDisplay.renderingHeight;

		public static Vector3 MousePosition => Application.isEditor ? InputManager.MousePosition : Display.RelativeMouseAt(InputManager.MousePosition);

		public static bool MouseInTargetDisplay => MousePosition.z == (float)ActiveDisplayIndex;

		internal static void Init()
		{
			SetDisplay(ConfigManager.Target_Display.Value);
			ConfigElement<int> target_Display = ConfigManager.Target_Display;
			target_Display.OnValueChanged = (Action<int>)System.Delegate.Combine(target_Display.OnValueChanged, new Action<int>(SetDisplay));
		}

		public static void SetDisplay(int display)
		{
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			if (ActiveDisplayIndex == display)
			{
				return;
			}
			if (((Il2CppArrayBase<Display>)(object)Display.displays).Length <= display)
			{
				ExplorerCore.LogWarning($"Cannot set display index to {display} as there are not enough monitors connected!");
				if (ConfigManager.Target_Display.Value == display)
				{
					ConfigManager.Target_Display.Value = 0;
				}
				return;
			}
			ActiveDisplayIndex = display;
			ActiveDisplay.Activate();
			UIManager.UICanvas.targetDisplay = display;
			if (!Object.op_Implicit((Object)(object)Camera.main) || Camera.main.targetDisplay != display)
			{
				if (!Object.op_Implicit((Object)(object)canvasCamera))
				{
					canvasCamera = new GameObject("UnityExplorer_CanvasCamera").AddComponent<Camera>();
					Object.DontDestroyOnLoad((Object)(object)((Component)canvasCamera).gameObject);
					((Object)canvasCamera).hideFlags = (HideFlags)61;
				}
				canvasCamera.targetDisplay = display;
			}
			RuntimeHelper.StartCoroutine(FixPanels());
		}

		private static IEnumerator FixPanels()
		{
			yield return null;
			yield return null;
			foreach (UEPanel panel in UIManager.UIPanels.Values)
			{
				((PanelBase)panel).EnsureValidSize();
				((PanelBase)panel).EnsureValidPosition();
				((PanelBase)panel).Dragger.OnEndResize();
			}
		}
	}
	internal class ExplorerUIBase : UIBase
	{
		public ExplorerUIBase(string id, Action updateMethod)
			: base(id, updateMethod)
		{
		}

		protected override PanelManager CreatePanelManager()
		{
			return (PanelManager)(object)new UEPanelManager((UIBase)(object)this);
		}
	}
	public static class Notification
	{
		private static Text popupLabel;

		private static string _currentNotification;

		private static float _timeOfLastNotification;

		public static void Init()
		{
			ConstructUI();
		}

		public static void ShowMessage(string message)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			popupLabel.text = message;
			_currentNotification = message;
			_timeOfLastNotification = Time.realtimeSinceStartup;
			((Component)popupLabel).transform.localPosition = ((Transform)UIManager.UIRootRect).InverseTransformPoint(DisplayManager.MousePosition) + Vector3.up * 25f;
		}

		public static void Update()
		{
			if (_currentNotification != null && Time.realtimeSinceStartup - _timeOfLastNotification > 2f)
			{
				_currentNotification = null;
				popupLabel.text = "";
			}
		}

		private static void ConstructUI()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			popupLabel = UIFactory.CreateLabel(UIManager.UIRoot, "ClipboardNotification", "", (TextAnchor)4, default(Color), true, 14);
			((Graphic)popupLabel).rectTransform.sizeDelta = new Vector2(500f, 100f);
			((Component)popupLabel).gameObject.AddComponent<Outline>();
			CanvasGroup val = ((Component)popupLabel).gameObject.AddComponent<CanvasGroup>();
			val.blocksRaycasts = false;
		}
	}
	public class UEPanelManager : PanelManager
	{
		protected override Vector3 MousePosition => DisplayManager.MousePosition;

		protected override Vector2 ScreenDimensions => new Vector2((float)DisplayManager.Width, (float)DisplayManager.Height);

		protected override bool MouseInTargetDisplay => DisplayManager.MouseInTargetDisplay;

		public UEPanelManager(UIBase owner)
			: base(owner)
		{
		}

		internal void DoInvokeOnPanelsReordered()
		{
			((PanelManager)this).InvokeOnPanelsReordered();
		}

		protected override void SortDraggerHeirarchy()
		{
			((PanelManager)this).SortDraggerHeirarchy();
			if (!UIManager.Initializing && AutoCompleteModal.Instance != null)
			{
				base.draggerInstances.Remove(((PanelBase)AutoCompleteModal.Instance).Dragger);
				base.draggerInstances.Insert(0, ((PanelBase)AutoCompleteModal.Instance).Dragger);
			}
		}
	}
	public static class UIManager
	{
		public enum Panels
		{
			ObjectExplorer,
			Inspector,
			CSConsole,
			Options,
			ConsoleLog,
			AutoCompleter,
			UIInspectorResults,
			HookManager,
			Clipboard,
			Freecam
		}

		public enum VerticalAnchor
		{
			Top,
			Bottom
		}

		public static VerticalAnchor NavbarAnchor = VerticalAnchor.Top;

		internal static readonly Dictionary<Panels, UEPanel> UIPanels = new Dictionary<Panels, UEPanel>();

		public static RectTransform NavBarRect;

		public static GameObject NavbarTabButtonHolder;

		private static readonly Vector2 NAVBAR_DIMENSIONS = new Vector2(1020f, 35f);

		private static ButtonRef closeBtn;

		private static int lastScreenWidth;

		private static int lastScreenHeight;

		public static bool Initializing { get; internal set; } = true;


		internal static UIBase UiBase { get; private set; }

		public static GameObject UIRoot
		{
			get
			{
				UIBase uiBase = UiBase;
				return (uiBase != null) ? uiBase.RootObject : null;
			}
		}

		public static RectTransform UIRootRect { get; private set; }

		public static Canvas UICanvas { get; private set; }

		public static bool ShowMenu
		{
			get
			{
				return UiBase != null && UiBase.Enabled;
			}
			set
			{
				if (UiBase != null && Object.op_Implicit((Object)(object)UIRoot) && UiBase.Enabled != value)
				{
					UniversalUI.SetUIActive("com.sinai.unityexplorer", value);
					UniversalUI.SetUIActive(MouseInspector.UIBaseGUID, value);
				}
			}
		}

		internal static void InitUI()
		{
			UiBase = (UIBase)(object)UniversalUI.RegisterUI<ExplorerUIBase>("com.sinai.unityexplorer", (Action)Update);
			UIRootRect = UIRoot.GetComponent<RectTransform>();
			UICanvas = UIRoot.GetComponent<Canvas>();
			DisplayManager.Init();
			Display activeDisplay = DisplayManager.ActiveDisplay;
			lastScreenWidth = activeDisplay.renderingWidth;
			lastScreenHeight = activeDisplay.renderingHeight;
			CreateTopNavBar();
			UIPanels.Add(Panels.AutoCompleter, new AutoCompleteModal(UiBase));
			UIPanels.Add(Panels.ObjectExplorer, new ObjectExplorerPanel(UiBase));
			UIPanels.Add(Panels.Inspector, new InspectorPanel(UiBase));
			UIPanels.Add(Panels.CSConsole, new CSConsolePanel(UiBase));
			UIPanels.Add(Panels.HookManager, new HookManagerPanel(UiBase));
			UIPanels.Add(Panels.Freecam, new FreeCamPanel(UiBase));
			UIPanels.Add(Panels.Clipboard, new ClipboardPanel(UiBase));
			UIPanels.Add(Panels.ConsoleLog, new LogPanel(UiBase));
			UIPanels.Add(Panels.Options, new OptionsPanel(UiBase));
			UIPanels.Add(Panels.UIInspectorResults, new MouseInspectorResultsPanel(UiBase));
			MouseInspector.inspectorUIBase = UniversalUI.RegisterUI(MouseInspector.UIBaseGUID, (Action)null);
			new MouseInspector(MouseInspector.inspectorUIBase);
			Notification.Init();
			ConsoleController.Init();
			foreach (Dropdown componentsInChild in UIRoot.GetComponentsInChildren<Dropdown>(true))
			{
				componentsInChild.RefreshShownValue();
			}
			Initializing = false;
			if (ConfigManager.Hide_On_Startup.Value)
			{
				ShowMenu = false;
			}
		}

		public static void Update()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)UIRoot) && !MouseInspector.Instance.TryUpdate())
			{
				Notification.Update();
				if (InputManager.GetKeyDown(ConfigManager.Force_Unlock_Toggle.Value))
				{
					ConfigManager.Force_Unlock_Mouse = !ConfigManager.Force_Unlock_Mouse;
				}
				TimeScaleWidget.Instance?.Update();
				Display activeDisplay = DisplayManager.ActiveDisplay;
				if (activeDisplay.renderingWidth != lastScreenWidth || activeDisplay.renderingHeight != lastScreenHeight)
				{
					OnScreenDimensionsChanged();
				}
			}
		}

		public static UEPanel GetPanel(Panels panel)
		{
			return UIPanels[panel];
		}

		public static T GetPanel<T>(Panels panel) where T : UEPanel
		{
			return (T)UIPanels[panel];
		}

		public static void TogglePanel(Panels panel)
		{
			UEPanel panel2 = GetPanel(panel);
			SetPanelActive(panel, !((UIModel)panel2).Enabled);
		}

		public static void SetPanelActive(Panels panelType, bool active)
		{
			((UIModel)GetPanel(panelType)).SetActive(active);
		}

		public static void SetPanelActive(UEPanel panel, bool active)
		{
			((UIModel)panel).SetActive(active);
		}

		public static void SetNavBarAnchor()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			switch (NavbarAnchor)
			{
			case VerticalAnchor.Top:
				NavBarRect.anchorMin = new Vector2(0.5f, 1f);
				NavBarRect.anchorMax = new Vector2(0.5f, 1f);
				NavBarRect.anchoredPosition = new Vector2(NavBarRect.anchoredPosition.x, 0f);
				NavBarRect.sizeDelta = NAVBAR_DIMENSIONS;
				break;
			case VerticalAnchor.Bottom:
				NavBarRect.anchorMin = new Vector2(0.5f, 0f);
				NavBarRect.anchorMax = new Vector2(0.5f, 0f);
				NavBarRect.anchoredPosition = new Vector2(NavBarRect.anchoredPosition.x, 35f);
				NavBarRect.sizeDelta = NAVBAR_DIMENSIONS;
				break;
			}
		}

		private static void OnScreenDimensionsChanged()
		{
			Display activeDisplay = DisplayManager.ActiveDisplay;
			lastScreenWidth = activeDisplay.renderingWidth;
			lastScreenHeight = activeDisplay.renderingHeight;
			foreach (KeyValuePair<Panels, UEPanel> uIPanel in UIPanels)
			{
				((PanelBase)uIPanel.Value).EnsureValidSize();
				((PanelBase)uIPanel.Value).EnsureValidPosition();
				((PanelBase)uIPanel.Value).Dragger.OnEndResize();
			}
		}

		private static void OnCloseButtonClicked()
		{
			ShowMenu = false;
		}

		private static void Master_Toggle_OnValueChanged(KeyCode val)
		{
			closeBtn.ButtonText.text = ((object)(KeyCode)(ref val)).ToString();
		}

		private static void CreateTopNavBar()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val2 = UIFactory.CreateUIObject("MainNavbar", UIRoot, default(Vector2));
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val2, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)4, (int?)4, (int?)4, (int?)4, (TextAnchor?)(TextAnchor)4);
			((Graphic)val2.AddComponent<Image>()).color = new Color(0.1f, 0.1f, 0.1f);
			NavBarRect = val2.GetComponent<RectTransform>();
			NavBarRect.pivot = new Vector2(0.5f, 1f);
			NavbarAnchor = ConfigManager.Main_Navbar_Anchor.Value;
			SetNavBarAnchor();
			ConfigElement<VerticalAnchor> main_Navbar_Anchor = ConfigManager.Main_Navbar_Anchor;
			main_Navbar_Anchor.OnValueChanged = (Action<VerticalAnchor>)System.Delegate.Combine(main_Navbar_Anchor.OnValueChanged, (Action<VerticalAnchor>)delegate(VerticalAnchor val)
			{
				NavbarAnchor = val;
				SetNavBarAnchor();
			});
			string text = "UE <i><color=grey>4.12.3</color></i>";
			Text val3 = UIFactory.CreateLabel(val2, "Title", text, (TextAnchor)4, default(Color), true, 14);
			GameObject gameObject = ((Component)val3).gameObject;
			int? num = 75;
			int? num2 = 0;
			UIFactory.SetLayoutElement(gameObject, num, (int?)null, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			NavbarTabButtonHolder = UIFactory.CreateUIObject("NavTabButtonHolder", val2, default(Vector2));
			GameObject navbarTabButtonHolder = NavbarTabButtonHolder;
			num2 = 25;
			int? num3 = 999;
			int? num4 = 999;
			UIFactory.SetLayoutElement(navbarTabButtonHolder, (int?)null, num2, num4, num3, (int?)null, (int?)null, (bool?)null);
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(NavbarTabButtonHolder, (bool?)false, (bool?)true, (bool?)true, (bool?)true, (int?)4, (int?)2, (int?)2, (int?)2, (int?)2, (TextAnchor?)null);
			TimeScaleWidget.SetUp(val2);
			GameObject val4 = UIFactory.CreateUIObject("Spacer", val2, default(Vector2));
			UIFactory.SetLayoutElement(val4, (int?)15, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			KeyCode value = ConfigManager.Master_Toggle.Value;
			closeBtn = UIFactory.CreateButton(val2, "CloseButton", ((object)(KeyCode)(ref value)).ToString(), (Color?)null);
			GameObject gameObject2 = ((Component)closeBtn.Component).gameObject;
			num4 = 25;
			UIFactory.SetLayoutElement(gameObject2, (int?)60, num4, (int?)0, (int?)null, (int?)null, (int?)null, (bool?)null);
			RuntimeHelper.SetColorBlock((Selectable)(object)closeBtn.Component, (Color?)new Color(0.63f, 0.32f, 0.31f), (Color?)new Color(0.81f, 0.25f, 0.2f), (Color?)new Color(0.6f, 0.18f, 0.16f), (Color?)null);
			ConfigElement<KeyCode> master_Toggle = ConfigManager.Master_Toggle;
			master_Toggle.OnValueChanged = (Action<KeyCode>)System.Delegate.Combine(master_Toggle.OnValueChanged, new Action<KeyCode>(Master_Toggle_OnValueChanged));
			ButtonRef obj = closeBtn;
			obj.OnClick = (Action)System.Delegate.Combine(obj.OnClick, new Action(OnCloseButtonClicked));
		}
	}
}
namespace UnityExplorer.UI.Widgets
{
	public abstract class BaseArgumentHandler : IPooledObject
	{
		internal Text argNameLabel;

		internal InputFieldRef inputField;

		internal TypeCompleter typeCompleter;

		public float DefaultHeight => 25f;

		public GameObject UIRoot { get; set; }

		public abstract void CreateSpecialContent();

		public GameObject CreateContent(GameObject parent)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			UIRoot = UIFactory.CreateUIObject("ArgRow", parent, default(Vector2));
			GameObject uIRoot = UIRoot;
			int? num = 25;
			int? num2 = 50;
			UIFactory.SetLayoutElement(uIRoot, (int?)50, num, (int?)9999, num2, (int?)null, (int?)null, (bool?)null);
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(UIRoot, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
			UIRoot.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			argNameLabel = UIFactory.CreateLabel(UIRoot, "ArgLabel", "not set", (TextAnchor)3, default(Color), true, 14);
			GameObject gameObject = ((Component)argNameLabel).gameObject;
			int? num3 = 40;
			num2 = 90;
			UIFactory.SetLayoutElement(gameObject, num3, (int?)25, num2, (int?)50, (int?)null, (int?)null, (bool?)null);
			argNameLabel.horizontalOverflow = (HorizontalWrapMode)0;
			inputField = UIFactory.CreateInputField(UIRoot, "InputField", "...");
			GameObject uIRoot2 = ((UIModel)inputField).UIRoot;
			num2 = 25;
			num = 50;
			UIFactory.SetLayoutElement(uIRoot2, (int?)100, num2, (int?)1000, num, (int?)null, (int?)null, (bool?)null);
			inputField.Component.lineType = (LineType)2;
			((UIModel)inputField).UIRoot.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			typeCompleter = new TypeCompleter(typeof(object), inputField)
			{
				Enabled = false
			};
			CreateSpecialContent();
			return UIRoot;
		}
	}
	public class EvaluateWidget : IPooledObject
	{
		private ParameterInfo[] parameters;

		internal GameObject parametersHolder;

		private ParameterHandler[] paramHandlers;

		private Type[] genericArguments;

		internal GameObject genericArgumentsHolder;

		private GenericArgumentHandler[] genericHandlers;

		public CacheMember Owner { get; set; }

		public GameObject UIRoot { get; set; }

		public float DefaultHeight => -1f;

		public void OnBorrowedFromPool(CacheMember owner)
		{
			Owner = owner;
			parameters = owner.Arguments;
			paramHandlers = new ParameterHandler[parameters.Length];
			genericArguments = owner.GenericArguments;
			genericHandlers = new GenericArgumentHandler[genericArguments.Length];
			SetArgRows();
			UIRoot.SetActive(true);
		}

		public void OnReturnToPool()
		{
			ParameterHandler[] array = paramHandlers;
			foreach (ParameterHandler parameterHandler in array)
			{
				parameterHandler.OnReturned();
				Pool<ParameterHandler>.Return(parameterHandler);
			}
			paramHandlers = null;
			GenericArgumentHandler[] array2 = genericHandlers;
			foreach (GenericArgumentHandler genericArgumentHandler in array2)
			{
				genericArgumentHandler.OnReturned();
				Pool<GenericArgumentHandler>.Return(genericArgumentHandler);
			}
			genericHandlers = null;
			Owner = null;
		}

		public Type[] TryParseGenericArguments()
		{
			Type[] array = new Type[genericArguments.Length];
			for (int i = 0; i < genericArguments.Length; i++)
			{
				array[i] = genericHandlers[i].Evaluate();
			}
			return array;
		}

		public object[] TryParseArguments()
		{
			if (!parameters.Any())
			{
				return ArgumentUtility.EmptyArgs;
			}
			object[] array = new object[parameters.Length];
			for (int i = 0; i < parameters.Length; i++)
			{
				array[i] = paramHandlers[i].Evaluate();
			}
			return array;
		}

		private void SetArgRows()
		{
			if (genericArguments.Any())
			{
				genericArgumentsHolder.SetActive(true);
				SetGenericRows();
			}
			else
			{
				genericArgumentsHolder.SetActive(false);
			}
			if (parameters.Any())
			{
				parametersHolder.SetActive(true);
				SetNormalArgRows();
			}
			else
			{
				parametersHolder.SetActive(false);
			}
		}

		private void SetGenericRows()
		{
			for (int i = 0; i < genericArguments.Length; i++)
			{
				Type genericArgument = genericArguments[i];
				GenericArgumentHandler genericArgumentHandler = (genericHandlers[i] = Pool<GenericArgumentHandler>.Borrow());
				genericArgumentHandler.UIRoot.transform.SetParent(genericArgumentsHolder.transform, false);
				genericArgumentHandler.OnBorrowed(genericArgument);
			}
		}

		private void SetNormalArgRows()
		{
			for (int i = 0; i < parameters.Length; i++)
			{
				ParameterInfo paramInfo = parameters[i];
				ParameterHandler parameterHandler = (paramHandlers[i] = Pool<ParameterHandler>.Borrow());
				parameterHandler.UIRoot.transform.SetParent(parametersHolder.transform, false);
				parameterHandler.OnBorrowed(paramInfo);
			}
		}

		public GameObject CreateContent(GameObject parent)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fd: Unknown result type (might be due to invalid IL or missing references)
			UIRoot = UIFactory.CreateVerticalGroup(parent, "EvaluateWidget", false, false, true, true, 3, new Vector4(2f, 2f, 2f, 2f), new Color(0.15f, 0.15f, 0.15f), (TextAnchor?)null);
			GameObject uIRoot = UIRoot;
			int? num = 50;
			int? num2 = 9999;
			UIFactory.SetLayoutElement(uIRoot, num, (int?)50, num2, (int?)800, (int?)null, (int?)null, (bool?)null);
			genericArgumentsHolder = UIFactory.CreateUIObject("GenericHolder", UIRoot, default(Vector2));
			GameObject obj = genericArgumentsHolder;
			num2 = 1000;
			UIFactory.SetLayoutElement(obj, (int?)null, (int?)null, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			Text val = UIFactory.CreateLabel(genericArgumentsHolder, "GenericsTitle", "Generic Arguments", (TextAnchor)3, default(Color), true, 14);
			GameObject gameObject = ((Component)val).gameObject;
			num2 = 25;
			int? num3 = 1000;
			UIFactory.SetLayoutElement(gameObject, (int?)null, num2, num3, (int?)null, (int?)null, (int?)null, (bool?)null);
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(genericArgumentsHolder, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)3, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
			GameObject obj2 = genericArgumentsHolder;
			num3 = 25;
			num2 = 750;
			UIFactory.SetLayoutElement(obj2, (int?)50, num3, (int?)9999, num2, (int?)null, (int?)null, (bool?)null);
			parametersHolder = UIFactory.CreateUIObject("ArgHolder", UIRoot, default(Vector2));
			GameObject obj3 = parametersHolder;
			num2 = 1000;
			UIFactory.SetLayoutElement(obj3, (int?)null, (int?)null, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			Text val2 = UIFactory.CreateLabel(parametersHolder, "ArgsTitle", "Arguments", (TextAnchor)3, default(Color), true, 14);
			GameObject gameObject2 = ((Component)val2).gameObject;
			num2 = 25;
			num3 = 1000;
			UIFactory.SetLayoutElement(gameObject2, (int?)null, num2, num3, (int?)null, (int?)null, (int?)null, (bool?)null);
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(parametersHolder, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)3, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
			GameObject obj4 = parametersHolder;
			num3 = 25;
			num2 = 750;
			UIFactory.SetLayoutElement(obj4, (int?)50, num3, (int?)9999, num2, (int?)null, (int?)null, (bool?)null);
			ButtonRef val3 = UIFactory.CreateButton(UIRoot, "EvaluateButton", "Evaluate", (Color?)new Color(0.2f, 0.2f, 0.2f));
			GameObject gameObject3 = ((Component)val3.Component).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject3, (int?)150, num2, (int?)0, (int?)null, (int?)null, (int?)null, (bool?)null);
			val3.OnClick = (Action)System.Delegate.Combine(val3.OnClick, (Action)delegate
			{
				Owner.EvaluateAndSetCell();
			});
			return UIRoot;
		}
	}
	public class GenericArgumentHandler : BaseArgumentHandler
	{
		private Type genericArgument;

		public void OnBorrowed(Type genericArgument)
		{
			this.genericArgument = genericArgument;
			typeCompleter.Enabled = true;
			typeCompleter.BaseType = this.genericArgument;
			typeCompleter.CacheTypes();
			Type[] genericParameterConstraints = this.genericArgument.GetGenericParameterConstraints();
			StringBuilder stringBuilder = new StringBuilder($"<color={"#92c470"}>{this.genericArgument.Name}</color>");
			for (int i = 0; i < genericParameterConstraints.Length; i++)
			{
				if (i == 0)
				{
					stringBuilder.Append(' ').Append('(');
				}
				else
				{
					stringBuilder.Append(',').Append(' ');
				}
				stringBuilder.Append(SignatureHighlighter.Parse(genericParameterConstraints[i], false, (MemberInfo)null));
				if (i + 1 == genericParameterConstraints.Length)
				{
					stringBuilder.Append(')');
				}
			}
			argNameLabel.text = stringBuilder.ToString();
		}

		public void OnReturned()
		{
			genericArgument = null;
			typeCompleter.Enabled = false;
			inputField.Text = "";
		}

		public Type Evaluate()
		{
			return ReflectionUtility.GetTypeByName(inputField.Text) ?? throw new Exception("Could not find any type by name '" + inputField.Text + "'!");
		}

		public override void CreateSpecialContent()
		{
		}
	}
	public class GenericConstructorWidget
	{
		private GenericArgumentHandler[] handlers;

		private Type[] currentGenericParameters;

		private Action<Type[]> currentOnSubmit;

		private Action currentOnCancel;

		public GameObject UIRoot;

		private Text Title;

		private GameObject ArgsHolder;

		public void Show(Action<Type[]> onSubmit, Action onCancel, Type genericTypeDefinition)
		{
			Title.text = "Setting generic arguments for " + SignatureHighlighter.Parse(genericTypeDefinition, false, (MemberInfo)null) + "...";
			OnShow(onSubmit, onCancel, genericTypeDefinition.GetGenericArguments());
		}

		public void Show(Action<Type[]> onSubmit, Action onCancel, MethodInfo genericMethodDefinition)
		{
			Title.text = "Setting generic arguments for " + SignatureHighlighter.ParseMethod(genericMethodDefinition) + "...";
			OnShow(onSubmit, onCancel, genericMethodDefinition.GetGenericArguments());
		}

		private void OnShow(Action<Type[]> onSubmit, Action onCancel, Type[] genericParameters)
		{
			currentOnSubmit = onSubmit;
			currentOnCancel = onCancel;
			SetGenericParameters(genericParameters);
		}

		private void SetGenericParameters(Type[] genericParameters)
		{
			currentGenericParameters = genericParameters;
			handlers = new GenericArgumentHandler[genericParameters.Length];
			for (int i = 0; i < genericParameters.Length; i++)
			{
				Type genericArgument = genericParameters[i];
				GenericArgumentHandler genericArgumentHandler = (handlers[i] = Pool<GenericArgumentHandler>.Borrow());
				genericArgumentHandler.UIRoot.transform.SetParent(ArgsHolder.transform, false);
				genericArgumentHandler.OnBorrowed(genericArgument);
			}
		}

		public void TrySubmit()
		{
			Type[] array = new Type[currentGenericParameters.Length];
			for (int i = 0; i < array.Length; i++)
			{
				GenericArgumentHandler genericArgumentHandler = handlers[i];
				Type type;
				try
				{
					type = genericArgumentHandler.Evaluate();
					if (type == null)
					{
						throw new Exception();
					}
				}
				catch
				{
					ExplorerCore.LogWarning("Generic argument '" + genericArgumentHandler.inputField.Text + "' is not a valid type.");
					return;
				}
				array[i] = type;
			}
			OnClose();
			currentOnSubmit(array);
		}

		public void Cancel()
		{
			OnClose();
			currentOnCancel?.Invoke();
		}

		private void OnClose()
		{
			if (handlers != null)
			{
				GenericArgumentHandler[] array = handlers;
				foreach (GenericArgumentHandler genericArgumentHandler in array)
				{
					genericArgumentHandler.OnReturned();
					Pool<GenericArgumentHandler>.Return(genericArgumentHandler);
				}
				handlers = null;
			}
		}

		internal void ConstructUI(GameObject parent)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			Vector4 val = new Vector4(5f, 5f, 5f, 5f);
			TextAnchor? val2 = (TextAnchor)4;
			UIRoot = UIFactory.CreateVerticalGroup(parent, "GenericArgsHandler", false, false, true, true, 5, val, default(Color), val2);
			GameObject uIRoot = UIRoot;
			int? num = 9999;
			int? num2 = 9999;
			UIFactory.SetLayoutElement(uIRoot, (int?)null, (int?)null, num, num2, (int?)null, (int?)null, (bool?)null);
			ButtonRef val3 = UIFactory.CreateButton(UIRoot, "SubmitButton", "Submit", (Color?)new Color(0.2f, 0.3f, 0.2f));
			GameObject gameObject = val3.GameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject, (int?)200, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			val3.OnClick = (Action)System.Delegate.Combine(val3.OnClick, new Action(TrySubmit));
			ButtonRef val4 = UIFactory.CreateButton(UIRoot, "CancelButton", "Cancel", (Color?)new Color(0.3f, 0.2f, 0.2f));
			GameObject gameObject2 = val4.GameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject2, (int?)200, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			val4.OnClick = (Action)System.Delegate.Combine(val4.OnClick, new Action(Cancel));
			Title = UIFactory.CreateLabel(UIRoot, "Title", "Generic Arguments", (TextAnchor)4, default(Color), true, 14);
			GameObject gameObject3 = ((Component)Title).gameObject;
			num2 = 25;
			num = 9999;
			UIFactory.SetLayoutElement(gameObject3, (int?)null, num2, num, (int?)null, (int?)null, (int?)null, (bool?)null);
			AutoSliderScrollbar val5 = default(AutoSliderScrollbar);
			GameObject val6 = UIFactory.CreateScrollView(UIRoot, "GenericArgsScrollView", ref ArgsHolder, ref val5, new Color(0.1f, 0.1f, 0.1f));
			num = 9999;
			num2 = 9999;
			UIFactory.SetLayoutElement(val6, (int?)null, (int?)null, num, num2, (int?)null, (int?)null, (bool?)null);
			GameObject argsHolder = ArgsHolder;
			num2 = 5;
			num = 5;
			int? num3 = 5;
			int? num4 = 5;
			UIFactory.SetLayoutGroup<VerticalLayoutGroup>(argsHolder, (bool?)null, (bool?)null, (bool?)null, (bool?)null, (int?)null, num2, num3, num, num4, (TextAnchor?)null);
		}
	}
	public class ParameterHandler : BaseArgumentHandler
	{
		private ParameterInfo paramInfo;

		private Type paramType;

		internal EnumCompleter enumCompleter;

		private ButtonRef enumHelperButton;

		private bool usingBasicLabel;

		private object basicValue;

		private GameObject basicLabelHolder;

		private Text basicLabel;

		private ButtonRef pasteButton;

		public void OnBorrowed(ParameterInfo paramInfo)
		{
			this.paramInfo = paramInfo;
			paramType = paramInfo.ParameterType;
			if (paramType.IsByRef)
			{
				paramType = paramType.GetElementType();
			}
			argNameLabel.text = $"{SignatureHighlighter.Parse(paramType, false, (MemberInfo)null)} <color={"#a6e9e9"}>{paramInfo.Name}</color>";
			if (ParseUtility.CanParse(paramType) || typeof(Type).IsAssignableFrom(paramType))
			{
				usingBasicLabel = false;
				((Component)inputField.Component).gameObject.SetActive(true);
				basicLabelHolder.SetActive(false);
				typeCompleter.Enabled = typeof(Type).IsAssignableFrom(paramType);
				enumCompleter.Enabled = paramType.IsEnum;
				((Component)enumHelperButton.Component).gameObject.SetActive(paramType.IsEnum);
				if (!typeCompleter.Enabled)
				{
					if (paramType == typeof(string))
					{
						inputField.PlaceholderText.text = "...";
					}
					else
					{
						inputField.PlaceholderText.text = "eg. " + ParseUtility.GetExampleInput(paramType);
					}
				}
				else
				{
					inputField.PlaceholderText.text = "Enter a Type name...";
					typeCompleter.BaseType = typeof(object);
					typeCompleter.CacheTypes();
				}
				if (enumCompleter.Enabled)
				{
					enumCompleter.EnumType = paramType;
					enumCompleter.CacheEnumValues();
				}
			}
			else
			{
				usingBasicLabel = true;
				((Component)inputField.Component).gameObject.SetActive(false);
				basicLabelHolder.SetActive(true);
				typeCompleter.Enabled = false;
				enumCompleter.Enabled = false;
				((Component)enumHelperButton.Component).gameObject.SetActive(false);
				SetDisplayedValueFromPaste();
			}
		}

		public void OnReturned()
		{
			paramInfo = null;
			enumCompleter.Enabled = false;
			typeCompleter.Enabled = false;
			inputField.Text = "";
			usingBasicLabel = false;
			basicValue = null;
		}

		public object Evaluate()
		{
			if (usingBasicLabel)
			{
				return basicValue;
			}
			string text = inputField.Text;
			if (typeof(Type).IsAssignableFrom(paramType))
			{
				return ReflectionUtility.GetTypeByName(text);
			}
			if (paramType == typeof(string))
			{
				return text;
			}
			if (string.IsNullOrEmpty(text))
			{
				if (paramInfo.IsOptional)
				{
					return paramInfo.DefaultValue;
				}
				return null;
			}
			object result = default(object);
			Exception ex = default(Exception);
			if (!ParseUtility.TryParse(text, paramType, ref result, ref ex))
			{
				ExplorerCore.LogWarning($"Cannot parse argument '{paramInfo.Name}' ({paramInfo.ParameterType.Name}){((ex == null) ? "" : (", " + ex.GetType().Name + ": " + ex.Message))}");
				return null;
			}
			return result;
		}

		private void OnPasteClicked()
		{
			if (ClipboardPanel.TryPaste(paramType, out var paste))
			{
				basicValue = paste;
				SetDisplayedValueFromPaste();
			}
		}

		private void SetDisplayedValueFromPaste()
		{
			if (usingBasicLabel)
			{
				basicLabel.text = ToStringUtility.ToStringWithType(basicValue, paramType, false);
			}
			else if (typeof(Type).IsAssignableFrom(paramType))
			{
				inputField.Text = GeneralExtensions.FullDescription(basicValue as Type);
			}
			else
			{
				inputField.Text = ParseUtility.ToStringForInput(basicValue, paramType);
			}
		}

		public override void CreateSpecialContent()
		{
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			enumCompleter = new EnumCompleter(paramType, inputField)
			{
				Enabled = false
			};
			enumHelperButton = UIFactory.CreateButton(base.UIRoot, "EnumHelper", "▼", (Color?)null);
			UIFactory.SetLayoutElement(((Component)enumHelperButton.Component).gameObject, (int?)25, (int?)25, (int?)0, (int?)0, (int?)null, (int?)null, (bool?)null);
			ButtonRef obj = enumHelperButton;
			obj.OnClick = (Action)System.Delegate.Combine(obj.OnClick, new Action(enumCompleter.HelperButtonClicked));
			GameObject uIRoot = base.UIRoot;
			Color val = default(Color);
			((Color)(ref val))..ctor(0.1f, 0.1f, 0.1f);
			basicLabelHolder = UIFactory.CreateHorizontalGroup(uIRoot, "BasicLabelHolder", true, true, true, true, 0, default(Vector4), val, (TextAnchor?)null);
			GameObject obj2 = basicLabelHolder;
			int? num = 25;
			int? num2 = 50;
			UIFactory.SetLayoutElement(obj2, (int?)100, num, (int?)1000, num2, (int?)null, (int?)null, (bool?)null);
			GameObject obj3 = basicLabelHolder;
			val = default(Color);
			basicLabel = UIFactory.CreateLabel(obj3, "BasicLabel", "null", (TextAnchor)3, val, true, 14);
			((Component)basicLabel).gameObject.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			pasteButton = UIFactory.CreateButton(base.UIRoot, "PasteButton", "Paste", (Color?)new Color(0.13f, 0.13f, 0.13f, 1f));
			GameObject gameObject = ((Component)pasteButton.Component).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject, (int?)28, num2, (int?)0, (int?)null, (int?)null, (int?)null, (bool?)null);
			((Graphic)pasteButton.ButtonText).color = Color.green;
			pasteButton.ButtonText.fontSize = 10;
			ButtonRef obj4 = pasteButton;
			obj4.OnClick = (Action)System.Delegate.Combine(obj4.OnClick, new Action(OnPasteClicked));
		}
	}
	public class AxisControl
	{
		public readonly Vector3Control parent;

		public readonly int axis;

		public readonly Slider slider;

		public AxisControl(int axis, Slider slider, Vector3Control parentControl)
		{
			parent = parentControl;
			this.axis = axis;
			this.slider = slider;
		}

		private void OnVectorSliderChanged(float value)
		{
			parent.Owner.CurrentSlidingAxisControl = ((value == 0f) ? null : this);
		}

		private void OnVectorMinusClicked()
		{
			parent.Owner.AxisControlOperation(0f - parent.Increment, parent, axis);
		}

		private void OnVectorPlusClicked()
		{
			parent.Owner.AxisControlOperation(parent.Increment, parent, axis);
		}

		public static AxisControl Create(GameObject parent, string title, int axis, Vector3Control owner)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			Text val = UIFactory.CreateLabel(parent, "Label_" + title, title + ":", (TextAnchor)5, Color.grey, true, 14);
			GameObject gameObject = ((Component)val).gameObject;
			int? num = 25;
			UIFactory.SetLayoutElement(gameObject, (int?)30, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			Slider val2 = default(Slider);
			GameObject val3 = UIFactory.CreateSlider(parent, "Slider_" + title, ref val2);
			num = 25;
			UIFactory.SetLayoutElement(val3, (int?)75, num, (int?)0, (int?)null, (int?)null, (int?)null, (bool?)null);
			((Graphic)val2.m_FillImage).color = Color.clear;
			val2.minValue = -0.1f;
			val2.maxValue = 0.1f;
			AxisControl axisControl = new AxisControl(axis, val2, owner);
			Il2CppExtensions.AddListener<float>((UnityEvent<float>)(object)val2.onValueChanged, (Action<float>)axisControl.OnVectorSliderChanged);
			ButtonRef val4 = UIFactory.CreateButton(parent, "MinusIncrementButton", "-", (Color?)null);
			GameObject gameObject2 = val4.GameObject;
			int? num2 = 20;
			num = 0;
			UIFactory.SetLayoutElement(gameObject2, num2, (int?)25, num, (int?)null, (int?)null, (int?)null, (bool?)null);
			val4.OnClick = (Action)System.Delegate.Combine(val4.OnClick, new Action(axisControl.OnVectorMinusClicked));
			ButtonRef val5 = UIFactory.CreateButton(parent, "PlusIncrementButton", "+", (Color?)null);
			GameObject gameObject3 = val5.GameObject;
			int? num3 = 20;
			num = 0;
			UIFactory.SetLayoutElement(gameObject3, num3, (int?)25, num, (int?)null, (int?)null, (int?)null, (bool?)null);
			val5.OnClick = (Action)System.Delegate.Combine(val5.OnClick, new Action(axisControl.OnVectorPlusClicked));
			return axisControl;
		}
	}
	public class ComponentCell : ButtonCell
	{
		public Toggle BehaviourToggle;

		public ButtonRef DestroyButton;

		public Action<bool, int> OnBehaviourToggled;

		public Action<int> OnDestroyClicked;

		private void BehaviourToggled(bool val)
		{
			OnBehaviourToggled?.Invoke(val, ((ButtonCell)this).CurrentDataIndex);
		}

		private void DestroyClicked()
		{
			OnDestroyClicked?.Invoke(((ButtonCell)this).CurrentDataIndex);
		}

		public override GameObject CreateContent(GameObject parent)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			GameObject result = ((ButtonCell)this).CreateContent(parent);
			((ButtonCell)this).Button.ButtonText.horizontalOverflow = (HorizontalWrapMode)0;
			Text val = default(Text);
			GameObject val2 = UIFactory.CreateToggle(((ButtonCell)this).UIRoot, "BehaviourToggle", ref BehaviourToggle, ref val, default(Color), 20, 20);
			int? num = 25;
			UIFactory.SetLayoutElement(val2, (int?)25, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			Il2CppExtensions.AddListener<bool>((UnityEvent<bool>)(object)BehaviourToggle.onValueChanged, (Action<bool>)BehaviourToggled);
			val2.transform.SetSiblingIndex(0);
			DestroyButton = UIFactory.CreateButton(((ButtonCell)this).UIRoot, "DestroyButton", "X", (Color?)new Color(0.3f, 0.2f, 0.2f));
			GameObject gameObject = ((Component)DestroyButton.Component).gameObject;
			num = 21;
			UIFactory.SetLayoutElement(gameObject, (int?)25, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			ButtonRef destroyButton = DestroyButton;
			destroyButton.OnClick = (Action)System.Delegate.Combine(destroyButton.OnClick, new Action(DestroyClicked));
			return result;
		}
	}
	public class ComponentList : ButtonListHandler<Component, ComponentCell>
	{
		public GameObjectInspector Parent;

		private static readonly Dictionary<string, string> compToStringCache = new Dictionary<string, string>();

		public ComponentList(ScrollPool<ComponentCell> scrollPool, Func<List<Component>> getEntriesMethod)
			: base(scrollPool, getEntriesMethod, (Action<ComponentCell, int>)null, (Func<Component, string, bool>)null, (Action<int>)null)
		{
			base.SetICell = SetComponentCell;
			base.ShouldDisplay = CheckShouldDisplay;
			base.OnCellClicked = OnComponentClicked;
		}

		public void Clear()
		{
			base.RefreshData();
			base.ScrollPool.Refresh(true, true);
		}

		private bool CheckShouldDisplay(Component _, string __)
		{
			return true;
		}

		public override void OnCellBorrowed(ComponentCell cell)
		{
			base.OnCellBorrowed(cell);
			cell.OnBehaviourToggled = (Action<bool, int>)System.Delegate.Combine(cell.OnBehaviourToggled, new Action<bool, int>(OnBehaviourToggled));
			cell.OnDestroyClicked = (Action<int>)System.Delegate.Combine(cell.OnDestroyClicked, new Action<int>(OnDestroyClicked));
		}

		public override void SetCell(ComponentCell cell, int index)
		{
			base.SetCell(cell, index);
		}

		private void OnComponentClicked(int index)
		{
			List<Component> list = base.GetEntries();
			if (index >= 0 && index < list.Count)
			{
				Component val = list[index];
				if (Object.op_Implicit((Object)(object)val))
				{
					InspectorManager.Inspect(val);
				}
			}
		}

		private void OnBehaviourToggled(bool value, int index)
		{
			try
			{
				List<Component> list = base.GetEntries();
				Component val = list[index];
				Behaviour val2 = ((Il2CppObjectBase)val).TryCast<Behaviour>();
				if (val2 != null)
				{
					val2.enabled = value;
				}
			}
			catch (Exception ex)
			{
				ExplorerCore.LogWarning("Exception toggling Behaviour.enabled: " + ReflectionExtensions.ReflectionExToString(ex, true));
			}
		}

		private void OnDestroyClicked(int index)
		{
			try
			{
				List<Component> list = base.GetEntries();
				Component val = list[index];
				Object.DestroyImmediate((Object)(object)val);
				Parent.UpdateComponents();
			}
			catch (Exception ex)
			{
				ExplorerCore.LogWarning("Exception destroying Component: " + ReflectionExtensions.ReflectionExToString(ex, true));
			}
		}

		private void SetComponentCell(ComponentCell cell, int index)
		{
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			List<Component> list = base.GetEntries();
			((ButtonCell)cell).Enable();
			Component val = list[index];
			Type actualType = ReflectionExtensions.GetActualType((object)val);
			if (!compToStringCache.ContainsKey(actualType.AssemblyQualifiedName))
			{
				compToStringCache.Add(actualType.AssemblyQualifiedName, SignatureHighlighter.Parse(actualType, true, (MemberInfo)null));
			}
			((ButtonCell)cell).Button.ButtonText.text = compToStringCache[actualType.AssemblyQualifiedName];
			if (typeof(Behaviour).IsAssignableFrom(actualType))
			{
				((Selectable)cell.BehaviourToggle).interactable = true;
				cell.BehaviourToggle.Set(((Il2CppObjectBase)val).TryCast<Behaviour>().enabled, false);
				cell.BehaviourToggle.graphic.color = new Color(0.8f, 1f, 0.8f, 0.3f);
			}
			else
			{
				((Selectable)cell.BehaviourToggle).interactable = false;
				cell.BehaviourToggle.Set(true, false);
				cell.BehaviourToggle.graphic.color = new Color(0.2f, 0.2f, 0.2f);
			}
			if (index == 0 && ((Component)cell.DestroyButton.Component).gameObject.activeSelf)
			{
				((Component)cell.DestroyButton.Component).gameObject.SetActive(false);
			}
			else if (index > 0 && !((Component)cell.DestroyButton.Component).gameObject.activeSelf)
			{
				((Component)cell.DestroyButton.Component).gameObject.SetActive(true);
			}
		}
	}
	public class GameObjectControls
	{
		public GameObjectInspector Parent { get; }

		public GameObject Target => Parent.Target;

		public GameObjectInfoPanel GameObjectInfo { get; }

		public TransformControls TransformControl { get; }

		public GameObjectControls(GameObjectInspector parent)
		{
			Parent = parent;
			GameObjectInfo = new GameObjectInfoPanel(this);
			TransformControl = new TransformControls(this);
		}

		public void UpdateGameObjectInfo(bool firstUpdate, bool force)
		{
			GameObjectInfo.UpdateGameObjectInfo(firstUpdate, force);
		}

		public void UpdateVectorSlider()
		{
			TransformControl.UpdateVectorSlider();
		}
	}
	public class GameObjectInfoPanel
	{
		private string lastGoName;

		private string lastPath;

		private bool lastParentState;

		private int lastSceneHandle;

		private string lastTag;

		private int lastLayer;

		private int lastFlags;

		private ButtonRef ViewParentButton;

		private InputFieldRef PathInput;

		private InputFieldRef NameInput;

		private Toggle ActiveSelfToggle;

		private Text ActiveSelfText;

		private Toggle IsStaticToggle;

		private ButtonRef SceneButton;

		private InputFieldRef InstanceIDInput;

		private InputFieldRef TagInput;

		private Dropdown LayerDropdown;

		private Dropdown FlagsDropdown;

		private static List<string> layerToNames;

		private static Dictionary<string, HideFlags> hideFlagsValues;

		public GameObjectControls Owner { get; }

		private GameObject Target => Owner.Target;

		public GameObjectInfoPanel(GameObjectControls owner)
		{
			Owner = owner;
			Create();
		}

		public void UpdateGameObjectInfo(bool firstUpdate, bool force)
		{
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Invalid comparison between Unknown and I4
			//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Expected I4, but got Unknown
			//IL_03fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			if (firstUpdate)
			{
				InstanceIDInput.Text = ((Object)Target).GetInstanceID().ToString();
			}
			if (force || (!NameInput.Component.isFocused && ((Object)Target).name != lastGoName))
			{
				lastGoName = ((Object)Target).name;
				Owner.Parent.Tab.TabText.text = "[G] " + ((Object)Target).name;
				NameInput.Text = ((Object)Target).name;
			}
			if (force || !PathInput.Component.isFocused)
			{
				string transformPath = UnityHelpers.GetTransformPath(Target.transform, false);
				if (transformPath != lastPath)
				{
					lastPath = transformPath;
					PathInput.Text = transformPath;
				}
			}
			if (force || Object.op_Implicit((Object)(object)Target.transform.parent) != lastParentState)
			{
				lastParentState = Object.op_Implicit((Object)(object)Target.transform.parent);
				((Selectable)ViewParentButton.Component).interactable = lastParentState;
				if (lastParentState)
				{
					((Graphic)ViewParentButton.ButtonText).color = Color.white;
					ViewParentButton.ButtonText.text = "◄ View Parent";
				}
				else
				{
					((Graphic)ViewParentButton.ButtonText).color = Color.grey;
					ViewParentButton.ButtonText.text = "No parent";
				}
			}
			if (force || Target.activeSelf != ActiveSelfToggle.isOn)
			{
				ActiveSelfToggle.Set(Target.activeSelf, false);
				((Graphic)ActiveSelfText).color = (ActiveSelfToggle.isOn ? Color.green : Color.red);
			}
			if (force || Target.isStatic != IsStaticToggle.isOn)
			{
				IsStaticToggle.Set(Target.isStatic, false);
			}
			Scene scene;
			if (!force)
			{
				scene = Target.scene;
				if (((Scene)(ref scene)).handle == lastSceneHandle)
				{
					goto IL_0310;
				}
			}
			scene = Target.scene;
			lastSceneHandle = ((Scene)(ref scene)).handle;
			Text buttonText = SceneButton.ButtonText;
			scene = Target.scene;
			object text;
			if (!((Scene)(ref scene)).IsValid())
			{
				text = "None (Asset/Resource)";
			}
			else
			{
				scene = Target.scene;
				text = ((Scene)(ref scene)).name;
			}
			buttonText.text = (string)text;
			goto IL_0310;
			IL_0310:
			if (force || (!TagInput.Component.isFocused && Target.tag != lastTag))
			{
				lastTag = Target.tag;
				TagInput.Text = lastTag;
			}
			if (force || Target.layer != lastLayer)
			{
				lastLayer = Target.layer;
				LayerDropdown.value = Target.layer;
			}
			if (force || (int)((Object)Target).hideFlags != lastFlags)
			{
				lastFlags = (int)((Object)Target).hideFlags;
				Text captionText = FlagsDropdown.captionText;
				HideFlags hideFlags = ((Object)Target).hideFlags;
				captionText.text = ((object)(HideFlags)(ref hideFlags)).ToString();
			}
		}

		private void DoSetParent(Transform transform)
		{
			ExplorerCore.Log("Setting target's transform parent to: " + (((Object)(object)transform == (Object)null) ? "null" : ("'" + ((Object)transform).name + "'")));
			if (Object.op_Implicit((Object)(object)Target.GetComponent<RectTransform>()))
			{
				Target.transform.SetParent(transform, false);
			}
			else
			{
				Target.transform.parent = transform;
			}
			UpdateGameObjectInfo(firstUpdate: false, force: false);
			Owner.TransformControl.UpdateTransformControlValues(force: false);
		}

		private void OnViewParentClicked()
		{
			if (Object.op_Implicit((Object)(object)Target) && Object.op_Implicit((Object)(object)Target.transform.parent))
			{
				Owner.Parent.OnTransformCellClicked(((Component)Target.transform.parent).gameObject);
			}
		}

		private void OnPathEndEdit(string input)
		{
			lastPath = input;
			if (string.IsNullOrEmpty(input))
			{
				DoSetParent(null);
				return;
			}
			Transform val = null;
			if (input.EndsWith("/"))
			{
				input = input.Remove(input.Length - 1);
			}
			GameObject val2 = GameObject.Find(input);
			if (val2 != null)
			{
				val = val2.transform;
			}
			else
			{
				string text = input.Split('/').Last();
				Object[] array = RuntimeHelper.FindObjectsOfTypeAll(typeof(GameObject));
				List<GameObject> list = new List<GameObject>();
				Object[] array2 = array;
				foreach (Object val3 in array2)
				{
					if (val3.name == text)
					{
						list.Add(((Il2CppObjectBase)val3).TryCast<GameObject>());
					}
				}
				foreach (GameObject item in list)
				{
					string text2 = UnityHelpers.GetTransformPath(item.transform, true);
					if (text2.EndsWith("/"))
					{
						text2 = text2.Remove(text2.Length - 1);
					}
					if (text2 == input)
					{
						val = item.transform;
						break;
					}
				}
			}
			if (Object.op_Implicit((Object)(object)val))
			{
				DoSetParent(val);
				return;
			}
			ExplorerCore.LogWarning("Could not find any GameObject name or path '" + input + "'!");
			UpdateGameObjectInfo(firstUpdate: false, force: true);
		}

		private void OnNameEndEdit(string value)
		{
			((Object)Target).name = value;
			UpdateGameObjectInfo(firstUpdate: false, force: true);
		}

		private void OnCopyClicked()
		{
			ClipboardPanel.Copy(Target);
		}

		private void OnActiveSelfToggled(bool value)
		{
			Target.SetActive(value);
			UpdateGameObjectInfo(firstUpdate: false, force: true);
		}

		private void OnTagEndEdit(string value)
		{
			try
			{
				Target.tag = value;
				UpdateGameObjectInfo(firstUpdate: false, force: true);
			}
			catch (Exception ex)
			{
				ExplorerCore.LogWarning("Exception setting tag! " + ReflectionExtensions.ReflectionExToString(ex, true));
			}
		}

		private void OnSceneButtonClicked()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			InspectorManager.Inspect(Target.scene);
		}

		private void OnExploreButtonClicked()
		{
			ObjectExplorerPanel panel = UIManager.GetPanel<ObjectExplorerPanel>(UIManager.Panels.ObjectExplorer);
			panel.SceneExplorer.JumpToTransform(Owner.Parent.Target.transform);
		}

		private void OnLayerDropdownChanged(int value)
		{
			Target.layer = value;
			UpdateGameObjectInfo(firstUpdate: false, force: true);
		}

		private void OnFlagsDropdownChanged(int value)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				HideFlags hideFlags = hideFlagsValues[FlagsDropdown.options[value].text];
				((Object)Target).hideFlags = hideFlags;
				UpdateGameObjectInfo(firstUpdate: false, force: true);
			}
			catch (Exception value2)
			{
				ExplorerCore.LogWarning($"Exception setting hideFlags: {value2}");
			}
		}

		private void OnDestroyClicked()
		{
			Object.Destroy((Object)(object)Target);
			InspectorManager.ReleaseInspector(Owner.Parent);
		}

		private void OnInstantiateClicked()
		{
			GameObject obj = Object.Instantiate<GameObject>(Target);
			InspectorManager.Inspect(obj);
		}

		public void Create()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0435: Unknown result type (might be due to invalid IL or missing references)
			//IL_043b: Unknown result type (might be due to invalid IL or missing references)
			//IL_054a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0550: Unknown result type (might be due to invalid IL or missing references)
			//IL_0609: Unknown result type (might be due to invalid IL or missing references)
			//IL_060f: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0715: Unknown result type (might be due to invalid IL or missing references)
			//IL_073a: Unknown result type (might be due to invalid IL or missing references)
			//IL_081b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0845: Unknown result type (might be due to invalid IL or missing references)
			//IL_0926: Unknown result type (might be due to invalid IL or missing references)
			//IL_096e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a13: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b6a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c10: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d1f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dfe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e42: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e4c: Expected O, but got Unknown
			//IL_0e8d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f20: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fb8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fc2: Expected O, but got Unknown
			GameObject val2 = UIFactory.CreateVerticalGroup(Owner.Parent.Content, "TopInfoHolder", false, false, true, true, 3, new Vector4(3f, 3f, 3f, 3f), new Color(0.1f, 0.1f, 0.1f), (TextAnchor?)(TextAnchor)3);
			int? num = 100;
			int? num2 = 9999;
			UIFactory.SetLayoutElement(val2, (int?)null, num, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			val2.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			GameObject val3 = UIFactory.CreateUIObject("ParentRow", val2, default(Vector2));
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val3, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)null);
			num2 = 25;
			num = 9999;
			UIFactory.SetLayoutElement(val3, (int?)null, num2, num, (int?)null, (int?)null, (int?)null, (bool?)null);
			ViewParentButton = UIFactory.CreateButton(val3, "ViewParentButton", "◄ View Parent", (Color?)new Color(0.2f, 0.2f, 0.2f));
			ViewParentButton.ButtonText.fontSize = 13;
			GameObject gameObject = ((Component)ViewParentButton.Component).gameObject;
			num = 25;
			UIFactory.SetLayoutElement(gameObject, (int?)100, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			ButtonRef viewParentButton = ViewParentButton;
			viewParentButton.OnClick = (Action)System.Delegate.Combine(viewParentButton.OnClick, new Action(OnViewParentClicked));
			PathInput = UIFactory.CreateInputField(val3, "PathInput", "...");
			((Graphic)PathInput.Component.textComponent).color = Color.grey;
			PathInput.Component.textComponent.fontSize = 14;
			GameObject uIRoot = ((UIModel)PathInput).UIRoot;
			num = 25;
			UIFactory.SetLayoutElement(uIRoot, (int?)100, num, (int?)9999, (int?)null, (int?)null, (int?)null, (bool?)null);
			PathInput.Component.lineType = (LineType)1;
			ButtonRef val4 = UIFactory.CreateButton(val3, "CopyButton", "Copy to Clipboard", (Color?)new Color(0.2f, 0.2f, 0.2f, 1f));
			((Graphic)val4.ButtonText).color = Color.yellow;
			GameObject gameObject2 = ((Component)val4.Component).gameObject;
			num = 25;
			UIFactory.SetLayoutElement(gameObject2, (int?)120, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			val4.OnClick = (Action)System.Delegate.Combine(val4.OnClick, new Action(OnCopyClicked));
			Il2CppExtensions.AddListener<string>(UnityHelpers.GetOnEndEdit(PathInput.Component), (Action<string>)delegate(string val)
			{
				OnPathEndEdit(val);
			});
			GameObject val5 = UIFactory.CreateUIObject("TitleRow", val2, default(Vector2));
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val5, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
			Text val6 = UIFactory.CreateLabel(val5, "Title", SignatureHighlighter.Parse(typeof(GameObject), false, (MemberInfo)null), (TextAnchor)3, default(Color), true, 17);
			GameObject gameObject3 = ((Component)val6).gameObject;
			num = 30;
			UIFactory.SetLayoutElement(gameObject3, (int?)100, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			NameInput = UIFactory.CreateInputField(val5, "NameInput", "untitled");
			GameObject gameObject4 = ((Component)NameInput.Component).gameObject;
			num = 30;
			UIFactory.SetLayoutElement(gameObject4, (int?)100, num, (int?)9999, (int?)null, (int?)null, (int?)null, (bool?)null);
			NameInput.Component.textComponent.fontSize = 15;
			Il2CppExtensions.AddListener<string>(UnityHelpers.GetOnEndEdit(NameInput.Component), (Action<string>)delegate(string val)
			{
				OnNameEndEdit(val);
			});
			GameObject val7 = UIFactory.CreateUIObject("ParentRow", val2, default(Vector2));
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val7, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)null);
			num = 25;
			num2 = 9999;
			UIFactory.SetLayoutElement(val7, (int?)null, num, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			GameObject val8 = UIFactory.CreateToggle(val7, "ActiveSelf", ref ActiveSelfToggle, ref ActiveSelfText, default(Color), 20, 20);
			num2 = 25;
			UIFactory.SetLayoutElement(val8, (int?)100, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			ActiveSelfText.text = "ActiveSelf";
			Il2CppExtensions.AddListener<bool>((UnityEvent<bool>)(object)ActiveSelfToggle.onValueChanged, (Action<bool>)OnActiveSelfToggled);
			Text val9 = default(Text);
			GameObject val10 = UIFactory.CreateToggle(val7, "IsStatic", ref IsStaticToggle, ref val9, default(Color), 20, 20);
			num2 = 25;
			UIFactory.SetLayoutElement(val10, (int?)80, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			val9.text = "IsStatic";
			((Graphic)val9).color = Color.grey;
			((Selectable)IsStaticToggle).interactable = false;
			Text val11 = UIFactory.CreateLabel(val7, "InstanceIDLabel", "Instance ID:", (TextAnchor)5, Color.grey, true, 14);
			GameObject gameObject5 = ((Component)val11).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject5, (int?)90, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			InstanceIDInput = UIFactory.CreateInputField(val7, "InstanceIDInput", "error");
			GameObject gameObject6 = ((Component)InstanceIDInput.Component).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject6, (int?)110, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			((Graphic)InstanceIDInput.Component.textComponent).color = Color.grey;
			InstanceIDInput.Component.readOnly = true;
			Text val12 = UIFactory.CreateLabel(val7, "TagLabel", "Tag:", (TextAnchor)5, Color.grey, true, 14);
			GameObject gameObject7 = ((Component)val12).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject7, (int?)40, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			TagInput = UIFactory.CreateInputField(val7, "TagInput", "none");
			GameObject gameObject8 = ((Component)TagInput.Component).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject8, (int?)100, num2, (int?)999, (int?)null, (int?)null, (int?)null, (bool?)null);
			((Graphic)TagInput.Component.textComponent).color = Color.white;
			Il2CppExtensions.AddListener<string>(UnityHelpers.GetOnEndEdit(TagInput.Component), (Action<string>)delegate(string val)
			{
				OnTagEndEdit(val);
			});
			ButtonRef val13 = UIFactory.CreateButton(val7, "InstantiateBtn", "Instantiate", (Color?)new Color(0.2f, 0.2f, 0.2f));
			GameObject gameObject9 = ((Component)val13.Component).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject9, (int?)120, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			val13.OnClick = (Action)System.Delegate.Combine(val13.OnClick, new Action(OnInstantiateClicked));
			ButtonRef val14 = UIFactory.CreateButton(val7, "DestroyBtn", "Destroy", (Color?)new Color(0.3f, 0.2f, 0.2f));
			GameObject gameObject10 = ((Component)val14.Component).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject10, (int?)80, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			val14.OnClick = (Action)System.Delegate.Combine(val14.OnClick, new Action(OnDestroyClicked));
			GameObject val15 = UIFactory.CreateUIObject("ParentRow", val2, default(Vector2));
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val15, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)null);
			num2 = 25;
			num = 9999;
			UIFactory.SetLayoutElement(val15, (int?)null, num2, num, (int?)null, (int?)null, (int?)null, (bool?)null);
			ButtonRef val16 = UIFactory.CreateButton(val15, "ExploreBtn", "Show in Explorer", (Color?)new Color(0.15f, 0.15f, 0.15f));
			GameObject gameObject11 = ((Component)val16.Component).gameObject;
			num = 25;
			UIFactory.SetLayoutElement(gameObject11, (int?)100, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			val16.ButtonText.fontSize = 12;
			val16.OnClick = (Action)System.Delegate.Combine(val16.OnClick, new Action(OnExploreButtonClicked));
			Text val17 = UIFactory.CreateLabel(val15, "SceneLabel", "Scene:", (TextAnchor)3, Color.grey, true, 14);
			GameObject gameObject12 = ((Component)val17).gameObject;
			num = 25;
			UIFactory.SetLayoutElement(gameObject12, (int?)50, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			SceneButton = UIFactory.CreateButton(val15, "SceneButton", "untitled", (Color?)null);
			GameObject gameObject13 = ((Component)SceneButton.Component).gameObject;
			num = 25;
			UIFactory.SetLayoutElement(gameObject13, (int?)120, num, (int?)999, (int?)null, (int?)null, (int?)null, (bool?)null);
			ButtonRef sceneButton = SceneButton;
			sceneButton.OnClick = (Action)System.Delegate.Combine(sceneButton.OnClick, new Action(OnSceneButtonClicked));
			Text val18 = UIFactory.CreateLabel(val15, "LayerLabel", "Layer:", (TextAnchor)3, Color.grey, true, 14);
			GameObject gameObject14 = ((Component)val18).gameObject;
			num = 25;
			UIFactory.SetLayoutElement(gameObject14, (int?)50, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			GameObject val19 = UIFactory.CreateDropdown(val15, "LayerDropdown", ref LayerDropdown, "0", 14, (Action<int>)OnLayerDropdownChanged, (string[])null);
			num = 25;
			UIFactory.SetLayoutElement(val19, (int?)110, num, (int?)999, (int?)null, (int?)null, (int?)null, (bool?)null);
			((Graphic)LayerDropdown.captionText).color = SignatureHighlighter.EnumGreen;
			if (layerToNames == null)
			{
				GetLayerNames();
			}
			foreach (string layerToName in layerToNames)
			{
				LayerDropdown.options.Add(new OptionData(layerToName));
			}
			LayerDropdown.value = 0;
			LayerDropdown.RefreshShownValue();
			Text val20 = UIFactory.CreateLabel(val15, "FlagsLabel", "Flags:", (TextAnchor)5, Color.grey, true, 14);
			GameObject gameObject15 = ((Component)val20).gameObject;
			num = 25;
			UIFactory.SetLayoutElement(gameObject15, (int?)50, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			GameObject val21 = UIFactory.CreateDropdown(val15, "FlagsDropdown", ref FlagsDropdown, "None", 14, (Action<int>)OnFlagsDropdownChanged, (string[])null);
			((Graphic)FlagsDropdown.captionText).color = SignatureHighlighter.EnumGreen;
			num = 25;
			UIFactory.SetLayoutElement(val21, (int?)135, num, (int?)999, (int?)null, (int?)null, (int?)null, (bool?)null);
			if (hideFlagsValues == null)
			{
				GetHideFlagNames();
			}
			foreach (string key in hideFlagsValues.Keys)
			{
				FlagsDropdown.options.Add(new OptionData(key));
			}
			FlagsDropdown.value = 0;
			FlagsDropdown.RefreshShownValue();
		}

		private static void GetLayerNames()
		{
			layerToNames = new List<string>();
			for (int i = 0; i < 32; i++)
			{
				string text = RuntimeHelper.LayerToName(i);
				if (string.IsNullOrEmpty(text))
				{
					text = i.ToString();
				}
				layerToNames.Add(text);
			}
		}

		private static void GetHideFlagNames()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			hideFlagsValues = new Dictionary<string, HideFlags>();
			Array values = System.Enum.GetValues(typeof(HideFlags));
			foreach (HideFlags item in values)
			{
				HideFlags value = item;
				hideFlagsValues.Add(((object)(HideFlags)(ref value)).ToString(), value);
			}
		}
	}
	public class TransformControls
	{
		private Vector3Control PositionControl;

		private Vector3Control LocalPositionControl;

		private Vector3Control RotationControl;

		private Vector3Control ScaleControl;

		public GameObjectControls Owner { get; }

		private GameObject Target => Owner.Target;

		public AxisControl CurrentSlidingAxisControl { get; set; }

		public TransformControls(GameObjectControls owner)
		{
			Owner = owner;
			Create();
		}

		public void UpdateTransformControlValues(bool force)
		{
			PositionControl.Update(force);
			LocalPositionControl.Update(force);
			RotationControl.Update(force);
			ScaleControl.Update(force);
		}

		public void UpdateVectorSlider()
		{
			AxisControl currentSlidingAxisControl = CurrentSlidingAxisControl;
			if (currentSlidingAxisControl != null)
			{
				if (!InputManager.GetMouseButton(0))
				{
					currentSlidingAxisControl.slider.value = 0f;
					currentSlidingAxisControl = null;
				}
				else
				{
					AxisControlOperation(currentSlidingAxisControl.slider.value, currentSlidingAxisControl.parent, currentSlidingAxisControl.axis);
				}
			}
		}

		public void AxisControlOperation(float value, Vector3Control parent, int axis)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = Target.transform;
			TransformType type = parent.Type;
			if (1 == 0)
			{
			}
			Vector3 val = (Vector3)(type switch
			{
				TransformType.Position => transform.position, 
				TransformType.LocalPosition => transform.localPosition, 
				TransformType.Rotation => transform.localEulerAngles, 
				TransformType.Scale => transform.localScale, 
				_ => throw new NotImplementedException(), 
			});
			if (1 == 0)
			{
			}
			Vector3 val2 = val;
			switch (axis)
			{
			case 0:
				val2.x += value;
				break;
			case 1:
				val2.y += value;
				break;
			case 2:
				val2.z += value;
				break;
			}
			switch (parent.Type)
			{
			case TransformType.Position:
				transform.position = val2;
				break;
			case TransformType.LocalPosition:
				transform.localPosition = val2;
				break;
			case TransformType.Rotation:
				transform.localEulerAngles = val2;
				break;
			case TransformType.Scale:
				transform.localScale = val2;
				break;
			}
			UpdateTransformControlValues(force: false);
		}

		public void Create()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = UIFactory.CreateVerticalGroup(Owner.Parent.Content, "TransformControls", false, false, true, true, 2, new Vector4(2f, 2f, 0f, 0f), new Color(0.1f, 0.1f, 0.1f), (TextAnchor?)null);
			int? num = 100;
			int? num2 = 9999;
			UIFactory.SetLayoutElement(val, (int?)null, num, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			PositionControl = Vector3Control.Create(this, val, "Position:", TransformType.Position);
			LocalPositionControl = Vector3Control.Create(this, val, "Local Position:", TransformType.LocalPosition);
			RotationControl = Vector3Control.Create(this, val, "Rotation:", TransformType.Rotation);
			ScaleControl = Vector3Control.Create(this, val, "Scale:", TransformType.Scale);
		}
	}
	public enum TransformType
	{
		Position,
		LocalPosition,
		Rotation,
		Scale
	}
	public class Vector3Control
	{
		private Vector3 lastValue;

		public TransformControls Owner { get; }

		public GameObject Target => Owner.Owner.Target;

		public Transform Transform => Target.transform;

		public TransformType Type { get; }

		public InputFieldRef MainInput { get; }

		public AxisControl[] AxisControls { get; } = new AxisControl[3];


		public InputFieldRef IncrementInput { get; set; }

		public float Increment { get; set; } = 0.1f;


		private Vector3 CurrentValue
		{
			get
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				TransformType type = Type;
				if (1 == 0)
				{
				}
				Vector3 result = (Vector3)(type switch
				{
					TransformType.Position => Transform.position, 
					TransformType.LocalPosition => Transform.localPosition, 
					TransformType.Rotation => Transform.localEulerAngles, 
					TransformType.Scale => Transform.localScale, 
					_ => throw new NotImplementedException(), 
				});
				if (1 == 0)
				{
				}
				return result;
			}
		}

		public Vector3Control(TransformControls owner, TransformType type, InputFieldRef input)
		{
			Owner = owner;
			Type = type;
			MainInput = input;
		}

		public void Update(bool force)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			Vector3 currentValue = CurrentValue;
			if (force || (!MainInput.Component.isFocused && !((Vector3)(ref lastValue)).Equals(currentValue)))
			{
				MainInput.Text = ParseUtility.ToStringForInput<Vector3>((object)currentValue);
				lastValue = currentValue;
			}
		}

		private void OnTransformInputEndEdit(TransformType type, string input)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			Exception ex = default(Exception);
			switch (type)
			{
			case TransformType.Position:
			{
				Vector3 position = default(Vector3);
				if (ParseUtility.TryParse<Vector3>(input, ref position, ref ex))
				{
					Target.transform.position = position;
				}
				break;
			}
			case TransformType.LocalPosition:
			{
				Vector3 localPosition = default(Vector3);
				if (ParseUtility.TryParse<Vector3>(input, ref localPosition, ref ex))
				{
					Target.transform.localPosition = localPosition;
				}
				break;
			}
			case TransformType.Rotation:
			{
				Vector3 localEulerAngles = default(Vector3);
				if (ParseUtility.TryParse<Vector3>(input, ref localEulerAngles, ref ex))
				{
					Target.transform.localEulerAngles = localEulerAngles;
				}
				break;
			}
			case TransformType.Scale:
			{
				Vector3 localScale = default(Vector3);
				if (ParseUtility.TryParse<Vector3>(input, ref localScale, ref ex))
				{
					Target.transform.localScale = localScale;
				}
				break;
			}
			}
			Owner.UpdateTransformControlValues(force: true);
		}

		private void IncrementInput_OnEndEdit(string value)
		{
			float num = default(float);
			Exception ex = default(Exception);
			if (!ParseUtility.TryParse<float>(value, ref num, ref ex))
			{
				IncrementInput.Text = ParseUtility.ToStringForInput<float>((object)Increment);
				return;
			}
			Increment = num;
			AxisControl[] axisControls = AxisControls;
			foreach (AxisControl axisControl in axisControls)
			{
				axisControl.slider.minValue = 0f - num;
				axisControl.slider.maxValue = num;
			}
		}

		public static Vector3Control Create(TransformControls owner, GameObject transformGroup, string title, TransformType type)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = UIFactory.CreateUIObject("Row_" + title, transformGroup, default(Vector2));
			UIFactory.SetLayoutGroup<HorizontalLayoutGroup>(val, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)null);
			int? num = 25;
			int? num2 = 9999;
			UIFactory.SetLayoutElement(val, (int?)null, num, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			Text val2 = UIFactory.CreateLabel(val, "PositionLabel", title, (TextAnchor)5, Color.grey, true, 14);
			GameObject gameObject = ((Component)val2).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject, (int?)110, num2, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			InputFieldRef val3 = UIFactory.CreateInputField(val, "InputField", "...");
			GameObject gameObject2 = ((Component)val3.Component).gameObject;
			num2 = 25;
			UIFactory.SetLayoutElement(gameObject2, (int?)100, num2, (int?)999, (int?)null, (int?)null, (int?)null, (bool?)null);
			Vector3Control control = new Vector3Control(owner, type, val3);
			Il2CppExtensions.AddListener<string>(UnityHelpers.GetOnEndEdit(val3.Component), (Action<string>)delegate(string value)
			{
				control.OnTransformInputEndEdit(type, value);
			});
			control.AxisControls[0] = AxisControl.Create(val, "X", 0, control);
			control.AxisControls[1] = AxisControl.Create(val, "Y", 1, control);
			control.AxisControls[2] = AxisControl.Create(val, "Z", 2, control);
			control.IncrementInput = UIFactory.CreateInputField(val, "IncrementInput", "...");
			control.IncrementInput.Text = "0.1";
			GameObject gameObject3 = control.IncrementInput.GameObject;
			int? num3 = 30;
			num2 = 0;
			UIFactory.SetLayoutElement(gameObject3, num3, (int?)25, num2, (int?)null, (int?)null, (int?)null, (bool?)null);
			Il2CppExtensions.AddListener<string>(UnityHelpers.GetOnEndEdit(control.IncrementInput.Component), (Action<string>)control.IncrementInput_OnEndEdit);
			return control;
		}
	}
	[<f53caacd-7f86-4d3a-91d0-b8db8ecef87f>NullableContext(1)]
	[<9ced412d-a286-472d-aa8e-ac6db7941b78>Nullable(0)]
	internal class TimeScaleWidget
	{
		[<9ced412d-a286-472d-aa8e-ac6db7941b78>Nullable(2)]
		public static TimeScaleWidget Instance;

		private readonly InputFieldRef timeInput;

		private readonly ButtonRef lockBtn;

		private bool locked;

		private bool settingTimeScale;

		public float DesiredTime { get; private set; }

		public static void SetUp(GameObject parent)
		{
			Instance = new TimeScaleWidget(parent);
		}

		private TimeScaleWidget(GameObject parent)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			Text val = UIFactory.CreateLabel(parent, "TimeLabel", "Time:", (TextAnchor)5, Color.grey, true, 14);
			GameObject gameObject = ((Component)val).gameObject;
			int? num = 25;
			UIFactory.SetLayoutElement(gameObject, (int?)35, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			timeInput = UIFactory.CreateInputField(parent, "TimeInput", "timeScale");
			GameObject gameObject2 = ((Component)timeInput.Component).gameObject;
			num = 25;
			UIFactory.SetLayoutElement(gameObject2, (int?)40, num, (int?)null, (int?)null, (int?)null, (int?)null, (bool?)null);
			Il2CppExtensions.AddListener<string>(UnityHelpers.GetOnEndEdit(timeInput.Component), (Action<string>)OnTimeInputEndEdit);
			timeInput.Text = string.Empty;
			timeInput.Text = Time.timeScale.ToString();
			lockBtn = UIFactory.CreateButton(pare