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(); } }