TestArtPig::~TestArtPig ( KDvoid ) { CC_SAFE_DELETE ( m_pSymbol ); }
EventDispatcher::EventListenerVector::~EventListenerVector() { CC_SAFE_DELETE(_sceneGraphListeners); CC_SAFE_DELETE(_fixedListeners); }
void ComAudioReader::purge() { CC_SAFE_DELETE(_instanceComAudioReader); }
DiscJockey::~DiscJockey() { CC_SAFE_DELETE(_dj); }
CAWebView::~CAWebView() { CC_SAFE_DELETE(_impl); }
CCTextFieldTTF::~CCTextFieldTTF() { CC_SAFE_DELETE(m_pInputText); CC_SAFE_DELETE(m_pPlaceHolder); }
//----------------------------------------------------------------------- void PUGeometryRotator::setRotationSpeed(PUDynamicAttribute* dynRotationSpeed) { if (_dynRotationSpeed) CC_SAFE_DELETE(_dynRotationSpeed); _dynRotationSpeed = dynRotationSpeed; }
TableView::~TableView() { CC_SAFE_DELETE(_indices); }
PlantManager::~PlantManager() { CC_SAFE_DELETE(m_plants); }
KDvoid SimpleAudioEngine::end ( KDvoid ) { CC_SAFE_DELETE ( l_pSharedEngine ); return; }
FrameData::~FrameData(void) { CC_SAFE_DELETE(easingParams); }
bool Armature::init(const char *name) { bool bRet = false; do { //cocos2d::CCLog("Armature (%s) create.", name); CC_SAFE_DELETE(m_pAnimation); m_pAnimation = Animation::create(this); CCAssert(m_pAnimation, "create Armature::m_pAnimation fail!"); m_pAnimation->retain(); CC_SAFE_DELETE(m_pBoneDic); m_pBoneDic = CCDictionary::create(); CCAssert(m_pBoneDic, "create Armature::m_pBoneDic fail!"); m_pBoneDic->retain(); m_sBlendFunc.src = CC_BLEND_SRC; m_sBlendFunc.dst = CC_BLEND_DST; m_strName = name == NULL ? "" : name; ArmatureDataManager *armatureDataManager = ArmatureDataManager::sharedArmatureDataManager(); if(m_strName.compare("") != 0) { m_strName = name; AnimationData* animationData = armatureDataManager->getAnimationData(name); CCAssert(animationData, "AnimationData not exist! "); m_pAnimation->setAnimationData(animationData); ArmatureData *armatureData = armatureDataManager->getArmatureData(name); CCAssert(armatureData, ""); m_pArmatureData = armatureData; CCDictElement *_element = NULL; CCDictionary *boneDataDic = &armatureData->boneDataDic; CCDICT_FOREACH(boneDataDic, _element) { Bone *bone = createBone(_element->getStrKey()); //! init bone's Tween to 1st movement's 1st frame do { MovementData *movData = animationData->getMovement(animationData->movementNames.at(0).c_str()); CC_BREAK_IF(!movData); MovementBoneData *movBoneData = movData->getMovementBoneData(bone->getName().c_str()); CC_BREAK_IF(!movBoneData || movBoneData->frameList.count() <= 0); FrameData *_frameData = movBoneData->getFrameData(0); CC_BREAK_IF(!_frameData); bone->getTweenData()->copy(_frameData); } while (0); } }
static CCEGL * create(TWindow * pWindow) { CCEGL * pEGL = new CCEGL; Boolean bSuccess = FALSE; do { CC_BREAK_IF(! pEGL); TUChar szError[] = {'E','R','R','O','R',0}; TUChar szEglInitFailed[] = {'e','g','l','I','n','i','t','i','a','l','i','z','e',' ','f','a','i','l','e','d',0}; TUChar szCreateContextFailed[] = {'e','g','l','C','r','e','a','t','e','C','o','n','t','e','x','t',' ','f','a','i','l','e','d',0}; TUChar szEglCreateWindowSurfaceFailed[] = {'e','g','l','C','r','e','a','t','e','W','i','n','d','o','w','S','u','r','f','a','c','e',' ','f','a','i','l','e','d',0}; TUChar szEglMakeCurrentFailed[] = {'e','g','l','M','a','k','e','C','u','r','r','e','n','t',' ','f','a','i','l','e','d',0}; pEGL->m_eglNativeWindow = pWindow; EGLDisplay eglDisplay; CC_BREAK_IF(EGL_NO_DISPLAY == (eglDisplay = eglGetDisplay(pEGL->m_eglNativeDisplay))); EGLint nMajor, nMinor; EGLBoolean bEglRet; bEglRet = eglInitialize(eglDisplay, &nMajor, &nMinor); if ( EGL_FALSE == bEglRet || 1 != nMajor ) { TApplication::GetCurrentApplication()->MessageBox(szEglInitFailed, szError, WMB_OK); break; } const EGLint aConfigAttribs[] = { EGL_LEVEL, 0, EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_NATIVE_RENDERABLE, EGL_FALSE, EGL_DEPTH_SIZE, 16, EGL_NONE, }; EGLint iConfigs; EGLConfig eglConfig; CC_BREAK_IF( EGL_FALSE == eglChooseConfig(eglDisplay, aConfigAttribs, &eglConfig, 1, &iConfigs) || (iConfigs != 1) ); EGLContext eglContext = eglCreateContext(eglDisplay, eglConfig, NULL, NULL); if (EGL_NO_CONTEXT == eglContext) { TApplication::GetCurrentApplication()->MessageBox(szCreateContextFailed, szError, WMB_OK); break; } EGLSurface eglSurface; eglSurface = eglCreateWindowSurface(eglDisplay, eglConfig, pEGL->m_eglNativeWindow, NULL); if (EGL_NO_SURFACE == eglSurface) { TApplication::GetCurrentApplication()->MessageBox(szEglCreateWindowSurfaceFailed, szError, WMB_OK); break; } bEglRet = eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext); if (EGL_FALSE == bEglRet) { TApplication::GetCurrentApplication()->MessageBox(szEglMakeCurrentFailed, szError, WMB_OK); break; } pEGL->m_eglDisplay = eglDisplay; pEGL->m_eglConfig = eglConfig; pEGL->m_eglContext = eglContext; pEGL->m_eglSurface = eglSurface; bSuccess = TRUE; } while (0); if (! bSuccess) { CC_SAFE_DELETE(pEGL); } return pEGL; }
CCEGLView::~CCEGLView() { CC_SAFE_DELETE(m_pDelegate); CC_SAFE_DELETE(m_pEGL); }
PetDatablock::~PetDatablock() { CC_SAFE_DELETE( pFeedPetData ); }
EventCondition::~EventCondition() { CC_SAFE_DELETE(m_value); }
void ActorManager::release() { CC_SAFE_DELETE(m_ActorManager); }
void StringUtil::purgeSharedStringUtil() { CC_SAFE_DELETE(g_sharedStringUtil); }
//----------------------------------------------------------------------- PUGeometryRotator::~PUGeometryRotator() { if (_dynRotationSpeed) CC_SAFE_DELETE(_dynRotationSpeed); }
void DictionaryHelper::purgeDictionaryHelper() { CC_SAFE_DELETE(sharedHelper); }
CCEditBox::~CCEditBox(void) { CC_SAFE_DELETE(m_pEditBoxImpl); }
//------------------------------------------------------------------------- // 资源清理 void CCocos2dxDBTextureAtlas::Clear() { CC_SAFE_DELETE( m_pTextureAtlasData ); m_pTextureAtlasData = NULL; CC_SAFE_RELEASE_NULL( m_pTextureAtlas ); }
GuideInfoUtil::~GuideInfoUtil(){ CC_SAFE_DELETE(m_instance); }
void HttpClient::destroyInstance() { CC_SAFE_DELETE(s_pHttpClient); }
CCColliderDetector::~CCColliderDetector() { m_pColliderBodyList->removeAllObjects(); CC_SAFE_DELETE(m_pColliderBodyList); }
int WebSocket::onSocketCallback(struct libwebsocket_context *ctx, struct libwebsocket *wsi, enum libwebsocket_callback_reasons reason, void *user, void *in, size_t len) { // CCLOG("socket callback for %d reason", reason); CCAssert(_wsContext == NULL || ctx == _wsContext, "Invalid context."); CCAssert(_wsInstance == NULL || wsi == NULL || wsi == _wsInstance, "Invaild websocket instance."); switch (reason) { case LWS_CALLBACK_DEL_POLL_FD: case LWS_CALLBACK_PROTOCOL_DESTROY: case LWS_CALLBACK_CLIENT_CONNECTION_ERROR: { WsMessage* msg = NULL; if (reason == LWS_CALLBACK_CLIENT_CONNECTION_ERROR || (reason == LWS_CALLBACK_PROTOCOL_DESTROY && _readyState == kStateConnecting) || (reason == LWS_CALLBACK_DEL_POLL_FD && _readyState == kStateConnecting) ) { msg = new WsMessage(); msg->what = WS_MSG_TO_UITHREAD_ERROR; _readyState = kStateClosing; } else if (reason == LWS_CALLBACK_PROTOCOL_DESTROY && _readyState == kStateClosing) { msg = new WsMessage(); msg->what = WS_MSG_TO_UITHREAD_CLOSE; } if (msg) { _wsHelper->sendMessageToUIThread(msg); } } break; case LWS_CALLBACK_CLIENT_ESTABLISHED: { WsMessage* msg = new WsMessage(); msg->what = WS_MSG_TO_UITHREAD_OPEN; _readyState = kStateOpen; /* * start the ball rolling, * LWS_CALLBACK_CLIENT_WRITEABLE will come next service */ libwebsocket_callback_on_writable(ctx, wsi); _wsHelper->sendMessageToUIThread(msg); } break; case LWS_CALLBACK_CLIENT_WRITEABLE: { pthread_mutex_lock(&_wsHelper->_subThreadWsMessageQueueMutex); std::list<WsMessage*>::iterator iter = _wsHelper->_subThreadWsMessageQueue->begin(); int bytesWrite = 0; for (; iter != _wsHelper->_subThreadWsMessageQueue->end();) { WsMessage* subThreadMsg = *iter; if ( WS_MSG_TO_SUBTRHEAD_SENDING_STRING == subThreadMsg->what || WS_MSG_TO_SUBTRHEAD_SENDING_BINARY == subThreadMsg->what) { Data* data = (Data*)subThreadMsg->obj; const size_t c_bufferSize = 4096; size_t remaining = data->len - data->issued; size_t n = min(remaining, c_bufferSize); unsigned char* buf = new unsigned char[LWS_SEND_BUFFER_PRE_PADDING + n + LWS_SEND_BUFFER_POST_PADDING]; memcpy((char*)&buf[LWS_SEND_BUFFER_PRE_PADDING], data->bytes + data->issued, n); int writeProtocol; if (data->issued == 0) { if (WS_MSG_TO_SUBTRHEAD_SENDING_STRING == subThreadMsg->what) { writeProtocol = LWS_WRITE_TEXT; } else { writeProtocol = LWS_WRITE_BINARY; } // If we have more than 1 fragment if (data->len > c_bufferSize) writeProtocol |= LWS_WRITE_NO_FIN; } else { // we are in the middle of fragments writeProtocol = LWS_WRITE_CONTINUATION; // and if not in the last fragment if (remaining != n) writeProtocol |= LWS_WRITE_NO_FIN; } bytesWrite = libwebsocket_write(wsi, &buf[LWS_SEND_BUFFER_PRE_PADDING], n, (libwebsocket_write_protocol)writeProtocol); // Buffer overrun? if (bytesWrite < 0) { break; } // Do we have another fragments to send? else if (remaining != n) { data->issued += n; break; } // Safely done! else { CC_SAFE_DELETE_ARRAY(data->bytes); CC_SAFE_DELETE(data); CC_SAFE_DELETE_ARRAY(buf); _wsHelper->_subThreadWsMessageQueue->erase(iter++); CC_SAFE_DELETE(subThreadMsg); } } CC_SAFE_DELETE(subThreadMsg); } _wsHelper->_subThreadWsMessageQueue->clear(); pthread_mutex_unlock(&_wsHelper->_subThreadWsMessageQueueMutex); /* get notified as soon as we can write again */ libwebsocket_callback_on_writable(ctx, wsi); } break; case LWS_CALLBACK_CLOSED: { CCLOG("%s", "connection closing.."); _wsHelper->quitSubThread(); if (_readyState != kStateClosed) { WsMessage* msg = new WsMessage(); _readyState = kStateClosed; msg->what = WS_MSG_TO_UITHREAD_CLOSE; _wsHelper->sendMessageToUIThread(msg); } } break; case LWS_CALLBACK_CLIENT_RECEIVE: { if (in && len > 0) { // Accumulate the data (increasing the buffer as we go) if (_currentDataLen == 0) { _currentData = new char[len]; memcpy (_currentData, in, len); _currentDataLen = len; } else { char *new_data = new char [_currentDataLen + len]; memcpy (new_data, _currentData, _currentDataLen); memcpy (new_data + _currentDataLen, in, len); CC_SAFE_DELETE_ARRAY(_currentData); _currentData = new_data; _currentDataLen = _currentDataLen + len; } _pendingFrameDataLen = libwebsockets_remaining_packet_payload (wsi); if (_pendingFrameDataLen > 0) { //CCLOG("%ld bytes of pending data to receive, consider increasing the libwebsocket rx_buffer_size value.", _pendingFrameDataLen); } // If no more data pending, send it to the client thread if (_pendingFrameDataLen == 0) { WsMessage* msg = new WsMessage(); msg->what = WS_MSG_TO_UITHREAD_MESSAGE; char* bytes = NULL; Data* data = new Data(); if (lws_frame_is_binary(wsi)) { bytes = new char[_currentDataLen]; data->isBinary = true; } else { bytes = new char[_currentDataLen+1]; bytes[_currentDataLen] = '\0'; data->isBinary = false; } memcpy(bytes, _currentData, _currentDataLen); data->bytes = bytes; data->len = _currentDataLen; msg->obj = (void*)data; CC_SAFE_DELETE_ARRAY (_currentData); _currentData = NULL; _currentDataLen = 0; _wsHelper->sendMessageToUIThread(msg); } } } break; default: break; } return 0; }
void EventDispatcher::removeEventListener(EventListener* listener) { if (listener == nullptr) return; bool isFound = false; auto removeListenerInVector = [&](std::vector<EventListener*>* listeners){ if (listeners == nullptr) return; for (auto iter = listeners->begin(); iter != listeners->end(); ++iter) { auto l = *iter; if (l == listener) { CC_SAFE_RETAIN(l); l->setRegistered(false); if (l->getAssociatedNode() != nullptr) { dissociateNodeAndEventListener(l->getAssociatedNode(), l); l->setAssociatedNode(nullptr); // nullptr out the node pointer so we don't have any dangling pointers to destroyed nodes. } if (_inDispatch == 0) { listeners->erase(iter); CC_SAFE_RELEASE(l); } isFound = true; break; } } }; for (auto iter = _listenerMap.begin(); iter != _listenerMap.end();) { auto listeners = iter->second; auto fixedPriorityListeners = listeners->getFixedPriorityListeners(); auto sceneGraphPriorityListeners = listeners->getSceneGraphPriorityListeners(); removeListenerInVector(sceneGraphPriorityListeners); if (isFound) { // fixed #4160: Dirty flag need to be updated after listeners were removed. setDirty(listener->getListenerID(), DirtyFlag::SCENE_GRAPH_PRIORITY); } else { removeListenerInVector(fixedPriorityListeners); if (isFound) { setDirty(listener->getListenerID(), DirtyFlag::FIXED_PRIORITY); } } #if CC_NODE_DEBUG_VERIFY_EVENT_LISTENERS CCASSERT(_inDispatch != 0 || !sceneGraphPriorityListeners || std::count(sceneGraphPriorityListeners->begin(), sceneGraphPriorityListeners->end(), listener) == 0, "Listener should be in no lists after this is done if we're not currently in dispatch mode."); CCASSERT(_inDispatch != 0 || !fixedPriorityListeners || std::count(fixedPriorityListeners->begin(), fixedPriorityListeners->end(), listener) == 0, "Listener should be in no lists after this is done if we're not currently in dispatch mode."); #endif if (iter->second->empty()) { _priorityDirtyFlagMap.erase(listener->getListenerID()); auto list = iter->second; iter = _listenerMap.erase(iter); CC_SAFE_DELETE(list); } else { ++iter; } if (isFound) break; } if (isFound) { CC_SAFE_RELEASE(listener); } else { for(auto iter = _toAddedListeners.begin(); iter != _toAddedListeners.end(); ++iter) { if (*iter == listener) { listener->setRegistered(false); listener->release(); _toAddedListeners.erase(iter); break; } } } }
Scene::~Scene() { #if CC_USE_PHYSICS CC_SAFE_DELETE(_physicsWorld); #endif }
void ComAudioReader::destroyInstance() { CC_SAFE_DELETE(_instanceComAudioReader); }
JewelControl::~JewelControl ( KDvoid ) { CC_SAFE_DELETE ( m_pJewelController ); }