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 #if defined(HAVE_LIBCRYSTALHD)
  33 #include "cores/dvdplayer/DVDCodecs/Video/CrystalHD.h"
  34 #endif // defined(HAVE_LIBCRYSTALHD)
  35 #include "cores/playercorefactory/PlayerCoreFactory.h"
  36 #include "cores/VideoRenderers/BaseRenderer.h"
  37 #include "filesystem/File.h"
  38 #include "guilib/GraphicContext.h"
  39 #include "guilib/GUIAudioManager.h"
  40 #include "guilib/GUIFontManager.h"
  41 #include "guilib/LocalizeStrings.h"
  42 #include "input/MouseStat.h"
  43 #if defined(TARGET_WINDOWS)
  44 #include "input/windows/WINJoystick.h"
  45 #elif defined(HAS_SDL_JOYSTICK)
  46 #include "input/SDLJoystick.h"
  47 #endif // defined(HAS_SDL_JOYSTICK)
  48 #if defined(TARGET_POSIX)
  49 #include "linux/LinuxTimezone.h"
  50 #endif // defined(TARGET_POSIX)
  51 #include "network/NetworkServices.h"
  52 #include "network/upnp/UPnPSettings.h"
  53 #include "network/WakeOnAccess.h"
  54 #if defined(TARGET_DARWIN_OSX)
  55 #include "osx/XBMCHelper.h"
  56 #include "cores/AudioEngine/Engines/CoreAudio/CoreAudioHardware.h"
  57 #endif // defined(TARGET_DARWIN_OSX)
  58 #if defined(TARGET_DARWIN)
  59 #include "osx/DarwinUtils.h"
  60 #endif
  61 #include "peripherals/Peripherals.h"
  62 #include "powermanagement/PowerManager.h"
  63 #include "profiles/ProfilesManager.h"
  64 #include "pvr/PVRManager.h"
  65 #include "pvr/windows/GUIWindowPVRGuide.h"
  66 #include "settings/AdvancedSettings.h"
  67 #include "settings/DisplaySettings.h"
  68 #include "settings/MediaSettings.h"
  69 #include "settings/MediaSourceSettings.h"
  70 #include "settings/SettingAddon.h"
  71 #include "settings/SettingsManager.h"
  72 #include "settings/SettingPath.h"
  73 #include "settings/SkinSettings.h"
  74 #include "threads/SingleLock.h"
  75 #include "utils/CharsetConverter.h"
  76 #include "utils/log.h"
  77 #include "utils/RssManager.h"
  78 #include "utils/StringUtils.h"
  79 #include "utils/SystemInfo.h"
  80 #include "utils/Weather.h"
  81 #include "utils/XBMCTinyXML.h"
  82 #include "view/ViewStateSettings.h"
  83 #include "windowing/WindowingFactory.h"
  84
  85 #define SETTINGS_XML_FOLDER "special://xbmc/system/settings/"
  86 #define SETTINGS_XML_ROOT   "settings"
  87
  88 using namespace XFILE;
  89
  90 bool AddonHasSettings(const std::string &condition, const std::string &value, const std::string &settingId)
  91 {
  92   if (settingId.empty())
  93     return false;
  94
  95   CSettingAddon *setting = (CSettingAddon*)CSettings::Get().GetSetting(settingId);
  96   if (setting == NULL)
  97     return false;
  98
  99   ADDON::AddonPtr addon;
 100   if (!ADDON::CAddonMgr::Get().GetAddon(setting->GetValue(), addon, setting->GetAddonType()) || addon == NULL)
 101     return false;
 102
 103   if (addon->Type() == ADDON::ADDON_SKIN)
 104     return ((ADDON::CSkinInfo*)addon.get())->HasSkinFile("SkinSettings.xml");
 105
 106   return addon->HasSettings();
 107 }
 108
 109 bool CheckMasterLock(const std::string &condition, const std::string &value, const std::string &settingId)
 110 {
 111   return g_passwordManager.IsMasterLockUnlocked(StringUtils::EqualsNoCase(value, "true"));
 112 }
 113
 114 bool CheckPVRParentalPin(const std::string &condition, const std::string &value, const std::string &settingId)
 115 {
 116   return PVR::g_PVRManager.CheckParentalPIN(g_localizeStrings.Get(19262).c_str());
 117 }
 118
 119 bool HasPeripherals(const std::string &condition, const std::string &value, const std::string &settingId)
 120 {
 121   return PERIPHERALS::g_peripherals.GetNumberOfPeripherals() > 0;
 122 }
 123
 124 bool IsFullscreen(const std::string &condition, const std::string &value, const std::string &settingId)
 125 {
 126   return g_Windowing.IsFullScreen();
 127 }
 128
 129 bool IsMasterUser(const std::string &condition, const std::string &value, const std::string &settingId)
 130 {
 131   return g_passwordManager.bMasterUser;
 132 }
 133
 134 bool IsUsingTTFSubtitles(const std::string &condition, const std::string &value, const std::string &settingId)
 135 {
 136   return CUtil::IsUsingTTFSubtitles();
 137 }
 138
 139 bool ProfileCanWriteDatabase(const std::string &condition, const std::string &value, const std::string &settingId)
 140 {
 141   return CProfilesManager::Get().GetCurrentProfile().canWriteDatabases();
 142 }
 143
 144 bool ProfileCanWriteSources(const std::string &condition, const std::string &value, const std::string &settingId)
 145 {
 146   return CProfilesManager::Get().GetCurrentProfile().canWriteSources();
 147 }
 148
 149 bool ProfileHasAddons(const std::string &condition, const std::string &value, const std::string &settingId)
 150 {
 151   return CProfilesManager::Get().GetCurrentProfile().hasAddons();
 152 }
 153
 154 bool ProfileHasDatabase(const std::string &condition, const std::string &value, const std::string &settingId)
 155 {
 156   return CProfilesManager::Get().GetCurrentProfile().hasDatabases();
 157 }
 158
 159 bool ProfileHasSources(const std::string &condition, const std::string &value, const std::string &settingId)
 160 {
 161   return CProfilesManager::Get().GetCurrentProfile().hasSources();
 162 }
 163
 164 bool ProfileHasAddonManagerLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 165 {
 166   return CProfilesManager::Get().GetCurrentProfile().addonmanagerLocked();
 167 }
 168
 169 bool ProfileHasFilesLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 170 {
 171   return CProfilesManager::Get().GetCurrentProfile().filesLocked();
 172 }
 173
 174 bool ProfileHasMusicLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 175 {
 176   return CProfilesManager::Get().GetCurrentProfile().musicLocked();
 177 }
 178
 179 bool ProfileHasPicturesLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 180 {
 181   return CProfilesManager::Get().GetCurrentProfile().picturesLocked();
 182 }
 183
 184 bool ProfileHasProgramsLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 185 {
 186   return CProfilesManager::Get().GetCurrentProfile().programsLocked();
 187 }
 188
 189 bool ProfileHasSettingsLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 190 {
 191   LOCK_LEVEL::SETTINGS_LOCK slValue=LOCK_LEVEL::ALL;
 192   if (StringUtils::EqualsNoCase(value, "none"))
 193     slValue = LOCK_LEVEL::NONE;
 194   else if (StringUtils::EqualsNoCase(value, "standard"))
 195     slValue = LOCK_LEVEL::STANDARD;
 196   else if (StringUtils::EqualsNoCase(value, "advanced"))
 197     slValue = LOCK_LEVEL::ADVANCED;
 198   else if (StringUtils::EqualsNoCase(value, "expert"))
 199     slValue = LOCK_LEVEL::EXPERT;
 200   return slValue <= CProfilesManager::Get().GetCurrentProfile().settingsLockLevel();
 201 }
 202
 203 bool ProfileHasVideosLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 204 {
 205   return CProfilesManager::Get().GetCurrentProfile().videoLocked();
 206 }
 207
 208 bool ProfileLockMode(const std::string &condition, const std::string &value, const std::string &settingId)
 209 {
 210   char *tmp = NULL;
 211   LockType lock = (LockType)strtol(value.c_str(), &tmp, 0);
 212   if (tmp != NULL && *tmp != '\0')
 213     return false;
 214
 215   return CProfilesManager::Get().GetCurrentProfile().getLockMode() == lock;
 216 }
 217
 218 CSettings::CSettings()
 219   : m_initialized(false)
 220 {
 221   m_settingsManager = new CSettingsManager();
 222 }
 223
 224 CSettings::~CSettings()
 225 {
 226   Uninitialize();
 227
 228   delete m_settingsManager;
 229 }
 230
 231 CSettings& CSettings::Get()
 232 {
 233   static CSettings sSettings;
 234   return sSettings;
 235 }
 236
 237 CSetting* CSettings::CreateSetting(const std::string &settingType, const std::string &settingId, CSettingsManager *settingsManager /* = NULL */) const
 238 {
 239   if (StringUtils::EqualsNoCase(settingType, "addon"))
 240     return new CSettingAddon(settingId, settingsManager);
 241   else if (StringUtils::EqualsNoCase(settingType, "path"))
 242     return new CSettingPath(settingId, settingsManager);
 243
 244   return NULL;
 245 }
 246
 247 bool CSettings::Initialize()
 248 {
 249   CSingleLock lock(m_critical);
 250   if (m_initialized)
 251     return false;
 252
 253   // register custom setting types
 254   InitializeSettingTypes();
 255
 256   // option fillers and conditions need to be
 257   // initialized before the setting definitions
 258   InitializeOptionFillers();
 259   InitializeConditions();
 260
 261   // load the settings definitions
 262   if (!InitializeDefinitions())
 263     return false;
 264
 265   m_settingsManager->SetInitialized();
 266
 267   InitializeISettingsHandlers();
 268   InitializeISubSettings();
 269   InitializeISettingCallbacks();
 270
 271   m_initialized = true;
 272
 273   return true;
 274 }
 275
 276 bool CSettings::Load()
 277 {
 278   return Load(CProfilesManager::Get().GetSettingsFile());
 279 }
 280
 281 bool CSettings::Load(const std::string &file)
 282 {
 283   CXBMCTinyXML xmlDoc;
 284   bool updated = false;
 285   if (!XFILE::CFile::Exists(file) || !xmlDoc.LoadFile(file) ||
 286       !m_settingsManager->Load(xmlDoc.RootElement(), updated))
 287   {
 288     CLog::Log(LOGERROR, "CSettingsManager: unable to load settings from %s, creating new default settings", file.c_str());
 289     if (!Reset())
 290       return false;
 291
 292     if (!Load(file))
 293       return false;
 294   }
 295   // if the settings had to be updated, we need to save the changes
 296   else if (updated)
 297     return Save(file);
 298
 299   return true;
 300 }
 301
 302 bool CSettings::Load(const TiXmlElement *root, bool hide /* = false */)
 303 {
 304   if (root == NULL)
 305     return false;
 306
 307   std::map<std::string, CSetting*> *loadedSettings = NULL;
 308   if (hide)
 309     loadedSettings = new std::map<std::string, CSetting*>();
 310
 311   bool updated;
 312   // only trigger settings events if hiding is disabled
 313   bool success = m_settingsManager->Load(root, updated, !hide, loadedSettings);
 314   // if necessary hide all the loaded settings
 315   if (success && hide && loadedSettings != NULL)
 316   {
 317     for(std::map<std::string, CSetting*>::const_iterator setting = loadedSettings->begin(); setting != loadedSettings->end(); ++setting)
 318       setting->second->SetVisible(false);
 319
 320     delete loadedSettings;
 321   }
 322
 323   return success;
 324 }
 325
 326 void CSettings::SetLoaded()
 327 {
 328   m_settingsManager->SetLoaded();
 329 }
 330
 331 bool CSettings::Save()
 332 {
 333   return Save(CProfilesManager::Get().GetSettingsFile());
 334 }
 335
 336 bool CSettings::Save(const std::string &file)
 337 {
 338   CXBMCTinyXML xmlDoc;
 339   TiXmlElement rootElement(SETTINGS_XML_ROOT);
 340   TiXmlNode *root = xmlDoc.InsertEndChild(rootElement);
 341   if (root == NULL)
 342     return false;
 343
 344   if (!m_settingsManager->Save(root))
 345     return false;
 346
 347   return xmlDoc.SaveFile(file);
 348 }
 349
 350 void CSettings::Unload()
 351 {
 352   CSingleLock lock(m_critical);
 353   m_settingsManager->Unload();
 354 }
 355
 356 void CSettings::Uninitialize()
 357 {
 358   CSingleLock lock(m_critical);
 359   if (!m_initialized)
 360     return;
 361
 362   // unregister setting option fillers
 363   m_settingsManager->UnregisterSettingOptionsFiller("audiocdactions");
 364   m_settingsManager->UnregisterSettingOptionsFiller("audiocdencoders");
 365   m_settingsManager->UnregisterSettingOptionsFiller("audiodevices");
 366   m_settingsManager->UnregisterSettingOptionsFiller("audiodevicespassthrough");
 367   m_settingsManager->UnregisterSettingOptionsFiller("audiooutputmodes");
 368   m_settingsManager->UnregisterSettingOptionsFiller("charsets");
 369   m_settingsManager->UnregisterSettingOptionsFiller("epgguideviews");
 370   m_settingsManager->UnregisterSettingOptionsFiller("fontheights");
 371   m_settingsManager->UnregisterSettingOptionsFiller("fonts");
 372   m_settingsManager->UnregisterSettingOptionsFiller("languages");
 373   m_settingsManager->UnregisterSettingOptionsFiller("pvrstartlastchannel");
 374   m_settingsManager->UnregisterSettingOptionsFiller("refreshchangedelays");
 375   m_settingsManager->UnregisterSettingOptionsFiller("refreshrates");
 376   m_settingsManager->UnregisterSettingOptionsFiller("regions");
 377   m_settingsManager->UnregisterSettingOptionsFiller("rendermethods");
 378   m_settingsManager->UnregisterSettingOptionsFiller("resolutions");
 379   m_settingsManager->UnregisterSettingOptionsFiller("screens");
 380   m_settingsManager->UnregisterSettingOptionsFiller("shutdownstates");
 381   m_settingsManager->UnregisterSettingOptionsFiller("startupwindows");
 382   m_settingsManager->UnregisterSettingOptionsFiller("streamlanguages");
 383   m_settingsManager->UnregisterSettingOptionsFiller("skincolors");
 384   m_settingsManager->UnregisterSettingOptionsFiller("skinfonts");
 385   m_settingsManager->UnregisterSettingOptionsFiller("skinsounds");
 386   m_settingsManager->UnregisterSettingOptionsFiller("skinthemes");
 387 #if defined(TARGET_LINUX)
 388   m_settingsManager->UnregisterSettingOptionsFiller("timezonecountries");
 389   m_settingsManager->UnregisterSettingOptionsFiller("timezones");
 390 #endif // defined(TARGET_LINUX)
 391   m_settingsManager->UnregisterSettingOptionsFiller("verticalsyncs");
 392
 393   // unregister ISettingCallback implementations
 394   m_settingsManager->UnregisterCallback(&g_advancedSettings);
 395   m_settingsManager->UnregisterCallback(&CMediaSettings::Get());
 396   m_settingsManager->UnregisterCallback(&CDisplaySettings::Get());
 397   m_settingsManager->UnregisterCallback(&g_application);
 398   m_settingsManager->UnregisterCallback(&g_audioManager);
 399   m_settingsManager->UnregisterCallback(&g_charsetConverter);
 400   m_settingsManager->UnregisterCallback(&g_graphicsContext);
 401   m_settingsManager->UnregisterCallback(&g_langInfo);
 402 #if defined(TARGET_WINDOWS) || defined(HAS_SDL_JOYSTICK)
 403   m_settingsManager->UnregisterCallback(&g_Joystick);
 404 #endif
 405   m_settingsManager->UnregisterCallback(&g_Mouse);
 406   m_settingsManager->UnregisterCallback(&CNetworkServices::Get());
 407   m_settingsManager->UnregisterCallback(&g_passwordManager);
 408   m_settingsManager->UnregisterCallback(&PVR::g_PVRManager);
 409   m_settingsManager->UnregisterCallback(&CRssManager::Get());
 410 #if defined(TARGET_LINUX)
 411   m_settingsManager->UnregisterCallback(&g_timezone);
 412 #endif // defined(TARGET_LINUX)
 413   m_settingsManager->UnregisterCallback(&g_weatherManager);
 414   m_settingsManager->UnregisterCallback(&PERIPHERALS::CPeripherals::Get());
 415
 416   // unregister ISubSettings implementations
 417   m_settingsManager->UnregisterSubSettings(&g_application);
 418   m_settingsManager->UnregisterSubSettings(&CDisplaySettings::Get());
 419   m_settingsManager->UnregisterSubSettings(&CMediaSettings::Get());
 420   m_settingsManager->UnregisterSubSettings(&CSkinSettings::Get());
 421   m_settingsManager->UnregisterSubSettings(&g_sysinfo);
 422   m_settingsManager->UnregisterSubSettings(&CViewStateSettings::Get());
 423
 424   // unregister ISettingsHandler implementations
 425   m_settingsManager->UnregisterSettingsHandler(&CWakeOnAccess::Get());
 426   m_settingsManager->UnregisterSettingsHandler(&g_advancedSettings);
 427   m_settingsManager->UnregisterSettingsHandler(&CMediaSourceSettings::Get());
 428   m_settingsManager->UnregisterSettingsHandler(&CPlayerCoreFactory::Get());
 429   m_settingsManager->UnregisterSettingsHandler(&CRssManager::Get());
 430 #ifdef HAS_UPNP
 431   m_settingsManager->UnregisterSettingsHandler(&CUPnPSettings::Get());
 432 #endif
 433   m_settingsManager->UnregisterSettingsHandler(&CProfilesManager::Get());
 434   m_settingsManager->UnregisterSettingsHandler(&g_application);
 435
 436   // cleanup the settings manager
 437   m_settingsManager->Clear();
 438
 439   m_initialized = false;
 440 }
 441
 442 void CSettings::RegisterCallback(ISettingCallback *callback, const std::set<std::string> &settingList)
 443 {
 444   m_settingsManager->RegisterCallback(callback, settingList);
 445 }
 446
 447 void CSettings::UnregisterCallback(ISettingCallback *callback)
 448 {
 449   m_settingsManager->UnregisterCallback(callback);
 450 }
 451
 452 CSetting* CSettings::GetSetting(const std::string &id) const
 453 {
 454   CSingleLock lock(m_critical);
 455   if (id.empty())
 456     return NULL;
 457
 458   return m_settingsManager->GetSetting(id);
 459 }
 460
 461 CSettingSection* CSettings::GetSection(const std::string &section) const
 462 {
 463   CSingleLock lock(m_critical);
 464   if (section.empty())
 465     return NULL;
 466
 467   return m_settingsManager->GetSection(section);
 468 }
 469
 470 bool CSettings::GetBool(const std::string &id) const
 471 {
 472   return m_settingsManager->GetBool(id);
 473 }
 474
 475 bool CSettings::SetBool(const std::string &id, bool value)
 476 {
 477   return m_settingsManager->SetBool(id, value);
 478 }
 479
 480 bool CSettings::ToggleBool(const std::string &id)
 481 {
 482   return m_settingsManager->ToggleBool(id);
 483 }
 484
 485 int CSettings::GetInt(const std::string &id) const
 486 {
 487   return m_settingsManager->GetInt(id);
 488 }
 489
 490 bool CSettings::SetInt(const std::string &id, int value)
 491 {
 492   return m_settingsManager->SetInt(id, value);
 493 }
 494
 495 double CSettings::GetNumber(const std::string &id) const
 496 {
 497   return m_settingsManager->GetNumber(id);
 498 }
 499
 500 bool CSettings::SetNumber(const std::string &id, double value)
 501 {
 502   return m_settingsManager->SetNumber(id, value);
 503 }
 504
 505 std::string CSettings::GetString(const std::string &id) const
 506 {
 507   return m_settingsManager->GetString(id);
 508 }
 509
 510 bool CSettings::SetString(const std::string &id, const std::string &value)
 511 {
 512   return m_settingsManager->SetString(id, value);
 513 }
 514
 515 bool CSettings::LoadSetting(const TiXmlNode *node, const std::string &settingId)
 516 {
 517   return m_settingsManager->LoadSetting(node, settingId);
 518 }
 519
 520 bool CSettings::Initialize(const std::string &file)
 521 {
 522   CXBMCTinyXML xmlDoc;
 523   if (!xmlDoc.LoadFile(file.c_str()))
 524   {
 525     CLog::Log(LOGERROR, "CSettings: error loading settings definition from %s, Line %d\n%s", file.c_str(), xmlDoc.ErrorRow(), xmlDoc.ErrorDesc());
 526     return false;
 527   }
 528
 529   CLog::Log(LOGDEBUG, "CSettings: loaded settings definition from %s", file.c_str());
 530
 531   TiXmlElement *root = xmlDoc.RootElement();
 532   if (root == NULL)
 533     return false;
 534
 535   return m_settingsManager->Initialize(root);
 536 }
 537
 538 bool CSettings::InitializeDefinitions()
 539 {
 540   if (!Initialize(SETTINGS_XML_FOLDER "settings.xml"))
 541   {
 542     CLog::Log(LOGFATAL, "Unable to load settings definitions");
 543     return false;
 544   }
 545 #if defined(TARGET_WINDOWS)
 546   if (CFile::Exists(SETTINGS_XML_FOLDER "win32.xml") && !Initialize(SETTINGS_XML_FOLDER "win32.xml"))
 547     CLog::Log(LOGFATAL, "Unable to load win32-specific settings definitions");
 548 #elif defined(TARGET_ANDROID)
 549   if (CFile::Exists(SETTINGS_XML_FOLDER "android.xml") && !Initialize(SETTINGS_XML_FOLDER "android.xml"))
 550     CLog::Log(LOGFATAL, "Unable to load android-specific settings definitions");
 551 #elif defined(TARGET_RASPBERRY_PI)
 552   if (CFile::Exists(SETTINGS_XML_FOLDER "rbp.xml") && !Initialize(SETTINGS_XML_FOLDER "rbp.xml"))
 553     CLog::Log(LOGFATAL, "Unable to load rbp-specific settings definitions");
 554 #elif defined(TARGET_FREEBSD)
 555   if (CFile::Exists(SETTINGS_XML_FOLDER "freebsd.xml") && !Initialize(SETTINGS_XML_FOLDER "freebsd.xml"))
 556     CLog::Log(LOGFATAL, "Unable to load freebsd-specific settings definitions");
 557 #elif defined(TARGET_LINUX)
 558   if (CFile::Exists(SETTINGS_XML_FOLDER "linux.xml") && !Initialize(SETTINGS_XML_FOLDER "linux.xml"))
 559     CLog::Log(LOGFATAL, "Unable to load linux-specific settings definitions");
 560 #elif defined(TARGET_DARWIN)
 561   if (CFile::Exists(SETTINGS_XML_FOLDER "darwin.xml") && !Initialize(SETTINGS_XML_FOLDER "darwin.xml"))
 562     CLog::Log(LOGFATAL, "Unable to load darwin-specific settings definitions");
 563 #if defined(TARGET_DARWIN_OSX)
 564   if (CFile::Exists(SETTINGS_XML_FOLDER "darwin_osx.xml") && !Initialize(SETTINGS_XML_FOLDER "darwin_osx.xml"))
 565     CLog::Log(LOGFATAL, "Unable to load osx-specific settings definitions");
 566 #elif defined(TARGET_DARWIN_IOS)
 567   if (CFile::Exists(SETTINGS_XML_FOLDER "darwin_ios.xml") && !Initialize(SETTINGS_XML_FOLDER "darwin_ios.xml"))
 568     CLog::Log(LOGFATAL, "Unable to load ios-specific settings definitions");
 569 #if defined(TARGET_DARWIN_IOS_ATV2)
 570   if (CFile::Exists(SETTINGS_XML_FOLDER "darwin_ios_atv2.xml") && !Initialize(SETTINGS_XML_FOLDER "darwin_ios_atv2.xml"))
 571     CLog::Log(LOGFATAL, "Unable to load atv2-specific settings definitions");
 572 #endif
 573 #endif
 574 #endif
 575
 576   // load any custom visibility and default values before loading the special
 577   // appliance.xml so that appliances are able to overwrite even those values
 578   InitializeVisibility();
 579   InitializeDefaults();
 580
 581   if (CFile::Exists(SETTINGS_XML_FOLDER "appliance.xml") && !Initialize(SETTINGS_XML_FOLDER "appliance.xml"))
 582     CLog::Log(LOGFATAL, "Unable to load appliance-specific settings definitions");
 583
 584   return true;
 585 }
 586
 587 void CSettings::InitializeSettingTypes()
 588 {
 589   // register "addon" and "path" setting types implemented by CSettingAddon
 590   m_settingsManager->RegisterSettingType("addon", this);
 591   m_settingsManager->RegisterSettingType("path", this);
 592 }
 593
 594 void CSettings::InitializeVisibility()
 595 {
 596   // hide some settings if necessary
 597 #if defined(TARGET_DARWIN)
 598   CSettingString* timezonecountry = (CSettingString*)m_settingsManager->GetSetting("locale.timezonecountry");
 599   CSettingString* timezone = (CSettingString*)m_settingsManager->GetSetting("locale.timezone");
 600
 601   if (!g_sysinfo.IsAppleTV2() || GetIOSVersion() >= 4.3)
 602   {
 603     timezonecountry->SetVisible(false);
 604     timezone->SetVisible(false);
 605   }
 606 #endif
 607 }
 608
 609 void CSettings::InitializeDefaults()
 610 {
 611   // set some default values if necessary
 612 #if defined(HAS_SKIN_TOUCHED) && defined(TARGET_DARWIN_IOS) && !defined(TARGET_DARWIN_IOS_ATV2)
 613   ((CSettingAddon*)m_settingsManager->GetSetting("lookandfeel.skin"))->SetDefault("skin.touched");
 614 #endif
 615
 616 #if defined(TARGET_POSIX)
 617   CSettingString* timezonecountry = (CSettingString*)m_settingsManager->GetSetting("locale.timezonecountry");
 618   CSettingString* timezone = (CSettingString*)m_settingsManager->GetSetting("locale.timezone");
 619
 620   if (timezonecountry->IsVisible())
 621     timezonecountry->SetDefault(g_timezone.GetCountryByTimezone(g_timezone.GetOSConfiguredTimezone()));
 622   if (timezone->IsVisible())
 623     timezone->SetDefault(g_timezone.GetOSConfiguredTimezone());
 624 #endif // defined(TARGET_POSIX)
 625
 626 #if defined(TARGET_WINDOWS)
 627   #if defined(HAS_DX)
 628   ((CSettingString*)m_settingsManager->GetSetting("musicplayer.visualisation"))->SetDefault("visualization.milkdrop");
 629   #endif
 630
 631   #if !defined(HAS_GL)
 632   // We prefer a fake fullscreen mode (window covering the screen rather than dedicated fullscreen)
 633   // as it works nicer with switching to other applications. However on some systems vsync is broken
 634   // when we do this (eg non-Aero on ATI in particular) and on others (AppleTV) we can't get XBMC to
 635   // the front
 636   if (g_sysinfo.IsAeroDisabled())
 637     ((CSettingBool*)m_settingsManager->GetSetting("videoscreen.fakefullscreen"))->SetDefault(false);
 638   #endif
 639 #endif
 640
 641 #if defined(TARGET_DARWIN)
 642   #if !defined(TARGET_DARWIN_IOS)
 643   CStdString defaultAudioDeviceName;
 644   CCoreAudioHardware::GetOutputDeviceName(defaultAudioDeviceName);
 645   ((CSettingString*)m_settingsManager->GetSetting("audiooutput.audiodevice"))->SetDefault(defaultAudioDeviceName);
 646   ((CSettingString*)m_settingsManager->GetSetting("audiooutput.passthroughdevice"))->SetDefault(defaultAudioDeviceName);
 647   #endif
 648 #else
 649   ((CSettingString*)m_settingsManager->GetSetting("audiooutput.audiodevice"))->SetDefault(CAEFactory::GetDefaultDevice(false));
 650   ((CSettingString*)m_settingsManager->GetSetting("audiooutput.passthroughdevice"))->SetDefault(CAEFactory::GetDefaultDevice(true));
 651 #endif
 652
 653   if (g_application.IsStandAlone())
 654     ((CSettingInt*)m_settingsManager->GetSetting("powermanagement.shutdownstate"))->SetDefault(POWERSTATE_SHUTDOWN);
 655
 656 #if defined(HAS_WEB_SERVER)
 657   if (CUtil::CanBindPrivileged())
 658     ((CSettingInt*)m_settingsManager->GetSetting("services.webserverport"))->SetDefault(80);
 659 #endif
 660 }
 661
 662 void CSettings::InitializeOptionFillers()
 663 {
 664   // register setting option fillers
 665 #ifdef HAS_DVD_DRIVE
 666   m_settingsManager->RegisterSettingOptionsFiller("audiocdactions", MEDIA_DETECT::CAutorun::SettingOptionAudioCdActionsFiller);
 667   m_settingsManager->RegisterSettingOptionsFiller("audiocdencoders", MEDIA_DETECT::CAutorun::SettingOptionAudioCdEncodersFiller);
 668 #endif
 669   m_settingsManager->RegisterSettingOptionsFiller("audiodevices", CAEFactory::SettingOptionsAudioDevicesFiller);
 670   m_settingsManager->RegisterSettingOptionsFiller("audiodevicespassthrough", CAEFactory::SettingOptionsAudioDevicesPassthroughFiller);
 671   m_settingsManager->RegisterSettingOptionsFiller("audiooutputmodes", CAEFactory::SettingOptionsAudioOutputModesFiller);
 672   m_settingsManager->RegisterSettingOptionsFiller("charsets", CCharsetConverter::SettingOptionsCharsetsFiller);
 673   m_settingsManager->RegisterSettingOptionsFiller("epgguideviews", PVR::CGUIWindowPVRGuide::SettingOptionsEpgGuideViewFiller);
 674   m_settingsManager->RegisterSettingOptionsFiller("fonts", GUIFontManager::SettingOptionsFontsFiller);
 675   m_settingsManager->RegisterSettingOptionsFiller("languages", CLangInfo::SettingOptionsLanguagesFiller);
 676   m_settingsManager->RegisterSettingOptionsFiller("pvrstartlastchannel", PVR::CPVRManager::SettingOptionsPvrStartLastChannelFiller);
 677   m_settingsManager->RegisterSettingOptionsFiller("refreshchangedelays", CDisplaySettings::SettingOptionsRefreshChangeDelaysFiller);
 678   m_settingsManager->RegisterSettingOptionsFiller("refreshrates", CDisplaySettings::SettingOptionsRefreshRatesFiller);
 679   m_settingsManager->RegisterSettingOptionsFiller("regions", CLangInfo::SettingOptionsRegionsFiller);
 680   m_settingsManager->RegisterSettingOptionsFiller("rendermethods", CBaseRenderer::SettingOptionsRenderMethodsFiller);
 681   m_settingsManager->RegisterSettingOptionsFiller("resolutions", CDisplaySettings::SettingOptionsResolutionsFiller);
 682   m_settingsManager->RegisterSettingOptionsFiller("screens", CDisplaySettings::SettingOptionsScreensFiller);
 683   m_settingsManager->RegisterSettingOptionsFiller("shutdownstates", CPowerManager::SettingOptionsShutdownStatesFiller);
 684   m_settingsManager->RegisterSettingOptionsFiller("startupwindows", ADDON::CSkinInfo::SettingOptionsStartupWindowsFiller);
 685   m_settingsManager->RegisterSettingOptionsFiller("streamlanguages", CLangInfo::SettingOptionsStreamLanguagesFiller);
 686   m_settingsManager->RegisterSettingOptionsFiller("skincolors", ADDON::CSkinInfo::SettingOptionsSkinColorsFiller);
 687   m_settingsManager->RegisterSettingOptionsFiller("skinfonts", ADDON::CSkinInfo::SettingOptionsSkinFontsFiller);
 688   m_settingsManager->RegisterSettingOptionsFiller("skinsounds", ADDON::CSkinInfo::SettingOptionsSkinSoundFiller);
 689   m_settingsManager->RegisterSettingOptionsFiller("skinthemes", ADDON::CSkinInfo::SettingOptionsSkinThemesFiller);
 690 #ifdef TARGET_LINUX
 691   m_settingsManager->RegisterSettingOptionsFiller("timezonecountries", CLinuxTimezone::SettingOptionsTimezoneCountriesFiller);
 692   m_settingsManager->RegisterSettingOptionsFiller("timezones", CLinuxTimezone::SettingOptionsTimezonesFiller);
 693 #endif
 694   m_settingsManager->RegisterSettingOptionsFiller("verticalsyncs", CDisplaySettings::SettingOptionsVerticalSyncsFiller);
 695 }
 696
 697 void CSettings::InitializeConditions()
 698 {
 699   // add basic conditions
 700   m_settingsManager->AddCondition("true");
 701 #ifdef HAS_AIRPLAY
 702   m_settingsManager->AddCondition("has_airplay");
 703 #endif
 704 #ifdef HAS_EVENT_SERVER
 705   m_settingsManager->AddCondition("has_event_server");
 706 #endif
 707 #ifdef HAS_GL
 708   m_settingsManager->AddCondition("has_gl");
 709 #endif
 710 #ifdef HAS_GLES
 711   m_settingsManager->AddCondition("has_gles");
 712 #endif
 713 #if HAS_GLES == 2
 714   m_settingsManager->AddCondition("has_glesv2");
 715 #endif
 716 #ifdef HAS_KARAOKE
 717   m_settingsManager->AddCondition("has_karaoke");
 718 #endif
 719 #ifdef HAS_SDL_JOYSTICK
 720   m_settingsManager->AddCondition("has_sdl_joystick");
 721 #endif
 722 #ifdef HAS_SKIN_TOUCHED
 723   m_settingsManager->AddCondition("has_skin_touched");
 724 #endif
 725 #ifdef HAS_TIME_SERVER
 726   m_settingsManager->AddCondition("has_time_server");
 727 #endif
 728 #ifdef HAS_WEB_SERVER
 729   m_settingsManager->AddCondition("has_web_server");
 730 #endif
 731 #ifdef HAS_ZEROCONF
 732   m_settingsManager->AddCondition("has_zeroconf");
 733 #endif
 734 #ifdef HAVE_LIBCRYSTALHD
 735   m_settingsManager->AddCondition("have_libcrystalhd");
 736   if (CCrystalHD::GetInstance()->DevicePresent())
 737     m_settingsManager->AddCondition("hascrystalhddevice");
 738 #endif
 739 #ifdef HAVE_LIBOPENMAX
 740   m_settingsManager->AddCondition("have_libopenmax");
 741 #endif
 742 #ifdef HAVE_LIBVA
 743   m_settingsManager->AddCondition("have_libva");
 744 #endif
 745 #ifdef HAVE_LIBVDPAU
 746   m_settingsManager->AddCondition("have_libvdpau");
 747 #endif
 748 #ifdef HAVE_VIDEOTOOLBOXDECODER
 749   m_settingsManager->AddCondition("have_videotoolboxdecoder");
 750   if (g_sysinfo.HasVideoToolBoxDecoder())
 751     m_settingsManager->AddCondition("hasvideotoolboxdecoder");
 752 #endif
 753 #ifdef TARGET_DARWIN_IOS_ATV2
 754   if (g_sysinfo.IsAppleTV2())
 755     m_settingsManager->AddCondition("isappletv2");
 756 #endif
 757 #if defined(TARGET_WINDOWS) && defined(HAS_DX)
 758   m_settingsManager->AddCondition("has_dx");
 759   if (g_sysinfo.IsWindowsVersionAtLeast(CSysInfo::WindowsVersionVista))
 760     m_settingsManager->AddCondition("hasdxva2");
 761 #endif
 762
 763   if (g_application.IsStandAlone())
 764     m_settingsManager->AddCondition("isstandalone");
 765
 766   if (CAEFactory::SupportsDrain())
 767     m_settingsManager->AddCondition("audiosupportsdrain");
 768
 769   // add more complex conditions
 770   m_settingsManager->AddCondition("addonhassettings", AddonHasSettings);
 771   m_settingsManager->AddCondition("checkmasterlock", CheckMasterLock);
 772   m_settingsManager->AddCondition("checkpvrparentalpin", CheckPVRParentalPin);
 773   m_settingsManager->AddCondition("hasperipherals", HasPeripherals);
 774   m_settingsManager->AddCondition("isfullscreen", IsFullscreen);
 775   m_settingsManager->AddCondition("ismasteruser", IsMasterUser);
 776   m_settingsManager->AddCondition("isusingttfsubtitles", IsUsingTTFSubtitles);
 777   m_settingsManager->AddCondition("profilecanwritedatabase", ProfileCanWriteDatabase);
 778   m_settingsManager->AddCondition("profilecanwritesources", ProfileCanWriteSources);
 779   m_settingsManager->AddCondition("profilehasaddons", ProfileHasAddons);
 780   m_settingsManager->AddCondition("profilehasdatabase", ProfileHasDatabase);
 781   m_settingsManager->AddCondition("profilehassources", ProfileHasSources);
 782   m_settingsManager->AddCondition("profilehasaddonmanagerlocked", ProfileHasAddonManagerLocked);
 783   m_settingsManager->AddCondition("profilehasfileslocked", ProfileHasFilesLocked);
 784   m_settingsManager->AddCondition("profilehasmusiclocked", ProfileHasMusicLocked);
 785   m_settingsManager->AddCondition("profilehaspictureslocked", ProfileHasPicturesLocked);
 786   m_settingsManager->AddCondition("profilehasprogramslocked", ProfileHasProgramsLocked);
 787   m_settingsManager->AddCondition("profilehassettingslocked", ProfileHasSettingsLocked);
 788   m_settingsManager->AddCondition("profilehasvideoslocked", ProfileHasVideosLocked);
 789   m_settingsManager->AddCondition("profilelockmode", ProfileLockMode);
 790 }
 791
 792 void CSettings::InitializeISettingsHandlers()
 793 {
 794   // register ISettingsHandler implementations
 795   m_settingsManager->RegisterSettingsHandler(&g_application);
 796   m_settingsManager->RegisterSettingsHandler(&CProfilesManager::Get());
 797   m_settingsManager->RegisterSettingsHandler(&g_advancedSettings);
 798   m_settingsManager->RegisterSettingsHandler(&CMediaSourceSettings::Get());
 799   m_settingsManager->RegisterSettingsHandler(&CPlayerCoreFactory::Get());
 800   m_settingsManager->RegisterSettingsHandler(&CRssManager::Get());
 801 #ifdef HAS_UPNP
 802   m_settingsManager->RegisterSettingsHandler(&CUPnPSettings::Get());
 803 #endif
 804   m_settingsManager->RegisterSettingsHandler(&CWakeOnAccess::Get());
 805 }
 806
 807 void CSettings::InitializeISubSettings()
 808 {
 809   // register ISubSettings implementations
 810   m_settingsManager->RegisterSubSettings(&g_application);
 811   m_settingsManager->RegisterSubSettings(&CDisplaySettings::Get());
 812   m_settingsManager->RegisterSubSettings(&CMediaSettings::Get());
 813   m_settingsManager->RegisterSubSettings(&CSkinSettings::Get());
 814   m_settingsManager->RegisterSubSettings(&g_sysinfo);
 815   m_settingsManager->RegisterSubSettings(&CViewStateSettings::Get());
 816 }
 817
 818 void CSettings::InitializeISettingCallbacks()
 819 {
 820   // register any ISettingCallback implementations
 821   std::set<std::string> settingSet;
 822   settingSet.insert("debug.showloginfo");
 823   settingSet.insert("debug.setextraloglevel");
 824   m_settingsManager->RegisterCallback(&g_advancedSettings, settingSet);
 825
 826   settingSet.clear();
 827   settingSet.insert("karaoke.export");
 828   settingSet.insert("karaoke.importcsv");
 829   settingSet.insert("musiclibrary.cleanup");
 830   settingSet.insert("musiclibrary.export");
 831   settingSet.insert("musiclibrary.import");
 832   settingSet.insert("musicfiles.trackformat");
 833   settingSet.insert("musicfiles.trackformatright");
 834   settingSet.insert("videolibrary.flattentvshows");
 835   settingSet.insert("videolibrary.removeduplicates");
 836   settingSet.insert("videolibrary.groupmoviesets");
 837   settingSet.insert("videolibrary.cleanup");
 838   settingSet.insert("videolibrary.import");
 839   settingSet.insert("videolibrary.export");
 840   m_settingsManager->RegisterCallback(&CMediaSettings::Get(), settingSet);
 841
 842   settingSet.clear();
 843   settingSet.insert("videoscreen.screen");
 844   settingSet.insert("videoscreen.resolution");
 845   settingSet.insert("videoscreen.screenmode");
 846   m_settingsManager->RegisterCallback(&CDisplaySettings::Get(), settingSet);
 847
 848   settingSet.clear();
 849   settingSet.insert("audiooutput.mode");
 850   settingSet.insert("audiooutput.channels");
 851   settingSet.insert("audiooutput.guisoundmode");
 852   settingSet.insert("audiooutput.stereoupmix");
 853   settingSet.insert("audiooutput.ac3passthrough");
 854   settingSet.insert("audiooutput.dtspassthrough");
 855   settingSet.insert("audiooutput.passthroughaac");
 856   settingSet.insert("audiooutput.truehdpassthrough");
 857   settingSet.insert("audiooutput.dtshdpassthrough");
 858   settingSet.insert("audiooutput.multichannellpcm");
 859   settingSet.insert("audiooutput.audiodevice");
 860   settingSet.insert("audiooutput.passthroughdevice");
 861   settingSet.insert("audiooutput.streamsilence");
 862   settingSet.insert("lookandfeel.skin");
 863   settingSet.insert("lookandfeel.skinsettings");
 864   settingSet.insert("lookandfeel.font");
 865   settingSet.insert("lookandfeel.skintheme");
 866   settingSet.insert("lookandfeel.skincolors");
 867   settingSet.insert("lookandfeel.skinzoom");
 868   settingSet.insert("musicplayer.replaygainpreamp");
 869   settingSet.insert("musicplayer.replaygainnogainpreamp");
 870   settingSet.insert("musicplayer.replaygaintype");
 871   settingSet.insert("musicplayer.replaygainavoidclipping");
 872   settingSet.insert("scrapers.musicvideosdefault");
 873   settingSet.insert("screensaver.mode");
 874   settingSet.insert("screensaver.preview");
 875   settingSet.insert("screensaver.settings");
 876   settingSet.insert("videoscreen.guicalibration");
 877   settingSet.insert("videoscreen.testpattern");
 878   m_settingsManager->RegisterCallback(&g_application, settingSet);
 879
 880   settingSet.clear();
 881   settingSet.insert("lookandfeel.soundskin");
 882   m_settingsManager->RegisterCallback(&g_audioManager, settingSet);
 883
 884   settingSet.clear();
 885   settingSet.insert("subtitles.charset");
 886   settingSet.insert("karaoke.charset");
 887   settingSet.insert("locale.charset");
 888   m_settingsManager->RegisterCallback(&g_charsetConverter, settingSet);
 889
 890   settingSet.clear();
 891   settingSet.insert("videoscreen.fakefullscreen");
 892   m_settingsManager->RegisterCallback(&g_graphicsContext, settingSet);
 893
 894   settingSet.clear();
 895   settingSet.insert("locale.audiolanguage");
 896   settingSet.insert("locale.subtitlelanguage");
 897   settingSet.insert("locale.language");
 898   settingSet.insert("locale.country");
 899   m_settingsManager->RegisterCallback(&g_langInfo, settingSet);
 900
 901 #if defined(HAS_SDL_JOYSTICK)
 902   settingSet.clear();
 903   settingSet.insert("input.enablejoystick");
 904   m_settingsManager->RegisterCallback(&g_Joystick, settingSet);
 905 #endif
 906
 907   settingSet.clear();
 908   settingSet.insert("input.enablemouse");
 909   m_settingsManager->RegisterCallback(&g_Mouse, settingSet);
 910
 911   settingSet.clear();
 912   settingSet.insert("services.webserver");
 913   settingSet.insert("services.webserverport");
 914   settingSet.insert("services.webserverusername");
 915   settingSet.insert("services.webserverpassword");
 916   settingSet.insert("services.zeroconf");
 917   settingSet.insert("services.airplay");
 918   settingSet.insert("services.useairplaypassword");
 919   settingSet.insert("services.airplaypassword");
 920   settingSet.insert("services.upnpserver");
 921   settingSet.insert("services.upnprenderer");
 922   settingSet.insert("services.upnpcontroller");
 923   settingSet.insert("services.esenabled");
 924   settingSet.insert("services.esport");
 925   settingSet.insert("services.esallinterfaces");
 926   settingSet.insert("services.esinitialdelay");
 927   settingSet.insert("services.escontinuousdelay");
 928   settingSet.insert("smb.winsserver");
 929   settingSet.insert("smb.workgroup");
 930   m_settingsManager->RegisterCallback(&CNetworkServices::Get(), settingSet);
 931
 932   settingSet.clear();
 933   settingSet.insert("masterlock.lockcode");
 934   m_settingsManager->RegisterCallback(&g_passwordManager, settingSet);
 935
 936   settingSet.clear();
 937   settingSet.insert("pvrmanager.enabled");
 938   settingSet.insert("pvrmanager.channelmanager");
 939   settingSet.insert("pvrmanager.channelscan");
 940   settingSet.insert("pvrmanager.resetdb");
 941   settingSet.insert("pvrclient.menuhook");
 942   settingSet.insert("pvrmenu.searchicons");
 943   settingSet.insert("epg.resetepg");
 944   settingSet.insert("pvrparental.enabled");
 945   m_settingsManager->RegisterCallback(&PVR::g_PVRManager, settingSet);
 946
 947   settingSet.clear();
 948   settingSet.insert("lookandfeel.rssedit");
 949   m_settingsManager->RegisterCallback(&CRssManager::Get(), settingSet);
 950
 951 #if defined(TARGET_LINUX)
 952   settingSet.clear();
 953   settingSet.insert("locale.timezone");
 954   settingSet.insert("locale.timezonecountry");
 955   m_settingsManager->RegisterCallback(&g_timezone, settingSet);
 956 #endif
 957
 958   settingSet.clear();
 959   settingSet.insert("weather.addon");
 960   settingSet.insert("weather.addonsettings");
 961   m_settingsManager->RegisterCallback(&g_weatherManager, settingSet);
 962
 963   settingSet.clear();
 964   settingSet.insert("input.peripherals");
 965   settingSet.insert("locale.language");
 966   m_settingsManager->RegisterCallback(&PERIPHERALS::CPeripherals::Get(), settingSet);
 967
 968 #if defined(TARGET_DARWIN_OSX)
 969   settingSet.clear();
 970   settingSet.insert("input.appleremotemode");
 971   m_settingsManager->RegisterCallback(&XBMCHelper::GetInstance(), settingSet);
 972 #endif
 973 }
 974
 975 bool CSettings::Reset()
 976 {
 977   std::string settingsFile = CProfilesManager::Get().GetSettingsFile();
 978   // try to delete the settings file
 979   if (XFILE::CFile::Exists(settingsFile, false) && !XFILE::CFile::Delete(settingsFile))
 980     CLog::Log(LOGWARNING, "Unable to delete old settings file at %s", settingsFile.c_str());
 981
 982   // unload any loaded settings
 983   Unload();
 984
 985   // try to save the default settings
 986   if (!Save())
 987   {
 988     CLog::Log(LOGWARNING, "Failed to save the default settings to %s", settingsFile.c_str());
 989     return false;
 990   }
 991
 992   return true;
 993 }