void CourseContentsList::SetFromGameState() { RemoveAllChildren(); if( GAMESTATE->GetMasterPlayerNumber() == PlayerNumber_Invalid ) return; const Trail *pMasterTrail = GAMESTATE->m_pCurTrail[GAMESTATE->GetMasterPlayerNumber()]; if( pMasterTrail == NULL ) return; unsigned uNumEntriesToShow = pMasterTrail->m_vEntries.size(); CLAMP( uNumEntriesToShow, 0, m_vpDisplay.size() ); for( int i=0; i<(int)uNumEntriesToShow; i++ ) { Actor *pDisplay = m_vpDisplay[i]; SetItemFromGameState( pDisplay, i ); this->AddChild( pDisplay ); } bool bLoop = pMasterTrail->m_vEntries.size() > uNumEntriesToShow; this->SetLoop( bLoop ); this->Load2(); this->SetTransformFromHeight( m_vpDisplay[0]->GetUnzoomedHeight() ); this->EnableMask( m_vpDisplay[0]->GetUnzoomedWidth(), m_vpDisplay[0]->GetUnzoomedHeight() ); if( bLoop ) { SetPauseCountdownSeconds( 1.5f ); this->SetDestinationItem( m_vpDisplay.size()+1 ); // loop forever } }
// ----------------------------------------------------------------------- // // // ROUTINE: CLTWnd::Term // // PURPOSE: Termination // // ----------------------------------------------------------------------- // void CLTWnd::Term() { // Sanity Check if(!m_bInitialized) return; // All children should die... uh... I mean all of our child windows should be removed. RemoveAllChildren(); // Delete the surface if necessary if(m_bDeleteSurfOnTerm) { FreeAllSurfaces(); } // If we've got the capture, release it if(s_pWndCapture == this) s_pWndCapture = NULL; if(s_pWndActive == this) s_pWndActive = NULL; if(s_pMainWnd == this) s_pMainWnd = NULL; m_nWidth = m_nSurfWidth = m_nHeight = m_nSurfHeight = 0; m_bInitialized = FALSE; }
LandscapeRegion::~LandscapeRegion() { RemoveAllChildren(); m_pLandscape->SetBody( NULL ); m_pLandscape->SetEffectInstance( NULL ); m_pLandscape->SetMesh( NULL ); WorldFn->SelectMemory( TEXT("Outdoor") ); Delete( m_pLandscape ); m_pLandscape = NULL; WorldFn->UnSelectMemory(); PhysicsFn->DestroyBody( m_pLandscapeBody ); m_pLandscapeBody = NULL; PhysicsFn->DestroyShape( m_pLandscapeShape ); m_pLandscapeShape = NULL; WorldFn->SelectMemory( TEXT("Outdoor") ); Delete( m_pLandscapeMesh ); m_pLandscapeMesh = NULL; WorldFn->UnSelectMemory(); GraphicsFn->DestroyEffectInstance( m_pLandscapeEffectInstance ); m_pLandscapeEffectInstance = NULL; }
void DomNode::SetText(const char* txt) { if (Children.size() != 1 || Children[0]->GetTag() != TagText) { RemoveAllChildren(); AddChild(TagText); } Children[0]->SetText(txt); }
void MultiFuncSelectorWidget::UpdateButtons() { RemoveAllChildren(); for (int i = 0; i < MFUNC_MAX; ++i) { Add(m_buttons[i], 36.0f + 36.0f * float(i), 0.0); } }
void COXLayoutManager::Detach() { ASSERT(m_pContainerWnd); RemoveAllChildren(); m_pContainerWnd = NULL; UnsubclassContainer(); }
void MoveableObject::RemoveAllChildrenRecursive() { for( auto& child : m_Children ) { child->RemoveAllChildrenRecursive(); } RemoveAllChildren(); }
//------------------------------------------------------------------ //------------------------------------------------------------------ void Entity::Reset() { RemoveAllComponents(); RemoveAllChildren(); RemoveFromParent(); m_name = std::string(); m_transform.Reset(); }
void COXLayoutManager::Attach(CWnd* pContainerWnd) { ASSERT(m_pContainerWnd == NULL); ASSERT(pContainerWnd); RemoveAllChildren(); m_pContainerWnd = pContainerWnd; VERIFY(SubclassContainer(pContainerWnd)); }
Node::~Node() { RemoveAllChildren(); RemoveAllComponents(); // Remove from the scene if (scene_) scene_->NodeRemoved(this); }
std::shared_ptr<touchmind::model::node::NodeModel> touchmind::model::node::NodeModel::DeepCopy() { auto src(shared_from_this()); auto dest = NodeModel::Create(*src.get()); dest->RemoveAllChildren(); _DeepCopy(src, dest); return dest; }
void Collider::BreakChain() { for(auto child : children) { child->ApplySpace(glm::one<glm::mat4>()); } RemoveAllChildren(); this->ApplySpace(glm::one<glm::mat4>()); parent->removeChild(this); }
void _DeepCopy(std::shared_ptr<touchmind::model::node::NodeModel> srcParent, std::shared_ptr<touchmind::model::node::NodeModel> destParent) { for (size_t i = 0; i < srcParent->GetActualChildrenCount(); ++i) { auto srcChild = srcParent->GetChild(i); auto destChild = touchmind::model::node::NodeModel::Create(*srcChild.get()); destChild->RemoveAllChildren(); destParent->AddChild(destChild); _DeepCopy(srcChild, destChild); } }
UiWidget::~UiWidget() { for(unsigned int i = 0; i < m_Animations.size(); ++i) { delete m_Animations[i]; } ScriptManager::getSingleton().RemoveEntity(ScriptManager::UI, m_PathName); RemoveAllChildren(); }
/* ===================== GameNode::~GameNode ===================== */ GameNode::~GameNode() { if (!willDelete) { PrepareDeletion(); } RemoveAllChildren(); UnlistenFrame(); UnlistenInput(); UnlistenController(); }
void EditorLightNode::Update(float32 timeElapsed) { Light * parent = (Light*)GetParent(); if(type != parent->GetType()) { RemoveAllChildren(); type = parent->GetType(); SceneNode * lightDrawNode = scene->GetRootNode(GetSceneFile())->Clone(); AddNode(lightDrawNode); SafeRelease(lightDrawNode); } }
/* ===================== GameNode::PrepareDeletion ===================== */ void GameNode::PrepareDeletion() { if (GetParentLayer()) { GetParentLayer()->RemoveLight(this); GetParentLayer()->RemoveShadowCaster(this); } if (shadowShape) { delete shadowShape; } RemoveAllChildren(); UnlistenInput(); UnlistenController(); parent = NULL; willDelete = true; }
bool Node::LoadXML(const XMLElement& source, SceneResolver& resolver, bool readChildren, bool rewriteIDs, CreateMode mode) { // Remove all children and components first in case this is not a fresh load RemoveAllChildren(); RemoveAllComponents(); if (!Serializable::LoadXML(source)) return false; XMLElement compElem = source.GetChild("component"); while (compElem) { String typeName = compElem.GetAttribute("type"); unsigned compID = compElem.GetInt("id"); Component* newComponent = CreateComponent(ShortStringHash(typeName), (mode == REPLICATED && compID < FIRST_LOCAL_ID) ? REPLICATED : LOCAL, rewriteIDs ? 0 : compID); if (newComponent) { resolver.AddComponent(compID, newComponent); if (!newComponent->LoadXML(compElem)) return false; } compElem = compElem.GetNext("component"); } if (!readChildren) return true; XMLElement childElem = source.GetChild("node"); while (childElem) { unsigned nodeID = childElem.GetInt("id"); Node* newNode = CreateChild(rewriteIDs ? 0 : nodeID, (mode == REPLICATED && nodeID < FIRST_LOCAL_ID) ? REPLICATED : LOCAL); resolver.AddNode(nodeID, newNode); if (!newNode->LoadXML(childElem, resolver, readChildren, rewriteIDs, mode)) return false; childElem = childElem.GetNext("node"); } return true; }
bool Node::Load(Deserializer& source, SceneResolver& resolver, bool readChildren, bool rewriteIDs, CreateMode mode) { // Remove all children and components first in case this is not a fresh load RemoveAllChildren(); RemoveAllComponents(); // ID has been read at the parent level if (!Serializable::Load(source)) return false; unsigned numComponents = source.ReadVLE(); for (unsigned i = 0; i < numComponents; ++i) { VectorBuffer compBuffer(source, source.ReadVLE()); ShortStringHash compType = compBuffer.ReadShortStringHash(); unsigned compID = compBuffer.ReadUInt(); Component* newComponent = CreateComponent(compType, (mode == REPLICATED && compID < FIRST_LOCAL_ID) ? REPLICATED : LOCAL, rewriteIDs ? 0 : compID); if (newComponent) { resolver.AddComponent(compID, newComponent); if (!newComponent->Load(compBuffer)) return false; } } if (!readChildren) return true; unsigned numChildren = source.ReadVLE(); for (unsigned i = 0; i < numChildren; ++i) { unsigned nodeID = source.ReadUInt(); Node* newNode = CreateChild(rewriteIDs ? 0 : nodeID, (mode == REPLICATED && nodeID < FIRST_LOCAL_ID) ? REPLICATED : LOCAL); resolver.AddNode(nodeID, newNode); if (!newNode->Load(source, resolver, readChildren, rewriteIDs, mode)) return false; } return true; }
// Moves all children to be under control of the widget. void ElementFormControlSelect::OnUpdate() { ElementFormControl::OnUpdate(); // Move any child elements into the widget (except for the three functional elements). for(int child_index = 0;child_index<GetNumChildren();++child_index) { Core::Element* child = GetChild(child_index); // Check for a value attribute. Rocket::Core::String attribute_value = child->GetAttribute<Rocket::Core::String>("value", ""); // Pull the inner RML and add the option. Rocket::Core::String rml; child->GetInnerRML(rml); widget->AddOption(rml, attribute_value, -1, child->GetAttribute("selected") != NULL, child->GetAttribute("unselectable") == NULL); } RemoveAllChildren(); }
Scene::~Scene() { for (Vector<AnimatedMesh*>::iterator t = animatedMeshes.begin(); t != animatedMeshes.end(); ++t) { AnimatedMesh * obj = *t; obj->Release(); } animatedMeshes.clear(); for (Vector<Camera*>::iterator t = cameras.begin(); t != cameras.end(); ++t) { Camera * obj = *t; obj->Release(); } cameras.clear(); SafeRelease(currentCamera); SafeRelease(clipCamera); for (Map<String, ProxyNode*>::iterator it = rootNodes.begin(); it != rootNodes.end(); ++it) { SafeRelease(it->second); } rootNodes.clear(); // Children should be removed first because they should unregister themselves in managers RemoveAllChildren(); SafeRelease(imposterManager); transformSystem = 0; renderUpdateSystem = 0; lodSystem = 0; uint32 size = (uint32)systems.size(); for (uint32 k = 0; k < size; ++k) SafeDelete(systems[k]); systems.clear(); SafeDelete(eventSystem); SafeDelete(renderSystem); }
void ReferenceNode::Update(float32 timeElapsed) { if(nodeToAdd) { AddNode(nodeToAdd); SafeRelease(nodeToAdd); } if(scene->IsReferenceNodeSuffixChanged()) { RemoveAllChildren(); String newFileName = FileSystem::Instance()->ReplaceExtension(customProperties->GetString("reference.path"), Format("_%s.sc2", scene->GetReferenceNodeSuffix().c_str())); SceneNode * node = scene->GetRootNode(newFileName); if(node) { nodeToAdd = node->Clone(); } else { SceneNode * node = scene->GetRootNode(customProperties->GetString("reference.path")); nodeToAdd = node->Clone(); } } }
COXLayoutManager::~COXLayoutManager() { RemoveAllChildren(); UnsubclassContainer(); }
ValueNodeContainer::~ValueNodeContainer() { RemoveAllChildren(); }
void ActorFrame::TransferChildren( ActorFrame *pTo ) { FOREACH( Actor*, m_SubActors, i ) pTo->AddChild( *i ); RemoveAllChildren(); }
//------------------------------------------------------------- //------------------------------------------------------------- Entity::~Entity() { RemoveAllComponents(); RemoveAllChildren(); }
String DomNode::Parse(const char* src) { RemoveAllChildren(); return ParseAppend(src); }
Actor::~Actor() { mGame.GetTime().ClearAllTimers(this); RemoveAllChildren(); RemoveAllComponents(); }
Scene::~Scene() { SceneCache::Instance()->RemoveScene(this); for (Vector<AnimatedMesh*>::iterator t = animatedMeshes.begin(); t != animatedMeshes.end(); ++t) { AnimatedMesh * obj = *t; obj->Release(); } animatedMeshes.clear(); for (Vector<Camera*>::iterator t = cameras.begin(); t != cameras.end(); ++t) { Camera * obj = *t; obj->Release(); } cameras.clear(); SafeRelease(mainCamera); SafeRelease(drawCamera); for (ProxyNodeMap::iterator it = rootNodes.begin(); it != rootNodes.end(); ++it) { SafeRelease(it->second); } rootNodes.clear(); // Children should be removed first because they should unregister themselves in managers RemoveAllChildren(); SafeRelease(imposterManager); SafeRelease(sceneGlobalMaterial); transformSystem = 0; renderUpdateSystem = 0; lodSystem = 0; debugRenderSystem = 0; particleEffectSystem = 0; updatableSystem = 0; lightUpdateSystem = 0; switchSystem = 0; soundSystem = 0; actionSystem = 0; skyboxSystem = 0; staticOcclusionSystem = 0; materialSystem = 0; speedTreeUpdateSystem = 0; foliageSystem = 0; windSystem = 0; waveSystem = 0; uint32 size = (uint32)systems.size(); for (uint32 k = 0; k < size; ++k) SafeDelete(systems[k]); systems.clear(); systemsToProcess.clear(); SafeDelete(eventSystem); SafeDelete(renderSystem); }
CBaseContainerNode::~CBaseContainerNode() { RemoveAllChildren(); pNodeView->OnContainerRemoved( this ); }