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