JSONRPC_STATUS CSettingsOperations::ResetSettingValue(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
string settingId = parameterObject["setting"].asString();
CSetting* setting = CSettings::Get().GetSetting(settingId);
if (setting == NULL ||
!setting->IsVisible())
return InvalidParams;
switch (setting->GetType())
{
case SettingTypeBool:
case SettingTypeInteger:
case SettingTypeNumber:
case SettingTypeString:
case SettingTypeList:
setting->Reset();
break;
case SettingTypeNone:
case SettingTypeAction:
default:
return InvalidParams;
}
return ACK;
}
// get all the settings beginning with the term "strGroup"
void CGUISettings::GetSettingsGroup(const char *strGroup, vecSettings &settings)
{
vecSettings unorderedSettings;
for (mapIter it = settingsMap.begin(); it != settingsMap.end(); it++)
{
if ((*it).first.Left(strlen(strGroup)).Equals(strGroup) && (*it).second->GetOrder() > 0 && !(*it).second->IsAdvanced())
unorderedSettings.push_back((*it).second);
}
// now order them...
sort(unorderedSettings.begin(), unorderedSettings.end(), sortsettings());
// remove any instances of 2 separators in a row
bool lastWasSeparator(false);
for (vecSettings::iterator it = unorderedSettings.begin(); it != unorderedSettings.end(); it++)
{
CSetting *setting = *it;
// only add separators if we don't have 2 in a row
if (setting->GetType() == SETTINGS_TYPE_SEPARATOR)
{
if (!lastWasSeparator)
settings.push_back(setting);
lastWasSeparator = true;
}
else
{
lastWasSeparator = false;
settings.push_back(setting);
}
}
}
std::vector<CVariant> CSettings::GetList(const std::string &id) const
{
CSetting *setting = m_settingsManager->GetSetting(id);
if (setting == NULL || setting->GetType() != SettingTypeList)
return std::vector<CVariant>();
return CSettingUtils::GetList(static_cast<CSettingList*>(setting));
}
bool CSettings::SetList(const std::string &id, const std::vector<CVariant> &value)
{
CSetting *setting = m_settingsManager->GetSetting(id);
if (setting == NULL || setting->GetType() != SettingTypeList)
return false;
return CSettingUtils::SetList(static_cast<CSettingList*>(setting), value);
}
bool CSettings::SetList(const std::string &id, const std::vector<CVariant> &value)
{
CSetting *setting = m_settingsManager->GetSetting(id);
if (setting == NULL || setting->GetType() != SettingTypeList)
return false;
CSettingList *listSetting = static_cast<CSettingList*>(setting);
SettingPtrList newValues;
bool ret = true;
int index = 0;
for (std::vector<CVariant>::const_iterator itValue = value.begin(); itValue != value.end(); ++itValue)
{
CSetting *settingValue = listSetting->GetDefinition()->Clone(StringUtils::Format("%s.%d", listSetting->GetId().c_str(), index++));
if (settingValue == NULL)
return false;
switch (listSetting->GetElementType())
{
case SettingTypeBool:
if (!itValue->isBoolean())
return false;
ret = static_cast<CSettingBool*>(settingValue)->SetValue(itValue->asBoolean());
break;
case SettingTypeInteger:
if (!itValue->isInteger())
return false;
ret = static_cast<CSettingInt*>(settingValue)->SetValue((int)itValue->asInteger());
break;
case SettingTypeNumber:
if (!itValue->isDouble())
return false;
ret = static_cast<CSettingNumber*>(settingValue)->SetValue(itValue->asDouble());
break;
case SettingTypeString:
if (!itValue->isString())
return false;
ret = static_cast<CSettingString*>(settingValue)->SetValue(itValue->asString());
break;
default:
ret = false;
break;
}
if (!ret)
{
delete settingValue;
return false;
}
newValues.push_back(SettingPtr(settingValue));
}
return listSetting->SetValue(newValues);
}
bool CSettingsManager::SetList(const std::string &id, const std::vector< boost::shared_ptr<CSetting> > &value)
{
CSharedLock lock(m_settingsCritical);
CSetting *setting = GetSetting(id);
if (setting == NULL || setting->GetType() != SettingTypeList)
return false;
return ((CSettingList*)setting)->SetValue(value);
}
bool CSettingsManager::SetInt(const std::string &id, int value)
{
CSingleLock lock(m_critical);
CSetting *setting = GetSetting(id);
if (setting == NULL || setting->GetType() != SettingTypeInteger)
return false;
return ((CSettingInt*)setting)->SetValue(value);
}
bool CSettingsManager::SetNumber(const std::string &id, double value)
{
CSingleLock lock(m_critical);
CSetting *setting = GetSetting(id);
if (setting == NULL || setting->GetType() != SettingTypeNumber)
return false;
return ((CSettingNumber*)setting)->SetValue(value);
}
int CSettingsManager::GetInt(const std::string &id) const
{
CSharedLock lock(m_settingsCritical);
CSetting *setting = GetSetting(id);
if (setting == NULL || setting->GetType() != SettingTypeInteger)
return 0;
return ((CSettingInt*)setting)->GetValue();
}
bool CSettingsManager::SetBool(const std::string &id, bool value)
{
CSingleLock lock(m_critical);
CSetting *setting = GetSetting(id);
if (setting == NULL || setting->GetType() != SettingTypeBool)
return false;
return ((CSettingBool*)setting)->SetValue(value);
}
std::string CSettingsManager::GetString(const std::string &id) const
{
CSharedLock lock(m_settingsCritical);
CSetting *setting = GetSetting(id);
if (setting == NULL || setting->GetType() != SettingTypeString)
return "";
return ((CSettingString*)setting)->GetValue();
}
double CSettingsManager::GetNumber(const std::string &id) const
{
CSharedLock lock(m_settingsCritical);
CSetting *setting = GetSetting(id);
if (setting == NULL || setting->GetType() != SettingTypeNumber)
return 0.0;
return ((CSettingNumber*)setting)->GetValue();
}
bool CSettingsManager::SetString(const std::string &id, const std::string &value)
{
CSharedLock lock(m_settingsCritical);
CSetting *setting = GetSetting(id);
if (setting == NULL || setting->GetType() != SettingTypeString)
return false;
return ((CSettingString*)setting)->SetValue(value);
}
std::vector< std::shared_ptr<CSetting> > CSettingsManager::GetList(const std::string &id) const
{
CSharedLock lock(m_settingsCritical);
CSetting *setting = GetSetting(id);
if (setting == NULL || setting->GetType() != SettingTypeList)
return std::vector< std::shared_ptr<CSetting> >();
return ((CSettingList*)setting)->GetValue();
}
bool CSettingsManager::ToggleBool(const std::string &id)
{
CSharedLock lock(m_settingsCritical);
CSetting *setting = GetSetting(id);
if (setting == NULL || setting->GetType() != SettingTypeBool)
return false;
return SetBool(id, !((CSettingBool*)setting)->GetValue());
}
std::vector<CVariant> CSettings::GetList(const std::string &id) const
{
CSetting *setting = m_settingsManager->GetSetting(id);
if (setting == NULL || setting->GetType() != SettingTypeList)
return std::vector<CVariant>();
CSettingList *listSetting = static_cast<CSettingList*>(setting);
return ListToValues(listSetting, listSetting->GetValue());
}
int CSettingManager::GetInt(const std::string &id) const
{
XR::CSingleLock lock(m_settingsCritical);
CSetting *setting = GetSetting(id);
if (!setting) {
LOGERR("GetInt() - Setting not found! - use AddInt() to add setting first");
return 0;
}
if (setting->GetType() != SettingType::ST_INT)
return false;
return ((CSettingInt*)setting)->GetValue();
}
std::string CSettingManager::GetString(const std::string &id) const
{
XR::CSingleLock lock(m_settingsCritical);
CSetting *setting = GetSetting(id);
if (!setting) {
LOGERR("GetString() - Setting not found! - use AddString() to add setting first");
return "";
}
if (setting->GetType() != SettingType::ST_STRING)
return "";
return ((CSettingString*)setting)->GetValue();
}
bool CSettingManager::SetFloat(const std::string &id, float value)
{
XR::CSingleLock lock(m_settingsCritical);
CSetting *setting = GetSetting(id);
if (!setting) {
LOGERR("SetFloat() - Setting not found! - use AddFloat() to add setting first");
return false;
}
if (setting->GetType() != SettingType::ST_FLOAT)
return false;
return ((CSettingFloat*)setting)->SetValue(value);
}
bool CSettingManager::GetBool(const std::string &id) const
{
XR::CSingleLock lock(m_settingsCritical);
CSetting* setting = GetSetting(id);
if (!setting) {
LOGERR("GetBool() - Setting not found! - use AddBool() to add setting first");
return false;
}
if (setting->GetType() != SettingType::ST_BOOL)
return false;
return ((CSettingIpml<bool>*)setting)->GetValue();
}
bool CSettingManager::ToggleBool(const std::string &id)
{
XR::CSingleLock lock(m_settingsCritical);
CSetting *setting = GetSetting(id);
if (!setting) {
LOGERR("ToggleBool() - Setting not found! - use AddSetting() to add setting first");
return false;
}
if (setting->GetType() != SettingType::ST_BOOL)
return false;
bool value = ((CSettingBool*)setting)->GetValue();
return ((CSettingBool*)setting)->SetValue(!value);
}
bool CSettingsManager::GetBool(const std::string &id) const
{
CSingleLock lock(m_critical);
CSetting *setting = GetSetting(id);
if (setting == NULL || setting->GetType() != SettingTypeBool)
{
// Backward compatibility (skins use this setting)
if (setting == NULL && StringUtils::EqualsNoCase(id.c_str(), "lookandfeel.enablemouse"))
return GetBool("input.enablemouse");
return false;
}
return ((CSettingBool*)setting)->GetValue();
}
void CSettingsManager::UpdateSettingByDependency(const std::string &settingId, const CSettingDependency &dependency)
{
CSetting *setting = GetSetting(settingId);
if (setting == NULL)
return;
switch (dependency.GetType())
{
case SettingDependencyTypeEnable:
// just trigger the property changed callback and a call to
// CSetting::IsEnabled() will automatically determine the new
// enabled state
OnSettingPropertyChanged(setting, "enabled");
break;
case SettingDependencyTypeUpdate:
{
SettingType type = (SettingType)setting->GetType();
if (type == SettingTypeInteger)
{
CSettingInt *settingInt = ((CSettingInt*)setting);
if (settingInt->GetOptionsType() == SettingOptionsTypeDynamic)
settingInt->UpdateDynamicOptions();
}
else if (type == SettingTypeString)
{
CSettingString *settingString = ((CSettingString*)setting);
if (settingString->GetOptionsType() == SettingOptionsTypeDynamic)
settingString->UpdateDynamicOptions();
}
break;
}
case SettingDependencyTypeVisible:
// just trigger the property changed callback and a call to
// CSetting::IsVisible() will automatically determine the new
// visible state
OnSettingPropertyChanged(setting, "visible");
break;
case SettingDependencyTypeNone:
default:
break;
}
}
JSONRPC_STATUS CSettingsOperations::GetSettingValue(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
string settingId = parameterObject["setting"].asString();
CSetting* setting = CSettings::Get().GetSetting(settingId);
if (setting == NULL ||
!setting->IsVisible())
return InvalidParams;
CVariant value;
switch (setting->GetType())
{
case SettingTypeBool:
value = static_cast<CSettingBool*>(setting)->GetValue();
break;
case SettingTypeInteger:
value = static_cast<CSettingInt*>(setting)->GetValue();
break;
case SettingTypeNumber:
value = static_cast<CSettingNumber*>(setting)->GetValue();
break;
case SettingTypeString:
value = static_cast<CSettingString*>(setting)->GetValue();
break;
case SettingTypeList:
{
SerializeSettingListValues(CSettings::Get().GetList(settingId), value);
break;
}
case SettingTypeNone:
case SettingTypeAction:
default:
return InvalidParams;
}
result["value"] = value;
return OK;
}
void CGUIDialogPeripheralSettings::CreateSettings()
{
m_bIsInitialising = true;
m_usePopupSliders = g_SkinInfo->HasSkinFile("DialogSlider.xml");
if (m_item)
{
CPeripheral *peripheral = g_peripherals.GetByPath(m_item->GetPath());
if (peripheral)
{
vector<CSetting *> settings = peripheral->GetSettings();
for (size_t iPtr = 0; iPtr < settings.size(); iPtr++)
{
CSetting *setting = settings[iPtr];
if (!setting->IsVisible())
{
CLog::Log(LOGDEBUG, "%s - invisible", __FUNCTION__);
continue;
}
switch(setting->GetType())
{
case SETTINGS_TYPE_BOOL:
{
CSettingBool *boolSetting = (CSettingBool *) setting;
if (boolSetting)
{
m_boolSettings.insert(make_pair(CStdString(boolSetting->GetSetting()), boolSetting->GetData()));
AddBool(boolSetting->GetOrder(), boolSetting->GetLabel(), &m_boolSettings[boolSetting->GetSetting()], true);
}
}
break;
case SETTINGS_TYPE_INT:
{
CSettingInt *intSetting = (CSettingInt *) setting;
if (intSetting)
{
if (intSetting->GetControlType() == SPIN_CONTROL_INT)
{
m_intSettings.insert(make_pair(CStdString(intSetting->GetSetting()), (float) intSetting->GetData()));
AddSlider(intSetting->GetOrder(), intSetting->GetLabel(), &m_intSettings[intSetting->GetSetting()], (float)intSetting->m_iMin, (float)intSetting->m_iStep, (float)intSetting->m_iMax, CGUIDialogVideoSettings::FormatInteger, false);
}
else if (intSetting->GetControlType() == SPIN_CONTROL_TEXT)
{
m_intTextSettings.insert(make_pair(CStdString(intSetting->GetSetting()), intSetting->GetData()));
vector<pair<int, int> > entries;
map<int, int>::iterator entriesItr = intSetting->m_entries.begin();
while (entriesItr != intSetting->m_entries.end())
{
entries.push_back(make_pair(entriesItr->first, entriesItr->second));
++entriesItr;
}
AddSpin(intSetting->GetOrder(), intSetting->GetLabel(), &m_intTextSettings[intSetting->GetSetting()], entries);
}
}
}
break;
case SETTINGS_TYPE_FLOAT:
{
CSettingFloat *floatSetting = (CSettingFloat *) setting;
if (floatSetting)
{
m_floatSettings.insert(make_pair(CStdString(floatSetting->GetSetting()), floatSetting->GetData()));
AddSlider(floatSetting->GetOrder(), floatSetting->GetLabel(), &m_floatSettings[floatSetting->GetSetting()], floatSetting->m_fMin, floatSetting->m_fStep, floatSetting->m_fMax, CGUIDialogVideoSettings::FormatFloat, false);
}
}
break;
case SETTINGS_TYPE_STRING:
{
CSettingString *stringSetting = (CSettingString *) setting;
if (stringSetting)
{
m_stringSettings.insert(make_pair(CStdString(stringSetting->GetSetting()), stringSetting->GetData()));
AddString(stringSetting->GetOrder(), stringSetting->GetLabel(), &m_stringSettings[stringSetting->GetSetting()]);
}
}
break;
default:
//TODO add more types if needed
CLog::Log(LOGDEBUG, "%s - unknown type", __FUNCTION__);
break;
}
}
}
else
{
CLog::Log(LOGDEBUG, "%s - no peripheral", __FUNCTION__);
}
}
m_bIsInitialising = false;
}
void CGUIDialogPeripheralSettings::CreateSettings()
{
m_bIsInitialising = true;
m_usePopupSliders = g_SkinInfo->HasSkinFile("DialogSlider.xml");
if (m_item)
{
CPeripheral *peripheral = g_peripherals.GetByPath(m_item->GetPath());
if (peripheral)
{
vector<CSetting *> settings = peripheral->GetSettings();
for (size_t iPtr = 0; iPtr < settings.size(); iPtr++)
{
CSetting *setting = settings[iPtr];
if (!setting->IsVisible())
{
CLog::Log(LOGDEBUG, "%s - invisible", __FUNCTION__);
continue;
}
switch(setting->GetType())
{
case SettingTypeBool:
{
CSettingBool *boolSetting = (CSettingBool *) setting;
if (boolSetting)
{
m_boolSettings.insert(make_pair(CStdString(boolSetting->GetId()), boolSetting->GetValue()));
AddBool(m_settingId++, boolSetting->GetLabel(), &m_boolSettings[boolSetting->GetId()], true);
}
}
break;
case SettingTypeInteger:
{
CSettingInt *intSetting = (CSettingInt *) setting;
if (intSetting)
{
if (intSetting->GetControl()->GetFormat() == "integer")
{
m_intSettings.insert(make_pair(CStdString(intSetting->GetId()), (float) intSetting->GetValue()));
AddSlider(m_settingId++, intSetting->GetLabel(), &m_intSettings[intSetting->GetId()], (float)intSetting->GetMinimum(), (float)intSetting->GetStep(), (float)intSetting->GetMaximum(), CGUIDialogVideoSettings::FormatInteger, false);
}
else if (intSetting->GetControl()->GetFormat() == "string")
{
m_intTextSettings.insert(make_pair(CStdString(intSetting->GetId()), intSetting->GetValue()));
vector<pair<int, int> > entries;
StaticIntegerSettingOptions::const_iterator entriesItr = intSetting->GetOptions().begin();
while (entriesItr != intSetting->GetOptions().end())
{
entries.push_back(make_pair(entriesItr->first, entriesItr->second));
++entriesItr;
}
AddSpin(m_settingId++, intSetting->GetLabel(), &m_intTextSettings[intSetting->GetId()], entries);
}
}
}
break;
case SettingTypeNumber:
{
CSettingNumber *floatSetting = (CSettingNumber *) setting;
if (floatSetting)
{
m_floatSettings.insert(make_pair(CStdString(floatSetting->GetId()), (float)floatSetting->GetValue()));
AddSlider(m_settingId++, floatSetting->GetLabel(), &m_floatSettings[floatSetting->GetId()], (float)floatSetting->GetMinimum(), (float)floatSetting->GetStep(), (float)floatSetting->GetMaximum(), CGUIDialogVideoSettings::FormatFloat, false);
}
}
break;
case SettingTypeString:
{
CSettingString *stringSetting = (CSettingString *) setting;
if (stringSetting)
{
m_stringSettings.insert(make_pair(CStdString(stringSetting->GetId()), stringSetting->GetValue()));
AddString(m_settingId++, stringSetting->GetLabel(), &m_stringSettings[stringSetting->GetId()]);
}
}
break;
default:
//TODO add more types if needed
CLog::Log(LOGDEBUG, "%s - unknown type", __FUNCTION__);
break;
}
}
}
else
{
CLog::Log(LOGDEBUG, "%s - no peripheral", __FUNCTION__);
}
}
m_bIsInitialising = false;
}
void CGUIDialogPeripheralSettings::InitializeSettings()
{
if (m_item == NULL)
{
m_initialising = false;
return;
}
m_initialising = true;
bool usePopup = g_SkinInfo->HasSkinFile("DialogSlider.xml");
CPeripheral *peripheral = g_peripherals.GetByPath(m_item->GetPath());
if (peripheral == NULL)
{
CLog::Log(LOGDEBUG, "%s - no peripheral", __FUNCTION__);
m_initialising = false;
return;
}
m_settingsMap.clear();
CGUIDialogSettingsManualBase::InitializeSettings();
CSettingCategory *category = AddCategory("peripheralsettings", -1);
if (category == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogPeripheralSettings: unable to setup settings");
return;
}
CSettingGroup *group = AddGroup(category);
if (group == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogPeripheralSettings: unable to setup settings");
return;
}
std::vector<CSetting*> settings = peripheral->GetSettings();
for (std::vector<CSetting*>::iterator itSetting = settings.begin(); itSetting != settings.end(); ++itSetting)
{
CSetting *setting = *itSetting;
if (setting == NULL)
continue;
if (!setting->IsVisible())
{
CLog::Log(LOGDEBUG, "%s - invisible", __FUNCTION__);
continue;
}
// we need to create a copy of the setting because the CSetting instances
// are destroyed when leaving the dialog
CSetting *settingCopy = NULL;
switch(setting->GetType())
{
case SettingTypeBool:
{
CSettingBool *settingBool = new CSettingBool(setting->GetId(), *static_cast<CSettingBool*>(setting));
settingBool->SetControl(GetCheckmarkControl());
settingCopy = static_cast<CSetting*>(settingBool);
break;
}
case SettingTypeInteger:
{
CSettingInt *intSetting = static_cast<CSettingInt*>(setting);
if (intSetting == NULL)
break;
CSettingInt *settingInt = new CSettingInt(setting->GetId(), *intSetting);
if (settingInt->GetOptions().empty())
settingInt->SetControl(GetSliderControl("integer", false, -1, usePopup, -1, "%i"));
else
settingInt->SetControl(GetSpinnerControl("string"));
settingCopy = static_cast<CSetting*>(settingInt);
break;
}
case SettingTypeNumber:
{
CSettingNumber *settingNumber = new CSettingNumber(setting->GetId(), *static_cast<CSettingNumber*>(setting));
settingNumber->SetControl(GetSliderControl("number", false, -1, usePopup, -1, "%2.2f"));
settingCopy = static_cast<CSetting*>(settingNumber);
break;
}
case SettingTypeString:
{
CSettingString *settingString = new CSettingString(setting->GetId(), *static_cast<CSettingString*>(setting));
settingString->SetControl(GetEditControl("string"));
settingCopy = static_cast<CSetting*>(settingString);
break;
}
default:
// TODO: add more types if needed
CLog::Log(LOGDEBUG, "%s - unknown type", __FUNCTION__);
break;
}
if (settingCopy != NULL && settingCopy->GetControl() != NULL)
{
settingCopy->SetLevel(SettingLevelBasic);
group->AddSetting(settingCopy);
m_settingsMap.insert(std::make_pair(setting->GetId(), setting));
}
}
m_initialising = false;
}
JSONRPC_STATUS CSettingsOperations::SetSettingValue(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
string settingId = parameterObject["setting"].asString();
CVariant value = parameterObject["value"];
CSetting* setting = CSettings::Get().GetSetting(settingId);
if (setting == NULL ||
!setting->IsVisible())
return InvalidParams;
switch (setting->GetType())
{
case SettingTypeBool:
if (!value.isBoolean())
return InvalidParams;
result = static_cast<CSettingBool*>(setting)->SetValue(value.asBoolean());
break;
case SettingTypeInteger:
if (!value.isInteger() && !value.isUnsignedInteger())
return InvalidParams;
result = static_cast<CSettingInt*>(setting)->SetValue((int)value.asInteger());
break;
case SettingTypeNumber:
if (!value.isDouble())
return InvalidParams;
result = static_cast<CSettingNumber*>(setting)->SetValue(value.asDouble());
break;
case SettingTypeString:
if (!value.isString())
return InvalidParams;
result = static_cast<CSettingString*>(setting)->SetValue(value.asString());
break;
case SettingTypeList:
{
if (!value.isArray())
return InvalidParams;
std::vector<CVariant> values;
for (CVariant::const_iterator_array itValue = value.begin_array(); itValue != value.end_array(); ++itValue)
values.push_back(*itValue);
result = CSettings::Get().SetList(settingId, values);
break;
}
case SettingTypeNone:
case SettingTypeAction:
default:
return InvalidParams;
}
return OK;
}