void CGUIWindowAddonBrowser::UpdateButtons()
{
const CGUIControl *control = GetControl(CONTROL_AUTOUPDATE);
if (control && control->GetControlType() == CGUIControl::GUICONTROL_BUTTON)
{ // set label
CSettingInt *setting = (CSettingInt *)CSettings::Get().GetSetting("general.addonupdates");
if (setting)
{
const StaticIntegerSettingOptions& options = setting->GetOptions();
for (StaticIntegerSettingOptions::const_iterator it = options.begin(); it != options.end(); ++it)
{
if (it->second == setting->GetValue())
{
SET_CONTROL_LABEL(CONTROL_AUTOUPDATE, it->first);
break;
}
}
}
}
else
{ // old skin with toggle button - set on if auto updates are on
SET_CONTROL_SELECTED(GetID(),CONTROL_AUTOUPDATE, CSettings::Get().GetInt("general.addonupdates") == AUTO_UPDATES_ON);
}
SET_CONTROL_SELECTED(GetID(),CONTROL_SHUTUP, CSettings::Get().GetBool("general.addonnotifications"));
SET_CONTROL_SELECTED(GetID(),CONTROL_FOREIGNFILTER, CSettings::Get().GetBool("general.addonforeignfilter"));
SET_CONTROL_SELECTED(GetID(),CONTROL_BROKENFILTER, CSettings::Get().GetBool("general.addonbrokenfilter"));
CONTROL_ENABLE(CONTROL_CHECK_FOR_UPDATES);
bool allowFilter = CAddonsDirectory::IsRepoDirectory(CURL(m_vecItems->GetPath()));
CONTROL_ENABLE_ON_CONDITION(CONTROL_FOREIGNFILTER, allowFilter);
CONTROL_ENABLE_ON_CONDITION(CONTROL_BROKENFILTER, allowFilter);
CGUIMediaWindow::UpdateButtons();
}
CSetting* CGUIDialogPVRTimerSettings::AddChannelNames(CSettingGroup *group, bool bRadio)
{
std::vector< std::pair<std::string, int> > options;
getChannelNames(bRadio, options, m_selectedChannelEntry, true);
int timerChannelID;
if (m_timerItem->GetPVRTimerInfoTag()->ChannelTag())
timerChannelID = m_timerItem->GetPVRTimerInfoTag()->ChannelTag()->ChannelID();
else
timerChannelID = PVR_VIRTUAL_CHANNEL_UID;
for (std::vector< std::pair<std::string, int> >::const_iterator option = options.begin(); option != options.end(); ++option)
{
std::map<std::pair<bool, int>, int>::const_iterator channelEntry = m_channelEntries.find(std::make_pair(bRadio, option->second));
if (channelEntry != m_channelEntries.end() && channelEntry->second == timerChannelID)
{
m_selectedChannelEntry = option->second;
break;
}
}
CSettingInt *setting = AddSpinner(group, bRadio ? SETTING_TMR_CHNAME_RADIO : SETTING_TMR_CHNAME_TV, 19078, 0, m_selectedChannelEntry, ChannelNamesOptionsFiller);
if (setting == NULL)
return NULL;
// define an enable dependency with tag->m_bIsRadio
CSettingDependency depdendencyIsRadio(SettingDependencyTypeEnable, m_settingsManager);
depdendencyIsRadio.And()
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition(SETTING_TMR_RADIO, "true", SettingDependencyOperatorEquals, !bRadio, m_settingsManager)));
SettingDependencies deps;
deps.push_back(depdendencyIsRadio);
setting->SetDependencies(deps);
return setting;
}
void CPeripheral::PersistSettings(bool bExiting /* = false */)
{
CXBMCTinyXML doc;
TiXmlElement node("settings");
doc.InsertEndChild(node);
for (map<CStdString, CSetting *>::const_iterator itr = m_settings.begin(); itr != m_settings.end(); itr++)
{
TiXmlElement nodeSetting("setting");
nodeSetting.SetAttribute("id", itr->first.c_str());
CStdString strValue;
switch ((*itr).second->GetType())
{
case SettingTypeString:
{
CSettingString *stringSetting = (CSettingString *) (*itr).second;
if (stringSetting)
strValue = stringSetting->GetValue();
}
break;
case SettingTypeInteger:
{
CSettingInt *intSetting = (CSettingInt *) (*itr).second;
if (intSetting)
strValue = StringUtils::Format("%d", intSetting->GetValue());
}
break;
case SettingTypeNumber:
{
CSettingNumber *floatSetting = (CSettingNumber *) (*itr).second;
if (floatSetting)
strValue = StringUtils::Format("%.2f", floatSetting->GetValue());
}
break;
case SettingTypeBool:
{
CSettingBool *boolSetting = (CSettingBool *) (*itr).second;
if (boolSetting)
strValue = StringUtils::Format("%d", boolSetting->GetValue() ? 1:0);
}
break;
default:
break;
}
nodeSetting.SetAttribute("value", strValue.c_str());
doc.RootElement()->InsertEndChild(nodeSetting);
}
doc.SaveFile(m_strSettingsFile);
if (!bExiting)
{
for (set<CStdString>::const_iterator it = m_changedSettings.begin(); it != m_changedSettings.end(); it++)
OnSettingChanged(*it);
}
m_changedSettings.clear();
}
void CGUIWindowSettingsCategory::FillControl(CSetting *pSetting, CGUIControl *pSettingControl)
{
void *filler = CSettings::Get().GetSettingOptionsFiller(pSetting);
if (filler == NULL)
return;
if (pSetting->GetType() == SettingTypeInteger)
{
CSettingInt *pSettingInt = (CSettingInt*)pSetting;
// get the list of options and the current option
IntegerSettingOptions options;
int currentOption = pSettingInt->GetValue();
((IntegerSettingOptionsFiller)filler)(pSetting, options, currentOption);
// clear the spinner control
CGUISpinControlEx *pSpinControl = (CGUISpinControlEx *)pSettingControl;
pSpinControl->Clear();
// fill the spinner control
for (IntegerSettingOptions::const_iterator option = options.begin(); option != options.end(); option++)
pSpinControl->AddLabel(option->first, option->second);
// set the current option
pSpinControl->SetValue(currentOption);
// check if the current setting has changed
if (currentOption != pSettingInt->GetValue())
pSettingInt->SetValue(currentOption);
}
else if (pSetting->GetType() == SettingTypeString)
{
CSettingString *pSettingString = (CSettingString*)pSetting;
// get the list of options and the current option
StringSettingOptions options;
std::string currentOption = pSettingString->GetValue();
((StringSettingOptionsFiller)filler)(pSetting, options, currentOption);
// clear the spinner control
CGUISpinControlEx *pSpinControl = (CGUISpinControlEx *)pSettingControl;
pSpinControl->Clear();
// fill the spinner control
for (StringSettingOptions::const_iterator option = options.begin(); option != options.end(); option++)
pSpinControl->AddLabel(option->first, option->second);
// set the current option
pSpinControl->SetStringValue(currentOption);
// check if the current setting has changed
if (currentOption.compare(pSettingString->GetValue()) != 0)
pSettingString->SetValue(currentOption);
}
}
int CPeripheral::GetSettingInt(const std::string &strKey) const
{
std::map<std::string, PeripheralDeviceSetting>::const_iterator it = m_settings.find(strKey);
if (it != m_settings.end() && (*it).second.m_setting->GetType() == SettingTypeInteger)
{
CSettingInt *intSetting = (CSettingInt *) (*it).second.m_setting;
if (intSetting)
return intSetting->GetValue();
}
return 0;
}
int CPeripheral::GetSettingInt(const CStdString &strKey) const
{
map<CStdString, CSetting *>::const_iterator it = m_settings.find(strKey);
if (it != m_settings.end() && (*it).second->GetType() == SettingTypeInteger)
{
CSettingInt *intSetting = (CSettingInt *) (*it).second;
if (intSetting)
return intSetting->GetValue();
}
return 0;
}
void CGUIControlSpinExSetting::FillIntegerSettingControl()
{
CSettingInt *pSettingInt = (CSettingInt *)m_pSetting;
switch (pSettingInt->GetOptionsType())
{
case SettingOptionsTypeStatic:
{
const StaticIntegerSettingOptions& options = pSettingInt->GetOptions();
for (StaticIntegerSettingOptions::const_iterator it = options.begin(); it != options.end(); ++it)
m_pSpin->AddLabel(g_localizeStrings.Get(it->first), it->second);
break;
}
case SettingOptionsTypeDynamic:
{
DynamicIntegerSettingOptions options = pSettingInt->UpdateDynamicOptions();
for (DynamicIntegerSettingOptions::const_iterator option = options.begin(); option != options.end(); ++option)
m_pSpin->AddLabel(option->first, option->second);
break;
}
case SettingOptionsTypeNone:
default:
{
std::string strLabel;
int i = pSettingInt->GetMinimum();
const CSettingControlSpinner *control = static_cast<const CSettingControlSpinner*>(pSettingInt->GetControl());
if (control->GetMinimumLabel() > -1)
{
strLabel = g_localizeStrings.Get(control->GetMinimumLabel());
m_pSpin->AddLabel(strLabel, pSettingInt->GetMinimum());
i += pSettingInt->GetStep();
}
for (; i <= pSettingInt->GetMaximum(); i += pSettingInt->GetStep())
{
if (control->GetFormatLabel() > -1)
strLabel = StringUtils::Format(g_localizeStrings.Get(control->GetFormatLabel()).c_str(), i);
else
strLabel = StringUtils::Format(control->GetFormatString().c_str(), i);
m_pSpin->AddLabel(strLabel, i);
}
break;
}
}
m_pSpin->SetValue(pSettingInt->GetValue());
}
void CPeripheral::PersistSettings(void) const
{
TiXmlDocument doc;
TiXmlElement node("settings");
doc.InsertEndChild(node);
for (map<CStdString, CSetting *>::const_iterator itr = m_settings.begin(); itr != m_settings.end(); itr++)
{
TiXmlElement nodeSetting("setting");
nodeSetting.SetAttribute("id", itr->first.c_str());
CStdString strValue;
switch ((*itr).second->GetType())
{
case SETTINGS_TYPE_STRING:
{
CSettingString *stringSetting = (CSettingString *) (*itr).second;
if (stringSetting)
strValue = stringSetting->GetData();
}
break;
case SETTINGS_TYPE_INT:
{
CSettingInt *intSetting = (CSettingInt *) (*itr).second;
if (intSetting)
strValue.Format("%d", intSetting->GetData());
}
break;
case SETTINGS_TYPE_FLOAT:
{
CSettingFloat *floatSetting = (CSettingFloat *) (*itr).second;
if (floatSetting)
strValue.Format("%.2f", floatSetting->GetData());
}
break;
case SETTINGS_TYPE_BOOL:
{
CSettingBool *boolSetting = (CSettingBool *) (*itr).second;
if (boolSetting)
strValue.Format("%d", boolSetting->GetData() ? 1:0);
}
break;
default:
break;
}
nodeSetting.SetAttribute("value", strValue.c_str());
doc.RootElement()->InsertEndChild(nodeSetting);
}
doc.SaveFile(m_strSettingsFile);
}
void CPeripheral::SetSetting(const CStdString &strKey, int iValue)
{
map<CStdString, CSetting *>::iterator it = m_settings.find(strKey);
if (it != m_settings.end() && (*it).second->GetType() == SETTINGS_TYPE_INT)
{
CSettingInt *intSetting = (CSettingInt *) (*it).second;
if (intSetting)
{
bool bChanged(intSetting->GetData() != iValue);
intSetting->SetData(iValue);
if (bChanged && m_bInitialised)
OnSettingChanged(strKey);
}
}
}
void CGUISpinExSettingControl::Update()
{
if (!m_pSpin)
return;
if (m_pSetting->GetControlType() == SPIN_CONTROL_FLOAT)
{
CSettingFloat *pSettingFloat = (CSettingFloat *)m_pSetting;
m_pSpin->SetFloatValue(pSettingFloat->GetData());
}
else if (m_pSetting->GetControlType() == SPIN_CONTROL_INT_PLUS || m_pSetting->GetControlType() == SPIN_CONTROL_INT)
{
CSettingInt *pSettingInt = (CSettingInt *)m_pSetting;
m_pSpin->SetValue(pSettingInt->GetData());
}
}
bool CGUISpinExSettingControl::OnClick()
{
// TODO: Should really check for a change here (as end of spincontrols may
// cause no change)
if (m_pSetting->GetControlType() == SPIN_CONTROL_FLOAT)
((CSettingFloat *)m_pSetting)->SetData(m_pSpin->GetFloatValue());
else
{
if (m_pSetting->GetType() == SETTINGS_TYPE_INT)
{
CSettingInt *pSettingInt = (CSettingInt *)m_pSetting;
pSettingInt->SetData(m_pSpin->GetValue());
}
}
return true;
}
bool CPeripheral::SetSetting(const CStdString &strKey, int iValue)
{
bool bChanged(false);
map<CStdString, CSetting *>::iterator it = m_settings.find(strKey);
if (it != m_settings.end() && (*it).second->GetType() == SettingTypeInteger)
{
CSettingInt *intSetting = (CSettingInt *) (*it).second;
if (intSetting)
{
bChanged = intSetting->GetValue() != iValue;
intSetting->SetValue(iValue);
if (bChanged && m_bInitialised)
m_changedSettings.insert(strKey);
}
}
return bChanged;
}
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;
}
}
CSettingList* CGUIDialogSettingsManualBase::AddRange(CSettingGroup *group, const std::string &id, int label, int level, int valueLower, int valueUpper, int minimum,
int step, int maximum, const std::string &format, int formatLabel, int valueFormatLabel,
const std::string &valueFormatString, bool delayed, bool visible, int help)
{
if (group == NULL || id.empty() || label < 0 ||
GetSetting(id) != NULL)
return NULL;
CSettingInt *settingDefinition = new CSettingInt(id, m_settingsManager);
if (settingDefinition == NULL)
return NULL;
settingDefinition->SetMinimum(minimum);
settingDefinition->SetStep(step);
settingDefinition->SetMaximum(maximum);
CSettingList *setting = new CSettingList(id, settingDefinition, label, m_settingsManager);
if (setting == NULL)
{
delete settingDefinition;
return NULL;
}
std::vector<CVariant> valueList;
valueList.push_back(valueLower);
valueList.push_back(valueUpper);
SettingPtrList settingValues;
if (!CSettingUtils::ValuesToList(setting, valueList, settingValues))
{
delete settingDefinition;
delete setting;
return NULL;
}
// setting the default will also set the actual value on an unchanged setting
setting->SetDefault(settingValues);
setting->SetControl(GetRangeControl(format, delayed, formatLabel, valueFormatLabel, valueFormatString));
setting->SetMinimumItems(2);
setting->SetMaximumItems(2);
setSettingDetails(setting, level, visible, help);
group->AddSetting(setting);
return setting;
}
CSettingInt* CGUIDialogSettingsManualBase::AddEdit(CSettingGroup *group, const std::string &id, int label, int level, int value,
int minimum /* = 0 */, int step /* = 1 */, int maximum /* = 0 */, bool verifyNewValue /* = false */,
int heading /* = -1 */, bool delayed /* = false */, bool visible /* = true */, int help /* = -1 */)
{
if (group == NULL || id.empty() || label < 0 ||
GetSetting(id) != NULL)
return NULL;
CSettingInt *setting = new CSettingInt(id, label, value, minimum, step, maximum, m_settingsManager);
if (setting == NULL)
return NULL;
setting->SetControl(GetEditControl("integer", delayed, false, verifyNewValue, heading));
setSettingDetails(setting, level, visible, help);
group->AddSetting(setting);
return setting;
}
CSettingInt* CGUIDialogSettingsManualBase::AddSpinner(CSettingGroup *group, const std::string &id, int label, int level, int value, const StaticIntegerSettingOptions &entries,
bool delayed /* = false */, bool visible /* = true */, int help /* = -1 */)
{
if (group == NULL || id.empty() || label < 0 || entries.empty() ||
GetSetting(id) != NULL)
return NULL;
CSettingInt *setting = new CSettingInt(id, label, value, m_settingsManager);
if (setting == NULL)
return NULL;
setting->SetControl(GetSpinnerControl("string", delayed));
setting->SetOptions(entries);
setSettingDetails(setting, level, visible, help);
group->AddSetting(setting);
return setting;
}
CSettingInt* CGUIDialogSettingsManualBase::AddList(CSettingGroup *group, const std::string &id, int label, int level, int value, IntegerSettingOptionsFiller filler,
int heading, bool visible /* = true */, int help /* = -1 */)
{
if (group == NULL || id.empty() || label < 0 || filler == NULL ||
GetSetting(id) != NULL)
return NULL;
CSettingInt *setting = new CSettingInt(id, label, value, m_settingsManager);
if (setting == NULL)
return NULL;
setting->SetControl(GetListControl("integer", false, heading, false));
setting->SetOptionsFiller(filler, this);
setSettingDetails(setting, level, visible, help);
group->AddSetting(setting);
return setting;
}
CSettingList* CGUIDialogSettingsManualBase::AddList(CSettingGroup *group, const std::string &id, int label, int level, std::vector<int> values,
IntegerSettingOptionsFiller filler, int heading, int minimumItems /* = 0 */, int maximumItems /* = -1 */,
bool visible /* = true */, int help /* = -1 */)
{
if (group == NULL || id.empty() || label < 0 || filler == NULL ||
GetSetting(id) != NULL)
return NULL;
CSettingInt *settingDefinition = new CSettingInt(id, m_settingsManager);
if (settingDefinition == NULL)
return NULL;
settingDefinition->SetOptionsFiller(filler, this);
CSettingList *setting = new CSettingList(id, settingDefinition, label, m_settingsManager);
if (setting == NULL)
{
delete settingDefinition;
return NULL;
}
std::vector<CVariant> valueList;
for (std::vector<int>::const_iterator itValue = values.begin(); itValue != values.end(); ++itValue)
valueList.push_back(CVariant(*itValue));
SettingPtrList settingValues;
if (!CSettingUtils::ValuesToList(setting, valueList, settingValues))
{
delete settingDefinition;
delete setting;
return NULL;
}
// setting the default will also set the actual value on an unchanged setting
setting->SetDefault(settingValues);
setting->SetControl(GetListControl("integer", false, heading, true));
setting->SetMinimumItems(minimumItems);
setting->SetMaximumItems(maximumItems);
setSettingDetails(setting, level, visible, help);
group->AddSetting(setting);
return setting;
}
CSettingInt* CGUIDialogSettingsManualBase::AddSlider(CSettingGroup *group, const std::string &id, int label, int level, int value, const std::string &formatString,
int minimum, int step, int maximum, int heading /* = -1 */, bool usePopup /* = false */, bool delayed /* = false */,
bool visible /* = true */, int help /* = -1 */)
{
if (group == NULL || id.empty() || label < 0 ||
GetSetting(id) != NULL)
return NULL;
CSettingInt *setting = new CSettingInt(id, label, value, m_settingsManager);
if (setting == NULL)
return NULL;
setting->SetControl(GetSliderControl("integer", delayed, heading, usePopup, -1, formatString));
setting->SetMinimum(minimum);
setting->SetStep(step);
setting->SetMaximum(maximum);
setSettingDetails(setting, level, visible, help);
group->AddSetting(setting);
return setting;
}
CGUIControlSliderSetting::CGUIControlSliderSetting(CGUISettingsSliderControl *pSlider, int id, CSetting *pSetting)
: CGUIControlBaseSetting(id, pSetting)
{
m_pSlider = pSlider;
if (m_pSlider == NULL)
return;
m_pSlider->SetID(id);
switch (m_pSetting->GetType())
{
case SettingTypeInteger:
{
CSettingInt *settingInt = static_cast<CSettingInt*>(m_pSetting);
if (m_pSetting->GetControl()->GetFormat() == "percentage")
m_pSlider->SetType(SLIDER_CONTROL_TYPE_PERCENTAGE);
else
{
m_pSlider->SetType(SLIDER_CONTROL_TYPE_INT);
m_pSlider->SetRange(settingInt->GetMinimum(), settingInt->GetMaximum());
}
m_pSlider->SetIntInterval(settingInt->GetStep());
break;
}
case SettingTypeNumber:
{
CSettingNumber *settingNumber = static_cast<CSettingNumber*>(m_pSetting);
m_pSlider->SetType(SLIDER_CONTROL_TYPE_FLOAT);
m_pSlider->SetFloatRange((float)settingNumber->GetMinimum(), (float)settingNumber->GetMaximum());
m_pSlider->SetFloatInterval((float)settingNumber->GetStep());
break;
}
default:
break;
}
Update();
}
bool CDisplaySettings::OnSettingUpdate(CSetting* &setting, const char *oldSettingId, const TiXmlNode *oldSettingNode)
{
if (setting == NULL)
return false;
const std::string &settingId = setting->GetId();
if (settingId == CSettings::SETTING_VIDEOSCREEN_SCREENMODE)
{
CSettingString *screenmodeSetting = (CSettingString*)setting;
std::string screenmode = screenmodeSetting->GetValue();
// in Eden there was no character ("i" or "p") indicating interlaced/progressive
// at the end so we just add a "p" and assume progressive
// no 3d mode existed before, so just assume std modes
if (screenmode.size() == 20)
return screenmodeSetting->SetValue(screenmode + "pstd");
if (screenmode.size() == 21)
return screenmodeSetting->SetValue(screenmode + "std");
}
else if (settingId == CSettings::SETTING_VIDEOSCREEN_VSYNC)
{
// This ifdef is intended to catch everything except Linux and FreeBSD
#if !defined(TARGET_LINUX) || defined(TARGET_DARWIN) || defined(TARGET_ANDROID) || defined(TARGET_RASPBERRY_PI)
// in the Gotham alphas through beta3 the default value for darwin and android was set incorrectly.
CSettingInt *vsyncSetting = (CSettingInt*)setting;
if (vsyncSetting->GetValue() == VSYNC_DRIVER)
return vsyncSetting->SetValue(VSYNC_ALWAYS);
#endif
}
else if (settingId == CSettings::SETTING_VIDEOSCREEN_PREFEREDSTEREOSCOPICMODE)
{
CSettingInt *stereomodeSetting = (CSettingInt*)setting;
STEREOSCOPIC_PLAYBACK_MODE playbackMode = (STEREOSCOPIC_PLAYBACK_MODE) CSettings::Get().GetInt(CSettings::SETTING_VIDEOPLAYER_STEREOSCOPICPLAYBACKMODE);
if (stereomodeSetting->GetValue() == RENDER_STEREO_MODE_OFF)
{
// if preferred playback mode was OFF, update playback mode to ignore
if (playbackMode == STEREOSCOPIC_PLAYBACK_MODE_PREFERRED)
CSettings::Get().SetInt(CSettings::SETTING_VIDEOPLAYER_STEREOSCOPICPLAYBACKMODE, STEREOSCOPIC_PLAYBACK_MODE_IGNORE);
return stereomodeSetting->SetValue(RENDER_STEREO_MODE_AUTO);
}
else if (stereomodeSetting->GetValue() == RENDER_STEREO_MODE_MONO)
{
// if preferred playback mode was MONO, update playback mode
if (playbackMode == STEREOSCOPIC_PLAYBACK_MODE_PREFERRED)
CSettings::Get().SetInt(CSettings::SETTING_VIDEOPLAYER_STEREOSCOPICPLAYBACKMODE, STEREOSCOPIC_PLAYBACK_MODE_MONO);
return stereomodeSetting->SetValue(RENDER_STEREO_MODE_AUTO);
}
}
return false;
}
void CGUIControlButtonSetting::OnSliderChange(void *data, CGUISliderControl *slider)
{
if (slider == NULL)
return;
std::string strText;
switch (m_pSetting->GetType())
{
case SettingTypeInteger:
{
CSettingInt *settingInt = static_cast<CSettingInt*>(m_pSetting);
if (settingInt->SetValue(slider->GetIntValue()))
strText = CGUIControlSliderSetting::GetText(static_cast<const CSettingControlSlider*>(m_pSetting->GetControl()),
settingInt->GetValue(), settingInt->GetMinimum(), settingInt->GetStep(), settingInt->GetMaximum());
break;
}
case SettingTypeNumber:
{
CSettingNumber *settingNumber = static_cast<CSettingNumber*>(m_pSetting);
if (settingNumber->SetValue(static_cast<double>(slider->GetFloatValue())))
strText = CGUIControlSliderSetting::GetText(static_cast<const CSettingControlSlider*>(m_pSetting->GetControl()),
settingNumber->GetValue(), settingNumber->GetMinimum(), settingNumber->GetStep(), settingNumber->GetMaximum());
break;
}
default:
break;
}
if (!strText.empty())
slider->SetTextValue(strText);
}
bool CDisplaySettings::OnSettingUpdate(CSetting* &setting, const char *oldSettingId, const TiXmlNode *oldSettingNode)
{
if (setting == NULL)
return false;
const std::string &settingId = setting->GetId();
if (settingId == CSettings::SETTING_VIDEOSCREEN_SCREENMODE)
{
CSettingString *screenmodeSetting = (CSettingString*)setting;
std::string screenmode = screenmodeSetting->GetValue();
// in Eden there was no character ("i" or "p") indicating interlaced/progressive
// at the end so we just add a "p" and assume progressive
// no 3d mode existed before, so just assume std modes
if (screenmode.size() == 20)
return screenmodeSetting->SetValue(screenmode + "pstd");
if (screenmode.size() == 21)
return screenmodeSetting->SetValue(screenmode + "std");
}
else if (settingId == CSettings::SETTING_VIDEOSCREEN_PREFEREDSTEREOSCOPICMODE)
{
CSettingInt *stereomodeSetting = (CSettingInt*)setting;
STEREOSCOPIC_PLAYBACK_MODE playbackMode = (STEREOSCOPIC_PLAYBACK_MODE) CSettings::GetInstance().GetInt(CSettings::SETTING_VIDEOPLAYER_STEREOSCOPICPLAYBACKMODE);
if (stereomodeSetting->GetValue() == RENDER_STEREO_MODE_OFF)
{
// if preferred playback mode was OFF, update playback mode to ignore
if (playbackMode == STEREOSCOPIC_PLAYBACK_MODE_PREFERRED)
CSettings::GetInstance().SetInt(CSettings::SETTING_VIDEOPLAYER_STEREOSCOPICPLAYBACKMODE, STEREOSCOPIC_PLAYBACK_MODE_IGNORE);
return stereomodeSetting->SetValue(RENDER_STEREO_MODE_AUTO);
}
else if (stereomodeSetting->GetValue() == RENDER_STEREO_MODE_MONO)
{
// if preferred playback mode was MONO, update playback mode
if (playbackMode == STEREOSCOPIC_PLAYBACK_MODE_PREFERRED)
CSettings::GetInstance().SetInt(CSettings::SETTING_VIDEOPLAYER_STEREOSCOPICPLAYBACKMODE, STEREOSCOPIC_PLAYBACK_MODE_MONO);
return stereomodeSetting->SetValue(RENDER_STEREO_MODE_AUTO);
}
}
return false;
}
bool CGUIControlListSetting::GetIntegerItems(CSetting *setting, CFileItemList &items)
{
CSettingInt *pSettingInt = (CSettingInt *)setting;
switch (pSettingInt->GetOptionsType())
{
case SettingOptionsTypeStatic:
{
const StaticIntegerSettingOptions& options = pSettingInt->GetOptions();
for (StaticIntegerSettingOptions::const_iterator it = options.begin(); it != options.end(); ++it)
{
CFileItemPtr pItem = GetItem(g_localizeStrings.Get(it->first), it->second);
if (it->second == pSettingInt->GetValue())
pItem->Select(true);
items.Add(pItem);
}
break;
}
case SettingOptionsTypeDynamic:
{
DynamicIntegerSettingOptions options = pSettingInt->UpdateDynamicOptions();
for (DynamicIntegerSettingOptions::const_iterator option = options.begin(); option != options.end(); ++option)
{
CFileItemPtr pItem = GetItem(option->first, option->second);
if (option->second == pSettingInt->GetValue())
pItem->Select(true);
items.Add(pItem);
}
break;
}
case SettingOptionsTypeNone:
default:
return false;
}
return true;
}
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;
}
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;
}
bool CGUIControlButtonSetting::OnClick()
{
if (m_pButton == NULL)
return false;
const ISettingControl *control = m_pSetting->GetControl();
const std::string &controlType = control->GetType();
const std::string &controlFormat = control->GetFormat();
if (controlType == "button")
{
const CSettingControlButton *buttonControl = static_cast<const CSettingControlButton*>(control);
if (controlFormat == "addon")
{
// prompt for the addon
CSettingAddon *setting = (CSettingAddon *)m_pSetting;
std::string addonID = setting->GetValue();
if (CGUIWindowAddonBrowser::SelectAddonID(setting->GetAddonType(), addonID, setting->AllowEmpty(),
buttonControl->ShowAddonDetails(), buttonControl->ShowInstalledAddons(),
buttonControl->ShowInstallableAddons(), buttonControl->ShowMoreAddons()) != 1)
return false;
SetValid(setting->SetValue(addonID));
}
else if (controlFormat == "path")
SetValid(GetPath((CSettingPath *)m_pSetting));
else if (controlFormat == "action")
{
// simply call the OnSettingAction callback and whoever knows what to
// do can do so (based on the setting's identification
CSettingAction *pSettingAction = (CSettingAction *)m_pSetting;
pSettingAction->OnSettingAction(pSettingAction);
SetValid(true);
}
}
else if (controlType == "slider")
{
float value, min, step, max;
if (m_pSetting->GetType() == SettingTypeInteger)
{
CSettingInt *settingInt = static_cast<CSettingInt*>(m_pSetting);
value = (float)settingInt->GetValue();
min = (float)settingInt->GetMinimum();
step = (float)settingInt->GetStep();
max = (float)settingInt->GetMaximum();
}
else if (m_pSetting->GetType() == SettingTypeNumber)
{
CSettingNumber *settingNumber = static_cast<CSettingNumber*>(m_pSetting);
value = (float)settingNumber->GetValue();
min = (float)settingNumber->GetMinimum();
step = (float)settingNumber->GetStep();
max = (float)settingNumber->GetMaximum();
}
else
return false;
const CSettingControlSlider *sliderControl = static_cast<const CSettingControlSlider*>(control);
CGUIDialogSlider::ShowAndGetInput(g_localizeStrings.Get(sliderControl->GetHeading()), value, min, step, max, this, NULL);
SetValid(true);
}
return IsValid();
}
void CPeripheral::AddSetting(const std::string &strKey, const CSetting *setting, int order)
{
if (!setting)
{
CLog::Log(LOGERROR, "%s - invalid setting", __FUNCTION__);
return;
}
if (!HasSetting(strKey))
{
PeripheralDeviceSetting deviceSetting = { NULL, order };
switch(setting->GetType())
{
case SettingTypeBool:
{
const CSettingBool *mappedSetting = (const CSettingBool *) setting;
CSettingBool *boolSetting = new CSettingBool(strKey, *mappedSetting);
if (boolSetting)
{
boolSetting->SetVisible(mappedSetting->IsVisible());
deviceSetting.m_setting = boolSetting;
}
}
break;
case SettingTypeInteger:
{
const CSettingInt *mappedSetting = (const CSettingInt *) setting;
CSettingInt *intSetting = new CSettingInt(strKey, *mappedSetting);
if (intSetting)
{
intSetting->SetVisible(mappedSetting->IsVisible());
deviceSetting.m_setting = intSetting;
}
}
break;
case SettingTypeNumber:
{
const CSettingNumber *mappedSetting = (const CSettingNumber *) setting;
CSettingNumber *floatSetting = new CSettingNumber(strKey, *mappedSetting);
if (floatSetting)
{
floatSetting->SetVisible(mappedSetting->IsVisible());
deviceSetting.m_setting = floatSetting;
}
}
break;
case SettingTypeString:
{
const CSettingString *mappedSetting = (const CSettingString *) setting;
CSettingString *stringSetting = new CSettingString(strKey, *mappedSetting);
if (stringSetting)
{
stringSetting->SetVisible(mappedSetting->IsVisible());
deviceSetting.m_setting = stringSetting;
}
}
break;
default:
//! @todo add more types if needed
break;
}
if (deviceSetting.m_setting != NULL)
m_settings.insert(make_pair(strKey, deviceSetting));
}
}
void CGUIDialogVideoSettings::InitializeSettings()
{
CGUIDialogSettingsManualBase::InitializeSettings();
CSettingCategory *category = AddCategory("videosettings", -1);
if (category == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogVideoSettings: unable to setup settings");
return;
}
// get all necessary setting groups
CSettingGroup *groupVideoStream = AddGroup(category);
if (groupVideoStream == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogVideoSettings: unable to setup settings");
return;
}
CSettingGroup *groupVideo = AddGroup(category);
if (groupVideo == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogVideoSettings: unable to setup settings");
return;
}
CSettingGroup *groupVideoPlayback = AddGroup(category);
if (groupVideoPlayback == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogVideoSettings: unable to setup settings");
return;
}
CSettingGroup *groupStereoscopic = AddGroup(category);
if (groupStereoscopic == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogVideoSettings: unable to setup settings");
return;
}
CSettingGroup *groupSaveAsDefault = AddGroup(category);
if (groupSaveAsDefault == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogVideoSettings: unable to setup settings");
return;
}
bool usePopup = g_SkinInfo->HasSkinFile("DialogSlider.xml");
CVideoSettings &videoSettings = CMediaSettings::GetInstance().GetCurrentVideoSettings();
StaticIntegerSettingOptions entries;
if (g_application.m_pPlayer->Supports(VS_DEINTERLACEMODE_OFF))
entries.push_back(std::make_pair(16039, VS_DEINTERLACEMODE_OFF));
if (g_application.m_pPlayer->Supports(VS_DEINTERLACEMODE_AUTO))
entries.push_back(std::make_pair(16040, VS_DEINTERLACEMODE_AUTO));
if (g_application.m_pPlayer->Supports(VS_DEINTERLACEMODE_FORCE))
entries.push_back(std::make_pair(16041, VS_DEINTERLACEMODE_FORCE));
if (!entries.empty())
AddSpinner(groupVideo, SETTING_VIDEO_DEINTERLACEMODE, 16037, 0, static_cast<int>(videoSettings.m_DeinterlaceMode), entries);
entries.clear();
entries.push_back(std::make_pair(16019, VS_INTERLACEMETHOD_AUTO));
entries.push_back(std::make_pair(20131, VS_INTERLACEMETHOD_RENDER_BLEND));
entries.push_back(std::make_pair(20130, VS_INTERLACEMETHOD_RENDER_WEAVE_INVERTED));
entries.push_back(std::make_pair(20129, VS_INTERLACEMETHOD_RENDER_WEAVE));
entries.push_back(std::make_pair(16022, VS_INTERLACEMETHOD_RENDER_BOB_INVERTED));
entries.push_back(std::make_pair(16021, VS_INTERLACEMETHOD_RENDER_BOB));
entries.push_back(std::make_pair(16020, VS_INTERLACEMETHOD_DEINTERLACE));
entries.push_back(std::make_pair(16036, VS_INTERLACEMETHOD_DEINTERLACE_HALF));
entries.push_back(std::make_pair(16314, VS_INTERLACEMETHOD_INVERSE_TELECINE));
entries.push_back(std::make_pair(16311, VS_INTERLACEMETHOD_VDPAU_TEMPORAL_SPATIAL));
entries.push_back(std::make_pair(16310, VS_INTERLACEMETHOD_VDPAU_TEMPORAL));
entries.push_back(std::make_pair(16325, VS_INTERLACEMETHOD_VDPAU_BOB));
entries.push_back(std::make_pair(16318, VS_INTERLACEMETHOD_VDPAU_TEMPORAL_SPATIAL_HALF));
entries.push_back(std::make_pair(16317, VS_INTERLACEMETHOD_VDPAU_TEMPORAL_HALF));
entries.push_back(std::make_pair(16314, VS_INTERLACEMETHOD_VDPAU_INVERSE_TELECINE));
entries.push_back(std::make_pair(16325, VS_INTERLACEMETHOD_AUTO_ION));
entries.push_back(std::make_pair(16327, VS_INTERLACEMETHOD_VAAPI_BOB));
entries.push_back(std::make_pair(16328, VS_INTERLACEMETHOD_VAAPI_MADI));
entries.push_back(std::make_pair(16329, VS_INTERLACEMETHOD_VAAPI_MACI));
entries.push_back(std::make_pair(16330, VS_INTERLACEMETHOD_MMAL_ADVANCED));
entries.push_back(std::make_pair(16331, VS_INTERLACEMETHOD_MMAL_ADVANCED_HALF));
entries.push_back(std::make_pair(16332, VS_INTERLACEMETHOD_MMAL_BOB));
entries.push_back(std::make_pair(16333, VS_INTERLACEMETHOD_MMAL_BOB_HALF));
entries.push_back(std::make_pair(16334, VS_INTERLACEMETHOD_IMX_FASTMOTION));
entries.push_back(std::make_pair(16335, VS_INTERLACEMETHOD_IMX_FASTMOTION_DOUBLE));
/* remove unsupported methods */
for (StaticIntegerSettingOptions::iterator it = entries.begin(); it != entries.end(); )
{
if (g_application.m_pPlayer->Supports((EINTERLACEMETHOD)it->second))
++it;
else
it = entries.erase(it);
}
if (!entries.empty())
{
CSettingInt *settingInterlaceMethod = AddSpinner(groupVideo, SETTING_VIDEO_INTERLACEMETHOD, 16038, 0, static_cast<int>(videoSettings.m_InterlaceMethod), entries);
CSettingDependency dependencyDeinterlaceModeOff(SettingDependencyTypeEnable, m_settingsManager);
dependencyDeinterlaceModeOff.And()
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition(SETTING_VIDEO_DEINTERLACEMODE, "0", SettingDependencyOperatorEquals, true, m_settingsManager)));
SettingDependencies depsDeinterlaceModeOff;
depsDeinterlaceModeOff.push_back(dependencyDeinterlaceModeOff);
settingInterlaceMethod->SetDependencies(depsDeinterlaceModeOff);
}
entries.clear();
entries.push_back(std::make_pair(16301, VS_SCALINGMETHOD_NEAREST));
entries.push_back(std::make_pair(16302, VS_SCALINGMETHOD_LINEAR));
entries.push_back(std::make_pair(16303, VS_SCALINGMETHOD_CUBIC ));
entries.push_back(std::make_pair(16304, VS_SCALINGMETHOD_LANCZOS2));
entries.push_back(std::make_pair(16323, VS_SCALINGMETHOD_SPLINE36_FAST));
entries.push_back(std::make_pair(16315, VS_SCALINGMETHOD_LANCZOS3_FAST));
entries.push_back(std::make_pair(16322, VS_SCALINGMETHOD_SPLINE36));
entries.push_back(std::make_pair(16305, VS_SCALINGMETHOD_LANCZOS3));
entries.push_back(std::make_pair(16306, VS_SCALINGMETHOD_SINC8));
// entries.push_back(make_pair(?????, VS_SCALINGMETHOD_NEDI));
entries.push_back(std::make_pair(16307, VS_SCALINGMETHOD_BICUBIC_SOFTWARE));
entries.push_back(std::make_pair(16308, VS_SCALINGMETHOD_LANCZOS_SOFTWARE));
entries.push_back(std::make_pair(16309, VS_SCALINGMETHOD_SINC_SOFTWARE));
entries.push_back(std::make_pair(13120, VS_SCALINGMETHOD_VDPAU_HARDWARE));
entries.push_back(std::make_pair(16319, VS_SCALINGMETHOD_DXVA_HARDWARE));
entries.push_back(std::make_pair(16316, VS_SCALINGMETHOD_AUTO));
/* remove unsupported methods */
for(StaticIntegerSettingOptions::iterator it = entries.begin(); it != entries.end(); )
{
if (g_application.m_pPlayer->Supports((ESCALINGMETHOD)it->second))
++it;
else
it = entries.erase(it);
}
AddSpinner(groupVideo, SETTING_VIDEO_SCALINGMETHOD, 16300, 0, static_cast<int>(videoSettings.m_ScalingMethod), entries);
#ifdef HAS_VIDEO_PLAYBACK
AddVideoStreams(groupVideoStream, SETTING_VIDEO_STREAM);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_STRETCH) || g_application.m_pPlayer->Supports(RENDERFEATURE_PIXEL_RATIO))
{
entries.clear();
for (int i = 0; i < 7; ++i)
entries.push_back(std::make_pair(630 + i, i));
AddSpinner(groupVideo, SETTING_VIDEO_VIEW_MODE, 629, 0, videoSettings.m_ViewMode, entries);
}
if (g_application.m_pPlayer->Supports(RENDERFEATURE_ZOOM))
AddSlider(groupVideo, SETTING_VIDEO_ZOOM, 216, 0, videoSettings.m_CustomZoomAmount, "%2.2f", 0.5f, 0.01f, 2.0f, 216, usePopup);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_VERTICAL_SHIFT))
AddSlider(groupVideo, SETTING_VIDEO_VERTICAL_SHIFT, 225, 0, videoSettings.m_CustomVerticalShift, "%2.2f", -2.0f, 0.01f, 2.0f, 225, usePopup);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_PIXEL_RATIO))
AddSlider(groupVideo, SETTING_VIDEO_PIXEL_RATIO, 217, 0, videoSettings.m_CustomPixelRatio, "%2.2f", 0.5f, 0.01f, 2.0f, 217, usePopup);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_POSTPROCESS))
AddToggle(groupVideo, SETTING_VIDEO_POSTPROCESS, 16400, 0, videoSettings.m_PostProcess);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_BRIGHTNESS))
AddPercentageSlider(groupVideoPlayback, SETTING_VIDEO_BRIGHTNESS, 464, 0, static_cast<int>(videoSettings.m_Brightness), 14047, 1, 464, usePopup);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_CONTRAST))
AddPercentageSlider(groupVideoPlayback, SETTING_VIDEO_CONTRAST, 465, 0, static_cast<int>(videoSettings.m_Contrast), 14047, 1, 465, usePopup);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_GAMMA))
AddPercentageSlider(groupVideoPlayback, SETTING_VIDEO_GAMMA, 466, 0, static_cast<int>(videoSettings.m_Gamma), 14047, 1, 466, usePopup);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_NOISE))
AddSlider(groupVideoPlayback, SETTING_VIDEO_VDPAU_NOISE, 16312, 0, videoSettings.m_NoiseReduction, "%2.2f", 0.0f, 0.01f, 1.0f, 16312, usePopup);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_SHARPNESS))
AddSlider(groupVideoPlayback, SETTING_VIDEO_VDPAU_SHARPNESS, 16313, 0, videoSettings.m_Sharpness, "%2.2f", -1.0f, 0.02f, 1.0f, 16313, usePopup);
if (g_application.m_pPlayer->Supports(RENDERFEATURE_NONLINSTRETCH))
AddToggle(groupVideoPlayback, SETTING_VIDEO_NONLIN_STRETCH, 659, 0, videoSettings.m_CustomNonLinStretch);
#endif
// stereoscopic settings
entries.clear();
entries.push_back(std::make_pair(16316, RENDER_STEREO_MODE_OFF));
entries.push_back(std::make_pair(36503, RENDER_STEREO_MODE_SPLIT_HORIZONTAL));
entries.push_back(std::make_pair(36504, RENDER_STEREO_MODE_SPLIT_VERTICAL));
AddSpinner(groupStereoscopic, SETTING_VIDEO_STEREOSCOPICMODE , 36535, 0, videoSettings.m_StereoMode, entries);
AddToggle(groupStereoscopic, SETTING_VIDEO_STEREOSCOPICINVERT, 36536, 0, videoSettings.m_StereoInvert);
// general settings
AddButton(groupSaveAsDefault, SETTING_VIDEO_MAKE_DEFAULT, 12376, 0);
AddButton(groupSaveAsDefault, SETTING_VIDEO_CALIBRATION, 214, 0);
}
void CPeripheral::AddSetting(const CStdString &strKey, const CSetting *setting)
{
if (!setting)
{
CLog::Log(LOGERROR, "%s - invalid setting", __FUNCTION__);
return;
}
if (!HasSetting(strKey))
{
switch(setting->GetType())
{
case SettingTypeBool:
{
const CSettingBool *mappedSetting = (const CSettingBool *) setting;
CSettingBool *boolSetting = new CSettingBool(strKey, *mappedSetting);
if (boolSetting)
{
boolSetting->SetVisible(mappedSetting->IsVisible());
m_settings.insert(make_pair(strKey, boolSetting));
}
}
break;
case SettingTypeInteger:
{
const CSettingInt *mappedSetting = (const CSettingInt *) setting;
CSettingInt *intSetting = new CSettingInt(strKey, *mappedSetting);
if (intSetting)
{
intSetting->SetVisible(mappedSetting->IsVisible());
m_settings.insert(make_pair(strKey, intSetting));
}
}
break;
case SettingTypeNumber:
{
const CSettingNumber *mappedSetting = (const CSettingNumber *) setting;
CSettingNumber *floatSetting = new CSettingNumber(strKey, *mappedSetting);
if (floatSetting)
{
floatSetting->SetVisible(mappedSetting->IsVisible());
m_settings.insert(make_pair(strKey, floatSetting));
}
}
break;
case SettingTypeString:
{
const CSettingString *mappedSetting = (const CSettingString *) setting;
CSettingString *stringSetting = new CSettingString(strKey, *mappedSetting);
if (stringSetting)
{
stringSetting->SetVisible(mappedSetting->IsVisible());
m_settings.insert(make_pair(strKey, stringSetting));
}
}
break;
default:
//TODO add more types if needed
break;
}
}
}
