std::string ArrayToString(SortAttribute attributes, const CVariant &variant, const std::string &seperator = " / ")
{
std::vector<std::string> strArray;
if (variant.isArray())
{
for (CVariant::const_iterator_array it = variant.begin_array(); it != variant.end_array(); it++)
{
if (attributes & SortAttributeIgnoreArticle)
strArray.push_back(SortUtils::RemoveArticles(it->asString()));
else
strArray.push_back(it->asString());
}
return StringUtils::Join(strArray, seperator);
}
else if (variant.isString())
{
if (attributes & SortAttributeIgnoreArticle)
return SortUtils::RemoveArticles(variant.asString());
else
return variant.asString();
}
return "";
}
TEST(TestUrlOptions, AddOptions)
{
std::string ref = "foo=bar&key=value";
CUrlOptions urlOptions(ref);
{
CVariant value;
EXPECT_TRUE(urlOptions.GetOption("foo", value));
EXPECT_TRUE(value.isString());
EXPECT_STREQ("bar", value.asString().c_str());
}
{
CVariant value;
EXPECT_TRUE(urlOptions.GetOption("key", value));
EXPECT_TRUE(value.isString());
EXPECT_STREQ("value", value.asString().c_str());
}
ref = "foo=bar&key";
urlOptions.Clear();
urlOptions.AddOptions(ref);
{
CVariant value;
EXPECT_TRUE(urlOptions.GetOption("foo", value));
EXPECT_TRUE(value.isString());
EXPECT_STREQ("bar", value.asString().c_str());
}
{
CVariant value;
EXPECT_TRUE(urlOptions.GetOption("key", value));
EXPECT_TRUE(value.isString());
EXPECT_TRUE(value.empty());
}
}
JSONRPC_STATUS CPlayerOperations::GoTo(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
CVariant to = parameterObject["to"];
switch (GetPlayer(parameterObject["playerid"]))
{
case Video:
case Audio:
if (to.isString())
{
std::string strTo = to.asString();
int actionID;
if (strTo == "previous")
actionID = ACTION_PREV_ITEM;
else if (strTo == "next")
actionID = ACTION_NEXT_ITEM;
else
return InvalidParams;
CApplicationMessenger::GetInstance().SendMsg(TMSG_GUI_ACTION, WINDOW_INVALID, -1, static_cast<void*>(new CAction(actionID)));
}
else if (to.isInteger())
{
if (IsPVRChannel())
CApplicationMessenger::GetInstance().SendMsg(TMSG_GUI_ACTION, WINDOW_INVALID, -1, static_cast<void*>(
new CAction(ACTION_CHANNEL_SWITCH, static_cast<float>(to.asInteger()))));
else
CApplicationMessenger::GetInstance().SendMsg(TMSG_PLAYLISTPLAYER_PLAY, static_cast<int>(to.asInteger()));
}
else
return InvalidParams;
break;
case Picture:
if (to.isString())
{
std::string strTo = to.asString();
int actionID;
if (strTo == "previous")
actionID = ACTION_PREV_PICTURE;
else if (strTo == "next")
actionID = ACTION_NEXT_PICTURE;
else
return InvalidParams;
SendSlideshowAction(actionID);
}
else
return FailedToExecute;
break;
case None:
default:
return FailedToExecute;
}
OnPlaylistChanged();
return ACK;
}
JSONRPC_STATUS CPlayerOperations::GoTo(const CStdString &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
CVariant to = parameterObject["to"];
switch (GetPlayer(parameterObject["playerid"]))
{
case Video:
case Audio:
if (to.isString())
{
std::string strTo = to.asString();
int actionID;
if (strTo == "previous")
actionID = ACTION_PREV_ITEM;
else if (strTo == "next")
actionID = ACTION_NEXT_ITEM;
else
return InvalidParams;
CApplicationMessenger::Get().SendAction(CAction(actionID));
}
else if (to.isInteger())
{
if (IsPVRChannel())
CApplicationMessenger::Get().SendAction(CAction(ACTION_CHANNEL_SWITCH, (float)to.asInteger()));
else
CApplicationMessenger::Get().PlayListPlayerPlay((int)to.asInteger());
}
else
return InvalidParams;
break;
case Picture:
if (to.isString())
{
std::string strTo = to.asString();
int actionID;
if (strTo == "previous")
actionID = ACTION_PREV_PICTURE;
else if (strTo == "next")
actionID = ACTION_NEXT_PICTURE;
else
return InvalidParams;
SendSlideshowAction(actionID);
}
else
return FailedToExecute;
break;
case None:
default:
return FailedToExecute;
}
OnPlaylistChanged();
return ACK;
}
JSONRPC_STATUS CPlayerOperations::SetShuffle(const CStdString &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
CGUIWindowSlideShow *slideshow = NULL;
CVariant shuffle = parameterObject["shuffle"];
switch (GetPlayer(parameterObject["playerid"]))
{
case Video:
case Audio:
{
if (IsPVRChannel())
return FailedToExecute;
int playlistid = GetPlaylist(GetPlayer(parameterObject["playerid"]));
if (g_playlistPlayer.IsShuffled(playlistid))
{
if ((shuffle.isBoolean() && !shuffle.asBoolean()) ||
(shuffle.isString() && shuffle.asString() == "toggle"))
{
CApplicationMessenger::Get().PlayListPlayerShuffle(playlistid, false);
OnPlaylistChanged();
}
}
else
{
if ((shuffle.isBoolean() && shuffle.asBoolean()) ||
(shuffle.isString() && shuffle.asString() == "toggle"))
{
CApplicationMessenger::Get().PlayListPlayerShuffle(playlistid, true);
OnPlaylistChanged();
}
}
break;
}
case Picture:
slideshow = (CGUIWindowSlideShow*)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
if (slideshow == NULL)
return FailedToExecute;
if (slideshow->IsShuffled())
{
if ((shuffle.isBoolean() && !shuffle.asBoolean()) ||
(shuffle.isString() && shuffle.asString() == "toggle"))
return FailedToExecute;
}
else
{
if ((shuffle.isBoolean() && shuffle.asBoolean()) ||
(shuffle.isString() && shuffle.asString() == "toggle"))
slideshow->Shuffle();
}
break;
default:
return FailedToExecute;
}
return ACK;
}
JSONRPC_STATUS CPlayerOperations::SetShuffle(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
CGUIWindowSlideShow *slideshow = NULL;
CVariant shuffle = parameterObject["shuffle"];
switch (GetPlayer(parameterObject["playerid"]))
{
case Video:
case Audio:
{
if (IsPVRChannel())
return FailedToExecute;
int playlistid = GetPlaylist(GetPlayer(parameterObject["playerid"]));
if (CServiceBroker::GetPlaylistPlayer().IsShuffled(playlistid))
{
if ((shuffle.isBoolean() && !shuffle.asBoolean()) ||
(shuffle.isString() && shuffle.asString() == "toggle"))
{
CApplicationMessenger::GetInstance().SendMsg(TMSG_PLAYLISTPLAYER_SHUFFLE, playlistid, 0);
OnPlaylistChanged();
}
}
else
{
if ((shuffle.isBoolean() && shuffle.asBoolean()) ||
(shuffle.isString() && shuffle.asString() == "toggle"))
{
CApplicationMessenger::GetInstance().SendMsg(TMSG_PLAYLISTPLAYER_SHUFFLE, playlistid, 1);
OnPlaylistChanged();
}
}
break;
}
case Picture:
slideshow = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIWindowSlideShow>(WINDOW_SLIDESHOW);
if (slideshow == NULL)
return FailedToExecute;
if (slideshow->IsShuffled())
{
if ((shuffle.isBoolean() && !shuffle.asBoolean()) ||
(shuffle.isString() && shuffle.asString() == "toggle"))
return FailedToExecute;
}
else
{
if ((shuffle.isBoolean() && shuffle.asBoolean()) ||
(shuffle.isString() && shuffle.asString() == "toggle"))
slideshow->Shuffle();
}
break;
default:
return FailedToExecute;
}
return ACK;
}
static bool FilterVar(bool valid, const CVariant& variant,
const std::string& check)
{
if (!valid)
return false;
if (variant.isNull() || variant.asString().empty())
return false;
std::string regions = variant.asString();
return regions.find(check) == std::string::npos;
}
bool CConnmanNetworkManager::PumpNetworkEvents(INetworkEventsCallback *callback)
{
bool result = false;
if (m_connection)
{
dbus_connection_read_write(m_connection, 0);
DBusMessage *msg = dbus_connection_pop_message(m_connection);
if (msg)
{
CDBusReplyPtr reply = CDBusReplyPtr(new CDBusReply(msg));
if (dbus_message_is_signal(msg, "net.connman.Manager", "PropertyChanged"))
{
CVariant key = reply->GetNextArgument();
m_properties[key.asString()] = reply->GetNextArgument();
UpdateNetworkManager();
if (strcmp(key.asString().c_str(), "Services") == 0)
callback->OnConnectionListChange(m_connections);
result = true;
}
else if (dbus_message_is_signal(msg, "net.connman.Manager", "StateChanged"))
{
CVariant stateString = reply->GetNextArgument();
result = true;
callback->OnConnectionStateChange(CConnmanConnection::ParseConnectionState(stateString.asString().c_str()));
}
else if (dbus_message_is_signal(msg, "net.connman.Manager", "NameAcquired"))
{
}
else
CLog::Log(LOGINFO, "ConnmanNetworkManager: Recieved an unknown signal %s", dbus_message_get_member(msg));
dbus_message_unref(msg);
}
}
for (size_t i = 0; i < m_connections.size(); i++)
{
if (((CConnmanConnection *)m_connections[i].get())->PumpNetworkEvents())
{
callback->OnConnectionChange(m_connections[i]);
result = true;
}
}
return result;
}
bool CGUIWindowMusicBase::GetDirectory(const CStdString &strDirectory, CFileItemList &items)
{
CStdString directory = strDirectory;
// check if the path contains a filter and if so load it and
// remove it from the path to get proper GUI view states etc
CSmartPlaylist filterXsp;
CMusicDbUrl musicUrl;
if (musicUrl.FromString(strDirectory))
{
CVariant filter;
if (musicUrl.GetOption("filter", filter))
{
// load the filter and if it's type does not match the
// path's item type reset it
if (filterXsp.LoadFromJson(filter.asString()) && !filterXsp.GetType().Equals(musicUrl.GetType().c_str()))
filterXsp.Reset();
// remove the "filter" option from the path
musicUrl.AddOption("filter", "");
}
directory = musicUrl.ToString();
}
items.SetArt("thumb", "");
bool bResult = CGUIMediaWindow::GetDirectory(directory, items);
if (bResult)
CMusicThumbLoader::FillThumb(items);
// (re-)apply the previously retrieved filter
// because it was reset in CGUIMediaWindow::GetDirectory()
if (!filterXsp.IsEmpty())
m_filter = filterXsp;
// add in the "New Playlist" item if we're in the playlists folder
if ((items.GetPath() == "special://musicplaylists/") && !items.Contains("newplaylist://"))
{
CFileItemPtr newPlaylist(new CFileItem(g_settings.GetUserDataItem("PartyMode.xsp"),false));
newPlaylist->SetLabel(g_localizeStrings.Get(16035));
newPlaylist->SetLabelPreformated(true);
newPlaylist->m_bIsFolder = true;
items.Add(newPlaylist);
newPlaylist.reset(new CFileItem("newplaylist://", false));
newPlaylist->SetLabel(g_localizeStrings.Get(525));
newPlaylist->SetLabelPreformated(true);
newPlaylist->SetSpecialSort(SortSpecialOnBottom);
newPlaylist->SetCanQueue(false);
items.Add(newPlaylist);
newPlaylist.reset(new CFileItem("newsmartplaylist://music", false));
newPlaylist->SetLabel(g_localizeStrings.Get(21437));
newPlaylist->SetLabelPreformated(true);
newPlaylist->SetSpecialSort(SortSpecialOnBottom);
newPlaylist->SetCanQueue(false);
items.Add(newPlaylist);
}
return bResult;
}
// Show keyboard with initial value (aTextString) and replace with result string.
// Returns: true - successful display and input (empty result may return true or false depending on parameter)
// false - unsuccessful display of the keyboard or cancelled editing
bool CGUIKeyboardFactory::ShowAndGetInput(std::string& aTextString, CVariant heading, bool allowEmptyResult, bool hiddenInput /* = false */, unsigned int autoCloseMs /* = 0 */)
{
bool confirmed = false;
CGUIKeyboard *kb = NULL;
//heading can be a string or a localization id
std::string headingStr;
if (heading.isString())
headingStr = heading.asString();
else if (heading.isInteger() && heading.asInteger())
headingStr = g_localizeStrings.Get((uint32_t)heading.asInteger());
#if defined(TARGET_DARWIN_IOS)
kb = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogKeyboardTouch>(WINDOW_DIALOG_KEYBOARD_TOUCH);
#else
kb = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogKeyboardGeneric>(WINDOW_DIALOG_KEYBOARD);
#endif
if (kb)
{
g_activeKeyboard = kb;
kb->startAutoCloseTimer(autoCloseMs);
confirmed = kb->ShowAndGetInput(keyTypedCB, aTextString, aTextString, headingStr, hiddenInput);
g_activeKeyboard = NULL;
}
if (confirmed)
{
if (!allowEmptyResult && aTextString.empty())
confirmed = false;
}
return confirmed;
}
JSONRPC_STATUS CPlayerOperations::Zoom(const CStdString &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
CVariant zoom = parameterObject["zoom"];
switch (GetPlayer(parameterObject["playerid"]))
{
case Picture:
if (zoom.isInteger())
SendSlideshowAction(ACTION_ZOOM_LEVEL_NORMAL + ((int)zoom.asInteger() - 1));
else if (zoom.isString())
{
std::string strZoom = zoom.asString();
if (strZoom == "in")
SendSlideshowAction(ACTION_ZOOM_IN);
else if (strZoom == "out")
SendSlideshowAction(ACTION_ZOOM_OUT);
else
return InvalidParams;
}
else
return InvalidParams;
return ACK;
case Video:
case Audio:
case None:
default:
return FailedToExecute;
}
}
bool CInputStream::Supports(const CFileItem &fileitem)
{
// check if a specific inputstream addon is requested
CVariant addon = fileitem.GetProperty("inputstreamaddon");
if (!addon.isNull())
{
if (addon.asString() != ID())
return false;
else
return true;
}
// check paths
CSingleLock lock(m_parentSection);
bool match = false;
for (auto &path : m_pathList)
{
if (path.empty())
continue;
CRegExp r(true, CRegExp::asciiOnly, path.c_str());
if (r.RegFind(fileitem.GetPath().c_str()) == 0 && r.GetFindLen() > 5)
{
match = true;
break;
}
}
return match;
}
void CGUIDialogKeyboard::SetHeading(const CVariant &heading)
{
if (heading.isString())
m_strHeading = heading.asString();
else if (heading.isInteger() && heading.asInteger())
m_strHeading = g_localizeStrings.Get((uint32_t)heading.asInteger());
}
JSONRPC_STATUS CPVROperations::GetChannels(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
if (!g_PVRManager.IsStarted())
return FailedToExecute;
CPVRChannelGroupsContainer *channelGroupContainer = g_PVRChannelGroups;
if (channelGroupContainer == NULL)
return FailedToExecute;
CPVRChannelGroupPtr channelGroup;
CVariant id = parameterObject["channelgroupid"];
if (id.isInteger())
channelGroup = channelGroupContainer->GetByIdFromAll((int)id.asInteger());
else if (id.isString())
channelGroup = channelGroupContainer->GetGroupAll(id.asString() == "allradio");
if (channelGroup == NULL)
return InvalidParams;
CFileItemList channels;
if (channelGroup->GetMembers(channels) < 0)
return InvalidParams;
HandleFileItemList("channelid", false, "channels", channels, parameterObject, result, true);
return OK;
}
CStdString IDirectory::GetLocalized(const CVariant &var) const
{
if (var.isString())
return var.asString();
else if (var.isInteger() && var.asInteger())
return g_localizeStrings.Get(var.asInteger());
return "";
}
std::string CGUIDialogBoxBase::GetLocalized(const CVariant &var) const
{
if (var.isString())
return var.asString();
else if (var.isInteger() && var.asInteger())
return g_localizeStrings.Get((uint32_t)var.asInteger());
return "";
}
bool CURL::GetProtocolOption(const std::string &key, std::string &value) const
{
CVariant valueObj;
if (!m_protocolOptions.GetOption(key, valueObj))
return false;
value = valueObj.asString();
return true;
}
void CGUIEditControl::SetInputType(CGUIEditControl::INPUT_TYPE type, CVariant heading)
{
m_inputType = type;
if (heading.isString())
m_inputHeading = heading.asString();
else if (heading.isInteger() && heading.asInteger())
m_inputHeading = g_localizeStrings.Get(static_cast<uint32_t>(heading.asInteger()));
//! @todo Verify the current input string?
}
bool CURL::GetOption(const CStdString &key, CStdString &value) const
{
CVariant valueObj;
if (!m_options.GetOption(key, valueObj))
return false;
value = valueObj.asString();
return true;
}
std::string CBaseEvent::VariantToLocalizedString(const CVariant& variant)
{
if (variant.isString())
return variant.asString();
if (variant.isInteger() && variant.asInteger() > 0)
return g_localizeStrings.Get(static_cast<uint32_t>(variant.asInteger()));
if (variant.isUnsignedInteger() && variant.asUnsignedInteger() > 0)
return g_localizeStrings.Get(static_cast<uint32_t>(variant.asUnsignedInteger()));
return "";
}
int CPlayerOperations::ParseRepeatState(const CVariant &repeat)
{
REPEAT_STATE state = REPEAT_NONE;
std::string strState = repeat.asString();
if (strState.compare("one") == 0)
state = REPEAT_ONE;
else if (strState.compare("all") == 0)
state = REPEAT_ALL;
return state;
}
void CGUIWindowSettingsCategory::SetDescription(const CVariant &label)
{
if (GetControl(CONTROL_DESCRIPTION) == NULL)
return;
if (label.isString())
SET_CONTROL_LABEL(CONTROL_DESCRIPTION, label.asString());
else if (label.isInteger() && label.asInteger() >= 0)
SET_CONTROL_LABEL(CONTROL_DESCRIPTION, (int)label.asInteger());
else
SET_CONTROL_LABEL(CONTROL_DESCRIPTION, "");
}
bool CInputStream::Supports(const CFileItem &fileitem)
{
{
CSingleLock lock(m_parentSection);
auto it = m_configMap.find(ID());
if (it == m_configMap.end())
return false;
if (!it->second.m_ready)
return false;
}
// check if a specific inputstream addon is requested
CVariant addon = fileitem.GetProperty("inputstreamaddon");
if (!addon.isNull())
{
if (addon.asString() != ID())
return false;
else
return true;
}
// check protocols
std::string protocol = fileitem.GetURL().GetProtocol();
if (!protocol.empty())
{
if (std::find(m_protocolsList.begin(),
m_protocolsList.end(), protocol) != m_protocolsList.end())
return true;
}
// check paths
CSingleLock lock(m_parentSection);
auto it = m_configMap.find(ID());
if (it == m_configMap.end())
return false;
bool match = false;
for (auto &path : it->second.m_pathList)
{
if (path.empty())
continue;
CRegExp r(true, CRegExp::asciiOnly, path.c_str());
if (r.RegFind(fileitem.GetPath().c_str()) == 0 && r.GetFindLen() > 5)
{
match = true;
break;
}
}
return match;
}
JSONRPC_STATUS CAddonsOperations::ExecuteAddon(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
std::string id = parameterObject["addonid"].asString();
AddonPtr addon;
if (!CServiceBroker::GetAddonMgr().GetAddon(id, addon) || addon.get() == NULL ||
addon->Type() < ADDON_VIZ || addon->Type() >= ADDON_MAX)
return InvalidParams;
std::string argv;
CVariant params = parameterObject["params"];
if (params.isObject())
{
for (CVariant::const_iterator_map it = params.begin_map(); it != params.end_map(); it++)
{
if (it != params.begin_map())
argv += ",";
argv += it->first + "=" + it->second.asString();
}
}
else if (params.isArray())
{
for (CVariant::const_iterator_array it = params.begin_array(); it != params.end_array(); it++)
{
if (it != params.begin_array())
argv += ",";
argv += StringUtils::Paramify(it->asString());
}
}
else if (params.isString())
{
if (!params.empty())
argv = StringUtils::Paramify(params.asString());
}
std::string cmd;
if (params.empty())
cmd = StringUtils::Format("RunAddon(%s)", id.c_str());
else
cmd = StringUtils::Format("RunAddon(%s, %s)", id.c_str(), argv.c_str());
if (params["wait"].asBoolean())
CApplicationMessenger::GetInstance().SendMsg(TMSG_EXECUTE_BUILT_IN, -1, -1, nullptr, cmd);
else
CApplicationMessenger::GetInstance().PostMsg(TMSG_EXECUTE_BUILT_IN, -1, -1, nullptr, cmd);
return ACK;
}
void CGUIDialogSettingsBase::SetControlLabel(int controlId, const CVariant &label)
{
if (GetControl(controlId) == NULL)
return;
if (label.isString())
SET_CONTROL_LABEL(controlId, label.asString());
else if (label.isInteger() && label.asInteger() >= 0)
{
int labelId = static_cast<uint32_t>(label.asInteger());
std::string localizedString = GetLocalizedString(labelId);
if (!localizedString.empty())
SET_CONTROL_LABEL(controlId, localizedString);
else
SET_CONTROL_LABEL(controlId, labelId);
}
else
SET_CONTROL_LABEL(controlId, "");
}
JSONRPC_STATUS CPVROperations::Record(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
if (!g_PVRManager.IsStarted())
return FailedToExecute;
CPVRChannelPtr pChannel;
CVariant channel = parameterObject["channel"];
if (channel.isString() && channel.asString() == "current")
{
pChannel = g_PVRManager.GetCurrentChannel();
if (!pChannel)
return InternalError;
}
else if (channel.isInteger())
{
CPVRChannelGroupsContainer *channelGroupContainer = g_PVRManager.ChannelGroups();
if (channelGroupContainer == NULL)
return FailedToExecute;
pChannel = channelGroupContainer->GetChannelById((int)channel.asInteger());
}
else
return InvalidParams;
if (pChannel == NULL)
return InvalidParams;
else if (!pChannel->CanRecord())
return FailedToExecute;
CVariant record = parameterObject["record"];
bool toggle = true;
if (record.isBoolean() && record.asBoolean() == pChannel->IsRecording())
toggle = false;
if (toggle)
{
if (!g_PVRManager.ToggleRecordingOnChannel(pChannel->ChannelID()))
return FailedToExecute;
}
return ACK;
}
bool CInputStreamAddon::Supports(BinaryAddonBasePtr& addonBase, const CFileItem &fileitem)
{
// check if a specific inputstream addon is requested
CVariant addon = fileitem.GetProperty("inputstreamaddon");
if (!addon.isNull())
return (addon.asString() == addonBase->ID());
// check protocols
std::string protocol = fileitem.GetURL().GetProtocol();
if (!protocol.empty())
{
std::string protocols = addonBase->Type(ADDON_INPUTSTREAM)->GetValue("@protocols").asString();
if (!protocols.empty())
{
std::vector<std::string> protocolsList = StringUtils::Tokenize(protocols, "|");
for (auto& value : protocolsList)
{
StringUtils::Trim(value);
if (value == protocol)
return true;
}
}
}
std::string filetype = fileitem.GetURL().GetFileType();
if (!filetype.empty())
{
std::string extensions = addonBase->Type(ADDON_INPUTSTREAM)->GetValue("@extension").asString();
if (!extensions.empty())
{
std::vector<std::string> extensionsList = StringUtils::Tokenize(extensions, "|");
for (auto& value : extensionsList)
{
StringUtils::Trim(value);
if (value == filetype)
return true;
}
}
}
return false;
}
bool CMusicDbUrl::validateOption(const std::string &key, const CVariant &value)
{
if (!CDbUrl::validateOption(key, value))
return false;
// if the value is empty it will remove the option which is ok
// otherwise we only care about the "filter" option here
if (value.empty() || !StringUtils::EqualsNoCase(key, "filter"))
return true;
if (!value.isString())
return false;
CSmartPlaylist xspFilter;
if (!xspFilter.LoadFromJson(value.asString()))
return false;
// check if the filter playlist matches the item type
return xspFilter.GetType() == m_type;
}
bool CGUIControlListSetting::OnClick()
{
if (m_pButton == NULL)
return false;
CGUIDialogSelect *dialog = (CGUIDialogSelect*)g_windowManager.GetWindow(WINDOW_DIALOG_SELECT);
if (dialog == NULL)
return false;
CFileItemList options;
if (!GetItems(m_pSetting, options) || options.Size() <= 1)
return false;
dialog->Reset();
dialog->SetHeading(g_localizeStrings.Get(m_pSetting->GetLabel()));
dialog->SetItems(&options);
dialog->SetMultiSelection(false);
dialog->DoModal();
if (!dialog->IsConfirmed())
return false;
const CFileItemPtr item = dialog->GetSelectedItem();
if (item == NULL || !item->HasProperty("value"))
return false;
CVariant value = item->GetProperty("value");
switch (m_pSetting->GetType())
{
case SettingTypeInteger:
return ((CSettingInt *)m_pSetting)->SetValue((int)value.asInteger());
case SettingTypeString:
return ((CSettingString *)m_pSetting)->SetValue(value.asString());
default:
break;
}
return true;
}
// Show keyboard with initial value (aTextString) and replace with result string.
// Returns: true - successful display and input (empty result may return true or false depending on parameter)
// false - unsucessful display of the keyboard or cancelled editing
bool CGUIKeyboardFactory::ShowAndGetInput(CStdString& aTextString, const CVariant &heading, bool allowEmptyResult, bool hiddenInput /* = false */, unsigned int autoCloseMs /* = 0 */)
{
bool confirmed = false;
CGUIKeyboard *kb = NULL;
bool needsFreeing = true;
//heading can be a string or a localization id
std::string headingStr;
if (heading.isString())
headingStr = heading.asString();
else if (heading.isInteger() && heading.asInteger())
headingStr = g_localizeStrings.Get((uint32_t)heading.asInteger());
#if defined(TARGET_DARWIN_IOS) && !defined(TARGET_DARWIN_IOS_ATV2)
kb = new CIOSKeyboard();
#endif
if(!kb)
{
kb = (CGUIDialogKeyboardGeneric*)g_windowManager.GetWindow(WINDOW_DIALOG_KEYBOARD);
needsFreeing = false;
}
if(kb)
{
kb->startAutoCloseTimer(autoCloseMs);
confirmed = kb->ShowAndGetInput(keyTypedCB, aTextString, aTextString, headingStr, hiddenInput);
if(needsFreeing)
delete kb;
}
if (confirmed)
{
if (!allowEmptyResult && aTextString.IsEmpty())
confirmed = false;
}
return confirmed;
}
