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 CGUIDialogCMSSettings::InitializeSettings()
{
CGUIDialogSettingsManualBase::InitializeSettings();
const std::shared_ptr<CSettingCategory> category = AddCategory("cms", -1);
if (category == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogCMSSettings: unable to setup settings");
return;
}
// get all necessary setting groups
const std::shared_ptr<CSettingGroup> groupColorManagement = AddGroup(category);
if (groupColorManagement == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogCMSSettings: unable to setup settings");
return;
}
bool usePopup = g_SkinInfo->HasSkinFile("DialogSlider.xml");
TranslatableIntegerSettingOptions entries;
// create "depsCmsEnabled" for settings depending on CMS being enabled
CSettingDependency dependencyCmsEnabled(SettingDependencyType::Enable, GetSettingsManager());
dependencyCmsEnabled.Or()
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition(SETTING_VIDEO_CMSENABLE, "true", SettingDependencyOperator::Equals, false, GetSettingsManager())));
SettingDependencies depsCmsEnabled;
depsCmsEnabled.push_back(dependencyCmsEnabled);
// create "depsCms3dlut" for 3dlut settings
CSettingDependency dependencyCms3dlut(SettingDependencyType::Visible, GetSettingsManager());
dependencyCms3dlut.And()
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition(SETTING_VIDEO_CMSMODE, std::to_string(CMS_MODE_3DLUT), SettingDependencyOperator::Equals, false, GetSettingsManager())));
SettingDependencies depsCms3dlut;
depsCms3dlut.push_back(dependencyCmsEnabled);
depsCms3dlut.push_back(dependencyCms3dlut);
// create "depsCmsIcc" for display settings with icc profile
CSettingDependency dependencyCmsIcc(SettingDependencyType::Visible, GetSettingsManager());
dependencyCmsIcc.And()
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition(SETTING_VIDEO_CMSMODE, std::to_string(CMS_MODE_PROFILE), SettingDependencyOperator::Equals, false, GetSettingsManager())));
SettingDependencies depsCmsIcc;
depsCmsIcc.push_back(dependencyCmsEnabled);
depsCmsIcc.push_back(dependencyCmsIcc);
// create "depsCmsGamma" for effective gamma adjustment (not available with bt.1886)
CSettingDependency dependencyCmsGamma(SettingDependencyType::Visible, GetSettingsManager());
dependencyCmsGamma.And()
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition(SETTING_VIDEO_CMSGAMMAMODE, std::to_string(CMS_TRC_BT1886), SettingDependencyOperator::Equals, true, GetSettingsManager())));
SettingDependencies depsCmsGamma;
depsCmsGamma.push_back(dependencyCmsEnabled);
depsCmsGamma.push_back(dependencyCmsIcc);
depsCmsGamma.push_back(dependencyCmsGamma);
// color management settings
AddToggle(groupColorManagement, SETTING_VIDEO_CMSENABLE, 36560, SettingLevel::Basic, CServiceBroker::GetSettings().GetBool(SETTING_VIDEO_CMSENABLE));
int currentMode = CServiceBroker::GetSettings().GetInt(SETTING_VIDEO_CMSMODE);
entries.clear();
// entries.push_back(std::make_pair(16039, CMS_MODE_OFF)); // FIXME: get from CMS class
entries.push_back(std::make_pair(36580, CMS_MODE_3DLUT));
#ifdef HAVE_LCMS2
entries.push_back(std::make_pair(36581, CMS_MODE_PROFILE));
#endif
std::shared_ptr<CSettingInt> settingCmsMode = AddSpinner(groupColorManagement, SETTING_VIDEO_CMSMODE, 36562, SettingLevel::Basic, currentMode, entries);
settingCmsMode->SetDependencies(depsCmsEnabled);
std::string current3dLUT = CServiceBroker::GetSettings().GetString(SETTING_VIDEO_CMS3DLUT);
std::shared_ptr<CSettingString> settingCms3dlut = AddList(groupColorManagement, SETTING_VIDEO_CMS3DLUT, 36564, SettingLevel::Basic, current3dLUT, Cms3dLutsFiller, 36564);
settingCms3dlut->SetDependencies(depsCms3dlut);
// display settings
int currentWhitepoint = CServiceBroker::GetSettings().GetInt(SETTING_VIDEO_CMSWHITEPOINT);
entries.clear();
entries.push_back(std::make_pair(36586, CMS_WHITEPOINT_D65));
entries.push_back(std::make_pair(36587, CMS_WHITEPOINT_D93));
std::shared_ptr<CSettingInt> settingCmsWhitepoint = AddSpinner(groupColorManagement, SETTING_VIDEO_CMSWHITEPOINT, 36568, SettingLevel::Basic, currentWhitepoint, entries);
settingCmsWhitepoint->SetDependencies(depsCmsIcc);
int currentPrimaries = CServiceBroker::GetSettings().GetInt(SETTING_VIDEO_CMSPRIMARIES);
entries.clear();
entries.push_back(std::make_pair(36588, CMS_PRIMARIES_AUTO));
entries.push_back(std::make_pair(36589, CMS_PRIMARIES_BT709));
entries.push_back(std::make_pair(36590, CMS_PRIMARIES_170M));
entries.push_back(std::make_pair(36591, CMS_PRIMARIES_BT470M));
entries.push_back(std::make_pair(36592, CMS_PRIMARIES_BT470BG));
entries.push_back(std::make_pair(36593, CMS_PRIMARIES_240M));
std::shared_ptr<CSettingInt> settingCmsPrimaries = AddSpinner(groupColorManagement, SETTING_VIDEO_CMSPRIMARIES, 36570, SettingLevel::Basic, currentPrimaries, entries);
settingCmsPrimaries->SetDependencies(depsCmsIcc);
int currentGammaMode = CServiceBroker::GetSettings().GetInt(SETTING_VIDEO_CMSGAMMAMODE);
entries.clear();
entries.push_back(std::make_pair(36582, CMS_TRC_BT1886));
entries.push_back(std::make_pair(36583, CMS_TRC_INPUT_OFFSET));
entries.push_back(std::make_pair(36584, CMS_TRC_OUTPUT_OFFSET));
entries.push_back(std::make_pair(36585, CMS_TRC_ABSOLUTE));
std::shared_ptr<CSettingInt> settingCmsGammaMode = AddSpinner(groupColorManagement, SETTING_VIDEO_CMSGAMMAMODE, 36572, SettingLevel::Basic, currentGammaMode, entries);
settingCmsGammaMode->SetDependencies(depsCmsIcc);
float currentGamma = CServiceBroker::GetSettings().GetInt(SETTING_VIDEO_CMSGAMMA)/100.0f;
if (currentGamma == 0.0) currentGamma = 2.20;
std::shared_ptr<CSettingNumber> settingCmsGamma = AddSlider(groupColorManagement, SETTING_VIDEO_CMSGAMMA, 36574, SettingLevel::Basic, currentGamma, 36597, 1.6, 0.05, 2.8, 36574, usePopup);
settingCmsGamma->SetDependencies(depsCmsGamma);
int currentLutSize = CServiceBroker::GetSettings().GetInt(SETTING_VIDEO_CMSLUTSIZE);
entries.clear();
entries.push_back(std::make_pair(36594, 4));
entries.push_back(std::make_pair(36595, 6));
entries.push_back(std::make_pair(36596, 8));
std::shared_ptr<CSettingInt> settingCmsLutSize = AddSpinner(groupColorManagement, SETTING_VIDEO_CMSLUTSIZE, 36576, SettingLevel::Basic, currentLutSize, entries);
settingCmsLutSize->SetDependencies(depsCmsIcc);
}
void CGUIDialogAudioSubtitleSettings::InitializeSettings()
{
CGUIDialogSettingsManualBase::InitializeSettings();
CSettingCategory *category = AddCategory("audiosubtitlesettings", -1);
if (category == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogAudioSubtitleSettings: unable to setup settings");
return;
}
// get all necessary setting groups
CSettingGroup *groupAudio = AddGroup(category);
if (groupAudio == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogAudioSubtitleSettings: unable to setup settings");
return;
}
CSettingGroup *groupSubtitles = AddGroup(category);
if (groupSubtitles == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogAudioSubtitleSettings: unable to setup settings");
return;
}
CSettingGroup *groupSaveAsDefault = AddGroup(category);
if (groupSaveAsDefault == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogAudioSubtitleSettings: unable to setup settings");
return;
}
bool usePopup = g_SkinInfo->HasSkinFile("DialogSlider.xml");
CVideoSettings &videoSettings = CMediaSettings::GetInstance().GetCurrentVideoSettings();
if (g_application.m_pPlayer->HasPlayer())
{
g_application.m_pPlayer->GetAudioCapabilities(m_audioCaps);
g_application.m_pPlayer->GetSubtitleCapabilities(m_subCaps);
}
// register IsPlayingPassthrough condition
m_settingsManager->AddCondition("IsPlayingPassthrough", IsPlayingPassthrough);
CSettingDependency dependencyAudioOutputPassthroughDisabled(SettingDependencyTypeEnable, m_settingsManager);
dependencyAudioOutputPassthroughDisabled.Or()
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition(SETTING_AUDIO_PASSTHROUGH, "false", SettingDependencyOperatorEquals, false, m_settingsManager)))
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition("IsPlayingPassthrough", "", "", true, m_settingsManager)));
SettingDependencies depsAudioOutputPassthroughDisabled;
depsAudioOutputPassthroughDisabled.push_back(dependencyAudioOutputPassthroughDisabled);
m_dspEnabled = CServiceBroker::GetSettings().GetBool(CSettings::SETTING_AUDIOOUTPUT_DSPADDONSENABLED);
// audio settings
// audio volume setting
m_volume = g_application.GetVolume(false);
CSettingNumber *settingAudioVolume = AddSlider(groupAudio, SETTING_AUDIO_VOLUME, 13376, 0, m_volume, 14054, VOLUME_MINIMUM, VOLUME_MAXIMUM / 100.0f, VOLUME_MAXIMUM);
settingAudioVolume->SetDependencies(depsAudioOutputPassthroughDisabled);
static_cast<CSettingControlSlider*>(settingAudioVolume->GetControl())->SetFormatter(SettingFormatterPercentAsDecibel);
if (m_dspEnabled)
AddButton(groupAudio, SETTING_AUDIO_DSP, 24136, 0);
// audio volume amplification setting
if (SupportsAudioFeature(IPC_AUD_AMP) && !m_dspEnabled)
{
CSettingNumber *settingAudioVolumeAmplification = AddSlider(groupAudio, SETTING_AUDIO_VOLUME_AMPLIFICATION, 660, 0, videoSettings.m_VolumeAmplification, 14054, VOLUME_DRC_MINIMUM * 0.01f, (VOLUME_DRC_MAXIMUM - VOLUME_DRC_MINIMUM) / 6000.0f, VOLUME_DRC_MAXIMUM * 0.01f);
settingAudioVolumeAmplification->SetDependencies(depsAudioOutputPassthroughDisabled);
}
// audio delay setting
if (SupportsAudioFeature(IPC_AUD_OFFSET) && !m_dspEnabled)
{
CSettingNumber *settingAudioDelay = AddSlider(groupAudio, SETTING_AUDIO_DELAY, 297, 0, videoSettings.m_AudioDelay, 0, -g_advancedSettings.m_videoAudioDelayRange, 0.025f, g_advancedSettings.m_videoAudioDelayRange, 297, usePopup);
static_cast<CSettingControlSlider*>(settingAudioDelay->GetControl())->SetFormatter(SettingFormatterDelay);
}
// audio stream setting
if (SupportsAudioFeature(IPC_AUD_SELECT_STREAM))
AddAudioStreams(groupAudio, SETTING_AUDIO_STREAM);
// audio output to all speakers setting
//! @todo remove this setting
if (SupportsAudioFeature(IPC_AUD_OUTPUT_STEREO) && !m_dspEnabled)
AddToggle(groupAudio, SETTING_AUDIO_OUTPUT_TO_ALL_SPEAKERS, 252, 0, videoSettings.m_OutputToAllSpeakers);
// audio digital/analog setting
if (SupportsAudioFeature(IPC_AUD_SELECT_OUTPUT))
{
m_passthrough = CServiceBroker::GetSettings().GetBool(CSettings::SETTING_AUDIOOUTPUT_PASSTHROUGH);
AddToggle(groupAudio, SETTING_AUDIO_PASSTHROUGH, 348, 0, m_passthrough);
}
// subtitle settings
m_subtitleVisible = g_application.m_pPlayer->GetSubtitleVisible();
// subtitle enabled setting
AddToggle(groupSubtitles, SETTING_SUBTITLE_ENABLE, 13397, 0, m_subtitleVisible);
// subtitle delay setting
if (SupportsSubtitleFeature(IPC_SUBS_OFFSET))
{
CSettingNumber *settingSubtitleDelay = AddSlider(groupSubtitles, SETTING_SUBTITLE_DELAY, 22006, 0, videoSettings.m_SubtitleDelay, 0, -g_advancedSettings.m_videoSubsDelayRange, 0.1f, g_advancedSettings.m_videoSubsDelayRange, 22006, usePopup);
static_cast<CSettingControlSlider*>(settingSubtitleDelay->GetControl())->SetFormatter(SettingFormatterDelay);
}
// subtitle stream setting
if (SupportsSubtitleFeature(IPC_SUBS_SELECT))
AddSubtitleStreams(groupSubtitles, SETTING_SUBTITLE_STREAM);
// subtitle browser setting
if (SupportsSubtitleFeature(IPC_SUBS_EXTERNAL))
AddButton(groupSubtitles, SETTING_SUBTITLE_BROWSER, 13250, 0);
// subtitle stream setting
AddButton(groupSaveAsDefault, SETTING_AUDIO_MAKE_DEFAULT, 12376, 0);
}
void CGUIDialogContentSettings::InitializeSettings()
{
CGUIDialogSettingsManualBase::InitializeSettings();
if (m_content == CONTENT_NONE)
m_showScanSettings = false;
else if (m_scraper != NULL && !CServiceBroker::GetAddonMgr().IsAddonDisabled(m_scraper->ID()))
m_showScanSettings = true;
std::shared_ptr<CSettingCategory> category = AddCategory("contentsettings", -1);
if (category == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogContentSettings: unable to setup settings");
return;
}
std::shared_ptr<CSettingGroup> group = AddGroup(category);
if (group == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogContentSettings: unable to setup settings");
return;
}
AddButton(group, SETTING_CONTENT_TYPE, 20344, SettingLevel::Basic);
AddButton(group, SETTING_SCRAPER_LIST, 38025, SettingLevel::Basic);
std::shared_ptr<CSettingAction> subsetting = AddButton(group, SETTING_SCRAPER_SETTINGS, 10004, SettingLevel::Basic);
if (subsetting != NULL)
subsetting->SetParent(SETTING_SCRAPER_LIST);
std::shared_ptr<CSettingGroup> groupDetails = AddGroup(category, 20322);
if (groupDetails == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogContentSettings: unable to setup scanning settings");
return;
}
switch (m_content)
{
case CONTENT_TVSHOWS:
{
AddToggle(groupDetails, SETTING_CONTAINS_SINGLE_ITEM, 20379, SettingLevel::Basic, m_containsSingleItem, false, m_showScanSettings);
AddToggle(groupDetails, SETTING_NO_UPDATING, 20432, SettingLevel::Basic, m_noUpdating, false, m_showScanSettings);
break;
}
case CONTENT_MOVIES:
case CONTENT_MUSICVIDEOS:
{
AddToggle(groupDetails, SETTING_USE_DIRECTORY_NAMES, m_content == CONTENT_MOVIES ? 20329 : 20330, SettingLevel::Basic, m_useDirectoryNames, false, m_showScanSettings);
std::shared_ptr<CSettingBool> settingScanRecursive = AddToggle(groupDetails, SETTING_SCAN_RECURSIVE, 20346, SettingLevel::Basic, m_scanRecursive, false, m_showScanSettings);
std::shared_ptr<CSettingBool> settingContainsSingleItem = AddToggle(groupDetails, SETTING_CONTAINS_SINGLE_ITEM, 20383, SettingLevel::Basic, m_containsSingleItem, false, m_showScanSettings);
AddToggle(groupDetails, SETTING_NO_UPDATING, 20432, SettingLevel::Basic, m_noUpdating, false, m_showScanSettings);
// define an enable dependency with (m_useDirectoryNames && !m_containsSingleItem) || !m_useDirectoryNames
CSettingDependency dependencyScanRecursive(SettingDependencyType::Enable, GetSettingsManager());
dependencyScanRecursive.Or()
->Add(CSettingDependencyConditionCombinationPtr((new CSettingDependencyConditionCombination(BooleanLogicOperationAnd, GetSettingsManager())) // m_useDirectoryNames && !m_containsSingleItem
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition(SETTING_USE_DIRECTORY_NAMES, "true", SettingDependencyOperator::Equals, false, GetSettingsManager()))) // m_useDirectoryNames
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition(SETTING_CONTAINS_SINGLE_ITEM, "false", SettingDependencyOperator::Equals, false, GetSettingsManager()))))) // !m_containsSingleItem
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition(SETTING_USE_DIRECTORY_NAMES, "false", SettingDependencyOperator::Equals, false, GetSettingsManager()))); // !m_useDirectoryNames
// define an enable dependency with m_useDirectoryNames && !m_scanRecursive
CSettingDependency dependencyContainsSingleItem(SettingDependencyType::Enable, GetSettingsManager());
dependencyContainsSingleItem.And()
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition(SETTING_USE_DIRECTORY_NAMES, "true", SettingDependencyOperator::Equals, false, GetSettingsManager()))) // m_useDirectoryNames
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition(SETTING_SCAN_RECURSIVE, "false", SettingDependencyOperator::Equals, false, GetSettingsManager()))); // !m_scanRecursive
SettingDependencies deps;
deps.push_back(dependencyScanRecursive);
settingScanRecursive->SetDependencies(deps);
deps.clear();
deps.push_back(dependencyContainsSingleItem);
settingContainsSingleItem->SetDependencies(deps);
break;
}
case CONTENT_ALBUMS:
case CONTENT_ARTISTS:
break;
case CONTENT_NONE:
default:
AddToggle(groupDetails, SETTING_EXCLUDE, 20380, SettingLevel::Basic, m_exclude, false, !m_showScanSettings);
break;
}
}
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 CGUIDialogPVRTimerSettings::InitializeSettings()
{
CGUIDialogSettingsManualBase::InitializeSettings();
CSettingCategory *category = AddCategory("pvrtimersettings", -1);
if (category == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogPVRTimerSettings: unable to setup settings");
return;
}
CSettingGroup *group = AddGroup(category);
if (group == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogPVRTimerSettings: unable to setup settings");
return;
}
// add a condition
m_settingsManager->AddCondition("IsTimerDayRepeating", IsTimerDayRepeating);
CPVRTimerInfoTag* tag = m_timerItem->GetPVRTimerInfoTag();
m_selectedChannelEntry = 0;
m_channelEntries.clear();
m_bTimerActive = tag->IsActive();
AddToggle(group, SETTING_TMR_ACTIVE, 19074, 0, m_bTimerActive);
AddEdit(group, SETTING_TMR_NAME, 19075, 0, tag->m_strTitle, false, false, 19097);
if (tag->SupportsFolders())
AddEdit(group, SETTING_TMR_DIR, 19076, 0, tag->m_strDirectory, true, false, 19104);
AddToggle(group, SETTING_TMR_RADIO, 19077, 0, tag->m_bIsRadio);
/// Channel names
{
// For TV
AddChannelNames(group, false);
// For Radio
AddChannelNames(group, true);
}
/// Day
{
// get diffence of timer in days between today and timer start date
tm time_cur; CDateTime::GetCurrentDateTime().GetAsTm(time_cur);
tm time_tmr; tag->StartAsLocalTime().GetAsTm(time_tmr);
m_tmp_day += time_tmr.tm_yday - time_cur.tm_yday;
if (time_tmr.tm_yday - time_cur.tm_yday < 0)
m_tmp_day += 365;
SetWeekdaySettingFromTimer(*tag);
AddSpinner(group, SETTING_TMR_DAY, 19079, 0, m_tmp_day, DaysOptionsFiller);
}
AddButton(group, SETTING_TMR_BEGIN, 19080, 0);
AddButton(group, SETTING_TMR_END, 19081, 0);
AddSpinner(group, SETTING_TMR_PRIORITY, 19082, 0, tag->m_iPriority, 0, 1, 99);
AddSpinner(group, SETTING_TMR_LIFETIME, 19083, 0, tag->m_iLifetime, 0, 1, 365);
/// First day
{
CDateTime time = CDateTime::GetCurrentDateTime();
CDateTime timestart = tag->FirstDayAsLocalTime();
// get diffence of timer in days between today and timer start date
if (time < timestart)
{
tm time_cur; time.GetAsTm(time_cur);
tm time_tmr; timestart.GetAsTm(time_tmr);
m_tmp_iFirstDay += time_tmr.tm_yday - time_cur.tm_yday + 1;
if (time_tmr.tm_yday - time_cur.tm_yday < 0)
m_tmp_iFirstDay += 365;
}
CSettingInt *settingFirstDay = AddSpinner(group, SETTING_TMR_FIRST_DAY, 19084, 0, m_tmp_iFirstDay, DaysOptionsFiller);
// define an enable dependency with m_tmp_day <= 10
CSettingDependency depdendencyFirstDay(SettingDependencyTypeEnable, m_settingsManager);
depdendencyFirstDay.And()
->Add(CSettingDependencyConditionPtr(new CSettingDependencyCondition("IsTimerDayRepeating", "true", SETTING_TMR_DAY, false, m_settingsManager)));
SettingDependencies deps;
deps.push_back(depdendencyFirstDay);
settingFirstDay->SetDependencies(deps);
}
}
