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