CTitleWidget::~CTitleWidget() { DELETE_POINTER(m_titleLabel); DELETE_POINTER(m_iconLabel); DELETE_POINTER(m_minimumBtn); DELETE_POINTER(m_closeBtn); qDebug() << "~CTitleWidget()"; }
CSystemTrayIcon::~CSystemTrayIcon() { qDebug() << "~CSystemTrayIcon()"; DELETE_POINTER(m_hideShowAct); DELETE_POINTER(m_aboutAct); DELETE_POINTER(m_exitAct); DELETE_POINTER(m_TrayIconMenu); }
cSatipDevice::~cSatipDevice() { debug("cSatipDevice::%s(%u)", __FUNCTION__, deviceIndexM); // Stop section handler StopSectionHandler(); DELETE_POINTER(pSectionFilterHandlerM); DELETE_POINTER(pTunerM); DELETE_POINTER(tsBufferM); }
CSMonitorClient::~CSMonitorClient() { qDebug() << "~CSMonitorClient()"; DELETE_POINTER(m_trayIcon); DELETE_POINTER(m_titleWidget); DELETE_POINTER(m_stackedWidget); DELETE_POINTER(m_sideBarWidget); //DELETE_POINTER(m_mainFrame); }
cSatipDevice::~cSatipDevice() { debug1("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM); // Stop section handler StopSectionHandler(); DELETE_POINTER(pSectionFilterHandlerM); DELETE_POINTER(pTunerM); DELETE_POINTER(tsBufferM); }
void CharacterUpdaterPlayer::goToUsingPath(const CCVector3 &target) { const CCPathFinderNetwork::PathNode *targetNode = pathFinderNetwork->findClosestNode( player, &target, false ); if( targetNode == NULL ) { DELETE_POINTER( path ); goTo( target ); return; } if( path == NULL ) { findNewAnchor = true; path = new CCPathFinderNetwork::Path(); } getClosestNode(); pathAnchorNode = anchorNode; if( pathAnchorNode != NULL ) { pathFinderNetwork->findPath( *path, pathAnchorNode, targetNode ); } if( path->endDirection == 0 ) { // See if we can head straight to our target CCObjectCollideable *hitObject = CCMovementOctreeCollisionCheck( player, *player->positionPtr, target ); if( hitObject == NULL ) { DELETE_POINTER( path ); } } // Check if we can head straight to our first path else { const int pathDirection = path->directions[0]; if( pathAnchorNode != NULL && pathDirection < pathAnchorNode->numberOfConnections ) { const CCPathFinderNetwork::PathNode::PathConnection *usingConnection = &pathAnchorNode->connections[pathDirection]; const CCVector3 *pathTarget = &usingConnection->node->point; CCObjectCollideable *hitObject = CCMovementOctreeCollisionCheck( player, *player->positionPtr, *pathTarget ); currentPath = hitObject == NULL ? 0 : -1; } else { currentPath = 0; } } goTo( target ); }
TileSocialProfile::TileSocialProfile(CCSceneBase *scene, const float size, const char *userSeed) : TileSocial( scene, size, size ) { drawOrder = 200; fbInfoDownloadedCallback = NULL; photosDownloadedCallback = NULL; rotationSpeed = 180.0f; taggedPhotosRefreshing = false; // Set a default profile photo CCModelBase *f7u12Model = new CCModelBase(); model->addModel( f7u12Model ); f7u12Photo = new CCPrimitiveSquare(); f7u12Photo->setupZFacing( collisionBounds.x - borderWidth, collisionBounds.y - borderWidth ); f7u12Photo->setTexture( GetDefaultProfilePhoto(), Resource_Packaged ); f7u12Model->addPrimitive( f7u12Photo ); f7u12Model->setColour( CCColour( 1.0f ) ); f7u12ColourInterpolator.setup( f7u12Model->getColour(), *f7u12Model->getColour() ); f7u12ColourInterpolator.setDuration( 0.25f ); // Provisionally set the userID to be the userSeed value // Which will be confirmed by the FBApi setUserID( userSeed ); scaleInterpolator.clear(); DELETE_POINTER( scale ); }
void MONGE_AMPERE_SOLVER::InitializeLinearSolver(const POISSON_SOLVER_TYPE linear_solver_type) { DELETE_POINTER(sub_linear_solver); switch (linear_solver_type) { case GS: sub_linear_solver = new GAUSS_SEIDEL_METHOD(); break; case SOR: sub_linear_solver = new SOR_METHOD(); break; case BICG: sub_linear_solver = new BICGSTAB_METHOD(); break; case NO_SOLVER: default: sub_linear_solver = 0; break; } sub_linear_solver->Initialize(tolerance, max_iteration_for_sub_linear_solver, multithreading); }
void CharacterUpdaterPlayer::goToScan(const CCVector3 &target) { CCObjectCollideable *hitObject = CCMovementOctreeCollisionCheck( player, *player->positionPtr, target ); if( hitObject != NULL ) { if( CCText::Equals( hitObject->getType(), "health" ) ) { PickupBase *pickup = (PickupBase*)( hitObject ); if( pickup != NULL ) { hitObject = NULL; } } } if( hitObject == NULL ) { DELETE_POINTER( path ); goTo( target ); } else { goToUsingPath( target ); } }
// CCPrimitiveBase void CCPrimitiveSquare::adjustTextureUVs() { // We scale the textures to be square on Android #ifndef ANDROID const int textureHandleIndex = textureInfo->primaryIndex; CCTextureHandle *textureHandle = gEngine->textureManager->getTextureHandle( textureHandleIndex ); const CCTextureBase *texture = textureHandle->texture; //ASSERT( texture != NULL ); if( texture != NULL ) { const float width = texture->getImageWidth(); const float height = texture->getImageHeight(); const float allocatedWidth = texture->getAllocatedWidth(); const float allocatedHeight = texture->getAllocatedHeight(); if( width == allocatedWidth && height == allocatedHeight ) { if( customUVs != NULL ) { DELETE_POINTER( customUVs ); } } else { CCPrimitiveSquareUVs::Setup( &customUVs, 0.0f, 0.0f, width / allocatedWidth, height / allocatedHeight ); } } #endif }
/*F+F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F Function: DllGetClassObject Summary: The standard exported function that the COM service library uses to obtain an object class of the class factory for a specified component provided by this server DLL. Args: REFCLSID rclsid, [in] The CLSID of the requested Component. REFIID riid, [in] The requested interface on the Class Factory. PPVOID ppv) [in/out] The output interface pointer to the Class Factory. Returns: HRESULT E_FAIL if requested component isn't supported. E_OUTOFMEMORY if out of memory. Error code out of the QueryInterface. F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F-F*/ STDAPI DllGetClassObject( REFCLSID rclsid, REFIID riid, PPVOID ppv) { HRESULT hr = CLASS_E_CLASSNOTAVAILABLE; IUnknown* pCob = NULL; if (CLSID_Ball == rclsid) { hr = E_OUTOFMEMORY; pCob = new CFBall(NULL, g_pServer); } if (NULL != pCob) { g_pServer->ObjectsUp(); hr = pCob->QueryInterface(riid, ppv); if (FAILED(hr)) { g_pServer->ObjectsDown(); DELETE_POINTER(pCob); } } return hr; }
void CCText::SetLastWord(const char *inBuffer, CCText &outText) { CCText nameData = inBuffer; CCList<char> *nameDataSplit = nameData.split( " " ); ASSERT( nameDataSplit->length > 0 ); outText = nameDataSplit->list[nameDataSplit->length-1]; DELETE_POINTER( nameDataSplit ); }
// CCSceneObject void CCTile3DButton::update(const CCTime &gameTime) { super::update( gameTime ); if( scale != NULL ) { const float speed = gameTime.delta * 1.0f; if( scaleInterpolator.update( speed ) ) { dirtyModelMatrix(); } else { DELETE_POINTER( scale ); } } // Touch depress: On update if( touchDepressRange > 0.0f ) { if( touchDepressInterpolator.update( gameTime.delta ) ) { dirtyModelMatrix(); } } if( touchRotationAllowed ) { const float speed = touching || touchReleased ? 3.0f : touchRotationSpeed; if( touchRotationInterpolator.update( gameTime.delta * speed ) ) { const float magnitudeSquared = rotation.x * rotation.x + rotation.y * rotation.y; touchRotationMagnitude = sqrtf( magnitudeSquared ); touchRotationMagnitude = MIN( touchRotationMagnitude, 1.0f ); dirtyModelMatrix(); } } if( touching ) { touchingTime += gameTime.real; } else if( touchReleased ) { if( touchDepressInterpolator.finished() && touchRotationInterpolator.finished() ) { handleTouchRelease(); } } colourInterpolator.update( gameTime.delta ); if( textModel != NULL ) { textModel->colourInterpolator.update( gameTime.delta ); } }
void CCText::stripDirectory() { CCList<char> *directorySplit = split( "/" ); if( directorySplit->length > 1 ) { set( directorySplit->list[directorySplit->length-1] ); } DELETE_POINTER( directorySplit ); }
void CharacterUpdaterPlayer::destruct() { if( shootingState != state_stopped ) { stopShooting(); } DELETE_POINTER( path ); super::destruct(); }
// --------------------------------------------------------------------------------- // Destructor // --------------------------------------------------------------------------------- ~Deck() { // Deallocate memory for (int i = 0; i < deckSize_; ++i) { DELETE_POINTER(ppCards_[i]); } DELETE_POINTER_ARRAY(pPresentInDeck_); DELETE_POINTER_ARRAY(ppCards_); }
const bool CCTextureFontPageFile::load(const char *name, const CCResourceType resourceType, const bool generateMipMap) { CCText textureFilename( name ); textureFilename += ".png"; texturePageIndex = gEngine->textureManager->assignTextureIndex( textureFilename.buffer, resourceType, true, generateMipMap ); CCText filename( name ); filename += ".data"; // Load the descriptor file char *fileData = NULL; CCFileManager::getPackagedFile( filename.buffer, &fileData ); CCText textData( fileData ); FREE_POINTER( fileData ); CCList<char> *lettersSplit = textData.split( "\n" ); CCText rawLetterData; for( int i=0; i<lettersSplit->length; ++i ) { const char *raw = lettersSplit->list[i]; rawLetterData.set( raw ); CCList<char> *letterDataSplit = rawLetterData.split( "," ); ASSERT( letterDataSplit->length == 4 ); Letters &letter = letters[i]; letter.start.x = (float)atof( letterDataSplit->list[0] ); letter.start.y = (float)atof( letterDataSplit->list[1] ); letter.end.x = (float)atof( letterDataSplit->list[2] ); letter.end.y = (float)atof( letterDataSplit->list[3] ); // 16.0f because there's 16 tiles per font page letter.size.width = ( letter.end.x - letter.start.x ) * 16.0f; letter.size.height = ( letter.end.y - letter.start.y ) * 16.0f; DELETE_POINTER( letterDataSplit ); } DELETE_POINTER( lettersSplit ); return true; }
/*F+F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F Function: DllMain Summary: Like WinMain is for an EXE application, this DllMain function is the main entry point for this DLL. It is called when the DLL is loaded by a process, and when new threads are created by a process that has already loaded this DLL. DllMain is also called when threads of a process that has loaded the DLL exit cleanly and when the process itself unloads the DLL. If you want to use C runtime libraries, keep this function named "DllMain" and you won't have to do anything special to initialize the runtime libraries. When fdwReason == DLL_PROCESS_ATTACH, the return value is used to determine if the DLL should remain loaded, or should be immediately unloaded depending upon whether the DLL could be initialized properly. For all other values of fdwReason, the return value is ignored. Args: HINSTANCE hDLLInst, Instance handle of the DLL. DWORD fdwReason, Process attach/detach or thread attach/detach. Reason for calling. LPVOID lpvReserved) Reserved and not used. Returns: BOOL, Return value is used only when fdwReason == DLL_PROCESS_ATTACH. TRUE - Used to signify that the DLL should remain loaded. FALSE - Used to signify that the DLL should be immediately unloaded. F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F-F*/ BOOL WINAPI DllMain( HINSTANCE hDllInst, DWORD fdwReason, LPVOID ) { BOOL bResult = TRUE; // Dispatch this main call based on the reason it was called. switch (fdwReason) { case DLL_PROCESS_ATTACH: // The DLL is being loaded for the first time by a given process. // Perform per-process initialization here. If the initialization // is successful, return TRUE; if unsuccessful, return FALSE. bResult = FALSE; if (UnicodeOk()) { // Instantiate the CServer utility class. g_pServer = new CServer; if (NULL != g_pServer) { // Remember the DLL Instance handle. g_pServer->m_hDllInst = hDllInst; bResult = TRUE; } } break; case DLL_PROCESS_DETACH: // The DLL is being unloaded by a given process. Do any // per-process clean up here, such as undoing what was done in // DLL_PROCESS_ATTACH. The return value is ignored. DELETE_POINTER(g_pServer); break; case DLL_THREAD_ATTACH: // A thread is being created in a process that has already loaded // this DLL. Perform any per-thread initialization here. The // return value is ignored. break; case DLL_THREAD_DETACH: // A thread is exiting cleanly in a process that has already // loaded this DLL. Perform any per-thread clean up here. The // return value is ignored. break; default: break; } return (bResult); }
void CCText::strip(const char *token) { CCList<char> *tokenSplit = split( token ); if( tokenSplit->length > 1 ) { set( tokenSplit->list[0] ); for( int i=1; i<tokenSplit->length; ++i ) { *this += tokenSplit->list[i]; } } DELETE_POINTER( tokenSplit ); }
void CCText::splitAfter(CCText source, const char *after) { CCList<char> *list1 = source.split( after, true ); if( list1->length > 1 ) { set( list1->list[1] ); for( int i=2; i<list1->length; ++i ) { *this += after; *this += list1->list[i]; } } DELETE_POINTER( list1 ); }
void CCText::removeBetweenIncluding(const char *from, const char *to) { CCText start( buffer ); CCList<char> *list1 = split( from ); if( list1->length > 1 ) { CCText end( list1->list[1] ); start.set( list1->list[0] ); end.splitAfter( end, to ); set( start.buffer ); *this += end.buffer; } DELETE_POINTER( list1 ); }
void CCText::replaceChars(const char *token, const char *replace) { CCList<char> *tokenSplit = split( token ); CCText newText; for( int i=0; i<tokenSplit->length; ++i ) { const char *rawData = tokenSplit->list[i]; newText += rawData; if( i < tokenSplit->length-1 ) { newText += replace; } } DELETE_POINTER( tokenSplit ); set( newText.buffer ); }
// CCSceneObject void CCTile3DButton::update(const CCTime &gameTime) { super::update( gameTime ); if( scale != NULL ) { const float speed = gameTime.delta * 1.0f; if( scaleInterpolator.update( speed ) ) { dirtyModelMatrix(); } else { DELETE_POINTER( scale ); } } colourInterpolator.update( gameTime.delta ); if( textModel != NULL ) { textModel->colourInterpolator.update( gameTime.delta ); } }
int main(int argc, const char * argv[]) { Deck *pDeck = new Deck(NUMBER_OF_DECKS, Deck::JPT_NO_JOKERS); // Remove jokers Deck &deck = *pDeck; deck.showCards(); printf("\n\nShuffling...\n\n"); deck.shuffle(); deck.showCards(); printf("\n\nDealing...\n\n"); // Play war by dealing the deck evenly to 2 hands // For now the hands are just pointers to lists of cards // Later we may actually encapsulate as a Hand as a means // to reference the cards from the deck... i.e., we never // really want to move the card data, just its reference. Card *pHandA = deck.deal(); Card *pHandB = deck.deal(); // Deal the rest of the cards until the deck is empty // May want to create a dealer that can handle multiple hands // and input to decide how much to deal. for(;;) { Card *pNext = deck.deal(); if (pNext != NULL) { pHandA->add(pNext); } else { break; } pNext = deck.deal(); if(pNext != NULL) { pHandB->add(pNext); } else { break; } } printf("\n\nHand A\n"); pHandA->showCards(); printf("\n\nHand B\n"); pHandB->showCards(); // Pull the first two cards // To prevent needing to traverse the list each time // we will retain some information in each pass Card *pTopA = pHandA->getFirst(); Card *pTopB = pHandB->getFirst(); Card *pNextA = pTopA->getNext(); Card *pNextB = pTopB->getNext(); Card *pLastA = pTopA->getLast(); Card *pLastB = pTopB->getLast(); Card *pDiscardA = pTopA->remove(); Card *pDiscardB = pTopB->remove(); Card *pNextDiscardToReturn[2]; pTopA = pNextA; pNextA = pNextA->getNext(); pTopB = pNextB; pNextB = pNextB->getNext(); unsigned int cycleCount = 0; while (((pTopA != NULL) && (pTopB != NULL)) || ((pDiscardA != NULL) && (pDiscardB != NULL))) { ++cycleCount; unsigned int countA = pTopA==NULL?0:pTopA->count(); unsigned int countB = pTopB==NULL?0:pTopB->count(); unsigned int discardCountA = pDiscardA==NULL?0:pDiscardA->count(); unsigned int discardCountB = pDiscardB==NULL?0:pDiscardB->count(); // Play war if (pDiscardA->getRank() > pDiscardB->getRank()) { printf("%4d %4d %2d %2d = %4d ------A WINS------- Cycle %6d\n", countA, countB, discardCountA, discardCountB, countA + countB + discardCountA + discardCountB, cycleCount); // Put both cards in Hand A and update the discard piles // Randomly select which to do first to prevent the cards // from sorting themselves into a war-free configuration unsigned int aOrB = rand() % 2; pNextDiscardToReturn[aOrB & 0x1] = pDiscardA; pNextDiscardToReturn[~aOrB & 0x1] = pDiscardB; for (unsigned int i = 0; i < DIM(pNextDiscardToReturn); ++i) { while (pNextDiscardToReturn[i] != NULL) { if (pLastA != NULL) { pNextDiscardToReturn[i] = pLastA->add(pNextDiscardToReturn[i]); pLastA = pLastA->getNext(); } else { Card *pNextReturn = pNextDiscardToReturn[i]->getNext(); pLastA = pNextDiscardToReturn[i]->remove(); pTopA = pLastA; pNextDiscardToReturn[i] = pNextReturn; } } } pNextA = pTopA->getNext(); pDiscardA = NULL; pDiscardB = NULL; } else if (pDiscardA->getRank() < pDiscardB->getRank()) { printf("%4d %4d %2d %2d = %4d ------B WINS------- Cycle %6d\n", countA, countB, discardCountA, discardCountB, countA + countB + discardCountA + discardCountB, cycleCount); // Put both cards in Hand B and update the discard piles // Randomly select which to do first to prevent the cards // from sorting themselves into a war-free configuration unsigned int aOrB = rand() % 2; pNextDiscardToReturn[aOrB & 0x1] = pDiscardB; pNextDiscardToReturn[~aOrB & 0x1] = pDiscardA; for (unsigned int i = 0; i < DIM(pNextDiscardToReturn); ++i) { while (pNextDiscardToReturn[i] != NULL) { if (pLastB != NULL) { pNextDiscardToReturn[i] = pLastB->add(pNextDiscardToReturn[i]); pLastB = pLastB->getNext(); } else { Card *pNextReturn = pNextDiscardToReturn[i]->getNext(); pLastB = pNextDiscardToReturn[i]->remove(); pTopB = pLastB; pNextDiscardToReturn[i] = pNextReturn; } } } pNextB = pTopB->getNext(); pDiscardA = NULL; pDiscardB = NULL; } else { printf("%4d %4d %2d %2d = %4d --------WAR-------- Cycle %6d\n", countA, countB, discardCountA, discardCountB, countA + countB + discardCountA + discardCountB, cycleCount); // Put a new card on top of each discard pile if ((pTopA != NULL) && (pDiscardA != NULL)) { pDiscardA = pDiscardA->insertBefore(pTopA->remove()); } if ((pTopB != NULL) && (pDiscardA != NULL)) { pDiscardB = pDiscardB->insertBefore(pTopB->remove()); } pTopA = pNextA; if (pNextA != NULL) { pNextA = pNextA->getNext(); } else { pLastA = NULL; } pTopB = pNextB; if (pNextB != NULL) { pNextB = pNextB->getNext(); } else { pLastB = NULL; } } // Pull two more cards if we know we // can play another round if ((pTopA != NULL) && (pTopB != NULL)) { if (pDiscardA == NULL) { if (pTopA != NULL) { pDiscardA = pTopA->remove(); } } else { if (pTopA != NULL) { pDiscardA = pDiscardA->insertBefore(pTopA->remove()); } } if (pDiscardB == NULL) { if (pTopB != NULL) { pDiscardB = pTopB->remove(); } } else { if (pTopB != NULL) { pDiscardB = pDiscardB->insertBefore(pTopB->remove()); } } pTopA = pNextA; if (pNextA != NULL) { pNextA = pNextA->getNext(); } else { pLastA = NULL; } pTopB = pNextB; if (pNextB != NULL) { pNextB = pNextB->getNext(); } else { pLastB = NULL; } } } if (pTopA != NULL) { printf("A CARDS--------\n"); pTopA->showCards(); } if (pTopB != NULL) { printf("B CARDS--------\n"); pTopB->showCards(); } if (pDiscardA != NULL) { printf("CARDS on Table from A\n"); pDiscardA->showCards(); } if (pDiscardB != NULL) { printf("CARDS on Table from B\n"); pDiscardB->showCards(); } printf("%s Wins in %d draws!\n", (pTopA == NULL)?"B":"A", cycleCount); // printf("Gathering Deck...\n"); // deck.gather(); // deck.showCards(); DELETE_POINTER(pDeck); return 0; }
void CCText::splitBefore(CCText source, const char *before) { CCList<char> *list1 = source.split( before, true ); set( list1->list[0] ); DELETE_POINTER( list1 ); }
void CharacterUpdaterPlayer::movePlayer(const float delta) { if( moving ) { if( path != NULL ) { if( currentPath == -1 ) { const CCVector3 *target = &pathAnchorNode->point; movePlayerRotation( *target, delta ); const float distance = CCVector3DistanceCheck2D( *player->positionPtr, *target, false ); if( distance < 1.0f ) { currentPath = 0; } } else { bool validPath = false; if( currentPath < path->endDirection ) { const int pathDirection = path->directions[currentPath]; if( pathDirection < pathAnchorNode->numberOfConnections ) { const CCPathFinderNetwork::PathNode::PathConnection *usingConnection = &pathAnchorNode->connections[pathDirection]; const CCVector3 *target = &usingConnection->node->point; if( target != NULL ) { validPath = true; movePlayerRotation( *target, delta ); const float distance = CCVector3DistanceCheck2D( *player->positionPtr, *target, false ); if( distance < 20.0f ) { bool goToNext = distance < 0.1f + player->collisionBounds.y; if( goToNext == false ) { const CCVector3 *testTarget = &positionTarget; if( currentPath+1 < path->endDirection ) { const CCPathFinderNetwork::PathNode::PathConnection *nextConnection = &usingConnection->node->connections[path->directions[currentPath+1]]; testTarget = &nextConnection->node->point; if( testTarget == NULL ) { testTarget = &positionTarget; } } CCObjectCollideable *hitObject = CCMovementOctreeCollisionCheck( player, *player->positionPtr, *testTarget ); goToNext = hitObject == NULL; } if( goToNext ) { pathAnchorNode = usingConnection->node; anchorNode = pathAnchorNode; currentPath++; if( currentPath >= path->endDirection ) { DELETE_POINTER( path ); } } } } } } if( validPath == false ) { // Try again? goTo( positionTarget ); } } } else { const float distance = CCVector3DistanceCheck2D( player->getPosition(), positionTarget, false ); if( distance > 5.0f ) { movePlayerRotation( positionTarget, delta ); } else { landPlayerOnTarget( distance, delta ); } } player->dirtyModelMatrix(); } }