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());
}
}
