/// <summary>
/// Finds a specific <see cref="RoutedEvent"/> identifier for a specific object type.
/// </summary>
/// <param name="ownerType">The type to start search with. Base types are included. Must not be null.</param>
/// <param name="eventName">Name of the event. Must not be null or empty.</param>
/// <param name="checkBaseTypes"><c>true</c> if all base types up to <see cref="UIElement"/> should be checked as well; <c>false</c> if only <param name="ownerType"/> should be checked</param>
/// <returns>The routed event identifier or <c>null</c> if not found.</returns>
public static RoutedEvent GetRoutedEventForOwner(Type ownerType, string eventName, bool checkBaseTypes)
{
if (ownerType == null)
{
throw new ArgumentNullException("ownerType");
}
if (eventName == null)
{
throw new ArgumentNullException("eventName");
}
if (String.IsNullOrEmpty(eventName))
{
throw new ArgumentException(@"Event name must not be an empty string", "eventName");
}
do
{
foreach (var routedEvent in GlobalEventManager.GetRoutedEventsForOwner(ownerType))
{
if (routedEvent.Name.Equals(eventName))
{
return(routedEvent);
}
}
if (ownerType == typeof(UIElement))
{
break;
}
// ReSharper disable once PossibleNullReferenceException
ownerType = ownerType.BaseType;
// ReSharper disable once LoopVariableIsNeverChangedInsideLoop
} while (checkBaseTypes);
return(null);
}
/// <summary>
/// Finds all <see cref="RoutedEvent"/> identifiers owned by a specified object type.
/// </summary>
/// <param name="ownerType">The type to start search with. Base types are included. Must not be null.</param>
/// <returns></returns>
public static RoutedEvent[] GetRoutedEventsForOwner(Type ownerType)
{
if (ownerType == null)
{
throw new ArgumentNullException("ownerType");
}
return(GlobalEventManager.GetRoutedEventsForOwner(ownerType));
}
/// <summary>
/// Associates another owner with the routed event represented by a <see cref="RoutedEvent"/> instance.
/// </summary>
/// <param name="ownerType">The type where the routed event is added. Must not be null.</param>
/// <returns></returns>
public RoutedEvent AddOwner(Type ownerType)
{
if (ownerType == null)
{
throw new ArgumentNullException("ownerType");
}
GlobalEventManager.AddOwner(this, ownerType);
return(this);
}
/// <summary>
/// REgisteres a class handler for a particular <see cref="RoutedEvent"/> with the option to handle events that have been marked as handled already.
/// </summary>
/// <param name="classType">Type of the class that is declaring class handling. Must not be null.</param>
/// <param name="routedEvent">The <see cref="RoutedEvent"/> identifier of the event to handle. Must not be null.</param>
/// <param name="handler">A reference to the class handler. Must not be null.</param>
/// <param name="handledEventsToo"><c>true</c> to invoke the handler, even if the <see>RoutedEventArgs.Handled</see> property has been set to <c>true</c> already;
/// <c>false</c> to retain the default behavior of not invoking handled events</param>.
public static void RegisterClassHandler(Type classType, RoutedEvent routedEvent, Delegate handler, bool handledEventsToo)
{
if (classType == null)
{
throw new ArgumentNullException("classType");
}
if (routedEvent == null)
{
throw new ArgumentNullException("routedEvent");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
GlobalEventManager.RegisterClassHandler(classType, routedEvent, handler, handledEventsToo);
}
/// <summary>
/// Registers a new event with the event system.
/// </summary>
/// <param name="name">Name of the event. The name must be unique within the owner class. It must not be <c>null</c> or empty.</param>
/// <param name="routingStrategy">The routing strategy for this event.</param>
/// <param name="handlerType">The type of the event handler. Can not be <c>null</c></param>
/// <param name="ownerType">The owner class type of the event. Can not be <c>null</c>.</param>
/// <returns></returns>
public static RoutedEvent RegisterRoutedEvent(string name, RoutingStrategy routingStrategy, Type handlerType, Type ownerType)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (handlerType == null)
{
throw new ArgumentNullException("handlerType");
}
if (ownerType == null)
{
throw new ArgumentNullException("ownerType");
}
if (String.IsNullOrEmpty(name))
{
throw new ArgumentException(@"name must not be an empty string", "name");
}
return(GlobalEventManager.RegisterRoutedEvent(name, routingStrategy, handlerType, ownerType));
}
/// <summary>
/// Returns identifiers for registered <see cref="RoutedEvent"/>s.
/// </summary>
/// <returns>An array of registered routed events.</returns>
public static RoutedEvent[] GetRoutedEvents()
{
return(GlobalEventManager.GetRoutedEvents());
}
