From c04dcc2e7d834218ef2d4194331e383402495ae1 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 10 Apr 2024 20:07:22 +0200 Subject: Adding upstream version 2:20.4+dfsg. Signed-off-by: Daniel Baumann --- xbmc/guilib/guiinfo/AddonsGUIInfo.cpp | 279 ++++++++ xbmc/guilib/guiinfo/AddonsGUIInfo.h | 37 + xbmc/guilib/guiinfo/CMakeLists.txt | 42 ++ xbmc/guilib/guiinfo/GUIControlsGUIInfo.cpp | 814 ++++++++++++++++++++++ xbmc/guilib/guiinfo/GUIControlsGUIInfo.h | 56 ++ xbmc/guilib/guiinfo/GUIInfo.cpp | 33 + xbmc/guilib/guiinfo/GUIInfo.h | 110 +++ xbmc/guilib/guiinfo/GUIInfoBool.cpp | 41 ++ xbmc/guilib/guiinfo/GUIInfoBool.h | 46 ++ xbmc/guilib/guiinfo/GUIInfoColor.cpp | 69 ++ xbmc/guilib/guiinfo/GUIInfoColor.h | 53 ++ xbmc/guilib/guiinfo/GUIInfoHelper.cpp | 205 ++++++ xbmc/guilib/guiinfo/GUIInfoHelper.h | 43 ++ xbmc/guilib/guiinfo/GUIInfoLabel.cpp | 337 +++++++++ xbmc/guilib/guiinfo/GUIInfoLabel.h | 146 ++++ xbmc/guilib/guiinfo/GUIInfoLabels.h | 985 +++++++++++++++++++++++++++ xbmc/guilib/guiinfo/GUIInfoProvider.h | 49 ++ xbmc/guilib/guiinfo/GUIInfoProviders.cpp | 122 ++++ xbmc/guilib/guiinfo/GUIInfoProviders.h | 157 +++++ xbmc/guilib/guiinfo/GamesGUIInfo.cpp | 87 +++ xbmc/guilib/guiinfo/GamesGUIInfo.h | 37 + xbmc/guilib/guiinfo/IGUIInfoProvider.h | 97 +++ xbmc/guilib/guiinfo/LibraryGUIInfo.cpp | 290 ++++++++ xbmc/guilib/guiinfo/LibraryGUIInfo.h | 59 ++ xbmc/guilib/guiinfo/MusicGUIInfo.cpp | 713 +++++++++++++++++++ xbmc/guilib/guiinfo/MusicGUIInfo.h | 46 ++ xbmc/guilib/guiinfo/PicturesGUIInfo.cpp | 259 +++++++ xbmc/guilib/guiinfo/PicturesGUIInfo.h | 45 ++ xbmc/guilib/guiinfo/PlayerGUIInfo.cpp | 726 ++++++++++++++++++++ xbmc/guilib/guiinfo/PlayerGUIInfo.h | 93 +++ xbmc/guilib/guiinfo/SkinGUIInfo.cpp | 140 ++++ xbmc/guilib/guiinfo/SkinGUIInfo.h | 37 + xbmc/guilib/guiinfo/SystemGUIInfo.cpp | 727 ++++++++++++++++++++ xbmc/guilib/guiinfo/SystemGUIInfo.h | 55 ++ xbmc/guilib/guiinfo/VideoGUIInfo.cpp | 818 ++++++++++++++++++++++ xbmc/guilib/guiinfo/VideoGUIInfo.h | 53 ++ xbmc/guilib/guiinfo/VisualisationGUIInfo.cpp | 115 ++++ xbmc/guilib/guiinfo/VisualisationGUIInfo.h | 37 + xbmc/guilib/guiinfo/WeatherGUIInfo.cpp | 81 +++ xbmc/guilib/guiinfo/WeatherGUIInfo.h | 37 + 40 files changed, 8176 insertions(+) create mode 100644 xbmc/guilib/guiinfo/AddonsGUIInfo.cpp create mode 100644 xbmc/guilib/guiinfo/AddonsGUIInfo.h create mode 100644 xbmc/guilib/guiinfo/CMakeLists.txt create mode 100644 xbmc/guilib/guiinfo/GUIControlsGUIInfo.cpp create mode 100644 xbmc/guilib/guiinfo/GUIControlsGUIInfo.h create mode 100644 xbmc/guilib/guiinfo/GUIInfo.cpp create mode 100644 xbmc/guilib/guiinfo/GUIInfo.h create mode 100644 xbmc/guilib/guiinfo/GUIInfoBool.cpp create mode 100644 xbmc/guilib/guiinfo/GUIInfoBool.h create mode 100644 xbmc/guilib/guiinfo/GUIInfoColor.cpp create mode 100644 xbmc/guilib/guiinfo/GUIInfoColor.h create mode 100644 xbmc/guilib/guiinfo/GUIInfoHelper.cpp create mode 100644 xbmc/guilib/guiinfo/GUIInfoHelper.h create mode 100644 xbmc/guilib/guiinfo/GUIInfoLabel.cpp create mode 100644 xbmc/guilib/guiinfo/GUIInfoLabel.h create mode 100644 xbmc/guilib/guiinfo/GUIInfoLabels.h create mode 100644 xbmc/guilib/guiinfo/GUIInfoProvider.h create mode 100644 xbmc/guilib/guiinfo/GUIInfoProviders.cpp create mode 100644 xbmc/guilib/guiinfo/GUIInfoProviders.h create mode 100644 xbmc/guilib/guiinfo/GamesGUIInfo.cpp create mode 100644 xbmc/guilib/guiinfo/GamesGUIInfo.h create mode 100644 xbmc/guilib/guiinfo/IGUIInfoProvider.h create mode 100644 xbmc/guilib/guiinfo/LibraryGUIInfo.cpp create mode 100644 xbmc/guilib/guiinfo/LibraryGUIInfo.h create mode 100644 xbmc/guilib/guiinfo/MusicGUIInfo.cpp create mode 100644 xbmc/guilib/guiinfo/MusicGUIInfo.h create mode 100644 xbmc/guilib/guiinfo/PicturesGUIInfo.cpp create mode 100644 xbmc/guilib/guiinfo/PicturesGUIInfo.h create mode 100644 xbmc/guilib/guiinfo/PlayerGUIInfo.cpp create mode 100644 xbmc/guilib/guiinfo/PlayerGUIInfo.h create mode 100644 xbmc/guilib/guiinfo/SkinGUIInfo.cpp create mode 100644 xbmc/guilib/guiinfo/SkinGUIInfo.h create mode 100644 xbmc/guilib/guiinfo/SystemGUIInfo.cpp create mode 100644 xbmc/guilib/guiinfo/SystemGUIInfo.h create mode 100644 xbmc/guilib/guiinfo/VideoGUIInfo.cpp create mode 100644 xbmc/guilib/guiinfo/VideoGUIInfo.h create mode 100644 xbmc/guilib/guiinfo/VisualisationGUIInfo.cpp create mode 100644 xbmc/guilib/guiinfo/VisualisationGUIInfo.h create mode 100644 xbmc/guilib/guiinfo/WeatherGUIInfo.cpp create mode 100644 xbmc/guilib/guiinfo/WeatherGUIInfo.h (limited to 'xbmc/guilib/guiinfo') diff --git a/xbmc/guilib/guiinfo/AddonsGUIInfo.cpp b/xbmc/guilib/guiinfo/AddonsGUIInfo.cpp new file mode 100644 index 0000000..6630fa1 --- /dev/null +++ b/xbmc/guilib/guiinfo/AddonsGUIInfo.cpp @@ -0,0 +1,279 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "guilib/guiinfo/AddonsGUIInfo.h" + +#include "FileItem.h" +#include "ServiceBroker.h" +#include "addons/Addon.h" +#include "addons/AddonManager.h" +#include "addons/addoninfo/AddonInfo.h" +#include "guilib/LocalizeStrings.h" +#include "guilib/guiinfo/GUIInfo.h" +#include "guilib/guiinfo/GUIInfoLabels.h" +#include "utils/StringUtils.h" + +using namespace KODI::GUILIB::GUIINFO; + +bool CAddonsGUIInfo::InitCurrentItem(CFileItem *item) +{ + return false; +} + +bool CAddonsGUIInfo::GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const +{ + const std::shared_ptr addonInfo = item->GetAddonInfo(); + if (addonInfo) + { + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // LISTITEM_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case LISTITEM_ADDON_NAME: + value = addonInfo->Name(); + return true; + case LISTITEM_ADDON_VERSION: + value = addonInfo->Version().asString(); + return true; + case LISTITEM_ADDON_CREATOR: + value = addonInfo->Author(); + return true; + case LISTITEM_ADDON_SUMMARY: + value = addonInfo->Summary(); + return true; + case LISTITEM_ADDON_DESCRIPTION: + value = addonInfo->Description(); + return true; + case LISTITEM_ADDON_DISCLAIMER: + value = addonInfo->Disclaimer(); + return true; + case LISTITEM_ADDON_NEWS: + value = addonInfo->ChangeLog(); + return true; + case LISTITEM_ADDON_BROKEN: + { + // Fallback for old GUI info + if (addonInfo->LifecycleState() == ADDON::AddonLifecycleState::BROKEN) + value = addonInfo->LifecycleStateDescription(); + else + value = ""; + return true; + } + case LISTITEM_ADDON_LIFECYCLE_TYPE: + { + const ADDON::AddonLifecycleState state = addonInfo->LifecycleState(); + switch (state) + { + case ADDON::AddonLifecycleState::BROKEN: + value = g_localizeStrings.Get(24171); // "Broken" + break; + case ADDON::AddonLifecycleState::DEPRECATED: + value = g_localizeStrings.Get(24170); // "Deprecated"; + break; + case ADDON::AddonLifecycleState::NORMAL: + default: + value = g_localizeStrings.Get(24169); // "Normal"; + break; + } + return true; + } + case LISTITEM_ADDON_LIFECYCLE_DESC: + value = addonInfo->LifecycleStateDescription(); + return true; + case LISTITEM_ADDON_TYPE: + value = ADDON::CAddonInfo::TranslateType(addonInfo->Type(), true); + return true; + case LISTITEM_ADDON_INSTALL_DATE: + value = addonInfo->InstallDate().GetAsLocalizedDateTime(); + return true; + case LISTITEM_ADDON_LAST_UPDATED: + if (addonInfo->LastUpdated().IsValid()) + { + value = addonInfo->LastUpdated().GetAsLocalizedDateTime(); + return true; + } + break; + case LISTITEM_ADDON_LAST_USED: + if (addonInfo->LastUsed().IsValid()) + { + value = addonInfo->LastUsed().GetAsLocalizedDateTime(); + return true; + } + break; + case LISTITEM_ADDON_ORIGIN: + { + if (item->GetAddonInfo()->Origin() == ADDON::ORIGIN_SYSTEM) + { + value = g_localizeStrings.Get(24992); + return true; + } + if (!item->GetAddonInfo()->OriginName().empty()) + { + value = item->GetAddonInfo()->OriginName(); + return true; + } + else if (!item->GetAddonInfo()->Origin().empty()) + { + value = item->GetAddonInfo()->Origin(); + return true; + } + value = g_localizeStrings.Get(25014); + return true; + } + case LISTITEM_ADDON_SIZE: + { + uint64_t packageSize = item->GetAddonInfo()->PackageSize(); + if (packageSize > 0) + { + value = StringUtils::FormatFileSize(packageSize); + return true; + } + break; + } + } + } + + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // ADDON_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case ADDON_SETTING_STRING: + { + ADDON::AddonPtr addon; + if (!CServiceBroker::GetAddonMgr().GetAddon(info.GetData3(), addon, + ADDON::OnlyEnabled::CHOICE_YES)) + { + return false; + } + value = addon->GetSetting(info.GetData5()); + return true; + } + /////////////////////////////////////////////////////////////////////////////////////////////// + // SYSTEM_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case SYSTEM_ADDON_TITLE: + case SYSTEM_ADDON_ICON: + case SYSTEM_ADDON_VERSION: + { + // This logic does not check/care whether an addon has been disabled/marked as broken, + // it simply retrieves it's name or icon that means if an addon is placed on the home screen it + // will stay there even if it's disabled/marked as broken. This might need to be changed/fixed + // in the future. + ADDON::AddonPtr addon; + if (!info.GetData3().empty()) + { + bool success = CServiceBroker::GetAddonMgr().GetAddon(info.GetData3(), addon, + ADDON::OnlyEnabled::CHOICE_YES); + if (!success || !addon) + break; + + if (info.m_info == SYSTEM_ADDON_TITLE) + { + value = addon->Name(); + return true; + } + if (info.m_info == SYSTEM_ADDON_ICON) + { + value = addon->Icon(); + return true; + } + if (info.m_info == SYSTEM_ADDON_VERSION) + { + value = addon->Version().asString(); + return true; + } + } + break; + } + } + + return false; +} + +bool CAddonsGUIInfo::GetInt(int& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // ADDON_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case ADDON_SETTING_INT: + { + ADDON::AddonPtr addon; + if (!CServiceBroker::GetAddonMgr().GetAddon(info.GetData3(), addon, + ADDON::OnlyEnabled::CHOICE_YES)) + { + return false; + } + return addon->GetSettingInt(info.GetData5(), value); + } + } + return false; +} + +bool CAddonsGUIInfo::GetBool(bool& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // ADDON_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case ADDON_SETTING_BOOL: + { + ADDON::AddonPtr addon; + if (!CServiceBroker::GetAddonMgr().GetAddon(info.GetData3(), addon, + ADDON::OnlyEnabled::CHOICE_YES)) + { + return false; + } + return addon->GetSettingBool(info.GetData5(), value); + } + /////////////////////////////////////////////////////////////////////////////////////////////// + // SYSTEM_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case SYSTEM_HAS_ADDON: + { + ADDON::AddonPtr addon; + value = CServiceBroker::GetAddonMgr().IsAddonInstalled(info.GetData3()); + return true; + } + case SYSTEM_ADDON_IS_ENABLED: + { + value = false; + ADDON::AddonPtr addon; + if (CServiceBroker::GetAddonMgr().GetAddon(info.GetData3(), addon, + ADDON::OnlyEnabled::CHOICE_YES)) + value = !CServiceBroker::GetAddonMgr().IsAddonDisabled(info.GetData3()); + return true; + } + case LISTITEM_ISAUTOUPDATEABLE: + { + value = true; + const CFileItem* item = static_cast(gitem); + if (item->GetAddonInfo()) + value = CServiceBroker::GetAddonMgr().IsAutoUpdateable(item->GetAddonInfo()->ID()) || + !CServiceBroker::GetAddonMgr().IsAddonInstalled(item->GetAddonInfo()->ID(), + item->GetAddonInfo()->Origin()); + + //! @Todo: store origin of not-autoupdateable installed addons in table 'update_rules' + // of the addon database. this is needed to pin ambiguous addon-id's that are + // available from multiple origins accordingly. + // + // after this is done the above call should be changed to + // + // value = CServiceBroker::GetAddonMgr().IsAutoUpdateable(item->GetAddonInfo()->ID(), + // item->GetAddonInfo()->Origin()); + + return true; + } + } + + return false; +} diff --git a/xbmc/guilib/guiinfo/AddonsGUIInfo.h b/xbmc/guilib/guiinfo/AddonsGUIInfo.h new file mode 100644 index 0000000..e06ef51 --- /dev/null +++ b/xbmc/guilib/guiinfo/AddonsGUIInfo.h @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "guilib/guiinfo/GUIInfoProvider.h" + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +class CGUIInfo; + +class CAddonsGUIInfo : public CGUIInfoProvider +{ +public: + CAddonsGUIInfo() = default; + ~CAddonsGUIInfo() override = default; + + // KODI::GUILIB::GUIINFO::IGUIInfoProvider implementation + bool InitCurrentItem(CFileItem *item) override; + bool GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const override; + bool GetInt(int& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; + bool GetBool(bool& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; +}; + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI diff --git a/xbmc/guilib/guiinfo/CMakeLists.txt b/xbmc/guilib/guiinfo/CMakeLists.txt new file mode 100644 index 0000000..9203511 --- /dev/null +++ b/xbmc/guilib/guiinfo/CMakeLists.txt @@ -0,0 +1,42 @@ +set(SOURCES GUIInfo.cpp + GUIInfoHelper.cpp + GUIInfoProviders.cpp + GUIInfoLabel.cpp + GUIInfoBool.cpp + GUIInfoColor.cpp + AddonsGUIInfo.cpp + GamesGUIInfo.cpp + GUIControlsGUIInfo.cpp + LibraryGUIInfo.cpp + MusicGUIInfo.cpp + PicturesGUIInfo.cpp + PlayerGUIInfo.cpp + SkinGUIInfo.cpp + SystemGUIInfo.cpp + VideoGUIInfo.cpp + VisualisationGUIInfo.cpp + WeatherGUIInfo.cpp) + +set(HEADERS GUIInfo.h + GUIInfoHelper.h + GUIInfoLabels.h + GUIInfoProvider.h + GUIInfoProviders.h + GUIInfoLabel.h + GUIInfoBool.h + GUIInfoColor.h + IGUIInfoProvider.h + AddonsGUIInfo.h + GamesGUIInfo.h + GUIControlsGUIInfo.h + LibraryGUIInfo.h + MusicGUIInfo.h + PicturesGUIInfo.h + PlayerGUIInfo.h + SkinGUIInfo.h + SystemGUIInfo.h + VideoGUIInfo.h + VisualisationGUIInfo.h + WeatherGUIInfo.h) + +core_add_library(guilib_guiinfo) diff --git a/xbmc/guilib/guiinfo/GUIControlsGUIInfo.cpp b/xbmc/guilib/guiinfo/GUIControlsGUIInfo.cpp new file mode 100644 index 0000000..a5ee133 --- /dev/null +++ b/xbmc/guilib/guiinfo/GUIControlsGUIInfo.cpp @@ -0,0 +1,814 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "guilib/guiinfo/GUIControlsGUIInfo.h" + +#include "FileItem.h" +#include "ServiceBroker.h" +#include "URL.h" +#include "dialogs/GUIDialogKeyboardGeneric.h" +#include "dialogs/GUIDialogNumeric.h" +#include "dialogs/GUIDialogProgress.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIControlGroupList.h" +#include "guilib/GUITextBox.h" +#include "guilib/GUIWindowManager.h" +#include "guilib/IGUIContainer.h" +#include "guilib/LocalizeStrings.h" +#include "guilib/guiinfo/GUIInfo.h" +#include "guilib/guiinfo/GUIInfoHelper.h" +#include "guilib/guiinfo/GUIInfoLabels.h" +#include "music/dialogs/GUIDialogMusicInfo.h" +#include "music/dialogs/GUIDialogSongInfo.h" +#include "music/tags/MusicInfoTag.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" +#include "video/VideoInfoTag.h" +#include "video/dialogs/GUIDialogVideoInfo.h" +#include "view/GUIViewState.h" +#include "windows/GUIMediaWindow.h" + +using namespace KODI::GUILIB; +using namespace KODI::GUILIB::GUIINFO; + +void CGUIControlsGUIInfo::SetContainerMoving(int id, bool next, bool scrolling) +{ + // magnitude 2 indicates a scroll, sign indicates direction + m_containerMoves[id] = (next ? 1 : -1) * (scrolling ? 2 : 1); +} + +void CGUIControlsGUIInfo::ResetContainerMovingCache() +{ + m_containerMoves.clear(); +} + +bool CGUIControlsGUIInfo::InitCurrentItem(CFileItem *item) +{ + return false; +} + +bool CGUIControlsGUIInfo::GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const +{ + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // CONTAINER_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case CONTAINER_FOLDERPATH: + case CONTAINER_FOLDERNAME: + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + if (info.m_info == CONTAINER_FOLDERNAME) + value = window->CurrentDirectory().GetLabel(); + else + value = CURL(window->CurrentDirectory().GetPath()).GetWithoutUserDetails(); + return true; + } + break; + } + case CONTAINER_PLUGINNAME: + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + const CURL url(window->CurrentDirectory().GetPath()); + if (url.IsProtocol("plugin")) + { + value = URIUtils::GetFileName(url.GetHostName()); + return true; + } + } + break; + } + case CONTAINER_VIEWCOUNT: + case CONTAINER_VIEWMODE: + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + const CGUIControl *control = window->GetControl(window->GetViewContainerID()); + if (control && control->IsContainer()) + { + if (info.m_info == CONTAINER_VIEWMODE) + { + value = static_cast(control)->GetLabel(); + return true; + } + else if (info.m_info == CONTAINER_VIEWCOUNT) + { + value = std::to_string(window->GetViewCount()); + return true; + } + } + } + break; + } + case CONTAINER_SORT_METHOD: + case CONTAINER_SORT_ORDER: + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + const CGUIViewState *viewState = window->GetViewState(); + if (viewState) + { + if (info.m_info == CONTAINER_SORT_METHOD) + { + value = g_localizeStrings.Get(viewState->GetSortMethodLabel()); + return true; + } + else if (info.m_info == CONTAINER_SORT_ORDER) + { + value = g_localizeStrings.Get(viewState->GetSortOrderLabel()); + return true; + } + } + } + break; + } + case CONTAINER_PROPERTY: + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + value = window->CurrentDirectory().GetProperty(info.GetData3()).asString(); + return true; + } + break; + } + case CONTAINER_ART: + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + value = window->CurrentDirectory().GetArt(info.GetData3()); + return true; + } + break; + } + case CONTAINER_CONTENT: + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + value = window->CurrentDirectory().GetContent(); + return true; + } + break; + } + case CONTAINER_SHOWPLOT: + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + value = window->CurrentDirectory().GetProperty("showplot").asString(); + return true; + } + break; + } + case CONTAINER_SHOWTITLE: + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + value = window->CurrentDirectory().GetProperty("showtitle").asString(); + return true; + } + break; + } + case CONTAINER_PLUGINCATEGORY: + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + value = window->CurrentDirectory().GetProperty("plugincategory").asString(); + return true; + } + break; + } + case CONTAINER_TOTALTIME: + case CONTAINER_TOTALWATCHED: + case CONTAINER_TOTALUNWATCHED: + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + int count = 0; + const CFileItemList& items = window->CurrentDirectory(); + for (const auto& item : items) + { + // Iterate through container and count watched, unwatched and total duration. + if (info.m_info == CONTAINER_TOTALWATCHED && item->HasVideoInfoTag() && item->GetVideoInfoTag()->GetPlayCount() > 0) + count += 1; + else if (info.m_info == CONTAINER_TOTALUNWATCHED && item->HasVideoInfoTag() && item->GetVideoInfoTag()->GetPlayCount() == 0) + count += 1; + else if (info.m_info == CONTAINER_TOTALTIME && item->HasMusicInfoTag()) + count += item->GetMusicInfoTag()->GetDuration(); + else if (info.m_info == CONTAINER_TOTALTIME && item->HasVideoInfoTag()) + count += item->GetVideoInfoTag()->m_streamDetails.GetVideoDuration(); + } + if (info.m_info == CONTAINER_TOTALTIME && count > 0) + { + value = StringUtils::SecondsToTimeString(count); + return true; + } + else if (info.m_info == CONTAINER_TOTALWATCHED || info.m_info == CONTAINER_TOTALUNWATCHED) + { + value = std::to_string(count); + return true; + } + } + break; + } + case CONTAINER_NUM_PAGES: + case CONTAINER_CURRENT_PAGE: + case CONTAINER_NUM_ITEMS: + case CONTAINER_POSITION: + case CONTAINER_ROW: + case CONTAINER_COLUMN: + case CONTAINER_CURRENT_ITEM: + case CONTAINER_NUM_ALL_ITEMS: + case CONTAINER_NUM_NONFOLDER_ITEMS: + { + const CGUIControl *control = nullptr; + if (info.GetData1()) + { // container specified + CGUIWindow *window = GUIINFO::GetWindow(contextWindow); + if (window) + control = window->GetControl(info.GetData1()); + } + else + { // no container specified - assume a mediawindow + CGUIMediaWindow *window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + control = window->GetControl(window->GetViewContainerID()); + } + if (control) + { + if (control->IsContainer()) + value = static_cast(control)->GetLabel(info.m_info); + else if (control->GetControlType() == CGUIControl::GUICONTROL_GROUPLIST) + value = static_cast(control)->GetLabel(info.m_info); + else if (control->GetControlType() == CGUIControl::GUICONTROL_TEXTBOX) + value = static_cast(control)->GetLabel(info.m_info); + return true; + } + break; + } + + /////////////////////////////////////////////////////////////////////////////////////////////// + // CONTROL_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case CONTROL_GET_LABEL: + { + CGUIWindow *window = GUIINFO::GetWindow(contextWindow); + if (window) + { + const CGUIControl *control = window->GetControl(info.GetData1()); + if (control) + { + int data2 = info.GetData2(); + if (data2) + value = control->GetDescriptionByIndex(data2); + else + value = control->GetDescription(); + return true; + } + } + break; + } + + /////////////////////////////////////////////////////////////////////////////////////////////// + // WINDOW_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case WINDOW_PROPERTY: + { + CGUIWindow *window = nullptr; + if (info.GetData1()) + { // window specified + window = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(info.GetData1()); + } + else + { // no window specified - assume active + window = GUIINFO::GetWindow(contextWindow); + } + if (window) + { + value = window->GetProperty(info.GetData3()).asString(); + return true; + } + break; + } + + /////////////////////////////////////////////////////////////////////////////////////////////// + // SYSTEM_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case SYSTEM_CURRENT_WINDOW: + value = g_localizeStrings.Get(CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindowOrDialog()); + return true; + case SYSTEM_STARTUP_WINDOW: + value = std::to_string(CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt( + CSettings::SETTING_LOOKANDFEEL_STARTUPWINDOW)); + return true; + case SYSTEM_CURRENT_CONTROL: + case SYSTEM_CURRENT_CONTROL_ID: + { + CGUIWindow *window = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindowOrDialog()); + if (window) + { + CGUIControl *control = window->GetFocusedControl(); + if (control) + { + if (info.m_info == SYSTEM_CURRENT_CONTROL_ID) + value = std::to_string(control->GetID()); + else if (info.m_info == SYSTEM_CURRENT_CONTROL) + value = control->GetDescription(); + return true; + } + } + break; + } + case SYSTEM_PROGRESS_BAR: + { + CGUIDialogProgress *bar = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_DIALOG_PROGRESS); + if (bar && bar->IsDialogRunning()) + value = std::to_string(bar->GetPercentage()); + return true; + } + + /////////////////////////////////////////////////////////////////////////////////////////////// + // FANART_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case FANART_COLOR1: + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + value = window->CurrentDirectory().GetProperty("fanart_color1").asString(); + return true; + } + break; + } + case FANART_COLOR2: + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + value = window->CurrentDirectory().GetProperty("fanart_color2").asString(); + return true; + } + break; + } + case FANART_COLOR3: + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + value = window->CurrentDirectory().GetProperty("fanart_color3").asString(); + return true; + } + break; + } + case FANART_IMAGE: + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + value = window->CurrentDirectory().GetArt("fanart"); + return true; + } + break; + } + } + + return false; +} + +bool CGUIControlsGUIInfo::GetInt(int& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // SYSTEM_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case SYSTEM_PROGRESS_BAR: + { + CGUIDialogProgress *bar = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_DIALOG_PROGRESS); + if (bar && bar->IsDialogRunning()) + value = bar->GetPercentage(); + return true; + } + } + + return false; +} + +bool CGUIControlsGUIInfo::GetBool(bool& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // CONTAINER_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case CONTAINER_HASFILES: + case CONTAINER_HASFOLDERS: + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + const CFileItemList& items = window->CurrentDirectory(); + for (const auto& item : items) + { + if ((!item->m_bIsFolder && info.m_info == CONTAINER_HASFILES) || + (item->m_bIsFolder && !item->IsParentFolder() && info.m_info == CONTAINER_HASFOLDERS)) + { + value = true; + return true; + } + } + } + break; + } + case CONTAINER_STACKED: + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + value = window->CurrentDirectory().GetProperty("isstacked").asBoolean(); + return true; + } + break; + } + case CONTAINER_HAS_THUMB: + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + value = window->CurrentDirectory().HasArt("thumb"); + return true; + } + break; + } + case CONTAINER_CAN_FILTER: + { + CGUIMediaWindow *window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + value = !window->CanFilterAdvanced(); + return true; + } + break; + } + case CONTAINER_CAN_FILTERADVANCED: + { + CGUIMediaWindow *window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + value = window->CanFilterAdvanced(); + return true; + } + break; + } + case CONTAINER_FILTERED: + { + CGUIMediaWindow *window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + value = window->IsFiltered(); + return true; + } + break; + } + case CONTAINER_SORT_METHOD: + { + CGUIMediaWindow *window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + const CGUIViewState *viewState = window->GetViewState(); + if (viewState) + { + value = (static_cast(viewState->GetSortMethod().sortBy) == info.GetData2()); + return true; + } + } + break; + } + case CONTAINER_SORT_DIRECTION: + { + CGUIMediaWindow *window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + const CGUIViewState *viewState = window->GetViewState(); + if (viewState) + { + value = (static_cast(viewState->GetSortOrder()) == info.GetData1()); + return true; + } + } + break; + } + case CONTAINER_CONTENT: + { + std::string content; + CGUIWindow *window = GUIINFO::GetWindow(contextWindow); + if (window) + { + if (window->GetID() == WINDOW_DIALOG_MUSIC_INFO) + content = static_cast(window)->GetContent(); + else if (window->GetID() == WINDOW_DIALOG_SONG_INFO) + content = static_cast(window)->GetContent(); + else if (window->GetID() == WINDOW_DIALOG_VIDEO_INFO) + content = static_cast(window)->CurrentDirectory().GetContent(); + } + if (content.empty()) + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + content = window->CurrentDirectory().GetContent(); + } + value = StringUtils::EqualsNoCase(info.GetData3(), content); + return true; + } + case CONTAINER_ROW: + case CONTAINER_COLUMN: + case CONTAINER_POSITION: + case CONTAINER_HAS_NEXT: + case CONTAINER_HAS_PREVIOUS: + case CONTAINER_SCROLLING: + case CONTAINER_SUBITEM: + case CONTAINER_ISUPDATING: + case CONTAINER_HAS_PARENT_ITEM: + { + if (info.GetData1()) + { + CGUIWindow *window = GUIINFO::GetWindow(contextWindow); + if (window) + { + const CGUIControl *control = window->GetControl(info.GetData1()); + if (control) + { + value = control->GetCondition(info.m_info, info.GetData2()); + return true; + } + } + } + else + { + const CGUIControl *activeContainer = GUIINFO::GetActiveContainer(0, contextWindow); + if (activeContainer) + { + value = activeContainer->GetCondition(info.m_info, info.GetData2()); + return true; + } + } + break; + } + case CONTAINER_HAS_FOCUS: + { // grab our container + CGUIWindow *window = GUIINFO::GetWindow(contextWindow); + if (window) + { + const CGUIControl *control = window->GetControl(info.GetData1()); + if (control && control->IsContainer()) + { + const CFileItemPtr item = std::static_pointer_cast(static_cast(control)->GetListItem(0)); + if (item && item->m_iprogramCount == info.GetData2()) // programcount used to store item id + { + value = true; + return true; + } + } + } + break; + } + case CONTAINER_SCROLL_PREVIOUS: + case CONTAINER_MOVE_PREVIOUS: + case CONTAINER_MOVE_NEXT: + case CONTAINER_SCROLL_NEXT: + { + int containerId = -1; + if (info.GetData1()) + { + containerId = info.GetData1(); + } + else + { + // no parameters, so we assume it's just requested for a media window. It therefore + // can only happen if the list has focus. + CGUIMediaWindow *window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + containerId = window->GetViewContainerID(); + } + if (containerId != -1) + { + const std::map::const_iterator it = m_containerMoves.find(containerId); + if (it != m_containerMoves.end()) + { + if (info.m_info == CONTAINER_SCROLL_PREVIOUS) + value = it->second <= -2; + else if (info.m_info == CONTAINER_MOVE_PREVIOUS) + value = it->second <= -1; + else if (info.m_info == CONTAINER_MOVE_NEXT) + value = it->second >= 1; + else if (info.m_info == CONTAINER_SCROLL_NEXT) + value = it->second >= 2; + return true; + } + } + break; + } + + /////////////////////////////////////////////////////////////////////////////////////////////// + // CONTROL_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case CONTROL_IS_VISIBLE: + { + CGUIWindow *window = GUIINFO::GetWindow(contextWindow); + if (window) + { + // Note: This'll only work for unique id's + const CGUIControl *control = window->GetControl(info.GetData1()); + if (control) + { + value = control->IsVisible(); + return true; + } + } + break; + } + case CONTROL_IS_ENABLED: + { + CGUIWindow *window = GUIINFO::GetWindow(contextWindow); + if (window) + { + // Note: This'll only work for unique id's + const CGUIControl *control = window->GetControl(info.GetData1()); + if (control) + { + value = !control->IsDisabled(); + return true; + } + } + break; + } + case CONTROL_HAS_FOCUS: + { + CGUIWindow *window = GUIINFO::GetWindow(contextWindow); + if (window) + { + value = (window->GetFocusedControlID() == static_cast(info.GetData1())); + return true; + } + break; + } + case CONTROL_GROUP_HAS_FOCUS: + { + CGUIWindow *window = GUIINFO::GetWindow(contextWindow); + if (window) + { + value = window->ControlGroupHasFocus(info.GetData1(), info.GetData2()); + return true; + } + break; + } + + /////////////////////////////////////////////////////////////////////////////////////////////// + // WINDOW_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case WINDOW_IS_MEDIA: + { // note: This doesn't return true for dialogs (content, favourites, login, videoinfo) + CGUIWindowManager& windowMgr = CServiceBroker::GetGUI()->GetWindowManager(); + CGUIWindow *window = windowMgr.GetWindow(windowMgr.GetActiveWindow()); + if (window) + { + value = window->IsMediaWindow(); + return true; + } + break; + } + case WINDOW_IS: + { + if (info.GetData1()) + { + CGUIWindowManager& windowMgr = CServiceBroker::GetGUI()->GetWindowManager(); + CGUIWindow *window = windowMgr.GetWindow(contextWindow); + if (!window) + { + // try topmost dialog + window = windowMgr.GetWindow(windowMgr.GetTopmostModalDialog()); + if (!window) + { + // try active window + window = windowMgr.GetWindow(windowMgr.GetActiveWindow()); + } + } + if (window) + { + value = (window && window->GetID() == static_cast(info.GetData1())); + return true; + } + } + break; + } + case WINDOW_IS_VISIBLE: + { + if (info.GetData1()) + value = CServiceBroker::GetGUI()->GetWindowManager().IsWindowVisible(info.GetData1()); + else + value = CServiceBroker::GetGUI()->GetWindowManager().IsWindowVisible(info.GetData3()); + return true; + } + case WINDOW_IS_ACTIVE: + { + if (info.GetData1()) + value = CServiceBroker::GetGUI()->GetWindowManager().IsWindowActive(info.GetData1()); + else + value = CServiceBroker::GetGUI()->GetWindowManager().IsWindowActive(info.GetData3()); + return true; + } + case WINDOW_IS_DIALOG_TOPMOST: + { + if (info.GetData1()) + value = CServiceBroker::GetGUI()->GetWindowManager().IsDialogTopmost(info.GetData1()); + else + value = CServiceBroker::GetGUI()->GetWindowManager().IsDialogTopmost(info.GetData3()); + return true; + } + case WINDOW_IS_MODAL_DIALOG_TOPMOST: + { + if (info.GetData1()) + value = CServiceBroker::GetGUI()->GetWindowManager().IsModalDialogTopmost(info.GetData1()); + else + value = CServiceBroker::GetGUI()->GetWindowManager().IsModalDialogTopmost(info.GetData3()); + return true; + } + case WINDOW_NEXT: + { + if (info.GetData1()) + { + value = (static_cast(info.GetData1()) == m_nextWindowID); + return true; + } + else + { + CGUIWindow *window = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(m_nextWindowID); + if (window && StringUtils::EqualsNoCase(URIUtils::GetFileName(window->GetProperty("xmlfile").asString()), info.GetData3())) + { + value = true; + return true; + } + } + break; + } + case WINDOW_PREVIOUS: + { + if (info.GetData1()) + { + value = (static_cast(info.GetData1()) == m_prevWindowID); + return true; + } + else + { + CGUIWindow *window = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(m_prevWindowID); + if (window && StringUtils::EqualsNoCase(URIUtils::GetFileName(window->GetProperty("xmlfile").asString()), info.GetData3())) + { + value = true; + return true; + } + } + break; + } + + /////////////////////////////////////////////////////////////////////////////////////////////// + // SYSTEM_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case SYSTEM_HAS_ACTIVE_MODAL_DIALOG: + value = CServiceBroker::GetGUI()->GetWindowManager().HasModalDialog(true); + return true; + case SYSTEM_HAS_VISIBLE_MODAL_DIALOG: + value = CServiceBroker::GetGUI()->GetWindowManager().HasVisibleModalDialog(); + return true; + case SYSTEM_HAS_INPUT_HIDDEN: + { + CGUIDialogNumeric *pNumeric = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_DIALOG_NUMERIC); + CGUIDialogKeyboardGeneric *pKeyboard = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_DIALOG_KEYBOARD); + + if (pNumeric && pNumeric->IsActive()) + value = pNumeric->IsInputHidden(); + else if (pKeyboard && pKeyboard->IsActive()) + value = pKeyboard->IsInputHidden(); + return true; + } + } + + return false; +} diff --git a/xbmc/guilib/guiinfo/GUIControlsGUIInfo.h b/xbmc/guilib/guiinfo/GUIControlsGUIInfo.h new file mode 100644 index 0000000..f6b8b68 --- /dev/null +++ b/xbmc/guilib/guiinfo/GUIControlsGUIInfo.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "guilib/WindowIDs.h" +#include "guilib/guiinfo/GUIInfoProvider.h" + +#include + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +class CGUIInfo; + +class CGUIControlsGUIInfo : public CGUIInfoProvider +{ +public: + ~CGUIControlsGUIInfo() override = default; + + // KODI::GUILIB::GUIINFO::IGUIInfoProvider implementation + bool InitCurrentItem(CFileItem *item) override; + bool GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const override; + bool GetInt(int& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; + bool GetBool(bool& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; + + void SetNextWindow(int windowID) { m_nextWindowID = windowID; } + void SetPreviousWindow(int windowID) { m_prevWindowID = windowID; } + + /*! \brief containers call this to specify that the focus is changing + \param id control id + \param next true if we're moving to the next item, false if previous + \param scrolling true if the container is scrolling, false if the movement requires no scroll + */ + void SetContainerMoving(int id, bool next, bool scrolling); + void ResetContainerMovingCache(); + +private: + int m_nextWindowID = WINDOW_INVALID; + int m_prevWindowID = WINDOW_INVALID; + + std::map m_containerMoves; // direction of list moving +}; + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI diff --git a/xbmc/guilib/guiinfo/GUIInfo.cpp b/xbmc/guilib/guiinfo/GUIInfo.cpp new file mode 100644 index 0000000..5542a78 --- /dev/null +++ b/xbmc/guilib/guiinfo/GUIInfo.cpp @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "GUIInfo.h" + +#include + +using namespace KODI::GUILIB::GUIINFO; + +void CGUIInfo::SetInfoFlag(uint32_t flag) +{ + assert(flag >= (1 << 24)); + m_data1 |= flag; +} + +uint32_t CGUIInfo::GetInfoFlag() const +{ + // we strip out the bottom 24 bits, where we keep data + // and return the flag only + return m_data1 & 0xff000000; +} + +uint32_t CGUIInfo::GetData1() const +{ + // we strip out the top 8 bits, where we keep flags + // and return the unflagged data + return m_data1 & ((1 << 24) -1); +} diff --git a/xbmc/guilib/guiinfo/GUIInfo.h b/xbmc/guilib/guiinfo/GUIInfo.h new file mode 100644 index 0000000..c5bffe8 --- /dev/null +++ b/xbmc/guilib/guiinfo/GUIInfo.h @@ -0,0 +1,110 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include +#include + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +// class to hold multiple integer data +// for storage referenced from a single integer +class CGUIInfo +{ +public: + CGUIInfo(int info, uint32_t data1, int data2, uint32_t flag, const std::string& data3, int data4) + : m_info(info), + m_data1(data1), + m_data2(data2), + m_data3(data3), + m_data4(data4) + { + if (flag) + SetInfoFlag(flag); + } + + explicit CGUIInfo(int info, uint32_t data1 = 0, int data2 = 0, uint32_t flag = 0) + : m_info(info), + m_data1(data1), + m_data2(data2), + m_data4(0) + { + if (flag) + SetInfoFlag(flag); + } + + CGUIInfo(int info, uint32_t data1, int data2, const std::string& data3) + : m_info(info), m_data1(data1), m_data2(data2), m_data3(data3), m_data4(0) + { + } + + CGUIInfo(int info, uint32_t data1, const std::string& data3) + : m_info(info), + m_data1(data1), + m_data2(0), + m_data3(data3), + m_data4(0) + { + } + + CGUIInfo(int info, const std::string& data3) + : m_info(info), + m_data1(0), + m_data2(0), + m_data3(data3), + m_data4(0) + { + } + + CGUIInfo(int info, const std::string& data3, int data2) + : m_info(info), + m_data1(0), + m_data2(data2), + m_data3(data3), + m_data4(0) + { + } + + CGUIInfo(int info, const std::string& data3, const std::string& data5) + : m_info(info), m_data1(0), m_data3(data3), m_data4(0), m_data5(data5) + { + } + + bool operator ==(const CGUIInfo &right) const + { + return (m_info == right.m_info && m_data1 == right.m_data1 && m_data2 == right.m_data2 && + m_data3 == right.m_data3 && m_data4 == right.m_data4 && m_data5 == right.m_data5); + } + + uint32_t GetInfoFlag() const; + uint32_t GetData1() const; + int GetData2() const { return m_data2; } + const std::string& GetData3() const { return m_data3; } + int GetData4() const { return m_data4; } + const std::string& GetData5() const { return m_data5; } + + int m_info; +private: + void SetInfoFlag(uint32_t flag); + + uint32_t m_data1; + int m_data2; + std::string m_data3; + int m_data4; + std::string m_data5; +}; + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI diff --git a/xbmc/guilib/guiinfo/GUIInfoBool.cpp b/xbmc/guilib/guiinfo/GUIInfoBool.cpp new file mode 100644 index 0000000..2f6b4f9 --- /dev/null +++ b/xbmc/guilib/guiinfo/GUIInfoBool.cpp @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "guilib/guiinfo/GUIInfoBool.h" + +#include "GUIInfoManager.h" +#include "ServiceBroker.h" +#include "guilib/GUIComponent.h" + +using namespace KODI::GUILIB::GUIINFO; + +CGUIInfoBool::CGUIInfoBool(bool value) +{ + m_value = value; +} + +CGUIInfoBool::~CGUIInfoBool() = default; + +void CGUIInfoBool::Parse(const std::string &expression, int context) +{ + if (expression == "true") + m_value = true; + else if (expression == "false") + m_value = false; + else + { + m_info = CServiceBroker::GetGUI()->GetInfoManager().Register(expression, context); + Update(context); + } +} + +void CGUIInfoBool::Update(int contextWindow, const CGUIListItem* item /*= nullptr*/) +{ + if (m_info) + m_value = m_info->Get(contextWindow, item); +} diff --git a/xbmc/guilib/guiinfo/GUIInfoBool.h b/xbmc/guilib/guiinfo/GUIInfoBool.h new file mode 100644 index 0000000..1913684 --- /dev/null +++ b/xbmc/guilib/guiinfo/GUIInfoBool.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +/*! +\file GUIInfoBool.h +\brief +*/ + +#include "interfaces/info/InfoBool.h" + +#include + +class CGUIListItem; + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +class CGUIInfoBool +{ +public: + explicit CGUIInfoBool(bool value = false); + ~CGUIInfoBool(); + + operator bool() const { return m_value; } + + void Update(int contextWindow, const CGUIListItem* item = nullptr); + void Parse(const std::string &expression, int context); +private: + INFO::InfoPtr m_info; + bool m_value; +}; + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI diff --git a/xbmc/guilib/guiinfo/GUIInfoColor.cpp b/xbmc/guilib/guiinfo/GUIInfoColor.cpp new file mode 100644 index 0000000..c20326d --- /dev/null +++ b/xbmc/guilib/guiinfo/GUIInfoColor.cpp @@ -0,0 +1,69 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "guilib/guiinfo/GUIInfoColor.h" + +#include "FileItem.h" +#include "GUIInfoManager.h" +#include "ServiceBroker.h" +#include "addons/Skin.h" +#include "guilib/GUIColorManager.h" +#include "guilib/GUIComponent.h" +#include "utils/StringUtils.h" + +using namespace KODI::GUILIB::GUIINFO; + +bool CGUIInfoColor::Update(const CGUIListItem* item /* = nullptr */) +{ + if (!m_info) + return false; // no infolabel + + // Expand the infolabel, and then convert it to a color + std::string infoLabel; + if (item && item->IsFileItem()) + infoLabel = CServiceBroker::GetGUI()->GetInfoManager().GetItemLabel( + static_cast(item), 0, m_info); + else + infoLabel = CServiceBroker::GetGUI()->GetInfoManager().GetLabel(m_info, INFO::DEFAULT_CONTEXT); + + UTILS::COLOR::Color color = + !infoLabel.empty() ? CServiceBroker::GetGUI()->GetColorManager().GetColor(infoLabel) : 0; + if (m_color != color) + { + m_color = color; + return true; + } + else + return false; +} + +void CGUIInfoColor::Parse(const std::string &label, int context) +{ + if (label.empty()) + return; + + CGUIInfoManager& infoMgr = CServiceBroker::GetGUI()->GetInfoManager(); + + // Check for the standard $INFO[] block layout, and strip it if present + std::string label2 = label; + if (StringUtils::StartsWithNoCase(label, "$var[")) + { + label2 = label.substr(5, label.length() - 6); + m_info = infoMgr.TranslateSkinVariableString(label2, context); + if (!m_info) + m_info = infoMgr.RegisterSkinVariableString(g_SkinInfo->CreateSkinVariable(label2, context)); + return; + } + + if (StringUtils::StartsWithNoCase(label, "$info[")) + label2 = label.substr(6, label.length()-7); + + m_info = infoMgr.TranslateString(label2); + if (!m_info) + m_color = CServiceBroker::GetGUI()->GetColorManager().GetColor(label); +} diff --git a/xbmc/guilib/guiinfo/GUIInfoColor.h b/xbmc/guilib/guiinfo/GUIInfoColor.h new file mode 100644 index 0000000..a711047 --- /dev/null +++ b/xbmc/guilib/guiinfo/GUIInfoColor.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +/*! +\file GUIInfoColor.h +\brief +*/ + +#include "guilib/GUIListItem.h" +#include "utils/ColorUtils.h" + +#include + +class CGUIListItem; + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +class CGUIInfoColor +{ +public: + constexpr CGUIInfoColor(UTILS::COLOR::Color color = 0) : m_color(color) {} + + constexpr operator UTILS::COLOR::Color() const { return m_color; } + + bool Update(const CGUIListItem* item = nullptr); + void Parse(const std::string &label, int context); + + /*! + * @brief Check if the infocolor has an info condition bound to its color definition (or otherwise, if it's constant color) + * @return true if the color depends on an info condition, false otherwise + */ + bool HasInfo() const { return m_info != 0; } + +private: + int m_info = 0; + UTILS::COLOR::Color m_color; +}; + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI diff --git a/xbmc/guilib/guiinfo/GUIInfoHelper.cpp b/xbmc/guilib/guiinfo/GUIInfoHelper.cpp new file mode 100644 index 0000000..f025b5e --- /dev/null +++ b/xbmc/guilib/guiinfo/GUIInfoHelper.cpp @@ -0,0 +1,205 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "GUIInfoHelper.h" + +#include "FileItem.h" +#include "PlayListPlayer.h" +#include "ServiceBroker.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindow.h" +#include "guilib/GUIWindowManager.h" +#include "guilib/IGUIContainer.h" +#include "guilib/LocalizeStrings.h" +#include "guilib/guiinfo/GUIInfoLabels.h" +#include "playlists/PlayList.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" +#include "windows/GUIMediaWindow.h" + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +// conditions for window retrieval +static const int WINDOW_CONDITION_HAS_LIST_ITEMS = 1; +static const int WINDOW_CONDITION_IS_MEDIA_WINDOW = 2; + +std::string GetPlaylistLabel(int item, PLAYLIST::Id playlistId /* = TYPE_NONE */) +{ + PLAYLIST::CPlayListPlayer& player = CServiceBroker::GetPlaylistPlayer(); + + if (playlistId == PLAYLIST::TYPE_NONE) + playlistId = player.GetCurrentPlaylist(); + + switch (item) + { + case PLAYLIST_LENGTH: + { + return std::to_string(player.GetPlaylist(playlistId).size()); + } + case PLAYLIST_POSITION: + { + int currentSong = player.GetCurrentSong(); + if (currentSong > -1) + return std::to_string(currentSong + 1); + break; + } + case PLAYLIST_RANDOM: + { + if (player.IsShuffled(playlistId)) + return g_localizeStrings.Get(16041); // 16041: On + else + return g_localizeStrings.Get(591); // 591: Off + } + case PLAYLIST_REPEAT: + { + PLAYLIST::RepeatState state = player.GetRepeat(playlistId); + if (state == PLAYLIST::RepeatState::ONE) + return g_localizeStrings.Get(592); // 592: One + else if (state == PLAYLIST::RepeatState::ALL) + return g_localizeStrings.Get(593); // 593: All + else + return g_localizeStrings.Get(594); // 594: Off + } + } + return std::string(); +} + +namespace +{ + +bool CheckWindowCondition(CGUIWindow *window, int condition) +{ + // check if it satisfies our condition + if (!window) + return false; + if ((condition & WINDOW_CONDITION_HAS_LIST_ITEMS) && !window->HasListItems()) + return false; + if ((condition & WINDOW_CONDITION_IS_MEDIA_WINDOW) && !window->IsMediaWindow()) + return false; + return true; +} + +CGUIWindow* GetWindowWithCondition(int contextWindow, int condition) +{ + const CGUIWindowManager& windowMgr = CServiceBroker::GetGUI()->GetWindowManager(); + + CGUIWindow *window = windowMgr.GetWindow(contextWindow); + if (CheckWindowCondition(window, condition)) + return window; + + // try topmost dialog + window = windowMgr.GetWindow(windowMgr.GetTopmostModalDialog()); + if (CheckWindowCondition(window, condition)) + return window; + + // try active window + window = windowMgr.GetWindow(windowMgr.GetActiveWindow()); + if (CheckWindowCondition(window, condition)) + return window; + + return nullptr; +} + +} // unnamed namespace + +CGUIWindow* GetWindow(int contextWindow) +{ + return GetWindowWithCondition(contextWindow, 0); +} + +CFileItemPtr GetCurrentListItemFromWindow(int contextWindow) +{ + CGUIWindow* window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_HAS_LIST_ITEMS); + if (window) + return window->GetCurrentListItem(); + + return CFileItemPtr(); +} + +CGUIMediaWindow* GetMediaWindow(int contextWindow) +{ + CGUIWindow* window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW); + if (window) + return static_cast(window); + + return nullptr; +} + +CGUIControl* GetActiveContainer(int containerId, int contextWindow) +{ + CGUIWindow *window = GetWindow(contextWindow); + if (!window) + return nullptr; + + CGUIControl *control = nullptr; + if (!containerId) // No container specified, so we lookup the current view container + { + if (window->IsMediaWindow()) + containerId = static_cast(window)->GetViewContainerID(); + else + control = window->GetFocusedControl(); + } + + if (!control) + control = window->GetControl(containerId); + + if (control && control->IsContainer()) + return control; + + return nullptr; +} + +CGUIListItemPtr GetCurrentListItem(int contextWindow, int containerId /* = 0 */, int itemOffset /* = 0 */, unsigned int itemFlags /* = 0 */) +{ + CGUIListItemPtr item; + + if (containerId == 0 && + itemOffset == 0 && + !(itemFlags & INFOFLAG_LISTITEM_CONTAINER) && + !(itemFlags & INFOFLAG_LISTITEM_ABSOLUTE) && + !(itemFlags & INFOFLAG_LISTITEM_POSITION)) + item = GetCurrentListItemFromWindow(contextWindow); + + if (!item) + { + CGUIControl* activeContainer = GetActiveContainer(containerId, contextWindow); + if (activeContainer) + item = static_cast(activeContainer)->GetListItem(itemOffset, itemFlags); + } + + return item; +} + +std::string GetFileInfoLabelValueFromPath(int info, const std::string& filenameAndPath) +{ + std::string value = filenameAndPath; + + if (info == PLAYER_PATH) + { + // do this twice since we want the path outside the archive if this is to be of use. + if (URIUtils::IsInArchive(value)) + value = URIUtils::GetParentPath(value); + + value = URIUtils::GetParentPath(value); + } + else if (info == PLAYER_FILENAME) + { + value = URIUtils::GetFileName(value); + } + + return value; +} + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI diff --git a/xbmc/guilib/guiinfo/GUIInfoHelper.h b/xbmc/guilib/guiinfo/GUIInfoHelper.h new file mode 100644 index 0000000..ce5191e --- /dev/null +++ b/xbmc/guilib/guiinfo/GUIInfoHelper.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "playlists/PlayListTypes.h" + +#include +#include + +class CFileItem; + +class CGUIListItem; +typedef std::shared_ptr CGUIListItemPtr; + +class CGUIControl; +class CGUIMediaWindow; +class CGUIWindow; + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +std::string GetPlaylistLabel(int item, PLAYLIST::Id playlistid = PLAYLIST::TYPE_NONE); + +CGUIWindow* GetWindow(int contextWindow); +CGUIControl* GetActiveContainer(int containerId, int contextWindow); +CGUIMediaWindow* GetMediaWindow(int contextWindow); +CGUIListItemPtr GetCurrentListItem(int contextWindow, int containerId = 0, int itemOffset = 0, unsigned int itemFlags = 0); + +std::string GetFileInfoLabelValueFromPath(int info, const std::string& filenameAndPath); + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI diff --git a/xbmc/guilib/guiinfo/GUIInfoLabel.cpp b/xbmc/guilib/guiinfo/GUIInfoLabel.cpp new file mode 100644 index 0000000..4a6ce13 --- /dev/null +++ b/xbmc/guilib/guiinfo/GUIInfoLabel.cpp @@ -0,0 +1,337 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "guilib/guiinfo/GUIInfoLabel.h" + +#include "FileItem.h" +#include "GUIInfoManager.h" +#include "addons/Skin.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIListItem.h" +#include "guilib/LocalizeStrings.h" +#include "utils/StringUtils.h" +#include "utils/log.h" + +using namespace KODI::GUILIB::GUIINFO; + +CGUIInfoLabel::CGUIInfoLabel(const std::string &label, const std::string &fallback /*= ""*/, int context /*= 0*/) +{ + SetLabel(label, fallback, context); +} + +int CGUIInfoLabel::GetIntValue(int contextWindow) const +{ + const std::string label = GetLabel(contextWindow); + if (!label.empty()) + return strtol(label.c_str(), NULL, 10); + + return 0; +} + +void CGUIInfoLabel::SetLabel(const std::string &label, const std::string &fallback, int context /*= 0*/) +{ + m_fallback = fallback; + Parse(label, context); +} + +const std::string &CGUIInfoLabel::GetLabel(int contextWindow, bool preferImage, std::string *fallback /*= NULL*/) const +{ + bool needsUpdate = m_dirty; + if (!m_info.empty()) + { + CGUIInfoManager& infoMgr = CServiceBroker::GetGUI()->GetInfoManager(); + for (const auto &portion : m_info) + { + if (portion.m_info) + { + std::string infoLabel; + if (preferImage) + infoLabel = infoMgr.GetImage(portion.m_info, contextWindow, fallback); + if (infoLabel.empty()) + infoLabel = infoMgr.GetLabel(portion.m_info, contextWindow, fallback); + needsUpdate |= portion.NeedsUpdate(infoLabel); + } + } + } + else + needsUpdate = !m_label.empty(); + + return CacheLabel(needsUpdate); +} + +const std::string &CGUIInfoLabel::GetItemLabel(const CGUIListItem *item, bool preferImages, std::string *fallback /*= NULL*/) const +{ + bool needsUpdate = m_dirty; + if (item->IsFileItem() && !m_info.empty()) + { + CGUIInfoManager& infoMgr = CServiceBroker::GetGUI()->GetInfoManager(); + for (const auto &portion : m_info) + { + if (portion.m_info) + { + std::string infoLabel; + if (preferImages) + infoLabel = infoMgr.GetItemImage(item, 0, portion.m_info, fallback); + else + infoLabel = infoMgr.GetItemLabel(static_cast(item), 0, portion.m_info, fallback); + needsUpdate |= portion.NeedsUpdate(infoLabel); + } + } + } + else + needsUpdate = !m_label.empty(); + + return CacheLabel(needsUpdate); +} + +const std::string &CGUIInfoLabel::CacheLabel(bool rebuild) const +{ + if (rebuild) + { + m_label.clear(); + for (const auto &portion : m_info) + m_label += portion.Get(); + m_dirty = false; + } + if (m_label.empty()) // empty label, use the fallback + return m_fallback; + return m_label; +} + +bool CGUIInfoLabel::IsEmpty() const +{ + return m_info.empty(); +} + +bool CGUIInfoLabel::IsConstant() const +{ + return m_info.empty() || (m_info.size() == 1 && m_info[0].m_info == 0); +} + +bool CGUIInfoLabel::ReplaceSpecialKeywordReferences(const std::string &strInput, const std::string &strKeyword, const StringReplacerFunc &func, std::string &strOutput) +{ + // replace all $strKeyword[value] with resolved strings + const std::string dollarStrPrefix = "$" + strKeyword + "["; + + size_t index = 0; + size_t startPos; + + while ((startPos = strInput.find(dollarStrPrefix, index)) != std::string::npos) + { + size_t valuePos = startPos + dollarStrPrefix.size(); + size_t endPos = StringUtils::FindEndBracket(strInput, '[', ']', valuePos); + if (endPos != std::string::npos) + { + if (index == 0) // first occurrence? + strOutput.clear(); + strOutput.append(strInput, index, startPos - index); // append part from the left side + strOutput += func(strInput.substr(valuePos, endPos - valuePos)); // resolve and append value part + index = endPos + 1; + } + else + { + // if closing bracket is missing, report error and leave incomplete reference in + CLog::Log(LOGERROR, "Error parsing value - missing ']' in \"{}\"", strInput); + break; + } + } + + if (index) // if we replaced anything + { + strOutput.append(strInput, index, std::string::npos); // append leftover from the right side + return true; + } + + return false; +} + +bool CGUIInfoLabel::ReplaceSpecialKeywordReferences(std::string &work, const std::string &strKeyword, const StringReplacerFunc &func) +{ + std::string output; + if (ReplaceSpecialKeywordReferences(work, strKeyword, func, output)) + { + work = std::move(output); + return true; + } + return false; +} + +std::string LocalizeReplacer(const std::string &str) +{ + std::string replace = g_localizeStringsTemp.Get(atoi(str.c_str())); + if (replace.empty()) + replace = g_localizeStrings.Get(atoi(str.c_str())); + return replace; +} + +std::string AddonReplacer(const std::string &str) +{ + // assumes "addon.id #####" + size_t length = str.find(' '); + const std::string addonid = str.substr(0, length); + int stringid = atoi(str.substr(length + 1).c_str()); + return g_localizeStrings.GetAddonString(addonid, stringid); +} + +std::string NumberReplacer(const std::string &str) +{ + return str; +} + +std::string CGUIInfoLabel::ReplaceLocalize(const std::string &label) +{ + std::string work(label); + ReplaceSpecialKeywordReferences(work, "LOCALIZE", LocalizeReplacer); + ReplaceSpecialKeywordReferences(work, "NUMBER", NumberReplacer); + return work; +} + +std::string CGUIInfoLabel::ReplaceAddonStrings(std::string &&label) +{ + ReplaceSpecialKeywordReferences(label, "ADDON", AddonReplacer); + return std::move(label); +} + +enum EINFOFORMAT { NONE = 0, FORMATINFO, FORMATESCINFO, FORMATVAR, FORMATESCVAR }; + +typedef struct +{ + const char *str; + EINFOFORMAT val; +} infoformat; + +const static infoformat infoformatmap[] = {{ "$INFO[", FORMATINFO}, + { "$ESCINFO[", FORMATESCINFO}, + { "$VAR[", FORMATVAR}, + { "$ESCVAR[", FORMATESCVAR}}; + +void CGUIInfoLabel::Parse(const std::string &label, int context) +{ + m_info.clear(); + m_dirty = true; + // Step 1: Replace all $LOCALIZE[number] with the real string + std::string work = ReplaceLocalize(label); + // Step 2: Replace all $ADDON[id number] with the real string + work = ReplaceAddonStrings(std::move(work)); + // Step 3: Find all $INFO[info,prefix,postfix] blocks + EINFOFORMAT format; + do + { + format = NONE; + size_t pos1 = work.size(); + size_t pos2; + size_t len = 0; + for (const infoformat& infoformat : infoformatmap) + { + pos2 = work.find(infoformat.str); + if (pos2 != std::string::npos && pos2 < pos1) + { + pos1 = pos2; + len = strlen(infoformat.str); + format = infoformat.val; + } + } + + if (format != NONE) + { + if (pos1 > 0) + m_info.emplace_back(0, work.substr(0, pos1), ""); + + pos2 = StringUtils::FindEndBracket(work, '[', ']', pos1 + len); + if (pos2 != std::string::npos) + { + // decipher the block + std::vector params = StringUtils::Split(work.substr(pos1 + len, pos2 - pos1 - len), ","); + if (!params.empty()) + { + CGUIInfoManager& infoMgr = CServiceBroker::GetGUI()->GetInfoManager(); + + int info; + if (format == FORMATVAR || format == FORMATESCVAR) + { + info = infoMgr.TranslateSkinVariableString(params[0], context); + if (info == 0) + info = infoMgr.RegisterSkinVariableString(g_SkinInfo->CreateSkinVariable(params[0], context)); + if (info == 0) // skinner didn't define this conditional label! + CLog::Log(LOGWARNING, "Label Formatting: $VAR[{}] is not defined", params[0]); + } + else + info = infoMgr.TranslateString(params[0]); + std::string prefix, postfix; + if (params.size() > 1) + prefix = params[1]; + if (params.size() > 2) + postfix = params[2]; + m_info.emplace_back(info, prefix, postfix, format == FORMATESCINFO || format == FORMATESCVAR); + } + // and delete it from our work string + work.erase(0, pos2 + 1); + } + else + { + CLog::Log(LOGERROR, "Error parsing label - missing ']' in \"{}\"", label); + return; + } + } + } + while (format != NONE); + + if (!work.empty()) + m_info.emplace_back(0, work, ""); +} + +CGUIInfoLabel::CInfoPortion::CInfoPortion(int info, const std::string &prefix, const std::string &postfix, bool escaped /*= false */): + m_prefix(prefix), + m_postfix(postfix) +{ + m_info = info; + m_escaped = escaped; + // filter our prefix and postfix for comma's + StringUtils::Replace(m_prefix, "$COMMA", ","); + StringUtils::Replace(m_postfix, "$COMMA", ","); + StringUtils::Replace(m_prefix, "$LBRACKET", "["); StringUtils::Replace(m_prefix, "$RBRACKET", "]"); + StringUtils::Replace(m_postfix, "$LBRACKET", "["); StringUtils::Replace(m_postfix, "$RBRACKET", "]"); +} + +bool CGUIInfoLabel::CInfoPortion::NeedsUpdate(const std::string &label) const +{ + if (m_label != label) + { + m_label = label; + return true; + } + return false; +} + +std::string CGUIInfoLabel::CInfoPortion::Get() const +{ + if (!m_info) + return m_prefix; + else if (m_label.empty()) + return ""; + std::string label = m_prefix + m_label + m_postfix; + if (m_escaped) // escape all quotes and backslashes, then quote + { + StringUtils::Replace(label, "\\", "\\\\"); + StringUtils::Replace(label, "\"", "\\\""); + return "\"" + label + "\""; + } + return label; +} + +std::string CGUIInfoLabel::GetLabel(const std::string &label, int contextWindow /*= 0*/, bool preferImage /*= false */) +{ // translate the label + const CGUIInfoLabel info(label, "", contextWindow); + return info.GetLabel(contextWindow, preferImage); +} + +std::string CGUIInfoLabel::GetItemLabel(const std::string &label, const CGUIListItem *item, bool preferImage /*= false */) +{ // translate the label + const CGUIInfoLabel info(label); + return info.GetItemLabel(item, preferImage); +} diff --git a/xbmc/guilib/guiinfo/GUIInfoLabel.h b/xbmc/guilib/guiinfo/GUIInfoLabel.h new file mode 100644 index 0000000..c9ae1a8 --- /dev/null +++ b/xbmc/guilib/guiinfo/GUIInfoLabel.h @@ -0,0 +1,146 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +/*! +\file GUIInfoLabel.h +\brief +*/ + +#include "interfaces/info/Info.h" + +#include +#include +#include + +class CGUIListItem; + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +class CGUIInfoLabel +{ +public: + CGUIInfoLabel() = default; + CGUIInfoLabel(const std::string& label, + const std::string& fallback = "", + int context = INFO::DEFAULT_CONTEXT); + + void SetLabel(const std::string& label, + const std::string& fallback, + int context = INFO::DEFAULT_CONTEXT); + + /*! + \brief Gets a label (or image) for a given window context from the info manager. + \param contextWindow the context in which to evaluate the expression. + \param preferImage caller is specifically wanting an image rather than a label. Defaults to false. + \param fallback if non-NULL, is set to an alternate value to use should the actual value be not appropriate. Defaults to NULL. + \return label (or image). + */ + const std::string &GetLabel(int contextWindow, bool preferImage = false, std::string *fallback = NULL) const; + + /*! + \brief Gets the label and returns it as an int value + \param contextWindow the context in which to evaluate the expression. + \return int value. + \sa GetLabel + */ + int GetIntValue(int contextWindow) const; + + /*! + \brief Gets a label (or image) for a given listitem from the info manager. + \param item listitem in question. + \param preferImage caller is specifically wanting an image rather than a label. Defaults to false. + \param fallback if non-NULL, is set to an alternate value to use should the actual value be not appropriate. Defaults to NULL. + \return label (or image). + */ + const std::string &GetItemLabel(const CGUIListItem *item, bool preferImage = false, std::string *fallback = NULL) const; + + bool IsConstant() const; + bool IsEmpty() const; + + const std::string& GetFallback() const { return m_fallback; } + + static std::string GetLabel(const std::string& label, + int contextWindow, + bool preferImage = false); + static std::string GetItemLabel(const std::string &label, const CGUIListItem *item, bool preferImage = false); + + /*! + \brief Replaces instances of $LOCALIZE[number] with the appropriate localized string + \param label text to replace + \return text with any localized strings filled in. + */ + static std::string ReplaceLocalize(const std::string &label); + + /*! + \brief Replaces instances of $ADDON[id number] with the appropriate localized addon string + \param label text to replace + \return text with any localized strings filled in. + */ + static std::string ReplaceAddonStrings(std::string &&label); + + typedef std::function StringReplacerFunc; + + /*! + \brief Replaces instances of $strKeyword[value] with the appropriate resolved string + \param strInput text to replace + \param strKeyword keyword to look for + \param func function that does the actual replacement of each bracketed value found + \param strOutput the output string + \return whether anything has been replaced. + */ + static bool ReplaceSpecialKeywordReferences(const std::string &strInput, const std::string &strKeyword, const StringReplacerFunc &func, std::string &strOutput); + + /*! + \brief Replaces instances of $strKeyword[value] with the appropriate resolved string in-place + \param work text to replace in-place + \param strKeyword keyword to look for + \param func function that does the actual replacement of each bracketed value found + \return whether anything has been replaced. + */ + static bool ReplaceSpecialKeywordReferences(std::string &work, const std::string &strKeyword, const StringReplacerFunc &func); + +private: + void Parse(const std::string &label, int context); + + /*! \brief return (and cache) built label from info portions. + \param rebuild whether we need to rebuild the label + \sa GetLabel, GetItemLabel + */ + const std::string &CacheLabel(bool rebuild) const; + + class CInfoPortion + { + public: + CInfoPortion(int info, const std::string &prefix, const std::string &postfix, bool escaped = false); + bool NeedsUpdate(const std::string &label) const; + std::string Get() const; + int m_info; + private: + bool m_escaped; + mutable std::string m_label; + std::string m_prefix; + std::string m_postfix; + }; + + mutable bool m_dirty = false; + mutable std::string m_label; + std::string m_fallback; + std::vector m_info; +}; + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI + diff --git a/xbmc/guilib/guiinfo/GUIInfoLabels.h b/xbmc/guilib/guiinfo/GUIInfoLabels.h new file mode 100644 index 0000000..3e2b163 --- /dev/null +++ b/xbmc/guilib/guiinfo/GUIInfoLabels.h @@ -0,0 +1,985 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +// clang-format off +#define PLAYER_HAS_MEDIA 1 +#define PLAYER_HAS_AUDIO 2 +#define PLAYER_HAS_VIDEO 3 +#define PLAYER_PLAYING 4 +#define PLAYER_PAUSED 5 +#define PLAYER_REWINDING 6 +#define PLAYER_REWINDING_2x 7 +#define PLAYER_REWINDING_4x 8 +#define PLAYER_REWINDING_8x 9 +#define PLAYER_REWINDING_16x 10 +#define PLAYER_REWINDING_32x 11 +#define PLAYER_FORWARDING 12 +#define PLAYER_FORWARDING_2x 13 +#define PLAYER_FORWARDING_4x 14 +#define PLAYER_FORWARDING_8x 15 +#define PLAYER_FORWARDING_16x 16 +#define PLAYER_FORWARDING_32x 17 +#define PLAYER_CACHING 20 +// unused id 21 +#define PLAYER_PROGRESS 22 +#define PLAYER_SEEKBAR 23 +#define PLAYER_SEEKTIME 24 +#define PLAYER_SEEKING 25 +#define PLAYER_SHOWTIME 26 +#define PLAYER_TIME 27 +#define PLAYER_TIME_REMAINING 28 +#define PLAYER_DURATION 29 +#define PLAYER_HASPERFORMEDSEEK 30 +#define PLAYER_SHOWINFO 31 +#define PLAYER_VOLUME 32 +#define PLAYER_MUTED 33 +#define PLAYER_HASDURATION 34 +#define PLAYER_CHAPTER 35 +#define PLAYER_CHAPTERCOUNT 36 +#define PLAYER_TIME_SPEED 37 +#define PLAYER_FINISH_TIME 38 +#define PLAYER_CACHELEVEL 39 +#define PLAYER_CHAPTERNAME 41 +#define PLAYER_SUBTITLE_DELAY 42 +#define PLAYER_AUDIO_DELAY 43 +#define PLAYER_PASSTHROUGH 44 +// unused 45 +// unused 46 +#define PLAYER_SEEKOFFSET 47 +#define PLAYER_PROGRESS_CACHE 48 +#define PLAYER_ITEM_ART 49 +#define PLAYER_CAN_PAUSE 50 +#define PLAYER_CAN_SEEK 51 +#define PLAYER_START_TIME 52 +// unused 53 +#define PLAYER_ISINTERNETSTREAM 54 +// unused 55 +#define PLAYER_SEEKSTEPSIZE 56 +#define PLAYER_IS_CHANNEL_PREVIEW_ACTIVE 57 +#define PLAYER_SUPPORTS_TEMPO 58 +#define PLAYER_IS_TEMPO 59 +#define PLAYER_PLAYSPEED 60 +#define PLAYER_SEEKNUMERIC 61 +#define PLAYER_HAS_GAME 62 +#define PLAYER_HAS_PROGRAMS 63 +#define PLAYER_HAS_RESOLUTIONS 64 +#define PLAYER_FRAMEADVANCE 65 +#define PLAYER_ICON 66 +#define PLAYER_CUTLIST 67 +#define PLAYER_CHAPTERS 68 +#define PLAYER_EDITLIST 69 +#define PLAYER_CUTS 70 +#define PLAYER_SCENE_MARKERS 71 +#define PLAYER_HAS_SCENE_MARKERS 72 +// Keep player infolabels that work with offset and position together +#define PLAYER_PATH 81 +#define PLAYER_FILEPATH 82 +#define PLAYER_TITLE 83 +#define PLAYER_FILENAME 84 + +// Range of player infolabels that work with offset and position +#define PLAYER_OFFSET_POSITION_FIRST PLAYER_PATH +#define PLAYER_OFFSET_POSITION_LAST PLAYER_FILENAME + +#define WEATHER_CONDITIONS_TEXT 100 +#define WEATHER_TEMPERATURE 101 +#define WEATHER_LOCATION 102 +#define WEATHER_IS_FETCHED 103 +#define WEATHER_FANART_CODE 104 +#define WEATHER_PLUGIN 105 +#define WEATHER_CONDITIONS_ICON 106 + +#define SYSTEM_TEMPERATURE_UNITS 107 +#define SYSTEM_PROGRESS_BAR 108 +#define SYSTEM_LANGUAGE 109 +#define SYSTEM_TIME 110 +#define SYSTEM_DATE 111 +#define SYSTEM_CPU_TEMPERATURE 112 +#define SYSTEM_GPU_TEMPERATURE 113 +#define SYSTEM_FAN_SPEED 114 +#define SYSTEM_FREE_SPACE_C 115 +// #define SYSTEM_FREE_SPACE_D 116 //116 is reserved for space on D +#define SYSTEM_FREE_SPACE_E 117 +#define SYSTEM_FREE_SPACE_F 118 +#define SYSTEM_FREE_SPACE_G 119 +#define SYSTEM_BUILD_VERSION 120 +#define SYSTEM_BUILD_DATE 121 +#define SYSTEM_ETHERNET_LINK_ACTIVE 122 +#define SYSTEM_FPS 123 +#define SYSTEM_ALWAYS_TRUE 125 // useful for true, to fade in a control +#define SYSTEM_ALWAYS_FALSE 126 // used for false, to fade out a control (ie not particularly useful!) +#define SYSTEM_MEDIA_DVD 127 +#define SYSTEM_DVDREADY 128 +#define SYSTEM_HAS_ALARM 129 +#define SYSTEM_SUPPORTS_CPU_USAGE 130 +#define SYSTEM_SCREEN_MODE 132 +#define SYSTEM_SCREEN_WIDTH 133 +#define SYSTEM_SCREEN_HEIGHT 134 +#define SYSTEM_CURRENT_WINDOW 135 +#define SYSTEM_CURRENT_CONTROL 136 +#define SYSTEM_CURRENT_CONTROL_ID 137 +#define SYSTEM_DVD_LABEL 138 +#define SYSTEM_HASLOCKS 140 +#define SYSTEM_ISMASTER 141 +#define SYSTEM_TRAYOPEN 142 +#define SYSTEM_SHOW_EXIT_BUTTON 143 +#define SYSTEM_ALARM_POS 144 +#define SYSTEM_LOGGEDON 145 +#define SYSTEM_PROFILENAME 146 +#define SYSTEM_PROFILETHUMB 147 +#define SYSTEM_HAS_LOGINSCREEN 148 +#define SYSTEM_HAS_ACTIVE_MODAL_DIALOG 149 +#define SYSTEM_HDD_SMART 150 +#define SYSTEM_HDD_TEMPERATURE 151 +#define SYSTEM_HDD_MODEL 152 +#define SYSTEM_HDD_SERIAL 153 +#define SYSTEM_HDD_FIRMWARE 154 +#define SYSTEM_HAS_VISIBLE_MODAL_DIALOG 155 +#define SYSTEM_HDD_PASSWORD 156 +#define SYSTEM_HDD_LOCKSTATE 157 +#define SYSTEM_HDD_LOCKKEY 158 +#define SYSTEM_INTERNET_STATE 159 +#define SYSTEM_HAS_INPUT_HIDDEN 160 +#define SYSTEM_HAS_PVR_ADDON 161 +#define SYSTEM_ALARM_LESS_OR_EQUAL 180 +#define SYSTEM_PROFILECOUNT 181 +#define SYSTEM_ISFULLSCREEN 182 +#define SYSTEM_ISSTANDALONE 183 +#define SYSTEM_IDLE_SHUTDOWN_INHIBITED 184 +#define SYSTEM_HAS_SHUTDOWN 185 +#define SYSTEM_HAS_PVR 186 +#define SYSTEM_STARTUP_WINDOW 187 +#define SYSTEM_STEREOSCOPIC_MODE 188 +#define SYSTEM_BUILD_VERSION_SHORT 189 + +#define NETWORK_IP_ADDRESS 190 +#define NETWORK_MAC_ADDRESS 191 +#define NETWORK_IS_DHCP 192 +#define NETWORK_LINK_STATE 193 +#define NETWORK_SUBNET_MASK 194 +#define NETWORK_GATEWAY_ADDRESS 195 +#define NETWORK_DNS1_ADDRESS 196 +#define NETWORK_DNS2_ADDRESS 197 +#define NETWORK_DHCP_ADDRESS 198 + +// Keep musicplayer infolabels that work with offset and position together +#define MUSICPLAYER_TITLE 200 +#define MUSICPLAYER_ALBUM 201 +#define MUSICPLAYER_ARTIST 202 +#define MUSICPLAYER_GENRE 203 +#define MUSICPLAYER_YEAR 204 +#define MUSICPLAYER_DURATION 205 +#define MUSICPLAYER_TRACK_NUMBER 208 +#define MUSICPLAYER_COVER 210 +#define MUSICPLAYER_BITRATE 211 +#define MUSICPLAYER_PLAYLISTLEN 212 +#define MUSICPLAYER_PLAYLISTPOS 213 +#define MUSICPLAYER_CHANNELS 214 +#define MUSICPLAYER_BITSPERSAMPLE 215 +#define MUSICPLAYER_SAMPLERATE 216 +#define MUSICPLAYER_CODEC 217 +#define MUSICPLAYER_DISC_NUMBER 218 +#define MUSICPLAYER_RATING 219 +#define MUSICPLAYER_COMMENT 220 +#define MUSICPLAYER_LYRICS 221 +#define MUSICPLAYER_ALBUM_ARTIST 222 +#define MUSICPLAYER_PLAYCOUNT 223 +#define MUSICPLAYER_LASTPLAYED 224 +#define MUSICPLAYER_USER_RATING 225 +#define MUSICPLAYER_RATING_AND_VOTES 226 +#define MUSICPLAYER_VOTES 227 +#define MUSICPLAYER_MOOD 228 +#define MUSICPLAYER_CONTRIBUTORS 229 +#define MUSICPLAYER_CONTRIBUTOR_AND_ROLE 230 +#define MUSICPLAYER_DBID 231 +#define MUSICPLAYER_DISC_TITLE 232 +#define MUSICPLAYER_RELEASEDATE 233 +#define MUSICPLAYER_ORIGINALDATE 234 +#define MUSICPLAYER_BPM 235 + +// Range of musicplayer infolabels that work with offset and position +#define MUSICPLAYER_OFFSET_POSITION_FIRST MUSICPLAYER_TITLE +#define MUSICPLAYER_OFFSET_POSITION_LAST MUSICPLAYER_BPM + +#define MUSICPLAYER_PROPERTY 236 +#define MUSICPLAYER_CHANNEL_NAME 237 +#define MUSICPLAYER_CHANNEL_GROUP 238 +#define MUSICPLAYER_CHANNEL_NUMBER 239 +#define MUSICPLAYER_TOTALDISCS 240 +#define MUSICPLAYER_STATIONNAME 241 + +// Musicplayer infobools +#define MUSICPLAYER_HASPREVIOUS 242 +#define MUSICPLAYER_HASNEXT 243 +#define MUSICPLAYER_EXISTS 244 +#define MUSICPLAYER_PLAYLISTPLAYING 245 +#define MUSICPLAYER_CONTENT 246 +#define MUSICPLAYER_ISMULTIDISC 247 + +// Videoplayer infolabels +#define VIDEOPLAYER_HDR_TYPE 249 +// Keep videoplayer infolabels that work with offset and position together +#define VIDEOPLAYER_TITLE 250 +#define VIDEOPLAYER_GENRE 251 +#define VIDEOPLAYER_DIRECTOR 252 +#define VIDEOPLAYER_YEAR 253 +#define VIDEOPLAYER_COVER 254 +#define VIDEOPLAYER_ORIGINALTITLE 255 +#define VIDEOPLAYER_PLOT 256 +#define VIDEOPLAYER_PLOT_OUTLINE 257 +#define VIDEOPLAYER_EPISODE 258 +#define VIDEOPLAYER_SEASON 259 +#define VIDEOPLAYER_RATING 260 +#define VIDEOPLAYER_TVSHOW 261 +#define VIDEOPLAYER_PREMIERED 262 +#define VIDEOPLAYER_STUDIO 263 +#define VIDEOPLAYER_MPAA 264 +#define VIDEOPLAYER_ARTIST 265 +#define VIDEOPLAYER_ALBUM 266 +#define VIDEOPLAYER_WRITER 267 +#define VIDEOPLAYER_TAGLINE 268 +#define VIDEOPLAYER_TOP250 269 +#define VIDEOPLAYER_RATING_AND_VOTES 270 +#define VIDEOPLAYER_TRAILER 271 +#define VIDEOPLAYER_COUNTRY 272 +#define VIDEOPLAYER_PLAYCOUNT 273 +#define VIDEOPLAYER_LASTPLAYED 274 +#define VIDEOPLAYER_VOTES 275 +#define VIDEOPLAYER_IMDBNUMBER 276 +#define VIDEOPLAYER_USER_RATING 277 +#define VIDEOPLAYER_DBID 278 +#define VIDEOPLAYER_TVSHOWDBID 279 +#define VIDEOPLAYER_ART 280 + +// Range of videoplayer infolabels that work with offset and position +#define VIDEOPLAYER_OFFSET_POSITION_FIRST VIDEOPLAYER_TITLE +#define VIDEOPLAYER_OFFSET_POSITION_LAST VIDEOPLAYER_ART + +#define VIDEOPLAYER_AUDIO_BITRATE 281 +#define VIDEOPLAYER_VIDEO_BITRATE 282 +#define VIDEOPLAYER_VIDEO_CODEC 283 +#define VIDEOPLAYER_VIDEO_RESOLUTION 284 +#define VIDEOPLAYER_AUDIO_CODEC 285 +#define VIDEOPLAYER_AUDIO_CHANNELS 286 +#define VIDEOPLAYER_VIDEO_ASPECT 287 +#define VIDEOPLAYER_SUBTITLES_LANG 288 +#define VIDEOPLAYER_AUDIO_LANG 290 +#define VIDEOPLAYER_STEREOSCOPIC_MODE 291 +#define VIDEOPLAYER_CAST 292 +#define VIDEOPLAYER_CAST_AND_ROLE 293 +#define VIDEOPLAYER_UNIQUEID 294 +#define VIDEOPLAYER_AUDIOSTREAMCOUNT 295 + +// Videoplayer infobools +#define VIDEOPLAYER_HASSUBTITLES 300 +#define VIDEOPLAYER_SUBTITLESENABLED 301 +#define VIDEOPLAYER_USING_OVERLAYS 302 +#define VIDEOPLAYER_ISFULLSCREEN 303 +#define VIDEOPLAYER_HASMENU 304 +#define VIDEOPLAYER_PLAYLISTLEN 305 +#define VIDEOPLAYER_PLAYLISTPOS 306 +#define VIDEOPLAYER_CONTENT 307 +#define VIDEOPLAYER_HAS_INFO 308 +#define VIDEOPLAYER_HASTELETEXT 309 +#define VIDEOPLAYER_IS_STEREOSCOPIC 310 + +// PVR infolabels +#define VIDEOPLAYER_EVENT 313 +#define VIDEOPLAYER_EPISODENAME 314 +#define VIDEOPLAYER_STARTTIME 315 +#define VIDEOPLAYER_ENDTIME 316 +#define VIDEOPLAYER_NEXT_TITLE 317 +#define VIDEOPLAYER_NEXT_GENRE 318 +#define VIDEOPLAYER_NEXT_PLOT 319 +#define VIDEOPLAYER_NEXT_PLOT_OUTLINE 320 +#define VIDEOPLAYER_NEXT_STARTTIME 321 +#define VIDEOPLAYER_NEXT_ENDTIME 322 +#define VIDEOPLAYER_NEXT_DURATION 323 +#define VIDEOPLAYER_CHANNEL_NAME 324 +#define VIDEOPLAYER_CHANNEL_GROUP 325 +#define VIDEOPLAYER_PARENTAL_RATING 326 +#define VIDEOPLAYER_CHANNEL_NUMBER 327 + +// PVR infobools +#define VIDEOPLAYER_HAS_EPG 328 +#define VIDEOPLAYER_CAN_RESUME_LIVE_TV 329 + +#define RETROPLAYER_VIDEO_FILTER 330 +#define RETROPLAYER_STRETCH_MODE 331 +#define RETROPLAYER_VIDEO_ROTATION 332 + +#define CONTAINER_HAS_PARENT_ITEM 341 +#define CONTAINER_CAN_FILTER 342 +#define CONTAINER_CAN_FILTERADVANCED 343 +#define CONTAINER_FILTERED 344 + +#define CONTAINER_SCROLL_PREVIOUS 345 +#define CONTAINER_MOVE_PREVIOUS 346 +// unused 347 +#define CONTAINER_MOVE_NEXT 348 +#define CONTAINER_SCROLL_NEXT 349 +#define CONTAINER_ISUPDATING 350 +#define CONTAINER_HASFILES 351 +#define CONTAINER_HASFOLDERS 352 +#define CONTAINER_STACKED 353 +#define CONTAINER_FOLDERNAME 354 +#define CONTAINER_SCROLLING 355 +#define CONTAINER_PLUGINNAME 356 +#define CONTAINER_PROPERTY 357 +#define CONTAINER_SORT_DIRECTION 358 +#define CONTAINER_NUM_ITEMS 359 +#define CONTAINER_FOLDERPATH 360 +#define CONTAINER_CONTENT 361 +#define CONTAINER_HAS_THUMB 362 +#define CONTAINER_SORT_METHOD 363 +#define CONTAINER_CURRENT_ITEM 364 +#define CONTAINER_ART 365 +#define CONTAINER_HAS_FOCUS 366 +#define CONTAINER_ROW 367 +#define CONTAINER_COLUMN 368 +#define CONTAINER_POSITION 369 +#define CONTAINER_VIEWMODE 370 +#define CONTAINER_HAS_NEXT 371 +#define CONTAINER_HAS_PREVIOUS 372 +#define CONTAINER_SUBITEM 373 +#define CONTAINER_NUM_PAGES 374 +#define CONTAINER_CURRENT_PAGE 375 +#define CONTAINER_SHOWPLOT 376 +#define CONTAINER_TOTALTIME 377 +#define CONTAINER_SORT_ORDER 378 +#define CONTAINER_TOTALWATCHED 379 +#define CONTAINER_TOTALUNWATCHED 380 +#define CONTAINER_VIEWCOUNT 381 +#define CONTAINER_SHOWTITLE 382 +#define CONTAINER_PLUGINCATEGORY 383 +#define CONTAINER_NUM_ALL_ITEMS 384 +#define CONTAINER_NUM_NONFOLDER_ITEMS 385 + +#define MUSICPM_ENABLED 390 +#define MUSICPM_SONGSPLAYED 391 +#define MUSICPM_MATCHINGSONGS 392 +#define MUSICPM_MATCHINGSONGSPICKED 393 +#define MUSICPM_MATCHINGSONGSLEFT 394 +#define MUSICPM_RELAXEDSONGSPICKED 395 +#define MUSICPM_RANDOMSONGSPICKED 396 + +#define PLAYLIST_LENGTH 400 +#define PLAYLIST_POSITION 401 +#define PLAYLIST_RANDOM 402 +#define PLAYLIST_REPEAT 403 +#define PLAYLIST_ISRANDOM 404 +#define PLAYLIST_ISREPEAT 405 +#define PLAYLIST_ISREPEATONE 406 + +#define VISUALISATION_LOCKED 410 +#define VISUALISATION_PRESET 411 +#define VISUALISATION_NAME 412 +#define VISUALISATION_ENABLED 413 +#define VISUALISATION_HAS_PRESETS 414 + +#define STRING_IS_EMPTY 420 +#define STRING_IS_EQUAL 421 +#define STRING_STARTS_WITH 422 +#define STRING_ENDS_WITH 423 +#define STRING_CONTAINS 424 + +#define INTEGER_IS_EQUAL 450 +#define INTEGER_GREATER_THAN 451 +#define INTEGER_GREATER_OR_EQUAL 452 +#define INTEGER_LESS_THAN 453 +#define INTEGER_LESS_OR_EQUAL 454 +#define INTEGER_EVEN 455 +#define INTEGER_ODD 456 +#define INTEGER_VALUEOF 457 + +#define SKIN_BOOL 600 +#define SKIN_STRING 601 +#define SKIN_STRING_IS_EQUAL 602 +#define SKIN_THEME 604 +#define SKIN_COLOUR_THEME 605 +#define SKIN_HAS_THEME 606 +#define SKIN_ASPECT_RATIO 607 +#define SKIN_FONT 608 +#define SKIN_INTEGER 609 +#define SKIN_TIMER_IS_RUNNING 610 +#define SKIN_TIMER_ELAPSEDSECS 611 + +#define SYSTEM_IS_SCREENSAVER_INHIBITED 641 +#define SYSTEM_ADDON_UPDATE_COUNT 642 +#define SYSTEM_PRIVACY_POLICY 643 +#define SYSTEM_TOTAL_MEMORY 644 +#define SYSTEM_CPU_USAGE 645 +#define SYSTEM_USED_MEMORY_PERCENT 646 +#define SYSTEM_USED_MEMORY 647 +#define SYSTEM_FREE_MEMORY 648 +#define SYSTEM_FREE_MEMORY_PERCENT 649 +#define SYSTEM_UPTIME 654 +#define SYSTEM_TOTALUPTIME 655 +#define SYSTEM_CPUFREQUENCY 656 +#define SYSTEM_SCREEN_RESOLUTION 659 +#define SYSTEM_VIDEO_ENCODER_INFO 660 +#define SYSTEM_OS_VERSION_INFO 667 +#define SYSTEM_FREE_SPACE 679 +#define SYSTEM_USED_SPACE 680 +#define SYSTEM_TOTAL_SPACE 681 +#define SYSTEM_USED_SPACE_PERCENT 682 +#define SYSTEM_FREE_SPACE_PERCENT 683 +#define SYSTEM_ADDON_IS_ENABLED 703 +#define SYSTEM_GET_BOOL 704 +#define SYSTEM_GET_CORE_USAGE 705 +#define SYSTEM_HAS_CORE_ID 706 +#define SYSTEM_RENDER_VENDOR 707 +#define SYSTEM_RENDER_RENDERER 708 +#define SYSTEM_RENDER_VERSION 709 +#define SYSTEM_SETTING 710 +#define SYSTEM_HAS_ADDON 711 +#define SYSTEM_ADDON_TITLE 712 +#define SYSTEM_ADDON_ICON 713 +#define SYSTEM_BATTERY_LEVEL 714 +#define SYSTEM_IDLE_TIME 715 +#define SYSTEM_FRIENDLY_NAME 716 +#define SYSTEM_SCREENSAVER_ACTIVE 717 +#define SYSTEM_ADDON_VERSION 718 +#define SYSTEM_DPMS_ACTIVE 719 + +#define LIBRARY_HAS_MUSIC 720 +#define LIBRARY_HAS_VIDEO 721 +#define LIBRARY_HAS_MOVIES 722 +#define LIBRARY_HAS_MOVIE_SETS 723 +#define LIBRARY_HAS_TVSHOWS 724 +#define LIBRARY_HAS_MUSICVIDEOS 725 +#define LIBRARY_HAS_SINGLES 726 +#define LIBRARY_HAS_COMPILATIONS 727 +#define LIBRARY_IS_SCANNING 728 +#define LIBRARY_IS_SCANNING_VIDEO 729 +#define LIBRARY_IS_SCANNING_MUSIC 730 +#define LIBRARY_HAS_ROLE 735 +#define LIBRARY_HAS_BOXSETS 736 +#define LIBRARY_HAS_NODE 737 + +#define SYSTEM_PLATFORM_LINUX 741 +#define SYSTEM_PLATFORM_WINDOWS 742 +#define SYSTEM_PLATFORM_DARWIN 743 +#define SYSTEM_PLATFORM_DARWIN_OSX 744 +#define SYSTEM_PLATFORM_DARWIN_IOS 745 +#define SYSTEM_PLATFORM_UWP 746 +#define SYSTEM_PLATFORM_ANDROID 747 +#define SYSTEM_PLATFORM_WINDOWING 748 +#define SYSTEM_PLATFORM_WIN10 749 + +#define SYSTEM_CAN_POWERDOWN 750 +#define SYSTEM_CAN_SUSPEND 751 +#define SYSTEM_CAN_HIBERNATE 752 +#define SYSTEM_CAN_REBOOT 753 +#define SYSTEM_MEDIA_AUDIO_CD 754 + +#define SYSTEM_PLATFORM_DARWIN_TVOS 755 +#define SYSTEM_SUPPORTED_HDR_TYPES 756 + +#define SLIDESHOW_ISPAUSED 800 +#define SLIDESHOW_ISRANDOM 801 +#define SLIDESHOW_ISACTIVE 802 +#define SLIDESHOW_ISVIDEO 803 + +#define SLIDESHOW_LABELS_START 900 +#define SLIDESHOW_FILE_NAME (SLIDESHOW_LABELS_START) +#define SLIDESHOW_FILE_PATH (SLIDESHOW_LABELS_START + 1) +#define SLIDESHOW_FILE_SIZE (SLIDESHOW_LABELS_START + 2) +#define SLIDESHOW_FILE_DATE (SLIDESHOW_LABELS_START + 3) +#define SLIDESHOW_INDEX (SLIDESHOW_LABELS_START + 4) +#define SLIDESHOW_RESOLUTION (SLIDESHOW_LABELS_START + 5) +#define SLIDESHOW_COMMENT (SLIDESHOW_LABELS_START + 6) +#define SLIDESHOW_COLOUR (SLIDESHOW_LABELS_START + 7) +#define SLIDESHOW_PROCESS (SLIDESHOW_LABELS_START + 8) + +#define SLIDESHOW_EXIF_LONG_DATE (SLIDESHOW_LABELS_START + 17) +#define SLIDESHOW_EXIF_LONG_DATE_TIME (SLIDESHOW_LABELS_START + 18) +#define SLIDESHOW_EXIF_DATE (SLIDESHOW_LABELS_START + 19) /* Implementation only to just get localized date */ +#define SLIDESHOW_EXIF_DATE_TIME (SLIDESHOW_LABELS_START + 20) +#define SLIDESHOW_EXIF_DESCRIPTION (SLIDESHOW_LABELS_START + 21) +#define SLIDESHOW_EXIF_CAMERA_MAKE (SLIDESHOW_LABELS_START + 22) +#define SLIDESHOW_EXIF_CAMERA_MODEL (SLIDESHOW_LABELS_START + 23) +#define SLIDESHOW_EXIF_COMMENT (SLIDESHOW_LABELS_START + 24) +#define SLIDESHOW_EXIF_SOFTWARE (SLIDESHOW_LABELS_START + 25) +#define SLIDESHOW_EXIF_APERTURE (SLIDESHOW_LABELS_START + 26) +#define SLIDESHOW_EXIF_FOCAL_LENGTH (SLIDESHOW_LABELS_START + 27) +#define SLIDESHOW_EXIF_FOCUS_DIST (SLIDESHOW_LABELS_START + 28) +#define SLIDESHOW_EXIF_EXPOSURE (SLIDESHOW_LABELS_START + 29) +#define SLIDESHOW_EXIF_EXPOSURE_TIME (SLIDESHOW_LABELS_START + 30) +#define SLIDESHOW_EXIF_EXPOSURE_BIAS (SLIDESHOW_LABELS_START + 31) +#define SLIDESHOW_EXIF_EXPOSURE_MODE (SLIDESHOW_LABELS_START + 32) +#define SLIDESHOW_EXIF_FLASH_USED (SLIDESHOW_LABELS_START + 33) +#define SLIDESHOW_EXIF_WHITE_BALANCE (SLIDESHOW_LABELS_START + 34) +#define SLIDESHOW_EXIF_LIGHT_SOURCE (SLIDESHOW_LABELS_START + 35) +#define SLIDESHOW_EXIF_METERING_MODE (SLIDESHOW_LABELS_START + 36) +#define SLIDESHOW_EXIF_ISO_EQUIV (SLIDESHOW_LABELS_START + 37) +#define SLIDESHOW_EXIF_DIGITAL_ZOOM (SLIDESHOW_LABELS_START + 38) +#define SLIDESHOW_EXIF_CCD_WIDTH (SLIDESHOW_LABELS_START + 39) +#define SLIDESHOW_EXIF_GPS_LATITUDE (SLIDESHOW_LABELS_START + 40) +#define SLIDESHOW_EXIF_GPS_LONGITUDE (SLIDESHOW_LABELS_START + 41) +#define SLIDESHOW_EXIF_GPS_ALTITUDE (SLIDESHOW_LABELS_START + 42) +#define SLIDESHOW_EXIF_ORIENTATION (SLIDESHOW_LABELS_START + 43) +#define SLIDESHOW_EXIF_XPCOMMENT (SLIDESHOW_LABELS_START + 44) + +#define SLIDESHOW_IPTC_SUBLOCATION (SLIDESHOW_LABELS_START + 57) +#define SLIDESHOW_IPTC_IMAGETYPE (SLIDESHOW_LABELS_START + 58) +#define SLIDESHOW_IPTC_TIMECREATED (SLIDESHOW_LABELS_START + 59) +#define SLIDESHOW_IPTC_SUP_CATEGORIES (SLIDESHOW_LABELS_START + 60) +#define SLIDESHOW_IPTC_KEYWORDS (SLIDESHOW_LABELS_START + 61) +#define SLIDESHOW_IPTC_CAPTION (SLIDESHOW_LABELS_START + 62) +#define SLIDESHOW_IPTC_AUTHOR (SLIDESHOW_LABELS_START + 63) +#define SLIDESHOW_IPTC_HEADLINE (SLIDESHOW_LABELS_START + 64) +#define SLIDESHOW_IPTC_SPEC_INSTR (SLIDESHOW_LABELS_START + 65) +#define SLIDESHOW_IPTC_CATEGORY (SLIDESHOW_LABELS_START + 66) +#define SLIDESHOW_IPTC_BYLINE (SLIDESHOW_LABELS_START + 67) +#define SLIDESHOW_IPTC_BYLINE_TITLE (SLIDESHOW_LABELS_START + 68) +#define SLIDESHOW_IPTC_CREDIT (SLIDESHOW_LABELS_START + 69) +#define SLIDESHOW_IPTC_SOURCE (SLIDESHOW_LABELS_START + 70) +#define SLIDESHOW_IPTC_COPYRIGHT_NOTICE (SLIDESHOW_LABELS_START + 71) +#define SLIDESHOW_IPTC_OBJECT_NAME (SLIDESHOW_LABELS_START + 72) +#define SLIDESHOW_IPTC_CITY (SLIDESHOW_LABELS_START + 73) +#define SLIDESHOW_IPTC_STATE (SLIDESHOW_LABELS_START + 74) +#define SLIDESHOW_IPTC_COUNTRY (SLIDESHOW_LABELS_START + 75) +#define SLIDESHOW_IPTC_TX_REFERENCE (SLIDESHOW_LABELS_START + 76) +#define SLIDESHOW_IPTC_DATE (SLIDESHOW_LABELS_START + 77) +#define SLIDESHOW_IPTC_URGENCY (SLIDESHOW_LABELS_START + 78) +#define SLIDESHOW_IPTC_COUNTRY_CODE (SLIDESHOW_LABELS_START + 79) +#define SLIDESHOW_IPTC_REF_SERVICE (SLIDESHOW_LABELS_START + 80) +#define SLIDESHOW_LABELS_END SLIDESHOW_IPTC_REF_SERVICE + +#define FANART_COLOR1 1000 +#define FANART_COLOR2 1001 +#define FANART_COLOR3 1002 +#define FANART_IMAGE 1003 + +#define SYSTEM_PROFILEAUTOLOGIN 1004 + +#define SYSTEM_HAS_CMS 1006 +#define SYSTEM_BUILD_VERSION_CODE 1007 +#define SYSTEM_BUILD_VERSION_GIT 1008 + +#define PVR_CONDITIONS_START 1100 +#define PVR_IS_RECORDING (PVR_CONDITIONS_START) +#define PVR_HAS_TIMER (PVR_CONDITIONS_START + 1) +#define PVR_HAS_NONRECORDING_TIMER (PVR_CONDITIONS_START + 2) +#define PVR_IS_PLAYING_TV (PVR_CONDITIONS_START + 3) +#define PVR_IS_PLAYING_RADIO (PVR_CONDITIONS_START + 4) +#define PVR_IS_PLAYING_RECORDING (PVR_CONDITIONS_START + 5) +#define PVR_ACTUAL_STREAM_ENCRYPTED (PVR_CONDITIONS_START + 6) +#define PVR_HAS_TV_CHANNELS (PVR_CONDITIONS_START + 7) +#define PVR_HAS_RADIO_CHANNELS (PVR_CONDITIONS_START + 8) +#define PVR_IS_TIMESHIFTING (PVR_CONDITIONS_START + 9) +#define PVR_IS_RECORDING_TV (PVR_CONDITIONS_START + 10) +#define PVR_HAS_TV_TIMER (PVR_CONDITIONS_START + 11) +#define PVR_HAS_NONRECORDING_TV_TIMER (PVR_CONDITIONS_START + 12) +#define PVR_IS_RECORDING_RADIO (PVR_CONDITIONS_START + 13) +#define PVR_HAS_RADIO_TIMER (PVR_CONDITIONS_START + 14) +#define PVR_HAS_NONRECORDING_RADIO_TIMER (PVR_CONDITIONS_START + 15) +#define PVR_IS_PLAYING_EPGTAG (PVR_CONDITIONS_START + 16) +#define PVR_CAN_RECORD_PLAYING_CHANNEL (PVR_CONDITIONS_START + 17) +#define PVR_IS_RECORDING_PLAYING_CHANNEL (PVR_CONDITIONS_START + 18) +#define PVR_IS_PLAYING_ACTIVE_RECORDING (PVR_CONDITIONS_START + 19) +#define PVR_CONDITIONS_END PVR_IS_PLAYING_ACTIVE_RECORDING + +#define PVR_STRINGS_START 1200 +#define PVR_NEXT_RECORDING_CHANNEL (PVR_STRINGS_START) +#define PVR_NEXT_RECORDING_CHAN_ICO (PVR_STRINGS_START + 1) +#define PVR_NEXT_RECORDING_DATETIME (PVR_STRINGS_START + 2) +#define PVR_NEXT_RECORDING_TITLE (PVR_STRINGS_START + 3) +#define PVR_NOW_RECORDING_CHANNEL (PVR_STRINGS_START + 4) +#define PVR_NOW_RECORDING_CHAN_ICO (PVR_STRINGS_START + 5) +#define PVR_NOW_RECORDING_DATETIME (PVR_STRINGS_START + 6) +#define PVR_NOW_RECORDING_TITLE (PVR_STRINGS_START + 7) +#define PVR_BACKEND_NAME (PVR_STRINGS_START + 8) +#define PVR_BACKEND_VERSION (PVR_STRINGS_START + 9) +#define PVR_BACKEND_HOST (PVR_STRINGS_START + 10) +#define PVR_BACKEND_DISKSPACE (PVR_STRINGS_START + 11) +#define PVR_BACKEND_CHANNELS (PVR_STRINGS_START + 12) +#define PVR_BACKEND_TIMERS (PVR_STRINGS_START + 13) +#define PVR_BACKEND_RECORDINGS (PVR_STRINGS_START + 14) +#define PVR_BACKEND_DELETED_RECORDINGS (PVR_STRINGS_START + 15) +#define PVR_BACKEND_NUMBER (PVR_STRINGS_START + 16) +#define PVR_TOTAL_DISKSPACE (PVR_STRINGS_START + 17) +#define PVR_NEXT_TIMER (PVR_STRINGS_START + 18) +#define PVR_EPG_EVENT_DURATION (PVR_STRINGS_START + 19) +#define PVR_EPG_EVENT_ELAPSED_TIME (PVR_STRINGS_START + 20) +#define PVR_EPG_EVENT_PROGRESS (PVR_STRINGS_START + 21) +#define PVR_ACTUAL_STREAM_CLIENT (PVR_STRINGS_START + 22) +#define PVR_ACTUAL_STREAM_DEVICE (PVR_STRINGS_START + 23) +#define PVR_ACTUAL_STREAM_STATUS (PVR_STRINGS_START + 24) +#define PVR_ACTUAL_STREAM_SIG (PVR_STRINGS_START + 25) +#define PVR_ACTUAL_STREAM_SNR (PVR_STRINGS_START + 26) +#define PVR_ACTUAL_STREAM_SIG_PROGR (PVR_STRINGS_START + 27) +#define PVR_ACTUAL_STREAM_SNR_PROGR (PVR_STRINGS_START + 28) +#define PVR_ACTUAL_STREAM_BER (PVR_STRINGS_START + 29) +#define PVR_ACTUAL_STREAM_UNC (PVR_STRINGS_START + 30) +#define PVR_ACTUAL_STREAM_CRYPTION (PVR_STRINGS_START + 34) +#define PVR_ACTUAL_STREAM_SERVICE (PVR_STRINGS_START + 35) +#define PVR_ACTUAL_STREAM_MUX (PVR_STRINGS_START + 36) +#define PVR_ACTUAL_STREAM_PROVIDER (PVR_STRINGS_START + 37) +#define PVR_BACKEND_DISKSPACE_PROGR (PVR_STRINGS_START + 38) +#define PVR_TIMESHIFT_START_TIME (PVR_STRINGS_START + 39) +#define PVR_TIMESHIFT_END_TIME (PVR_STRINGS_START + 40) +#define PVR_TIMESHIFT_PLAY_TIME (PVR_STRINGS_START + 41) +#define PVR_TIMESHIFT_PROGRESS (PVR_STRINGS_START + 42) +#define PVR_TV_NOW_RECORDING_TITLE (PVR_STRINGS_START + 43) +#define PVR_TV_NOW_RECORDING_CHANNEL (PVR_STRINGS_START + 44) +#define PVR_TV_NOW_RECORDING_CHAN_ICO (PVR_STRINGS_START + 45) +#define PVR_TV_NOW_RECORDING_DATETIME (PVR_STRINGS_START + 46) +#define PVR_TV_NEXT_RECORDING_TITLE (PVR_STRINGS_START + 47) +#define PVR_TV_NEXT_RECORDING_CHANNEL (PVR_STRINGS_START + 48) +#define PVR_TV_NEXT_RECORDING_CHAN_ICO (PVR_STRINGS_START + 49) +#define PVR_TV_NEXT_RECORDING_DATETIME (PVR_STRINGS_START + 50) +#define PVR_RADIO_NOW_RECORDING_TITLE (PVR_STRINGS_START + 51) +#define PVR_RADIO_NOW_RECORDING_CHANNEL (PVR_STRINGS_START + 52) +#define PVR_RADIO_NOW_RECORDING_CHAN_ICO (PVR_STRINGS_START + 53) +#define PVR_RADIO_NOW_RECORDING_DATETIME (PVR_STRINGS_START + 54) +#define PVR_RADIO_NEXT_RECORDING_TITLE (PVR_STRINGS_START + 55) +#define PVR_RADIO_NEXT_RECORDING_CHANNEL (PVR_STRINGS_START + 56) +#define PVR_RADIO_NEXT_RECORDING_CHAN_ICO (PVR_STRINGS_START + 57) +#define PVR_RADIO_NEXT_RECORDING_DATETIME (PVR_STRINGS_START + 58) +#define PVR_CHANNEL_NUMBER_INPUT (PVR_STRINGS_START + 59) +#define PVR_EPG_EVENT_REMAINING_TIME (PVR_STRINGS_START + 60) +#define PVR_EPG_EVENT_FINISH_TIME (PVR_STRINGS_START + 61) +#define PVR_TIMESHIFT_OFFSET (PVR_STRINGS_START + 62) +#define PVR_EPG_EVENT_SEEK_TIME (PVR_STRINGS_START + 63) +#define PVR_TIMESHIFT_PROGRESS_PLAY_POS (PVR_STRINGS_START + 64) +#define PVR_TIMESHIFT_PROGRESS_DURATION (PVR_STRINGS_START + 65) +#define PVR_TIMESHIFT_PROGRESS_EPG_START (PVR_STRINGS_START + 66) +#define PVR_TIMESHIFT_PROGRESS_EPG_END (PVR_STRINGS_START + 67) +#define PVR_TIMESHIFT_PROGRESS_BUFFER_START (PVR_STRINGS_START + 68) +#define PVR_TIMESHIFT_PROGRESS_BUFFER_END (PVR_STRINGS_START + 69) +#define PVR_TIMESHIFT_PROGRESS_START_TIME (PVR_STRINGS_START + 70) +#define PVR_TIMESHIFT_PROGRESS_END_TIME (PVR_STRINGS_START + 71) +#define PVR_EPG_EVENT_ICON (PVR_STRINGS_START + 72) +#define PVR_TIMESHIFT_SEEKBAR (PVR_STRINGS_START + 73) +#define PVR_BACKEND_PROVIDERS (PVR_STRINGS_START + 74) +#define PVR_BACKEND_CHANNEL_GROUPS (PVR_STRINGS_START + 75) +#define PVR_STRINGS_END PVR_BACKEND_CHANNEL_GROUPS + +#define RDS_DATA_START 1400 +#define RDS_HAS_RDS (RDS_DATA_START) +#define RDS_HAS_RADIOTEXT (RDS_DATA_START + 1) +#define RDS_HAS_RADIOTEXT_PLUS (RDS_DATA_START + 2) +#define RDS_GET_RADIOTEXT_LINE (RDS_DATA_START + 3) +#define RDS_TITLE (RDS_DATA_START + 4) +#define RDS_BAND (RDS_DATA_START + 5) +#define RDS_ARTIST (RDS_DATA_START + 6) +#define RDS_COMPOSER (RDS_DATA_START + 7) +#define RDS_CONDUCTOR (RDS_DATA_START + 8) +#define RDS_ALBUM (RDS_DATA_START + 9) +#define RDS_ALBUM_TRACKNUMBER (RDS_DATA_START + 10) +#define RDS_GET_RADIO_STYLE (RDS_DATA_START + 11) +#define RDS_COMMENT (RDS_DATA_START + 12) +#define RDS_INFO_NEWS (RDS_DATA_START + 13) +#define RDS_INFO_NEWS_LOCAL (RDS_DATA_START + 14) +#define RDS_INFO_STOCK (RDS_DATA_START + 15) +#define RDS_INFO_STOCK_SIZE (RDS_DATA_START + 16) +#define RDS_INFO_SPORT (RDS_DATA_START + 17) +#define RDS_INFO_SPORT_SIZE (RDS_DATA_START + 18) +#define RDS_INFO_LOTTERY (RDS_DATA_START + 19) +#define RDS_INFO_LOTTERY_SIZE (RDS_DATA_START + 20) +#define RDS_INFO_WEATHER (RDS_DATA_START + 21) +#define RDS_INFO_WEATHER_SIZE (RDS_DATA_START + 22) +#define RDS_INFO_CINEMA (RDS_DATA_START + 23) +#define RDS_INFO_CINEMA_SIZE (RDS_DATA_START + 24) +#define RDS_INFO_HOROSCOPE (RDS_DATA_START + 25) +#define RDS_INFO_HOROSCOPE_SIZE (RDS_DATA_START + 26) +#define RDS_INFO_OTHER (RDS_DATA_START + 27) +#define RDS_INFO_OTHER_SIZE (RDS_DATA_START + 28) +#define RDS_PROG_STATION (RDS_DATA_START + 29) +#define RDS_PROG_NOW (RDS_DATA_START + 30) +#define RDS_PROG_NEXT (RDS_DATA_START + 31) +#define RDS_PROG_HOST (RDS_DATA_START + 32) +#define RDS_PROG_EDIT_STAFF (RDS_DATA_START + 33) +#define RDS_PROG_HOMEPAGE (RDS_DATA_START + 34) +#define RDS_PROG_STYLE (RDS_DATA_START + 35) +#define RDS_PHONE_HOTLINE (RDS_DATA_START + 36) +#define RDS_PHONE_STUDIO (RDS_DATA_START + 37) +#define RDS_SMS_STUDIO (RDS_DATA_START + 38) +#define RDS_EMAIL_HOTLINE (RDS_DATA_START + 39) +#define RDS_EMAIL_STUDIO (RDS_DATA_START + 40) +#define RDS_HAS_HOTLINE_DATA (RDS_DATA_START + 41) +#define RDS_HAS_STUDIO_DATA (RDS_DATA_START + 42) +#define RDS_AUDIO_LANG (RDS_DATA_START + 43) +#define RDS_CHANNEL_COUNTRY (RDS_DATA_START + 44) +#define RDS_DATA_END RDS_CHANNEL_COUNTRY + +#define PLAYER_PROCESS 1500 +#define PLAYER_PROCESS_VIDEODECODER (PLAYER_PROCESS) +#define PLAYER_PROCESS_DEINTMETHOD (PLAYER_PROCESS + 1) +#define PLAYER_PROCESS_PIXELFORMAT (PLAYER_PROCESS + 2) +#define PLAYER_PROCESS_VIDEOWIDTH (PLAYER_PROCESS + 3) +#define PLAYER_PROCESS_VIDEOHEIGHT (PLAYER_PROCESS + 4) +#define PLAYER_PROCESS_VIDEOFPS (PLAYER_PROCESS + 5) +#define PLAYER_PROCESS_VIDEODAR (PLAYER_PROCESS + 6) +#define PLAYER_PROCESS_VIDEOHWDECODER (PLAYER_PROCESS + 7) +#define PLAYER_PROCESS_AUDIODECODER (PLAYER_PROCESS + 8) +#define PLAYER_PROCESS_AUDIOCHANNELS (PLAYER_PROCESS + 9) +#define PLAYER_PROCESS_AUDIOSAMPLERATE (PLAYER_PROCESS + 10) +#define PLAYER_PROCESS_AUDIOBITSPERSAMPLE (PLAYER_PROCESS + 11) +#define PLAYER_PROCESS_VIDEOSCANTYPE (PLAYER_PROCESS + 12) + +#define ADDON_INFOS 1600 +#define ADDON_SETTING_STRING (ADDON_INFOS) +#define ADDON_SETTING_BOOL (ADDON_INFOS + 1) +#define ADDON_SETTING_INT (ADDON_INFOS + 2) + +#define WINDOW_PROPERTY 9993 +#define WINDOW_IS_VISIBLE 9995 +#define WINDOW_NEXT 9996 +#define WINDOW_PREVIOUS 9997 +#define WINDOW_IS_MEDIA 9998 +#define WINDOW_IS_ACTIVE 9999 +#define WINDOW_IS 10000 +#define WINDOW_IS_DIALOG_TOPMOST 10001 +#define WINDOW_IS_MODAL_DIALOG_TOPMOST 10002 + +#define CONTROL_GET_LABEL 29996 +#define CONTROL_IS_ENABLED 29997 +#define CONTROL_IS_VISIBLE 29998 +#define CONTROL_GROUP_HAS_FOCUS 29999 +#define CONTROL_HAS_FOCUS 30000 + +#define LISTITEM_START 35000 +#define LISTITEM_THUMB (LISTITEM_START) +#define LISTITEM_LABEL (LISTITEM_START + 1) +#define LISTITEM_TITLE (LISTITEM_START + 2) +#define LISTITEM_TRACKNUMBER (LISTITEM_START + 3) +#define LISTITEM_ARTIST (LISTITEM_START + 4) +#define LISTITEM_ALBUM (LISTITEM_START + 5) +#define LISTITEM_YEAR (LISTITEM_START + 6) +#define LISTITEM_GENRE (LISTITEM_START + 7) +#define LISTITEM_ICON (LISTITEM_START + 8) +#define LISTITEM_DIRECTOR (LISTITEM_START + 9) +#define LISTITEM_OVERLAY (LISTITEM_START + 10) +#define LISTITEM_LABEL2 (LISTITEM_START + 11) +#define LISTITEM_FILENAME (LISTITEM_START + 12) +#define LISTITEM_DATE (LISTITEM_START + 13) +#define LISTITEM_SIZE (LISTITEM_START + 14) +#define LISTITEM_RATING (LISTITEM_START + 15) +#define LISTITEM_PROGRAM_COUNT (LISTITEM_START + 16) +#define LISTITEM_DURATION (LISTITEM_START + 17) +#define LISTITEM_ISPLAYING (LISTITEM_START + 18) +#define LISTITEM_ISSELECTED (LISTITEM_START + 19) +#define LISTITEM_PLOT (LISTITEM_START + 20) +#define LISTITEM_PLOT_OUTLINE (LISTITEM_START + 21) +#define LISTITEM_EPISODE (LISTITEM_START + 22) +#define LISTITEM_SEASON (LISTITEM_START + 23) +#define LISTITEM_TVSHOW (LISTITEM_START + 24) +#define LISTITEM_PREMIERED (LISTITEM_START + 25) +#define LISTITEM_COMMENT (LISTITEM_START + 26) +#define LISTITEM_ACTUAL_ICON (LISTITEM_START + 27) +#define LISTITEM_PATH (LISTITEM_START + 28) +#define LISTITEM_PICTURE_PATH (LISTITEM_START + 29) + +#define LISTITEM_PICTURE_START (LISTITEM_START + 30) +#define LISTITEM_PICTURE_RESOLUTION (LISTITEM_PICTURE_START) // => SLIDESHOW_RESOLUTION +#define LISTITEM_PICTURE_LONGDATE (LISTITEM_START + 31) // => SLIDESHOW_EXIF_LONG_DATE +#define LISTITEM_PICTURE_LONGDATETIME (LISTITEM_START + 32) // => SLIDESHOW_EXIF_LONG_DATE_TIME +#define LISTITEM_PICTURE_DATE (LISTITEM_START + 33) // => SLIDESHOW_EXIF_DATE +#define LISTITEM_PICTURE_DATETIME (LISTITEM_START + 34) // => SLIDESHOW_EXIF_DATE_TIME +#define LISTITEM_PICTURE_COMMENT (LISTITEM_START + 35) // => SLIDESHOW_COMMENT +#define LISTITEM_PICTURE_CAPTION (LISTITEM_START + 36) // => SLIDESHOW_IPTC_CAPTION +#define LISTITEM_PICTURE_DESC (LISTITEM_START + 37) // => SLIDESHOW_EXIF_DESCRIPTION +#define LISTITEM_PICTURE_KEYWORDS (LISTITEM_START + 38) // => SLIDESHOW_IPTC_KEYWORDS +#define LISTITEM_PICTURE_CAM_MAKE (LISTITEM_START + 39) // => SLIDESHOW_EXIF_CAMERA_MAKE +#define LISTITEM_PICTURE_CAM_MODEL (LISTITEM_START + 40) // => SLIDESHOW_EXIF_CAMERA_MODEL +#define LISTITEM_PICTURE_APERTURE (LISTITEM_START + 41) // => SLIDESHOW_EXIF_APERTURE +#define LISTITEM_PICTURE_FOCAL_LEN (LISTITEM_START + 42) // => SLIDESHOW_EXIF_FOCAL_LENGTH +#define LISTITEM_PICTURE_FOCUS_DIST (LISTITEM_START + 43) // => SLIDESHOW_EXIF_FOCUS_DIST +#define LISTITEM_PICTURE_EXP_MODE (LISTITEM_START + 44) // => SLIDESHOW_EXIF_EXPOSURE_MODE +#define LISTITEM_PICTURE_EXP_TIME (LISTITEM_START + 45) // => SLIDESHOW_EXIF_EXPOSURE_TIME +#define LISTITEM_PICTURE_ISO (LISTITEM_START + 46) // => SLIDESHOW_EXIF_ISO_EQUIV +#define LISTITEM_PICTURE_AUTHOR (LISTITEM_START + 47) // => SLIDESHOW_IPTC_AUTHOR +#define LISTITEM_PICTURE_BYLINE (LISTITEM_START + 48) // => SLIDESHOW_IPTC_BYLINE +#define LISTITEM_PICTURE_BYLINE_TITLE (LISTITEM_START + 49) // => SLIDESHOW_IPTC_BYLINE_TITLE +#define LISTITEM_PICTURE_CATEGORY (LISTITEM_START + 50) // => SLIDESHOW_IPTC_CATEGORY +#define LISTITEM_PICTURE_CCD_WIDTH (LISTITEM_START + 51) // => SLIDESHOW_EXIF_CCD_WIDTH +#define LISTITEM_PICTURE_CITY (LISTITEM_START + 52) // => SLIDESHOW_IPTC_CITY +#define LISTITEM_PICTURE_URGENCY (LISTITEM_START + 53) // => SLIDESHOW_IPTC_URGENCY +#define LISTITEM_PICTURE_COPYRIGHT_NOTICE (LISTITEM_START + 54) // => SLIDESHOW_IPTC_COPYRIGHT_NOTICE +#define LISTITEM_PICTURE_COUNTRY (LISTITEM_START + 55) // => SLIDESHOW_IPTC_COUNTRY +#define LISTITEM_PICTURE_COUNTRY_CODE (LISTITEM_START + 56) // => SLIDESHOW_IPTC_COUNTRY_CODE +#define LISTITEM_PICTURE_CREDIT (LISTITEM_START + 57) // => SLIDESHOW_IPTC_CREDIT +#define LISTITEM_PICTURE_IPTCDATE (LISTITEM_START + 58) // => SLIDESHOW_IPTC_DATE +#define LISTITEM_PICTURE_DIGITAL_ZOOM (LISTITEM_START + 59) // => SLIDESHOW_EXIF_DIGITAL_ZOOM +#define LISTITEM_PICTURE_EXPOSURE (LISTITEM_START + 60) // => SLIDESHOW_EXIF_EXPOSURE +#define LISTITEM_PICTURE_EXPOSURE_BIAS (LISTITEM_START + 61) // => SLIDESHOW_EXIF_EXPOSURE_BIAS +#define LISTITEM_PICTURE_FLASH_USED (LISTITEM_START + 62) // => SLIDESHOW_EXIF_FLASH_USED +#define LISTITEM_PICTURE_HEADLINE (LISTITEM_START + 63) // => SLIDESHOW_IPTC_HEADLINE +#define LISTITEM_PICTURE_COLOUR (LISTITEM_START + 64) // => SLIDESHOW_COLOUR +#define LISTITEM_PICTURE_LIGHT_SOURCE (LISTITEM_START + 65) // => SLIDESHOW_EXIF_LIGHT_SOURCE +#define LISTITEM_PICTURE_METERING_MODE (LISTITEM_START + 66) // => SLIDESHOW_EXIF_METERING_MODE +#define LISTITEM_PICTURE_OBJECT_NAME (LISTITEM_START + 67) // => SLIDESHOW_IPTC_OBJECT_NAME +#define LISTITEM_PICTURE_ORIENTATION (LISTITEM_START + 68) // => SLIDESHOW_EXIF_ORIENTATION +#define LISTITEM_PICTURE_PROCESS (LISTITEM_START + 69) // => SLIDESHOW_PROCESS +#define LISTITEM_PICTURE_REF_SERVICE (LISTITEM_START + 70) // => SLIDESHOW_IPTC_REF_SERVICE +#define LISTITEM_PICTURE_SOURCE (LISTITEM_START + 71) // => SLIDESHOW_IPTC_SOURCE +#define LISTITEM_PICTURE_SPEC_INSTR (LISTITEM_START + 72) // => SLIDESHOW_IPTC_SPEC_INSTR +#define LISTITEM_PICTURE_STATE (LISTITEM_START + 73) // => SLIDESHOW_IPTC_STATE +#define LISTITEM_PICTURE_SUP_CATEGORIES (LISTITEM_START + 74) // => SLIDESHOW_IPTC_SUP_CATEGORIES +#define LISTITEM_PICTURE_TX_REFERENCE (LISTITEM_START + 75) // => SLIDESHOW_IPTC_TX_REFERENCE +#define LISTITEM_PICTURE_WHITE_BALANCE (LISTITEM_START + 76) // => SLIDESHOW_EXIF_WHITE_BALANCE +#define LISTITEM_PICTURE_IMAGETYPE (LISTITEM_START + 77) // => SLIDESHOW_IPTC_IMAGETYPE +#define LISTITEM_PICTURE_SUBLOCATION (LISTITEM_START + 78) // => SLIDESHOW_IPTC_SUBLOCATION +#define LISTITEM_PICTURE_TIMECREATED (LISTITEM_START + 79) // => SLIDESHOW_IPTC_TIMECREATED +#define LISTITEM_PICTURE_GPS_LAT (LISTITEM_START + 80) // => SLIDESHOW_EXIF_GPS_LATITUDE +#define LISTITEM_PICTURE_GPS_LON (LISTITEM_START + 81) // => SLIDESHOW_EXIF_GPS_LONGITUDE +#define LISTITEM_PICTURE_GPS_ALT (LISTITEM_START + 82) // => SLIDESHOW_EXIF_GPS_ALTITUDE +#define LISTITEM_PICTURE_END (LISTITEM_PICTURE_GPS_ALT) + +#define LISTITEM_STUDIO (LISTITEM_START + 83) +#define LISTITEM_MPAA (LISTITEM_START + 84) +#define LISTITEM_CAST (LISTITEM_START + 85) +#define LISTITEM_CAST_AND_ROLE (LISTITEM_START + 86) +#define LISTITEM_WRITER (LISTITEM_START + 87) +#define LISTITEM_TAGLINE (LISTITEM_START + 88) +#define LISTITEM_TOP250 (LISTITEM_START + 89) +#define LISTITEM_RATING_AND_VOTES (LISTITEM_START + 90) +#define LISTITEM_TRAILER (LISTITEM_START + 91) +#define LISTITEM_APPEARANCES (LISTITEM_START + 92) +#define LISTITEM_FILENAME_AND_PATH (LISTITEM_START + 93) +#define LISTITEM_SORT_LETTER (LISTITEM_START + 94) +#define LISTITEM_ALBUM_ARTIST (LISTITEM_START + 95) +#define LISTITEM_FOLDERNAME (LISTITEM_START + 96) +#define LISTITEM_VIDEO_CODEC (LISTITEM_START + 97) +#define LISTITEM_VIDEO_RESOLUTION (LISTITEM_START + 98) +#define LISTITEM_VIDEO_ASPECT (LISTITEM_START + 99) +#define LISTITEM_AUDIO_CODEC (LISTITEM_START + 100) +#define LISTITEM_AUDIO_CHANNELS (LISTITEM_START + 101) +#define LISTITEM_AUDIO_LANGUAGE (LISTITEM_START + 102) +#define LISTITEM_SUBTITLE_LANGUAGE (LISTITEM_START + 103) +#define LISTITEM_IS_FOLDER (LISTITEM_START + 104) +#define LISTITEM_ORIGINALTITLE (LISTITEM_START + 105) +#define LISTITEM_COUNTRY (LISTITEM_START + 106) +#define LISTITEM_PLAYCOUNT (LISTITEM_START + 107) +#define LISTITEM_LASTPLAYED (LISTITEM_START + 108) +#define LISTITEM_FOLDERPATH (LISTITEM_START + 109) +#define LISTITEM_DISC_NUMBER (LISTITEM_START + 110) +#define LISTITEM_FILE_EXTENSION (LISTITEM_START + 111) +#define LISTITEM_IS_RESUMABLE (LISTITEM_START + 112) +#define LISTITEM_PERCENT_PLAYED (LISTITEM_START + 113) +#define LISTITEM_DATE_ADDED (LISTITEM_START + 114) +#define LISTITEM_DBTYPE (LISTITEM_START + 115) +#define LISTITEM_DBID (LISTITEM_START + 116) +#define LISTITEM_ART (LISTITEM_START + 117) +#define LISTITEM_STARTTIME (LISTITEM_START + 118) +#define LISTITEM_ENDTIME (LISTITEM_START + 119) +#define LISTITEM_STARTDATE (LISTITEM_START + 120) +#define LISTITEM_ENDDATE (LISTITEM_START + 121) +#define LISTITEM_NEXT_TITLE (LISTITEM_START + 122) +#define LISTITEM_NEXT_GENRE (LISTITEM_START + 123) +#define LISTITEM_NEXT_PLOT (LISTITEM_START + 124) +#define LISTITEM_NEXT_PLOT_OUTLINE (LISTITEM_START + 125) +#define LISTITEM_NEXT_STARTTIME (LISTITEM_START + 126) +#define LISTITEM_NEXT_ENDTIME (LISTITEM_START + 127) +#define LISTITEM_NEXT_STARTDATE (LISTITEM_START + 128) +#define LISTITEM_NEXT_ENDDATE (LISTITEM_START + 129) +#define LISTITEM_NEXT_DURATION (LISTITEM_START + 130) +#define LISTITEM_CHANNEL_NAME (LISTITEM_START + 131) +#define LISTITEM_CHANNEL_GROUP (LISTITEM_START + 132) +#define LISTITEM_HASTIMER (LISTITEM_START + 133) +#define LISTITEM_ISRECORDING (LISTITEM_START + 134) +#define LISTITEM_ISENCRYPTED (LISTITEM_START + 135) +#define LISTITEM_PARENTAL_RATING (LISTITEM_START + 136) +#define LISTITEM_PROGRESS (LISTITEM_START + 137) +#define LISTITEM_HAS_EPG (LISTITEM_START + 138) +#define LISTITEM_VOTES (LISTITEM_START + 139) +#define LISTITEM_STEREOSCOPIC_MODE (LISTITEM_START + 140) +#define LISTITEM_IS_STEREOSCOPIC (LISTITEM_START + 141) +#define LISTITEM_INPROGRESS (LISTITEM_START + 142) +#define LISTITEM_HASRECORDING (LISTITEM_START + 143) +#define LISTITEM_HASREMINDER (LISTITEM_START + 144) +#define LISTITEM_CHANNEL_NUMBER (LISTITEM_START + 145) +#define LISTITEM_IMDBNUMBER (LISTITEM_START + 146) +#define LISTITEM_EPISODENAME (LISTITEM_START + 147) +#define LISTITEM_IS_COLLECTION (LISTITEM_START + 148) +#define LISTITEM_HASTIMERSCHEDULE (LISTITEM_START + 149) +#define LISTITEM_TIMERTYPE (LISTITEM_START + 150) +#define LISTITEM_EPG_EVENT_TITLE (LISTITEM_START + 151) +#define LISTITEM_DATETIME (LISTITEM_START + 152) +#define LISTITEM_USER_RATING (LISTITEM_START + 153) +#define LISTITEM_TAG (LISTITEM_START + 154) +#define LISTITEM_SET (LISTITEM_START + 155) +#define LISTITEM_SETID (LISTITEM_START + 156) +#define LISTITEM_IS_PARENTFOLDER (LISTITEM_START + 157) +#define LISTITEM_MOOD (LISTITEM_START + 158) +#define LISTITEM_CONTRIBUTORS (LISTITEM_START + 159) +#define LISTITEM_CONTRIBUTOR_AND_ROLE (LISTITEM_START + 160) +#define LISTITEM_TIMERISACTIVE (LISTITEM_START + 161) +#define LISTITEM_TIMERHASCONFLICT (LISTITEM_START + 162) +#define LISTITEM_TIMERHASERROR (LISTITEM_START + 163) + +#define LISTITEM_ADDON_NAME (LISTITEM_START + 164) +#define LISTITEM_ADDON_VERSION (LISTITEM_START + 165) +#define LISTITEM_ADDON_CREATOR (LISTITEM_START + 166) +#define LISTITEM_ADDON_SUMMARY (LISTITEM_START + 167) +#define LISTITEM_ADDON_DESCRIPTION (LISTITEM_START + 168) +#define LISTITEM_ADDON_DISCLAIMER (LISTITEM_START + 169) +#define LISTITEM_ADDON_BROKEN (LISTITEM_START + 170) +#define LISTITEM_ADDON_LIFECYCLE_TYPE (LISTITEM_START + 171) +#define LISTITEM_ADDON_LIFECYCLE_DESC (LISTITEM_START + 172) +#define LISTITEM_ADDON_TYPE (LISTITEM_START + 173) +#define LISTITEM_ADDON_INSTALL_DATE (LISTITEM_START + 174) +#define LISTITEM_ADDON_LAST_UPDATED (LISTITEM_START + 175) +#define LISTITEM_ADDON_LAST_USED (LISTITEM_START + 176) +#define LISTITEM_STATUS (LISTITEM_START + 177) +#define LISTITEM_ENDTIME_RESUME (LISTITEM_START + 178) +#define LISTITEM_ADDON_ORIGIN (LISTITEM_START + 179) +#define LISTITEM_ADDON_NEWS (LISTITEM_START + 180) +#define LISTITEM_ADDON_SIZE (LISTITEM_START + 181) +#define LISTITEM_EXPIRATION_DATE (LISTITEM_START + 182) +#define LISTITEM_EXPIRATION_TIME (LISTITEM_START + 183) +#define LISTITEM_PROPERTY (LISTITEM_START + 184) +#define LISTITEM_EPG_EVENT_ICON (LISTITEM_START + 185) +#define LISTITEM_HASREMINDERRULE (LISTITEM_START + 186) +#define LISTITEM_HASARCHIVE (LISTITEM_START + 187) +#define LISTITEM_ISPLAYABLE (LISTITEM_START + 188) +#define LISTITEM_FILENAME_NO_EXTENSION (LISTITEM_START + 189) +#define LISTITEM_CURRENTITEM (LISTITEM_START + 190) +#define LISTITEM_IS_NEW (LISTITEM_START + 191) +#define LISTITEM_DISC_TITLE (LISTITEM_START + 192) +#define LISTITEM_IS_BOXSET (LISTITEM_START + 193) +#define LISTITEM_TOTALDISCS (LISTITEM_START + 194) +#define LISTITEM_RELEASEDATE (LISTITEM_START + 195) +#define LISTITEM_ORIGINALDATE (LISTITEM_START + 196) +#define LISTITEM_BPM (LISTITEM_START + 197) +#define LISTITEM_UNIQUEID (LISTITEM_START + 198) +#define LISTITEM_BITRATE (LISTITEM_START + 199) +#define LISTITEM_SAMPLERATE (LISTITEM_START + 200) +#define LISTITEM_MUSICCHANNELS (LISTITEM_START + 201) +#define LISTITEM_IS_PREMIERE (LISTITEM_START + 202) +#define LISTITEM_IS_FINALE (LISTITEM_START + 203) +#define LISTITEM_IS_LIVE (LISTITEM_START + 204) +#define LISTITEM_TVSHOWDBID (LISTITEM_START + 205) +#define LISTITEM_ALBUMSTATUS (LISTITEM_START + 206) +#define LISTITEM_ISAUTOUPDATEABLE (LISTITEM_START + 207) +#define LISTITEM_VIDEO_HDR_TYPE (LISTITEM_START + 208) + +#define LISTITEM_END (LISTITEM_START + 2500) + +#define CONDITIONAL_LABEL_START (LISTITEM_END + 1) // 37501 +#define CONDITIONAL_LABEL_END 39999 + +// the multiple information vector +#define MULTI_INFO_START 40000 +#define MULTI_INFO_END 99999 +#define COMBINED_VALUES_START 100000 + +// listitem info Flags +// Stored in the top 8 bits of GUIInfo::m_data1 +// therefore we only have room for 8 flags +#define INFOFLAG_LISTITEM_WRAP (static_cast(1 << 25)) // Wrap ListItem lookups +#define INFOFLAG_LISTITEM_POSITION (static_cast(1 << 26)) // ListItem lookups based on cursor position +#define INFOFLAG_LISTITEM_ABSOLUTE (static_cast(1 << 27)) // Absolute ListItem lookups +#define INFOFLAG_LISTITEM_NOWRAP (static_cast(1 << 28)) // Do not wrap ListItem lookups +#define INFOFLAG_LISTITEM_CONTAINER (static_cast(1 << 29)) // Lookup the item in given container +// clang-format on diff --git a/xbmc/guilib/guiinfo/GUIInfoProvider.h b/xbmc/guilib/guiinfo/GUIInfoProvider.h new file mode 100644 index 0000000..a03159b --- /dev/null +++ b/xbmc/guilib/guiinfo/GUIInfoProvider.h @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "cores/VideoPlayer/Interface/StreamInfo.h" +#include "guilib/guiinfo/IGUIInfoProvider.h" + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +class CGUIInfo; + +class CGUIInfoProvider : public IGUIInfoProvider +{ +public: + CGUIInfoProvider() = default; + ~CGUIInfoProvider() override = default; + + bool GetFallbackLabel(std::string& value, + const CFileItem* item, + int contextWindow, + const CGUIInfo& info, + std::string* fallback) override + { + return false; + } + + void UpdateAVInfo(const AudioStreamInfo& audioInfo, const VideoStreamInfo& videoInfo, const SubtitleStreamInfo& subtitleInfo) override + { m_audioInfo = audioInfo, m_videoInfo = videoInfo, m_subtitleInfo = subtitleInfo; } + +protected: + VideoStreamInfo m_videoInfo; + AudioStreamInfo m_audioInfo; + SubtitleStreamInfo m_subtitleInfo; +}; + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI diff --git a/xbmc/guilib/guiinfo/GUIInfoProviders.cpp b/xbmc/guilib/guiinfo/GUIInfoProviders.cpp new file mode 100644 index 0000000..274318e --- /dev/null +++ b/xbmc/guilib/guiinfo/GUIInfoProviders.cpp @@ -0,0 +1,122 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "guilib/guiinfo/GUIInfoProviders.h" + +#include "guilib/guiinfo/IGUIInfoProvider.h" + +#include + +using namespace KODI::GUILIB::GUIINFO; + +CGUIInfoProviders::CGUIInfoProviders() +{ + RegisterProvider(&m_guiControlsGUIInfo); + RegisterProvider(&m_videoGUIInfo); // Note: video info provider must be registered before music info provider, + // because of music videos having both a video info tag and a music info tag + // and video info tag always has to be evaluated first. + RegisterProvider(&m_musicGUIInfo); + RegisterProvider(&m_picturesGUIInfo); + RegisterProvider(&m_playerGUIInfo); + RegisterProvider(&m_libraryGUIInfo); + RegisterProvider(&m_addonsGUIInfo); + RegisterProvider(&m_weatherGUIInfo); + RegisterProvider(&m_gamesGUIInfo); + RegisterProvider(&m_systemGUIInfo); + RegisterProvider(&m_visualisationGUIInfo); + RegisterProvider(&m_skinGUIInfo); +} + +CGUIInfoProviders::~CGUIInfoProviders() +{ + UnregisterProvider(&m_skinGUIInfo); + UnregisterProvider(&m_visualisationGUIInfo); + UnregisterProvider(&m_systemGUIInfo); + UnregisterProvider(&m_gamesGUIInfo); + UnregisterProvider(&m_weatherGUIInfo); + UnregisterProvider(&m_addonsGUIInfo); + UnregisterProvider(&m_libraryGUIInfo); + UnregisterProvider(&m_playerGUIInfo); + UnregisterProvider(&m_picturesGUIInfo); + UnregisterProvider(&m_musicGUIInfo); + UnregisterProvider(&m_videoGUIInfo); + UnregisterProvider(&m_guiControlsGUIInfo); +} + +void CGUIInfoProviders::RegisterProvider(IGUIInfoProvider *provider, bool bAppend /* = true */) +{ + auto it = std::find(m_providers.begin(), m_providers.end(), provider); + if (it == m_providers.end()) + { + if (bAppend) + m_providers.emplace_back(provider); + else + m_providers.insert(m_providers.begin(), provider); + } +} + +void CGUIInfoProviders::UnregisterProvider(IGUIInfoProvider *provider) +{ + auto it = std::find(m_providers.begin(), m_providers.end(), provider); + if (it != m_providers.end()) + m_providers.erase(it); +} + +bool CGUIInfoProviders::InitCurrentItem(CFileItem *item) +{ + bool bReturn = false; + + for (const auto& provider : m_providers) + { + bReturn = provider->InitCurrentItem(item); + } + return bReturn; +} + +bool CGUIInfoProviders::GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const +{ + for (const auto& provider : m_providers) + { + if (provider->GetLabel(value, item, contextWindow, info, fallback)) + return true; + } + for (const auto& provider : m_providers) + { + if (provider->GetFallbackLabel(value, item, contextWindow, info, fallback)) + return true; + } + return false; +} + +bool CGUIInfoProviders::GetInt(int& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const +{ + for (const auto& provider : m_providers) + { + if (provider->GetInt(value, item, contextWindow, info)) + return true; + } + return false; +} + +bool CGUIInfoProviders::GetBool(bool& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const +{ + for (const auto& provider : m_providers) + { + if (provider->GetBool(value, item, contextWindow, info)) + return true; + } + return false; +} + +void CGUIInfoProviders::UpdateAVInfo(const AudioStreamInfo& audioInfo, const VideoStreamInfo& videoInfo, const SubtitleStreamInfo& subtitleInfo) +{ + for (const auto& provider : m_providers) + { + provider->UpdateAVInfo(audioInfo, videoInfo, subtitleInfo); + } +} diff --git a/xbmc/guilib/guiinfo/GUIInfoProviders.h b/xbmc/guilib/guiinfo/GUIInfoProviders.h new file mode 100644 index 0000000..1aed710 --- /dev/null +++ b/xbmc/guilib/guiinfo/GUIInfoProviders.h @@ -0,0 +1,157 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "guilib/guiinfo/AddonsGUIInfo.h" +#include "guilib/guiinfo/GUIControlsGUIInfo.h" +#include "guilib/guiinfo/GamesGUIInfo.h" +#include "guilib/guiinfo/LibraryGUIInfo.h" +#include "guilib/guiinfo/MusicGUIInfo.h" +#include "guilib/guiinfo/PicturesGUIInfo.h" +#include "guilib/guiinfo/PlayerGUIInfo.h" +#include "guilib/guiinfo/SkinGUIInfo.h" +#include "guilib/guiinfo/SystemGUIInfo.h" +#include "guilib/guiinfo/VideoGUIInfo.h" +#include "guilib/guiinfo/VisualisationGUIInfo.h" +#include "guilib/guiinfo/WeatherGUIInfo.h" + +#include +#include + +class CFileItem; +class CGUIListItem; + +struct AudioStreamInfo; +struct VideoStreamInfo; + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +class CGUIInfo; +class IGUIInfoProvider; + +class CGUIInfoProviders +{ +public: + CGUIInfoProviders(); + virtual ~CGUIInfoProviders(); + + /*! + * @brief Register a guiinfo provider. + * @param provider The provider to register. + * @param bAppend True to append to the list of providers, false to insert before the first provider + */ + void RegisterProvider(IGUIInfoProvider *provider, bool bAppend = true); + + /*! + * @brief Unregister a guiinfo provider. + * @param provider The provider to unregister. + */ + void UnregisterProvider(IGUIInfoProvider *provider); + + /*! + * @brief Init a new current guiinfo manager item. Gets called whenever the active guiinfo manager item changes. + * @param item The new item. + * @return True if the item was inited by one of the providers, false otherwise. + */ + bool InitCurrentItem(CFileItem *item); + + /*! + * @brief Get a GUIInfoManager label string from one of the registered providers. + * @param value Will be filled with the requested value. + * @param item The item to get the value for. Can be nullptr. + * @param contextWindow The context window. Can be 0. + * @param info The GUI info (label id + additional data). + * @param fallback A fallback value. Can be nullptr. + * @return True if the value was filled successfully by one of the providers, false otherwise. + */ + bool GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const; + + /*! + * @brief Get a GUIInfoManager integer value from one of the registered providers. + * @param value Will be filled with the requested value. + * @param item The item to get the value for. Can be nullptr. + * @param contextWindow The context window. Can be 0. + * @param info The GUI info (label id + additional data). + * @return True if the value was filled successfully by one of the providers, false otherwise. + */ + bool GetInt(int& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const; + + /*! + * @brief Get a GUIInfoManager bool value from one of the registered providers. + * @param value Will be filled with the requested value. + * @param item The item to get the value for. Can be nullptr. + * @param contextWindow The context window. Can be 0. + * @param info The GUI info (label id + additional data). + * @return True if the value was filled successfully by one of the providers, false otherwise. + */ + bool GetBool(bool& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const; + + /*! + * @brief Set new audio/video/subtitle stream info data at all registered providers. + * @param audioInfo New audio stream info. + * @param videoInfo New video stream info. + * @param subtitleInfo New subtitle stream info. + */ + void UpdateAVInfo(const AudioStreamInfo& audioInfo, const VideoStreamInfo& videoInfo, const SubtitleStreamInfo& subtitleInfo); + + /*! + * @brief Get the player guiinfo provider. + * @return The player guiinfo provider. + */ + CPlayerGUIInfo& GetPlayerInfoProvider() { return m_playerGUIInfo; } + + /*! + * @brief Get the system guiinfo provider. + * @return The system guiinfo provider. + */ + CSystemGUIInfo& GetSystemInfoProvider() { return m_systemGUIInfo; } + + /*! + * @brief Get the pictures guiinfo provider. + * @return The pictures guiinfo provider. + */ + CPicturesGUIInfo& GetPicturesInfoProvider() { return m_picturesGUIInfo; } + + /*! + * @brief Get the gui controls guiinfo provider. + * @return The gui controls guiinfo provider. + */ + CGUIControlsGUIInfo& GetGUIControlsInfoProvider() { return m_guiControlsGUIInfo; } + + /*! + * @brief Get the library guiinfo provider. + * @return The library guiinfo provider. + */ + CLibraryGUIInfo& GetLibraryInfoProvider() { return m_libraryGUIInfo; } + +private: + std::vector m_providers; + + CAddonsGUIInfo m_addonsGUIInfo; + CGamesGUIInfo m_gamesGUIInfo; + CGUIControlsGUIInfo m_guiControlsGUIInfo; + CLibraryGUIInfo m_libraryGUIInfo; + CMusicGUIInfo m_musicGUIInfo; + CPicturesGUIInfo m_picturesGUIInfo; + CPlayerGUIInfo m_playerGUIInfo; + CSkinGUIInfo m_skinGUIInfo; + CSystemGUIInfo m_systemGUIInfo; + CVideoGUIInfo m_videoGUIInfo; + CVisualisationGUIInfo m_visualisationGUIInfo; + CWeatherGUIInfo m_weatherGUIInfo; +}; + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI diff --git a/xbmc/guilib/guiinfo/GamesGUIInfo.cpp b/xbmc/guilib/guiinfo/GamesGUIInfo.cpp new file mode 100644 index 0000000..5428c3a --- /dev/null +++ b/xbmc/guilib/guiinfo/GamesGUIInfo.cpp @@ -0,0 +1,87 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "guilib/guiinfo/GamesGUIInfo.h" + +#include "FileItem.h" +#include "Util.h" +#include "cores/RetroPlayer/RetroPlayerUtils.h" +#include "games/tags/GameInfoTag.h" +#include "guilib/guiinfo/GUIInfo.h" +#include "guilib/guiinfo/GUIInfoLabels.h" +#include "settings/MediaSettings.h" +#include "utils/StringUtils.h" +#include "utils/Variant.h" +#include "utils/log.h" + +using namespace KODI::GUILIB::GUIINFO; +using namespace KODI::GAME; +using namespace KODI::RETRO; + +//! @todo Savestates were removed from v18 +//#define FILEITEM_PROPERTY_SAVESTATE_DURATION "duration" + +bool CGamesGUIInfo::InitCurrentItem(CFileItem *item) +{ + if (item && item->IsGame()) + { + CLog::Log(LOGDEBUG, "CGamesGUIInfo::InitCurrentItem({})", item->GetPath()); + + item->LoadGameTag(); + CGameInfoTag* tag = item->GetGameInfoTag(); // creates item if not yet set, so no nullptr checks needed + + if (tag->GetTitle().empty()) + { + // No title in tag, show filename only + tag->SetTitle(CUtil::GetTitleFromPath(item->GetPath())); + } + return true; + } + return false; +} + +bool CGamesGUIInfo::GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const +{ + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // RETROPLAYER_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case RETROPLAYER_VIDEO_FILTER: + { + value = CMediaSettings::GetInstance().GetCurrentGameSettings().VideoFilter(); + return true; + } + case RETROPLAYER_STRETCH_MODE: + { + STRETCHMODE stretchMode = CMediaSettings::GetInstance().GetCurrentGameSettings().StretchMode(); + value = CRetroPlayerUtils::StretchModeToIdentifier(stretchMode); + return true; + } + case RETROPLAYER_VIDEO_ROTATION: + { + const unsigned int rotationDegCCW = CMediaSettings::GetInstance().GetCurrentGameSettings().RotationDegCCW(); + value = std::to_string(rotationDegCCW); + return true; + } + default: + break; + } + + return false; +} + +bool CGamesGUIInfo::GetInt(int& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + return false; +} + +bool CGamesGUIInfo::GetBool(bool& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + return false; +} diff --git a/xbmc/guilib/guiinfo/GamesGUIInfo.h b/xbmc/guilib/guiinfo/GamesGUIInfo.h new file mode 100644 index 0000000..5ad78d9 --- /dev/null +++ b/xbmc/guilib/guiinfo/GamesGUIInfo.h @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "guilib/guiinfo/GUIInfoProvider.h" + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +class CGUIInfo; + +class CGamesGUIInfo : public CGUIInfoProvider +{ +public: + CGamesGUIInfo() = default; + ~CGamesGUIInfo() override = default; + + // KODI::GUILIB::GUIINFO::IGUIInfoProvider implementation + bool InitCurrentItem(CFileItem *item) override; + bool GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const override; + bool GetInt(int& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; + bool GetBool(bool& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; +}; + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI diff --git a/xbmc/guilib/guiinfo/IGUIInfoProvider.h b/xbmc/guilib/guiinfo/IGUIInfoProvider.h new file mode 100644 index 0000000..4560b08 --- /dev/null +++ b/xbmc/guilib/guiinfo/IGUIInfoProvider.h @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include + +class CFileItem; +class CGUIListItem; + +struct AudioStreamInfo; +struct VideoStreamInfo; + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +class CGUIInfo; + +class IGUIInfoProvider +{ +public: + virtual ~IGUIInfoProvider() = default; + + /*! + * @brief Init a new current guiinfo manager item. Gets called whenever the active guiinfo manager item changes. + * @param item The new item. + * @return True if the item was inited by the provider, false otherwise. + */ + virtual bool InitCurrentItem(CFileItem *item) = 0; + + /*! + * @brief Get a GUIInfoManager label string. + * @param value Will be filled with the requested value. + * @param item The item to get the value for. Can be nullptr. + * @param contextWindow The context window. Can be 0. + * @param info The GUI info (label id + additional data). + * @param fallback A fallback value. Can be nullptr. + * @return True if the value was filled successfully, false otherwise. + */ + virtual bool GetLabel(std::string &value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const = 0; + + /*! + * @brief Get a GUIInfoManager label fallback string. Will be called if none of the registered + * provider's GetLabel() implementation has returned success. + * @param value Will be filled with the requested value. + * @param item The item to get the value for. Can be nullptr. + * @param contextWindow The context window. Can be 0. + * @param info The GUI info (label id + additional data). + * @param fallback A fallback value. Can be nullptr. + * @return True if the value was filled successfully, false otherwise. + */ + virtual bool GetFallbackLabel(std::string& value, + const CFileItem* item, + int contextWindow, + const CGUIInfo& info, + std::string* fallback) = 0; + + /*! + * @brief Get a GUIInfoManager integer value. + * @param value Will be filled with the requested value. + * @param item The item to get the value for. Can be nullptr. + * @param contextWindow The context window. Can be 0. + * @param info The GUI info (label id + additional data). + * @return True if the value was filled successfully, false otherwise. + */ + virtual bool GetInt(int& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const = 0; + + /*! + * @brief Get a GUIInfoManager bool value. + * @param value Will be filled with the requested value. + * @param item The item to get the value for. Can be nullptr. + * @param contextWindow The context window. Can be 0. + * @param info The GUI info (label id + additional data). + * @return True if the value was filled successfully, false otherwise. + */ + virtual bool GetBool(bool& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const = 0; + + /*! + * @brief Set new audio/video stream info data. + * @param audioInfo New audio stream info. + * @param videoInfo New video stream info. + */ + virtual void UpdateAVInfo(const AudioStreamInfo& audioInfo, const VideoStreamInfo& videoInfo, const SubtitleStreamInfo& subtitleInfo) = 0; +}; + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI diff --git a/xbmc/guilib/guiinfo/LibraryGUIInfo.cpp b/xbmc/guilib/guiinfo/LibraryGUIInfo.cpp new file mode 100644 index 0000000..fc0f471 --- /dev/null +++ b/xbmc/guilib/guiinfo/LibraryGUIInfo.cpp @@ -0,0 +1,290 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "guilib/guiinfo/LibraryGUIInfo.h" + +#include "FileItem.h" +#include "ServiceBroker.h" +#include "URL.h" +#include "filesystem/Directory.h" +#include "guilib/guiinfo/GUIInfo.h" +#include "guilib/guiinfo/GUIInfoLabels.h" +#include "music/MusicDatabase.h" +#include "music/MusicLibraryQueue.h" +#include "profiles/ProfileManager.h" +#include "settings/SettingsComponent.h" +#include "utils/FileUtils.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" +#include "video/VideoDatabase.h" +#include "video/VideoLibraryQueue.h" + +using namespace KODI::GUILIB::GUIINFO; + +CLibraryGUIInfo::CLibraryGUIInfo() +{ + ResetLibraryBools(); +} + +bool CLibraryGUIInfo::GetLibraryBool(int condition) const +{ + bool value = false; + GetBool(value, nullptr, 0, CGUIInfo(condition)); + return value; +} + +void CLibraryGUIInfo::SetLibraryBool(int condition, bool value) +{ + switch (condition) + { + case LIBRARY_HAS_MUSIC: + m_libraryHasMusic = value ? 1 : 0; + break; + case LIBRARY_HAS_MOVIES: + m_libraryHasMovies = value ? 1 : 0; + break; + case LIBRARY_HAS_MOVIE_SETS: + m_libraryHasMovieSets = value ? 1 : 0; + break; + case LIBRARY_HAS_TVSHOWS: + m_libraryHasTVShows = value ? 1 : 0; + break; + case LIBRARY_HAS_MUSICVIDEOS: + m_libraryHasMusicVideos = value ? 1 : 0; + break; + case LIBRARY_HAS_SINGLES: + m_libraryHasSingles = value ? 1 : 0; + break; + case LIBRARY_HAS_COMPILATIONS: + m_libraryHasCompilations = value ? 1 : 0; + break; + case LIBRARY_HAS_BOXSETS: + m_libraryHasBoxsets = value ? 1 : 0; + break; + default: + break; + } +} + +void CLibraryGUIInfo::ResetLibraryBools() +{ + m_libraryHasMusic = -1; + m_libraryHasMovies = -1; + m_libraryHasTVShows = -1; + m_libraryHasMusicVideos = -1; + m_libraryHasMovieSets = -1; + m_libraryHasSingles = -1; + m_libraryHasCompilations = -1; + m_libraryHasBoxsets = -1; + m_libraryRoleCounts.clear(); +} + +bool CLibraryGUIInfo::InitCurrentItem(CFileItem *item) +{ + return false; +} + +bool CLibraryGUIInfo::GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const +{ + return false; +} + +bool CLibraryGUIInfo::GetInt(int& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + return false; +} + +bool CLibraryGUIInfo::GetBool(bool& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // LIBRARY_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case LIBRARY_HAS_MUSIC: + { + if (m_libraryHasMusic < 0) + { // query + CMusicDatabase db; + if (db.Open()) + { + m_libraryHasMusic = (db.GetSongsCount() > 0) ? 1 : 0; + db.Close(); + } + } + value = m_libraryHasMusic > 0; + return true; + } + case LIBRARY_HAS_MOVIES: + { + if (m_libraryHasMovies < 0) + { + CVideoDatabase db; + if (db.Open()) + { + m_libraryHasMovies = db.HasContent(VideoDbContentType::MOVIES) ? 1 : 0; + db.Close(); + } + } + value = m_libraryHasMovies > 0; + return true; + } + case LIBRARY_HAS_MOVIE_SETS: + { + if (m_libraryHasMovieSets < 0) + { + CVideoDatabase db; + if (db.Open()) + { + m_libraryHasMovieSets = db.HasSets() ? 1 : 0; + db.Close(); + } + } + value = m_libraryHasMovieSets > 0; + return true; + } + case LIBRARY_HAS_TVSHOWS: + { + if (m_libraryHasTVShows < 0) + { + CVideoDatabase db; + if (db.Open()) + { + m_libraryHasTVShows = db.HasContent(VideoDbContentType::TVSHOWS) ? 1 : 0; + db.Close(); + } + } + value = m_libraryHasTVShows > 0; + return true; + } + case LIBRARY_HAS_MUSICVIDEOS: + { + if (m_libraryHasMusicVideos < 0) + { + CVideoDatabase db; + if (db.Open()) + { + m_libraryHasMusicVideos = db.HasContent(VideoDbContentType::MUSICVIDEOS) ? 1 : 0; + db.Close(); + } + } + value = m_libraryHasMusicVideos > 0; + return true; + } + case LIBRARY_HAS_SINGLES: + { + if (m_libraryHasSingles < 0) + { + CMusicDatabase db; + if (db.Open()) + { + m_libraryHasSingles = (db.GetSinglesCount() > 0) ? 1 : 0; + db.Close(); + } + } + value = m_libraryHasSingles > 0; + return true; + } + case LIBRARY_HAS_COMPILATIONS: + { + if (m_libraryHasCompilations < 0) + { + CMusicDatabase db; + if (db.Open()) + { + m_libraryHasCompilations = (db.GetCompilationAlbumsCount() > 0) ? 1 : 0; + db.Close(); + } + } + value = m_libraryHasCompilations > 0; + return true; + } + case LIBRARY_HAS_BOXSETS: + { + if (m_libraryHasBoxsets < 0) + { + CMusicDatabase db; + if (db.Open()) + { + m_libraryHasBoxsets = (db.GetBoxsetsCount() > 0) ? 1 : 0; + db.Close(); + } + } + value = m_libraryHasBoxsets > 0; + return true; + } + case LIBRARY_HAS_VIDEO: + { + return (GetBool(value, gitem, contextWindow, CGUIInfo(LIBRARY_HAS_MOVIES)) || + GetBool(value, gitem, contextWindow, CGUIInfo(LIBRARY_HAS_TVSHOWS)) || + GetBool(value, gitem, contextWindow, CGUIInfo(LIBRARY_HAS_MUSICVIDEOS))); + } + case LIBRARY_HAS_ROLE: + { + std::string strRole = info.GetData3(); + // Find value for role if already stored + int artistcount = -1; + for (const auto &role : m_libraryRoleCounts) + { + if (StringUtils::EqualsNoCase(strRole, role.first)) + { + artistcount = role.second; + break; + } + } + // Otherwise get from DB and store + if (artistcount < 0) + { + CMusicDatabase db; + if (db.Open()) + { + artistcount = db.GetArtistCountForRole(strRole); + db.Close(); + m_libraryRoleCounts.emplace_back(std::make_pair(strRole, artistcount)); + } + } + value = artistcount > 0; + return true; + } + case LIBRARY_HAS_NODE: + { + const CURL url(info.GetData3()); + const std::shared_ptr profileManager = + CServiceBroker::GetSettingsComponent()->GetProfileManager(); + CFileItemList items; + + std::string libDir = profileManager->GetLibraryFolder(); + XFILE::CDirectory::GetDirectory(libDir, items, "", XFILE::DIR_FLAG_NO_FILE_DIRS); + if (items.Size() == 0) + libDir = "special://xbmc/system/library/"; + + std::string nodePath = URIUtils::AddFileToFolder(libDir, url.GetHostName() + "/"); + nodePath = URIUtils::AddFileToFolder(nodePath, url.GetFileName()); + value = CFileUtils::Exists(nodePath); + return true; + } + case LIBRARY_IS_SCANNING: + { + value = (CMusicLibraryQueue::GetInstance().IsScanningLibrary() || + CVideoLibraryQueue::GetInstance().IsScanningLibrary()); + return true; + } + case LIBRARY_IS_SCANNING_VIDEO: + { + value = CVideoLibraryQueue::GetInstance().IsScanningLibrary(); + return true; + } + case LIBRARY_IS_SCANNING_MUSIC: + { + value = CMusicLibraryQueue::GetInstance().IsScanningLibrary(); + return true; + } + } + + return false; +} diff --git a/xbmc/guilib/guiinfo/LibraryGUIInfo.h b/xbmc/guilib/guiinfo/LibraryGUIInfo.h new file mode 100644 index 0000000..a9d47fc --- /dev/null +++ b/xbmc/guilib/guiinfo/LibraryGUIInfo.h @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "guilib/guiinfo/GUIInfoProvider.h" + +#include +#include +#include + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +class CGUIInfo; + +class CLibraryGUIInfo : public CGUIInfoProvider +{ +public: + CLibraryGUIInfo(); + ~CLibraryGUIInfo() override = default; + + // KODI::GUILIB::GUIINFO::IGUIInfoProvider implementation + bool InitCurrentItem(CFileItem *item) override; + bool GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const override; + bool GetInt(int& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; + bool GetBool(bool& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; + + bool GetLibraryBool(int condition) const; + void SetLibraryBool(int condition, bool value); + void ResetLibraryBools(); + +private: + mutable int m_libraryHasMusic; + mutable int m_libraryHasMovies; + mutable int m_libraryHasTVShows; + mutable int m_libraryHasMusicVideos; + mutable int m_libraryHasMovieSets; + mutable int m_libraryHasSingles; + mutable int m_libraryHasCompilations; + mutable int m_libraryHasBoxsets; + + //Count of artists in music library contributing to song by role e.g. composers, conductors etc. + //For checking visibility of custom nodes for a role. + mutable std::vector> m_libraryRoleCounts; +}; + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI diff --git a/xbmc/guilib/guiinfo/MusicGUIInfo.cpp b/xbmc/guilib/guiinfo/MusicGUIInfo.cpp new file mode 100644 index 0000000..f58a9ae --- /dev/null +++ b/xbmc/guilib/guiinfo/MusicGUIInfo.cpp @@ -0,0 +1,713 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "guilib/guiinfo/MusicGUIInfo.h" + +#include "FileItem.h" +#include "PartyModeManager.h" +#include "PlayListPlayer.h" +#include "ServiceBroker.h" +#include "URL.h" +#include "Util.h" +#include "application/Application.h" +#include "application/ApplicationComponents.h" +#include "application/ApplicationPlayer.h" +#include "guilib/LocalizeStrings.h" +#include "guilib/guiinfo/GUIInfo.h" +#include "guilib/guiinfo/GUIInfoHelper.h" +#include "guilib/guiinfo/GUIInfoLabels.h" +#include "music/MusicInfoLoader.h" +#include "music/MusicThumbLoader.h" +#include "music/tags/MusicInfoTag.h" +#include "playlists/PlayList.h" +#include "settings/AdvancedSettings.h" +#include "settings/SettingsComponent.h" +#include "utils/URIUtils.h" +#include "utils/log.h" + +using namespace KODI::GUILIB; +using namespace KODI::GUILIB::GUIINFO; +using namespace MUSIC_INFO; + +bool CMusicGUIInfo::InitCurrentItem(CFileItem *item) +{ + const auto& components = CServiceBroker::GetAppComponents(); + const auto appPlayer = components.GetComponent(); + if (item && (item->IsAudio() || (item->IsInternetStream() && appPlayer->IsPlayingAudio()))) + { + CLog::Log(LOGDEBUG, "CMusicGUIInfo::InitCurrentItem({})", item->GetPath()); + + item->LoadMusicTag(); + + CMusicInfoTag* tag = item->GetMusicInfoTag(); // creates item if not yet set, so no nullptr checks needed + tag->SetLoaded(true); + + // find a thumb for this file. + if (item->IsInternetStream() && !item->IsMusicDb()) + { + if (!g_application.m_strPlayListFile.empty()) + { + CLog::Log(LOGDEBUG, "Streaming media detected... using {} to find a thumb", + g_application.m_strPlayListFile); + CFileItem streamingItem(g_application.m_strPlayListFile,false); + + CMusicThumbLoader loader; + loader.FillThumb(streamingItem); + if (streamingItem.HasArt("thumb")) + item->SetArt("thumb", streamingItem.GetArt("thumb")); + } + } + else + { + CMusicThumbLoader loader; + loader.LoadItem(item); + } + + CMusicInfoLoader::LoadAdditionalTagInfo(item); + return true; + } + return false; +} + +bool CMusicGUIInfo::GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const +{ + // For musicplayer "offset" and "position" info labels check playlist + if (info.GetData1() && ((info.m_info >= MUSICPLAYER_OFFSET_POSITION_FIRST && + info.m_info <= MUSICPLAYER_OFFSET_POSITION_LAST) || + (info.m_info >= PLAYER_OFFSET_POSITION_FIRST && info.m_info <= PLAYER_OFFSET_POSITION_LAST))) + return GetPlaylistInfo(value, info); + + const CMusicInfoTag* tag = item->GetMusicInfoTag(); + if (tag) + { + switch (info.m_info) + { + ///////////////////////////////////////////////////////////////////////////////////////////// + // PLAYER_* / MUSICPLAYER_* / LISTITEM_* + ///////////////////////////////////////////////////////////////////////////////////////////// + case PLAYER_PATH: + case PLAYER_FILENAME: + case PLAYER_FILEPATH: + value = tag->GetURL(); + if (value.empty()) + value = item->GetPath(); + value = GUIINFO::GetFileInfoLabelValueFromPath(info.m_info, value); + return true; + case PLAYER_TITLE: + value = tag->GetTitle(); + return !value.empty(); + case MUSICPLAYER_TITLE: + value = tag->GetTitle(); + return !value.empty(); + case LISTITEM_TITLE: + value = tag->GetTitle(); + return true; + case MUSICPLAYER_PLAYCOUNT: + case LISTITEM_PLAYCOUNT: + if (tag->GetPlayCount() > 0) + { + value = std::to_string(tag->GetPlayCount()); + return true; + } + break; + case MUSICPLAYER_LASTPLAYED: + case LISTITEM_LASTPLAYED: + { + const CDateTime& dateTime = tag->GetLastPlayed(); + if (dateTime.IsValid()) + { + value = dateTime.GetAsLocalizedDate(); + return true; + } + break; + } + case MUSICPLAYER_TRACK_NUMBER: + case LISTITEM_TRACKNUMBER: + if (tag->Loaded() && tag->GetTrackNumber() > 0) + { + value = StringUtils::Format("{:02}", tag->GetTrackNumber()); + return true; + } + break; + case MUSICPLAYER_DISC_NUMBER: + case LISTITEM_DISC_NUMBER: + if (tag->GetDiscNumber() > 0) + { + value = std::to_string(tag->GetDiscNumber()); + return true; + } + break; + case MUSICPLAYER_TOTALDISCS: + case LISTITEM_TOTALDISCS: + value = std::to_string(tag->GetTotalDiscs()); + return true; + case MUSICPLAYER_DISC_TITLE: + case LISTITEM_DISC_TITLE: + value = tag->GetDiscSubtitle(); + return true; + case MUSICPLAYER_ARTIST: + case LISTITEM_ARTIST: + value = tag->GetArtistString(); + return true; + case MUSICPLAYER_ALBUM_ARTIST: + case LISTITEM_ALBUM_ARTIST: + value = tag->GetAlbumArtistString(); + return true; + case MUSICPLAYER_CONTRIBUTORS: + case LISTITEM_CONTRIBUTORS: + if (tag->HasContributors()) + { + value = tag->GetContributorsText(); + return true; + } + break; + case MUSICPLAYER_CONTRIBUTOR_AND_ROLE: + case LISTITEM_CONTRIBUTOR_AND_ROLE: + if (tag->HasContributors()) + { + value = tag->GetContributorsAndRolesText(); + return true; + } + break; + case MUSICPLAYER_ALBUM: + case LISTITEM_ALBUM: + value = tag->GetAlbum(); + return true; + case MUSICPLAYER_YEAR: + case LISTITEM_YEAR: + value = tag->GetYearString(); + return true; + case MUSICPLAYER_GENRE: + case LISTITEM_GENRE: + value = StringUtils::Join(tag->GetGenre(), CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_musicItemSeparator); + return true; + case MUSICPLAYER_LYRICS: + value = tag->GetLyrics(); + return true; + case MUSICPLAYER_RATING: + case LISTITEM_RATING: + { + float rating = tag->GetRating(); + if (rating > 0.f) + { + value = StringUtils::FormatNumber(rating); + return true; + } + break; + } + case MUSICPLAYER_RATING_AND_VOTES: + case LISTITEM_RATING_AND_VOTES: + { + float rating = tag->GetRating(); + if (rating > 0.f) + { + int votes = tag->GetVotes(); + if (votes <= 0) + value = StringUtils::FormatNumber(rating); + else + value = + StringUtils::Format(g_localizeStrings.Get(20350), StringUtils::FormatNumber(rating), + StringUtils::FormatNumber(votes)); + return true; + } + break; + } + case MUSICPLAYER_USER_RATING: + case LISTITEM_USER_RATING: + if (tag->GetUserrating() > 0) + { + value = std::to_string(tag->GetUserrating()); + return true; + } + break; + case MUSICPLAYER_COMMENT: + case LISTITEM_COMMENT: + value = tag->GetComment(); + return true; + case MUSICPLAYER_MOOD: + case LISTITEM_MOOD: + value = tag->GetMood(); + return true; + case LISTITEM_DBTYPE: + value = tag->GetType(); + return true; + case MUSICPLAYER_DBID: + case LISTITEM_DBID: + { + int dbId = tag->GetDatabaseId(); + if (dbId > -1) + { + value = std::to_string(dbId); + return true; + } + break; + } + case PLAYER_DURATION: + { + const auto& components = CServiceBroker::GetAppComponents(); + const auto appPlayer = components.GetComponent(); + if (!appPlayer->IsPlayingAudio()) + break; + } + [[fallthrough]]; + case MUSICPLAYER_DURATION: + case LISTITEM_DURATION: + { + int iDuration = tag->GetDuration(); + if (iDuration > 0) + { + value = StringUtils::SecondsToTimeString(iDuration, + static_cast(info.m_info == LISTITEM_DURATION + ? info.GetData4() + : info.GetData1())); + return true; + } + break; + } + case MUSICPLAYER_BPM: + case LISTITEM_BPM: + if (tag->GetBPM() > 0) + { + value = std::to_string(tag->GetBPM()); + return true; + } + break; + case MUSICPLAYER_STATIONNAME: + // This property can be used for example by addons to enforce/override the station name. + value = item->GetProperty("StationName").asString(); + if (value.empty()) + value = tag->GetStationName(); + return true; + + ///////////////////////////////////////////////////////////////////////////////////////////// + // LISTITEM_* + ///////////////////////////////////////////////////////////////////////////////////////////// + case LISTITEM_PROPERTY: + if (StringUtils::StartsWithNoCase(info.GetData3(), "Role.")) + { + // "Role.xxxx" properties are held in music tag + std::string property = info.GetData3(); + property.erase(0, 5); //Remove Role. + value = tag->GetArtistStringForRole(property); + return true; + } + break; + case LISTITEM_VOTES: + value = StringUtils::FormatNumber(tag->GetVotes()); + return true; + case MUSICPLAYER_ORIGINALDATE: + case LISTITEM_ORIGINALDATE: + { + value = tag->GetOriginalDate(); + if (!CServiceBroker::GetSettingsComponent() + ->GetAdvancedSettings() + ->m_bMusicLibraryUseISODates) + value = StringUtils::ISODateToLocalizedDate(value); + return true; + } + case MUSICPLAYER_RELEASEDATE: + case LISTITEM_RELEASEDATE: + { + value = tag->GetReleaseDate(); + if (!CServiceBroker::GetSettingsComponent() + ->GetAdvancedSettings() + ->m_bMusicLibraryUseISODates) + value = StringUtils::ISODateToLocalizedDate(value); + return true; + } + break; + case LISTITEM_BITRATE: + { + int BitRate = tag->GetBitRate(); + if (BitRate > 0) + { + value = std::to_string(BitRate); + return true; + } + break; + } + case LISTITEM_SAMPLERATE: + { + int sampleRate = tag->GetSampleRate(); + if (sampleRate > 0) + { + value = StringUtils::Format("{:.5}", static_cast(sampleRate) / 1000.0); + return true; + } + break; + } + case LISTITEM_MUSICCHANNELS: + { + int channels = tag->GetNoOfChannels(); + if (channels > 0) + { + value = std::to_string(channels); + return true; + } + break; + } + case LISTITEM_ALBUMSTATUS: + value = tag->GetAlbumReleaseStatus(); + return true; + case LISTITEM_FILENAME: + case LISTITEM_FILE_EXTENSION: + if (item->IsMusicDb()) + value = URIUtils::GetFileName(tag->GetURL()); + else if (item->HasVideoInfoTag()) // special handling for music videos, which have both a videotag and a musictag + break; + else + value = URIUtils::GetFileName(item->GetPath()); + + if (info.m_info == LISTITEM_FILE_EXTENSION) + { + std::string strExtension = URIUtils::GetExtension(value); + value = StringUtils::TrimLeft(strExtension, "."); + } + return true; + case LISTITEM_FOLDERNAME: + case LISTITEM_PATH: + if (item->IsMusicDb()) + value = URIUtils::GetDirectory(tag->GetURL()); + else if (item->HasVideoInfoTag()) // special handling for music videos, which have both a videotag and a musictag + break; + else + URIUtils::GetParentPath(item->GetPath(), value); + + value = CURL(value).GetWithoutUserDetails(); + + if (info.m_info == LISTITEM_FOLDERNAME) + { + URIUtils::RemoveSlashAtEnd(value); + value = URIUtils::GetFileName(value); + } + return true; + case LISTITEM_FILENAME_AND_PATH: + if (item->IsMusicDb()) + value = tag->GetURL(); + else if (item->HasVideoInfoTag()) // special handling for music videos, which have both a videotag and a musictag + break; + else + value = item->GetPath(); + + value = CURL(value).GetWithoutUserDetails(); + return true; + case LISTITEM_DATE_ADDED: + if (tag->GetDateAdded().IsValid()) + { + value = tag->GetDateAdded().GetAsLocalizedDate(); + return true; + } + break; + } + } + + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // MUSICPLAYER_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case MUSICPLAYER_PROPERTY: + if (StringUtils::StartsWithNoCase(info.GetData3(), "Role.") && item->HasMusicInfoTag()) + { + // "Role.xxxx" properties are held in music tag + std::string property = info.GetData3(); + property.erase(0, 5); //Remove Role. + value = item->GetMusicInfoTag()->GetArtistStringForRole(property); + return true; + } + value = item->GetProperty(info.GetData3()).asString(); + return true; + case MUSICPLAYER_PLAYLISTLEN: + if (CServiceBroker::GetPlaylistPlayer().GetCurrentPlaylist() == PLAYLIST::TYPE_MUSIC) + { + value = GUIINFO::GetPlaylistLabel(PLAYLIST_LENGTH); + return true; + } + break; + case MUSICPLAYER_PLAYLISTPOS: + if (CServiceBroker::GetPlaylistPlayer().GetCurrentPlaylist() == PLAYLIST::TYPE_MUSIC) + { + value = GUIINFO::GetPlaylistLabel(PLAYLIST_POSITION); + return true; + } + break; + case MUSICPLAYER_COVER: + { + const auto& components = CServiceBroker::GetAppComponents(); + const auto appPlayer = components.GetComponent(); + if (appPlayer->IsPlayingAudio()) + { + if (fallback) + *fallback = "DefaultAlbumCover.png"; + value = item->HasArt("thumb") ? item->GetArt("thumb") : "DefaultAlbumCover.png"; + return true; + } + break; + } + case MUSICPLAYER_BITRATE: + { + int iBitrate = m_audioInfo.bitrate; + if (iBitrate > 0) + { + value = std::to_string(std::lrint(static_cast(iBitrate) / 1000.0)); + return true; + } + break; + } + case MUSICPLAYER_CHANNELS: + { + int iChannels = m_audioInfo.channels; + if (iChannels > 0) + { + value = std::to_string(iChannels); + return true; + } + break; + } + case MUSICPLAYER_BITSPERSAMPLE: + { + int iBPS = m_audioInfo.bitspersample; + if (iBPS > 0) + { + value = std::to_string(iBPS); + return true; + } + break; + } + case MUSICPLAYER_SAMPLERATE: + { + int iSamplerate = m_audioInfo.samplerate; + if (iSamplerate > 0) + { + value = StringUtils::Format("{:.5}", static_cast(iSamplerate) / 1000.0); + return true; + } + break; + } + case MUSICPLAYER_CODEC: + value = m_audioInfo.codecName; + return true; + } + + /////////////////////////////////////////////////////////////////////////////////////////////// + // MUSICPM_* + /////////////////////////////////////////////////////////////////////////////////////////////// + if (GetPartyModeLabel(value, info)) + return true; + + return false; +} + +bool CMusicGUIInfo::GetPartyModeLabel(std::string& value, const CGUIInfo &info) const +{ + int iSongs = -1; + + switch (info.m_info) + { + case MUSICPM_SONGSPLAYED: + iSongs = g_partyModeManager.GetSongsPlayed(); + break; + case MUSICPM_MATCHINGSONGS: + iSongs = g_partyModeManager.GetMatchingSongs(); + break; + case MUSICPM_MATCHINGSONGSPICKED: + iSongs = g_partyModeManager.GetMatchingSongsPicked(); + break; + case MUSICPM_MATCHINGSONGSLEFT: + iSongs = g_partyModeManager.GetMatchingSongsLeft(); + break; + case MUSICPM_RELAXEDSONGSPICKED: + iSongs = g_partyModeManager.GetRelaxedSongs(); + break; + case MUSICPM_RANDOMSONGSPICKED: + iSongs = g_partyModeManager.GetRandomSongs(); + break; + } + + if (iSongs >= 0) + { + value = std::to_string(iSongs); + return true; + } + + return false; +} + +bool CMusicGUIInfo::GetPlaylistInfo(std::string& value, const CGUIInfo &info) const +{ + const PLAYLIST::CPlayList& playlist = + CServiceBroker::GetPlaylistPlayer().GetPlaylist(PLAYLIST::TYPE_MUSIC); + if (playlist.size() < 1) + return false; + + int index = info.GetData2(); + if (info.GetData1() == 1) + { // relative index (requires current playlist is TYPE_MUSIC) + if (CServiceBroker::GetPlaylistPlayer().GetCurrentPlaylist() != PLAYLIST::TYPE_MUSIC) + return false; + + index = CServiceBroker::GetPlaylistPlayer().GetNextSong(index); + } + + if (index < 0 || index >= playlist.size()) + return false; + + const CFileItemPtr playlistItem = playlist[index]; + if (playlistItem->HasMusicInfoTag() && !playlistItem->GetMusicInfoTag()->Loaded()) + { + playlistItem->LoadMusicTag(); + playlistItem->GetMusicInfoTag()->SetLoaded(); + } + // try to set a thumbnail + if (!playlistItem->HasArt("thumb")) + { + CMusicThumbLoader loader; + loader.LoadItem(playlistItem.get()); + // still no thumb? then just the set the default cover + if (!playlistItem->HasArt("thumb")) + playlistItem->SetArt("thumb", "DefaultAlbumCover.png"); + } + if (info.m_info == MUSICPLAYER_PLAYLISTPOS) + { + value = std::to_string(index + 1); + return true; + } + else if (info.m_info == MUSICPLAYER_COVER) + { + value = playlistItem->GetArt("thumb"); + return true; + } + + return GetLabel(value, playlistItem.get(), 0, CGUIInfo(info.m_info), nullptr); +} + +bool CMusicGUIInfo::GetFallbackLabel(std::string& value, + const CFileItem* item, + int contextWindow, + const CGUIInfo& info, + std::string* fallback) +{ + // No fallback for musicplayer "offset" and "position" info labels + if (info.GetData1() && ((info.m_info >= MUSICPLAYER_OFFSET_POSITION_FIRST && + info.m_info <= MUSICPLAYER_OFFSET_POSITION_LAST) || + (info.m_info >= PLAYER_OFFSET_POSITION_FIRST && info.m_info <= PLAYER_OFFSET_POSITION_LAST))) + return false; + + const CMusicInfoTag* tag = item->GetMusicInfoTag(); + if (tag) + { + switch (info.m_info) + { + ///////////////////////////////////////////////////////////////////////////////////////////// + // MUSICPLAYER_* + ///////////////////////////////////////////////////////////////////////////////////////////// + case MUSICPLAYER_TITLE: + value = item->GetLabel(); + if (value.empty()) + value = CUtil::GetTitleFromPath(item->GetPath()); + return true; + default: + break; + } + } + return false; +} + +bool CMusicGUIInfo::GetInt(int& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + return false; +} + +bool CMusicGUIInfo::GetBool(bool& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + const CFileItem* item = static_cast(gitem); + const CMusicInfoTag* tag = item->GetMusicInfoTag(); + + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // MUSICPLAYER_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case MUSICPLAYER_CONTENT: + value = StringUtils::EqualsNoCase(info.GetData3(), "files"); + return value; // if no match for this provider, other providers shall be asked. + case MUSICPLAYER_HASPREVIOUS: + // requires current playlist be TYPE_MUSIC + if (CServiceBroker::GetPlaylistPlayer().GetCurrentPlaylist() == PLAYLIST::TYPE_MUSIC) + { + value = (CServiceBroker::GetPlaylistPlayer().GetCurrentSong() > 0); // not first song + return true; + } + break; + case MUSICPLAYER_HASNEXT: + // requires current playlist be TYPE_MUSIC + if (CServiceBroker::GetPlaylistPlayer().GetCurrentPlaylist() == PLAYLIST::TYPE_MUSIC) + { + value = (CServiceBroker::GetPlaylistPlayer().GetCurrentSong() < + (CServiceBroker::GetPlaylistPlayer().GetPlaylist(PLAYLIST::TYPE_MUSIC).size() - + 1)); // not last song + return true; + } + break; + case MUSICPLAYER_PLAYLISTPLAYING: + { + const auto& components = CServiceBroker::GetAppComponents(); + const auto appPlayer = components.GetComponent(); + if (appPlayer->IsPlayingAudio() && + CServiceBroker::GetPlaylistPlayer().GetCurrentPlaylist() == PLAYLIST::TYPE_MUSIC) + { + value = true; + return true; + } + break; + } + case MUSICPLAYER_EXISTS: + { + int index = info.GetData2(); + if (info.GetData1() == 1) + { // relative index + if (CServiceBroker::GetPlaylistPlayer().GetCurrentPlaylist() != PLAYLIST::TYPE_MUSIC) + { + value = false; + return true; + } + index += CServiceBroker::GetPlaylistPlayer().GetCurrentSong(); + } + value = + (index >= 0 && + index < CServiceBroker::GetPlaylistPlayer().GetPlaylist(PLAYLIST::TYPE_MUSIC).size()); + return true; + } + case MUSICPLAYER_ISMULTIDISC: + if (tag) + { + value = (item->GetMusicInfoTag()->GetTotalDiscs() > 1); + return true; + } + break; + /////////////////////////////////////////////////////////////////////////////////////////////// + // MUSICPM_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case MUSICPM_ENABLED: + value = g_partyModeManager.IsEnabled(); + return true; + + /////////////////////////////////////////////////////////////////////////////////////////////// + // LISTITEM_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case LISTITEM_IS_BOXSET: + if (tag) + { + value = tag->GetBoxset() == true; + return true; + } + break; + } + + return false; +} diff --git a/xbmc/guilib/guiinfo/MusicGUIInfo.h b/xbmc/guilib/guiinfo/MusicGUIInfo.h new file mode 100644 index 0000000..4132ca6 --- /dev/null +++ b/xbmc/guilib/guiinfo/MusicGUIInfo.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "guilib/guiinfo/GUIInfoProvider.h" + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +class CGUIInfo; + +class CMusicGUIInfo : public CGUIInfoProvider +{ +public: + CMusicGUIInfo() = default; + ~CMusicGUIInfo() override = default; + + // KODI::GUILIB::GUIINFO::IGUIInfoProvider implementation + bool InitCurrentItem(CFileItem *item) override; + bool GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const override; + bool GetFallbackLabel(std::string& value, + const CFileItem* item, + int contextWindow, + const CGUIInfo& info, + std::string* fallback) override; + bool GetInt(int& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; + bool GetBool(bool& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; + +private: + bool GetPartyModeLabel(std::string& value, const CGUIInfo &info) const; + bool GetPlaylistInfo(std::string& value, const CGUIInfo &info) const; +}; + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI diff --git a/xbmc/guilib/guiinfo/PicturesGUIInfo.cpp b/xbmc/guilib/guiinfo/PicturesGUIInfo.cpp new file mode 100644 index 0000000..6115517 --- /dev/null +++ b/xbmc/guilib/guiinfo/PicturesGUIInfo.cpp @@ -0,0 +1,259 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "guilib/guiinfo/PicturesGUIInfo.h" + +#include "FileItem.h" +#include "ServiceBroker.h" +#include "URL.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +#include "guilib/guiinfo/GUIInfo.h" +#include "guilib/guiinfo/GUIInfoLabels.h" +#include "pictures/GUIWindowSlideShow.h" +#include "pictures/PictureInfoTag.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" +#include "utils/log.h" + +#include + +using namespace KODI::GUILIB::GUIINFO; + +static const std::map listitem2slideshow_map = +{ + { LISTITEM_PICTURE_RESOLUTION , SLIDESHOW_RESOLUTION }, + { LISTITEM_PICTURE_LONGDATE , SLIDESHOW_EXIF_LONG_DATE }, + { LISTITEM_PICTURE_LONGDATETIME , SLIDESHOW_EXIF_LONG_DATE_TIME }, + { LISTITEM_PICTURE_DATE , SLIDESHOW_EXIF_DATE }, + { LISTITEM_PICTURE_DATETIME , SLIDESHOW_EXIF_DATE_TIME }, + { LISTITEM_PICTURE_COMMENT , SLIDESHOW_COMMENT }, + { LISTITEM_PICTURE_CAPTION , SLIDESHOW_IPTC_CAPTION }, + { LISTITEM_PICTURE_DESC , SLIDESHOW_EXIF_DESCRIPTION }, + { LISTITEM_PICTURE_KEYWORDS , SLIDESHOW_IPTC_KEYWORDS }, + { LISTITEM_PICTURE_CAM_MAKE , SLIDESHOW_EXIF_CAMERA_MAKE }, + { LISTITEM_PICTURE_CAM_MODEL , SLIDESHOW_EXIF_CAMERA_MODEL }, + { LISTITEM_PICTURE_APERTURE , SLIDESHOW_EXIF_APERTURE }, + { LISTITEM_PICTURE_FOCAL_LEN , SLIDESHOW_EXIF_FOCAL_LENGTH }, + { LISTITEM_PICTURE_FOCUS_DIST , SLIDESHOW_EXIF_FOCUS_DIST }, + { LISTITEM_PICTURE_EXP_MODE , SLIDESHOW_EXIF_EXPOSURE_MODE }, + { LISTITEM_PICTURE_EXP_TIME , SLIDESHOW_EXIF_EXPOSURE_TIME }, + { LISTITEM_PICTURE_ISO , SLIDESHOW_EXIF_ISO_EQUIV }, + { LISTITEM_PICTURE_AUTHOR , SLIDESHOW_IPTC_AUTHOR }, + { LISTITEM_PICTURE_BYLINE , SLIDESHOW_IPTC_BYLINE }, + { LISTITEM_PICTURE_BYLINE_TITLE , SLIDESHOW_IPTC_BYLINE_TITLE }, + { LISTITEM_PICTURE_CATEGORY , SLIDESHOW_IPTC_CATEGORY }, + { LISTITEM_PICTURE_CCD_WIDTH , SLIDESHOW_EXIF_CCD_WIDTH }, + { LISTITEM_PICTURE_CITY , SLIDESHOW_IPTC_CITY }, + { LISTITEM_PICTURE_URGENCY , SLIDESHOW_IPTC_URGENCY }, + { LISTITEM_PICTURE_COPYRIGHT_NOTICE , SLIDESHOW_IPTC_COPYRIGHT_NOTICE }, + { LISTITEM_PICTURE_COUNTRY , SLIDESHOW_IPTC_COUNTRY }, + { LISTITEM_PICTURE_COUNTRY_CODE , SLIDESHOW_IPTC_COUNTRY_CODE }, + { LISTITEM_PICTURE_CREDIT , SLIDESHOW_IPTC_CREDIT }, + { LISTITEM_PICTURE_IPTCDATE , SLIDESHOW_IPTC_DATE }, + { LISTITEM_PICTURE_DIGITAL_ZOOM , SLIDESHOW_EXIF_DIGITAL_ZOOM, }, + { LISTITEM_PICTURE_EXPOSURE , SLIDESHOW_EXIF_EXPOSURE }, + { LISTITEM_PICTURE_EXPOSURE_BIAS , SLIDESHOW_EXIF_EXPOSURE_BIAS }, + { LISTITEM_PICTURE_FLASH_USED , SLIDESHOW_EXIF_FLASH_USED }, + { LISTITEM_PICTURE_HEADLINE , SLIDESHOW_IPTC_HEADLINE }, + { LISTITEM_PICTURE_COLOUR , SLIDESHOW_COLOUR }, + { LISTITEM_PICTURE_LIGHT_SOURCE , SLIDESHOW_EXIF_LIGHT_SOURCE }, + { LISTITEM_PICTURE_METERING_MODE , SLIDESHOW_EXIF_METERING_MODE }, + { LISTITEM_PICTURE_OBJECT_NAME , SLIDESHOW_IPTC_OBJECT_NAME }, + { LISTITEM_PICTURE_ORIENTATION , SLIDESHOW_EXIF_ORIENTATION }, + { LISTITEM_PICTURE_PROCESS , SLIDESHOW_PROCESS }, + { LISTITEM_PICTURE_REF_SERVICE , SLIDESHOW_IPTC_REF_SERVICE }, + { LISTITEM_PICTURE_SOURCE , SLIDESHOW_IPTC_SOURCE }, + { LISTITEM_PICTURE_SPEC_INSTR , SLIDESHOW_IPTC_SPEC_INSTR }, + { LISTITEM_PICTURE_STATE , SLIDESHOW_IPTC_STATE }, + { LISTITEM_PICTURE_SUP_CATEGORIES , SLIDESHOW_IPTC_SUP_CATEGORIES }, + { LISTITEM_PICTURE_TX_REFERENCE , SLIDESHOW_IPTC_TX_REFERENCE }, + { LISTITEM_PICTURE_WHITE_BALANCE , SLIDESHOW_EXIF_WHITE_BALANCE }, + { LISTITEM_PICTURE_IMAGETYPE , SLIDESHOW_IPTC_IMAGETYPE }, + { LISTITEM_PICTURE_SUBLOCATION , SLIDESHOW_IPTC_SUBLOCATION }, + { LISTITEM_PICTURE_TIMECREATED , SLIDESHOW_IPTC_TIMECREATED }, + { LISTITEM_PICTURE_GPS_LAT , SLIDESHOW_EXIF_GPS_LATITUDE }, + { LISTITEM_PICTURE_GPS_LON , SLIDESHOW_EXIF_GPS_LONGITUDE }, + { LISTITEM_PICTURE_GPS_ALT , SLIDESHOW_EXIF_GPS_ALTITUDE } +}; + +CPicturesGUIInfo::CPicturesGUIInfo() = default; + +CPicturesGUIInfo::~CPicturesGUIInfo() = default; + +void CPicturesGUIInfo::SetCurrentSlide(CFileItem *item) +{ + if (m_currentSlide && item && m_currentSlide->GetPath() == item->GetPath()) + return; + + if (item) + { + if (item->HasPictureInfoTag()) // Note: item may also be a video + { + CPictureInfoTag* tag = item->GetPictureInfoTag(); + if (!tag->Loaded()) // If picture metadata has not been loaded yet, load it now + tag->Load(item->GetPath()); + } + m_currentSlide.reset(new CFileItem(*item)); + } + else if (m_currentSlide) + { + m_currentSlide.reset(); + } +} + +const CFileItem* CPicturesGUIInfo::GetCurrentSlide() const +{ + return m_currentSlide.get(); +} + +bool CPicturesGUIInfo::InitCurrentItem(CFileItem *item) +{ + return false; +} + +bool CPicturesGUIInfo::GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const +{ + if (item->IsPicture() && info.m_info >= LISTITEM_PICTURE_START && info.m_info <= LISTITEM_PICTURE_END) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // LISTITEM_* + /////////////////////////////////////////////////////////////////////////////////////////////// + const auto& it = listitem2slideshow_map.find(info.m_info); + if (it != listitem2slideshow_map.end()) + { + if (item->HasPictureInfoTag()) + { + value = item->GetPictureInfoTag()->GetInfo(it->second); + return true; + } + } + else + { + CLog::Log(LOGERROR, + "CPicturesGUIInfo::GetLabel - cannot map LISTITEM ({}) to SLIDESHOW label!", + info.m_info); + return false; + } + } + else if (m_currentSlide && info.m_info >= SLIDESHOW_LABELS_START && info.m_info <= SLIDESHOW_LABELS_END) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // SLIDESHOW_* + /////////////////////////////////////////////////////////////////////////////////////////////// + switch (info.m_info) + { + case SLIDESHOW_FILE_NAME: + { + value = URIUtils::GetFileName(m_currentSlide->GetPath()); + return true; + } + case SLIDESHOW_FILE_PATH: + { + const std::string path = URIUtils::GetDirectory(m_currentSlide->GetPath()); + value = CURL(path).GetWithoutUserDetails(); + return true; + } + case SLIDESHOW_FILE_SIZE: + { + if (!m_currentSlide->m_bIsFolder || m_currentSlide->m_dwSize) + { + value = StringUtils::SizeToString(m_currentSlide->m_dwSize); + return true; + } + break; + } + case SLIDESHOW_FILE_DATE: + { + if (m_currentSlide->m_dateTime.IsValid()) + { + value = m_currentSlide->m_dateTime.GetAsLocalizedDate(); + return true; + } + break; + } + case SLIDESHOW_INDEX: + { + CGUIWindowSlideShow *slideshow = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_SLIDESHOW); + if (slideshow && slideshow->NumSlides()) + { + value = StringUtils::Format("{}/{}", slideshow->CurrentSlide(), slideshow->NumSlides()); + return true; + } + break; + } + default: + { + value = m_currentSlide->GetPictureInfoTag()->GetInfo(info.m_info); + return true; + } + } + } + + if (item->IsPicture()) + { + ///////////////////////////////////////////////////////////////////////////////////////////////// + // LISTITEM_* + ///////////////////////////////////////////////////////////////////////////////////////////////// + switch (info.m_info) + { + case LISTITEM_PICTURE_PATH: + { + if (!(item->IsZIP() || item->IsRAR() || item->IsCBZ() || item->IsCBR())) + { + value = item->GetPath(); + return true; + } + break; + } + } + } + + return false; +} + +bool CPicturesGUIInfo::GetInt(int& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + return false; +} + +bool CPicturesGUIInfo::GetBool(bool& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // SLIDESHOW_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case SLIDESHOW_ISPAUSED: + { + CGUIWindowSlideShow *slideShow = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_SLIDESHOW); + value = (slideShow && slideShow->IsPaused()); + return true; + } + case SLIDESHOW_ISRANDOM: + { + CGUIWindowSlideShow *slideShow = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_SLIDESHOW); + value = (slideShow && slideShow->IsShuffled()); + return true; + } + case SLIDESHOW_ISACTIVE: + { + CGUIWindowSlideShow *slideShow = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_SLIDESHOW); + value = (slideShow && slideShow->InSlideShow()); + return true; + } + case SLIDESHOW_ISVIDEO: + { + CGUIWindowSlideShow *slideShow = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_SLIDESHOW); + value = (slideShow && slideShow->GetCurrentSlide() && slideShow->GetCurrentSlide()->IsVideo()); + return true; + } + } + + return false; +} diff --git a/xbmc/guilib/guiinfo/PicturesGUIInfo.h b/xbmc/guilib/guiinfo/PicturesGUIInfo.h new file mode 100644 index 0000000..68cdb4c --- /dev/null +++ b/xbmc/guilib/guiinfo/PicturesGUIInfo.h @@ -0,0 +1,45 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "guilib/guiinfo/GUIInfoProvider.h" + +#include + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +class CGUIInfo; + +class CPicturesGUIInfo : public CGUIInfoProvider +{ +public: + CPicturesGUIInfo(); + ~CPicturesGUIInfo() override; + + // KODI::GUILIB::GUIINFO::IGUIInfoProvider implementation + bool InitCurrentItem(CFileItem *item) override; + bool GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const override; + bool GetInt(int& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; + bool GetBool(bool& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; + + void SetCurrentSlide(CFileItem *item); + const CFileItem* GetCurrentSlide() const; + +private: + std::unique_ptr m_currentSlide; +}; + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI diff --git a/xbmc/guilib/guiinfo/PlayerGUIInfo.cpp b/xbmc/guilib/guiinfo/PlayerGUIInfo.cpp new file mode 100644 index 0000000..dfb9455 --- /dev/null +++ b/xbmc/guilib/guiinfo/PlayerGUIInfo.cpp @@ -0,0 +1,726 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "guilib/guiinfo/PlayerGUIInfo.h" + +#include "FileItem.h" +#include "PlayListPlayer.h" +#include "ServiceBroker.h" +#include "URL.h" +#include "Util.h" +#include "application/Application.h" +#include "application/ApplicationComponents.h" +#include "application/ApplicationPlayer.h" +#include "application/ApplicationVolumeHandling.h" +#include "cores/AudioEngine/Utils/AEUtil.h" +#include "cores/DataCacheCore.h" +#include "cores/EdlEdit.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIDialog.h" +#include "guilib/GUIWindowManager.h" +#include "guilib/guiinfo/GUIInfo.h" +#include "guilib/guiinfo/GUIInfoHelper.h" +#include "guilib/guiinfo/GUIInfoLabels.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" +#include "utils/Variant.h" +#include "utils/log.h" + +#include +#include + +using namespace KODI::GUILIB::GUIINFO; + +CPlayerGUIInfo::CPlayerGUIInfo() + : m_appPlayer(CServiceBroker::GetAppComponents().GetComponent()), + m_appVolume(CServiceBroker::GetAppComponents().GetComponent()) +{ +} + +CPlayerGUIInfo::~CPlayerGUIInfo() = default; + +int CPlayerGUIInfo::GetTotalPlayTime() const +{ + return std::lrint(g_application.GetTotalTime()); +} + +int CPlayerGUIInfo::GetPlayTime() const +{ + return std::lrint(g_application.GetTime()); +} + +int CPlayerGUIInfo::GetPlayTimeRemaining() const +{ + int iReverse = GetTotalPlayTime() - std::lrint(g_application.GetTime()); + return iReverse > 0 ? iReverse : 0; +} + +float CPlayerGUIInfo::GetSeekPercent() const +{ + int iTotal = GetTotalPlayTime(); + if (iTotal == 0) + return 0.0f; + + float fPercentPlayTime = static_cast(GetPlayTime() * 1000) / iTotal * 0.1f; + float fPercentPerSecond = 100.0f / static_cast(iTotal); + float fPercent = + fPercentPlayTime + fPercentPerSecond * m_appPlayer->GetSeekHandler().GetSeekSize(); + fPercent = std::max(0.0f, std::min(fPercent, 100.0f)); + return fPercent; +} + +std::string CPlayerGUIInfo::GetCurrentPlayTime(TIME_FORMAT format) const +{ + if (format == TIME_FORMAT_GUESS && GetTotalPlayTime() >= 3600) + format = TIME_FORMAT_HH_MM_SS; + + return StringUtils::SecondsToTimeString(std::lrint(GetPlayTime()), format); +} + +std::string CPlayerGUIInfo::GetCurrentPlayTimeRemaining(TIME_FORMAT format) const +{ + if (format == TIME_FORMAT_GUESS && GetTotalPlayTime() >= 3600) + format = TIME_FORMAT_HH_MM_SS; + + int iTimeRemaining = GetPlayTimeRemaining(); + if (iTimeRemaining) + return StringUtils::SecondsToTimeString(iTimeRemaining, format); + + return std::string(); +} + +std::string CPlayerGUIInfo::GetDuration(TIME_FORMAT format) const +{ + int iTotal = GetTotalPlayTime(); + if (iTotal > 0) + { + if (format == TIME_FORMAT_GUESS && iTotal >= 3600) + format = TIME_FORMAT_HH_MM_SS; + return StringUtils::SecondsToTimeString(iTotal, format); + } + return std::string(); +} + +std::string CPlayerGUIInfo::GetCurrentSeekTime(TIME_FORMAT format) const +{ + if (format == TIME_FORMAT_GUESS && GetTotalPlayTime() >= 3600) + format = TIME_FORMAT_HH_MM_SS; + + return StringUtils::SecondsToTimeString( + g_application.GetTime() + m_appPlayer->GetSeekHandler().GetSeekSize(), format); +} + +std::string CPlayerGUIInfo::GetSeekTime(TIME_FORMAT format) const +{ + if (!m_appPlayer->GetSeekHandler().HasTimeCode()) + return std::string(); + + int iSeekTimeCode = m_appPlayer->GetSeekHandler().GetTimeCodeSeconds(); + if (format == TIME_FORMAT_GUESS && iSeekTimeCode >= 3600) + format = TIME_FORMAT_HH_MM_SS; + + return StringUtils::SecondsToTimeString(iSeekTimeCode, format); +} + +void CPlayerGUIInfo::SetShowInfo(bool showinfo) +{ + if (showinfo != m_playerShowInfo) + { + m_playerShowInfo = showinfo; + m_events.Publish(PlayerShowInfoChangedEvent(m_playerShowInfo)); + } +} + +bool CPlayerGUIInfo::ToggleShowInfo() +{ + SetShowInfo(!m_playerShowInfo); + return m_playerShowInfo; +} + +bool CPlayerGUIInfo::InitCurrentItem(CFileItem *item) +{ + if (item && m_appPlayer->IsPlaying()) + { + CLog::Log(LOGDEBUG, "CPlayerGUIInfo::InitCurrentItem({})", CURL::GetRedacted(item->GetPath())); + m_currentItem.reset(new CFileItem(*item)); + } + else + { + m_currentItem.reset(); + } + return false; +} + +bool CPlayerGUIInfo::GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const +{ + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // PLAYER_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case PLAYER_SEEKOFFSET: + { + int lastSeekOffset = CServiceBroker::GetDataCacheCore().GetSeekOffSet(); + std::string seekOffset = StringUtils::SecondsToTimeString( + std::abs(lastSeekOffset / 1000), static_cast(info.GetData1())); + if (lastSeekOffset < 0) + value = "-" + seekOffset; + else if (lastSeekOffset > 0) + value = "+" + seekOffset; + return true; + } + case PLAYER_PROGRESS: + value = std::to_string(std::lrintf(g_application.GetPercentage())); + return true; + case PLAYER_PROGRESS_CACHE: + value = std::to_string(std::lrintf(g_application.GetCachePercentage())); + return true; + case PLAYER_VOLUME: + value = + StringUtils::Format("{:2.1f} dB", CAEUtil::PercentToGain(m_appVolume->GetVolumeRatio())); + return true; + case PLAYER_SUBTITLE_DELAY: + value = StringUtils::Format("{:2.3f} s", m_appPlayer->GetVideoSettings().m_SubtitleDelay); + return true; + case PLAYER_AUDIO_DELAY: + value = StringUtils::Format("{:2.3f} s", m_appPlayer->GetVideoSettings().m_AudioDelay); + return true; + case PLAYER_CHAPTER: + value = StringUtils::Format("{:02}", m_appPlayer->GetChapter()); + return true; + case PLAYER_CHAPTERCOUNT: + value = StringUtils::Format("{:02}", m_appPlayer->GetChapterCount()); + return true; + case PLAYER_CHAPTERNAME: + m_appPlayer->GetChapterName(value); + return true; + case PLAYER_PATH: + case PLAYER_FILENAME: + case PLAYER_FILEPATH: + value = GUIINFO::GetFileInfoLabelValueFromPath(info.m_info, item->GetPath()); + return true; + case PLAYER_TITLE: + // use label or drop down to title from path + value = item->GetLabel(); + if (value.empty()) + value = CUtil::GetTitleFromPath(item->GetPath()); + return true; + case PLAYER_PLAYSPEED: + { + float speed = m_appPlayer->GetPlaySpeed(); + if (speed == 1.0f) + speed = m_appPlayer->GetPlayTempo(); + value = StringUtils::Format("{:.2f}", speed); + return true; + } + case PLAYER_TIME: + value = GetCurrentPlayTime(static_cast(info.GetData1())); + return true; + case PLAYER_START_TIME: + { + const CDateTime time(m_appPlayer->GetStartTime()); + value = time.GetAsLocalizedTime(static_cast(info.GetData1())); + return true; + } + case PLAYER_DURATION: + value = GetDuration(static_cast(info.GetData1())); + return true; + case PLAYER_TIME_REMAINING: + value = GetCurrentPlayTimeRemaining(static_cast(info.GetData1())); + return true; + case PLAYER_FINISH_TIME: + { + CDateTime time(CDateTime::GetCurrentDateTime()); + int playTimeRemaining = GetPlayTimeRemaining(); + float speed = m_appPlayer->GetPlaySpeed(); + float tempo = m_appPlayer->GetPlayTempo(); + if (speed == 1.0f) + playTimeRemaining /= tempo; + time += CDateTimeSpan(0, 0, 0, playTimeRemaining); + value = time.GetAsLocalizedTime(static_cast(info.GetData1())); + return true; + } + case PLAYER_TIME_SPEED: + { + float speed = m_appPlayer->GetPlaySpeed(); + if (speed != 1.0f) + value = StringUtils::Format("{} ({}x)", + GetCurrentPlayTime(static_cast(info.GetData1())), + static_cast(speed)); + else + value = GetCurrentPlayTime(TIME_FORMAT_GUESS); + return true; + } + case PLAYER_SEEKTIME: + value = GetCurrentSeekTime(static_cast(info.GetData1())); + return true; + case PLAYER_SEEKSTEPSIZE: + { + int seekSize = m_appPlayer->GetSeekHandler().GetSeekSize(); + std::string strSeekSize = StringUtils::SecondsToTimeString(abs(seekSize), static_cast(info.GetData1())); + if (seekSize < 0) + value = "-" + strSeekSize; + if (seekSize > 0) + value = "+" + strSeekSize; + return true; + } + case PLAYER_SEEKNUMERIC: + value = GetSeekTime(static_cast(info.GetData1())); + return !value.empty(); + case PLAYER_CACHELEVEL: + { + int iLevel = m_appPlayer->GetCacheLevel(); + if (iLevel >= 0) + { + value = std::to_string(iLevel); + return true; + } + break; + } + case PLAYER_ITEM_ART: + value = item->GetArt(info.GetData3()); + return true; + case PLAYER_ICON: + value = item->GetArt("thumb"); + if (value.empty()) + value = item->GetArt("icon"); + if (fallback) + *fallback = item->GetArt("icon"); + return true; + case PLAYER_EDITLIST: + case PLAYER_CUTS: + case PLAYER_SCENE_MARKERS: + case PLAYER_CUTLIST: + case PLAYER_CHAPTERS: + value = GetContentRanges(info.m_info); + return true; + + /////////////////////////////////////////////////////////////////////////////////////////////// + // PLAYER_PROCESS_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case PLAYER_PROCESS_VIDEODECODER: + value = CServiceBroker::GetDataCacheCore().GetVideoDecoderName(); + return true; + case PLAYER_PROCESS_DEINTMETHOD: + value = CServiceBroker::GetDataCacheCore().GetVideoDeintMethod(); + return true; + case PLAYER_PROCESS_PIXELFORMAT: + value = CServiceBroker::GetDataCacheCore().GetVideoPixelFormat(); + return true; + case PLAYER_PROCESS_VIDEOFPS: + value = StringUtils::Format("{:.3f}", CServiceBroker::GetDataCacheCore().GetVideoFps()); + return true; + case PLAYER_PROCESS_VIDEODAR: + value = StringUtils::Format("{:.2f}", CServiceBroker::GetDataCacheCore().GetVideoDAR()); + return true; + case PLAYER_PROCESS_VIDEOWIDTH: + value = StringUtils::FormatNumber(CServiceBroker::GetDataCacheCore().GetVideoWidth()); + return true; + case PLAYER_PROCESS_VIDEOHEIGHT: + value = StringUtils::FormatNumber(CServiceBroker::GetDataCacheCore().GetVideoHeight()); + return true; + case PLAYER_PROCESS_VIDEOSCANTYPE: + value = CServiceBroker::GetDataCacheCore().IsVideoInterlaced() ? "i" : "p"; + return true; + case PLAYER_PROCESS_AUDIODECODER: + value = CServiceBroker::GetDataCacheCore().GetAudioDecoderName(); + return true; + case PLAYER_PROCESS_AUDIOCHANNELS: + value = CServiceBroker::GetDataCacheCore().GetAudioChannels(); + return true; + case PLAYER_PROCESS_AUDIOSAMPLERATE: + value = StringUtils::FormatNumber(CServiceBroker::GetDataCacheCore().GetAudioSampleRate()); + return true; + case PLAYER_PROCESS_AUDIOBITSPERSAMPLE: + value = StringUtils::FormatNumber(CServiceBroker::GetDataCacheCore().GetAudioBitsPerSample()); + return true; + + /////////////////////////////////////////////////////////////////////////////////////////////// + // PLAYLIST_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case PLAYLIST_LENGTH: + case PLAYLIST_POSITION: + case PLAYLIST_RANDOM: + case PLAYLIST_REPEAT: + value = GUIINFO::GetPlaylistLabel(info.m_info, info.GetData1()); + return true; + } + + return false; +} + +bool CPlayerGUIInfo::GetInt(int& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // PLAYER_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case PLAYER_VOLUME: + value = static_cast(m_appVolume->GetVolumePercent()); + return true; + case PLAYER_PROGRESS: + value = std::lrintf(g_application.GetPercentage()); + return true; + case PLAYER_PROGRESS_CACHE: + value = std::lrintf(g_application.GetCachePercentage()); + return true; + case PLAYER_SEEKBAR: + value = std::lrintf(GetSeekPercent()); + return true; + case PLAYER_CACHELEVEL: + value = m_appPlayer->GetCacheLevel(); + return true; + case PLAYER_CHAPTER: + value = m_appPlayer->GetChapter(); + return true; + case PLAYER_CHAPTERCOUNT: + value = m_appPlayer->GetChapterCount(); + return true; + case PLAYER_SUBTITLE_DELAY: + value = m_appPlayer->GetSubtitleDelay(); + return true; + case PLAYER_AUDIO_DELAY: + value = m_appPlayer->GetAudioDelay(); + return true; + } + + return false; +} + +bool CPlayerGUIInfo::GetBool(bool& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + const CFileItem *item = nullptr; + if (gitem->IsFileItem()) + item = static_cast(gitem); + + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // PLAYER_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case PLAYER_SHOWINFO: + value = m_playerShowInfo; + return true; + case PLAYER_SHOWTIME: + value = m_playerShowTime; + return true; + case PLAYER_MUTED: + value = (m_appVolume->IsMuted() || + m_appVolume->GetVolumeRatio() <= CApplicationVolumeHandling::VOLUME_MINIMUM); + return true; + case PLAYER_HAS_MEDIA: + value = m_appPlayer->IsPlaying(); + return true; + case PLAYER_HAS_AUDIO: + value = m_appPlayer->IsPlayingAudio(); + return true; + case PLAYER_HAS_VIDEO: + value = m_appPlayer->IsPlayingVideo(); + return true; + case PLAYER_HAS_GAME: + value = m_appPlayer->IsPlayingGame(); + return true; + case PLAYER_PLAYING: + value = m_appPlayer->GetPlaySpeed() == 1.0f; + return true; + case PLAYER_PAUSED: + value = m_appPlayer->IsPausedPlayback(); + return true; + case PLAYER_REWINDING: + value = m_appPlayer->GetPlaySpeed() < 0.0f; + return true; + case PLAYER_FORWARDING: + value = m_appPlayer->GetPlaySpeed() > 1.5f; + return true; + case PLAYER_REWINDING_2x: + value = m_appPlayer->GetPlaySpeed() == -2; + return true; + case PLAYER_REWINDING_4x: + value = m_appPlayer->GetPlaySpeed() == -4; + return true; + case PLAYER_REWINDING_8x: + value = m_appPlayer->GetPlaySpeed() == -8; + return true; + case PLAYER_REWINDING_16x: + value = m_appPlayer->GetPlaySpeed() == -16; + return true; + case PLAYER_REWINDING_32x: + value = m_appPlayer->GetPlaySpeed() == -32; + return true; + case PLAYER_FORWARDING_2x: + value = m_appPlayer->GetPlaySpeed() == 2; + return true; + case PLAYER_FORWARDING_4x: + value = m_appPlayer->GetPlaySpeed() == 4; + return true; + case PLAYER_FORWARDING_8x: + value = m_appPlayer->GetPlaySpeed() == 8; + return true; + case PLAYER_FORWARDING_16x: + value = m_appPlayer->GetPlaySpeed() == 16; + return true; + case PLAYER_FORWARDING_32x: + value = m_appPlayer->GetPlaySpeed() == 32; + return true; + case PLAYER_CAN_PAUSE: + value = m_appPlayer->CanPause(); + return true; + case PLAYER_CAN_SEEK: + value = m_appPlayer->CanSeek(); + return true; + case PLAYER_SUPPORTS_TEMPO: + value = m_appPlayer->SupportsTempo(); + return true; + case PLAYER_IS_TEMPO: + value = (m_appPlayer->GetPlayTempo() != 1.0f && m_appPlayer->GetPlaySpeed() == 1.0f); + return true; + case PLAYER_CACHING: + value = m_appPlayer->IsCaching(); + return true; + case PLAYER_SEEKBAR: + { + CGUIDialog *seekBar = CServiceBroker::GetGUI()->GetWindowManager().GetDialog(WINDOW_DIALOG_SEEK_BAR); + value = seekBar ? seekBar->IsDialogRunning() : false; + return true; + } + case PLAYER_SEEKING: + value = m_appPlayer->GetSeekHandler().InProgress(); + return true; + case PLAYER_HASPERFORMEDSEEK: + { + int requestedLastSecondInterval{0}; + std::from_chars_result result = + std::from_chars(info.GetData3().data(), info.GetData3().data() + info.GetData3().size(), + requestedLastSecondInterval); + if (result.ec == std::errc::invalid_argument) + { + value = false; + return false; + } + + value = CServiceBroker::GetDataCacheCore().HasPerformedSeek(requestedLastSecondInterval); + return true; + } + case PLAYER_PASSTHROUGH: + value = m_appPlayer->IsPassthrough(); + return true; + case PLAYER_ISINTERNETSTREAM: + if (item) + { + value = URIUtils::IsInternetStream(item->GetDynPath()); + return true; + } + break; + case PLAYER_HAS_PROGRAMS: + value = (m_appPlayer->GetProgramsCount() > 1) ? true : false; + return true; + case PLAYER_HAS_RESOLUTIONS: + value = CServiceBroker::GetWinSystem()->GetGfxContext().IsFullScreenRoot() && + CResolutionUtils::HasWhitelist(); + return true; + case PLAYER_HASDURATION: + value = g_application.GetTotalTime() > 0; + return true; + case PLAYER_FRAMEADVANCE: + value = CServiceBroker::GetDataCacheCore().IsFrameAdvance(); + return true; + case PLAYER_HAS_SCENE_MARKERS: + value = !CServiceBroker::GetDataCacheCore().GetSceneMarkers().empty(); + return true; + + /////////////////////////////////////////////////////////////////////////////////////////////// + // PLAYLIST_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case PLAYLIST_ISRANDOM: + { + PLAYLIST::CPlayListPlayer& player = CServiceBroker::GetPlaylistPlayer(); + PLAYLIST::Id playlistid = info.GetData1(); + if (info.GetData2() > 0 && playlistid != PLAYLIST::TYPE_NONE) + value = player.IsShuffled(playlistid); + else + value = player.IsShuffled(player.GetCurrentPlaylist()); + return true; + } + case PLAYLIST_ISREPEAT: + { + PLAYLIST::CPlayListPlayer& player = CServiceBroker::GetPlaylistPlayer(); + PLAYLIST::Id playlistid = info.GetData1(); + if (info.GetData2() > 0 && playlistid != PLAYLIST::TYPE_NONE) + value = (player.GetRepeat(playlistid) == PLAYLIST::RepeatState::ALL); + else + value = player.GetRepeat(player.GetCurrentPlaylist()) == PLAYLIST::RepeatState::ALL; + return true; + } + case PLAYLIST_ISREPEATONE: + { + PLAYLIST::CPlayListPlayer& player = CServiceBroker::GetPlaylistPlayer(); + PLAYLIST::Id playlistid = info.GetData1(); + if (info.GetData2() > 0 && playlistid != PLAYLIST::TYPE_NONE) + value = (player.GetRepeat(playlistid) == PLAYLIST::RepeatState::ONE); + else + value = player.GetRepeat(player.GetCurrentPlaylist()) == PLAYLIST::RepeatState::ONE; + return true; + } + + /////////////////////////////////////////////////////////////////////////////////////////////// + // PLAYER_PROCESS_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case PLAYER_PROCESS_VIDEOHWDECODER: + value = CServiceBroker::GetDataCacheCore().IsVideoHwDecoder(); + return true; + + /////////////////////////////////////////////////////////////////////////////////////////////// + // LISTITEM_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case LISTITEM_ISPLAYING: + { + if (item) + { + if (item->HasProperty("playlistposition")) + { + value = static_cast(item->GetProperty("playlisttype").asInteger()) == CServiceBroker::GetPlaylistPlayer().GetCurrentPlaylist() && + static_cast(item->GetProperty("playlistposition").asInteger()) == CServiceBroker::GetPlaylistPlayer().GetCurrentSong(); + return true; + } + else if (m_currentItem && !m_currentItem->GetPath().empty()) + { + if (!g_application.m_strPlayListFile.empty()) + { + //playlist file that is currently playing or the playlistitem that is currently playing. + value = item->IsPath(g_application.m_strPlayListFile) || m_currentItem->IsSamePath(item); + } + else + { + value = m_currentItem->IsSamePath(item); + } + return true; + } + } + break; + } + } + + return false; +} + +std::string CPlayerGUIInfo::GetContentRanges(int iInfo) const +{ + std::string values; + + CDataCacheCore& data = CServiceBroker::GetDataCacheCore(); + std::vector> ranges; + + std::time_t start; + int64_t current; + int64_t min; + int64_t max; + data.GetPlayTimes(start, current, min, max); + + std::time_t duration = max - start * 1000; + if (duration > 0) + { + switch (iInfo) + { + case PLAYER_EDITLIST: + case PLAYER_CUTLIST: + ranges = GetEditList(data, duration); + break; + case PLAYER_CUTS: + ranges = GetCuts(data, duration); + break; + case PLAYER_SCENE_MARKERS: + ranges = GetSceneMarkers(data, duration); + break; + case PLAYER_CHAPTERS: + ranges = GetChapters(data, duration); + break; + default: + CLog::Log(LOGERROR, "CPlayerGUIInfo::GetContentRanges({}) - unhandled guiinfo", iInfo); + break; + } + + // create csv string from ranges + for (const auto& range : ranges) + values += StringUtils::Format("{:.5f},{:.5f},", range.first, range.second); + + if (!values.empty()) + values.pop_back(); // remove trailing comma + } + + return values; +} + +std::vector> CPlayerGUIInfo::GetEditList(const CDataCacheCore& data, + std::time_t duration) const +{ + std::vector> ranges; + + const std::vector& edits = data.GetEditList(); + for (const auto& edit : edits) + { + float editStart = edit.start * 100.0f / duration; + float editEnd = edit.end * 100.0f / duration; + ranges.emplace_back(std::make_pair(editStart, editEnd)); + } + return ranges; +} + +std::vector> CPlayerGUIInfo::GetCuts(const CDataCacheCore& data, + std::time_t duration) const +{ + std::vector> ranges; + + const std::vector& cuts = data.GetCuts(); + float lastMarker = 0.0f; + for (const auto& cut : cuts) + { + float marker = cut * 100.0f / duration; + if (marker != 0) + ranges.emplace_back(std::make_pair(lastMarker, marker)); + + lastMarker = marker; + } + return ranges; +} + +std::vector> CPlayerGUIInfo::GetSceneMarkers(const CDataCacheCore& data, + std::time_t duration) const +{ + std::vector> ranges; + + const std::vector& scenes = data.GetSceneMarkers(); + float lastMarker = 0.0f; + for (const auto& scene : scenes) + { + float marker = scene * 100.0f / duration; + if (marker != 0) + ranges.emplace_back(std::make_pair(lastMarker, marker)); + + lastMarker = marker; + } + return ranges; +} + +std::vector> CPlayerGUIInfo::GetChapters(const CDataCacheCore& data, + std::time_t duration) const +{ + std::vector> ranges; + + const std::vector>& chapters = data.GetChapters(); + float lastMarker = 0.0f; + for (const auto& chapter : chapters) + { + float marker = chapter.second * 1000 * 100.0f / duration; + if (marker != 0) + ranges.emplace_back(std::make_pair(lastMarker, marker)); + + lastMarker = marker; + } + return ranges; +} diff --git a/xbmc/guilib/guiinfo/PlayerGUIInfo.h b/xbmc/guilib/guiinfo/PlayerGUIInfo.h new file mode 100644 index 0000000..e0cb3c8 --- /dev/null +++ b/xbmc/guilib/guiinfo/PlayerGUIInfo.h @@ -0,0 +1,93 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "guilib/guiinfo/GUIInfoProvider.h" +#include "utils/EventStream.h" +#include "utils/TimeFormat.h" + +#include +#include +#include +#include +#include + +class CApplicationPlayer; +class CApplicationVolumeHandling; +class CDataCacheCore; + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +class CGUIInfo; + +struct PlayerShowInfoChangedEvent +{ + explicit PlayerShowInfoChangedEvent(bool showInfo) : m_showInfo(showInfo) {} + virtual ~PlayerShowInfoChangedEvent() = default; + + bool m_showInfo{false}; +}; + +class CPlayerGUIInfo : public CGUIInfoProvider +{ +public: + CPlayerGUIInfo(); + ~CPlayerGUIInfo() override; + + CEventStream& Events() { return m_events; } + + // KODI::GUILIB::GUIINFO::IGUIInfoProvider implementation + bool InitCurrentItem(CFileItem *item) override; + bool GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const override; + bool GetInt(int& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; + bool GetBool(bool& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; + + void SetShowTime(bool showtime) { m_playerShowTime = showtime; } + void SetShowInfo(bool showinfo); + bool GetShowInfo() const { return m_playerShowInfo; } + bool ToggleShowInfo(); + +private: + int GetTotalPlayTime() const; + int GetPlayTime() const; + int GetPlayTimeRemaining() const; + float GetSeekPercent() const; + + std::string GetCurrentPlayTime(TIME_FORMAT format) const; + std::string GetCurrentPlayTimeRemaining(TIME_FORMAT format) const; + std::string GetDuration(TIME_FORMAT format) const; + std::string GetCurrentSeekTime(TIME_FORMAT format) const; + std::string GetSeekTime(TIME_FORMAT format) const; + + std::string GetContentRanges(int iInfo) const; + std::vector> GetEditList(const CDataCacheCore& data, + std::time_t duration) const; + std::vector> GetCuts(const CDataCacheCore& data, + std::time_t duration) const; + std::vector> GetSceneMarkers(const CDataCacheCore& data, + std::time_t duration) const; + std::vector> GetChapters(const CDataCacheCore& data, + std::time_t duration) const; + + std::unique_ptr m_currentItem; + std::atomic_bool m_playerShowTime{false}; + std::atomic_bool m_playerShowInfo{false}; + const std::shared_ptr m_appPlayer; + const std::shared_ptr m_appVolume; + CEventSource m_events; +}; + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI diff --git a/xbmc/guilib/guiinfo/SkinGUIInfo.cpp b/xbmc/guilib/guiinfo/SkinGUIInfo.cpp new file mode 100644 index 0000000..1d51b96 --- /dev/null +++ b/xbmc/guilib/guiinfo/SkinGUIInfo.cpp @@ -0,0 +1,140 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "guilib/guiinfo/SkinGUIInfo.h" + +#include "ServiceBroker.h" +#include "addons/Skin.h" +#include "guilib/LocalizeStrings.h" +#include "guilib/guiinfo/GUIInfo.h" +#include "guilib/guiinfo/GUIInfoLabels.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" +#include "settings/SkinSettings.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" + +using namespace KODI::GUILIB::GUIINFO; + +bool CSkinGUIInfo::InitCurrentItem(CFileItem *item) +{ + return false; +} + +bool CSkinGUIInfo::GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const +{ + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // SKIN_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case SKIN_BOOL: + { + bool bInfo = CSkinSettings::GetInstance().GetBool(info.GetData1()); + if (bInfo) + { + value = g_localizeStrings.Get(20122); // True + return true; + } + break; + } + case SKIN_STRING: + { + value = CSkinSettings::GetInstance().GetString(info.GetData1()); + return true; + } + case SKIN_THEME: + { + value = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_LOOKANDFEEL_SKINTHEME); + return true; + } + case SKIN_COLOUR_THEME: + { + value = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_LOOKANDFEEL_SKINCOLORS); + return true; + } + case SKIN_ASPECT_RATIO: + { + if (g_SkinInfo) + { + value = g_SkinInfo->GetCurrentAspect(); + return true; + } + break; + } + case SKIN_FONT: + { + value = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_LOOKANDFEEL_FONT); + return true; + } + case SKIN_TIMER_ELAPSEDSECS: + { + value = std::to_string(g_SkinInfo->GetTimerElapsedSeconds(info.GetData3())); + return true; + } + } + + return false; +} + +bool CSkinGUIInfo::GetInt(int& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + switch (info.m_info) + { + case SKIN_INTEGER: + { + value = CSkinSettings::GetInstance().GetInt(info.GetData1()); + return true; + } + case SKIN_TIMER_ELAPSEDSECS: + { + value = g_SkinInfo->GetTimerElapsedSeconds(info.GetData3()); + return true; + } + } + return false; +} + +bool CSkinGUIInfo::GetBool(bool& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // SKIN_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case SKIN_BOOL: + { + value = CSkinSettings::GetInstance().GetBool(info.GetData1()); + return true; + } + case SKIN_STRING_IS_EQUAL: + { + value = StringUtils::EqualsNoCase(CSkinSettings::GetInstance().GetString(info.GetData1()), info.GetData3()); + return true; + } + case SKIN_STRING: + { + value = !CSkinSettings::GetInstance().GetString(info.GetData1()).empty(); + return true; + } + case SKIN_HAS_THEME: + { + std::string theme = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_LOOKANDFEEL_SKINTHEME); + URIUtils::RemoveExtension(theme); + value = StringUtils::EqualsNoCase(theme, info.GetData3()); + return true; + } + case SKIN_TIMER_IS_RUNNING: + { + value = g_SkinInfo->TimerIsRunning(info.GetData3()); + return true; + } + } + + return false; +} diff --git a/xbmc/guilib/guiinfo/SkinGUIInfo.h b/xbmc/guilib/guiinfo/SkinGUIInfo.h new file mode 100644 index 0000000..7f6c1c4 --- /dev/null +++ b/xbmc/guilib/guiinfo/SkinGUIInfo.h @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "guilib/guiinfo/GUIInfoProvider.h" + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +class CGUIInfo; + +class CSkinGUIInfo : public CGUIInfoProvider +{ +public: + CSkinGUIInfo() = default; + ~CSkinGUIInfo() override = default; + + // KODI::GUILIB::GUIINFO::IGUIInfoProvider implementation + bool InitCurrentItem(CFileItem *item) override; + bool GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const override; + bool GetInt(int& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; + bool GetBool(bool& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; +}; + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI diff --git a/xbmc/guilib/guiinfo/SystemGUIInfo.cpp b/xbmc/guilib/guiinfo/SystemGUIInfo.cpp new file mode 100644 index 0000000..bc01047 --- /dev/null +++ b/xbmc/guilib/guiinfo/SystemGUIInfo.cpp @@ -0,0 +1,727 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "guilib/guiinfo/SystemGUIInfo.h" + +#include "FileItem.h" +#include "GUIPassword.h" +#include "LangInfo.h" +#include "ServiceBroker.h" +#include "addons/AddonManager.h" +#include "addons/addoninfo/AddonType.h" +#include "application/AppParams.h" +#include "application/ApplicationComponents.h" +#include "application/ApplicationPowerHandling.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +#include "guilib/LocalizeStrings.h" +#include "network/Network.h" +#if defined(TARGET_DARWIN_OSX) +#include "platform/darwin/osx/smc.h" +#endif +#include "guilib/guiinfo/GUIInfo.h" +#include "guilib/guiinfo/GUIInfoHelper.h" +#include "guilib/guiinfo/GUIInfoLabels.h" +#include "powermanagement/PowerManager.h" +#include "profiles/ProfileManager.h" +#include "settings/AdvancedSettings.h" +#include "settings/MediaSettings.h" +#include "settings/SettingUtils.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" +#include "storage/MediaManager.h" +#include "storage/discs/IDiscDriveHandler.h" +#include "utils/AlarmClock.h" +#include "utils/CPUInfo.h" +#include "utils/HDRCapabilities.h" +#include "utils/MemUtils.h" +#include "utils/StringUtils.h" +#include "utils/SystemInfo.h" +#include "utils/TimeUtils.h" +#include "windowing/WinSystem.h" +#include "windows/GUIMediaWindow.h" + +using namespace KODI::GUILIB; +using namespace KODI::GUILIB::GUIINFO; + +CSystemGUIInfo::CSystemGUIInfo() +: m_lastSysHeatInfoTime(-SYSTEM_HEAT_UPDATE_INTERVAL) +{ +} + +std::string CSystemGUIInfo::GetSystemHeatInfo(int info) const +{ + if (CTimeUtils::GetFrameTime() - m_lastSysHeatInfoTime >= SYSTEM_HEAT_UPDATE_INTERVAL) + { + m_lastSysHeatInfoTime = CTimeUtils::GetFrameTime(); +#if defined(TARGET_POSIX) + CServiceBroker::GetCPUInfo()->GetTemperature(m_cpuTemp); + m_gpuTemp = GetGPUTemperature(); +#endif + } + + std::string text; + switch(info) + { + case SYSTEM_CPU_TEMPERATURE: + return m_cpuTemp.IsValid() ? g_langInfo.GetTemperatureAsString(m_cpuTemp) : g_localizeStrings.Get(10005); // Not available + case SYSTEM_GPU_TEMPERATURE: + return m_gpuTemp.IsValid() ? g_langInfo.GetTemperatureAsString(m_gpuTemp) : g_localizeStrings.Get(10005); + case SYSTEM_FAN_SPEED: + text = StringUtils::Format("{}%", m_fanSpeed * 2); + break; + case SYSTEM_CPU_USAGE: + if (CServiceBroker::GetCPUInfo()->SupportsCPUUsage()) +#if defined(TARGET_DARWIN) || defined(TARGET_WINDOWS) + text = StringUtils::Format("{}%", CServiceBroker::GetCPUInfo()->GetUsedPercentage()); +#else + text = CServiceBroker::GetCPUInfo()->GetCoresUsageString(); +#endif + else + text = g_localizeStrings.Get(10005); // Not available + break; + } + return text; +} + +CTemperature CSystemGUIInfo::GetGPUTemperature() const +{ + int value = 0; + char scale = 0; + +#if defined(TARGET_DARWIN_OSX) + value = SMCGetTemperature(SMC_KEY_GPU_TEMP); + return CTemperature::CreateFromCelsius(value); +#elif defined(TARGET_WINDOWS_STORE) + return CTemperature::CreateFromCelsius(0); +#else + std::string cmd = CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_gpuTempCmd; + int ret = 0; + FILE* p = NULL; + + if (cmd.empty() || !(p = popen(cmd.c_str(), "r"))) + return CTemperature(); + + ret = fscanf(p, "%d %c", &value, &scale); + pclose(p); + + if (ret != 2) + return CTemperature(); +#endif + + if (scale == 'C' || scale == 'c') + return CTemperature::CreateFromCelsius(value); + if (scale == 'F' || scale == 'f') + return CTemperature::CreateFromFahrenheit(value); + return CTemperature(); +} + +void CSystemGUIInfo::UpdateFPS() +{ + m_frameCounter++; + unsigned int curTime = CTimeUtils::GetFrameTime(); + + float fTimeSpan = static_cast(curTime - m_lastFPSTime); + if (fTimeSpan >= 1000.0f) + { + fTimeSpan /= 1000.0f; + m_fps = m_frameCounter / fTimeSpan; + m_lastFPSTime = curTime; + m_frameCounter = 0; + } +} + +bool CSystemGUIInfo::InitCurrentItem(CFileItem *item) +{ + return false; +} + +bool CSystemGUIInfo::GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const +{ + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // SYSTEM_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case SYSTEM_TIME: + value = CDateTime::GetCurrentDateTime().GetAsLocalizedTime(static_cast(info.GetData1())); + return true; + case SYSTEM_DATE: + if (info.GetData3().empty()) + value = CDateTime::GetCurrentDateTime().GetAsLocalizedDate(true); + else + value = CDateTime::GetCurrentDateTime().GetAsLocalizedDate(info.GetData3()); + return true; + case SYSTEM_FREE_SPACE: + case SYSTEM_USED_SPACE: + case SYSTEM_TOTAL_SPACE: + case SYSTEM_FREE_SPACE_PERCENT: + case SYSTEM_USED_SPACE_PERCENT: + value = g_sysinfo.GetHddSpaceInfo(info.m_info); + return true; + case SYSTEM_CPU_TEMPERATURE: + case SYSTEM_GPU_TEMPERATURE: + case SYSTEM_FAN_SPEED: + case SYSTEM_CPU_USAGE: + value = GetSystemHeatInfo(info.m_info); + return true; + case SYSTEM_VIDEO_ENCODER_INFO: + case NETWORK_MAC_ADDRESS: + case SYSTEM_OS_VERSION_INFO: + case SYSTEM_CPUFREQUENCY: + case SYSTEM_INTERNET_STATE: + case SYSTEM_UPTIME: + case SYSTEM_TOTALUPTIME: + case SYSTEM_BATTERY_LEVEL: + value = g_sysinfo.GetInfo(info.m_info); + return true; + case SYSTEM_PRIVACY_POLICY: + value = g_sysinfo.GetPrivacyPolicy(); + return true; + case SYSTEM_SCREEN_RESOLUTION: + { + const auto winSystem = CServiceBroker::GetWinSystem(); + if (winSystem) + { + const RESOLUTION_INFO& resInfo = winSystem->GetGfxContext().GetResInfo(); + + if (winSystem->IsFullScreen()) + value = StringUtils::Format("{}x{} @ {:.2f} Hz - {}", resInfo.iScreenWidth, + resInfo.iScreenHeight, resInfo.fRefreshRate, + g_localizeStrings.Get(244)); + else + value = StringUtils::Format("{}x{} - {}", resInfo.iScreenWidth, resInfo.iScreenHeight, + g_localizeStrings.Get(242)); + } + else + { + value = ""; + } + return true; + } + case SYSTEM_BUILD_VERSION_SHORT: + value = CSysInfo::GetVersionShort(); + return true; + case SYSTEM_BUILD_VERSION: + value = CSysInfo::GetVersion(); + return true; + case SYSTEM_BUILD_DATE: + value = CSysInfo::GetBuildDate(); + return true; + case SYSTEM_BUILD_VERSION_CODE: + value = CSysInfo::GetVersionCode(); + return true; + case SYSTEM_BUILD_VERSION_GIT: + value = CSysInfo::GetVersionGit(); + return true; + case SYSTEM_FREE_MEMORY: + case SYSTEM_FREE_MEMORY_PERCENT: + case SYSTEM_USED_MEMORY: + case SYSTEM_USED_MEMORY_PERCENT: + case SYSTEM_TOTAL_MEMORY: + { + KODI::MEMORY::MemoryStatus stat; + KODI::MEMORY::GetMemoryStatus(&stat); + int iMemPercentFree = 100 - static_cast(100.0f * (stat.totalPhys - stat.availPhys) / stat.totalPhys + 0.5f); + int iMemPercentUsed = 100 - iMemPercentFree; + + if (info.m_info == SYSTEM_FREE_MEMORY) + value = StringUtils::Format("{}MB", static_cast(stat.availPhys / MB)); + else if (info.m_info == SYSTEM_FREE_MEMORY_PERCENT) + value = StringUtils::Format("{}%", iMemPercentFree); + else if (info.m_info == SYSTEM_USED_MEMORY) + value = StringUtils::Format( + "{}MB", static_cast((stat.totalPhys - stat.availPhys) / MB)); + else if (info.m_info == SYSTEM_USED_MEMORY_PERCENT) + value = StringUtils::Format("{}%", iMemPercentUsed); + else if (info.m_info == SYSTEM_TOTAL_MEMORY) + value = StringUtils::Format("{}MB", static_cast(stat.totalPhys / MB)); + return true; + } + case SYSTEM_SCREEN_MODE: + value = CServiceBroker::GetWinSystem()->GetGfxContext().GetResInfo().strMode; + return true; + case SYSTEM_SCREEN_WIDTH: + value = StringUtils::Format( + "{}", CServiceBroker::GetWinSystem()->GetGfxContext().GetResInfo().iScreenWidth); + return true; + case SYSTEM_SCREEN_HEIGHT: + value = StringUtils::Format( + "{}", CServiceBroker::GetWinSystem()->GetGfxContext().GetResInfo().iScreenHeight); + return true; + case SYSTEM_FPS: + value = StringUtils::Format("{:02.2f}", m_fps); + return true; +#ifdef HAS_DVD_DRIVE + case SYSTEM_DVD_LABEL: + value = CServiceBroker::GetMediaManager().GetDiskLabel(); + return true; +#endif + case SYSTEM_ALARM_POS: + if (g_alarmClock.GetRemaining("shutdowntimer") == 0.0) + value.clear(); + else + { + double fTime = g_alarmClock.GetRemaining("shutdowntimer"); + if (fTime > 60.0) + value = StringUtils::Format(g_localizeStrings.Get(13213), + g_alarmClock.GetRemaining("shutdowntimer") / 60.0); + else + value = StringUtils::Format(g_localizeStrings.Get(13214), + g_alarmClock.GetRemaining("shutdowntimer")); + } + return true; + case SYSTEM_PROFILENAME: + value = CServiceBroker::GetSettingsComponent()->GetProfileManager()->GetCurrentProfile().getName(); + return true; + case SYSTEM_PROFILECOUNT: + value = StringUtils::Format("{0}", CServiceBroker::GetSettingsComponent()->GetProfileManager()->GetNumberOfProfiles()); + return true; + case SYSTEM_PROFILEAUTOLOGIN: + { + const std::shared_ptr profileManager = CServiceBroker::GetSettingsComponent()->GetProfileManager(); + int iProfileId = profileManager->GetAutoLoginProfileId(); + if ((iProfileId < 0) || !profileManager->GetProfileName(iProfileId, value)) + value = g_localizeStrings.Get(37014); // Last used profile + return true; + } + case SYSTEM_PROFILETHUMB: + { + const std::string& thumb = CServiceBroker::GetSettingsComponent()->GetProfileManager()->GetCurrentProfile().getThumb(); + value = thumb.empty() ? "DefaultUser.png" : thumb; + return true; + } + case SYSTEM_LANGUAGE: + value = g_langInfo.GetEnglishLanguageName(); + return true; + case SYSTEM_TEMPERATURE_UNITS: + value = g_langInfo.GetTemperatureUnitString(); + return true; + case SYSTEM_FRIENDLY_NAME: + value = CSysInfo::GetDeviceName(); + return true; + case SYSTEM_STEREOSCOPIC_MODE: + { + int iStereoMode = CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_VIDEOSCREEN_STEREOSCOPICMODE); + value = std::to_string(iStereoMode); + return true; + } + case SYSTEM_GET_CORE_USAGE: + value = StringUtils::Format( + "{:4.2f}", + CServiceBroker::GetCPUInfo()->GetCoreInfo(std::stoi(info.GetData3())).m_usagePercent); + return true; + case SYSTEM_RENDER_VENDOR: + value = CServiceBroker::GetRenderSystem()->GetRenderVendor(); + return true; + case SYSTEM_RENDER_RENDERER: + value = CServiceBroker::GetRenderSystem()->GetRenderRenderer(); + return true; + case SYSTEM_RENDER_VERSION: + value = CServiceBroker::GetRenderSystem()->GetRenderVersionString(); + return true; + case SYSTEM_ADDON_UPDATE_COUNT: + value = CServiceBroker::GetAddonMgr().GetLastAvailableUpdatesCountAsString(); + return true; +#if defined(TARGET_LINUX) + case SYSTEM_PLATFORM_WINDOWING: + value = CServiceBroker::GetWinSystem()->GetName(); + StringUtils::ToCapitalize(value); + return true; +#endif + case SYSTEM_SUPPORTED_HDR_TYPES: + { + if (CServiceBroker::GetWinSystem()->IsHDRDisplay()) + { + // Assumes HDR10 minimum requirement for HDR + std::string types = "HDR10"; + + const CHDRCapabilities caps = CServiceBroker::GetWinSystem()->GetDisplayHDRCapabilities(); + + if (caps.SupportsHLG()) + types += ", HLG"; + if (caps.SupportsHDR10Plus()) + types += ", HDR10+"; + if (caps.SupportsDolbyVision()) + types += ", Dolby Vision"; + + value = types; + } + + return true; + } + + /////////////////////////////////////////////////////////////////////////////////////////////// + // NETWORK_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case NETWORK_IP_ADDRESS: + { + CNetworkInterface* iface = CServiceBroker::GetNetwork().GetFirstConnectedInterface(); + if (iface) + { + value = iface->GetCurrentIPAddress(); + return true; + } + break; + } + case NETWORK_SUBNET_MASK: + { + CNetworkInterface* iface = CServiceBroker::GetNetwork().GetFirstConnectedInterface(); + if (iface) + { + value = iface->GetCurrentNetmask(); + return true; + } + break; + } + case NETWORK_GATEWAY_ADDRESS: + { + CNetworkInterface* iface = CServiceBroker::GetNetwork().GetFirstConnectedInterface(); + if (iface) + { + value = iface->GetCurrentDefaultGateway(); + return true; + } + break; + } + case NETWORK_DNS1_ADDRESS: + { + const std::vector nss = CServiceBroker::GetNetwork().GetNameServers(); + if (nss.size() >= 1) + { + value = nss[0]; + return true; + } + break; + } + case NETWORK_DNS2_ADDRESS: + { + const std::vector nss = CServiceBroker::GetNetwork().GetNameServers(); + if (nss.size() >= 2) + { + value = nss[1]; + return true; + } + break; + } + case NETWORK_DHCP_ADDRESS: + { + // wtf? + std::string dhcpserver; + value = dhcpserver; + return true; + } + case NETWORK_LINK_STATE: + { + std::string linkStatus = g_localizeStrings.Get(151); + linkStatus += " "; + CNetworkInterface* iface = CServiceBroker::GetNetwork().GetFirstConnectedInterface(); + if (iface && iface->IsConnected()) + linkStatus += g_localizeStrings.Get(15207); + else + linkStatus += g_localizeStrings.Get(15208); + value = linkStatus; + return true; + } + } + + return false; +} + +bool CSystemGUIInfo::GetInt(int& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // SYSTEM_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case SYSTEM_FREE_MEMORY: + case SYSTEM_USED_MEMORY: + { + KODI::MEMORY::MemoryStatus stat; + KODI::MEMORY::GetMemoryStatus(&stat); + int memPercentUsed = static_cast(100.0f * (stat.totalPhys - stat.availPhys) / stat.totalPhys + 0.5f); + if (info.m_info == SYSTEM_FREE_MEMORY) + value = 100 - memPercentUsed; + else + value = memPercentUsed; + return true; + } + case SYSTEM_FREE_SPACE: + case SYSTEM_USED_SPACE: + { + g_sysinfo.GetHddSpaceInfo(value, info.m_info, true); + return true; + } + case SYSTEM_CPU_USAGE: + value = CServiceBroker::GetCPUInfo()->GetUsedPercentage(); + return true; + case SYSTEM_BATTERY_LEVEL: + value = CServiceBroker::GetPowerManager().BatteryLevel(); + return true; + } + + return false; +} + +bool CSystemGUIInfo::GetBool(bool& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // SYSTEM_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case SYSTEM_ALWAYS_TRUE: + value = true; + return true; + case SYSTEM_ALWAYS_FALSE: + value = false; + return true; + case SYSTEM_ETHERNET_LINK_ACTIVE: + // wtf: not implemented - always returns true?! + value = true; + return true; + case SYSTEM_PLATFORM_LINUX: +#if defined(TARGET_LINUX) || defined(TARGET_FREEBSD) + value = true; +#else + value = false; +#endif + return true; + case SYSTEM_PLATFORM_WINDOWS: +#ifdef TARGET_WINDOWS + value = true; +#else + value = false; +#endif + return true; + case SYSTEM_PLATFORM_UWP: +#ifdef TARGET_WINDOWS_STORE + value = true; +#else + value = false; +#endif + return true; + case SYSTEM_PLATFORM_DARWIN: +#ifdef TARGET_DARWIN + value = true; +#else + value = false; +#endif + return true; + case SYSTEM_PLATFORM_DARWIN_OSX: +#ifdef TARGET_DARWIN_OSX + value = true; +#else + value = false; +#endif + return true; + case SYSTEM_PLATFORM_DARWIN_IOS: +#ifdef TARGET_DARWIN_IOS + value = true; +#else + value = false; +#endif + return true; + case SYSTEM_PLATFORM_DARWIN_TVOS: +#ifdef TARGET_DARWIN_TVOS + value = true; +#else + value = false; +#endif + return true; + case SYSTEM_PLATFORM_ANDROID: +#if defined(TARGET_ANDROID) + value = true; +#else + value = false; +#endif + return true; + case SYSTEM_MEDIA_DVD: + value = CServiceBroker::GetMediaManager().IsDiscInDrive(); + return true; + case SYSTEM_MEDIA_AUDIO_CD: + #ifdef HAS_DVD_DRIVE + if (CServiceBroker::GetMediaManager().IsDiscInDrive()) + { + MEDIA_DETECT::CCdInfo* pCdInfo = CServiceBroker::GetMediaManager().GetCdInfo(); + value = pCdInfo && (pCdInfo->IsAudio(1) || pCdInfo->IsCDExtra(1) || pCdInfo->IsMixedMode(1)); + } + else + #endif + { + value = false; + } + return true; +#ifdef HAS_DVD_DRIVE + case SYSTEM_DVDREADY: + value = CServiceBroker::GetMediaManager().GetDriveStatus() != DriveState::NOT_READY; + return true; + case SYSTEM_TRAYOPEN: + value = CServiceBroker::GetMediaManager().GetDriveStatus() == DriveState::OPEN; + return true; +#endif + case SYSTEM_CAN_POWERDOWN: + value = CServiceBroker::GetPowerManager().CanPowerdown(); + return true; + case SYSTEM_CAN_SUSPEND: + value = CServiceBroker::GetPowerManager().CanSuspend(); + return true; + case SYSTEM_CAN_HIBERNATE: + value = CServiceBroker::GetPowerManager().CanHibernate(); + return true; + case SYSTEM_CAN_REBOOT: + value = CServiceBroker::GetPowerManager().CanReboot(); + return true; + case SYSTEM_SCREENSAVER_ACTIVE: + case SYSTEM_IS_SCREENSAVER_INHIBITED: + case SYSTEM_DPMS_ACTIVE: + case SYSTEM_IDLE_SHUTDOWN_INHIBITED: + case SYSTEM_IDLE_TIME: + { + auto& components = CServiceBroker::GetAppComponents(); + const auto appPower = components.GetComponent(); + switch (info.m_info) + { + case SYSTEM_SCREENSAVER_ACTIVE: + value = appPower->IsInScreenSaver(); + return true; + case SYSTEM_IS_SCREENSAVER_INHIBITED: + value = appPower->IsScreenSaverInhibited(); + return true; + case SYSTEM_DPMS_ACTIVE: + value = appPower->IsDPMSActive(); + return true; + case SYSTEM_IDLE_SHUTDOWN_INHIBITED: + value = appPower->IsIdleShutdownInhibited(); + return true; + case SYSTEM_IDLE_TIME: + value = appPower->GlobalIdleTime() >= static_cast(info.GetData1()); + return true; + default: + return false; + } + } + case SYSTEM_HASLOCKS: + value = CServiceBroker::GetSettingsComponent()->GetProfileManager()->GetMasterProfile().getLockMode() != LOCK_MODE_EVERYONE; + return true; + case SYSTEM_HAS_PVR: + value = true; + return true; + case SYSTEM_HAS_PVR_ADDON: + value = CServiceBroker::GetAddonMgr().HasAddons(ADDON::AddonType::PVRDLL); + return true; + case SYSTEM_HAS_CMS: +#if defined(HAS_GL) || defined(HAS_DX) + value = true; +#else + value = false; +#endif + return true; + case SYSTEM_ISMASTER: + value = CServiceBroker::GetSettingsComponent()->GetProfileManager()->GetMasterProfile().getLockMode() != LOCK_MODE_EVERYONE && g_passwordManager.bMasterUser; + return true; + case SYSTEM_ISFULLSCREEN: + value = CServiceBroker::GetWinSystem()->IsFullScreen(); + return true; + case SYSTEM_ISSTANDALONE: + value = CServiceBroker::GetAppParams()->IsStandAlone(); + return true; + case SYSTEM_HAS_SHUTDOWN: + value = (CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_POWERMANAGEMENT_SHUTDOWNTIME) > 0); + return true; + case SYSTEM_LOGGEDON: + value = !(CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow() == WINDOW_LOGIN_SCREEN); + return true; + case SYSTEM_SHOW_EXIT_BUTTON: + value = CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_showExitButton; + return true; + case SYSTEM_HAS_LOGINSCREEN: + value = CServiceBroker::GetSettingsComponent()->GetProfileManager()->UsingLoginScreen(); + return true; + case SYSTEM_INTERNET_STATE: + { + g_sysinfo.GetInfo(info.m_info); + value = g_sysinfo.HasInternet(); + return true; + } + case SYSTEM_HAS_CORE_ID: + value = CServiceBroker::GetCPUInfo()->HasCoreId(info.GetData1()); + return true; + case SYSTEM_DATE: + { + if (info.GetData2() == -1) // info doesn't contain valid startDate + return false; + const CDateTime date = CDateTime::GetCurrentDateTime(); + int currentDate = date.GetMonth() * 100 + date.GetDay(); + int startDate = info.GetData1(); + int stopDate = info.GetData2(); + + if (stopDate < startDate) + value = currentDate >= startDate || currentDate < stopDate; + else + value = currentDate >= startDate && currentDate < stopDate; + return true; + } + case SYSTEM_TIME: + { + int currentTime = CDateTime::GetCurrentDateTime().GetMinuteOfDay(); + int startTime = info.GetData1(); + int stopTime = info.GetData2(); + + if (stopTime < startTime) + value = currentTime >= startTime || currentTime < stopTime; + else + value = currentTime >= startTime && currentTime < stopTime; + return true; + } + case SYSTEM_ALARM_LESS_OR_EQUAL: + { + int time = std::lrint(g_alarmClock.GetRemaining(info.GetData3())); + int timeCompare = info.GetData2(); + if (time > 0) + value = timeCompare >= time; + else + value = false; + return true; + } + case SYSTEM_HAS_ALARM: + value = g_alarmClock.HasAlarm(info.GetData3()); + return true; + case SYSTEM_SUPPORTS_CPU_USAGE: + value = CServiceBroker::GetCPUInfo()->SupportsCPUUsage(); + return true; + case SYSTEM_GET_BOOL: + value = CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(info.GetData3()); + return true; + case SYSTEM_SETTING: + { + if (StringUtils::EqualsNoCase(info.GetData3(), "hidewatched")) + { + CGUIMediaWindow* window = GUIINFO::GetMediaWindow(contextWindow); + if (window) + { + value = CMediaSettings::GetInstance().GetWatchedMode(window->CurrentDirectory().GetContent()) == WatchedModeUnwatched; + return true; + } + } + else if (StringUtils::EqualsNoCase(info.GetData3(), "hideunwatchedepisodethumbs")) + { + const std::shared_ptr setting(std::dynamic_pointer_cast( + CServiceBroker::GetSettingsComponent()->GetSettings()->GetSetting( + CSettings::SETTING_VIDEOLIBRARY_SHOWUNWATCHEDPLOTS))); + value = setting && !CSettingUtils::FindIntInList( + setting, CSettings::VIDEOLIBRARY_THUMB_SHOW_UNWATCHED_EPISODE); + return true; + } + break; + } + } + + return false; +} diff --git a/xbmc/guilib/guiinfo/SystemGUIInfo.h b/xbmc/guilib/guiinfo/SystemGUIInfo.h new file mode 100644 index 0000000..ed2ea03 --- /dev/null +++ b/xbmc/guilib/guiinfo/SystemGUIInfo.h @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "guilib/guiinfo/GUIInfoProvider.h" +#include "utils/Temperature.h" + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +class CGUIInfo; + +class CSystemGUIInfo : public CGUIInfoProvider +{ +public: + CSystemGUIInfo(); + ~CSystemGUIInfo() override = default; + + // KODI::GUILIB::GUIINFO::IGUIInfoProvider implementation + bool InitCurrentItem(CFileItem *item) override; + bool GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const override; + bool GetInt(int& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; + bool GetBool(bool& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; + + float GetFPS() const { return m_fps; } + void UpdateFPS(); + +private: + std::string GetSystemHeatInfo(int info) const; + CTemperature GetGPUTemperature() const; + + static const int SYSTEM_HEAT_UPDATE_INTERVAL = 60000; + + mutable unsigned int m_lastSysHeatInfoTime; + mutable CTemperature m_gpuTemp; + mutable CTemperature m_cpuTemp; + int m_fanSpeed = 0; + float m_fps = 0.0; + unsigned int m_frameCounter = 0; + unsigned int m_lastFPSTime = 0; +}; + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI diff --git a/xbmc/guilib/guiinfo/VideoGUIInfo.cpp b/xbmc/guilib/guiinfo/VideoGUIInfo.cpp new file mode 100644 index 0000000..794434f --- /dev/null +++ b/xbmc/guilib/guiinfo/VideoGUIInfo.cpp @@ -0,0 +1,818 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "guilib/guiinfo/VideoGUIInfo.h" + +#include "FileItem.h" +#include "PlayListPlayer.h" +#include "ServiceBroker.h" +#include "URL.h" +#include "Util.h" +#include "application/Application.h" +#include "application/ApplicationComponents.h" +#include "application/ApplicationPlayer.h" +#include "cores/DataCacheCore.h" +#include "cores/VideoPlayer/VideoRenderers/BaseRenderer.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +#include "guilib/LocalizeStrings.h" +#include "guilib/StereoscopicsManager.h" +#include "guilib/WindowIDs.h" +#include "guilib/guiinfo/GUIInfo.h" +#include "guilib/guiinfo/GUIInfoHelper.h" +#include "guilib/guiinfo/GUIInfoLabels.h" +#include "playlists/PlayList.h" +#include "settings/AdvancedSettings.h" +#include "settings/SettingUtils.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" +#include "settings/lib/Setting.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" +#include "utils/log.h" +#include "video/VideoInfoTag.h" +#include "video/VideoThumbLoader.h" + +#include + +using namespace KODI::GUILIB; +using namespace KODI::GUILIB::GUIINFO; + +CVideoGUIInfo::CVideoGUIInfo() + : m_appPlayer(CServiceBroker::GetAppComponents().GetComponent()) +{ +} + +int CVideoGUIInfo::GetPercentPlayed(const CVideoInfoTag* tag) const +{ + CBookmark bookmark = tag->GetResumePoint(); + if (bookmark.IsPartWay()) + return std::lrintf(static_cast(bookmark.timeInSeconds) / + static_cast(bookmark.totalTimeInSeconds) * 100.0f); + else + return 0; +} + +bool CVideoGUIInfo::InitCurrentItem(CFileItem *item) +{ + if (item && item->IsVideo()) + { + // special case where .strm is used to start an audio stream + if (item->IsInternetStream() && m_appPlayer->IsPlayingAudio()) + return false; + + CLog::Log(LOGDEBUG, "CVideoGUIInfo::InitCurrentItem({})", CURL::GetRedacted(item->GetPath())); + + // Find a thumb for this file. + if (!item->HasArt("thumb")) + { + CVideoThumbLoader loader; + loader.LoadItem(item); + } + + // find a thumb for this stream + if (item->IsInternetStream()) + { + if (!g_application.m_strPlayListFile.empty()) + { + CLog::Log(LOGDEBUG, "Streaming media detected... using {} to find a thumb", + g_application.m_strPlayListFile); + CFileItem thumbItem(g_application.m_strPlayListFile,false); + + CVideoThumbLoader loader; + if (loader.FillThumb(thumbItem)) + item->SetArt("thumb", thumbItem.GetArt("thumb")); + } + } + return true; + } + return false; +} + +bool CVideoGUIInfo::GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const +{ + // For videoplayer "offset" and "position" info labels check playlist + if (info.GetData1() && ((info.m_info >= VIDEOPLAYER_OFFSET_POSITION_FIRST && + info.m_info <= VIDEOPLAYER_OFFSET_POSITION_LAST) || + (info.m_info >= PLAYER_OFFSET_POSITION_FIRST && info.m_info <= PLAYER_OFFSET_POSITION_LAST))) + return GetPlaylistInfo(value, info); + + const CVideoInfoTag* tag = item->GetVideoInfoTag(); + if (tag) + { + switch (info.m_info) + { + ///////////////////////////////////////////////////////////////////////////////////////////// + // PLAYER_* / VIDEOPLAYER_* / LISTITEM_* + ///////////////////////////////////////////////////////////////////////////////////////////// + case VIDEOPLAYER_ART: + value = item->GetArt(info.GetData3()); + return true; + case PLAYER_PATH: + case PLAYER_FILENAME: + case PLAYER_FILEPATH: + if (item->HasMusicInfoTag()) // special handling for music videos, which have both a videotag and a musictag + break; + + value = tag->m_strFileNameAndPath; + if (value.empty()) + value = item->GetPath(); + value = GUIINFO::GetFileInfoLabelValueFromPath(info.m_info, value); + return true; + case PLAYER_TITLE: + value = tag->m_strTitle; + return !value.empty(); + case VIDEOPLAYER_TITLE: + value = tag->m_strTitle; + return !value.empty(); + case LISTITEM_TITLE: + value = tag->m_strTitle; + return true; + case VIDEOPLAYER_ORIGINALTITLE: + case LISTITEM_ORIGINALTITLE: + value = tag->m_strOriginalTitle; + return true; + case VIDEOPLAYER_GENRE: + case LISTITEM_GENRE: + value = StringUtils::Join(tag->m_genre, CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_videoItemSeparator); + return true; + case VIDEOPLAYER_DIRECTOR: + case LISTITEM_DIRECTOR: + value = StringUtils::Join(tag->m_director, CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_videoItemSeparator); + return true; + case VIDEOPLAYER_IMDBNUMBER: + case LISTITEM_IMDBNUMBER: + value = tag->GetUniqueID(); + return true; + case VIDEOPLAYER_DBID: + case LISTITEM_DBID: + if (tag->m_iDbId > -1) + { + value = std::to_string(tag->m_iDbId); + return true; + } + break; + case VIDEOPLAYER_TVSHOWDBID: + case LISTITEM_TVSHOWDBID: + if (tag->m_iIdShow > -1) + { + value = std::to_string(tag->m_iIdShow); + return true; + } + break; + case VIDEOPLAYER_UNIQUEID: + case LISTITEM_UNIQUEID: + if (!info.GetData3().empty()) + value = tag->GetUniqueID(info.GetData3()); + return true; + case VIDEOPLAYER_RATING: + case LISTITEM_RATING: + { + float rating = tag->GetRating(info.GetData3()).rating; + if (rating > 0.f) + { + value = StringUtils::FormatNumber(rating); + return true; + } + break; + } + case VIDEOPLAYER_RATING_AND_VOTES: + case LISTITEM_RATING_AND_VOTES: + { + CRating rating = tag->GetRating(info.GetData3()); + if (rating.rating >= 0.f) + { + if (rating.rating > 0.f && rating.votes == 0) + value = StringUtils::FormatNumber(rating.rating); + else if (rating.votes > 0) + value = StringUtils::Format(g_localizeStrings.Get(20350), + StringUtils::FormatNumber(rating.rating), + StringUtils::FormatNumber(rating.votes)); + else + break; + return true; + } + break; + } + case VIDEOPLAYER_USER_RATING: + case LISTITEM_USER_RATING: + if (tag->m_iUserRating > 0) + { + value = std::to_string(tag->m_iUserRating); + return true; + } + break; + case VIDEOPLAYER_VOTES: + case LISTITEM_VOTES: + value = StringUtils::FormatNumber(tag->GetRating(info.GetData3()).votes); + return true; + case VIDEOPLAYER_YEAR: + case LISTITEM_YEAR: + if (tag->HasYear()) + { + value = std::to_string(tag->GetYear()); + return true; + } + break; + case VIDEOPLAYER_PREMIERED: + case LISTITEM_PREMIERED: + { + CDateTime dateTime; + if (tag->m_firstAired.IsValid()) + dateTime = tag->m_firstAired; + else if (tag->HasPremiered()) + dateTime = tag->GetPremiered(); + + if (dateTime.IsValid()) + { + value = dateTime.GetAsLocalizedDate(); + return true; + } + break; + } + case VIDEOPLAYER_PLOT: + value = tag->m_strPlot; + return true; + case VIDEOPLAYER_TRAILER: + case LISTITEM_TRAILER: + value = tag->m_strTrailer; + return true; + case VIDEOPLAYER_PLOT_OUTLINE: + case LISTITEM_PLOT_OUTLINE: + value = tag->m_strPlotOutline; + return true; + case VIDEOPLAYER_EPISODE: + case LISTITEM_EPISODE: + { + int iEpisode = -1; + if (tag->m_iEpisode > 0) + { + iEpisode = tag->m_iEpisode; + } + + if (iEpisode >= 0) + { + value = std::to_string(iEpisode); + return true; + } + break; + } + case VIDEOPLAYER_SEASON: + case LISTITEM_SEASON: + if (tag->m_iSeason >= 0) + { + value = std::to_string(tag->m_iSeason); + return true; + } + break; + case VIDEOPLAYER_TVSHOW: + case LISTITEM_TVSHOW: + value = tag->m_strShowTitle; + return true; + case VIDEOPLAYER_STUDIO: + case LISTITEM_STUDIO: + value = StringUtils::Join(tag->m_studio, CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_videoItemSeparator); + return true; + case VIDEOPLAYER_COUNTRY: + case LISTITEM_COUNTRY: + value = StringUtils::Join(tag->m_country, CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_videoItemSeparator); + return true; + case VIDEOPLAYER_MPAA: + case LISTITEM_MPAA: + value = tag->m_strMPAARating; + return true; + case VIDEOPLAYER_TOP250: + case LISTITEM_TOP250: + if (tag->m_iTop250 > 0) + { + value = std::to_string(tag->m_iTop250); + return true; + } + break; + case VIDEOPLAYER_CAST: + case LISTITEM_CAST: + value = tag->GetCast(); + return true; + case VIDEOPLAYER_CAST_AND_ROLE: + case LISTITEM_CAST_AND_ROLE: + value = tag->GetCast(true); + return true; + case VIDEOPLAYER_ARTIST: + case LISTITEM_ARTIST: + value = StringUtils::Join(tag->m_artist, CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_videoItemSeparator); + return true; + case VIDEOPLAYER_ALBUM: + case LISTITEM_ALBUM: + value = tag->m_strAlbum; + return true; + case VIDEOPLAYER_WRITER: + case LISTITEM_WRITER: + value = StringUtils::Join(tag->m_writingCredits, CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_videoItemSeparator); + return true; + case VIDEOPLAYER_TAGLINE: + case LISTITEM_TAGLINE: + value = tag->m_strTagLine; + return true; + case VIDEOPLAYER_LASTPLAYED: + case LISTITEM_LASTPLAYED: + { + const CDateTime dateTime = tag->m_lastPlayed; + if (dateTime.IsValid()) + { + value = dateTime.GetAsLocalizedDate(); + return true; + } + break; + } + case VIDEOPLAYER_PLAYCOUNT: + case LISTITEM_PLAYCOUNT: + if (tag->GetPlayCount() > 0) + { + value = std::to_string(tag->GetPlayCount()); + return true; + } + break; + + ///////////////////////////////////////////////////////////////////////////////////////////// + // LISTITEM_* + ///////////////////////////////////////////////////////////////////////////////////////////// + case LISTITEM_DURATION: + { + int iDuration = tag->GetDuration(); + if (iDuration > 0) + { + value = StringUtils::SecondsToTimeString(iDuration, static_cast(info.GetData4())); + return true; + } + break; + } + case LISTITEM_TRACKNUMBER: + if (tag->m_iTrack > -1 ) + { + value = std::to_string(tag->m_iTrack); + return true; + } + break; + case LISTITEM_PLOT: + { + std::shared_ptr setting(std::dynamic_pointer_cast( + CServiceBroker::GetSettingsComponent()->GetSettings()->GetSetting( + CSettings::SETTING_VIDEOLIBRARY_SHOWUNWATCHEDPLOTS))); + if (tag->m_type != MediaTypeTvShow && tag->m_type != MediaTypeVideoCollection && + tag->GetPlayCount() == 0 && setting && + ((tag->m_type == MediaTypeMovie && + !CSettingUtils::FindIntInList( + setting, CSettings::VIDEOLIBRARY_PLOTS_SHOW_UNWATCHED_MOVIES)) || + (tag->m_type == MediaTypeEpisode && + !CSettingUtils::FindIntInList( + setting, CSettings::VIDEOLIBRARY_PLOTS_SHOW_UNWATCHED_TVSHOWEPISODES)))) + { + value = g_localizeStrings.Get(20370); + } + else + { + value = tag->m_strPlot; + } + return true; + } + case LISTITEM_STATUS: + value = tag->m_strStatus; + return true; + case LISTITEM_TAG: + value = StringUtils::Join(tag->m_tags, CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_videoItemSeparator); + return true; + case LISTITEM_SET: + value = tag->m_set.title; + return true; + case LISTITEM_SETID: + if (tag->m_set.id > 0) + { + value = std::to_string(tag->m_set.id); + return true; + } + break; + case LISTITEM_ENDTIME_RESUME: + { + const CDateTimeSpan duration(0, 0, 0, tag->GetDuration() - tag->GetResumePoint().timeInSeconds); + value = (CDateTime::GetCurrentDateTime() + duration).GetAsLocalizedTime("", false); + return true; + } + case LISTITEM_ENDTIME: + { + const CDateTimeSpan duration(0, 0, 0, tag->GetDuration()); + value = (CDateTime::GetCurrentDateTime() + duration).GetAsLocalizedTime("", false); + return true; + } + case LISTITEM_DATE_ADDED: + if (tag->m_dateAdded.IsValid()) + { + value = tag->m_dateAdded.GetAsLocalizedDate(); + return true; + } + break; + case LISTITEM_DBTYPE: + value = tag->m_type; + return true; + case LISTITEM_APPEARANCES: + if (tag->m_relevance > -1) + { + value = std::to_string(tag->m_relevance); + return true; + } + break; + case LISTITEM_PERCENT_PLAYED: + value = std::to_string(GetPercentPlayed(tag)); + return true; + case LISTITEM_VIDEO_CODEC: + value = tag->m_streamDetails.GetVideoCodec(); + return true; + case LISTITEM_VIDEO_RESOLUTION: + value = CStreamDetails::VideoDimsToResolutionDescription(tag->m_streamDetails.GetVideoWidth(), tag->m_streamDetails.GetVideoHeight()); + return true; + case LISTITEM_VIDEO_ASPECT: + value = CStreamDetails::VideoAspectToAspectDescription(tag->m_streamDetails.GetVideoAspect()); + return true; + case LISTITEM_AUDIO_CODEC: + value = tag->m_streamDetails.GetAudioCodec(); + return true; + case LISTITEM_AUDIO_CHANNELS: + { + int iChannels = tag->m_streamDetails.GetAudioChannels(); + if (iChannels > 0) + { + value = std::to_string(iChannels); + return true; + } + break; + } + case LISTITEM_AUDIO_LANGUAGE: + value = tag->m_streamDetails.GetAudioLanguage(); + return true; + case LISTITEM_SUBTITLE_LANGUAGE: + value = tag->m_streamDetails.GetSubtitleLanguage(); + return true; + case LISTITEM_FILENAME: + case LISTITEM_FILE_EXTENSION: + if (item->IsVideoDb()) + value = URIUtils::GetFileName(tag->m_strFileNameAndPath); + else if (item->HasMusicInfoTag()) // special handling for music videos, which have both a videotag and a musictag + break; + else + value = URIUtils::GetFileName(item->GetPath()); + + if (info.m_info == LISTITEM_FILE_EXTENSION) + { + std::string strExtension = URIUtils::GetExtension(value); + value = StringUtils::TrimLeft(strExtension, "."); + } + return true; + case LISTITEM_FOLDERNAME: + case LISTITEM_PATH: + if (item->IsVideoDb()) + { + if (item->m_bIsFolder) + value = tag->m_strPath; + else + URIUtils::GetParentPath(tag->m_strFileNameAndPath, value); + } + else if (item->HasMusicInfoTag()) // special handling for music videos, which have both a videotag and a musictag + break; + else + URIUtils::GetParentPath(item->GetPath(), value); + + value = CURL(value).GetWithoutUserDetails(); + + if (info.m_info == LISTITEM_FOLDERNAME) + { + URIUtils::RemoveSlashAtEnd(value); + value = URIUtils::GetFileName(value); + } + return true; + case LISTITEM_FILENAME_AND_PATH: + if (item->IsVideoDb()) + value = tag->m_strFileNameAndPath; + else if (item->HasMusicInfoTag()) // special handling for music videos, which have both a videotag and a musictag + break; + else + value = item->GetPath(); + + value = CURL(value).GetWithoutUserDetails(); + return true; + case LISTITEM_VIDEO_HDR_TYPE: + value = tag->m_streamDetails.GetVideoHdrType(); + return true; + } + } + + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // VIDEOPLAYER_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case VIDEOPLAYER_PLAYLISTLEN: + if (CServiceBroker::GetPlaylistPlayer().GetCurrentPlaylist() == PLAYLIST::TYPE_VIDEO) + { + value = GUIINFO::GetPlaylistLabel(PLAYLIST_LENGTH); + return true; + } + break; + case VIDEOPLAYER_PLAYLISTPOS: + if (CServiceBroker::GetPlaylistPlayer().GetCurrentPlaylist() == PLAYLIST::TYPE_VIDEO) + { + value = GUIINFO::GetPlaylistLabel(PLAYLIST_POSITION); + return true; + } + break; + case VIDEOPLAYER_VIDEO_ASPECT: + value = CStreamDetails::VideoAspectToAspectDescription(CServiceBroker::GetDataCacheCore().GetVideoDAR()); + return true; + case VIDEOPLAYER_STEREOSCOPIC_MODE: + value = CServiceBroker::GetDataCacheCore().GetVideoStereoMode(); + return true; + case VIDEOPLAYER_SUBTITLES_LANG: + value = m_subtitleInfo.language; + return true; + break; + case VIDEOPLAYER_COVER: + if (m_appPlayer->IsPlayingVideo()) + { + if (fallback) + *fallback = "DefaultVideoCover.png"; + + value = item->HasArt("thumb") ? item->GetArt("thumb") : "DefaultVideoCover.png"; + return true; + } + break; + + /////////////////////////////////////////////////////////////////////////////////////////////// + // LISTITEM_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case LISTITEM_STEREOSCOPIC_MODE: + value = item->GetProperty("stereomode").asString(); + if (value.empty() && tag) + value = CStereoscopicsManager::NormalizeStereoMode(tag->m_streamDetails.GetStereoMode()); + return true; + + /////////////////////////////////////////////////////////////////////////////////////////////// + // VIDEOPLAYER_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case VIDEOPLAYER_VIDEO_CODEC: + value = m_videoInfo.codecName; + return true; + case VIDEOPLAYER_VIDEO_RESOLUTION: + value = CStreamDetails::VideoDimsToResolutionDescription(m_videoInfo.width, m_videoInfo.height); + return true; + case VIDEOPLAYER_HDR_TYPE: + value = CStreamDetails::HdrTypeToString(m_videoInfo.hdrType); + return true; + case VIDEOPLAYER_AUDIO_CODEC: + value = m_audioInfo.codecName; + return true; + case VIDEOPLAYER_AUDIO_CHANNELS: + { + int iChannels = m_audioInfo.channels; + if (iChannels > 0) + { + value = std::to_string(iChannels); + return true; + } + break; + } + case VIDEOPLAYER_AUDIO_BITRATE: + { + int iBitrate = m_audioInfo.bitrate; + if (iBitrate > 0) + { + value = std::to_string(std::lrint(static_cast(iBitrate) / 1000.0)); + return true; + } + break; + } + case VIDEOPLAYER_VIDEO_BITRATE: + { + int iBitrate = m_videoInfo.bitrate; + if (iBitrate > 0) + { + value = std::to_string(std::lrint(static_cast(iBitrate) / 1000.0)); + return true; + } + break; + } + case VIDEOPLAYER_AUDIO_LANG: + value = m_audioInfo.language; + return true; + } + + return false; +} + +bool CVideoGUIInfo::GetPlaylistInfo(std::string& value, const CGUIInfo& info) const +{ + const PLAYLIST::CPlayList& playlist = + CServiceBroker::GetPlaylistPlayer().GetPlaylist(PLAYLIST::TYPE_VIDEO); + if (playlist.size() < 1) + return false; + + int index = info.GetData2(); + if (info.GetData1() == 1) + { // relative index (requires current playlist is TYPE_VIDEO) + if (CServiceBroker::GetPlaylistPlayer().GetCurrentPlaylist() != PLAYLIST::TYPE_VIDEO) + return false; + + index = CServiceBroker::GetPlaylistPlayer().GetNextSong(index); + } + + if (index < 0 || index >= playlist.size()) + return false; + + const CFileItemPtr playlistItem = playlist[index]; + // try to set a thumbnail + if (!playlistItem->HasArt("thumb")) + { + CVideoThumbLoader loader; + loader.LoadItem(playlistItem.get()); + // still no thumb? then just the set the default cover + if (!playlistItem->HasArt("thumb")) + playlistItem->SetArt("thumb", "DefaultVideoCover.png"); + } + if (info.m_info == VIDEOPLAYER_PLAYLISTPOS) + { + value = std::to_string(index + 1); + return true; + } + else if (info.m_info == VIDEOPLAYER_COVER) + { + value = playlistItem->GetArt("thumb"); + return true; + } + else if (info.m_info == VIDEOPLAYER_ART) + { + value = playlistItem->GetArt(info.GetData3()); + return true; + } + + return GetLabel(value, playlistItem.get(), 0, CGUIInfo(info.m_info), nullptr); +} + +bool CVideoGUIInfo::GetFallbackLabel(std::string& value, + const CFileItem* item, + int contextWindow, + const CGUIInfo& info, + std::string* fallback) +{ + // No fallback for videoplayer "offset" and "position" info labels + if (info.GetData1() && ((info.m_info >= VIDEOPLAYER_OFFSET_POSITION_FIRST && + info.m_info <= VIDEOPLAYER_OFFSET_POSITION_LAST) || + (info.m_info >= PLAYER_OFFSET_POSITION_FIRST && info.m_info <= PLAYER_OFFSET_POSITION_LAST))) + return false; + + const CVideoInfoTag* tag = item->GetVideoInfoTag(); + if (tag) + { + switch (info.m_info) + { + ///////////////////////////////////////////////////////////////////////////////////////////// + // VIDEOPLAYER_* + ///////////////////////////////////////////////////////////////////////////////////////////// + case VIDEOPLAYER_TITLE: + value = item->GetLabel(); + if (value.empty()) + value = CUtil::GetTitleFromPath(item->GetPath()); + return true; + default: + break; + } + } + return false; +} + +bool CVideoGUIInfo::GetInt(int& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + if (!gitem->IsFileItem()) + return false; + + const CFileItem *item = static_cast(gitem); + const CVideoInfoTag* tag = item->GetVideoInfoTag(); + if (tag) + { + switch (info.m_info) + { + ///////////////////////////////////////////////////////////////////////////////////////////// + // LISTITEM_* + ///////////////////////////////////////////////////////////////////////////////////////////// + case LISTITEM_PERCENT_PLAYED: + value = GetPercentPlayed(tag); + return true; + } + } + + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // VIDEOPLAYER_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case VIDEOPLAYER_AUDIOSTREAMCOUNT: + value = m_appPlayer->GetAudioStreamCount(); + return true; + + default: + break; + } + + return false; +} + +bool CVideoGUIInfo::GetBool(bool& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + if (!gitem->IsFileItem()) + return false; + + const CFileItem *item = static_cast(gitem); + const CVideoInfoTag* tag = item->GetVideoInfoTag(); + if (tag) + { + switch (info.m_info) + { + ///////////////////////////////////////////////////////////////////////////////////////////// + // VIDEOPLAYER_* + ///////////////////////////////////////////////////////////////////////////////////////////// + case VIDEOPLAYER_HAS_INFO: + value = !tag->IsEmpty(); + return true; + + ///////////////////////////////////////////////////////////////////////////////////////////// + // LISTITEM_* + ///////////////////////////////////////////////////////////////////////////////////////////// + case LISTITEM_IS_RESUMABLE: + value = tag->GetResumePoint().timeInSeconds > 0; + return true; + case LISTITEM_IS_COLLECTION: + value = tag->m_type == MediaTypeVideoCollection; + return true; + } + } + + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // VIDEOPLAYER_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case VIDEOPLAYER_CONTENT: + { + std::string strContent = "files"; + if (tag) + { + if (tag->m_type == MediaTypeMovie) + strContent = "movies"; + else if (tag->m_type == MediaTypeEpisode) + strContent = "episodes"; + else if (tag->m_type == MediaTypeMusicVideo) + strContent = "musicvideos"; + } + value = StringUtils::EqualsNoCase(info.GetData3(), strContent); + return value; // if no match for this provider, other providers shall be asked. + } + case VIDEOPLAYER_USING_OVERLAYS: + value = (CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_VIDEOPLAYER_RENDERMETHOD) == RENDER_OVERLAYS); + return true; + case VIDEOPLAYER_ISFULLSCREEN: + value = CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow() == WINDOW_FULLSCREEN_VIDEO || + CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow() == WINDOW_FULLSCREEN_GAME; + return true; + case VIDEOPLAYER_HASMENU: + value = m_appPlayer->GetSupportedMenuType() != MenuType::NONE; + return true; + case VIDEOPLAYER_HASTELETEXT: + value = m_appPlayer->HasTeletextCache(); + return true; + case VIDEOPLAYER_HASSUBTITLES: + value = m_appPlayer->GetSubtitleCount() > 0; + return true; + case VIDEOPLAYER_SUBTITLESENABLED: + value = m_appPlayer->GetSubtitleVisible(); + return true; + case VIDEOPLAYER_IS_STEREOSCOPIC: + value = !CServiceBroker::GetDataCacheCore().GetVideoStereoMode().empty(); + return true; + + /////////////////////////////////////////////////////////////////////////////////////////////// + // LISTITEM_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case LISTITEM_IS_STEREOSCOPIC: + { + std::string stereoMode = item->GetProperty("stereomode").asString(); + if (stereoMode.empty() && tag) + stereoMode = CStereoscopicsManager::NormalizeStereoMode(tag->m_streamDetails.GetStereoMode()); + if (!stereoMode.empty() && stereoMode != "mono") + value = true; + return true; + } + } + + return false; +} diff --git a/xbmc/guilib/guiinfo/VideoGUIInfo.h b/xbmc/guilib/guiinfo/VideoGUIInfo.h new file mode 100644 index 0000000..55202b2 --- /dev/null +++ b/xbmc/guilib/guiinfo/VideoGUIInfo.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "guilib/guiinfo/GUIInfoProvider.h" + +#include + +class CApplicationPlayer; +class CVideoInfoTag; + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +class CGUIInfo; + +class CVideoGUIInfo : public CGUIInfoProvider +{ +public: + CVideoGUIInfo(); + ~CVideoGUIInfo() override = default; + + // KODI::GUILIB::GUIINFO::IGUIInfoProvider implementation + bool InitCurrentItem(CFileItem *item) override; + bool GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const override; + bool GetFallbackLabel(std::string& value, + const CFileItem* item, + int contextWindow, + const CGUIInfo& info, + std::string* fallback) override; + bool GetInt(int& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; + bool GetBool(bool& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; + +private: + int GetPercentPlayed(const CVideoInfoTag* tag) const; + bool GetPlaylistInfo(std::string& value, const CGUIInfo& info) const; + + const std::shared_ptr m_appPlayer; +}; + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI diff --git a/xbmc/guilib/guiinfo/VisualisationGUIInfo.cpp b/xbmc/guilib/guiinfo/VisualisationGUIInfo.cpp new file mode 100644 index 0000000..27a892f --- /dev/null +++ b/xbmc/guilib/guiinfo/VisualisationGUIInfo.cpp @@ -0,0 +1,115 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "guilib/guiinfo/VisualisationGUIInfo.h" + +#include "GUIUserMessages.h" +#include "ServiceBroker.h" +#include "addons/Addon.h" +#include "addons/AddonManager.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIVisualisationControl.h" +#include "guilib/GUIWindowManager.h" +#include "guilib/guiinfo/GUIInfo.h" +#include "guilib/guiinfo/GUIInfoLabels.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" +#include "utils/URIUtils.h" + +using namespace KODI::GUILIB::GUIINFO; + +bool CVisualisationGUIInfo::InitCurrentItem(CFileItem *item) +{ + return false; +} + +bool CVisualisationGUIInfo::GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const +{ + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // VISUALISATION_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case VISUALISATION_PRESET: + { + CGUIMessage msg(GUI_MSG_GET_VISUALISATION, 0, 0); + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(msg); + if (msg.GetPointer()) + { + CGUIVisualisationControl* viz = static_cast(msg.GetPointer()); + if (viz) + { + value = viz->GetActivePresetName(); + URIUtils::RemoveExtension(value); + return true; + } + } + break; + } + case VISUALISATION_NAME: + { + ADDON::AddonPtr addon; + value = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_MUSICPLAYER_VISUALISATION); + if (CServiceBroker::GetAddonMgr().GetAddon(value, addon, ADDON::OnlyEnabled::CHOICE_YES) && + addon) + { + value = addon->Name(); + return true; + } + break; + } + } + + return false; +} + +bool CVisualisationGUIInfo::GetInt(int& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + return false; +} + +bool CVisualisationGUIInfo::GetBool(bool& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // VISUALISATION_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case VISUALISATION_LOCKED: + { + CGUIMessage msg(GUI_MSG_GET_VISUALISATION, 0, 0); + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(msg); + if (msg.GetPointer()) + { + CGUIVisualisationControl *pVis = static_cast(msg.GetPointer()); + value = pVis->IsLocked(); + return true; + } + break; + } + case VISUALISATION_ENABLED: + { + value = !CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_MUSICPLAYER_VISUALISATION).empty(); + return true; + } + case VISUALISATION_HAS_PRESETS: + { + CGUIMessage msg(GUI_MSG_GET_VISUALISATION, 0, 0); + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(msg); + if (msg.GetPointer()) + { + CGUIVisualisationControl* viz = static_cast(msg.GetPointer()); + value = (viz && viz->HasPresets()); + return true; + } + break; + } + } + + return false; +} diff --git a/xbmc/guilib/guiinfo/VisualisationGUIInfo.h b/xbmc/guilib/guiinfo/VisualisationGUIInfo.h new file mode 100644 index 0000000..d3cb05d --- /dev/null +++ b/xbmc/guilib/guiinfo/VisualisationGUIInfo.h @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "guilib/guiinfo/GUIInfoProvider.h" + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +class CGUIInfo; + +class CVisualisationGUIInfo : public CGUIInfoProvider +{ +public: + CVisualisationGUIInfo() = default; + ~CVisualisationGUIInfo() override = default; + + // KODI::GUILIB::GUIINFO::IGUIInfoProvider implementation + bool InitCurrentItem(CFileItem *item) override; + bool GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const override; + bool GetInt(int& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; + bool GetBool(bool& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; +}; + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI diff --git a/xbmc/guilib/guiinfo/WeatherGUIInfo.cpp b/xbmc/guilib/guiinfo/WeatherGUIInfo.cpp new file mode 100644 index 0000000..3aa2044 --- /dev/null +++ b/xbmc/guilib/guiinfo/WeatherGUIInfo.cpp @@ -0,0 +1,81 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "guilib/guiinfo/WeatherGUIInfo.h" + +#include "FileItem.h" +#include "LangInfo.h" +#include "ServiceBroker.h" +#include "guilib/guiinfo/GUIInfo.h" +#include "guilib/guiinfo/GUIInfoLabels.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" +#include "weather/WeatherManager.h" + +using namespace KODI::GUILIB::GUIINFO; + +bool CWeatherGUIInfo::InitCurrentItem(CFileItem *item) +{ + return false; +} + +bool CWeatherGUIInfo::GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const +{ + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // WEATHER_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case WEATHER_CONDITIONS_TEXT: + value = CServiceBroker::GetWeatherManager().GetInfo(WEATHER_LABEL_CURRENT_COND); + StringUtils::Trim(value); + return true; + case WEATHER_CONDITIONS_ICON: + value = CServiceBroker::GetWeatherManager().GetInfo(WEATHER_IMAGE_CURRENT_ICON); + return true; + case WEATHER_TEMPERATURE: + value = StringUtils::Format( + "{}{}", CServiceBroker::GetWeatherManager().GetInfo(WEATHER_LABEL_CURRENT_TEMP), + g_langInfo.GetTemperatureUnitString()); + return true; + case WEATHER_LOCATION: + value = CServiceBroker::GetWeatherManager().GetInfo(WEATHER_LABEL_LOCATION); + return true; + case WEATHER_FANART_CODE: + value = URIUtils::GetFileName(CServiceBroker::GetWeatherManager().GetInfo(WEATHER_IMAGE_CURRENT_ICON)); + URIUtils::RemoveExtension(value); + return true; + case WEATHER_PLUGIN: + value = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_WEATHER_ADDON); + return true; + } + + return false; +} + +bool CWeatherGUIInfo::GetInt(int& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + return false; +} + +bool CWeatherGUIInfo::GetBool(bool& value, const CGUIListItem *gitem, int contextWindow, const CGUIInfo &info) const +{ + switch (info.m_info) + { + /////////////////////////////////////////////////////////////////////////////////////////////// + // WEATHER_* + /////////////////////////////////////////////////////////////////////////////////////////////// + case WEATHER_IS_FETCHED: + value = CServiceBroker::GetWeatherManager().IsFetched(); + return true;; + } + + return false; +} diff --git a/xbmc/guilib/guiinfo/WeatherGUIInfo.h b/xbmc/guilib/guiinfo/WeatherGUIInfo.h new file mode 100644 index 0000000..560d025 --- /dev/null +++ b/xbmc/guilib/guiinfo/WeatherGUIInfo.h @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "guilib/guiinfo/GUIInfoProvider.h" + +namespace KODI +{ +namespace GUILIB +{ +namespace GUIINFO +{ + +class CGUIInfo; + +class CWeatherGUIInfo : public CGUIInfoProvider +{ +public: + CWeatherGUIInfo() = default; + ~CWeatherGUIInfo() override = default; + + // KODI::GUILIB::GUIINFO::IGUIInfoProvider implementation + bool InitCurrentItem(CFileItem *item) override; + bool GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const override; + bool GetInt(int& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; + bool GetBool(bool& value, const CGUIListItem *item, int contextWindow, const CGUIInfo &info) const override; +}; + +} // namespace GUIINFO +} // namespace GUILIB +} // namespace KODI -- cgit v1.2.3