public void AddRoutedEventHandler(RoutedEvent routedEvent, Delegate handler, bool handledEventsToo)
{
if (_routedEventHandlers == null)
{
_routedEventHandlers = new RoutedEventHandlerInfoList();
}
_routedEventHandlers.AddHandler(routedEvent, handler, handledEventsToo);
}
public void AddRoutedEventHandler(RoutedEvent routedEvent, Delegate handler, bool handledEventsToo)
{
if (_routedEventHandlers == null)
{
_routedEventHandlers = new RoutedEventHandlerInfoList();
}
_routedEventHandlers.AddHandler(routedEvent, handler, handledEventsToo);
}
public void AddHandler(RoutedEvent routedEvent, Delegate handler, bool handledEventsToo)
{
RoutedEventHandlerInfoList list = _handlers[routedEvent] as RoutedEventHandlerInfoList;
if (list == null)
{
_handlers[routedEvent] = list = new RoutedEventHandlerInfoList();
}
list.AddHandler(routedEvent, handler, handledEventsToo);
}
// Creates reference to given handlers and RoutedEvent
// Returns the index at which the new reference was added
// NOTE: There should not exist a set of handlers for the
// given routedEvent
internal int CreateHandlersLink(RoutedEvent routedEvent, RoutedEventHandlerInfoList handlers)
{
Debug.Assert(GetHandlersIndex(routedEvent) == -1, "There should not exist a set of handlers for the given routedEvent");
ClassHandlers classHandlers = new ClassHandlers();
classHandlers.RoutedEvent = routedEvent;
classHandlers.Handlers = handlers;
classHandlers.HasSelfHandlers = false;
_eventHandlersList.Add(classHandlers);
return _eventHandlersList.Count - 1;
}
// Creates reference to given handlers and RoutedEvent
// Returns the index at which the new reference was added
// NOTE: There should not exist a set of handlers for the
// given routedEvent
internal int CreateHandlersLink(RoutedEvent routedEvent, RoutedEventHandlerInfoList handlers)
{
Debug.Assert(GetHandlersIndex(routedEvent) == -1, "There should not exist a set of handlers for the given routedEvent");
ClassHandlers classHandlers = new ClassHandlers();
classHandlers.RoutedEvent = routedEvent;
classHandlers.Handlers = handlers;
classHandlers.HasSelfHandlers = false;
_eventHandlersList.Add(classHandlers);
return(_eventHandlersList.Count - 1);
}
internal bool Contains(RoutedEventHandlerInfoList handlers)
{
RoutedEventHandlerInfoList tempHandlers = this;
while (tempHandlers != null)
{
if (tempHandlers == handlers)
{
return(true);
}
tempHandlers = tempHandlers.Next;
}
return(false);
}
// Register a Class Handler
// NOTE: Handler Type must be the
// same as the one specified when
// registering the corresponding RoutedEvent
internal static void RegisterClassHandler(
Type classType,
RoutedEvent routedEvent,
Delegate handler,
bool handledEventsToo)
{
Debug.Assert(
typeof(UIElement).IsAssignableFrom(classType) ||
typeof(ContentElement).IsAssignableFrom(classType) ||
typeof(UIElement3D).IsAssignableFrom(classType),
"Class Handlers can be registered only for UIElement/ContentElement/UIElement3D and their sub types");
Debug.Assert(routedEvent.IsLegalHandler(handler),
"Handler Type mismatch");
ClassHandlersStore classListenersLists;
int index;
// We map the classType to a DType use DTypeMap for storage
DependencyObjectType dType = DependencyObjectType.FromSystemTypeInternal(classType);
// Get the updated EventHandlersStore for the given DType
GetDTypedClassListeners(dType, routedEvent, out classListenersLists, out index);
// Reuired to update storage
lock (Synchronized)
{
// Add new routed event handler and get the updated set of handlers
RoutedEventHandlerInfoList updatedClassListeners =
classListenersLists.AddToExistingHandlers(index, handler, handledEventsToo);
// Update Sub Classes
ItemStructList <DependencyObjectType> keys = _dTypedClassListeners.ActiveDTypes;
for (int i = 0; i < keys.Count; i++)
{
if (keys.List[i].IsSubclassOf(dType) == true)
{
classListenersLists = (ClassHandlersStore)_dTypedClassListeners[keys.List[i]];
classListenersLists.UpdateSubClassHandlers(routedEvent, updatedClassListeners);
}
}
}
}
// Adds a routed event handler at the given index of the store
// Returns updated set of handlers
// NOTE: index must be valid, i.e. not -1
internal RoutedEventHandlerInfoList AddToExistingHandlers(
int index,
Delegate handler,
bool handledEventsToo)
{
Debug.Assert(index != -1, "There should exist a set of handlers for the given routedEvent");
// Create a new RoutedEventHandler
RoutedEventHandlerInfo routedEventHandlerInfo =
new RoutedEventHandlerInfo(handler, handledEventsToo);
// Check if we need to create a new node in the linked list
RoutedEventHandlerInfoList handlers = _eventHandlersList.List[index].Handlers;
if (handlers == null || _eventHandlersList.List[index].HasSelfHandlers == false)
{
// Create a new node in the linked list of class
// handlers for this type and routed event.
handlers = new RoutedEventHandlerInfoList();
handlers.Handlers = new RoutedEventHandlerInfo[1];
handlers.Handlers[0] = routedEventHandlerInfo;
handlers.Next = _eventHandlersList.List[index].Handlers;
_eventHandlersList.List[index].Handlers = handlers;
_eventHandlersList.List[index].HasSelfHandlers = true;
}
else
{
// Add this handler to the existing node in the linked list
// of class handlers for this type and routed event.
int length = handlers.Handlers.Length;
RoutedEventHandlerInfo[] mergedHandlers = new RoutedEventHandlerInfo[length + 1];
Array.Copy(handlers.Handlers, 0, mergedHandlers, 0, length);
mergedHandlers[length] = routedEventHandlerInfo;
handlers.Handlers = mergedHandlers;
}
return(handlers);
}
// Adds a routed event handler at the given index of the store
// Returns updated set of handlers
// NOTE: index must be valid, i.e. not -1
internal RoutedEventHandlerInfoList AddToExistingHandlers(
int index,
Delegate handler,
bool handledEventsToo)
{
Debug.Assert(index != -1, "There should exist a set of handlers for the given routedEvent");
// Create a new RoutedEventHandler
RoutedEventHandlerInfo routedEventHandlerInfo =
new RoutedEventHandlerInfo(handler, handledEventsToo);
// Check if we need to create a new node in the linked list
RoutedEventHandlerInfoList handlers = _eventHandlersList.List[index].Handlers;
if (handlers == null || _eventHandlersList.List[index].HasSelfHandlers == false)
{
// Create a new node in the linked list of class
// handlers for this type and routed event.
handlers = new RoutedEventHandlerInfoList();
handlers.Handlers = new RoutedEventHandlerInfo[1];
handlers.Handlers[0] = routedEventHandlerInfo;
handlers.Next = _eventHandlersList.List[index].Handlers;
_eventHandlersList.List[index].Handlers = handlers;
_eventHandlersList.List[index].HasSelfHandlers = true;
}
else
{
// Add this handler to the existing node in the linked list
// of class handlers for this type and routed event.
int length = handlers.Handlers.Length;
RoutedEventHandlerInfo[] mergedHandlers = new RoutedEventHandlerInfo[length + 1];
Array.Copy(handlers.Handlers, 0, mergedHandlers, 0, length);
mergedHandlers[length] = routedEventHandlerInfo;
handlers.Handlers = mergedHandlers;
}
return handlers;
}
// Helper method for GetDTypedClassListeners
// Returns updated list of class listeners for the given
// DType and RoutedEvent
// NOTE: Returns null if no matches found
// Invoked when trying to build the event route
// as well as when registering a new class handler
private static RoutedEventHandlerInfoList GetUpdatedDTypedClassListeners(
DependencyObjectType dType,
RoutedEvent routedEvent,
out ClassHandlersStore classListenersLists,
out int index)
{
// Get the ClassHandlersStore for the given DType
classListenersLists = (ClassHandlersStore)_dTypedClassListeners[dType];
RoutedEventHandlerInfoList handlers;
if (classListenersLists != null)
{
// Get the handlers for the given DType and RoutedEvent
index = classListenersLists.GetHandlersIndex(routedEvent);
if (index != -1)
{
handlers = classListenersLists.GetExistingHandlers(index);
return(handlers);
}
}
// Since matching handlers were not found at this level
// browse base classes to check for registered class handlers
DependencyObjectType tempDType = dType;
ClassHandlersStore tempClassListenersLists = null;
RoutedEventHandlerInfoList tempHandlers = null;
int tempIndex = -1;
while (tempIndex == -1 && tempDType.Id != _dependencyObjectType.Id)
{
tempDType = tempDType.BaseType;
tempClassListenersLists = (ClassHandlersStore)_dTypedClassListeners[tempDType];
if (tempClassListenersLists != null)
{
// Get the handlers for the DType and RoutedEvent
tempIndex = tempClassListenersLists.GetHandlersIndex(routedEvent);
if (tempIndex != -1)
{
tempHandlers = tempClassListenersLists.GetExistingHandlers(tempIndex);
}
}
}
if (classListenersLists == null)
{
if (dType.SystemType == typeof(UIElement) || dType.SystemType == typeof(ContentElement))
{
classListenersLists = new ClassHandlersStore(80); // Based on the number of class handlers for these classes
}
else
{
classListenersLists = new ClassHandlersStore(1);
}
_dTypedClassListeners[dType] = classListenersLists;
}
index = classListenersLists.CreateHandlersLink(routedEvent, tempHandlers);
return(tempHandlers);
}
// Update Sub Class Handlers with the given base class listeners
// NOTE : Do not wastefully try to update subclass listeners when
// base class listeners are null
internal void UpdateSubClassHandlers(
RoutedEvent routedEvent,
RoutedEventHandlerInfoList baseClassListeners)
{
Debug.Assert(baseClassListeners != null, "Update only when there are base class listeners to be updated");
// Get the handlers index corresponding to the given RoutedEvent
int index = GetHandlersIndex(routedEvent);
if (index != -1)
{
bool hasSelfHandlers = _eventHandlersList.List[index].HasSelfHandlers;
// Fetch the handlers for your baseType that the current node knows of
RoutedEventHandlerInfoList handlers = hasSelfHandlers ?
_eventHandlersList.List[index].Handlers.Next :
_eventHandlersList.List[index].Handlers;
bool needToChange = false;
// If the current node has baseType handlers check if the baseClassListeners
// provided is for a super type of that baseType. If it is then you will
// replace the baseType handlers for the current node with the provided
// baseClassListeners. If the given baseClassListeners is for a sub type
// of the current nodes's baseType then we do not need to update the current node.
//
// Example: Consider the following class hierarchy A -> B -> C.
//
// Now imagine that we register class handlers in the following order.
// 1. Register class handler for A.
// - A's linked list will be A -> NULL.
// - B's linked list will be NULL.
// - C's linked list will be NULL.
// 2. Register class handler for C.
// - A's linked list will be A -> NULL.
// - B's linkedList will be NULL.
// - C's linked list will be C -> A -> NULL.
// 3. Register class handler for B.
// - A's linked list will be A -> NULL.
// - B's linkedList will be B -> A -> NULL.
// - While updating C's linked list we are given B's linked list for the baseClassListers.
// Now we want to check if B is a super type of A which is the current baseType that C
// knows of. The contains check below determines this. Since it is we now replace C.Next
// to be B. Thus we get C -> B -> A -> NULL.
//
// Now imagine that we register class handlers in the following order.
// 1. Register class handler for C.
// - A's linked list will be NULL.
// - B's linked list will be NULL.
// - C's linked list will be C -> NULL.
// 2. Register class handler for B.
// - A's linked list will be NULL.
// - B's linkedList will be B -> NULL.
// - While updating C's linked list we are given B's linked list for the baseClassListeners.
// Since C does not know of any baseType listeners already it takes the given
// baseClassListeners as is. Thus it has C -> B -> NULL
// 3. Register class handler for A.
// - A's linked list will be A -> NULL.
// - B's linkedList will be B -> A -> NULL.
// - While updating C's linked list we are given A's linked list for the baseClassListers.
// Now we want to check if A is a super type of B which is the current baseType that C
// knows of. The contains check below determines this. Since it isn't we do not need to
// change the linked list for C. Since B's linked list has already been updated we get
// C -> B - > A -> NULL.
if (handlers != null)
{
if (baseClassListeners.Next != null && baseClassListeners.Next.Contains(handlers))
{
needToChange = true;
}
}
// If the current node does not have any baseType handlers then if will
// simply use the given baseClassListeners.
else
{
needToChange = true;
}
if (needToChange)
{
// If current node has self handlers then its next pointer
// needs update if not the current node needs update.
if (hasSelfHandlers)
{
_eventHandlersList.List[index].Handlers.Next = baseClassListeners;
}
else
{
_eventHandlersList.List[index].Handlers = baseClassListeners;
}
}
}
}
// Update Sub Class Handlers with the given base class listeners
// NOTE : Do not wastefully try to update subclass listeners when
// base class listeners are null
internal void UpdateSubClassHandlers(
RoutedEvent routedEvent,
RoutedEventHandlerInfoList baseClassListeners)
{
Debug.Assert(baseClassListeners != null, "Update only when there are base class listeners to be updated");
// Get the handlers index corresponding to the given RoutedEvent
int index = GetHandlersIndex(routedEvent);
if (index != -1)
{
bool hasSelfHandlers = _eventHandlersList.List[index].HasSelfHandlers;
// Fetch the handlers for your baseType that the current node knows of
RoutedEventHandlerInfoList handlers = hasSelfHandlers ?
_eventHandlersList.List[index].Handlers.Next :
_eventHandlersList.List[index].Handlers;
bool needToChange = false;
// If the current node has baseType handlers check if the baseClassListeners
// provided is for a super type of that baseType. If it is then you will
// replace the baseType handlers for the current node with the provided
// baseClassListeners. If the given baseClassListeners is for a sub type
// of the current nodes's baseType then we do not need to update the current node.
//
// Example: Consider the following class hierarchy A -> B -> C.
//
// Now imagine that we register class handlers in the following order.
// 1. Register class handler for A.
// - A's linked list will be A -> NULL.
// - B's linked list will be NULL.
// - C's linked list will be NULL.
// 2. Register class handler for C.
// - A's linked list will be A -> NULL.
// - B's linkedList will be NULL.
// - C's linked list will be C -> A -> NULL.
// 3. Register class handler for B.
// - A's linked list will be A -> NULL.
// - B's linkedList will be B -> A -> NULL.
// - While updating C's linked list we are given B's linked list for the baseClassListers.
// Now we want to check if B is a super type of A which is the current baseType that C
// knows of. The contains check below determines this. Since it is we now replace C.Next
// to be B. Thus we get C -> B -> A -> NULL.
//
// Now imagine that we register class handlers in the following order.
// 1. Register class handler for C.
// - A's linked list will be NULL.
// - B's linked list will be NULL.
// - C's linked list will be C -> NULL.
// 2. Register class handler for B.
// - A's linked list will be NULL.
// - B's linkedList will be B -> NULL.
// - While updating C's linked list we are given B's linked list for the baseClassListeners.
// Since C does not know of any baseType listeners already it takes the given
// baseClassListeners as is. Thus it has C -> B -> NULL
// 3. Register class handler for A.
// - A's linked list will be A -> NULL.
// - B's linkedList will be B -> A -> NULL.
// - While updating C's linked list we are given A's linked list for the baseClassListers.
// Now we want to check if A is a super type of B which is the current baseType that C
// knows of. The contains check below determines this. Since it isn't we do not need to
// change the linked list for C. Since B's linked list has already been updated we get
// C -> B - > A -> NULL.
if (handlers != null)
{
if (baseClassListeners.Next != null && baseClassListeners.Next.Contains(handlers))
{
needToChange = true;
}
}
// If the current node does not have any baseType handlers then if will
// simply use the given baseClassListeners.
else
{
needToChange = true;
}
if (needToChange)
{
// If current node has self handlers then its next pointer
// needs update if not the current node needs update.
if (hasSelfHandlers)
{
_eventHandlersList.List[index].Handlers.Next = baseClassListeners;
}
else
{
_eventHandlersList.List[index].Handlers = baseClassListeners;
}
}
}
}
internal bool Contains(RoutedEventHandlerInfoList handlers)
{
RoutedEventHandlerInfoList tempHandlers = this;
while (tempHandlers != null)
{
if (tempHandlers == handlers)
{
return true;
}
tempHandlers = tempHandlers.Next;
}
return false;
}