internal List<FunctionalEventHandlerContainer> GetHandlerList(FunctionalEvent functionalEvent, IFunctionalTreeElement element) { if (HandlerListInternal.ContainsKey(functionalEvent) && HandlerListInternal[functionalEvent].ContainsKey(element)) return HandlerListInternal[functionalEvent][element]; return null; }
public static void AddFunctionalHandler(this IFunctionalTreeElement source, FunctionalEvent functionalEvent, Delegate handler) { if (source == null) return; AddFunctionalHandler(source, functionalEvent, handler, false); }
public FunctionalEventArgs(FunctionalEvent functionalEvent) { if (functionalEvent == null) throw new ArgumentNullException("functionalEvent", "functionalEvent is null."); FunctionalEvent = functionalEvent; }
public static void AddFunctionalHandler(this IFunctionalTreeElement source, FunctionalEvent functionalEvent, Delegate handler, bool handledEventsToo) { if (source == null) return; if (functionalEvent == null) throw new ArgumentNullException("functionalEvent", "functionalEvent is null."); FunctionalEventManager.Instance.AddHandler(functionalEvent, source, handler, handledEventsToo); }
static DockingBase() { //Register Dependency Properties IsEmptyProperty = DependencyProperty.Register("IsEmpty", typeof(bool), typeof(DockingBase), new UIPropertyMetadata(false)); DockingWidthProperty = DependencyProperty.Register("DockingWidth", typeof(GridLength), typeof(DockingBase), new UIPropertyMetadata(new GridLengthConverter().ConvertFrom("*"))); DockingHeightProperty = DependencyProperty.Register("DockingHeight", typeof(GridLength), typeof(DockingBase), new UIPropertyMetadata(new GridLengthConverter().ConvertFrom("*"))); //Register Functional Properties DockManagerProperty = FunctionalProperty.Register("DockManager", typeof(DockManager), typeof(DockingBase), new FunctionalPropertyMetadata(null, FunctionalPropertyMetadataOptions.Inherits, DockManagerChangedHandler)); //Register Events ClosedEvent = FunctionalEventManager.RegisterEvent("Closed", FunctionalStrategy.Bubble, typeof(FunctionalEventHandler), typeof(DockingBase)); }
static TestingElement() { // Functional Properties InfoProperty = FunctionalProperty.Register("Info", typeof(string), typeof(TestingElement), new FunctionalPropertyMetadata("Empty", FunctionalPropertyMetadataOptions.Inherits, InfoChangedHandler, InfoCoercingHandler), InfoValidateHandler); // Functional Events BubblingTestEvent = FunctionalEventManager.RegisterEvent("BubblingTest", FunctionalStrategy.Bubble, typeof(FunctionalEventHandler), typeof(TestingElement)); TunnelingTestEvent = FunctionalEventManager.RegisterEvent("TunnelingTest", FunctionalStrategy.Tunnel, typeof(FunctionalEventHandler), typeof(TestingElement)); ParentTestEvent = FunctionalEventManager.RegisterEvent("ParentTest", FunctionalStrategy.Parent, typeof(FunctionalEventHandler), typeof(TestingElement)); SiblingsTestEvent = FunctionalEventManager.RegisterEvent("SiblingsTest", FunctionalStrategy.Siblings, typeof(FunctionalEventHandler), typeof(TestingElement)); DescendentsTestEvent = FunctionalEventManager.RegisterEvent("DescendentsTest", FunctionalStrategy.Descendents, typeof(FunctionalEventHandler), typeof(TestingElement)); ChildrenTestEvent = FunctionalEventManager.RegisterEvent("ChildrenTest", FunctionalStrategy.Children, typeof(FunctionalEventHandler), typeof(TestingElement)); SpreadTestEvent = FunctionalEventManager.RegisterEvent("SpreadTest", FunctionalStrategy.Spread, typeof(FunctionalEventHandler), typeof(TestingElement)); }
internal void AddHandler(FunctionalEvent functionalEvent, IFunctionalTreeElement element, Delegate handler, bool handledEventsToo = false) { if (functionalEvent == null) throw new ArgumentNullException("functionalEvent", "functionalEvent is null."); if (element == null) throw new ArgumentNullException("element", "element is null."); if (handler == null) throw new ArgumentNullException("handler", "handler is null."); if (handler.GetType() != functionalEvent.HandlerType && handler.GetType() != typeof(FunctionalEventHandler)) throw new ArgumentException("handler", "Handler type mismatched."); if (!HandlerListInternal.ContainsKey(functionalEvent)) { HandlerListInternal[functionalEvent] = new Dictionary<IFunctionalTreeElement, List<FunctionalEventHandlerContainer>>(); } if (!HandlerListInternal[functionalEvent].ContainsKey(element)) { HandlerListInternal[functionalEvent][element] = new List<FunctionalEventHandlerContainer>(); } GetHandlerList(functionalEvent, element).Add(new FunctionalEventHandlerContainer(handler, handledEventsToo)); }
public FunctionalDockingBaseEventArgs(FunctionalEvent functionalEvent, DockingBase target) : base(functionalEvent) { Target = target; }
private void EventTracer_EventRaising(FunctionalEvent functionalEvent, FunctionalEventTracingArgs e) { TestingElement previous = e.PreviousElement as TestingElement; TestingElement next = e.NextElement as TestingElement; string previousName = previous != null ? previous.Name : ""; string nextName = next != null ? next.Name : ""; string currentName = (e.CurrentElement as TestingElement).Name; WriteEventTracingLine(string.Format("[EventRaising] Event: {0} Previous: {1} Current: {2} Next: {3}", functionalEvent.Name, previousName, currentName, nextName)); }
/// <summary> /// Registers a new functional event. /// </summary> /// <param name="name">The name of the functional event. The name must be unique within the owner type and cannot be null or an empty string.</param> /// <param name="functionalStretegy">The functional strategy of the event as a value of the enumeration.</param> /// <param name="handlerType">The type of the event handler. This must be a delegate type and cannot be null.</param> /// <param name="ownerType">The owner class type of the routed event. This cannot be null.</param> private FunctionalEvent RegisterEventInternal(string name, FunctionalStrategy functionalStrategy, Type handlerType, Type ownerType) { if (String.IsNullOrEmpty(name)) throw new ArgumentNullException("name", "name is null."); if (handlerType == null) throw new ArgumentNullException("handlerType", "handlerType is null."); if (ownerType == null) throw new ArgumentNullException("ownerType", "ownerType is null."); if (FunctionalEventsInternal.ContainsKey(ownerType)) { if (FunctionalEventsInternal[ownerType].Any(cur => cur.Name == name)) throw new ArgumentException(String.Format("RoutedEvent Name '{0}' for OwnerType '{1}' already used.", name, ownerType)); } FunctionalEvent functionalEvent = new FunctionalEvent(name, functionalStrategy, handlerType, ownerType); if (!FunctionalEventsInternal.ContainsKey(ownerType)) FunctionalEventsInternal[ownerType] = new List<FunctionalEvent>(); FunctionalEventsInternal[ownerType].Add(functionalEvent); return functionalEvent; }
internal void RemoveHandler(FunctionalEvent functionalEvent, IFunctionalTreeElement element, Delegate handler) { if (functionalEvent == null) throw new ArgumentNullException("functionalEvent", "functionalEvent is null."); if (element == null) throw new ArgumentNullException("element", "element is null."); if (handler == null) throw new ArgumentNullException("handler", "handler is null."); List<FunctionalEventHandlerContainer> handlerList = GetHandlerList(functionalEvent, element); if (handlerList != null) handlerList.RemoveAll(cur => cur.Handler == handler); }
/// <summary> /// The event will be raised only on objects of type T. /// </summary> internal void RaiseEventPair(FunctionalEvent tunnelEvent, FunctionalEvent bubbleEvent, FunctionalEventArgs eventArgs, Predicate<IFunctionalTreeElement> predicate = null) { if (tunnelEvent == null) throw new ArgumentNullException("tunnelEvent", "tunnelEvent is null."); if (bubbleEvent == null) throw new ArgumentNullException("bubbleEvent", "bubbleEvent is null."); if (eventArgs == null) throw new ArgumentNullException("eventArgs", "eventArgs is null."); if (tunnelEvent.FunctionalStretegy != FunctionalStrategy.Tunnel) throw new ArgumentNullException("tunnelEvent", "tunnelEvent is not tunnel."); if (bubbleEvent.FunctionalStretegy != FunctionalStrategy.Bubble) throw new ArgumentNullException("bubbleEvent", "bubbleEvent is bubble."); if (!FunctionalEventsInternal.ContainsKey(eventArgs.FunctionalEvent.OwnerType)) return; eventArgs.FunctionalEvent = tunnelEvent; RaiseEvent(eventArgs, predicate); eventArgs.FunctionalEvent = bubbleEvent; RaiseEvent(eventArgs, predicate); }
internal void RaiseEventRaising(FunctionalEvent functionalEvent, FunctionalEventTracingArgs eventRaisingArgs) { if (EventRaising != null) EventRaising(functionalEvent, eventRaisingArgs); }
public static void RaiseFunctionalEventPair(this IFunctionalTreeElement source, FunctionalEvent tunnelEvent, FunctionalEvent bubbleEvent, FunctionalEventArgs e, Predicate<IFunctionalTreeElement> predicate) { if (source == null || tunnelEvent == null || bubbleEvent == null || e == null) return; e.Source = source; FunctionalEventManager.Instance.RaiseEventPair(tunnelEvent, bubbleEvent, e, predicate); }
public static void RaiseFunctionalEventPair(this IFunctionalTreeElement source, FunctionalEvent tunnelEvent, FunctionalEvent bubbleEvent, FunctionalEventArgs e) { RaiseFunctionalEventPair(source, tunnelEvent, bubbleEvent, e, null); }
static DockingContentBase() { //Register Events ItemPromotedEvent = FunctionalEventManager.RegisterEvent("ItemPromoted", FunctionalStrategy.Bubble, typeof(FunctionalDockingBaseEventHandler), typeof(DockingContentBase)); }