xbmc/settings/dialogs/GUIDialogSettingsManualBase.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "GUIDialogSettingsManualBase.h"
  10
  11 #include "settings/SettingAddon.h"
  12 #include "settings/SettingDateTime.h"
  13 #include "settings/SettingPath.h"
  14 #include "settings/SettingUtils.h"
  15 #include "settings/lib/Setting.h"
  16 #include "settings/lib/SettingSection.h"
  17 #include "settings/lib/SettingsManager.h"
  18 #include "utils/StringUtils.h"
  19 #include "utils/Variant.h"
  20
  21 #include <string>
  22 #include <vector>
  23
  24 CGUIDialogSettingsManualBase::CGUIDialogSettingsManualBase(int windowId, const std::string& xmlFile)
  25   : CGUIDialogSettingsManagerBase(windowId, xmlFile)
  26 { }
  27
  28 CGUIDialogSettingsManualBase::~CGUIDialogSettingsManualBase()
  29 {
  30   if (GetSettingsManager() != nullptr)
  31   {
  32     GetSettingsManager()->Clear();
  33     m_section = nullptr;
  34     delete GetSettingsManager();
  35   }
  36 }
  37
  38 void CGUIDialogSettingsManualBase::SetupView()
  39 {
  40   InitializeSettings();
  41
  42   if (GetSettingsManager() != nullptr)
  43   {
  44     // add the created setting section to the settings manager and mark it as ready
  45     GetSettingsManager()->AddSection(m_section);
  46     GetSettingsManager()->SetInitialized();
  47     GetSettingsManager()->SetLoaded();
  48   }
  49
  50   CGUIDialogSettingsBase::SetupView();
  51 }
  52
  53 CSettingsManager* CGUIDialogSettingsManualBase::GetSettingsManager() const
  54 {
  55   if (m_settingsManager == nullptr)
  56     m_settingsManager = new CSettingsManager();
  57
  58   return m_settingsManager;
  59 }
  60
  61 void CGUIDialogSettingsManualBase::InitializeSettings()
  62 {
  63   if (GetSettingsManager() != nullptr)
  64   {
  65     GetSettingsManager()->Clear();
  66     m_section = NULL;
  67
  68     // create a std::make_shared<section
  69     m_section = std::make_shared<CSettingSection>(GetProperty("xmlfile").asString(), GetSettingsManager());
  70   }
  71 }
  72
  73 SettingCategoryPtr CGUIDialogSettingsManualBase::AddCategory(const std::string &id, int label, int help /* = -1 */)
  74 {
  75   if (id.empty())
  76     return NULL;
  77
  78   SettingCategoryPtr category = std::make_shared<CSettingCategory>(id, GetSettingsManager());
  79   if (category == NULL)
  80     return NULL;
  81
  82   category->SetLabel(label);
  83   if (help >= 0)
  84     category->SetHelp(help);
  85
  86   m_section->AddCategory(category);
  87   return category;
  88 }
  89
  90 SettingGroupPtr CGUIDialogSettingsManualBase::AddGroup(const SettingCategoryPtr& category,
  91                                                        int label /* = -1 */,
  92                                                        int help /* = -1 */,
  93                                                        bool separatorBelowLabel /* = true */,
  94                                                        bool hideSeparator /* = false */)
  95 {
  96   if (category == NULL)
  97     return NULL;
  98
  99   size_t groups = category->GetGroups().size();
 100
 101   SettingGroupPtr group = std::make_shared<CSettingGroup>(StringUtils::Format("{0}", groups + 1), GetSettingsManager());
 102   if (group == NULL)
 103     return NULL;
 104
 105   if (label >= 0)
 106     group->SetLabel(label);
 107   if (help >= 0)
 108     group->SetHelp(help);
 109   group->SetControl(GetTitleControl(separatorBelowLabel, hideSeparator));
 110
 111   category->AddGroup(group);
 112   return group;
 113 }
 114
 115 std::shared_ptr<CSettingBool> CGUIDialogSettingsManualBase::AddToggle(const SettingGroupPtr& group,
 116                                                                       const std::string& id,
 117                                                                       int label,
 118                                                                       SettingLevel level,
 119                                                                       bool value,
 120                                                                       bool delayed /* = false */,
 121                                                                       bool visible /* = true */,
 122                                                                       int help /* = -1 */)
 123 {
 124   if (group == NULL || id.empty() || label < 0 ||
 125       GetSetting(id) != NULL)
 126     return NULL;
 127
 128   std::shared_ptr<CSettingBool> setting = std::make_shared<CSettingBool>(id, label, value, GetSettingsManager());
 129   if (setting == NULL)
 130     return NULL;
 131
 132   setting->SetControl(GetCheckmarkControl(delayed));
 133   setSettingDetails(setting, level, visible, help);
 134
 135   group->AddSetting(setting);
 136   return setting;
 137 }
 138
 139 std::shared_ptr<CSettingInt> CGUIDialogSettingsManualBase::AddEdit(
 140     const SettingGroupPtr& group,
 141     const std::string& id,
 142     int label,
 143     SettingLevel level,
 144     int value,
 145     int minimum /* = 0 */,
 146     int step /* = 1 */,
 147     int maximum /* = 0 */,
 148     bool verifyNewValue /* = false */,
 149     int heading /* = -1 */,
 150     bool delayed /* = false */,
 151     bool visible /* = true */,
 152     int help /* = -1 */)
 153 {
 154   if (group == NULL || id.empty() || label < 0 ||
 155       GetSetting(id) != NULL)
 156     return NULL;
 157
 158   std::shared_ptr<CSettingInt> setting = std::make_shared<CSettingInt>(id, label, value, minimum, step, maximum, GetSettingsManager());
 159   if (setting == NULL)
 160     return NULL;
 161
 162   setting->SetControl(GetEditControl("integer", delayed, false, verifyNewValue, heading));
 163   setSettingDetails(setting, level, visible, help);
 164
 165   group->AddSetting(setting);
 166   return setting;
 167 }
 168
 169 std::shared_ptr<CSettingNumber> CGUIDialogSettingsManualBase::AddEdit(
 170     const SettingGroupPtr& group,
 171     const std::string& id,
 172     int label,
 173     SettingLevel level,
 174     float value,
 175     float minimum /* = 0.0f */,
 176     float step /* = 1.0f */,
 177     float maximum /* = 0.0f */,
 178     bool verifyNewValue /* = false */,
 179     int heading /* = -1 */,
 180     bool delayed /* = false */,
 181     bool visible /* = true */,
 182     int help /* = -1 */)
 183 {
 184   if (group == NULL || id.empty() || label < 0 ||
 185       GetSetting(id) != NULL)
 186     return NULL;
 187
 188   std::shared_ptr<CSettingNumber> setting = std::make_shared<CSettingNumber>(id, label, value, minimum, step, maximum, GetSettingsManager());
 189   if (setting == NULL)
 190     return NULL;
 191
 192   setting->SetControl(GetEditControl("number", delayed, false, verifyNewValue, heading));
 193   setSettingDetails(setting, level, visible, help);
 194
 195   group->AddSetting(setting);
 196   return setting;
 197 }
 198
 199 std::shared_ptr<CSettingString> CGUIDialogSettingsManualBase::AddEdit(const SettingGroupPtr& group,
 200                                                                       const std::string& id,
 201                                                                       int label,
 202                                                                       SettingLevel level,
 203                                                                       const std::string& value,
 204                                                                       bool allowEmpty /* = false */,
 205                                                                       bool hidden /* = false */,
 206                                                                       int heading /* = -1 */,
 207                                                                       bool delayed /* = false */,
 208                                                                       bool visible /* = true */,
 209                                                                       int help /* = -1 */)
 210 {
 211   if (group == NULL || id.empty() || label < 0 ||
 212       GetSetting(id) != NULL)
 213     return NULL;
 214
 215   std::shared_ptr<CSettingString> setting = std::make_shared<CSettingString>(id, label, value, GetSettingsManager());
 216   if (setting == NULL)
 217     return NULL;
 218
 219   setting->SetControl(GetEditControl("string", delayed, hidden, false, heading));
 220   setting->SetAllowEmpty(allowEmpty);
 221   setSettingDetails(setting, level, visible, help);
 222
 223   group->AddSetting(setting);
 224   return setting;
 225 }
 226
 227 std::shared_ptr<CSettingString> CGUIDialogSettingsManualBase::AddIp(const SettingGroupPtr& group,
 228                                                                     const std::string& id,
 229                                                                     int label,
 230                                                                     SettingLevel level,
 231                                                                     const std::string& value,
 232                                                                     bool allowEmpty /* = false */,
 233                                                                     int heading /* = -1 */,
 234                                                                     bool delayed /* = false */,
 235                                                                     bool visible /* = true */,
 236                                                                     int help /* = -1 */)
 237 {
 238   if (group == NULL || id.empty() || label < 0 ||
 239       GetSetting(id) != NULL)
 240     return NULL;
 241
 242   std::shared_ptr<CSettingString> setting = std::make_shared<CSettingString>(id, label, value, GetSettingsManager());
 243   if (setting == NULL)
 244     return NULL;
 245
 246   setting->SetControl(GetEditControl("ip", delayed, false, false, heading));
 247   setting->SetAllowEmpty(allowEmpty);
 248   setSettingDetails(setting, level, visible, help);
 249
 250   group->AddSetting(setting);
 251   return setting;
 252 }
 253
 254 std::shared_ptr<CSettingString> CGUIDialogSettingsManualBase::AddPasswordMd5(
 255     const SettingGroupPtr& group,
 256     const std::string& id,
 257     int label,
 258     SettingLevel level,
 259     const std::string& value,
 260     bool allowEmpty /* = false */,
 261     int heading /* = -1 */,
 262     bool delayed /* = false */,
 263     bool visible /* = true */,
 264     int help /* = -1 */)
 265 {
 266   if (group == NULL || id.empty() || label < 0 ||
 267       GetSetting(id) != NULL)
 268     return NULL;
 269
 270   std::shared_ptr<CSettingString> setting = std::make_shared<CSettingString>(id, label, value, GetSettingsManager());
 271   if (setting == NULL)
 272     return NULL;
 273
 274   setting->SetControl(GetEditControl("md5", delayed, false, false, heading));
 275   setting->SetAllowEmpty(allowEmpty);
 276   setSettingDetails(setting, level, visible, help);
 277
 278   group->AddSetting(setting);
 279   return setting;
 280 }
 281
 282 std::shared_ptr<CSettingAction> CGUIDialogSettingsManualBase::AddButton(
 283     const SettingGroupPtr& group,
 284     const std::string& id,
 285     int label,
 286     SettingLevel level,
 287     const std::string& data /* = "" */,
 288     bool delayed /* = false */,
 289     bool visible /* = true */,
 290     int help /* = -1 */)
 291 {
 292   if (group == NULL || id.empty() || label < 0 ||
 293       GetSetting(id) != NULL)
 294     return NULL;
 295
 296   std::shared_ptr<CSettingAction> setting = std::make_shared<CSettingAction>(id, label, GetSettingsManager());
 297   if (setting == NULL)
 298     return NULL;
 299
 300   setting->SetControl(GetButtonControl("action", delayed));
 301   setting->SetData(data);
 302   setSettingDetails(setting, level, visible, help);
 303
 304   group->AddSetting(setting);
 305   return setting;
 306 }
 307
 308 std::shared_ptr<CSettingString> CGUIDialogSettingsManualBase::AddInfoLabelButton(
 309     const SettingGroupPtr& group,
 310     const std::string& id,
 311     int label,
 312     SettingLevel level,
 313     const std::string& info,
 314     bool visible /* = true */,
 315     int help /* = -1 */)
 316 {
 317   if (group == NULL || id.empty() || label < 0 ||
 318       GetSetting(id) != NULL)
 319     return NULL;
 320
 321   std::shared_ptr<CSettingString> setting = std::make_shared<CSettingString>(id, label, info, GetSettingsManager());
 322   if (setting == NULL)
 323     return NULL;
 324
 325   setting->SetControl(GetButtonControl("infolabel", false));
 326   setSettingDetails(setting, level, visible, help);
 327
 328   group->AddSetting(setting);
 329   return setting;
 330 }
 331
 332 std::shared_ptr<CSettingAddon> CGUIDialogSettingsManualBase::AddAddon(
 333     const SettingGroupPtr& group,
 334     const std::string& id,
 335     int label,
 336     SettingLevel level,
 337     const std::string& value,
 338     ADDON::AddonType addonType,
 339     bool allowEmpty /* = false */,
 340     int heading /* = -1 */,
 341     bool hideValue /* = false */,
 342     bool showInstalledAddons /* = true */,
 343     bool showInstallableAddons /* = false */,
 344     bool showMoreAddons /* = true */,
 345     bool delayed /* = false */,
 346     bool visible /* = true */,
 347     int help /* = -1 */)
 348 {
 349   if (group == NULL || id.empty() || label < 0 ||
 350       GetSetting(id) != NULL)
 351     return NULL;
 352
 353   std::shared_ptr<CSettingAddon> setting = std::make_shared<CSettingAddon>(id, label, value, GetSettingsManager());
 354   if (setting == NULL)
 355     return NULL;
 356
 357   setting->SetControl(GetButtonControl("addon", delayed, heading, hideValue, showInstalledAddons, showInstallableAddons, showMoreAddons));
 358   setting->SetAddonType(addonType);
 359   setting->SetAllowEmpty(allowEmpty);
 360   setSettingDetails(setting, level, visible, help);
 361
 362   group->AddSetting(setting);
 363   return setting;
 364 }
 365
 366 std::shared_ptr<CSettingPath> CGUIDialogSettingsManualBase::AddPath(
 367     const SettingGroupPtr& group,
 368     const std::string& id,
 369     int label,
 370     SettingLevel level,
 371     const std::string& value,
 372     bool writable /* = true */,
 373     const std::vector<std::string>& sources /* = std::vector<std::string>() */,
 374     bool allowEmpty /* = false */,
 375     int heading /* = -1 */,
 376     bool hideValue /* = false */,
 377     bool delayed /* = false */,
 378     bool visible /* = true */,
 379     int help /* = -1 */)
 380 {
 381   if (group == NULL || id.empty() || label < 0 ||
 382       GetSetting(id) != NULL)
 383     return NULL;
 384
 385   std::shared_ptr<CSettingPath> setting = std::make_shared<CSettingPath>(id, label, value, GetSettingsManager());
 386   if (setting == NULL)
 387     return NULL;
 388
 389   setting->SetControl(GetButtonControl("path", delayed, heading, hideValue));
 390   setting->SetWritable(writable);
 391   setting->SetSources(sources);
 392   setting->SetAllowEmpty(allowEmpty);
 393   setSettingDetails(setting, level, visible, help);
 394
 395   group->AddSetting(setting);
 396   return setting;
 397 }
 398
 399 std::shared_ptr<CSettingDate> CGUIDialogSettingsManualBase::AddDate(const SettingGroupPtr& group,
 400                                                                     const std::string& id,
 401                                                                     int label,
 402                                                                     SettingLevel level,
 403                                                                     const std::string& value,
 404                                                                     bool allowEmpty /* = false */,
 405                                                                     int heading /* = -1 */,
 406                                                                     bool delayed /* = false */,
 407                                                                     bool visible /* = true */,
 408                                                                     int help /* = -1 */)
 409 {
 410   if (group == NULL || id.empty() || label < 0 || GetSetting(id) != NULL)
 411     return NULL;
 412
 413   std::shared_ptr<CSettingDate> setting = std::make_shared<CSettingDate>(id, label, value, GetSettingsManager());
 414   if (setting == NULL)
 415     return NULL;
 416
 417   setting->SetControl(GetButtonControl("date", delayed, heading));
 418   setting->SetAllowEmpty(allowEmpty);
 419   setSettingDetails(setting, level, visible, help);
 420
 421   group->AddSetting(setting);
 422   return setting;
 423 }
 424
 425 std::shared_ptr<CSettingTime> CGUIDialogSettingsManualBase::AddTime(const SettingGroupPtr& group,
 426                                                                     const std::string& id,
 427                                                                     int label,
 428                                                                     SettingLevel level,
 429                                                                     const std::string& value,
 430                                                                     bool allowEmpty /* = false */,
 431                                                                     int heading /* = -1 */,
 432                                                                     bool delayed /* = false */,
 433                                                                     bool visible /* = true */,
 434                                                                     int help /* = -1 */)
 435 {
 436   if (group == NULL || id.empty() || label < 0 || GetSetting(id) != NULL)
 437     return NULL;
 438
 439   std::shared_ptr<CSettingTime> setting = std::make_shared<CSettingTime>(id, label, value, GetSettingsManager());
 440   if (setting == NULL)
 441     return NULL;
 442
 443   setting->SetControl(GetButtonControl("time", delayed, heading));
 444   setting->SetAllowEmpty(allowEmpty);
 445   setSettingDetails(setting, level, visible, help);
 446
 447   group->AddSetting(setting);
 448   return setting;
 449 }
 450
 451 std::shared_ptr<CSettingString> CGUIDialogSettingsManualBase::AddSpinner(
 452     const SettingGroupPtr& group,
 453     const std::string& id,
 454     int label,
 455     SettingLevel level,
 456     const std::string& value,
 457     StringSettingOptionsFiller filler,
 458     bool delayed /* = false */,
 459     bool visible /* = true */,
 460     int help /* = -1 */)
 461 {
 462   if (group == NULL || id.empty() || label < 0 || filler == NULL ||
 463       GetSetting(id) != NULL)
 464     return NULL;
 465
 466   std::shared_ptr<CSettingString> setting = std::make_shared<CSettingString>(id, label, value, GetSettingsManager());
 467   if (setting == NULL)
 468     return NULL;
 469
 470   setting->SetControl(GetSpinnerControl("string", delayed));
 471   setting->SetOptionsFiller(filler, this);
 472   setSettingDetails(setting, level, visible, help);
 473
 474   group->AddSetting(setting);
 475   return setting;
 476 }
 477
 478 std::shared_ptr<CSettingInt> CGUIDialogSettingsManualBase::AddSpinner(const SettingGroupPtr& group,
 479                                                                       const std::string& id,
 480                                                                       int label,
 481                                                                       SettingLevel level,
 482                                                                       int value,
 483                                                                       int minimum,
 484                                                                       int step,
 485                                                                       int maximum,
 486                                                                       int formatLabel /* = -1 */,
 487                                                                       int minimumLabel /* = -1 */,
 488                                                                       bool delayed /* = false */,
 489                                                                       bool visible /* = true */,
 490                                                                       int help /* = -1 */)
 491 {
 492   if (group == NULL || id.empty() || label < 0 ||
 493       GetSetting(id) != NULL)
 494     return NULL;
 495
 496   std::shared_ptr<CSettingInt> setting = std::make_shared<CSettingInt>(id, label, value, GetSettingsManager());
 497   if (setting == NULL)
 498     return NULL;
 499
 500   setting->SetControl(GetSpinnerControl("string", delayed, minimumLabel, formatLabel));
 501   setting->SetMinimum(minimum);
 502   setting->SetStep(step);
 503   setting->SetMaximum(maximum);
 504   setSettingDetails(setting, level, visible, help);
 505
 506   group->AddSetting(setting);
 507   return setting;
 508 }
 509
 510 std::shared_ptr<CSettingInt> CGUIDialogSettingsManualBase::AddSpinner(
 511     const SettingGroupPtr& group,
 512     const std::string& id,
 513     int label,
 514     SettingLevel level,
 515     int value,
 516     int minimum,
 517     int step,
 518     int maximum,
 519     const std::string& formatString,
 520     int minimumLabel /* = -1 */,
 521     bool delayed /* = false */,
 522     bool visible /* = true */,
 523     int help /* = -1 */)
 524 {
 525   if (group == NULL || id.empty() || label < 0 ||
 526       GetSetting(id) != NULL)
 527     return NULL;
 528
 529   std::shared_ptr<CSettingInt> setting = std::make_shared<CSettingInt>(id, label, value, GetSettingsManager());
 530   if (setting == NULL)
 531     return NULL;
 532
 533   setting->SetControl(GetSpinnerControl("string", delayed, minimumLabel, -1, formatString));
 534   setting->SetMinimum(minimum);
 535   setting->SetStep(step);
 536   setting->SetMaximum(maximum);
 537   setSettingDetails(setting, level, visible, help);
 538
 539   group->AddSetting(setting);
 540   return setting;
 541 }
 542
 543 std::shared_ptr<CSettingInt> CGUIDialogSettingsManualBase::AddSpinner(
 544     const SettingGroupPtr& group,
 545     const std::string& id,
 546     int label,
 547     SettingLevel level,
 548     int value,
 549     const TranslatableIntegerSettingOptions& entries,
 550     bool delayed /* = false */,
 551     bool visible /* = true */,
 552     int help /* = -1 */)
 553 {
 554   if (group == NULL || id.empty() || label < 0 || entries.empty() ||
 555       GetSetting(id) != NULL)
 556     return NULL;
 557
 558   std::shared_ptr<CSettingInt> setting = std::make_shared<CSettingInt>(id, label, value, GetSettingsManager());
 559   if (setting == NULL)
 560     return NULL;
 561
 562   setting->SetControl(GetSpinnerControl("string", delayed));
 563   setting->SetTranslatableOptions(entries);
 564   setSettingDetails(setting, level, visible, help);
 565
 566   group->AddSetting(setting);
 567   return setting;
 568 }
 569
 570 std::shared_ptr<CSettingInt> CGUIDialogSettingsManualBase::AddSpinner(
 571     const SettingGroupPtr& group,
 572     const std::string& id,
 573     int label,
 574     SettingLevel level,
 575     int value,
 576     const IntegerSettingOptions& entries,
 577     bool delayed /* = false */,
 578     bool visible /* = true */,
 579     int help /* = -1 */)
 580 {
 581   if (group == NULL || id.empty() || label < 0 || entries.empty() ||
 582       GetSetting(id) != NULL)
 583     return NULL;
 584
 585   std::shared_ptr<CSettingInt> setting = std::make_shared<CSettingInt>(id, label, value, GetSettingsManager());
 586   if (setting == NULL)
 587     return NULL;
 588
 589   setting->SetControl(GetSpinnerControl("string", delayed));
 590   setting->SetOptions(entries);
 591   setSettingDetails(setting, level, visible, help);
 592
 593   group->AddSetting(setting);
 594   return setting;
 595 }
 596
 597 std::shared_ptr<CSettingInt> CGUIDialogSettingsManualBase::AddSpinner(
 598     const SettingGroupPtr& group,
 599     const std::string& id,
 600     int label,
 601     SettingLevel level,
 602     int value,
 603     IntegerSettingOptionsFiller filler,
 604     bool delayed /* = false */,
 605     bool visible /* = true */,
 606     int help /* = -1 */)
 607 {
 608   if (group == NULL || id.empty() || label < 0 || filler == NULL ||
 609       GetSetting(id) != NULL)
 610     return NULL;
 611
 612   std::shared_ptr<CSettingInt> setting = std::make_shared<CSettingInt>(id, label, value, GetSettingsManager());
 613   if (setting == NULL)
 614     return NULL;
 615
 616   setting->SetControl(GetSpinnerControl("string", delayed));
 617   setting->SetOptionsFiller(filler, this);
 618   setSettingDetails(setting, level, visible, help);
 619
 620   group->AddSetting(setting);
 621   return setting;
 622 }
 623
 624 std::shared_ptr<CSettingNumber> CGUIDialogSettingsManualBase::AddSpinner(
 625     const SettingGroupPtr& group,
 626     const std::string& id,
 627     int label,
 628     SettingLevel level,
 629     float value,
 630     float minimum,
 631     float step,
 632     float maximum,
 633     int formatLabel /* = -1 */,
 634     int minimumLabel /* = -1 */,
 635     bool delayed /* = false */,
 636     bool visible /* = true */,
 637     int help /* = -1 */)
 638 {
 639   if (group == NULL || id.empty() || label < 0 ||
 640       GetSetting(id) != NULL)
 641     return NULL;
 642
 643   std::shared_ptr<CSettingNumber> setting = std::make_shared<CSettingNumber>(id, label, value, GetSettingsManager());
 644   if (setting == NULL)
 645     return NULL;
 646
 647   setting->SetControl(GetSpinnerControl("number", delayed, minimumLabel, formatLabel));
 648   setting->SetMinimum(static_cast<double>(minimum));
 649   setting->SetStep(static_cast<double>(step));
 650   setting->SetMaximum(static_cast<double>(maximum));
 651   setSettingDetails(setting, level, visible, help);
 652
 653   group->AddSetting(setting);
 654   return setting;
 655 }
 656
 657 std::shared_ptr<CSettingNumber> CGUIDialogSettingsManualBase::AddSpinner(
 658     const SettingGroupPtr& group,
 659     const std::string& id,
 660     int label,
 661     SettingLevel level,
 662     float value,
 663     float minimum,
 664     float step,
 665     float maximum,
 666     const std::string& formatString,
 667     int minimumLabel /* = -1 */,
 668     bool delayed /* = false */,
 669     bool visible /* = true */,
 670     int help /* = -1 */)
 671 {
 672   if (group == NULL || id.empty() || label < 0 ||
 673       GetSetting(id) != NULL)
 674     return NULL;
 675
 676   std::shared_ptr<CSettingNumber> setting = std::make_shared<CSettingNumber>(id, label, value, GetSettingsManager());
 677   if (setting == NULL)
 678     return NULL;
 679
 680   setting->SetControl(GetSpinnerControl("number", delayed, minimumLabel, -1, formatString));
 681   setting->SetMinimum(static_cast<double>(minimum));
 682   setting->SetStep(static_cast<double>(step));
 683   setting->SetMaximum(static_cast<double>(maximum));
 684   setSettingDetails(setting, level, visible, help);
 685
 686   group->AddSetting(setting);
 687   return setting;
 688 }
 689
 690 std::shared_ptr<CSettingString> CGUIDialogSettingsManualBase::AddList(
 691     const SettingGroupPtr& group,
 692     const std::string& id,
 693     int label,
 694     SettingLevel level,
 695     const std::string& value,
 696     StringSettingOptionsFiller filler,
 697     int heading,
 698     bool visible /* = true */,
 699     int help /* = -1 */,
 700     bool details /* = false */)
 701 {
 702   if (group == NULL || id.empty() || label < 0 || filler == NULL ||
 703       GetSetting(id) != NULL)
 704     return NULL;
 705
 706   std::shared_ptr<CSettingString> setting = std::make_shared<CSettingString>(id, label, value, GetSettingsManager());
 707   if (setting == NULL)
 708     return NULL;
 709
 710   setting->SetControl(GetListControl("string", false, heading, false, nullptr, details));
 711   setting->SetOptionsFiller(filler, this);
 712   setSettingDetails(setting, level, visible, help);
 713
 714   group->AddSetting(setting);
 715   return setting;
 716 }
 717
 718 std::shared_ptr<CSettingInt> CGUIDialogSettingsManualBase::AddList(
 719     const SettingGroupPtr& group,
 720     const std::string& id,
 721     int label,
 722     SettingLevel level,
 723     int value,
 724     const TranslatableIntegerSettingOptions& entries,
 725     int heading,
 726     bool visible /* = true */,
 727     int help /* = -1 */,
 728     bool details /* = false */)
 729 {
 730   if (group == NULL || id.empty() || label < 0 || entries.empty() ||
 731       GetSetting(id) != NULL)
 732     return NULL;
 733
 734   std::shared_ptr<CSettingInt> setting = std::make_shared<CSettingInt>(id, label, value, GetSettingsManager());
 735   if (setting == NULL)
 736     return NULL;
 737
 738   setting->SetControl(GetListControl("integer", false, heading, false, nullptr, details));
 739   setting->SetTranslatableOptions(entries);
 740   setSettingDetails(setting, level, visible, help);
 741
 742   group->AddSetting(setting);
 743   return setting;
 744 }
 745
 746 std::shared_ptr<CSettingInt> CGUIDialogSettingsManualBase::AddList(
 747     const SettingGroupPtr& group,
 748     const std::string& id,
 749     int label,
 750     SettingLevel level,
 751     int value,
 752     const IntegerSettingOptions& entries,
 753     int heading,
 754     bool visible /* = true */,
 755     int help /* = -1 */,
 756     bool details /* = false */)
 757 {
 758   if (group == NULL || id.empty() || label < 0 || entries.empty() ||
 759       GetSetting(id) != NULL)
 760     return NULL;
 761
 762   std::shared_ptr<CSettingInt> setting = std::make_shared<CSettingInt>(id, label, value, GetSettingsManager());
 763   if (setting == NULL)
 764     return NULL;
 765
 766   setting->SetControl(GetListControl("integer", false, heading, false, nullptr, details));
 767   setting->SetOptions(entries);
 768   setSettingDetails(setting, level, visible, help);
 769
 770   group->AddSetting(setting);
 771   return setting;
 772 }
 773
 774 std::shared_ptr<CSettingInt> CGUIDialogSettingsManualBase::AddList(
 775     const SettingGroupPtr& group,
 776     const std::string& id,
 777     int label,
 778     SettingLevel level,
 779     int value,
 780     IntegerSettingOptionsFiller filler,
 781     int heading,
 782     bool visible /* = true */,
 783     int help /* = -1 */,
 784     bool details /* = false */)
 785 {
 786   if (group == NULL || id.empty() || label < 0 || filler == NULL ||
 787       GetSetting(id) != NULL)
 788     return NULL;
 789
 790   std::shared_ptr<CSettingInt> setting = std::make_shared<CSettingInt>(id, label, value, GetSettingsManager());
 791   if (setting == NULL)
 792     return NULL;
 793
 794   setting->SetControl(GetListControl("integer", false, heading, false, nullptr, details));
 795   setting->SetOptionsFiller(filler, this);
 796   setSettingDetails(setting, level, visible, help);
 797
 798   group->AddSetting(setting);
 799   return setting;
 800 }
 801
 802 std::shared_ptr<CSettingList> CGUIDialogSettingsManualBase::AddList(
 803     const SettingGroupPtr& group,
 804     const std::string& id,
 805     int label,
 806     SettingLevel level,
 807     std::vector<std::string> values,
 808     StringSettingOptionsFiller filler,
 809     int heading,
 810     int minimumItems /* = 0 */,
 811     int maximumItems /* = -1 */,
 812     bool visible /* = true */,
 813     int help /* = -1 */,
 814     bool details /* = false */)
 815 {
 816   if (group == NULL || id.empty() || label < 0 || filler == NULL ||
 817       GetSetting(id) != NULL)
 818     return NULL;
 819
 820   std::shared_ptr<CSettingString> settingDefinition = std::make_shared<CSettingString>(id, GetSettingsManager());
 821   if (settingDefinition == NULL)
 822     return NULL;
 823
 824   settingDefinition->SetOptionsFiller(filler, this);
 825
 826   std::shared_ptr<CSettingList> setting = std::make_shared<CSettingList>(id, settingDefinition, label, GetSettingsManager());
 827   if (setting == NULL)
 828     return NULL;
 829
 830   std::vector<CVariant> valueList;
 831   for (std::vector<std::string>::const_iterator itValue = values.begin(); itValue != values.end(); ++itValue)
 832     valueList.emplace_back(*itValue);
 833   SettingList settingValues;
 834   if (!CSettingUtils::ValuesToList(setting, valueList, settingValues))
 835     return NULL;
 836   // setting the default will also set the actual value on an unchanged setting
 837   setting->SetDefault(settingValues);
 838
 839   setting->SetControl(GetListControl("string", false, heading, true, nullptr, details));
 840   setting->SetMinimumItems(minimumItems);
 841   setting->SetMaximumItems(maximumItems);
 842   setSettingDetails(setting, level, visible, help);
 843
 844   group->AddSetting(setting);
 845   return setting;
 846 }
 847
 848 std::shared_ptr<CSettingList> CGUIDialogSettingsManualBase::AddList(
 849     const SettingGroupPtr& group,
 850     const std::string& id,
 851     int label,
 852     SettingLevel level,
 853     std::vector<int> values,
 854     const TranslatableIntegerSettingOptions& entries,
 855     int heading,
 856     int minimumItems /* = 0 */,
 857     int maximumItems /* = -1 */,
 858     bool visible /* = true */,
 859     int help /* = -1 */,
 860     bool details /* = false */)
 861 {
 862   if (group == NULL || id.empty() || label < 0 || entries.empty() ||
 863       GetSetting(id) != NULL)
 864     return NULL;
 865
 866   std::shared_ptr<CSettingInt> settingDefinition = std::make_shared<CSettingInt>(id, GetSettingsManager());
 867   if (settingDefinition == NULL)
 868     return NULL;
 869
 870   settingDefinition->SetTranslatableOptions(entries);
 871
 872   std::shared_ptr<CSettingList> setting = std::make_shared<CSettingList>(id, settingDefinition, label, GetSettingsManager());
 873   if (setting == NULL)
 874     return NULL;
 875
 876   std::vector<CVariant> valueList;
 877   for (std::vector<int>::const_iterator itValue = values.begin(); itValue != values.end(); ++itValue)
 878     valueList.emplace_back(*itValue);
 879   SettingList settingValues;
 880   if (!CSettingUtils::ValuesToList(setting, valueList, settingValues))
 881     return NULL;
 882   // setting the default will also set the actual value on an unchanged setting
 883   setting->SetDefault(settingValues);
 884
 885   setting->SetControl(GetListControl("integer", false, heading, true, nullptr, details));
 886   setting->SetMinimumItems(minimumItems);
 887   setting->SetMaximumItems(maximumItems);
 888   setSettingDetails(setting, level, visible, help);
 889
 890   group->AddSetting(setting);
 891   return setting;
 892 }
 893
 894 std::shared_ptr<CSettingList> CGUIDialogSettingsManualBase::AddList(
 895     const SettingGroupPtr& group,
 896     const std::string& id,
 897     int label,
 898     SettingLevel level,
 899     std::vector<int> values,
 900     const IntegerSettingOptions& entries,
 901     int heading,
 902     int minimumItems /* = 0 */,
 903     int maximumItems /* = -1 */,
 904     bool visible /* = true */,
 905     int help /* = -1 */,
 906     bool details /* = false */)
 907 {
 908   if (group == NULL || id.empty() || label < 0 || entries.empty() ||
 909       GetSetting(id) != NULL)
 910     return NULL;
 911
 912   std::shared_ptr<CSettingInt> settingDefinition = std::make_shared<CSettingInt>(id, GetSettingsManager());
 913   if (settingDefinition == NULL)
 914     return NULL;
 915
 916   settingDefinition->SetOptions(entries);
 917
 918   std::shared_ptr<CSettingList> setting = std::make_shared<CSettingList>(id, settingDefinition, label, GetSettingsManager());
 919   if (setting == NULL)
 920     return NULL;
 921
 922   std::vector<CVariant> valueList;
 923   for (std::vector<int>::const_iterator itValue = values.begin(); itValue != values.end(); ++itValue)
 924     valueList.emplace_back(*itValue);
 925   SettingList settingValues;
 926   if (!CSettingUtils::ValuesToList(setting, valueList, settingValues))
 927     return NULL;
 928   // setting the default will also set the actual value on an unchanged setting
 929   setting->SetDefault(settingValues);
 930
 931   setting->SetControl(GetListControl("integer", false, heading, true, nullptr, details));
 932   setting->SetMinimumItems(minimumItems);
 933   setting->SetMaximumItems(maximumItems);
 934   setSettingDetails(setting, level, visible, help);
 935
 936   group->AddSetting(setting);
 937   return setting;
 938 }
 939
 940 std::shared_ptr<CSettingList> CGUIDialogSettingsManualBase::AddList(
 941     const SettingGroupPtr& group,
 942     const std::string& id,
 943     int label,
 944     SettingLevel level,
 945     std::vector<int> values,
 946     IntegerSettingOptionsFiller filler,
 947     int heading,
 948     int minimumItems /* = 0 */,
 949     int maximumItems /* = -1 */,
 950     bool visible /* = true */,
 951     int help /* = -1 */,
 952     SettingControlListValueFormatter formatter /* = NULL */,
 953     bool details /* = false */)
 954 {
 955   if (group == NULL || id.empty() || label < 0 || filler == NULL ||
 956       GetSetting(id) != NULL)
 957     return NULL;
 958
 959   std::shared_ptr<CSettingInt> settingDefinition = std::make_shared<CSettingInt>(id, GetSettingsManager());
 960   if (settingDefinition == NULL)
 961     return NULL;
 962
 963   settingDefinition->SetOptionsFiller(filler, this);
 964
 965   std::shared_ptr<CSettingList> setting = std::make_shared<CSettingList>(id, settingDefinition, label, GetSettingsManager());
 966   if (setting == NULL)
 967     return NULL;
 968
 969   std::vector<CVariant> valueList;
 970   for (std::vector<int>::const_iterator itValue = values.begin(); itValue != values.end(); ++itValue)
 971     valueList.emplace_back(*itValue);
 972   SettingList settingValues;
 973   if (!CSettingUtils::ValuesToList(setting, valueList, settingValues))
 974     return NULL;
 975   // setting the default will also set the actual value on an unchanged setting
 976   setting->SetDefault(settingValues);
 977
 978   setting->SetControl(GetListControl("integer", false, heading, true, formatter, details));
 979   setting->SetMinimumItems(minimumItems);
 980   setting->SetMaximumItems(maximumItems);
 981   setSettingDetails(setting, level, visible, help);
 982
 983   group->AddSetting(setting);
 984   return setting;
 985 }
 986
 987 std::shared_ptr<CSettingInt> CGUIDialogSettingsManualBase::AddPercentageSlider(
 988     const SettingGroupPtr& group,
 989     const std::string& id,
 990     int label,
 991     SettingLevel level,
 992     int value,
 993     int formatLabel,
 994     int step /* = 1 */,
 995     int heading /* = -1 */,
 996     bool usePopup /* = false */,
 997     bool delayed /* = false */,
 998     bool visible /* = true */,
 999     int help /* = -1 */)
1000 {
1001   if (group == NULL || id.empty() || label < 0 ||
1002       GetSetting(id) != NULL)
1003     return NULL;
1004
1005   std::shared_ptr<CSettingInt> setting = std::make_shared<CSettingInt>(id, label, value, GetSettingsManager());
1006   if (setting == NULL)
1007     return NULL;
1008
1009   setting->SetControl(GetSliderControl("percentage", delayed, heading, usePopup, formatLabel));
1010   setting->SetMinimum(0);
1011   setting->SetStep(step);
1012   setting->SetMaximum(100);
1013   setSettingDetails(setting, level, visible, help);
1014
1015   group->AddSetting(setting);
1016   return setting;
1017 }
1018
1019 std::shared_ptr<CSettingInt> CGUIDialogSettingsManualBase::AddPercentageSlider(
1020     const SettingGroupPtr& group,
1021     const std::string& id,
1022     int label,
1023     SettingLevel level,
1024     int value,
1025     const std::string& formatString,
1026     int step /* = 1 */,
1027     int heading /* = -1 */,
1028     bool usePopup /* = false */,
1029     bool delayed /* = false */,
1030     bool visible /* = true */,
1031     int help /* = -1 */)
1032 {
1033   if (group == NULL || id.empty() || label < 0 ||
1034       GetSetting(id) != NULL)
1035     return NULL;
1036
1037   std::shared_ptr<CSettingInt> setting = std::make_shared<CSettingInt>(id, label, value, GetSettingsManager());
1038   if (setting == NULL)
1039     return NULL;
1040
1041   setting->SetControl(GetSliderControl("percentage", delayed, heading, usePopup, -1, formatString));
1042   setting->SetMinimum(0);
1043   setting->SetStep(step);
1044   setting->SetMaximum(100);
1045   setSettingDetails(setting, level, visible, help);
1046
1047   group->AddSetting(setting);
1048   return setting;
1049 }
1050
1051 std::shared_ptr<CSettingInt> CGUIDialogSettingsManualBase::AddSlider(const SettingGroupPtr& group,
1052                                                                      const std::string& id,
1053                                                                      int label,
1054                                                                      SettingLevel level,
1055                                                                      int value,
1056                                                                      int formatLabel,
1057                                                                      int minimum,
1058                                                                      int step,
1059                                                                      int maximum,
1060                                                                      int heading /* = -1 */,
1061                                                                      bool usePopup /* = false */,
1062                                                                      bool delayed /* = false */,
1063                                                                      bool visible /* = true */,
1064                                                                      int help /* = -1 */)
1065 {
1066   if (group == NULL || id.empty() || label < 0 ||
1067       GetSetting(id) != NULL)
1068     return NULL;
1069
1070   std::shared_ptr<CSettingInt> setting = std::make_shared<CSettingInt>(id, label, value, GetSettingsManager());
1071   if (setting == NULL)
1072     return NULL;
1073
1074   setting->SetControl(GetSliderControl("integer", delayed, heading, usePopup, formatLabel));
1075   setting->SetMinimum(minimum);
1076   setting->SetStep(step);
1077   setting->SetMaximum(maximum);
1078   setSettingDetails(setting, level, visible, help);
1079
1080   group->AddSetting(setting);
1081   return setting;
1082 }
1083
1084 std::shared_ptr<CSettingInt> CGUIDialogSettingsManualBase::AddSlider(
1085     const SettingGroupPtr& group,
1086     const std::string& id,
1087     int label,
1088     SettingLevel level,
1089     int value,
1090     const std::string& formatString,
1091     int minimum,
1092     int step,
1093     int maximum,
1094     int heading /* = -1 */,
1095     bool usePopup /* = false */,
1096     bool delayed /* = false */,
1097     bool visible /* = true */,
1098     int help /* = -1 */)
1099 {
1100   if (group == NULL || id.empty() || label < 0 ||
1101       GetSetting(id) != NULL)
1102     return NULL;
1103
1104   std::shared_ptr<CSettingInt> setting = std::make_shared<CSettingInt>(id, label, value, GetSettingsManager());
1105   if (setting == NULL)
1106     return NULL;
1107
1108   setting->SetControl(GetSliderControl("integer", delayed, heading, usePopup, -1, formatString));
1109   setting->SetMinimum(minimum);
1110   setting->SetStep(step);
1111   setting->SetMaximum(maximum);
1112   setSettingDetails(setting, level, visible, help);
1113
1114   group->AddSetting(setting);
1115   return setting;
1116 }
1117
1118 std::shared_ptr<CSettingNumber> CGUIDialogSettingsManualBase::AddSlider(
1119     const SettingGroupPtr& group,
1120     const std::string& id,
1121     int label,
1122     SettingLevel level,
1123     float value,
1124     int formatLabel,
1125     float minimum,
1126     float step,
1127     float maximum,
1128     int heading /* = -1 */,
1129     bool usePopup /* = false */,
1130     bool delayed /* = false */,
1131     bool visible /* = true */,
1132     int help /* = -1 */)
1133 {
1134   if (group == NULL || id.empty() || label < 0 ||
1135       GetSetting(id) != NULL)
1136     return NULL;
1137
1138   std::shared_ptr<CSettingNumber> setting = std::make_shared<CSettingNumber>(id, label, value, GetSettingsManager());
1139   if (setting == NULL)
1140     return NULL;
1141
1142   setting->SetControl(GetSliderControl("number", delayed, heading, usePopup, formatLabel));
1143   setting->SetMinimum(static_cast<double>(minimum));
1144   setting->SetStep(static_cast<double>(step));
1145   setting->SetMaximum(static_cast<double>(maximum));
1146   setSettingDetails(setting, level, visible, help);
1147
1148   group->AddSetting(setting);
1149   return setting;
1150 }
1151
1152 std::shared_ptr<CSettingNumber> CGUIDialogSettingsManualBase::AddSlider(
1153     const SettingGroupPtr& group,
1154     const std::string& id,
1155     int label,
1156     SettingLevel level,
1157     float value,
1158     const std::string& formatString,
1159     float minimum,
1160     float step,
1161     float maximum,
1162     int heading /* = -1 */,
1163     bool usePopup /* = false */,
1164     bool delayed /* = false */,
1165     bool visible /* = true */,
1166     int help /* = -1 */)
1167 {
1168   if (group == NULL || id.empty() || label < 0 ||
1169       GetSetting(id) != NULL)
1170     return NULL;
1171
1172   std::shared_ptr<CSettingNumber> setting = std::make_shared<CSettingNumber>(id, label, value, GetSettingsManager());
1173   if (setting == NULL)
1174     return NULL;
1175
1176   setting->SetControl(GetSliderControl("number", delayed, heading, usePopup, -1, formatString));
1177   setting->SetMinimum(static_cast<double>(minimum));
1178   setting->SetStep(static_cast<double>(step));
1179   setting->SetMaximum(static_cast<double>(maximum));
1180   setSettingDetails(setting, level, visible, help);
1181
1182   group->AddSetting(setting);
1183   return setting;
1184 }
1185
1186 std::shared_ptr<CSettingList> CGUIDialogSettingsManualBase::AddPercentageRange(
1187     const SettingGroupPtr& group,
1188     const std::string& id,
1189     int label,
1190     SettingLevel level,
1191     int valueLower,
1192     int valueUpper,
1193     int valueFormatLabel,
1194     int step /* = 1 */,
1195     int formatLabel /* = 21469 */,
1196     bool delayed /* = false */,
1197     bool visible /* = true */,
1198     int help /* = -1 */)
1199 {
1200   return AddRange(group, id, label, level, valueLower, valueUpper, 0, step, 100, "percentage", formatLabel, valueFormatLabel, "", delayed, visible, help);
1201 }
1202
1203 std::shared_ptr<CSettingList> CGUIDialogSettingsManualBase::AddPercentageRange(
1204     const SettingGroupPtr& group,
1205     const std::string& id,
1206     int label,
1207     SettingLevel level,
1208     int valueLower,
1209     int valueUpper,
1210     const std::string& valueFormatString /* = "{:d} %" */,
1211     int step /* = 1 */,
1212     int formatLabel /* = 21469 */,
1213     bool delayed /* = false */,
1214     bool visible /* = true */,
1215     int help /* = -1 */)
1216 {
1217   return AddRange(group, id, label, level, valueLower, valueUpper, 0, step, 100, "percentage", formatLabel, -1, valueFormatString, delayed, visible, help);
1218 }
1219
1220 std::shared_ptr<CSettingList> CGUIDialogSettingsManualBase::AddRange(const SettingGroupPtr& group,
1221                                                                      const std::string& id,
1222                                                                      int label,
1223                                                                      SettingLevel level,
1224                                                                      int valueLower,
1225                                                                      int valueUpper,
1226                                                                      int minimum,
1227                                                                      int step,
1228                                                                      int maximum,
1229                                                                      int valueFormatLabel,
1230                                                                      int formatLabel /* = 21469 */,
1231                                                                      bool delayed /* = false */,
1232                                                                      bool visible /* = true */,
1233                                                                      int help /* = -1 */)
1234 {
1235   return AddRange(group, id, label, level, valueLower, valueUpper, minimum, step, maximum, "integer", formatLabel, valueFormatLabel, "", delayed, visible, help);
1236 }
1237
1238 std::shared_ptr<CSettingList> CGUIDialogSettingsManualBase::AddRange(
1239     const SettingGroupPtr& group,
1240     const std::string& id,
1241     int label,
1242     SettingLevel level,
1243     int valueLower,
1244     int valueUpper,
1245     int minimum,
1246     int step,
1247     int maximum,
1248     const std::string& valueFormatString /* = "{:d}" */,
1249     int formatLabel /* = 21469 */,
1250     bool delayed /* = false */,
1251     bool visible /* = true */,
1252     int help /* = -1 */)
1253 {
1254   return AddRange(group, id, label, level, valueLower, valueUpper, minimum, step, maximum, "integer", formatLabel, -1, valueFormatString, delayed, visible, help);
1255 }
1256
1257 std::shared_ptr<CSettingList> CGUIDialogSettingsManualBase::AddRange(const SettingGroupPtr& group,
1258                                                                      const std::string& id,
1259                                                                      int label,
1260                                                                      SettingLevel level,
1261                                                                      float valueLower,
1262                                                                      float valueUpper,
1263                                                                      float minimum,
1264                                                                      float step,
1265                                                                      float maximum,
1266                                                                      int valueFormatLabel,
1267                                                                      int formatLabel /* = 21469 */,
1268                                                                      bool delayed /* = false */,
1269                                                                      bool visible /* = true */,
1270                                                                      int help /* = -1 */)
1271 {
1272   return AddRange(group, id, label, level, valueLower, valueUpper, minimum, step, maximum, "number", formatLabel, valueFormatLabel, "", delayed, visible, help);
1273 }
1274
1275 std::shared_ptr<CSettingList> CGUIDialogSettingsManualBase::AddRange(
1276     const SettingGroupPtr& group,
1277     const std::string& id,
1278     int label,
1279     SettingLevel level,
1280     float valueLower,
1281     float valueUpper,
1282     float minimum,
1283     float step,
1284     float maximum,
1285     const std::string& valueFormatString /* = "{:.1f}" */,
1286     int formatLabel /* = 21469 */,
1287     bool delayed /* = false */,
1288     bool visible /* = true */,
1289     int help /* = -1 */)
1290 {
1291   return AddRange(group, id, label, level, valueLower, valueUpper, minimum, step, maximum, "number", formatLabel, -1, valueFormatString, delayed, visible, help);
1292 }
1293
1294 std::shared_ptr<CSettingList> CGUIDialogSettingsManualBase::AddDateRange(
1295     const SettingGroupPtr& group,
1296     const std::string& id,
1297     int label,
1298     SettingLevel level,
1299     int valueLower,
1300     int valueUpper,
1301     int minimum,
1302     int step,
1303     int maximum,
1304     int valueFormatLabel,
1305     int formatLabel /* = 21469 */,
1306     bool delayed /* = false */,
1307     bool visible /* = true */,
1308     int help /* = -1 */)
1309 {
1310   return AddRange(group, id, label, level, valueLower, valueUpper, minimum, step, maximum, "date", formatLabel, valueFormatLabel, "", delayed, visible, help);
1311 }
1312
1313 std::shared_ptr<CSettingList> CGUIDialogSettingsManualBase::AddDateRange(
1314     const SettingGroupPtr& group,
1315     const std::string& id,
1316     int label,
1317     SettingLevel level,
1318     int valueLower,
1319     int valueUpper,
1320     int minimum,
1321     int step,
1322     int maximum,
1323     const std::string& valueFormatString /* = "" */,
1324     int formatLabel /* = 21469 */,
1325     bool delayed /* = false */,
1326     bool visible /* = true */,
1327     int help /* = -1 */)
1328 {
1329   return AddRange(group, id, label, level, valueLower, valueUpper, minimum, step, maximum, "date", formatLabel, -1, valueFormatString, delayed, visible, help);
1330 }
1331
1332 std::shared_ptr<CSettingList> CGUIDialogSettingsManualBase::AddTimeRange(
1333     const SettingGroupPtr& group,
1334     const std::string& id,
1335     int label,
1336     SettingLevel level,
1337     int valueLower,
1338     int valueUpper,
1339     int minimum,
1340     int step,
1341     int maximum,
1342     int valueFormatLabel,
1343     int formatLabel /* = 21469 */,
1344     bool delayed /* = false */,
1345     bool visible /* = true */,
1346     int help /* = -1 */)
1347 {
1348   return AddRange(group, id, label, level, valueLower, valueUpper, minimum, step, maximum, "time", formatLabel, valueFormatLabel, "", delayed, visible, help);
1349 }
1350
1351 std::shared_ptr<CSettingList> CGUIDialogSettingsManualBase::AddTimeRange(
1352     const SettingGroupPtr& group,
1353     const std::string& id,
1354     int label,
1355     SettingLevel level,
1356     int valueLower,
1357     int valueUpper,
1358     int minimum,
1359     int step,
1360     int maximum,
1361     const std::string& valueFormatString /* = "mm:ss" */,
1362     int formatLabel /* = 21469 */,
1363     bool delayed /* = false */,
1364     bool visible /* = true */,
1365     int help /* = -1 */)
1366 {
1367   return AddRange(group, id, label, level, valueLower, valueUpper, minimum, step, maximum, "time", formatLabel, -1, valueFormatString, delayed, visible, help);
1368 }
1369
1370 std::shared_ptr<CSettingList> CGUIDialogSettingsManualBase::AddRange(
1371     const SettingGroupPtr& group,
1372     const std::string& id,
1373     int label,
1374     SettingLevel level,
1375     int valueLower,
1376     int valueUpper,
1377     int minimum,
1378     int step,
1379     int maximum,
1380     const std::string& format,
1381     int formatLabel,
1382     int valueFormatLabel,
1383     const std::string& valueFormatString,
1384     bool delayed,
1385     bool visible,
1386     int help)
1387 {
1388   if (group == NULL || id.empty() || label < 0 ||
1389       GetSetting(id) != NULL)
1390     return NULL;
1391
1392   std::shared_ptr<CSettingInt> settingDefinition = std::make_shared<CSettingInt>(id, GetSettingsManager());
1393   if (settingDefinition == NULL)
1394     return NULL;
1395
1396   settingDefinition->SetMinimum(minimum);
1397   settingDefinition->SetStep(step);
1398   settingDefinition->SetMaximum(maximum);
1399
1400   std::shared_ptr<CSettingList> setting = std::make_shared<CSettingList>(id, settingDefinition, label, GetSettingsManager());
1401   if (setting == NULL)
1402     return NULL;
1403
1404   std::vector<CVariant> valueList;
1405   valueList.emplace_back(valueLower);
1406   valueList.emplace_back(valueUpper);
1407   SettingList settingValues;
1408   if (!CSettingUtils::ValuesToList(setting, valueList, settingValues))
1409     return NULL;
1410   // setting the default will also set the actual value on an unchanged setting
1411   setting->SetDefault(settingValues);
1412
1413   setting->SetControl(GetRangeControl(format, delayed, formatLabel, valueFormatLabel, valueFormatString));
1414   setting->SetMinimumItems(2);
1415   setting->SetMaximumItems(2);
1416
1417   setSettingDetails(setting, level, visible, help);
1418
1419   group->AddSetting(setting);
1420   return setting;
1421 }
1422
1423 std::shared_ptr<CSettingList> CGUIDialogSettingsManualBase::AddRange(
1424     const SettingGroupPtr& group,
1425     const std::string& id,
1426     int label,
1427     SettingLevel level,
1428     float valueLower,
1429     float valueUpper,
1430     float minimum,
1431     float step,
1432     float maximum,
1433     const std::string& format,
1434     int formatLabel,
1435     int valueFormatLabel,
1436     const std::string& valueFormatString,
1437     bool delayed,
1438     bool visible,
1439     int help)
1440 {
1441   if (group == NULL || id.empty() || label < 0 ||
1442       GetSetting(id) != NULL)
1443     return NULL;
1444
1445   std::shared_ptr<CSettingNumber> settingDefinition = std::make_shared<CSettingNumber>(id, GetSettingsManager());
1446   if (settingDefinition == NULL)
1447     return NULL;
1448
1449   settingDefinition->SetMinimum(static_cast<double>(minimum));
1450   settingDefinition->SetStep(static_cast<double>(step));
1451   settingDefinition->SetMaximum(static_cast<double>(maximum));
1452
1453   std::shared_ptr<CSettingList> setting = std::make_shared<CSettingList>(id, settingDefinition, label, GetSettingsManager());
1454   if (setting == NULL)
1455     return NULL;
1456
1457   std::vector<CVariant> valueList;
1458   valueList.emplace_back(valueLower);
1459   valueList.emplace_back(valueUpper);
1460   SettingList settingValues;
1461   if (!CSettingUtils::ValuesToList(setting, valueList, settingValues))
1462     return NULL;
1463   // setting the default will also set the actual value on an unchanged setting
1464   setting->SetDefault(settingValues);
1465
1466   setting->SetControl(GetRangeControl(format, delayed, formatLabel, valueFormatLabel, valueFormatString));
1467   setting->SetMinimumItems(2);
1468   setting->SetMaximumItems(2);
1469
1470   setSettingDetails(setting, level, visible, help);
1471
1472   group->AddSetting(setting);
1473   return setting;
1474 }
1475
1476 void CGUIDialogSettingsManualBase::setSettingDetails(const std::shared_ptr<CSetting>& setting,
1477                                                      SettingLevel level,
1478                                                      bool visible,
1479                                                      int help)
1480 {
1481   if (setting == NULL)
1482     return;
1483
1484   if (level < SettingLevel::Basic)
1485     level = SettingLevel::Basic;
1486   else if (level > SettingLevel::Expert)
1487     level = SettingLevel::Expert;
1488
1489   setting->SetLevel(level);
1490   setting->SetVisible(visible);
1491   if (help >= 0)
1492     setting->SetHelp(help);
1493 }
1494
1495 std::shared_ptr<ISettingControl> CGUIDialogSettingsManualBase::GetCheckmarkControl(bool delayed /* = false */)
1496 {
1497   std::shared_ptr<CSettingControlCheckmark> control = std::make_shared<CSettingControlCheckmark>();
1498   control->SetDelayed(delayed);
1499
1500   return control;
1501 }
1502
1503 std::shared_ptr<ISettingControl> CGUIDialogSettingsManualBase::GetTitleControl(bool separatorBelowLabel /* = true */, bool hideSeparator /* = false */)
1504 {
1505   std::shared_ptr<CSettingControlTitle> control = std::make_shared<CSettingControlTitle>();
1506   control->SetSeparatorBelowLabel(separatorBelowLabel);
1507   control->SetSeparatorHidden(hideSeparator);
1508
1509   return control;
1510 }
1511
1512 std::shared_ptr<ISettingControl> CGUIDialogSettingsManualBase::GetEditControl(const std::string &format, bool delayed /* = false */, bool hidden /* = false */, bool verifyNewValue /* = false */, int heading /* = -1 */)
1513 {
1514   std::shared_ptr<CSettingControlEdit> control = std::make_shared<CSettingControlEdit>();
1515   if (!control->SetFormat(format))
1516     return NULL;
1517
1518   control->SetDelayed(delayed);
1519   control->SetHidden(hidden);
1520   control->SetVerifyNewValue(verifyNewValue);
1521   control->SetHeading(heading);
1522
1523   return control;
1524 }
1525
1526 std::shared_ptr<ISettingControl> CGUIDialogSettingsManualBase::GetButtonControl(const std::string &format, bool delayed /* = false */, int heading /* = -1 */, bool hideValue /* = false */,
1527                                                                 bool showInstalledAddons /* = true */, bool showInstallableAddons /* = false */, bool showMoreAddons /* = true */)
1528 {
1529   std::shared_ptr<CSettingControlButton> control = std::make_shared<CSettingControlButton>();
1530   if (!control->SetFormat(format))
1531     return NULL;
1532
1533   control->SetDelayed(delayed);
1534   control->SetHeading(heading);
1535   control->SetHideValue(hideValue);
1536   control->SetShowInstalledAddons(showInstalledAddons);
1537   control->SetShowInstallableAddons(showInstallableAddons);
1538   control->SetShowMoreAddons(showMoreAddons);
1539
1540   return control;
1541 }
1542
1543 std::shared_ptr<ISettingControl> CGUIDialogSettingsManualBase::GetSpinnerControl(const std::string &format, bool delayed /* = false */, int minimumLabel /* = -1 */, int formatLabel /* = -1 */, const std::string &formatString /* = "" */)
1544 {
1545   std::shared_ptr<CSettingControlSpinner> control = std::make_shared<CSettingControlSpinner>();
1546   if (!control->SetFormat(format))
1547     return NULL;
1548
1549   control->SetDelayed(delayed);
1550   if (formatLabel >= 0)
1551     control->SetFormatLabel(formatLabel);
1552   if (!formatString.empty())
1553     control->SetFormatString(formatString);
1554   if (minimumLabel >= 0)
1555     control->SetMinimumLabel(minimumLabel);
1556
1557   return control;
1558 }
1559
1560 std::shared_ptr<ISettingControl> CGUIDialogSettingsManualBase::GetListControl(
1561     const std::string& format,
1562     bool delayed /* = false */,
1563     int heading /* = -1 */,
1564     bool multiselect /* = false */,
1565     SettingControlListValueFormatter formatter /* = NULL */,
1566     bool details /* = false */)
1567 {
1568   std::shared_ptr<CSettingControlList> control = std::make_shared<CSettingControlList>();
1569   if (!control->SetFormat(format))
1570     return NULL;
1571
1572   control->SetDelayed(delayed);
1573   control->SetHeading(heading);
1574   control->SetMultiSelect(multiselect);
1575   control->SetFormatter(formatter);
1576   control->SetUseDetails(details);
1577
1578   return control;
1579 }
1580
1581 std::shared_ptr<ISettingControl> CGUIDialogSettingsManualBase::GetSliderControl(const std::string &format, bool delayed /* = false */, int heading /* = -1 */, bool usePopup /* = false */,
1582                                                                 int formatLabel /* = -1 */, const std::string &formatString /* = "" */)
1583 {
1584   std::shared_ptr<CSettingControlSlider> control = std::make_shared<CSettingControlSlider>();
1585   if (!control->SetFormat(format))
1586     return NULL;
1587
1588   control->SetDelayed(delayed);
1589   if (heading >= 0)
1590     control->SetHeading(heading);
1591   control->SetPopup(usePopup);
1592   if (formatLabel >= 0)
1593     control->SetFormatLabel(formatLabel);
1594   if (!formatString.empty())
1595     control->SetFormatString(formatString);
1596
1597   return control;
1598 }
1599
1600 std::shared_ptr<ISettingControl> CGUIDialogSettingsManualBase::GetRangeControl(const std::string &format, bool delayed /* = false */, int formatLabel /* = -1 */,
1601                                                                int valueFormatLabel /* = -1 */, const std::string &valueFormatString /* = "" */)
1602 {
1603   std::shared_ptr<CSettingControlRange> control = std::make_shared<CSettingControlRange>();
1604   if (!control->SetFormat(format))
1605     return NULL;
1606
1607   control->SetDelayed(delayed);
1608   if (formatLabel >= 0)
1609     control->SetFormatLabel(formatLabel);
1610   if (valueFormatLabel >= 0)
1611     control->SetValueFormatLabel(valueFormatLabel);
1612   if (!valueFormatString.empty())
1613     control->SetValueFormat(valueFormatString);
1614
1615   return control;
1616 }