public virtual void OnBorrowed(object target, Type targetType, ReflectionInspector inspector) { this.ParentInspector = inspector ?? throw new ArgumentNullException(nameof(inspector)); if (!this.UIRoot) { CreateContent(inspector.UIRoot); } else { this.UIRoot.transform.SetParent(inspector.UIRoot.transform); } this.UIRoot.transform.SetSiblingIndex(inspector.UIRoot.transform.childCount - 2); UnityObjectRef = (UnityEngine.Object)target.TryCast(typeof(UnityEngine.Object)); UIRoot.SetActive(true); nameInput.Text = UnityObjectRef.name; instanceIdInput.Text = UnityObjectRef.GetInstanceID().ToString(); if (typeof(Component).IsAssignableFrom(targetType)) { ComponentRef = (Component)target.TryCast(typeof(Component)); gameObjectButton.Component.gameObject.SetActive(true); } else { gameObjectButton.Component.gameObject.SetActive(false); } }
public override void SetInspectorOwner(ReflectionInspector inspector, MemberInfo member) { Type ctorReturnType; // if is parameterless struct ctor if (typeForStructConstructor != null) { ctorReturnType = typeForStructConstructor; this.Owner = inspector; // eg. Vector3.Vector3() this.NameLabelText = SignatureHighlighter.Parse(typeForStructConstructor, false); NameLabelText += $".{NameLabelText}()"; this.NameForFiltering = SignatureHighlighter.RemoveHighlighting(NameLabelText); this.NameLabelTextRaw = NameForFiltering; return; } else { base.SetInspectorOwner(inspector, member); Arguments = CtorInfo.GetParameters(); ctorReturnType = CtorInfo.DeclaringType; } if (ctorReturnType.IsGenericTypeDefinition) { GenericArguments = ctorReturnType.GetGenericArguments(); } }
public override void SetInspectorOwner(ReflectionInspector inspector, MemberInfo member) { base.SetInspectorOwner(inspector, member); Arguments = MethodInfo.GetParameters(); if (MethodInfo.IsGenericMethod) { GenericArguments = MethodInfo.GetGenericArguments(); } }
public override void OnBorrowed(object target, Type targetType, ReflectionInspector inspector) { base.OnBorrowed(target, targetType, inspector); TextureRef = target.TryCast <Texture2D>(); realWidth = TextureRef.width; realHeight = TextureRef.height; if (this.textureViewerRoot) { this.textureViewerRoot.transform.SetParent(inspector.UIRoot.transform); } InspectorPanel.Instance.Dragger.OnFinishResize += OnInspectorFinishResize; }
public override void OnBorrowed(object target, Type targetType, ReflectionInspector inspector) { base.OnBorrowed(target, targetType, inspector); this.audioPlayerRoot.transform.SetParent(inspector.UIRoot.transform); this.audioPlayerRoot.transform.SetSiblingIndex(inspector.UIRoot.transform.childCount - 2); RefAudioClip = target.TryCast <AudioClip>(); this.fullLengthText = GetLengthString(RefAudioClip.length); if (RefAudioClip.loadType == AudioClipLoadType.DecompressOnLoad) { cantSaveRow.SetActive(false); saveObjectRow.SetActive(true); SetDefaultSavePath(); } else { cantSaveRow.SetActive(true); saveObjectRow.SetActive(false); } ResetProgressLabel(); }
public override void SetInspectorOwner(ReflectionInspector inspector, MemberInfo member) { base.SetInspectorOwner(inspector, member); Arguments = PropertyInfo.GetIndexParameters(); }
public virtual void OnReturnToPool() { UnityObjectRef = null; ComponentRef = null; ParentInspector = null; }
public override void SetInspectorOwner(ReflectionInspector inspector, MemberInfo member) { base.SetInspectorOwner(inspector, member); }
public static UnityObjectWidget GetUnityWidget(object target, Type targetType, ReflectionInspector inspector) { if (!typeof(UnityEngine.Object).IsAssignableFrom(targetType)) { return(null); } UnityObjectWidget ret; if (targetType == typeof(Texture2D)) { ret = Pool <Texture2DWidget> .Borrow(); } else if (targetType == typeof(AudioClip)) { ret = Pool <AudioClipWidget> .Borrow(); } else { ret = Pool <UnityObjectWidget> .Borrow(); } ret.OnBorrowed(target, targetType, inspector); return(ret); }
public virtual void SetInspectorOwner(ReflectionInspector inspector, MemberInfo member) { this.Owner = inspector; this.NameLabelText = SignatureHighlighter.Parse(member.DeclaringType, false, member); this.NameForFiltering = $"{member.DeclaringType.Name}.{member.Name}"; }
private static void TryCacheMember(MemberInfo member, List <CacheMember> list, HashSet <string> cachedSigs, Type declaringType, ReflectionInspector _inspector, bool ignorePropertyMethodInfos = true) { try { if (ReflectionUtility.IsBlacklisted(member)) { return; } var sig = GetSig(member); //ExplorerCore.Log($"Trying to cache member {sig}..."); CacheMember cached; Type returnType; switch (member.MemberType) { case MemberTypes.Method: { var mi = member as MethodInfo; if (ignorePropertyMethodInfos && (mi.Name.StartsWith("get_") || mi.Name.StartsWith("set_"))) { return; } var args = mi.GetParameters(); if (!CanParseArgs(args)) { return; } sig += GetArgumentString(args); if (cachedSigs.Contains(sig)) { return; } cached = new CacheMethod() { MethodInfo = mi }; returnType = mi.ReturnType; break; } case MemberTypes.Property: { var pi = member as PropertyInfo; var args = pi.GetIndexParameters(); if (!CanParseArgs(args)) { return; } if (!pi.CanRead && pi.CanWrite) { // write-only property, cache the set method instead. var setMethod = pi.GetSetMethod(true); if (setMethod != null) { TryCacheMember(setMethod, list, cachedSigs, declaringType, _inspector, false); } return; } sig += GetArgumentString(args); if (cachedSigs.Contains(sig)) { return; } cached = new CacheProperty() { PropertyInfo = pi }; returnType = pi.PropertyType; break; } case MemberTypes.Field: { var fi = member as FieldInfo; cached = new CacheField() { FieldInfo = fi }; returnType = fi.FieldType; break; } default: return; } cachedSigs.Add(sig); //cached.Initialize(_inspector, declaringType, member, returnType); cached.SetFallbackType(returnType); cached.SetInspectorOwner(_inspector, member); list.Add(cached); } catch (Exception e) { ExplorerCore.LogWarning($"Exception caching member {member.DeclaringType.FullName}.{member.Name}!"); ExplorerCore.Log(e.ToString()); } }
public static List <CacheMember> GetCacheMembers(object inspectorTarget, Type _type, ReflectionInspector _inspector) { var list = new List <CacheMember>(); var cachedSigs = new HashSet <string>(); var types = ReflectionUtility.GetAllBaseTypes(_type); var flags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static; if (!_inspector.StaticOnly) { flags |= BindingFlags.Instance; } var infos = new List <MemberInfo>(); foreach (var declaringType in types) { var target = inspectorTarget; if (!_inspector.StaticOnly) { target = target.TryCast(declaringType); } infos.Clear(); infos.AddRange(declaringType.GetProperties(flags)); infos.AddRange(declaringType.GetFields(flags)); infos.AddRange(declaringType.GetMethods(flags)); foreach (var member in infos) { if (member.DeclaringType != declaringType) { continue; } TryCacheMember(member, list, cachedSigs, declaringType, _inspector); } } var typeList = types.ToList(); var sorted = new List <CacheMember>(); sorted.AddRange(list.Where(it => it is CacheProperty) .OrderBy(it => typeList.IndexOf(it.DeclaringType)) .ThenBy(it => it.NameForFiltering)); sorted.AddRange(list.Where(it => it is CacheField) .OrderBy(it => typeList.IndexOf(it.DeclaringType)) .ThenBy(it => it.NameForFiltering)); sorted.AddRange(list.Where(it => it is CacheMethod) .OrderBy(it => typeList.IndexOf(it.DeclaringType)) .ThenBy(it => it.NameForFiltering)); return(sorted); }
public static List <CacheMember> GetCacheMembers(object inspectorTarget, Type type, ReflectionInspector inspector) { //var list = new List<CacheMember>(); HashSet <string> cachedSigs = new(); List <CacheMember> props = new(); List <CacheMember> fields = new(); List <CacheMember> ctors = new(); List <CacheMember> methods = new(); var types = ReflectionUtility.GetAllBaseTypes(type); var flags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static; if (!inspector.StaticOnly) { flags |= BindingFlags.Instance; } if (!type.IsAbstract) { // Get non-static constructors of the main type. // There's no reason to get the static cctor, it will be invoked when we inspect the class. // Also no point getting ctors on inherited types. foreach (var ctor in type.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)) { TryCacheMember(ctor, ctors, cachedSigs, type, inspector); } // structs always have a parameterless constructor if (type.IsValueType) { CacheConstructor cached = new(type); cached.SetFallbackType(type); cached.SetInspectorOwner(inspector, null); ctors.Add(cached); } } foreach (var declaringType in types) { var target = inspectorTarget; if (!inspector.StaticOnly) { target = target.TryCast(declaringType); } foreach (var prop in declaringType.GetProperties(flags)) { if (prop.DeclaringType == declaringType) { TryCacheMember(prop, props, cachedSigs, declaringType, inspector); } } foreach (var field in declaringType.GetFields(flags)) { if (field.DeclaringType == declaringType) { TryCacheMember(field, fields, cachedSigs, declaringType, inspector); } } foreach (var method in declaringType.GetMethods(flags)) { if (method.DeclaringType == declaringType) { TryCacheMember(method, methods, cachedSigs, declaringType, inspector); } } } var sorted = new List <CacheMember>(); sorted.AddRange(props.OrderBy(it => Array.IndexOf(types, it.DeclaringType)) .ThenBy(it => it.NameForFiltering)); sorted.AddRange(fields.OrderBy(it => Array.IndexOf(types, it.DeclaringType)) .ThenBy(it => it.NameForFiltering)); sorted.AddRange(ctors.OrderBy(it => Array.IndexOf(types, it.DeclaringType)) .ThenBy(it => it.NameForFiltering)); sorted.AddRange(methods.OrderBy(it => Array.IndexOf(types, it.DeclaringType)) .ThenBy(it => it.NameForFiltering)); return(sorted); }
static void TryCacheMember( MemberInfo member, IList list, HashSet <string> cachedSigs, Type declaringType, ReflectionInspector inspector, bool ignorePropertyMethodInfos = true) { try { if (UERuntimeHelper.IsBlacklisted(member)) { return; } string sig = member switch { MethodBase mb => mb.FullDescription(), PropertyInfo or FieldInfo => $"{member.DeclaringType.FullDescription()}.{member.Name}", _ => throw new NotImplementedException(), }; if (cachedSigs.Contains(sig)) { return; } // ExplorerCore.Log($"Trying to cache member {sig}... ({member.MemberType})"); CacheMember cached; Type returnType; switch (member.MemberType) { case MemberTypes.Constructor: { var ci = member as ConstructorInfo; cached = new CacheConstructor(ci); returnType = ci.DeclaringType; } break; case MemberTypes.Method: { var mi = member as MethodInfo; if (ignorePropertyMethodInfos && (mi.Name.StartsWith("get_") || mi.Name.StartsWith("set_"))) { return; } cached = new CacheMethod(mi); returnType = mi.ReturnType; break; } case MemberTypes.Property: { var pi = member as PropertyInfo; if (!pi.CanRead && pi.CanWrite) { // write-only property, cache the set method instead. var setMethod = pi.GetSetMethod(true); if (setMethod != null) { TryCacheMember(setMethod, list, cachedSigs, declaringType, inspector, false); } return; } cached = new CacheProperty(pi); returnType = pi.PropertyType; break; } case MemberTypes.Field: { var fi = member as FieldInfo; cached = new CacheField(fi); returnType = fi.FieldType; break; } default: throw new NotImplementedException(); } cachedSigs.Add(sig); cached.SetFallbackType(returnType); cached.SetInspectorOwner(inspector, member); list.Add(cached); } catch (Exception e) { ExplorerCore.LogWarning($"Exception caching member {member.DeclaringType.FullName}.{member.Name}!"); ExplorerCore.Log(e.ToString()); } }