void CGUIWindowSettingsCategory::UpdateControl(const std::string &dependingSetting, const CSettingDependency &dependency)
{
if (dependingSetting.empty())
return;
BaseSettingControlPtr pControl = GetSettingControl(dependingSetting);
if (pControl == NULL)
return;
CSetting *pSetting = pControl->GetSetting();
if (pSetting == NULL)
return;
CheckDependency(pControl, dependency);
const SettingDependencyMap& deps = m_settings.GetDependencies(pSetting->GetId());
for (SettingDependencyMap::const_iterator depsIt = deps.begin(); depsIt != deps.end(); depsIt++)
{
for (SettingDependencies::const_iterator depIt = depsIt->second.begin(); depIt != depsIt->second.end(); depIt++)
UpdateControl(depsIt->first, *depIt);
}
// update GUI of the changed setting as the change could have been triggered by something else
pControl->Update();
}
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;
}
void CGUIWindowSettingsCategory::UpdateSettings()
{
for (vector<BaseSettingControlPtr>::iterator it = m_settingControls.begin(); it != m_settingControls.end(); it++)
{
BaseSettingControlPtr pSettingControl = *it;
CSetting *pSetting = pSettingControl->GetSetting();
CGUIControl *pControl = pSettingControl->GetControl();
if (pSetting == NULL || pControl == NULL)
continue;
// update the setting's control's state (enabled/disabled etc)
const SettingDependencies &deps = pSetting->GetDependencies();
for (SettingDependencies::const_iterator dep = deps.begin(); dep != deps.end(); dep++)
{
// don't check "update" dependencies here as all the controls are already
// setup properly based on the existing values
if (dep->GetType() == SettingDependencyTypeUpdate)
continue;
CheckDependency(pSettingControl, *dep);
}
pSettingControl->Update();
}
}
bool CSetting::IsEnabled() const
{
if (m_dependencies.empty() && m_parentSetting.empty())
return m_enabled;
// if the setting has a parent setting and that parent setting is disabled
// the setting should automatically also be disabled
if (!m_parentSetting.empty())
{
CSetting *parentSetting = m_settingsManager->GetSetting(m_parentSetting);
if (parentSetting != NULL && !parentSetting->IsEnabled())
return false;
}
bool enabled = true;
for (SettingDependencies::const_iterator depIt = m_dependencies.begin(); depIt != m_dependencies.end(); ++depIt)
{
if (depIt->GetType() != SettingDependencyTypeEnable)
continue;
if (!depIt->Check())
{
enabled = false;
break;
}
}
return enabled;
}
bool CSettingList::fromValues(const std::vector<std::string> &strValues, SettingPtrList &values) const
{
if ((int)strValues.size() < m_minimumItems ||
(m_maximumItems > 0 && (int)strValues.size() > m_maximumItems))
return false;
bool ret = true;
int index = 0;
for (std::vector<std::string>::const_iterator itValue = strValues.begin(); itValue != strValues.end(); ++itValue)
{
CSetting *settingValue = m_definition->Clone(StringUtils::Format("%s.%d", m_id.c_str(), index++));
if (settingValue == NULL ||
!settingValue->FromString(*itValue))
{
delete settingValue;
ret = false;
break;
}
values.push_back(SettingPtr(settingValue));
}
if (!ret)
values.clear();
return ret;
}
BOOL CRFIDprototypeApp::CheckGSM()
{
int nRate;
nRate = _ttoi(m_strRate);
while (!::OpenComm(m_strPort, nRate))
{
CString strError;
strError.Format(L"无法打开端口%s! 现在设置吗?", m_strPort);
if (AfxMessageBox(strError, MB_YESNO) == IDNO) return FALSE;
CSetting dlg;
dlg.m_strPort = m_strPort;
dlg.m_strRate = m_strRate;
dlg.m_strSmsc = m_strSmsc;
if (dlg.DoModal() == IDOK)
{
m_strPort = dlg.m_strPort;
m_strRate = dlg.m_strRate;
m_strSmsc = dlg.m_strSmsc;
}
else
{
return FALSE;
}
}
if (!gsmInit())
{
CString strError;
strError.Format(L"端口%s上没有发现MODEM!", m_strPort);
AfxMessageBox(strError, MB_OK);
CloseComm();
return FALSE;
}
if (m_strSmsc.IsEmpty())
{
AfxMessageBox(L"请设置SMSC!");
CSetting dlg;
dlg.m_strPort = m_strPort;
dlg.m_strRate = m_strRate;
dlg.m_strSmsc = m_strSmsc;
if (dlg.DoModal() == IDOK)
{
m_strPort = dlg.m_strPort;
m_strRate = dlg.m_strRate;
m_strSmsc = dlg.m_strSmsc;
}
else
{
CloseComm();
return FALSE;
}
}
return TRUE;
}
bool CGUIWindowSettingsCategory::OnAction(const CAction &action)
{
switch (action.GetID())
{
case ACTION_SETTINGS_RESET:
{
if (CGUIDialogYesNo::ShowAndGetInput(10041, 0, 10042, 0))
{
for(vector<BaseSettingControlPtr>::iterator it = m_settingControls.begin(); it != m_settingControls.end(); ++it)
{
CSetting *setting = (*it)->GetSetting();
if (setting != NULL)
setting->Reset();
}
}
return true;
}
case ACTION_SETTINGS_LEVEL_CHANGE:
{
//Test if we can access the new level
if (!g_passwordManager.CheckSettingLevelLock(CViewStateSettings::Get().GetNextSettingLevel(), true))
return false;
CViewStateSettings::Get().CycleSettingLevel();
CSettings::Get().Save();
// try to keep the current position
std::string oldCategory;
if (m_iCategory >= 0 && m_iCategory < (int)m_categories.size())
oldCategory = m_categories[m_iCategory]->GetId();
SET_CONTROL_LABEL(CONTRL_BTN_LEVELS, 10036 + (int)CViewStateSettings::Get().GetSettingLevel());
// only re-create the categories, the settings will be created later
SetupControls(false);
m_iCategory = 0;
// try to find the category that was previously selected
if (!oldCategory.empty())
{
for (int i = 0; i < (int)m_categories.size(); i++)
{
if (m_categories[i]->GetId() == oldCategory)
{
m_iCategory = i;
break;
}
}
}
CreateSettings();
return true;
}
default:
break;
}
return CGUIWindow::OnAction(action);
}
std::set<std::string> CGUIDialogSettingsBase::CreateSettings()
{
FreeSettingsControls();
std::set<std::string> settingMap;
if (m_categories.size() <= 0)
return settingMap;
if (m_iCategory < 0 || m_iCategory >= (int)m_categories.size())
m_iCategory = 0;
CGUIControlGroupList *group = dynamic_cast<CGUIControlGroupList *>(GetControl(SETTINGS_GROUP_ID));
if (group == NULL)
return settingMap;
const CSettingCategory* category = m_categories.at(m_iCategory);
if (category == NULL)
return settingMap;
// set the description of the current category
SetDescription(category->GetHelp());
const SettingGroupList& groups = category->GetGroups((SettingLevel)GetSettingLevel());
int iControlID = CONTROL_SETTINGS_START_CONTROL;
bool first = true;
for (SettingGroupList::const_iterator groupIt = groups.begin(); groupIt != groups.end(); groupIt++)
{
if (*groupIt == NULL)
continue;
const SettingList& settings = (*groupIt)->GetSettings((SettingLevel)GetSettingLevel());
if (settings.size() <= 0)
continue;
if (first)
first = false;
else
AddSeparator(group->GetWidth(), iControlID);
for (SettingList::const_iterator settingIt = settings.begin(); settingIt != settings.end(); settingIt++)
{
CSetting *pSetting = *settingIt;
settingMap.insert(pSetting->GetId());
AddSetting(pSetting, group->GetWidth(), iControlID);
}
}
if (AllowResettingSettings() && !settingMap.empty())
{
// add "Reset" control
AddSeparator(group->GetWidth(), iControlID);
AddSetting(m_resetSetting, group->GetWidth(), iControlID);
}
// update our settings (turns controls on/off as appropriate)
UpdateSettings();
return settingMap;
}
// 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);
}
}
}
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);
}
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;
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);
}
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();
}
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();
}
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::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::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());
}
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);
}
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::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::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());
}
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 CSettingGroup::Deserialize(const TiXmlNode *node, bool update /* = false */)
{
// handle <visible> conditions
if (!ISetting::Deserialize(node, update))
return false;
const TiXmlElement *settingElement = node->FirstChildElement(XML_SETTING);
while (settingElement != NULL)
{
std::string settingId;
if (CSettingCategory::DeserializeIdentification(settingElement, settingId))
{
CSetting *setting = NULL;
for (SettingList::iterator itSetting = m_settings.begin(); itSetting != m_settings.end(); itSetting++)
{
if ((*itSetting)->GetId() == settingId)
{
setting = *itSetting;
break;
}
}
update = (setting != NULL);
if (!update)
{
const char* settingType = settingElement->Attribute(XML_ATTR_TYPE);
if (settingType == NULL || strlen(settingType) <= 0)
{
CLog::Log(LOGERROR, "CSettingGroup: unable to read setting type of \"%s\"", settingId.c_str());
return false;
}
setting = m_settingsManager->CreateSetting(settingType, settingId, m_settingsManager);
if (setting == NULL)
CLog::Log(LOGERROR, "CSettingGroup: unknown setting type \"%s\" of \"%s\"", settingType, settingId.c_str());
}
if (setting == NULL)
CLog::Log(LOGERROR, "CSettingGroup: unable to create new setting \"%s\"", settingId.c_str());
else if (!setting->Deserialize(settingElement, update))
{
CLog::Log(LOGWARNING, "CSettingGroup: unable to read setting \"%s\"", settingId.c_str());
if (!update)
delete setting;
}
else if (!update)
addISetting(settingElement, setting, m_settings);
}
settingElement = settingElement->NextSiblingElement(XML_SETTING);
}
return true;
}
void CGUIWindowSettingsCategory::CreateSettings()
{
FreeSettingsControls();
if (m_categories.size() <= 0)
return;
if (m_iCategory < 0 || m_iCategory >= (int)m_categories.size())
m_iCategory = 0;
CGUIControlGroupList *group = (CGUIControlGroupList *)GetControl(SETTINGS_GROUP_ID);
if (group == NULL)
return;
const CSettingCategory* category = m_categories.at(m_iCategory);
if (category == NULL)
return;
// set the description of the current category
SetDescription(category->GetHelp());
std::set<std::string> settingMap;
const SettingGroupList& groups = category->GetGroups(CViewStateSettings::Get().GetSettingLevel());
int iControlID = CONTROL_START_CONTROL;
bool first = true;
for (SettingGroupList::const_iterator groupIt = groups.begin(); groupIt != groups.end(); groupIt++)
{
if (*groupIt == NULL)
continue;
const SettingList& settings = (*groupIt)->GetSettings(CViewStateSettings::Get().GetSettingLevel());
if (settings.size() <= 0)
continue;
if (first)
first = false;
else
AddSeparator(group->GetWidth(), iControlID);
for (SettingList::const_iterator settingIt = settings.begin(); settingIt != settings.end(); settingIt++)
{
CSetting *pSetting = *settingIt;
settingMap.insert(pSetting->GetId());
AddSetting(pSetting, group->GetWidth(), iControlID);
}
}
if (settingMap.size() > 0)
m_settings.RegisterCallback(this, settingMap);
// update our settings (turns controls on/off as appropriate)
UpdateSettings();
}
void CGUIDialogSettingsBase::OnResetSettings()
{
if (CGUIDialogYesNo::ShowAndGetInput(CVariant{10041}, CVariant{10042}))
{
for(std::vector<BaseSettingControlPtr>::iterator it = m_settingControls.begin(); it != m_settingControls.end(); ++it)
{
CSetting *setting = (*it)->GetSetting();
if (setting != NULL)
setting->Reset();
}
}
}
void CGUIDialogSettingsBase::OnResetSettings()
{
if (CGUIDialogYesNo::ShowAndGetInput(10041, 0, 10042, 0))
{
for(vector<BaseSettingControlPtr>::iterator it = m_settingControls.begin(); it != m_settingControls.end(); it++)
{
CSetting *setting = (*it)->GetSetting();
if (setting != NULL)
setting->Reset();
}
}
}
void CPeripherals::GetSettingsFromMappingsFile(TiXmlElement *xmlNode, map<CStdString, CSetting *> &m_settings)
{
TiXmlElement *currentNode = xmlNode->FirstChildElement("setting");
while (currentNode)
{
CSetting *setting = NULL;
CStdString strKey(currentNode->Attribute("key"));
if (strKey.IsEmpty())
continue;
CStdString strSettingsType(currentNode->Attribute("type"));
int iLabelId = currentNode->Attribute("label") ? atoi(currentNode->Attribute("label")) : -1;
bool bConfigurable = (!currentNode->Attribute("configurable") ||
strcmp(currentNode->Attribute("configurable"), "") == 0 ||
(strcmp(currentNode->Attribute("configurable"), "no") != 0 &&
strcmp(currentNode->Attribute("configurable"), "false") != 0 &&
strcmp(currentNode->Attribute("configurable"), "0") != 0));
if (strSettingsType.Equals("bool"))
{
bool bValue = (strcmp(currentNode->Attribute("value"), "no") != 0 &&
strcmp(currentNode->Attribute("value"), "false") != 0 &&
strcmp(currentNode->Attribute("value"), "0") != 0);
setting = new CSettingBool(0, strKey, iLabelId, bValue, CHECKMARK_CONTROL);
}
else if (strSettingsType.Equals("int"))
{
int iValue = currentNode->Attribute("value") ? atoi(currentNode->Attribute("value")) : 0;
int iMin = currentNode->Attribute("min") ? atoi(currentNode->Attribute("min")) : 0;
int iStep = currentNode->Attribute("step") ? atoi(currentNode->Attribute("step")) : 1;
int iMax = currentNode->Attribute("max") ? atoi(currentNode->Attribute("max")) : 255;
CStdString strFormat(currentNode->Attribute("format"));
setting = new CSettingInt(0, strKey, iLabelId, iValue, iMin, iStep, iMax, SPIN_CONTROL_INT, strFormat);
}
else if (strSettingsType.Equals("float"))
{
float fValue = currentNode->Attribute("value") ? (float) atof(currentNode->Attribute("value")) : 0;
float fMin = currentNode->Attribute("min") ? (float) atof(currentNode->Attribute("min")) : 0;
float fStep = currentNode->Attribute("step") ? (float) atof(currentNode->Attribute("step")) : 0;
float fMax = currentNode->Attribute("max") ? (float) atof(currentNode->Attribute("max")) : 0;
setting = new CSettingFloat(0, strKey, iLabelId, fValue, fMin, fStep, fMax, SPIN_CONTROL_FLOAT);
}
else
{
CStdString strValue(currentNode->Attribute("value"));
setting = new CSettingString(0, strKey, iLabelId, strValue, EDIT_CONTROL_INPUT, !bConfigurable, -1);
}
//TODO add more types if needed
setting->SetVisible(bConfigurable);
m_settings[strKey] = setting;
currentNode = currentNode->NextSiblingElement("setting");
}
}
void CSetting::Copy(const CSetting &setting)
{
SetVisible(setting.IsVisible());
SetRequirementsMet(setting.MeetsRequirements());
m_callback = setting.m_callback;
m_label = setting.m_label;
m_help = setting.m_help;
m_level = setting.m_level;
m_control = setting.m_control;
m_dependencies = setting.m_dependencies;
m_updates = setting.m_updates;
m_changed = setting.m_changed;
}
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);
}