示例#1
0
        public void InvokeHandleEvent(Event evt)
        {
            Contract.Requires<ArgumentNullException>(evt != null);

            invoker.Invoke(() =>
                handler.Value.HandleEvent(evt));
        }
示例#2
0
文件: Submit.cs 项目: nxkit/nxkit
 void IEventDefaultAction.DefaultAction(Event evt)
 {
     switch (evt.Type)
     {
         case DOMEvents.Events.DOMActivate:
             OnDOMActivate();
             break;
     }
 }
示例#3
0
文件: Action.cs 项目: nxkit/nxkit
        public void HandleEvent(Event ev)
        {
            var handlers = Element
                .Elements()
                .SelectMany(i => i.Interfaces<IEventHandler>());

            foreach (var handler in handlers)
                handler.HandleEvent(ev);
        }
示例#4
0
文件: Submission.cs 项目: nxkit/nxkit
 void IEventDefaultAction.DefaultAction(Event evt)
 {
     switch (evt.Type)
     {
         case Events.Submit:
             OnSubmit();
             break;
     }
 }
示例#5
0
        /// <summary>
        /// Dispatches the event to this <see cref="XElement"/>.
        /// </summary>
        /// <param name="element"></param>
        /// <param name="evt"></param>
        public static void DispatchEvent(this XElement element, Event evt)
        {
            Contract.Requires<ArgumentNullException>(element != null);
            Contract.Requires<ArgumentNullException>(evt != null);

            var target = element.InterfaceOrDefault<EventTarget>();
            if (target == null)
                throw new NullReferenceException();

            target.Dispatch(evt);
        }
示例#6
0
文件: SetValue.cs 项目: nxkit/nxkit
        public void HandleEvent(Event ev)
        {
            var context = GetContext();
            if (context == null)
                return;

            var sequenceBindingNodeSequence = GetSequenceBindingNodeSequence(context);
            if (sequenceBindingNodeSequence.Length == 0)
                return;

            var insertNode = sequenceBindingNodeSequence[0];
            var insertItem = ModelItem.Get(insertNode);
            if (insertItem.ReadOnly)
                return;

            if (insertNode is XElement)
                if (((XElement)insertNode).HasElements)
                    throw new DOMTargetEventException(Element, Events.BindingException);

            insertItem.Value = Element.Value;
            insertItem.Model.State.Recalculate = true;
            insertItem.Model.State.Revalidate = true;
            insertItem.Model.State.Refresh = true;
        }
示例#7
0
 public void HandleEvent(Event evt)
 {
     Contract.Requires<ArgumentNullException>(evt != null);
     throw new NotImplementedException();
 }
示例#8
0
        public void HandleEvent(Event evt)
        {
            // resolve target object
            var handler = evt.Host.Xml.ResolveObjectId(handlerId);
            if (handler == null)
                return;

            // resolve each interface
            foreach (var h in handler.Interfaces(interfaceType))
            {
                if (methodInfo.DeclaringType.IsInstanceOfType(h) &&
                    methodInfo.GetParameters().Length == 0)
                {
                    methodInfo.Invoke(h, new object[0]);
                    continue;
                }

                if (methodInfo.DeclaringType.IsInstanceOfType(h) &&
                    methodInfo.GetParameters().Length == 1)
                {
                    methodInfo.Invoke(h, new object[] { evt });
                    continue;
                }
            }
        }
示例#9
0
 void IEventListener.HandleEvent(Event @event)
 {
     action(@event);
 }
示例#10
0
        /// <summary>
        /// Dispatches the event to this <see cref="XNode"/>.
        /// </summary>
        /// <param name="evt"></param>
        /// <returns></returns>
        public bool Dispatch(Event evt)
        {
            Contract.Requires<ArgumentNullException>(evt != null);

            trace.Information("EventDispatcher.DispatchEvent: {0} to {1}", evt.Type, node);

            if (evt.dispatch ||
                evt.initialized == false ||
                evt.type == null)
                throw new DOMException(DOMException.INVALID_STATE_ERR);

            evt.dispatch = true;
            evt.target = node;

            // path to root from root
            var path = node.Ancestors()
                .Cast<XNode>()
                .Append(node.Document)
                .ToLinkedList();

            evt.eventPhase = EventPhase.Capturing;

            // capture phase moves from root to target
            foreach (var currentTarget in path.Backwards())
            {
                if (evt.stopPropagation)
                    break;

                InvokeListeners(currentTarget, evt);
            }

            // at-target phase
            evt.eventPhase = EventPhase.AtTarget;

            if (!evt.stopPropagation)
                InvokeListeners(node, evt);

            // bubbling phase
            if (evt.bubbles)
            {
                evt.eventPhase = EventPhase.Bubbling;

                // bubbling phase moves from target to root
                foreach (var currentTarget in path.Forwards())
                {
                    if (evt.stopPropagation)
                        break;

                    InvokeListeners(currentTarget, evt);
                }
            }

            evt.dispatch = false;
            evt.eventPhase = EventPhase.None;
            evt.currentTarget = null;

            if (evt.canceled)
                return false;

            // handle default action
            foreach (var da in node.Interfaces<IEventDefaultAction>())
                if (da != null)
                    da.DefaultAction(evt);

            return true;
        }
示例#11
0
        /// <summary>
        /// Invokes the applicable listeners for this node.
        /// </summary>
        /// <param name="node"></param>
        /// <param name="evt"></param>
        void InvokeListeners(XNode node, Event evt)
        {
            Contract.Requires<ArgumentNullException>(node != null);
            Contract.Requires<ArgumentNullException>(evt != null);

            // Initialize event's currentTarget attribute to the object for which these steps are run.
            evt.currentTarget = node;

            // invoke registered listeners
            foreach (var registration in node.Interface<EventTarget>().state.registrations)
            {
                // If event's stop immediate propagation flag is set, terminate the invoke algorithm.
                if (evt.stopImmediatePropagation)
                    return;

                // If event's type attribute value is not listener's type, terminate these substeps (and run them for
                // the next event listener).
                if (evt.type != registration.EventType)
                    continue;

                // If event's eventPhase attribute value is CAPTURING_PHASE and listener's capture is false, terminate
                // these substeps (and run them for the next event listener).
                if (evt.eventPhase == EventPhase.Capturing && registration.Capture == false)
                    continue;

                // If event's eventPhase attribute value is BUBBLING_PHASE and listener's capture is true, terminate
                // these substeps (and run them for the next event listener).
                if (evt.eventPhase == EventPhase.Bubbling && registration.Capture == true)
                    continue;

                // Call listener's callback's handleEvent, with the event passed to this algorithm as the first
                // argument and event's currentTarget attribute value as callback this value.
                invoker.Invoke(() =>
                    registration.Listener.HandleEvent(evt));
            }

            // invoke listeners available directly as interfaces
            foreach (var listener in node.Interfaces<IEventListener>())
            {
                // If event's stop immediate propagation flag is set, terminate the invoke algorithm.
                if (evt.stopImmediatePropagation)
                    return;

                invoker.Invoke(() =>
                    listener.HandleEvent(evt));
            }
        }
示例#12
0
 bool IEventTarget.DispatchEvent(Event evt)
 {
     evt.isTrusted = false;
     return Dispatch(evt);
 }
示例#13
0
文件: Message.cs 项目: nxkit/nxkit
 public void HandleEvent(Event ev)
 {
 }
示例#14
0
文件: EventInfo.cs 项目: nxkit/nxkit
        public virtual void InitEvent(Event evt)
        {
            Contract.Requires<ArgumentNullException>(evt != null);

            evt.InitEvent(type, canBubble, cancelable);
        }
示例#15
0
文件: Rebuild.cs 项目: nxkit/nxkit
 public void HandleEvent(Event ev)
 {
     Invoke();
 }
示例#16
0
文件: Input.cs 项目: nxkit/nxkit
 void IEventDefaultAction.DefaultAction(Event evt)
 {
     if (evt.Type == DOMEvents.Events.DOMFocusIn)
         eventTarget.Value.Dispatch(Events.Focus);
 }
示例#17
0
文件: Load.cs 项目: nxkit/nxkit
 public void HandleEvent(Event ev)
 {
     throw new NotImplementedException();
 }
示例#18
0
文件: RepeatItem.cs 项目: nxkit/nxkit
 void IEventListener.HandleEvent(Event evt)
 {
     if (evt.Type == DOMEvents.Events.DOMFocusIn)
         SetIndex();
 }