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;
}
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>
/// 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);
}
/// <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>
/// Constructor
/// </summary>
public EventTypePhase(string type, EventPhase phase)
{
EventType = type;
Phase = phase;
}
/// <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 override void RemoveEventListener(string eventType, EventHandler handler, EventPhase phases)
{
base.RemoveEventListener(eventType, handler, phases);
_touchCount--;
if (_touchCount <= 0)
{
SystemManager.Instance.TouchSignal.Disconnect(TouchSlot);
}
}
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;
}
}
/// <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);
}
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);
}
}
}
public override void AddEventListener(string eventType, EventHandler handler, EventPhase phases)
{
base.AddEventListener(eventType, handler, phases);
_touchCount++;
SystemManager.Instance.TouchSignal.Connect(TouchSlot);
}
/// <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);
}
}
}
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);
}
/// <summary>
/// Constructor
/// </summary>
public EventTypePhase(string type)
{
EventType = type;
Phase = EventPhase.Target | EventPhase.Bubbling; // this is the default
}
