bool CArtist::Save(TiXmlNode *node, const CStdString &tag, const CStdString& strPath)
{
if (!node) return false;
// we start with a <tag> tag
TiXmlElement artistElement(tag.c_str());
TiXmlNode *artist = node->InsertEndChild(artistElement);
if (!artist) return false;
XMLUtils::SetString(artist, "name", strArtist);
XMLUtils::SetString(artist, "musicBrainzArtistID", strMusicBrainzArtistID);
XMLUtils::SetStringArray(artist, "genre", genre);
XMLUtils::SetStringArray(artist, "style", styles);
XMLUtils::SetStringArray(artist, "mood", moods);
XMLUtils::SetStringArray(artist, "yearsactive", yearsActive);
XMLUtils::SetStringArray(artist, "instruments", instruments);
XMLUtils::SetString(artist, "born", strBorn);
XMLUtils::SetString(artist, "formed", strFormed);
XMLUtils::SetString(artist, "biography", strBiography);
XMLUtils::SetString(artist, "died", strDied);
XMLUtils::SetString(artist, "disbanded", strDisbanded);
if (!thumbURL.m_xml.empty())
{
CXBMCTinyXML doc;
doc.Parse(thumbURL.m_xml);
const TiXmlNode* thumb = doc.FirstChild("thumb");
while (thumb)
{
artist->InsertEndChild(*thumb);
thumb = thumb->NextSibling("thumb");
}
}
XMLUtils::SetString(artist, "path", strPath);
if (fanart.m_xml.size())
{
CXBMCTinyXML doc;
doc.Parse(fanart.m_xml);
artist->InsertEndChild(*doc.RootElement());
}
// albums
for (vector< pair<CStdString,CStdString> >::const_iterator it = discography.begin(); it != discography.end(); ++it)
{
// add a <album> tag
TiXmlElement cast("album");
TiXmlNode *node = artist->InsertEndChild(cast);
TiXmlElement title("title");
TiXmlNode *titleNode = node->InsertEndChild(title);
TiXmlText name(it->first);
titleNode->InsertEndChild(name);
TiXmlElement year("year");
TiXmlNode *yearNode = node->InsertEndChild(year);
TiXmlText name2(it->second);
yearNode->InsertEndChild(name2);
}
return true;
}
bool CDisplaySettings::Save(TiXmlNode *settings) const
{
if (settings == NULL)
return false;
CSingleLock lock(m_critical);
TiXmlElement xmlRootElement("resolutions");
TiXmlNode *pRoot = settings->InsertEndChild(xmlRootElement);
if (pRoot == NULL)
return false;
// save calibrations
for (ResolutionInfos::const_iterator it = m_calibrations.begin(); it != m_calibrations.end(); ++it)
{
// Write the resolution tag
TiXmlElement resElement("resolution");
TiXmlNode *pNode = pRoot->InsertEndChild(resElement);
if (pNode == NULL)
return false;
// Now write each of the pieces of information we need...
XMLUtils::SetString(pNode, "description", it->strMode);
XMLUtils::SetInt(pNode, "subtitles", it->iSubtitles);
XMLUtils::SetFloat(pNode, "pixelratio", it->fPixelRatio);
#ifdef HAS_XRANDR
XMLUtils::SetFloat(pNode, "refreshrate", it->fRefreshRate);
XMLUtils::SetString(pNode, "output", it->strOutput);
XMLUtils::SetString(pNode, "xrandrid", it->strId);
#endif
// create the overscan child
TiXmlElement overscanElement("overscan");
TiXmlNode *pOverscanNode = pNode->InsertEndChild(overscanElement);
if (pOverscanNode == NULL)
return false;
XMLUtils::SetInt(pOverscanNode, "left", it->Overscan.left);
XMLUtils::SetInt(pOverscanNode, "top", it->Overscan.top);
XMLUtils::SetInt(pOverscanNode, "right", it->Overscan.right);
XMLUtils::SetInt(pOverscanNode, "bottom", it->Overscan.bottom);
}
return true;
}
bool CSettingsManager::Serialize(TiXmlNode *parent) const
{
if (parent == NULL)
return false;
for (SettingMap::const_iterator it = m_settings.begin(); it != m_settings.end(); ++it)
{
if (it->second.setting->GetType() == SettingTypeAction)
continue;
std::vector<std::string> parts = StringUtils::Split(it->first, ".");
if (parts.size() != 2 || parts.at(0).empty() || parts.at(1).empty())
{
CLog::Log(LOGWARNING, "CSettingsManager: unable to save setting \"%s\"", it->first.c_str());
continue;
}
TiXmlNode *sectionNode = parent->FirstChild(parts.at(0));
if (sectionNode == NULL)
{
TiXmlElement sectionElement(parts.at(0));
sectionNode = parent->InsertEndChild(sectionElement);
if (sectionNode == NULL)
{
CLog::Log(LOGWARNING, "CSettingsManager: unable to write <%s> tag", parts.at(0).c_str());
continue;
}
}
TiXmlElement settingElement(parts.at(1));
TiXmlNode *settingNode = sectionNode->InsertEndChild(settingElement);
if (settingNode == NULL)
{
CLog::Log(LOGWARNING, "CSetting: unable to write <%s> tag in <%s>", parts.at(1).c_str(), parts.at(0).c_str());
continue;
}
TiXmlText value(it->second.setting->ToString());
settingNode->InsertEndChild(value);
}
return true;
}
bool CPluginSettings::LoadFromPlexMediaServer(TiXmlElement* root)
{
m_pluginXmlDoc.Clear();
m_userXmlDoc.Clear();
// This holds the settings.
TiXmlElement xmlSettingsElement("settings");
TiXmlNode* pSettings = m_pluginXmlDoc.InsertEndChild(xmlSettingsElement);
// This holds the values.
TiXmlElement xmlValuesElement("settings");
TiXmlNode* pValues = m_userXmlDoc.InsertEndChild(xmlValuesElement);
TiXmlElement *setting = root->FirstChildElement("Setting");
while (setting)
{
TiXmlElement xmlSetting("setting");
TiXmlElement xmlValueSetting("setting");
// Walk through the attributes.
TiXmlAttribute* attrib = setting->FirstAttribute();
while (attrib)
{
string name = attrib->Name();
string value = attrib->Value();
if (name == "id" || name == "value")
xmlValueSetting.SetAttribute(name, value);
if (name != "value")
xmlSetting.SetAttribute(name, value);
attrib = attrib->Next();
}
pSettings->InsertEndChild(xmlSetting);
pValues->InsertEndChild(xmlValueSetting);
setting = setting->NextSiblingElement("Setting");
}
return true;
}
void XMLUtils::SetString(TiXmlNode* pRootNode, const char *strTag, const CStdString& strValue)
{
TiXmlElement newElement(strTag);
TiXmlNode *pNewNode = pRootNode->InsertEndChild(newElement);
if (pNewNode)
{
TiXmlText value(strValue);
pNewNode->InsertEndChild(value);
}
}
/** Changes the server's technical note
*
* The xml document should be saved after this call.
*
* \param v The new server's technical note
*
*/
void RainbruRPG::Server::xmlServerConf::setTechNote(const std::string& v){
TiXmlText nameNode(v.c_str());
TiXmlNode* childNode = root->FirstChild( "TechnicalNote" );
if (childNode){
childNode->Clear();
childNode->InsertEndChild(nameNode);
}
}
bool LinearParameter::Write2XML(TiXmlNode& root)
{
TiXmlElement para("Parameter");
para.SetAttribute("Type","Linear");
Parameter::Write2XML(para);
para.SetDoubleAttribute("min",dMin);
para.SetDoubleAttribute("max",dMax);
para.SetDoubleAttribute("step",dStep);
root.InsertEndChild(para);
return true;
}
void XMLUtils::SetPath(TiXmlNode* pRootNode, const char *strTag, const CStdString& strValue)
{
TiXmlElement newElement(strTag);
newElement.SetAttribute("pathversion", path_version);
TiXmlNode *pNewNode = pRootNode->InsertEndChild(newElement);
if (pNewNode)
{
TiXmlText value(strValue);
pNewNode->InsertEndChild(value);
}
}
static int _Encode( TiXmlNode *pNode, sqbind::CSqMulti *pData, int bIndexed, int nDepth = 0 )
{_STT();
if ( !pNode || !pData )
return 0;
// For each element
for ( sqbind::CSqMulti::iterator it = pData->list().begin(); it != pData->list().end(); it++ )
{
// Key name?
if ( it->first == oexT( "$" ) )
; // Ignore
else
{
// Is it just an attribute
if ( nDepth && !it->second.size() )
{
((TiXmlElement*)pNode)->SetAttribute( oexStrToMbPtr( it->first.c_str() ), oexStrToMbPtr( it->second.str().c_str() ) );
} // end else if
// Handle nested tag
else
{
TiXmlNode *pItem = oexNULL;
if ( !bIndexed )
{ if ( it->first.length() )
pItem = pNode->InsertEndChild( TiXmlElement( oexStrToMbPtr( it->first.c_str() ) ) );
} // end if
else if ( it->second.isset( oexT( "$" ) ) && it->second[ oexT( "$" ) ].str().length() )
pItem = pNode->InsertEndChild( TiXmlElement( oexStrToMbPtr( it->second[ oexT( "$" ) ].str().c_str() ) ) );
// Did we get an item?
if ( pItem )
{
// Default value?
if ( it->second.str().length() )
pItem->InsertEndChild( TiXmlText( oexStrToMbPtr( it->second.str().c_str() ) ) );
// Encode sub items
_Encode( pItem, &it->second, bIndexed, nDepth + 1 );
} // end if
} // end else if
} // end if
} // end for
return 1;
}
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);
}
}
for (const auto& upnp : m_UPnPServers)
{
TiXmlElement xmlSetting("upnp_map");
TiXmlNode* pUPnPNode = pRoot->InsertEndChild(xmlSetting);
if (pUPnPNode)
{
XMLUtils::SetString(pUPnPNode, "name", upnp.m_name);
XMLUtils::SetString(pUPnPNode, "uuid", upnp.m_uuid);
XMLUtils::SetString(pUPnPNode, "mac", upnp.m_mac);
}
}
xmlDoc.SaveFile(GetSettingFile());
}
bool CArtist::Save(TiXmlNode *node, const CStdString &tag, const CStdString& strPath)
{
if (!node) return false;
// we start with a <tag> tag
TiXmlElement artistElement(tag.c_str());
TiXmlNode *artist = node->InsertEndChild(artistElement);
if (!artist) return false;
XMLUtils::SetString(artist, "name", strArtist);
CStdStringArray array;
StringUtils::SplitString(strGenre, g_advancedSettings.m_musicItemSeparator,array);
for (unsigned int i=0;i<array.size();++i)
XMLUtils::SetString(artist, "genre", array[i]);
array.clear();
StringUtils::SplitString(strStyles, g_advancedSettings.m_musicItemSeparator,array);
for (unsigned int i=0;i<array.size();++i)
XMLUtils::SetString(artist, "style", array[i]);
array.clear();
StringUtils::SplitString(strMoods, g_advancedSettings.m_musicItemSeparator,array);
for (unsigned int i=0;i<array.size();++i)
XMLUtils::SetString(artist, "mood", array[i]);
array.clear();
StringUtils::SplitString(strYearsActive, g_advancedSettings.m_musicItemSeparator,array);
for (unsigned int i=0;i<array.size();++i)
XMLUtils::SetString(artist, "yearsactive", array[i]);
XMLUtils::SetString(artist, "born", strBorn);
XMLUtils::SetString(artist, "formed", strFormed);
XMLUtils::SetString(artist, "instruments", strInstruments);
XMLUtils::SetString(artist, "biography", strBiography);
XMLUtils::SetString(artist, "died", strDied);
XMLUtils::SetString(artist, "disbanded", strDisbanded);
XMLUtils::SetString(artist, "thumbs", thumbURL.m_xml);
XMLUtils::SetString(artist, "path", strPath);
if (fanart.m_xml.size())
{
TiXmlDocument doc;
doc.Parse(fanart.m_xml);
artist->InsertEndChild(*doc.RootElement());
}
// albums
for (vector< pair<CStdString,CStdString> >::const_iterator it = discography.begin(); it != discography.end(); ++it)
{
// add a <album> tag
TiXmlElement cast("album");
TiXmlNode *node = artist->InsertEndChild(cast);
TiXmlElement title("title");
TiXmlNode *titleNode = node->InsertEndChild(title);
TiXmlText name(it->first);
titleNode->InsertEndChild(name);
TiXmlElement year("year");
TiXmlNode *yearNode = node->InsertEndChild(year);
TiXmlText name2(it->second);
yearNode->InsertEndChild(name2);
}
return true;
}
XBool addLeafNode(TiXmlNode &pElmParent, const char* pszNode, bool flag)
{
if (pszNode == NULL) return XFalse;
std::string text("0");
if (flag) text = "1";
TiXmlElement elmNode(pszNode);
TiXmlText elmText(text.c_str());
return !(elmNode.InsertEndChild(elmText) == NULL ||
pElmParent.InsertEndChild(elmNode) == NULL);
//if(elmNode.InsertEndChild(elmText) == NULL) return XFalse;
//if(pElmParent.InsertEndChild(elmNode) == NULL) return XFalse;
//return XTrue;
}
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 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);
}
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);
}
}
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 CViewStateSettings::Save(TiXmlNode *settings) const
{
if (settings == NULL)
return false;
CSingleLock lock(m_critical);
// add the <viewstates> tag
TiXmlElement xmlViewStateElement(XML_VIEWSTATESETTINGS);
TiXmlNode *pViewStateNode = settings->InsertEndChild(xmlViewStateElement);
if (pViewStateNode == NULL)
{
CLog::Log(LOGWARNING, "CViewStateSettings: could not create <viewstates> tag");
return false;
}
for (map<string, CViewState*>::const_iterator viewState = m_viewStates.begin(); viewState != m_viewStates.end(); viewState++)
{
TiXmlElement newElement(viewState->first);
TiXmlNode *pNewNode = pViewStateNode->InsertEndChild(newElement);
if (pNewNode == NULL)
continue;
XMLUtils::SetInt(pNewNode, XML_VIEWMODE, viewState->second->m_viewMode);
XMLUtils::SetInt(pNewNode, XML_SORTMETHOD, (int)viewState->second->m_sortMethod);
XMLUtils::SetInt(pNewNode, XML_SORTORDER, (int)viewState->second->m_sortOrder);
}
TiXmlNode *generalNode = settings->FirstChild(XML_GENERAL);
if (generalNode == NULL)
{
TiXmlElement generalElement(XML_GENERAL);
generalNode = settings->InsertEndChild(generalElement);
if (generalNode == NULL)
return false;
}
XMLUtils::SetInt(generalNode, XML_SETTINGLEVEL, (int)m_settingLevel);
return true;
}
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");
return doc.SaveFile(favourites);
}
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);
}
void CWebBrowserDownloadHandler::ResetHistory()
{
{
std::lock_guard<std::mutex> lock(m_mutex);
m_finishedDownloads.clear();
}
TiXmlDocument xmlDoc;
TiXmlElement xmlRootElement("downloadhistory");
TiXmlNode *pRoot = xmlDoc.InsertEndChild(xmlRootElement);
if (pRoot == nullptr)
return;
TiXmlElement xmlDownloadHistory("histories");
pRoot->InsertEndChild(xmlDownloadHistory);
std::string strSettingsFile = kodi::GetBaseUserPath("download_history.xml");
if (!xmlDoc.SaveFile(strSettingsFile))
{
kodi::Log(ADDON_LOG_ERROR, "failed to write download history data");
return;
}
}
bool CMediaSourceSettings::SetSources(TiXmlNode *root, const char *section, const VECSOURCES &shares, const std::string &defaultPath) const
{
TiXmlElement sectionElement(section);
TiXmlNode *sectionNode = root->InsertEndChild(sectionElement);
if (sectionNode == NULL)
return false;
XMLUtils::SetPath(sectionNode, "default", defaultPath);
for (CIVECSOURCES it = shares.begin(); it != shares.end(); it++)
{
const CMediaSource &share = *it;
if (share.m_ignore)
continue;
TiXmlElement source(XML_SOURCE);
XMLUtils::SetString(&source, "name", share.strName);
for (unsigned int i = 0; i < share.vecPaths.size(); i++)
XMLUtils::SetPath(&source, "path", share.vecPaths[i]);
if (share.m_iHasLock)
{
XMLUtils::SetInt(&source, "lockmode", share.m_iLockMode);
XMLUtils::SetString(&source, "lockcode", share.m_strLockCode);
XMLUtils::SetInt(&source, "badpwdcount", share.m_iBadPwdCount);
}
if (!share.m_strThumbnailImage.empty())
XMLUtils::SetPath(&source, "thumbnail", share.m_strThumbnailImage);
XMLUtils::SetBoolean(&source, "allowsharing", share.m_allowSharing);
sectionNode->InsertEndChild(source);
}
return true;
}
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);
}
bool CVideoInfoTag::Save(TiXmlNode *node, const std::string &tag, bool savePathInfo, const TiXmlElement *additionalNode)
{
if (!node) return false;
// we start with a <tag> tag
TiXmlElement movieElement(tag.c_str());
TiXmlNode *movie = node->InsertEndChild(movieElement);
if (!movie) return false;
XMLUtils::SetString(movie, "title", m_strTitle);
if (!m_strOriginalTitle.empty())
XMLUtils::SetString(movie, "originaltitle", m_strOriginalTitle);
if (!m_strShowTitle.empty())
XMLUtils::SetString(movie, "showtitle", m_strShowTitle);
if (!m_strSortTitle.empty())
XMLUtils::SetString(movie, "sorttitle", m_strSortTitle);
if (!m_ratings.empty())
{
TiXmlElement ratings("ratings");
for (const auto& it : m_ratings)
{
TiXmlElement rating("rating");
rating.SetAttribute("name", it.first.c_str());
XMLUtils::SetFloat(&rating, "value", it.second.rating);
XMLUtils::SetInt(&rating, "votes", it.second.votes);
rating.SetAttribute("max", 10);
if (it.first == m_strDefaultRating)
rating.SetAttribute("default", "true");
ratings.InsertEndChild(rating);
}
movie->InsertEndChild(ratings);
}
XMLUtils::SetInt(movie, "userrating", m_iUserRating);
if (m_EpBookmark.timeInSeconds > 0)
{
TiXmlElement epbookmark("episodebookmark");
XMLUtils::SetFloat(&epbookmark, "position", (float)m_EpBookmark.timeInSeconds);
if (!m_EpBookmark.playerState.empty())
{
TiXmlElement playerstate("playerstate");
CXBMCTinyXML doc;
doc.Parse(m_EpBookmark.playerState);
playerstate.InsertEndChild(*doc.RootElement());
epbookmark.InsertEndChild(playerstate);
}
movie->InsertEndChild(epbookmark);
}
XMLUtils::SetInt(movie, "top250", m_iTop250);
if (tag == "episodedetails" || tag == "tvshow")
{
XMLUtils::SetInt(movie, "season", m_iSeason);
XMLUtils::SetInt(movie, "episode", m_iEpisode);
XMLUtils::SetInt(movie, "displayseason",m_iSpecialSortSeason);
XMLUtils::SetInt(movie, "displayepisode",m_iSpecialSortEpisode);
}
if (tag == "musicvideo")
{
XMLUtils::SetInt(movie, "track", m_iTrack);
XMLUtils::SetString(movie, "album", m_strAlbum);
}
XMLUtils::SetString(movie, "outline", m_strPlotOutline);
XMLUtils::SetString(movie, "plot", m_strPlot);
XMLUtils::SetString(movie, "tagline", m_strTagLine);
XMLUtils::SetInt(movie, "runtime", GetDuration() / 60);
if (!m_strPictureURL.m_xml.empty())
{
CXBMCTinyXML doc;
doc.Parse(m_strPictureURL.m_xml);
const TiXmlNode* thumb = doc.FirstChild("thumb");
while (thumb)
{
movie->InsertEndChild(*thumb);
thumb = thumb->NextSibling("thumb");
}
}
if (m_fanart.m_xml.size())
{
CXBMCTinyXML doc;
doc.Parse(m_fanart.m_xml);
movie->InsertEndChild(*doc.RootElement());
}
XMLUtils::SetString(movie, "mpaa", m_strMPAARating);
XMLUtils::SetInt(movie, "playcount", m_playCount);
XMLUtils::SetDate(movie, "lastplayed", m_lastPlayed);
if (savePathInfo)
{
XMLUtils::SetString(movie, "file", m_strFile);
XMLUtils::SetString(movie, "path", m_strPath);
XMLUtils::SetString(movie, "filenameandpath", m_strFileNameAndPath);
XMLUtils::SetString(movie, "basepath", m_basePath);
}
if (!m_strEpisodeGuide.empty())
{
CXBMCTinyXML doc;
doc.Parse(m_strEpisodeGuide);
if (doc.RootElement())
movie->InsertEndChild(*doc.RootElement());
else
XMLUtils::SetString(movie, "episodeguide", m_strEpisodeGuide);
}
XMLUtils::SetString(movie, "id", GetUniqueID());
for (const auto& uniqueid : m_uniqueIDs)
{
TiXmlElement uniqueID("uniqueid");
uniqueID.SetAttribute("type", uniqueid.first);
if (uniqueid.first == m_strDefaultUniqueID)
uniqueID.SetAttribute("default", "true");
TiXmlText value(uniqueid.second);
uniqueID.InsertEndChild(value);
movie->InsertEndChild(uniqueID);
}
XMLUtils::SetStringArray(movie, "genre", m_genre);
XMLUtils::SetStringArray(movie, "country", m_country);
if (!m_strSet.empty())
{
TiXmlElement set("set");
XMLUtils::SetString(&set, "name", m_strSet);
if (!m_strSetOverview.empty())
XMLUtils::SetString(&set, "overview", m_strSetOverview);
movie->InsertEndChild(set);
}
XMLUtils::SetStringArray(movie, "tag", m_tags);
XMLUtils::SetStringArray(movie, "credits", m_writingCredits);
XMLUtils::SetStringArray(movie, "director", m_director);
if (HasPremiered())
XMLUtils::SetDate(movie, "premiered", m_premiered);
if (HasYear())
XMLUtils::SetInt(movie, "year", GetYear());
XMLUtils::SetString(movie, "status", m_strStatus);
XMLUtils::SetString(movie, "code", m_strProductionCode);
XMLUtils::SetDate(movie, "aired", m_firstAired);
XMLUtils::SetStringArray(movie, "studio", m_studio);
XMLUtils::SetString(movie, "trailer", m_strTrailer);
if (m_streamDetails.HasItems())
{
// it goes fileinfo/streamdetails/[video|audio|subtitle]
TiXmlElement fileinfo("fileinfo");
TiXmlElement streamdetails("streamdetails");
for (int iStream=1; iStream<=m_streamDetails.GetVideoStreamCount(); iStream++)
{
TiXmlElement stream("video");
XMLUtils::SetString(&stream, "codec", m_streamDetails.GetVideoCodec(iStream));
XMLUtils::SetFloat(&stream, "aspect", m_streamDetails.GetVideoAspect(iStream));
XMLUtils::SetInt(&stream, "width", m_streamDetails.GetVideoWidth(iStream));
XMLUtils::SetInt(&stream, "height", m_streamDetails.GetVideoHeight(iStream));
XMLUtils::SetInt(&stream, "durationinseconds", m_streamDetails.GetVideoDuration(iStream));
XMLUtils::SetString(&stream, "stereomode", m_streamDetails.GetStereoMode(iStream));
streamdetails.InsertEndChild(stream);
}
for (int iStream=1; iStream<=m_streamDetails.GetAudioStreamCount(); iStream++)
{
TiXmlElement stream("audio");
XMLUtils::SetString(&stream, "codec", m_streamDetails.GetAudioCodec(iStream));
XMLUtils::SetString(&stream, "language", m_streamDetails.GetAudioLanguage(iStream));
XMLUtils::SetInt(&stream, "channels", m_streamDetails.GetAudioChannels(iStream));
streamdetails.InsertEndChild(stream);
}
for (int iStream=1; iStream<=m_streamDetails.GetSubtitleStreamCount(); iStream++)
{
TiXmlElement stream("subtitle");
XMLUtils::SetString(&stream, "language", m_streamDetails.GetSubtitleLanguage(iStream));
streamdetails.InsertEndChild(stream);
}
fileinfo.InsertEndChild(streamdetails);
movie->InsertEndChild(fileinfo);
} /* if has stream details */
// cast
for (iCast it = m_cast.begin(); it != m_cast.end(); ++it)
{
// add a <actor> tag
TiXmlElement cast("actor");
TiXmlNode *node = movie->InsertEndChild(cast);
XMLUtils::SetString(node, "name", it->strName);
XMLUtils::SetString(node, "role", it->strRole);
XMLUtils::SetInt(node, "order", it->order);
XMLUtils::SetString(node, "thumb", it->thumbUrl.GetFirstThumb().m_url);
}
XMLUtils::SetStringArray(movie, "artist", m_artist);
XMLUtils::SetStringArray(movie, "showlink", m_showLink);
for (const auto& namedSeason : m_namedSeasons)
{
TiXmlElement season("namedseason");
season.SetAttribute("number", namedSeason.first);
season.SetValue(namedSeason.second);
movie->InsertEndChild(season);
}
TiXmlElement resume("resume");
XMLUtils::SetFloat(&resume, "position", (float)m_resumePoint.timeInSeconds);
XMLUtils::SetFloat(&resume, "total", (float)m_resumePoint.totalTimeInSeconds);
movie->InsertEndChild(resume);
XMLUtils::SetDateTime(movie, "dateadded", m_dateAdded);
if (additionalNode)
movie->InsertEndChild(*additionalNode);
return true;
}
bool CMediaSettings::Save(TiXmlNode *settings) const
{
if (settings == NULL)
return false;
CSingleLock lock(m_critical);
// default video settings
TiXmlElement videoSettingsNode("defaultvideosettings");
TiXmlNode *pNode = settings->InsertEndChild(videoSettingsNode);
if (pNode == NULL)
return false;
XMLUtils::SetInt(pNode, "interlacemethod", m_defaultVideoSettings.m_InterlaceMethod);
XMLUtils::SetInt(pNode, "scalingmethod", m_defaultVideoSettings.m_ScalingMethod);
XMLUtils::SetFloat(pNode, "noisereduction", m_defaultVideoSettings.m_NoiseReduction);
XMLUtils::SetBoolean(pNode, "postprocess", m_defaultVideoSettings.m_PostProcess);
XMLUtils::SetFloat(pNode, "sharpness", m_defaultVideoSettings.m_Sharpness);
XMLUtils::SetInt(pNode, "viewmode", m_defaultVideoSettings.m_ViewMode);
XMLUtils::SetFloat(pNode, "zoomamount", m_defaultVideoSettings.m_CustomZoomAmount);
XMLUtils::SetFloat(pNode, "pixelratio", m_defaultVideoSettings.m_CustomPixelRatio);
XMLUtils::SetFloat(pNode, "verticalshift", m_defaultVideoSettings.m_CustomVerticalShift);
XMLUtils::SetFloat(pNode, "volumeamplification", m_defaultVideoSettings.m_VolumeAmplification);
XMLUtils::SetBoolean(pNode, "outputtoallspeakers", m_defaultVideoSettings.m_OutputToAllSpeakers);
XMLUtils::SetBoolean(pNode, "showsubtitles", m_defaultVideoSettings.m_SubtitleOn);
XMLUtils::SetFloat(pNode, "brightness", m_defaultVideoSettings.m_Brightness);
XMLUtils::SetFloat(pNode, "contrast", m_defaultVideoSettings.m_Contrast);
XMLUtils::SetFloat(pNode, "gamma", m_defaultVideoSettings.m_Gamma);
XMLUtils::SetFloat(pNode, "audiodelay", m_defaultVideoSettings.m_AudioDelay);
XMLUtils::SetFloat(pNode, "subtitledelay", m_defaultVideoSettings.m_SubtitleDelay);
XMLUtils::SetBoolean(pNode, "nonlinstretch", m_defaultVideoSettings.m_CustomNonLinStretch);
XMLUtils::SetInt(pNode, "stereomode", m_defaultVideoSettings.m_StereoMode);
// default audio settings for dsp addons
TiXmlElement audioSettingsNode("defaultaudiosettings");
pNode = settings->InsertEndChild(audioSettingsNode);
if (pNode == NULL)
return false;
XMLUtils::SetInt(pNode, "masterstreamtype", m_defaultAudioSettings.m_MasterStreamType);
XMLUtils::SetInt(pNode, "masterstreamtypesel", m_defaultAudioSettings.m_MasterStreamTypeSel);
XMLUtils::SetInt(pNode, "masterstreambase", m_defaultAudioSettings.m_MasterStreamBase);
std::string strTag;
for (int type = AE_DSP_ASTREAM_BASIC; type < AE_DSP_ASTREAM_MAX; type++)
{
for (int base = AE_DSP_ABASE_STEREO; base < AE_DSP_ABASE_MAX; base++)
{
strTag = StringUtils::Format("masterprocess_%i_%i", type, base);
XMLUtils::SetInt(pNode, strTag.c_str(), m_defaultAudioSettings.m_MasterModes[type][base]);
}
}
// Default game settings
TiXmlElement gameSettingsNode("defaultgamesettings");
pNode = settings->InsertEndChild(gameSettingsNode);
if (pNode == nullptr)
return false;
XMLUtils::SetInt(pNode, "scalingmethod", m_defaultGameSettings.ScalingMethod());
XMLUtils::SetInt(pNode, "viewmode", m_defaultGameSettings.ViewMode());
// mymusic
pNode = settings->FirstChild("mymusic");
if (pNode == NULL)
{
TiXmlElement videosNode("mymusic");
pNode = settings->InsertEndChild(videosNode);
if (pNode == NULL)
return false;
}
TiXmlElement musicPlaylistNode("playlist");
TiXmlNode *playlistNode = pNode->InsertEndChild(musicPlaylistNode);
if (playlistNode == NULL)
return false;
XMLUtils::SetBoolean(playlistNode, "repeat", m_musicPlaylistRepeat);
XMLUtils::SetBoolean(playlistNode, "shuffle", m_musicPlaylistShuffle);
XMLUtils::SetInt(pNode, "needsupdate", m_musicNeedsUpdate);
// myvideos
pNode = settings->FirstChild("myvideos");
if (pNode == NULL)
{
TiXmlElement videosNode("myvideos");
pNode = settings->InsertEndChild(videosNode);
if (pNode == NULL)
return false;
}
XMLUtils::SetInt(pNode, "watchmodemovies", m_watchedModes.find("movies")->second);
XMLUtils::SetInt(pNode, "watchmodetvshows", m_watchedModes.find("tvshows")->second);
XMLUtils::SetInt(pNode, "watchmodemusicvideos", m_watchedModes.find("musicvideos")->second);
XMLUtils::SetInt(pNode, "watchmoderecordings", m_watchedModes.find("recordings")->second);
TiXmlElement videoPlaylistNode("playlist");
playlistNode = pNode->InsertEndChild(videoPlaylistNode);
if (playlistNode == NULL)
return false;
XMLUtils::SetBoolean(playlistNode, "repeat", m_videoPlaylistRepeat);
XMLUtils::SetBoolean(playlistNode, "shuffle", m_videoPlaylistShuffle);
XMLUtils::SetInt(pNode, "needsupdate", m_videoNeedsUpdate);
return true;
}
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);
}
bool CShortcut::Save(const CStdString& strFileName)
{
// Make shortcut filename compatible
CStdString strTotalPath = CUtil::MakeLegalPath(strFileName);
// Remove old file
CFile::Delete(strTotalPath);
// Create shortcut document:
// <shortcut>
// <path>F:\App\default.xbe</path>
// </shortcut>
TiXmlDocument xmlDoc;
TiXmlElement xmlRootElement("shortcut");
TiXmlNode *pRootNode = xmlDoc.InsertEndChild(xmlRootElement);
if (!pRootNode) return false;
TiXmlElement newElement("path");
TiXmlNode *pNewNode = pRootNode->InsertEndChild(newElement);
if (!pNewNode) return false;
TiXmlText value(m_strPath);
pNewNode->InsertEndChild(value);
if (!m_strThumb.IsEmpty())
{
TiXmlElement newElement("thumb");
TiXmlNode *pNewNode = pRootNode->InsertEndChild(newElement);
if (!pNewNode) return false;
TiXmlText thumbValue(m_strThumb);
pNewNode->InsertEndChild(thumbValue);
}
if (!m_strLabel.IsEmpty())
{
TiXmlElement newElement("label");
TiXmlNode *pNewNode = pRootNode->InsertEndChild(newElement);
if (!pNewNode) return false;
TiXmlText labelValue(m_strLabel);
pNewNode->InsertEndChild(labelValue);
}
if (!m_strVideo.IsEmpty())
{
TiXmlElement newElement("video");
TiXmlNode *pNewNode = pRootNode->InsertEndChild(newElement);
if (!pNewNode) return false;
TiXmlText labelValue(m_strVideo);
pNewNode->InsertEndChild(labelValue);
}
if (!m_strParameters.IsEmpty())
{
TiXmlElement newElement("parameters");
TiXmlNode *pNewNode = pRootNode->InsertEndChild(newElement);
if (!pNewNode) return false;
TiXmlText labelValue(m_strParameters);
pNewNode->InsertEndChild(labelValue);
}
if (!m_strCustomGame.IsEmpty())
{
TiXmlElement customElement("custom");
TiXmlNode* pCustomNode = pRootNode->InsertEndChild(customElement);
TiXmlText game(m_strCustomGame);
TiXmlElement gameElement("game");
TiXmlNode* pGameNode = pCustomNode->InsertEndChild(gameElement);
pGameNode->InsertEndChild(game);
}
return xmlDoc.SaveFile(strTotalPath);
}
int main(){
//______________________________________________________________________
// Read information from xml file.
// define xml file path, as follow , we use relative path,
// but you can use absolute path also.
const char* filepath = "phonebookdata.xml";
TiXmlDocument doc(filepath);
bool loadOkay = doc.LoadFile();
// faile to load 'phonebookdata.xml'.
if (!loadOkay) {
printf( "Could not load test file %s. Error='%s'. Exiting.\n", filepath,doc.ErrorDesc() );
exit( 1 );
}
// get dom root of 'phonebookdata.xml', here root should be 'phonebook'.
TiXmlElement* root = doc.RootElement();
printf("_______________________________________\n\n");
printf(" contacted person information \n\n");
// trace every items below root.
for( TiXmlNode* item = root->FirstChild( "item" );
item;
item = item->NextSibling( "item" ) ) {
printf("_______________________________________\n");
// read name.
TiXmlNode* child = item->FirstChild();
const char* name = child->ToElement()->GetText();
if (name) {
printf("name:%s\n",name);
} else {
printf("name:\n");
}
// read address.
child = item->IterateChildren(child);
const char* addr = child->ToElement()->GetText();
if (addr) {
printf("addr:%s\n",addr);
} else {
printf("addr:\n");
}
// read telephone no.
child = item->IterateChildren(child);
const char* tel = child->ToElement()->GetText();
if (tel) {
printf("tel:%s\n",tel);
} else {
printf("tel:\n");
}
// read e-mail.
child = item->IterateChildren(child);
const char* email = child->ToElement()->GetText();
if(email) {
printf("email:%s\n",email);
} else {
printf("email:\n");
}
printf("\n");
}
//______________________________________________________________________
//______________________________________________________________________
// Add information to xml file and save it.
TiXmlElement* writeRoot = doc.RootElement();
TiXmlNode* newNode = new TiXmlElement("item");
const TiXmlNode* name4NewNode = new TiXmlElement("name");
newNode->InsertEndChild(*name4NewNode)->InsertEndChild(TiXmlText("pipi"));
const TiXmlNode* addr4NewNode = new TiXmlElement("addr");
newNode->InsertEndChild(*addr4NewNode)->InsertEndChild(TiXmlText("Shaanxi Xianyang"));
const TiXmlNode* tel4NewNode = new TiXmlElement("tel");
newNode->InsertEndChild(*tel4NewNode)->InsertEndChild(TiXmlText("02937310627"));
const TiXmlNode* email4NewNode = new TiXmlElement("email");
newNode->InsertEndChild(*email4NewNode)->InsertEndChild(TiXmlText("*****@*****.**"));
writeRoot->InsertEndChild(*newNode);
doc.SaveFile();
//______________________________________________________________________
}
bool CAlbum::Save(TiXmlNode *node, const CStdString &tag, const CStdString& strPath)
{
if (!node) return false;
// we start with a <tag> tag
TiXmlElement albumElement(tag.c_str());
TiXmlNode *album = node->InsertEndChild(albumElement);
if (!album) return false;
XMLUtils::SetString(album, "title", strAlbum);
XMLUtils::SetString(album, "musicBrainzAlbumID", strMusicBrainzAlbumID);
XMLUtils::SetStringArray(album, "artist", artist);
XMLUtils::SetStringArray(album, "genre", genre);
XMLUtils::SetStringArray(album, "style", styles);
XMLUtils::SetStringArray(album, "mood", moods);
XMLUtils::SetStringArray(album, "theme", themes);
XMLUtils::SetBoolean(album, "compilation", bCompilation);
XMLUtils::SetString(album, "review", strReview);
XMLUtils::SetString(album, "type", strType);
XMLUtils::SetString(album, "releasedate", m_strDateOfRelease);
XMLUtils::SetString(album, "label", strLabel);
XMLUtils::SetString(album, "type", strType);
if (!thumbURL.m_xml.empty())
{
CXBMCTinyXML doc;
doc.Parse(thumbURL.m_xml);
const TiXmlNode* thumb = doc.FirstChild("thumb");
while (thumb)
{
album->InsertEndChild(*thumb);
thumb = thumb->NextSibling("thumb");
}
}
XMLUtils::SetString(album, "path", strPath);
XMLUtils::SetInt(album, "rating", iRating);
XMLUtils::SetInt(album, "year", iYear);
for( VECARTISTCREDITS::const_iterator artistCredit = artistCredits.begin();artistCredit != artistCredits.end();++artistCredit)
{
// add an <albumArtistCredits> tag
TiXmlElement albumArtistCreditsElement("albumArtistCredits");
TiXmlNode *albumArtistCreditsNode = album->InsertEndChild(albumArtistCreditsElement);
XMLUtils::SetString(albumArtistCreditsNode, "artist", artistCredit->m_strArtist);
XMLUtils::SetString(albumArtistCreditsNode, "musicBrainzArtistID", artistCredit->m_strMusicBrainzArtistID);
XMLUtils::SetString(albumArtistCreditsNode, "joinphrase", artistCredit->m_strJoinPhrase);
XMLUtils::SetString(albumArtistCreditsNode, "featuring", artistCredit->GetArtist());
}
for( VECSONGS::const_iterator song = songs.begin(); song != songs.end(); ++song)
{
// add a <song> tag
TiXmlElement cast("track");
TiXmlNode *node = album->InsertEndChild(cast);
for( VECARTISTCREDITS::const_iterator artistCredit = song->artistCredits.begin(); artistCredit != artistCredits.end(); ++artistCredit)
{
// add an <albumArtistCredits> tag
TiXmlElement songArtistCreditsElement("songArtistCredits");
TiXmlNode *songArtistCreditsNode = node->InsertEndChild(songArtistCreditsElement);
XMLUtils::SetString(songArtistCreditsNode, "artist", artistCredit->m_strArtist);
XMLUtils::SetString(songArtistCreditsNode, "musicBrainzArtistID", artistCredit->m_strMusicBrainzArtistID);
XMLUtils::SetString(songArtistCreditsNode, "joinphrase", artistCredit->m_strJoinPhrase);
XMLUtils::SetString(songArtistCreditsNode, "featuring", artistCredit->GetArtist());
}
XMLUtils::SetString(node, "musicBrainzTrackID", song->strMusicBrainzTrackID);
XMLUtils::SetString(node, "title", song->strTitle);
XMLUtils::SetInt(node, "position", song->iTrack);
XMLUtils::SetString(node, "duration", StringUtils::SecondsToTimeString(song->iDuration));
}
return true;
}
bool CMediaSettings::Save(TiXmlNode *settings) const
{
if (settings == NULL)
return false;
CSingleLock lock(m_critical);
// default video settings
TiXmlElement videoSettingsNode("defaultvideosettings");
TiXmlNode *pNode = settings->InsertEndChild(videoSettingsNode);
if (pNode == NULL)
return false;
XMLUtils::SetInt(pNode, "deinterlacemode", m_defaultVideoSettings.m_DeinterlaceMode);
XMLUtils::SetInt(pNode, "interlacemethod", m_defaultVideoSettings.m_InterlaceMethod);
XMLUtils::SetInt(pNode, "scalingmethod", m_defaultVideoSettings.m_ScalingMethod);
XMLUtils::SetFloat(pNode, "noisereduction", m_defaultVideoSettings.m_NoiseReduction);
XMLUtils::SetBoolean(pNode, "postprocess", m_defaultVideoSettings.m_PostProcess);
XMLUtils::SetFloat(pNode, "sharpness", m_defaultVideoSettings.m_Sharpness);
XMLUtils::SetInt(pNode, "viewmode", m_defaultVideoSettings.m_ViewMode);
XMLUtils::SetFloat(pNode, "zoomamount", m_defaultVideoSettings.m_CustomZoomAmount);
XMLUtils::SetFloat(pNode, "pixelratio", m_defaultVideoSettings.m_CustomPixelRatio);
XMLUtils::SetFloat(pNode, "verticalshift", m_defaultVideoSettings.m_CustomVerticalShift);
XMLUtils::SetFloat(pNode, "volumeamplification", m_defaultVideoSettings.m_VolumeAmplification);
XMLUtils::SetBoolean(pNode, "outputtoallspeakers", m_defaultVideoSettings.m_OutputToAllSpeakers);
XMLUtils::SetBoolean(pNode, "showsubtitles", m_defaultVideoSettings.m_SubtitleOn);
XMLUtils::SetFloat(pNode, "brightness", m_defaultVideoSettings.m_Brightness);
XMLUtils::SetFloat(pNode, "contrast", m_defaultVideoSettings.m_Contrast);
XMLUtils::SetFloat(pNode, "gamma", m_defaultVideoSettings.m_Gamma);
XMLUtils::SetFloat(pNode, "audiodelay", m_defaultVideoSettings.m_AudioDelay);
XMLUtils::SetFloat(pNode, "subtitledelay", m_defaultVideoSettings.m_SubtitleDelay);
XMLUtils::SetBoolean(pNode, "nonlinstretch", m_defaultVideoSettings.m_CustomNonLinStretch);
XMLUtils::SetInt(pNode, "stereomode", m_defaultVideoSettings.m_StereoMode);
// mymusic
pNode = settings->FirstChild("mymusic");
if (pNode == NULL)
{
TiXmlElement videosNode("mymusic");
pNode = settings->InsertEndChild(videosNode);
if (pNode == NULL)
return false;
}
TiXmlElement musicPlaylistNode("playlist");
TiXmlNode *playlistNode = pNode->InsertEndChild(musicPlaylistNode);
if (playlistNode == NULL)
return false;
XMLUtils::SetBoolean(playlistNode, "repeat", m_musicPlaylistRepeat);
XMLUtils::SetBoolean(playlistNode, "shuffle", m_musicPlaylistShuffle);
XMLUtils::SetInt(pNode, "needsupdate", m_musicNeedsUpdate);
// myvideos
pNode = settings->FirstChild("myvideos");
if (pNode == NULL)
{
TiXmlElement videosNode("myvideos");
pNode = settings->InsertEndChild(videosNode);
if (pNode == NULL)
return false;
}
XMLUtils::SetInt(pNode, "watchmodemovies", m_watchedModes.find("movies")->second);
XMLUtils::SetInt(pNode, "watchmodetvshows", m_watchedModes.find("tvshows")->second);
XMLUtils::SetInt(pNode, "watchmodemusicvideos", m_watchedModes.find("musicvideos")->second);
TiXmlElement videoPlaylistNode("playlist");
playlistNode = pNode->InsertEndChild(videoPlaylistNode);
if (playlistNode == NULL)
return false;
XMLUtils::SetBoolean(playlistNode, "repeat", m_videoPlaylistRepeat);
XMLUtils::SetBoolean(playlistNode, "shuffle", m_videoPlaylistShuffle);
XMLUtils::SetInt(pNode, "needsupdate", m_videoNeedsUpdate);
return true;
}
bool CVideoInfoTag::Save(TiXmlNode *node, const CStdString &tag, bool savePathInfo)
{
if (!node) return false;
// we start with a <tag> tag
TiXmlElement movieElement(tag.c_str());
TiXmlNode *movie = node->InsertEndChild(movieElement);
if (!movie) return false;
XMLUtils::SetString(movie, "title", m_strTitle);
if (!m_strOriginalTitle.IsEmpty())
XMLUtils::SetString(movie, "originaltitle", m_strOriginalTitle);
if (!m_strShowTitle.IsEmpty())
XMLUtils::SetString(movie, "showtitle", m_strShowTitle);
if (!m_strSortTitle.IsEmpty())
XMLUtils::SetString(movie, "sorttitle", m_strSortTitle);
XMLUtils::SetFloat(movie, "rating", m_fRating);
XMLUtils::SetFloat(movie, "epbookmark", m_fEpBookmark);
XMLUtils::SetInt(movie, "year", m_iYear);
XMLUtils::SetInt(movie, "top250", m_iTop250);
if (tag == "episodedetails" || tag == "tvshow")
{
XMLUtils::SetInt(movie, "season", m_iSeason);
XMLUtils::SetInt(movie, "episode", m_iEpisode);
XMLUtils::SetInt(movie, "displayseason",m_iSpecialSortSeason);
XMLUtils::SetInt(movie, "displayepisode",m_iSpecialSortEpisode);
}
if (tag == "musicvideo")
{
XMLUtils::SetInt(movie, "track", m_iTrack);
XMLUtils::SetString(movie, "album", m_strAlbum);
}
XMLUtils::SetString(movie, "votes", m_strVotes);
XMLUtils::SetString(movie, "outline", m_strPlotOutline);
XMLUtils::SetString(movie, "plot", m_strPlot);
XMLUtils::SetString(movie, "tagline", m_strTagLine);
XMLUtils::SetString(movie, "runtime", m_strRuntime);
if (!m_strPictureURL.m_xml.empty())
{
TiXmlDocument doc;
doc.Parse(m_strPictureURL.m_xml);
const TiXmlNode* thumb = doc.FirstChild("thumb");
while (thumb)
{
movie->InsertEndChild(*thumb);
thumb = thumb->NextSibling("thumb");
}
}
if (m_fanart.m_xml.size())
{
TiXmlDocument doc;
doc.Parse(m_fanart.m_xml);
movie->InsertEndChild(*doc.RootElement());
}
XMLUtils::SetString(movie, "mpaa", m_strMPAARating);
XMLUtils::SetInt(movie, "playcount", m_playCount);
XMLUtils::SetDate(movie, "lastplayed", m_lastPlayed);
if (savePathInfo)
{
XMLUtils::SetString(movie, "file", m_strFile);
XMLUtils::SetString(movie, "path", m_strPath);
XMLUtils::SetString(movie, "filenameandpath", m_strFileNameAndPath);
XMLUtils::SetString(movie, "basepath", m_basePath);
}
if (!m_strEpisodeGuide.IsEmpty())
{
TiXmlDocument doc;
doc.Parse(m_strEpisodeGuide);
if (doc.RootElement())
movie->InsertEndChild(*doc.RootElement());
else
XMLUtils::SetString(movie, "episodeguide", m_strEpisodeGuide);
}
XMLUtils::SetString(movie, "id", m_strIMDBNumber);
XMLUtils::SetStringArray(movie, "genre", m_genre);
XMLUtils::SetStringArray(movie, "country", m_country);
XMLUtils::SetStringArray(movie, "set", m_set);
XMLUtils::SetStringArray(movie, "credits", m_writingCredits);
XMLUtils::SetStringArray(movie, "director", m_director);
XMLUtils::SetDate(movie, "premiered", m_premiered);
XMLUtils::SetString(movie, "status", m_strStatus);
XMLUtils::SetString(movie, "code", m_strProductionCode);
XMLUtils::SetDate(movie, "aired", m_firstAired);
XMLUtils::SetStringArray(movie, "studio", m_studio);
XMLUtils::SetString(movie, "trailer", m_strTrailer);
if (m_streamDetails.HasItems())
{
// it goes fileinfo/streamdetails/[video|audio|subtitle]
TiXmlElement fileinfo("fileinfo");
TiXmlElement streamdetails("streamdetails");
for (int iStream=1; iStream<=m_streamDetails.GetVideoStreamCount(); iStream++)
{
TiXmlElement stream("video");
XMLUtils::SetString(&stream, "codec", m_streamDetails.GetVideoCodec(iStream));
XMLUtils::SetFloat(&stream, "aspect", m_streamDetails.GetVideoAspect(iStream));
XMLUtils::SetInt(&stream, "width", m_streamDetails.GetVideoWidth(iStream));
XMLUtils::SetInt(&stream, "height", m_streamDetails.GetVideoHeight(iStream));
XMLUtils::SetInt(&stream, "durationinseconds", m_streamDetails.GetVideoDuration(iStream));
streamdetails.InsertEndChild(stream);
}
for (int iStream=1; iStream<=m_streamDetails.GetAudioStreamCount(); iStream++)
{
TiXmlElement stream("audio");
XMLUtils::SetString(&stream, "codec", m_streamDetails.GetAudioCodec(iStream));
XMLUtils::SetString(&stream, "language", m_streamDetails.GetAudioLanguage(iStream));
XMLUtils::SetInt(&stream, "channels", m_streamDetails.GetAudioChannels(iStream));
streamdetails.InsertEndChild(stream);
}
for (int iStream=1; iStream<=m_streamDetails.GetSubtitleStreamCount(); iStream++)
{
TiXmlElement stream("subtitle");
XMLUtils::SetString(&stream, "language", m_streamDetails.GetSubtitleLanguage(iStream));
streamdetails.InsertEndChild(stream);
}
fileinfo.InsertEndChild(streamdetails);
movie->InsertEndChild(fileinfo);
} /* if has stream details */
// cast
for (iCast it = m_cast.begin(); it != m_cast.end(); ++it)
{
// add a <actor> tag
TiXmlElement cast("actor");
TiXmlNode *node = movie->InsertEndChild(cast);
TiXmlElement actor("name");
TiXmlNode *actorNode = node->InsertEndChild(actor);
TiXmlText name(it->strName);
actorNode->InsertEndChild(name);
TiXmlElement role("role");
TiXmlNode *roleNode = node->InsertEndChild(role);
TiXmlText character(it->strRole);
roleNode->InsertEndChild(character);
TiXmlElement thumb("thumb");
TiXmlNode *thumbNode = node->InsertEndChild(thumb);
TiXmlText th(it->thumbUrl.GetFirstThumb().m_url);
thumbNode->InsertEndChild(th);
}
XMLUtils::SetStringArray(movie, "artist", m_artist);
XMLUtils::SetStringArray(movie, "showlink", m_showLink);
TiXmlElement resume("resume");
XMLUtils::SetFloat(&resume, "position", (float)m_resumePoint.timeInSeconds);
XMLUtils::SetFloat(&resume, "total", (float)m_resumePoint.totalTimeInSeconds);
movie->InsertEndChild(resume);
XMLUtils::SetString(movie, "dateadded", m_dateAdded.GetAsDBDateTime());
return true;
}