bool cSubMenu::SaveXml(char *fname )
{
if (_fname)
{
TiXmlDocument xml = TiXmlDocument(fname );
TiXmlComment comment;
comment.SetValue(
" Mini-VDR cSetupConfiguration File\n"
" (c) Ralf Dotzert\n"
"\n\n"
" for Example see vdr-menu.xml.example\n\n"
);
TiXmlElement root("menus");
root.SetAttribute("suffix", _menuSuffix);
for (cSubMenuNode *node = _menuTree.First(); node; node = _menuTree.Next(node))
node->SaveXml(&root);
if (xml.InsertEndChild(comment) != NULL &&
xml.InsertEndChild(root) != NULL)
{
return xml.SaveFile(fname);
}
}
else
{
return false;
}
return true;
}
bool Wiinnertag::CreateExample(const string &filepath)
{
if(filepath.size() == 0)
return false;
CreateSubfolder(filepath.c_str());
string fullpath = filepath;
if(fullpath[fullpath.size()-1] != '/')
fullpath += '/';
fullpath += "Wiinnertag.xml";
TiXmlDocument xmlDoc;
TiXmlDeclaration declaration("1.0", "UTF-8", "");
xmlDoc.InsertEndChild(declaration);
TiXmlElement Tag("Tag");
Tag.SetAttribute("URL", "http://www.wiinnertag.com/wiinnertag_scripts/update_sign.php?key={KEY}&game_id={ID6}");
Tag.SetAttribute("Key", "1234567890");
xmlDoc.InsertEndChild(Tag);
xmlDoc.SaveFile(fullpath);
return true;
}
void CUIDesignerView::OnEditCopy()
{
ASSERT(m_cfUI != NULL);
TiXmlDocument xmlDoc;
TiXmlDeclaration Declaration("1.0","utf-8","yes");
xmlDoc.InsertEndChild(Declaration);
TiXmlElement* pCopyElm = new TiXmlElement("UICopy");
CopyUI(pCopyElm);
xmlDoc.InsertEndChild(*pCopyElm);
TiXmlPrinter printer;
xmlDoc.Accept(&printer);
delete pCopyElm;
CSharedFile file(GMEM_MOVEABLE, printer.Size() + 1);
file.Write(printer.CStr(), printer.Size());
file.Write("\0", 1);
COleDataSource* pDataSource = NULL;
TRY
{
pDataSource = new COleDataSource;
pDataSource->CacheGlobalData(m_cfUI, file.Detach());
pDataSource->SetClipboard();
}
CATCH_ALL(e)
{
delete pDataSource;
THROW_LAST();
}
END_CATCH_ALL
}
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 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);
}
bool CPluginSettings::Load(const CURL& url)
{
m_url = url;
// create the users filepath
m_userFileName.Format("P:\\plugin_data\\%s\\%s", url.GetHostName().c_str(), url.GetFileName().c_str());
CUtil::RemoveSlashAtEnd(m_userFileName);
CUtil::AddFileToFolder(m_userFileName, "settings.xml", m_userFileName);
// Create our final path
CStdString pluginFileName = "Q:\\plugins\\";
CUtil::AddFileToFolder(pluginFileName, url.GetHostName(), pluginFileName);
CUtil::AddFileToFolder(pluginFileName, url.GetFileName(), pluginFileName);
// Replace the / at end, GetFileName() leaves a / at the end
pluginFileName.Replace("/", "\\");
CUtil::AddFileToFolder(pluginFileName, "resources", pluginFileName);
CUtil::AddFileToFolder(pluginFileName, "settings.xml", pluginFileName);
pluginFileName = _P(pluginFileName);
m_userFileName = _P(m_userFileName);
if (!m_pluginXmlDoc.LoadFile(pluginFileName.c_str()))
{
CLog::Log(LOGERROR, "Unable to load: %s, Line %d\n%s", pluginFileName.c_str(), m_pluginXmlDoc.ErrorRow(), m_pluginXmlDoc.ErrorDesc());
return false;
}
// Make sure that the plugin XML has the settings element
TiXmlElement *setting = m_pluginXmlDoc.RootElement();
if (!setting || strcmpi(setting->Value(), "settings") != 0)
{
CLog::Log(LOGERROR, "Error loading Settings %s: cannot find root element 'settings'", pluginFileName.c_str());
return false;
}
// Load the user saved settings. If it does not exist, create it
if (!m_userXmlDoc.LoadFile(m_userFileName.c_str()))
{
TiXmlDocument doc;
TiXmlDeclaration decl("1.0", "UTF-8", "yes");
doc.InsertEndChild(decl);
TiXmlElement xmlRootElement("settings");
doc.InsertEndChild(xmlRootElement);
m_userXmlDoc = doc;
// Don't worry about the actual settings, they will be set when the user clicks "Ok"
// in the settings dialog
}
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 TracksXml::SaveXml(Ogre::String file)
{
TiXmlDocument xml; TiXmlElement root("tracks");
for (int i=0; i < trks.size(); ++i)
{
const TrackInfo& t = trks[i];
TiXmlElement trk("track");
trk.SetAttribute("n", toStrC( t.n ));
trk.SetAttribute("name", t.name.c_str());
trk.SetAttribute("created", dt2s(t.created).c_str());
trk.SetAttribute("crtver", toStrC( t.crtver ));
trk.SetAttribute("modified", dt2s(t.modified).c_str());
trk.SetAttribute("scenery", t.scenery.c_str());
trk.SetAttribute("author", t.author.c_str());
trk.SetAttribute("fluids", toStrC( t.fluids ));
trk.SetAttribute("bumps", toStrC( t.bumps )); trk.SetAttribute("jumps", toStrC( t.jumps ));
trk.SetAttribute("loops", toStrC( t.loops )); trk.SetAttribute("pipes", toStrC( t.pipes ));
trk.SetAttribute("banked", toStrC( t.banked )); trk.SetAttribute("frenzy", toStrC( t.frenzy ));
trk.SetAttribute("long", toStrC( t.longn ));
trk.SetAttribute("diff", toStrC( t.diff ));
trk.SetAttribute("rating", toStrC( t.rating ));
trk.SetAttribute("rateuser", toStrC( t.rateuser ));
trk.SetAttribute("drivenlaps", toStrC( t.drivenlaps ));
root.InsertEndChild(trk);
}
xml.InsertEndChild(root);
return xml.SaveFile(file.c_str());
}
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;
}
bool CWebBrowserDownloadHandler::SaveDownloadHistory()
{
TiXmlDocument xmlDoc;
TiXmlElement xmlRootElement("downloadhistory");
TiXmlNode *pRoot = xmlDoc.InsertEndChild(xmlRootElement);
if (pRoot == nullptr)
return false;
TiXmlElement xmlDownloadHistory("histories");
TiXmlNode* pHistoriesNode = pRoot->InsertEndChild(xmlDownloadHistory);
if (pHistoriesNode)
{
for (const auto& entry : m_finishedDownloads)
{
TiXmlElement xmlSetting("history");
TiXmlNode* pHistoryNode = pHistoriesNode->InsertEndChild(xmlSetting);
if (pHistoryNode)
{
XMLUtils::SetString(pHistoryNode, "name", entry.second->GetName().c_str());
XMLUtils::SetString(pHistoryNode, "path", entry.second->GetPath().c_str());
XMLUtils::SetString(pHistoryNode, "url", entry.second->GetURL().c_str());
XMLUtils::SetLong(pHistoryNode, "time", static_cast<long>(entry.second->GetDownloadTime()));
}
}
}
std::string strSettingsFile = kodi::GetBaseUserPath("download_history.xml");
if (!xmlDoc.SaveFile(strSettingsFile))
{
kodi::Log(ADDON_LOG_ERROR, "failed to write download history data");
return false;
}
return true;
}
// ----------------------------------------------------------------------------
//
void TrackInfoCacheFile::write( AudioTrackInfoCache& cache )
{
TiXmlDocument doc;
TiXmlElement root( "audio_track_info" );
for ( AudioTrackInfoCache::value_type pair : cache ) {
TiXmlElement entry( "entry" );
add_text_element( entry, "link", pair.first );
add_text_element( entry, "id", pair.second.id );
add_text_element( entry, "song_type", pair.second.song_type );
TiXmlElement attributes( "attrs" );
add_attribute( attributes, "key", pair.second.key );
add_attribute( attributes, "mode", pair.second.mode );
add_attribute( attributes, "time_signature", pair.second.time_signature );
add_attribute( attributes, "energy", pair.second.energy );
add_attribute( attributes, "liveness", pair.second.liveness );
add_attribute( attributes, "tempo", pair.second.tempo );
add_attribute( attributes, "speechiness", pair.second.speechiness );
add_attribute( attributes, "acousticness", pair.second.acousticness );
add_attribute( attributes, "instrumentalness", pair.second.instrumentalness );
add_attribute( attributes, "duration", pair.second.duration );
add_attribute( attributes, "loudness", pair.second.loudness );
add_attribute( attributes, "valence", pair.second.valence );
add_attribute( attributes, "danceability", pair.second.danceability );
entry.InsertEndChild( attributes );
root.InsertEndChild( entry );
}
doc.InsertEndChild( root );
doc.SaveFile( m_filename );
}
//------------------------------------------------------------------------------
void CToolsHistory::SaveFile( )
{
TiXmlDocument aDoc;
TiXmlNode* pRootNode = aDoc.InsertEndChild( TiXmlElement( "cache" ));
TiXmlNode* pSceneNode = pRootNode->InsertEndChild( TiXmlElement("Scenes"));
TiXmlNode* pPathsNode = pRootNode->InsertEndChild( TiXmlElement("paths"));
//Scene
for( unsigned i=0; i<m_sceneHistory.size(); ++i )
{
TiXmlElement aHistoryNode("history");
aHistoryNode.SetAttribute("Scene", m_sceneHistory[i].first.c_str());
aHistoryNode.SetAttribute("path", m_sceneHistory[i].second.c_str());
pSceneNode->InsertEndChild(aHistoryNode);
}
//path
for( unsigned i=0; i<m_pathHistory.size(); ++i )
{
TiXmlElement aHistoryNode("history");
aHistoryNode.SetAttribute("path", m_pathHistory[i].c_str());
pPathsNode->InsertEndChild(aHistoryNode);
}
//default editor
TiXmlElement aEditorNode("default_editor");
aEditorNode.SetAttribute("path", m_strDefaultEditor.c_str());
pRootNode->InsertEndChild(aEditorNode);
aDoc.SaveFile(m_strCacheFile.c_str());
}
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);
}
// Save progress
bool ProgressXml::SaveXml(std::string file)
{
TiXmlDocument xml; TiXmlElement root("progress");
for (int i=0; i < chs.size(); ++i)
{
const ProgressChamp& pc = chs[i];
TiXmlElement eCh("champ");
eCh.SetAttribute("name", pc.name.c_str() );
eCh.SetAttribute("ver", toStrC( pc.ver ));
eCh.SetAttribute("cur", toStrC( pc.curTrack ));
eCh.SetAttribute("p", toStrC( pc.points ));
for (int i=0; i < pc.trks.size(); ++i)
{
const ProgressTrack& pt = pc.trks[i];
TiXmlElement eTr("t");
eTr.SetAttribute("p", fToStr( pt.points, 1).c_str());
eCh.InsertEndChild(eTr);
}
root.InsertEndChild(eCh);
}
xml.InsertEndChild(root);
return xml.SaveFile(file.c_str());
}
// ----------------------------------------------------------------------------
//
void DefinitionWriter::writeFixtureDefinition(
LPCSTR file_name,
LPCSTR author,
LPCSTR version,
FixtureDefinitionPtrArray& definitions )
{
TiXmlElement fixtures( "fixture_definitions" );
add_text_element( fixtures, "author", author );
add_text_element( fixtures, "version", version );
visit_ptr_array<FixtureDefinitionPtrArray>( fixtures, definitions );
TiXmlDocument doc;
TiXmlDeclaration xml_decl( "1.0", "", "" );
doc.InsertEndChild( xml_decl );
doc.InsertEndChild( fixtures );
//doc.Print();
CString output_file = file_name;
if ( doc.SaveFile( output_file ) )
studio.log_status( "Wrote fixture definitions to '%s'\n", output_file );
else
studio.log_status( "Error writing to '%s'\n", output_file );
}
void CAppRegistry::Save()
{
CSingleLock lock(m_lock);
TiXmlElement rootElement("registry");
CStdString key;
for (RegistryDataIterator keyIter = m_data.begin(); keyIter != m_data.end(); keyIter++)
{
key = keyIter->first;
RegistryValue& values = keyIter->second;
for (size_t i = 0; i < values.size(); i++)
{
TiXmlElement valueElement("value");
valueElement.SetAttribute("id", key.c_str());
TiXmlText valueText(values[i]);
valueElement.InsertEndChild(valueText);
rootElement.InsertEndChild(valueElement);
}
}
TiXmlDocument xmlDoc;
xmlDoc.InsertEndChild(rootElement);
::CreateDirectory(m_dir, NULL);
xmlDoc.SaveFile(m_fileName);
}
//------------------------------------------------ save ------------------------------------------------
void cAmp::ClrSave() // unused
{
TiXmlDocument xml; TiXmlElement root("cAmp");
TiXmlElement Rclrs("RatingColors");
for (size_t i = 0; i < vRclr.size(); i++)
{ TiXmlElement rclr("Rclr");
sfmt(s) "%.3f %.3f %.3f", vRclr[i].r, vRclr[i].g, vRclr[i].b);
rclr.SetAttribute("rgb", s);
Rclrs.InsertEndChild(rclr);
}
root.InsertEndChild(Rclrs);
TiXmlElement Rtx("RatingTex");
Rtx.SetAttribute("xmin", strF(rtx.r));
Rtx.SetAttribute("xmax", strF(rtx.g));
Rtx.SetAttribute("ymin", strF(rtx.b));
Rtx.SetAttribute("ymax", strF(rtx.a));
root.InsertEndChild(Rtx);
TiXmlElement Tclrs("TimeColors");
Tclrs.SetAttribute("mode", strI(tmClrMode));
for (size_t i = 0; i < vTclr.size(); i++)
{ TiXmlElement tclr("Tclr");
tclr.SetAttribute("time", strF(vTclr[i].a));
sfmt(s) "%.3f %.3f %.3f", vTclr[i].r, vTclr[i].g, vTclr[i].b);
tclr.SetAttribute("rgb", s);
Tclrs.InsertEndChild(tclr);
}
root.InsertEndChild(Tclrs);
string p = appPath + "Media\\colors.xml";
xml.InsertEndChild(root); xml.SaveFile(p.c_str());
}
void savePointsAsXML(vector<Point2f> & contour){
TiXmlDocument doc;
TiXmlDeclaration decl("1.0", "", "");
doc.InsertEndChild(decl);
for(int i = 0; i < contour.size(); i++)
{
TiXmlElement point("point");
point.SetAttribute("x",contour[i].x);
point.SetAttribute("y",contour[i].y);
doc.InsertEndChild(point);
}
if(doc.SaveFile(xml.c_str()))
cout << "file saved succesfully.\n";
else
cout << "file not saved, something went wrong!\n";
}
//------------------------------------------------------------------------------
int WxEditorCanvasContainer::SaveFileAs(const std::string& rNewFileName)
{
//open xml file
TiXmlDocument aDoc;
TiXmlElement aNewToppestNode("guiex");
aDoc.InsertEndChild(aNewToppestNode);
//get page
if( GSystem->GetUICanvas()->GetOpenedPageNum() != 0 )
{
CGUIWidget* pWidget = GSystem->GetUICanvas()->GetOpenedPageByIndex(0);
if( pWidget )
{
//save it to doc
if( 0 != SaveWidgetNodeToDoc( pWidget, aDoc ))
{
//failed
return -1;
}
}
}
//save it to file
if( false == aDoc.SaveFile( rNewFileName.c_str()))
{
//failed to save as file
return -1;
}
return 0;
}
bool CDSPSettings::SaveSettingsData()
{
TiXmlDocument xmlDoc;
TiXmlElement xmlRootElement("demo");
TiXmlNode *pRoot = xmlDoc.InsertEndChild(xmlRootElement);
if (pRoot == NULL)
return false;
TiXmlElement xmlChannelsSetting("channels");
TiXmlNode* pChannelsNode = pRoot->InsertEndChild(xmlChannelsSetting);
if (pChannelsNode)
{
for (int i = 0; i < AE_DSP_CH_MAX; i++)
{
TiXmlElement xmlSetting("channel");
TiXmlNode* pChannelNode = pChannelsNode->InsertEndChild(xmlSetting);
if (pChannelNode)
{
XMLUtils::SetInt(pChannelNode, "number", i);
XMLUtils::SetString(pChannelNode, "name", m_Settings.m_channels[i].strName.c_str());
XMLUtils::SetInt(pChannelNode, "volume", m_Settings.m_channels[i].iVolumeCorrection);
XMLUtils::SetInt(pChannelNode, "distance", m_Settings.m_channels[i].iDistanceCorrection);
}
}
}
if (!xmlDoc.SaveFile(GetSettingsFile()))
{
XBMC->Log(LOG_ERROR, "failed to write speaker settings data");
return false;
}
return true;
}
bool CDSPSettings::SaveSettingsData()
{
TiXmlDocument xmlDoc;
TiXmlElement xmlRootElement("freesurround");
TiXmlNode *pRoot = xmlDoc.InsertEndChild(xmlRootElement);
if (pRoot == NULL)
return false;
TiXmlElement xmlCS2Setting("settings");
TiXmlNode* pNode = pRoot->InsertEndChild(xmlCS2Setting);
if (pNode)
{
XMLUtils::SetFloat(pNode, "inputgain", m_Settings.fInputGain);
XMLUtils::SetFloat(pNode, "circularwrap", m_Settings.fCircularWrap);
XMLUtils::SetFloat(pNode, "shift", m_Settings.fShift);
XMLUtils::SetFloat(pNode, "depth", m_Settings.fDepth);
XMLUtils::SetFloat(pNode, "centerimage", m_Settings.fCenterImage);
XMLUtils::SetFloat(pNode, "focus", m_Settings.fFocus);
XMLUtils::SetFloat(pNode, "frontseparation", m_Settings.fFrontSeparation);
XMLUtils::SetFloat(pNode, "rearseparation", m_Settings.fRearSeparation);
XMLUtils::SetBoolean(pNode, "bassredirection", m_Settings.bLFE);
XMLUtils::SetFloat(pNode, "lowcutoff", m_Settings.fLowCutoff);
XMLUtils::SetFloat(pNode, "highcutoff", m_Settings.fHighCutoff);
}
if (!xmlDoc.SaveFile(GetSettingsFile()))
{
KODI->Log(LOG_ERROR, "failed to write circle surround 2 settings data");
return false;
}
return true;
}
XnStatus loadLicensesFile(TiXmlDocument& doc)
{
XnStatus nRetVal = XN_STATUS_OK;
XnChar strFileName[XN_FILE_MAX_PATH];
nRetVal = resolveLicensesFile(strFileName, XN_FILE_MAX_PATH);
XN_IS_STATUS_OK(nRetVal);
XnBool bDoesExist = FALSE;
nRetVal = xnOSDoesFileExist(strFileName, &bDoesExist);
XN_IS_STATUS_OK(nRetVal);
if (bDoesExist)
{
nRetVal = xnXmlLoadDocument(doc, strFileName);
XN_IS_STATUS_OK(nRetVal);
}
else
{
TiXmlElement root(XN_XML_LICENSES_ROOT);
doc.InsertEndChild(root);
doc.SaveFile(strFileName);
}
return (XN_STATUS_OK);
}
// Opens the specified XML file if it exists or creates a new one otherwise.
// Returns 0 on error.
TiXmlElement* GetXmlFile(wxFileName file)
{
if (wxFileExists(file.GetFullPath()) && file.GetSize() > 0)
{
// File does exist, open it
TiXmlDocument* pXmlDocument = new TiXmlDocument();
pXmlDocument->SetCondenseWhiteSpace(false);
if (!pXmlDocument->LoadFile(file.GetFullPath().mb_str()))
{
delete pXmlDocument;
return 0;
}
if (!pXmlDocument->FirstChildElement("FileZilla3"))
{
delete pXmlDocument;
return 0;
}
TiXmlElement* pElement = pXmlDocument->FirstChildElement("FileZilla3");
if (!pElement)
{
delete pXmlDocument;
return 0;
}
else
return pElement;
}
else
{
// File does not exist, create new XML document
TiXmlDocument* pXmlDocument = new TiXmlDocument();
pXmlDocument->SetCondenseWhiteSpace(false);
pXmlDocument->InsertEndChild(TiXmlDeclaration("1.0", "UTF-8", "yes"));
pXmlDocument->InsertEndChild(TiXmlElement("FileZilla3"));
if (!pXmlDocument->SaveFile(file.GetFullPath().mb_str()))
{
delete pXmlDocument;
return 0;
}
return pXmlDocument->FirstChildElement("FileZilla3");
}
}
bool Project::write(ProgressFeedback* feedback)
{
String pathname(mPath);
pathname += PATHSEP;
pathname += mName;
pathname += ".project";
TiXmlDocument doc;
TiXmlDeclaration decl("1.0", "", "");
doc.InsertEndChild(decl);
TiXmlElement project("project");
std::stringstream ss;
ss << mVersion;
std::string str(ss.str());
project.SetAttribute("version", str.c_str());
ss.str("");
ss << mPackageManagers.size();
str.assign(ss.str());
project.SetAttribute("package_count", str.c_str());
String packagePath(mPath);
packagePath += "/packages/";
for (PackageManagers::iterator it = mPackageManagers.begin(); it != mPackageManagers.end(); ++it) {
PackageManager* pkgMgr = *it;
TiXmlElement package("package");
String name(pkgMgr->metadata()->getName());
package.SetAttribute("name", name);
name = pkgMgr->packageFilename();
package.SetAttribute("filename", name);
project.InsertEndChild(package);
// write out the actual package file
pkgMgr->save(packagePath);
}
doc.InsertEndChild(project);
doc.SaveFile(pathname);
return true;
}
bool CSmartPlaylist::Save(const CStdString &path)
{
TiXmlDocument doc;
TiXmlDeclaration decl("1.0", "UTF-8", "yes");
doc.InsertEndChild(decl);
TiXmlElement xmlRootElement("smartplaylist");
xmlRootElement.SetAttribute("type",m_playlistType.c_str());
TiXmlNode *pRoot = doc.InsertEndChild(xmlRootElement);
if (!pRoot) return false;
// add the <name> tag
TiXmlText name(m_playlistName.c_str());
TiXmlElement nodeName("name");
nodeName.InsertEndChild(name);
pRoot->InsertEndChild(nodeName);
// add the <match> tag
TiXmlText match(m_matchAllRules ? "all" : "one");
TiXmlElement nodeMatch("match");
nodeMatch.InsertEndChild(match);
pRoot->InsertEndChild(nodeMatch);
// add <rule> tags
for (vector<CSmartPlaylistRule>::iterator it = m_playlistRules.begin(); it != m_playlistRules.end(); ++it)
{
pRoot->InsertEndChild((*it).GetAsElement());
}
// add <limit> tag
if (m_limit)
{
CStdString limitFormat;
limitFormat.Format("%i", m_limit);
TiXmlText limit(limitFormat);
TiXmlElement nodeLimit("limit");
nodeLimit.InsertEndChild(limit);
pRoot->InsertEndChild(nodeLimit);
}
// add <order> tag
if (m_orderField != CSmartPlaylistRule::FIELD_NONE)
{
TiXmlText order(CSmartPlaylistRule::TranslateField(m_orderField).c_str());
TiXmlElement nodeOrder("order");
nodeOrder.SetAttribute("direction", m_orderAscending ? "ascending" : "descending");
nodeOrder.InsertEndChild(order);
pRoot->InsertEndChild(nodeOrder);
}
return doc.SaveFile(path);
}
bool CScrobbler::SaveJournal()
{
CSingleLock lock(m_queueLock);
if (m_vecSubmissionQueue.size() == 0)
{
if (XFILE::CFile::Exists(GetJournalFileName()))
XFILE::CFile::Delete(GetJournalFileName());
return true;
}
CStdString strJournalVersion;
TiXmlDocument xmlDoc;
TiXmlDeclaration decl("1.0", "utf-8", "yes");
TiXmlElement xmlRootElement("asjournal");
xmlDoc.InsertEndChild(decl);
strJournalVersion.Format("%d", SCROBBLER_JOURNAL_VERSION);
xmlRootElement.SetAttribute("version", strJournalVersion.c_str());
TiXmlNode *pRoot = xmlDoc.InsertEndChild(xmlRootElement);
if (!pRoot)
return false;
int i = 0;
SCROBBLERJOURNALITERATOR it = m_vecSubmissionQueue.begin();
for (; it != m_vecSubmissionQueue.end(); it++, i++)
{
TiXmlElement entryNode("entry");
TiXmlNode *pNode = pRoot->InsertEndChild(entryNode);
if (!pNode)
return false;
XMLUtils::SetString(pNode, "artist", it->strArtist);
XMLUtils::SetString(pNode, "album", it->strAlbum);
XMLUtils::SetString(pNode, "title", it->strTitle);
XMLUtils::SetString(pNode, "length", it->strLength);
XMLUtils::SetString(pNode, "starttime", it->strStartTime);
XMLUtils::SetString(pNode, "musicbrainzid", it->strMusicBrainzID);
XMLUtils::SetString(pNode, "tracknum", it->strTrackNum);
XMLUtils::SetString(pNode, "source", it->strSource);
XMLUtils::SetString(pNode, "rating", it->strRating);
}
lock.Leave();
CStdString FileName = GetJournalFileName();
CLog::Log(LOGDEBUG, "%s: Journal with %d entries saved to %s",
m_strLogPrefix.c_str(), i, FileName.c_str());
return xmlDoc.SaveFile(FileName);
}
void object::test <1>()
{
TiXmlDocument doc;
TiXmlDeclaration dcl("1.0", std::string(), "no");
doc.InsertEndChild(dcl);
std::ostringstream os;
os<<doc;
tut::ensure_equals(os.str(), std::string("<?xml version=\"1.0\" standalone=\"no\" ?>"));
}
void SettingsStorage::SaveFile(const String& path) const {
TiXmlDocument doc;
TiXmlElement root("settings");
Save(&root);
doc.InsertEndChild(root);
doc.SaveFile(Mbs(path).c_str());
}
bool Project::Save(const _TCHAR* filename)
{
TiXmlDocument doc;
USES_CONVERSION;
TiXmlNode* pRoot = doc.InsertEndChild(TiXmlElement("project"));
TiXmlElement scene("scene");
if(m_pScene)
{
scene.InsertEndChild(TiXmlText(m_pScene->GetFileName().string().c_str()));
}
pRoot->InsertEndChild(scene);
TiXmlElement clearClr("clear_color");
char szBuffer[1024];
sprintf_s(szBuffer,1024, "%.3f,%.3f,%.3f,%.3f", m_clearClr.r, m_clearClr.g, m_clearClr.b, m_clearClr.a);
clearClr.InsertEndChild(TiXmlText(szBuffer));
pRoot->InsertEndChild(clearClr);
TiXmlElement camera("camera");
math::Vector3 eye = m_pRenderer->GetCamera()->GetEyePos();
math::Vector3 focus = m_pRenderer->GetCamera()->GetFocusPos();
TiXmlElement eEye("eye_pos");
sprintf_s(szBuffer,1024, "%.3f,%.3f,%.3f", eye.z, eye.y, eye.z);
eEye.InsertEndChild(TiXmlText(szBuffer));
TiXmlElement eFocus("focus_pos");
sprintf_s(szBuffer,1024, "%.3f,%.3f,%.3f", focus.z, focus.y, focus.z);
eFocus.InsertEndChild(TiXmlText(szBuffer));
camera.InsertEndChild(eEye);
camera.InsertEndChild(eFocus);
pRoot->InsertEndChild(camera);
if(false == doc.SaveFile(W2A(filename)))
{
return false;
}
m_filePath = filename;
RestoreCurrentDirectory();
return true;
}
status_t Converter::ConvertPDoc2FreeMind()
{
status_t err = B_OK;
BMessage *inMessage = new BMessage();
BMessage *tmpMessage = new BMessage();
void *id = NULL;
allConnections = new BMessage();
selected = new BMessage();
allNodes = new BMessage();
err = inMessage->Unflatten(in);
if (err == B_OK)
{
inMessage->FindMessage("PDocument::allConnections",allConnections);
inMessage->FindMessage("PDocument::selected",selected);
inMessage->FindMessage("PDocument::allNodes",allNodes);
int32 i = 0;
while(allNodes->FindMessage("node",i,tmpMessage)==B_OK)
{
tmpMessage->FindPointer("this",&id);
nodes[(int32)id]=tmpMessage;
tmpMessage = new BMessage();
- i++;
}
i = 0;
while(allConnections->FindMessage("node",i,tmpMessage)==B_OK)
{
tmpMessage->FindPointer("this",&id);
connections[(int32)id]=tmpMessage;
tmpMessage = new BMessage();
i++;
}
BMessage *node= GuessStartNode();
TiXmlDocument doc;
TiXmlElement freeMap("map");
freeMap.SetAttribute("version","0.9.0");
freeMap.SetAttribute("background_color","#ffffff");
TiXmlComment comment("this File was gernerated by ProjectConceptor! - To view this file, download free mind mapping software FreeMind from http://freemind.sourceforge.net");
freeMap.InsertEndChild(comment);
tmpMessage=GuessStartNode();
// tmpMessage = nodes.begin()->second;
freeMap.InsertEndChild(ProcessNode(tmpMessage));
doc.InsertEndChild(freeMap);
TiXmlPrinter printer;
// printer.SetStreamPrinting();
// printer.SetLineBreak("\n");
// printer.SetIndent("\t");
doc.Accept( &printer );
out->Write(printer.CStr(),strlen(printer.CStr()));
}
return err;
}
