xbmc/video/dialogs/GUIDialogSubtitleSettings.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 "GUIDialogSubtitleSettings.h"
  10
  11 #include "FileItem.h"
  12 #include "GUIDialogSubtitles.h"
  13 #include "GUIPassword.h"
  14 #include "ServiceBroker.h"
  15 #include "URL.h"
  16 #include "addons/Skin.h"
  17 #include "addons/VFSEntry.h"
  18 #include "application/Application.h"
  19 #include "application/ApplicationComponents.h"
  20 #include "application/ApplicationPlayer.h"
  21 #include "cores/IPlayer.h"
  22 #include "dialogs/GUIDialogFileBrowser.h"
  23 #include "dialogs/GUIDialogYesNo.h"
  24 #include "guilib/GUIComponent.h"
  25 #include "guilib/GUIWindowManager.h"
  26 #include "guilib/LocalizeStrings.h"
  27 #include "profiles/ProfileManager.h"
  28 #include "settings/AdvancedSettings.h"
  29 #include "settings/MediaSettings.h"
  30 #include "settings/MediaSourceSettings.h"
  31 #include "settings/Settings.h"
  32 #include "settings/SettingsComponent.h"
  33 #include "settings/lib/Setting.h"
  34 #include "settings/lib/SettingDefinitions.h"
  35 #include "settings/lib/SettingsManager.h"
  36 #include "utils/FileUtils.h"
  37 #include "utils/LangCodeExpander.h"
  38 #include "utils/StringUtils.h"
  39 #include "utils/URIUtils.h"
  40 #include "utils/Variant.h"
  41 #include "utils/log.h"
  42 #include "video/VideoDatabase.h"
  43
  44 #include <string>
  45 #include <vector>
  46
  47 #define SETTING_SUBTITLE_ENABLE                "subtitles.enable"
  48 #define SETTING_SUBTITLE_DELAY                 "subtitles.delay"
  49 #define SETTING_SUBTITLE_STREAM                "subtitles.stream"
  50 #define SETTING_SUBTITLE_BROWSER               "subtitles.browser"
  51 #define SETTING_SUBTITLE_SEARCH                "subtitles.search"
  52 #define SETTING_MAKE_DEFAULT                   "audio.makedefault"
  53
  54 CGUIDialogSubtitleSettings::CGUIDialogSubtitleSettings()
  55   : CGUIDialogSettingsManualBase(WINDOW_DIALOG_SUBTITLE_OSD_SETTINGS, "DialogSettings.xml")
  56 { }
  57
  58 CGUIDialogSubtitleSettings::~CGUIDialogSubtitleSettings() = default;
  59
  60 void CGUIDialogSubtitleSettings::FrameMove()
  61 {
  62   const auto& components = CServiceBroker::GetAppComponents();
  63   const auto appPlayer = components.GetComponent<CApplicationPlayer>();
  64   if (appPlayer->HasPlayer())
  65   {
  66     const CVideoSettings videoSettings = appPlayer->GetVideoSettings();
  67
  68     // these settings can change on the fly
  69     //! @todo m_settingsManager->SetBool(SETTING_SUBTITLE_ENABLE, g_application.GetAppPlayer().GetSubtitleVisible());
  70     //   \-> Unless subtitle visibility can change on the fly, while Dialog is up, this code should be removed.
  71     GetSettingsManager()->SetNumber(SETTING_SUBTITLE_DELAY,
  72                                     static_cast<double>(videoSettings.m_SubtitleDelay));
  73     //! @todo (needs special handling): m_settingsManager->SetInt(SETTING_SUBTITLE_STREAM, g_application.GetAppPlayer().GetSubtitle());
  74   }
  75
  76   CGUIDialogSettingsManualBase::FrameMove();
  77 }
  78
  79 bool CGUIDialogSubtitleSettings::OnMessage(CGUIMessage& message)
  80 {
  81   if (message.GetMessage() == GUI_MSG_SUBTITLE_DOWNLOADED)
  82   {
  83     Close();
  84   }
  85   return CGUIDialogSettingsManualBase::OnMessage(message);
  86 }
  87
  88 void CGUIDialogSubtitleSettings::OnSettingChanged(const std::shared_ptr<const CSetting>& setting)
  89 {
  90   if (setting == NULL)
  91     return;
  92
  93   auto& components = CServiceBroker::GetAppComponents();
  94   const auto appPlayer = components.GetComponent<CApplicationPlayer>();
  95
  96   CGUIDialogSettingsManualBase::OnSettingChanged(setting);
  97
  98   const std::string &settingId = setting->GetId();
  99   if (settingId == SETTING_SUBTITLE_ENABLE)
 100   {
 101     bool value = std::static_pointer_cast<const CSettingBool>(setting)->GetValue();
 102     appPlayer->SetSubtitleVisible(value);
 103   }
 104   else if (settingId == SETTING_SUBTITLE_DELAY)
 105   {
 106     float value = static_cast<float>(std::static_pointer_cast<const CSettingNumber>(setting)->GetValue());
 107     appPlayer->SetSubTitleDelay(value);
 108   }
 109   else if (settingId == SETTING_SUBTITLE_STREAM)
 110   {
 111     m_subtitleStream = std::static_pointer_cast<const CSettingInt>(setting)->GetValue();
 112     appPlayer->SetSubtitle(m_subtitleStream);
 113   }
 114 }
 115
 116 std::string CGUIDialogSubtitleSettings::BrowseForSubtitle()
 117 {
 118   std::string extras;
 119   for (const auto& vfsAddon : CServiceBroker::GetVFSAddonCache().GetAddonInstances())
 120   {
 121     if (vfsAddon->ID() == "vfs.rar" || vfsAddon->ID() == "vfs.libarchive")
 122       extras += '|' + vfsAddon->GetExtensions();
 123   }
 124
 125   std::string strPath;
 126   if (URIUtils::IsInRAR(g_application.CurrentFileItem().GetPath()) || URIUtils::IsInZIP(g_application.CurrentFileItem().GetPath()))
 127   {
 128     strPath = CURL(g_application.CurrentFileItem().GetPath()).GetHostName();
 129   }
 130   else if (!URIUtils::IsPlugin(g_application.CurrentFileItem().GetPath()))
 131   {
 132     strPath = g_application.CurrentFileItem().GetPath();
 133   }
 134
 135   std::string strMask =
 136       ".utf|.utf8|.utf-8|.sub|.srt|.smi|.rt|.txt|.ssa|.aqt|.jss|.ass|.vtt|.idx|.zip|.sup";
 137
 138   if (g_application.GetCurrentPlayer() == "VideoPlayer")
 139     strMask = ".srt|.zip|.ifo|.smi|.sub|.idx|.ass|.ssa|.vtt|.txt|.sup";
 140
 141   strMask += extras;
 142
 143   VECSOURCES shares(*CMediaSourceSettings::GetInstance().GetSources("video"));
 144   if (CMediaSettings::GetInstance().GetAdditionalSubtitleDirectoryChecked() != -1 && !CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_SUBTITLES_CUSTOMPATH).empty())
 145   {
 146     CMediaSource share;
 147     std::vector<std::string> paths;
 148     if (!strPath.empty())
 149     {
 150       paths.push_back(URIUtils::GetDirectory(strPath));
 151     }
 152     paths.push_back(CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_SUBTITLES_CUSTOMPATH));
 153     share.FromNameAndPaths("video",g_localizeStrings.Get(21367),paths);
 154     shares.push_back(share);
 155     strPath = share.strPath;
 156     URIUtils::AddSlashAtEnd(strPath);
 157   }
 158
 159   if (CGUIDialogFileBrowser::ShowAndGetFile(shares, strMask, g_localizeStrings.Get(293), strPath, false, true)) // "subtitles"
 160   {
 161     if (URIUtils::HasExtension(strPath, ".sub"))
 162     {
 163       if (CFileUtils::Exists(URIUtils::ReplaceExtension(strPath, ".idx")))
 164         strPath = URIUtils::ReplaceExtension(strPath, ".idx");
 165     }
 166
 167     return strPath;
 168   }
 169
 170   return "";
 171 }
 172
 173 void CGUIDialogSubtitleSettings::OnSettingAction(const std::shared_ptr<const CSetting>& setting)
 174 {
 175   if (setting == NULL)
 176     return;
 177
 178   CGUIDialogSettingsManualBase::OnSettingAction(setting);
 179
 180   const std::string &settingId = setting->GetId();
 181   if (settingId == SETTING_SUBTITLE_BROWSER)
 182   {
 183     std::string strPath = BrowseForSubtitle();
 184     if (!strPath.empty())
 185     {
 186       auto& components = CServiceBroker::GetAppComponents();
 187       const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 188       appPlayer->AddSubtitle(strPath);
 189       Close();
 190     }
 191   }
 192   else if (settingId == SETTING_SUBTITLE_SEARCH)
 193   {
 194     auto dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSubtitles>(WINDOW_DIALOG_SUBTITLES);
 195     if (dialog)
 196     {
 197       dialog->Open();
 198       m_subtitleStreamSetting->UpdateDynamicOptions();
 199     }
 200   }
 201   else if (settingId == SETTING_MAKE_DEFAULT)
 202     Save();
 203 }
 204
 205 bool CGUIDialogSubtitleSettings::Save()
 206 {
 207   const std::shared_ptr<CProfileManager> profileManager = CServiceBroker::GetSettingsComponent()->GetProfileManager();
 208
 209   if (!g_passwordManager.CheckSettingLevelLock(SettingLevel::Expert) &&
 210       profileManager->GetMasterProfile().getLockMode() != LOCK_MODE_EVERYONE)
 211     return true;
 212
 213   // prompt user if they are sure
 214   if (!CGUIDialogYesNo::ShowAndGetInput(CVariant{12376}, CVariant{12377}))
 215     return true;
 216
 217   // reset the settings
 218   CVideoDatabase db;
 219   if (!db.Open())
 220     return true;
 221
 222   db.EraseAllVideoSettings();
 223   db.Close();
 224   const auto& components = CServiceBroker::GetAppComponents();
 225   const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 226
 227   CMediaSettings::GetInstance().GetDefaultVideoSettings() = appPlayer->GetVideoSettings();
 228   CMediaSettings::GetInstance().GetDefaultVideoSettings().m_SubtitleStream = -1;
 229   CServiceBroker::GetSettingsComponent()->GetSettings()->Save();
 230
 231   return true;
 232 }
 233
 234 void CGUIDialogSubtitleSettings::SetupView()
 235 {
 236   CGUIDialogSettingsManualBase::SetupView();
 237
 238   SetHeading(24133);
 239   SET_CONTROL_HIDDEN(CONTROL_SETTINGS_OKAY_BUTTON);
 240   SET_CONTROL_HIDDEN(CONTROL_SETTINGS_CUSTOM_BUTTON);
 241   SET_CONTROL_LABEL(CONTROL_SETTINGS_CANCEL_BUTTON, 15067);
 242 }
 243
 244 void CGUIDialogSubtitleSettings::InitializeSettings()
 245 {
 246   CGUIDialogSettingsManualBase::InitializeSettings();
 247
 248   const auto& components = CServiceBroker::GetAppComponents();
 249   const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 250
 251   const std::shared_ptr<CSettingCategory> category = AddCategory("audiosubtitlesettings", -1);
 252   if (category == NULL)
 253   {
 254     CLog::Log(LOGERROR, "CGUIDialogSubtitleSettings: unable to setup settings");
 255     return;
 256   }
 257
 258   // get all necessary setting groups
 259   const std::shared_ptr<CSettingGroup> groupAudio = AddGroup(category);
 260   if (groupAudio == NULL)
 261   {
 262     CLog::Log(LOGERROR, "CGUIDialogSubtitleSettings: unable to setup settings");
 263     return;
 264   }
 265   const std::shared_ptr<CSettingGroup> groupSubtitles = AddGroup(category);
 266   if (groupSubtitles == NULL)
 267   {
 268     CLog::Log(LOGERROR, "CGUIDialogSubtitleSettings: unable to setup settings");
 269     return;
 270   }
 271   const std::shared_ptr<CSettingGroup> groupSaveAsDefault = AddGroup(category);
 272   if (groupSaveAsDefault == NULL)
 273   {
 274     CLog::Log(LOGERROR, "CGUIDialogSubtitleSettings: unable to setup settings");
 275     return;
 276   }
 277
 278   bool usePopup = g_SkinInfo->HasSkinFile("DialogSlider.xml");
 279
 280   const CVideoSettings videoSettings = appPlayer->GetVideoSettings();
 281
 282   if (appPlayer->HasPlayer())
 283   {
 284     appPlayer->GetSubtitleCapabilities(m_subtitleCapabilities);
 285   }
 286
 287   // subtitle settings
 288   m_subtitleVisible = appPlayer->GetSubtitleVisible();
 289
 290   // subtitle enabled setting
 291   AddToggle(groupSubtitles, SETTING_SUBTITLE_ENABLE, 13397, SettingLevel::Basic, m_subtitleVisible);
 292
 293   // subtitle delay setting
 294   if (SupportsSubtitleFeature(IPC_SUBS_OFFSET))
 295   {
 296     std::shared_ptr<CSettingNumber> settingSubtitleDelay = AddSlider(groupSubtitles, SETTING_SUBTITLE_DELAY, 22006, SettingLevel::Basic, videoSettings.m_SubtitleDelay, 0, -CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_videoSubsDelayRange, 0.1f, CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_videoSubsDelayRange, 22006, usePopup);
 297     std::static_pointer_cast<CSettingControlSlider>(settingSubtitleDelay->GetControl())->SetFormatter(SettingFormatterDelay);
 298   }
 299
 300   // subtitle stream setting
 301   if (SupportsSubtitleFeature(IPC_SUBS_SELECT))
 302     AddSubtitleStreams(groupSubtitles, SETTING_SUBTITLE_STREAM);
 303
 304   // subtitle browser setting
 305   if (SupportsSubtitleFeature(IPC_SUBS_EXTERNAL))
 306     AddButton(groupSubtitles, SETTING_SUBTITLE_BROWSER, 13250, SettingLevel::Basic);
 307
 308   AddButton(groupSubtitles, SETTING_SUBTITLE_SEARCH, 24134, SettingLevel::Basic);
 309
 310   // subtitle stream setting
 311   AddButton(groupSaveAsDefault, SETTING_MAKE_DEFAULT, 12376, SettingLevel::Basic);
 312 }
 313
 314 bool CGUIDialogSubtitleSettings::SupportsSubtitleFeature(int feature)
 315 {
 316   for (auto item : m_subtitleCapabilities)
 317   {
 318     if (item == feature || item == IPC_SUBS_ALL)
 319       return true;
 320   }
 321   return false;
 322 }
 323
 324 void CGUIDialogSubtitleSettings::AddSubtitleStreams(const std::shared_ptr<CSettingGroup>& group,
 325                                                     const std::string& settingId)
 326 {
 327   if (group == NULL || settingId.empty())
 328     return;
 329
 330   auto& components = CServiceBroker::GetAppComponents();
 331   const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 332
 333   m_subtitleStream = appPlayer->GetSubtitle();
 334   if (m_subtitleStream < 0)
 335     m_subtitleStream = 0;
 336
 337   m_subtitleStreamSetting = AddList(group, settingId, 462, SettingLevel::Basic, m_subtitleStream, SubtitleStreamsOptionFiller, 462);
 338 }
 339
 340 void CGUIDialogSubtitleSettings::SubtitleStreamsOptionFiller(
 341     const SettingConstPtr& setting,
 342     std::vector<IntegerSettingOption>& list,
 343     int& current,
 344     void* data)
 345 {
 346   const auto& components = CServiceBroker::GetAppComponents();
 347   const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 348
 349   int subtitleStreamCount = appPlayer->GetSubtitleCount();
 350
 351   // cycle through each subtitle and add it to our entry list
 352   for (int i = 0; i < subtitleStreamCount; ++i)
 353   {
 354     SubtitleStreamInfo info;
 355     appPlayer->GetSubtitleStreamInfo(i, info);
 356
 357     std::string strItem;
 358     std::string strLanguage;
 359
 360     if (!g_LangCodeExpander.Lookup(info.language, strLanguage))
 361       strLanguage = g_localizeStrings.Get(13205); // Unknown
 362
 363     if (info.name.length() == 0)
 364       strItem = strLanguage;
 365     else
 366       strItem = StringUtils::Format("{} - {}", strLanguage, info.name);
 367
 368     strItem += FormatFlags(info.flags);
 369     strItem += StringUtils::Format(" ({}/{})", i + 1, subtitleStreamCount);
 370
 371     list.emplace_back(strItem, i);
 372   }
 373
 374   // no subtitle streams - just add a "None" entry
 375   if (list.empty())
 376   {
 377     list.emplace_back(g_localizeStrings.Get(231), -1);
 378     current = -1;
 379   }
 380 }
 381
 382 std::string CGUIDialogSubtitleSettings::SettingFormatterDelay(
 383     const std::shared_ptr<const CSettingControlSlider>& control,
 384     const CVariant& value,
 385     const CVariant& minimum,
 386     const CVariant& step,
 387     const CVariant& maximum)
 388 {
 389   if (!value.isDouble())
 390     return "";
 391
 392   float fValue = value.asFloat();
 393   float fStep = step.asFloat();
 394
 395   if (fabs(fValue) < 0.5f * fStep)
 396     return StringUtils::Format(g_localizeStrings.Get(22003), 0.0);
 397   if (fValue < 0)
 398     return StringUtils::Format(g_localizeStrings.Get(22004), fabs(fValue));
 399
 400   return StringUtils::Format(g_localizeStrings.Get(22005), fValue);
 401 }
 402
 403 std::string CGUIDialogSubtitleSettings::FormatFlags(StreamFlags flags)
 404 {
 405   std::vector<std::string> localizedFlags;
 406   if (flags & StreamFlags::FLAG_DEFAULT)
 407     localizedFlags.emplace_back(g_localizeStrings.Get(39105));
 408   if (flags & StreamFlags::FLAG_FORCED)
 409     localizedFlags.emplace_back(g_localizeStrings.Get(39106));
 410   if (flags & StreamFlags::FLAG_HEARING_IMPAIRED)
 411     localizedFlags.emplace_back(g_localizeStrings.Get(39107));
 412   if (flags &  StreamFlags::FLAG_VISUAL_IMPAIRED)
 413     localizedFlags.emplace_back(g_localizeStrings.Get(39108));
 414
 415   std::string formated = StringUtils::Join(localizedFlags, ", ");
 416
 417   if (!formated.empty())
 418     formated = StringUtils::Format(" [{}]", formated);
 419
 420   return formated;
 421 }