bool CAddonInstaller::InstallFromZip(const CStdString &path)
{
if (!g_passwordManager.CheckMenuLock(WINDOW_ADDON_BROWSER))
return false;
// grab the descriptive XML document from the zip, and read it in
CFileItemList items;
// BUG: some zip files return a single item (root folder) that we think is stored, so we don't use the zip:// protocol
CURL pathToUrl(path);
CURL zipDir = URIUtils::CreateArchivePath("zip", pathToUrl, "");
if (!CDirectory::GetDirectory(zipDir, items) || items.Size() != 1 || !items[0]->m_bIsFolder)
{
CGUIDialogKaiToast::QueueNotification("", path, g_localizeStrings.Get(24045), TOAST_DISPLAY_TIME, false);
return false;
}
// TODO: possibly add support for github generated zips here?
CStdString archive = URIUtils::AddFileToFolder(items[0]->GetPath(), "addon.xml");
CXBMCTinyXML xml;
AddonPtr addon;
if (xml.LoadFile(archive) && CAddonMgr::Get().LoadAddonDescriptionFromMemory(xml.RootElement(), addon))
{
// set the correct path
addon->Props().path = items[0]->GetPath();
// install the addon
return DoInstall(addon);
}
CGUIDialogKaiToast::QueueNotification("", path, g_localizeStrings.Get(24045), TOAST_DISPLAY_TIME, false);
return false;
}
bool CGUIIncludes::Load_Internal(const std::string &file)
{
// check to see if we already have this loaded
if (HasLoaded(file))
return true;
CXBMCTinyXML doc;
if (!doc.LoadFile(file))
{
CLog::Log(LOGINFO, "Error loading include file %s: %s (row: %i, col: %i)", file.c_str(), doc.ErrorDesc(), doc.ErrorRow(), doc.ErrorCol());
return false;
}
TiXmlElement *root = doc.RootElement();
if (!root || !StringUtils::EqualsNoCase(root->Value(), "includes"))
{
CLog::Log(LOGERROR, "Error loading include file %s: Root element <includes> required.", file.c_str());
return false;
}
// load components
LoadDefaults(root);
LoadConstants(root);
LoadExpressions(root);
LoadVariables(root);
LoadIncludes(root);
m_files.push_back(file);
return true;
}
bool CProfilesManager::LoadProfile(size_t index)
{
CSingleLock lock(m_critical);
// check if the index is valid or not
if (index >= m_profiles.size())
return false;
// check if the profile is already active
if (m_currentProfile == index)
return true;
// unload any old settings
CSettings::Get().Unload();
SetCurrentProfileId(index);
// load the new settings
if (!CSettings::Get().Load())
{
CLog::Log(LOGFATAL, "CProfilesManager: unable to load settings for profile \"%s\"", m_profiles.at(index).getName().c_str());
return false;
}
CSettings::Get().SetLoaded();
CreateProfileFolders();
CDatabaseManager::Get().Initialize();
CButtonTranslator::GetInstance().Load(true);
CInputManager::Get().SetMouseEnabled(CSettings::Get().GetBool(CSettings::SETTING_INPUT_ENABLEMOUSE));
g_infoManager.ResetCache();
g_infoManager.ResetLibraryBools();
if (m_currentProfile != 0)
{
CXBMCTinyXML doc;
if (doc.LoadFile(URIUtils::AddFileToFolder(GetUserDataFolder(), "guisettings.xml")))
{
CSettings::Get().LoadSetting(doc.RootElement(), CSettings::SETTING_MASTERLOCK_MAXRETRIES);
CSettings::Get().LoadSetting(doc.RootElement(), CSettings::SETTING_MASTERLOCK_STARTUPLOCK);
}
}
CPasswordManager::GetInstance().Clear();
// to set labels - shares are reloaded
#if !defined(TARGET_WINDOWS) && defined(HAS_DVD_DRIVE)
MEDIA_DETECT::CDetectDVDMedia::UpdateState();
#endif
// init windows
CGUIMessage msg(GUI_MSG_NOTIFY_ALL, 0, 0, GUI_MSG_WINDOW_RESET);
g_windowManager.SendMessage(msg);
CUtil::DeleteDirectoryCache();
g_directoryCache.Clear();
return true;
}
bool CUPnPSettings::Load(const std::string &file)
{
CSingleLock lock(m_critical);
Clear();
if (!CFile::Exists(file))
return false;
CXBMCTinyXML doc;
if (!doc.LoadFile(file))
{
CLog::Log(LOGERROR, "CUPnPSettings: error loading %s, Line %d\n%s", file.c_str(), doc.ErrorRow(), doc.ErrorDesc());
return false;
}
TiXmlElement *pRootElement = doc.RootElement();
if (pRootElement == NULL || !StringUtils::EqualsNoCase(pRootElement->Value(), XML_UPNP))
{
CLog::Log(LOGERROR, "CUPnPSettings: error loading %s, no <upnpserver> node", file.c_str());
return false;
}
// load settings
XMLUtils::GetString(pRootElement, XML_SERVER_UUID, m_serverUUID);
XMLUtils::GetInt(pRootElement, XML_SERVER_PORT, m_serverPort);
XMLUtils::GetInt(pRootElement, XML_MAX_ITEMS, m_maxReturnedItems);
XMLUtils::GetString(pRootElement, XML_RENDERER_UUID, m_rendererUUID);
XMLUtils::GetInt(pRootElement, XML_RENDERER_PORT, m_rendererPort);
return true;
}
void ILCD::LoadSkin(const CStdString &xmlFile)
{
Reset();
bool condensed = TiXmlBase::IsWhiteSpaceCondensed();
TiXmlBase::SetCondenseWhiteSpace(false);
CXBMCTinyXML doc;
if (!doc.LoadFile(xmlFile.c_str()))
{
CLog::Log(LOGERROR, "Unable to load LCD skin file %s", xmlFile.c_str());
TiXmlBase::SetCondenseWhiteSpace(condensed);
return;
}
TiXmlElement *element = doc.RootElement();
if (!element || strcmp(element->Value(), "lcd") != 0)
{
TiXmlBase::SetCondenseWhiteSpace(condensed);
return;
}
// load our settings
CStdString disableOnPlay;
XMLUtils::GetString(element, "disableonplay", disableOnPlay);
if (disableOnPlay.Find("video") != -1)
m_disableOnPlay |= DISABLE_ON_PLAY_VIDEO;
if (disableOnPlay.Find("music") != -1)
m_disableOnPlay |= DISABLE_ON_PLAY_MUSIC;
TiXmlElement *mode = element->FirstChildElement();
while (mode)
{
if (strcmpi(mode->Value(), "music") == 0)
{ // music mode
LoadMode(mode, LCD_MODE_MUSIC);
}
else if (strcmpi(mode->Value(), "video") == 0)
{ // video mode
LoadMode(mode, LCD_MODE_VIDEO);
}
else if (strcmpi(mode->Value(), "general") == 0)
{ // general mode
LoadMode(mode, LCD_MODE_GENERAL);
}
else if (strcmpi(mode->Value(), "navigation") == 0)
{ // navigation mode
LoadMode(mode, LCD_MODE_NAVIGATION);
}
else if (strcmpi(mode->Value(), "screensaver") == 0)
{ // screensaver mode
LoadMode(mode, LCD_MODE_SCREENSAVER);
}
else if (strcmpi(mode->Value(), "xbelaunch") == 0)
{ // xbe launch mode
LoadMode(mode, LCD_MODE_XBE_LAUNCH);
}
mode = mode->NextSiblingElement();
}
TiXmlBase::SetCondenseWhiteSpace(condensed);
}
bool CAddon::LoadUserSettings()
{
m_userSettingsLoaded = false;
CXBMCTinyXML doc;
if (doc.LoadFile(m_userSettingsPath))
m_userSettingsLoaded = SettingsFromXML(doc);
return m_userSettingsLoaded;
}
void CSkinInfo::SettingOptionsSkinFontsFiller(const CSetting *setting, std::vector< std::pair<std::string, std::string> > &list, std::string ¤t)
{
std::string strPath = g_SkinInfo->GetSkinPath("Font.xml");
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile(strPath))
{
CLog::Log(LOGERROR, "FillInSkinFonts: Couldn't load %s", strPath.c_str());
return;
}
TiXmlElement* pRootElement = xmlDoc.RootElement();
std::string strValue = pRootElement->ValueStr();
if (strValue != "fonts")
{
CLog::Log(LOGERROR, "FillInSkinFonts: file %s doesn't start with <fonts>", strPath.c_str());
return;
}
const TiXmlNode *pChild = pRootElement->FirstChild();
strValue = pChild->ValueStr();
if (strValue == "fontset")
{
while (pChild)
{
strValue = pChild->ValueStr();
if (strValue == "fontset")
{
const char* idAttr = ((TiXmlElement*) pChild)->Attribute("id");
const char* idLocAttr = ((TiXmlElement*) pChild)->Attribute("idloc");
const char* unicodeAttr = ((TiXmlElement*) pChild)->Attribute("unicode");
bool isUnicode = (unicodeAttr && stricmp(unicodeAttr, "true") == 0);
bool isAllowed = true;
if (g_langInfo.ForceUnicodeFont() && !isUnicode)
isAllowed = false;
if (idAttr != NULL && isAllowed)
{
if (idLocAttr)
list.push_back(make_pair(g_localizeStrings.Get(atoi(idLocAttr)), idAttr));
else
list.push_back(make_pair(idAttr, idAttr));
}
}
pChild = pChild->NextSibling();
}
}
else
{
// Since no fontset is defined, there is no selection of a fontset, so disable the component
list.push_back(make_pair(g_localizeStrings.Get(13278), ""));
}
}
bool CPeripherals::LoadMappings()
{
CSingleLock lock(m_critSectionMappings);
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile("special://xbmc/system/peripherals.xml"))
{
CLog::Log(LOGWARNING, "%s - peripherals.xml does not exist", __FUNCTION__);
return true;
}
TiXmlElement *pRootElement = xmlDoc.RootElement();
if (!pRootElement || strcmpi(pRootElement->Value(), "peripherals") != 0)
{
CLog::Log(LOGERROR, "%s - peripherals.xml does not contain <peripherals>", __FUNCTION__);
return false;
}
for (TiXmlElement *currentNode = pRootElement->FirstChildElement("peripheral"); currentNode; currentNode = currentNode->NextSiblingElement("peripheral"))
{
PeripheralID id;
PeripheralDeviceMapping mapping;
mapping.m_strDeviceName = XMLUtils::GetAttribute(currentNode, "name");
// If there is no vendor_product attribute ignore this entry
if (currentNode->Attribute("vendor_product"))
{
// The vendor_product attribute is a list of comma separated vendor:product pairs
std::vector<std::string> vpArray = StringUtils::Split(currentNode->Attribute("vendor_product"), ",");
for (const auto& i : vpArray)
{
std::vector<std::string> idArray = StringUtils::Split(i, ":");
if (idArray.size() != 2)
{
CLog::Log(LOGERROR, "%s - ignoring node \"%s\" with invalid vendor_product attribute", __FUNCTION__, mapping.m_strDeviceName.c_str());
continue;
}
id.m_iVendorId = PeripheralTypeTranslator::HexStringToInt(idArray[0].c_str());
id.m_iProductId = PeripheralTypeTranslator::HexStringToInt(idArray[1].c_str());
mapping.m_PeripheralID.push_back(id);
}
}
mapping.m_busType = PeripheralTypeTranslator::GetBusTypeFromString(XMLUtils::GetAttribute(currentNode, "bus"));
mapping.m_class = PeripheralTypeTranslator::GetTypeFromString(XMLUtils::GetAttribute(currentNode, "class"));
mapping.m_mappedTo = PeripheralTypeTranslator::GetTypeFromString(XMLUtils::GetAttribute(currentNode, "mapTo"));
GetSettingsFromMappingsFile(currentNode, mapping.m_settings);
m_mappings.push_back(mapping);
CLog::Log(LOGDEBUG, "%s - loaded node \"%s\"", __FUNCTION__, mapping.m_strDeviceName.c_str());
}
return true;
}
bool CAddon::LoadUserSettings()
{
m_userSettingsLoaded = false;
CXBMCTinyXML doc;
if (doc.LoadFile(m_userSettingsPath))
m_userSettingsLoaded = SettingsFromXML(doc);
else
CLog::Log(LOGERROR, "Error loading addon settings to %s", m_userSettingsPath.c_str());
return m_userSettingsLoaded;
}
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;
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;
}
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 CPeripherals::LoadMappings(void)
{
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile("special://xbmc/system/peripherals.xml"))
{
CLog::Log(LOGWARNING, "%s - peripherals.xml does not exist", __FUNCTION__);
return true;
}
TiXmlElement *pRootElement = xmlDoc.RootElement();
if (strcmpi(pRootElement->Value(), "peripherals") != 0)
{
CLog::Log(LOGERROR, "%s - peripherals.xml does not contain <peripherals>", __FUNCTION__);
return false;
}
for (TiXmlElement *currentNode = pRootElement->FirstChildElement("peripheral"); currentNode; currentNode = currentNode->NextSiblingElement("peripheral"))
{
CStdStringArray vpArray, idArray;
PeripheralID id;
PeripheralDeviceMapping mapping;
mapping.m_strDeviceName = currentNode->Attribute("name") ? CStdString(currentNode->Attribute("name")) : StringUtils::EmptyString;
// If there is no vendor_product attribute ignore this entry
if (currentNode->Attribute("vendor_product"))
{
// The vendor_product attribute is a list of comma separated vendor:product pairs
StringUtils::SplitString(currentNode->Attribute("vendor_product"), ",", vpArray);
for (unsigned int i = 0; i < vpArray.size(); i++)
{
StringUtils::SplitString(vpArray[i], ":", idArray);
if (idArray.size() != 2)
{
CLog::Log(LOGERROR, "%s - ignoring node \"%s\" with invalid vendor_product attribute", __FUNCTION__, mapping.m_strDeviceName.c_str());
continue;
}
id.m_iVendorId = PeripheralTypeTranslator::HexStringToInt(idArray[0]);
id.m_iProductId = PeripheralTypeTranslator::HexStringToInt(idArray[1]);
mapping.m_PeripheralID.push_back(id);
}
}
mapping.m_busType = PeripheralTypeTranslator::GetBusTypeFromString(currentNode->Attribute("bus"));
mapping.m_class = PeripheralTypeTranslator::GetTypeFromString(currentNode->Attribute("class"));
mapping.m_mappedTo = PeripheralTypeTranslator::GetTypeFromString(currentNode->Attribute("mapTo"));
GetSettingsFromMappingsFile(currentNode, mapping.m_settings);
m_mappings.push_back(mapping);
CLog::Log(LOGDEBUG, "%s - loaded node \"%s\"", __FUNCTION__, mapping.m_strDeviceName.c_str());
}
return true;
}
void CSettings::LoadProfiles(const CStdString& profilesFile)
{
// clear out our profiles
m_vecProfiles.clear();
CXBMCTinyXML profilesDoc;
if (CFile::Exists(profilesFile))
{
if (profilesDoc.LoadFile(profilesFile))
{
TiXmlElement *rootElement = profilesDoc.RootElement();
if (rootElement && strcmpi(rootElement->Value(),"profiles") == 0)
{
XMLUtils::GetUInt(rootElement, "lastloaded", m_lastUsedProfile);
XMLUtils::GetBoolean(rootElement, "useloginscreen", m_usingLoginScreen);
XMLUtils::GetInt(rootElement, "nextIdProfile", m_nextIdProfile);
TiXmlElement* pProfile = rootElement->FirstChildElement("profile");
CStdString defaultDir("special://home/userdata");
if (!CDirectory::Exists(defaultDir))
defaultDir = "special://xbmc/userdata";
while (pProfile)
{
CProfile profile(defaultDir);
profile.Load(pProfile,GetNextProfileId());
AddProfile(profile);
pProfile = pProfile->NextSiblingElement("profile");
}
}
else
CLog::Log(LOGERROR, "Error loading %s, no <profiles> node", profilesFile.c_str());
}
else
CLog::Log(LOGERROR, "Error loading %s, Line %d\n%s", profilesFile.c_str(), profilesDoc.ErrorRow(), profilesDoc.ErrorDesc());
}
if (m_vecProfiles.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_vecProfiles.size())
m_lastUsedProfile = 0;
m_currentProfile = m_lastUsedProfile;
// 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)
m_currentProfile = 0;
}
bool CGUIDialogPlayEject::ShowAndGetInput(const CFileItem & item,
unsigned int uiAutoCloseTime /* = 0 */)
{
// Make sure we're actually dealing with a Disc Stub
if (!item.IsDiscStub())
return false;
// Create the dialog
CGUIDialogPlayEject * pDialog = (CGUIDialogPlayEject *)g_windowManager.
GetWindow(WINDOW_DIALOG_PLAY_EJECT);
if (!pDialog)
return false;
// Figure out Line 1 of the dialog
CStdString strLine1;
if (item.GetVideoInfoTag())
{
strLine1 = item.GetVideoInfoTag()->m_strTitle;
}
else
{
strLine1 = URIUtils::GetFileName(item.GetPath());
URIUtils::RemoveExtension(strLine1);
}
// Figure out Line 2 of the dialog
CStdString strLine2;
CXBMCTinyXML discStubXML;
if (discStubXML.LoadFile(item.GetPath()))
{
TiXmlElement * pRootElement = discStubXML.RootElement();
if (!pRootElement || strcmpi(pRootElement->Value(), "discstub") != 0)
CLog::Log(LOGERROR, "Error loading %s, no <discstub> node", item.GetPath().c_str());
else
XMLUtils::GetString(pRootElement, "message", strLine2);
}
// Setup dialog parameters
pDialog->SetHeading(219);
pDialog->SetLine(0, 429);
pDialog->SetLine(1, strLine1);
pDialog->SetLine(2, strLine2);
pDialog->SetChoice(ID_BUTTON_PLAY - 10, 208);
pDialog->SetChoice(ID_BUTTON_EJECT - 10, 13391);
if (uiAutoCloseTime)
pDialog->SetAutoClose(uiAutoCloseTime);
// Display the dialog
pDialog->DoModal();
return pDialog->IsConfirmed();
}
void CXRandR::LoadCustomModeLinesToAllOutputs(void)
{
Query();
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile("special://xbmc/userdata/ModeLines.xml"))
{
return;
}
TiXmlElement *pRootElement = xmlDoc.RootElement();
if (strcasecmp(pRootElement->Value(), "modelines") != 0)
{
//! @todo ERROR
return;
}
char cmd[255];
std::string name;
std::string strModeLine;
for (TiXmlElement* modeline = pRootElement->FirstChildElement("modeline"); modeline; modeline = modeline->NextSiblingElement("modeline"))
{
name = modeline->Attribute("label");
StringUtils::Trim(name);
strModeLine = modeline->FirstChild()->Value();
StringUtils::Trim(strModeLine);
std::string appname = CCompileInfo::GetAppName();
StringUtils::ToLower(appname);
if (getenv("KODI_BIN_HOME"))
{
snprintf(cmd, sizeof(cmd), "%s/%s-xrandr --newmode \"%s\" %s > /dev/null 2>&1", getenv("KODI_BIN_HOME"),
appname.c_str(), name.c_str(), strModeLine.c_str());
if (system(cmd) != 0)
CLog::Log(LOGERROR, "Unable to create modeline \"%s\"", name.c_str());
}
for (unsigned int i = 0; i < m_outputs.size(); i++)
{
if (getenv("KODI_BIN_HOME"))
{
snprintf(cmd, sizeof(cmd), "%s/%s-xrandr --addmode %s \"%s\" > /dev/null 2>&1", getenv("KODI_BIN_HOME"),
appname.c_str(), m_outputs[i].name.c_str(), name.c_str());
if (system(cmd) != 0)
CLog::Log(LOGERROR, "Unable to add modeline \"%s\"", name.c_str());
}
}
}
}
void GUIFontManager::LoadFonts(const std::string& fontSet)
{
// Get the file to load fonts from:
const std::string strPath = g_SkinInfo->GetSkinPath("Font.xml", &m_skinResolution);
CLog::Log(LOGINFO, "Loading fonts from %s", strPath.c_str());
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile(strPath))
{
CLog::Log(LOGERROR, "Couldn't load %s", strPath.c_str());
return;
}
TiXmlElement* pRootElement = xmlDoc.RootElement();
if (!pRootElement || pRootElement->ValueStr() != "fonts")
{
CLog::Log(LOGERROR, "file %s doesnt start with <fonts>", strPath.c_str());
return;
}
// take note of the first font available in case we can't load the one specified
std::string firstFont;
const TiXmlElement *pChild = pRootElement->FirstChildElement("fontset");
while (pChild)
{
const char* idAttr = pChild->Attribute("id");
if (idAttr)
{
if (firstFont.empty())
firstFont = idAttr;
if (StringUtils::EqualsNoCase(fontSet, idAttr))
{
LoadFonts(pChild->FirstChild("font"));
return;
}
}
pChild = pChild->NextSiblingElement("fontset");
}
// no fontset was loaded, try the first
if (!firstFont.empty())
{
CLog::Log(LOGWARNING, "file doesnt have <fontset> with name '%s', defaulting to first fontset", fontSet.c_str());
LoadFonts(firstFont);
}
else
CLog::Log(LOGERROR, "file '%s' doesnt have a valid <fontset>", strPath.c_str());
}
void CXRandR::LoadCustomModeLinesToAllOutputs(void)
{
Query();
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile("special://xbmc/userdata/ModeLines.xml"))
{
return;
}
TiXmlElement *pRootElement = xmlDoc.RootElement();
if (strcasecmp(pRootElement->Value(), "modelines") != 0)
{
// TODO ERROR
return;
}
char cmd[255];
CStdString name;
CStdString strModeLine;
for (TiXmlElement* modeline = pRootElement->FirstChildElement("modeline"); modeline; modeline = modeline->NextSiblingElement("modeline"))
{
name = modeline->Attribute("label");
name.TrimLeft(" \n\t\r");
name.TrimRight(" \n\t\r");
strModeLine = modeline->FirstChild()->Value();
strModeLine.TrimLeft(" \n\t\r");
strModeLine.TrimRight(" \n\t\r");
if (getenv("XBMC_BIN_HOME"))
{
snprintf(cmd, sizeof(cmd), "%s/xbmc-xrandr --newmode \"%s\" %s > /dev/null 2>&1", getenv("XBMC_BIN_HOME"),
name.c_str(), strModeLine.c_str());
if (system(cmd) != 0)
CLog::Log(LOGERROR, "Unable to create modeline \"%s\"", name.c_str());
}
for (unsigned int i = 0; i < m_outputs.size(); i++)
{
if (getenv("XBMC_BIN_HOME"))
{
snprintf(cmd, sizeof(cmd), "%s/xbmc-xrandr --addmode %s \"%s\" > /dev/null 2>&1", getenv("XBMC_BIN_HOME"),
m_outputs[i].name.c_str(), name.c_str());
if (system(cmd) != 0)
CLog::Log(LOGERROR, "Unable to add modeline \"%s\"", name.c_str());
}
}
}
}
void CSkinInfo::SettingOptionsSkinFontsFiller(const CSetting *setting, std::vector< std::pair<std::string, std::string> > &list, std::string ¤t, void *data)
{
std::string settingValue = ((const CSettingString*)setting)->GetValue();
bool currentValueSet = false;
std::string strPath = g_SkinInfo->GetSkinPath("Font.xml");
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile(strPath))
{
CLog::Log(LOGERROR, "FillInSkinFonts: Couldn't load %s", strPath.c_str());
return;
}
const TiXmlElement* pRootElement = xmlDoc.RootElement();
if (!pRootElement || pRootElement->ValueStr() != "fonts")
{
CLog::Log(LOGERROR, "FillInSkinFonts: file %s doesn't start with <fonts>", strPath.c_str());
return;
}
const TiXmlElement *pChild = pRootElement->FirstChildElement("fontset");
while (pChild)
{
const char* idAttr = pChild->Attribute("id");
const char* idLocAttr = pChild->Attribute("idloc");
if (idAttr != NULL)
{
if (idLocAttr)
list.push_back(make_pair(g_localizeStrings.Get(atoi(idLocAttr)), idAttr));
else
list.push_back(make_pair(idAttr, idAttr));
if (StringUtils::EqualsNoCase(idAttr, settingValue))
currentValueSet = true;
}
pChild = pChild->NextSiblingElement("fontset");
}
if (list.empty())
{ // Since no fontset is defined, there is no selection of a fontset, so disable the component
list.push_back(make_pair(g_localizeStrings.Get(13278), ""));
current = "";
currentValueSet = true;
}
if (!currentValueSet)
current = list[0].second;
}
void CPeripheral::LoadPersistedSettings(void)
{
CXBMCTinyXML doc;
if (doc.LoadFile(m_strSettingsFile))
{
const TiXmlElement *setting = doc.RootElement()->FirstChildElement("setting");
while (setting)
{
CStdString strId(setting->Attribute("id"));
CStdString strValue(setting->Attribute("value"));
SetSetting(strId, strValue);
setting = setting->NextSiblingElement("setting");
}
}
}
bool CButtonTranslator::LoadKeymap(const std::string &keymapPath)
{
CXBMCTinyXML xmlDoc;
CLog::Log(LOGINFO, "Loading %s", keymapPath.c_str());
if (!xmlDoc.LoadFile(keymapPath))
{
CLog::Log(LOGERROR, "Error loading keymap: %s, Line %d\n%s", keymapPath.c_str(), xmlDoc.ErrorRow(), xmlDoc.ErrorDesc());
return false;
}
TiXmlElement* pRoot = xmlDoc.RootElement();
if (pRoot == nullptr)
{
CLog::Log(LOGERROR, "Error getting keymap root: %s", keymapPath.c_str());
return false;
}
std::string strValue = pRoot->Value();
if (strValue != "keymap")
{
CLog::Log(LOGERROR, "%s Doesn't contain <keymap>", keymapPath.c_str());
return false;
}
// run through our window groups
TiXmlNode* pWindow = pRoot->FirstChild();
while (pWindow != nullptr)
{
if (pWindow->Type() == TiXmlNode::TINYXML_ELEMENT)
{
int windowID = WINDOW_INVALID;
const char *szWindow = pWindow->Value();
if (szWindow != nullptr)
{
if (strcmpi(szWindow, "global") == 0)
windowID = -1;
else
windowID = CWindowTranslator::TranslateWindow(szWindow);
}
MapWindowActions(pWindow, windowID);
}
pWindow = pWindow->NextSibling();
}
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 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);
}
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 CAddon::LoadSettings(bool bForce, bool loadUserSettings /* = true */)
{
if (SettingsInitialized() && !bForce)
return true;
if (m_loadSettingsFailed)
return false;
// assume loading settings fails
m_loadSettingsFailed = true;
// reset the settings if we are forced to
if (SettingsInitialized() && bForce)
GetSettings()->Uninitialize();
// load the settings definition XML file
auto addonSettingsDefinitionFile = URIUtils::AddFileToFolder(m_addonInfo.Path(), "resources", "settings.xml");
CXBMCTinyXML addonSettingsDefinitionDoc;
if (!addonSettingsDefinitionDoc.LoadFile(addonSettingsDefinitionFile))
{
if (CFile::Exists(addonSettingsDefinitionFile))
{
CLog::Log(LOGERROR, "CAddon[%s]: unable to load: %s, Line %d\n%s",
ID().c_str(), addonSettingsDefinitionFile.c_str(), addonSettingsDefinitionDoc.ErrorRow(), addonSettingsDefinitionDoc.ErrorDesc());
}
return false;
}
// initialize the settings definition
if (!GetSettings()->Initialize(addonSettingsDefinitionDoc))
{
CLog::Log(LOGERROR, "CAddon[%s]: failed to initialize addon settings", ID().c_str());
return false;
}
// loading settings didn't fail
m_loadSettingsFailed = false;
// load user settings / values
if (loadUserSettings)
LoadUserSettings();
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;
}
static bool LoadFromFile(const std::string& strPath, CFileItemList& items)
{
CXBMCTinyXML doc;
if (!doc.LoadFile(strPath))
{
CLog::Log(LOGERROR, "Unable to load %s (row %i column %i)", strPath.c_str(), doc.Row(), doc.Column());
return false;
}
TiXmlElement *root = doc.RootElement();
if (!root || strcmp(root->Value(), "favourites"))
{
CLog::Log(LOGERROR, "Favourites.xml doesn't contain the <favourites> root element");
return false;
}
TiXmlElement *favourite = root->FirstChildElement("favourite");
while (favourite)
{
// format:
// <favourite name="Cool Video" thumb="foo.jpg">PlayMedia(c:\videos\cool_video.avi)</favourite>
// <favourite name="My Album" thumb="bar.tbn">ActivateWindow(MyMusic,c:\music\my album)</favourite>
// <favourite name="Apple Movie Trailers" thumb="path_to_thumb.png">RunScript(special://xbmc/scripts/apple movie trailers/default.py)</favourite>
const char *name = favourite->Attribute("name");
const char *thumb = favourite->Attribute("thumb");
if (name && favourite->FirstChild())
{
CURL url;
url.SetProtocol("favourites");
url.SetHostName(CURL::Encode(favourite->FirstChild()->Value()));
const std::string favURL(url.Get());
if (!items.Contains(favURL))
{
const CFileItemPtr item(std::make_shared<CFileItem>(name));
item->SetPath(favURL);
if (thumb)
item->SetArt("thumb", thumb);
items.Add(item);
}
}
favourite = favourite->NextSiblingElement("favourite");
}
return true;
}
bool CGUIIncludes::LoadIncludes(const CStdString &includeFile)
{
// check to see if we already have this loaded
if (HasIncludeFile(includeFile))
return true;
CXBMCTinyXML doc;
if (!doc.LoadFile(includeFile))
{
CLog::Log(LOGINFO, "Error loading includes.xml file (%s): %s (row=%i, col=%i)", includeFile.c_str(), doc.ErrorDesc(), doc.ErrorRow(), doc.ErrorCol());
return false;
}
// success, load the tags
if (LoadIncludesFromXML(doc.RootElement()))
{
m_files.push_back(includeFile);
return true;
}
return false;
}
bool CSettings::Load(const std::string &file)
{
CXBMCTinyXML xmlDoc;
bool updated = false;
if (!XFILE::CFile::Exists(file) || !xmlDoc.LoadFile(file) ||
!m_settingsManager->Load(xmlDoc.RootElement(), updated))
{
CLog::Log(LOGERROR, "CSettingsManager: unable to load settings from %s, creating new default settings", file.c_str());
if (!Reset())
return false;
if (!Load(file))
return false;
}
// if the settings had to be updated, we need to save the changes
else if (updated)
return Save(file);
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;
}
TEST(TestXBMCTinyXML, ParseFromFileHandle)
{
bool retval = false;
// scraper results with unescaped &
CXBMCTinyXML doc;
FILE *f = fopen(XBMC_REF_FILE_PATH("/xbmc/utils/test/CXBMCTinyXML-test.xml"), "r");
ASSERT_TRUE(f);
doc.LoadFile(f);
fclose(f);
TiXmlNode *root = doc.RootElement();
if (root && root->ValueStr() == "details")
{
TiXmlElement *url = root->FirstChildElement("url");
if (url && url->FirstChild())
{
CStdString str = url->FirstChild()->ValueStr();
retval = (str.Trim() == "http://api.themoviedb.org/3/movie/12244?api_key=57983e31fb435df4df77afb854740ea9&language=en???");
}
}
EXPECT_TRUE(retval);
}
bool CAddonInstaller::InstallFromZip(const std::string &path)
{
if (!g_passwordManager.CheckMenuLock(WINDOW_ADDON_BROWSER))
return false;
CLog::Log(LOGDEBUG, "CAddonInstaller: installing from zip '%s'", CURL::GetRedacted(path).c_str());
// grab the descriptive XML document from the zip, and read it in
CFileItemList items;
// BUG: some zip files return a single item (root folder) that we think is stored, so we don't use the zip:// protocol
CURL pathToUrl(path);
CURL zipDir = URIUtils::CreateArchivePath("zip", pathToUrl, "");
if (!CDirectory::GetDirectory(zipDir, items) || items.Size() != 1 || !items[0]->m_bIsFolder)
{
CEventLog::GetInstance().AddWithNotification(
EventPtr(new CNotificationEvent(EventLevelError, 24045,
StringUtils::Format(g_localizeStrings.Get(24143).c_str(), path.c_str()))), false);
return false;
}
// TODO: possibly add support for github generated zips here?
std::string archive = URIUtils::AddFileToFolder(items[0]->GetPath(), "addon.xml");
CXBMCTinyXML xml;
AddonPtr addon;
if (xml.LoadFile(archive) && CAddonMgr::GetInstance().LoadAddonDescriptionFromMemory(xml.RootElement(), addon))
{
// set the correct path
addon->Props().path = items[0]->GetPath();
addon->Props().icon = URIUtils::AddFileToFolder(items[0]->GetPath(), "icon.png");
// install the addon
return DoInstall(addon, RepositoryPtr());
}
CEventLog::GetInstance().AddWithNotification(
EventPtr(new CNotificationEvent(EventLevelError, 24045,
StringUtils::Format(g_localizeStrings.Get(24143).c_str(), path.c_str()))), false);
return false;
}