public void SwapGroupMethod(string groupName, EventMethodInfo method, Reorder direction)
{
var group = groups.Find(x => x.GroupName.Equals(groupName));
if (group == null)
{
throw new ArgumentException("group was not found!");
}
if (!group.ContainsMethod(method))
{
throw new ArgumentException("method was not found in the group!");
}
var indexOfMethod = group.IndexOfMethod(x => x.Equals(method));
var nextIndex = indexOfMethod;
if (direction == Reorder.MoveUp)
{
nextIndex--;
}
else if (direction == Reorder.MoveDown)
{
nextIndex++;
}
if (group.Methods.IndexInRange(nextIndex))
{
group.SwapMethods(indexOfMethod, nextIndex);
}
}
public void ReplaceMethod(EventMethodInfo oldMethod, EventMethodInfo newMethod)
{
if (IsReadOnly)
{
throw new MemberAccessException("attribute is read-only (non-Modifiable)!");
}
if (oldMethod == null || newMethod == null)
{
throw new ArgumentException("cannot accept null arguments");
}
var index = _methods.FindIndex(oldMethod.Equals);
if (index == -1)
{
throw new ArgumentException("oldMethod was not found");
}
if (index != -1)
{
_methods[index] = newMethod.Clone() as EventMethodInfo;
}
}
public void ChangeEventGroup(string groupName, string otherGroupName, EventMethodInfo method)
{
if (!ContainsGroup(groupName))
{
throw new ArgumentException("group was not found!");
}
if (!ContainsGroup(otherGroupName))
{
throw new ArgumentException("other group was not found!");
}
if (!IsEventMethodExists(groupName, method))
{
throw new ArgumentException("method was not found in the group");
}
if (IsEventMethodExists(otherGroupName, method))
{
throw new ArgumentException("method with the same signature already exists in the other group");
}
RemoveEvent(groupName, method);
AddEvent(otherGroupName, method);
if (_onModifyListener != null)
{
_onModifyListener();
}
}
public bool IsEventMethodExists(string groupName, EventMethodInfo method)
{
if (!ContainsGroup(groupName))
{
return(false);
}
return(groups.Where(group => group.GroupName.Equals(groupName)).Any(group => group.ContainsMethod(method))); //PluginEvents.UsedEvents.Exists(x=>x.Name== name);
}
internal void HookUpAutomaticHandlers()
{
if (this.SupportAutoEvents)
{
object obj2 = _eventListCache[base.GetType()];
IDictionary dictionary = null;
if (obj2 == null)
{
lock (_lockObject)
{
obj2 = _eventListCache[base.GetType()];
if (obj2 == null)
{
dictionary = new ListDictionary();
this.GetDelegateInformation(dictionary);
if (dictionary.Count == 0)
{
obj2 = _emptyEventSingleton;
}
else
{
obj2 = dictionary;
}
_eventListCache[base.GetType()] = obj2;
}
}
}
if (obj2 != _emptyEventSingleton)
{
dictionary = (IDictionary)obj2;
foreach (string str in dictionary.Keys)
{
EventMethodInfo info = (EventMethodInfo)dictionary[str];
bool flag2 = false;
MethodInfo methodInfo = info.MethodInfo;
Delegate delegate2 = base.Events[_eventObjects[str]];
if (delegate2 != null)
{
foreach (Delegate delegate3 in delegate2.GetInvocationList())
{
if (delegate3.Method.Equals(methodInfo))
{
flag2 = true;
break;
}
}
}
if (!flag2)
{
IntPtr functionPointer = methodInfo.MethodHandle.GetFunctionPointer();
EventHandler handler = new CalliEventHandlerDelegateProxy(this, functionPointer, info.IsArgless).Handler;
base.Events.AddHandler(_eventObjects[str], handler);
}
}
}
}
}
public bool RemoveMethod(EventMethodInfo eventMethod)
{
if (IsReadOnly)
{
throw new MemberAccessException("attribute is read-only (non-Modifiable)!");
}
return(_methods.Remove(eventMethod));
}
public virtual void FireEvent02(EventData eventData)
{
Debug.Assert(eventData != null && !string.IsNullOrWhiteSpace(eventData.EventName));
EventMethodName = string.Format("{0}{1}", eventData.EventName, !eventData.EventName.EndsWith("Event") ? "Event" : "");
EventMethodInfo = GetType().GetMethod(EventMethodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
if (EventMethodInfo != null)
{
EventMethodInfo.Invoke(this, new object[] { eventData.EventParam });
}
}
void DrawBottomButtons()
{
GUILayout.BeginHorizontal();
if (GUILayout.Button(IsInEditMode ? "Edit" : "Create"))
{
try
{
if (IsInEditMode)
{
var methodToAdd = new EventMethodInfo(eventName, args);
if (EventsManager.Instance.GroupsContainer[GroupNames[selectedgroupNamePopupValue]].ContainsMethod(methodToAdd))
{
throw new ArgumentException("another event method with the same signature already exists.");
}
EventsManager.Instance.GroupsContainer.RemoveEvent(ContainingGroup, eventmethod);
EventsManager.Instance.GroupsContainer.AddEvent(GroupNames[selectedgroupNamePopupValue], methodToAdd);
}
else
{
EventsManager.Instance.GroupsContainer.AddEvent(ContainingGroup, new EventMethodInfo(eventName, args));
}
Close();
}
catch (Exception e)
{
errorString = e.Message;
}
}
if (GUILayout.Button("Close"))
{
Close();
}
GUILayout.EndHorizontal();
if (!string.IsNullOrEmpty(errorString))
{
GUILayout.BeginHorizontal();
var tempColor = GUI.color;
GUI.color = Color.red;
GUILayout.Label(errorString);
GUI.color = tempColor;
GUILayout.EndHorizontal();
}
}
public EventMethodModifier(EventMethodsGroup containingGroup, EventMethodInfo method)
{
if (containingGroup == null || method == null)
{
throw new ArgumentException("arguments cannot be null!");
}
if (!containingGroup.ContainsMethod(method))
{
throw new ArgumentException("the method must be contained in the group in order!");
}
_containingGroup = containingGroup;
_method = method;
}
//------------------------------------
public void AddEvent(string groupName, EventMethodInfo method)
{
var temp = groups.Find(x => x.GroupName.Equals(groupName));
if (temp == null)
{
throw new ArgumentException("group was not found!");
}
temp.AddMethod(method);
if (_onModifyListener != null)
{
_onModifyListener();
}
}
private bool GetDelegateInformationFromMethod(string methodName, IDictionary dictionary)
{
EventHandler handler = (EventHandler)Delegate.CreateDelegate(typeof(EventHandler), this, methodName, true, false);
if (handler != null)
{
dictionary[methodName] = new EventMethodInfo(handler.Method, false);
return(true);
}
VoidMethod method = (VoidMethod)Delegate.CreateDelegate(typeof(VoidMethod), this, methodName, true, false);
if (method != null)
{
dictionary[methodName] = new EventMethodInfo(method.Method, true);
return(true);
}
return(false);
}
//methods---------------------------------------------------------------------------
public void AddMethod(EventMethodInfo eventMethod)
{
if (IsReadOnly)
{
throw new MemberAccessException("attribute is read-only (non-Modifiable)!");
}
if (eventMethod == null)
{
throw new ArgumentException("cannot add a null method");
}
if (_methods.Contains(eventMethod))
{
throw new ArgumentException("method with the same signature already exits");
}
_methods.Add(eventMethod.Clone() as EventMethodInfo);
}
//----------------------------------------------
public void Initialize(string containingGroupName, EventMethodInfo eventMethod)
{
if (EventsManager.Instance.GroupsContainer.ContainsGroup(containingGroupName))
{
ContainingGroup = containingGroupName;
selectedgroupNamePopupValue = GroupNames.ToList().IndexOf(containingGroupName);
if (EventsManager.Instance.GroupsContainer[containingGroupName].ContainsMethod(eventMethod))
{
this.eventmethod = eventMethod;
eventName = eventMethod.Name;
Args = eventMethod.Args.ToList();
}
}
else
{
Close();
}
}
private bool GetDelegateInformationFromMethod(string methodName, IDictionary dictionary)
{
EventHandler handler = (EventHandler) Delegate.CreateDelegate(typeof(EventHandler), this, methodName, true, false);
if (handler != null)
{
dictionary[methodName] = new EventMethodInfo(handler.Method, false);
return true;
}
VoidMethod method = (VoidMethod) Delegate.CreateDelegate(typeof(VoidMethod), this, methodName, true, false);
if (method != null)
{
dictionary[methodName] = new EventMethodInfo(method.Method, true);
return true;
}
return false;
}
public ReadOnlyEventMethodInfo(EventMethodInfo other) : base(other)
{
}
public bool ContainsMethod(EventMethodInfo other)
{
return(_methods.Exists(x => x.Equals(other)));
}
