code.vuplus.com Git - vuplus_xbmc/blob - xbmc/settings/Settings.cpp

   1 /*
   2  *      Copyright (C) 2005-2013 Team XBMC
   3  *      http://xbmc.org
   4  *
   5  *  This Program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This Program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with XBMC; see the file COPYING.  If not, see
  17  *  <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #include "system.h"
  22
  23 #include "Settings.h"
  24 #include "Application.h"
  25 #include "Autorun.h"
  26 #include "GUIPassword.h"
  27 #include "LangInfo.h"
  28 #include "Util.h"
  29 #include "addons/AddonManager.h"
  30 #include "addons/Skin.h"
  31 #include "cores/AudioEngine/AEFactory.h"
  32 #include "cores/dvdplayer/DVDCodecs/Video/DVDVideoCodec.h"
  33 #if defined(HAVE_LIBCRYSTALHD)
  34 #include "cores/dvdplayer/DVDCodecs/Video/CrystalHD.h"
  35 #endif // defined(HAVE_LIBCRYSTALHD)
  36 #include "cores/playercorefactory/PlayerCoreFactory.h"
  37 #include "cores/VideoRenderers/BaseRenderer.h"
  38 #include "filesystem/File.h"
  39 #include "guilib/GraphicContext.h"
  40 #include "guilib/GUIAudioManager.h"
  41 #include "guilib/GUIFontManager.h"
  42 #include "guilib/LocalizeStrings.h"
  43 #include "guilib/StereoscopicsManager.h"
  44 #include "input/MouseStat.h"
  45 #if defined(TARGET_WINDOWS)
  46 #include "input/windows/WINJoystick.h"
  47 #elif defined(HAS_SDL_JOYSTICK)
  48 #include "input/SDLJoystick.h"
  49 #endif // defined(HAS_SDL_JOYSTICK)
  50 #if defined(TARGET_POSIX)
  51 #include "linux/LinuxTimezone.h"
  52 #endif // defined(TARGET_POSIX)
  53 #include "network/NetworkServices.h"
  54 #include "network/upnp/UPnPSettings.h"
  55 #include "network/WakeOnAccess.h"
  56 #if defined(TARGET_DARWIN_OSX)
  57 #include "osx/XBMCHelper.h"
  58 #endif // defined(TARGET_DARWIN_OSX)
  59 #if defined(TARGET_DARWIN)
  60 #include "osx/DarwinUtils.h"
  61 #endif
  62 #include "peripherals/Peripherals.h"
  63 #include "powermanagement/PowerManager.h"
  64 #include "profiles/ProfilesManager.h"
  65 #include "pvr/PVRManager.h"
  66 #include "pvr/windows/GUIWindowPVRGuide.h"
  67 #include "settings/AdvancedSettings.h"
  68 #include "settings/DisplaySettings.h"
  69 #include "settings/MediaSettings.h"
  70 #include "settings/MediaSourceSettings.h"
  71 #include "settings/SettingAddon.h"
  72 #include "settings/SettingControl.h"
  73 #include "settings/SettingPath.h"
  74 #include "settings/SkinSettings.h"
  75 #include "settings/lib/SettingsManager.h"
  76 #include "threads/SingleLock.h"
  77 #include "utils/CharsetConverter.h"
  78 #include "utils/log.h"
  79 #include "utils/RssManager.h"
  80 #include "utils/StringUtils.h"
  81 #include "utils/SystemInfo.h"
  82 #include "utils/Weather.h"
  83 #include "utils/XBMCTinyXML.h"
  84 #include "view/ViewStateSettings.h"
  85 #include "windowing/WindowingFactory.h"
  86 #if defined(TARGET_ANDROID)
  87 #include "android/activity/AndroidFeatures.h"
  88 #endif
  89
  90 #if defined(HAS_LIBAMCODEC)
  91 #include "utils/AMLUtils.h"
  92 #endif
  93
  94 #define SETTINGS_XML_FOLDER "special://xbmc/system/settings/"
  95 #define SETTINGS_XML_ROOT   "settings"
  96
  97 using namespace XFILE;
  98
  99 bool AddonHasSettings(const std::string &condition, const std::string &value, const std::string &settingId)
 100 {
 101   if (settingId.empty())
 102     return false;
 103
 104   CSettingAddon *setting = (CSettingAddon*)CSettings::Get().GetSetting(settingId);
 105   if (setting == NULL)
 106     return false;
 107
 108   ADDON::AddonPtr addon;
 109   if (!ADDON::CAddonMgr::Get().GetAddon(setting->GetValue(), addon, setting->GetAddonType()) || addon == NULL)
 110     return false;
 111
 112   if (addon->Type() == ADDON::ADDON_SKIN)
 113     return ((ADDON::CSkinInfo*)addon.get())->HasSkinFile("SkinSettings.xml");
 114
 115   return addon->HasSettings();
 116 }
 117
 118 bool CheckMasterLock(const std::string &condition, const std::string &value, const std::string &settingId)
 119 {
 120   return g_passwordManager.IsMasterLockUnlocked(StringUtils::EqualsNoCase(value, "true"));
 121 }
 122
 123 bool CheckPVRParentalPin(const std::string &condition, const std::string &value, const std::string &settingId)
 124 {
 125   return PVR::g_PVRManager.CheckParentalPIN(g_localizeStrings.Get(19262).c_str());
 126 }
 127
 128 bool HasPeripherals(const std::string &condition, const std::string &value, const std::string &settingId)
 129 {
 130   return PERIPHERALS::g_peripherals.GetNumberOfPeripherals() > 0;
 131 }
 132
 133 bool IsFullscreen(const std::string &condition, const std::string &value, const std::string &settingId)
 134 {
 135   return g_Windowing.IsFullScreen();
 136 }
 137
 138 bool IsMasterUser(const std::string &condition, const std::string &value, const std::string &settingId)
 139 {
 140   return g_passwordManager.bMasterUser;
 141 }
 142
 143 bool IsUsingTTFSubtitles(const std::string &condition, const std::string &value, const std::string &settingId)
 144 {
 145   return CUtil::IsUsingTTFSubtitles();
 146 }
 147
 148 bool ProfileCanWriteDatabase(const std::string &condition, const std::string &value, const std::string &settingId)
 149 {
 150   return CProfilesManager::Get().GetCurrentProfile().canWriteDatabases();
 151 }
 152
 153 bool ProfileCanWriteSources(const std::string &condition, const std::string &value, const std::string &settingId)
 154 {
 155   return CProfilesManager::Get().GetCurrentProfile().canWriteSources();
 156 }
 157
 158 bool ProfileHasAddons(const std::string &condition, const std::string &value, const std::string &settingId)
 159 {
 160   return CProfilesManager::Get().GetCurrentProfile().hasAddons();
 161 }
 162
 163 bool ProfileHasDatabase(const std::string &condition, const std::string &value, const std::string &settingId)
 164 {
 165   return CProfilesManager::Get().GetCurrentProfile().hasDatabases();
 166 }
 167
 168 bool ProfileHasSources(const std::string &condition, const std::string &value, const std::string &settingId)
 169 {
 170   return CProfilesManager::Get().GetCurrentProfile().hasSources();
 171 }
 172
 173 bool ProfileHasAddonManagerLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 174 {
 175   return CProfilesManager::Get().GetCurrentProfile().addonmanagerLocked();
 176 }
 177
 178 bool ProfileHasFilesLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 179 {
 180   return CProfilesManager::Get().GetCurrentProfile().filesLocked();
 181 }
 182
 183 bool ProfileHasMusicLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 184 {
 185   return CProfilesManager::Get().GetCurrentProfile().musicLocked();
 186 }
 187
 188 bool ProfileHasPicturesLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 189 {
 190   return CProfilesManager::Get().GetCurrentProfile().picturesLocked();
 191 }
 192
 193 bool ProfileHasProgramsLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 194 {
 195   return CProfilesManager::Get().GetCurrentProfile().programsLocked();
 196 }
 197
 198 bool ProfileHasSettingsLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 199 {
 200   LOCK_LEVEL::SETTINGS_LOCK slValue=LOCK_LEVEL::ALL;
 201   if (StringUtils::EqualsNoCase(value, "none"))
 202     slValue = LOCK_LEVEL::NONE;
 203   else if (StringUtils::EqualsNoCase(value, "standard"))
 204     slValue = LOCK_LEVEL::STANDARD;
 205   else if (StringUtils::EqualsNoCase(value, "advanced"))
 206     slValue = LOCK_LEVEL::ADVANCED;
 207   else if (StringUtils::EqualsNoCase(value, "expert"))
 208     slValue = LOCK_LEVEL::EXPERT;
 209   return slValue <= CProfilesManager::Get().GetCurrentProfile().settingsLockLevel();
 210 }
 211
 212 bool ProfileHasVideosLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 213 {
 214   return CProfilesManager::Get().GetCurrentProfile().videoLocked();
 215 }
 216
 217 bool ProfileLockMode(const std::string &condition, const std::string &value, const std::string &settingId)
 218 {
 219   char *tmp = NULL;
 220   LockType lock = (LockType)strtol(value.c_str(), &tmp, 0);
 221   if (tmp != NULL && *tmp != '\0')
 222     return false;
 223
 224   return CProfilesManager::Get().GetCurrentProfile().getLockMode() == lock;
 225 }
 226
 227 CSettings::CSettings()
 228   : m_initialized(false)
 229 {
 230   m_settingsManager = new CSettingsManager();
 231 }
 232
 233 CSettings::~CSettings()
 234 {
 235   Uninitialize();
 236
 237   delete m_settingsManager;
 238 }
 239
 240 CSettings& CSettings::Get()
 241 {
 242   static CSettings sSettings;
 243   return sSettings;
 244 }
 245
 246 CSetting* CSettings::CreateSetting(const std::string &settingType, const std::string &settingId, CSettingsManager *settingsManager /* = NULL */) const
 247 {
 248   if (StringUtils::EqualsNoCase(settingType, "addon"))
 249     return new CSettingAddon(settingId, settingsManager);
 250   else if (StringUtils::EqualsNoCase(settingType, "path"))
 251     return new CSettingPath(settingId, settingsManager);
 252
 253   return NULL;
 254 }
 255
 256 ISettingControl* CSettings::CreateControl(const std::string &controlType) const
 257 {
 258   if (StringUtils::EqualsNoCase(controlType, "toggle"))
 259     return new CSettingControlCheckmark();
 260   else if (StringUtils::EqualsNoCase(controlType, "spinner"))
 261     return new CSettingControlSpinner();
 262   else if (StringUtils::EqualsNoCase(controlType, "edit"))
 263     return new CSettingControlEdit();
 264   else if (StringUtils::EqualsNoCase(controlType, "button"))
 265     return new CSettingControlButton();
 266   else if (StringUtils::EqualsNoCase(controlType, "list"))
 267     return new CSettingControlList();
 268
 269   return NULL;
 270 }
 271
 272 bool CSettings::Initialize()
 273 {
 274   CSingleLock lock(m_critical);
 275   if (m_initialized)
 276     return false;
 277
 278   // register custom setting types
 279   InitializeSettingTypes();
 280   // register custom setting controls
 281   InitializeControls();
 282
 283   // option fillers and conditions need to be
 284   // initialized before the setting definitions
 285   InitializeOptionFillers();
 286   InitializeConditions();
 287
 288   // load the settings definitions
 289   if (!InitializeDefinitions())
 290     return false;
 291
 292   m_settingsManager->SetInitialized();
 293
 294   InitializeISettingsHandlers();
 295   InitializeISubSettings();
 296   InitializeISettingCallbacks();
 297
 298   m_initialized = true;
 299
 300   return true;
 301 }
 302
 303 bool CSettings::Load()
 304 {
 305   return Load(CProfilesManager::Get().GetSettingsFile());
 306 }
 307
 308 bool CSettings::Load(const std::string &file)
 309 {
 310   CXBMCTinyXML xmlDoc;
 311   bool updated = false;
 312   if (!XFILE::CFile::Exists(file) || !xmlDoc.LoadFile(file) ||
 313       !m_settingsManager->Load(xmlDoc.RootElement(), updated))
 314   {
 315     CLog::Log(LOGERROR, "CSettingsManager: unable to load settings from %s, creating new default settings", file.c_str());
 316     if (!Reset())
 317       return false;
 318
 319     if (!Load(file))
 320       return false;
 321   }
 322   // if the settings had to be updated, we need to save the changes
 323   else if (updated)
 324     return Save(file);
 325
 326   return true;
 327 }
 328
 329 bool CSettings::Load(const TiXmlElement *root, bool hide /* = false */)
 330 {
 331   if (root == NULL)
 332     return false;
 333
 334   std::map<std::string, CSetting*> *loadedSettings = NULL;
 335   if (hide)
 336     loadedSettings = new std::map<std::string, CSetting*>();
 337
 338   bool updated;
 339   // only trigger settings events if hiding is disabled
 340   bool success = m_settingsManager->Load(root, updated, !hide, loadedSettings);
 341   // if necessary hide all the loaded settings
 342   if (success && hide && loadedSettings != NULL)
 343   {
 344     for(std::map<std::string, CSetting*>::const_iterator setting = loadedSettings->begin(); setting != loadedSettings->end(); ++setting)
 345       setting->second->SetVisible(false);
 346   }
 347   delete loadedSettings;
 348
 349   return success;
 350 }
 351
 352 void CSettings::SetLoaded()
 353 {
 354   m_settingsManager->SetLoaded();
 355 }
 356
 357 bool CSettings::Save()
 358 {
 359   return Save(CProfilesManager::Get().GetSettingsFile());
 360 }
 361
 362 bool CSettings::Save(const std::string &file)
 363 {
 364   CXBMCTinyXML xmlDoc;
 365   TiXmlElement rootElement(SETTINGS_XML_ROOT);
 366   TiXmlNode *root = xmlDoc.InsertEndChild(rootElement);
 367   if (root == NULL)
 368     return false;
 369
 370   if (!m_settingsManager->Save(root))
 371     return false;
 372
 373   return xmlDoc.SaveFile(file);
 374 }
 375
 376 void CSettings::Unload()
 377 {
 378   CSingleLock lock(m_critical);
 379   m_settingsManager->Unload();
 380 }
 381
 382 void CSettings::Uninitialize()
 383 {
 384   CSingleLock lock(m_critical);
 385   if (!m_initialized)
 386     return;
 387
 388   // unregister setting option fillers
 389   m_settingsManager->UnregisterSettingOptionsFiller("audiocdactions");
 390   m_settingsManager->UnregisterSettingOptionsFiller("audiocdencoders");
 391   m_settingsManager->UnregisterSettingOptionsFiller("aequalitylevels");
 392   m_settingsManager->UnregisterSettingOptionsFiller("audiodevices");
 393   m_settingsManager->UnregisterSettingOptionsFiller("audiodevicespassthrough");
 394   m_settingsManager->UnregisterSettingOptionsFiller("audiostreamsilence");
 395   m_settingsManager->UnregisterSettingOptionsFiller("charsets");
 396   m_settingsManager->UnregisterSettingOptionsFiller("epgguideviews");
 397   m_settingsManager->UnregisterSettingOptionsFiller("fontheights");
 398   m_settingsManager->UnregisterSettingOptionsFiller("fonts");
 399   m_settingsManager->UnregisterSettingOptionsFiller("languages");
 400   m_settingsManager->UnregisterSettingOptionsFiller("pvrstartlastchannel");
 401   m_settingsManager->UnregisterSettingOptionsFiller("refreshchangedelays");
 402   m_settingsManager->UnregisterSettingOptionsFiller("refreshrates");
 403   m_settingsManager->UnregisterSettingOptionsFiller("regions");
 404   m_settingsManager->UnregisterSettingOptionsFiller("rendermethods");
 405   m_settingsManager->UnregisterSettingOptionsFiller("resolutions");
 406   m_settingsManager->UnregisterSettingOptionsFiller("screens");
 407   m_settingsManager->UnregisterSettingOptionsFiller("stereoscopicmodes");
 408   m_settingsManager->UnregisterSettingOptionsFiller("preferedstereoscopicviewmodes");
 409   m_settingsManager->UnregisterSettingOptionsFiller("shutdownstates");
 410   m_settingsManager->UnregisterSettingOptionsFiller("startupwindows");
 411   m_settingsManager->UnregisterSettingOptionsFiller("streamlanguages");
 412   m_settingsManager->UnregisterSettingOptionsFiller("skincolors");
 413   m_settingsManager->UnregisterSettingOptionsFiller("skinfonts");
 414   m_settingsManager->UnregisterSettingOptionsFiller("skinsounds");
 415   m_settingsManager->UnregisterSettingOptionsFiller("skinthemes");
 416 #if defined(TARGET_LINUX)
 417   m_settingsManager->UnregisterSettingOptionsFiller("timezonecountries");
 418   m_settingsManager->UnregisterSettingOptionsFiller("timezones");
 419 #endif // defined(TARGET_LINUX)
 420   m_settingsManager->UnregisterSettingOptionsFiller("verticalsyncs");
 421
 422   // unregister ISettingCallback implementations
 423   m_settingsManager->UnregisterCallback(&g_advancedSettings);
 424   m_settingsManager->UnregisterCallback(&CMediaSettings::Get());
 425   m_settingsManager->UnregisterCallback(&CDisplaySettings::Get());
 426   m_settingsManager->UnregisterCallback(&CStereoscopicsManager::Get());
 427   m_settingsManager->UnregisterCallback(&g_application);
 428   m_settingsManager->UnregisterCallback(&g_audioManager);
 429   m_settingsManager->UnregisterCallback(&g_charsetConverter);
 430   m_settingsManager->UnregisterCallback(&g_graphicsContext);
 431   m_settingsManager->UnregisterCallback(&g_langInfo);
 432 #if defined(TARGET_WINDOWS) || defined(HAS_SDL_JOYSTICK)
 433   m_settingsManager->UnregisterCallback(&g_Joystick);
 434 #endif
 435   m_settingsManager->UnregisterCallback(&g_Mouse);
 436   m_settingsManager->UnregisterCallback(&CNetworkServices::Get());
 437   m_settingsManager->UnregisterCallback(&g_passwordManager);
 438   m_settingsManager->UnregisterCallback(&PVR::g_PVRManager);
 439   m_settingsManager->UnregisterCallback(&CRssManager::Get());
 440 #if defined(TARGET_LINUX)
 441   m_settingsManager->UnregisterCallback(&g_timezone);
 442 #endif // defined(TARGET_LINUX)
 443   m_settingsManager->UnregisterCallback(&g_weatherManager);
 444   m_settingsManager->UnregisterCallback(&PERIPHERALS::CPeripherals::Get());
 445 #if defined(TARGET_DARWIN_OSX)
 446   m_settingsManager->UnregisterCallback(&XBMCHelper::GetInstance());
 447 #endif
 448
 449   // cleanup the settings manager
 450   m_settingsManager->Clear();
 451
 452   // unregister ISubSettings implementations
 453   m_settingsManager->UnregisterSubSettings(&g_application);
 454   m_settingsManager->UnregisterSubSettings(&CDisplaySettings::Get());
 455   m_settingsManager->UnregisterSubSettings(&CMediaSettings::Get());
 456   m_settingsManager->UnregisterSubSettings(&CSkinSettings::Get());
 457   m_settingsManager->UnregisterSubSettings(&g_sysinfo);
 458   m_settingsManager->UnregisterSubSettings(&CViewStateSettings::Get());
 459
 460   // unregister ISettingsHandler implementations
 461   m_settingsManager->UnregisterSettingsHandler(&g_advancedSettings);
 462   m_settingsManager->UnregisterSettingsHandler(&CMediaSourceSettings::Get());
 463   m_settingsManager->UnregisterSettingsHandler(&CPlayerCoreFactory::Get());
 464   m_settingsManager->UnregisterSettingsHandler(&CProfilesManager::Get());
 465 #ifdef HAS_UPNP
 466   m_settingsManager->UnregisterSettingsHandler(&CUPnPSettings::Get());
 467 #endif
 468   m_settingsManager->UnregisterSettingsHandler(&CWakeOnAccess::Get());
 469   m_settingsManager->UnregisterSettingsHandler(&CRssManager::Get());
 470   m_settingsManager->UnregisterSettingsHandler(&g_application);
 471 #if defined(TARGET_LINUX) && !defined(TARGET_ANDROID) && !defined(__UCLIBC__)
 472   m_settingsManager->UnregisterSettingsHandler(&g_timezone);
 473 #endif
 474
 475   m_initialized = false;
 476 }
 477
 478 void CSettings::RegisterCallback(ISettingCallback *callback, const std::set<std::string> &settingList)
 479 {
 480   m_settingsManager->RegisterCallback(callback, settingList);
 481 }
 482
 483 void CSettings::UnregisterCallback(ISettingCallback *callback)
 484 {
 485   m_settingsManager->UnregisterCallback(callback);
 486 }
 487
 488 CSetting* CSettings::GetSetting(const std::string &id) const
 489 {
 490   CSingleLock lock(m_critical);
 491   if (id.empty())
 492     return NULL;
 493
 494   return m_settingsManager->GetSetting(id);
 495 }
 496
 497 std::vector<CSettingSection*> CSettings::GetSections() const
 498 {
 499   CSingleLock lock(m_critical);
 500   return m_settingsManager->GetSections();
 501 }
 502
 503 CSettingSection* CSettings::GetSection(const std::string &section) const
 504 {
 505   CSingleLock lock(m_critical);
 506   if (section.empty())
 507     return NULL;
 508
 509   return m_settingsManager->GetSection(section);
 510 }
 511
 512 bool CSettings::GetBool(const std::string &id) const
 513 {
 514   // Backward compatibility (skins use this setting)
 515   if (StringUtils::EqualsNoCase(id, "lookandfeel.enablemouse"))
 516     return GetBool("input.enablemouse");
 517
 518   return m_settingsManager->GetBool(id);
 519 }
 520
 521 bool CSettings::SetBool(const std::string &id, bool value)
 522 {
 523   return m_settingsManager->SetBool(id, value);
 524 }
 525
 526 bool CSettings::ToggleBool(const std::string &id)
 527 {
 528   return m_settingsManager->ToggleBool(id);
 529 }
 530
 531 int CSettings::GetInt(const std::string &id) const
 532 {
 533   return m_settingsManager->GetInt(id);
 534 }
 535
 536 bool CSettings::SetInt(const std::string &id, int value)
 537 {
 538   return m_settingsManager->SetInt(id, value);
 539 }
 540
 541 double CSettings::GetNumber(const std::string &id) const
 542 {
 543   return m_settingsManager->GetNumber(id);
 544 }
 545
 546 bool CSettings::SetNumber(const std::string &id, double value)
 547 {
 548   return m_settingsManager->SetNumber(id, value);
 549 }
 550
 551 std::string CSettings::GetString(const std::string &id) const
 552 {
 553   return m_settingsManager->GetString(id);
 554 }
 555
 556 bool CSettings::SetString(const std::string &id, const std::string &value)
 557 {
 558   return m_settingsManager->SetString(id, value);
 559 }
 560
 561 std::vector<CVariant> CSettings::GetList(const std::string &id) const
 562 {
 563   CSetting *setting = m_settingsManager->GetSetting(id);
 564   if (setting == NULL || setting->GetType() != SettingTypeList)
 565     return std::vector<CVariant>();
 566
 567   CSettingList *listSetting = static_cast<CSettingList*>(setting);
 568   return ListToValues(listSetting, listSetting->GetValue());
 569 }
 570
 571 bool CSettings::SetList(const std::string &id, const std::vector<CVariant> &value)
 572 {
 573   CSetting *setting = m_settingsManager->GetSetting(id);
 574   if (setting == NULL || setting->GetType() != SettingTypeList)
 575     return false;
 576
 577   CSettingList *listSetting = static_cast<CSettingList*>(setting);
 578   SettingPtrList newValues;
 579   bool ret = true;
 580   int index = 0;
 581   for (std::vector<CVariant>::const_iterator itValue = value.begin(); itValue != value.end(); ++itValue)
 582   {
 583     CSetting *settingValue = listSetting->GetDefinition()->Clone(StringUtils::Format("%s.%d", listSetting->GetId().c_str(), index++));
 584     if (settingValue == NULL)
 585       return false;
 586
 587     switch (listSetting->GetElementType())
 588     {
 589       case SettingTypeBool:
 590         if (!itValue->isBoolean())
 591           return false;
 592         ret = static_cast<CSettingBool*>(settingValue)->SetValue(itValue->asBoolean());
 593         break;
 594
 595       case SettingTypeInteger:
 596         if (!itValue->isInteger())
 597           return false;
 598         ret = static_cast<CSettingInt*>(settingValue)->SetValue((int)itValue->asInteger());
 599         break;
 600
 601       case SettingTypeNumber:
 602         if (!itValue->isDouble())
 603           return false;
 604         ret = static_cast<CSettingNumber*>(settingValue)->SetValue(itValue->asDouble());
 605         break;
 606
 607       case SettingTypeString:
 608         if (!itValue->isString())
 609           return false;
 610         ret = static_cast<CSettingString*>(settingValue)->SetValue(itValue->asString());
 611         break;
 612
 613       default:
 614         ret = false;
 615         break;
 616     }
 617
 618     if (!ret)
 619     {
 620       delete settingValue;
 621       return false;
 622     }
 623
 624     newValues.push_back(SettingPtr(settingValue));
 625   }
 626
 627   return listSetting->SetValue(newValues);
 628 }
 629
 630 bool CSettings::LoadSetting(const TiXmlNode *node, const std::string &settingId)
 631 {
 632   return m_settingsManager->LoadSetting(node, settingId);
 633 }
 634
 635 std::vector<CVariant> CSettings::ListToValues(const CSettingList *setting, const std::vector< boost::shared_ptr<CSetting> > &values)
 636 {
 637   std::vector<CVariant> realValues;
 638
 639   if (setting == NULL)
 640     return realValues;
 641
 642   for (SettingPtrList::const_iterator it = values.begin(); it != values.end(); ++it)
 643   {
 644     switch (setting->GetElementType())
 645     {
 646       case SettingTypeBool:
 647         realValues.push_back(static_cast<const CSettingBool*>(it->get())->GetValue());
 648         break;
 649
 650       case SettingTypeInteger:
 651         realValues.push_back(static_cast<const CSettingInt*>(it->get())->GetValue());
 652         break;
 653
 654       case SettingTypeNumber:
 655         realValues.push_back(static_cast<const CSettingNumber*>(it->get())->GetValue());
 656         break;
 657
 658       case SettingTypeString:
 659         realValues.push_back(static_cast<const CSettingString*>(it->get())->GetValue());
 660         break;
 661
 662       default:
 663         break;
 664     }
 665   }
 666
 667   return realValues;
 668 }
 669
 670 bool CSettings::Initialize(const std::string &file)
 671 {
 672   CXBMCTinyXML xmlDoc;
 673   if (!xmlDoc.LoadFile(file.c_str()))
 674   {
 675     CLog::Log(LOGERROR, "CSettings: error loading settings definition from %s, Line %d\n%s", file.c_str(), xmlDoc.ErrorRow(), xmlDoc.ErrorDesc());
 676     return false;
 677   }
 678
 679   CLog::Log(LOGDEBUG, "CSettings: loaded settings definition from %s", file.c_str());
 680
 681   TiXmlElement *root = xmlDoc.RootElement();
 682   if (root == NULL)
 683     return false;
 684
 685   return m_settingsManager->Initialize(root);
 686 }
 687
 688 bool CSettings::InitializeDefinitions()
 689 {
 690   if (!Initialize(SETTINGS_XML_FOLDER "settings.xml"))
 691   {
 692     CLog::Log(LOGFATAL, "Unable to load settings definitions");
 693     return false;
 694   }
 695 #if defined(TARGET_WINDOWS)
 696   if (CFile::Exists(SETTINGS_XML_FOLDER "win32.xml") && !Initialize(SETTINGS_XML_FOLDER "win32.xml"))
 697     CLog::Log(LOGFATAL, "Unable to load win32-specific settings definitions");
 698 #elif defined(TARGET_ANDROID)
 699   if (CFile::Exists(SETTINGS_XML_FOLDER "android.xml") && !Initialize(SETTINGS_XML_FOLDER "android.xml"))
 700     CLog::Log(LOGFATAL, "Unable to load android-specific settings definitions");
 701 #elif defined(TARGET_RASPBERRY_PI)
 702   if (CFile::Exists(SETTINGS_XML_FOLDER "rbp.xml") && !Initialize(SETTINGS_XML_FOLDER "rbp.xml"))
 703     CLog::Log(LOGFATAL, "Unable to load rbp-specific settings definitions");
 704 #elif defined(TARGET_FREEBSD)
 705   if (CFile::Exists(SETTINGS_XML_FOLDER "freebsd.xml") && !Initialize(SETTINGS_XML_FOLDER "freebsd.xml"))
 706     CLog::Log(LOGFATAL, "Unable to load freebsd-specific settings definitions");
 707 #elif defined(TARGET_LINUX)
 708   if (CFile::Exists(SETTINGS_XML_FOLDER "linux.xml") && !Initialize(SETTINGS_XML_FOLDER "linux.xml"))
 709     CLog::Log(LOGFATAL, "Unable to load linux-specific settings definitions");
 710 #elif defined(TARGET_DARWIN)
 711   if (CFile::Exists(SETTINGS_XML_FOLDER "darwin.xml") && !Initialize(SETTINGS_XML_FOLDER "darwin.xml"))
 712     CLog::Log(LOGFATAL, "Unable to load darwin-specific settings definitions");
 713 #if defined(TARGET_DARWIN_OSX)
 714   if (CFile::Exists(SETTINGS_XML_FOLDER "darwin_osx.xml") && !Initialize(SETTINGS_XML_FOLDER "darwin_osx.xml"))
 715     CLog::Log(LOGFATAL, "Unable to load osx-specific settings definitions");
 716 #elif defined(TARGET_DARWIN_IOS)
 717   if (CFile::Exists(SETTINGS_XML_FOLDER "darwin_ios.xml") && !Initialize(SETTINGS_XML_FOLDER "darwin_ios.xml"))
 718     CLog::Log(LOGFATAL, "Unable to load ios-specific settings definitions");
 719 #if defined(TARGET_DARWIN_IOS_ATV2)
 720   if (CFile::Exists(SETTINGS_XML_FOLDER "darwin_ios_atv2.xml") && !Initialize(SETTINGS_XML_FOLDER "darwin_ios_atv2.xml"))
 721     CLog::Log(LOGFATAL, "Unable to load atv2-specific settings definitions");
 722 #endif
 723 #endif
 724 #endif
 725
 726   // load any custom visibility and default values before loading the special
 727   // appliance.xml so that appliances are able to overwrite even those values
 728   InitializeVisibility();
 729   InitializeDefaults();
 730
 731   if (CFile::Exists(SETTINGS_XML_FOLDER "appliance.xml") && !Initialize(SETTINGS_XML_FOLDER "appliance.xml"))
 732     CLog::Log(LOGFATAL, "Unable to load appliance-specific settings definitions");
 733
 734   return true;
 735 }
 736
 737 void CSettings::InitializeSettingTypes()
 738 {
 739   // register "addon" and "path" setting types implemented by CSettingAddon
 740   m_settingsManager->RegisterSettingType("addon", this);
 741   m_settingsManager->RegisterSettingType("path", this);
 742 }
 743
 744 void CSettings::InitializeControls()
 745 {
 746   m_settingsManager->RegisterSettingControl("toggle", this);
 747   m_settingsManager->RegisterSettingControl("spinner", this);
 748   m_settingsManager->RegisterSettingControl("edit", this);
 749   m_settingsManager->RegisterSettingControl("button", this);
 750   m_settingsManager->RegisterSettingControl("list", this);
 751 }
 752
 753 void CSettings::InitializeVisibility()
 754 {
 755   // hide some settings if necessary
 756 #if defined(TARGET_DARWIN)
 757   CSettingString* timezonecountry = (CSettingString*)m_settingsManager->GetSetting("locale.timezonecountry");
 758   CSettingString* timezone = (CSettingString*)m_settingsManager->GetSetting("locale.timezone");
 759
 760   if (!g_sysinfo.IsAppleTV2() || GetIOSVersion() >= 4.3)
 761   {
 762     timezonecountry->SetRequirementsMet(false);
 763     timezone->SetRequirementsMet(false);
 764   }
 765 #endif
 766 }
 767
 768 void CSettings::InitializeDefaults()
 769 {
 770   // set some default values if necessary
 771 #if defined(HAS_SKIN_TOUCHED) && defined(TARGET_DARWIN_IOS) && !defined(TARGET_DARWIN_IOS_ATV2)
 772   ((CSettingAddon*)m_settingsManager->GetSetting("lookandfeel.skin"))->SetDefault("skin.touched");
 773 #endif
 774
 775 #if defined(TARGET_POSIX)
 776   CSettingString* timezonecountry = (CSettingString*)m_settingsManager->GetSetting("locale.timezonecountry");
 777   CSettingString* timezone = (CSettingString*)m_settingsManager->GetSetting("locale.timezone");
 778
 779   if (timezonecountry->IsVisible())
 780     timezonecountry->SetDefault(g_timezone.GetCountryByTimezone(g_timezone.GetOSConfiguredTimezone()));
 781   if (timezone->IsVisible())
 782     timezone->SetDefault(g_timezone.GetOSConfiguredTimezone());
 783 #endif // defined(TARGET_POSIX)
 784
 785 #if defined(TARGET_WINDOWS)
 786   #if defined(HAS_DX)
 787   ((CSettingString*)m_settingsManager->GetSetting("musicplayer.visualisation"))->SetDefault("visualization.milkdrop");
 788   #endif
 789
 790   #if !defined(HAS_GL)
 791   // We prefer a fake fullscreen mode (window covering the screen rather than dedicated fullscreen)
 792   // as it works nicer with switching to other applications. However on some systems vsync is broken
 793   // when we do this (eg non-Aero on ATI in particular) and on others (AppleTV) we can't get XBMC to
 794   // the front
 795   if (g_sysinfo.IsAeroDisabled())
 796     ((CSettingBool*)m_settingsManager->GetSetting("videoscreen.fakefullscreen"))->SetDefault(false);
 797   #endif
 798 #endif
 799
 800 #if !defined(TARGET_WINDOWS)
 801   ((CSettingString*)m_settingsManager->GetSetting("audiooutput.audiodevice"))->SetDefault(CAEFactory::GetDefaultDevice(false));
 802   ((CSettingString*)m_settingsManager->GetSetting("audiooutput.passthroughdevice"))->SetDefault(CAEFactory::GetDefaultDevice(true));
 803 #endif
 804
 805   if (g_application.IsStandAlone())
 806     ((CSettingInt*)m_settingsManager->GetSetting("powermanagement.shutdownstate"))->SetDefault(POWERSTATE_SHUTDOWN);
 807
 808 #if defined(HAS_WEB_SERVER)
 809   if (CUtil::CanBindPrivileged())
 810     ((CSettingInt*)m_settingsManager->GetSetting("services.webserverport"))->SetDefault(80);
 811 #endif
 812 }
 813
 814 void CSettings::InitializeOptionFillers()
 815 {
 816   // register setting option fillers
 817 #ifdef HAS_DVD_DRIVE
 818   m_settingsManager->RegisterSettingOptionsFiller("audiocdactions", MEDIA_DETECT::CAutorun::SettingOptionAudioCdActionsFiller);
 819   m_settingsManager->RegisterSettingOptionsFiller("audiocdencoders", MEDIA_DETECT::CAutorun::SettingOptionAudioCdEncodersFiller);
 820 #endif
 821   m_settingsManager->RegisterSettingOptionsFiller("aequalitylevels", CAEFactory::SettingOptionsAudioQualityLevelsFiller);
 822   m_settingsManager->RegisterSettingOptionsFiller("audiodevices", CAEFactory::SettingOptionsAudioDevicesFiller);
 823   m_settingsManager->RegisterSettingOptionsFiller("audiodevicespassthrough", CAEFactory::SettingOptionsAudioDevicesPassthroughFiller);
 824   m_settingsManager->RegisterSettingOptionsFiller("audiostreamsilence", CAEFactory::SettingOptionsAudioStreamsilenceFiller);
 825   m_settingsManager->RegisterSettingOptionsFiller("charsets", CCharsetConverter::SettingOptionsCharsetsFiller);
 826   m_settingsManager->RegisterSettingOptionsFiller("epgguideviews", PVR::CGUIWindowPVRGuide::SettingOptionsEpgGuideViewFiller);
 827   m_settingsManager->RegisterSettingOptionsFiller("fonts", GUIFontManager::SettingOptionsFontsFiller);
 828   m_settingsManager->RegisterSettingOptionsFiller("languages", CLangInfo::SettingOptionsLanguagesFiller);
 829   m_settingsManager->RegisterSettingOptionsFiller("pvrstartlastchannel", PVR::CPVRManager::SettingOptionsPvrStartLastChannelFiller);
 830   m_settingsManager->RegisterSettingOptionsFiller("refreshchangedelays", CDisplaySettings::SettingOptionsRefreshChangeDelaysFiller);
 831   m_settingsManager->RegisterSettingOptionsFiller("refreshrates", CDisplaySettings::SettingOptionsRefreshRatesFiller);
 832   m_settingsManager->RegisterSettingOptionsFiller("regions", CLangInfo::SettingOptionsRegionsFiller);
 833   m_settingsManager->RegisterSettingOptionsFiller("rendermethods", CBaseRenderer::SettingOptionsRenderMethodsFiller);
 834   m_settingsManager->RegisterSettingOptionsFiller("resolutions", CDisplaySettings::SettingOptionsResolutionsFiller);
 835   m_settingsManager->RegisterSettingOptionsFiller("screens", CDisplaySettings::SettingOptionsScreensFiller);
 836   m_settingsManager->RegisterSettingOptionsFiller("stereoscopicmodes", CDisplaySettings::SettingOptionsStereoscopicModesFiller);
 837   m_settingsManager->RegisterSettingOptionsFiller("preferedstereoscopicviewmodes", CDisplaySettings::SettingOptionsPreferredStereoscopicViewModesFiller);
 838   m_settingsManager->RegisterSettingOptionsFiller("shutdownstates", CPowerManager::SettingOptionsShutdownStatesFiller);
 839   m_settingsManager->RegisterSettingOptionsFiller("startupwindows", ADDON::CSkinInfo::SettingOptionsStartupWindowsFiller);
 840   m_settingsManager->RegisterSettingOptionsFiller("streamlanguages", CLangInfo::SettingOptionsStreamLanguagesFiller);
 841   m_settingsManager->RegisterSettingOptionsFiller("skincolors", ADDON::CSkinInfo::SettingOptionsSkinColorsFiller);
 842   m_settingsManager->RegisterSettingOptionsFiller("skinfonts", ADDON::CSkinInfo::SettingOptionsSkinFontsFiller);
 843   m_settingsManager->RegisterSettingOptionsFiller("skinsounds", ADDON::CSkinInfo::SettingOptionsSkinSoundFiller);
 844   m_settingsManager->RegisterSettingOptionsFiller("skinthemes", ADDON::CSkinInfo::SettingOptionsSkinThemesFiller);
 845 #ifdef TARGET_LINUX
 846   m_settingsManager->RegisterSettingOptionsFiller("timezonecountries", CLinuxTimezone::SettingOptionsTimezoneCountriesFiller);
 847   m_settingsManager->RegisterSettingOptionsFiller("timezones", CLinuxTimezone::SettingOptionsTimezonesFiller);
 848 #endif
 849   m_settingsManager->RegisterSettingOptionsFiller("verticalsyncs", CDisplaySettings::SettingOptionsVerticalSyncsFiller);
 850 }
 851
 852 void CSettings::InitializeConditions()
 853 {
 854   // add basic conditions
 855   m_settingsManager->AddCondition("true");
 856 #ifdef HAS_UPNP
 857   m_settingsManager->AddCondition("has_upnp");
 858 #endif
 859 #ifdef HAS_AIRPLAY
 860   m_settingsManager->AddCondition("has_airplay");
 861 #endif
 862 #ifdef HAS_EVENT_SERVER
 863   m_settingsManager->AddCondition("has_event_server");
 864 #endif
 865 #ifdef HAVE_X11
 866   m_settingsManager->AddCondition("have_x11");
 867 #endif
 868 #ifdef HAS_GL
 869   m_settingsManager->AddCondition("has_gl");
 870 #endif
 871 #ifdef HAS_GLES
 872   m_settingsManager->AddCondition("has_gles");
 873 #endif
 874 #if HAS_GLES == 2
 875   m_settingsManager->AddCondition("has_glesv2");
 876 #endif
 877 #ifdef HAS_KARAOKE
 878   m_settingsManager->AddCondition("has_karaoke");
 879 #endif
 880 #ifdef HAS_SDL_JOYSTICK
 881   m_settingsManager->AddCondition("has_sdl_joystick");
 882 #endif
 883 #ifdef HAS_SKIN_TOUCHED
 884   m_settingsManager->AddCondition("has_skin_touched");
 885 #endif
 886 #ifdef HAS_TIME_SERVER
 887   m_settingsManager->AddCondition("has_time_server");
 888 #endif
 889 #ifdef HAS_WEB_SERVER
 890   m_settingsManager->AddCondition("has_web_server");
 891 #endif
 892 #ifdef HAS_ZEROCONF
 893   m_settingsManager->AddCondition("has_zeroconf");
 894 #endif
 895 #ifdef HAVE_LIBCRYSTALHD
 896   m_settingsManager->AddCondition("have_libcrystalhd");
 897   if (CCrystalHD::GetInstance()->DevicePresent())
 898     m_settingsManager->AddCondition("hascrystalhddevice");
 899 #endif
 900 #ifdef HAVE_LIBOPENMAX
 901   m_settingsManager->AddCondition("have_libopenmax");
 902 #endif
 903 #ifdef HAVE_LIBVA
 904   m_settingsManager->AddCondition("have_libva");
 905 #endif
 906 #ifdef HAVE_LIBVDPAU
 907   m_settingsManager->AddCondition("have_libvdpau");
 908 #endif
 909 #ifdef TARGET_ANDROID
 910   if (CAndroidFeatures::GetVersion() > 15)
 911     m_settingsManager->AddCondition("has_mediacodec");
 912 #endif
 913 #ifdef HAS_LIBSTAGEFRIGHT
 914   m_settingsManager->AddCondition("have_libstagefrightdecoder");
 915 #endif
 916 #ifdef HAVE_VIDEOTOOLBOXDECODER
 917   m_settingsManager->AddCondition("have_videotoolboxdecoder");
 918   if (g_sysinfo.HasVideoToolBoxDecoder())
 919     m_settingsManager->AddCondition("hasvideotoolboxdecoder");
 920 #endif
 921 #ifdef HAS_LIBAMCODEC
 922   if (aml_present())
 923     m_settingsManager->AddCondition("have_amcodec");
 924 #endif
 925 #ifdef TARGET_DARWIN_IOS_ATV2
 926   if (g_sysinfo.IsAppleTV2())
 927     m_settingsManager->AddCondition("isappletv2");
 928 #endif
 929 #if defined(TARGET_WINDOWS) && defined(HAS_DX)
 930   m_settingsManager->AddCondition("has_dx");
 931   m_settingsManager->AddCondition("hasdxva2");
 932 #endif
 933
 934   if (g_application.IsStandAlone())
 935     m_settingsManager->AddCondition("isstandalone");
 936
 937   if(CAEFactory::SupportsQualitySetting())
 938     m_settingsManager->AddCondition("has_ae_quality_levels");
 939
 940   // add more complex conditions
 941   m_settingsManager->AddCondition("addonhassettings", AddonHasSettings);
 942   m_settingsManager->AddCondition("checkmasterlock", CheckMasterLock);
 943   m_settingsManager->AddCondition("checkpvrparentalpin", CheckPVRParentalPin);
 944   m_settingsManager->AddCondition("hasperipherals", HasPeripherals);
 945   m_settingsManager->AddCondition("isfullscreen", IsFullscreen);
 946   m_settingsManager->AddCondition("ismasteruser", IsMasterUser);
 947   m_settingsManager->AddCondition("isusingttfsubtitles", IsUsingTTFSubtitles);
 948   m_settingsManager->AddCondition("profilecanwritedatabase", ProfileCanWriteDatabase);
 949   m_settingsManager->AddCondition("profilecanwritesources", ProfileCanWriteSources);
 950   m_settingsManager->AddCondition("profilehasaddons", ProfileHasAddons);
 951   m_settingsManager->AddCondition("profilehasdatabase", ProfileHasDatabase);
 952   m_settingsManager->AddCondition("profilehassources", ProfileHasSources);
 953   m_settingsManager->AddCondition("profilehasaddonmanagerlocked", ProfileHasAddonManagerLocked);
 954   m_settingsManager->AddCondition("profilehasfileslocked", ProfileHasFilesLocked);
 955   m_settingsManager->AddCondition("profilehasmusiclocked", ProfileHasMusicLocked);
 956   m_settingsManager->AddCondition("profilehaspictureslocked", ProfileHasPicturesLocked);
 957   m_settingsManager->AddCondition("profilehasprogramslocked", ProfileHasProgramsLocked);
 958   m_settingsManager->AddCondition("profilehassettingslocked", ProfileHasSettingsLocked);
 959   m_settingsManager->AddCondition("profilehasvideoslocked", ProfileHasVideosLocked);
 960   m_settingsManager->AddCondition("profilelockmode", ProfileLockMode);
 961   m_settingsManager->AddCondition("aesettingvisible", CAEFactory::IsSettingVisible);
 962   m_settingsManager->AddCondition("codecoptionvisible", CDVDVideoCodec::IsSettingVisible);
 963 }
 964
 965 void CSettings::InitializeISettingsHandlers()
 966 {
 967   // register ISettingsHandler implementations
 968   // The order of these matters! Handlers are processed in the order they were registered.
 969   m_settingsManager->RegisterSettingsHandler(&g_advancedSettings);
 970   m_settingsManager->RegisterSettingsHandler(&CMediaSourceSettings::Get());
 971   m_settingsManager->RegisterSettingsHandler(&CPlayerCoreFactory::Get());
 972   m_settingsManager->RegisterSettingsHandler(&CProfilesManager::Get());
 973 #ifdef HAS_UPNP
 974   m_settingsManager->RegisterSettingsHandler(&CUPnPSettings::Get());
 975 #endif
 976   m_settingsManager->RegisterSettingsHandler(&CWakeOnAccess::Get());
 977   m_settingsManager->RegisterSettingsHandler(&CRssManager::Get());
 978   m_settingsManager->RegisterSettingsHandler(&g_application);
 979 #if defined(TARGET_LINUX) && !defined(TARGET_ANDROID) && !defined(__UCLIBC__)
 980   m_settingsManager->RegisterSettingsHandler(&g_timezone);
 981 #endif
 982 }
 983
 984 void CSettings::InitializeISubSettings()
 985 {
 986   // register ISubSettings implementations
 987   m_settingsManager->RegisterSubSettings(&g_application);
 988   m_settingsManager->RegisterSubSettings(&CDisplaySettings::Get());
 989   m_settingsManager->RegisterSubSettings(&CMediaSettings::Get());
 990   m_settingsManager->RegisterSubSettings(&CSkinSettings::Get());
 991   m_settingsManager->RegisterSubSettings(&g_sysinfo);
 992   m_settingsManager->RegisterSubSettings(&CViewStateSettings::Get());
 993 }
 994
 995 void CSettings::InitializeISettingCallbacks()
 996 {
 997   // register any ISettingCallback implementations
 998   std::set<std::string> settingSet;
 999   settingSet.insert("debug.showloginfo");
1000   settingSet.insert("debug.setextraloglevel");
1001   m_settingsManager->RegisterCallback(&g_advancedSettings, settingSet);
1002
1003   settingSet.clear();
1004   settingSet.insert("karaoke.export");
1005   settingSet.insert("karaoke.importcsv");
1006   settingSet.insert("musiclibrary.cleanup");
1007   settingSet.insert("musiclibrary.export");
1008   settingSet.insert("musiclibrary.import");
1009   settingSet.insert("musicfiles.trackformat");
1010   settingSet.insert("musicfiles.trackformatright");
1011   settingSet.insert("videolibrary.flattentvshows");
1012   settingSet.insert("videolibrary.removeduplicates");
1013   settingSet.insert("videolibrary.groupmoviesets");
1014   settingSet.insert("videolibrary.cleanup");
1015   settingSet.insert("videolibrary.import");
1016   settingSet.insert("videolibrary.export");
1017   m_settingsManager->RegisterCallback(&CMediaSettings::Get(), settingSet);
1018
1019   settingSet.clear();
1020   settingSet.insert("videoscreen.screen");
1021   settingSet.insert("videoscreen.resolution");
1022   settingSet.insert("videoscreen.screenmode");
1023   settingSet.insert("videoscreen.vsync");
1024   m_settingsManager->RegisterCallback(&CDisplaySettings::Get(), settingSet);
1025
1026   settingSet.clear();
1027   settingSet.insert("videoscreen.stereoscopicmode");
1028   m_settingsManager->RegisterCallback(&CStereoscopicsManager::Get(), settingSet);
1029
1030   settingSet.clear();
1031   settingSet.insert("audiooutput.config");
1032   settingSet.insert("audiooutput.samplerate");
1033   settingSet.insert("audiooutput.passthrough");
1034   settingSet.insert("audiooutput.channels");
1035   settingSet.insert("audiooutput.processquality");
1036   settingSet.insert("audiooutput.guisoundmode");
1037   settingSet.insert("audiooutput.stereoupmix");
1038   settingSet.insert("audiooutput.ac3passthrough");
1039   settingSet.insert("audiooutput.ac3transcode");
1040   settingSet.insert("audiooutput.eac3passthrough");
1041   settingSet.insert("audiooutput.dtspassthrough");
1042   settingSet.insert("audiooutput.truehdpassthrough");
1043   settingSet.insert("audiooutput.dtshdpassthrough");
1044   settingSet.insert("audiooutput.audiodevice");
1045   settingSet.insert("audiooutput.passthroughdevice");
1046   settingSet.insert("audiooutput.streamsilence");
1047   settingSet.insert("audiooutput.normalizelevels");
1048   settingSet.insert("lookandfeel.skin");
1049   settingSet.insert("lookandfeel.skinsettings");
1050   settingSet.insert("lookandfeel.font");
1051   settingSet.insert("lookandfeel.skintheme");
1052   settingSet.insert("lookandfeel.skincolors");
1053   settingSet.insert("lookandfeel.skinzoom");
1054   settingSet.insert("musicplayer.replaygainpreamp");
1055   settingSet.insert("musicplayer.replaygainnogainpreamp");
1056   settingSet.insert("musicplayer.replaygaintype");
1057   settingSet.insert("musicplayer.replaygainavoidclipping");
1058   settingSet.insert("scrapers.musicvideosdefault");
1059   settingSet.insert("screensaver.mode");
1060   settingSet.insert("screensaver.preview");
1061   settingSet.insert("screensaver.settings");
1062   settingSet.insert("videoscreen.guicalibration");
1063   settingSet.insert("videoscreen.testpattern");
1064   settingSet.insert("videoplayer.useamcodec");
1065   settingSet.insert("videoplayer.usemediacodec");
1066   m_settingsManager->RegisterCallback(&g_application, settingSet);
1067
1068   settingSet.clear();
1069   settingSet.insert("lookandfeel.soundskin");
1070   m_settingsManager->RegisterCallback(&g_audioManager, settingSet);
1071
1072   settingSet.clear();
1073   settingSet.insert("subtitles.charset");
1074   settingSet.insert("karaoke.charset");
1075   settingSet.insert("locale.charset");
1076   m_settingsManager->RegisterCallback(&g_charsetConverter, settingSet);
1077
1078   settingSet.clear();
1079   settingSet.insert("videoscreen.fakefullscreen");
1080   m_settingsManager->RegisterCallback(&g_graphicsContext, settingSet);
1081
1082   settingSet.clear();
1083   settingSet.insert("locale.audiolanguage");
1084   settingSet.insert("locale.subtitlelanguage");
1085   settingSet.insert("locale.language");
1086   settingSet.insert("locale.country");
1087   m_settingsManager->RegisterCallback(&g_langInfo, settingSet);
1088
1089 #if defined(HAS_SDL_JOYSTICK)
1090   settingSet.clear();
1091   settingSet.insert("input.enablejoystick");
1092   m_settingsManager->RegisterCallback(&g_Joystick, settingSet);
1093 #endif
1094
1095   settingSet.clear();
1096   settingSet.insert("input.enablemouse");
1097   m_settingsManager->RegisterCallback(&g_Mouse, settingSet);
1098
1099 #if defined(HAS_GL) && defined(HAVE_X11)
1100   settingSet.clear();
1101   settingSet.insert("input.enablesystemkeys");
1102   m_settingsManager->RegisterCallback(&g_Windowing, settingSet);
1103 #endif
1104
1105   settingSet.clear();
1106   settingSet.insert("services.webserver");
1107   settingSet.insert("services.webserverport");
1108   settingSet.insert("services.webserverusername");
1109   settingSet.insert("services.webserverpassword");
1110   settingSet.insert("services.zeroconf");
1111   settingSet.insert("services.airplay");
1112   settingSet.insert("services.airplayvolumecontrol");
1113   settingSet.insert("services.useairplaypassword");
1114   settingSet.insert("services.airplaypassword");
1115   settingSet.insert("services.upnpserver");
1116   settingSet.insert("services.upnprenderer");
1117   settingSet.insert("services.upnpcontroller");
1118   settingSet.insert("services.esenabled");
1119   settingSet.insert("services.esport");
1120   settingSet.insert("services.esallinterfaces");
1121   settingSet.insert("services.esinitialdelay");
1122   settingSet.insert("services.escontinuousdelay");
1123   settingSet.insert("smb.winsserver");
1124   settingSet.insert("smb.workgroup");
1125   m_settingsManager->RegisterCallback(&CNetworkServices::Get(), settingSet);
1126
1127   settingSet.clear();
1128   settingSet.insert("masterlock.lockcode");
1129   m_settingsManager->RegisterCallback(&g_passwordManager, settingSet);
1130
1131   settingSet.clear();
1132   settingSet.insert("pvrmanager.enabled");
1133   settingSet.insert("pvrmanager.channelmanager");
1134   settingSet.insert("pvrmanager.channelscan");
1135   settingSet.insert("pvrmanager.resetdb");
1136   settingSet.insert("pvrclient.menuhook");
1137   settingSet.insert("pvrmenu.searchicons");
1138   settingSet.insert("epg.resetepg");
1139   settingSet.insert("pvrparental.enabled");
1140   m_settingsManager->RegisterCallback(&PVR::g_PVRManager, settingSet);
1141
1142   settingSet.clear();
1143   settingSet.insert("lookandfeel.rssedit");
1144   m_settingsManager->RegisterCallback(&CRssManager::Get(), settingSet);
1145
1146 #if defined(TARGET_LINUX)
1147   settingSet.clear();
1148   settingSet.insert("locale.timezone");
1149   settingSet.insert("locale.timezonecountry");
1150   m_settingsManager->RegisterCallback(&g_timezone, settingSet);
1151 #endif
1152
1153   settingSet.clear();
1154   settingSet.insert("weather.addon");
1155   settingSet.insert("weather.addonsettings");
1156   m_settingsManager->RegisterCallback(&g_weatherManager, settingSet);
1157
1158   settingSet.clear();
1159   settingSet.insert("input.peripherals");
1160   settingSet.insert("locale.language");
1161   m_settingsManager->RegisterCallback(&PERIPHERALS::CPeripherals::Get(), settingSet);
1162
1163 #if defined(TARGET_DARWIN_OSX)
1164   settingSet.clear();
1165   settingSet.insert("input.appleremotemode");
1166   m_settingsManager->RegisterCallback(&XBMCHelper::GetInstance(), settingSet);
1167 #endif
1168 }
1169
1170 bool CSettings::Reset()
1171 {
1172   std::string settingsFile = CProfilesManager::Get().GetSettingsFile();
1173   // try to delete the settings file
1174   if (XFILE::CFile::Exists(settingsFile, false) && !XFILE::CFile::Delete(settingsFile))
1175     CLog::Log(LOGWARNING, "Unable to delete old settings file at %s", settingsFile.c_str());
1176
1177   // unload any loaded settings
1178   Unload();
1179
1180   // try to save the default settings
1181   if (!Save())
1182   {
1183     CLog::Log(LOGWARNING, "Failed to save the default settings to %s", settingsFile.c_str());
1184     return false;
1185   }
1186
1187   return true;
1188 }