public MineshaftSpawnRegistrationEvent(MineshaftSpawnRegistry registry, EventPhase phase, MonsterLocomotion type, MineshaftArea area) : base(phase) { Registry = registry; Type = type; Area = area; }
/// <summary> /// Returns true if handler is mapped to any of the specified phases /// </summary> /// <param name="eventType"></param> /// <param name="handler"></param> /// <param name="phases"></param> /// <returns></returns> public virtual bool MappedToAnyPhase(string eventType, EventHandler handler, EventPhase phases) { var arr = EventPhaseHelper.BreakUpPhases(phases); foreach (EventPhase phase in arr) { EventTypePhase key = new EventTypePhase(eventType, phase); //if (_eventHandlerDict.ContainsKey(key) && _eventHandlerDict[key].Contains(handler)) if (_eventHandlerDict.ContainsKey(key)) { var exists = _eventHandlerDict[key].Exists(delegate(PriorityGroup group) { return(group.Contains(handler)); }); //foreach (PriorityGroup group in _eventHandlerDict[key]) //{ // //if (_eventHandlerDict[key].Contains(handler)) // // return true; //} return(exists); } } return(false); }
protected DragEventHandlerAttribute(Type requiredType, KeyboardModifiers modifiers, InputEventType eventType, EventPhase phase) { this.modifiers = modifiers; this.eventType = eventType; this.phase = phase; this.requiredType = requiredType; }
public KeyboardEvent(EventPhase eventPhase, DisplayObject target, DisplayObject currentTarget, Char charCode, Byte asciiCode, VirtualKey virtualKeyCode, bool keyDown = true, bool bubbles = true, bool cancelable = false, bool altKey = false, bool controlKey = false, bool shiftKey = false) : base(eventPhase, target, currentTarget, bubbles, cancelable) { AltKey = altKey; ControlKey = controlKey; ShiftKey = shiftKey; KeyDown = keyDown; CharCode = charCode; AsciiCode = asciiCode; VirtualKeyCode = virtualKeyCode; }
/// <summary> /// Dispatch the event as described in the specification. /// http://www.w3.org/TR/DOM-Level-3-Events/ /// </summary> /// <param name="target">The target of the event.</param> /// <returns>A boolean if the event has been cancelled.</returns> internal Boolean Dispatch(IEventTarget target) { _flags |= EventFlags.Dispatch; _target = target; var eventPath = new List <IEventTarget>(); if (target is Node parent) { while ((parent = parent.Parent !) != null) { eventPath.Add(parent); } } _phase = EventPhase.Capturing; DispatchAt(eventPath.Reverse <IEventTarget>()); _phase = EventPhase.AtTarget; if ((_flags & EventFlags.StopPropagation) != EventFlags.StopPropagation) { CallListeners(target); } if (_bubbles) { _phase = EventPhase.Bubbling; DispatchAt(eventPath); } _flags &= ~EventFlags.Dispatch; _phase = EventPhase.None; _current = null !; return((_flags & EventFlags.Canceled) == EventFlags.Canceled); }
public Event(EventPhase eventPhase, DisplayObject target, DisplayObject currentTarget, bool bubbles = true, bool cancelable = false) { EventPhase = eventPhase; Target = target; CurrentTarget = currentTarget; Bubbles = bubbles; Cancelable = cancelable; }
protected KeyboardInputBindingAttribute(KeyCode key, char character, KeyboardModifiers modifiers, InputEventType eventType, bool requiresFocusKeyEventPhase, EventPhase keyEventPhase) { this.key = key; this.character = character; this.modifiers = modifiers; this.eventType = eventType; this.requiresFocus = requiresFocusKeyEventPhase; this.keyEventPhase = keyEventPhase; }
public ProfilerToken(string name, string cat, EventPhase phase, long timeStamp, int processId, int threadId) { Name = name; Category = cat; Phase = phase; TimeStamp = timeStamp; ProcessId = processId; ThreadId = threadId; }
/// <summary> /// Initializes a new instance. /// </summary> public Event(Document host) { Contract.Requires<ArgumentNullException>(host != null); this.initialized = false; this.host = host; this.eventPhase = EventPhase.None; this.timeStamp = (ulong)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds; this.isTrusted = false; this.context = new ExpandoObject(); }
/// <summary> /// Initializes a new instance. /// </summary> public Event(Document host) { Contract.Requires <ArgumentNullException>(host != null); this.initialized = false; this.host = host; this.eventPhase = EventPhase.None; this.timeStamp = (ulong)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds; this.isTrusted = false; this.context = new ExpandoObject(); }
internal SynchronizedReceiptHandlerEventArgs( EventPhase phase, Table table, CRUDSubscriptionEvent.EventType et, Row row) { this.Phase = phase; this.Table = table; this.EventType = et; this.Row = row; this.Proceed = true; }
/// <summary> /// Breaks up flags to a list /// </summary> /// <param name="phases"></param> /// <returns></returns> public static List<EventPhase> BreakUpPhases(EventPhase phases) { List.Clear(); if ((phases & EventPhase.Capture) == EventPhase.Capture) List.Add(EventPhase.Capture); if ((phases & EventPhase.Target) == EventPhase.Target) List.Add(EventPhase.Target); if ((phases & EventPhase.Bubbling) == EventPhase.Bubbling) List.Add(EventPhase.Bubbling); return List; }
public MouseEvent( MouseEvent mouseEvent, EventPhase eventPhase, DisplayObject target, DisplayObject currentTarget) : base(eventPhase, target, currentTarget, mouseEvent.Bubbles, mouseEvent.Cancelable) { this.AltKey = mouseEvent.AltKey; this.ControlKey = mouseEvent.ControlKey; this.ShiftKey = mouseEvent.ShiftKey; this.ButtonDown = mouseEvent.ButtonDown; }
public void AddDragCreator(KeyboardModifiers modifiers, bool requiresFocus, EventPhase phase, Func <MouseInputEvent, DragEvent> creator) { dragCreators = dragCreators ?? new LightList <DragCreatorData>(1); handledEvents |= InputEventType.DragCreate; dragCreators.Add(new DragCreatorData() { eventPhase = phase, keyCode = 0, character = '\0', requireFocus = requiresFocus, modifiers = modifiers, handler = creator }); }
/// <summary> /// Removes all listeners for the spacified event type and phases /// </summary> /// <param name="eventType">Event type</param> /// /// <param name="phases"></param> public virtual void RemoveAllListeners(string eventType, EventPhase phases) { var arr = EventPhaseHelper.BreakUpPhases(phases); foreach (EventPhase phase in arr) { EventTypePhase key = new EventTypePhase(eventType, phase); if (_eventHandlerDict.ContainsKey(key)) { _eventHandlerDict[key].Clear(); _eventHandlerDict.Remove(key); } } }
/// <summary> /// Returns true if handler is mapped to any of the specified phases /// </summary> /// <param name="eventType"></param> /// <param name="handler"></param> /// <param name="phases"></param> /// <returns></returns> public virtual bool MappedToAnyPhase(string eventType, EventHandler handler, EventPhase phases) { var arr = EventPhaseHelper.BreakUpPhases(phases); foreach (EventPhase phase in arr) { EventTypePhase key = new EventTypePhase(eventType, phase); if (_eventHandlerDict.ContainsKey(key) && _eventHandlerDict[key].Contains(handler)) { return(true); } } return(false); }
public KeyboardEvent( KeyboardEvent keyboardEvent, EventPhase eventPhase, DisplayObject target, DisplayObject currentTarget) : base(eventPhase, target, currentTarget, keyboardEvent.Bubbles, keyboardEvent.Cancelable) { this.AltKey = keyboardEvent.AltKey; this.ControlKey = keyboardEvent.ControlKey; this.ShiftKey = keyboardEvent.ShiftKey; this.KeyDown = keyboardEvent.KeyDown; this.CharCode = keyboardEvent.CharCode; this.AsciiCode = keyboardEvent.AsciiCode; this.VirtualKeyCode = keyboardEvent.VirtualKeyCode; }
public MouseEvent(EventPhase eventPhase, DisplayObject target, DisplayObject currentTarget, bool buttonDown = true, bool bubbles = true, bool cancelable = false, bool altKey = false, bool controlKey = false, bool shiftKey = false) : base(eventPhase, target, currentTarget, bubbles, cancelable) { AltKey = altKey; ControlKey = controlKey; ShiftKey = shiftKey; ButtonDown = buttonDown; }
/// <summary> /// Breaks up flags to a list /// </summary> /// <param name="phases"></param> /// <returns></returns> public static List <EventPhase> BreakUpPhases(EventPhase phases) { List.Clear(); if ((phases & EventPhase.Capture) == EventPhase.Capture) { List.Add(EventPhase.Capture); } if ((phases & EventPhase.Target) == EventPhase.Target) { List.Add(EventPhase.Target); } if ((phases & EventPhase.Bubbling) == EventPhase.Bubbling) { List.Add(EventPhase.Bubbling); } return(List); }
/// <summary> /// Adds the event listener /// </summary> /// <param name="eventType">Event type</param> /// <param name="handler">Event handler</param> /// <param name="phases">Event bubbling phases that we listen to</param> public virtual void AddEventListener(string eventType, EventHandler handler, EventPhase phases) { var arr = EventPhaseHelper.BreakUpPhases(phases); foreach (EventPhase phase in arr) { EventTypePhase key = new EventTypePhase(eventType, phase); if (!_eventHandlerDict.ContainsKey(key)) // avoid key duplication { _eventHandlerDict.Add(key, new List <EventHandler>()); } if (!_eventHandlerDict[key].Contains(handler)) // avoid key + value duplication { _eventHandlerDict[key].Add(handler); } } }
/// <summary> /// Adds the event listener /// </summary> /// <param name="eventType">Event type</param> /// <param name="handler">Event handler</param> /// <param name="phases">Event bubbling phases that we listen to</param> /// <param name="priority">Event priority</param> public virtual void AddEventListener(string eventType, EventHandler handler, EventPhase phases, int priority) { var arr = EventPhaseHelper.BreakUpPhases(phases); foreach (EventPhase phase in arr) { EventTypePhase key = new EventTypePhase(eventType, phase); if (!_eventHandlerDict.ContainsKey(key)) // avoid key duplication { _eventHandlerDict.Add(key, new List <PriorityGroup>()); } var group = _eventHandlerDict[key].Find(delegate(PriorityGroup g) { return(g.Priority == priority); }); if (null == group) { //if (0 != priority) // Debug.Log("Creating new group with priority " + priority); group = new PriorityGroup { Priority = priority }; // add and sort _eventHandlerDict[key].Add(group); // if having multiple priorities, sort now if (_eventHandlerDict[key].Count > 0) { _eventHandlerDict[key].Sort(PriorityComparer); } } if (!group.Contains(handler)) // avoid key + value duplication { group.Add(handler); } } }
void CreateSelectedEvent(Type eventType, T item, EventPhase phase) { Event e = (Event)Activator.CreateInstance(eventType); e.Type = key; e.Phase = phase; if (e is SelectEvent <T> se) { e.Targets = new object[] { item, select }; se.select = select; se.layer = this; se.item = item; } else { e.Target = item; } events.Add(e); }
internal Boolean Dispatch(EventTarget target) { _flags |= EventFlags.Dispatch; _target = target; var eventPath = new List <EventTarget>(); var parent = target as Node; if (parent != null) { while ((parent = parent.Parent) != null) { eventPath.Add(parent); } } _phase = EventPhase.Capturing; DispatchAt(eventPath.Reverse <EventTarget>()); _phase = EventPhase.AtTarget; if (!_flags.HasFlag(EventFlags.StopPropagation)) { CallListeners(target); } if (_bubbles) { _phase = EventPhase.Bubbling; DispatchAt(eventPath); } _flags &= ~EventFlags.Dispatch; _phase = EventPhase.None; _current = null; return(!_flags.HasFlag(EventFlags.Canceled)); }
/// <summary> /// Constructor /// </summary> public EventTypePhase(string type, EventPhase phase) { EventType = type; Phase = phase; }
/// <summary> /// Overriding the MAIN AddEventListener method! /// </summary> /// <param name="eventType"></param> /// <param name="handler"></param> /// <param name="phases"></param> /// <param name="priority"></param> public override void AddEventListener(string eventType, EventHandler handler, EventPhase phases, int priority) { if (eventType == "propertyChange") { if (!HasEventListener(eventType)) TileLayout.AddEventListener(eventType, RedispatchHandler, phases, priority); } base.AddEventListener(eventType, handler); }
/// <summary> /// Adds the event listener /// </summary> /// <param name="eventType">Event type</param> /// <param name="handler">Event handler</param> /// <param name="phases">Event bubbling phases that we listen to</param> /// <param name="priority">Event priority</param> public void AddEventListener(string eventType, EventHandler handler, EventPhase phases, int priority) { _dispatcher.AddEventListener(eventType, handler, phases, priority); HandleAddTarget(handler); }
public OnMouseClickAttribute(EventPhase phase) : base(KeyboardModifiers.None, InputEventType.MouseClick, phase) { }
/// <summary> /// Removes an event listener /// </summary> /// <param name="eventType"></param> /// <param name="handler"></param> /// <param name="phases"></param> public void RemoveEventListener(string eventType, EventHandler handler, EventPhase phases) { Stage.RemoveEventListener(eventType, handler, phases); }
/// <summary> /// Returns true if handler is mapped to any of the specified phases /// </summary> /// <param name="eventType"></param> /// <param name="handler"></param> /// <param name="phases"></param> /// <returns></returns> public virtual bool MappedToAnyPhase(string eventType, EventHandler handler, EventPhase phases) { var arr = EventPhaseHelper.BreakUpPhases(phases); foreach (EventPhase phase in arr) { EventTypePhase key = new EventTypePhase(eventType, phase); if (_eventHandlerDict.ContainsKey(key) && _eventHandlerDict[key].Contains(handler)) return true; } return false; }
/// <summary> /// Creates a new event. /// </summary> public Event() { _flags = EventFlags.None; _phase = EventPhase.None; _time = DateTime.Now; }
/// <summary> /// Dispatch the event as described in the specification. /// http://www.w3.org/TR/DOM-Level-3-Events/ /// </summary> /// <param name="target">The target of the event.</param> /// <returns>A boolean if the event has been cancelled.</returns> internal Boolean Dispatch(IEventTarget target) { _flags |= EventFlags.Dispatch; _target = target; var eventPath = new List<IEventTarget>(); var parent = target as Node; if (parent != null) { while ((parent = parent.Parent) != null) { eventPath.Add(parent); } } _phase = EventPhase.Capturing; DispatchAt(eventPath.Reverse<IEventTarget>()); _phase = EventPhase.AtTarget; if ((_flags & EventFlags.StopPropagation) != EventFlags.StopPropagation) { CallListeners(target); } if (_bubbles) { _phase = EventPhase.Bubbling; DispatchAt(eventPath); } _flags &= ~EventFlags.Dispatch; _phase = EventPhase.None; _current = null; return (_flags & EventFlags.Canceled) == EventFlags.Canceled; }
/// <summary> /// Adds the event listener /// </summary> /// <param name="eventType">Event type</param> /// <param name="handler">Event handler</param> /// <param name="phases">Event bubbling phases that we listen to</param> /// <param name="priority">Event priority</param> public void AddEventListener(string eventType, EventHandler handler, EventPhase phases, int priority) { Initialize(); _dispatcher.AddEventListener(eventType, handler, phases, priority); }
public override void RemoveEventListener(string eventType, EventHandler handler, EventPhase phases) { base.RemoveEventListener(eventType, handler, phases); //if (!MappedToAnyPhase(eventType, handler, phases)) // TODO: fix wrong counting // return; switch (eventType) { // mouse case MouseEvent.MOUSE_MOVE: if (_mouseMoveCount > 0) { _mouseMoveCount--; if (0 == _mouseMoveCount) SystemManager.Instance.MouseMoveSignal.Disconnect(MouseMoveSlot); } break; case MouseEvent.MOUSE_DOWN: if (_mouseDownCount > 0) { _mouseDownCount--; if (0 == _mouseDownCount) SystemManager.Instance.MouseDownSignal.Disconnect(MouseDownSlot); } break; case MouseEvent.MOUSE_UP: if (_mouseUpCount > 0) { _mouseUpCount--; if (0 == _mouseUpCount) SystemManager.Instance.MouseDownSignal.Disconnect(MouseUpSlot); } break; case MouseEvent.RIGHT_MOUSE_DOWN: if (_rightMouseDownCount > 0) { _rightMouseDownCount--; if (0 == _rightMouseDownCount) SystemManager.Instance.RightMouseDownSignal.Disconnect(RightMouseDownSlot); } break; case MouseEvent.RIGHT_MOUSE_UP: if (_rightMouseUpCount > 0) { _rightMouseUpCount--; if (0 == _rightMouseUpCount) SystemManager.Instance.RightMouseUpSignal.Disconnect(RightMouseUpSlot); } break; case MouseEvent.MIDDLE_MOUSE_DOWN: if (_middleMouseDownCount > 0) { _middleMouseDownCount--; if (0 == _middleMouseDownCount) SystemManager.Instance.MiddleMouseDownSignal.Disconnect(MiddleMouseDownSlot); } break; case MouseEvent.MIDDLE_MOUSE_UP: if (_middleMouseUpCount > 0) { _middleMouseUpCount--; if (0 == _middleMouseUpCount) SystemManager.Instance.MiddleMouseUpSignal.Disconnect(MiddleMouseUpSlot); } break; case MouseEvent.MOUSE_DRAG: if (_mouseDragCount > 0) { _mouseDragCount--; if (0 == _mouseDragCount) SystemManager.Instance.MouseDragSignal.Disconnect(MouseDragSlot); } break; case MouseEvent.MOUSE_WHEEL: if (_mouseWheelCount > 0) { _mouseWheelCount--; if (0 == _mouseWheelCount) SystemManager.Instance.MouseWheelSignal.Disconnect(MouseWheelSlot); } break; // keys case KeyboardEvent.KEY_DOWN: if (_keyDownCount > 0) { _keyDownCount--; SystemManager.Instance.KeyDownSignal.Disconnect(KeyDownSlot); } break; case KeyboardEvent.KEY_UP: if (_keyUpCount > 0) { _keyUpCount--; SystemManager.Instance.KeyUpSignal.Disconnect(KeyUpSlot); } break; } }
public override void AddEventListener(string eventType, EventHandler handler, EventPhase phases) { base.AddEventListener(eventType, handler, phases); //if (MappedToAnyPhase(eventType, handler, phases)) // TODO: fix wrong counting // return; switch (eventType) { // mouse case MouseEvent.MOUSE_MOVE: _mouseMoveCount++; SystemManager.Instance.MouseMoveSignal.Connect(MouseMoveSlot); break; case MouseEvent.MOUSE_DOWN: _mouseDownCount++; SystemManager.Instance.MouseDownSignal.Connect(MouseDownSlot); break; case MouseEvent.MOUSE_UP: _mouseUpCount++; SystemManager.Instance.MouseUpSignal.Connect(MouseUpSlot); //Debug.Log("MouseUpSignal signal connected"); break; case MouseEvent.RIGHT_MOUSE_DOWN: _rightMouseDownCount++; SystemManager.Instance.RightMouseDownSignal.Connect(RightMouseDownSlot); break; case MouseEvent.RIGHT_MOUSE_UP: _rightMouseUpCount++; SystemManager.Instance.RightMouseUpSignal.Connect(RightMouseUpSlot); break; case MouseEvent.MIDDLE_MOUSE_DOWN: _middleMouseDownCount++; SystemManager.Instance.MiddleMouseDownSignal.Connect(MiddleMouseDownSlot); break; case MouseEvent.MIDDLE_MOUSE_UP: _middleMouseUpCount++; SystemManager.Instance.MiddleMouseUpSignal.Connect(MiddleMouseUpSlot); break; case MouseEvent.MOUSE_DRAG: _mouseDragCount++; SystemManager.Instance.MouseDragSignal.Connect(MouseDragSlot); break; case MouseEvent.MOUSE_WHEEL: _mouseWheelCount++; SystemManager.Instance.MouseWheelSignal.Connect(MouseWheelSlot); break; // keys case KeyboardEvent.KEY_DOWN: _keyDownCount++; SystemManager.Instance.KeyDownSignal.Connect(KeyDownSlot); break; case KeyboardEvent.KEY_UP: _keyUpCount++; SystemManager.Instance.KeyUpSignal.Connect(KeyUpSlot); break; } }
public override void RemoveEventListener(string eventType, EventHandler handler, EventPhase phases) { if (MouseEvent.ROLL_OVER == eventType) { MouseEventDispatcher.Instance.UnregisterRollOverComponent(this); } else if (MouseEvent.ROLL_OUT == eventType) { MouseEventDispatcher.Instance.UnregisterRollOverComponent(this); } base.RemoveEventListener(eventType, handler, phases); }
public override void RemoveEventListener(string eventType, EventHandler handler, EventPhase phases) { base.RemoveEventListener(eventType, handler, phases); _touchCount--; if (_touchCount <= 0) { SystemManager.Instance.TouchSignal.Disconnect(TouchSlot); } }
/// <summary> /// Removes the event listener /// </summary> /// <param name="eventType">Event type</param> /// <param name="handler">Event handler</param> /// <param name="phases"></param> public void RemoveEventListener(string eventType, EventHandler handler, EventPhase phases) { Initialize(); _dispatcher.RemoveEventListener(eventType, handler, phases); }
/// <summary> /// Removes the event listener /// </summary> /// <param name="eventType">Event type</param> /// <param name="handler">Event handler</param> /// <param name="phases"></param> public void RemoveEventListener(string eventType, EventHandler handler, EventPhase phases) { _dispatcher.RemoveEventListener(eventType, handler, phases); HandleRemoveTarget(handler); }
/// <summary> /// Adds the event listener /// </summary> /// <param name="eventType">Event type</param> /// <param name="handler">Event handler</param> /// <param name="phases">Event bubbling phases that we listen to</param> public virtual void AddEventListener(string eventType, EventHandler handler, EventPhase phases) { var arr = EventPhaseHelper.BreakUpPhases(phases); foreach (EventPhase phase in arr) { EventTypePhase key = new EventTypePhase(eventType, phase); if (!_eventHandlerDict.ContainsKey(key)) // avoid key duplication _eventHandlerDict.Add(key, new List<EventHandler>()); if (!_eventHandlerDict[key].Contains(handler)) // avoid key + value duplication _eventHandlerDict[key].Add(handler); } }
/// <summary> /// Adds the event listener /// </summary> /// <param name="eventType">Event type</param> /// <param name="handler">Event handler</param> /// <param name="phases">Event bubbling phases that we listen to</param> /// <param name="priority">Event priority</param> public void AddEventListener(string eventType, EventHandler handler, EventPhase phases, int priority) { Stage.AddEventListener(eventType, handler, phases, priority); }
public override void AddEventListener(string eventType, EventHandler handler, EventPhase phases) { base.AddEventListener(eventType, handler, phases); _touchCount++; SystemManager.Instance.TouchSignal.Connect(TouchSlot); }
/// <summary> /// Overriding the MAIN RemoveEventListener method! /// </summary> /// <param name="eventType"></param> /// <param name="handler"></param> /// <param name="phases"></param> public override void RemoveEventListener(string eventType, EventHandler handler, EventPhase phases) { if (eventType == "propertyChange") { if (!HasEventListener(eventType)) TileLayout.RemoveEventListener(eventType, RedispatchHandler); } base.RemoveEventListener(eventType, handler, phases); }
public OnMouseClickAttribute(KeyboardModifiers modifiers = KeyboardModifiers.None, EventPhase phase = EventPhase.Bubble) : base(modifiers, InputEventType.MouseClick, phase) { }
public override void AddEventListener(string eventType, EventHandler handler, EventPhase phases) { base.AddEventListener(eventType, handler, phases); switch (eventType) { // mouse case MouseEvent.MOUSE_MOVE: //Debug.Log("Subscribing to MOUSE_MOVE: " + handler); SystemManager.Instance.MouseMoveSignal.Connect(MouseMoveSlot); break; case MouseEvent.MOUSE_DOWN: SystemManager.Instance.MouseDownSignal.Connect(MouseDownSlot); break; case MouseEvent.MOUSE_UP: //Debug.Log("Subscribing to MOUSE_UP: " + handler); SystemManager.Instance.MouseUpSignal.Connect(MouseUpSlot); break; case MouseEvent.RIGHT_MOUSE_DOWN: SystemManager.Instance.RightMouseDownSignal.Connect(RightMouseDownSlot); break; case MouseEvent.RIGHT_MOUSE_UP: SystemManager.Instance.RightMouseUpSignal.Connect(RightMouseUpSlot); break; case MouseEvent.MIDDLE_MOUSE_DOWN: SystemManager.Instance.MiddleMouseDownSignal.Connect(MiddleMouseDownSlot); break; case MouseEvent.MIDDLE_MOUSE_UP: SystemManager.Instance.MiddleMouseUpSignal.Connect(MiddleMouseUpSlot); break; case MouseEvent.MOUSE_DRAG: SystemManager.Instance.MouseDragSignal.Connect(MouseDragSlot); break; case MouseEvent.MOUSE_WHEEL: SystemManager.Instance.MouseWheelSignal.Connect(MouseWheelSlot); break; // keys case KeyboardEvent.KEY_DOWN: SystemManager.Instance.KeyDownSignal.Connect(KeyDownSlot); break; case KeyboardEvent.KEY_UP: SystemManager.Instance.KeyUpSignal.Connect(KeyUpSlot); break; } }
public override void RemoveEventListener(string eventType, EventHandler handler, EventPhase phases) { base.RemoveEventListener(eventType, handler, phases); switch (eventType) { // mouse case MouseEvent.MOUSE_MOVE: //Debug.Log("Unsubscribing from MOUSE_MOVE: " + handler); if (!HasEventListener(MouseEvent.MOUSE_MOVE)) SystemManager.Instance.MouseMoveSignal.Disconnect(MouseMoveSlot); break; case MouseEvent.MOUSE_DOWN: if (!HasEventListener(MouseEvent.MOUSE_DOWN)) SystemManager.Instance.MouseDownSignal.Disconnect(MouseDownSlot); break; case MouseEvent.MOUSE_UP: //Debug.Log("Unsubscribing from MOUSE_UP: " + handler); if (!HasEventListener(MouseEvent.MOUSE_UP)) { //Debug.Log("Unsubscribing from MOUSE_UP: " + handler); SystemManager.Instance.MouseUpSignal.Disconnect(MouseUpSlot); } break; case MouseEvent.RIGHT_MOUSE_DOWN: if (!HasEventListener(MouseEvent.RIGHT_MOUSE_DOWN)) SystemManager.Instance.RightMouseDownSignal.Disconnect(RightMouseDownSlot); break; case MouseEvent.RIGHT_MOUSE_UP: if (!HasEventListener(MouseEvent.RIGHT_MOUSE_UP)) SystemManager.Instance.RightMouseUpSignal.Disconnect(RightMouseUpSlot); break; case MouseEvent.MIDDLE_MOUSE_DOWN: if (!HasEventListener(MouseEvent.MIDDLE_MOUSE_DOWN)) SystemManager.Instance.MiddleMouseDownSignal.Disconnect(MiddleMouseDownSlot); break; case MouseEvent.MIDDLE_MOUSE_UP: if (!HasEventListener(MouseEvent.MIDDLE_MOUSE_UP)) SystemManager.Instance.MiddleMouseUpSignal.Disconnect(MiddleMouseUpSlot); break; case MouseEvent.MOUSE_DRAG: if (!HasEventListener(MouseEvent.MOUSE_DRAG)) SystemManager.Instance.MouseDragSignal.Disconnect(MouseDragSlot); break; case MouseEvent.MOUSE_WHEEL: if (!HasEventListener(MouseEvent.MOUSE_WHEEL)) SystemManager.Instance.MouseWheelSignal.Disconnect(MouseWheelSlot); break; // keys case KeyboardEvent.KEY_DOWN: if (!HasEventListener(KeyboardEvent.KEY_DOWN)) SystemManager.Instance.KeyDownSignal.Disconnect(KeyDownSlot); break; case KeyboardEvent.KEY_UP: if (!HasEventListener(KeyboardEvent.KEY_UP)) SystemManager.Instance.KeyUpSignal.Disconnect(KeyUpSlot); break; } }
/// <summary> /// Constructor /// </summary> public EventTypePhase(string type) { EventType = type; Phase = EventPhase.Target | EventPhase.Bubbling; // this is the default }
/// <summary> /// Removes the event listener /// </summary> /// <param name="eventType">Event type</param> /// <param name="handler">Event handler (function)</param> /// <param name="phases">Event bubbling phases that we listen to</param> public virtual void RemoveEventListener(string eventType, EventHandler handler, EventPhase phases) { var arr = EventPhaseHelper.BreakUpPhases(phases); foreach (EventPhase phase in arr) { EventTypePhase key = new EventTypePhase(eventType, phase); if (_eventHandlerDict.ContainsKey(key)) { if (_eventHandlerDict[key].Contains(handler)) _eventHandlerDict[key].Remove(handler); if (_eventHandlerDict[key].Count == 0) // cleanup _eventHandlerDict.Remove(key); } } }