public static RegisteredListener RegisterListener(object obj, IPlugin plugin)
{
var registeredListener = new RegisteredListener(obj, plugin);
if (PluginListeners.TryGetValue(plugin, out var list))
{
list.Add(registeredListener);
}
else
{
PluginListeners.Add(plugin, new HashSet <RegisteredListener> {
registeredListener
});
}
foreach (var(type, listeners) in registeredListener.Listeners)
{
foreach (var listener in listeners)
{
if (Events.TryGetValue(type, out var dict))
{
dict[listener.Priority].Add(listener);
}
else
{
ConsoleFunctions.WriteErrorLine($"Type {type.Name} is not registered!");
break;
}
}
}
return(registeredListener);
}
public static MessageListenerFilterRegistrationResult Register(Action <WindowMessageEventArgs> callback)
{
lock (_registerLock)
{
uint message = 0;
RegisteredListener package = _packages.FirstOrDefault(x => x.TryRegister(callback, out message));
if (package == null)
{
package = new RegisteredListener();
if (!package.TryRegister(callback, out message))
{
// this should never happen
throw new ShellException(LocalizedMessages.MessageListenerFilterUnableToRegister);
}
_packages.Add(package);
}
return(new MessageListenerFilterRegistrationResult(
package.Listener.WindowHandle,
message));
}
}
public void Unregister(RegisteredListener listener)
{
if (handlerslots[listener.Priority].Remove(listener))
{
handlers = null;
}
}
public void Register(RegisteredListener listener)
{
if (handlerslots[listener.Priority].Contains(listener))
{
throw new Exception("This listener is already registered to priority " + listener.Priority.ToString());
}
handlers = null;
handlerslots[listener.Priority].Add(listener);
}
public static void UnregisterListener(RegisteredListener listener)
{
PluginListeners[listener.Plugin].Remove(listener);
foreach (var(type, listeners) in listener.Listeners)
{
foreach (var methodListener in listeners)
{
Events[type][methodListener.Priority].Remove(methodListener);
}
}
}
public static void Unregister(IntPtr listenerHandle, uint message)
{
lock (_registerLock)
{
RegisteredListener package = _packages.FirstOrDefault(x => x.Listener.WindowHandle == listenerHandle);
if (package == null || !package.Callbacks.Remove(message))
{
throw new ArgumentException(LocalizedMessages.MessageListenerFilterUnknownListenerHandle);
}
if (package.Callbacks.Count == 0)
{
package.Listener.Dispose();
_packages.Remove(package);
}
}
}
public static MessageListenerFilterRegistrationResult Register(Action<WindowMessageEventArgs> callback) {
lock (_registerLock) {
uint message = 0;
var package = _packages.FirstOrDefault(x => x.TryRegister(callback, out message));
if (package == null) {
package = new RegisteredListener();
if (!package.TryRegister(callback, out message)) { // this should never happen
throw new ShellException(LocalizedMessages.MessageListenerFilterUnableToRegister);
}
_packages.Add(package);
}
return new MessageListenerFilterRegistrationResult(
package.Listener.WindowHandle,
message);
}
}
public static void Unregister(RegisteredListener listener){
if (_Instance.listeners.Contains(listener)){
_Instance.listeners.Remove(listener);
_Instance.numListeners[(int)listener.type]--;
}
}
public static void Register(RegisteredListener listener){
if (_Instance == null) CreateInstance();
if (!_Instance.listeners.Contains(listener)){
_Instance.listeners.Add(listener);
_Instance.numListeners[(int)listener.type]++;
}
}
public MethodListener(EventPriority priority, MethodInfo method, RegisteredListener listener)
{
Priority = priority;
Method = method;
Listener = listener;
}
public static Dictionary <Type, List <MethodListener> > GetListeners(object obj, RegisteredListener listener)
{
var result = new Dictionary <Type, List <MethodListener> >();
foreach (var method in obj.GetType().GetMethods(
BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic))
{
foreach (var attribute1 in method.GetCustomAttributes(typeof(EListener)))
{
var attribute = (EListener)attribute1;
if (Events.ContainsKey(attribute.EventType))
{
if (result.TryGetValue(attribute.EventType, out var val))
{
val.Add(new MethodListener(attribute.Priority, method, listener));
}
else
{
result.Add(attribute.EventType,
new List <MethodListener>()
{
new MethodListener(attribute.Priority, method, listener)
});
}
}
else
{
ConsoleFunctions.WriteWarningLine($"{attribute.EventType.FullName} is not registered!");
}
}
}
return(result);
}
