void CPasswordManager::Load()
{
Clear();
CStdString passwordsFile = g_settings.GetUserDataItem("passwords.xml");
if (XFILE::CFile::Exists(passwordsFile))
{
CXBMCTinyXML doc;
if (!doc.LoadFile(passwordsFile))
{
CLog::Log(LOGERROR, "%s - Unable to load: %s, Line %d\n%s",
__FUNCTION__, passwordsFile.c_str(), doc.ErrorRow(), doc.ErrorDesc());
return;
}
const TiXmlElement *root = doc.RootElement();
if (root->ValueStr() != "passwords")
return;
// read in our passwords
const TiXmlElement *path = root->FirstChildElement("path");
while (path)
{
CStdString from, to;
if (XMLUtils::GetPath(path, "from", from) && XMLUtils::GetPath(path, "to", to))
{
m_permanentCache[from] = to;
m_temporaryCache[from] = to;
m_temporaryCache[GetServerLookup(from)] = to;
}
path = path->NextSiblingElement("path");
}
}
m_loaded = true;
}
bool CLocalizeStrings::LoadXML(const CStdString &filename, CStdString &encoding, uint32_t offset /* = 0 */)
{
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile(filename))
{
CLog::Log(LOGDEBUG, "unable to load %s: %s at line %d", filename.c_str(), xmlDoc.ErrorDesc(), xmlDoc.ErrorRow());
return false;
}
XMLUtils::GetEncoding(&xmlDoc, encoding);
TiXmlElement* pRootElement = xmlDoc.RootElement();
if (!pRootElement || pRootElement->NoChildren() ||
pRootElement->ValueStr()!=CStdString("strings"))
{
CLog::Log(LOGERROR, "%s Doesn't contain <strings>", filename.c_str());
return false;
}
const TiXmlElement *pChild = pRootElement->FirstChildElement("string");
while (pChild)
{
// Load new style language file with id as attribute
const char* attrId=pChild->Attribute("id");
if (attrId && !pChild->NoChildren())
{
int id = atoi(attrId) + offset;
if (m_strings.find(id) == m_strings.end())
m_strings[id] = ToUTF8(encoding, pChild->FirstChild()->Value());
}
pChild = pChild->NextSiblingElement("string");
}
return true;
}
bool CController::LoadLayout(void)
{
if (!m_bLoaded)
{
std::string strLayoutXmlPath = LibPath();
CLog::Log(LOGINFO, "Loading controller layout: %s", CURL::GetRedacted(strLayoutXmlPath).c_str());
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile(strLayoutXmlPath))
{
CLog::Log(LOGDEBUG, "Unable to load file: %s at line %d", xmlDoc.ErrorDesc(), xmlDoc.ErrorRow());
return false;
}
TiXmlElement* pRootElement = xmlDoc.RootElement();
if (!pRootElement || pRootElement->NoChildren() || pRootElement->ValueStr() != LAYOUT_XML_ROOT)
{
CLog::Log(LOGERROR, "Can't find root <%s> tag", LAYOUT_XML_ROOT);
return false;
}
m_layout->Deserialize(pRootElement, this, m_features);
if (m_layout->IsValid(true))
{
m_bLoaded = true;
}
else
{
m_layout->Reset();
}
}
return m_bLoaded;
}
/*! \brief Tries to load ids and strings from a strings.xml file to the `strings` map..
* It should only be called from the LoadStr2Mem function to try a PO file first.
\param pathname The directory name, where we look for the strings file.
\param strings [out] The resulting strings map.
\param encoding Encoding of the strings.
\param offset An offset value to place strings from the id value.
\return false if no strings.xml file was loaded.
*/
static bool LoadXML(const std::string &filename, std::map<uint32_t, LocStr>& strings,
std::string &encoding, uint32_t offset = 0)
{
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile(filename))
{
CLog::Log(LOGDEBUG, "unable to load %s: %s at line %d", filename.c_str(), xmlDoc.ErrorDesc(), xmlDoc.ErrorRow());
return false;
}
TiXmlElement* pRootElement = xmlDoc.RootElement();
if (!pRootElement || pRootElement->NoChildren() ||
pRootElement->ValueStr()!="strings")
{
CLog::Log(LOGERROR, "%s Doesn't contain <strings>", filename.c_str());
return false;
}
const auto originalSize = strings.size();
const TiXmlElement *pChild = pRootElement->FirstChildElement("string");
while (pChild)
{
// Load old style language file with id as attribute
const char* attrId=pChild->Attribute("id");
if (attrId && !pChild->NoChildren())
{
uint32_t id = atoi(attrId) + offset;
if (strings.find(id) == strings.end())
strings[id].strTranslated = pChild->FirstChild()->Value();
}
pChild = pChild->NextSiblingElement("string");
}
CLog::Log(LOGDEBUG, "LocalizeStrings: loaded %i strings from file %s", strings.size() - originalSize, filename.c_str());
return true;
}
bool CPlayListB4S::LoadData(istream& stream)
{
CXBMCTinyXML xmlDoc;
stream >> xmlDoc;
if (xmlDoc.Error())
{
CLog::Log(LOGERROR, "Unable to parse B4S info Error: %s", xmlDoc.ErrorDesc());
return false;
}
TiXmlElement* pRootElement = xmlDoc.RootElement();
if (!pRootElement ) return false;
TiXmlElement* pPlayListElement = pRootElement->FirstChildElement("playlist");
if (!pPlayListElement ) return false;
m_strPlayListName = XMLUtils::GetAttribute(pPlayListElement, "label");
TiXmlElement* pEntryElement = pPlayListElement->FirstChildElement("entry");
if (!pEntryElement) return false;
while (pEntryElement)
{
std::string strFileName = XMLUtils::GetAttribute(pEntryElement, "Playstring");
size_t iColon = strFileName.find(":");
if (iColon != std::string::npos)
{
iColon++;
strFileName.erase(0, iColon);
}
if (strFileName.size())
{
TiXmlNode* pNodeInfo = pEntryElement->FirstChild("Name");
TiXmlNode* pNodeLength = pEntryElement->FirstChild("Length");
long lDuration = 0;
if (pNodeLength)
{
lDuration = atol(pNodeLength->FirstChild()->Value());
}
if (pNodeInfo)
{
std::string strInfo = pNodeInfo->FirstChild()->Value();
strFileName = URIUtils::SubstitutePath(strFileName);
CUtil::GetQualifiedFilename(m_strBasePath, strFileName);
CFileItemPtr newItem(new CFileItem(strInfo));
newItem->SetPath(strFileName);
newItem->GetMusicInfoTag()->SetDuration(lDuration);
Add(newItem);
}
}
pEntryElement = pEntryElement->NextSiblingElement();
}
return true;
}
bool CPlayListWPL::LoadData(istream& stream)
{
CXBMCTinyXML xmlDoc;
stream >> xmlDoc;
if (xmlDoc.Error())
{
CLog::Log(LOGERROR, "Unable to parse B4S info Error: %s", xmlDoc.ErrorDesc());
return false;
}
TiXmlElement* pRootElement = xmlDoc.RootElement();
if (!pRootElement ) return false;
TiXmlElement* pHeadElement = pRootElement->FirstChildElement("head");
if (pHeadElement )
{
TiXmlElement* pTitelElement = pHeadElement->FirstChildElement("title");
if (pTitelElement )
m_strPlayListName = pTitelElement->Value();
}
TiXmlElement* pBodyElement = pRootElement->FirstChildElement("body");
if (!pBodyElement ) return false;
TiXmlElement* pSeqElement = pBodyElement->FirstChildElement("seq");
if (!pSeqElement ) return false;
TiXmlElement* pMediaElement = pSeqElement->FirstChildElement("media");
if (!pMediaElement) return false;
while (pMediaElement)
{
CStdString strFileName = pMediaElement->Attribute("src");
if (strFileName.size())
{
strFileName = URIUtils::SubstitutePath(strFileName);
CUtil::GetQualifiedFilename(m_strBasePath, strFileName);
CStdString strDescription = URIUtils::GetFileName(strFileName);
CFileItemPtr newItem(new CFileItem(strDescription));
newItem->SetPath(strFileName);
Add(newItem);
}
pMediaElement = pMediaElement->NextSiblingElement();
}
return true;
}
bool CIRTranslator::LoadIRMap(const std::string &irMapPath)
{
std::string remoteMapTag;
#ifdef TARGET_POSIX
remoteMapTag = "lircmap";
#else
remoteMapTag = "irssmap";
#endif
// Load our xml file, and fill up our mapping tables
CXBMCTinyXML xmlDoc;
// Load the config file
CLog::Log(LOGINFO, "Loading %s", irMapPath.c_str());
if (!xmlDoc.LoadFile(irMapPath))
{
CLog::Log(LOGERROR, "%s, Line %d\n%s", irMapPath.c_str(), xmlDoc.ErrorRow(), xmlDoc.ErrorDesc());
return false;
}
TiXmlElement* pRoot = xmlDoc.RootElement();
std::string strValue = pRoot->Value();
if (strValue != remoteMapTag)
{
CLog::Log(LOGERROR, "%s Doesn't contain <%s>", irMapPath.c_str(), remoteMapTag.c_str());
return false;
}
// Run through our window groups
TiXmlNode* pRemote = pRoot->FirstChild();
while (pRemote != nullptr)
{
if (pRemote->Type() == TiXmlNode::TINYXML_ELEMENT)
{
const char *szRemote = pRemote->Value();
if (szRemote != nullptr)
{
TiXmlAttribute* pAttr = pRemote->ToElement()->FirstAttribute();
if (pAttr != nullptr)
MapRemote(pRemote, pAttr->Value());
}
}
pRemote = pRemote->NextSibling();
}
return true;
}
bool CIRTranslator::LoadIRMap(const std::string &irMapPath)
{
std::string remoteMapTag = URIUtils::GetFileName(irMapPath);
size_t lastindex = remoteMapTag.find_last_of(".");
if (lastindex != std::string::npos)
remoteMapTag = remoteMapTag.substr(0, lastindex);
StringUtils::ToLower(remoteMapTag);
// Load our xml file, and fill up our mapping tables
CXBMCTinyXML xmlDoc;
// Load the config file
CLog::Log(LOGINFO, "Loading %s", irMapPath.c_str());
if (!xmlDoc.LoadFile(irMapPath))
{
CLog::Log(LOGERROR, "%s, Line %d\n%s", irMapPath.c_str(), xmlDoc.ErrorRow(), xmlDoc.ErrorDesc());
return false;
}
TiXmlElement* pRoot = xmlDoc.RootElement();
std::string strValue = pRoot->Value();
if (strValue != remoteMapTag)
{
CLog::Log(LOGERROR, "%s Doesn't contain <%s>", irMapPath.c_str(), remoteMapTag.c_str());
return false;
}
// Run through our window groups
TiXmlNode* pRemote = pRoot->FirstChild();
while (pRemote != nullptr)
{
if (pRemote->Type() == TiXmlNode::TINYXML_ELEMENT)
{
const char *szRemote = pRemote->Value();
if (szRemote != nullptr)
{
TiXmlAttribute* pAttr = pRemote->ToElement()->FirstAttribute();
if (pAttr != nullptr)
MapRemote(pRemote, pAttr->Value());
}
}
pRemote = pRemote->NextSibling();
}
return true;
}
bool CButtonTranslator::LoadLircMap(const CStdString &lircmapPath)
{
#ifdef _LINUX
#define REMOTEMAPTAG "lircmap"
#else
#define REMOTEMAPTAG "irssmap"
#endif
// load our xml file, and fill up our mapping tables
CXBMCTinyXML xmlDoc;
// Load the config file
CLog::Log(LOGINFO, "Loading %s", lircmapPath.c_str());
if (!xmlDoc.LoadFile(lircmapPath))
{
CLog::Log(LOGERROR, "%s, Line %d\n%s", lircmapPath.c_str(), xmlDoc.ErrorRow(), xmlDoc.ErrorDesc());
return false; // This is so people who don't have the file won't fail, just warn
}
TiXmlElement* pRoot = xmlDoc.RootElement();
CStdString strValue = pRoot->Value();
if (strValue != REMOTEMAPTAG)
{
CLog::Log(LOGERROR, "%sl Doesn't contain <%s>", lircmapPath.c_str(), REMOTEMAPTAG);
return false;
}
// run through our window groups
TiXmlNode* pRemote = pRoot->FirstChild();
while (pRemote)
{
if (pRemote->Type() == TiXmlNode::TINYXML_ELEMENT)
{
const char *szRemote = pRemote->Value();
if (szRemote)
{
TiXmlAttribute* pAttr = pRemote->ToElement()->FirstAttribute();
const char* szDeviceName = pAttr->Value();
MapRemote(pRemote, szDeviceName);
}
}
pRemote = pRemote->NextSibling();
}
return true;
}
bool CKeyboardLayoutConfiguration::Load(const CStdString& strFileName)
{
SetDefaults();
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile(strFileName))
{
CLog::Log(LOGINFO, "unable to load %s: %s at line %d", strFileName.c_str(), xmlDoc.ErrorDesc(), xmlDoc.ErrorRow());
return false;
}
TiXmlElement* pRootElement = xmlDoc.RootElement();
CStdString strValue = pRootElement->Value();
if (strValue != CStdString("keyboard_layout"))
{
CLog::Log(LOGERROR, "%s Doesn't contain <keyboard_layout>", strFileName.c_str());
return false;
}
CLog::Log(LOGDEBUG, "reading char2char ");
const TiXmlElement* pMapChangeXbmcCharRegardlessModifiers = pRootElement->FirstChildElement("char2char");
readCharMapFromXML(pMapChangeXbmcCharRegardlessModifiers, m_changeXbmcCharRegardlessModifiers, ("char2char"));
CLog::Log(LOGDEBUG, "reading char2char_ralt ");
const TiXmlElement* pMapChangeXbmcCharWithRalt = pRootElement->FirstChildElement("char2char_ralt");
readCharMapFromXML(pMapChangeXbmcCharWithRalt, m_changeXbmcCharWithRalt, ("char2char_ralt"));
CLog::Log(LOGDEBUG, "reading vkey2char ");
const TiXmlElement* pMapDeriveXbmcCharFromVkeyRegardlessModifiers = pRootElement->FirstChildElement("vkey2char");
readByteMapFromXML(pMapDeriveXbmcCharFromVkeyRegardlessModifiers, m_deriveXbmcCharFromVkeyRegardlessModifiers, ("vkey2char"));
CLog::Log(LOGDEBUG, "reading vkey2char_shift ");
const TiXmlElement* pMapDeriveXbmcCharFromVkeyWithShift = pRootElement->FirstChildElement("vkey2char_shift");
readByteMapFromXML(pMapDeriveXbmcCharFromVkeyWithShift, m_deriveXbmcCharFromVkeyWithShift, ("vkey2char_shift"));
CLog::Log(LOGDEBUG, "reading vkey2char_ralt ");
const TiXmlElement* pMapDeriveXbmcCharFromVkeyWithRalt = pRootElement->FirstChildElement("vkey2char_ralt");
readByteMapFromXML(pMapDeriveXbmcCharFromVkeyWithRalt, m_deriveXbmcCharFromVkeyWithRalt, ("vkey2char_ralt"));
return true;
}
bool CMediaSourceSettings::Load(const std::string &file)
{
Clear();
if (!CFile::Exists(file))
return false;
CLog::Log(LOGNOTICE, "CMediaSourceSettings: loading media sources from %s", file.c_str());
// load xml file
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile(file))
{
CLog::Log(LOGERROR, "CMediaSourceSettings: error loading %s: Line %d, %s", file.c_str(), xmlDoc.ErrorRow(), xmlDoc.ErrorDesc());
return false;
}
TiXmlElement *pRootElement = xmlDoc.RootElement();
if (pRootElement == NULL || !StringUtils::EqualsNoCase(pRootElement->ValueStr(), XML_SOURCES))
CLog::Log(LOGERROR, "CMediaSourceSettings: sources.xml file does not contain <sources>");
// parse sources
std::string dummy;
GetSources(pRootElement, "video", m_videoSources, dummy);
GetSources(pRootElement, "programs", m_programSources, m_defaultProgramSource);
GetSources(pRootElement, "pictures", m_pictureSources, m_defaultPictureSource);
GetSources(pRootElement, "files", m_fileSources, m_defaultFileSource);
GetSources(pRootElement, "music", m_musicSources, m_defaultMusicSource);
return true;
}
bool CPlayerCoreFactory::LoadConfiguration(const std::string &file, bool clear)
{
CSingleLock lock(m_section);
CLog::Log(LOGNOTICE, "Loading player core factory settings from %s.", file.c_str());
if (!XFILE::CFile::Exists(file))
{ // tell the user it doesn't exist
CLog::Log(LOGNOTICE, "%s does not exist. Skipping.", file.c_str());
return false;
}
CXBMCTinyXML playerCoreFactoryXML;
if (!playerCoreFactoryXML.LoadFile(file))
{
CLog::Log(LOGERROR, "Error loading %s, Line %d (%s)", file.c_str(), playerCoreFactoryXML.ErrorRow(), playerCoreFactoryXML.ErrorDesc());
return false;
}
TiXmlElement *pConfig = playerCoreFactoryXML.RootElement();
if (pConfig == NULL)
{
CLog::Log(LOGERROR, "Error loading %s, Bad structure", file.c_str());
return false;
}
if (clear)
{
for (auto config: m_vecPlayerConfigs)
delete config;
m_vecPlayerConfigs.clear();
for (auto rule: m_vecCoreSelectionRules)
delete rule;
m_vecCoreSelectionRules.clear();
// Builtin players
CPlayerCoreConfig* VideoPlayer = new CPlayerCoreConfig("VideoPlayer", "video", nullptr);
VideoPlayer->m_bPlaysAudio = true;
VideoPlayer->m_bPlaysVideo = true;
m_vecPlayerConfigs.push_back(VideoPlayer);
CPlayerCoreConfig* paplayer = new CPlayerCoreConfig("PAPlayer", "music", nullptr);
paplayer->m_bPlaysAudio = true;
m_vecPlayerConfigs.push_back(paplayer);
}
if (!pConfig || strcmpi(pConfig->Value(), "playercorefactory") != 0)
{
CLog::Log(LOGERROR, "Error loading configuration, no <playercorefactory> node");
return false;
}
TiXmlElement *pPlayers = pConfig->FirstChildElement("players");
if (pPlayers)
{
TiXmlElement* pPlayer = pPlayers->FirstChildElement("player");
while (pPlayer)
{
std::string name = XMLUtils::GetAttribute(pPlayer, "name");
std::string type = XMLUtils::GetAttribute(pPlayer, "type");
if (type.empty()) type = name;
StringUtils::ToLower(type);
std::string internaltype;
if (type == "videoplayer")
internaltype = "video";
else if (type == "paplayer")
internaltype = "music";
else if (type == "externalplayer")
internaltype = "external";
int count = 0;
std::string playername = name;
while (GetPlayerIndex(playername) >= 0)
{
count++;
std::stringstream itoa;
itoa << count;
playername = name + itoa.str();
}
if (!internaltype.empty())
{
m_vecPlayerConfigs.push_back(new CPlayerCoreConfig(playername, internaltype, pPlayer));
}
pPlayer = pPlayer->NextSiblingElement("player");
}
}
TiXmlElement *pRule = pConfig->FirstChildElement("rules");
while (pRule)
{
const char* szAction = pRule->Attribute("action");
if (szAction)
{
if (stricmp(szAction, "append") == 0)
{
m_vecCoreSelectionRules.push_back(new CPlayerSelectionRule(pRule));
}
else if (stricmp(szAction, "prepend") == 0)
{
m_vecCoreSelectionRules.insert(m_vecCoreSelectionRules.begin(), 1, new CPlayerSelectionRule(pRule));
}
else
{
m_vecCoreSelectionRules.clear();
m_vecCoreSelectionRules.push_back(new CPlayerSelectionRule(pRule));
}
}
else
{
m_vecCoreSelectionRules.push_back(new CPlayerSelectionRule(pRule));
}
pRule = pRule->NextSiblingElement("rules");
}
// succeeded - tell the user it worked
CLog::Log(LOGNOTICE, "Loaded playercorefactory configuration");
return true;
}
bool CEdl::ReadBeyondTV(const std::string& strMovie)
{
Clear();
std::string beyondTVFilename(URIUtils::ReplaceExtension(strMovie, URIUtils::GetExtension(strMovie) + ".chapters.xml"));
if (!CFile::Exists(beyondTVFilename))
return false;
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile(beyondTVFilename))
{
CLog::Log(LOGERROR, "%s - Could not load Beyond TV file: %s. %s", __FUNCTION__, beyondTVFilename.c_str(),
xmlDoc.ErrorDesc());
return false;
}
if (xmlDoc.Error())
{
CLog::Log(LOGERROR, "%s - Could not parse Beyond TV file: %s. %s", __FUNCTION__, beyondTVFilename.c_str(),
xmlDoc.ErrorDesc());
return false;
}
TiXmlElement *pRoot = xmlDoc.RootElement();
if (!pRoot || strcmp(pRoot->Value(), "cutlist"))
{
CLog::Log(LOGERROR, "%s - Invalid Beyond TV file: %s. Expected root node to be <cutlist>", __FUNCTION__,
beyondTVFilename.c_str());
return false;
}
bool bValid = true;
TiXmlElement *pRegion = pRoot->FirstChildElement("Region");
while (bValid && pRegion)
{
TiXmlElement *pStart = pRegion->FirstChildElement("start");
TiXmlElement *pEnd = pRegion->FirstChildElement("end");
if (pStart && pEnd && pStart->FirstChild() && pEnd->FirstChild())
{
/*
* Need to divide the start and end times by a factor of 10,000 to get msec.
* E.g. <start comment="00:02:44.9980867">1649980867</start>
*
* Use atof so doesn't overflow 32 bit float or integer / long.
* E.g. <end comment="0:26:49.0000009">16090090000</end>
*
* Don't use atoll even though it is more correct as it isn't natively supported by
* Visual Studio.
*
* atof() returns 0 if there were any problems and will subsequently be rejected in AddCut().
*/
Cut cut;
cut.start = (int64_t)(atof(pStart->FirstChild()->Value()) / 10000);
cut.end = (int64_t)(atof(pEnd->FirstChild()->Value()) / 10000);
cut.action = COMM_BREAK;
bValid = AddCut(cut);
}
else
bValid = false;
pRegion = pRegion->NextSiblingElement("Region");
}
if (!bValid)
{
CLog::Log(LOGERROR, "%s - Invalid Beyond TV file: %s. Clearing any valid commercial breaks found.", __FUNCTION__,
beyondTVFilename.c_str());
Clear();
return false;
}
else if (HasCut())
{
CLog::Log(LOGDEBUG, "%s - Read %" PRIuS" commercial breaks from Beyond TV file: %s", __FUNCTION__, m_vecCuts.size(),
beyondTVFilename.c_str());
return true;
}
else
{
CLog::Log(LOGDEBUG, "%s - No commercial breaks found in Beyond TV file: %s", __FUNCTION__,
beyondTVFilename.c_str());
return false;
}
}
void CAdvancedSettings::ParseSettingsFile(const CStdString &file)
{
CXBMCTinyXML advancedXML;
if (!CFile::Exists(file))
{
CLog::Log(LOGNOTICE, "No settings file to load (%s)", file.c_str());
return;
}
if (!advancedXML.LoadFile(file))
{
CLog::Log(LOGERROR, "Error loading %s, Line %d\n%s", file.c_str(), advancedXML.ErrorRow(), advancedXML.ErrorDesc());
return;
}
TiXmlElement *pRootElement = advancedXML.RootElement();
if (!pRootElement || strcmpi(pRootElement->Value(),"advancedsettings") != 0)
{
CLog::Log(LOGERROR, "Error loading %s, no <advancedsettings> node", file.c_str());
return;
}
// succeeded - tell the user it worked
CLog::Log(LOGNOTICE, "Loaded settings file from %s", file.c_str());
// Dump contents of AS.xml to debug log
TiXmlPrinter printer;
printer.SetLineBreak("\n");
printer.SetIndent(" ");
advancedXML.Accept(&printer);
CLog::Log(LOGNOTICE, "Contents of %s are...\n%s", file.c_str(), printer.CStr());
TiXmlElement *pElement = pRootElement->FirstChildElement("audio");
if (pElement)
{
XMLUtils::GetFloat(pElement, "ac3downmixgain", m_ac3Gain, -96.0f, 96.0f);
XMLUtils::GetInt(pElement, "headroom", m_audioHeadRoom, 0, 12);
XMLUtils::GetString(pElement, "defaultplayer", m_audioDefaultPlayer);
// 101 on purpose - can be used to never automark as watched
XMLUtils::GetFloat(pElement, "playcountminimumpercent", m_audioPlayCountMinimumPercent, 0.0f, 101.0f);
XMLUtils::GetBoolean(pElement, "usetimeseeking", m_musicUseTimeSeeking);
XMLUtils::GetInt(pElement, "timeseekforward", m_musicTimeSeekForward, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackward", m_musicTimeSeekBackward, -6000, 0);
XMLUtils::GetInt(pElement, "timeseekforwardbig", m_musicTimeSeekForwardBig, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackwardbig", m_musicTimeSeekBackwardBig, -6000, 0);
XMLUtils::GetInt(pElement, "percentseekforward", m_musicPercentSeekForward, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackward", m_musicPercentSeekBackward, -100, 0);
XMLUtils::GetInt(pElement, "percentseekforwardbig", m_musicPercentSeekForwardBig, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackwardbig", m_musicPercentSeekBackwardBig, -100, 0);
XMLUtils::GetInt(pElement, "resample", m_musicResample, 0, 192000);
TiXmlElement* pAudioExcludes = pElement->FirstChildElement("excludefromlisting");
if (pAudioExcludes)
GetCustomRegexps(pAudioExcludes, m_audioExcludeFromListingRegExps);
pAudioExcludes = pElement->FirstChildElement("excludefromscan");
if (pAudioExcludes)
GetCustomRegexps(pAudioExcludes, m_audioExcludeFromScanRegExps);
XMLUtils::GetString(pElement, "audiohost", m_audioHost);
XMLUtils::GetBoolean(pElement, "applydrc", m_audioApplyDrc);
XMLUtils::GetBoolean(pElement, "dvdplayerignoredtsinwav", m_dvdplayerIgnoreDTSinWAV);
XMLUtils::GetFloat(pElement, "limiterhold", m_limiterHold, 0.0f, 100.0f);
XMLUtils::GetFloat(pElement, "limiterrelease", m_limiterRelease, 0.001f, 100.0f);
}
pElement = pRootElement->FirstChildElement("karaoke");
if (pElement)
{
XMLUtils::GetFloat(pElement, "syncdelaycdg", m_karaokeSyncDelayCDG, -3.0f, 3.0f); // keep the old name for comp
XMLUtils::GetFloat(pElement, "syncdelaylrc", m_karaokeSyncDelayLRC, -3.0f, 3.0f);
XMLUtils::GetBoolean(pElement, "alwaysreplacegenre", m_karaokeChangeGenreForKaraokeSongs );
XMLUtils::GetBoolean(pElement, "storedelay", m_karaokeKeepDelay );
XMLUtils::GetInt(pElement, "autoassignstartfrom", m_karaokeStartIndex, 1, 2000000000);
XMLUtils::GetBoolean(pElement, "nocdgbackground", m_karaokeAlwaysEmptyOnCdgs );
XMLUtils::GetBoolean(pElement, "lookupsongbackground", m_karaokeUseSongSpecificBackground );
TiXmlElement* pKaraokeBackground = pElement->FirstChildElement("defaultbackground");
if (pKaraokeBackground)
{
const char* attr = pKaraokeBackground->Attribute("type");
if ( attr )
m_karaokeDefaultBackgroundType = attr;
attr = pKaraokeBackground->Attribute("path");
if ( attr )
m_karaokeDefaultBackgroundFilePath = attr;
}
}
pElement = pRootElement->FirstChildElement("video");
if (pElement)
{
XMLUtils::GetFloat(pElement, "subsdelayrange", m_videoSubsDelayRange, 10, 600);
XMLUtils::GetFloat(pElement, "audiodelayrange", m_videoAudioDelayRange, 10, 600);
XMLUtils::GetInt(pElement, "blackbarcolour", m_videoBlackBarColour, 0, 255);
XMLUtils::GetString(pElement, "defaultplayer", m_videoDefaultPlayer);
XMLUtils::GetString(pElement, "defaultdvdplayer", m_videoDefaultDVDPlayer);
XMLUtils::GetBoolean(pElement, "fullscreenonmoviestart", m_fullScreenOnMovieStart);
// 101 on purpose - can be used to never automark as watched
XMLUtils::GetFloat(pElement, "playcountminimumpercent", m_videoPlayCountMinimumPercent, 0.0f, 101.0f);
XMLUtils::GetInt(pElement, "ignoresecondsatstart", m_videoIgnoreSecondsAtStart, 0, 900);
XMLUtils::GetFloat(pElement, "ignorepercentatend", m_videoIgnorePercentAtEnd, 0, 100.0f);
XMLUtils::GetInt(pElement, "smallstepbackseconds", m_videoSmallStepBackSeconds, 1, INT_MAX);
XMLUtils::GetInt(pElement, "smallstepbacktries", m_videoSmallStepBackTries, 1, 10);
XMLUtils::GetInt(pElement, "smallstepbackdelay", m_videoSmallStepBackDelay, 100, 5000); //MS
XMLUtils::GetBoolean(pElement, "usetimeseeking", m_videoUseTimeSeeking);
XMLUtils::GetInt(pElement, "timeseekforward", m_videoTimeSeekForward, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackward", m_videoTimeSeekBackward, -6000, 0);
XMLUtils::GetInt(pElement, "timeseekforwardbig", m_videoTimeSeekForwardBig, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackwardbig", m_videoTimeSeekBackwardBig, -6000, 0);
XMLUtils::GetInt(pElement, "percentseekforward", m_videoPercentSeekForward, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackward", m_videoPercentSeekBackward, -100, 0);
XMLUtils::GetInt(pElement, "percentseekforwardbig", m_videoPercentSeekForwardBig, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackwardbig", m_videoPercentSeekBackwardBig, -100, 0);
TiXmlElement* pVideoExcludes = pElement->FirstChildElement("excludefromlisting");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_videoExcludeFromListingRegExps);
pVideoExcludes = pElement->FirstChildElement("excludefromscan");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_moviesExcludeFromScanRegExps);
pVideoExcludes = pElement->FirstChildElement("excludetvshowsfromscan");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_tvshowExcludeFromScanRegExps);
pVideoExcludes = pElement->FirstChildElement("cleanstrings");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_videoCleanStringRegExps);
XMLUtils::GetString(pElement,"cleandatetime", m_videoCleanDateTimeRegExp);
XMLUtils::GetString(pElement,"ppffmpegdeinterlacing",m_videoPPFFmpegDeint);
XMLUtils::GetString(pElement,"ppffmpegpostprocessing",m_videoPPFFmpegPostProc);
XMLUtils::GetBoolean(pElement,"vdpauscaling",m_videoVDPAUScaling);
XMLUtils::GetFloat(pElement, "nonlinearstretchratio", m_videoNonLinStretchRatio, 0.01f, 1.0f);
XMLUtils::GetBoolean(pElement,"enablehighqualityhwscalers", m_videoEnableHighQualityHwScalers);
XMLUtils::GetFloat(pElement,"autoscalemaxfps",m_videoAutoScaleMaxFps, 0.0f, 1000.0f);
XMLUtils::GetBoolean(pElement,"allowmpeg4vdpau",m_videoAllowMpeg4VDPAU);
XMLUtils::GetBoolean(pElement,"allowmpeg4vaapi",m_videoAllowMpeg4VAAPI);
XMLUtils::GetBoolean(pElement, "disablebackgrounddeinterlace", m_videoDisableBackgroundDeinterlace);
XMLUtils::GetInt(pElement, "useocclusionquery", m_videoCaptureUseOcclusionQuery, -1, 1);
TiXmlElement* pAdjustRefreshrate = pElement->FirstChildElement("adjustrefreshrate");
if (pAdjustRefreshrate)
{
TiXmlElement* pRefreshOverride = pAdjustRefreshrate->FirstChildElement("override");
while (pRefreshOverride)
{
RefreshOverride override = {0};
float fps;
if (XMLUtils::GetFloat(pRefreshOverride, "fps", fps))
{
override.fpsmin = fps - 0.01f;
override.fpsmax = fps + 0.01f;
}
float fpsmin, fpsmax;
if (XMLUtils::GetFloat(pRefreshOverride, "fpsmin", fpsmin) &&
XMLUtils::GetFloat(pRefreshOverride, "fpsmax", fpsmax))
{
override.fpsmin = fpsmin;
override.fpsmax = fpsmax;
}
float refresh;
if (XMLUtils::GetFloat(pRefreshOverride, "refresh", refresh))
{
override.refreshmin = refresh - 0.01f;
override.refreshmax = refresh + 0.01f;
bool CGUIWindow::LoadXML(const std::string &strPath, const std::string &strLowerPath)
{
// load window xml if we don't have it stored yet
if (!m_windowXMLRootElement)
{
CXBMCTinyXML xmlDoc;
std::string strPathLower = strPath;
StringUtils::ToLower(strPathLower);
if (!xmlDoc.LoadFile(strPath) && !xmlDoc.LoadFile(strPathLower) && !xmlDoc.LoadFile(strLowerPath))
{
CLog::Log(LOGERROR, "Unable to load window XML: %s. Line %d\n%s", strPath.c_str(), xmlDoc.ErrorRow(), xmlDoc.ErrorDesc());
SetID(WINDOW_INVALID);
return false;
}
// xml need a <window> root element
if (!StringUtils::EqualsNoCase(xmlDoc.RootElement()->Value(), "window"))
{
CLog::Log(LOGERROR, "XML file %s does not contain a <window> root element", GetProperty("xmlfile").c_str());
return false;
}
// store XML for further processing if window's load type is LOAD_EVERY_TIME or a reload is needed
m_windowXMLRootElement = static_cast<TiXmlElement*>(xmlDoc.RootElement()->Clone());
}
else
CLog::Log(LOGDEBUG, "Using already stored xml root node for %s", strPath.c_str());
return Load(Prepare(m_windowXMLRootElement).get());
}
void CWeatherJob::LoadLocalizedToken()
{
// We load the english strings in to get our tokens
std::string language = LANGUAGE_DEFAULT;
std::shared_ptr<CSettingString> languageSetting = std::static_pointer_cast<CSettingString>(CServiceBroker::GetSettings().GetSetting(CSettings::SETTING_LOCALE_LANGUAGE));
if (languageSetting != NULL)
language = languageSetting->GetDefault();
// Try the strings PO file first
CPODocument PODoc;
if (PODoc.LoadFile(URIUtils::AddFileToFolder(CLangInfo::GetLanguagePath(language), "strings.po")))
{
int counter = 0;
while (PODoc.GetNextEntry())
{
if (PODoc.GetEntryType() != ID_FOUND)
continue;
uint32_t id = PODoc.GetEntryID();
PODoc.ParseEntry(ISSOURCELANG);
if (id > LOCALIZED_TOKEN_LASTID2) break;
if ((LOCALIZED_TOKEN_FIRSTID <= id && id <= LOCALIZED_TOKEN_LASTID) ||
(LOCALIZED_TOKEN_FIRSTID2 <= id && id <= LOCALIZED_TOKEN_LASTID2) ||
(LOCALIZED_TOKEN_FIRSTID3 <= id && id <= LOCALIZED_TOKEN_LASTID3) ||
(LOCALIZED_TOKEN_FIRSTID4 <= id && id <= LOCALIZED_TOKEN_LASTID4))
{
if (!PODoc.GetMsgid().empty())
{
m_localizedTokens.insert(make_pair(PODoc.GetMsgid(), id));
counter++;
}
}
}
CLog::Log(LOGDEBUG, "POParser: loaded %i weather tokens", counter);
return;
}
CLog::Log(LOGDEBUG,
"Weather: no PO string file available, to load English tokens, "
"fallback to strings.xml file");
// We load the tokens from the strings.xml file
std::string strLanguagePath = URIUtils::AddFileToFolder(CLangInfo::GetLanguagePath(language), "strings.xml");
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile(strLanguagePath) || !xmlDoc.RootElement())
{
CLog::Log(LOGERROR, "Weather: unable to load %s: %s at line %d", strLanguagePath.c_str(), xmlDoc.ErrorDesc(), xmlDoc.ErrorRow());
return;
}
TiXmlElement* pRootElement = xmlDoc.RootElement();
if (pRootElement->ValueStr() != "strings")
return;
const TiXmlElement *pChild = pRootElement->FirstChildElement();
while (pChild)
{
std::string strValue = pChild->ValueStr();
if (strValue == "string")
{ // Load new style language file with id as attribute
const char* attrId = pChild->Attribute("id");
if (attrId && !pChild->NoChildren())
{
int id = atoi(attrId);
if ((LOCALIZED_TOKEN_FIRSTID <= id && id <= LOCALIZED_TOKEN_LASTID) ||
(LOCALIZED_TOKEN_FIRSTID2 <= id && id <= LOCALIZED_TOKEN_LASTID2) ||
(LOCALIZED_TOKEN_FIRSTID3 <= id && id <= LOCALIZED_TOKEN_LASTID3) ||
(LOCALIZED_TOKEN_FIRSTID4 <= id && id <= LOCALIZED_TOKEN_LASTID4))
{
std::string utf8Label(pChild->FirstChild()->ValueStr());
if (!utf8Label.empty())
m_localizedTokens.insert(make_pair(utf8Label, id));
}
}
}
pChild = pChild->NextSiblingElement();
}
}
void CSlingboxFile::LoadSettings(const CStdString& strHostname)
{
// Load default settings
m_sSlingboxSettings.strHostname = strHostname;
m_sSlingboxSettings.iVideoWidth = 320;
m_sSlingboxSettings.iVideoHeight = 240;
m_sSlingboxSettings.iVideoResolution = (int)CSlingbox::RESOLUTION320X240;
m_sSlingboxSettings.iVideoBitrate = 704;
m_sSlingboxSettings.iVideoFramerate = 30;
m_sSlingboxSettings.iVideoSmoothing = 50;
m_sSlingboxSettings.iAudioBitrate = 64;
m_sSlingboxSettings.iIFrameInterval = 10;
m_sSlingboxSettings.uiCodeChannelUp = 0;
m_sSlingboxSettings.uiCodeChannelDown = 0;
for (unsigned int i = 0; i < 10; i++)
m_sSlingboxSettings.uiCodeNumber[i] = 0;
// Check if a SlingboxSettings.xml file exists
CStdString slingboxXMLFile = g_settings.GetUserDataItem("SlingboxSettings.xml");
if (!CFile::Exists(slingboxXMLFile))
{
CLog::Log(LOGNOTICE, "No SlingboxSettings.xml file (%s) found - using default settings",
slingboxXMLFile.c_str());
return;
}
// Load the XML file
CXBMCTinyXML slingboxXML;
if (!slingboxXML.LoadFile(slingboxXMLFile))
{
CLog::Log(LOGERROR, "%s - Error loading %s - line %d\n%s", __FUNCTION__,
slingboxXMLFile.c_str(), slingboxXML.ErrorRow(), slingboxXML.ErrorDesc());
return;
}
// Check to make sure layout is correct
TiXmlElement * pRootElement = slingboxXML.RootElement();
if (!pRootElement || strcmpi(pRootElement->Value(), "slingboxsettings") != 0)
{
CLog::Log(LOGERROR, "%s - Error loading %s - no <slingboxsettings> node found",
__FUNCTION__, slingboxXMLFile.c_str());
return;
}
// Success so far
CLog::Log(LOGNOTICE, "Loaded SlingboxSettings.xml from %s", slingboxXMLFile.c_str());
// Search for the first settings that specify no hostname or match our hostname
TiXmlElement *pElement;
for (pElement = pRootElement->FirstChildElement("slingbox"); pElement;
pElement = pElement->NextSiblingElement("slingbox"))
{
if (pElement->Attribute("hostname") == NULL ||
!m_sSlingboxSettings.strHostname.CompareNoCase(pElement->Attribute("hostname")))
{
// Load setting values
XMLUtils::GetInt(pElement, "width", m_sSlingboxSettings.iVideoWidth, 0, 640);
XMLUtils::GetInt(pElement, "height", m_sSlingboxSettings.iVideoHeight, 0, 480);
XMLUtils::GetInt(pElement, "videobitrate", m_sSlingboxSettings.iVideoBitrate, 50, 8000);
XMLUtils::GetInt(pElement, "framerate", m_sSlingboxSettings.iVideoFramerate, 1, 30);
XMLUtils::GetInt(pElement, "smoothing", m_sSlingboxSettings.iVideoSmoothing, 0, 100);
XMLUtils::GetInt(pElement, "audiobitrate", m_sSlingboxSettings.iAudioBitrate, 16, 96);
XMLUtils::GetInt(pElement, "iframeinterval", m_sSlingboxSettings.iIFrameInterval, 1, 30);
// Load any button code values
TiXmlElement * pCodes = pElement->FirstChildElement("buttons");
if (pCodes)
{
XMLUtils::GetHex(pCodes, "channelup", m_sSlingboxSettings.uiCodeChannelUp);
XMLUtils::GetHex(pCodes, "channeldown", m_sSlingboxSettings.uiCodeChannelDown);
XMLUtils::GetHex(pCodes, "zero", m_sSlingboxSettings.uiCodeNumber[0]);
XMLUtils::GetHex(pCodes, "one", m_sSlingboxSettings.uiCodeNumber[1]);
XMLUtils::GetHex(pCodes, "two", m_sSlingboxSettings.uiCodeNumber[2]);
XMLUtils::GetHex(pCodes, "three", m_sSlingboxSettings.uiCodeNumber[3]);
XMLUtils::GetHex(pCodes, "four", m_sSlingboxSettings.uiCodeNumber[4]);
XMLUtils::GetHex(pCodes, "five", m_sSlingboxSettings.uiCodeNumber[5]);
XMLUtils::GetHex(pCodes, "six", m_sSlingboxSettings.uiCodeNumber[6]);
XMLUtils::GetHex(pCodes, "seven", m_sSlingboxSettings.uiCodeNumber[7]);
XMLUtils::GetHex(pCodes, "eight", m_sSlingboxSettings.uiCodeNumber[8]);
XMLUtils::GetHex(pCodes, "nine", m_sSlingboxSettings.uiCodeNumber[9]);
}
break;
}
}
// Prepare our resolution enum mapping array
const struct
{
unsigned int uiWidth;
unsigned int uiHeight;
CSlingbox::Resolution eEnum;
} m_resolutionMap[11] = {
{0, 0, CSlingbox::NOVIDEO},
{128, 96, CSlingbox::RESOLUTION128X96},
{160, 120, CSlingbox::RESOLUTION160X120},
{176, 120, CSlingbox::RESOLUTION176X120},
{224, 176, CSlingbox::RESOLUTION224X176},
{256, 192, CSlingbox::RESOLUTION256X192},
{320, 240, CSlingbox::RESOLUTION320X240},
{352, 240, CSlingbox::RESOLUTION352X240},
{320, 480, CSlingbox::RESOLUTION320X480},
{640, 240, CSlingbox::RESOLUTION640X240},
{640, 480, CSlingbox::RESOLUTION640X480}
};
// See if the specified resolution matches something in our mapping array and
// setup things accordingly
for (unsigned int i = 0; i < 11; i++)
{
if (m_sSlingboxSettings.iVideoWidth == (int)m_resolutionMap[i].uiWidth &&
m_sSlingboxSettings.iVideoHeight == (int)m_resolutionMap[i].uiHeight)
{
m_sSlingboxSettings.iVideoResolution = (int)m_resolutionMap[i].eEnum;
return;
}
}
// If it didn't match anything setup safe defaults
CLog::Log(LOGERROR, "%s - Defaulting to 320x240 resolution due to invalid "
"resolution specified in SlingboxSettings.xml for Slingbox: %s",
__FUNCTION__, m_sSlingboxSettings.strHostname.c_str());
m_sSlingboxSettings.iVideoWidth = 320;
m_sSlingboxSettings.iVideoHeight = 240;
m_sSlingboxSettings.iVideoResolution = (int)CSlingbox::RESOLUTION320X240;
}
bool CPlayListASX::LoadData(istream& stream)
{
CLog::Log(LOGNOTICE, "Parsing ASX");
if(stream.peek() == '[')
{
return LoadAsxIniInfo(stream);
}
else
{
CXBMCTinyXML xmlDoc;
stream >> xmlDoc;
if (xmlDoc.Error())
{
CLog::Log(LOGERROR, "Unable to parse ASX info Error: %s", xmlDoc.ErrorDesc());
return false;
}
TiXmlElement *pRootElement = xmlDoc.RootElement();
// lowercase every element
TiXmlNode *pNode = pRootElement;
TiXmlNode *pChild = NULL;
CStdString value;
value = pNode->Value();
value.ToLower();
pNode->SetValue(value);
while(pNode)
{
pChild = pNode->IterateChildren(pChild);
if(pChild)
{
if (pChild->Type() == TiXmlNode::TINYXML_ELEMENT)
{
value = pChild->Value();
value.ToLower();
pChild->SetValue(value);
TiXmlAttribute* pAttr = pChild->ToElement()->FirstAttribute();
while(pAttr)
{
value = pAttr->Name();
value.ToLower();
pAttr->SetName(value);
pAttr = pAttr->Next();
}
}
pNode = pChild;
pChild = NULL;
continue;
}
pChild = pNode;
pNode = pNode->Parent();
}
CStdString roottitle = "";
TiXmlElement *pElement = pRootElement->FirstChildElement();
while (pElement)
{
value = pElement->Value();
if (value == "title")
{
roottitle = pElement->GetText();
}
else if (value == "entry")
{
CStdString title(roottitle);
TiXmlElement *pRef = pElement->FirstChildElement("ref");
TiXmlElement *pTitle = pElement->FirstChildElement("title");
if(pTitle)
title = pTitle->GetText();
while (pRef)
{ // multiple references may apear for one entry
// duration may exist on this level too
value = pRef->Attribute("href");
if (value != "")
{
if(title.IsEmpty())
title = value;
CLog::Log(LOGINFO, "Adding element %s, %s", title.c_str(), value.c_str());
CFileItemPtr newItem(new CFileItem(title));
newItem->SetPath(value);
Add(newItem);
}
pRef = pRef->NextSiblingElement("ref");
}
}
else if (value == "entryref")
{
value = pElement->Attribute("href");
if (value != "")
{ // found an entryref, let's try loading that url
auto_ptr<CPlayList> playlist(CPlayListFactory::Create(value));
if (NULL != playlist.get())
if (playlist->Load(value))
Add(*playlist);
}
}
pElement = pElement->NextSiblingElement();
}
}
return true;
}
bool CMediaManager::LoadSources()
{
// clear our location list
m_locations.clear();
// load xml file...
CXBMCTinyXML xmlDoc;
if ( !xmlDoc.LoadFile( MEDIA_SOURCES_XML ) )
return false;
TiXmlElement* pRootElement = xmlDoc.RootElement();
if ( !pRootElement || strcmpi(pRootElement->Value(), "mediasources") != 0)
{
CLog::Log(LOGERROR, "Error loading %s, Line %d (%s)", MEDIA_SOURCES_XML, xmlDoc.ErrorRow(), xmlDoc.ErrorDesc());
return false;
}
// load the <network> block
TiXmlNode *pNetwork = pRootElement->FirstChild("network");
if (pNetwork)
{
TiXmlElement *pLocation = pNetwork->FirstChildElement("location");
while (pLocation)
{
CNetworkLocation location;
pLocation->Attribute("id", &location.id);
if (pLocation->FirstChild())
{
location.path = pLocation->FirstChild()->Value();
m_locations.push_back(location);
}
pLocation = pLocation->NextSiblingElement("location");
}
}
return true;
}
// \brief Load the config file (sounds.xml) for nav sounds
// Can be located in a folder "sounds" in the skin or from a
// subfolder of the folder "sounds" in the root directory of
// xbmc
bool CGUIAudioManager::Load()
{
CSingleLock lock(m_cs);
UnLoad();
if (CSettings::Get().GetString("lookandfeel.soundskin")=="OFF")
return true;
else
Enable(true);
std::string soundSkin = CSettings::Get().GetString("lookandfeel.soundskin");
if (soundSkin == "SKINDEFAULT")
{
m_strMediaDir = URIUtils::AddFileToFolder(g_SkinInfo->Path(), "sounds");
}
else
{
//check if sound skin is located in home, otherwise fallback to built-ins
m_strMediaDir = URIUtils::AddFileToFolder("special://home/sounds", soundSkin);
if (!XFILE::CDirectory::Exists(m_strMediaDir))
m_strMediaDir = URIUtils::AddFileToFolder("special://xbmc/sounds", soundSkin);
}
std::string strSoundsXml = URIUtils::AddFileToFolder(m_strMediaDir, "sounds.xml");
// Load our xml file
CXBMCTinyXML xmlDoc;
CLog::Log(LOGINFO, "Loading %s", strSoundsXml.c_str());
// Load the config file
if (!xmlDoc.LoadFile(strSoundsXml))
{
CLog::Log(LOGNOTICE, "%s, Line %d\n%s", strSoundsXml.c_str(), xmlDoc.ErrorRow(), xmlDoc.ErrorDesc());
return false;
}
TiXmlElement* pRoot = xmlDoc.RootElement();
std::string strValue = pRoot->Value();
if ( strValue != "sounds")
{
CLog::Log(LOGNOTICE, "%s Doesn't contain <sounds>", strSoundsXml.c_str());
return false;
}
// Load sounds for actions
TiXmlElement* pActions = pRoot->FirstChildElement("actions");
if (pActions)
{
TiXmlNode* pAction = pActions->FirstChild("action");
while (pAction)
{
TiXmlNode* pIdNode = pAction->FirstChild("name");
int id = 0; // action identity
if (pIdNode && pIdNode->FirstChild())
{
CButtonTranslator::TranslateActionString(pIdNode->FirstChild()->Value(), id);
}
TiXmlNode* pFileNode = pAction->FirstChild("file");
std::string strFile;
if (pFileNode && pFileNode->FirstChild())
strFile += pFileNode->FirstChild()->Value();
if (id > 0 && !strFile.empty())
{
std::string filename = URIUtils::AddFileToFolder(m_strMediaDir, strFile);
IAESound *sound = LoadSound(filename);
if (sound)
m_actionSoundMap.insert(pair<int, IAESound *>(id, sound));
}
pAction = pAction->NextSibling();
}
}
// Load window specific sounds
TiXmlElement* pWindows = pRoot->FirstChildElement("windows");
if (pWindows)
{
TiXmlNode* pWindow = pWindows->FirstChild("window");
while (pWindow)
{
int id = 0;
TiXmlNode* pIdNode = pWindow->FirstChild("name");
if (pIdNode)
{
if (pIdNode->FirstChild())
id = CButtonTranslator::TranslateWindow(pIdNode->FirstChild()->Value());
}
CWindowSounds sounds;
sounds.initSound = LoadWindowSound(pWindow, "activate" );
sounds.deInitSound = LoadWindowSound(pWindow, "deactivate");
if (id > 0)
m_windowSoundMap.insert(pair<int, CWindowSounds>(id, sounds));
pWindow = pWindow->NextSibling();
}
}
return true;
}
bool CProfilesManager::Load(const std::string &file)
{
CSingleLock lock(m_critical);
bool ret = true;
// clear out our profiles
m_profiles.clear();
if (CFile::Exists(file))
{
CXBMCTinyXML profilesDoc;
if (profilesDoc.LoadFile(file))
{
const TiXmlElement *rootElement = profilesDoc.RootElement();
if (rootElement && StringUtils::EqualsNoCase(rootElement->Value(), XML_PROFILES))
{
XMLUtils::GetUInt(rootElement, XML_LAST_LOADED, m_lastUsedProfile);
XMLUtils::GetBoolean(rootElement, XML_LOGIN_SCREEN, m_usingLoginScreen);
XMLUtils::GetInt(rootElement, XML_AUTO_LOGIN, m_autoLoginProfile);
XMLUtils::GetInt(rootElement, XML_NEXTID, m_nextProfileId);
CStdString defaultDir("special://home/userdata");
if (!CDirectory::Exists(defaultDir))
defaultDir = "special://xbmc/userdata";
const TiXmlElement* pProfile = rootElement->FirstChildElement(XML_PROFILE);
while (pProfile)
{
CProfile profile(defaultDir);
profile.Load(pProfile, GetNextProfileId());
AddProfile(profile);
pProfile = pProfile->NextSiblingElement(XML_PROFILE);
}
}
else
{
CLog::Log(LOGERROR, "CProfilesManager: error loading %s, no <profiles> node", file.c_str());
ret = false;
}
}
else
{
CLog::Log(LOGERROR, "CProfilesManager: error loading %s, Line %d\n%s", file.c_str(), profilesDoc.ErrorRow(), profilesDoc.ErrorDesc());
ret = false;
}
}
if (m_profiles.empty())
{ // add the master user
CProfile profile("special://masterprofile/", "Master user", 0);
AddProfile(profile);
}
// check the validity of the previous profile index
if (m_lastUsedProfile >= m_profiles.size())
m_lastUsedProfile = 0;
SetCurrentProfileId(m_lastUsedProfile);
// check the validity of the auto login profile index
if (m_autoLoginProfile < -1 || m_autoLoginProfile >= (int)m_profiles.size())
m_autoLoginProfile = -1;
else if (m_autoLoginProfile >= 0)
SetCurrentProfileId(m_autoLoginProfile);
// the login screen runs as the master profile, so if we're using this, we need to ensure
// we switch to the master profile
if (m_usingLoginScreen)
SetCurrentProfileId(0);
return ret;
}
bool CLangInfo::Load(const std::string& strLanguage)
{
SetDefaults();
std::string strFileName = GetLanguageInfoPath(strLanguage);
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile(strFileName))
{
CLog::Log(LOGERROR, "unable to load %s: %s at line %d", strFileName.c_str(), xmlDoc.ErrorDesc(), xmlDoc.ErrorRow());
return false;
}
// get the matching language addon
m_languageAddon = GetLanguageAddon(strLanguage);
if (m_languageAddon == NULL)
{
CLog::Log(LOGERROR, "Unknown language %s", strLanguage.c_str());
return false;
}
// get some language-specific information from the language addon
m_strGuiCharSet = m_languageAddon->GetGuiCharset();
m_forceUnicodeFont = m_languageAddon->ForceUnicodeFont();
m_strSubtitleCharSet = m_languageAddon->GetSubtitleCharset();
m_strDVDMenuLanguage = m_languageAddon->GetDvdMenuLanguage();
m_strDVDAudioLanguage = m_languageAddon->GetDvdAudioLanguage();
m_strDVDSubtitleLanguage = m_languageAddon->GetDvdSubtitleLanguage();
m_sortTokens = m_languageAddon->GetSortTokens();
TiXmlElement* pRootElement = xmlDoc.RootElement();
if (pRootElement->ValueStr() != "language")
{
CLog::Log(LOGERROR, "%s Doesn't contain <language>", strFileName.c_str());
return false;
}
if (pRootElement->Attribute("locale"))
m_defaultRegion.m_strLangLocaleName = pRootElement->Attribute("locale");
#ifdef TARGET_WINDOWS
// Windows need 3 chars isolang code
if (m_defaultRegion.m_strLangLocaleName.length() == 2)
{
if (!g_LangCodeExpander.ConvertISO6391ToISO6392T(m_defaultRegion.m_strLangLocaleName, m_defaultRegion.m_strLangLocaleName, true))
m_defaultRegion.m_strLangLocaleName = "";
}
if (!g_LangCodeExpander.ConvertWindowsLanguageCodeToISO6392T(m_defaultRegion.m_strLangLocaleName, m_languageCodeGeneral))
m_languageCodeGeneral = "";
#else
if (m_defaultRegion.m_strLangLocaleName.length() != 3)
{
if (!g_LangCodeExpander.ConvertToISO6392T(m_defaultRegion.m_strLangLocaleName, m_languageCodeGeneral))
m_languageCodeGeneral = "";
}
else
m_languageCodeGeneral = m_defaultRegion.m_strLangLocaleName;
#endif
std::string tmp;
if (g_LangCodeExpander.ConvertToISO6391(m_defaultRegion.m_strLangLocaleName, tmp))
m_defaultRegion.m_strLangLocaleCodeTwoChar = tmp;
const TiXmlNode *pRegions = pRootElement->FirstChild("regions");
if (pRegions && !pRegions->NoChildren())
{
const TiXmlElement *pRegion=pRegions->FirstChildElement("region");
while (pRegion)
{
CRegion region(m_defaultRegion);
region.m_strName = XMLUtils::GetAttribute(pRegion, "name");
if (region.m_strName.empty())
region.m_strName="N/A";
if (pRegion->Attribute("locale"))
region.m_strRegionLocaleName = pRegion->Attribute("locale");
#ifdef TARGET_WINDOWS
// Windows need 3 chars regions code
if (region.m_strRegionLocaleName.length() == 2)
{
if (!g_LangCodeExpander.ConvertISO36111Alpha2ToISO36111Alpha3(region.m_strRegionLocaleName, region.m_strRegionLocaleName))
region.m_strRegionLocaleName = "";
}
#endif
const TiXmlNode *pDateLong=pRegion->FirstChild("datelong");
if (pDateLong && !pDateLong->NoChildren())
region.m_strDateFormatLong=pDateLong->FirstChild()->ValueStr();
const TiXmlNode *pDateShort=pRegion->FirstChild("dateshort");
if (pDateShort && !pDateShort->NoChildren())
region.m_strDateFormatShort=pDateShort->FirstChild()->ValueStr();
const TiXmlElement *pTime=pRegion->FirstChildElement("time");
if (pTime && !pTime->NoChildren())
{
region.m_strTimeFormat=pTime->FirstChild()->Value();
region.m_strMeridiemSymbols[MeridiemSymbolAM] = XMLUtils::GetAttribute(pTime, "symbolAM");
region.m_strMeridiemSymbols[MeridiemSymbolPM] = XMLUtils::GetAttribute(pTime, "symbolPM");
}
const TiXmlNode *pTempUnit=pRegion->FirstChild("tempunit");
if (pTempUnit && !pTempUnit->NoChildren())
region.SetTemperatureUnit(pTempUnit->FirstChild()->ValueStr());
const TiXmlNode *pSpeedUnit=pRegion->FirstChild("speedunit");
if (pSpeedUnit && !pSpeedUnit->NoChildren())
region.SetSpeedUnit(pSpeedUnit->FirstChild()->ValueStr());
const TiXmlNode *pTimeZone=pRegion->FirstChild("timezone");
if (pTimeZone && !pTimeZone->NoChildren())
region.SetTimeZone(pTimeZone->FirstChild()->ValueStr());
m_regions.insert(PAIR_REGIONS(region.m_strName, region));
pRegion=pRegion->NextSiblingElement("region");
}
const std::string& strName = CSettings::GetInstance().GetString(CSettings::SETTING_LOCALE_COUNTRY);
SetCurrentRegion(strName);
}
g_charsetConverter.reinitCharsetsFromSettings();
return true;
}
bool CLangInfo::Load(const CStdString& strFileName)
{
SetDefaults();
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile(strFileName))
{
CLog::Log(LOGERROR, "unable to load %s: %s at line %d", strFileName.c_str(), xmlDoc.ErrorDesc(), xmlDoc.ErrorRow());
return false;
}
TiXmlElement* pRootElement = xmlDoc.RootElement();
CStdString strValue = pRootElement->Value();
if (strValue != CStdString("language"))
{
CLog::Log(LOGERROR, "%s Doesn't contain <language>", strFileName.c_str());
return false;
}
if (pRootElement->Attribute("locale"))
m_defaultRegion.m_strLangLocaleName = pRootElement->Attribute("locale");
#ifdef _WIN32
// Windows need 3 chars isolang code
if (m_defaultRegion.m_strLangLocaleName.length() == 2)
{
if (! g_LangCodeExpander.ConvertTwoToThreeCharCode(m_defaultRegion.m_strLangLocaleName, m_defaultRegion.m_strLangLocaleName, true))
m_defaultRegion.m_strLangLocaleName = "";
}
if (!g_LangCodeExpander.ConvertWindowsToGeneralCharCode(m_defaultRegion.m_strLangLocaleName, m_languageCodeGeneral))
m_languageCodeGeneral = "";
#else
if (m_defaultRegion.m_strLangLocaleName.length() != 3)
{
if (!g_LangCodeExpander.ConvertToThreeCharCode(m_languageCodeGeneral, m_defaultRegion.m_strLangLocaleName))
m_languageCodeGeneral = "";
}
else
m_languageCodeGeneral = m_defaultRegion.m_strLangLocaleName;
#endif
const TiXmlNode *pCharSets = pRootElement->FirstChild("charsets");
if (pCharSets && !pCharSets->NoChildren())
{
const TiXmlNode *pGui = pCharSets->FirstChild("gui");
if (pGui && !pGui->NoChildren())
{
CStdString strForceUnicodeFont = ((TiXmlElement*) pGui)->Attribute("unicodefont");
if (strForceUnicodeFont.Equals("true"))
m_defaultRegion.m_forceUnicodeFont=true;
m_defaultRegion.m_strGuiCharSet=pGui->FirstChild()->Value();
}
const TiXmlNode *pSubtitle = pCharSets->FirstChild("subtitle");
if (pSubtitle && !pSubtitle->NoChildren())
m_defaultRegion.m_strSubtitleCharSet=pSubtitle->FirstChild()->Value();
}
const TiXmlNode *pDVD = pRootElement->FirstChild("dvd");
if (pDVD && !pDVD->NoChildren())
{
const TiXmlNode *pMenu = pDVD->FirstChild("menu");
if (pMenu && !pMenu->NoChildren())
m_defaultRegion.m_strDVDMenuLanguage=pMenu->FirstChild()->Value();
const TiXmlNode *pAudio = pDVD->FirstChild("audio");
if (pAudio && !pAudio->NoChildren())
m_defaultRegion.m_strDVDAudioLanguage=pAudio->FirstChild()->Value();
const TiXmlNode *pSubtitle = pDVD->FirstChild("subtitle");
if (pSubtitle && !pSubtitle->NoChildren())
m_defaultRegion.m_strDVDSubtitleLanguage=pSubtitle->FirstChild()->Value();
}
const TiXmlNode *pRegions = pRootElement->FirstChild("regions");
if (pRegions && !pRegions->NoChildren())
{
const TiXmlElement *pRegion=pRegions->FirstChildElement("region");
while (pRegion)
{
CRegion region(m_defaultRegion);
region.m_strName=pRegion->Attribute("name");
if (region.m_strName.IsEmpty())
region.m_strName="N/A";
if (pRegion->Attribute("locale"))
region.m_strRegionLocaleName = pRegion->Attribute("locale");
#ifdef _WIN32
// Windows need 3 chars regions code
if (region.m_strRegionLocaleName.length() == 2)
{
if (! g_LangCodeExpander.ConvertLinuxToWindowsRegionCodes(region.m_strRegionLocaleName, region.m_strRegionLocaleName))
region.m_strRegionLocaleName = "";
}
#endif
const TiXmlNode *pDateLong=pRegion->FirstChild("datelong");
if (pDateLong && !pDateLong->NoChildren())
region.m_strDateFormatLong=pDateLong->FirstChild()->Value();
const TiXmlNode *pDateShort=pRegion->FirstChild("dateshort");
if (pDateShort && !pDateShort->NoChildren())
region.m_strDateFormatShort=pDateShort->FirstChild()->Value();
const TiXmlElement *pTime=pRegion->FirstChildElement("time");
if (pTime && !pTime->NoChildren())
{
region.m_strTimeFormat=pTime->FirstChild()->Value();
region.m_strMeridiemSymbols[MERIDIEM_SYMBOL_AM]=pTime->Attribute("symbolAM");
region.m_strMeridiemSymbols[MERIDIEM_SYMBOL_PM]=pTime->Attribute("symbolPM");
}
const TiXmlNode *pTempUnit=pRegion->FirstChild("tempunit");
if (pTempUnit && !pTempUnit->NoChildren())
region.SetTempUnit(pTempUnit->FirstChild()->Value());
const TiXmlNode *pSpeedUnit=pRegion->FirstChild("speedunit");
if (pSpeedUnit && !pSpeedUnit->NoChildren())
region.SetSpeedUnit(pSpeedUnit->FirstChild()->Value());
const TiXmlNode *pTimeZone=pRegion->FirstChild("timezone");
if (pTimeZone && !pTimeZone->NoChildren())
region.SetTimeZone(pTimeZone->FirstChild()->Value());
m_regions.insert(PAIR_REGIONS(region.m_strName, region));
pRegion=pRegion->NextSiblingElement("region");
}
const CStdString& strName=g_guiSettings.GetString("locale.country");
SetCurrentRegion(strName);
}
LoadTokens(pRootElement->FirstChild("sorttokens"),g_advancedSettings.m_vecTokens);
return true;
}
bool CPlayerCoreFactory::LoadConfiguration(const std::string &file, bool clear)
{
CSingleLock lock(m_section);
CLog::Log(LOGNOTICE, "Loading player core factory settings from %s.", file.c_str());
if (!XFILE::CFile::Exists(file))
{ // tell the user it doesn't exist
CLog::Log(LOGNOTICE, "%s does not exist. Skipping.", file.c_str());
return false;
}
CXBMCTinyXML playerCoreFactoryXML;
if (!playerCoreFactoryXML.LoadFile(file))
{
CLog::Log(LOGERROR, "Error loading %s, Line %d (%s)", file.c_str(), playerCoreFactoryXML.ErrorRow(), playerCoreFactoryXML.ErrorDesc());
return false;
}
TiXmlElement *pConfig = playerCoreFactoryXML.RootElement();
if (pConfig == NULL)
{
CLog::Log(LOGERROR, "Error loading %s, Bad structure", file.c_str());
return false;
}
if (clear)
{
for(std::vector<CPlayerCoreConfig *>::iterator it = m_vecCoreConfigs.begin(); it != m_vecCoreConfigs.end(); ++it)
delete *it;
m_vecCoreConfigs.clear();
// Builtin players; hard-coded because re-ordering them would break scripts
CPlayerCoreConfig* dvdplayer = new CPlayerCoreConfig("DVDPlayer", EPC_DVDPLAYER, NULL);
dvdplayer->m_bPlaysAudio = dvdplayer->m_bPlaysVideo = true;
m_vecCoreConfigs.push_back(dvdplayer);
// Don't remove this, its a placeholder for the old MPlayer core, it would break scripts
CPlayerCoreConfig* mplayer = new CPlayerCoreConfig("oldmplayercore", EPC_DVDPLAYER, NULL);
m_vecCoreConfigs.push_back(mplayer);
CPlayerCoreConfig* paplayer = new CPlayerCoreConfig("PAPlayer", EPC_PAPLAYER, NULL);
paplayer->m_bPlaysAudio = true;
m_vecCoreConfigs.push_back(paplayer);
for(std::vector<CPlayerSelectionRule *>::iterator it = m_vecCoreSelectionRules.begin(); it != m_vecCoreSelectionRules.end(); ++it)
delete *it;
m_vecCoreSelectionRules.clear();
}
if (!pConfig || strcmpi(pConfig->Value(),"playercorefactory") != 0)
{
CLog::Log(LOGERROR, "Error loading configuration, no <playercorefactory> node");
return false;
}
TiXmlElement *pPlayers = pConfig->FirstChildElement("players");
if (pPlayers)
{
TiXmlElement* pPlayer = pPlayers->FirstChildElement("player");
while (pPlayer)
{
std::string name = XMLUtils::GetAttribute(pPlayer, "name");
std::string type = XMLUtils::GetAttribute(pPlayer, "type");
if (type.empty()) type = name;
StringUtils::ToLower(type);
EPLAYERCORES eCore = EPC_NONE;
if (type == "dvdplayer" || type == "mplayer") eCore = EPC_DVDPLAYER;
if (type == "paplayer" ) eCore = EPC_PAPLAYER;
if (type == "externalplayer" ) eCore = EPC_EXTPLAYER;
if (eCore != EPC_NONE)
{
m_vecCoreConfigs.push_back(new CPlayerCoreConfig(name, eCore, pPlayer));
}
pPlayer = pPlayer->NextSiblingElement("player");
}
}
TiXmlElement *pRule = pConfig->FirstChildElement("rules");
while (pRule)
{
const char* szAction = pRule->Attribute("action");
if (szAction)
{
if (stricmp(szAction, "append") == 0)
{
m_vecCoreSelectionRules.push_back(new CPlayerSelectionRule(pRule));
}
else if (stricmp(szAction, "prepend") == 0)
{
m_vecCoreSelectionRules.insert(m_vecCoreSelectionRules.begin(), 1, new CPlayerSelectionRule(pRule));
}
else
{
m_vecCoreSelectionRules.clear();
m_vecCoreSelectionRules.push_back(new CPlayerSelectionRule(pRule));
}
}
else
{
m_vecCoreSelectionRules.push_back(new CPlayerSelectionRule(pRule));
}
pRule = pRule->NextSiblingElement("rules");
}
// succeeded - tell the user it worked
CLog::Log(LOGNOTICE, "Loaded playercorefactory configuration");
return true;
}
bool CGUIWindow::LoadXML(const CStdString &strPath, const CStdString &strLowerPath)
{
// load window xml if we don't have it stored yet
if (!m_windowXMLRootElement)
{
CXBMCTinyXML xmlDoc;
std::string strPathLower = strPath;
StringUtils::ToLower(strPathLower);
if (!xmlDoc.LoadFile(strPath) && !xmlDoc.LoadFile(strPathLower) && !xmlDoc.LoadFile(strLowerPath))
{
CLog::Log(LOGERROR, "unable to load:%s, Line %d\n%s", strPath.c_str(), xmlDoc.ErrorRow(), xmlDoc.ErrorDesc());
SetID(WINDOW_INVALID);
return false;
}
m_windowXMLRootElement = (TiXmlElement*)xmlDoc.RootElement()->Clone();
}
else
CLog::Log(LOGDEBUG, "Using already stored xml root node for %s", strPath.c_str());
return Load(m_windowXMLRootElement);
}
bool CLastFmManager::RequestRadioTracks()
{
unsigned int start = XbmcThreads::SystemClockMillis();
CStdString url;
CStdString html;
url.Format("http://" + m_RadioBaseUrl + m_RadioBasePath + "/xspf.php?sk=%s&discovery=0&desktop=", m_RadioSession);
{
CCurlFile http;
if (!http.Get(url, html))
{
m_RadioSession.empty();
CLog::Log(LOGERROR, "LastFmManager: Connect to Last.fm to request tracks failed.");
return false;
}
}
//CLog::Log(LOGDEBUG, "RequestRadioTracks: %s", html.c_str());
//parse playlist
CXBMCTinyXML xmlDoc;
xmlDoc.Parse(html);
if (xmlDoc.Error())
{
m_RadioSession.empty();
CLog::Log(LOGERROR, "LastFmManager: Unable to parse tracklist Error: %s", xmlDoc.ErrorDesc());
return false;
}
TiXmlElement* pRootElement = xmlDoc.RootElement();
if (!pRootElement )
{
CLog::Log(LOGWARNING, "LastFmManager: No more tracks received");
m_RadioSession.empty();
return false;
}
TiXmlElement* pBodyElement = pRootElement->FirstChildElement("trackList");
if (!pBodyElement )
{
CLog::Log(LOGWARNING, "LastFmManager: No more tracks received, no tracklist");
m_RadioSession.empty();
return false;
}
TiXmlElement* pTrackElement = pBodyElement->FirstChildElement("track");
if (!pTrackElement)
{
CLog::Log(LOGWARNING, "LastFmManager: No more tracks received, empty tracklist");
m_RadioSession.empty();
return false;
}
while (pTrackElement)
{
CFileItemPtr newItem(new CFileItem);
TiXmlElement* pElement = pTrackElement->FirstChildElement("location");
if (pElement)
{
TiXmlNode* child = pElement->FirstChild();
if (child)
{
CStdString url = child->Value();
url.Replace("http:", "lastfm:");
newItem->SetPath(url);
}
}
pElement = pTrackElement->FirstChildElement("title");
if (pElement)
{
TiXmlNode* child = pElement->FirstChild();
if (child)
{
newItem->SetLabel(child->Value());
newItem->GetMusicInfoTag()->SetTitle(child->Value());
}
}
pElement = pTrackElement->FirstChildElement("creator");
if (pElement)
{
TiXmlNode* child = pElement->FirstChild();
if (child)
{
newItem->GetMusicInfoTag()->SetArtist(child->Value());
}
}
pElement = pTrackElement->FirstChildElement("album");
if (pElement)
{
TiXmlNode* child = pElement->FirstChild();
if (child)
{
newItem->GetMusicInfoTag()->SetAlbum(child->Value());
}
}
pElement = pTrackElement->FirstChildElement("duration");
if (pElement)
{
TiXmlNode* child = pElement->FirstChild();
if (child)
{
int iDuration = atoi(child->Value())/1000;
newItem->GetMusicInfoTag()->SetDuration(iDuration);
}
}
newItem->FillInDefaultIcon();
pElement = pTrackElement->FirstChildElement("image");
if (pElement)
{
TiXmlNode* child = pElement->FirstChild();
if (child)
{
CStdString coverUrl = child->Value();
if ((coverUrl != "") && (coverUrl.Find("noimage") == -1) && (coverUrl.Right(1) != "/"))
{
newItem->SetThumbnailImage(coverUrl);
}
}
}
//trackauth is needed for validating the track when scrobbling
pElement = pTrackElement->FirstChildElement("lastfm:trackauth");
if (pElement)
{
TiXmlNode* child = pElement->FirstChild();
if (child)
{
CStdString trackAuth = child->Value();
//abuse comment field for the track authcode
newItem->GetMusicInfoTag()->SetComment(trackAuth);
}
}
{
CSingleLock lock(m_lockCache);
m_RadioTrackQueue->Add(newItem);
}
pTrackElement = pTrackElement->NextSiblingElement();
}
//end parse
CSingleLock lock(m_lockCache);
int iNrCachedTracks = m_RadioTrackQueue->size();
CLog::Log(LOGDEBUG, "%s: Done (time: %i ms)", __FUNCTION__, (int)(XbmcThreads::SystemClockMillis() - start));
return iNrCachedTracks > 0;
}
bool CSettings::Initialize(const std::string &file)
{
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile(file.c_str()))
{
CLog::Log(LOGERROR, "CSettings: error loading settings definition from %s, Line %d\n%s", file.c_str(), xmlDoc.ErrorRow(), xmlDoc.ErrorDesc());
return false;
}
CLog::Log(LOGDEBUG, "CSettings: loaded settings definition from %s", file.c_str());
TiXmlElement *root = xmlDoc.RootElement();
if (root == NULL)
return false;
return m_settingsManager->Initialize(root);
}
// \brief Load the config file (sounds.xml) for nav sounds
// Can be located in a folder "sounds" in the skin or from a
// subfolder of the folder "sounds" in the root directory of
// xbmc
bool CGUIAudioManager::Load()
{
CSingleLock lock(m_cs);
m_actionSoundMap.clear();
m_windowSoundMap.clear();
if (g_guiSettings.GetString("lookandfeel.soundskin")=="OFF")
return true;
else
Enable(true);
if (g_guiSettings.GetString("lookandfeel.soundskin")=="SKINDEFAULT")
{
m_strMediaDir = URIUtils::AddFileToFolder(g_SkinInfo->Path(), "sounds");
}
else
m_strMediaDir = URIUtils::AddFileToFolder("special://xbmc/sounds", g_guiSettings.GetString("lookandfeel.soundskin"));
CStdString strSoundsXml = URIUtils::AddFileToFolder(m_strMediaDir, "sounds.xml");
// Load our xml file
CXBMCTinyXML xmlDoc;
CLog::Log(LOGINFO, "Loading %s", strSoundsXml.c_str());
// Load the config file
if (!xmlDoc.LoadFile(strSoundsXml))
{
CLog::Log(LOGNOTICE, "%s, Line %d\n%s", strSoundsXml.c_str(), xmlDoc.ErrorRow(), xmlDoc.ErrorDesc());
return false;
}
TiXmlElement* pRoot = xmlDoc.RootElement();
CStdString strValue = pRoot->Value();
if ( strValue != "sounds")
{
CLog::Log(LOGNOTICE, "%s Doesn't contain <sounds>", strSoundsXml.c_str());
return false;
}
// Load sounds for actions
TiXmlElement* pActions = pRoot->FirstChildElement("actions");
if (pActions)
{
TiXmlNode* pAction = pActions->FirstChild("action");
while (pAction)
{
TiXmlNode* pIdNode = pAction->FirstChild("name");
int id = 0; // action identity
if (pIdNode && pIdNode->FirstChild())
{
CButtonTranslator::TranslateActionString(pIdNode->FirstChild()->Value(), id);
}
TiXmlNode* pFileNode = pAction->FirstChild("file");
CStdString strFile;
if (pFileNode && pFileNode->FirstChild())
strFile+=pFileNode->FirstChild()->Value();
if (id > 0 && !strFile.IsEmpty())
m_actionSoundMap.insert(pair<int, CStdString>(id, strFile));
pAction = pAction->NextSibling();
}
}
// Load window specific sounds
TiXmlElement* pWindows = pRoot->FirstChildElement("windows");
if (pWindows)
{
TiXmlNode* pWindow = pWindows->FirstChild("window");
while (pWindow)
{
int id = 0;
TiXmlNode* pIdNode = pWindow->FirstChild("name");
if (pIdNode)
{
if (pIdNode->FirstChild())
id = CButtonTranslator::TranslateWindow(pIdNode->FirstChild()->Value());
}
CWindowSounds sounds;
LoadWindowSound(pWindow, "activate", sounds.strInitFile);
LoadWindowSound(pWindow, "deactivate", sounds.strDeInitFile);
if (id > 0)
m_windowSoundMap.insert(pair<int, CWindowSounds>(id, sounds));
pWindow = pWindow->NextSibling();
}
}
return true;
}
bool CScrobbler::LoadJournal()
{
int journalVersion = 0;
SubmissionJournalEntry entry;
CXBMCTinyXML xmlDoc;
CStdString JournalFileName = GetJournalFileName();
CSingleLock lock(m_queueLock);
m_vecSubmissionQueue.clear();
if (!xmlDoc.LoadFile(JournalFileName))
{
CLog::Log(LOGDEBUG, "%s: %s, Line %d (%s)", m_strLogPrefix.c_str(),
JournalFileName.c_str(), xmlDoc.ErrorRow(), xmlDoc.ErrorDesc());
return false;
}
TiXmlElement *pRoot = xmlDoc.RootElement();
if (strcmpi(pRoot->Value(), "asjournal") != 0)
{
CLog::Log(LOGDEBUG, "%s: %s missing <asjournal>", m_strLogPrefix.c_str(),
JournalFileName.c_str());
return false;
}
if (pRoot->Attribute("version"))
journalVersion = atoi(pRoot->Attribute("version"));
TiXmlNode *pNode = pRoot->FirstChild("entry");
for (; pNode; pNode = pNode->NextSibling("entry"))
{
entry.Clear();
XMLUtils::GetString(pNode, "artist", entry.strArtist);
XMLUtils::GetString(pNode, "album", entry.strAlbum);
XMLUtils::GetString(pNode, "title", entry.strTitle);
XMLUtils::GetString(pNode, "length", entry.strLength);
entry.length = atoi(entry.strLength.c_str());
XMLUtils::GetString(pNode, "starttime", entry.strStartTime);
XMLUtils::GetString(pNode, "musicbrainzid", entry.strMusicBrainzID);
if (journalVersion > 0)
{
XMLUtils::GetString(pNode, "tracknum", entry.strTrackNum);
XMLUtils::GetString(pNode, "source", entry.strSource);
XMLUtils::GetString(pNode, "rating", entry.strRating);
}
else
{
// Update from journal v0
// Convert start time stamp
struct tm starttm;
time_t startt;
if (!strptime(entry.strStartTime.c_str(), "%Y-%m-%d %H:%M:%S", &starttm))
continue;
if ((startt = mktime(&starttm)) == -1)
continue;
entry.strStartTime.Format("%d", startt);
// url encode entries
CURL::Encode(entry.strArtist);
CURL::Encode(entry.strTitle);
CURL::Encode(entry.strAlbum);
CURL::Encode(entry.strMusicBrainzID);
}
m_vecSubmissionQueue.push_back(entry);
}
CLog::Log(LOGDEBUG, "%s: Journal loaded with %"PRIuS" entries.", m_strLogPrefix.c_str(),
m_vecSubmissionQueue.size());
return !m_vecSubmissionQueue.empty();
}
bool CGUIWindow::LoadXML(const CStdString &strPath, const CStdString &strLowerPath)
{
CXBMCTinyXML xmlDoc;
if ( !xmlDoc.LoadFile(strPath) && !xmlDoc.LoadFile(CStdString(strPath).ToLower()) && !xmlDoc.LoadFile(strLowerPath))
{
CLog::Log(LOGERROR, "unable to load:%s, Line %d\n%s", strPath.c_str(), xmlDoc.ErrorRow(), xmlDoc.ErrorDesc());
SetID(WINDOW_INVALID);
return false;
}
return Load(xmlDoc);
}