/// <summary>
/// Invokes all the handlers that have been
/// added to the route
/// </summary>
/// <remarks>
/// NOTE: If the <see cref="RoutingStrategy"/>
/// of the associated <see cref="RoutedEvent"/>
/// is <see cref="RoutingStrategy.Bubble"/>
/// the last handlers added are the
/// last ones invoked <para/>
/// However if the <see cref="RoutingStrategy"/>
/// of the associated <see cref="RoutedEvent"/>
/// is <see cref="RoutingStrategy.Tunnel"/>,
/// the last handlers added are the
/// first ones invoked.
/// However the handlers for a particular object
/// are always invoked in the order they were added
/// regardless of whether its a tunnel or buble.
///
/// </remarks>
/// <param name="source">
/// <see cref="RoutedEventArgs.Source"/>
/// that raised the RoutedEvent
/// </param>
/// <param name="args">
/// <see cref="RoutedEventArgs"/> that carry
/// all the details specific to this RoutedEvent
/// </param>
internal void InvokeHandlers(object source, RoutedEventArgs args)
{
// Check RoutingStrategy to know the order of invocation
if (args.RoutedEvent.RoutingStrategy == RoutingStrategy.Bubble ||
args.RoutedEvent.RoutingStrategy == RoutingStrategy.Direct)
{
// If the RoutingStrategy of the associated is
// Bubble the handlers for the last target
// added are the last ones invoked
// Invoke class listeners
for (int i = 0, count = _routeItemList.Count; i < count; i++)
{
RouteItem ri = ((RouteItem)_routeItemList[i]);
args.InvokeHandler(ri);
}
}
else
{
int endTargetIndex = _routeItemList.Count - 1;
int startTargetIndex;
// If the RoutingStrategy of the associated is
// Tunnel the handlers for the last target
// added are the first ones invoked
while (endTargetIndex >= 0)
{
// For tunnel events we need to invoke handlers for the last target first.
// However the handlers for that individual target must be fired in the right order.
object currTarget = ((RouteItem)_routeItemList[endTargetIndex]).Target;
for (startTargetIndex = endTargetIndex; startTargetIndex >= 0; startTargetIndex--)
{
if (((RouteItem)_routeItemList[startTargetIndex]).Target != currTarget)
{
if (startTargetIndex == endTargetIndex && endTargetIndex > 0)
{
endTargetIndex--;
}
else
{
break;
}
}
}
for (int i = startTargetIndex + 1; i <= endTargetIndex; i++)
{
RouteItem ri = ((RouteItem)_routeItemList[i]);
args.InvokeHandler(ri);
}
endTargetIndex = startTargetIndex;
}
}
}
/// <summary>
/// Adds this handler for the
/// specified target to the route
/// </summary>
/// <remarks>
/// NOTE: It is not an error to add a
/// handler for a particular target instance
/// twice (handler will simply be called twice).
/// </remarks>
/// <param name="target">
/// Target object whose handler is to be
/// added to the route
/// </param>
/// <param name="handler">
/// Handler to be added to the route
/// </param>
/// <param name="handledEventsToo">
/// Flag indicating whether or not the listener wants to
/// hear about events that have already been handled
/// </param>
// need to consider creating an AddImpl, and consider if we even need to
// make this public?
public void Add(object target, Delegate handler, bool handledEventsToo)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
RouteItem routeItem = new RouteItem(target, new RoutedEventHandlerInfo(handler, handledEventsToo));
_routeItemList.Add(routeItem);
}
/// <summary>
/// Invokes the handler associated with the specified RouteItem
/// </summary>
/// <param name="routeItem">
/// RouteItem containing handler and target
/// </param>
internal void InvokeHandler(RouteItem routeItem)
{
RoutedEventHandlerInfo routedEventHandlerInfo = routeItem._routedEventHandlerInfo;
if (this.Handled == false || routedEventHandlerInfo._handledEventsToo == true)
{
Delegate handler = routedEventHandlerInfo._handler;
_flags |= Flags.InvokingHandler;
try
{
handler.Method.Invoke(handler.Target, new object[] { routeItem._target, this });
}
finally
{
_flags &= ~Flags.InvokingHandler;
}
}
}
/// <summary>
/// Invokes the handler associated with the specified RouteItem
/// </summary>
/// <param name="routeItem">
/// RouteItem containing handler and target
/// </param>
internal void InvokeHandler(RouteItem routeItem)
{
RoutedEventHandlerInfo routedEventHandlerInfo = routeItem._routedEventHandlerInfo;
if (this.Handled == false || routedEventHandlerInfo._handledEventsToo == true)
{
RoutedEventHandler handler = routedEventHandlerInfo._handler;
_flags |= Flags.InvokingHandler;
try
{
handler(routeItem._target, this);
}
finally
{
_flags &= ~Flags.InvokingHandler;
}
}
}
/// <summary>
/// Adds this handler for the
/// specified target to the route
/// </summary>
/// <remarks>
/// NOTE: It is not an error to add a
/// handler for a particular target instance
/// twice (handler will simply be called twice).
/// </remarks>
/// <param name="target">
/// Target object whose handler is to be
/// added to the route
/// </param>
/// <param name="handler">
/// Handler to be added to the route
/// </param>
/// <param name="handledEventsToo">
/// Flag indicating whether or not the listener wants to
/// hear about events that have already been handled
/// </param>
// need to consider creating an AddImpl, and consider if we even need to
// make this public?
public void Add(object target, RoutedEventHandler handler, bool handledEventsToo)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
RouteItem routeItem = new RouteItem(target, new RoutedEventHandlerInfo(handler, handledEventsToo));
_routeItemList.Add(routeItem);
}
/// <summary>
/// Invokes the handler associated with the specified RouteItem
/// </summary>
/// <param name="routeItem">
/// RouteItem containing handler and target
/// </param>
internal void InvokeHandler(RouteItem routeItem)
{
RoutedEventHandlerInfo routedEventHandlerInfo = routeItem._routedEventHandlerInfo;
if (this.Handled == false || routedEventHandlerInfo._handledEventsToo == true)
{
Delegate handler = routedEventHandlerInfo._handler;
_flags |= Flags.InvokingHandler;
try
{
handler.Method.Invoke(handler.Target, new object[] { routeItem._target, this });
}
finally
{
_flags &= ~Flags.InvokingHandler;
}
}
}
/// <summary>
/// Is the given RouteItem equals the current
/// </summary>
public bool Equals(RouteItem routeItem)
{
return (
routeItem._target == this._target &&
routeItem._routedEventHandlerInfo == this._routedEventHandlerInfo);
}
/// <summary>
/// Invokes the handler associated with the specified RouteItem
/// </summary>
/// <param name="routeItem">
/// RouteItem containing handler and target
/// </param>
internal void InvokeHandler(RouteItem routeItem)
{
RoutedEventHandlerInfo routedEventHandlerInfo = routeItem._routedEventHandlerInfo;
if (this.Handled == false || routedEventHandlerInfo._handledEventsToo == true)
{
RoutedEventHandler handler = routedEventHandlerInfo._handler;
_flags |= Flags.InvokingHandler;
try
{
handler(routeItem._target, this);
}
finally
{
_flags &= ~Flags.InvokingHandler;
}
}
}
/// <summary>
/// Is the given RouteItem equals the current
/// </summary>
public bool Equals(RouteItem routeItem)
{
return(
routeItem._target == this._target &&
routeItem._routedEventHandlerInfo == this._routedEventHandlerInfo);
}
