using Exoa; using System; using System.Collections; using System.Collections.Generic; using System.Reflection; using UnityEngine.UIElements; namespace UnityEngine.Expansions { public static class Reflection { private static MethodInfo ResolveTemplate { get; set; } private static Assembly UnityEngine { get; set; } private static PropertyInfo ContextAttributeOverrides { get; set; } private static PropertyInfo TemplateAttributeOverrides { get; set; } private static MethodInfo AddRange { get; set; } private static MethodInfo CloneTree { get; set; } private static Type TemplateAsset { get; set; } private static Type AttributeOverride { get; set; } private static Type AttributeOverrideList { get; set; } private static MethodInfo RegisterTemplate { get; set; } private static MethodInfo TemplateExists { get; set; } private static Type UsingEntry { get; set; } private static Type UsingEntryList { get; set; } private static FieldInfo Using { get; set; } private static FieldInfo UsingAlias { get; set; } private static FieldInfo UsingPath { get; set; } private static FieldInfo UsingAsset { get; set; } private static MethodInfo RegisterTemplatePath { get; set; } private static MethodInfo RegisterTemplateAsset { get; set; } static Reflection() { Reflection.Init(); } private static void Init() { try { if (Reflection.UnityEngine == null) { Reflection.UnityEngine = Assembly.Load("UnityEngine"); } if (Reflection.ResolveTemplate == null) { Reflection.ResolveTemplate = typeof(VisualTreeAsset).GetMethod("ResolveTemplate", BindingFlags.Instance | BindingFlags.NonPublic); } if (Reflection.TemplateAsset == null) { Reflection.TemplateAsset = Reflection.UnityEngine.GetType("UnityEngine.UIElements.TemplateAsset"); } if (Reflection.AttributeOverride == null) { Reflection.AttributeOverride = Reflection.UnityEngine.GetType("UnityEngine.UIElements.TemplateAsset+AttributeOverride"); } if (Reflection.ContextAttributeOverrides == null) { Reflection.ContextAttributeOverrides = typeof(CreationContext).GetProperty("attributeOverrides", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetProperty); } if (Reflection.AttributeOverrideList == null) { Reflection.AttributeOverrideList = typeof(List<>).MakeGenericType(new Type[] { Reflection.AttributeOverride }); } if (Reflection.TemplateAttributeOverrides == null) { Reflection.TemplateAttributeOverrides = Reflection.TemplateAsset.GetProperty("attributeOverrides", BindingFlags.Instance | BindingFlags.Public | BindingFlags.GetProperty); } if (Reflection.AddRange == null) { Reflection.AddRange = Reflection.AttributeOverrideList.GetMethod("AddRange", BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod); } if (Reflection.CloneTree == null) { Reflection.CloneTree = typeof(VisualTreeAsset).GetMethod("CloneTree", BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[] { typeof(VisualElement), typeof(Dictionary), Reflection.AttributeOverrideList }, null); } if (Reflection.RegisterTemplate == null) { Reflection.RegisterTemplate = typeof(VisualTreeAsset).GetMethod("RegisterTemplate", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.InvokeMethod, null, new Type[] { typeof(string), typeof(string) }, null); } if (Reflection.TemplateExists == null) { Reflection.TemplateExists = typeof(VisualTreeAsset).GetMethod("TemplateExists", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.InvokeMethod, null, new Type[] { typeof(string) }, null); } if (Reflection.UsingEntry == null) { Reflection.UsingEntry = Reflection.UnityEngine.GetType("UnityEngine.UIElements.VisualTreeAsset+UsingEntry"); } if (Reflection.UsingEntryList == null) { Reflection.UsingEntryList = typeof(List<>).MakeGenericType(new Type[] { Reflection.UsingEntry }); } if (Reflection.Using == null) { Reflection.Using = typeof(VisualTreeAsset).GetField("m_Usings", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetField); } if (Reflection.UsingAlias == null) { Reflection.UsingAlias = Reflection.UsingEntry.GetField("alias", BindingFlags.Instance | BindingFlags.Public | BindingFlags.GetField); } if (Reflection.UsingPath == null) { Reflection.UsingPath = Reflection.UsingEntry.GetField("path", BindingFlags.Instance | BindingFlags.Public | BindingFlags.GetField); } if (Reflection.UsingAsset == null) { Reflection.UsingAsset = Reflection.UsingEntry.GetField("asset", BindingFlags.Instance | BindingFlags.Public | BindingFlags.GetField); } if (Reflection.RegisterTemplatePath == null) { Reflection.RegisterTemplatePath = typeof(VisualTreeAsset).GetMethod("RegisterTemplate", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.InvokeMethod, null, new Type[] { typeof(string), typeof(string) }, null); } if (Reflection.RegisterTemplateAsset == null) { Reflection.RegisterTemplateAsset = typeof(VisualTreeAsset).GetMethod("RegisterTemplate", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.InvokeMethod, null, new Type[] { typeof(string), typeof(VisualTreeAsset) }, null); } } catch (Exception ex) { Debug.Log(ex.Message + ex.StackTrace); } } internal static void Invoke(string assemblyName, string typeName, string methodName, string value = null) { try { if (assemblyName.IsNullOrEmpty()) { assemblyName = "Assembly-CSharp"; } if (!typeName.IsNullOrEmpty() && !methodName.IsNullOrEmpty()) { Reflection.Init(); Assembly assembly = Assembly.Load(assemblyName); Type type = (assembly != null) ? assembly.GetType(typeName, false, true, true) : null; if (!value.IsNullOrEmpty()) { MethodInfo methodInfo = (type != null) ? type.GetMethod(methodName, BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(string) }, null) : null; if (methodInfo == null) { //UnityEngine.Debug.LogError("The method was not found: " + assemblyName + " " + typeName + " " + methodName); } else { object[] parameters = new object[] { value }; methodInfo.Invoke(null, parameters); } } else { MethodInfo methodInfo = (type != null) ? type.GetMethod(methodName, BindingFlags.Static | BindingFlags.Public) : null; object[] parameters = new object[0]; if (methodInfo == null) { //Log.Error("The method was not found: {0}.{1}.{2}", new object[] //{ //assemblyName, //typeName, //methodName //}); } else { methodInfo.Invoke(null, parameters); } } } } catch (Exception) { //Log.Error(ex.Message + ex.StackTrace, new object[0]); } } internal static VisualTreeAsset GetVisualTreeAssetInternal(string path, VisualTreeAsset visualTreeAsset, VisualElement ve, IUxmlAttributes bag, CreationContext cc) { try { VisualTreeAsset result; if (visualTreeAsset == null) { result = null; return result; } Reflection.Init(); visualTreeAsset = (Reflection.ResolveTemplate.Invoke(visualTreeAsset, new object[] { path }) as VisualTreeAsset); if (visualTreeAsset == null) { ve.Add(new Label(string.Format("Unknown Template: '{0}'", path))); result = null; return result; } result = visualTreeAsset; return result; } catch (Exception) { //Log.Error(ex.Message + ex.StackTrace, new object[0]); } return null; } internal static Action CloneTreeInternal(string path, VisualTreeAsset visualTreeAsset, Dictionary slotInsertionPoints, VisualElement ve, IUxmlAttributes bag, CreationContext cc) { try { Action result; if (visualTreeAsset == null) { result = null; return result; } Reflection.Init(); object attributeOverrides = Activator.CreateInstance(Reflection.AttributeOverrideList); object value = Reflection.ContextAttributeOverrides.GetValue(cc); if (value != null) { Reflection.AddRange.Invoke(attributeOverrides, new object[] { value }); } if (bag.GetType().IsSubclassOf(Reflection.TemplateAsset)) { object value2 = Reflection.TemplateAttributeOverrides.GetValue(bag); if (value2 != null) { Reflection.AddRange.Invoke(attributeOverrides, new object[] { value2 }); } } result = delegate (VisualElement parent) { Reflection.CloneTree.Invoke(visualTreeAsset, new object[] { parent, slotInsertionPoints, attributeOverrides }); }; return result; } catch (Exception) { //Log.Error(ex.Message + ex.StackTrace, new object[0]); } return null; } internal static void CopyTemplateInternal(VisualTreeAsset visualTreeAsset, VisualTreeAsset targetTreeAsset) { try { Reflection.Init(); IList list = Reflection.Using.GetValue(visualTreeAsset) as IList; foreach (object current in list) { if (current != null) { string text = Reflection.UsingAlias.GetValue(current) as string; string text2 = Reflection.UsingPath.GetValue(current) as string; VisualTreeAsset visualTreeAsset2 = Reflection.UsingAsset.GetValue(current) as VisualTreeAsset; if (!text.IsNullOrEmpty()) { if (!text2.IsNullOrEmpty()) { Reflection.RegisterTemplatePath.Invoke(targetTreeAsset, new object[] { text, text2 }); } else { if (visualTreeAsset2 != null) { Reflection.RegisterTemplateAsset.Invoke(targetTreeAsset, new object[] { text, visualTreeAsset2 }); } } } } } } catch (Exception) { //Log.Error(ex.Message + ex.StackTrace, new object[0]); } } internal static void RegisterTemplateInternal(string path, string name, VisualTreeAsset visualTreeAsset) { try { Reflection.Init(); if (!(bool)Reflection.TemplateExists.Invoke(visualTreeAsset, new object[] { name })) { Reflection.RegisterTemplate.Invoke(visualTreeAsset, new object[] { name, path }); } } catch (Exception) { //Log.Error(ex.Message + ex.StackTrace, new object[0]); } } } }