xbmc/settings/dialogs/GUIDialogLibExportSettings.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 "GUIDialogLibExportSettings.h"
  10
  11 #include "ServiceBroker.h"
  12 #include "Util.h"
  13 #include "dialogs/GUIDialogFileBrowser.h"
  14 #include "filesystem/Directory.h"
  15 #include "guilib/GUIComponent.h"
  16 #include "guilib/GUIWindowManager.h"
  17 #include "guilib/LocalizeStrings.h"
  18 #include "messaging/helpers/DialogHelper.h"
  19 #include "messaging/helpers/DialogOKHelper.h"
  20 #include "settings/SettingUtils.h"
  21 #include "settings/Settings.h"
  22 #include "settings/SettingsComponent.h"
  23 #include "settings/lib/Setting.h"
  24 #include "settings/windows/GUIControlSettings.h"
  25 #include "storage/MediaManager.h"
  26 #include "utils/URIUtils.h"
  27 #include "utils/log.h"
  28
  29 #include <limits.h>
  30 #include <map>
  31 #include <memory>
  32 #include <string>
  33 #include <utility>
  34 #include <vector>
  35
  36 using namespace ADDON;
  37 using namespace KODI::MESSAGING;
  38
  39 using KODI::MESSAGING::HELPERS::DialogResponse;
  40
  41 CGUIDialogLibExportSettings::CGUIDialogLibExportSettings()
  42   : CGUIDialogSettingsManualBase(WINDOW_DIALOG_LIBEXPORT_SETTINGS, "DialogSettings.xml")
  43 { }
  44
  45 bool CGUIDialogLibExportSettings::Show(CLibExportSettings& settings)
  46 {
  47   CGUIDialogLibExportSettings *dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogLibExportSettings>(WINDOW_DIALOG_LIBEXPORT_SETTINGS);
  48   if (!dialog)
  49     return false;
  50
  51   // Get current export settings from service broker
  52   const std::shared_ptr<CSettings> pSettings = CServiceBroker::GetSettingsComponent()->GetSettings();
  53   dialog->m_settings.SetExportType(pSettings->GetInt(CSettings::SETTING_MUSICLIBRARY_EXPORT_FILETYPE));
  54   dialog->m_settings.m_strPath = pSettings->GetString(CSettings::SETTING_MUSICLIBRARY_EXPORT_FOLDER);
  55   dialog->m_settings.SetItemsToExport(pSettings->GetInt(CSettings::SETTING_MUSICLIBRARY_EXPORT_ITEMS));
  56   dialog->m_settings.m_unscraped = pSettings->GetBool(CSettings::SETTING_MUSICLIBRARY_EXPORT_UNSCRAPED);
  57   dialog->m_settings.m_artwork = pSettings->GetBool(CSettings::SETTING_MUSICLIBRARY_EXPORT_ARTWORK);
  58   dialog->m_settings.m_skipnfo = pSettings->GetBool(CSettings::SETTING_MUSICLIBRARY_EXPORT_SKIPNFO);
  59   dialog->m_settings.m_overwrite = pSettings->GetBool(CSettings::SETTING_MUSICLIBRARY_EXPORT_OVERWRITE);
  60
  61   // Ensure NFO or art output enabled when albums exported (adjust old saved settings)
  62   if (dialog->m_settings.IsItemExported(ELIBEXPORT_ALBUMS) && (dialog->m_settings.m_skipnfo && !dialog->m_settings.m_artwork))
  63     dialog->m_settings.m_skipnfo = false;
  64
  65   dialog->m_destinationChecked = false;
  66   dialog->Open();
  67
  68   bool confirmed = dialog->IsConfirmed();
  69   if (confirmed)
  70   {
  71     // Return the new settings (saved by service broker but avoids re-reading)
  72     settings = dialog->m_settings;
  73   }
  74   return confirmed;
  75 }
  76
  77 void CGUIDialogLibExportSettings::OnInitWindow()
  78 {
  79   CGUIDialogSettingsManualBase::OnInitWindow();
  80 }
  81
  82 void CGUIDialogLibExportSettings::OnSettingChanged(const std::shared_ptr<const CSetting>& setting)
  83 {
  84   if (!setting)
  85     return;
  86
  87   CGUIDialogSettingsManualBase::OnSettingChanged(setting);
  88
  89   const std::string &settingId = setting->GetId();
  90
  91   if (settingId == CSettings::SETTING_MUSICLIBRARY_EXPORT_FILETYPE)
  92   {
  93     m_settings.SetExportType(std::static_pointer_cast<const CSettingInt>(setting)->GetValue());
  94     SetupView();
  95     SetFocus(CSettings::SETTING_MUSICLIBRARY_EXPORT_FILETYPE);
  96   }
  97   else if (settingId == CSettings::SETTING_MUSICLIBRARY_EXPORT_FOLDER)
  98   {
  99     m_settings.m_strPath = std::static_pointer_cast<const CSettingString>(setting)->GetValue();
 100     UpdateButtons();
 101   }
 102   else if (settingId == CSettings::SETTING_MUSICLIBRARY_EXPORT_OVERWRITE)
 103     m_settings.m_overwrite = std::static_pointer_cast<const CSettingBool>(setting)->GetValue();
 104   else if (settingId == CSettings::SETTING_MUSICLIBRARY_EXPORT_ITEMS)
 105   {
 106     m_settings.SetItemsToExport(GetExportItemsFromSetting(setting));
 107     if (m_settings.IsItemExported(ELIBEXPORT_ALBUMS) && (m_settings.m_skipnfo && !m_settings.m_artwork))
 108     {
 109       m_settings.m_skipnfo = false;
 110       m_settingNFO->SetValue(true);
 111       UpdateToggles();
 112     }
 113     UpdateDescription();
 114   }
 115   else if (settingId == CSettings::SETTING_MUSICLIBRARY_EXPORT_ARTWORK)
 116   {
 117     m_settings.m_artwork = std::static_pointer_cast<const CSettingBool>(setting)->GetValue();
 118     if (m_settings.IsItemExported(ELIBEXPORT_ALBUMS) && (m_settings.m_skipnfo && !m_settings.m_artwork))
 119     {
 120       m_settings.m_skipnfo = false;
 121       m_settingNFO->SetValue(true);
 122     }
 123     UpdateToggles();
 124   }
 125   else if (settingId == CSettings::SETTING_MUSICLIBRARY_EXPORT_UNSCRAPED)
 126     m_settings.m_unscraped = std::static_pointer_cast<const CSettingBool>(setting)->GetValue();
 127   else if (settingId == CSettings::SETTING_MUSICLIBRARY_EXPORT_SKIPNFO)
 128   {
 129     m_settings.m_skipnfo = !std::static_pointer_cast<const CSettingBool>(setting)->GetValue();
 130     if (m_settings.IsItemExported(ELIBEXPORT_ALBUMS) && (m_settings.m_skipnfo && !m_settings.m_artwork))
 131     {
 132       m_settings.m_artwork = true;
 133       m_settingArt->SetValue(true);
 134     }
 135     UpdateToggles();
 136   }
 137 }
 138
 139 void CGUIDialogLibExportSettings::OnSettingAction(const std::shared_ptr<const CSetting>& setting)
 140 {
 141   if (setting == NULL)
 142     return;
 143
 144   CGUIDialogSettingsManualBase::OnSettingAction(setting);
 145
 146   const std::string &settingId = setting->GetId();
 147
 148   if (settingId == CSettings::SETTING_MUSICLIBRARY_EXPORT_FOLDER && !m_settings.IsToLibFolders() &&
 149       !m_settings.IsArtistFoldersOnly())
 150   {
 151     VECSOURCES shares;
 152     CServiceBroker::GetMediaManager().GetLocalDrives(shares);
 153     CServiceBroker::GetMediaManager().GetNetworkLocations(shares);
 154     CServiceBroker::GetMediaManager().GetRemovableDrives(shares);
 155     std::string strDirectory = m_settings.m_strPath;
 156     if (!strDirectory.empty())
 157     {
 158       URIUtils::AddSlashAtEnd(strDirectory);
 159       bool bIsSource;
 160       if (CUtil::GetMatchingSource(strDirectory, shares, bIsSource) < 0) // path is outside shares - add it as a separate one
 161       {
 162         CMediaSource share;
 163         share.strName = g_localizeStrings.Get(13278);
 164         share.strPath = strDirectory;
 165         shares.push_back(share);
 166       }
 167     }
 168     else
 169       strDirectory = "default location";
 170
 171     if (CGUIDialogFileBrowser::ShowAndGetDirectory(shares, g_localizeStrings.Get(661), strDirectory, true))
 172     {
 173       if (!strDirectory.empty())
 174       {
 175         m_destinationChecked = true;
 176         m_settings.m_strPath = strDirectory;
 177         SetLabel2(CSettings::SETTING_MUSICLIBRARY_EXPORT_FOLDER, strDirectory);
 178         SetFocus(CSettings::SETTING_MUSICLIBRARY_EXPORT_FOLDER);
 179       }
 180     }
 181     UpdateButtons();
 182   }
 183 }
 184
 185 bool CGUIDialogLibExportSettings::OnMessage(CGUIMessage& message)
 186 {
 187   switch (message.GetMessage())
 188   {
 189     case GUI_MSG_CLICKED:
 190     {
 191       int iControl = message.GetSenderId();
 192       if (iControl == CONTROL_SETTINGS_OKAY_BUTTON)
 193       {
 194         OnOK();
 195         return true;
 196       }
 197     }
 198     break;
 199   }
 200   return CGUIDialogSettingsManualBase::OnMessage(message);
 201 }
 202
 203 void CGUIDialogLibExportSettings::OnOK()
 204 {
 205   // Validate destination folder
 206   if (m_settings.IsToLibFolders() || m_settings.IsArtistFoldersOnly())
 207   {
 208     // Check artist info folder setting
 209     std::string path = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_MUSICLIBRARY_ARTISTSFOLDER);
 210     if (path.empty())
 211     {
 212       //"Unable to export to library folders as the system artist information folder setting is empty"
 213       //Settings (YES) button takes user to enter the artist info folder setting
 214       if (HELPERS::ShowYesNoDialogText(20223, 38317, 186, 10004) == DialogResponse::CHOICE_YES)
 215       {
 216         m_confirmed = false;
 217         Close();
 218         CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(WINDOW_SETTINGS_MEDIA, CSettings::SETTING_MUSICLIBRARY_ARTISTSFOLDER);
 219       }
 220       return;
 221     }
 222   }
 223   else if (!m_destinationChecked)
 224   {
 225     // ELIBEXPORT_SINGLEFILE or LIBEXPORT_SEPARATEFILES
 226     // Check that destination folder exists
 227     if (!XFILE::CDirectory::Exists(m_settings.m_strPath))
 228     {
 229       HELPERS::ShowOKDialogText(CVariant{ 38300 }, CVariant{ 38318 });
 230       return;
 231     }
 232   }
 233   m_confirmed = true;
 234   Save();
 235   Close();
 236 }
 237
 238 bool CGUIDialogLibExportSettings::Save()
 239 {
 240   CLog::Log(LOGINFO, "CGUIDialogMusicExportSettings: Save() called");
 241   const std::shared_ptr<CSettings> settings = CServiceBroker::GetSettingsComponent()->GetSettings();
 242   settings->SetInt(CSettings::SETTING_MUSICLIBRARY_EXPORT_FILETYPE, m_settings.GetExportType());
 243   settings->SetString(CSettings::SETTING_MUSICLIBRARY_EXPORT_FOLDER, m_settings.m_strPath);
 244   settings->SetInt(CSettings::SETTING_MUSICLIBRARY_EXPORT_ITEMS, m_settings.GetItemsToExport());
 245   settings->SetBool(CSettings::SETTING_MUSICLIBRARY_EXPORT_UNSCRAPED, m_settings.m_unscraped);
 246   settings->SetBool(CSettings::SETTING_MUSICLIBRARY_EXPORT_OVERWRITE, m_settings.m_overwrite);
 247   settings->SetBool(CSettings::SETTING_MUSICLIBRARY_EXPORT_ARTWORK, m_settings.m_artwork);
 248   settings->SetBool(CSettings::SETTING_MUSICLIBRARY_EXPORT_SKIPNFO, m_settings.m_skipnfo);
 249   settings->Save();
 250
 251   return true;
 252 }
 253
 254 void CGUIDialogLibExportSettings::SetupView()
 255 {
 256   CGUIDialogSettingsManualBase::SetupView();
 257   SetHeading(38300);
 258
 259   SET_CONTROL_HIDDEN(CONTROL_SETTINGS_CUSTOM_BUTTON);
 260   SET_CONTROL_LABEL(CONTROL_SETTINGS_OKAY_BUTTON, 38319);
 261   SET_CONTROL_LABEL(CONTROL_SETTINGS_CANCEL_BUTTON, 222);
 262
 263   UpdateButtons();
 264   UpdateToggles();
 265   UpdateDescription();
 266 }
 267
 268 void CGUIDialogLibExportSettings::UpdateButtons()
 269 {
 270   // Enable Export button when destination folder has a path (but may not exist)
 271   bool enableExport(true);
 272   if (m_settings.IsSingleFile() ||
 273       m_settings.IsSeparateFiles())
 274     enableExport = !m_settings.m_strPath.empty();
 275
 276   CONTROL_ENABLE_ON_CONDITION(CONTROL_SETTINGS_OKAY_BUTTON, enableExport);
 277   if (!enableExport)
 278     SetFocus(CSettings::SETTING_MUSICLIBRARY_EXPORT_FOLDER);
 279 }
 280
 281 void CGUIDialogLibExportSettings::UpdateToggles()
 282 {
 283   if (m_settings.IsSeparateFiles())
 284     ToggleState(CSettings::SETTING_MUSICLIBRARY_EXPORT_UNSCRAPED, !m_settings.m_skipnfo);
 285
 286   if (!m_settings.IsItemExported(ELIBEXPORT_ALBUMS) && m_settings.m_skipnfo && !m_settings.m_artwork)
 287   {
 288     //"Output information to NFO files (currently exporting artist folders only)"
 289     SetLabel(CSettings::SETTING_MUSICLIBRARY_EXPORT_SKIPNFO, g_localizeStrings.Get(38310));
 290     ToggleState(CSettings::SETTING_MUSICLIBRARY_EXPORT_OVERWRITE, false);
 291   }
 292   else
 293   {
 294     //"Output information to NFO files"
 295     SetLabel(CSettings::SETTING_MUSICLIBRARY_EXPORT_SKIPNFO, g_localizeStrings.Get(38309));
 296     ToggleState(CSettings::SETTING_MUSICLIBRARY_EXPORT_OVERWRITE, true);
 297   }
 298 }
 299
 300 void CGUIDialogLibExportSettings::UpdateDescription()
 301 {
 302   if (m_settings.IsToLibFolders())
 303   {
 304     // Destination button is description of what to library means
 305     SetLabel(CSettings::SETTING_MUSICLIBRARY_EXPORT_FOLDER, "");
 306     if (m_settings.IsItemExported(ELIBEXPORT_ALBUMS))
 307       if (m_settings.IsArtists())
 308         //"Artists exported to Artist Information Folder and albums to music folders"
 309         SetLabel2(CSettings::SETTING_MUSICLIBRARY_EXPORT_FOLDER, g_localizeStrings.Get(38322));
 310       else
 311         //"Albums exported to music folders"
 312         SetLabel2(CSettings::SETTING_MUSICLIBRARY_EXPORT_FOLDER, g_localizeStrings.Get(38323));
 313     else
 314       // "Artists exported to Artist Information Folder"
 315       SetLabel2(CSettings::SETTING_MUSICLIBRARY_EXPORT_FOLDER, g_localizeStrings.Get(38324));
 316   }
 317   else if (m_settings.IsArtistFoldersOnly())
 318   {
 319     // Destination button is description of what artist folders means
 320     SetLabel(CSettings::SETTING_MUSICLIBRARY_EXPORT_FOLDER, "");
 321     //"Artists folders created in Artist Information Folder"
 322     SetLabel2(CSettings::SETTING_MUSICLIBRARY_EXPORT_FOLDER, g_localizeStrings.Get(38325));
 323   }
 324   else
 325   {
 326     SetLabel2(CSettings::SETTING_MUSICLIBRARY_EXPORT_FOLDER, m_settings.m_strPath);
 327     SetLabel(CSettings::SETTING_MUSICLIBRARY_EXPORT_FOLDER, g_localizeStrings.Get(38305));
 328   }
 329 }
 330
 331 void CGUIDialogLibExportSettings::InitializeSettings()
 332 {
 333   CGUIDialogSettingsManualBase::InitializeSettings();
 334
 335   std::shared_ptr<CSettingCategory> category = AddCategory("exportsettings", -1);
 336   if (!category)
 337   {
 338     CLog::Log(LOGERROR, "CGUIDialogLibExportSettings: unable to setup settings");
 339     return;
 340   }
 341
 342   std::shared_ptr<CSettingGroup> groupDetails = AddGroup(category);
 343   if (!groupDetails)
 344   {
 345     CLog::Log(LOGERROR, "CGUIDialogLibExportSettings: unable to setup settings");
 346     return;
 347   }
 348
 349   TranslatableIntegerSettingOptions entries;
 350
 351   entries.emplace_back(38301, ELIBEXPORT_SINGLEFILE);
 352   entries.emplace_back(38303, ELIBEXPORT_TOLIBRARYFOLDER);
 353   entries.emplace_back(38302, ELIBEXPORT_SEPARATEFILES);
 354   entries.emplace_back(38321, ELIBEXPORT_ARTISTFOLDERS);
 355   AddList(groupDetails, CSettings::SETTING_MUSICLIBRARY_EXPORT_FILETYPE, 38304, SettingLevel::Basic, m_settings.GetExportType(), entries, 38304); // "Choose kind of export output"
 356   AddButton(groupDetails, CSettings::SETTING_MUSICLIBRARY_EXPORT_FOLDER, 38305, SettingLevel::Basic);
 357
 358   entries.clear();
 359   if (!m_settings.IsArtistFoldersOnly())
 360     entries.emplace_back(132, ELIBEXPORT_ALBUMS); //ablums
 361   if (m_settings.IsSingleFile())
 362     entries.emplace_back(134, ELIBEXPORT_SONGS); //songs
 363   entries.emplace_back(38043, ELIBEXPORT_ALBUMARTISTS); //album artists
 364   entries.emplace_back(38312, ELIBEXPORT_SONGARTISTS); //song artists
 365   entries.emplace_back(38313, ELIBEXPORT_OTHERARTISTS); //other artists
 366
 367   std::vector<int> items;
 368   if (m_settings.IsArtistFoldersOnly())
 369   {
 370     // Only artists, not albums, at least album artists
 371     items = m_settings.GetLimitedItems(ELIBEXPORT_ALBUMARTISTS + ELIBEXPORT_SONGARTISTS + ELIBEXPORT_OTHERARTISTS);
 372     if (items.size() == 0)
 373       items.emplace_back(ELIBEXPORT_ALBUMARTISTS);
 374   }
 375   else if (!m_settings.IsSingleFile())
 376   {
 377     // No songs unless single file export, at least album artists
 378     items = m_settings.GetLimitedItems(ELIBEXPORT_ALBUMS + ELIBEXPORT_ALBUMARTISTS + ELIBEXPORT_SONGARTISTS + ELIBEXPORT_OTHERARTISTS);
 379     if (items.size() == 0)
 380       items.emplace_back(ELIBEXPORT_ALBUMARTISTS);
 381   }
 382   else
 383    items = m_settings.GetExportItems();
 384
 385   AddList(groupDetails, CSettings::SETTING_MUSICLIBRARY_EXPORT_ITEMS, 38306, SettingLevel::Basic, items, entries, 133, 1);
 386
 387   if (m_settings.IsToLibFolders() || m_settings.IsSeparateFiles())
 388   {
 389     m_settingNFO = AddToggle(groupDetails, CSettings::SETTING_MUSICLIBRARY_EXPORT_SKIPNFO, 38309, SettingLevel::Basic, !m_settings.m_skipnfo);
 390     if (m_settings.IsSeparateFiles())
 391       AddToggle(groupDetails, CSettings::SETTING_MUSICLIBRARY_EXPORT_UNSCRAPED, 38308, SettingLevel::Basic, m_settings.m_unscraped);
 392     m_settingArt = AddToggle(groupDetails, CSettings::SETTING_MUSICLIBRARY_EXPORT_ARTWORK, 38307, SettingLevel::Basic, m_settings.m_artwork);
 393     AddToggle(groupDetails, CSettings::SETTING_MUSICLIBRARY_EXPORT_OVERWRITE, 38311, SettingLevel::Basic, m_settings.m_overwrite);
 394   }
 395 }
 396
 397 void CGUIDialogLibExportSettings::SetLabel2(const std::string &settingid, const std::string &label)
 398 {
 399   BaseSettingControlPtr settingControl = GetSettingControl(settingid);
 400   if (settingControl != nullptr && settingControl->GetControl() != nullptr)
 401     SET_CONTROL_LABEL2(settingControl->GetID(), label);
 402 }
 403
 404 void CGUIDialogLibExportSettings::SetLabel(const std::string &settingid, const std::string &label)
 405 {
 406   BaseSettingControlPtr settingControl = GetSettingControl(settingid);
 407   if (settingControl != nullptr && settingControl->GetControl() != nullptr)
 408     SetControlLabel(settingControl->GetID(), label);
 409 }
 410
 411 void CGUIDialogLibExportSettings::ToggleState(const std::string & settingid, bool enabled)
 412 {
 413   BaseSettingControlPtr settingControl = GetSettingControl(settingid);
 414   if (settingControl != nullptr && settingControl->GetControl() != nullptr)
 415   {
 416     if (enabled)
 417       CONTROL_ENABLE(settingControl->GetID());
 418     else
 419       CONTROL_DISABLE(settingControl->GetID());
 420   }
 421 }
 422
 423 void CGUIDialogLibExportSettings::SetFocus(const std::string &settingid)
 424 {
 425   BaseSettingControlPtr settingControl = GetSettingControl(settingid);
 426   if (settingControl != NULL && settingControl->GetControl() != NULL)
 427     SET_CONTROL_FOCUS(settingControl->GetID(), 0);
 428 }
 429
 430 int CGUIDialogLibExportSettings::GetExportItemsFromSetting(const SettingConstPtr& setting)
 431 {
 432   std::shared_ptr<const CSettingList> settingList = std::static_pointer_cast<const CSettingList>(setting);
 433   if (settingList->GetElementType() != SettingType::Integer)
 434   {
 435     CLog::Log(LOGERROR, "CGUIDialogLibExportSettings::{} - wrong items element type", __FUNCTION__);
 436     return 0;
 437   }
 438   int exportitems = 0;
 439   std::vector<CVariant> list = CSettingUtils::GetList(settingList);
 440   for (const auto &value : list)
 441   {
 442     if (!value.isInteger())
 443     {
 444       CLog::Log(LOGERROR, "CGUIDialogLibExportSettings::{} - wrong items value type", __FUNCTION__);
 445       return 0;
 446     }
 447     exportitems += static_cast<int>(value.asInteger());
 448   }
 449   return exportitems;
 450 }