diff options
Diffstat (limited to '')
35 files changed, 5362 insertions, 0 deletions
diff --git a/xbmc/interfaces/builtins/AddonBuiltins.cpp b/xbmc/interfaces/builtins/AddonBuiltins.cpp new file mode 100644 index 0000000..056128d --- /dev/null +++ b/xbmc/interfaces/builtins/AddonBuiltins.cpp @@ -0,0 +1,522 @@ +/* + * 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 "AddonBuiltins.h" + +#include "FileItem.h" +#include "GUIPassword.h" +#include "GUIUserMessages.h" +#include "ServiceBroker.h" +#include "addons/AddonInstaller.h" +#include "addons/AddonManager.h" +#include "addons/AddonSystemSettings.h" +#include "addons/PluginSource.h" +#include "addons/RepositoryUpdater.h" +#include "addons/addoninfo/AddonInfo.h" +#include "addons/addoninfo/AddonType.h" +#include "addons/gui/GUIDialogAddonSettings.h" +#include "addons/gui/GUIWindowAddonBrowser.h" +#include "application/Application.h" +#include "filesystem/PluginDirectory.h" +#include "games/tags/GameInfoTag.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +#include "interfaces/generic/ScriptInvocationManager.h" +#include "messaging/helpers/DialogHelper.h" +#include "playlists/PlayListTypes.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" +#include "utils/log.h" + +#include <memory> + +#if defined(TARGET_DARWIN) +#include "filesystem/SpecialProtocol.h" +#if defined(TARGET_DARWIN_OSX) +#include "platform/darwin/osx/CocoaInterface.h" +#endif +#endif + +using namespace ADDON; +using namespace KODI::MESSAGING; +using KODI::MESSAGING::HELPERS::DialogResponse; + +/*! \brief Install an addon. + * \param params The parameters. + * \details params[0] = add-on id. + */ +static int InstallAddon(const std::vector<std::string>& params) +{ + const std::string& addonid = params[0]; + + AddonPtr addon; + CAddonInstaller::GetInstance().InstallModal(addonid, addon, InstallModalPrompt::CHOICE_YES); + + return 0; +} + +/*! \brief Enable an addon. + * \param params The parameters. + * \details params[0] = add-on id. + */ +static int EnableAddon(const std::vector<std::string>& params) +{ + const std::string& addonid = params[0]; + + if (!g_passwordManager.CheckMenuLock(WINDOW_ADDON_BROWSER)) + return -1; + + AddonPtr addon; + if (!CServiceBroker::GetAddonMgr().GetAddon(addonid, addon, OnlyEnabled::CHOICE_NO)) + return -1; + + auto response = HELPERS::ShowYesNoDialogLines(CVariant{24076}, CVariant{24135}, CVariant{addon->Name()}, CVariant{24136}); + if (response == DialogResponse::CHOICE_YES) + CServiceBroker::GetAddonMgr().EnableAddon(addonid); + + return 0; +} + +/*! \brief Run a plugin. + * \param params The parameters. + * \details params[0] = plugin:// URL to script. + */ +static int RunPlugin(const std::vector<std::string>& params) +{ + if (params.size()) + { + CFileItem item(params[0]); + if (!item.m_bIsFolder) + { + item.SetPath(params[0]); + XFILE::CPluginDirectory::RunScriptWithParams(item.GetPath(), false); + } + } + else + CLog::Log(LOGERROR, "RunPlugin called with no arguments."); + + return 0; +} + +/*! \brief Run a script, plugin or game add-on. + * \param params The parameters. + * \details params[0] = add-on id. + * params[1] is blank for no add-on parameters + * or + * params[1] = add-on parameters in url format + * or + * params[1,...] = additional parameters in format param=value. + */ +static int RunAddon(const std::vector<std::string>& params) +{ + if (params.size()) + { + const std::string& addonid = params[0]; + + AddonPtr addon; + if (CServiceBroker::GetAddonMgr().GetAddon(addonid, addon, AddonType::PLUGIN, + OnlyEnabled::CHOICE_YES)) + { + const auto plugin = std::dynamic_pointer_cast<CPluginSource>(addon); + std::string urlParameters; + std::vector<std::string> parameters; + if (params.size() == 2 && + (StringUtils::StartsWith(params[1], "/") || StringUtils::StartsWith(params[1], "?"))) + urlParameters = params[1]; + else if (params.size() > 1) + { + parameters.insert(parameters.begin(), params.begin() + 1, params.end()); + urlParameters = "?" + StringUtils::Join(parameters, "&"); + } + else + { + // Add '/' if addon is run without params (will be removed later so it's safe) + // Otherwise there are 2 entries for the same plugin in ViewModesX.db + urlParameters = "/"; + } + + std::string cmd; + if (plugin->Provides(CPluginSource::VIDEO)) + cmd = StringUtils::Format("ActivateWindow(Videos,plugin://{}{},return)", addonid, + urlParameters); + else if (plugin->Provides(CPluginSource::AUDIO)) + cmd = StringUtils::Format("ActivateWindow(Music,plugin://{}{},return)", addonid, + urlParameters); + else if (plugin->Provides(CPluginSource::EXECUTABLE)) + cmd = StringUtils::Format("ActivateWindow(Programs,plugin://{}{},return)", addonid, + urlParameters); + else if (plugin->Provides(CPluginSource::IMAGE)) + cmd = StringUtils::Format("ActivateWindow(Pictures,plugin://{}{},return)", addonid, + urlParameters); + else if (plugin->Provides(CPluginSource::GAME)) + cmd = StringUtils::Format("ActivateWindow(Games,plugin://{}{},return)", addonid, + urlParameters); + else + // Pass the script name (addonid) and all the parameters + // (params[1] ... params[x]) separated by a comma to RunPlugin + cmd = StringUtils::Format("RunPlugin({})", StringUtils::Join(params, ",")); + CBuiltins::GetInstance().Execute(cmd); + } + else if (CServiceBroker::GetAddonMgr().GetAddon(addonid, addon, AddonType::SCRIPT, + OnlyEnabled::CHOICE_YES) || + CServiceBroker::GetAddonMgr().GetAddon(addonid, addon, AddonType::SCRIPT_WEATHER, + OnlyEnabled::CHOICE_YES) || + CServiceBroker::GetAddonMgr().GetAddon(addonid, addon, AddonType::SCRIPT_LYRICS, + OnlyEnabled::CHOICE_YES) || + CServiceBroker::GetAddonMgr().GetAddon(addonid, addon, AddonType::SCRIPT_LIBRARY, + OnlyEnabled::CHOICE_YES)) + { + // Pass the script name (addonid) and all the parameters + // (params[1] ... params[x]) separated by a comma to RunScript + CBuiltins::GetInstance().Execute( + StringUtils::Format("RunScript({})", StringUtils::Join(params, ","))); + } + else if (CServiceBroker::GetAddonMgr().GetAddon(addonid, addon, AddonType::GAMEDLL, + OnlyEnabled::CHOICE_YES)) + { + CFileItem item; + + if (params.size() >= 2) + { + item = CFileItem(params[1], false); + item.GetGameInfoTag()->SetGameClient(addonid); + } + else + item = CFileItem(addon); + + if (!g_application.PlayMedia(item, "", PLAYLIST::TYPE_NONE)) + { + CLog::Log(LOGERROR, "RunAddon could not start {}", addonid); + return false; + } + } + else + CLog::Log( + LOGERROR, + "RunAddon: unknown add-on id '{}', or unexpected add-on type (not a script or plugin).", + addonid); + } + else + { + CLog::Log(LOGERROR, "RunAddon called with no arguments."); + } + + return 0; +} + +/*! \brief Run a script add-on or an apple script. + * \param params The parameters. + * \details params[0] is the URL to the apple script + * or + * params[0] is the addon-ID to the script add-on + * or + * params[0] is the URL to the python script. + * + * Set the OnlyApple template parameter to true to only attempt + * execution of applescripts. + */ +template<bool OnlyApple=false> +static int RunScript(const std::vector<std::string>& params) +{ +#if defined(TARGET_DARWIN_OSX) + std::string execute; + std::string parameter = params.size() ? params[0] : ""; + if (URIUtils::HasExtension(parameter, ".applescript|.scpt")) + { + std::string osxPath = CSpecialProtocol::TranslatePath(parameter); + Cocoa_DoAppleScriptFile(osxPath.c_str()); + } + else if (OnlyApple) + return 1; + else +#endif + { + AddonPtr addon; + std::string scriptpath; + // Test to see if the param is an addon ID + if (CServiceBroker::GetAddonMgr().GetAddon(params[0], addon, OnlyEnabled::CHOICE_YES)) + { + //Get the correct extension point to run + if (CServiceBroker::GetAddonMgr().GetAddon(params[0], addon, AddonType::SCRIPT, + OnlyEnabled::CHOICE_YES) || + CServiceBroker::GetAddonMgr().GetAddon(params[0], addon, AddonType::SCRIPT_WEATHER, + OnlyEnabled::CHOICE_YES) || + CServiceBroker::GetAddonMgr().GetAddon(params[0], addon, AddonType::SCRIPT_LYRICS, + OnlyEnabled::CHOICE_YES) || + CServiceBroker::GetAddonMgr().GetAddon(params[0], addon, AddonType::SCRIPT_LIBRARY, + OnlyEnabled::CHOICE_YES)) + { + scriptpath = addon->LibPath(); + } + else + { + // Run a random extension point (old behaviour). + if (CServiceBroker::GetAddonMgr().GetAddon(params[0], addon, OnlyEnabled::CHOICE_YES)) + { + scriptpath = addon->LibPath(); + CLog::Log(LOGWARNING, + "RunScript called for a non-script addon '{}'. This behaviour is deprecated.", + params[0]); + } + else + { + CLog::Log(LOGERROR, "{} - Could not get addon: {}", __FUNCTION__, params[0]); + } + } + } + else + scriptpath = params[0]; + + // split the path up to find the filename + std::vector<std::string> argv = params; + std::string filename = URIUtils::GetFileName(scriptpath); + if (!filename.empty()) + argv[0] = filename; + + CScriptInvocationManager::GetInstance().ExecuteAsync(scriptpath, addon, argv); + } + + return 0; +} + +/*! \brief Open the settings for the default add-on of a given type. + * \param params The parameters. + * \details params[0] = The add-on type. + */ +static int OpenDefaultSettings(const std::vector<std::string>& params) +{ + AddonPtr addon; + AddonType type = CAddonInfo::TranslateType(params[0]); + if (CAddonSystemSettings::GetInstance().GetActive(type, addon)) + { + bool changed = CGUIDialogAddonSettings::ShowForAddon(addon); + if (type == AddonType::VISUALIZATION && changed) + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(GUI_MSG_VISUALISATION_RELOAD, 0, 0); + } + + return 0; +} + +/*! \brief Set the default add-on for a given type. + * \param params The parameters. + * \details params[0] = The add-on type + */ +static int SetDefaultAddon(const std::vector<std::string>& params) +{ + std::string addonID; + AddonType type = CAddonInfo::TranslateType(params[0]); + bool allowNone = false; + if (type == AddonType::VISUALIZATION) + allowNone = true; + + if (type != AddonType::UNKNOWN && CGUIWindowAddonBrowser::SelectAddonID(type, addonID, allowNone)) + { + CAddonSystemSettings::GetInstance().SetActive(type, addonID); + if (type == AddonType::VISUALIZATION) + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(GUI_MSG_VISUALISATION_RELOAD, 0, 0); + } + + return 0; +} + +/*! \brief Open the settings for a given add-on. + * \param params The parameters. + * \details params[0] = The add-on ID. + */ +static int AddonSettings(const std::vector<std::string>& params) +{ + AddonPtr addon; + if (CServiceBroker::GetAddonMgr().GetAddon(params[0], addon, OnlyEnabled::CHOICE_YES)) + CGUIDialogAddonSettings::ShowForAddon(addon); + + return 0; +} + +/*! \brief Open the settings for a given add-on. +* \param params The parameters. +*/ +static int InstallFromZip(const std::vector<std::string>& params) +{ + CGUIWindowAddonBrowser::InstallFromZip(); + return 0; +} + +/*! \brief Stop a running script. + * \param params The parameters. + * \details params[0] = The add-on ID of the script to stop + * or + * params[0] = The URL of the script to stop. + */ +static int StopScript(const std::vector<std::string>& params) +{ + //! @todo FIXME: This does not work for addons with multiple extension points! + //! Are there any use for this? TODO: Fix hack in CScreenSaver::Destroy() and deprecate. + std::string scriptpath(params[0]); + // Test to see if the param is an addon ID + AddonPtr script; + if (CServiceBroker::GetAddonMgr().GetAddon(params[0], script, OnlyEnabled::CHOICE_YES)) + scriptpath = script->LibPath(); + CScriptInvocationManager::GetInstance().Stop(scriptpath); + + return 0; +} + +/*! \brief Check add-on repositories for updates. + * \param params (ignored) + */ +static int UpdateRepos(const std::vector<std::string>& params) +{ + CServiceBroker::GetRepositoryUpdater().CheckForUpdates(); + + return 0; +} + +/*! \brief Check local add-on directories for updates. + * \param params (ignored) + */ +static int UpdateLocals(const std::vector<std::string>& params) +{ + CServiceBroker::GetAddonMgr().FindAddons(); + + return 0; +} + +// Note: For new Texts with comma add a "\" before!!! Is used for table text. +// +/// \page page_List_of_built_in_functions List of built-in functions +/// \section built_in_functions_1 Add-on built-in's +/// +/// ----------------------------------------------------------------------------- +/// +/// \table_start +/// \table_h2_l{ +/// Function, +/// Description } +/// \table_row2_l{ +/// <b>`Addon.Default.OpenSettings(extensionpoint)`</b> +/// , +/// Open a settings dialog for the default addon of the given type +/// (extensionpoint) +/// @param[in] extensionpoint The add-on type +/// } +/// \table_row2_l{ +/// <b>`Addon.Default.Set(extensionpoint)`</b> +/// , +/// Open a select dialog to allow choosing the default addon of the given type +/// (extensionpoint) +/// @param[in] extensionpoint The add-on type +/// } +/// \table_row2_l{ +/// <b>`Addon.OpenSettings(id)`</b> +/// , +/// Open a settings dialog for the addon of the given id +/// @param[in] id The add-on ID +/// } +/// \table_row2_l{ +/// <b>`EnableAddon(id)`</b> +/// \anchor Builtin_EnableAddonId, +/// Enable the specified plugin/script +/// @param[in] id The add-on id +/// <p><hr> +/// @skinning_v19 **[New builtin]** \link Builtin_EnableAddonId `EnableAddon(id)`\endlink +/// <p> +/// } +/// \table_row2_l{ +/// <b>`InstallAddon(id)`</b> +/// , +/// Install the specified plugin/script +/// @param[in] id The add-on id +/// } +/// \table_row2_l{ +/// <b>`InstallFromZip`</b> +/// , +/// Opens the "Install from zip" dialog if "Unknown sources" is enabled. Prompts the warning message if not. +/// } +/// \table_row2_l{ +/// <b>`RunAddon(id[\,opt])`</b> +/// , +/// Runs the specified plugin/script +/// @param[in] id The add-on id. +/// @param[in] opt is blank for no add-on parameters\n +/// or +/// @param[in] opt Add-on parameters in url format\n +/// or +/// @param[in] opt[\,...] Additional parameters in format param=value. +/// } +/// \table_row2_l{ +/// <b>`RunAppleScript(script[\,args]*)`</b> +/// , +/// Run the specified AppleScript command +/// @param[in] script Is the URL to the apple script\n +/// or +/// @param[in] script Is the addon-ID to the script add-on\n +/// or +/// @param[in] script Is the URL to the python script. +/// +/// @note Set the OnlyApple template parameter to true to only attempt +/// execution of applescripts. +/// } +/// \table_row2_l{ +/// <b>`RunPlugin(plugin)`</b> +/// , +/// Runs the plugin. Full path must be specified. Does not work for folder +/// plugins +/// @param[in] plugin plugin:// URL to script. +/// } +/// \table_row2_l{ +/// <b>`RunScript(script[\,args]*)`</b> +/// , +/// Runs the python script. You must specify the full path to the script. If +/// the script is an add-on\, you can also execute it using its add-on id. As +/// of 2007/02/24\, all extra parameters are passed to the script as arguments +/// and can be accessed by python using sys.argv +/// @param[in] script Is the addon-ID to the script add-on\n +/// or +/// @param[in] script Is the URL to the python script. +/// } +/// \table_row2_l{ +/// <b>`StopScript(id)`</b> +/// , +/// Stop the script by ID or path\, if running +/// @param[in] id The add-on ID of the script to stop\n +/// or +/// @param[in] id The URL of the script to stop. +/// } +/// \table_row2_l{ +/// <b>`UpdateAddonRepos`</b> +/// , +/// Triggers a forced update of enabled add-on repositories. +/// } +/// \table_row2_l{ +/// <b>`UpdateLocalAddons`</b> +/// , +/// Triggers a scan of local add-on directories. +/// } +/// \table_end +/// + +CBuiltins::CommandMap CAddonBuiltins::GetOperations() const +{ + return { + {"addon.default.opensettings", {"Open a settings dialog for the default addon of the given type", 1, OpenDefaultSettings}}, + {"addon.default.set", {"Open a select dialog to allow choosing the default addon of the given type", 1, SetDefaultAddon}}, + {"addon.opensettings", {"Open a settings dialog for the addon of the given id", 1, AddonSettings}}, + {"enableaddon", {"Enables the specified plugin/script", 1, EnableAddon}}, + {"installaddon", {"Install the specified plugin/script", 1, InstallAddon}}, + {"installfromzip", { "Open the install from zip dialog", 0, InstallFromZip}}, + {"runaddon", {"Run the specified plugin/script", 1, RunAddon}}, +#ifdef TARGET_DARWIN + {"runapplescript", {"Run the specified AppleScript command", 1, RunScript<true>}}, +#endif + {"runplugin", {"Run the specified plugin", 1, RunPlugin}}, + {"runscript", {"Run the specified script", 1, RunScript}}, + {"stopscript", {"Stop the script by ID or path, if running", 1, StopScript}}, + {"updateaddonrepos", {"Check add-on repositories for updates", 0, UpdateRepos}}, + {"updatelocaladdons", {"Check for local add-on changes", 0, UpdateLocals}} + }; +} diff --git a/xbmc/interfaces/builtins/AddonBuiltins.h b/xbmc/interfaces/builtins/AddonBuiltins.h new file mode 100644 index 0000000..9418420 --- /dev/null +++ b/xbmc/interfaces/builtins/AddonBuiltins.h @@ -0,0 +1,19 @@ +/* + * 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 "Builtins.h" + +//! \brief Class providing add-on related built-in commands. +class CAddonBuiltins +{ +public: + //! \brief Returns the map of operations. + CBuiltins::CommandMap GetOperations() const; +}; diff --git a/xbmc/interfaces/builtins/AndroidBuiltins.cpp b/xbmc/interfaces/builtins/AndroidBuiltins.cpp new file mode 100644 index 0000000..17f4076 --- /dev/null +++ b/xbmc/interfaces/builtins/AndroidBuiltins.cpp @@ -0,0 +1,73 @@ +/* + * 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 "AndroidBuiltins.h" + +#include "ServiceBroker.h" +#include "messaging/ApplicationMessenger.h" + +/*! \brief Launch an android system activity. + * \param params The parameters. + * \details params[0] = package + * params[1] = intent (optional) + * params[2] = datatype (optional) + * params[3] = dataURI (optional) + * params[4] = flags (optional) + * params[5] = extras (optional) + * params[6] = action (optional) + * params[7] = category (optional) + * params[8] = className (optional) + */ +static int LaunchAndroidActivity(const std::vector<std::string>& params) +{ + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_START_ANDROID_ACTIVITY, -1, -1, nullptr, "", + params); + + return 0; +} + +// Note: For new Texts with comma add a "\" before!!! Is used for table text. +// +/// \page page_List_of_built_in_functions +/// \section built_in_functions_2 Android built-in's +/// +/// ----------------------------------------------------------------------------- +/// +/// \table_start +/// \table_h2_l{ +/// Function, +/// Description } +/// \table_row2_l{ +/// <b>`StartAndroidActivity(package\,[intent\,dataType\,dataURI\,flags\,extras\,action\,category\,className])`</b> +/// , +/// Launch an Android native app with the given package name. Optional parms +/// (in order): intent\, dataType\, dataURI\, flags\, extras\, action\, +/// category\, className. +/// @param[in] package +/// @param[in] intent (optional) +/// @param[in] datatype (optional) +/// @param[in] dataURI (optional) +/// @param[in] flags (optional) +/// @param[in] extras (optional) +/// @param[in] action (optional) +/// @param[in] category (optional) +/// @param[in] className (optional) +/// <p><hr> +/// @skinning_v20 Added parameters `flags`\,`extras`\,`action`\,`category`\,`className`. +/// <p> +/// } +/// \table_end +/// + +CBuiltins::CommandMap CAndroidBuiltins::GetOperations() const +{ + return {{"startandroidactivity", + {"Launch an Android native app with the given package name. Optional parms (in order): " + "intent, dataType, dataURI, flags, extras, action, category, className.", + 1, LaunchAndroidActivity}}}; +} diff --git a/xbmc/interfaces/builtins/AndroidBuiltins.h b/xbmc/interfaces/builtins/AndroidBuiltins.h new file mode 100644 index 0000000..d4059e2 --- /dev/null +++ b/xbmc/interfaces/builtins/AndroidBuiltins.h @@ -0,0 +1,19 @@ +/* + * 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 "Builtins.h" + +//! \brief Class providing CEC related built-in commands. +class CAndroidBuiltins +{ +public: + //! \brief Returns the map of operations. + CBuiltins::CommandMap GetOperations() const; +}; diff --git a/xbmc/interfaces/builtins/ApplicationBuiltins.cpp b/xbmc/interfaces/builtins/ApplicationBuiltins.cpp new file mode 100644 index 0000000..dfec66d --- /dev/null +++ b/xbmc/interfaces/builtins/ApplicationBuiltins.cpp @@ -0,0 +1,222 @@ +/* + * 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 "ApplicationBuiltins.h" + +#include "ServiceBroker.h" +#include "application/ApplicationComponents.h" +#include "application/ApplicationPowerHandling.h" +#include "application/ApplicationVolumeHandling.h" +#include "filesystem/ZipManager.h" +#include "input/actions/ActionIDs.h" +#include "interfaces/AnnouncementManager.h" +#include "messaging/ApplicationMessenger.h" +#include "network/Network.h" +#include "settings/AdvancedSettings.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" +#include "utils/JSONVariantParser.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" +#include "utils/Variant.h" +#include "utils/log.h" + +#include <stdlib.h> + +/*! \brief Extract an archive. + * \param params The parameters + * \details params[0] = The archive URL. + * params[1] = Destination path (optional). + * If not given, extracts to folder with archive. + */ +static int Extract(const std::vector<std::string>& params) +{ + // Detects if file is zip or rar then extracts + std::string strDestDirect; + if (params.size() < 2) + strDestDirect = URIUtils::GetDirectory(params[0]); + else + strDestDirect = params[1]; + + URIUtils::AddSlashAtEnd(strDestDirect); + + if (URIUtils::IsZIP(params[0])) + g_ZipManager.ExtractArchive(params[0],strDestDirect); + else + CLog::Log(LOGERROR, "Extract, No archive given"); + + return 0; +} + +/*! \brief Mute volume. + * \param params (ignored) + */ +static int Mute(const std::vector<std::string>& params) +{ + auto& components = CServiceBroker::GetAppComponents(); + const auto appVolume = components.GetComponent<CApplicationVolumeHandling>(); + appVolume->ToggleMute(); + + return 0; +} + +/*! \brief Notify all listeners on announcement bus. + * \param params The parameters. + * \details params[0] = sender. + * params[1] = data. + * params[2] = JSON with extra parameters (optional). + */ +static int NotifyAll(const std::vector<std::string>& params) +{ + CVariant data; + if (params.size() > 2) + { + if (!CJSONVariantParser::Parse(params[2], data)) + { + CLog::Log(LOGERROR, "NotifyAll failed to parse data: {}", params[2]); + return -3; + } + } + + CServiceBroker::GetAnnouncementManager()->Announce(ANNOUNCEMENT::Other, params[0].c_str(), params[1].c_str(), data); + + return 0; +} + +/*! \brief Set volume. + * \param params the parameters. + * \details params[0] = Volume level. + * params[1] = "showVolumeBar" to show volume bar (optional). + */ +static int SetVolume(const std::vector<std::string>& params) +{ + auto& components = CServiceBroker::GetAppComponents(); + const auto appVolume = components.GetComponent<CApplicationVolumeHandling>(); + float oldVolume = appVolume->GetVolumePercent(); + float volume = static_cast<float>(strtod(params[0].c_str(), nullptr)); + + appVolume->SetVolume(volume); + if (oldVolume != volume) + { + if (params.size() > 1 && StringUtils::EqualsNoCase(params[1], "showVolumeBar")) + { + CServiceBroker::GetAppMessenger()->PostMsg( + TMSG_VOLUME_SHOW, oldVolume < volume ? ACTION_VOLUME_UP : ACTION_VOLUME_DOWN); + } + } + + return 0; +} + +/*! \brief Toggle debug info. + * \param params (ignored) + */ +static int ToggleDebug(const std::vector<std::string>& params) +{ + bool debug = CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_DEBUG_SHOWLOGINFO); + CServiceBroker::GetSettingsComponent()->GetSettings()->SetBool(CSettings::SETTING_DEBUG_SHOWLOGINFO, !debug); + CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->SetDebugMode(!debug); + + return 0; +} + +/*! \brief Toggle DPMS state. + * \param params (ignored) + */ +static int ToggleDPMS(const std::vector<std::string>& params) +{ + auto& components = CServiceBroker::GetAppComponents(); + const auto appPower = components.GetComponent<CApplicationPowerHandling>(); + appPower->ToggleDPMS(true); + + return 0; +} + +/*! \brief Send a WOL packet to a given host. + * \param params The parameters. + * \details params[0] = The MAC of the host to wake. + */ +static int WakeOnLAN(const std::vector<std::string>& params) +{ + CServiceBroker::GetNetwork().WakeOnLan(params[0].c_str()); + + return 0; +} + +// Note: For new Texts with comma add a "\" before!!! Is used for table text. +// +/// \page page_List_of_built_in_functions +/// \section built_in_functions_3 Application built-in's +/// +/// ----------------------------------------------------------------------------- +/// +/// \table_start +/// \table_h2_l{ +/// Function, +/// Description } +/// \table_row2_l{ +/// <b>`Extract(url [\, dest])`</b> +/// , +/// Extracts a specified archive to an optionally specified 'absolute' path. +/// @param[in] url The archive URL. +/// @param[in] dest Destination path (optional). +/// @note If not given\, extracts to folder with archive. +/// } +/// \table_row2_l{ +/// <b>`Mute`</b> +/// , +/// Mutes (or unmutes) the volume. +/// } +/// \table_row2_l{ +/// <b>`NotifyAll(sender\, data [\, json])`</b> +/// , +/// Notify all connected clients +/// @param[in] sender Sender. +/// @param[in] data Data. +/// @param[in] json JSON with extra parameters (optional). +/// } +/// \table_row2_l{ +/// <b>`SetVolume(percent[\,showvolumebar])`</b> +/// , +/// Sets the volume to the percentage specified. Optionally\, show the Volume +/// Dialog in Kodi when setting the volume. +/// @param[in] percent Volume level. +/// @param[in] showvolumebar Add "showVolumeBar" to show volume bar (optional). +/// } +/// \table_row2_l{ +/// <b>`ToggleDebug`</b> +/// , +/// Toggles debug mode on/off +/// } +/// \table_row2_l{ +/// <b>`ToggleDPMS`</b> +/// , +/// Toggle DPMS mode manually +/// } +/// \table_row2_l{ +/// <b>`WakeOnLan(mac)`</b> +/// , +/// Sends the wake-up packet to the broadcast address for the specified MAC +/// address (Format: FF:FF:FF:FF:FF:FF or FF-FF-FF-FF-FF-FF). +/// @param[in] mac The MAC of the host to wake. +/// } +/// \table_end +/// + +CBuiltins::CommandMap CApplicationBuiltins::GetOperations() const +{ + return { + {"extract", {"Extracts the specified archive", 1, Extract}}, + {"mute", {"Mute the player", 0, Mute}}, + {"notifyall", {"Notify all connected clients", 2, NotifyAll}}, + {"setvolume", {"Set the current volume", 1, SetVolume}}, + {"toggledebug", {"Enables/disables debug mode", 0, ToggleDebug}}, + {"toggledpms", {"Toggle DPMS mode manually", 0, ToggleDPMS}}, + {"wakeonlan", {"Sends the wake-up packet to the broadcast address for the specified MAC address", 1, WakeOnLAN}} + }; +} diff --git a/xbmc/interfaces/builtins/ApplicationBuiltins.h b/xbmc/interfaces/builtins/ApplicationBuiltins.h new file mode 100644 index 0000000..f237fe4 --- /dev/null +++ b/xbmc/interfaces/builtins/ApplicationBuiltins.h @@ -0,0 +1,19 @@ +/* + * 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 "Builtins.h" + +//! \brief Class providing application related built-in commands. +class CApplicationBuiltins +{ +public: + //! \brief Returns the map of operations. + CBuiltins::CommandMap GetOperations() const; +}; diff --git a/xbmc/interfaces/builtins/Builtins.cpp b/xbmc/interfaces/builtins/Builtins.cpp new file mode 100644 index 0000000..624d9d1 --- /dev/null +++ b/xbmc/interfaces/builtins/Builtins.cpp @@ -0,0 +1,168 @@ +/* + * 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 "Builtins.h" + +#include "AddonBuiltins.h" +#include "ApplicationBuiltins.h" +#include "CECBuiltins.h" +#include "GUIBuiltins.h" +#include "GUIContainerBuiltins.h" +#include "GUIControlBuiltins.h" +#include "LibraryBuiltins.h" +#include "OpticalBuiltins.h" +#include "PVRBuiltins.h" +#include "PictureBuiltins.h" +#include "PlayerBuiltins.h" +#include "ProfileBuiltins.h" +#include "ServiceBroker.h" +#include "SkinBuiltins.h" +#include "SystemBuiltins.h" +#include "WeatherBuiltins.h" +#include "input/InputManager.h" +#include "powermanagement/PowerTypes.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" +#include "utils/ExecString.h" +#include "utils/StringUtils.h" +#include "utils/log.h" + +#if defined(TARGET_ANDROID) +#include "AndroidBuiltins.h" +#endif + +#if defined(TARGET_POSIX) +#include "PlatformDefs.h" +#endif + +CBuiltins::CBuiltins() +{ + RegisterCommands<CAddonBuiltins>(); + RegisterCommands<CApplicationBuiltins>(); + RegisterCommands<CGUIBuiltins>(); + RegisterCommands<CGUIContainerBuiltins>(); + RegisterCommands<CGUIControlBuiltins>(); + RegisterCommands<CLibraryBuiltins>(); + RegisterCommands<COpticalBuiltins>(); + RegisterCommands<CPictureBuiltins>(); + RegisterCommands<CPlayerBuiltins>(); + RegisterCommands<CProfileBuiltins>(); + RegisterCommands<CPVRBuiltins>(); + RegisterCommands<CSkinBuiltins>(); + RegisterCommands<CSystemBuiltins>(); + RegisterCommands<CWeatherBuiltins>(); + +#if defined(HAVE_LIBCEC) + RegisterCommands<CCECBuiltins>(); +#endif + +#if defined(TARGET_ANDROID) + RegisterCommands<CAndroidBuiltins>(); +#endif +} + +CBuiltins::~CBuiltins() = default; + +CBuiltins& CBuiltins::GetInstance() +{ + static CBuiltins sBuiltins; + return sBuiltins; +} + +bool CBuiltins::HasCommand(const std::string& execString) +{ + const CExecString exec(execString); + if (!exec.IsValid()) + return false; + + const std::string function = exec.GetFunction(); + const std::vector<std::string> parameters = exec.GetParams(); + + if (CServiceBroker::GetInputManager().HasBuiltin(function)) + return true; + + const auto& it = m_command.find(function); + if (it != m_command.end()) + { + if (it->second.parameters == 0 || it->second.parameters <= parameters.size()) + return true; + } + + return false; +} + +bool CBuiltins::IsSystemPowerdownCommand(const std::string& execString) +{ + const CExecString exec(execString); + if (!exec.IsValid()) + return false; + + const std::string execute = exec.GetFunction(); + + // Check if action is resulting in system powerdown. + if (execute == "reboot" || + execute == "restart" || + execute == "reset" || + execute == "powerdown" || + execute == "hibernate" || + execute == "suspend" ) + { + return true; + } + else if (execute == "shutdown") + { + switch (CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_POWERMANAGEMENT_SHUTDOWNSTATE)) + { + case POWERSTATE_SHUTDOWN: + case POWERSTATE_SUSPEND: + case POWERSTATE_HIBERNATE: + return true; + + default: + return false; + } + } + return false; +} + +void CBuiltins::GetHelp(std::string &help) +{ + help.clear(); + + for (const auto& it : m_command) + { + help += it.first; + help += "\t"; + help += it.second.description; + help += "\n"; + } +} + +int CBuiltins::Execute(const std::string& execString) +{ + const CExecString exec(execString); + if (!exec.IsValid()) + return -1; + + const std::string execute = exec.GetFunction(); + const std::vector<std::string> params = exec.GetParams(); + + const auto& it = m_command.find(execute); + if (it != m_command.end()) + { + if (it->second.parameters == 0 || params.size() >= it->second.parameters) + return it->second.Execute(params); + else + { + CLog::Log(LOGERROR, "{0} called with invalid number of parameters (should be: {1}, is {2})", + execute, it->second.parameters, params.size()); + return -1; + } + } + else + return CServiceBroker::GetInputManager().ExecuteBuiltin(execute, params); +} diff --git a/xbmc/interfaces/builtins/Builtins.h b/xbmc/interfaces/builtins/Builtins.h new file mode 100644 index 0000000..7d0345a --- /dev/null +++ b/xbmc/interfaces/builtins/Builtins.h @@ -0,0 +1,55 @@ +/* + * 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 <map> +#include <string> +#include <vector> + +class CBuiltins +{ +public: + //! \brief Struct representing a command from handler classes. + struct BUILT_IN + { + std::string description; //!< Description of command (help string) + size_t parameters; //!< Number of required parameters (can be 0) + int (*Execute)(const std::vector<std::string>& params); //!< Function to handle command + }; + + //! \brief A map of commands + typedef std::map<std::string,CBuiltins::BUILT_IN> CommandMap; + + static CBuiltins& GetInstance(); + + bool HasCommand(const std::string& execString); + bool IsSystemPowerdownCommand(const std::string& execString); + void GetHelp(std::string &help); + int Execute(const std::string& execString); + +protected: + CBuiltins(); + CBuiltins(const CBuiltins&) = delete; + const CBuiltins& operator=(const CBuiltins&) = delete; + virtual ~CBuiltins(); + +private: + CommandMap m_command; //!< Map of registered commands + + + //! \brief Convenience template used to register commands from providers + template<class T> + void RegisterCommands() + { + T t; + CommandMap map = t.GetOperations(); + m_command.insert(map.begin(), map.end()); + } +}; + diff --git a/xbmc/interfaces/builtins/CECBuiltins.cpp b/xbmc/interfaces/builtins/CECBuiltins.cpp new file mode 100644 index 0000000..d381816 --- /dev/null +++ b/xbmc/interfaces/builtins/CECBuiltins.cpp @@ -0,0 +1,82 @@ +/* + * 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 "CECBuiltins.h" + +#include "ServiceBroker.h" +#include "messaging/ApplicationMessenger.h" + +/*! \brief Wake up device through CEC. + * \param params (ignored) + */ +static int ActivateSource(const std::vector<std::string>& params) +{ + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_CECACTIVATESOURCE); + + return 0; +} + +/*! \brief Put device in standby through CEC. + * \param params (ignored) + */ +static int Standby(const std::vector<std::string>& params) +{ + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_CECSTANDBY); + + return 0; +} + +/*! \brief Toggle device state through CEC. + * \param params (ignored) + */ +static int ToggleState(const std::vector<std::string>& params) +{ + bool result; + CServiceBroker::GetAppMessenger()->SendMsg(TMSG_CECTOGGLESTATE, 0, 0, + static_cast<void*>(&result)); + + return 0; +} + +// Note: For new Texts with comma add a "\" before!!! Is used for table text. +// +/// \page page_List_of_built_in_functions +/// \section built_in_functions_4 CEC built-in's +/// +/// ----------------------------------------------------------------------------- +/// +/// \table_start +/// \table_h2_l{ +/// Function, +/// Description } +/// \table_row2_l{ +/// <b>`CECActivateSource`</b> +/// , +/// Wake up playing device via a CEC peripheral +/// } +/// \table_row2_l{ +/// <b>`CECStandby`</b> +/// , +/// Put playing device on standby via a CEC peripheral +/// } +/// \table_row2_l{ +/// <b>`CECToggleState`</b> +/// , +/// Toggle state of playing device via a CEC peripheral +/// } +/// \table_end +/// + +CBuiltins::CommandMap CCECBuiltins::GetOperations() const +{ + return { + {"cectogglestate", {"Toggle state of playing device via a CEC peripheral", 0, ToggleState}}, + {"cecactivatesource", {"Wake up playing device via a CEC peripheral", 0, ActivateSource}}, + {"cecstandby", {"Put playing device on standby via a CEC peripheral", 0, Standby}} + }; +} diff --git a/xbmc/interfaces/builtins/CECBuiltins.h b/xbmc/interfaces/builtins/CECBuiltins.h new file mode 100644 index 0000000..d06c291 --- /dev/null +++ b/xbmc/interfaces/builtins/CECBuiltins.h @@ -0,0 +1,19 @@ +/* + * 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 "Builtins.h" + +//! \brief Class providing CEC related built-in commands. +class CCECBuiltins +{ +public: + //! \brief Returns the map of operations. + CBuiltins::CommandMap GetOperations() const; +}; diff --git a/xbmc/interfaces/builtins/CMakeLists.txt b/xbmc/interfaces/builtins/CMakeLists.txt new file mode 100644 index 0000000..27785af --- /dev/null +++ b/xbmc/interfaces/builtins/CMakeLists.txt @@ -0,0 +1,41 @@ +set(SOURCES AddonBuiltins.cpp + ApplicationBuiltins.cpp + Builtins.cpp + CECBuiltins.cpp + GUIBuiltins.cpp + GUIControlBuiltins.cpp + GUIContainerBuiltins.cpp + LibraryBuiltins.cpp + OpticalBuiltins.cpp + PictureBuiltins.cpp + PlayerBuiltins.cpp + ProfileBuiltins.cpp + PVRBuiltins.cpp + SkinBuiltins.cpp + SystemBuiltins.cpp + WeatherBuiltins.cpp) + +set(HEADERS AddonBuiltins.h + AndroidBuiltins.h + ApplicationBuiltins.h + Builtins.h + CECBuiltins.h + GUIBuiltins.h + GUIContainerBuiltins.h + GUIControlBuiltins.h + LibraryBuiltins.h + OpticalBuiltins.h + PictureBuiltins.h + PlayerBuiltins.h + ProfileBuiltins.h + PVRBuiltins.h + SkinBuiltins.h + SystemBuiltins.h + WeatherBuiltins.h) + +if(CORE_SYSTEM_NAME STREQUAL android) + list(APPEND SOURCES AndroidBuiltins.cpp) + list(APPEND HEADERS AndroidBuiltins.h) +endif() + +core_add_library(interfaces_builtins) diff --git a/xbmc/interfaces/builtins/GUIBuiltins.cpp b/xbmc/interfaces/builtins/GUIBuiltins.cpp new file mode 100644 index 0000000..f368e69 --- /dev/null +++ b/xbmc/interfaces/builtins/GUIBuiltins.cpp @@ -0,0 +1,601 @@ +/* + * 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 "GUIBuiltins.h" + +#include "ServiceBroker.h" +#include "Util.h" +#include "application/ApplicationComponents.h" +#include "application/ApplicationPowerHandling.h" +#include "dialogs/GUIDialogKaiToast.h" +#include "dialogs/GUIDialogNumeric.h" +#include "filesystem/Directory.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +#include "guilib/LocalizeStrings.h" +#include "guilib/StereoscopicsManager.h" +#include "input/WindowTranslator.h" +#include "input/actions/Action.h" +#include "input/actions/ActionIDs.h" +#include "input/actions/ActionTranslator.h" +#include "messaging/ApplicationMessenger.h" +#include "settings/AdvancedSettings.h" +#include "settings/SettingsComponent.h" +#include "utils/AlarmClock.h" +#include "utils/RssManager.h" +#include "utils/Screenshot.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" +#include "utils/log.h" +#include "windows/GUIMediaWindow.h" + +/*! \brief Execute a GUI action. + * \param params The parameters. + * \details params[0] = Action to execute. + * params[1] = Window to send action to (optional). + */ +static int Action(const std::vector<std::string>& params) +{ + // try translating the action from our ButtonTranslator + unsigned int actionID; + if (CActionTranslator::TranslateString(params[0], actionID)) + { + int windowID = params.size() == 2 ? CWindowTranslator::TranslateWindow(params[1]) : WINDOW_INVALID; + CServiceBroker::GetAppMessenger()->SendMsg(TMSG_GUI_ACTION, windowID, -1, + static_cast<void*>(new CAction(actionID))); + } + + return 0; +} + +/*! \brief Activate a window. + * \param params The parameters. + * \details params[0] = The window name. + * params[1] = Window starting folder (optional). + * + * Set the Replace template parameter to true to replace current + * window in history. + */ + template<bool Replace> +static int ActivateWindow(const std::vector<std::string>& params2) +{ + std::vector<std::string> params(params2); + // get the parameters + std::string strWindow; + if (params.size()) + { + strWindow = params[0]; + params.erase(params.begin()); + } + + // confirm the window destination is valid prior to switching + int iWindow = CWindowTranslator::TranslateWindow(strWindow); + if (iWindow != WINDOW_INVALID) + { + // compare the given directory param with the current active directory + // if no directory is given, and you switch from a video window to another + // we retain history, so it makes sense to not switch to the same window in + // that case + bool bIsSameStartFolder = true; + if (!params.empty()) + { + CGUIWindow *activeWindow = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow()); + if (activeWindow && activeWindow->IsMediaWindow()) + bIsSameStartFolder = static_cast<CGUIMediaWindow*>(activeWindow)->IsSameStartFolder(params[0]); + } + + // activate window only if window and path differ from the current active window + if (iWindow != CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow() || !bIsSameStartFolder) + { + // if the window doesn't change, make sure it knows it's gonna be replaced + // this ensures setting the start directory if we switch paths + // if we change windows, that's done anyway + if (Replace && !params.empty() && + iWindow == CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow()) + params.emplace_back("replace"); + + auto& components = CServiceBroker::GetAppComponents(); + const auto appPower = components.GetComponent<CApplicationPowerHandling>(); + appPower->WakeUpScreenSaverAndDPMS(); + CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(iWindow, params, Replace); + return 0; + } + } + else + { + CLog::Log(LOGERROR, "Activate/ReplaceWindow called with invalid destination window: {}", + strWindow); + return false; + } + + return 1; +} + +/*! \brief Activate a window and give given controls focus. + * \param params The parameters. + * \details params[0] = The window name. + * params[1,...] = Pair of (container ID, focus item). + * + * Set the Replace template parameter to true to replace current + * window in history. + */ + template<bool Replace> +static int ActivateAndFocus(const std::vector<std::string>& params) +{ + std::string strWindow = params[0]; + + // confirm the window destination is valid prior to switching + int iWindow = CWindowTranslator::TranslateWindow(strWindow); + if (iWindow != WINDOW_INVALID) + { + if (iWindow != CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow()) + { + // disable the screensaver + auto& components = CServiceBroker::GetAppComponents(); + const auto appPower = components.GetComponent<CApplicationPowerHandling>(); + appPower->WakeUpScreenSaverAndDPMS(); + CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(iWindow, {}, Replace); + + unsigned int iPtr = 1; + while (params.size() > iPtr + 1) + { + CGUIMessage msg(GUI_MSG_SETFOCUS, CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindowOrDialog(), + atol(params[iPtr].c_str()), + (params.size() >= iPtr + 2) ? atol(params[iPtr + 1].c_str())+1 : 0); + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(msg); + iPtr += 2; + } + return 0; + } + + } + else + CLog::Log(LOGERROR, "Replace/ActivateWindowAndFocus called with invalid destination window: {}", + strWindow); + + return 1; +} + +/*! \brief Start an alarm clock + * \param params The parameters. + * \details param[0] = name + * param[1] = command + * param[2] = Length in seconds (optional). + * param[3] = "silent" to suppress notifications. + * param[3] = "loop" to loop the alarm. + */ +static int AlarmClock(const std::vector<std::string>& params) +{ + // format is alarmclock(name,command[,time,true,false]); + float seconds = 0; + if (params.size() > 2) + { + if (params[2].find(':') == std::string::npos) + seconds = static_cast<float>(atoi(params[2].c_str())*60); + else + seconds = (float)StringUtils::TimeStringToSeconds(params[2]); + } + else + { // check if shutdown is specified in particular, and get the time for it + std::string strHeading; + if (StringUtils::EqualsNoCase(params[0], "shutdowntimer")) + strHeading = g_localizeStrings.Get(20145); + else + strHeading = g_localizeStrings.Get(13209); + std::string strTime; + if( CGUIDialogNumeric::ShowAndGetNumber(strTime, strHeading) ) + seconds = static_cast<float>(atoi(strTime.c_str())*60); + else + return false; + } + bool silent = false; + bool loop = false; + for (unsigned int i = 3; i < params.size() ; i++) + { + // check "true" for backward comp + if (StringUtils::EqualsNoCase(params[i], "true") || StringUtils::EqualsNoCase(params[i], "silent")) + silent = true; + else if (StringUtils::EqualsNoCase(params[i], "loop")) + loop = true; + } + + if( g_alarmClock.IsRunning() ) + g_alarmClock.Stop(params[0],silent); + // no negative times not allowed, loop must have a positive time + if (seconds < 0 || (seconds == 0 && loop)) + return false; + g_alarmClock.Start(params[0], seconds, params[1], silent, loop); + + return 0; +} + +/*! \brief Cancel an alarm clock. + * \param params The parameters. + * \details params[0] = "true" to silently cancel alarm (optional). + */ +static int CancelAlarm(const std::vector<std::string>& params) +{ + bool silent = (params.size() > 1 && + (StringUtils::EqualsNoCase(params[1], "true") || + StringUtils::EqualsNoCase(params[1], "silent"))); + g_alarmClock.Stop(params[0],silent); + + return 0; +} + +/*! \brief Clear a property in a window. + * \param params The parameters. + * \details params[0] = The property to clear. + * params[1] = The window to clear property in (optional). + */ +static int ClearProperty(const std::vector<std::string>& params) +{ + CGUIWindow *window = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(params.size() > 1 ? CWindowTranslator::TranslateWindow(params[1]) : CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindowOrDialog()); + if (window) + window->SetProperty(params[0],""); + + return 0; +} + +/*! \brief Close a dialog. + * \param params The parameters. + * \details params[0] = "all" to close all dialogs, or dialog name. + * params[1] = "true" to force close (skip animations) (optional). + */ +static int CloseDialog(const std::vector<std::string>& params) +{ + bool bForce = false; + if (params.size() > 1 && StringUtils::EqualsNoCase(params[1], "true")) + bForce = true; + if (StringUtils::EqualsNoCase(params[0], "all")) + { + CServiceBroker::GetGUI()->GetWindowManager().CloseDialogs(bForce); + } + else + { + int id = CWindowTranslator::TranslateWindow(params[0]); + CGUIWindow *window = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(id); + if (window && window->IsDialog()) + static_cast<CGUIDialog*>(window)->Close(bForce); + } + + return 0; +} + +/*! \brief Send a notification. + * \param params The parameters. + * \details params[0] = Notification title. + * params[1] = Notification text. + * params[2] = Display time in milliseconds (optional). + * params[3] = Notification icon (optional). + */ +static int Notification(const std::vector<std::string>& params) +{ + if (params.size() < 2) + return -1; + if (params.size() == 4) + CGUIDialogKaiToast::QueueNotification(params[3],params[0],params[1],atoi(params[2].c_str())); + else if (params.size() == 3) + CGUIDialogKaiToast::QueueNotification("",params[0],params[1],atoi(params[2].c_str())); + else + CGUIDialogKaiToast::QueueNotification(params[0],params[1]); + + return 0; +} + +/*! \brief Refresh RSS feed. + * \param params (ignored) + */ +static int RefreshRSS(const std::vector<std::string>& params) +{ + CRssManager::GetInstance().Reload(); + + return 0; +} + +/*! \brief Take a screenshot. + * \param params The parameters. + * \details params[0] = URL to save file to. Blank to use default. + * params[1] = "sync" to run synchronously (optional). + */ +static int Screenshot(const std::vector<std::string>& params) +{ + if (!params.empty()) + { + // get the parameters + std::string strSaveToPath = params[0]; + bool sync = false; + if (params.size() >= 2) + sync = StringUtils::EqualsNoCase(params[1], "sync"); + + if (!strSaveToPath.empty()) + { + if (XFILE::CDirectory::Exists(strSaveToPath)) + { + std::string file = CUtil::GetNextFilename( + URIUtils::AddFileToFolder(strSaveToPath, "screenshot{:05}.png"), 65535); + + if (!file.empty()) + { + CScreenShot::TakeScreenshot(file, sync); + } + else + { + CLog::Log(LOGWARNING, "Too many screen shots or invalid folder {}", strSaveToPath); + } + } + else + CScreenShot::TakeScreenshot(strSaveToPath, sync); + } + } + else + CScreenShot::TakeScreenshot(); + + return 0; +} + +/*! \brief Set GUI language. + * \param params The parameters. + * \details params[0] = The language to use. + */ +static int SetLanguage(const std::vector<std::string>& params) +{ + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_SETLANGUAGE, -1, -1, nullptr, params[0]); + + return 0; +} + +/*! \brief Set a property in a window. + * \param params The parameters. + * \details params[0] = The property to set. + * params[1] = The property value. + * params[2] = The window to set property in (optional). + */ +static int SetProperty(const std::vector<std::string>& params) +{ + CGUIWindow *window = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(params.size() > 2 ? CWindowTranslator::TranslateWindow(params[2]) : CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindowOrDialog()); + if (window) + window->SetProperty(params[0],params[1]); + + return 0; +} + +/*! \brief Set GUI stereo mode. + * \param params The parameters. + * \details param[0] = Stereo mode identifier. + */ +static int SetStereoMode(const std::vector<std::string>& params) +{ + CAction action = CStereoscopicsManager::ConvertActionCommandToAction("SetStereoMode", params[0]); + if (action.GetID() != ACTION_NONE) + CServiceBroker::GetAppMessenger()->SendMsg(TMSG_GUI_ACTION, WINDOW_INVALID, -1, + static_cast<void*>(new CAction(action))); + else + { + CLog::Log(LOGERROR, "Builtin 'SetStereoMode' called with unknown parameter: {}", params[0]); + return -2; + } + + return 0; +} + +/*! \brief Toggle visualization of dirty regions. + * \param params Ignored. + */ +static int ToggleDirty(const std::vector<std::string>&) +{ + CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->ToggleDirtyRegionVisualization(); + + return 0; +} + +// Note: For new Texts with comma add a "\" before!!! Is used for table text. +// +/// \page page_List_of_built_in_functions +/// \section built_in_functions_5 GUI built-in's +/// +/// ----------------------------------------------------------------------------- +/// +/// \table_start +/// \table_h2_l{ +/// Function, +/// Description } +/// \table_row2_l{ +/// <b>`Action(action[\,window])`</b> +/// , +/// Executes an action (same as in keymap) for the given window or the +/// active window if the parameter window is omitted. The parameter window +/// can either be the window's id\, or in the case of a standard window\, the +/// window's name. See here for a list of window names\, and their respective +/// ids. +/// @param[in] action Action to execute. +/// @param[in] window Window to send action to (optional). +/// } +/// \table_row2_l{ +/// <b>`CancelAlarm(name[\,silent])`</b> +/// , +/// Cancel a running alarm. Set silent to true to hide the alarm notification. +/// @param[in] silent Send "true" or "silent" to silently cancel alarm (optional). +/// } +/// \table_row2_l{ +/// <b>`AlarmClock(name\,command[\,time\,silent\,loop])`</b> +/// , +/// Pops up a dialog asking for the length of time for the alarm (unless the +/// parameter time is specified)\, and starts a timer. When the timer runs out\, +/// it'll execute the built-in command (the parameter command) if it is +/// specified\, otherwise it'll pop up an alarm notice. Add silent to hide the +/// alarm notification. Add loop for the alarm to execute the command each +/// time the specified time interval expires. +/// @note if using any of the last optional parameters (silent or loop)\, both must +/// be provided for any to take effect. +/// <p> +/// <b>Example:</b> +/// The following example will create an alarmclock named `mytimer` which will silently +/// fire (a single time) and set a property (timerelapsed) with value 1 in the window with +/// id 1109 after 5 seconds have passed. +/// ~~~~~~~~~~~~~ +/// AlarmClock(mytimer\,SetProperty(timerelapsed\,1\,1109)\,00:00:05\,silent\,false]) +/// ~~~~~~~~~~~~~ +/// <p> +/// @param[in] name name +/// @param[in] command command +/// @param[in] time [opt] <b>(a)</b> Length in minutes or <b>(b)</b> a timestring in the format `hh:mm:ss` or `mm min`. +/// @param[in] silent [opt] Send "silent" to suppress notifications. +/// @param[in] loop [opt] Send "loop" to loop the alarm. +/// } +/// \table_row2_l{ +/// <b>`ActivateWindow(window[\,dir\, return])`</b> +/// , +/// Opens the given window. The parameter window can either be the window's id\, +/// or in the case of a standard window\, the window's name. See \ref window_ids "here" for a list +/// of window names\, and their respective ids. +/// If\, furthermore\, the window is +/// Music\, Video\, Pictures\, or Program files\, then the optional dir parameter +/// specifies which folder Kodi should default to once the window is opened. +/// This must be a source as specified in sources.xml\, or a subfolder of a +/// valid source. For some windows (MusicLibrary and VideoLibrary)\, a third +/// parameter (return) may be specified\, which indicates that Kodi should use this +/// folder as the "root" of the level\, and thus the "parent directory" action +/// from within this folder will return the user to where they were prior to +/// the window activating. +/// @param[in] window The window name. +/// @param[in] dir Window starting folder (optional). +/// @param[in] return if dir should be used as the rootfolder of the level +/// } +/// \table_row2_l{ +/// <b>`ActivateWindowAndFocus(id1\, id2\,item1\, id3\,item2)`</b> +/// , +/// Activate window with id1\, first focus control id2 and then focus control +/// id3. if either of the controls is a container\, you can specify which +/// item to focus (else\, set it to 0). +/// @param[in] id1 The window name. +/// @param[in] params[1\,...] Pair of (container ID\, focus item). +/// } +/// \table_row2_l{ +/// <b>`ClearProperty(key[\,id])`</b> +/// , +/// Clears a window property for the current focused window/dialog(key)\, or +/// the specified window (key\,id). +/// @param[in] key The property to clear. +/// @param[in] id The window to clear property in (optional). +/// } +/// \table_row2_l{ +/// <b>`Dialog.Close(dialog[\,force])`</b> +/// , +/// Close a dialog. Set force to true to bypass animations. Use (all\,true) +/// to close all opened dialogs at once. +/// @param[in] dialog Send "all" to close all dialogs\, or dialog name. +/// @param[in] force Send "true" to force close (skip animations) (optional). +/// } +/// \table_row2_l{ +/// <b>`Notification(header\,message[\,time\,image])`</b> +/// , +/// Will display a notification dialog with the specified header and message\, +/// in addition you can set the length of time it displays in milliseconds +/// and a icon image. +/// @param[in] header Notification title. +/// @param[in] message Notification text. +/// @param[in] time Display time in milliseconds (optional). +/// @param[in] image Notification icon (optional). +/// } +/// \table_row2_l{ +/// <b>`RefreshRSS`</b> +/// , +/// Reload RSS feeds from RSSFeeds.xml +/// } +/// \table_row2_l{ +/// <b>`ReplaceWindow(window\,dir)`</b> +/// , +/// Replaces the current window with the given window. This is the same as +/// ActivateWindow() but it doesn't update the window history list\, so when +/// you go back from the new window it will not return to the previous +/// window\, rather will return to the previous window's previous window. +/// @param[in] window The window name. +/// @param[in] dir Window starting folder (optional). +/// } +/// \table_row2_l{ +/// <b>`ReplaceWindowAndFocus(id1\, id2\,item1\, id3\,item2)`</b> +/// , +/// Replace window with id1\, first focus control id2 and then focus control +/// id3. if either of the controls is a container\, you can specify which +/// item to focus (else\, set it to 0). +/// @param[in] id1 The window name. +/// @param[in] params[1\,...] Pair of (container ID\, focus item). +/// } +/// \table_row2_l{ +/// <b>`Resolution(resIdent)`</b> +/// , +/// Change Kodi's Resolution (default is 4x3). +/// param[in] resIdent A resolution identifier. +/// | | Identifiers | | +/// |:--------:|:-----------:|:--------:| +/// | pal | pal16x9 | ntsc | +/// | ntsc16x9 | 720p | 720psbs | +/// | 720ptb | 1080psbs | 1080ptb | +/// | 1080i | | | +/// } +/// \table_row2_l{ +/// <b>`SetGUILanguage(lang)`</b> +/// , +/// Set GUI Language +/// @param[in] lang The language to use. +/// } +/// \table_row2_l{ +/// <b>`SetProperty(key\,value[\,id])`</b> +/// , +/// Sets a window property for the current window (key\,value)\, or the +/// specified window (key\,value\,id). +/// @param[in] key The property to set. +/// @param[in] value The property value. +/// @param[in] id The window to set property in (optional). +/// } +/// \table_row2_l{ +/// <b>`SetStereoMode(ident)`</b> +/// , +/// Changes the stereo mode of the GUI. +/// Params can be: +/// toggle\, next\, previous\, select\, tomono or any of the supported stereomodes (off\, +/// split_vertical\, split_horizontal\, row_interleaved\, hardware_based\, anaglyph_cyan_red\, anaglyph_green_magenta\, monoscopic) +/// @param[in] ident Stereo mode identifier. +/// } +/// \table_row2_l{ +/// <b>`TakeScreenshot(url[\,sync)`</b> +/// , +/// Takes a Screenshot +/// @param[in] url URL to save file to. Blank to use default. +/// @param[in] sync Add "sync" to run synchronously (optional). +/// } +/// \table_row2_l{ +/// <b>`ToggleDirtyRegionVisualization`</b> +/// , +/// makes dirty regions visible for debugging proposes. +/// } +/// \table_end +/// + +CBuiltins::CommandMap CGUIBuiltins::GetOperations() const +{ + return { + {"action", {"Executes an action for the active window (same as in keymap)", 1, Action}}, + {"cancelalarm", {"Cancels an alarm", 1, CancelAlarm}}, + {"alarmclock", {"Prompt for a length of time and start an alarm clock", 2, AlarmClock}}, + {"activatewindow", {"Activate the specified window", 1, ActivateWindow<false>}}, + {"activatewindowandfocus", {"Activate the specified window and sets focus to the specified id", 1, ActivateAndFocus<false>}}, + {"clearproperty", {"Clears a window property for the current focused window/dialog (key,value)", 1, ClearProperty}}, + {"dialog.close", {"Close a dialog", 1, CloseDialog}}, + {"notification", {"Shows a notification on screen, specify header, then message, and optionally time in milliseconds and a icon.", 2, Notification}}, + {"refreshrss", {"Reload RSS feeds from RSSFeeds.xml", 0, RefreshRSS}}, + {"replacewindow", {"Replaces the current window with the new one", 1, ActivateWindow<true>}}, + {"replacewindowandfocus", {"Replaces the current window with the new one and sets focus to the specified id", 1, ActivateAndFocus<true>}}, + {"setguilanguage", {"Set GUI Language", 1, SetLanguage}}, + {"setproperty", {"Sets a window property for the current focused window/dialog (key,value)", 2, SetProperty}}, + {"setstereomode", {"Changes the stereo mode of the GUI. Params can be: toggle, next, previous, select, tomono or any of the supported stereomodes (off, split_vertical, split_horizontal, row_interleaved, hardware_based, anaglyph_cyan_red, anaglyph_green_magenta, anaglyph_yellow_blue, monoscopic)", 1, SetStereoMode}}, + {"takescreenshot", {"Takes a Screenshot", 0, Screenshot}}, + {"toggledirtyregionvisualization", {"Enables/disables dirty-region visualization", 0, ToggleDirty}} + }; +} diff --git a/xbmc/interfaces/builtins/GUIBuiltins.h b/xbmc/interfaces/builtins/GUIBuiltins.h new file mode 100644 index 0000000..fd8f238 --- /dev/null +++ b/xbmc/interfaces/builtins/GUIBuiltins.h @@ -0,0 +1,19 @@ +/* + * 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 "Builtins.h" + +//! \brief Class providing GUI related built-in commands. +class CGUIBuiltins +{ +public: + //! \brief Returns the map of operations. + CBuiltins::CommandMap GetOperations() const; +}; diff --git a/xbmc/interfaces/builtins/GUIContainerBuiltins.cpp b/xbmc/interfaces/builtins/GUIContainerBuiltins.cpp new file mode 100644 index 0000000..a97565c --- /dev/null +++ b/xbmc/interfaces/builtins/GUIContainerBuiltins.cpp @@ -0,0 +1,189 @@ +/* + * 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 "GUIContainerBuiltins.h" + +#include "GUIUserMessages.h" +#include "ServiceBroker.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +#include "utils/StringUtils.h" + +/*! \brief Change sort method. + * \param params (ignored) + * + * Set the Dir template parameter to 1 to switch to next sort method + * or -1 to switch to previous sort method. + */ + template<int Dir> +static int ChangeSortMethod(const std::vector<std::string>& params) +{ + CGUIMessage message(GUI_MSG_CHANGE_SORT_METHOD, CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow(), 0, 0, Dir); + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(message); + + return 0; +} + +/*! \brief Change view mode. + * \param params (ignored) + * + * Set the Dir template parameter to 1 to switch to next view mode + * or -1 to switch to previous view mode. + */ + template<int Dir> +static int ChangeViewMode(const std::vector<std::string>& params) +{ + CGUIMessage message(GUI_MSG_CHANGE_VIEW_MODE, CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow(), 0, 0, Dir); + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(message); + + return 0; +} + +/*! \brief Refresh a media window. + * \param params The parameters. + * \details params[0] = The URL to refresh window at. + */ +static int Refresh(const std::vector<std::string>& params) +{ // NOTE: These messages require a media window, thus they're sent to the current activewindow. + // This shouldn't stop a dialog intercepting it though. + CGUIMessage message(GUI_MSG_NOTIFY_ALL, CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow(), 0, GUI_MSG_UPDATE, 1); // 1 to reset the history + message.SetStringParam(!params.empty() ? params[0] : ""); + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(message); + + return 0; +} + +/*! \brief Set sort method. + * \param params The parameters. + * \details params[0] = ID of sort method. + */ +static int SetSortMethod(const std::vector<std::string>& params) +{ + CGUIMessage message(GUI_MSG_CHANGE_SORT_METHOD, CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow(), 0, atoi(params[0].c_str())); + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(message); + + return 0; +} + +/*! \brief Set view mode. + * \param params The parameters. + * \details params[0] = ID of view mode. + */ +static int SetViewMode(const std::vector<std::string>& params) +{ + CGUIMessage message(GUI_MSG_CHANGE_VIEW_MODE, CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow(), 0, atoi(params[0].c_str())); + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(message); + + return 0; +} + +/*! \brief Toggle sort direction. + * \param params (ignored) + */ +static int ToggleSortDirection(const std::vector<std::string>& params) +{ + CGUIMessage message(GUI_MSG_CHANGE_SORT_DIRECTION, CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow(), 0, 0); + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(message); + + return 0; +} + +/*! \brief Update a listing in a media window. + * \param params The parameters. + * \details params[0] = The URL to update listing at. + * params[1] = "replace" to reset history (optional). + */ +static int Update(const std::vector<std::string>& params) +{ + CGUIMessage message(GUI_MSG_NOTIFY_ALL, CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow(), 0, GUI_MSG_UPDATE, 0); + message.SetStringParam(params[0]); + if (params.size() > 1 && StringUtils::EqualsNoCase(params[1], "replace")) + message.SetParam2(1); // reset the history + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(message); + + return 0; +} + +// Note: For new Texts with comma add a "\" before!!! Is used for table text. +// +/// \page page_List_of_built_in_functions +/// \section built_in_functions_6 GUI container built-in's +/// +/// ----------------------------------------------------------------------------- +/// +/// \table_start +/// \table_h2_l{ +/// Function, +/// Description } +/// \table_row2_l{ +/// <b>`Container.NextSortMethod`</b> +/// , +/// Change to the next sort method. +/// } +/// \table_row2_l{ +/// <b>`Container.NextViewMode`</b> +/// , +/// Select the next view mode. +/// } +/// \table_row2_l{ +/// <b>`Container.PreviousSortMethod`</b> +/// , +/// Change to the previous sort method. +/// } +/// \table_row2_l{ +/// <b>`Container.PreviousViewMode`</b> +/// , +/// Select the previous view mode. +/// } +/// \table_row2_l{ +/// <b>`Container.Refresh(url)`</b> +/// , +/// Refresh current listing +/// @param[in] url The URL to refresh window at. +/// } +/// \table_row2_l{ +/// <b>`Container.SetSortMethod(id)`</b> +/// , +/// Change to the specified sort method. (For list of ID's \ref SortBy "see List" of sort methods below) +/// @param[in] id ID of sort method. +/// } +/// \table_row2_l{ +/// <b>`Container.SetViewMode(id)`</b> +/// , +/// Set the current view mode (list\, icons etc.) to the given container id. +/// @param[in] id ID of view mode. +/// } +/// \table_row2_l{ +/// <b>`Container.SortDirection`</b> +/// , +/// Toggle the sort direction +/// } +/// \table_row2_l{ +/// <b>`Container.Update(url\,[replace])`</b> +/// , +/// Update current listing. Send `Container.Update(path\,replace)` to reset the path history. +/// @param[in] url The URL to update listing at. +/// @param[in] replace "replace" to reset history (optional). +/// } +/// \table_end +/// + +CBuiltins::CommandMap CGUIContainerBuiltins::GetOperations() const +{ + return { + {"container.nextsortmethod", {"Change to the next sort method", 0, ChangeSortMethod<1>}}, + {"container.nextviewmode", {"Move to the next view type (and refresh the listing)", 0, ChangeViewMode<1>}}, + {"container.previoussortmethod", {"Change to the previous sort method", 0, ChangeSortMethod<-1>}}, + {"container.previousviewmode", {"Move to the previous view type (and refresh the listing)", 0, ChangeViewMode<-1>}}, + {"container.refresh", {"Refresh current listing", 0, Refresh}}, + {"container.setsortdirection", {"Toggle the sort direction", 0, ToggleSortDirection}}, + {"container.setsortmethod", {"Change to the specified sort method", 1, SetSortMethod}}, + {"container.setviewmode", {"Move to the view with the given id", 1, SetViewMode}}, + {"container.update", {"Update current listing. Send Container.Update(path,replace) to reset the path history", 1, Update}} + }; +} diff --git a/xbmc/interfaces/builtins/GUIContainerBuiltins.h b/xbmc/interfaces/builtins/GUIContainerBuiltins.h new file mode 100644 index 0000000..906afa1 --- /dev/null +++ b/xbmc/interfaces/builtins/GUIContainerBuiltins.h @@ -0,0 +1,19 @@ +/* + * 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 "Builtins.h" + +//! \brief Class providing GUI container related built-in commands. +class CGUIContainerBuiltins +{ +public: + //! \brief Returns the map of operations. + CBuiltins::CommandMap GetOperations() const; +}; diff --git a/xbmc/interfaces/builtins/GUIControlBuiltins.cpp b/xbmc/interfaces/builtins/GUIControlBuiltins.cpp new file mode 100644 index 0000000..d8d89fa --- /dev/null +++ b/xbmc/interfaces/builtins/GUIControlBuiltins.cpp @@ -0,0 +1,238 @@ +/* + * 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 "GUIControlBuiltins.h" + +#include "ServiceBroker.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +#include "input/WindowTranslator.h" +#include "utils/StringUtils.h" + +/*! \brief Send a move event to a GUI control. + * \param params The parameters. + * \details params[0] = ID of control. + * params[1] = Offset of move. + */ +static int ControlMove(const std::vector<std::string>& params) +{ + CGUIMessage message(GUI_MSG_MOVE_OFFSET, CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindowOrDialog(), + atoi(params[0].c_str()), atoi(params[1].c_str())); + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(message); + + return 0; +} + +/*! \brief Send a click event to a GUI control. + * \param params The parameters. + * \details params[0] = ID of control. + * params[1] = ID for window with control (optional). + */ +static int SendClick(const std::vector<std::string>& params) +{ + if (params.size() == 2) + { + // have a window - convert it + int windowID = CWindowTranslator::TranslateWindow(params[0]); + CGUIMessage message(GUI_MSG_CLICKED, atoi(params[1].c_str()), windowID); + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(message); + } + else + { // single param - assume you meant the focused window + CGUIMessage message(GUI_MSG_CLICKED, atoi(params[0].c_str()), CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindowOrDialog()); + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(message); + } + + return 0; +} + +/*! \brief Send a message to a control. + * \param params The parameters. + * \details params[0] = ID of control. + * params[1] = Action name. + * \params[2] = ID of window with control (optional). + */ +static int SendMessage(const std::vector<std::string>& params) +{ + int controlID = atoi(params[0].c_str()); + int windowID = (params.size() == 3) ? CWindowTranslator::TranslateWindow(params[2]) : CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow(); + if (params[1] == "moveup") + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(GUI_MSG_MOVE_OFFSET, windowID, controlID, 1); + else if (params[1] == "movedown") + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(GUI_MSG_MOVE_OFFSET, windowID, controlID, -1); + else if (params[1] == "pageup") + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(GUI_MSG_PAGE_UP, windowID, controlID); + else if (params[1] == "pagedown") + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(GUI_MSG_PAGE_DOWN, windowID, controlID); + else if (params[1] == "click") + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(GUI_MSG_CLICKED, controlID, windowID); + + return 0; +} + +/*! \brief Give a control focus. + * \param params The parameters. + * \details params[0] = ID of control. + * params[1] = ID of subitem of control (optional). + * params[2] = "absolute" to focus the absolute position instead of the relative one (optional). + */ +static int SetFocus(const std::vector<std::string>& params) +{ + int controlID = atol(params[0].c_str()); + int subItem = (params.size() > 1) ? atol(params[1].c_str())+1 : 0; + int absID = 0; + if (params.size() > 2 && StringUtils::EqualsNoCase(params[2].c_str(), "absolute")) + absID = 1; + CGUIMessage msg(GUI_MSG_SETFOCUS, CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindowOrDialog(), controlID, subItem, absID); + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(msg); + + return 0; +} + +/*! \brief Set a control to visible. + * \param params The parameters. + * \details params[0] = ID of control. + */ +static int SetVisible(const std::vector<std::string>& params) +{ + int controlID = std::stol(params[0]); + CGUIMessage msg{GUI_MSG_VISIBLE, + CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindowOrDialog(), + controlID}; + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(msg); + + return 0; +} + +/*! \brief Set a control to hidden. + * \param params The parameters. + * \details params[0] = ID of control. + */ +static int SetHidden(const std::vector<std::string>& params) +{ + int controlID = std::stol(params[0]); + CGUIMessage msg{GUI_MSG_HIDDEN, + CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindowOrDialog(), + controlID}; + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(msg); + + return 0; +} + +/*! \brief Shift page in a control. + * \param params The parameters. + * \details params[0] = ID of control + * + * Set Message template parameter to GUI_MSG_PAGE_DOWN/GUI_MSG_PAGE_UP. + */ + template<int Message> +static int ShiftPage(const std::vector<std::string>& params) +{ + int id = atoi(params[0].c_str()); + CGUIMessage message(Message, CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindowOrDialog(), id); + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(message); + + return 0; +} + +// Note: For new Texts with comma add a "\" before!!! Is used for table text. +// +/// \page page_List_of_built_in_functions +/// \section built_in_functions_7 GUI control built-in's +/// +/// ----------------------------------------------------------------------------- +/// +/// \table_start +/// \table_h2_l{ +/// Function, +/// Description } +/// \table_row2_l{ +/// <b>`control.message(controlId\, action[\, windowId])`</b> +/// , +/// Send a given message to a control within a given window +/// @param[in] controlId ID of control. +/// @param[in] action Action name. +/// @param[in] windowId ID of window with control (optional). +/// } +/// \table_row2_l{ +/// <b>`control.move(id\, offset)`</b> +/// , +/// Tells the specified control to 'move' to another entry specified by offset +/// @param[in] id ID of control. +/// @param[in] offset Offset of move. +/// } +/// \table_row2_l{ +/// <b>`control.setfocus(controlId[\, subitemId])`</b> +/// , +/// Change current focus to a different control id +/// @param[in] controlId ID of control. +/// @param[in] subitemId ID of subitem of control (optional). +/// @param[in] absolute "absolute" to focus the absolute position instead of the relative one (optional). +/// } +/// \table_row2_l{ +/// <b>`control.setvisible(controlId)`</b> +/// \anchor Builtin_SetVisible, +/// Set the control id to visible +/// @param[in] controlId ID of control. +/// <p><hr> +/// @skinning_v20 **[New builtin]** \link Builtin_SetVisible `SetVisible(id)`\endlink +/// <p> +/// } +/// \table_row2_l{ +/// <b>`control.sethidden(controlId)`</b> +/// \anchor Builtin_SetHidden, +/// Set the control id to hidden +/// @param[in] controlId ID of control. +/// <p><hr> +/// @skinning_v20 **[New builtin]** \link Builtin_SetHidden `SetHidden(id)`\endlink +/// <p> +/// } +/// \table_row2_l{ +/// <b>`pagedown(controlId)`</b> +/// , +/// Send a page down event to the pagecontrol with given id +/// @param[in] controlId ID of control. +/// } +/// \table_row2_l{ +/// <b>`pageup(controlId)`</b> +/// , +/// Send a page up event to the pagecontrol with given id +/// @param[in] controlId ID of control. +/// } +/// \table_row2_l{ +/// <b>`sendclick(controlId [\, windowId])`</b> +/// , +/// Send a click message from the given control to the given window +/// @param[in] controlId ID of control. +/// @param[in] windowId ID for window with control (optional). +/// } +/// \table_row2_l{ +/// <b>`setfocus`</b> +/// , +/// Change current focus to a different control id +/// @param[in] controlId ID of control. +/// @param[in] subitemId ID of subitem of control (optional). +/// @param[in] absolute "absolute" to focus the absolute position instead of the relative one (optional). +/// } +/// \table_end +/// + +CBuiltins::CommandMap CGUIControlBuiltins::GetOperations() const +{ + return { + {"control.message", {"Send a given message to a control within a given window", 2, SendMessage}}, + {"control.move", {"Tells the specified control to 'move' to another entry specified by offset", 2, ControlMove}}, + {"control.setfocus", {"Change current focus to a different control id", 1, SetFocus}}, + {"control.setvisible", {"Set the control id to visible", 1, SetVisible}}, + {"control.sethidden", {"Set the control id to Hidden", 1, SetHidden}}, + {"pagedown", {"Send a page down event to the pagecontrol with given id", 1, ShiftPage<GUI_MSG_PAGE_DOWN>}}, + {"pageup", {"Send a page up event to the pagecontrol with given id", 1, ShiftPage<GUI_MSG_PAGE_UP>}}, + {"sendclick", {"Send a click message from the given control to the given window", 1, SendClick}}, + {"setfocus", {"Change current focus to a different control id", 1, SetFocus}}, + }; +} diff --git a/xbmc/interfaces/builtins/GUIControlBuiltins.h b/xbmc/interfaces/builtins/GUIControlBuiltins.h new file mode 100644 index 0000000..70831d6 --- /dev/null +++ b/xbmc/interfaces/builtins/GUIControlBuiltins.h @@ -0,0 +1,19 @@ +/* + * 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 "Builtins.h" + +//! \brief Class providing GUI control related built-in commands. +class CGUIControlBuiltins +{ +public: + //! \brief Returns the map of operations. + CBuiltins::CommandMap GetOperations() const; +}; diff --git a/xbmc/interfaces/builtins/LibraryBuiltins.cpp b/xbmc/interfaces/builtins/LibraryBuiltins.cpp new file mode 100644 index 0000000..5cb678a --- /dev/null +++ b/xbmc/interfaces/builtins/LibraryBuiltins.cpp @@ -0,0 +1,416 @@ +/* + * 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 "LibraryBuiltins.h" + +#include "GUIUserMessages.h" +#include "MediaSource.h" +#include "ServiceBroker.h" +#include "dialogs/GUIDialogFileBrowser.h" +#include "dialogs/GUIDialogYesNo.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +#include "guilib/LocalizeStrings.h" +#include "messaging/helpers/DialogHelper.h" +#include "messaging/helpers/DialogOKHelper.h" +#include "music/MusicLibraryQueue.h" +#include "music/infoscanner/MusicInfoScanner.h" +#include "settings/LibExportSettings.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" +#include "storage/MediaManager.h" +#include "utils/StringUtils.h" +#include "utils/log.h" +#include "video/VideoDatabase.h" +#include "video/VideoLibraryQueue.h" + +using namespace KODI::MESSAGING; + +/*! \brief Clean a library. + * \param params The parameters. + * \details params[0] = "video" or "music". + */ +static int CleanLibrary(const std::vector<std::string>& params) +{ + bool userInitiated = true; + if (params.size() > 1) + userInitiated = StringUtils::EqualsNoCase(params[1], "true"); + if (!params.size() || StringUtils::EqualsNoCase(params[0], "video") + || StringUtils::EqualsNoCase(params[0], "movies") + || StringUtils::EqualsNoCase(params[0], "tvshows") + || StringUtils::EqualsNoCase(params[0], "musicvideos")) + { + if (!CVideoLibraryQueue::GetInstance().IsScanningLibrary()) + { + if (userInitiated && CVideoLibraryQueue::GetInstance().IsRunning()) + HELPERS::ShowOKDialogText(CVariant{700}, CVariant{703}); + else + { + const std::string content = (params.empty() || params[0] == "video") ? "" : params[0]; + const std::string directory = params.size() > 2 ? params[2] : ""; + + std::set<int> paths; + if (!content.empty() || !directory.empty()) + { + CVideoDatabase db; + std::set<std::string> contentPaths; + if (db.Open()) + { + if (!directory.empty()) + contentPaths.insert(directory); + else + db.GetPaths(contentPaths); + for (const std::string& path : contentPaths) + { + if (db.GetContentForPath(path) == content) + { + paths.insert(db.GetPathId(path)); + std::vector<std::pair<int, std::string>> sub; + if (db.GetSubPaths(path, sub)) + { + for (const auto& it : sub) + paths.insert(it.first); + } + } + } + } + if (paths.empty()) + return 0; + } + + if (userInitiated) + CVideoLibraryQueue::GetInstance().CleanLibraryModal(paths); + else + CVideoLibraryQueue::GetInstance().CleanLibrary(paths, true); + } + } + else + CLog::Log(LOGERROR, "CleanLibrary is not possible while scanning or cleaning"); + } + else if (StringUtils::EqualsNoCase(params[0], "music")) + { + if (!CMusicLibraryQueue::GetInstance().IsScanningLibrary()) + { + if (!(userInitiated && CMusicLibraryQueue::GetInstance().IsRunning())) + CMusicLibraryQueue::GetInstance().CleanLibrary(userInitiated); + } + else + CLog::Log(LOGERROR, "CleanLibrary is not possible while scanning for media info"); + } + else + CLog::Log(LOGERROR, "Unknown content type '{}' passed to CleanLibrary, ignoring", params[0]); + + return 0; +} + +/*! \brief Export a library. + * \param params The parameters. + * \details params[0] = "video" or "music". + * params[1] = "true" to export to separate files (optional). + * params[2] = "true" to export thumbs (optional) or the file path for export to singlefile. + * params[3] = "true" to overwrite existing files (optional). + * params[4] = "true" to export actor thumbs (optional). + */ +static int ExportLibrary(const std::vector<std::string>& params) +{ + int iHeading = 647; + if (StringUtils::EqualsNoCase(params[0], "music")) + iHeading = 20196; + std::string path; + VECSOURCES shares; + CServiceBroker::GetMediaManager().GetLocalDrives(shares); + CServiceBroker::GetMediaManager().GetNetworkLocations(shares); + CServiceBroker::GetMediaManager().GetRemovableDrives(shares); + bool singleFile; + bool thumbs=false; + bool actorThumbs=false; + bool overwrite=false; + bool cancelled=false; + + if (params.size() > 1) + singleFile = StringUtils::EqualsNoCase(params[1], "false"); + else + { + HELPERS::DialogResponse result = HELPERS::ShowYesNoDialogText(CVariant{iHeading}, CVariant{20426}, CVariant{20428}, CVariant{20429}); + cancelled = result == HELPERS::DialogResponse::CHOICE_CANCELLED; + singleFile = result != HELPERS::DialogResponse::CHOICE_YES; + } + + if (cancelled) + return -1; + + if (!singleFile) + { + if (params.size() > 2) + thumbs = StringUtils::EqualsNoCase(params[2], "true"); + else + { + HELPERS::DialogResponse result = HELPERS::ShowYesNoDialogText(CVariant{iHeading}, CVariant{20430}); + cancelled = result == HELPERS::DialogResponse::CHOICE_CANCELLED; + thumbs = result == HELPERS::DialogResponse::CHOICE_YES; + } + } + + if (cancelled) + return -1; + + if (thumbs && !singleFile && StringUtils::EqualsNoCase(params[0], "video")) + { + std::string movieSetsInfoPath = CServiceBroker::GetSettingsComponent()->GetSettings()-> + GetString(CSettings::SETTING_VIDEOLIBRARY_MOVIESETSFOLDER); + if (movieSetsInfoPath.empty()) + { + auto result = HELPERS::ShowYesNoDialogText(CVariant{iHeading}, CVariant{36301}); + cancelled = result != HELPERS::DialogResponse::CHOICE_YES; + } + } + + if (cancelled) + return -1; + + if (thumbs && StringUtils::EqualsNoCase(params[0], "video")) + { + if (params.size() > 4) + actorThumbs = StringUtils::EqualsNoCase(params[4], "true"); + else + { + HELPERS::DialogResponse result = HELPERS::ShowYesNoDialogText(CVariant{iHeading}, CVariant{20436}); + cancelled = result == HELPERS::DialogResponse::CHOICE_CANCELLED; + actorThumbs = result == HELPERS::DialogResponse::CHOICE_YES; + } + } + + if (cancelled) + return -1; + + if (!singleFile) + { + if (params.size() > 3) + overwrite = StringUtils::EqualsNoCase(params[3], "true"); + else + { + HELPERS::DialogResponse result = HELPERS::ShowYesNoDialogText(CVariant{iHeading}, CVariant{20431}); + cancelled = result == HELPERS::DialogResponse::CHOICE_CANCELLED; + overwrite = result == HELPERS::DialogResponse::CHOICE_YES; + } + } + + if (cancelled) + return -1; + + if (params.size() > 2) + path=params[2]; + if (!singleFile || !path.empty() || + CGUIDialogFileBrowser::ShowAndGetDirectory(shares, g_localizeStrings.Get(661), + path, true)) + { + if (StringUtils::EqualsNoCase(params[0], "video")) + { + CVideoDatabase videodatabase; + videodatabase.Open(); + videodatabase.ExportToXML(path, singleFile, thumbs, actorThumbs, overwrite); + videodatabase.Close(); + } + else + { + CLibExportSettings settings; + // ELIBEXPORT_SINGLEFILE, ELIBEXPORT_ALBUMS + ELIBEXPORT_ALBUMARTISTS by default + settings.m_strPath = path; + if (!singleFile) + settings.SetExportType(ELIBEXPORT_TOLIBRARYFOLDER); + settings.m_artwork = thumbs; + settings.m_overwrite = overwrite; + // Export music library (not showing progress dialog) + CMusicLibraryQueue::GetInstance().ExportLibrary(settings, false); + } + } + + return 0; +} + +/*! \brief Export a library with extended parameters +Avoiding breaking change to original ExportLibrary routine parameters +* \param params The parameters. +* \details params[0] = "video" or "music". +* params[1] = export type "singlefile", "separate", or "library". +* params[2] = path of destination folder. +* params[3,...] = "unscraped" to include unscraped items +* params[3,...] = "overwrite" to overwrite existing files. +* params[3,...] = "artwork" to include images such as thumbs and fanart. +* params[3,...] = "skipnfo" to not include nfo files (just art). +* params[3,...] = "ablums" to include albums. +* params[3,...] = "albumartists" to include album artists. +* params[3,...] = "songartists" to include song artists. +* params[3,...] = "otherartists" to include other artists. +*/ +static int ExportLibrary2(const std::vector<std::string>& params) +{ + CLibExportSettings settings; + if (params.size() < 3) + return -1; + settings.m_strPath = params[2]; + settings.SetExportType(ELIBEXPORT_SINGLEFILE); + if (StringUtils::EqualsNoCase(params[1], "separate")) + settings.SetExportType(ELIBEXPORT_SEPARATEFILES); + else if (StringUtils::EqualsNoCase(params[1], "library")) + { + settings.SetExportType(ELIBEXPORT_TOLIBRARYFOLDER); + settings.m_strPath.clear(); + } + settings.ClearItems(); + + for (unsigned int i = 2; i < params.size(); i++) + { + if (StringUtils::EqualsNoCase(params[i], "artwork")) + settings.m_artwork = true; + else if (StringUtils::EqualsNoCase(params[i], "overwrite")) + settings.m_overwrite = true; + else if (StringUtils::EqualsNoCase(params[i], "unscraped")) + settings.m_unscraped = true; + else if (StringUtils::EqualsNoCase(params[i], "skipnfo")) + settings.m_skipnfo = true; + else if (StringUtils::EqualsNoCase(params[i], "albums")) + settings.AddItem(ELIBEXPORT_ALBUMS); + else if (StringUtils::EqualsNoCase(params[i], "albumartists")) + settings.AddItem(ELIBEXPORT_ALBUMARTISTS); + else if (StringUtils::EqualsNoCase(params[i], "songartists")) + settings.AddItem(ELIBEXPORT_SONGARTISTS); + else if (StringUtils::EqualsNoCase(params[i], "otherartists")) + settings.AddItem(ELIBEXPORT_OTHERARTISTS); + else if (StringUtils::EqualsNoCase(params[i], "actorthumbs")) + settings.AddItem(ELIBEXPORT_ACTORTHUMBS); + } + if (StringUtils::EqualsNoCase(params[0], "music")) + { + // Export music library (not showing progress dialog) + CMusicLibraryQueue::GetInstance().ExportLibrary(settings, false); + } + else + { + CVideoDatabase videodatabase; + videodatabase.Open(); + videodatabase.ExportToXML(settings.m_strPath, settings.IsSingleFile(), + settings.m_artwork, settings.IsItemExported(ELIBEXPORT_ACTORTHUMBS), settings.m_overwrite); + videodatabase.Close(); + } + return 0; +} + + +/*! \brief Update a library. + * \param params The parameters. + * \details params[0] = "video" or "music". + * params[1] = "true" to suppress dialogs (optional). + */ +static int UpdateLibrary(const std::vector<std::string>& params) +{ + bool userInitiated = true; + if (params.size() > 2) + userInitiated = StringUtils::EqualsNoCase(params[2], "true"); + if (StringUtils::EqualsNoCase(params[0], "music")) + { + if (CMusicLibraryQueue::GetInstance().IsScanningLibrary()) + CMusicLibraryQueue::GetInstance().StopLibraryScanning(); + else + CMusicLibraryQueue::GetInstance().ScanLibrary(params.size() > 1 ? params[1] : "", + MUSIC_INFO::CMusicInfoScanner::SCAN_NORMAL, + userInitiated); + } + else if (StringUtils::EqualsNoCase(params[0], "video")) + { + if (CVideoLibraryQueue::GetInstance().IsScanningLibrary()) + CVideoLibraryQueue::GetInstance().StopLibraryScanning(); + else + CVideoLibraryQueue::GetInstance().ScanLibrary(params.size() > 1 ? params[1] : "", false, + userInitiated); + } + + return 0; +} + +/*! \brief Open a video library search. + * \param params (ignored) + */ +static int SearchVideoLibrary(const std::vector<std::string>& params) +{ + CGUIMessage msg(GUI_MSG_SEARCH, 0, 0, 0); + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(msg, WINDOW_VIDEO_NAV); + + return 0; +} + +// Note: For new Texts with comma add a "\" before!!! Is used for table text. +// +/// \page page_List_of_built_in_functions +/// \section built_in_functions_8 Library built-in's +/// +/// ----------------------------------------------------------------------------- +/// +/// \table_start +/// \table_h2_l{ +/// Function, +/// Description } +/// \table_row2_l{ +/// <b>`cleanlibrary(type)`</b> +/// , +/// Clean the video/music library +/// @param[in] type "video"\, "movies"\, "tvshows"\, "musicvideos" or "music". +/// } +/// \table_row2_l{ +/// <b>`exportlibrary(type [\, exportSingeFile\, exportThumbs\, overwrite\, exportActorThumbs])`</b> +/// , +/// Export the video/music library +/// @param[in] type "video" or "music". +/// @param[in] exportSingleFile Add "true" to export to separate files (optional). +/// @param[in] exportThumbs Add "true" to export thumbs (optional). +/// @param[in] overwrite Add "true" to overwrite existing files (optional). +/// @param[in] exportActorThumbs Add "true" to export actor thumbs (optional). +/// } +/// \table_row2_l{ +/// <b>`exportlibrary2(library\, exportFiletype\, path [\, unscraped][\, overwrite][\, artwork][\, skipnfo] +/// [\, albums][\, albumartists][\, songartists][\, otherartists][\, actorthumbs])`</b> +/// , +/// Export the video/music library with extended parameters +/// @param[in] library "video" or "music". +/// @param[in] exportFiletype "singlefile"\, "separate" or "library". +/// @param[in] path Path to destination folder. +/// @param[in] unscraped Add "unscraped" to include unscraped items. +/// @param[in] overwrite Add "overwrite" to overwrite existing files. +/// @param[in] artwork Add "artwork" to include images such as thumbs and fanart. +/// @param[in] skipnfo Add "skipnfo" to not include nfo files(just art). +/// @param[in] albums Add "ablums" to include albums. +/// @param[in] albumartists Add "albumartists" to include album artists. +/// @param[in] songartists Add "songartists" to include song artists. +/// @param[in] otherartists Add "otherartists" to include other artists. +/// @param[in] actorthumbs Add "actorthumbs" to include other actor thumbs. +/// } +/// \table_row2_l{ +/// <b>`updatelibrary([type\, suppressDialogs])`</b> +/// , +/// Update the selected library (music or video) +/// @param[in] type "video" or "music". +/// @param[in] suppressDialogs Add "true" to suppress dialogs (optional). +/// } +/// \table_row2_l{ +/// <b>`videolibrary.search`</b> +/// , +/// Brings up a search dialog which will search the library +/// } +/// \table_end +/// + +CBuiltins::CommandMap CLibraryBuiltins::GetOperations() const +{ + return { + {"cleanlibrary", {"Clean the video/music library", 1, CleanLibrary}}, + {"exportlibrary", {"Export the video/music library", 1, ExportLibrary}}, + {"exportlibrary2", {"Export the video/music library", 1, ExportLibrary2}}, + {"updatelibrary", {"Update the selected library (music or video)", 1, UpdateLibrary}}, + {"videolibrary.search", {"Brings up a search dialog which will search the library", 0, SearchVideoLibrary}} + }; +} diff --git a/xbmc/interfaces/builtins/LibraryBuiltins.h b/xbmc/interfaces/builtins/LibraryBuiltins.h new file mode 100644 index 0000000..1bc8744 --- /dev/null +++ b/xbmc/interfaces/builtins/LibraryBuiltins.h @@ -0,0 +1,19 @@ +/* + * 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 "Builtins.h" + +//! \brief Class providing library related built-in commands. +class CLibraryBuiltins +{ +public: + //! \brief Returns the map of operations. + CBuiltins::CommandMap GetOperations() const; +}; diff --git a/xbmc/interfaces/builtins/OpticalBuiltins.cpp b/xbmc/interfaces/builtins/OpticalBuiltins.cpp new file mode 100644 index 0000000..4a0ec5d --- /dev/null +++ b/xbmc/interfaces/builtins/OpticalBuiltins.cpp @@ -0,0 +1,75 @@ +/* + * 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 "OpticalBuiltins.h" + +#include "ServiceBroker.h" + +#ifdef HAS_DVD_DRIVE +#include "storage/MediaManager.h" +#endif + +#ifdef HAS_CDDA_RIPPER +#include "cdrip/CDDARipper.h" +#endif + +/*! \brief Eject the tray of an optical drive. + * \param params (ignored) + */ +static int Eject(const std::vector<std::string>& params) +{ +#ifdef HAS_DVD_DRIVE + CServiceBroker::GetMediaManager().ToggleTray(); +#endif + + return 0; +} + +/*! \brief Rip currently inserted CD. + * \param params (ignored) + */ +static int RipCD(const std::vector<std::string>& params) +{ +#ifdef HAS_CDDA_RIPPER + KODI::CDRIP::CCDDARipper::GetInstance().RipCD(); +#endif + + return 0; +} + +// Note: For new Texts with comma add a "\" before!!! Is used for table text. +// +/// \page page_List_of_built_in_functions +/// \section built_in_functions_9 Optical container built-in's +/// +/// ----------------------------------------------------------------------------- +/// +/// \table_start +/// \table_h2_l{ +/// Function, +/// Description } +/// \table_row2_l{ +/// <b>`EjectTray`</b> +/// , +/// Either opens or closes the DVD tray\, depending on its current state. +/// } +/// \table_row2_l{ +/// <b>`RipCD`</b> +/// , +/// Will rip the inserted CD from the DVD-ROM drive. +/// } +/// \table_end +/// + +CBuiltins::CommandMap COpticalBuiltins::GetOperations() const +{ + return { + {"ejecttray", {"Close or open the DVD tray", 0, Eject}}, + {"ripcd", {"Rip the currently inserted audio CD", 0, RipCD}} + }; +} diff --git a/xbmc/interfaces/builtins/OpticalBuiltins.h b/xbmc/interfaces/builtins/OpticalBuiltins.h new file mode 100644 index 0000000..c1b218e --- /dev/null +++ b/xbmc/interfaces/builtins/OpticalBuiltins.h @@ -0,0 +1,19 @@ +/* + * 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 "Builtins.h" + +//! \brief Class providing optical media related built-in commands. +class COpticalBuiltins +{ +public: + //! \brief Returns the map of operations. + CBuiltins::CommandMap GetOperations() const; +}; diff --git a/xbmc/interfaces/builtins/PVRBuiltins.cpp b/xbmc/interfaces/builtins/PVRBuiltins.cpp new file mode 100644 index 0000000..f87d0d6 --- /dev/null +++ b/xbmc/interfaces/builtins/PVRBuiltins.cpp @@ -0,0 +1,224 @@ +/* + * 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 "PVRBuiltins.h" + +#include "GUIInfoManager.h" +#include "ServiceBroker.h" +#include "application/Application.h" +#include "application/ApplicationComponents.h" +#include "application/ApplicationPlayer.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +#include "guilib/guiinfo/GUIInfoLabels.h" +#include "pvr/PVRManager.h" +#include "pvr/guilib/PVRGUIActionsTimers.h" +#include "pvr/windows/GUIWindowPVRGuide.h" +#include "utils/StringUtils.h" +#include "utils/log.h" + +#include <algorithm> +#include <cstdlib> +#include <regex> + +using namespace PVR; + +/*! \brief Search for missing channel icons + * \param params (ignored) + */ +static int SearchMissingIcons(const std::vector<std::string>& params) +{ + CServiceBroker::GetPVRManager().TriggerSearchMissingChannelIcons(); + return 0; +} + +/*! \brief will toggle recording of playing channel, if any. + * \param params (ignored) + */ +static int ToggleRecordPlayingChannel(const std::vector<std::string>& params) +{ + CServiceBroker::GetPVRManager().Get<PVR::GUI::Timers>().ToggleRecordingOnPlayingChannel(); + return 0; +} + +/*! \brief seeks to the given percentage in timeshift buffer, if timeshifting is supported. + * \param params The parameters + * \details params[0] = percentage to seek to in the timeshift buffer. + */ +static int SeekPercentage(const std::vector<std::string>& params) +{ + const auto& components = CServiceBroker::GetAppComponents(); + const auto appPlayer = components.GetComponent<CApplicationPlayer>(); + + if (params.empty()) + { + CLog::Log(LOGERROR,"PVR.SeekPercentage(n) - No argument given"); + } + else + { + const float fTimeshiftPercentage = static_cast<float>(std::atof(params.front().c_str())); + if (fTimeshiftPercentage < 0 || fTimeshiftPercentage > 100) + { + CLog::Log(LOGERROR, "PVR.SeekPercentage(n) - Invalid argument ({:f}), must be in range 0-100", + fTimeshiftPercentage); + } + else if (appPlayer->IsPlaying()) + { + CGUIInfoManager& infoMgr = CServiceBroker::GetGUI()->GetInfoManager(); + + int iTimeshiftProgressDuration = 0; + infoMgr.GetInt(iTimeshiftProgressDuration, PVR_TIMESHIFT_PROGRESS_DURATION, + INFO::DEFAULT_CONTEXT); + + int iTimeshiftBufferStart = 0; + infoMgr.GetInt(iTimeshiftBufferStart, PVR_TIMESHIFT_PROGRESS_BUFFER_START, + INFO::DEFAULT_CONTEXT); + + float fPlayerPercentage = static_cast<float>(iTimeshiftProgressDuration) / + static_cast<float>(g_application.GetTotalTime()) * + (fTimeshiftPercentage - static_cast<float>(iTimeshiftBufferStart)); + fPlayerPercentage = std::max(0.0f, std::min(fPlayerPercentage, 100.0f)); + + g_application.SeekPercentage(fPlayerPercentage); + } + } + return 0; +} + +namespace +{ +/*! \brief Control PVR Guide window's EPG grid. + * \param params The parameters + * \details params[0] = Control to execute. + */ +int EpgGridControl(const std::vector<std::string>& params) +{ + if (params.empty()) + { + CLog::Log(LOGERROR, "EpgGridControl(n) - No argument given"); + return 0; + } + + int activeWindow = CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow(); + if (activeWindow != WINDOW_TV_GUIDE && activeWindow != WINDOW_RADIO_GUIDE) + { + CLog::Log(LOGERROR, "EpgGridControl(n) - Guide window not active"); + return 0; + } + + CGUIWindowPVRGuideBase* guideWindow = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIWindowPVRGuideBase>(activeWindow); + if (!guideWindow) + { + CLog::Log(LOGERROR, "EpgGridControl(n) - Unable to get Guide window instance"); + return 0; + } + + std::string param(params[0]); + StringUtils::ToLower(param); + + if (param == "firstprogramme") + { + guideWindow->GotoBegin(); + } + else if (param == "lastprogramme") + { + guideWindow->GotoEnd(); + } + else if (param == "currentprogramme") + { + guideWindow->GotoCurrentProgramme(); + } + else if (param == "selectdate") + { + guideWindow->OpenDateSelectionDialog(); + } + else if (StringUtils::StartsWithNoCase(param, "+") || StringUtils::StartsWithNoCase(param, "-")) + { + // jump back/forward n hours + if (std::regex_match(param, std::regex("[(-|+)|][0-9]+"))) + { + guideWindow->GotoDate(std::atoi(param.c_str())); + } + else + { + CLog::Log(LOGERROR, "EpgGridControl(n) - invalid argument"); + } + } + else if (param == "firstchannel") + { + guideWindow->GotoFirstChannel(); + } + else if (param == "playingchannel") + { + guideWindow->GotoPlayingChannel(); + } + else if (param == "lastchannel") + { + guideWindow->GotoLastChannel(); + } + else if (param == "previousgroup") + { + guideWindow->ActivatePreviousChannelGroup(); + } + else if (param == "nextgroup") + { + guideWindow->ActivateNextChannelGroup(); + } + else if (param == "selectgroup") + { + guideWindow->OpenChannelGroupSelectionDialog(); + } + + return 0; +} + +} // unnamed namespace + +// Note: For new Texts with comma add a "\" before!!! Is used for table text. +// +/// \page page_List_of_built_in_functions +/// \section built_in_functions_10 PVR built-in's +/// +/// ----------------------------------------------------------------------------- +/// +/// \table_start +/// \table_h2_l{ +/// Function, +/// Description } +/// \table_row2_l{ +/// <b>`PVR.SearchMissingChannelIcons`</b> +/// , +/// Will start a search for missing channel icons +/// } +/// \table_row2_l{ +/// <b>`PVR.ToggleRecordPlayingChannel`</b> +/// , +/// Will toggle recording on playing channel\, if any +/// } +/// \table_row2_l{ +/// <b>`PVR.SeekPercentage`</b> +/// , +/// Performs a seek to the given percentage in timeshift buffer\, if timeshifting is supported +/// } +/// \table_row2_l{ +/// <b>`PVR.EpgGridControl`</b> +/// , +/// Control PVR Guide window's EPG grid +/// } +/// \table_end +/// + +CBuiltins::CommandMap CPVRBuiltins::GetOperations() const +{ + return { + {"pvr.searchmissingchannelicons", {"Search for missing channel icons", 0, SearchMissingIcons}}, + {"pvr.togglerecordplayingchannel", {"Toggle recording on playing channel", 0, ToggleRecordPlayingChannel}}, + {"pvr.seekpercentage", {"Performs a seek to the given percentage in timeshift buffer", 1, SeekPercentage}}, + {"pvr.epggridcontrol", {"Control PVR Guide window's EPG grid", 1, EpgGridControl}}, + }; +} diff --git a/xbmc/interfaces/builtins/PVRBuiltins.h b/xbmc/interfaces/builtins/PVRBuiltins.h new file mode 100644 index 0000000..a22259b --- /dev/null +++ b/xbmc/interfaces/builtins/PVRBuiltins.h @@ -0,0 +1,19 @@ +/* + * 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 "Builtins.h" + +//! \brief Class providing PVR related built-in commands. +class CPVRBuiltins +{ +public: + //! \brief Returns the map of operations. + CBuiltins::CommandMap GetOperations() const; +}; diff --git a/xbmc/interfaces/builtins/PictureBuiltins.cpp b/xbmc/interfaces/builtins/PictureBuiltins.cpp new file mode 100644 index 0000000..15cfe0a --- /dev/null +++ b/xbmc/interfaces/builtins/PictureBuiltins.cpp @@ -0,0 +1,135 @@ +/* + * 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 "PictureBuiltins.h" + +#include "GUIUserMessages.h" +#include "ServiceBroker.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +#include "utils/StringUtils.h" + +/*! \brief Show a picture. + * \param params The parameters. + * \details params[0] = URL of picture. + */ +static int Show(const std::vector<std::string>& params) +{ + CGUIMessage msg(GUI_MSG_SHOW_PICTURE, 0, 0); + msg.SetStringParam(params[0]); + CGUIWindow *pWindow = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_SLIDESHOW); + if (pWindow) + pWindow->OnMessage(msg); + + return 0; +} + +/*! \brief Start a slideshow. + * \param params The parameters. + * \details params[0] = Path to run slideshow for. + * params[1,..] = "recursive" to run a recursive slideshow. + * params[1,...] = "random" to randomize slideshow. + * params[1,...] = "notrandom" to not randomize slideshow. + * params[1,...] = "pause" to start slideshow paused. + * params[1,...] = "beginslide=<number>" to start at a given slide. + * + * Set the template parameter Recursive to true to run a recursive slideshow. + */ + template<bool Recursive> +static int Slideshow(const std::vector<std::string>& params) +{ + std::string beginSlidePath; + // leave RecursiveSlideShow command as-is + unsigned int flags = 0; + if (Recursive) + flags |= 1; + + // SlideShow(dir[,recursive][,[not]random][,pause][,beginslide="/path/to/start/slide.jpg"]) + // the beginslide value need be escaped (for '"' or '\' in it, by backslash) + // and then quoted, or not. See CUtil::SplitParams() + else + { + for (unsigned int i = 1 ; i < params.size() ; i++) + { + if (StringUtils::EqualsNoCase(params[i], "recursive")) + flags |= 1; + else if (StringUtils::EqualsNoCase(params[i], "random")) // set fullscreen or windowed + flags |= 2; + else if (StringUtils::EqualsNoCase(params[i], "notrandom")) + flags |= 4; + else if (StringUtils::EqualsNoCase(params[i], "pause")) + flags |= 8; + else if (StringUtils::StartsWithNoCase(params[i], "beginslide=")) + beginSlidePath = params[i].substr(11); + } + } + + CGUIMessage msg(GUI_MSG_START_SLIDESHOW, 0, 0, flags); + std::vector<std::string> strParams; + strParams.push_back(params[0]); + strParams.push_back(beginSlidePath); + msg.SetStringParams(strParams); + CGUIWindow *pWindow = CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_SLIDESHOW); + if (pWindow) + pWindow->OnMessage(msg); + + return 0; +} + +// Note: For new Texts with comma add a "\" before!!! Is used for table text +// +/// \page page_List_of_built_in_functions +/// \section built_in_functions_11 Picture built-in's +/// +/// ----------------------------------------------------------------------------- +/// +/// \table_start +/// \table_h2_l{ +/// Function, +/// Description } +/// \table_row2_l{ +/// <b>`RecursiveSlideShow(dir)`</b> +/// , +/// Run a slideshow from the specified directory\, including all subdirs. +/// @param[in] dir Path to run slideshow for. +/// @param[in] random Add "random" to randomize slideshow (optional). +/// @param[in] notrandom Add "notrandom" to not randomize slideshow (optional). +/// @param[in] pause Add "pause" to start slideshow paused (optional). +/// @param[in] beginslide Add "beginslide=<number>" to start at a given slide (optional). +/// } +/// \table_row2_l{ +/// <b>`ShowPicture(picture)`</b> +/// , +/// Display a picture by file path. +/// @param[in] url URL of picture. +/// } +/// \table_row2_l{ +/// <b>`SlideShow(dir [\,recursive\, [not]random])`</b> +/// , +/// Starts a slideshow of pictures in the folder dir. Optional parameters are +/// <b>recursive</b>\, and **random** or **notrandom** slideshow\, adding images +/// from sub-folders. The **random** and **notrandom** parameters override +/// the Randomize setting found in the pictures media window. +/// @param[in] dir Path to run slideshow for. +/// @param[in] recursive Add "recursive" to run a recursive slideshow (optional). +/// @param[in] random Add "random" to randomize slideshow (optional). +/// @param[in] notrandom Add "notrandom" to not randomize slideshow (optional). +/// @param[in] pause Add "pause" to start slideshow paused (optional). +/// @param[in] beginslide Add "beginslide=<number>" to start at a given slide (optional). +/// } +/// \table_end +/// + +CBuiltins::CommandMap CPictureBuiltins::GetOperations() const +{ + return { + {"recursiveslideshow", {"Run a slideshow from the specified directory, including all subdirs", 1, Slideshow<true>}}, + {"showpicture", {"Display a picture by file path", 1, Show}}, + {"slideshow", {"Run a slideshow from the specified directory", 1, Slideshow<false>}} + }; +} diff --git a/xbmc/interfaces/builtins/PictureBuiltins.h b/xbmc/interfaces/builtins/PictureBuiltins.h new file mode 100644 index 0000000..4dd396b --- /dev/null +++ b/xbmc/interfaces/builtins/PictureBuiltins.h @@ -0,0 +1,19 @@ +/* + * 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 "Builtins.h" + +//! \brief Class providing picture related built-in commands. +class CPictureBuiltins +{ +public: + //! \brief Returns the map of operations. + CBuiltins::CommandMap GetOperations() const; +}; diff --git a/xbmc/interfaces/builtins/PlayerBuiltins.cpp b/xbmc/interfaces/builtins/PlayerBuiltins.cpp new file mode 100644 index 0000000..ca69d69 --- /dev/null +++ b/xbmc/interfaces/builtins/PlayerBuiltins.cpp @@ -0,0 +1,842 @@ +/* + * 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 "PlayerBuiltins.h" + +#include "FileItem.h" +#include "GUIUserMessages.h" +#include "PartyModeManager.h" +#include "PlayListPlayer.h" +#include "SeekHandler.h" +#include "ServiceBroker.h" +#include "Util.h" +#include "application/Application.h" +#include "application/ApplicationComponents.h" +#include "application/ApplicationPlayer.h" +#include "application/ApplicationPowerHandling.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +#include "music/MusicUtils.h" +#include "playlists/PlayList.h" +#include "pvr/PVRManager.h" +#include "pvr/channels/PVRChannel.h" +#include "pvr/guilib/PVRGUIActionsChannels.h" +#include "pvr/recordings/PVRRecording.h" +#include "settings/MediaSettings.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" +#include "storage/MediaManager.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" +#include "utils/log.h" +#include "video/PlayerController.h" +#include "video/VideoUtils.h" +#include "video/windows/GUIWindowVideoBase.h" + +#include <math.h> + +#ifdef HAS_DVD_DRIVE +#include "Autorun.h" +#endif + +/*! \brief Clear current playlist + * \param params (ignored) + */ +static int ClearPlaylist(const std::vector<std::string>& params) +{ + CServiceBroker::GetPlaylistPlayer().Clear(); + + return 0; +} + +/*! \brief Start a playlist from a given offset. + * \param params The parameters. + * \details params[0] = Position in playlist or playlist type. + * params[1] = Position in playlist if params[0] is playlist type (optional). + */ +static int PlayOffset(const std::vector<std::string>& params) +{ + // playlist.playoffset(offset) + // playlist.playoffset(music|video,offset) + std::string strPos = params[0]; + std::string paramlow(params[0]); + StringUtils::ToLower(paramlow); + if (params.size() > 1) + { + // ignore any other parameters if present + std::string strPlaylist = params[0]; + strPos = params[1]; + + PLAYLIST::Id playlistId = PLAYLIST::TYPE_NONE; + if (paramlow == "music") + playlistId = PLAYLIST::TYPE_MUSIC; + else if (paramlow == "video") + playlistId = PLAYLIST::TYPE_VIDEO; + + // unknown playlist + if (playlistId == PLAYLIST::TYPE_NONE) + { + CLog::Log(LOGERROR, "Playlist.PlayOffset called with unknown playlist: {}", strPlaylist); + return false; + } + + // user wants to play the 'other' playlist + if (playlistId != CServiceBroker::GetPlaylistPlayer().GetCurrentPlaylist()) + { + g_application.StopPlaying(); + CServiceBroker::GetPlaylistPlayer().Reset(); + CServiceBroker::GetPlaylistPlayer().SetCurrentPlaylist(playlistId); + } + } + // play the desired offset + int pos = atol(strPos.c_str()); + + const auto& components = CServiceBroker::GetAppComponents(); + const auto appPlayer = components.GetComponent<CApplicationPlayer>(); + // playlist is already playing + if (appPlayer->IsPlaying()) + CServiceBroker::GetPlaylistPlayer().PlayNext(pos); + // we start playing the 'other' playlist so we need to use play to initialize the player state + else + CServiceBroker::GetPlaylistPlayer().Play(pos, ""); + + return 0; +} + +/*! \brief Control player. + * \param params The parameters + * \details params[0] = Control to execute. + * params[1] = "notify" to notify user (optional, certain controls). + */ +static int PlayerControl(const std::vector<std::string>& params) +{ + auto& components = CServiceBroker::GetAppComponents(); + const auto appPower = components.GetComponent<CApplicationPowerHandling>(); + appPower->ResetScreenSaver(); + appPower->WakeUpScreenSaverAndDPMS(); + + std::string paramlow(params[0]); + StringUtils::ToLower(paramlow); + + const auto appPlayer = components.GetComponent<CApplicationPlayer>(); + + if (paramlow == "play") + { // play/pause + // either resume playing, or pause + if (appPlayer->IsPlaying()) + { + if (appPlayer->GetPlaySpeed() != 1) + appPlayer->SetPlaySpeed(1); + else + appPlayer->Pause(); + } + } + else if (paramlow == "stop") + { + g_application.StopPlaying(); + } + else if (StringUtils::StartsWithNoCase(params[0], "frameadvance")) + { + std::string strFrames; + if (params[0].size() == 12) + CLog::Log(LOGERROR, "PlayerControl(frameadvance(n)) called with no argument"); + else if (params[0].size() < 15) // arg must be at least "(N)" + CLog::Log(LOGERROR, "PlayerControl(frameadvance(n)) called with invalid argument: \"{}\"", + params[0].substr(13)); + else + + strFrames = params[0].substr(13); + StringUtils::TrimRight(strFrames, ")"); + float frames = (float) atof(strFrames.c_str()); + appPlayer->FrameAdvance(frames); + } + else if (paramlow =="rewind" || paramlow == "forward") + { + if (appPlayer->IsPlaying() && !appPlayer->IsPaused()) + { + float playSpeed = appPlayer->GetPlaySpeed(); + + if (paramlow == "rewind" && playSpeed == 1) // Enables Rewinding + playSpeed *= -2; + else if (paramlow == "rewind" && playSpeed > 1) //goes down a notch if you're FFing + playSpeed /= 2; + else if (paramlow == "forward" && playSpeed < 1) //goes up a notch if you're RWing + { + playSpeed /= 2; + if (playSpeed == -1) + playSpeed = 1; + } + else + playSpeed *= 2; + + if (playSpeed > 32 || playSpeed < -32) + playSpeed = 1; + + appPlayer->SetPlaySpeed(playSpeed); + } + } + else if (paramlow =="tempoup" || paramlow == "tempodown") + { + if (appPlayer->SupportsTempo() && appPlayer->IsPlaying() && !appPlayer->IsPaused()) + { + float playTempo = appPlayer->GetPlayTempo(); + if (paramlow == "tempodown") + playTempo -= 0.1f; + else if (paramlow == "tempoup") + playTempo += 0.1f; + + appPlayer->SetTempo(playTempo); + } + } + else if (StringUtils::StartsWithNoCase(params[0], "tempo")) + { + if (params[0].size() == 5) + CLog::Log(LOGERROR, "PlayerControl(tempo(n)) called with no argument"); + else if (params[0].size() < 8) // arg must be at least "(N)" + CLog::Log(LOGERROR, "PlayerControl(tempo(n)) called with invalid argument: \"{}\"", + params[0].substr(6)); + else + { + if (appPlayer->SupportsTempo() && appPlayer->IsPlaying() && !appPlayer->IsPaused()) + { + std::string strTempo = params[0].substr(6); + StringUtils::TrimRight(strTempo, ")"); + float playTempo = strtof(strTempo.c_str(), nullptr); + + appPlayer->SetTempo(playTempo); + } + } + } + else if (paramlow == "next") + { + g_application.OnAction(CAction(ACTION_NEXT_ITEM)); + } + else if (paramlow == "previous") + { + g_application.OnAction(CAction(ACTION_PREV_ITEM)); + } + else if (paramlow == "bigskipbackward") + { + if (appPlayer->IsPlaying()) + appPlayer->Seek(false, true); + } + else if (paramlow == "bigskipforward") + { + if (appPlayer->IsPlaying()) + appPlayer->Seek(true, true); + } + else if (paramlow == "smallskipbackward") + { + if (appPlayer->IsPlaying()) + appPlayer->Seek(false, false); + } + else if (paramlow == "smallskipforward") + { + if (appPlayer->IsPlaying()) + appPlayer->Seek(true, false); + } + else if (StringUtils::StartsWithNoCase(params[0], "seekpercentage")) + { + std::string offset; + if (params[0].size() == 14) + CLog::Log(LOGERROR,"PlayerControl(seekpercentage(n)) called with no argument"); + else if (params[0].size() < 17) // arg must be at least "(N)" + CLog::Log(LOGERROR, "PlayerControl(seekpercentage(n)) called with invalid argument: \"{}\"", + params[0].substr(14)); + else + { + // Don't bother checking the argument: an invalid arg will do seek(0) + offset = params[0].substr(15); + StringUtils::TrimRight(offset, ")"); + float offsetpercent = (float) atof(offset.c_str()); + if (offsetpercent < 0 || offsetpercent > 100) + CLog::Log(LOGERROR, "PlayerControl(seekpercentage(n)) argument, {:f}, must be 0-100", + offsetpercent); + else if (appPlayer->IsPlaying()) + g_application.SeekPercentage(offsetpercent); + } + } + else if (paramlow == "showvideomenu") + { + if (appPlayer->IsPlaying()) + appPlayer->OnAction(CAction(ACTION_SHOW_VIDEOMENU)); + } + else if (StringUtils::StartsWithNoCase(params[0], "partymode")) + { + std::string strXspPath; + //empty param=music, "music"=music, "video"=video, else xsp path + PartyModeContext context = PARTYMODECONTEXT_MUSIC; + if (params[0].size() > 9) + { + if (params[0].size() == 16 && StringUtils::EndsWithNoCase(params[0], "video)")) + context = PARTYMODECONTEXT_VIDEO; + else if (params[0].size() != 16 || !StringUtils::EndsWithNoCase(params[0], "music)")) + { + strXspPath = params[0].substr(10); + StringUtils::TrimRight(strXspPath, ")"); + context = PARTYMODECONTEXT_UNKNOWN; + } + } + if (g_partyModeManager.IsEnabled()) + g_partyModeManager.Disable(); + else + g_partyModeManager.Enable(context, strXspPath); + } + else if (paramlow == "random" || paramlow == "randomoff" || paramlow == "randomon") + { + // get current playlist + PLAYLIST::Id playlistId = CServiceBroker::GetPlaylistPlayer().GetCurrentPlaylist(); + + // reverse the current setting + bool shuffled = CServiceBroker::GetPlaylistPlayer().IsShuffled(playlistId); + if ((shuffled && paramlow == "randomon") || (!shuffled && paramlow == "randomoff")) + return 0; + + // check to see if we should notify the user + bool notify = (params.size() == 2 && StringUtils::EqualsNoCase(params[1], "notify")); + CServiceBroker::GetPlaylistPlayer().SetShuffle(playlistId, !shuffled, notify); + + // save settings for now playing windows + switch (playlistId) + { + case PLAYLIST::TYPE_MUSIC: + CMediaSettings::GetInstance().SetMusicPlaylistShuffled( + CServiceBroker::GetPlaylistPlayer().IsShuffled(playlistId)); + CServiceBroker::GetSettingsComponent()->GetSettings()->Save(); + break; + case PLAYLIST::TYPE_VIDEO: + CMediaSettings::GetInstance().SetVideoPlaylistShuffled( + CServiceBroker::GetPlaylistPlayer().IsShuffled(playlistId)); + CServiceBroker::GetSettingsComponent()->GetSettings()->Save(); + default: + break; + } + + // send message + CGUIMessage msg(GUI_MSG_PLAYLISTPLAYER_RANDOM, 0, 0, playlistId, + CServiceBroker::GetPlaylistPlayer().IsShuffled(playlistId)); + CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg); + } + else if (StringUtils::StartsWithNoCase(params[0], "repeat")) + { + // get current playlist + PLAYLIST::Id playlistId = CServiceBroker::GetPlaylistPlayer().GetCurrentPlaylist(); + PLAYLIST::RepeatState prevRepeatState = + CServiceBroker::GetPlaylistPlayer().GetRepeat(playlistId); + + std::string paramlow(params[0]); + StringUtils::ToLower(paramlow); + + PLAYLIST::RepeatState repeatState; + if (paramlow == "repeatall") + repeatState = PLAYLIST::RepeatState::ALL; + else if (paramlow == "repeatone") + repeatState = PLAYLIST::RepeatState::ONE; + else if (paramlow == "repeatoff") + repeatState = PLAYLIST::RepeatState::NONE; + else if (prevRepeatState == PLAYLIST::RepeatState::NONE) + repeatState = PLAYLIST::RepeatState::ALL; + else if (prevRepeatState == PLAYLIST::RepeatState::ALL) + repeatState = PLAYLIST::RepeatState::ONE; + else + repeatState = PLAYLIST::RepeatState::NONE; + + if (repeatState == prevRepeatState) + return 0; + + // check to see if we should notify the user + bool notify = (params.size() == 2 && StringUtils::EqualsNoCase(params[1], "notify")); + CServiceBroker::GetPlaylistPlayer().SetRepeat(playlistId, repeatState, notify); + + // save settings for now playing windows + switch (playlistId) + { + case PLAYLIST::TYPE_MUSIC: + CMediaSettings::GetInstance().SetMusicPlaylistRepeat(repeatState == + PLAYLIST::RepeatState::ALL); + CServiceBroker::GetSettingsComponent()->GetSettings()->Save(); + break; + case PLAYLIST::TYPE_VIDEO: + CMediaSettings::GetInstance().SetVideoPlaylistRepeat(repeatState == + PLAYLIST::RepeatState::ALL); + CServiceBroker::GetSettingsComponent()->GetSettings()->Save(); + } + + // send messages so now playing window can get updated + CGUIMessage msg(GUI_MSG_PLAYLISTPLAYER_REPEAT, 0, 0, playlistId, static_cast<int>(repeatState)); + CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg); + } + else if (StringUtils::StartsWithNoCase(params[0], "resumelivetv")) + { + CFileItem& fileItem(g_application.CurrentFileItem()); + std::shared_ptr<PVR::CPVRChannel> channel = fileItem.HasPVRRecordingInfoTag() ? fileItem.GetPVRRecordingInfoTag()->Channel() : std::shared_ptr<PVR::CPVRChannel>(); + + if (channel) + { + const std::shared_ptr<PVR::CPVRChannelGroupMember> groupMember = + CServiceBroker::GetPVRManager().Get<PVR::GUI::Channels>().GetChannelGroupMember(channel); + if (!groupMember) + { + CLog::Log(LOGERROR, "ResumeLiveTv could not obtain channel group member for channel: {}", + channel->ChannelName()); + return false; + } + + CFileItem playItem(groupMember); + if (!g_application.PlayMedia( + playItem, "", channel->IsRadio() ? PLAYLIST::TYPE_MUSIC : PLAYLIST::TYPE_VIDEO)) + { + CLog::Log(LOGERROR, "ResumeLiveTv could not play channel: {}", channel->ChannelName()); + return false; + } + } + } + else if (paramlow == "reset") + { + g_application.OnAction(CAction(ACTION_PLAYER_RESET)); + } + + return 0; +} + +/*! \brief Play currently inserted DVD. + * \param params The parameters. + * \details params[0] = "restart" to restart from resume point (optional). + */ +static int PlayDVD(const std::vector<std::string>& params) +{ +#ifdef HAS_DVD_DRIVE + bool restart = false; + if (!params.empty() && StringUtils::EqualsNoCase(params[0], "restart")) + restart = true; + MEDIA_DETECT::CAutorun::PlayDisc(CServiceBroker::GetMediaManager().GetDiscPath(), true, restart); +#endif + + return 0; +} + +namespace +{ +void GetItemsForPlayList(const std::shared_ptr<CFileItem>& item, CFileItemList& queuedItems) +{ + if (VIDEO_UTILS::IsItemPlayable(*item)) + VIDEO_UTILS::GetItemsForPlayList(item, queuedItems); + else if (MUSIC_UTILS::IsItemPlayable(*item)) + MUSIC_UTILS::GetItemsForPlayList(item, queuedItems); + else + CLog::LogF(LOGERROR, "Unable to get playlist items for {}", item->GetPath()); +} + +int PlayOrQueueMedia(const std::vector<std::string>& params, bool forcePlay) +{ + // restore to previous window if needed + if( CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow() == WINDOW_SLIDESHOW || + CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow() == WINDOW_FULLSCREEN_VIDEO || + CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow() == WINDOW_FULLSCREEN_GAME || + CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow() == WINDOW_VISUALISATION ) + CServiceBroker::GetGUI()->GetWindowManager().PreviousWindow(); + + // reset screensaver + auto& components = CServiceBroker::GetAppComponents(); + const auto appPower = components.GetComponent<CApplicationPowerHandling>(); + appPower->ResetScreenSaver(); + appPower->WakeUpScreenSaverAndDPMS(); + + CFileItem item(params[0], URIUtils::HasSlashAtEnd(params[0], true)); + + // at this point the item instance has only the path and the folder flag set. We + // need some extended item properties to process resume successfully. Load them. + item.LoadDetails(); + + // ask if we need to check guisettings to resume + bool askToResume = true; + int playOffset = 0; + bool hasPlayOffset = false; + bool playNext = true; + for (unsigned int i = 1 ; i < params.size() ; i++) + { + if (StringUtils::EqualsNoCase(params[i], "isdir")) + item.m_bIsFolder = true; + else if (params[i] == "1") // set fullscreen or windowed + CMediaSettings::GetInstance().SetMediaStartWindowed(true); + else if (StringUtils::EqualsNoCase(params[i], "resume")) + { + // force the item to resume (if applicable) + if (VIDEO_UTILS::GetItemResumeInformation(item).isResumable) + item.SetStartOffset(STARTOFFSET_RESUME); + else + item.SetStartOffset(0); + + askToResume = false; + } + else if (StringUtils::EqualsNoCase(params[i], "noresume")) + { + // force the item to start at the beginning + item.SetStartOffset(0); + askToResume = false; + } + else if (StringUtils::StartsWithNoCase(params[i], "playoffset=")) + { + playOffset = atoi(params[i].substr(11).c_str()) - 1; + item.SetProperty("playlist_starting_track", playOffset); + hasPlayOffset = true; + } + else if (StringUtils::StartsWithNoCase(params[i], "playlist_type_hint=")) + { + // Set the playlist type for the playlist file (e.g. STRM) + int playlistTypeHint = std::stoi(params[i].substr(19)); + item.SetProperty("playlist_type_hint", playlistTypeHint); + } + else if (StringUtils::EqualsNoCase(params[i], "playnext")) + { + // If app player is currently playing, the queued media shall be played next. + playNext = true; + } + } + + if (!item.m_bIsFolder && item.IsPlugin()) + item.SetProperty("IsPlayable", true); + + if (askToResume == true) + { + if (CGUIWindowVideoBase::ShowResumeMenu(item) == false) + return false; + item.SetProperty("check_resume", false); + } + + if (item.m_bIsFolder || item.IsPlayList()) + { + CFileItemList items; + GetItemsForPlayList(std::make_shared<CFileItem>(item), items); + if (!items.IsEmpty()) // fall through on non expandable playlist + { + bool containsMusic = false; + bool containsVideo = false; + for (const auto& i : items) + { + const bool isVideo = i->IsVideo(); + containsMusic |= !isVideo; + containsVideo |= isVideo; + + if (containsMusic && containsVideo) + break; + } + + PLAYLIST::Id playlistId = containsVideo ? PLAYLIST::TYPE_VIDEO : PLAYLIST::TYPE_MUSIC; + // Mixed playlist item played by music player, mixed content folder has music removed + if (containsMusic && containsVideo) + { + if (item.IsPlayList()) + playlistId = PLAYLIST::TYPE_MUSIC; + else + { + for (int i = items.Size() - 1; i >= 0; i--) //remove music entries + { + if (!items[i]->IsVideo()) + items.Remove(i); + } + } + } + + auto& playlistPlayer = CServiceBroker::GetPlaylistPlayer(); + + // Play vs. Queue (+Play) + if (forcePlay) + { + playlistPlayer.ClearPlaylist(playlistId); + playlistPlayer.Reset(); + playlistPlayer.Add(playlistId, items); + playlistPlayer.SetCurrentPlaylist(playlistId); + playlistPlayer.Play(playOffset, ""); + } + else + { + const int oldSize = playlistPlayer.GetPlaylist(playlistId).size(); + + const auto appPlayer = components.GetComponent<CApplicationPlayer>(); + if (playNext) + { + if (appPlayer->IsPlaying()) + playlistPlayer.Insert(playlistId, items, playlistPlayer.GetCurrentSong() + 1); + else + playlistPlayer.Add(playlistId, items); + } + else + { + playlistPlayer.Add(playlistId, items); + } + + if (items.Size() && !appPlayer->IsPlaying()) + { + playlistPlayer.SetCurrentPlaylist(playlistId); + + if (containsMusic) + { + // video does not auto play on queue like music + playlistPlayer.Play(hasPlayOffset ? playOffset : oldSize, ""); + } + } + } + + return 0; + } + } + + if (forcePlay) + { + if (item.HasVideoInfoTag() && item.GetStartOffset() == STARTOFFSET_RESUME) + { + const CBookmark bookmark = item.GetVideoInfoTag()->GetResumePoint(); + if (bookmark.IsSet()) + item.SetStartOffset(CUtil::ConvertSecsToMilliSecs(bookmark.timeInSeconds)); + } + + if ((item.IsAudio() || item.IsVideo()) && !item.IsSmartPlayList()) + { + if (!item.HasProperty("playlist_type_hint")) + item.SetProperty("playlist_type_hint", PLAYLIST::TYPE_MUSIC); + + CServiceBroker::GetPlaylistPlayer().Play(std::make_shared<CFileItem>(item), ""); + } + else + { + g_application.PlayMedia(item, "", PLAYLIST::TYPE_NONE); + } + } + + return 0; +} + +/*! \brief Start playback of media. + * \param params The parameters. + * \details params[0] = URL to media to play (optional). + * params[1,...] = "isdir" if media is a directory (optional). + * params[1,...] = "1" to start playback in fullscreen (optional). + * params[1,...] = "resume" to force resuming (optional). + * params[1,...] = "noresume" to force not resuming (optional). + * params[1,...] = "playoffset=<offset>" to start playback from a given position in a playlist (optional). + * params[1,...] = "playlist_type_hint=<id>" to set the playlist type if a playlist file (e.g. STRM) is played (optional), + * for <id> value refer to PLAYLIST::TYPE_MUSIC / PLAYLIST::TYPE_VIDEO values, if not set will fallback to music playlist. + */ +int PlayMedia(const std::vector<std::string>& params) +{ + return PlayOrQueueMedia(params, true); +} + +/*! \brief Queue media in the video or music playlist, according to type of media items. If both audio and video items are contained, queue to video + * playlist. Start playback at requested position if player is not playing. + * \param params The parameters. + * \details params[0] = URL of media to queue. + * params[1,...] = "isdir" if media is a directory (optional). + * params[1,...] = "1" to start playback in fullscreen (optional). + * params[1,...] = "resume" to force resuming (optional). + * params[1,...] = "noresume" to force not resuming (optional). + * params[1,...] = "playoffset=<offset>" to start playback from a given position in a playlist (optional). + * params[1,...] = "playlist_type_hint=<id>" to set the playlist type if a playlist file (e.g. STRM) is played (optional), + * for <id> value refer to PLAYLIST::TYPE_MUSIC / PLAYLIST::TYPE_VIDEO values, if not set will fallback to music playlist. + * params[1,...] = "playnext" if player is currently playing, to play the media right after the currently playing item. If player is not + * playing, append media to current playlist (optional). + */ +int QueueMedia(const std::vector<std::string>& params) +{ + return PlayOrQueueMedia(params, false); +} + +} // unnamed namespace + +/*! \brief Start playback with a given playback core. + * \param params The parameters. + * \details params[0] = Name of playback core. + */ +static int PlayWith(const std::vector<std::string>& params) +{ + g_application.OnAction(CAction(ACTION_PLAYER_PLAY, params[0])); + + return 0; +} + +/*! \brief Seek in currently playing media. + * \param params The parameters. + * \details params[0] = Number of seconds to seek. + */ +static int Seek(const std::vector<std::string>& params) +{ + auto& components = CServiceBroker::GetAppComponents(); + const auto appPlayer = components.GetComponent<CApplicationPlayer>(); + if (appPlayer->IsPlaying()) + appPlayer->GetSeekHandler().SeekSeconds(atoi(params[0].c_str())); + + return 0; +} + +static int SubtitleShiftUp(const std::vector<std::string>& params) +{ + CAction action{ACTION_SUBTITLE_VSHIFT_UP}; + if (!params.empty() && params[0] == "save") + action.SetText("save"); + CPlayerController::GetInstance().OnAction(action); + return 0; +} + +static int SubtitleShiftDown(const std::vector<std::string>& params) +{ + CAction action{ACTION_SUBTITLE_VSHIFT_DOWN}; + if (!params.empty() && params[0] == "save") + action.SetText("save"); + CPlayerController::GetInstance().OnAction(action); + return 0; +} + +// Note: For new Texts with comma add a "\" before!!! Is used for table text. +// +/// \page page_List_of_built_in_functions +/// \section built_in_functions_12 Player built-in's +/// +/// ----------------------------------------------------------------------------- +/// +/// \table_start +/// \table_h2_l{ +/// Function, +/// Description } +/// \table_row2_l{ +/// <b>`PlaysDisc(parm)`</b>\n +/// <b>`PlayDVD(param)`</b>(deprecated) +/// , +/// Plays the inserted disc\, like CD\, DVD or Blu-ray\, in the disc drive. +/// @param[in] param "restart" to restart from resume point (optional) +/// } +/// \table_row2_l{ +/// <b>`PlayerControl(control[\,param])`</b> +/// , +/// Allows control of music and videos. <br> +/// <br> +/// | Control | Video playback behaviour | Audio playback behaviour | Added in | +/// |:------------------------|:---------------------------------------|:----------------------------|:------------| +/// | Play | Play/Pause | Play/Pause | | +/// | Stop | Stop | Stop | | +/// | Forward | Fast Forward | Fast Forward | | +/// | Rewind | Rewind | Rewind | | +/// | Next | Next chapter or movie in playlists | Next track | | +/// | Previous | Previous chapter or movie in playlists | Previous track | | +/// | TempoUp | Increases playback speed | none | Kodi v18 | +/// | TempoDown | Decreases playback speed | none | Kodi v18 | +/// | Tempo(n) | Sets playback speed to given value | none | Kodi v19 | +/// | BigSkipForward | Big Skip Forward | Big Skip Forward | Kodi v15 | +/// | BigSkipBackward | Big Skip Backward | Big Skip Backward | Kodi v15 | +/// | SmallSkipForward | Small Skip Forward | Small Skip Forward | Kodi v15 | +/// | SmallSkipBackward | Small Skip Backward | Small Skip Backward | Kodi v15 | +/// | SeekPercentage(n) | Seeks to given percentage | Seeks to given percentage | | +/// | Random * | Toggle Random Playback | Toggle Random Playback | | +/// | RandomOn | Sets 'Random' to 'on' | Sets 'Random' to 'on' | | +/// | RandomOff | Sets 'Random' to 'off' | Sets 'Random' to 'off' | | +/// | Repeat * | Cycles through repeat modes | Cycles through repeat modes | | +/// | RepeatOne | Repeats a single video | Repeats a single track | | +/// | RepeatAll | Repeat all videos in a list | Repeats all tracks in a list| | +/// | RepeatOff | Sets 'Repeat' to 'off' | Sets 'Repeat' to 'off' | | +/// | Partymode(music) ** | none | Toggles music partymode | | +/// | Partymode(video) ** | Toggles video partymode | none | | +/// | Partymode(path to .xsp) | Partymode for *.xsp-file | Partymode for *.xsp-file | | +/// | ShowVideoMenu | Shows the DVD/BR menu if available | none | | +/// | FrameAdvance(n) *** | Advance video by _n_ frames | none | Kodi v18 | +/// | SubtitleShiftUp(save) | Shift up the subtitle position, add "save" to save the change permanently | none | Kodi v20 | +/// | SubtitleShiftDown(save) | Shift down the subtitle position, add "save" to save the change permanently | none | Kodi v20 | +/// <br> +/// '*' = For these controls\, the PlayerControl built-in function can make use of the 'notify'-parameter. For example: PlayerControl(random\, notify) +/// <br> +/// '**' = If no argument is given for 'partymode'\, the control will default to music. +/// <br> +/// '***' = This only works if the player is paused. +/// <br> +/// @param[in] control Control to execute. +/// @param[in] param "notify" to notify user (optional\, certain controls). +/// +/// @note 'TempoUp' or 'TempoDown' only works if "Sync playback to display" is enabled. +/// @note 'Next' will behave differently while using video playlists. In those\, chapters will be ignored and the next movie will be played. +/// } +/// \table_row2_l{ +/// <b>`Playlist.Clear`</b> +/// , +/// Clear the current playlist +/// @param[in] (ignored) +/// } +/// \table_row2_l{ +/// <b>`Playlist.PlayOffset(positionType[\,position])`</b> +/// , +/// Start playing from a particular offset in the playlist +/// @param[in] positionType Position in playlist or playlist type. +/// @param[in] position Position in playlist if params[0] is playlist type (optional). +/// } +/// \table_row2_l{ +/// <b>`PlayMedia(media[\,isdir][\,1]\,[playoffset=xx])`</b> +/// , +/// Plays the media. This can be a playlist\, music\, or video file\, directory\, +/// plugin or an Url. The optional parameter "\,isdir" can be used for playing +/// a directory. "\,1" will start the media without switching to fullscreen. +/// If media is a playlist\, you can use playoffset=xx where xx is +/// the position to start playback from. +/// @param[in] media URL to media to play (optional). +/// @param[in] isdir Set "isdir" if media is a directory (optional). +/// @param[in] windowed Set "1" to start playback without switching to fullscreen (optional). +/// @param[in] resume Set "resume" to force resuming (optional). +/// @param[in] noresume Set "noresume" to force not resuming (optional). +/// @param[in] playeroffset Set "playoffset=<offset>" to start playback from a given position in a playlist (optional). +/// } +/// \table_row2_l{ +/// <b>`PlayWith(core)`</b> +/// , +/// Play the selected item with the specified player core. +/// @param[in] core Name of playback core. +/// } +/// \table_row2_l{ +/// <b>`Seek(seconds)`</b> +/// , +/// Seeks to the specified relative amount of seconds within the current +/// playing media. A negative value will seek backward and a positive value forward. +/// @param[in] seconds Number of seconds to seek. +/// } +/// \table_row2_l{ +/// <b>`QueueMedia(media[\,isdir][\,1][\,playnext]\,[playoffset=xx])`</b> +/// \anchor Builtin_QueueMedia, +/// Queues the given media. This can be a playlist\, music\, or video file\, directory\, +/// plugin or an Url. The optional parameter "\,isdir" can be used for playing +/// a directory. "\,1" will start the media without switching to fullscreen. +/// If media is a playlist\, you can use playoffset=xx where xx is +/// the position to start playback from. +/// @param[in] media URL of media to queue. +/// @param[in] isdir Set "isdir" if media is a directory (optional). +/// @param[in] 1 Set "1" to start playback without switching to fullscreen (optional). +/// @param[in] resume Set "resume" to force resuming (optional). +/// @param[in] noresume Set "noresume" to force not resuming (optional). +/// @param[in] playeroffset Set "playoffset=<offset>" to start playback from a given position in a playlist (optional). +/// @param[in] playnext Set "playnext" to play the media right after the currently playing item, if player is currently +/// playing. If player is not playing, append media to current playlist (optional). +/// <p><hr> +/// @skinning_v20 **[New builtin]** \link Builtin_QueueMedia `QueueMedia(media[\,isdir][\,1][\,playnext]\,[playoffset=xx])`\endlink +/// <p> +/// } +/// \table_end +/// + +// clang-format off +CBuiltins::CommandMap CPlayerBuiltins::GetOperations() const +{ + return { + {"playdisc", {"Plays the inserted disc, like CD, DVD or Blu-ray, in the disc drive.", 0, PlayDVD}}, + {"playdvd", {"Plays the inserted disc, like CD, DVD or Blu-ray, in the disc drive.", 0, PlayDVD}}, + {"playlist.clear", {"Clear the current playlist", 0, ClearPlaylist}}, + {"playlist.playoffset", {"Start playing from a particular offset in the playlist", 1, PlayOffset}}, + {"playercontrol", {"Control the music or video player", 1, PlayerControl}}, + {"playmedia", {"Play the specified media file (or playlist)", 1, PlayMedia}}, + {"queuemedia", {"Queue the specified media in video or music playlist", 1, QueueMedia}}, + {"playwith", {"Play the selected item with the specified core", 1, PlayWith}}, + {"seek", {"Performs a seek in seconds on the current playing media file", 1, Seek}}, + {"subtitleshiftup", {"Shift up the subtitle position", 0, SubtitleShiftUp}}, + {"subtitleshiftdown", {"Shift down the subtitle position", 0, SubtitleShiftDown}}, + }; +} +// clang-format on diff --git a/xbmc/interfaces/builtins/PlayerBuiltins.h b/xbmc/interfaces/builtins/PlayerBuiltins.h new file mode 100644 index 0000000..efa9474 --- /dev/null +++ b/xbmc/interfaces/builtins/PlayerBuiltins.h @@ -0,0 +1,19 @@ +/* + * 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 "Builtins.h" + +//! \brief Class providing player related built-in commands. +class CPlayerBuiltins +{ +public: + //! \brief Returns the map of operations. + CBuiltins::CommandMap GetOperations() const; +}; diff --git a/xbmc/interfaces/builtins/ProfileBuiltins.cpp b/xbmc/interfaces/builtins/ProfileBuiltins.cpp new file mode 100644 index 0000000..448f821 --- /dev/null +++ b/xbmc/interfaces/builtins/ProfileBuiltins.cpp @@ -0,0 +1,133 @@ +/* + * 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 "ProfileBuiltins.h" + +#include "GUIPassword.h" +#include "GUIUserMessages.h" +#include "ServiceBroker.h" +#include "Util.h" +#include "dialogs/GUIDialogKaiToast.h" +#include "favourites/FavouritesService.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +#include "guilib/LocalizeStrings.h" +#include "messaging/ApplicationMessenger.h" +#include "profiles/ProfileManager.h" +#include "settings/SettingsComponent.h" +#include "utils/StringUtils.h" + +/*! \brief Load a profile. + * \param params The parameters. + * \details params[0] = The profile name. + * params[1] = "prompt" to allow unlocking dialogs (optional) + */ +static int LoadProfile(const std::vector<std::string>& params) +{ + const std::shared_ptr<CProfileManager> profileManager = CServiceBroker::GetSettingsComponent()->GetProfileManager(); + + int index = profileManager->GetProfileIndex(params[0]); + bool prompt = (params.size() == 2 && StringUtils::EqualsNoCase(params[1], "prompt")); + bool bCanceled; + if (index >= 0 + && (profileManager->GetMasterProfile().getLockMode() == LOCK_MODE_EVERYONE + || g_passwordManager.IsProfileLockUnlocked(index,bCanceled,prompt))) + { + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_LOADPROFILE, index); + } + + return 0; +} + +/*! \brief Log off currently signed in profile. + * \param params (ignored) + */ +static int LogOff(const std::vector<std::string>& params) +{ + const std::shared_ptr<CProfileManager> profileManager = CServiceBroker::GetSettingsComponent()->GetProfileManager(); + profileManager->LogOff(); + + return 0; +} + +/*! \brief Toggle master mode. + * \param params (ignored) + */ +static int MasterMode(const std::vector<std::string>& params) +{ + if (g_passwordManager.bMasterUser) + { + g_passwordManager.bMasterUser = false; + g_passwordManager.LockSources(true); + + // master mode turned OFF => refresh favourites due to possible visibility changes + CServiceBroker::GetFavouritesService().RefreshFavourites(); + + CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Warning, g_localizeStrings.Get(20052),g_localizeStrings.Get(20053)); + } + else if (g_passwordManager.IsMasterLockUnlocked(true)) // prompt user for code + { + g_passwordManager.LockSources(false); + g_passwordManager.bMasterUser = true; + + // master mode turned ON => refresh favourites due to possible visibility changes + CServiceBroker::GetFavouritesService().RefreshFavourites(); + + CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Warning, g_localizeStrings.Get(20052),g_localizeStrings.Get(20054)); + } + + CUtil::DeleteVideoDatabaseDirectoryCache(); + CGUIMessage msg(GUI_MSG_NOTIFY_ALL, 0, 0, GUI_MSG_UPDATE); + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(msg); + + return 0; +} + + +// Note: For new Texts with comma add a "\" before!!! Is used for table text. +// +/// \page page_List_of_built_in_functions +/// \section built_in_functions_13 Profile built-in's +/// +/// ----------------------------------------------------------------------------- +/// +/// \table_start +/// \table_h2_l{ +/// Function, +/// Description } +/// \table_row2_l{ +/// <b>`LoadProfile(profilename\,[prompt])`</b> +/// , +/// Load the specified profile. If prompt is not specified\, and a password +/// would be required for the requested profile\, this command will silently +/// fail. If prompt is specified and a password is required\, a password +/// dialog will be shown. +/// @param[in] profilename The profile name. +/// @param[in] prompt Add "prompt" to allow unlocking dialogs (optional) +/// } +/// \table_row2_l{ +/// <b>`Mastermode`</b> +/// , +/// Runs Kodi in master mode +/// } +/// \table_row2_l{ +/// <b>`System.LogOff`</b> +/// , +/// Log off current user. +/// } +/// \table_end +/// + +CBuiltins::CommandMap CProfileBuiltins::GetOperations() const +{ + return { + {"loadprofile", {"Load the specified profile (note; if locks are active it won't work)", 1, LoadProfile}}, + {"mastermode", {"Control master mode", 0, MasterMode}}, + {"system.logoff", {"Log off current user", 0, LogOff}} + }; +} diff --git a/xbmc/interfaces/builtins/ProfileBuiltins.h b/xbmc/interfaces/builtins/ProfileBuiltins.h new file mode 100644 index 0000000..e30c1ee --- /dev/null +++ b/xbmc/interfaces/builtins/ProfileBuiltins.h @@ -0,0 +1,19 @@ +/* + * 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 "Builtins.h" + +//! \brief Class providing profile related built-in commands. +class CProfileBuiltins +{ +public: + //! \brief Returns the map of operations. + CBuiltins::CommandMap GetOperations() const; +}; diff --git a/xbmc/interfaces/builtins/SkinBuiltins.cpp b/xbmc/interfaces/builtins/SkinBuiltins.cpp new file mode 100644 index 0000000..5b2b4c2 --- /dev/null +++ b/xbmc/interfaces/builtins/SkinBuiltins.cpp @@ -0,0 +1,687 @@ +/* + * 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 "SkinBuiltins.h" + +#include "MediaSource.h" +#include "ServiceBroker.h" +#include "URL.h" +#include "Util.h" +#include "addons/addoninfo/AddonInfo.h" +#include "addons/addoninfo/AddonType.h" +#include "addons/gui/GUIWindowAddonBrowser.h" +#include "application/ApplicationComponents.h" +#include "application/ApplicationSkinHandling.h" +#include "dialogs/GUIDialogColorPicker.h" +#include "dialogs/GUIDialogFileBrowser.h" +#include "dialogs/GUIDialogNumeric.h" +#include "dialogs/GUIDialogSelect.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIKeyboardFactory.h" +#include "guilib/GUIWindowManager.h" +#include "guilib/LocalizeStrings.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" +#include "settings/SkinSettings.h" +#include "storage/MediaManager.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" + +using namespace ADDON; + +/*! \brief Reload current skin. + * \param params The parameters. + * \details params[0] = "confirm" to show a confirmation dialog (optional). + */ +static int ReloadSkin(const std::vector<std::string>& params) +{ + // Reload the skin + auto& components = CServiceBroker::GetAppComponents(); + const auto appSkin = components.GetComponent<CApplicationSkinHandling>(); + appSkin->ReloadSkin(!params.empty() && StringUtils::EqualsNoCase(params[0], "confirm")); + + return 0; +} + +/*! \brief Unload current skin. + * \param params (ignored) + */ +static int UnloadSkin(const std::vector<std::string>& params) +{ + auto& components = CServiceBroker::GetAppComponents(); + const auto appSkin = components.GetComponent<CApplicationSkinHandling>(); + appSkin->UnloadSkin(); + + return 0; +} + +/*! \brief Toggle a skin bool setting. + * \param params The parameters. + * \details params[0] = Skin setting to toggle. + */ +static int ToggleSetting(const std::vector<std::string>& params) +{ + int setting = CSkinSettings::GetInstance().TranslateBool(params[0]); + CSkinSettings::GetInstance().SetBool(setting, !CSkinSettings::GetInstance().GetBool(setting)); + CServiceBroker::GetSettingsComponent()->GetSettings()->Save(); + + return 0; +} + +/*! \brief Set an add-on type skin setting. + * \param params The parameters. + * \details params[0] = Skin setting to store result in. + * params[1,...] = Add-on types to allow selecting. + */ +static int SetAddon(const std::vector<std::string>& params) +{ + int string = CSkinSettings::GetInstance().TranslateString(params[0]); + std::vector<ADDON::AddonType> types; + for (unsigned int i = 1 ; i < params.size() ; i++) + { + ADDON::AddonType type = CAddonInfo::TranslateType(params[i]); + if (type != AddonType::UNKNOWN) + types.push_back(type); + } + std::string result; + if (!types.empty() && CGUIWindowAddonBrowser::SelectAddonID(types, result, true) == 1) + { + CSkinSettings::GetInstance().SetString(string, result); + CServiceBroker::GetSettingsComponent()->GetSettings()->Save(); + } + + return 0; +} + +/*! \brief Select and set a skin bool setting. + * \param params The parameters. + * \details params[0] = Names of skin settings. + */ +static int SelectBool(const std::vector<std::string>& params) +{ + std::vector<std::pair<std::string, std::string>> settings; + + CGUIDialogSelect* pDlgSelect = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSelect>(WINDOW_DIALOG_SELECT); + pDlgSelect->Reset(); + pDlgSelect->SetHeading(CVariant{g_localizeStrings.Get(atoi(params[0].c_str()))}); + + for (unsigned int i = 1 ; i < params.size() ; i++) + { + if (params[i].find('|') != std::string::npos) + { + std::vector<std::string> values = StringUtils::Split(params[i], '|'); + std::string label = g_localizeStrings.Get(atoi(values[0].c_str())); + settings.emplace_back(label, values[1].c_str()); + pDlgSelect->Add(label); + } + } + + pDlgSelect->Open(); + + if(pDlgSelect->IsConfirmed()) + { + unsigned int iItem = pDlgSelect->GetSelectedItem(); + + for (unsigned int i = 0 ; i < settings.size() ; i++) + { + std::string item = settings[i].second; + int setting = CSkinSettings::GetInstance().TranslateBool(item); + if (i == iItem) + CSkinSettings::GetInstance().SetBool(setting, true); + else + CSkinSettings::GetInstance().SetBool(setting, false); + } + CServiceBroker::GetSettingsComponent()->GetSettings()->Save(); + } + + return 0; +} + +/*! \brief Set a skin bool setting. + * \param params The parameters. + * \details params[0] = Name of skin setting. + * params[1] = Value to set ("false", or "true") (optional). + */ +static int SetBool(const std::vector<std::string>& params) +{ + if (params.size() > 1) + { + int string = CSkinSettings::GetInstance().TranslateBool(params[0]); + CSkinSettings::GetInstance().SetBool(string, StringUtils::EqualsNoCase(params[1], "true")); + CServiceBroker::GetSettingsComponent()->GetSettings()->Save(); + return 0; + } + // default is to set it to true + int setting = CSkinSettings::GetInstance().TranslateBool(params[0]); + CSkinSettings::GetInstance().SetBool(setting, true); + CServiceBroker::GetSettingsComponent()->GetSettings()->Save(); + + return 0; +} + +/*! \brief Set a numeric skin setting. + * \param params The parameters. + * \details params[0] = Name of skin setting. + */ +static int SetNumeric(const std::vector<std::string>& params) +{ + int string = CSkinSettings::GetInstance().TranslateString(params[0]); + std::string value = CSkinSettings::GetInstance().GetString(string); + if (CGUIDialogNumeric::ShowAndGetNumber(value, g_localizeStrings.Get(611))) + CSkinSettings::GetInstance().SetString(string, value); + + return 0; +} + +/*! \brief Set a path skin setting. + * \param params The parameters. + * \details params[0] = Name of skin setting. + * params[1] = Extra URL to allow selection from (optional). + */ +static int SetPath(const std::vector<std::string>& params) +{ + int string = CSkinSettings::GetInstance().TranslateString(params[0]); + std::string value = CSkinSettings::GetInstance().GetString(string); + VECSOURCES localShares; + CServiceBroker::GetMediaManager().GetLocalDrives(localShares); + CServiceBroker::GetMediaManager().GetNetworkLocations(localShares); + if (params.size() > 1) + { + value = params[1]; + URIUtils::AddSlashAtEnd(value); + bool bIsSource; + if (CUtil::GetMatchingSource(value,localShares,bIsSource) < 0) // path is outside shares - add it as a separate one + { + CMediaSource share; + share.strName = g_localizeStrings.Get(13278); + share.strPath = value; + localShares.push_back(share); + } + } + + if (CGUIDialogFileBrowser::ShowAndGetDirectory(localShares, g_localizeStrings.Get(657), value)) + CSkinSettings::GetInstance().SetString(string, value); + + CServiceBroker::GetSettingsComponent()->GetSettings()->Save(); + + return 0; +} + +/*! \brief Set a skin file setting. + * \param params The parameters. + * \details params[0] = Name of skin setting. + * params[1] = File mask or add-on type (optional). + * params[2] = Extra URL to allow selection from or + * content type if mask is an addon-on type (optional). + */ +static int SetFile(const std::vector<std::string>& params) +{ + int string = CSkinSettings::GetInstance().TranslateString(params[0]); + std::string value = CSkinSettings::GetInstance().GetString(string); + VECSOURCES localShares; + CServiceBroker::GetMediaManager().GetLocalDrives(localShares); + + // Note. can only browse one addon type from here + // if browsing for addons, required param[1] is addontype string, with optional param[2] + // as contenttype string see IAddon.h & ADDON::TranslateXX + std::string strMask = (params.size() > 1) ? params[1] : ""; + StringUtils::ToLower(strMask); + ADDON::AddonType type; + if ((type = CAddonInfo::TranslateType(strMask)) != AddonType::UNKNOWN) + { + CURL url; + url.SetProtocol("addons"); + url.SetHostName("enabled"); + url.SetFileName(strMask+"/"); + localShares.clear(); + std::string content = (params.size() > 2) ? params[2] : ""; + StringUtils::ToLower(content); + url.SetPassword(content); + std::string strMask; + if (type == AddonType::SCRIPT) + strMask = ".py"; + std::string replace; + if (CGUIDialogFileBrowser::ShowAndGetFile(url.Get(), strMask, CAddonInfo::TranslateType(type, true), replace, true, true, true)) + { + if (StringUtils::StartsWithNoCase(replace, "addons://")) + CSkinSettings::GetInstance().SetString(string, URIUtils::GetFileName(replace)); + else + CSkinSettings::GetInstance().SetString(string, replace); + } + } + else + { + if (params.size() > 2) + { + value = params[2]; + URIUtils::AddSlashAtEnd(value); + bool bIsSource; + if (CUtil::GetMatchingSource(value,localShares,bIsSource) < 0) // path is outside shares - add it as a separate one + { + CMediaSource share; + share.strName = g_localizeStrings.Get(13278); + share.strPath = value; + localShares.push_back(share); + } + } + if (CGUIDialogFileBrowser::ShowAndGetFile(localShares, strMask, g_localizeStrings.Get(1033), value)) + CSkinSettings::GetInstance().SetString(string, value); + } + + return 0; +} + +/*! \brief Set a skin image setting. + * \param params The parameters. + * \details params[0] = Name of skin setting. + * params[1] = Extra URL to allow selection from (optional). + */ +static int SetImage(const std::vector<std::string>& params) +{ + int string = CSkinSettings::GetInstance().TranslateString(params[0]); + std::string value = CSkinSettings::GetInstance().GetString(string); + VECSOURCES localShares; + CServiceBroker::GetMediaManager().GetLocalDrives(localShares); + if (params.size() > 1) + { + value = params[1]; + URIUtils::AddSlashAtEnd(value); + bool bIsSource; + if (CUtil::GetMatchingSource(value,localShares,bIsSource) < 0) // path is outside shares - add it as a separate one + { + CMediaSource share; + share.strName = g_localizeStrings.Get(13278); + share.strPath = value; + localShares.push_back(share); + } + } + if (CGUIDialogFileBrowser::ShowAndGetImage(localShares, g_localizeStrings.Get(1030), value)) + CSkinSettings::GetInstance().SetString(string, value); + + return 0; +} + +/*! \brief Set a skin color setting. + * \param params The parameters. + * \details params[0] = Name of skin setting. + * params[1] = Dialog header text. + * params[2] = Hex value of the preselected color (optional). + * params[3] = XML file containing color definitions (optional). + */ +static int SetColor(const std::vector<std::string>& params) +{ + int string = CSkinSettings::GetInstance().TranslateString(params[0]); + std::string value = CSkinSettings::GetInstance().GetString(string); + + if (value.empty() && params.size() > 2) + { + value = params[2]; + } + + CGUIDialogColorPicker* pDlgColorPicker = + CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogColorPicker>( + WINDOW_DIALOG_COLOR_PICKER); + pDlgColorPicker->Reset(); + pDlgColorPicker->SetHeading(CVariant{g_localizeStrings.Get(atoi(params[1].c_str()))}); + + if (params.size() > 3) + { + pDlgColorPicker->LoadColors(params[3]); + } + else + { + pDlgColorPicker->LoadColors(); + } + + pDlgColorPicker->SetSelectedColor(value); + + pDlgColorPicker->Open(); + + if (pDlgColorPicker->IsConfirmed()) + { + value = pDlgColorPicker->GetSelectedColor(); + CSkinSettings::GetInstance().SetString(string, value); + } + + return 0; +} + +/*! \brief Set a string skin setting. + * \param params The parameters. + * \details params[0] = Name of skin setting. + * params[1] = Value of skin setting (optional). + */ +static int SetString(const std::vector<std::string>& params) +{ + // break the parameter up if necessary + int string = 0; + if (params.size() > 1) + { + string = CSkinSettings::GetInstance().TranslateString(params[0]); + CSkinSettings::GetInstance().SetString(string, params[1]); + CServiceBroker::GetSettingsComponent()->GetSettings()->Save(); + return 0; + } + else + string = CSkinSettings::GetInstance().TranslateString(params[0]); + + std::string value = CSkinSettings::GetInstance().GetString(string); + if (CGUIKeyboardFactory::ShowAndGetInput(value, CVariant{g_localizeStrings.Get(1029)}, true)) + CSkinSettings::GetInstance().SetString(string, value); + + return 0; +} + +/*! \brief Select skin theme. + * \param params The parameters. + * \details params[0] = 0 or 1 to increase theme, -1 to decrease. + */ +static int SetTheme(const std::vector<std::string>& params) +{ + // enumerate themes + std::vector<std::string> vecTheme; + CUtil::GetSkinThemes(vecTheme); + + int iTheme = -1; + + // find current theme + const std::shared_ptr<CSettings> settings = CServiceBroker::GetSettingsComponent()->GetSettings(); + const std::string strTheme = settings->GetString(CSettings::SETTING_LOOKANDFEEL_SKINTHEME); + if (!StringUtils::EqualsNoCase(strTheme, "SKINDEFAULT")) + { + for (size_t i=0;i<vecTheme.size();++i) + { + std::string strTmpTheme(strTheme); + URIUtils::RemoveExtension(strTmpTheme); + if (StringUtils::EqualsNoCase(vecTheme[i], strTmpTheme)) + { + iTheme=i; + break; + } + } + } + + int iParam = atoi(params[0].c_str()); + if (iParam == 0 || iParam == 1) + iTheme++; + else if (iParam == -1) + iTheme--; + if (iTheme > (int)vecTheme.size()-1) + iTheme = -1; + if (iTheme < -1) + iTheme = vecTheme.size()-1; + + std::string strSkinTheme = "SKINDEFAULT"; + if (iTheme != -1 && iTheme < (int)vecTheme.size()) + strSkinTheme = vecTheme[iTheme]; + + settings->SetString(CSettings::SETTING_LOOKANDFEEL_SKINTHEME, strSkinTheme); + // also set the default color theme + std::string colorTheme(URIUtils::ReplaceExtension(strSkinTheme, ".xml")); + if (StringUtils::EqualsNoCase(colorTheme, "Textures.xml")) + colorTheme = "defaults.xml"; + settings->SetString(CSettings::SETTING_LOOKANDFEEL_SKINCOLORS, colorTheme); + auto& components = CServiceBroker::GetAppComponents(); + const auto appSkin = components.GetComponent<CApplicationSkinHandling>(); + appSkin->ReloadSkin(); + + return 0; +} + +/*! \brief Reset a skin setting. + * \param params The parameters. + * \details params[0] = Name of setting to reset. + */ +static int SkinReset(const std::vector<std::string>& params) +{ + CSkinSettings::GetInstance().Reset(params[0]); + CServiceBroker::GetSettingsComponent()->GetSettings()->Save(); + + return 0; +} + +/*! \brief Reset all skin settings. + * \param params (ignored) + */ +static int SkinResetAll(const std::vector<std::string>& params) +{ + CSkinSettings::GetInstance().Reset(); + CServiceBroker::GetSettingsComponent()->GetSettings()->Save(); + + return 0; +} + +/*! \brief Toggle skin debug. + * \param params (ignored) + */ +static int SkinDebug(const std::vector<std::string>& params) +{ + g_SkinInfo->ToggleDebug(); + + return 0; +} + +/*! \brief Starts a given skin timer + * \param params The parameters. + * \details params[0] = Name of the timer. + * \return -1 in case of error, 0 in case of success + */ +static int SkinTimerStart(const std::vector<std::string>& params) +{ + if (params.empty()) + { + return -1; + } + + g_SkinInfo->TimerStart(params[0]); + return 0; +} + +/*! \brief Stops a given skin timer + * \param params The parameters. + * \details params[0] = Name of the timer. + * \return -1 in case of error, 0 in case of success + */ +static int SkinTimerStop(const std::vector<std::string>& params) +{ + if (params.empty()) + { + return -1; + } + + g_SkinInfo->TimerStop(params[0]); + return 0; +} + +// Note: For new Texts with comma add a "\" before!!! Is used for table text. +// +/// \page page_List_of_built_in_functions +/// \section built_in_functions_14 Skin built-in's +/// +/// ----------------------------------------------------------------------------- +/// +/// \table_start +/// \table_h2_l{ +/// Function, +/// Description } +/// \table_row2_l{ +/// <b>`ReloadSkin(reload)`</b> +/// , +/// Reloads the current skin – useful for Skinners to use after they upload +/// modified skin files (saves power cycling) +/// @param[in] reload <b>"confirm"</b> to show a confirmation dialog (optional). +/// } +/// \table_row2_l{ +/// <b>`UnloadSkin()`</b> +/// , +/// Unloads the current skin +/// } +/// \table_row2_l{ +/// <b>`Skin.Reset(setting)`</b> +/// , +/// Resets the skin `setting`. If `setting` is a bool setting (i.e. set via +/// `SetBool` or `ToggleSetting`) then the setting is reset to false. If +/// `setting` is a string (Set via <c>SetString</c>\, <c>SetImage</c> or +/// <c>SetPath</c>) then it is set to empty. +/// @param[in] setting Name of setting to reset. +/// } +/// \table_row2_l{ +/// <b>`Skin.ResetSettings()`</b> +/// , +/// Resets all the above skin settings to their defaults (toggles all set to +/// false\, strings all set to empty.) +/// } +/// \table_row2_l{ +/// <b>`Skin.SetAddon(string\,type)`</b> +/// , +/// Pops up a select dialog and allows the user to select an add-on of the +/// given type to be used elsewhere in the skin via the info tag +/// `Skin.String(string)`. The most common types are xbmc.addon.video\, +/// xbmc.addon.audio\, xbmc.addon.image and xbmc.addon.executable. +/// @param[in] string[0] Skin setting to store result in. +/// @param[in] type[1\,...] Add-on types to allow selecting. +/// } +/// \table_row2_l{ +/// <b>`Skin.SetBool(setting[\,value])`</b> +/// \anchor Skin_SetBool, +/// Sets the skin `setting` to true\, for use with the conditional visibility +/// tags containing \link Skin_HasSetting `Skin.HasSetting(setting)`\endlink. The settings are saved +/// per-skin in settings.xml just like all the other Kodi settings. +/// @param[in] setting Name of skin setting. +/// @param[in] value Value to set ("false"\, or "true") (optional). +/// } +/// \table_row2_l{ +/// <b>`Skin.SetFile(string\,mask\,folderpath)`</b> +/// , +/// \" minus quotes. If the folderpath parameter is set the file browser will +/// start in that folder. +/// @param[in] string Name of skin setting. +/// @param[in] mask File mask or add-on type (optional). +/// @param[in] folderpath Extra URL to allow selection from or. +/// content type if mask is an addon-on type (optional). +/// } +/// \table_row2_l{ +/// <b>`Skin.SetImage(string[\,url])`</b> +/// , +/// Pops up a file browser and allows the user to select an image file to be +/// used in an image control elsewhere in the skin via the info tag +/// `Skin.String(string)`. If the value parameter is specified\, then the +/// file browser dialog does not pop up\, and the image path is set directly. +/// The path option allows you to open the file browser in the specified +/// folder. +/// @param[in] string Name of skin setting. +/// @param[in] url Extra URL to allow selection from (optional). +/// } +/// \table_row2_l{ +/// <b>`Skin.SetColor(string\,header[\,colorfile\,selectedcolor])`</b> +/// \anchor Builtin_SetColor, +/// Pops up a color selection dialog and allows the user to select a color to be +/// used to define the color of a label control or as a colordiffuse value for a texture +/// elsewhere in the skin via the info tag `Skin.String(string)`. +/// Skinners can optionally set the color that needs to be preselected in the +/// dialog by specifying the hex value of this color. +/// Also optionally\, skinners can include their own color definition file. If not specified\, +/// the default colorfile included with Kodi will be used. +/// @param[in] string Name of skin setting. +/// @param[in] string Dialog header text. +/// @param[in] string Hex value of the color to preselect (optional)\, +/// example: FF00FF00. +/// @param[in] string Filepath of the color definition file (optional). +/// <p><hr> +/// @skinning_v20 **[New builtin]** \link Builtin_SetColor `SetColor(string\,header[\,colorfile\,selectedcolor])`\endlink +/// <p> +/// } +/// \table_row2_l{ +/// <b>`Skin.SetNumeric(numeric[\,value])`</b> +/// \anchor Skin_SetNumeric, +/// Pops up a keyboard dialog and allows the user to input a numerical. +/// @param[in] numeric Name of skin setting. +/// @param[in] value Value of skin setting (optional). +/// } +/// \table_row2_l{ +/// <b>`Skin.SetPath(string[\,value])`</b> +/// , +/// Pops up a folder browser and allows the user to select a folder of images +/// to be used in a multi image control else where in the skin via the info +/// tag `Skin.String(string)`. If the value parameter is specified\, then the +/// file browser dialog does not pop up\, and the path is set directly. +/// @param[in] string Name of skin setting. +/// @param[in] value Extra URL to allow selection from (optional). +/// } +/// \table_row2_l{ +/// <b>`Skin.SetString(string[\,value])`</b> +/// \anchor Skin_SetString, +/// Pops up a keyboard dialog and allows the user to input a string which can +/// be used in a label control elsewhere in the skin via the info tag +/// \link Skin_StringValue `Skin.String(string)`\endlink. The value of the setting +/// can also be compared to another value using the info bool \link Skin_StringCompare `Skin.String(string\, value)`\endlink. +/// If the value parameter is specified\, then the +/// keyboard dialog does not pop up\, and the string is set directly. +/// @param[in] string Name of skin setting. +/// @param[in] value Value of skin setting (optional). +/// } +/// \table_row2_l{ +/// <b>`Skin.Theme(cycle)`</b> +/// \anchor Skin_CycleTheme, +/// Cycles the skin theme. Skin.theme(-1) will go backwards. +/// @param[in] cycle 0 or 1 to increase theme\, -1 to decrease. +/// } +/// \table_row2_l{ +/// <b>`Skin.ToggleDebug`</b> +/// , +/// Toggles skin debug info on/off +/// } +/// \table_row2_l{ +/// <b>`Skin.ToggleSetting(setting)`</b> +/// , +/// Toggles the skin `setting` for use with conditional visibility tags +/// containing `Skin.HasSetting(setting)`. +/// @param[in] setting Skin setting to toggle +/// } +/// \table_row2_l{ +/// <b>`Skin.TimerStart(timer)`</b> +/// \anchor Builtin_SkinStartTimer, +/// Starts the timer with name `timer` +/// @param[in] timer The name of the timer +/// <p><hr> +/// @skinning_v20 **[New builtin]** \link Builtin_SkinStartTimer `Skin.TimerStart(timer)`\endlink +/// <p> +/// } +/// \table_row2_l{ +/// <b>`Skin.TimerStop(timer)`</b> +/// \anchor Builtin_SkinStopTimer, +/// Stops the timer with name `timer` +/// @param[in] timer The name of the timer +/// <p><hr> +/// @skinning_v20 **[New builtin]** \link Builtin_SkinStopTimer `Skin.TimerStop(timer)`\endlink +/// <p> +/// } +/// \table_end +/// + +CBuiltins::CommandMap CSkinBuiltins::GetOperations() const +{ + return {{"reloadskin", {"Reload Kodi's skin", 0, ReloadSkin}}, + {"unloadskin", {"Unload Kodi's skin", 0, UnloadSkin}}, + {"skin.reset", {"Resets a skin setting to default", 1, SkinReset}}, + {"skin.resetsettings", {"Resets all skin settings", 0, SkinResetAll}}, + {"skin.setaddon", {"Prompts and set an addon", 2, SetAddon}}, + {"skin.selectbool", {"Prompts and set a skin setting", 2, SelectBool}}, + {"skin.setbool", {"Sets a skin setting on", 1, SetBool}}, + {"skin.setfile", {"Prompts and sets a file", 1, SetFile}}, + {"skin.setimage", {"Prompts and sets a skin image", 1, SetImage}}, + {"skin.setcolor", {"Prompts and sets a skin color", 1, SetColor}}, + {"skin.setnumeric", {"Prompts and sets numeric input", 1, SetNumeric}}, + {"skin.setpath", {"Prompts and sets a skin path", 1, SetPath}}, + {"skin.setstring", {"Prompts and sets skin string", 1, SetString}}, + {"skin.theme", {"Control skin theme", 1, SetTheme}}, + {"skin.toggledebug", {"Toggle skin debug", 0, SkinDebug}}, + {"skin.togglesetting", {"Toggles a skin setting on or off", 1, ToggleSetting}}, + {"skin.timerstart", {"Starts a given skin timer", 1, SkinTimerStart}}, + {"skin.timerstop", {"Stops a given skin timer", 1, SkinTimerStop}}}; +} diff --git a/xbmc/interfaces/builtins/SkinBuiltins.h b/xbmc/interfaces/builtins/SkinBuiltins.h new file mode 100644 index 0000000..48a4306 --- /dev/null +++ b/xbmc/interfaces/builtins/SkinBuiltins.h @@ -0,0 +1,19 @@ +/* + * 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 "Builtins.h" + +//! \brief Class providing skin related built-in commands. +class CSkinBuiltins +{ +public: + //! \brief Returns the map of operations. + CBuiltins::CommandMap GetOperations() const; +}; diff --git a/xbmc/interfaces/builtins/SystemBuiltins.cpp b/xbmc/interfaces/builtins/SystemBuiltins.cpp new file mode 100644 index 0000000..3a41a5f --- /dev/null +++ b/xbmc/interfaces/builtins/SystemBuiltins.cpp @@ -0,0 +1,267 @@ +/* + * 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 "SystemBuiltins.h" + +#include "ServiceBroker.h" +#include "messaging/ApplicationMessenger.h" +#include "utils/StringUtils.h" + +/*! \brief Execute a system executable. + * \param params The parameters. + * \details params[0] = The path to the executable. + * + * Set the template parameter Wait to true to wait for execution exit. + */ + template<int Wait=0> +static int Exec(const std::vector<std::string>& params) +{ + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_MINIMIZE); + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_EXECUTE_OS, Wait, -1, nullptr, params[0]); + + return 0; +} + +/*! \brief Hibernate system. + * \param params (ignored) + */ +static int Hibernate(const std::vector<std::string>& params) +{ + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_HIBERNATE); + + return 0; +} + +/*! \brief Inhibit idle shutdown timer. + * \param params The parameters. + * \details params[0] = "true" to inhibit shutdown timer (optional). + */ +static int InhibitIdle(const std::vector<std::string>& params) +{ + bool inhibit = (params.size() == 1 && StringUtils::EqualsNoCase(params[0], "true")); + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_INHIBITIDLESHUTDOWN, inhibit); + + return 0; +} + +/*! \brief Minimize application. + * \param params (ignored) + */ +static int Minimize(const std::vector<std::string>& params) +{ + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_MINIMIZE); + + return 0; +} + +/*! \brief Powerdown system. + * \param params (ignored) + */ +static int Powerdown(const std::vector<std::string>& params) +{ + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_POWERDOWN); + + return 0; +} + +/*! \brief Quit application. + * \param params (ignored) + */ +static int Quit(const std::vector<std::string>& params) +{ + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_QUIT); + + return 0; +} + +/*! \brief Reboot system. + * \param params (ignored) + */ +static int Reboot(const std::vector<std::string>& params) +{ + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_RESTART); + + return 0; +} + +/*! \brief Restart application. + * \param params (ignored) + */ +static int RestartApp(const std::vector<std::string>& params) +{ + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_RESTARTAPP); + + return 0; +} + +/*! \brief Activate screensaver. + * \param params (ignored) + */ +static int ActivateScreensaver(const std::vector<std::string>& params) +{ + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_ACTIVATESCREENSAVER); + + return 0; +} + +/*! \brief Reset screensaver. + * \param params (ignored) + */ +static int ResetScreensaver(const std::vector<std::string>& params) +{ + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_RESETSCREENSAVER); + + return 0; +} + +/*! \brief Inhibit screensaver. + * \param params The parameters. + * \details params[0] = "true" to inhibit screensaver (optional). + */ +static int InhibitScreenSaver(const std::vector<std::string>& params) +{ + bool inhibit = (params.size() == 1 && StringUtils::EqualsNoCase(params[0], "true")); + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_INHIBITSCREENSAVER, inhibit); + + return 0; +} + +/*! \brief Shutdown system. + * \param params (ignored) + */ +static int Shutdown(const std::vector<std::string>& params) +{ + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_SHUTDOWN); + + return 0; +} + +/*! \brief Suspend system. + * \param params (ignored) + */ +static int Suspend(const std::vector<std::string>& params) +{ + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_SUSPEND); + + return 0; +} + + +// Note: For new Texts with comma add a "\" before!!! Is used for table text. +// +/// \page page_List_of_built_in_functions +/// \section built_in_functions_15 System built-in's +/// +/// ----------------------------------------------------------------------------- +/// +/// \table_start +/// \table_h2_l{ +/// Function, +/// Description } +/// \table_row2_l{ +/// <b>`ActivateScreensaver`</b> +/// , +/// Starts the screensaver +/// } +/// \table_row2_l{ +/// <b>`InhibitScreensaver(yesNo)`</b> +/// , +/// Inhibit the screensaver +/// @param[in] yesNo value with "true" or "false" to inhibit or allow screensaver (leaving empty defaults to false) +/// } +/// \table_row2_l{ +/// <b>`Hibernate`</b> +/// , +/// Hibernate (S4) the System +/// } +/// \table_row2_l{ +/// <b>`InhibitIdleShutdown(true/false)`</b> +/// , +/// Prevent the system to shutdown on idle. +/// @param[in] value "true" to inhibit shutdown timer (optional). +/// } +/// \table_row2_l{ +/// <b>`Minimize`</b> +/// , +/// Minimizes Kodi +/// } +/// \table_row2_l{ +/// <b>`Powerdown`</b> +/// , +/// Powerdown system +/// } +/// \table_row2_l{ +/// <b>`Quit`</b> +/// , +/// Quits Kodi +/// } +/// \table_row2_l{ +/// <b>`Reboot`</b> +/// , +/// Cold reboots the system (power cycle) +/// } +/// \table_row2_l{ +/// <b>`Reset`</b> +/// , +/// Reset the system (same as reboot) +/// } +/// \table_row2_l{ +/// <b>`Restart`</b> +/// , +/// Restart the system (same as reboot) +/// } +/// \table_row2_l{ +/// <b>`RestartApp`</b> +/// , +/// Restarts Kodi (only implemented under Windows and Linux) +/// } +/// \table_row2_l{ +/// <b>`ShutDown`</b> +/// , +/// Trigger default Shutdown action defined in System Settings +/// } +/// \table_row2_l{ +/// <b>`Suspend`</b> +/// , +/// Suspends (S3 / S1 depending on bios setting) the System +/// } +/// \table_row2_l{ +/// <b>`System.Exec(exec)`</b> +/// , +/// Execute shell commands +/// @param[in] exec The path to the executable +/// } +/// \table_row2_l{ +/// <b>`System.ExecWait(exec)`</b> +/// , +/// Execute shell commands and freezes Kodi until shell is closed +/// @param[in] exec The path to the executable +/// } +/// \table_end +/// + +CBuiltins::CommandMap CSystemBuiltins::GetOperations() const +{ + return {{"activatescreensaver", {"Activate Screensaver", 0, ActivateScreensaver}}, + {"resetscreensaver", {"Reset Screensaver", 0, ResetScreensaver}}, + {"hibernate", {"Hibernates the system", 0, Hibernate}}, + {"inhibitidleshutdown", {"Inhibit idle shutdown", 0, InhibitIdle}}, + {"inhibitscreensaver", {"Inhibit Screensaver", 0, InhibitScreenSaver}}, + {"minimize", {"Minimize Kodi", 0, Minimize}}, + {"powerdown", {"Powerdown system", 0, Powerdown}}, + {"quit", {"Quit Kodi", 0, Quit}}, + {"reboot", {"Reboot the system", 0, Reboot}}, + {"reset", {"Reset the system (same as reboot)", 0, Reboot}}, + {"restart", {"Restart the system (same as reboot)", 0, Reboot}}, + {"restartapp", {"Restart Kodi", 0, RestartApp}}, + {"shutdown", {"Shutdown the system", 0, Shutdown}}, + {"suspend", {"Suspends the system", 0, Suspend}}, + {"system.exec", {"Execute shell commands", 1, Exec<0>}}, + {"system.execwait", + {"Execute shell commands and freezes Kodi until shell is closed", 1, Exec<1>}}}; +} diff --git a/xbmc/interfaces/builtins/SystemBuiltins.h b/xbmc/interfaces/builtins/SystemBuiltins.h new file mode 100644 index 0000000..ad5c16c --- /dev/null +++ b/xbmc/interfaces/builtins/SystemBuiltins.h @@ -0,0 +1,19 @@ +/* + * 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 "Builtins.h" + +//! \brief Class providing system related built-in commands. +class CSystemBuiltins +{ +public: + //! \brief Returns the map of operations. + CBuiltins::CommandMap GetOperations() const; +}; diff --git a/xbmc/interfaces/builtins/WeatherBuiltins.cpp b/xbmc/interfaces/builtins/WeatherBuiltins.cpp new file mode 100644 index 0000000..8769a88 --- /dev/null +++ b/xbmc/interfaces/builtins/WeatherBuiltins.cpp @@ -0,0 +1,88 @@ +/* + * 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 "WeatherBuiltins.h" + +#include "ServiceBroker.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" + +#include <stdlib.h> + +/*! \brief Switch to a given weather location. + * \param params The parameters. + * \details params[0] = 1, 2 or 3. + */ +static int SetLocation(const std::vector<std::string>& params) +{ + int loc = atoi(params[0].c_str()); + CGUIMessage msg(GUI_MSG_ITEM_SELECT, 0, 0, loc); + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(msg, WINDOW_WEATHER); + + return 0; +} + +/*! \brief Switch weather location or refresh current. + * \param params (ignored) + * + * The Direction template parameter can be -1 for previous location, + * 1 for next location or 0 to refresh current location. + */ + template<int Direction> +static int SwitchLocation(const std::vector<std::string>& params) +{ + CGUIMessage msg(GUI_MSG_MOVE_OFFSET, 0, 0, Direction); + CServiceBroker::GetGUI()->GetWindowManager().SendMessage(msg, WINDOW_WEATHER); + + return 0; +} + +// Note: For new Texts with comma add a "\" before!!! Is used for table text. +// +/// \page page_List_of_built_in_functions +/// \section built_in_functions_16 Weather built-in's +/// +/// ----------------------------------------------------------------------------- +/// +/// \table_start +/// \table_h2_l{ +/// Function, +/// Description } +/// \table_row2_l{ +/// <b>`Weather.Refresh`</b> +/// , +/// Force weather data refresh. +/// } +/// \table_row2_l{ +/// <b>`Weather.LocationNext`</b> +/// , +/// Switch to next weather location +/// } +/// \table_row2_l{ +/// <b>`Weather.LocationPrevious`</b> +/// , +/// Switch to previous weather location +/// } +/// \table_row2_l{ +/// <b>`Weather.LocationSet`</b> +/// , +/// Switch to given weather location (parameter can be 1-3). +/// @param[in] parameter 1-3 +/// } +/// \table_end +/// + +CBuiltins::CommandMap CWeatherBuiltins::GetOperations() const +{ + return { + {"weather.refresh", {"Force weather data refresh", 0, SwitchLocation<0>}}, + {"weather.locationnext", {"Switch to next weather location", 0, SwitchLocation<1>}}, + {"weather.locationprevious", {"Switch to previous weather location", 0, SwitchLocation<-1>}}, + {"weather.locationset", {"Switch to given weather location (parameter can be 1-3)", 1, SetLocation}} + }; +} diff --git a/xbmc/interfaces/builtins/WeatherBuiltins.h b/xbmc/interfaces/builtins/WeatherBuiltins.h new file mode 100644 index 0000000..6827cfc --- /dev/null +++ b/xbmc/interfaces/builtins/WeatherBuiltins.h @@ -0,0 +1,19 @@ +/* + * 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 "Builtins.h" + +//! \brief Class providing weather related built-in commands. +class CWeatherBuiltins +{ +public: + //! \brief Returns the map of operations. + CBuiltins::CommandMap GetOperations() const; +}; |