public void touches(List <CCTouch> pTouches, CCEvent pEvent, int uIndex)
{
List <CCTouch> pMutableTouches;
m_bLocked = true;
// optimization to prevent a mutable copy when it is not necessary
int uTargetedHandlersCount = m_pTargetedHandlers.Count;
int uStandardHandlersCount = m_pStandardHandlers.Count;
bool bNeedsMutableSet = (uTargetedHandlersCount > 0 && uStandardHandlersCount > 0);
if (bNeedsMutableSet)
{
CCTouch[] tempArray = pTouches.ToArray();
pMutableTouches = tempArray.ToList();
}
else
{
pMutableTouches = pTouches;
}
CCTouchType sHelper = (CCTouchType)uIndex;
// process the target handlers 1st
if (uTargetedHandlersCount > 0)
{
#region CCTargetedTouchHandler
foreach (CCTouch pTouch in pTouches)
{
foreach (CCTargetedTouchHandler pHandler in m_pTargetedHandlers)
{
ICCTargetedTouchDelegate pDelegate = (ICCTargetedTouchDelegate)(pHandler.Delegate);
bool bClaimed = false;
if (sHelper == CCTouchType.CCTOUCHBEGAN)
{
bClaimed = pDelegate.ccTouchBegan(pTouch, pEvent);
if (bClaimed)
{
pHandler.ClaimedTouches.Add(pTouch);
}
}
else
{
if (pHandler.ClaimedTouches.Contains(pTouch))
{
// moved ended cancelled
bClaimed = true;
switch (sHelper)
{
case CCTouchType.CCTOUCHMOVED:
pDelegate.ccTouchMoved(pTouch, pEvent);
break;
case CCTouchType.CCTOUCHENDED:
pDelegate.ccTouchEnded(pTouch, pEvent);
pHandler.ClaimedTouches.Remove(pTouch);
break;
case CCTouchType.CCTOUCHCANCELLED:
pDelegate.ccTouchCancelled(pTouch, pEvent);
pHandler.ClaimedTouches.Remove(pTouch);
break;
}
}
}
if (bClaimed && pHandler.IsSwallowsTouches)
{
if (bNeedsMutableSet)
{
pMutableTouches.Remove(pTouch);
}
break;
}
}
}
#endregion
}
// process standard handlers 2nd
if (uStandardHandlersCount > 0 && pMutableTouches.Count > 0)
{
#region CCStandardTouchHandler
foreach (CCStandardTouchHandler pHandler in m_pStandardHandlers)
{
ICCStandardTouchDelegate pDelegate = (ICCStandardTouchDelegate)pHandler.Delegate;
switch (sHelper)
{
case CCTouchType.CCTOUCHBEGAN:
pDelegate.ccTouchesBegan(pMutableTouches, pEvent);
break;
case CCTouchType.CCTOUCHMOVED:
pDelegate.ccTouchesMoved(pMutableTouches, pEvent);
break;
case CCTouchType.CCTOUCHENDED:
pDelegate.ccTouchesEnded(pMutableTouches, pEvent);
break;
case CCTouchType.CCTOUCHCANCELLED:
pDelegate.ccTouchesCancelled(pMutableTouches, pEvent);
break;
}
}
#endregion
}
if (bNeedsMutableSet)
{
pMutableTouches = null;
}
//
// Optimization. To prevent a [handlers copy] which is expensive
// the add/removes/quit is done after the iterations
//
m_bLocked = false;
if (m_bToRemove)
{
m_bToRemove = false;
for (int i = 0; i < m_pHandlersToRemove.Count; ++i)
{
forceRemoveDelegate((ICCTouchDelegate)m_pHandlersToRemove[i]);
}
m_pHandlersToRemove.Clear();
}
if (m_bToAdd)
{
m_bToAdd = false;
foreach (CCTouchHandler pHandler in m_pHandlersToAdd)
{
if (pHandler is CCTargetedTouchHandler && pHandler.Delegate is ICCTargetedTouchDelegate)
{
forceAddHandler(pHandler, m_pTargetedHandlers);
}
else if (pHandler is CCStandardTouchHandler && pHandler.Delegate is ICCStandardTouchDelegate)
{
forceAddHandler(pHandler, m_pStandardHandlers);
}
else
{
CCLog.Log("ERROR: inconsistent touch handler and delegate found in m_pHandlersToAdd of CCTouchDispatcher");
}
}
m_pHandlersToAdd.Clear();
}
if (m_bToQuit)
{
m_bToQuit = false;
forceRemoveAllDelegates();
}
}
public void Touches(List <CCTouch> pTouches, CCTouchType touchType)
{
m_bLocked = true;
if (m_bRearrangeTargetedHandlersUponTouch)
{
RearrangeHandlers(m_pTargetedHandlers);
m_bRearrangeTargetedHandlersUponTouch = false;
}
if (m_bRearrangeStandardHandlersUponTouch)
{
RearrangeHandlers(m_pStandardHandlers);
m_bRearrangeStandardHandlersUponTouch = false;
}
// optimization to prevent a mutable copy when it is not necessary
int uTargetedHandlersCount = m_pTargetedHandlers.Count;
int uStandardHandlersCount = m_pStandardHandlers.Count;
bool bNeedsMutableSet = (uTargetedHandlersCount > 0 && uStandardHandlersCount > 0);
if (bNeedsMutableSet)
{
CCTouch[] tempArray = pTouches.ToArray();
pMutableTouches = tempArray.ToList();
}
else
{
pMutableTouches = pTouches;
}
// var sHelper = (CCTouchType) touchType;
//
// Process non-began touches that were consumed by a handler and they
// need to be focused on their targets
//
/*
* Remove this preprocessing step for these touches. Let't the claim/unclaimed logic
* handle targeted touches.
* if (touchType != CCTouchType.Began)
* {
#if WINDOWS_PHONE || XBOX360
* List<CCTouch> focused = new List<CCTouch>();
* foreach (CCTouch t in pTouches)
* {
* if (t.Consumer != null)
* {
* focused.Add(t);
* }
* }
#else
* var focused = pTouches.FindAll((t) => t.Consumer != null);
#endif
* if (focused != null)
* {
* // Thes touches already were handled by another consumer, so continue to send them to that
* // consumer. Make sure we remove them from the other lists.
* foreach (CCTouch t in focused)
* {
* var pDelegate = (ICCTargetedTouchDelegate)(t.Consumer.Delegate);
* switch (touchType)
* {
* case CCTouchType.Moved:
* pDelegate.TouchMoved(t);
* break;
* case CCTouchType.Ended:
* pDelegate.TouchEnded(t);
* t.Consumer.ClaimedTouches.Remove(t);
* break;
* case CCTouchType.Cancelled:
* pDelegate.TouchCancelled(t);
* t.Consumer.ClaimedTouches.Remove(t);
* break;
* }
* }
* }
* }
*/
// process the target handlers 1st
if (uTargetedHandlersCount > 0)
{
#region CCTargetedTouchHandler
foreach (CCTouch pTouch in pTouches)
{
if (pTouch.Consumer != null)
{
var pDelegate = (ICCTargetedTouchDelegate)(pTouch.Consumer.Delegate);
switch (touchType)
{
case CCTouchType.Moved:
pDelegate.TouchMoved(pTouch);
break;
case CCTouchType.Ended:
pDelegate.TouchEnded(pTouch);
pTouch.Consumer.ClaimedTouches.Remove(pTouch);
break;
case CCTouchType.Cancelled:
pDelegate.TouchCancelled(pTouch);
pTouch.Consumer.ClaimedTouches.Remove(pTouch);
break;
}
continue;
}
bool bClaimed = false;
foreach (CCTargetedTouchHandler pHandler in m_pTargetedHandlers)
{
if (bClaimed)
{
break;
}
var pDelegate = (ICCTargetedTouchDelegate)(pHandler.Delegate);
if (!pDelegate.VisibleForTouches)
{
continue;
}
if (touchType == CCTouchType.Began)
{
bClaimed = pDelegate.TouchBegan(pTouch);
// Touches must be claimed here regardless of ConsumesTouches.
// If the touch doesn't get claimed properly then it will not be
// associated with the proper delegate for TouchMoved.
if (bClaimed)
{
pHandler.ClaimedTouches.Add(pTouch);
pTouch.Consumer = pHandler;
}
}
else
{
if (pHandler.ClaimedTouches.Contains(pTouch))
{
// move ended cancelled
bClaimed = true;
switch (touchType)
{
case CCTouchType.Moved:
pDelegate.TouchMoved(pTouch);
break;
case CCTouchType.Ended:
pDelegate.TouchEnded(pTouch);
pHandler.ClaimedTouches.Remove(pTouch);
break;
case CCTouchType.Cancelled:
pDelegate.TouchCancelled(pTouch);
pHandler.ClaimedTouches.Remove(pTouch);
break;
}
}
}
if (bClaimed && pHandler.ConsumesTouches)
{
if (bNeedsMutableSet)
{
pMutableTouches.Remove(pTouch);
}
break;
}
}
}
#endregion
}
// process standard handlers 2nd
if (uStandardHandlersCount > 0 && pMutableTouches.Count > 0)
{
#region CCStandardTouchHandler
foreach (CCStandardTouchHandler pHandler in m_pStandardHandlers)
{
var pDelegate = (ICCStandardTouchDelegate)pHandler.Delegate;
if (!pDelegate.VisibleForTouches)
{
continue;
}
switch (touchType)
{
case CCTouchType.Began:
pDelegate.TouchesBegan(pMutableTouches);
break;
case CCTouchType.Moved:
pDelegate.TouchesMoved(pMutableTouches);
break;
case CCTouchType.Ended:
pDelegate.TouchesEnded(pMutableTouches);
break;
case CCTouchType.Cancelled:
pDelegate.TouchesCancelled(pMutableTouches);
break;
}
}
#endregion
}
if (bNeedsMutableSet)
{
pMutableTouches = null;
}
//
// Optimization. To prevent a [handlers copy] which is expensive
// the add/removes/quit is done after the iterations
//
m_bLocked = false;
if (m_bToRemove)
{
m_bToRemove = false;
for (int i = 0; i < m_pHandlersToRemove.Count; ++i)
{
ForceRemoveDelegate((ICCTouchDelegate)m_pHandlersToRemove[i]);
}
m_pHandlersToRemove.Clear();
}
if (m_bToAdd)
{
m_bToAdd = false;
foreach (CCTouchHandler pHandler in m_pHandlersToAdd)
{
if (pHandler is CCTargetedTouchHandler && pHandler.Delegate is ICCTargetedTouchDelegate)
{
ForceAddHandler(pHandler, m_pTargetedHandlers);
}
else if (pHandler is CCStandardTouchHandler && pHandler.Delegate is ICCStandardTouchDelegate)
{
ForceAddHandler(pHandler, m_pStandardHandlers);
}
else
{
CCLog.Log("ERROR: inconsistent touch handler and delegate found in m_pHandlersToAdd of CCTouchDispatcher");
}
}
m_pHandlersToAdd.Clear();
}
if (m_bToQuit)
{
m_bToQuit = false;
ForceRemoveAllDelegates();
}
}
public void touches(List <CCTouch> pTouches, CCEvent pEvent, int uIndex)
{
List <CCTouch> cCTouches;
this.m_bLocked = true;
int count = this.m_pTargetedHandlers.Count;
int num = this.m_pStandardHandlers.Count;
bool flag = (count <= 0 ? false : num > 0);
cCTouches = (!flag ? pTouches : pTouches.ToArray().ToList <CCTouch>());
CCTouchType cCTouchType = (CCTouchType)uIndex;
if (count > 0)
{
foreach (CCTouch pTouch in pTouches)
{
foreach (CCTargetedTouchHandler mPTargetedHandler in this.m_pTargetedHandlers)
{
ICCTargetedTouchDelegate @delegate = (ICCTargetedTouchDelegate)mPTargetedHandler.Delegate;
bool flag1 = false;
if (cCTouchType == CCTouchType.CCTOUCHBEGAN)
{
flag1 = @delegate.ccTouchBegan(pTouch, pEvent);
if (flag1)
{
mPTargetedHandler.ClaimedTouches.Add(pTouch);
}
}
else if (mPTargetedHandler.ClaimedTouches.Contains(pTouch))
{
flag1 = true;
switch (cCTouchType)
{
case CCTouchType.CCTOUCHMOVED:
{
@delegate.ccTouchMoved(pTouch, pEvent);
break;
}
case CCTouchType.CCTOUCHENDED:
{
@delegate.ccTouchEnded(pTouch, pEvent);
mPTargetedHandler.ClaimedTouches.Remove(pTouch);
break;
}
case CCTouchType.CCTOUCHCANCELLED:
{
@delegate.ccTouchCancelled(pTouch, pEvent);
mPTargetedHandler.ClaimedTouches.Remove(pTouch);
break;
}
}
}
if (!flag1 || !mPTargetedHandler.IsSwallowsTouches)
{
continue;
}
if (!flag)
{
break;
}
cCTouches.Remove(pTouch);
break;
}
}
}
if (num > 0 && cCTouches.Count > 0)
{
foreach (CCStandardTouchHandler mPStandardHandler in this.m_pStandardHandlers)
{
ICCStandardTouchDelegate cCStandardTouchDelegate = (ICCStandardTouchDelegate)mPStandardHandler.Delegate;
switch (cCTouchType)
{
case CCTouchType.CCTOUCHBEGAN:
{
cCStandardTouchDelegate.ccTouchesBegan(cCTouches, pEvent);
continue;
}
case CCTouchType.CCTOUCHMOVED:
{
cCStandardTouchDelegate.ccTouchesMoved(cCTouches, pEvent);
continue;
}
case CCTouchType.CCTOUCHENDED:
{
cCStandardTouchDelegate.ccTouchesEnded(cCTouches, pEvent);
continue;
}
case CCTouchType.CCTOUCHCANCELLED:
{
cCStandardTouchDelegate.ccTouchesCancelled(cCTouches, pEvent);
continue;
}
default:
{
continue;
}
}
}
}
if (flag)
{
cCTouches = null;
}
this.m_bLocked = false;
if (this.m_bToRemove)
{
this.m_bToRemove = false;
for (int i = 0; i < this.m_pHandlersToRemove.Count; i++)
{
this.forceRemoveDelegate((ICCTouchDelegate)this.m_pHandlersToRemove[i]);
}
this.m_pHandlersToRemove.Clear();
}
if (this.m_bToAdd)
{
this.m_bToAdd = false;
foreach (CCTouchHandler mPHandlersToAdd in this.m_pHandlersToAdd)
{
if (mPHandlersToAdd is CCTargetedTouchHandler && mPHandlersToAdd.Delegate is ICCTargetedTouchDelegate)
{
this.forceAddHandler(mPHandlersToAdd, this.m_pTargetedHandlers);
}
else if (!(mPHandlersToAdd is CCStandardTouchHandler) || !(mPHandlersToAdd.Delegate is ICCStandardTouchDelegate))
{
CCLog.Log("ERROR: inconsistent touch handler and delegate found in m_pHandlersToAdd of CCTouchDispatcher");
}
else
{
this.forceAddHandler(mPHandlersToAdd, this.m_pStandardHandlers);
}
}
this.m_pHandlersToAdd.Clear();
}
if (this.m_bToQuit)
{
this.m_bToQuit = false;
this.forceRemoveAllDelegates();
}
}
public void Touches(List<CCTouch> pTouches, CCTouchType touchType)
{
m_bLocked = true;
if (m_bRearrangeTargetedHandlersUponTouch)
{
RearrangeHandlers(m_pTargetedHandlers);
m_bRearrangeTargetedHandlersUponTouch = false;
}
if (m_bRearrangeStandardHandlersUponTouch)
{
RearrangeHandlers(m_pStandardHandlers);
m_bRearrangeStandardHandlersUponTouch = false;
}
// optimization to prevent a mutable copy when it is not necessary
int uTargetedHandlersCount = m_pTargetedHandlers.Count;
int uStandardHandlersCount = m_pStandardHandlers.Count;
bool bNeedsMutableSet = (uTargetedHandlersCount > 0 && uStandardHandlersCount > 0);
if (bNeedsMutableSet)
{
CCTouch[] tempArray = pTouches.ToArray();
pMutableTouches = tempArray.ToList();
}
else
{
pMutableTouches = pTouches;
}
// var sHelper = (CCTouchType) touchType;
//
// Process non-began touches that were consumed by a handler and they
// need to be focused on their targets
//
/*
* Remove this preprocessing step for these touches. Let't the claim/unclaimed logic
* handle targeted touches.
if (touchType != CCTouchType.Began)
{
#if WINDOWS_PHONE || XBOX360
List<CCTouch> focused = new List<CCTouch>();
foreach (CCTouch t in pTouches)
{
if (t.Consumer != null)
{
focused.Add(t);
}
}
#else
var focused = pTouches.FindAll((t) => t.Consumer != null);
#endif
if (focused != null)
{
// Thes touches already were handled by another consumer, so continue to send them to that
// consumer. Make sure we remove them from the other lists.
foreach (CCTouch t in focused)
{
var pDelegate = (ICCTargetedTouchDelegate)(t.Consumer.Delegate);
switch (touchType)
{
case CCTouchType.Moved:
pDelegate.TouchMoved(t);
break;
case CCTouchType.Ended:
pDelegate.TouchEnded(t);
t.Consumer.ClaimedTouches.Remove(t);
break;
case CCTouchType.Cancelled:
pDelegate.TouchCancelled(t);
t.Consumer.ClaimedTouches.Remove(t);
break;
}
}
}
}
*/
// process the target handlers 1st
if (uTargetedHandlersCount > 0)
{
#region CCTargetedTouchHandler
foreach (CCTouch pTouch in pTouches)
{
if (pTouch.Consumer != null)
{
var pDelegate = (ICCTargetedTouchDelegate)(pTouch.Consumer.Delegate);
switch (touchType)
{
case CCTouchType.Moved:
pDelegate.TouchMoved(pTouch);
break;
case CCTouchType.Ended:
pDelegate.TouchEnded(pTouch);
pTouch.Consumer.ClaimedTouches.Remove(pTouch);
break;
case CCTouchType.Cancelled:
pDelegate.TouchCancelled(pTouch);
pTouch.Consumer.ClaimedTouches.Remove(pTouch);
break;
}
continue;
}
bool bClaimed = false;
foreach (CCTargetedTouchHandler pHandler in m_pTargetedHandlers)
{
if (bClaimed)
{
//break;
}
var pDelegate = (ICCTargetedTouchDelegate) (pHandler.Delegate);
if (!pDelegate.VisibleForTouches)
{
continue;
}
if (touchType == CCTouchType.Began)
{
bClaimed = pDelegate.TouchBegan(pTouch);
// Touches must be claimed here regardless of ConsumesTouches.
// If the touch doesn't get claimed properly then it will not be
// associated with the proper delegate for TouchMoved.
if (bClaimed)
{
pHandler.ClaimedTouches.Add(pTouch);
pTouch.Consumer = pHandler;
}
}
else
{
if (pHandler.ClaimedTouches.Contains(pTouch))
{
// move ended cancelled
bClaimed = true;
switch (touchType)
{
case CCTouchType.Moved:
pDelegate.TouchMoved(pTouch);
break;
case CCTouchType.Ended:
pDelegate.TouchEnded(pTouch);
pHandler.ClaimedTouches.Remove(pTouch);
break;
case CCTouchType.Cancelled:
pDelegate.TouchCancelled(pTouch);
pHandler.ClaimedTouches.Remove(pTouch);
break;
}
}
}
if (bClaimed && pHandler.ConsumesTouches)
{
if (bNeedsMutableSet)
{
pMutableTouches.Remove(pTouch);
}
break;
}
}
}
#endregion
}
// process standard handlers 2nd
if (uStandardHandlersCount > 0 && pMutableTouches.Count > 0)
{
#region CCStandardTouchHandler
foreach (CCStandardTouchHandler pHandler in m_pStandardHandlers)
{
var pDelegate = (ICCStandardTouchDelegate) pHandler.Delegate;
if (!pDelegate.VisibleForTouches)
{
continue;
}
switch (touchType)
{
case CCTouchType.Began:
pDelegate.TouchesBegan(pMutableTouches);
break;
case CCTouchType.Moved:
pDelegate.TouchesMoved(pMutableTouches);
break;
case CCTouchType.Ended:
pDelegate.TouchesEnded(pMutableTouches);
break;
case CCTouchType.Cancelled:
pDelegate.TouchesCancelled(pMutableTouches);
break;
}
}
#endregion
}
if (bNeedsMutableSet)
{
pMutableTouches = null;
}
//
// Optimization. To prevent a [handlers copy] which is expensive
// the add/removes/quit is done after the iterations
//
m_bLocked = false;
if (m_bToRemove)
{
m_bToRemove = false;
for (int i = 0; i < m_pHandlersToRemove.Count; ++i)
{
ForceRemoveDelegate((ICCTouchDelegate) m_pHandlersToRemove[i]);
}
m_pHandlersToRemove.Clear();
}
if (m_bToAdd)
{
m_bToAdd = false;
foreach (CCTouchHandler pHandler in m_pHandlersToAdd)
{
if (pHandler is CCTargetedTouchHandler && pHandler.Delegate is ICCTargetedTouchDelegate)
{
ForceAddHandler(pHandler, m_pTargetedHandlers);
}
else if (pHandler is CCStandardTouchHandler && pHandler.Delegate is ICCStandardTouchDelegate)
{
ForceAddHandler(pHandler, m_pStandardHandlers);
}
else
{
CCLog.Log("ERROR: inconsistent touch handler and delegate found in m_pHandlersToAdd of CCTouchDispatcher");
}
}
m_pHandlersToAdd.Clear();
}
if (m_bToQuit)
{
m_bToQuit = false;
ForceRemoveAllDelegates();
}
}
