void ActionManager::removeActionAtIndex(ssize_t index, tHashElement *element) { Action *action = (Action*)element->actions->arr[index]; if (action == element->currentAction && (! element->currentActionSalvaged)) { element->currentAction->retain(); element->currentActionSalvaged = true; } ccArrayRemoveObjectAtIndex(element->actions, index, true); // update actionIndex in case we are in tick. looping over the actions if (element->actionIndex >= index) { element->actionIndex--; } if (element->actions->num == 0) { if (_currentTarget == element) { _currentTargetSalvaged = true; } else { deleteHashElement(element); } } }
void CCActionManager::removeActionAtIndex(unsigned int uIndex, tHashElement *pElement) { CCAction *pAction = (CCAction*)pElement->actions->arr[uIndex]; if (pAction == pElement->currentAction && (! pElement->currentActionSalvaged)) { pElement->currentAction->retain(); pElement->currentActionSalvaged = true; } ccArrayRemoveObjectAtIndex(pElement->actions, uIndex, true); // update actionIndex in case we are in tick. looping over the actions if (pElement->actionIndex >= uIndex) { pElement->actionIndex--; } if (pElement->actions->num == 0) { if (m_pCurrentTarget == pElement) { m_bCurrentTargetSalvaged = true; } else { deleteHashElement(pElement); } } }
/** Searches for the first occurrence of object and removes it. If object is not found the function has no effect. */ void ccArrayRemoveObject(ccArray *arr, Ref* object, bool releaseObj/* = true*/) { auto index = ccArrayGetIndexOfObject(arr, object); if (index != CC_INVALID_INDEX) { ccArrayRemoveObjectAtIndex(arr, index, releaseObj); } }
/** Searches for the first occurrence of object and removes it. If object is not found the function has no effect. */ void ccArrayRemoveObject(ccArray *arr, CCObject* object, bool bReleaseObj/* = true*/) { unsigned int index = ccArrayGetIndexOfObject(arr, object); if (index != CC_INVALID_INDEX) { ccArrayRemoveObjectAtIndex(arr, index, bReleaseObj); } }
void ParallaxContainer::removeChild(Node* child, bool cleanup) { for( int i=0;i < _parallaxArray->num;i++) { PointObject *point = (PointObject*)_parallaxArray->arr[i]; if (point->getChild() == child) { ccArrayRemoveObjectAtIndex(_parallaxArray, i, true); break; } } Node::removeChild(child, cleanup); }
void CCScheduler::unscheduleSelector(SEL_SCHEDULE pfnSelector, SelectorProtocol *pTarget) { // explicity handle nil arguments when removing an object if (pTarget == 0 || pfnSelector == 0) { return; } assert(pTarget); assert(pfnSelector); tHashSelectorEntry *pElement = NULL; HASH_FIND_INT(m_pHashForSelectors, &pTarget, pElement); if (pElement) { for (unsigned int i = 0; i < pElement->timers->num; ++i) { CCTimer *pTimer = (CCTimer*)(pElement->timers->arr[i]); if (pfnSelector == pTimer->m_pfnSelector) { if (pTimer == pElement->currentTimer && (! pElement->currentTimerSalvaged)) { pElement->currentTimer->retain(); pElement->currentTimerSalvaged = true; } ccArrayRemoveObjectAtIndex(pElement->timers, i ); // update timerIndex in case we are in tick:, looping over the actions if (pElement->timerIndex >= i) { pElement->timerIndex--; } if (pElement->timers->num == 0) { if (m_pCurrentTarget == pElement) { m_bCurrentTargetSalvaged = true; } else { removeHashElement(pElement); } } return; } } } }
void CCParallaxScrollNode::removeChild(CCSprite *node, bool cleanup) { for (int i=0; i < scrollOffsets->num; i++) { CCParallaxScrollOffset *scrollOffset = (CCParallaxScrollOffset*)scrollOffsets->arr[i]; if(scrollOffset->getChild()->isEqual(node)) { ccArrayRemoveObjectAtIndex(scrollOffsets, i); break; } } if (batch) { batch->removeChild(node, cleanup); } }
void CCArray::removeObjectAtIndex(unsigned int index) { ccArrayRemoveObjectAtIndex(data, index); }
void CCArray::removeLastObject() { CCAssert(data->num, "no objects added"); ccArrayRemoveObjectAtIndex(data, data->num-1); }