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