bool CSmartPlaylist::Save(const CStdString &path)
{
CXBMCTinyXML 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)
it->Save(pRoot);
// 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 != SortByNone)
{
TiXmlText order(CSmartPlaylistRule::TranslateOrder(m_orderField).c_str());
TiXmlElement nodeOrder("order");
nodeOrder.SetAttribute("direction", m_orderAscending ? "ascending" : "descending");
nodeOrder.InsertEndChild(order);
pRoot->InsertEndChild(nodeOrder);
}
return doc.SaveFile(path);
}
void CWakeOnAccess::SaveToXML()
{
CXBMCTinyXML xmlDoc;
TiXmlElement xmlRootElement("onaccesswakeup");
TiXmlNode *pRoot = xmlDoc.InsertEndChild(xmlRootElement);
if (!pRoot) return;
XMLUtils::SetInt(pRoot, "netinittimeout", m_netinit_sec);
XMLUtils::SetInt(pRoot, "netsettletime", m_netsettle_ms);
for (EntriesVector::const_iterator i = m_entries.begin(); i != m_entries.end(); ++i)
{
TiXmlElement xmlSetting("wakeup");
TiXmlNode* pWakeUpNode = pRoot->InsertEndChild(xmlSetting);
if (pWakeUpNode)
{
XMLUtils::SetString(pWakeUpNode, "host", i->host);
XMLUtils::SetString(pWakeUpNode, "mac", i->mac);
XMLUtils::SetInt(pWakeUpNode, "pingport", i->ping_port);
XMLUtils::SetInt(pWakeUpNode, "pingmode", i->ping_mode);
XMLUtils::SetInt(pWakeUpNode, "timeout", GetTotalSeconds(i->timeout));
XMLUtils::SetInt(pWakeUpNode, "waitonline", i->wait_online1_sec);
XMLUtils::SetInt(pWakeUpNode, "waitonline2", i->wait_online2_sec);
XMLUtils::SetInt(pWakeUpNode, "waitservices", i->wait_services_sec);
}
}
xmlDoc.SaveFile(GetSettingFile());
}
bool CFavouritesDirectory::Save(const CFileItemList &items)
{
std::string favourites;
CXBMCTinyXML doc;
TiXmlElement xmlRootElement("favourites");
TiXmlNode *rootNode = doc.InsertEndChild(xmlRootElement);
if (!rootNode) return false;
for (int i = 0; i < items.Size(); i++)
{
const CFileItemPtr item = items[i];
TiXmlElement favNode("favourite");
favNode.SetAttribute("name", item->GetLabel().c_str());
if (item->HasArt("thumb"))
favNode.SetAttribute("thumb", item->GetArt("thumb").c_str());
TiXmlText execute(item->GetPath());
favNode.InsertEndChild(execute);
rootNode->InsertEndChild(favNode);
}
favourites = URIUtils::AddFileToFolder(CProfilesManager::GetInstance().GetProfileUserDataFolder(), "favourites.xml");
bool bRet = doc.SaveFile(favourites);
if (bRet)
ANNOUNCEMENT::CAnnouncementManager::GetInstance().Announce(ANNOUNCEMENT::GUI, "xbmc", "OnFavouritesUpdated");
return bRet;
}
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;
CXBMCTinyXML 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);
}
bool CSettingsBase::SaveValuesToXml(CXBMCTinyXML& xml) const
{
TiXmlElement rootElement(SETTINGS_XML_ROOT);
TiXmlNode* xmlRoot = xml.InsertEndChild(rootElement);
if (xmlRoot == nullptr)
return false;
return m_settingsManager->Save(xmlRoot);
}
void CPeripheral::PersistSettings(bool bExiting /* = false */)
{
CXBMCTinyXML doc;
TiXmlElement node("settings");
doc.InsertEndChild(node);
for (std::map<std::string, PeripheralDeviceSetting>::const_iterator itr = m_settings.begin(); itr != m_settings.end(); ++itr)
{
TiXmlElement nodeSetting("setting");
nodeSetting.SetAttribute("id", itr->first.c_str());
std::string strValue;
switch ((*itr).second.m_setting->GetType())
{
case SettingType::String:
{
std::shared_ptr<CSettingString> stringSetting = std::static_pointer_cast<CSettingString>((*itr).second.m_setting);
if (stringSetting)
strValue = stringSetting->GetValue();
}
break;
case SettingType::Integer:
{
std::shared_ptr<CSettingInt> intSetting = std::static_pointer_cast<CSettingInt>((*itr).second.m_setting);
if (intSetting)
strValue = StringUtils::Format("%d", intSetting->GetValue());
}
break;
case SettingType::Number:
{
std::shared_ptr<CSettingNumber> floatSetting = std::static_pointer_cast<CSettingNumber>((*itr).second.m_setting);
if (floatSetting)
strValue = StringUtils::Format("%.2f", floatSetting->GetValue());
}
break;
case SettingType::Boolean:
{
std::shared_ptr<CSettingBool> boolSetting = std::static_pointer_cast<CSettingBool>((*itr).second.m_setting);
if (boolSetting)
strValue = StringUtils::Format("%d", boolSetting->GetValue() ? 1:0);
}
break;
default:
break;
}
nodeSetting.SetAttribute("value", strValue.c_str());
doc.RootElement()->InsertEndChild(nodeSetting);
}
doc.SaveFile(m_strSettingsFile);
if (!bExiting)
{
for (std::set<std::string>::const_iterator it = m_changedSettings.begin(); it != m_changedSettings.end(); ++it)
OnSettingChanged(*it);
}
m_changedSettings.clear();
}
void CPeripheral::PersistSettings(bool bExiting /* = false */)
{
CXBMCTinyXML doc;
TiXmlElement node("settings");
doc.InsertEndChild(node);
for (map<CStdString, CSetting *>::const_iterator itr = m_settings.begin(); itr != m_settings.end(); itr++)
{
TiXmlElement nodeSetting("setting");
nodeSetting.SetAttribute("id", itr->first.c_str());
CStdString strValue;
switch ((*itr).second->GetType())
{
case SettingTypeString:
{
CSettingString *stringSetting = (CSettingString *) (*itr).second;
if (stringSetting)
strValue = stringSetting->GetValue();
}
break;
case SettingTypeInteger:
{
CSettingInt *intSetting = (CSettingInt *) (*itr).second;
if (intSetting)
strValue = StringUtils::Format("%d", intSetting->GetValue());
}
break;
case SettingTypeNumber:
{
CSettingNumber *floatSetting = (CSettingNumber *) (*itr).second;
if (floatSetting)
strValue = StringUtils::Format("%.2f", floatSetting->GetValue());
}
break;
case SettingTypeBool:
{
CSettingBool *boolSetting = (CSettingBool *) (*itr).second;
if (boolSetting)
strValue = StringUtils::Format("%d", boolSetting->GetValue() ? 1:0);
}
break;
default:
break;
}
nodeSetting.SetAttribute("value", strValue.c_str());
doc.RootElement()->InsertEndChild(nodeSetting);
}
doc.SaveFile(m_strSettingsFile);
if (!bExiting)
{
for (set<CStdString>::const_iterator it = m_changedSettings.begin(); it != m_changedSettings.end(); it++)
OnSettingChanged(*it);
}
m_changedSettings.clear();
}
bool CSettings::Save(const std::string &file)
{
CXBMCTinyXML xmlDoc;
TiXmlElement rootElement(SETTINGS_XML_ROOT);
TiXmlNode *root = xmlDoc.InsertEndChild(rootElement);
if (root == NULL)
return false;
if (!m_settingsManager->Save(root))
return false;
return xmlDoc.SaveFile(file);
}
void CAddon::SettingsToXML(CXBMCTinyXML &doc) const
{
TiXmlElement node("settings");
doc.InsertEndChild(node);
for (map<std::string, std::string>::const_iterator i = m_settings.begin(); i != m_settings.end(); ++i)
{
TiXmlElement nodeSetting("setting");
nodeSetting.SetAttribute("id", i->first.c_str());
nodeSetting.SetAttribute("value", i->second.c_str());
doc.RootElement()->InsertEndChild(nodeSetting);
}
doc.SaveFile(m_userSettingsPath);
}
bool CSettings::SaveProfiles(const CStdString& profilesFile) const
{
CXBMCTinyXML xmlDoc;
TiXmlElement xmlRootElement("profiles");
TiXmlNode *pRoot = xmlDoc.InsertEndChild(xmlRootElement);
if (!pRoot) return false;
XMLUtils::SetInt(pRoot,"lastloaded", m_currentProfile);
XMLUtils::SetBoolean(pRoot,"useloginscreen",m_usingLoginScreen);
XMLUtils::SetInt(pRoot,"nextIdProfile",m_nextIdProfile);
for (unsigned int i = 0; i < m_vecProfiles.size(); ++i)
m_vecProfiles[i].Save(pRoot);
// save the file
return xmlDoc.SaveFile(profilesFile);
}
bool CGUIControlProfiler::SaveResults(void)
{
if (m_strOutputFile.IsEmpty())
return false;
CXBMCTinyXML doc;
TiXmlDeclaration decl("1.0", "", "yes");
doc.InsertEndChild(decl);
TiXmlElement *root = new TiXmlElement("guicontrolprofiler");
CStdString str;
str.Format("%d", m_iFrameCount);
root->SetAttribute("framecount", str.c_str());
root->SetAttribute("timeunit", "ms");
doc.LinkEndChild(root);
m_ItemHead.SaveToXML(root);
return doc.SaveFile(m_strOutputFile);
}
bool CUPnPSettings::Save(const std::string &file) const
{
CSingleLock lock(m_critical);
CXBMCTinyXML doc;
TiXmlElement xmlRootElement(XML_UPNP);
TiXmlNode *pRoot = doc.InsertEndChild(xmlRootElement);
if (pRoot == NULL)
return false;
XMLUtils::SetString(pRoot, XML_SERVER_UUID, m_serverUUID);
XMLUtils::SetInt(pRoot, XML_SERVER_PORT, m_serverPort);
XMLUtils::SetInt(pRoot, XML_MAX_ITEMS, m_maxReturnedItems);
XMLUtils::SetString(pRoot, XML_RENDERER_UUID, m_rendererUUID);
XMLUtils::SetInt(pRoot, XML_RENDERER_PORT, m_rendererPort);
// save the file
return doc.SaveFile(file);
}
bool CMediaSourceSettings::Save(const std::string &file) const
{
//! @todo Should we be specifying utf8 here??
CXBMCTinyXML doc;
TiXmlElement xmlRootElement(XML_SOURCES);
TiXmlNode *pRoot = doc.InsertEndChild(xmlRootElement);
if (pRoot == NULL)
return false;
// ok, now run through and save each sources section
SetSources(pRoot, "programs", m_programSources, m_defaultProgramSource);
SetSources(pRoot, "video", m_videoSources, "");
SetSources(pRoot, "music", m_musicSources, m_defaultMusicSource);
SetSources(pRoot, "pictures", m_pictureSources, m_defaultPictureSource);
SetSources(pRoot, "files", m_fileSources, m_defaultFileSource);
CWakeOnAccess::GetInstance().QueueMACDiscoveryForAllRemotes();
return doc.SaveFile(file);
}
void Control::setAnimations(const std::vector< Tuple<String,String> >& eventAttr)
{
CXBMCTinyXML xmlDoc;
TiXmlElement xmlRootElement("control");
TiXmlNode *pRoot = xmlDoc.InsertEndChild(xmlRootElement);
if (!pRoot)
throw WindowException("TiXmlNode creation error");
std::vector<CAnimation> animations;
for (unsigned int anim = 0; anim < eventAttr.size(); anim++)
{
const Tuple<String,String>& pTuple = eventAttr[anim];
if (pTuple.GetNumValuesSet() != 2)
throw WindowException("Error unpacking tuple found in list");
const String& cEvent = pTuple.first();
const String& cAttr = pTuple.second();
TiXmlElement pNode("animation");
std::vector<std::string> attrs = StringUtils::Split(cAttr, " ");
for (std::vector<std::string>::const_iterator i = attrs.begin(); i != attrs.end(); ++i)
{
std::vector<std::string> attrs2 = StringUtils::Split(*i, "=");
if (attrs2.size() == 2)
pNode.SetAttribute(attrs2[0], attrs2[1]);
}
TiXmlText value(cEvent.c_str());
pNode.InsertEndChild(value);
pRoot->InsertEndChild(pNode);
}
const CRect animRect((float)dwPosX, (float)dwPosY, (float)dwPosX + dwWidth, (float)dwPosY + dwHeight);
LOCKGUI;
if (pGUIControl)
{
CGUIControlFactory::GetAnimations(pRoot, animRect, iParentId, animations);
pGUIControl->SetAnimations(animations);
}
}
bool CMediaSourceSettings::Save(const std::string &file) const
{
if (!CFile::Exists(file))
return false;
// TODO: Should we be specifying utf8 here??
CXBMCTinyXML doc;
TiXmlElement xmlRootElement(XML_SOURCES);
TiXmlNode *pRoot = doc.InsertEndChild(xmlRootElement);
if (pRoot == NULL)
return false;
// ok, now run through and save each sources section
SetSources(pRoot, "programs", m_programSources, m_defaultProgramSource);
SetSources(pRoot, "video", m_videoSources, "");
SetSources(pRoot, "music", m_musicSources, m_defaultMusicSource);
SetSources(pRoot, "pictures", m_pictureSources, m_defaultPictureSource);
SetSources(pRoot, "files", m_fileSources, m_defaultFileSource);
return doc.SaveFile(file);
}
bool CProfilesManager::Save(const std::string &file) const
{
CSingleLock lock(m_critical);
CXBMCTinyXML xmlDoc;
TiXmlElement xmlRootElement(XML_PROFILES);
TiXmlNode *pRoot = xmlDoc.InsertEndChild(xmlRootElement);
if (pRoot == NULL)
return false;
XMLUtils::SetInt(pRoot, XML_LAST_LOADED, m_currentProfile);
XMLUtils::SetBoolean(pRoot, XML_LOGIN_SCREEN, m_usingLoginScreen);
XMLUtils::SetInt(pRoot, XML_AUTO_LOGIN, m_autoLoginProfile);
XMLUtils::SetInt(pRoot, XML_NEXTID, m_nextProfileId);
for (vector<CProfile>::const_iterator profile = m_profiles.begin(); profile != m_profiles.end(); profile++)
profile->Save(pRoot);
// save the file
return xmlDoc.SaveFile(file);
}
void CPasswordManager::Save() const
{
if (!m_permanentCache.size())
return;
CXBMCTinyXML doc;
TiXmlElement rootElement("passwords");
TiXmlNode *root = doc.InsertEndChild(rootElement);
if (!root)
return;
for (map<CStdString, CStdString>::const_iterator i = m_permanentCache.begin(); i != m_permanentCache.end(); ++i)
{
TiXmlElement pathElement("path");
TiXmlNode *path = root->InsertEndChild(pathElement);
XMLUtils::SetPath(path, "from", i->first);
XMLUtils::SetPath(path, "to", i->second);
}
doc.SaveFile(g_settings.GetUserDataItem("passwords.xml"));
}
bool CMediaManager::SaveSources()
{
CXBMCTinyXML xmlDoc;
TiXmlElement xmlRootElement("mediasources");
TiXmlNode *pRoot = xmlDoc.InsertEndChild(xmlRootElement);
if (!pRoot) return false;
TiXmlElement networkNode("network");
TiXmlNode *pNetworkNode = pRoot->InsertEndChild(networkNode);
if (pNetworkNode)
{
for (std::vector<CNetworkLocation>::iterator it = m_locations.begin(); it != m_locations.end(); ++it)
{
TiXmlElement locationNode("location");
locationNode.SetAttribute("id", (*it).id);
TiXmlText value((*it).path);
locationNode.InsertEndChild(value);
pNetworkNode->InsertEndChild(locationNode);
}
}
return xmlDoc.SaveFile(MEDIA_SOURCES_XML);
}
bool CProfileManager::Save() const
{
const std::string file = PROFILES_FILE;
CSingleLock lock(m_critical);
CXBMCTinyXML xmlDoc;
TiXmlElement xmlRootElement(XML_PROFILES);
TiXmlNode *pRoot = xmlDoc.InsertEndChild(xmlRootElement);
if (pRoot == nullptr)
return false;
XMLUtils::SetInt(pRoot, XML_LAST_LOADED, m_currentProfile);
XMLUtils::SetBoolean(pRoot, XML_LOGIN_SCREEN, m_usingLoginScreen);
XMLUtils::SetInt(pRoot, XML_AUTO_LOGIN, m_autoLoginProfile);
XMLUtils::SetInt(pRoot, XML_NEXTID, m_nextProfileId);
for (const auto& profile : m_profiles)
profile.Save(pRoot);
// save the file
return xmlDoc.SaveFile(file);
}
bool CFavourites::Save(const CFileItemList &items)
{
CStdString favourites;
CXBMCTinyXML doc;
TiXmlElement xmlRootElement("favourites");
TiXmlNode *rootNode = doc.InsertEndChild(xmlRootElement);
if (!rootNode) return false;
for (int i = 0; i < items.Size(); i++)
{
const CFileItemPtr item = items[i];
TiXmlElement favNode("favourite");
favNode.SetAttribute("name", item->GetLabel().c_str());
if (item->HasThumbnail())
favNode.SetAttribute("thumb", item->GetThumbnailImage().c_str());
TiXmlText execute(item->GetPath());
favNode.InsertEndChild(execute);
rootNode->InsertEndChild(favNode);
}
URIUtils::AddFileToFolder(g_settings.GetProfileUserDataFolder(), "favourites.xml", favourites);
return doc.SaveFile(favourites);
}
bool CFavouritesService::Persist()
{
CXBMCTinyXML doc;
TiXmlElement xmlRootElement("favourites");
TiXmlNode *rootNode = doc.InsertEndChild(xmlRootElement);
if (!rootNode)
return false;
for (const auto& item : m_favourites)
{
TiXmlElement favNode("favourite");
favNode.SetAttribute("name", item->GetLabel().c_str());
if (item->HasArt("thumb"))
favNode.SetAttribute("thumb", item->GetArt("thumb").c_str());
const CURL url(item->GetPath());
TiXmlText execute(CURL::Decode(url.GetHostName()));
favNode.InsertEndChild(execute);
rootNode->InsertEndChild(favNode);
}
auto path = URIUtils::AddFileToFolder(m_userDataFolder, "favourites.xml");
return doc.SaveFile(path);
}
PyObject* Control_SetAnimations(Control* self, PyObject* args)
{
PyObject *pList = NULL;
if (!PyArg_ParseTuple(args, (char*)"O", &pList) || pList == NULL || !PyObject_TypeCheck(pList, &PyList_Type))
{
PyErr_SetString(PyExc_TypeError, "Object should be of type List");
return NULL;
}
CXBMCTinyXML xmlDoc;
TiXmlElement xmlRootElement("control");
TiXmlNode *pRoot = xmlDoc.InsertEndChild(xmlRootElement);
if (!pRoot)
{
PyErr_SetString(PyExc_TypeError, "TiXmlNode creation error");
return NULL;
}
vector<CAnimation> animations;
for (int anim = 0; anim < PyList_Size(pList); anim++)
{
PyObject *pTuple = NULL;
char *cEvent = NULL;
char *cAttr = NULL;
pTuple = PyList_GetItem(pList, anim);
if (pTuple == NULL || !PyObject_TypeCheck(pTuple, &PyTuple_Type))
{
PyErr_SetString(PyExc_TypeError, "List must only contain tuples");
return NULL;
}
if (!PyArg_ParseTuple(pTuple, (char*)"ss", &cEvent, &cAttr))
{
PyErr_SetString(PyExc_TypeError, "Error unpacking tuple found in list");
return NULL;
}
if (NULL != cAttr && NULL != cEvent)
{
TiXmlElement pNode("animation");
CStdStringArray attrs;
StringUtils::SplitString(cAttr, " ", attrs);
for (unsigned int i = 0; i < attrs.size(); i++)
{
CStdStringArray attrs2;
StringUtils::SplitString(attrs[i], "=", attrs2);
if (attrs2.size() == 2)
pNode.SetAttribute(attrs2[0], attrs2[1]);
}
TiXmlText value(cEvent);
pNode.InsertEndChild(value);
pRoot->InsertEndChild(pNode);
}
}
//bool ret = xmlDoc.SaveFile("special://profile/test.txt");
const CRect animRect((float)self->dwPosX, (float)self->dwPosY, (float)self->dwPosX + self->dwWidth, (float)self->dwPosY + self->dwHeight);
PyXBMCGUILock();
if (self->pGUIControl)
{
CGUIControlFactory::GetAnimations(pRoot, animRect, self->iParentId, animations);
self->pGUIControl->SetAnimations(animations);
}
PyXBMCGUIUnlock();
Py_INCREF(Py_None);
return Py_None;
}
bool CSettings::SaveSettings(const CStdString& strSettingsFile, CGUISettings *localSettings /* = NULL */) const
{
CXBMCTinyXML xmlDoc;
TiXmlElement xmlRootElement("settings");
TiXmlNode *pRoot = xmlDoc.InsertEndChild(xmlRootElement);
if (!pRoot) return false;
// write our tags one by one - just a big list for now (can be flashed up later)
if (!OnSettingsSaving())
return false;
// mymusic settings
TiXmlElement musicNode("mymusic");
TiXmlNode *pNode = pRoot->InsertEndChild(musicNode);
if (!pNode) return false;
{
TiXmlElement childNode("playlist");
TiXmlNode *pChild = pNode->InsertEndChild(childNode);
if (!pChild) return false;
XMLUtils::SetBoolean(pChild, "repeat", m_bMyMusicPlaylistRepeat);
XMLUtils::SetBoolean(pChild, "shuffle", m_bMyMusicPlaylistShuffle);
}
XMLUtils::SetInt(pNode, "needsupdate", m_musicNeedsUpdate);
XMLUtils::SetInt(pNode, "startwindow", m_iMyMusicStartWindow);
XMLUtils::SetBoolean(pNode, "songinfoinvis", m_bMyMusicSongInfoInVis);
XMLUtils::SetBoolean(pNode, "songthumbinvis", m_bMyMusicSongThumbInVis);
XMLUtils::SetPath(pNode, "defaultlibview", m_defaultMusicLibSource);
// myvideos settings
TiXmlElement videosNode("myvideos");
pNode = pRoot->InsertEndChild(videosNode);
if (!pNode) return false;
XMLUtils::SetInt(pNode, "startwindow", m_iVideoStartWindow);
XMLUtils::SetBoolean(pNode, "stackvideos", m_videoStacking);
XMLUtils::SetInt(pNode, "needsupdate", m_videoNeedsUpdate);
XMLUtils::SetBoolean(pNode, "flatten", m_bMyVideoNavFlatten);
{ // playlist window
TiXmlElement childNode("playlist");
TiXmlNode *pChild = pNode->InsertEndChild(childNode);
if (!pChild) return false;
XMLUtils::SetBoolean(pChild, "repeat", m_bMyVideoPlaylistRepeat);
XMLUtils::SetBoolean(pChild, "shuffle", m_bMyVideoPlaylistShuffle);
}
// general settings
TiXmlElement generalNode("general");
pNode = pRoot->InsertEndChild(generalNode);
if (!pNode) return false;
XMLUtils::SetInt(pNode, "systemtotaluptime", m_iSystemTimeTotalUp);
XMLUtils::SetBoolean(pNode, "addonautoupdate", m_bAddonAutoUpdate);
XMLUtils::SetBoolean(pNode, "addonnotifications", m_bAddonNotifications);
XMLUtils::SetBoolean(pNode, "addonforeignfilter", m_bAddonForeignFilter);
// audio settings
TiXmlElement volumeNode("audio");
pNode = pRoot->InsertEndChild(volumeNode);
if (!pNode) return false;
XMLUtils::SetBoolean(pNode, "mute", m_bMute);
XMLUtils::SetFloat(pNode, "fvolumelevel", m_fVolumeLevel);
if (localSettings) // local settings to save
localSettings->SaveXML(pRoot);
else // save the global settings
g_guiSettings.SaveXML(pRoot);
OnSettingsSaved();
if (!Save(pRoot))
return false;
// save the file
return xmlDoc.SaveFile(strSettingsFile);
}