//--------------------------------------------------------------------- void XMLSkeletonSerializer::writeAnimation(TiXmlElement* animsNode, const Animation* anim) { TiXmlElement* animNode = animsNode->InsertEndChild(TiXmlElement("animation"))->ToElement(); animNode->SetAttribute("name", anim->getName()); animNode->SetAttribute("length", StringConverter::toString(anim->getLength())); // Optional base keyframe information if (anim->getUseBaseKeyFrame()) { TiXmlElement* baseInfoNode = animNode->InsertEndChild(TiXmlElement("baseinfo"))->ToElement(); baseInfoNode->SetAttribute("baseanimationname", anim->getBaseKeyFrameAnimationName()); baseInfoNode->SetAttribute("basekeyframetime", StringConverter::toString(anim->getBaseKeyFrameTime())); } // Write all tracks TiXmlElement* tracksNode = animNode->InsertEndChild(TiXmlElement("tracks"))->ToElement(); Animation::NodeTrackIterator trackIt = anim->getNodeTrackIterator(); while (trackIt.hasMoreElements()) { writeAnimationTrack(tracksNode, trackIt.getNext()); } }
//----------------------------------------------------------------------------------------- TiXmlElement* CParticleEditor::exportDotScene(TiXmlElement *pParent) { TiXmlElement *pNode = pParent->InsertEndChild(TiXmlElement("node"))->ToElement(); // node properties pNode->SetAttribute("name", mName->get().c_str()); pNode->SetAttribute("id", Ogre::StringConverter::toString(mObjectID->get()).c_str()); // position TiXmlElement *pPosition = pNode->InsertEndChild(TiXmlElement("position"))->ToElement(); pPosition->SetAttribute("x", Ogre::StringConverter::toString(mPosition->get().x).c_str()); pPosition->SetAttribute("y", Ogre::StringConverter::toString(mPosition->get().y).c_str()); pPosition->SetAttribute("z", Ogre::StringConverter::toString(mPosition->get().z).c_str()); // rotation TiXmlElement *pRotation = pNode->InsertEndChild(TiXmlElement("rotation"))->ToElement(); pRotation->SetAttribute("qw", Ogre::StringConverter::toString(mOrientation->get().w).c_str()); pRotation->SetAttribute("qx", Ogre::StringConverter::toString(mOrientation->get().x).c_str()); pRotation->SetAttribute("qy", Ogre::StringConverter::toString(mOrientation->get().y).c_str()); pRotation->SetAttribute("qz", Ogre::StringConverter::toString(mOrientation->get().z).c_str()); // scale TiXmlElement *pScale = pNode->InsertEndChild(TiXmlElement("scale"))->ToElement(); pScale->SetAttribute("x", Ogre::StringConverter::toString(mScale->get().x).c_str()); pScale->SetAttribute("y", Ogre::StringConverter::toString(mScale->get().y).c_str()); pScale->SetAttribute("z", Ogre::StringConverter::toString(mScale->get().z).c_str()); TiXmlElement *pParticleSystem = pNode->InsertEndChild(TiXmlElement("particleSystem"))->ToElement(); pParticleSystem->SetAttribute("name", mName->get().c_str()); pParticleSystem->SetAttribute("script", mParticleSystem->get().c_str()); return pNode; }
TiXmlElement* GetSpecProcElement(SpecProc *sProc) { TiXmlElement *sProcEl = new TiXmlElement("HProc"); sProcEl->SetAttribute("Qual", sProc->GetParentModule()->Name.c_str()); sProcEl->SetAttribute("Name", sProc->GetCPPProcName(false).c_str()); sProcEl->SetAttribute("UID", sProc->num); if (sProc->returnType) sProcEl->SetAttribute("ReturnType", sProc->returnType->GetCPPTypeName(false).c_str()); // записываем спец-е параметры обработчика vector<Parameter*>::const_iterator ci; for (ci = sProc->commonParams.begin(); ci != sProc->commonParams.end(); ci++) { TiXmlElement *sParam = GetSParamElement(static_cast<Parameter*>(*ci)); sProcEl->InsertEndChild(*sParam); } // записываем форм-е параметры обработчика for (ci = sProc->formalParams.begin(); ci != sProc->formalParams.end(); ci++) { TiXmlElement *fParam = GetFormalParamElement(static_cast<Parameter*>(*ci)); sProcEl->InsertEndChild(*fParam); } return sProcEl; }
void COptions::SetXmlValue(unsigned int nID, wxString value) { if (!m_pXmlFile) return; // No checks are made about the validity of the value, that's done in SetOption char *utf8 = ConvUTF8(value); if (!utf8) return; TiXmlElement *settings = m_pXmlFile->GetElement()->FirstChildElement("Settings"); if (!settings) { TiXmlNode *node = m_pXmlFile->GetElement()->InsertEndChild(TiXmlElement("Settings")); if (!node) { delete [] utf8; return; } settings = node->ToElement(); if (!settings) { delete [] utf8; return; } } else { TiXmlNode *node = 0; while ((node = settings->IterateChildren("Setting", node))) { TiXmlElement *setting = node->ToElement(); if (!setting) continue; const char *attribute = setting->Attribute("name"); if (!attribute) continue; if (strcmp(attribute, options[nID].name)) continue; setting->RemoveAttribute("type"); setting->Clear(); setting->SetAttribute("type", (options[nID].type == string) ? "string" : "number"); setting->InsertEndChild(TiXmlText(utf8)); delete [] utf8; return; } } wxASSERT(options[nID].name[0]); TiXmlElement setting("Setting"); setting.SetAttribute("name", options[nID].name); setting.SetAttribute("type", (options[nID].type == string) ? "string" : "number"); setting.InsertEndChild(TiXmlText(utf8)); settings->InsertEndChild(setting); delete [] utf8; }
//--------------------------------------------------------------------- void XMLSkeletonSerializer::writeSkeleton(const Skeleton* pSkel) { TiXmlElement* rootNode = mXMLDoc->RootElement(); TiXmlElement* bonesElem = rootNode->InsertEndChild(TiXmlElement("bones"))->ToElement(); unsigned short numBones = pSkel->getNumBones(); LogManager::getSingleton().logMessage("There are " + StringConverter::toString(numBones) + " bones."); unsigned short i; for (i = 0; i < numBones; ++i) { LogManager::getSingleton().logMessage(" Exporting Bone number " + StringConverter::toString(i)); Bone* pBone = pSkel->getBone(i); writeBone(bonesElem, pBone); } // Write parents TiXmlElement* hierElem = rootNode->InsertEndChild(TiXmlElement("bonehierarchy"))->ToElement(); for (i = 0; i < numBones; ++i) { Bone* pBone = pSkel->getBone(i); String name = pBone->getName() ; if ((pBone->getParent())!=NULL) // root bone { Bone* pParent = (Bone*)pBone->getParent(); writeBoneParent(hierElem, name, pParent->getName()); } } }
/* virtual */ opera_update_checker::status::Status OAUCRequestImpl::AddProductUpdatePart(const UpdateDataProvider& provider) { try { if (!document_.RootElement()) { document_.Parse(update_request_root); if (document_.Error()) return opera_update_checker::status::StatusCode::FAILED; } TiXmlDocument temp; TIXML_STRING name(provider.GetProductName() ? provider.GetProductName() : ""); TIXML_STRING encoded_name; TIXML_STRING ver(provider.GetProductVersion() ? provider.GetProductVersion() : ""); TIXML_STRING encoded_ver; TIXML_STRING lang(provider.GetProductLanguage() ? provider.GetProductLanguage() : ""); TIXML_STRING encoded_lang; document_.EncodeString(name, &encoded_name); document_.EncodeString(ver, &encoded_ver); document_.EncodeString(lang, &encoded_lang); sprintf(shared_work_buffer, update_product_part_template, encoded_name.c_str() ? encoded_name.c_str() : "", encoded_ver.c_str() ? encoded_ver.c_str() : "", encoded_lang.c_str() ? encoded_lang.c_str() : ""); temp.Parse(shared_work_buffer); if (temp.Error()) return opera_update_checker::status::StatusCode::FAILED; OAUC_ASSERT(document_.RootElement() && document_.RootElement()->FirstChildElement()); TiXmlElement* child = document_.RootElement()->FirstChildElement(); while (opera_update_checker::system_utils::SystemUtils::strnicmp(child->Value(), "product", 7) != 0) { child = child->NextSiblingElement(); OAUC_ASSERT(child); } TiXmlElement* elm = temp.RootElement(); do { child->InsertEndChild(*elm); elm = elm->NextSiblingElement(); } while (elm); if (TiXmlElement* products = product_res_document_.RootElement()) child->InsertEndChild(*products); } catch (...) { return opera_update_checker::status::StatusCode::OOM; } return opera_update_checker::status::StatusCode::OK; }
void wxsProject::WriteConfiguration(TiXmlElement* element) { TiXmlElement* SmithElement = element->FirstChildElement("wxsmith"); if ( !m_GUI && m_Resources.empty() && m_UnknownConfig.NoChildren() && m_UnknownResources.NoChildren() ) { // Nothing to write if ( SmithElement ) { element->RemoveChild(SmithElement); } return; } if ( !SmithElement ) { SmithElement = element->InsertEndChild(TiXmlElement("wxsmith"))->ToElement(); } SmithElement->Clear(); SmithElement->SetAttribute("version",CurrentVersionStr); // saving GUI item if ( m_GUI ) { TiXmlElement* GUIElement = SmithElement->InsertEndChild(TiXmlElement("gui"))->ToElement(); GUIElement->SetAttribute("name",cbU2C(m_GUI->GetName())); m_GUI->WriteConfig(GUIElement); } // saving resources if ( !m_Resources.empty() || !m_UnknownResources.NoChildren() ) { TiXmlElement* ResElement = SmithElement->InsertEndChild(TiXmlElement("resources"))->ToElement(); size_t Count = m_Resources.Count(); for ( size_t i=0; i<Count; i++ ) { const wxString& Name = m_Resources[i]->GetResourceName(); const wxString& Type = m_Resources[i]->GetResourceType(); TiXmlElement* Element = ResElement->InsertEndChild(TiXmlElement(cbU2C(Type)))->ToElement(); // TODO: Check value returned from WriteConfig m_Resources[i]->WriteConfig(Element); Element->SetAttribute("name",cbU2C(Name)); } // Saving all unknown resources for ( TiXmlNode* Node = m_UnknownResources.FirstChild(); Node; Node=Node->NextSibling() ) { SmithElement->InsertEndChild(*Node); } } // Saving all unknown configuration nodes for ( TiXmlNode* Node = m_UnknownConfig.FirstChild(); Node; Node=Node->NextSibling() ) { SmithElement->InsertEndChild(*Node); } }
//---------------------------------------------------------------------------------------- TiXmlElement* PortalEditor::exportDotScene(TiXmlElement *pParent) { TiXmlElement *pNode = pParent->InsertEndChild(TiXmlElement("portal"))->ToElement(); // node properties pNode->SetAttribute("name", mName->get().c_str()); pNode->SetAttribute("id", Ogre::StringConverter::toString(mObjectID->get()).c_str()); // position TiXmlElement *pPosition = pNode->InsertEndChild(TiXmlElement("position"))->ToElement(); pPosition->SetAttribute("x", Ogre::StringConverter::toString(mPosition->get().x).c_str()); pPosition->SetAttribute("y", Ogre::StringConverter::toString(mPosition->get().y).c_str()); pPosition->SetAttribute("z", Ogre::StringConverter::toString(mPosition->get().z).c_str()); // rotation TiXmlElement *pRotation = pNode->InsertEndChild(TiXmlElement("rotation"))->ToElement(); pRotation->SetAttribute("qw", Ogre::StringConverter::toString(mOrientation->get().w).c_str()); pRotation->SetAttribute("qx", Ogre::StringConverter::toString(mOrientation->get().x).c_str()); pRotation->SetAttribute("qy", Ogre::StringConverter::toString(mOrientation->get().y).c_str()); pRotation->SetAttribute("qz", Ogre::StringConverter::toString(mOrientation->get().z).c_str()); // scale TiXmlElement *pScale = pNode->InsertEndChild(TiXmlElement("scale"))->ToElement(); pScale->SetAttribute("x", Ogre::StringConverter::toString(mScale->get().x).c_str()); pScale->SetAttribute("y", Ogre::StringConverter::toString(mScale->get().y).c_str()); pScale->SetAttribute("z", Ogre::StringConverter::toString(mScale->get().z).c_str()); //*coords of portal corners* //(use that instead of width/height, thus this format can be used for //more fully implemented PCZSM editors) TiXmlElement *pCorners = pNode->InsertEndChild(TiXmlElement("corners"))->ToElement(); TiXmlElement *pCorner0 = pCorners->InsertEndChild(TiXmlElement("corner0"))->ToElement(); pCorner0->SetAttribute("x", Ogre::StringConverter::toString(-(mWidth->get())/2).c_str()); pCorner0->SetAttribute("y", Ogre::StringConverter::toString((mHeight->get())/2).c_str()); pCorner0->SetAttribute("z", "0.0"); TiXmlElement *pCorner1 = pCorners->InsertEndChild(TiXmlElement("corner1"))->ToElement(); pCorner1->SetAttribute("x", Ogre::StringConverter::toString((mWidth->get())/2).c_str()); pCorner1->SetAttribute("y", Ogre::StringConverter::toString((mHeight->get())/2).c_str()); pCorner1->SetAttribute("z", "0.0"); TiXmlElement *pCorner2 = pCorners->InsertEndChild(TiXmlElement("corner2"))->ToElement(); pCorner2->SetAttribute("x", Ogre::StringConverter::toString((mWidth->get())/2).c_str()); pCorner2->SetAttribute("y", Ogre::StringConverter::toString(-(mHeight->get())/2).c_str()); pCorner2->SetAttribute("z", "0.0"); TiXmlElement *pCorner3 = pCorners->InsertEndChild(TiXmlElement("corner3"))->ToElement(); pCorner3->SetAttribute("x", Ogre::StringConverter::toString(-(mWidth->get())/2).c_str()); pCorner3->SetAttribute("y", Ogre::StringConverter::toString(-(mHeight->get())/2).c_str()); pCorner3->SetAttribute("z", "0.0"); //*destination* TiXmlElement *pDestination = pNode->InsertEndChild(TiXmlElement("destination"))->ToElement(); if(mConnected) { pDestination->SetAttribute("zone", mConnected->mParentZone->getName().c_str()); pDestination->SetAttribute("portal",mConnected->getName().c_str()); } return pNode; }
bool CSPrimBox::Write2XML(TiXmlElement &elem, bool parameterised) { CSPrimitives::Write2XML(elem,parameterised); TiXmlElement P1("P1"); m_Coords[0].Write2XML(&P1,parameterised); elem.InsertEndChild(P1); TiXmlElement P2("P2"); m_Coords[1].Write2XML(&P2,parameterised); elem.InsertEndChild(P2); return true; }
bool wxsItemResData::RebuildXrcFile() { // First - opening file TiXmlDocument Doc; TiXmlElement* Resources = nullptr; TiXmlElement* Object = nullptr; if ( TinyXML::LoadDocument(m_XrcFileName,&Doc) ) { Resources = Doc.FirstChildElement("resource"); } if ( !Resources ) { Doc.Clear(); Doc.InsertEndChild(TiXmlDeclaration("1.0","utf-8","")); Resources = Doc.InsertEndChild(TiXmlElement("resource"))->ToElement(); Resources->SetAttribute("xmlns","http://www.wxwidgets.org/wxxrc"); } // Searching for object representing this resource for ( Object = Resources->FirstChildElement("object"); Object; Object = Object->NextSiblingElement("object") ) { if ( cbC2U(Object->Attribute("name")) == m_ClassName ) { Object->Clear(); while ( Object->FirstAttribute() ) { Object->RemoveAttribute(Object->FirstAttribute()->Name()); } break; } } if ( !Object ) { Object = Resources->InsertEndChild(TiXmlElement("object"))->ToElement(); } // The only things left are: to dump item into object ... m_RootItem->XmlWrite(Object,true,false); Object->SetAttribute("name",cbU2C(m_ClassName)); for ( int i=0; i<GetToolsCount(); i++ ) { TiXmlElement* ToolElement = Object->InsertEndChild(TiXmlElement("object"))->ToElement(); m_Tools[i]->XmlWrite(ToolElement,true,false); } // ... and save back the file return TinyXML::SaveDocument(m_XrcFileName,&Doc); }
bool CRedisProxyCfg::saveProxyLastState(RedisProxy* proxy) { TiXmlElement* pRootNode = (TiXmlElement*)m_operateXmlPointer->get_rootElement(); string nodeHash = "hash_mapping"; TiXmlElement* pOldHashMap; if (GetNodePointerByName(pRootNode, nodeHash, pOldHashMap)) { pRootNode->RemoveChild(pOldHashMap); } TiXmlElement hashMappingNode("hash_mapping"); for (int i = 0; i < proxy->slotCount(); ++i) { TiXmlElement hashNode("hash"); hashNode.SetAttribute("value", i); hashNode.SetAttribute("group_name", proxy->groupBySlot(i)->groupName()); hashMappingNode.InsertEndChild(hashNode); } pRootNode->InsertEndChild(hashMappingNode); // key mapping string nodeKey = "key_mapping"; TiXmlElement* pKey; if (GetNodePointerByName(pRootNode, nodeKey, pKey)) { pRootNode->RemoveChild(pKey); } TiXmlElement keyMappingNode("key_mapping"); StringMap<RedisServantGroup*>& keyMapping = proxy->keyMapping(); StringMap<RedisServantGroup*>::iterator it = keyMapping.begin(); for (; it != keyMapping.end(); ++it) { String key = it->first; TiXmlElement keyNode("key"); keyNode.SetAttribute("key_name", key.data()); RedisServantGroup* group = it->second; if (group != NULL) { keyNode.SetAttribute("group_name", group->groupName()); } keyMappingNode.InsertEndChild(keyNode); } pRootNode->InsertEndChild(keyMappingNode); // add time time_t now = time(NULL); char fileName[512]; struct tm* current_time = localtime(&now); sprintf(fileName,"onecache%d%02d%02d%02d.xml", current_time->tm_year + 1900, current_time->tm_mon + 1, current_time->tm_mday, current_time->tm_hour); bool ok = m_operateXmlPointer->m_docPointer->SaveFile(fileName); return ok; }
void XMLModelDefinitionSerializer::exportPoses(ModelDefinitionPtr modelDef, TiXmlElement& modelElem) { if (modelDef->mPoseDefinitions.size()) { TiXmlElement elem("poses"); for (PoseDefinitionStore::const_iterator I = modelDef->mPoseDefinitions.begin(); I != modelDef->mPoseDefinitions.end(); ++I) { TiXmlElement poseElem("pose"); poseElem.SetAttribute("name", I->first.c_str()); if (I->second.IgnoreEntityData) { poseElem.SetAttribute("ignoreEntityData", "true"); } if (!I->second.Translate.isNaN()) { TiXmlElement translateElem("translate"); XMLHelper::fillElementFromVector3(translateElem, I->second.Translate); poseElem.InsertEndChild(translateElem); } if (!I->second.Rotate.isNaN()) { TiXmlElement rotateElem("rotate"); XMLHelper::fillElementFromQuaternion(rotateElem, I->second.Rotate); poseElem.InsertEndChild(rotateElem); } elem.InsertEndChild(poseElem); } modelElem.InsertEndChild(elem); } }
void WriteToXml(string& strXml, vector<bool>& vecType,string& FileName) { COriFileOperate oriFile(FileName); size_t nVecSize = vecType.size(); if (strXml.find("chinese_simple") != -1) { for (size_t i=1;i<nVecSize;++i) { vecType[i] = false; } } char* szNumOrStrInfo = new char[nVecSize+1]; for (size_t i = 0; i < nVecSize; i++) { if (vecType[i]) { szNumOrStrInfo[i] = 'n'; } else { szNumOrStrInfo[i] = 's'; } } szNumOrStrInfo[nVecSize] = '\0'; TiXmlDocument* pXmlDoc = new TiXmlDocument; pXmlDoc->InsertEndChild(TiXmlElement("config")); TiXmlNode* pXmlNode = pXmlDoc->FirstChild("config"); pXmlNode->InsertEndChild(TiXmlElement("TableType")); TiXmlElement* pXmlElem = pXmlNode->FirstChildElement("TableType"); pXmlElem->InsertEndChild(TiXmlText("S")); string str = szNumOrStrInfo; string str1 = oriFile.GetDataByRowCol(0,0); transform(str1.begin(),str1.end(),str1.begin(),toupper); for(uint32 i=1;i<=str.size();i++) { TiXmlElement* cxn = new TiXmlElement("Col"); pXmlNode->LinkEndChild(cxn); // cxn->SetAttribute("ColNum",i); if(str1!="NOTE:") { cxn->SetAttribute("Name",oriFile.GetDataByRowCol(0,i-1).c_str()); } else { cxn->SetAttribute("Name",oriFile.GetDataByRowCol(1,i-1).c_str()); } string ss; stringstream temp; temp<<szNumOrStrInfo[i-1]; temp>>ss; cxn->SetAttribute("Type",ss); } pXmlDoc->SaveFile(strXml); delete pXmlDoc; pXmlDoc = NULL; delete[] szNumOrStrInfo; szNumOrStrInfo = NULL; }
void ConfigManager::SetControlType(int controller, const char* type) { TiXmlHandle docHandle( config_file ); TiXmlElement* player = docHandle.FirstChild( "Balder" ).FirstChild( "Player" ).Element(); TiXmlElement* lastPlayer = 0; while(player) { lastPlayer = player; int c; int result = player->QueryIntAttribute("controller",&c); if (TIXML_SUCCESS == result){ if (controller == c){ TiXmlHandle h(player); TiXmlElement *controlEl = h.FirstChild("Control").Element(); if (!controlEl){ // first make sure the Control section exists controlEl = new TiXmlElement("Control"); controlEl->SetAttribute("type", type); } else {controlEl->SetAttribute("type", type);} return; } } player=player->NextSiblingElement("Player"); } // it appears that we did not find the player, must add it . . if (!lastPlayer) { lastPlayer = docHandle.FirstChild("Balder").Element(); } player = new TiXmlElement("Player"); player->SetAttribute("controller", controller); player->InsertEndChild(*(new TiXmlElement("Control"))); player->FirstChildElement("Control")->SetAttribute("type", type); docHandle.FirstChild("Balder").Element()->InsertAfterChild(lastPlayer, *player); }
int main() { // TiXmlDocument doc; // doc.LoadFile("Configuration.xml"); // TiXmlHandle hXml(&doc); // TiXmlElement xmlElement("ContourColor"); // TiXmlElement* pElement = hXml.FirstChildElement("DlgChain").ToElement(); // pElement->InsertEndChild(xmlElement); // //doc.Print(stdout); // //hXml.ToNode()->Print(stdout,0); // hXml.Print(stdout,0); CXmlParser xmlParser("..\\bin\\Configuration\\Configuration.xml"); //xmlParser.LoadFile("Configuration.xml"); TiXmlElement element("ContourColor"); TiXmlElement* pElement = xmlParser.FirstChild("DlgChain").ToElement(); pElement->InsertEndChild(element); pElement = pElement->FirstChild("ContourColor")->ToElement(); pElement->SetAttribute("edge",0xffffff); pElement->SetAttribute("mask",0xff00ff); pElement->SetAttribute("num",0x0000ff); xmlParser.SaveAs("Configuration1.xml"); system("pause"); return 0; }
//----------------------------------------------------------------------------------------- TiXmlElement* CTerrainGroupEditor::exportDotScene(TiXmlElement *pParent) { TiXmlElement *pTerrain = pParent->InsertEndChild(TiXmlElement("terrain"))->ToElement(); pTerrain->SetAttribute("worldSize", Ogre::StringConverter::toString(mWorldSize->get()).c_str()); pTerrain->SetAttribute("mapSize", Ogre::StringConverter::toString(mMapSize->get()).c_str()); pTerrain->SetAttribute("pagenameprefix", mPageNamePrefix->get().c_str()); pTerrain->SetAttribute("colourmapEnabled", Ogre::StringConverter::toString(mColourMapEnabled->get()).c_str()); pTerrain->SetAttribute("colourMapTextureSize", Ogre::StringConverter::toString(mColourMapTextureSize->get()).c_str()); pTerrain->SetAttribute("tuningCompositeMapDistance", Ogre::StringConverter::toString(mCompositeMapDistance->get()).c_str()); pTerrain->SetAttribute("tuningMaxPixelError", Ogre::StringConverter::toString(mMaxPixelError->get()).c_str()); pTerrain->SetAttribute("tuningMinBatchSize", Ogre::StringConverter::toString(mMinBatchSize->get()).c_str()); pTerrain->SetAttribute("tuningMaxBatchSize", Ogre::StringConverter::toString(mMaxBatchSize->get()).c_str()); pTerrain->SetAttribute("tuningSkirtSize", Ogre::StringConverter::toString(mSkirtSize->get()).c_str()); pTerrain->SetAttribute("tuningUseRayBoxDistancealculation", Ogre::StringConverter::toString(mUseRayBoxDistanceCalculation->get()).c_str()); TiXmlElement *pTerrainPages = pTerrain->InsertEndChild(TiXmlElement("terrainPages"))->ToElement(); NameObjectPairList::const_iterator it = mChildren.begin(); while(it != mChildren.end()) { CTerrainPageEditor *terrain = static_cast<CTerrainPageEditor*>(it->second); terrain->exportDotScene(pTerrainPages); it++; } return pTerrain; }
void XMLModelDefinitionSerializer::exportParticleSystems(ModelDefinitionPtr modelDef, TiXmlElement& modelElem) { if (modelDef->mParticleSystems.size()) { TiXmlElement particleSystemsElem("particlesystems"); for (ModelDefinition::ParticleSystemSet::const_iterator I = modelDef->mParticleSystems.begin(); I != modelDef->mParticleSystems.end(); ++I) { TiXmlElement particleSystemElem("particlesystem"); particleSystemElem.SetAttribute("script", I->Script.c_str()); if (!I->Direction.isNaN()) { TiXmlElement directionElem("direction"); XMLHelper::fillElementFromVector3(directionElem, I->Direction); particleSystemElem.InsertEndChild(directionElem); } if (I->Bindings.size()) { TiXmlElement bindingsElem("bindings"); for (ModelDefinition::BindingSet::const_iterator J = I->Bindings.begin(); J != I->Bindings.end(); ++J) { TiXmlElement bindingElem("binding"); bindingsElem.SetAttribute("emittervar", J->EmitterVar); bindingsElem.SetAttribute("atlasattribute", J->AtlasAttribute); particleSystemElem.InsertEndChild(bindingsElem); } } particleSystemsElem.InsertEndChild(particleSystemElem); } modelElem.InsertEndChild(particleSystemsElem); } }
void CALLBACK CUICommandHistory::UIAdd(TiXmlNode* pNode) { TiXmlElement* pElement = pNode->ToElement(); CStringA strParentName = pElement->Attribute("parentname"); pElement->RemoveAttribute("parentname"); if(strParentName.IsEmpty()) return; CUIDesignerView* pUIView = g_pMainFrame->GetActiveUIView(); CPaintManagerUI* pManager = pUIView->GetPaintManager(); CControlUI* pParentControl = pManager->FindControl(StringConvertor::Utf8ToWide(strParentName)); if(pParentControl == NULL) return; TiXmlDocument xmlDoc; TiXmlDeclaration Declaration("1.0","utf-8","yes"); xmlDoc.InsertEndChild(Declaration); TiXmlElement* pRootElem = new TiXmlElement("UIAdd"); pRootElem->InsertEndChild(*pElement); xmlDoc.InsertEndChild(*pRootElem); TiXmlPrinter printer; xmlDoc.Accept(&printer); delete pRootElem; CDialogBuilder builder; CControlUI* pRoot=builder.Create(StringConvertor::Utf8ToWide(printer.CStr()), (UINT)0, NULL, pManager); if(pRoot) pUIView->RedoUI(pRoot, pParentControl); }
// ----------------------------------------------------------------------------- // Create a new element and set to child of current stack element. // New element is placed on top of element stack. // ----------------------------------------------------------------------------- void SimXMLDocument::pushNewElement(const char* rName) { TiXmlElement cElement( rName ); TiXmlElement* pStackTop = 0; if(m_paNode.empty()) { pStackTop = dynamic_cast<TiXmlElement*> (m_qDocument->InsertEndChild( cElement ) ); } else { const int iFinalElement = m_paNode.size() - 1; TiXmlElement* pNode = m_paNode[iFinalElement]; if(!pNode) { return; } pStackTop = dynamic_cast<TiXmlElement*> (pNode->InsertEndChild( cElement )); } if(!pStackTop) { return; } m_paNode.push_back(pStackTop); }
void ConfigManager::Write(const wxString& name, const ConfigManagerContainer::IntToStringMap& map) { wxString key(name); TiXmlElement* e = AssertPath(key); TiXmlElement *leaf = GetUniqElement(e, key); TiXmlElement *mNode; mNode = GetUniqElement(leaf, _T("ismap")); leaf->RemoveChild(mNode); mNode = GetUniqElement(leaf, _T("ismap")); wxString tmp; for (ConfigManagerContainer::IntToStringMap::const_iterator it = map.begin(); it != map.end(); ++it) { tmp.Printf(_T("x%d"), (int) it->first); TiXmlElement s(tmp.mb_str()); TiXmlText t(cbU2C(it->second)); t.SetCDATA(true); s.InsertEndChild(t); mNode->InsertEndChild(s); } }
//---------------------------------------------------------------------------- void saveUserData(OgitorsCustomPropertySet *set, TiXmlElement *pParent) { if(!set || !pParent) return; OgitorsPropertyVector vec = set->getPropertyVector(); if(vec.size() < 1) return; TiXmlElement *pNode = pParent->InsertEndChild(TiXmlElement("userData"))->ToElement(); for(unsigned int i = 0; i < vec.size(); i++) { OgitorsPropertyBase *property = vec[i]; const OgitorsPropertyDef *def = property->getDefinition(); OgitorsPropertyValue value; value.propType = property->getType(); value.val = property->getValue(); TiXmlElement *pProp = pNode->InsertEndChild(TiXmlElement("property"))->ToElement(); pProp->SetAttribute("type", Ogre::StringConverter::toString(value.propType).c_str()); pProp->SetAttribute("name", property->getName().c_str()); pProp->SetAttribute("data", OgitorsUtils::GetValueString(value).c_str()); } }
bool wxsItemResData::SaveInMixedMode() { // Should be currently up to date, but just for sure udpating it once again if ( !RebuildXrcFile() ) return false; // Storing extra data into Wxs file TiXmlDocument Doc; Doc.InsertEndChild(TiXmlDeclaration("1.0","utf-8","")); TiXmlElement* wxSmithNode = Doc.InsertEndChild(TiXmlElement("wxsmith"))->ToElement(); // Now storing all extra data TiXmlElement* Extra = wxSmithNode->InsertEndChild(TiXmlElement("resource_extra"))->ToElement(); SaveExtraDataReq(m_RootItem,Extra); for ( int i=0; i<GetToolsCount(); i++ ) { SaveExtraDataReq(m_Tools[i],Extra); } if ( TinyXML::SaveDocument(m_WxsFileName,&Doc) ) { m_Undo.Saved(); return true; } return false; }
void COptions::CreateSettingsXmlElement() { if (!m_pXmlFile) return; TiXmlElement *element = m_pXmlFile->GetElement(); if (element->FirstChildElement("Settings")) return; TiXmlElement settings("Settings"); element->InsertEndChild(settings); for (int i = 0; i < OPTIONS_NUM; i++) { m_optionsCache[i].cached = true; if (options[i].type == string) m_optionsCache[i].strValue = options[i].defaultValue; else { long numValue = 0; options[i].defaultValue.ToLong(&numValue); m_optionsCache[i].numValue = numValue; } SetXmlValue(i, options[i].defaultValue); } m_pXmlFile->Save(); }
bool CButtonMapXml::Save(void) const { TiXmlDocument xmlFile; TiXmlDeclaration* decl = new TiXmlDeclaration("1.0", "", ""); xmlFile.LinkEndChild(decl); TiXmlElement rootElement(BUTTONMAP_XML_ROOT); TiXmlNode* root = xmlFile.InsertEndChild(rootElement); if (root == NULL) return false; TiXmlElement* pElem = root->ToElement(); if (!pElem) return false; TiXmlElement deviceElement(DEVICES_XML_ELEM_DEVICE); TiXmlNode* deviceNode = pElem->InsertEndChild(deviceElement); if (deviceNode == NULL) return false; TiXmlElement* deviceElem = deviceNode->ToElement(); if (deviceElem == NULL) return false; CDeviceXml::Serialize(m_device, deviceElem); if (!SerializeButtonMaps(deviceElem)) return false; return xmlFile.SaveFile(m_strResourcePath); }
TiXmlElement * AddString(TiXmlNode * node, const char * name, const char * str) { TiXmlElement * txe = new TiXmlElement(name); TiXmlText txt(str); txe->InsertEndChild(txt); node->LinkEndChild(txe); return txe; }
//--------------------------------------------------------------------- void XMLSkeletonSerializer::writeBone(TiXmlElement* bonesElement, const Bone* pBone) { TiXmlElement* boneElem = bonesElement->InsertEndChild(TiXmlElement("bone"))->ToElement(); // Bone name & handle boneElem->SetAttribute("id", StringConverter::toString(pBone->getHandle())); boneElem->SetAttribute("name", pBone->getName()); // Position TiXmlElement* subNode = boneElem->InsertEndChild(TiXmlElement("position"))->ToElement(); Vector3 pos = pBone->getPosition(); subNode->SetAttribute("x", StringConverter::toString(pos.x)); subNode->SetAttribute("y", StringConverter::toString(pos.y)); subNode->SetAttribute("z", StringConverter::toString(pos.z)); // Orientation subNode = boneElem->InsertEndChild(TiXmlElement("rotation"))->ToElement(); // Show Quaternion as angle / axis Radian angle; Vector3 axis; pBone->getOrientation().ToAngleAxis(angle, axis); TiXmlElement* axisNode = subNode->InsertEndChild(TiXmlElement("axis"))->ToElement(); subNode->SetAttribute("angle", StringConverter::toString(angle.valueRadians())); axisNode->SetAttribute("x", StringConverter::toString(axis.x)); axisNode->SetAttribute("y", StringConverter::toString(axis.y)); axisNode->SetAttribute("z", StringConverter::toString(axis.z)); // Scale optional Vector3 scale = pBone->getScale(); if (scale != Vector3::UNIT_SCALE) { TiXmlElement* scaleNode = boneElem->InsertEndChild(TiXmlElement("scale"))->ToElement(); scaleNode->SetAttribute("x", StringConverter::toString(scale.x)); scaleNode->SetAttribute("y", StringConverter::toString(scale.y)); scaleNode->SetAttribute("z", StringConverter::toString(scale.z)); } }
TiXmlElement* GetModuleElement(Module* module) { TiXmlElement *moduleEl = new TiXmlElement("Module"); moduleEl->SetAttribute("Name", module->Name.c_str()); // ищем все обобщения, обобщенные или специализированные процедуры for(unsigned int i = 0; i < module->objects.objList.size(); ++i) { Type *type = dynamic_cast<Type*>(module->objects.objList[i]); if(type && (type->WhatIsIt() == ItIsTypeGeneric || type->WhatIsIt() == ItIsTypeGenRecord)) { TiXmlElement *genEl = GetGenericElement(type); if (genEl) moduleEl->InsertEndChild(*genEl); continue; } GenericProc *gProc = dynamic_cast<GenericProc*>(module->objects.objList[i]); if (gProc) { TiXmlElement *gProcEl = GetGenericProcElement(gProc); moduleEl->InsertEndChild(*gProcEl); } } // также ищем в подключаемом модуле if (module->AttachmentModule) { // ищем все обобщения, обобщенные или специализированные процедуры for(unsigned int i = 0; i < module->AttachmentModule->objects.objList.size(); ++i) { Type *type = dynamic_cast<Type*>(module->AttachmentModule->objects.objList[i]); if(type && (type->WhatIsIt() == ItIsTypeGeneric || type->WhatIsIt() == ItIsTypeGenRecord)) { TiXmlElement *genEl = GetGenericElement(type); if (genEl) moduleEl->InsertEndChild(*genEl); continue; } } } return moduleEl; }
//----------------------------------------------------------------------------------------- TiXmlElement* CPGInstanceManager::exportDotScene(TiXmlElement *pParent) { Ogre::String name = mName->get(); std::replace(name.begin(), name.end(), '<', ' '); std::replace(name.begin(), name.end(), '>', ' '); std::replace(name.begin(), name.end(), '#', ' '); name = Ogre::StringConverter::toString(mObjectID->get()) + "_" + name; Ogre::String filename = "PGInstances/" + name + ".instance"; TiXmlElement *pNode = pParent->InsertEndChild(TiXmlElement("node"))->ToElement(); // node properties pNode->SetAttribute("name", mName->get().c_str()); pNode->SetAttribute("id", Ogre::StringConverter::toString(mObjectID->get()).c_str()); // position TiXmlElement *pPosition = pNode->InsertEndChild(TiXmlElement("position"))->ToElement(); pPosition->SetAttribute("x", "0"); pPosition->SetAttribute("y", "0"); pPosition->SetAttribute("z", "0"); // rotation TiXmlElement *pRotation = pNode->InsertEndChild(TiXmlElement("rotation"))->ToElement(); pRotation->SetAttribute("qw", "1"); pRotation->SetAttribute("qx", "0"); pRotation->SetAttribute("qy", "0"); pRotation->SetAttribute("qz", "0"); // scale TiXmlElement *pScale = pNode->InsertEndChild(TiXmlElement("scale"))->ToElement(); pScale->SetAttribute("x", "1"); pScale->SetAttribute("y", "1"); pScale->SetAttribute("z", "1"); TiXmlElement *pPG = pNode->InsertEndChild(TiXmlElement("pagedgeometry"))->ToElement(); pPG->SetAttribute("fileName", filename.c_str()); pPG->SetAttribute("model", mModel->get().c_str()); pPG->SetAttribute("pageSize", Ogre::StringConverter::toString(mPageSize->get()).c_str()); pPG->SetAttribute("batchDistance", Ogre::StringConverter::toString(mBatchDistance->get()).c_str()); pPG->SetAttribute("impostorDistance", Ogre::StringConverter::toString(mImpostorDistance->get()).c_str()); pPG->SetAttribute("bounds", Ogre::StringConverter::toString(mBounds->get()).c_str()); pPG->SetAttribute("castShadows", Ogre::StringConverter::toString(mCastShadows->get()).c_str()); return pPG; }
// Sets the color for player indicated in the 'controller' parameter using // the color indicated in the 'newColor' parameter to the saved player // settings in the config file indicated by 'config_file'. // The color in 'newColor' must be a color formatted in a 24 bit color format. // Format for 'newColor' should equal the 24 bit format 'RRGGBB' because this // functions mate, ConfigManager::GetPlayerColor() will only load a 24 bit color. void ConfigManager::SetPlayerColor(int controller, probe_color newColor) { if (newColor > 0xFFFFFF) newColor = 0xFFFFFF; else if (newColor < 0) newColor = 0; TiXmlHandle docHandle( config_file ); TiXmlElement* player = docHandle.FirstChild( "Balder" ).FirstChild( "Player" ).Element(); TiXmlElement* lastPlayer = 0; while(player) { lastPlayer = player; int c; int result = player->QueryIntAttribute("controller",&c); if (TIXML_SUCCESS == result){ if (controller == c){ TiXmlHandle h(player); TiXmlElement *clrEl = h.FirstChild("Probe").FirstChild("Color").Element(); if (!clrEl){ // first make sure the Probe section exists if (!h.FirstChild("Probe").Element()){ player->InsertEndChild(*(new TiXmlElement("Probe"))); } clrEl = new TiXmlElement("Color"); clrEl->SetAttribute("probe_color", newColor); h.FirstChild("Probe").Element()->InsertEndChild(*(clrEl)); } else {clrEl->SetAttribute("probe_color", newColor);} return; } } player=player->NextSiblingElement("Player"); } // it appears that we did not find the player, must add it . . if (!lastPlayer) { lastPlayer = docHandle.FirstChild("Balder").Element(); } player = new TiXmlElement("Player"); player->SetAttribute("controller", controller); player->InsertEndChild(*(new TiXmlElement("Probe"))); player->FirstChildElement("Probe")->InsertEndChild(*(new TiXmlElement("Color"))); player->FirstChildElement("Probe")->FirstChildElement("Color")->SetAttribute("probe_color", newColor); docHandle.FirstChild("Balder").Element()->InsertAfterChild(lastPlayer, *player); }
bool WorkspaceLoader::Save(const wxString& title, const wxString& filename) { const char* ROOT_TAG = "CodeBlocks_workspace_file"; TiXmlDocument doc; doc.SetCondenseWhiteSpace(false); doc.InsertEndChild(TiXmlDeclaration("1.0", "UTF-8", "yes")); TiXmlElement* rootnode = static_cast<TiXmlElement*>(doc.InsertEndChild(TiXmlElement(ROOT_TAG))); if (!rootnode) return false; TiXmlElement* wksp = static_cast<TiXmlElement*>(rootnode->InsertEndChild(TiXmlElement("Workspace"))); wksp->SetAttribute("title", cbU2C(title)); ProjectsArray* arr = Manager::Get()->GetProjectManager()->GetProjects(); for (unsigned int i = 0; i < arr->GetCount(); ++i) { cbProject* prj = arr->Item(i); wxFileName wfname(filename); wxFileName fname(prj->GetFilename()); fname.MakeRelativeTo(wfname.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR)); TiXmlElement* node = static_cast<TiXmlElement*>(wksp->InsertEndChild(TiXmlElement("Project"))); node->SetAttribute("filename", cbU2C( ExportFilename(fname) ) ); if (prj == Manager::Get()->GetProjectManager()->GetActiveProject()) node->SetAttribute("active", 1); const ProjectsArray* deps = Manager::Get()->GetProjectManager()->GetDependenciesForProject(prj); if (deps && deps->GetCount()) { for (size_t i = 0; i < deps->GetCount(); ++i) { prj = deps->Item(i); fname.Assign(prj->GetFilename()); fname.MakeRelativeTo(wfname.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR)); TiXmlElement* dnode = static_cast<TiXmlElement*>(node->InsertEndChild(TiXmlElement("Depends"))); dnode->SetAttribute("filename", cbU2C( ExportFilename(fname) ) ); } } } return cbSaveTinyXMLDocument(&doc, filename); }