349 lines
8.4 KiB
C#
349 lines
8.4 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Reflection;
|
|
using UnityEngine;
|
|
|
|
internal static class vp_TargetEventHandler
|
|
{
|
|
private static List<Dictionary<object, Dictionary<string, Delegate>>> m_TargetDict;
|
|
|
|
private static List<Dictionary<object, Dictionary<string, Delegate>>> TargetDict
|
|
{
|
|
get
|
|
{
|
|
if (m_TargetDict == null)
|
|
{
|
|
m_TargetDict = new List<Dictionary<object, Dictionary<string, Delegate>>>(100);
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
m_TargetDict.Add(new Dictionary<object, Dictionary<string, Delegate>>(100));
|
|
}
|
|
}
|
|
return m_TargetDict;
|
|
}
|
|
}
|
|
|
|
public static void Register(object target, string eventName, Delegate callback, int dictionary)
|
|
{
|
|
if (target == null)
|
|
{
|
|
Debug.LogWarning("Warning: (" + vp_Utility.GetErrorLocation(2) + " -> vp_TargetEvent.Register) Target object is null.");
|
|
return;
|
|
}
|
|
if (string.IsNullOrEmpty(eventName))
|
|
{
|
|
Debug.LogWarning("Warning: (" + vp_Utility.GetErrorLocation(2) + " -> vp_TargetEvent.Register) Event name is null or empty.");
|
|
return;
|
|
}
|
|
if ((object)callback == null)
|
|
{
|
|
Debug.LogWarning("Warning: (" + vp_Utility.GetErrorLocation(2) + " -> vp_TargetEvent.Register) Callback is null.");
|
|
return;
|
|
}
|
|
if (callback.Method.Name.StartsWith("<"))
|
|
{
|
|
Debug.LogWarning("Warning: (" + vp_Utility.GetErrorLocation(2) + " -> vp_TargetEvent.Register) Target events can only be registered to declared methods.");
|
|
return;
|
|
}
|
|
if (!TargetDict[dictionary].ContainsKey(target))
|
|
{
|
|
TargetDict[dictionary].Add(target, new Dictionary<string, Delegate>(100));
|
|
}
|
|
Dictionary<string, Delegate> value;
|
|
TargetDict[dictionary].TryGetValue(target, out value);
|
|
Delegate value2;
|
|
while (true)
|
|
{
|
|
value.TryGetValue(eventName, out value2);
|
|
if ((object)value2 == null)
|
|
{
|
|
value.Add(eventName, callback);
|
|
return;
|
|
}
|
|
if (value2.GetType() == callback.GetType())
|
|
{
|
|
break;
|
|
}
|
|
eventName += "_";
|
|
}
|
|
callback = Delegate.Combine(value2, callback);
|
|
if ((object)callback != null)
|
|
{
|
|
value.Remove(eventName);
|
|
value.Add(eventName, callback);
|
|
}
|
|
}
|
|
|
|
public static void Unregister(object target, string eventName = null, Delegate callback = null)
|
|
{
|
|
if ((eventName != null || (object)callback == null) && ((object)callback != null || eventName == null))
|
|
{
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
Unregister(target, i, eventName, callback);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void Unregister(Component component)
|
|
{
|
|
if (!(component == null))
|
|
{
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
Unregister(i, component);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void Unregister(int dictionary, Component component)
|
|
{
|
|
if (component == null)
|
|
{
|
|
return;
|
|
}
|
|
Dictionary<string, Delegate> value;
|
|
if (TargetDict[dictionary].TryGetValue(component, out value))
|
|
{
|
|
TargetDict[dictionary].Remove(component);
|
|
}
|
|
object transform = component.transform;
|
|
if (transform == null || !TargetDict[dictionary].TryGetValue(transform, out value))
|
|
{
|
|
return;
|
|
}
|
|
List<string> list = new List<string>(value.Keys);
|
|
foreach (string item in list)
|
|
{
|
|
Delegate value2;
|
|
if (item == null || !value.TryGetValue(item, out value2) || (object)value2 == null)
|
|
{
|
|
continue;
|
|
}
|
|
Delegate[] invocationList = value2.GetInvocationList();
|
|
if (invocationList == null || invocationList.Length < 1)
|
|
{
|
|
continue;
|
|
}
|
|
for (int num = invocationList.Length - 1; num > -1; num--)
|
|
{
|
|
if (invocationList[num].Target == component)
|
|
{
|
|
value.Remove(item);
|
|
Delegate obj = Delegate.Remove(value2, invocationList[num]);
|
|
if (obj.GetInvocationList().Length > 0)
|
|
{
|
|
value.Add(item, obj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void Unregister(object target, int dictionary, string eventName, Delegate callback)
|
|
{
|
|
Dictionary<string, Delegate> value;
|
|
if (target == null || !TargetDict[dictionary].TryGetValue(target, out value) || value == null || value.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
if (eventName == null && (object)callback == null)
|
|
{
|
|
TargetDict[dictionary].Remove(value);
|
|
}
|
|
else
|
|
{
|
|
Delegate value2;
|
|
if (!value.TryGetValue(eventName, out value2))
|
|
{
|
|
return;
|
|
}
|
|
if ((object)value2 != null)
|
|
{
|
|
value.Remove(eventName);
|
|
value2 = Delegate.Remove(value2, callback);
|
|
if ((object)value2 != null && value2.GetInvocationList() != null)
|
|
{
|
|
value.Add(eventName, value2);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
value.Remove(eventName);
|
|
}
|
|
if (value.Count <= 0)
|
|
{
|
|
TargetDict[dictionary].Remove(target);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void UnregisterAll()
|
|
{
|
|
m_TargetDict = null;
|
|
}
|
|
|
|
public static Delegate GetCallback(object target, string eventName, bool upwards, int d, vp_TargetEventOptions options)
|
|
{
|
|
if (target == null)
|
|
{
|
|
return null;
|
|
}
|
|
if (string.IsNullOrEmpty(eventName))
|
|
{
|
|
return null;
|
|
}
|
|
Delegate value;
|
|
do
|
|
{
|
|
value = null;
|
|
if ((options & vp_TargetEventOptions.IncludeInactive) == vp_TargetEventOptions.IncludeInactive)
|
|
{
|
|
goto IL_008c;
|
|
}
|
|
GameObject gameObject = target as GameObject;
|
|
if (gameObject != null)
|
|
{
|
|
if (vp_Utility.IsActive(gameObject))
|
|
{
|
|
goto IL_008c;
|
|
}
|
|
if (!upwards)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Behaviour behaviour = target as Behaviour;
|
|
if (!(behaviour != null) || (behaviour.enabled && vp_Utility.IsActive(behaviour.gameObject)))
|
|
{
|
|
goto IL_008c;
|
|
}
|
|
if (!upwards)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
goto IL_00ce;
|
|
IL_00ce:
|
|
if ((object)value != null || !upwards)
|
|
{
|
|
break;
|
|
}
|
|
target = vp_Utility.GetParent(target as Component);
|
|
continue;
|
|
IL_008c:
|
|
Dictionary<string, Delegate> value2 = null;
|
|
if (!TargetDict[d].TryGetValue(target, out value2))
|
|
{
|
|
if (!upwards)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
else if (!value2.TryGetValue(eventName, out value) && !upwards)
|
|
{
|
|
return null;
|
|
}
|
|
goto IL_00ce;
|
|
}
|
|
while (target != null);
|
|
return value;
|
|
}
|
|
|
|
public static void OnNoReceiver(string eventName, vp_TargetEventOptions options)
|
|
{
|
|
if ((options & vp_TargetEventOptions.RequireReceiver) == vp_TargetEventOptions.RequireReceiver)
|
|
{
|
|
Debug.LogError("Error: (" + vp_Utility.GetErrorLocation(2) + ") vp_TargetEvent '" + eventName + "' has no receiver!");
|
|
}
|
|
}
|
|
|
|
public static string Dump()
|
|
{
|
|
Dictionary<object, string> dictionary = new Dictionary<object, string>();
|
|
foreach (Dictionary<object, Dictionary<string, Delegate>> item in TargetDict)
|
|
{
|
|
foreach (object key in item.Keys)
|
|
{
|
|
string text = string.Empty;
|
|
if (key == null)
|
|
{
|
|
continue;
|
|
}
|
|
Dictionary<string, Delegate> value;
|
|
if (item.TryGetValue(key, out value))
|
|
{
|
|
foreach (string key2 in value.Keys)
|
|
{
|
|
text = text + " \"" + key2 + "\" -> ";
|
|
bool flag = false;
|
|
Delegate value2;
|
|
if (string.IsNullOrEmpty(key2) || !value.TryGetValue(key2, out value2))
|
|
{
|
|
continue;
|
|
}
|
|
if (value2.GetInvocationList().Length > 1)
|
|
{
|
|
flag = true;
|
|
text += "\n";
|
|
}
|
|
Delegate[] invocationList = value2.GetInvocationList();
|
|
foreach (Delegate obj in invocationList)
|
|
{
|
|
string text2 = text;
|
|
text = string.Concat(text2, (!flag) ? string.Empty : " ", obj.Method.ReflectedType, ".cs -> ");
|
|
string text3 = string.Empty;
|
|
ParameterInfo[] parameters = obj.Method.GetParameters();
|
|
foreach (ParameterInfo parameterInfo in parameters)
|
|
{
|
|
text2 = text3;
|
|
text3 = text2 + vp_Utility.GetTypeAlias(parameterInfo.ParameterType) + " " + parameterInfo.Name + ", ";
|
|
}
|
|
if (text3.Length > 0)
|
|
{
|
|
text3 = text3.Remove(text3.LastIndexOf(", "));
|
|
}
|
|
text = text + vp_Utility.GetTypeAlias(obj.Method.ReturnType) + " ";
|
|
if (obj.Method.Name.Contains("m_"))
|
|
{
|
|
string text4 = obj.Method.Name.TrimStart('<');
|
|
text4 = text4.Remove(text4.IndexOf('>'));
|
|
text = text + text4 + " -> delegate";
|
|
}
|
|
else
|
|
{
|
|
text += obj.Method.Name;
|
|
}
|
|
text = text + "(" + text3 + ")\n";
|
|
}
|
|
}
|
|
}
|
|
string value3;
|
|
if (!dictionary.TryGetValue(key, out value3))
|
|
{
|
|
dictionary.Add(key, text);
|
|
continue;
|
|
}
|
|
dictionary.Remove(key);
|
|
dictionary.Add(key, value3 + text);
|
|
}
|
|
}
|
|
string text5 = "--- TARGET EVENT DUMP ---\n\n";
|
|
foreach (object key3 in dictionary.Keys)
|
|
{
|
|
if (key3 != null)
|
|
{
|
|
text5 = text5 + key3.ToString() + ":\n";
|
|
string value4;
|
|
if (dictionary.TryGetValue(key3, out value4))
|
|
{
|
|
text5 += value4;
|
|
}
|
|
}
|
|
}
|
|
return text5;
|
|
}
|
|
}
|