xbmc/settings/dialogs/GUIDialogContentSettings.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 "GUIDialogContentSettings.h"
  10
  11 #include "ServiceBroker.h"
  12 #include "addons/AddonManager.h"
  13 #include "addons/AddonSystemSettings.h"
  14 #include "addons/gui/GUIDialogAddonSettings.h"
  15 #include "addons/gui/GUIWindowAddonBrowser.h"
  16 #include "dialogs/GUIDialogKaiToast.h"
  17 #include "dialogs/GUIDialogSelect.h"
  18 #include "filesystem/AddonsDirectory.h"
  19 #include "guilib/GUIComponent.h"
  20 #include "guilib/GUIWindowManager.h"
  21 #include "guilib/LocalizeStrings.h"
  22 #include "settings/lib/Setting.h"
  23 #include "settings/lib/SettingsManager.h"
  24 #include "settings/windows/GUIControlSettings.h"
  25 #include "utils/log.h"
  26 #include "video/VideoInfoScanner.h"
  27
  28 #include <limits.h>
  29 #include <map>
  30 #include <memory>
  31 #include <string>
  32 #include <utility>
  33 #include <vector>
  34
  35 #define SETTING_CONTENT_TYPE          "contenttype"
  36 #define SETTING_SCRAPER_LIST          "scraperlist"
  37 #define SETTING_SCRAPER_SETTINGS      "scrapersettings"
  38 #define SETTING_SCAN_RECURSIVE        "scanrecursive"
  39 #define SETTING_USE_DIRECTORY_NAMES   "usedirectorynames"
  40 #define SETTING_CONTAINS_SINGLE_ITEM  "containssingleitem"
  41 #define SETTING_EXCLUDE               "exclude"
  42 #define SETTING_NO_UPDATING           "noupdating"
  43 #define SETTING_ALL_EXTERNAL_AUDIO "allexternalaudio"
  44
  45 using namespace ADDON;
  46 using namespace KODI;
  47
  48 CGUIDialogContentSettings::CGUIDialogContentSettings()
  49   : CGUIDialogSettingsManualBase(WINDOW_DIALOG_CONTENT_SETTINGS, "DialogSettings.xml")
  50 { }
  51
  52 void CGUIDialogContentSettings::SetContent(CONTENT_TYPE content)
  53 {
  54   m_content = m_originalContent = content;
  55 }
  56
  57 void CGUIDialogContentSettings::ResetContent()
  58 {
  59   SetContent(CONTENT_NONE);
  60 }
  61
  62 void CGUIDialogContentSettings::SetScanSettings(const VIDEO::SScanSettings &scanSettings)
  63 {
  64   m_scanRecursive       = (scanSettings.recurse > 0 && !scanSettings.parent_name) ||
  65                           (scanSettings.recurse > 1 && scanSettings.parent_name);
  66   m_useDirectoryNames   = scanSettings.parent_name;
  67   m_exclude             = scanSettings.exclude;
  68   m_containsSingleItem  = scanSettings.parent_name_root;
  69   m_noUpdating          = scanSettings.noupdate;
  70   m_allExternalAudio = scanSettings.m_allExtAudio;
  71 }
  72
  73 bool CGUIDialogContentSettings::Show(ADDON::ScraperPtr& scraper, CONTENT_TYPE content /* = CONTENT_NONE */)
  74 {
  75   VIDEO::SScanSettings dummy;
  76   return Show(scraper, dummy, content);
  77 }
  78
  79 bool CGUIDialogContentSettings::Show(ADDON::ScraperPtr& scraper, VIDEO::SScanSettings& settings, CONTENT_TYPE content /* = CONTENT_NONE */)
  80 {
  81   CGUIDialogContentSettings *dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogContentSettings>(WINDOW_DIALOG_CONTENT_SETTINGS);
  82   if (dialog == NULL)
  83     return false;
  84
  85   if (scraper != NULL)
  86   {
  87     dialog->SetContent(content != CONTENT_NONE ? content : scraper->Content());
  88     dialog->SetScraper(scraper);
  89     // toast selected but disabled scrapers
  90     if (CServiceBroker::GetAddonMgr().IsAddonDisabled(scraper->ID()))
  91       CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Error, g_localizeStrings.Get(24024), scraper->Name(), 2000, true);
  92   }
  93
  94   dialog->SetScanSettings(settings);
  95   dialog->Open();
  96
  97   bool confirmed = dialog->IsConfirmed();
  98   if (confirmed)
  99   {
 100     scraper = dialog->GetScraper();
 101     content = dialog->GetContent();
 102
 103     settings.m_allExtAudio = dialog->GetUseAllExternalAudio();
 104
 105     if (scraper == NULL || content == CONTENT_NONE)
 106       settings.exclude = dialog->GetExclude();
 107     else
 108     {
 109       settings.exclude = false;
 110       settings.noupdate = dialog->GetNoUpdating();
 111       scraper->SetPathSettings(content, "");
 112
 113       if (content == CONTENT_TVSHOWS)
 114       {
 115         settings.parent_name = settings.parent_name_root = dialog->GetContainsSingleItem();
 116         settings.recurse = 0;
 117       }
 118       else if (content == CONTENT_MOVIES || content == CONTENT_MUSICVIDEOS)
 119       {
 120         if (dialog->GetUseDirectoryNames())
 121         {
 122           settings.parent_name = true;
 123           settings.parent_name_root = false;
 124           settings.recurse = dialog->GetScanRecursive() ? INT_MAX : 1;
 125
 126           if (dialog->GetContainsSingleItem())
 127           {
 128             settings.parent_name_root = true;
 129             settings.recurse = 0;
 130           }
 131         }
 132         else
 133         {
 134           settings.parent_name = false;
 135           settings.parent_name_root = false;
 136           settings.recurse = dialog->GetScanRecursive() ? INT_MAX : 0;
 137         }
 138       }
 139     }
 140   }
 141
 142   // now that we have evaluated all settings we need to reset the content
 143   dialog->ResetContent();
 144
 145   return confirmed;
 146 }
 147
 148 void CGUIDialogContentSettings::OnInitWindow()
 149 {
 150   CGUIDialogSettingsManualBase::OnInitWindow();
 151 }
 152
 153 void CGUIDialogContentSettings::OnSettingChanged(const std::shared_ptr<const CSetting>& setting)
 154 {
 155   if (setting == NULL)
 156     return;
 157
 158   CGUIDialogSettingsManualBase::OnSettingChanged(setting);
 159
 160   const std::string &settingId = setting->GetId();
 161   if (settingId == SETTING_CONTAINS_SINGLE_ITEM)
 162     m_containsSingleItem = std::static_pointer_cast<const CSettingBool>(setting)->GetValue();
 163   else if (settingId == SETTING_NO_UPDATING)
 164     m_noUpdating = std::static_pointer_cast<const CSettingBool>(setting)->GetValue();
 165   else if (settingId == SETTING_USE_DIRECTORY_NAMES)
 166     m_useDirectoryNames = std::static_pointer_cast<const CSettingBool>(setting)->GetValue();
 167   else if (settingId == SETTING_SCAN_RECURSIVE)
 168   {
 169     m_scanRecursive = std::static_pointer_cast<const CSettingBool>(setting)->GetValue();
 170     GetSettingsManager()->SetBool(SETTING_CONTAINS_SINGLE_ITEM, false);
 171   }
 172   else if (settingId == SETTING_EXCLUDE)
 173     m_exclude = std::static_pointer_cast<const CSettingBool>(setting)->GetValue();
 174   else if (settingId == SETTING_ALL_EXTERNAL_AUDIO)
 175     m_allExternalAudio = std::static_pointer_cast<const CSettingBool>(setting)->GetValue();
 176 }
 177
 178 void CGUIDialogContentSettings::OnSettingAction(const std::shared_ptr<const CSetting>& setting)
 179 {
 180   if (setting == NULL)
 181     return;
 182
 183   CGUIDialogSettingsManualBase::OnSettingAction(setting);
 184
 185   const std::string &settingId = setting->GetId();
 186
 187   if (settingId == SETTING_CONTENT_TYPE)
 188   {
 189     std::vector<std::pair<std::string, int>> labels;
 190     if (m_content == CONTENT_ALBUMS || m_content == CONTENT_ARTISTS)
 191     {
 192       labels.emplace_back(ADDON::TranslateContent(m_content, true), m_content);
 193     }
 194     else
 195     {
 196       labels.emplace_back(ADDON::TranslateContent(CONTENT_NONE, true), CONTENT_NONE);
 197       labels.emplace_back(ADDON::TranslateContent(CONTENT_MOVIES, true), CONTENT_MOVIES);
 198       labels.emplace_back(ADDON::TranslateContent(CONTENT_TVSHOWS, true), CONTENT_TVSHOWS);
 199       labels.emplace_back(ADDON::TranslateContent(CONTENT_MUSICVIDEOS, true), CONTENT_MUSICVIDEOS);
 200     }
 201     std::sort(labels.begin(), labels.end());
 202
 203     CGUIDialogSelect *dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSelect>(WINDOW_DIALOG_SELECT);
 204     if (dialog)
 205     {
 206       dialog->SetHeading(CVariant{ 20344 }); //Label "This directory contains"
 207
 208       int iIndex = 0;
 209       int iSelected = 0;
 210       for (const auto &label : labels)
 211       {
 212         dialog->Add(label.first);
 213
 214         if (m_content == label.second)
 215           iSelected = iIndex;
 216         iIndex++;
 217       }
 218
 219       dialog->SetSelected(iSelected);
 220
 221       dialog->Open();
 222       // Selected item has not changes - in case of cancel or the user selecting the same item
 223       int newSelected = dialog->GetSelectedItem();
 224       if (!dialog->IsConfirmed() || newSelected < 0 || newSelected == iSelected)
 225         return;
 226
 227       auto selected = labels.at(newSelected);
 228       m_content = static_cast<CONTENT_TYPE>(selected.second);
 229
 230       AddonPtr scraperAddon;
 231       if (!CAddonSystemSettings::GetInstance().GetActive(ADDON::ScraperTypeFromContent(m_content), scraperAddon) && m_content != CONTENT_NONE)
 232         return;
 233
 234       m_scraper = std::dynamic_pointer_cast<CScraper>(scraperAddon);
 235
 236       SetupView();
 237       SetFocusToSetting(SETTING_CONTENT_TYPE);
 238     }
 239   }
 240   else if (settingId == SETTING_SCRAPER_LIST)
 241   {
 242     ADDON::AddonType type = ADDON::ScraperTypeFromContent(m_content);
 243     std::string currentScraperId;
 244     if (m_scraper != nullptr)
 245       currentScraperId = m_scraper->ID();
 246     std::string selectedAddonId = currentScraperId;
 247
 248     if (CGUIWindowAddonBrowser::SelectAddonID(type, selectedAddonId, false) == 1
 249         && selectedAddonId != currentScraperId)
 250     {
 251       AddonPtr scraperAddon;
 252       if (CServiceBroker::GetAddonMgr().GetAddon(selectedAddonId, scraperAddon,
 253                                                  ADDON::OnlyEnabled::CHOICE_YES))
 254       {
 255         m_scraper = std::dynamic_pointer_cast<CScraper>(scraperAddon);
 256         SetupView();
 257         SetFocusToSetting(SETTING_SCRAPER_LIST);
 258       }
 259       else
 260       {
 261         CLog::Log(LOGERROR, "{} - Could not get settings for addon: {}", __FUNCTION__,
 262                   selectedAddonId);
 263       }
 264     }
 265   }
 266   else if (settingId == SETTING_SCRAPER_SETTINGS)
 267     CGUIDialogAddonSettings::ShowForAddon(m_scraper, false);
 268 }
 269
 270 bool CGUIDialogContentSettings::Save()
 271 {
 272   //Should be saved by caller of ::Show
 273   return true;
 274 }
 275
 276 void CGUIDialogContentSettings::SetupView()
 277 {
 278   CGUIDialogSettingsManualBase::SetupView();
 279   SetHeading(20333);
 280
 281   SET_CONTROL_HIDDEN(CONTROL_SETTINGS_CUSTOM_BUTTON);
 282   SET_CONTROL_LABEL(CONTROL_SETTINGS_OKAY_BUTTON, 186);
 283   SET_CONTROL_LABEL(CONTROL_SETTINGS_CANCEL_BUTTON, 222);
 284
 285   SetLabel2(SETTING_CONTENT_TYPE, ADDON::TranslateContent(m_content, true));
 286
 287   if (m_content == CONTENT_NONE)
 288   {
 289     ToggleState(SETTING_SCRAPER_LIST, false);
 290     ToggleState(SETTING_SCRAPER_SETTINGS, false);
 291   }
 292   else
 293   {
 294     ToggleState(SETTING_SCRAPER_LIST, true);
 295     if (m_scraper != NULL && !CServiceBroker::GetAddonMgr().IsAddonDisabled(m_scraper->ID()))
 296     {
 297       SetLabel2(SETTING_SCRAPER_LIST, m_scraper->Name());
 298       if (m_scraper && m_scraper->Supports(m_content) && m_scraper->HasSettings())
 299         ToggleState(SETTING_SCRAPER_SETTINGS, true);
 300       else
 301         ToggleState(SETTING_SCRAPER_SETTINGS, false);
 302     }
 303     else
 304     {
 305       SetLabel2(SETTING_SCRAPER_LIST, g_localizeStrings.Get(231)); //Set label2 to "None"
 306       ToggleState(SETTING_SCRAPER_SETTINGS, false);
 307     }
 308   }
 309 }
 310
 311 void CGUIDialogContentSettings::InitializeSettings()
 312 {
 313   CGUIDialogSettingsManualBase::InitializeSettings();
 314
 315   if (m_content == CONTENT_NONE)
 316     m_showScanSettings = false;
 317   else if (m_scraper != NULL && !CServiceBroker::GetAddonMgr().IsAddonDisabled(m_scraper->ID()))
 318     m_showScanSettings = true;
 319
 320   std::shared_ptr<CSettingCategory> category = AddCategory("contentsettings", -1);
 321   if (category == NULL)
 322   {
 323     CLog::Log(LOGERROR, "CGUIDialogContentSettings: unable to setup settings");
 324     return;
 325   }
 326
 327   std::shared_ptr<CSettingGroup> group = AddGroup(category);
 328   if (group == NULL)
 329   {
 330     CLog::Log(LOGERROR, "CGUIDialogContentSettings: unable to setup settings");
 331     return;
 332   }
 333
 334   AddButton(group, SETTING_CONTENT_TYPE, 20344, SettingLevel::Basic);
 335   AddButton(group, SETTING_SCRAPER_LIST, 38025, SettingLevel::Basic);
 336   std::shared_ptr<CSettingAction> subsetting = AddButton(group, SETTING_SCRAPER_SETTINGS, 10004, SettingLevel::Basic);
 337   if (subsetting != NULL)
 338     subsetting->SetParent(SETTING_SCRAPER_LIST);
 339
 340   std::shared_ptr<CSettingGroup> groupDetails = AddGroup(category, 20322);
 341   if (groupDetails == NULL)
 342   {
 343     CLog::Log(LOGERROR, "CGUIDialogContentSettings: unable to setup scanning settings");
 344     return;
 345   }
 346   switch (m_content)
 347   {
 348     case CONTENT_TVSHOWS:
 349     {
 350       AddToggle(groupDetails, SETTING_CONTAINS_SINGLE_ITEM, 20379, SettingLevel::Basic, m_containsSingleItem, false, m_showScanSettings);
 351       AddToggle(groupDetails, SETTING_NO_UPDATING, 20432, SettingLevel::Basic, m_noUpdating, false, m_showScanSettings);
 352       AddToggle(groupDetails, SETTING_ALL_EXTERNAL_AUDIO, 39120, SettingLevel::Basic,
 353                 m_allExternalAudio, false, m_showScanSettings);
 354       break;
 355     }
 356
 357     case CONTENT_MOVIES:
 358     case CONTENT_MUSICVIDEOS:
 359     {
 360       AddToggle(groupDetails, SETTING_USE_DIRECTORY_NAMES, m_content == CONTENT_MOVIES ? 20329 : 20330, SettingLevel::Basic, m_useDirectoryNames, false, m_showScanSettings);
 361       std::shared_ptr<CSettingBool> settingScanRecursive = AddToggle(groupDetails, SETTING_SCAN_RECURSIVE, 20346, SettingLevel::Basic, m_scanRecursive, false, m_showScanSettings);
 362       std::shared_ptr<CSettingBool> settingContainsSingleItem = AddToggle(groupDetails, SETTING_CONTAINS_SINGLE_ITEM, 20383, SettingLevel::Basic, m_containsSingleItem, false, m_showScanSettings);
 363       AddToggle(groupDetails, SETTING_NO_UPDATING, 20432, SettingLevel::Basic, m_noUpdating, false, m_showScanSettings);
 364       AddToggle(groupDetails, SETTING_ALL_EXTERNAL_AUDIO, 39120, SettingLevel::Basic,
 365                 m_allExternalAudio, false, m_showScanSettings);
 366
 367       // define an enable dependency with (m_useDirectoryNames && !m_containsSingleItem) || !m_useDirectoryNames
 368       CSettingDependency dependencyScanRecursive(SettingDependencyType::Enable, GetSettingsManager());
 369       dependencyScanRecursive.Or()
 370           ->Add(CSettingDependencyConditionCombinationPtr(
 371               (new CSettingDependencyConditionCombination(
 372                    BooleanLogicOperationAnd,
 373                    GetSettingsManager())) // m_useDirectoryNames && !m_containsSingleItem
 374                   ->Add(std::make_shared<CSettingDependencyCondition>(
 375                       SETTING_USE_DIRECTORY_NAMES, "true", SettingDependencyOperator::Equals, false,
 376                       GetSettingsManager())) // m_useDirectoryNames
 377                   ->Add(std::make_shared<CSettingDependencyCondition>(
 378                       SETTING_CONTAINS_SINGLE_ITEM, "false", SettingDependencyOperator::Equals,
 379                       false, GetSettingsManager())))) // !m_containsSingleItem
 380           ->Add(std::make_shared<CSettingDependencyCondition>(
 381               SETTING_USE_DIRECTORY_NAMES, "false", SettingDependencyOperator::Equals, false,
 382               GetSettingsManager())); // !m_useDirectoryNames
 383
 384       // define an enable dependency with m_useDirectoryNames && !m_scanRecursive
 385       CSettingDependency dependencyContainsSingleItem(SettingDependencyType::Enable, GetSettingsManager());
 386       dependencyContainsSingleItem.And()
 387           ->Add(std::make_shared<CSettingDependencyCondition>(
 388               SETTING_USE_DIRECTORY_NAMES, "true", SettingDependencyOperator::Equals, false,
 389               GetSettingsManager())) // m_useDirectoryNames
 390           ->Add(std::make_shared<CSettingDependencyCondition>(
 391               SETTING_SCAN_RECURSIVE, "false", SettingDependencyOperator::Equals, false,
 392               GetSettingsManager())); // !m_scanRecursive
 393
 394       SettingDependencies deps;
 395       deps.push_back(dependencyScanRecursive);
 396       settingScanRecursive->SetDependencies(deps);
 397
 398       deps.clear();
 399       deps.push_back(dependencyContainsSingleItem);
 400       settingContainsSingleItem->SetDependencies(deps);
 401       break;
 402     }
 403
 404     case CONTENT_ALBUMS:
 405     case CONTENT_ARTISTS:
 406       break;
 407
 408     case CONTENT_NONE:
 409     default:
 410       AddToggle(groupDetails, SETTING_EXCLUDE, 20380, SettingLevel::Basic, m_exclude, false, !m_showScanSettings);
 411       AddToggle(groupDetails, SETTING_ALL_EXTERNAL_AUDIO, 39120, SettingLevel::Basic,
 412                 m_allExternalAudio, false, !m_showScanSettings);
 413       break;
 414   }
 415 }
 416
 417 void CGUIDialogContentSettings::SetLabel2(const std::string &settingid, const std::string &label)
 418 {
 419   BaseSettingControlPtr settingControl = GetSettingControl(settingid);
 420   if (settingControl != NULL && settingControl->GetControl() != NULL)
 421     SET_CONTROL_LABEL2(settingControl->GetID(), label);
 422 }
 423
 424 void CGUIDialogContentSettings::ToggleState(const std::string &settingid, bool enabled)
 425 {
 426   BaseSettingControlPtr settingControl = GetSettingControl(settingid);
 427   if (settingControl != NULL && settingControl->GetControl() != NULL)
 428   {
 429     if (enabled)
 430       CONTROL_ENABLE(settingControl->GetID());
 431     else
 432       CONTROL_DISABLE(settingControl->GetID());
 433   }
 434 }
 435
 436 void CGUIDialogContentSettings::SetFocusToSetting(const std::string& settingid)
 437 {
 438   BaseSettingControlPtr settingControl = GetSettingControl(settingid);
 439   if (settingControl != NULL && settingControl->GetControl() != NULL)
 440     SET_CONTROL_FOCUS(settingControl->GetID(), 0);
 441 }