/// <summary>
/// Removes all listeners which are associated with the specified target.
/// </summary>
/// <param name="target"></param>
/// <param name="recursive"></param>
public void RemoveEventListeners(CCNode target, bool recursive = false)
{
if (nodeListenersMap.ContainsKey(target))
{
var nodeListeners = nodeListenersMap[target];
var listenersCopy2 = new CCEventListener[nodeListeners.Count];
nodeListeners.CopyTo(listenersCopy2);
for (int x = 0; x < listenersCopy2.Length; x++)
{
var listener = listenersCopy2 [x];
RemoveEventListener(listener);
}
}
if (recursive)
{
var children = target.Children;
if (children != null)
{
foreach (var child in children)
{
RemoveEventListeners(child, true);
}
}
}
}
/// <summary>
/// Sets listener's priority with fixed value.
/// </summary>
/// <param name="listener"></param>
/// <param name="fixedPriority"></param>
public void SetPriority(CCEventListener listener, int fixedPriority)
{
if (listener == null)
{
return;
}
foreach (var l in listenerMap)
{
var fixedPriorityListeners = l.Value.FixedPriorityListeners;
if (fixedPriorityListeners != null && fixedPriorityListeners.Count > 0)
{
var found = fixedPriorityListeners.IndexOf(listener);
if (found >= 0)
{
//Debug.Assert(listener.)
if (listener.FixedPriority != fixedPriority)
{
listener.FixedPriority = fixedPriority;
SetDirty(listener.ListenerID, DirtyFlag.FIXED_PRIORITY);
}
return;
}
}
}
}
bool RemoveListenerInVector(List <CCEventListener> listeners, CCEventListener listener)
{
if (listeners == null)
{
return(false);
}
for (int x = 0; x < listeners.Count; x++)
{
var l = listeners [x];
if (l == listener)
{
l.IsRegistered = false;
if (l.SceneGraphPriority != null)
{
DissociateNodeAndEventListener(l.SceneGraphPriority, l);
}
if (inDispatch == 0)
{
listeners.Remove(l);
}
return(true);
}
}
return(false);
}
/// <summary>
/// Adds an event listener with item
/// ** Note ** if it is dispatching event, the added operation will be delayed to the end of current dispatch
/// <see cref=">ForceAddEventListener"/>
/// </summary>
///
/// <param name="listener"></param>
void AddEventListener(CCEventListener listener)
{
if (inDispatch == 0)
{
#if DUMP_LISTENER_ITEM_PRIORITY_INFO
CCLog.Log("----- Add > -- Available > " + listener.IsAvailable + " ------{0}------{1}---------", listener, listener.SceneGraphPriority);
#endif
ForceAddEventListener(listener);
}
else
{
toBeAddedListeners.Add(listener);
}
}
/// <summary>
/// Associates node with event listener
/// </summary>
/// <param name="node"></param>
/// <param name="listener"></param>
void AssociateNodeAndEventListener(CCNode node, CCEventListener listener)
{
List <CCEventListener> listeners = null;
if (nodeListenersMap.ContainsKey(node))
{
listeners = nodeListenersMap [node];
}
else
{
listeners = new List <CCEventListener> ();
nodeListenersMap.Add(node, listeners);
}
listeners.Add(listener);
}
/// <summary>
/// Adds a event listener for a specified event with the priority of scene graph.
/// The priority of scene graph will be fixed value 0. So the order of listener item
/// in the vector will be ' <0, scene graph (0 priority), >0'.
/// </summary>
/// <param name="listener">The listener of a specified event.</param>
/// <param name="node">The priority of the listener is based on the draw order of this node.</param>
public void AddEventListener(CCEventListener listener, CCNode node)
{
Debug.Assert((listener != null && node != null), "Invalid parameters.");
Debug.Assert(!listener.IsRegistered, "The listener has been registered.");
if (!listener.IsAvailable)
{
return;
}
listener.SceneGraphPriority = node;
listener.FixedPriority = 0;
listener.IsRegistered = true;
listener.Sender = node;
AddEventListener(listener);
}
/// <summary>
/// Dissociates node with event listener
/// </summary>
/// <param name="node"></param>
/// <param name="listener"></param>
void DissociateNodeAndEventListener(CCNode node, CCEventListener listener)
{
List <CCEventListener> listeners = null;
if (nodeListenersMap.ContainsKey(node))
{
listeners = nodeListenersMap [node];
if (listeners.Contains(listener))
{
listeners.Remove(listener);
}
if (listeners.Count == 0)
{
nodeListenersMap.Remove(node);
}
}
}
/// <summary>
/// Adds a event listener for a specified event with the fixed priority.
/// A lower priority will be called before the ones that have a higher value.
/// 0 priority is not allowed for fixed priority since it's used for scene graph based priority.
/// </summary>
/// <param name="listener">The listener of a specified event.</param>
/// <param name="fixedPriority">The fixed priority of the listener.</param>
public void AddEventListener(CCEventListener listener, int fixedPriority, CCNode sender)
{
Debug.Assert((listener != null && sender != null), "Invalid parameters.");
Debug.Assert(!listener.IsRegistered, "The listener has been registered.");
Debug.Assert(fixedPriority != 0, "0 priority is forbidden for fixed priority since it's used for scene graph based priority.");
if (!listener.IsAvailable)
{
return;
}
listener.SceneGraphPriority = null;
listener.FixedPriority = fixedPriority;
listener.IsRegistered = true;
listener.IsPaused = false;
listener.Sender = sender;
AddEventListener(listener);
}
public void PushBack(CCEventListener listener)
{
if (listener.FixedPriority == 0)
{
if (sceneGraphListeners == null)
{
sceneGraphListeners = new List <CCEventListener> (100);
}
sceneGraphListeners.Add(listener);
}
else
{
if (fixedListeners == null)
{
fixedListeners = new List <CCEventListener> (100);
}
fixedListeners.Add(listener);
}
}
/// <summary>
/// Force adding an event listener
/// ** Note ** force add an event listener which will ignore whether it's in dispatching.
/// <see cref=">AddEventListener"/>
/// </summary>
/// <param name="listener"></param>
internal void ForceAddEventListener(CCEventListener listener)
{
CCEventListenerVector listeners = new CCEventListenerVector();
var listenerID = listener.ListenerID;
if (!listenerMap.ContainsKey(listenerID))
{
listeners = new CCEventListenerVector();
listenerMap.Add(listenerID, listeners);
}
else
{
listeners = listenerMap[listenerID];
}
listeners.PushBack(listener);
if (listener.FixedPriority == 0)
{
SetDirty(listenerID, DirtyFlag.SCENE_GRAPH_PRIORITY);
var node = listener.SceneGraphPriority;
Debug.Assert(node != null, "Invalid scene graph priority!");
AssociateNodeAndEventListener(node, listener);
if (node.IsRunning)
{
Resume(node);
}
}
else
{
SetDirty(listenerID, DirtyFlag.FIXED_PRIORITY);
}
}
/// <summary>
/// Removes all listeners which are associated with the specified target.
/// </summary>
/// <param name="target"></param>
/// <param name="recursive"></param>
public void RemoveEventListeners(CCNode target, bool recursive = false)
{
if (nodeListenersMap.ContainsKey(target))
{
var nodeListeners = nodeListenersMap[target];
var listenersCopy2 = new CCEventListener[nodeListeners.Count];
nodeListeners.CopyTo(listenersCopy2);
for (int x = 0; x < listenersCopy2.Length; x++)
{
var listener = listenersCopy2 [x];
RemoveEventListener(listener);
}
}
if (recursive)
{
var children = target.Children;
if (children != null)
{
foreach (var child in children) {
RemoveEventListeners (child, true);
}
}
}
}
bool RemoveListenerInVector (List<CCEventListener> listeners, CCEventListener listener)
{
if (listeners == null)
return false;
for (int x = 0; x < listeners.Count; x++)
{
var l = listeners [x];
if (l == listener) {
l.IsRegistered = false;
if (l.SceneGraphPriority != null) {
DissociateNodeAndEventListener (l.SceneGraphPriority, l);
}
if (inDispatch == 0) {
listeners.Remove (l);
}
return true;
}
}
return false;
}
/// <summary>
/// Remove a listener
/// </summary>
/// <param name="listener">The specified event listener which needs to be removed.</param>
public void RemoveEventListener(CCEventListener listener)
{
if (listener == null)
return;
bool isFound = false;
#if DUMP_LISTENER_ITEM_PRIORITY_INFO
CCLog.Log("----- Remove > " + listener + " -----------------------");
#endif
var listenerIds = listenerMap.Keys;
foreach (var listenerId in listenerIds)
{
var listeners = listenerMap [listenerId];
//var listeners = iter.Value;
var fixedPriorityListeners = listeners.FixedPriorityListeners;
var sceneGraphPriorityListeners = listeners.SceneGraphPriorityListeners;
isFound = RemoveListenerInVector(sceneGraphPriorityListeners, listener);
if (isFound)
{
// fixed #4160: Dirty flag need to be updated after listeners were removed.
SetDirty(listener.ListenerID, DirtyFlag.SCENE_GRAPH_PRIORITY);
}
else
{
isFound = RemoveListenerInVector(fixedPriorityListeners, listener);
if (isFound)
{
SetDirty(listener.ListenerID, DirtyFlag.FIXED_PRIORITY);
}
}
if (listeners.IsEmpty)
{
priorityDirtyFlagMap.Remove (listenerId);
listenerMap.Remove (listenerId);
}
if (isFound)
break;
}
if (isFound)
{
listener.Dispose ();
}
else
{
for (int iter = 0; iter < toBeAddedListeners.Count; iter++)
{
var l = toBeAddedListeners [iter];
if (l == listener)
{
listener.Dispose ();
toBeAddedListeners.Remove(l);
break;
}
}
}
}
public void PushBack(CCEventListener listener)
{
if (listener.FixedPriority == 0)
{
if (sceneGraphListeners == null)
{
sceneGraphListeners = new List<CCEventListener> (100);
}
sceneGraphListeners.Add(listener);
}
else
{
if (fixedListeners == null)
{
fixedListeners = new List<CCEventListener> (100);
}
fixedListeners.Add(listener);
}
}
/// <summary>
/// Adds a event listener for a specified event with the fixed priority.
/// A lower priority will be called before the ones that have a higher value.
/// 0 priority is not allowed for fixed priority since it's used for scene graph based priority.
/// </summary>
/// <param name="listener">The listener of a specified event.</param>
/// <param name="fixedPriority">The fixed priority of the listener.</param>
public void AddEventListener(CCEventListener listener, int fixedPriority)
{
Debug.Assert((listener != null), "Invalid parameters.");
Debug.Assert(!listener.IsRegistered, "The listener has been registered.");
Debug.Assert(fixedPriority != 0, "0 priority is forbidden for fixed priority since it's used for scene graph based priority.");
if (!listener.IsAvailable)
return;
listener.SceneGraphPriority = null;
listener.FixedPriority = fixedPriority;
listener.IsRegistered = true;
listener.IsPaused = false;
AddEventListener(listener);
}
/// <summary>
/// Adds a event listener for a specified event with the priority of scene graph.
/// The priority of scene graph will be fixed value 0. So the order of listener item
/// in the vector will be ' <0, scene graph (0 priority), >0'.
/// </summary>
/// <param name="listener">The listener of a specified event.</param>
/// <param name="node">The priority of the listener is based on the draw order of this node.</param>
public void AddEventListener(CCEventListener listener, CCNode node)
{
Debug.Assert((listener != null && node != null), "Invalid parameters.");
Debug.Assert(!listener.IsRegistered, "The listener has been registered.");
if (!listener.IsAvailable)
return;
listener.SceneGraphPriority = node;
listener.FixedPriority = 0;
listener.IsRegistered = true;
AddEventListener(listener);
}
/// <summary>
/// Dissociates node with event listener
/// </summary>
/// <param name="node"></param>
/// <param name="listener"></param>
void DissociateNodeAndEventListener(CCNode node, CCEventListener listener)
{
List<CCEventListener> listeners = null;
if (nodeListenersMap.ContainsKey(node))
{
listeners = nodeListenersMap [node];
if (listeners.Contains(listener))
listeners.Remove (listener);
if (listeners.Count == 0)
{
nodeListenersMap.Remove (node);
}
}
}
/// <summary>
/// Remove a listener
/// </summary>
/// <param name="listener">The specified event listener which needs to be removed.</param>
public void RemoveEventListener(CCEventListener listener)
{
if (listener == null)
{
return;
}
bool isFound = false;
#if DUMP_LISTENER_ITEM_PRIORITY_INFO
CCLog.Log("----- Remove > " + listener + " -----------------------");
#endif
var listenerIds = listenerMap.Keys;
foreach (var listenerId in listenerIds)
{
var listeners = listenerMap [listenerId];
//var listeners = iter.Value;
var fixedPriorityListeners = listeners.FixedPriorityListeners;
var sceneGraphPriorityListeners = listeners.SceneGraphPriorityListeners;
isFound = RemoveListenerInVector(sceneGraphPriorityListeners, listener);
if (isFound)
{
// fixed #4160: Dirty flag need to be updated after listeners were removed.
SetDirty(listener.ListenerID, DirtyFlag.SCENE_GRAPH_PRIORITY);
}
else
{
isFound = RemoveListenerInVector(fixedPriorityListeners, listener);
if (isFound)
{
SetDirty(listener.ListenerID, DirtyFlag.FIXED_PRIORITY);
}
}
if (listeners.IsEmpty)
{
priorityDirtyFlagMap.Remove(listenerId);
listenerMap.Remove(listenerId);
}
if (isFound)
{
break;
}
}
if (isFound)
{
listener.Dispose();
}
else
{
for (int iter = 0; iter < toBeAddedListeners.Count; iter++)
{
var l = toBeAddedListeners [iter];
if (l == listener)
{
listener.Dispose();
toBeAddedListeners.Remove(l);
break;
}
}
}
}
/// <summary>
/// Force adding an event listener
/// ** Note ** force add an event listener which will ignore whether it's in dispatching.
/// <see cref=">AddEventListener"/>
/// </summary>
/// <param name="listener"></param>
internal void ForceAddEventListener(CCEventListener listener)
{
CCEventListenerVector listeners = new CCEventListenerVector();
var listenerID = listener.ListenerID;
if (!listenerMap.ContainsKey(listenerID))
{
listeners = new CCEventListenerVector();
listenerMap.Add(listenerID, listeners);
}
else
{
listeners = listenerMap[listenerID];;
}
listeners.PushBack(listener);
if (listener.FixedPriority == 0)
{
SetDirty(listenerID, DirtyFlag.SCENE_GRAPH_PRIORITY);
var node = listener.SceneGraphPriority;
Debug.Assert(node != null, "Invalid scene graph priority!");
AssociateNodeAndEventListener(node, listener);
if (node.IsRunning)
{
Resume(node);
}
}
else
{
SetDirty(listenerID, DirtyFlag.FIXED_PRIORITY);
}
}
/// <summary>
/// Sets listener's priority with fixed value.
/// </summary>
/// <param name="listener"></param>
/// <param name="fixedPriority"></param>
public void SetPriority(CCEventListener listener, int fixedPriority)
{
if (listener == null)
return;
foreach (var l in listenerMap)
{
var fixedPriorityListeners = l.Value.FixedPriorityListeners;
if (fixedPriorityListeners != null && fixedPriorityListeners.Count > 0)
{
var found = fixedPriorityListeners.IndexOf(listener);
if (found >= 0)
{
//Debug.Assert(listener.)
if (listener.FixedPriority != fixedPriority)
{
listener.FixedPriority = fixedPriority;
SetDirty(listener.ListenerID, DirtyFlag.FIXED_PRIORITY);
}
return;
}
}
}
}
/// <summary>
/// Adds an event listener with item
/// ** Note ** if it is dispatching event, the added operation will be delayed to the end of current dispatch
/// <see cref=">ForceAddEventListener"/>
/// </summary>
///
/// <param name="listener"></param>
void AddEventListener(CCEventListener listener)
{
if (inDispatch == 0)
{
#if DUMP_LISTENER_ITEM_PRIORITY_INFO
CCLog.Log("----- Add > -- Available > " + listener.IsAvailable + " ------{0}------{1}---------", listener, listener.SceneGraphPriority);
#endif
ForceAddEventListener(listener);
}
else
{
toBeAddedListeners.Add(listener);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CocosSharp.CCEventListener"/> class using the event listener passed
/// </summary>
/// <param name="eventListener">Event listener.</param>
protected CCEventListener(CCEventListener eventListener)
{
//throw new NotImplementedException ();
}
/// <summary>
/// Initializes a new instance of the <see cref="CocosSharp.CCEventListener"/> class using the event listener passed
/// </summary>
/// <param name="eventListener">Event listener.</param>
protected CCEventListener(CCEventListener eventListener)
{
//throw new NotImplementedException ();
}
/// <summary>
/// Associates node with event listener
/// </summary>
/// <param name="node"></param>
/// <param name="listener"></param>
void AssociateNodeAndEventListener(CCNode node, CCEventListener listener)
{
List<CCEventListener> listeners = null;
if (nodeListenersMap.ContainsKey(node))
{
listeners = nodeListenersMap [node];
}
else
{
listeners = new List<CCEventListener> ();
nodeListenersMap.Add (node, listeners);
}
listeners.Add (listener);
}
